@gradial/aci 0.1.52-rc.29 → 0.1.52-rc.34-e2e.1

package/dist/audience-data-models.js

@@ -1,9 +1,190 @@
+// GENERATED by scripts/generate-data-models.go — DO NOT EDIT.
+// Regenerate: make data-models
+//
+// Authoring data models for the audience-family and experimentation content
+// documents, generated from the Go document readers' contracts (the readers
+// stay the authority on what the API accepts; these give authors client-side
+// validation that cannot drift from them). The canonical descriptor artifact
+// is packages/sdk/schema/audience-data-models.v1.json, drift-gated in CI by
+// make data-models-verify.
 import { z } from 'zod';
 import { defineDataModel } from './define-data-model.js';
-const resourceStatus = z.enum(['draft', 'enabled', 'disabled']);
-const experimentStatus = z.enum(['draft', 'running', 'paused', 'stopped', 'promoted', 'archived']);
-const experimentKind = z.enum(['ab', 'abn', 'xt']);
+// 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 scalarValue = z.union([z.string(), z.number(), z.boolean()]);
+const maxInValues = 32;
+const maxConditions = 64;
+const maxExpressionDepth = 5;
+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']);
+// A condition is strict — the kernel's decoder retains unknown leaf keys so
+// validation can reject them rather than silently dropping authored meaning.
+const expressionConditionSchema = z.object({
+    field: z.string().min(1),
+    operator: z.enum(expressionOperators),
+    value: conditionValueSchema.optional(),
+}).strict().superRefine((condition, context) => {
+    const { operator, value } = condition;
+    const fail = (message) => context.addIssue({ code: '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`);
+    }
+});
+// Groups are strict too: a member carrying all/any is a group, and any other
+// key on it is an unsupported expression group the kernel refuses. An empty
+// group is refused by validateAuthoredExpression below, mirroring the
+// kernel's members-not-leaves emptiness rule.
+const expressionGroupSchema = z.lazy(() => z.object({
+    all: z.array(expressionMemberSchema).optional(),
+    any: z.array(expressionMemberSchema).optional(),
+}).strict());
+const expressionMemberSchema = z.lazy(() => z.union([expressionConditionSchema, expressionGroupSchema]));
+const requestScopeFields = [
+    { field: 'referrer' },
+    { field: 'query.', prefix: true },
+    { field: 'header.', prefix: true },
+    { field: 'cookie.', prefix: true },
+    { field: 'geo.', prefix: true },
+    { field: 'utm.', prefix: true },
+    { field: 'device.class', operators: ['equals', 'in', 'exists'], values: ['desktop', 'mobile', 'tablet', 'unknown'] },
+    { field: 'time.now', operators: ['before', 'after', 'between', 'exists'], instant: true },
+    { field: 'audience.memberships', operators: ['equals', 'in', 'exists'] },
+];
+const eventScopeFields = [
+    { field: 'referrer' },
+    { field: 'page.path' },
+    { field: 'properties.', prefix: true },
+    { field: 'utm.', prefix: true },
+];
+function expressionFieldRule(fields, field) {
+    for (const rule of fields) {
+        if (rule.prefix) {
+            // A prefix rule needs at least one character past the prefix, exactly
+            // like the kernel's fieldRuleFor.
+            if (field.length > rule.field.length && field.startsWith(rule.field))
+                return rule;
+            continue;
+        }
+        if (rule.field === field)
+            return rule;
+    }
+    return undefined;
+}
+// validateAuthoredExpression mirrors the kernel's validation walk
+// (personalization/expression Validate): one diagnostic per broken node, the
+// leaf budget counted with the same depth cutoff, emptiness judged on
+// members not leaves.
+function validateAuthoredExpression(expressionValue, fields, allowsEmpty, context) {
+    const fail = (path, message) => context.addIssue({ code: 'custom', path, message });
+    const walk = (members, path, depth) => {
+        (members ?? []).forEach((member, index) => {
+            const memberPath = [...path, index];
+            if (!('all' in member || 'any' in member)) {
+                validateScopedCondition(member, fields, memberPath, fail);
+                return;
+            }
+            const group = member;
+            // One diagnostic per broken node, and no descent past it: a too-deep
+            // branch reports its depth once rather than repeating for every
+            // condition buried inside it.
+            if (depth + 1 > maxExpressionDepth) {
+                fail(memberPath, `must not nest more than ${maxExpressionDepth} levels deep`);
+                return;
+            }
+            if ((group.all?.length ?? 0) + (group.any?.length ?? 0) === 0) {
+                fail(memberPath, 'must include at least one all or any condition');
+                return;
+            }
+            walk(group.all, [...memberPath, 'all'], depth + 1);
+            walk(group.any, [...memberPath, 'any'], depth + 1);
+        });
+    };
+    if ((expressionValue.all?.length ?? 0) + (expressionValue.any?.length ?? 0) === 0 && !allowsEmpty) {
+        fail([], 'must include at least one all or any condition');
+    }
+    if (countExpressionLeaves(expressionValue.all, 1) + countExpressionLeaves(expressionValue.any, 1) > maxConditions) {
+        fail([], `must contain at most ${maxConditions} conditions`);
+    }
+    walk(expressionValue.all, ['all'], 1);
+    walk(expressionValue.any, ['any'], 1);
+}
+// countExpressionLeaves counts leaf conditions across the tree with the same
+// depth cutoff the validating walk applies, so the two limits never disagree
+// about a tree.
+function countExpressionLeaves(members, depth) {
+    let total = 0;
+    for (const member of members ?? []) {
+        if (!('all' in member || 'any' in member)) {
+            total++;
+            continue;
+        }
+        if (depth + 1 > maxExpressionDepth)
+            continue;
+        const group = member;
+        total += countExpressionLeaves(group.all, depth + 1) + countExpressionLeaves(group.any, depth + 1);
+    }
+    return total;
+}
+function validateScopedCondition(condition, fields, path, fail) {
+    const rule = expressionFieldRule(fields, condition.field);
+    if (!rule) {
+        fail([...path, 'field'], `field ${condition.field} is not supported in this scope`);
+        return;
+    }
+    if (rule.operators && !rule.operators.includes(condition.operator)) {
+        fail([...path, 'operator'], `operator ${condition.operator} is not supported for ${condition.field}`);
+        return;
+    }
+    if (rule.values && (condition.operator === 'equals' || condition.operator === 'in')) {
+        const members = condition.operator === 'in' && Array.isArray(condition.value) ? condition.value : [condition.value];
+        for (const memberValue of members) {
+            if (typeof memberValue === 'string' && !rule.values.includes(memberValue)) {
+                fail([...path, 'value'], `value ${JSON.stringify(memberValue)} is not supported for ${condition.field}`);
+            }
+        }
+    }
+    // An instant field narrows a dual-typed operand: between on time.now takes
+    // timestamp bounds, so a numeric range cannot validate and then sit
+    // silently inert at execution.
+    if (rule.instant && condition.operator === 'between') {
+        const range = condition.value;
+        if (typeof range?.min !== 'string' || typeof range?.max !== 'string') {
+            fail([...path, 'value'], `between takes timestamp bounds on ${condition.field}`);
+        }
+    }
+}
+const requestRuleExpressionSchema = expressionGroupSchema.superRefine((expressionValue, context) => validateAuthoredExpression(expressionValue, requestScopeFields, false, context));
+const eventRuleExpressionSchema = expressionGroupSchema.superRefine((expressionValue, context) => validateAuthoredExpression(expressionValue, eventScopeFields, true, context));
 // Largest whole-day window whose nanoseconds fit in Go's time.Duration:
 // floor(MaxInt64 / (24 * time.Hour)) = 106751.
 const maxCriteriaWithinDays = 106751;
@@ -16,12 +197,20 @@ const criteriaExperimentSchema = z.object({
     experimentId: z.string().regex(/\S/, 'experimentId is required'),
     armId: z.string().optional(),
 }).strict();
+// The server-stamped request geo filter (CollectGeo): normalized codes,
+// exact match. geo requires country or region — the write gate owns that
+// rule (a refinement would make this model uncompilable to JSON Schema).
+const criteriaGeoSchema = z.object({
+    country: z.string().regex(/^[A-Z]{2}$/, 'geo.country must be an uppercase ISO 3166-1 alpha-2 code').optional(),
+    region: z.string().regex(/^[A-Z0-9]{1,3}$/, 'geo.region must be 1-3 uppercase alphanumerics').optional(),
+}).strict();
 const criteriaFilterShape = {
     event: z.string().regex(/\S/, 'event is required'),
     path: z.string().regex(/^(?!\*$)/, 'path must not be a lone "*"').optional(),
     referrer: z.string().regex(/^(?!\*$)/, 'referrer must not be a lone "*"').optional(),
     withinDays: z.number().int().positive().max(maxCriteriaWithinDays).optional(),
     experiment: criteriaExperimentSchema.optional(),
+    geo: criteriaGeoSchema.optional(),
     properties: z.record(z.string(), criteriaFilterValue).optional(),
 };
 const segmentCriteriaConditionSchema = z.discriminatedUnion('type', [
@@ -51,192 +240,167 @@ 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(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');
+// The mapped-json extraction matrix (validateProviderMapping): mapping is
+// forbidden for aep-batch-export and required for mapped-json, whose
+// membership declares exactly one source. Pointer grammar and pattern
+// compilation stay with the write gate.
+function providerFormatMappingMatrix(props, context) {
+    const fail = (path, message) => context.addIssue({ code: 'custom', path, message });
+    if (props.format === "aep-batch-export") {
+        if (props.mapping !== undefined) {
+            fail(['mapping'], 'mapping is only valid for format "mapped-json"');
+        }
         return;
     }
-    if (value === undefined) {
-        fail(`value is required for operator ${operator}`);
+    if (props.mapping === undefined) {
+        fail(['mapping'], 'mapping is required for format "mapped-json"');
         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');
+    const membership = props.mapping.membership;
+    if (membership === undefined) {
+        fail(['mapping', 'membership'], 'mapping.membership is required');
+        return;
     }
-    else if (operator === 'in' && !Array.isArray(value)) {
-        fail(`in takes an array of 1 to ${maxInValues} scalars`);
+    const sources = [membership.segmentIdsPath, membership.objectNamePattern]
+        .filter((value) => value !== undefined && value !== '');
+    if (sources.length !== 1) {
+        fail(['mapping', 'membership'], 'mapping.membership must declare exactly one of segmentIdsPath or objectNamePattern');
     }
-});
-const requestRuleExpressionSchema = z.object({
-    all: z.array(requestRuleConditionSchema).optional(),
-    any: z.array(requestRuleConditionSchema).optional(),
-});
+}
+// scopedID is the experiment scope's path-safe grammar (validateScope): ""
+// is the homepage route; segments are identifiers; ".." is rejected.
+const scopedID = z.string().refine((value) => {
+    const trimmed = value.replace(/^\/+|\/+$/g, '');
+    if (trimmed === '')
+        return true;
+    if (trimmed.includes('..'))
+        return false;
+    return trimmed.split('/').every((part) => /^[A-Za-z0-9_-]+$/.test(part));
+}, { message: 'must be a path-safe scoped id' });
 export const segmentDataModel = defineDataModel({
     type: 'segment',
     schema: z.object({
-        id: z.string().min(1),
-        displayName: z.string().min(1),
-        status: resourceStatus,
-        priority: z.number().int().nonnegative().optional(),
+        id: z.string().regex(/^(?!base$)[A-Za-z0-9_-]+$/, 'must contain only letters, numbers, underscores, or hyphens; "base" is reserved (it names the base variant key and the no-leg-won selectedLeg sentinel, ADR 0050)'),
+        displayName: z.string().regex(/\S/, 'displayName is required'),
+        status: z.enum(['draft', 'enabled', 'disabled']),
+        priority: z.number().int().min(0).optional(),
         description: z.string().optional(),
+        // Absent = a static label the deriver never evaluates. The conditions budget (64) and geo's country-or-region requirement stay with the write gate: this model compiles to JSON Schema (compileSchema), which cannot represent refinements.
         criteria: segmentCriteriaSchema.optional(),
     }),
 });
 export const audienceDataModel = defineDataModel({
     type: 'audience',
     schema: z.object({
-        id: z.string().min(1),
-        displayName: z.string().min(1),
-        status: resourceStatus,
-        priority: z.number().int().nonnegative(),
+        id: z.string().regex(/^(?!base$)[A-Za-z0-9_-]+$/, 'must contain only letters, numbers, underscores, or hyphens; "base" is reserved (it names the base variant key and the no-leg-won selectedLeg sentinel, ADR 0050)'),
+        displayName: z.string().regex(/\S/, 'displayName is required'),
+        description: z.string().optional(),
+        status: z.enum(['draft', 'enabled', 'disabled']),
+        priority: z.number().int().min(0),
         membershipSource: z.enum(['rule', 'segment', 'manual', 'external', 'none']),
         ruleRef: z.string().optional(),
         segmentRef: z.string().optional(),
         providerRef: z.string().optional(),
-        externalSegmentId: z
-            .string()
-            .min(1)
-            .max(256)
-            .refine((value) => value.trim() === value, {
-            message: 'externalSegmentId must not have leading or trailing whitespace',
-        })
-            .optional(),
+        externalSegmentId: z.string().min(1).max(256).refine((value) => value.trim() === value, { message: 'must not have leading or trailing whitespace' }).optional(),
     }),
 });
-const providerIdentityResolutionSchema = z.object({
-    field: z.string().regex(/^(cookie|query|header)\..+$/, 'field must be cookie.<name>, query.<name>, or header.<name>'),
-}).strict();
 export const audienceProviderDataModel = defineDataModel({
     type: 'audience_provider',
     schema: z.object({
-        id: z.string().regex(/^[A-Za-z0-9_-]+$/, 'id must contain only letters, numbers, underscores, or hyphens'),
-        displayName: z.string().min(1),
-        status: resourceStatus,
+        id: z.string().regex(/^(?!base$)[A-Za-z0-9_-]+$/, 'must contain only letters, numbers, underscores, or hyphens; "base" is reserved (it names the base variant key and the no-leg-won selectedLeg sentinel, ADR 0050)'),
+        displayName: z.string().regex(/\S/, 'displayName is required'),
+        status: z.enum(['draft', 'enabled', 'disabled']),
         format: z.enum(['aep-batch-export', 'mapped-json']),
         identity: z.object({
-            sourceNamespace: z.string().min(1),
-            resolution: z.array(providerIdentityResolutionSchema).optional(),
+            sourceNamespace: z.string().regex(/\S/, 'sourceNamespace is required').refine((value) => value.trim().toLowerCase() !== 'aci_id', { message: 'must be an external namespace, not the first-party aci_id namespace' }),
+            absencePolicy: z.enum(['unlink', 'retain']),
+            resolution: z.array(z.object({
+                field: z.string().regex(/^(cookie|query|header)\.[A-Za-z0-9_-]+$/),
+            }).strict()).optional(),
         }).strict(),
-        membershipTtlDays: z.number().int().positive(),
+        membershipTtlDays: z.number().int().min(1),
+        // The write gate compiles it (CompileProviderDumpSchema); the schema only pins the object envelope.
         dumpSchema: z.record(z.string(), z.unknown()).optional(),
-        // mapped-json extraction declarations (required for that format; the Go
-        // write gate owns the full matrix — exactly one membership source, valid
-        // RFC 6901 pointers, a compiling single-capture pattern).
+        // mapped-json extraction declarations (required for that format; the Go write gate owns the full matrix — valid RFC 6901 pointers, a compiling single-capture pattern).
         mapping: z.object({
             identity: z.object({
-                path: z.string().regex(/^\//, 'identity.path must be an RFC 6901 JSON pointer'),
+                path: z.string().regex(/^\//),
             }).strict(),
             membership: z.object({
                 segmentIdsPath: z.string().regex(/^\//).optional(),
-                objectNamePattern: z.string().min(1).optional(),
+                objectNamePattern: z.string().regex(/\S/, 'objectNamePattern must not be blank').optional(),
             }).strict(),
             qualifiedAtPath: z.string().regex(/^\//).optional(),
         }).strict().optional(),
         discovery: z.object({
             mode: z.enum(['draft', 'report-only']),
-            maxPerImport: z.number().int().positive().max(1000).optional(),
+            maxPerImport: z.number().int().min(1).max(1000).optional(),
         }).strict(),
         limits: z.object({
-            maxDumpBytes: z.number().int().positive().optional(),
-            maxRecords: z.number().int().positive().optional(),
-            maxIdentitiesPerRecord: z.number().int().positive().optional(),
+            maxDumpBytes: z.number().int().min(1).optional(),
+            maxRecords: z.number().int().min(1).optional(),
+            maxIdentitiesPerRecord: z.number().int().min(1).optional(),
         }).strict().optional(),
-    }),
+    }).strict().superRefine(providerFormatMappingMatrix),
 });
 export const audienceRuleDataModel = defineDataModel({
     type: 'audience_rule',
     schema: z.object({
-        id: z.string().min(1),
-        status: resourceStatus,
+        id: z.string().regex(/^(?!base$)[A-Za-z0-9_-]+$/, 'must contain only letters, numbers, underscores, or hyphens; "base" is reserved (it names the base variant key and the no-leg-won selectedLeg sentinel, ADR 0050)'),
+        status: z.enum(['draft', 'enabled', 'disabled']),
         description: z.string().optional(),
         expression: requestRuleExpressionSchema,
     }),
 });
-export const visitorProfileDataModel = defineDataModel({
-    type: 'visitor_profile',
-    schema: z.object({
-        visitorId: z.string().min(1),
-        audienceIds: z.array(z.string().min(1)).optional(),
-        segmentIds: z.array(z.string().min(1)).optional(),
-        traits: z.record(z.string(), scalarValue).optional(),
-        updatedAt: z.string().optional(),
-    }),
-});
 export const goalDataModel = defineDataModel({
     type: 'goal',
     schema: z.object({
-        id: z.string().min(1),
-        displayName: z.string().min(1),
-        status: resourceStatus,
-        eventName: z.string().min(1),
-        eventRule: requestRuleExpressionSchema.optional(),
+        id: z.string().regex(/^[A-Za-z0-9_-]+$/, 'must contain only letters, numbers, underscores, or hyphens'),
+        displayName: z.string().regex(/\S/, 'displayName is required'),
+        status: z.enum(['draft', 'enabled', 'disabled']),
+        eventName: z.string().regex(/^(?:rum\.page_view|rum\.link_click|rum\.variation_view|rum\.web_vital|experiment\.exposure|experiment\.conversion|experiment\.engagement|custom\.[^\s/\\]+)$/, 'must be one of the rum.* or experiment.* events, or use the custom.* namespace').max(128),
+        // Event scope (expression.ScopeEvent): referrer, page.path, properties.*, utm.* — request-only fields are rejected.
+        eventRule: eventRuleExpressionSchema.optional(),
     }),
 });
 export const experimentDataModel = defineDataModel({
     type: 'experiment',
     schema: z.object({
-        id: z.string().min(1),
-        displayName: z.string().min(1),
-        status: experimentStatus,
-        kind: experimentKind,
-        priority: z.number().int().nonnegative(),
+        id: z.string().regex(/^[A-Za-z0-9_-]+$/, 'must contain only letters, numbers, underscores, or hyphens'),
+        displayName: z.string().regex(/\S/, 'displayName is required'),
+        status: z.enum(['draft', 'running', 'paused', 'stopped', 'promoted', 'archived']),
+        kind: z.enum(['ab', 'abn', 'xt']),
+        priority: z.number().int().min(0),
         allocationVersion: z.string().optional(),
         salt: z.string().optional(),
+        // At least one route or fragment (validateScope); "" is the homepage.
         scope: z.object({
-            routes: z.array(z.string().min(1)).optional(),
-            fragments: z.array(z.string().min(1)).optional(),
-        }),
-        // ADR 0050: mode is claims or selected; absent means claims. The object
-        // stays strict so an unknown mode value — or an unknown key — is refused.
+            routes: z.array(scopedID).optional(),
+            fragments: z.array(scopedID).optional(),
+        }).refine((value) => Object.values(value).some((list) => Array.isArray(list) && list.length > 0), { message: 'must include at least one route or fragment' }),
         eligibility: z.object({
-            audienceRef: z.string().min(1),
+            // Top-level ref grammar: $ref:audiences/{id}, one path-safe segment (parseAudienceRef).
+            audienceRef: z.string().regex(/^\$ref:audiences\/[A-Za-z0-9_-]+$/),
             mode: z.enum(['claims', 'selected']).optional(),
         }).strict().optional(),
         primaryGoalRef: z.string().optional(),
         primaryGoalId: z.string().optional(),
-        goalRefs: z.array(z.string().min(1)).optional(),
-        goalIds: z.array(z.string().min(1)).optional(),
+        goalRefs: z.array(z.string().regex(/\S/, 'entries must be non-blank')).optional(),
+        goalIds: z.array(z.string().regex(/\S/, 'entries must be non-blank')).optional(),
+        promotedArmId: z.string().optional(),
+        promotedAt: z.string().optional(),
+        horizon: z.object({
+            uniqueExposedPerArm: z.number().int().min(1),
+            conversionWindowDays: z.number().int().min(1).max(90).optional(),
+            declaredAfterRun: z.literal(true).optional(),
+        }).strict().optional(),
         arms: z.array(z.object({
-            id: z.string().min(1),
-            displayName: z.string().min(1),
+            id: z.string().regex(/^[A-Za-z0-9_-]+$/, 'must contain only letters, numbers, underscores, or hyphens'),
+            displayName: z.string().regex(/\S/, 'displayName is required'),
             role: z.enum(['control', 'variant']),
             allocationBasisPoints: z.number().int().min(0).max(10000).optional(),
             rule: requestRuleExpressionSchema.optional(),
-        })).min(1),
+        }).strict()).min(1),
     }),
 });
 export const experimentationDataModels = [
@@ -248,6 +412,5 @@ export const audienceDataModels = [
     audienceDataModel,
     audienceRuleDataModel,
     audienceProviderDataModel,
-    visitorProfileDataModel,
     ...experimentationDataModels,
 ];

package/dist/cli/compile-registry.mjs

@@ -352,12 +352,10 @@ function isImageSchema(schema) {
         return compiled?.type === 'object'
             && properties.$type?.const === 'gradial.image'
             && properties.assetId?.type === 'string'
-            && properties.versionId?.type === 'string'
             && properties.alt?.type === 'string'
             && properties.sources?.type === 'array'
             && required.has('$type')
             && required.has('assetId')
-            && required.has('versionId')
             && required.has('alt')
             && required.has('sources');
     }