@gradial/aci 0.1.52-rc.8 → 0.1.52

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,93 +240,166 @@ const segmentCriteriaSchema = z.union([
         none: z.array(segmentCriteriaConditionSchema).optional(),
     }).strict(),
 ]);
-const requestRuleConditionSchema = z.object({
-    field: z.string().min(1),
-    operator: z.enum(['equals', 'contains', 'startsWith', 'exists']),
-    value: scalarValue.optional(),
-});
-const requestRuleExpressionSchema = z.object({
-    all: z.array(requestRuleConditionSchema).optional(),
-    any: z.array(requestRuleConditionSchema).optional(),
-});
+// 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 (props.mapping === undefined) {
+        fail(['mapping'], 'mapping is required for format "mapped-json"');
+        return;
+    }
+    const membership = props.mapping.membership;
+    if (membership === undefined) {
+        fail(['mapping', 'membership'], 'mapping.membership is required');
+        return;
+    }
+    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');
+    }
+}
+// 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: 'must not have leading or trailing whitespace' }).optional(),
     }),
 });
+export const audienceProviderDataModel = defineDataModel({
+    type: 'audience_provider',
+    schema: z.object({
+        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().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().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 — valid RFC 6901 pointers, a compiling single-capture pattern).
+        mapping: z.object({
+            identity: z.object({
+                path: z.string().regex(/^\//),
+            }).strict(),
+            membership: z.object({
+                segmentIdsPath: z.string().regex(/^\//).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().min(1).max(1000).optional(),
+        }).strict(),
+        limits: z.object({
+            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(),
-        }),
+            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({
+            // 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(),
+        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 = [
@@ -148,6 +410,6 @@ export const audienceDataModels = [
     segmentDataModel,
     audienceDataModel,
     audienceRuleDataModel,
-    visitorProfileDataModel,
+    audienceProviderDataModel,
     ...experimentationDataModels,
 ];

package/dist/cli/compile-registry.mjs

@@ -31,13 +31,15 @@ if (isMainModule()) {
     }
 }
 async function compileRegistry(options) {
-    const required = ['components', 'layouts', 'output'];
+    if (options.layouts) {
+        throw new Error('--layouts is retired; author page composition under /templates instead');
+    }
+    const required = ['components', 'output'];
     for (const key of required) {
         if (!options[key])
             throw new Error(`missing --${key}`);
     }
     const components = await loadDefaultArray(options.components, 'component registry');
-    const layouts = await loadDefaultArray(options.layouts, 'layout registry');
     const dataModels = options.data
         ? await loadDefaultArray(options.data, 'data model registry')
         : [];
@@ -65,8 +67,6 @@ async function compileRegistry(options) {
             ...(Object.keys(slots).length ? { slots } : {}),
         });
     }
-    const seenLayouts = new Set();
-    const layoutEntries = layouts.map((layout, index) => validateLayout(layout, index, seenLayouts));
     const seenDataModels = new Set();
     const dataModelEntries = [];
     if (dataModels.length > 0) {
@@ -98,7 +98,6 @@ async function compileRegistry(options) {
         manifestVersion: '1',
         generatedAt: new Date().toISOString(),
         components: componentEntries,
-        layouts: layoutEntries,
         dataModels: dataModelEntries,
     };
     const registryPath = path.join(outDir, 'registry.json');
@@ -109,7 +108,7 @@ async function compileRegistry(options) {
 }
 async function loadDefaultArray(modulePath, label) {
     const mod = await import(pathToFileURL(path.resolve(modulePath)).href);
-    const value = mod.default ?? mod.registry ?? mod.components ?? mod.layouts ?? mod.dataModels;
+    const value = mod.default ?? mod.registry ?? mod.components ?? mod.dataModels;
     if (!Array.isArray(value))
         throw new Error(`${label} must export an array`);
     return value;
@@ -397,32 +396,6 @@ function unwrapSchema(schema) {
     }
     return current;
 }
-function validateLayout(layout, index, seen) {
-    if (!layout || typeof layout !== 'object')
-        throw new Error(`layouts[${index}] must be an object`);
-    if (!layout.name)
-        throw new Error(`layouts[${index}].name is required`);
-    if (seen.has(layout.name))
-        throw new Error(`duplicate layout name ${layout.name}`);
-    seen.add(layout.name);
-    if (!Array.isArray(layout.slots))
-        throw new Error(`layouts[${index}].slots must be an array`);
-    const slots = [];
-    const seenSlots = new Set();
-    for (const [slotIndex, slot] of layout.slots.entries()) {
-        if (!slot?.name)
-            throw new Error(`layouts[${index}].slots[${slotIndex}].name is required`);
-        if (seenSlots.has(slot.name))
-            throw new Error(`duplicate slot name ${slot.name} in layout ${layout.name}`);
-        seenSlots.add(slot.name);
-        slots.push({ name: slot.name, required: Boolean(slot.required) });
-    }
-    const entry = { name: layout.name, slots };
-    if (layout.defaults && typeof layout.defaults === 'object') {
-        entry.defaults = layout.defaults;
-    }
-    return entry;
-}
 function compileSchema(schema, name) {
     const toJSONSchema = z.toJSONSchema;
     if (typeof toJSONSchema !== 'function') {
@@ -516,13 +489,12 @@ async function generatePageSchema(schemaDir, componentEntries, outDir) {
         $id: 'https://baremetal.local/schemas/page.schema.json',
         title: 'bare-metal Page',
         type: 'object',
-        required: ['$type', 'id', 'status', 'layout', 'metadata', 'regions'],
+        required: ['$type', 'id', 'status', 'metadata', 'regions'],
         additionalProperties: true,
         properties: {
             $type: { const: 'page' },
             id: { type: 'string', minLength: 1 },
             status: { type: 'string', minLength: 1 },
-            layout: { type: 'string', minLength: 1 },
             metadata: {
                 type: 'object',
                 required: ['title'],

package/dist/cli/mintlify-render.mjs

@@ -0,0 +1,8 @@
+import path from 'node:path';
+import { loadCompiledMintlifySource, materializeMintlifySite } from '../../dist/mintlify/index.js';
+const [sourceArg, compiledArg, outputArg] = process.argv.slice(2);
+if (!sourceArg || !compiledArg || !outputArg) {
+    throw new Error('Mintlify renderer requires content, compiled, and output directories');
+}
+const source = await loadCompiledMintlifySource(path.resolve(sourceArg), path.resolve(compiledArg));
+await materializeMintlifySite({ ...source, outputDir: path.resolve(outputArg) });