@gradial/aci 0.1.52-rc.16 → 0.1.52-rc.21

package/README.md

@@ -1,6 +1,6 @@
 # Agentic Content Infrastructure SDK
 
-`@gradial/aci` `0.1.52-rc.16` is a pre-1.0 public-surface reset for the ACI
+`@gradial/aci` `0.1.52-rc.21` is a pre-1.0 public-surface reset for the ACI
 client SDK. Breaking changes from the old `0.1.x` accidental surface are
 intentional: the root import is framework-neutral, framework runtime behavior is
 behind explicit subpaths, and the first required customer path is React/Next.
@@ -8,7 +8,7 @@ behind explicit subpaths, and the first required customer path is React/Next.
 ## Install
 
 ```bash
-npm install @gradial/aci@0.1.52-rc.16 zod@^4
+npm install @gradial/aci@0.1.52-rc.21 zod@^4
 ```
 
 ## Root Import
@@ -78,13 +78,13 @@ host bundles select and serve immutable release artifacts.
 The first RC scaffold path is Next:
 
 ```bash
-npx @gradial/aci@0.1.52-rc.16 init my-site --template next-starter
+npx @gradial/aci@0.1.52-rc.21 init my-site --template next-starter
 ```
 
 List available templates:
 
 ```bash
-npx @gradial/aci@0.1.52-rc.16 init --list
+npx @gradial/aci@0.1.52-rc.21 init --list
 ```
 
 ## Personalization: The One-Tag Install

package/dist/astro/preview.js

@@ -1,9 +1,9 @@
-import { extractPreviewToken, resolvePreviewContext, createPreviewBannerHTML as coreCreatePreviewBannerHTML, createPreviewCookies as coreCreatePreviewCookies, previewSignKey, } from '../preview/core.js';
+import { extractPreviewToken, parseCookies, resolvePreviewContext, createPreviewBannerHTML as coreCreatePreviewBannerHTML, createPreviewCookies as coreCreatePreviewCookies, previewSignKey, } from '../preview/core.js';
 export async function getPreviewMode(request, siteId) {
     const url = new URL(request.url);
     const token = extractPreviewToken({
         query: url.searchParams,
-        cookies: parseCookieHeader(request.headers.get('cookie') || ''),
+        cookies: parseCookies(request.headers.get('cookie') || ''),
         authorization: request.headers.get('authorization') || undefined,
     });
     if (!token)
@@ -16,18 +16,3 @@ export function createPreviewBannerHTML(releaseId) {
 export function createPreviewCookies(token, releaseId) {
     return coreCreatePreviewCookies(token, releaseId);
 }
-function parseCookieHeader(header) {
-    const cookies = new Map();
-    for (const part of header.split(';')) {
-        const trimmed = part.trim();
-        if (!trimmed)
-            continue;
-        const idx = trimmed.indexOf('=');
-        if (idx < 0)
-            continue;
-        const name = trimmed.slice(0, idx).trim();
-        const value = trimmed.slice(idx + 1).trim();
-        cookies.set(name, decodeURIComponent(value));
-    }
-    return cookies;
-}

package/dist/audience-data-models.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare const expressionOperators: readonly ["equals", "contains", "startsWith", "exists", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "before", "after", "between", "in"];
 export declare const segmentDataModel: import("./index.js").DataModelContract<z.ZodObject<{
     id: z.ZodString;
     displayName: z.ZodString;
@@ -299,22 +300,44 @@ export declare const audienceRuleDataModel: import("./index.js").DataModelContra
         all: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
         any: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
 }, z.core.$strip>, "audience_rule">;
@@ -338,22 +361,44 @@ export declare const goalDataModel: import("./index.js").DataModelContract<z.Zod
         all: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
         any: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, "goal">;
@@ -399,22 +444,44 @@ export declare const experimentDataModel: import("./index.js").DataModelContract
             all: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 field: z.ZodString;
                 operator: z.ZodEnum<{
+                    in: "in";
                     equals: "equals";
                     contains: "contains";
                     startsWith: "startsWith";
                     exists: "exists";
+                    greaterThan: "greaterThan";
+                    greaterThanOrEqual: "greaterThanOrEqual";
+                    lessThan: "lessThan";
+                    lessThanOrEqual: "lessThanOrEqual";
+                    before: "before";
+                    after: "after";
+                    between: "between";
                 }>;
-                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                    min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>]>>;
             }, z.core.$strip>>>;
             any: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 field: z.ZodString;
                 operator: z.ZodEnum<{
+                    in: "in";
                     equals: "equals";
                     contains: "contains";
                     startsWith: "startsWith";
                     exists: "exists";
+                    greaterThan: "greaterThan";
+                    greaterThanOrEqual: "greaterThanOrEqual";
+                    lessThan: "lessThan";
+                    lessThanOrEqual: "lessThanOrEqual";
+                    before: "before";
+                    after: "after";
+                    between: "between";
                 }>;
