@@ -22,15 +22,17 @@
  * <p>Implements FSSDK-12813:
  * <ul>
  *   <li>{@code campaign_id} and impression {@code entity_id} must be a non-empty
- *       decimal-digit string. If empty / null / non-numeric / whitespace, substitute
- *       {@code experiment_id}.</li>
+ *       string of any character content (IDs may be opaque, e.g. {@code "default-12345"},
+ *       {@code "layer_abc"}). If null or empty string, substitute {@code experiment_id}.
+ *       Non-numeric strings pass through unchanged.</li>
  *   <li>{@code variation_id} must be a non-empty decimal-digit string OR {@code null}.
- *       If empty / non-numeric / non-string / whitespace, substitute {@code null}.</li>
+ *       If empty / non-numeric / whitespace, substitute {@code null}. This field retains
+ *       the stricter numeric-string-only contract.</li>
  * </ul>
  *
- * <p>A "numeric string" is a non-empty string consisting entirely of decimal digits
- * {@code [0-9]}. Leading zeros are allowed. Whitespace, negatives, decimals, and
- * exponents are INVALID.
+ * <p>For {@code variation_id}, a "numeric string" is a non-empty string consisting
+ * entirely of decimal digits {@code [0-9]}. Leading zeros are allowed. Whitespace,
+ * negatives, decimals, and exponents are INVALID.
  *
  * <p>Normalization applies uniformly to all decision types (experiment, feature test,
  * rollout, holdout). It must not drop, defer, or fail event dispatch, and it must not
@@ -42,9 +44,20 @@ private EventIdNormalizer() {
         // Utility class — not instantiable.
     }
 