-                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                    min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>]>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
@@ -432,22 +499,44 @@ export declare const experimentationDataModels: (import("./index.js").DataModelC
         all: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
         any: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, "goal"> | import("./index.js").DataModelContract<z.ZodObject<{
@@ -492,22 +581,44 @@ export declare const experimentationDataModels: (import("./index.js").DataModelC
             all: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 field: z.ZodString;
                 operator: z.ZodEnum<{
+                    in: "in";
                     equals: "equals";
                     contains: "contains";
                     startsWith: "startsWith";
                     exists: "exists";
+                    greaterThan: "greaterThan";
+                    greaterThanOrEqual: "greaterThanOrEqual";
+                    lessThan: "lessThan";
+                    lessThanOrEqual: "lessThanOrEqual";
+                    before: "before";
+                    after: "after";
+                    between: "between";
                 }>;
-                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                    min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>]>>;
             }, z.core.$strip>>>;
             any: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 field: z.ZodString;
                 operator: z.ZodEnum<{
+                    in: "in";
                     equals: "equals";
                     contains: "contains";
                     startsWith: "startsWith";
                     exists: "exists";
+                    greaterThan: "greaterThan";
+                    greaterThanOrEqual: "greaterThanOrEqual";
+                    lessThan: "lessThan";
+                    lessThanOrEqual: "lessThanOrEqual";
+                    before: "before";
+                    after: "after";
+                    between: "between";
                 }>;
-                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                    min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>]>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
@@ -809,22 +920,44 @@ export declare const audienceDataModels: (import("./index.js").DataModelContract
         all: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
         any: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
 }, z.core.$strip>, "audience_rule"> | import("./index.js").DataModelContract<z.ZodObject<{
@@ -846,22 +979,44 @@ export declare const audienceDataModels: (import("./index.js").DataModelContract
         all: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
         any: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             operator: z.ZodEnum<{
+                in: "in";
                 equals: "equals";
                 contains: "contains";
                 startsWith: "startsWith";
                 exists: "exists";
+                greaterThan: "greaterThan";
+                greaterThanOrEqual: "greaterThanOrEqual";
+                lessThan: "lessThan";
+                lessThanOrEqual: "lessThanOrEqual";
+                before: "before";
+                after: "after";
+                between: "between";
             }>;
-            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, "goal"> | import("./index.js").DataModelContract<z.ZodObject<{
@@ -906,22 +1061,44 @@ export declare const audienceDataModels: (import("./index.js").DataModelContract
             all: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 field: z.ZodString;
                 operator: z.ZodEnum<{
+                    in: "in";
                     equals: "equals";
                     contains: "contains";
                     startsWith: "startsWith";
                     exists: "exists";
+                    greaterThan: "greaterThan";
+                    greaterThanOrEqual: "greaterThanOrEqual";
+                    lessThan: "lessThan";
+                    lessThanOrEqual: "lessThanOrEqual";
+                    before: "before";
+                    after: "after";
+                    between: "between";
                 }>;
-                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                    min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>]>>;
             }, z.core.$strip>>>;
             any: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 field: z.ZodString;
                 operator: z.ZodEnum<{
+                    in: "in";
                     equals: "equals";
                     contains: "contains";
                     startsWith: "startsWith";
                     exists: "exists";
+                    greaterThan: "greaterThan";
+                    greaterThanOrEqual: "greaterThanOrEqual";
+                    lessThan: "lessThan";
+                    lessThanOrEqual: "lessThanOrEqual";
+                    before: "before";
+                    after: "after";
+                    between: "between";
                 }>;
-                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodObject<{
+                    min: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    max: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>]>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;

package/dist/audience-data-models.js

@@ -51,10 +51,55 @@ const segmentCriteriaSchema = z.union([
         none: z.array(segmentCriteriaConditionSchema).optional(),
     }).strict(),
 ]);