+    /**
+     * @return {@code true} iff {@code value} is non-null and has length &ge; 1.
+     *         Character content is not validated — any non-empty string is accepted.
+     *         Used to validate {@code campaign_id} and impression {@code entity_id}
+     *         per the FSSDK-12813 relaxed contract.
+     */
+    static boolean isNonEmptyString(String value) {
+        return value != null && !value.isEmpty();
+    }
+
     /**
      * @return {@code true} iff {@code value} is non-null and consists entirely of decimal digits.
      *         Empty strings, whitespace, negatives, decimals, and exponents are all invalid.
+     *         Used to validate {@code variation_id} per the FSSDK-12813 strict numeric-string contract.
      */
     static boolean isNumericString(String value) {
         if (value == null) {
@@ -66,13 +79,18 @@ static boolean isNumericString(String value) {
     /**
      * Normalize a {@code campaign_id} or impression {@code entity_id}.
      *
-     * @param campaignId the candidate campaign_id (may be null, empty, or non-numeric)
+     * <p>Per FSSDK-12813, any non-empty string is accepted as-is (IDs may be opaque,
+     * e.g. {@code "default-12345"}, {@code "layer_abc"}). The fallback to
+     * {@code experiment_id} fires ONLY when {@code campaignId} is {@code null} or
+     * the empty string {@code ""}.
+     *
+     * @param campaignId the candidate campaign_id (may be null or empty)
      * @param experimentId fallback experiment_id (returned as-is; not re-validated)
-     * @return {@code campaignId} when it is a non-empty numeric string,
+     * @return {@code campaignId} when it is a non-empty string of any content,
      *         otherwise {@code experimentId} (which may itself be {@code null}).
      */
     static String normalizeCampaignId(String campaignId, String experimentId) {
-        if (isNumericString(campaignId)) {
+        if (isNonEmptyString(campaignId)) {
             return campaignId;
         }
         return experimentId;
@@ -81,6 +99,10 @@ static String normalizeCampaignId(String campaignId, String experimentId) {
     /**
      * Normalize a {@code variation_id}.
      *
+     * <p>Per FSSDK-12813, {@code variation_id} retains the stricter contract: must be
+     * a non-empty decimal-digit string. Anything else (null, empty, whitespace, or
+     * non-numeric) is replaced with {@code null}.
+     *
      * @param variationId the candidate variation_id (may be null, empty, or non-numeric)
      * @return {@code variationId} when it is a non-empty numeric string, otherwise {@code null}.
      */
 
@@ -44,7 +44,8 @@
  * <p>Verifies:
  * <ul>
  *   <li>FR-001/FR-002: {@code campaign_id} substitution from {@code experiment_id}
- *       when campaign_id is empty / null / non-numeric / whitespace.</li>
+ *       when campaign_id is null or empty string. Non-numeric / opaque strings
+ *       (e.g. {@code "layer_abc"}) are valid and pass through unchanged.</li>
  *   <li>FR-003/FR-004: {@code variation_id} replacement with {@code null} when
  *       empty / non-numeric / whitespace.</li>
  *   <li>FR-005: Uniform behavior across all rule types (experiment / feature-test /
@@ -167,21 +168,37 @@ public void campaignId_empty_fallsBackToExperimentId() {
     }
 
     @Test
-    public void campaignId_whitespace_fallsBackToExperimentId() {
+    public void campaignId_whitespace_passesThroughUnchanged() {
+        // FSSDK-12813 (relaxed): any non-empty string is valid for campaign_id.
+        // Whitespace-only strings have length >= 1, so they pass through as-is.
         ImpressionEvent imp = buildImpression(
             "experiment", " ", "2222", "3333");
         LogEvent log = EventFactory.createLogEvent(imp);
-        assertEquals("2222", firstDecision(log).getCampaignId());
-        assertEquals("2222", firstEvent(log).getEntityId());
+        assertEquals(" ", firstDecision(log).getCampaignId());
+        assertEquals(" ", firstEvent(log).getEntityId());
     }
 
     @Test
-    public void campaignId_nonNumericString_fallsBackToExperimentId() {
+    public void campaignId_nonNumericString_passesThroughUnchanged() {
+        // FSSDK-12813 (relaxed): opaque/non-numeric IDs (e.g. "layerKey",
+        // "default-12345", "layer_abc") are valid campaign_id values and must
+        // pass through to both decisions[].campaign_id and events[].entity_id.
         ImpressionEvent imp = buildImpression(
             "experiment", "layerKey", "2222", "3333");
         LogEvent log = EventFactory.createLogEvent(imp);
-        assertEquals("2222", firstDecision(log).getCampaignId());
-        assertEquals("2222", firstEvent(log).getEntityId());
+        assertEquals("layerKey", firstDecision(log).getCampaignId());
+        assertEquals("layerKey", firstEvent(log).getEntityId());
+    }
+
+    @Test
+    public void campaignId_opaqueDashSeparatedString_passesThroughUnchanged() {
+        // FSSDK-12813 (relaxed): explicit coverage for the canonical opaque-ID
+        // example from the spec ("default-12345").
+        ImpressionEvent imp = buildImpression(
+            "experiment", "default-12345", "2222", "3333");
+        LogEvent log = EventFactory.createLogEvent(imp);
+        assertEquals("default-12345", firstDecision(log).getCampaignId());
+        assertEquals("default-12345", firstEvent(log).getEntityId());
     }
 
     // ---------------------------------------------------------------------
@@ -226,6 +243,14 @@ public void variationId_nonNumericString_becomesNull() {
 
     @Test
     public void normalization_uniformAcrossAllRuleTypes() {
+        // FSSDK-12813 (relaxed):
+        //   - campaign_id: any non-empty string passes through unchanged
+        //     (including opaque IDs like "bad-layer"). Fallback to experiment_id
+        //     only fires for null / empty string.
+        //   - variation_id: still strict numeric-string-only; non-numeric
+        //     inputs like "bad-variation" become null.
+        // This test verifies the SAME relaxed-campaign / strict-variation
+        // behavior applies uniformly across every rule type.
         String[] ruleTypes = {"experiment", "feature-test", "rollout", "holdout"};
         for (String ruleType : ruleTypes) {
             ImpressionEvent imp = buildImpression(
@@ -235,9 +260,36 @@ public void normalization_uniformAcrossAllRuleTypes() {
             Decision d = firstDecision(log);
             Event e = firstEvent(log);
 
-            // For every rule type, the same normalization rules apply.
+            // campaign_id: opaque string is valid under the relaxed contract,
+            // so it passes through unchanged for every rule type.
+            assertEquals(
+                "campaign_id should pass through unchanged for ruleType=" + ruleType,
+                "bad-layer", d.getCampaignId());
+            assertEquals(
+                "entity_id must mirror campaign_id for ruleType=" + ruleType,
+                "bad-layer", e.getEntityId());
+            // variation_id: still strict numeric-only — non-numeric becomes null.
+            assertNull(
+                "variation_id should become null for ruleType=" + ruleType,
+                d.getVariationId());
+        }
+    }
+
+    @Test
+    public void normalization_uniformAcrossAllRuleTypes_nullCampaignFallsBack() {
+        // FSSDK-12813 (relaxed): when campaign_id is null, fallback to
+        // experiment_id still fires uniformly across every rule type.
+        String[] ruleTypes = {"experiment", "feature-test", "rollout", "holdout"};
+        for (String ruleType : ruleTypes) {
+            ImpressionEvent imp = buildImpression(
+                ruleType, null, "2222", "bad-variation");
+            LogEvent log = EventFactory.createLogEvent(imp);
+
+            Decision d = firstDecision(log);
+            Event e = firstEvent(log);
+
             assertEquals(
-                "campaign_id should fall back to experiment_id for ruleType=" + ruleType,
+                "campaign_id should fall back to experiment_id when null for ruleType=" + ruleType,
                 "2222", d.getCampaignId());
             assertEquals(
                 "entity_id must mirror campaign_id for ruleType=" + ruleType,
@@ -254,21 +306,30 @@ public void normalization_uniformAcrossAllRuleTypes() {
 
     @Test
     public void entityId_alwaysMirrorsNormalizedCampaignId() {
-        // 1) Both valid → equal.
+        // 1) Both valid numeric → equal, passed through.
         ImpressionEvent imp1 = buildImpression("experiment", "1111", "2222", "3333");
         LogEvent log1 = EventFactory.createLogEvent(imp1);
         assertEquals(firstDecision(log1).getCampaignId(), firstEvent(log1).getEntityId());
+        assertEquals("1111", firstEvent(log1).getEntityId());
 
-        // 2) campaign_id invalid → both equal to experiment_id.
+        // 2) campaign_id is opaque non-numeric string → passes through unchanged
+        //    under the relaxed FSSDK-12813 contract; entity_id still mirrors it.
         ImpressionEvent imp2 = buildImpression("experiment", "bad", "2222", "3333");
         LogEvent log2 = EventFactory.createLogEvent(imp2);
         assertEquals(firstDecision(log2).getCampaignId(), firstEvent(log2).getEntityId());
-        assertEquals("2222", firstEvent(log2).getEntityId());
+        assertEquals("bad", firstEvent(log2).getEntityId());
 
-        // 3) campaign_id null → both equal to experiment_id.
+        // 3) campaign_id null → fallback to experiment_id, entity_id mirrors it.
         ImpressionEvent imp3 = buildImpression("experiment", null, "2222", "3333");
         LogEvent log3 = EventFactory.createLogEvent(imp3);
         assertEquals(firstDecision(log3).getCampaignId(), firstEvent(log3).getEntityId());
+        assertEquals("2222", firstEvent(log3).getEntityId());
+
+        // 4) campaign_id empty string → fallback to experiment_id, entity_id mirrors it.
+        ImpressionEvent imp4 = buildImpression("experiment", "", "2222", "3333");
+        LogEvent log4 = EventFactory.createLogEvent(imp4);
+        assertEquals(firstDecision(log4).getCampaignId(), firstEvent(log4).getEntityId());
+        assertEquals("2222", firstEvent(log4).getEntityId());
     }
 
     // ---------------------------------------------------------------------
@@ -277,12 +338,32 @@ public void entityId_alwaysMirrorsNormalizedCampaignId() {
 
     @Test
     public void event_isNeverDropped_evenWhenAllIdsAreInvalid() {
-        ImpressionEvent imp = buildImpression(
+        // FSSDK-12813 (FR-006/FR-007): Even when EVERY id is null or non-numeric,
+        // the event must still be created — normalization never drops events and
+        // never throws. We use null/empty campaign_id (triggers fallback) and a
+        // non-numeric variation_id (becomes null) to exercise both fallback paths.
+        ImpressionEvent impNullCampaign = buildImpression(
+            "experiment", null, "2222", "bad");
+        LogEvent logNull = EventFactory.createLogEvent(impNullCampaign);
+        assertNotNull("Event must not be dropped due to id normalization", logNull);
+        assertNotNull(firstDecision(logNull));
+        assertNotNull(firstEvent(logNull));
+
+        ImpressionEvent impEmptyCampaign = buildImpression(
+            "experiment", "", "2222", "bad");
+        LogEvent logEmpty = EventFactory.createLogEvent(impEmptyCampaign);
+        assertNotNull("Event must not be dropped due to id normalization", logEmpty);
+        assertNotNull(firstDecision(logEmpty));
+        assertNotNull(firstEvent(logEmpty));
+
+        // Also verify an opaque-but-non-empty campaign_id (now valid under the
+        // relaxed contract) still produces a non-null event.
+        ImpressionEvent impOpaqueCampaign = buildImpression(
             "experiment", "bad", "2222", "bad");
-        LogEvent log = EventFactory.createLogEvent(imp);
-        assertNotNull("Event must not be dropped due to id normalization", log);
-        assertNotNull(firstDecision(log));
-        assertNotNull(firstEvent(log));
+        LogEvent logOpaque = EventFactory.createLogEvent(impOpaqueCampaign);
+        assertNotNull("Event must not be dropped due to id normalization", logOpaque);
+        assertNotNull(firstDecision(logOpaque));
+        assertNotNull(firstEvent(logOpaque));
     }
 
     // ---------------------------------------------------------------------