+// Mirrors the ADR 0038 operator vocabulary for author-time DX; the expression
+// kernel stays the authority, and the capability drift test pins this enum
+// and the operand pairing to the generated artifact.
+export const expressionOperators = [
+    'equals', 'contains', 'startsWith', 'exists',
+    'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual',
+    'before', 'after', 'between', 'in',
+];
+const maxInValues = 32;
+const rangeBoundValue = z.union([z.number(), z.string()]);
+const conditionValueSchema = z.union([
+    scalarValue,
+    z.array(scalarValue).min(1).max(maxInValues),
+    z.object({ min: rangeBoundValue, max: rangeBoundValue }).strict(),
+]);
+const scalarOperandOperators = new Set(['equals', 'contains', 'startsWith']);
+const numberOperandOperators = new Set(['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual']);
+const timestampOperandOperators = new Set(['before', 'after']);
 const requestRuleConditionSchema = z.object({
     field: z.string().min(1),
-    operator: z.enum(['equals', 'contains', 'startsWith', 'exists']),
-    value: scalarValue.optional(),
+    operator: z.enum(expressionOperators),
+    value: conditionValueSchema.optional(),
+}).superRefine((condition, context) => {
+    const { operator, value } = condition;
+    const fail = (message) => context.addIssue({ code: z.ZodIssueCode.custom, path: ['value'], message });
+    if (operator === 'exists') {
+        if (value !== undefined && typeof value !== 'boolean')
+            fail('exists takes an optional boolean value');
+        return;
+    }
+    if (value === undefined) {
+        fail(`value is required for operator ${operator}`);
+        return;
+    }
+    if (scalarOperandOperators.has(operator) && (typeof value === 'object')) {
+        fail(`${operator} takes one scalar value`);
+    }
+    else if (numberOperandOperators.has(operator) && typeof value !== 'number') {
+        fail(`${operator} takes one finite JSON number`);
+    }
+    else if (timestampOperandOperators.has(operator) && typeof value !== 'string') {
+        fail(`${operator} takes one RFC 3339 timestamp string`);
+    }
+    else if (operator === 'between' && (typeof value !== 'object' || Array.isArray(value))) {
+        fail('between takes a {min, max} object');
+    }
+    else if (operator === 'in' && !Array.isArray(value)) {
+        fail(`in takes an array of 1 to ${maxInValues} scalars`);
+    }
 });
 const requestRuleExpressionSchema = z.object({
     all: z.array(requestRuleConditionSchema).optional(),

package/dist/collect/batcher.d.ts

@@ -26,11 +26,12 @@ export type PendingEvent = Omit<CollectEvent, "eventId">;
 /** Planning threshold: full serialized envelope, UTF-8 bytes. */
 export declare const MAX_BATCH_BYTES: number;
 /**
- * Hard event-count cap per envelope. The Next collect-route imports this
- * constant and rejects larger envelopes (the Go handler enforces only the
- * 64KiB body cap today), so a byte-capped-only batch of small events (~400
- * fit in 60KiB) would 400 on that host and silently lose the whole flush.
- * The client caps at the strictest host.
+ * Hard event-count cap per envelope. The provider-neutral runtime collector
+ * (internal/domain/audience/runtime/collect.ts MAX_BATCH_EVENTS) enforces the
+ * same bound server-side (the Go handler enforces only the 64KiB body cap
+ * today), so a byte-capped-only batch of small events (~400 fit in 60KiB)
+ * would 400 on that host and silently lose the whole flush. The client caps
+ * at the strictest host; keep the two constants equal.
  */
 export declare const MAX_BATCH_EVENTS = 100;
 /** Flush interval (build-time constant, design/04 config table). */

package/dist/collect/batcher.js

@@ -7,11 +7,12 @@ import { ulid } from "./ulid.js";
 /** Planning threshold: full serialized envelope, UTF-8 bytes. */
 export const MAX_BATCH_BYTES = 60 * 1024;
 /**
- * Hard event-count cap per envelope. The Next collect-route imports this
- * constant and rejects larger envelopes (the Go handler enforces only the
- * 64KiB body cap today), so a byte-capped-only batch of small events (~400
- * fit in 60KiB) would 400 on that host and silently lose the whole flush.
- * The client caps at the strictest host.
+ * Hard event-count cap per envelope. The provider-neutral runtime collector
+ * (internal/domain/audience/runtime/collect.ts MAX_BATCH_EVENTS) enforces the
+ * same bound server-side (the Go handler enforces only the 64KiB body cap
+ * today), so a byte-capped-only batch of small events (~400 fit in 60KiB)
+ * would 400 on that host and silently lose the whole flush. The client caps
+ * at the strictest host; keep the two constants equal.
  */
 export const MAX_BATCH_EVENTS = 100;
 /** Flush interval (build-time constant, design/04 config table). */

package/dist/edge/expression-capabilities.v1.d.ts

@@ -0,0 +1,106 @@
+export declare const expressionCapabilities: {
+    readonly schemaVersion: 1;
+    readonly contract: "personalization-expression";
+    readonly maxConditions: 64;
+    readonly maxDepth: 5;
+    readonly maxInValues: 32;
+    readonly grammars: {
+        readonly number: "^-?(0|[1-9][0-9]*)(\\.[0-9]+)?([eE][+-]?[0-9]+)?$";
+        readonly timestamp: "^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})(\\.\\d{1,9})?(Z|[+-]\\d{2}:\\d{2})$";
+    };
+    readonly operators: readonly [{
+        readonly name: "equals";
+        readonly operand: "scalar";
+        readonly compact: "eq";
+    }, {
+        readonly name: "contains";
+        readonly operand: "scalar";
+        readonly compact: "ct";
+    }, {
+        readonly name: "startsWith";
+        readonly operand: "scalar";
+        readonly compact: "sw";
+    }, {
+        readonly name: "exists";
+        readonly operand: "optionalBoolean";
+        readonly compact: "ex";
+    }, {
+        readonly name: "greaterThan";
+        readonly operand: "number";
+        readonly compact: "gt";
+    }, {
+        readonly name: "greaterThanOrEqual";
+        readonly operand: "number";
+        readonly compact: "ge";
+    }, {
+        readonly name: "lessThan";
+        readonly operand: "number";
+        readonly compact: "lt";
+    }, {
+        readonly name: "lessThanOrEqual";
+        readonly operand: "number";
+        readonly compact: "le";
+    }, {
+        readonly name: "before";
+        readonly operand: "timestamp";
+        readonly compact: "bf";
+    }, {
+        readonly name: "after";
+        readonly operand: "timestamp";
+        readonly compact: "af";
+    }, {
+        readonly name: "between";
+        readonly operand: "range";
+        readonly compact: "bt";
+        readonly range: {
+            readonly memberTypes: readonly ["number", "timestamp"];
+            readonly homogeneous: true;
+            readonly inclusive: true;
+        };
+    }, {
+        readonly name: "in";
+        readonly operand: "scalarList";
+        readonly compact: "in";
+        readonly maxValues: 32;
+    }];
+    readonly scopes: readonly [{
+        readonly scope: "request";
+        readonly allowsEmpty: false;
+        readonly fields: readonly [{
+            readonly field: "referrer";
+        }, {
+            readonly field: "query.*";
+        }, {
+            readonly field: "header.*";
+        }, {
+            readonly field: "cookie.*";
+        }, {
+            readonly field: "geo.*";
+        }, {
+            readonly field: "utm.*";
+        }, {
+            readonly field: "device.class";
+            readonly operators: readonly ["equals", "in", "exists"];
+            readonly values: readonly ["desktop", "mobile", "tablet", "unknown"];
+        }, {
+            readonly field: "time.now";
+            readonly operators: readonly ["before", "after", "between", "exists"];
+            readonly instant: true;
+        }, {
+            readonly field: "audience.memberships";
+            readonly operators: readonly ["equals", "in", "exists"];
+        }];
+    }, {
+        readonly scope: "event";
+        readonly allowsEmpty: true;
+        readonly fields: readonly [{
+            readonly field: "referrer";
+        }, {
+            readonly field: "page.path";
+        }, {
+            readonly field: "properties.*";
+        }, {
+            readonly field: "utm.*";
+        }];
+    }];
+};