@vectoriox/iox-ui 5.60.0 → 5.61.0

package/fesm2022/vectoriox-iox-ui-generation-core.mjs

@@ -10818,23 +10818,23 @@ const RESERVED_PREFIX = '$';
 const ID_FIELD = '_id';
 /** The documented plan shape (contract `site.planShape`): its key lists are READ (`shape-check`), so a key
  *  the plan documents is a key the gate validates — and an undocumented one is refused. */
-const SHAPE$1 = SPEC_SITE_PLAN_SHAPE;
-const PLAN_KEYS = shapeKeys(SHAPE$1['plan']);
-const TEMPLATE_SOURCE_KEYS = shapeKeys(SHAPE$1['sourceTemplate']);
-const AI_SOURCE_KEYS = shapeKeys(SHAPE$1['sourceAi']);
-const BUSINESS_KEYS = shapeKeys(SHAPE$1['business']);
-const DESIGN_REQUIRED = requiredShapeKeys(SHAPE$1['design']);
-const DESIGN_KEYS = shapeKeys(SHAPE$1['design']);
-const CONTENT_TYPE_KEYS = shapeKeys(SHAPE$1['contentType']);
-const ROLE_KEYS = shapeKeys(SHAPE$1['roles']);
-const PAGE_SEO_KEYS = shapeKeys(SHAPE$1['pageSeo']);
+const SHAPE = SPEC_SITE_PLAN_SHAPE;
+const PLAN_KEYS = shapeKeys(SHAPE['plan']);
+const TEMPLATE_SOURCE_KEYS = shapeKeys(SHAPE['sourceTemplate']);
+const AI_SOURCE_KEYS = shapeKeys(SHAPE['sourceAi']);
+const BUSINESS_KEYS = shapeKeys(SHAPE['business']);
+const DESIGN_REQUIRED = requiredShapeKeys(SHAPE['design']);
+const DESIGN_KEYS = shapeKeys(SHAPE['design']);
+const CONTENT_TYPE_KEYS = shapeKeys(SHAPE['contentType']);
+const ROLE_KEYS = shapeKeys(SHAPE['roles']);
+const PAGE_SEO_KEYS = shapeKeys(SHAPE['pageSeo']);
 const ARRAY_TYPE = 'array';
-const FIELD_KEYS = shapeKeys(SHAPE$1['field']);
-const SEED_FIXED_KEYS = shapeKeys(SHAPE$1['seed']);
-const CMS_SOURCE_KEYS = shapeKeys(SHAPE$1['cmsDataSource']);
-const RELATIVE_SOURCE_KEYS = shapeKeys(SHAPE$1['relativeDataSource']);
-const PAGE_KEYS = shapeKeys(SHAPE$1['page']);
-const SECTION_KEYS = shapeKeys(SHAPE$1['section']);
+const FIELD_KEYS = shapeKeys(SHAPE['field']);
+const SEED_FIXED_KEYS = shapeKeys(SHAPE['seed']);
+const CMS_SOURCE_KEYS = shapeKeys(SHAPE['cmsDataSource']);
+const RELATIVE_SOURCE_KEYS = shapeKeys(SHAPE['relativeDataSource']);
+const PAGE_KEYS = shapeKeys(SHAPE['page']);
+const SECTION_KEYS = shapeKeys(SHAPE['section']);
 const GLOBAL_POSITION = {
     [GlobalSlot.Header]: PatternGlobalPosition.Before,
     [GlobalSlot.Footer]: PatternGlobalPosition.After,
@@ -11348,13 +11348,13 @@ const ENTRANCE_TRIGGER = 'viewportEnter';
 const ENTRANCE_EASING = 'ease-out';
 const LEVELS = SPEC_AXES.animations;
 const FAMILIES = SPEC_AXES.animationFamilies;
-const NOTHING$1 = { content: null, parts: {} };
+const NOTHING = { content: null, parts: {} };
 /** What a section of `family` moves at `level` — nothing for an unknown level or family. */
 function sectionEntrances(level, family) {
     const lv = level ? LEVELS[level] : undefined;
     const allow = FAMILIES[family] ?? [];
     if (!lv || !allow.length)
-        return NOTHING$1;
+        return NOTHING;
     if (lv.parts.content && allow.includes(EntrancePart.Content))
         return { content: lv.parts.content, parts: {} };
     const parts = {};
@@ -11484,7 +11484,7 @@ const TEXT$1 = 'Text';
 const HEADING = 'Heading';
 const NAV_STYLE = 'nav';
 const DISPLAY = 'display';
-const NONE = 'none';
+const NONE$1 = 'none';
 const CLICK = 'click';
 const HOME_ROUTE = '/';
 const COMPOSED$1 = { releaseLayoutDefaults: true };
@@ -11557,7 +11557,7 @@ function navShapeOf(globals) {
         return NavShape.Bar;
     return drawer ? NavShape.Drawer : null;
 }
-const hiddenAt = (n) => Object.entries(n.responsive ?? {}).find(([, layer]) => layer?.styleProps?.[DISPLAY] === NONE)?.[0] ?? null;
+const hiddenAt = (n) => Object.entries(n.responsive ?? {}).find(([, layer]) => layer?.styleProps?.[DISPLAY] === NONE$1)?.[0] ?? null;
 /** The breakpoint the phone shape takes over at, read off the header's links row (default Mobile). */
 function navShapeBreakpoint(globals) {
     const links = find(globals, NavRole.Links);
@@ -11649,12 +11649,12 @@ function clickTo(kit, suffix, type, target) {
 }
 /** Show at the phone width, hidden above it (base `display: none`, the breakpoint's own `display`). */
 function phoneOnly(node, at, display) {
-    node.styleProps[DISPLAY] = NONE;
+    node.styleProps[DISPLAY] = NONE$1;
     node.responsive = { ...(node.responsive ?? {}), [at]: { ...(node.responsive?.[at] ?? {}), styleProps: { ...(node.responsive?.[at]?.styleProps ?? {}), [DISPLAY]: display } } };
 }
 /** Hidden at the phone width: the header's links row. */
 function hideAt(node, at) {
-    node.responsive = { ...(node.responsive ?? {}), [at]: { ...(node.responsive?.[at] ?? {}), styleProps: { ...(node.responsive?.[at]?.styleProps ?? {}), [DISPLAY]: NONE } } };
+    node.responsive = { ...(node.responsive ?? {}), [at]: { ...(node.responsive?.[at] ?? {}), styleProps: { ...(node.responsive?.[at]?.styleProps ?? {}), [DISPLAY]: NONE$1 } } };
 }
 /** Move every `display` override the shape owns to the new breakpoint. */
 function moveDisplayOverride(node, to) {
@@ -13544,229 +13544,492 @@ var AiCallStatus;
 })(AiCallStatus || (AiCallStatus = {}));
 
 /**
- * The structured-output format a model writes a Site Plan in (AI plan §3d step 4, M1-3) — built from the SAME shape
- * table `validateSitePlan` reads (`SPEC_SITE_PLAN_SHAPE`) and the SAME pattern library, so the plan a model is told
- * about is the plan the gate refuses. ONE source: a key the table gains breaks this builder until it is written here.
+ * The plan WIRE (AI plan M1-3, vectoriox/iox-cms#45): what a model writes when it plans a site — a compact format inside
+ * the Claude API's structured-output limits (≤ 24 optional parameters and ≤ 16 unions per request; `strict-schema.ts`).
+ * The Site Plan itself (`SPEC_SITE_PLAN_SHAPE`) has 213 optional keys once every pattern is a branch, so the model never
+ * writes it: it writes this, and ONE pure `expandPlanWire` turns it into the Site Plan that `validateSitePlan` and the
+ * stage's gate judge exactly as before.
+ *
+ * - **Every key required.** A plan key that may be absent is written with its stated "none" — `''`, `0`, `false`, `[]`.
+ * - **Closed lists as enums** (patterns, page types, needs, slots, parts, forms, entrances, header/footer), from the
+ *   contract — never per-pattern branches: the gate refuses a slot or a part the chosen pattern does not have, with its path.
+ * - **Maps as lists:** slots `[{ slot, text }]`, links `[{ slot, route }]`, seed values `[{ field, value }]`, roles fixed.
+ * - **One data source object** for both kinds; `type` says which keys are read (the other kind's hold their none).
+ * - **What the model does not decide is not on the wire** (`PLAN_WIRE_DERIVED`): the look (the owner's pick), the run,
+ *   the language (the reading's), the facts (the owner's own, verbatim), the version, the home page (the page at `/`).
+ *   So the format is the same for every studio and every run — one compiled grammar, cached by the provider.
  *
- * Two maps of the shape are written as LISTS on the wire, because no strict mode can say "any key": a section's
- * `slots` (`[{ slot, text }]`, the slot names closed per pattern) and a seed's field values (`values: [{ field,
- * value }]`). `sitePlanFromWire` turns them back; nothing else differs. Every section is one `anyOf` branch per
- * pattern — its id, its declared slots, its optional parts, a binding only when it takes one — and the design, the
- * source and the version are PINNED to the owner's pick and this run (one-value enums), so the provider cannot let
- * a model change the look. The gate still checks both (`plan.design` deep-equals the pick).
+ * ONE source: every wire key names the plan keys it carries (`refs`) and is described in the plan table's own words, and
+ * every plan key is either carried or derived (`planWireGaps()`); a key the plan shape gains breaks the builder until it
+ * is placed. The expanders translate, never repair: a value the model got wrong stays wrong, for the gate to refuse.
  */
-const SITE_PLAN_SCHEMA_NAME = 'site_plan';
-/** The wire keys of the two maps written as lists. */
-var SitePlanWireKey;
-(function (SitePlanWireKey) {
-    SitePlanWireKey["SlotName"] = "slot";
-    SitePlanWireKey["SlotText"] = "text";
-    SitePlanWireKey["SeedValues"] = "values";
-    SitePlanWireKey["SeedField"] = "field";
-    SitePlanWireKey["SeedValue"] = "value";
-})(SitePlanWireKey || (SitePlanWireKey = {}));
-const SHAPE = SPEC_SITE_PLAN_SHAPE;
-const one$1 = (value) => jsonOneOf([value]);
-const oneBoolean = (value) => ({ type: 'boolean', enum: [value] });
-/** The pick, key by key, as one-value enums; an optional key the pick leaves out may only be left out (or empty). */
-function pinnedDesign(design) {
-    const entry = SHAPE['design'];
-    const values = design;
-    const properties = {};
-    for (const key of Object.keys(entry).map(k => k.replace(/\?$/, ''))) {
-        const v = values[key];
-        if (typeof v === 'string')
-            properties[key] = one$1(v);
-        else if (typeof v === 'boolean')
-            properties[key] = oneBoolean(v);
-        else if (isPlainObject(v))
-            properties[key] = jsonClosedObject(Object.fromEntries(Object.entries(v).map(([role, family]) => [role, one$1(String(family))])), Object.keys(v));
-        else
-            properties[key] = jsonClosedObject({}, []);
-    }
-    const shaped = jsonShapedObject(entry, properties, 'design');
-    // Everything the pick carries is required: a model may not leave a choice out and let a default stand in.
-    const given = Object.keys(values).filter(k => values[k] !== undefined && k in properties);
-    return { ...shaped, required: [...new Set([...shaped['required'], ...given])] };
-}
-function sourceSchema(source) {
-    if (source.kind === SitePlanSourceKind.Ai)
-        return jsonShapedObject(SHAPE['sourceAi'], { kind: one$1(source.kind), runId: one$1(source.runId) }, 'sourceAi');
-    return jsonShapedObject(SHAPE['sourceTemplate'], {
-        kind: one$1(source.kind), templateId: one$1(source.templateId), templateVersion: { type: 'integer', enum: [source.templateVersion] },
-    }, 'sourceTemplate');
-}
-function businessSchema() {
-    const facts = jsonClosedObject(Object.fromEntries(FACT_KEYS.map(key => [key, jsonText()])), []);
-    return jsonShapedObject(SHAPE['business'], { name: jsonText(), tagline: jsonText(), facts }, 'business');
-}
-/** A content type's field. */
-function fieldJsonSchema() {
-    return jsonShapedObject(SHAPE['field'], { name: jsonText(), type: jsonText(), controller: jsonText(), required: jsonBoolean(), note: jsonText() }, 'field');
-}
-/** A content type, its seed's field values as a list (`values: [{ field, value }]`). */
-function contentTypeJsonSchema() {
-    const value = jsonAnyOf([jsonText(), jsonListOf(jsonText())]);
-    const values = jsonListOf(jsonClosedObject({ [SitePlanWireKey.SeedField]: jsonText(), [SitePlanWireKey.SeedValue]: value }, [SitePlanWireKey.SeedField, SitePlanWireKey.SeedValue]));
-    const seed = jsonShapedObject(SHAPE['seed'], { count: jsonInteger(), sample: jsonBoolean(), isPublished: jsonBoolean() }, 'seed', { key: SitePlanWireKey.SeedValues, schema: values });
-    const roleKeys = Object.keys(SHAPE['roles']).map(k => k.replace(/\?$/, ''));
-    const roles = jsonShapedObject(SHAPE['roles'], Object.fromEntries(roleKeys.map(k => [k, jsonText()])), 'roles');
-    return jsonShapedObject(SHAPE['contentType'], {
-        name: jsonText(), label: jsonText(), roles, fields: jsonListOf(fieldJsonSchema()), seed,
-    }, 'contentType');
-}
-/** A data source: a cms list / single item, or a relative one. */
-function dataSourceJsonSchema() {
-    const byRoute = jsonClosedObject({ field: jsonText(), routeParam: jsonText() }, ['field', 'routeParam']);
-    const cms = jsonShapedObject(SHAPE['cmsDataSource'], {
-        alias: jsonText(), type: one$1(PlanDataSourceType.Cms), mode: jsonOneOf(Object.values(PlanDataSourceMode)),
-        contentType: jsonText(), limit: jsonInteger(), filterByRouteParam: byRoute,
-    }, 'cmsDataSource');
-    const relative = jsonShapedObject(SHAPE['relativeDataSource'], {
-        alias: jsonText(), type: one$1(PlanDataSourceType.Relative), of: jsonText(), op: jsonOneOf(Object.values(RelativeOp)), within: jsonText(),
-    }, 'relativeDataSource');
-    return jsonAnyOf([cms, relative]);
+const PLAN_WIRE_SCHEMA_NAME = 'site_plan';
+var PlanWireEntry;
+(function (PlanWireEntry) {
+    PlanWireEntry["Plan"] = "plan";
+    PlanWireEntry["Business"] = "business";
+    PlanWireEntry["ContentType"] = "contentType";
+    PlanWireEntry["Roles"] = "roles";
+    PlanWireEntry["Field"] = "field";
+    PlanWireEntry["Seed"] = "seed";
+    PlanWireEntry["SeedValue"] = "seedValue";
+    PlanWireEntry["DataSource"] = "dataSource";
+    PlanWireEntry["Page"] = "page";
+    PlanWireEntry["PageSeo"] = "pageSeo";
+    PlanWireEntry["Section"] = "section";
+    PlanWireEntry["SlotText"] = "slotText";
+    PlanWireEntry["SlotLink"] = "slotLink";
+    PlanWireEntry["Globals"] = "globals";
+})(PlanWireEntry || (PlanWireEntry = {}));
+const PLAN_SHAPE = SPEC_SITE_PLAN_SHAPE;
+const key = (ref, none) => ({ refs: [ref], ...(none !== undefined ? { none } : {}) });
+const WIRE_KEYS = {
+    plan: {
+        business: key('plan.business'),
+        contentTypes: key('plan.contentTypes'),
+        dataSources: { refs: ['plan.dataSources'], text: 'dataSource[] — merged by alias into the org library' },
+        pages: key('plan.pages'),
+        globals: key('plan.globals'),
+    },
+    business: {
+        name: key('business.name'),
+        tagline: key('business.tagline', "''"),
+    },
+    contentType: {
+        name: key('contentType.name'),
+        label: key('contentType.label'),
+        roles: key('contentType.roles'),
+        fields: key('contentType.fields'),
+        seed: { refs: ['contentType.seed'], text: 'seed — the sample items', none: 'count 0 and no values' },
+    },
+    roles: {
+        title: key('roles.title'),
+        summary: key('roles.summary', "''"),
+        image: key('roles.image', "''"),
+        meta: key('roles.meta', "''"),
+        date: key('roles.date', "''"),
+        gallery: key('roles.gallery', "''"),
+    },
+    field: {
+        name: key('field.name'),
+        type: key('field.type'),
+        controller: key('field.controller'),
+        required: { refs: ['field.required'], text: 'boolean — the field must be filled', none: 'false' },
+        note: key('field.note', "''"),
+    },
+    seed: {
+        count: key('seed.count'),
+        sample: key('seed.sample'),
+        isPublished: key('seed.isPublished'),
+        values: { refs: ['seed.[field]'], text: "seedValue[] — one per field: the samples' value for it" },
+    },
+    seedValue: {
+        field: { refs: ['seed.[field]'], text: 'string — a field of the type' },
+        value: { refs: ['seed.[field]'], text: `string | string[] — ${describeShapeKey(PLAN_SHAPE['seed'], '[field]')} (a list for an array field)` },
+    },
+    dataSource: {
+        alias: { refs: ['cmsDataSource.alias', 'relativeDataSource.alias'] },
+        type: { refs: ['cmsDataSource.type', 'relativeDataSource.type'], text: "'cms' | 'relative' — which of the keys below are read" },
+        mode: key('cmsDataSource.mode', "'' (relative)"),
+        contentType: key('cmsDataSource.contentType', "'' (relative)"),
+        limit: key('cmsDataSource.limit', '0 (all, or relative)'),
+        filterField: { refs: ['cmsDataSource.filterByRouteParam'], text: "string — single only: the field that holds the route param's value (e.g. slug)", none: "''" },
+        routeParam: { refs: ['cmsDataSource.filterByRouteParam'], text: 'string — single only: the route param that picks the item (the :param of its page route)', none: "''" },
+        of: key('relativeDataSource.of', "'' (cms)"),
+        op: key('relativeDataSource.op', "'' (cms)"),
+        within: key('relativeDataSource.within', "'' (cms)"),
+    },
+    page: {
+        key: key('page.key'),
+        name: key('page.name'),
+        route: { refs: ['page.route'], text: `${describeShapeKey(PLAN_SHAPE['page'], 'route')}; the page at "/" is the home page` },
+        inNav: key('page.inNav', 'false'),
+        archetype: key('page.archetype', "''"),
+        need: key('page.need', "''"),
+        template: key('page.template', "''"),
+        routeSource: key('page.routeSource', "''"),
+        seo: key('page.seo'),
+        sections: key('page.sections'),
+    },
+    pageSeo: {
+        title: key('pageSeo.title', "''"),
+        description: key('pageSeo.description', "''"),
+    },
+    section: {
+        pattern: key('section.pattern'),
+        slots: { refs: ['section.slots'], text: "slotText[] — the pattern's declared slots it fills, each within its budget (site.patterns … max × site.copyLengths)", none: '[]' },
+        links: { refs: ['section.links'], text: 'slotLink[] — re-points a linked slot (a button, a link) to another page route of the plan', none: '[]' },
+        binding: key('section.binding', "''"),
+        without: key('section.without', '[]'),
+        form: key('section.form', "''"),
+        enter: key('section.enter', "'' (the look's)"),
+    },
+    slotText: {
+        slot: { refs: ['section.slots'], text: "string — one of the pattern's slots" },
+        text: { refs: ['section.slots'], text: "string — the words, in the owner's language and voice" },
+    },
+    slotLink: {
+        slot: { refs: ['section.links'], text: "string — one of the pattern's linked slots" },
+        route: { refs: ['section.links'], text: 'string — a page route of the plan (no :param)' },
+    },
+    globals: {
+        header: key('globals.header'),
+        footer: key('globals.footer'),
+    },
+};
+/** The plan keys the model does not write, and where the expander takes each from. */
+const PLAN_WIRE_DERIVED = {
+    'plan.version': `always '${SITE_PLAN_VERSION}'`,
+    'plan.source': 'this run (the context)',
+    'plan.locale': "the reading's language (the context)",
+    'plan.design': "the owner's pick (the context)",
+    'business.facts': "the owner's own facts, verbatim (the context)",
+    'page.isHome': 'the page at "/"',
+    'page.required': "a template page's (the wizard's Pages step), never the AI's",
+    sourceTemplate: 'the AI never writes a template plan',
+    sourceAi: 'this run (the context)',
+    design: "the owner's pick (the context)",
+};
+const wireText = (spec) => {
+    const [entry, planKey] = spec.refs[0].split('.');
+    const base = spec.text ?? describeShapeKey(PLAN_SHAPE[entry], planKey);
+    return spec.none === undefined ? base : `${base} — ${spec.none} = none`;
+};
+/** The wire's shape table, in the plan table's words — what the model reads, and what the format is built from. */
+const PLAN_WIRE_SHAPE = Object.fromEntries(Object.entries(WIRE_KEYS).map(([entry, keys]) => [entry, Object.fromEntries(Object.entries(keys).map(([k, spec]) => [k, wireText(spec)]))]));
+/** Plan keys neither carried by a wire key nor derived — always empty (a spec and the builder hold it). */
+function planWireGaps() {
+    const carried = new Set(Object.values(WIRE_KEYS).flatMap(keys => Object.values(keys).flatMap(spec => spec.refs)));
+    const gaps = [];
+    for (const [entry, shape] of Object.entries(PLAN_SHAPE)) {
+        if (PLAN_WIRE_DERIVED[entry])
+            continue;
+        for (const raw of Object.keys(shape)) {
+            const ref = `${entry}.${raw.replace(/\?$/, '')}`;
+            if (!carried.has(ref) && !PLAN_WIRE_DERIVED[ref])
+                gaps.push(ref);
+        }
+    }
+    return gaps;
 }
+class PlanWireShapeError extends Error {
+}
+// ── The format ─────────────────────────────────────────────────────────────────────────────────────────────────────
+const unique = (values) => [...new Set(values)];
+const NONE = '';
+const orNone = (values) => jsonOneOf([NONE, ...values]);
+const closedOrText = (values) => (values.length ? jsonOneOf(values) : jsonText());
+const shaped = (entry, properties) => jsonShapedObject(PLAN_WIRE_SHAPE[entry], properties, `wire ${entry}`);
 /** The patterns a page section may use (every non-global one), in library order. */
 function sectionPatternIds() {
     return Object.entries(SITE_PATTERNS).filter(([, p]) => !p.global).map(([id]) => id);
 }
-/** A key a pattern has nothing for: only `{}` (or leaving it out) — the decoder drops it. */
-const NOTHING = () => jsonClosedObject({}, []);
-/** One section branch: this pattern's id, its declared slots (a list), the slots it may re-point (`links`, closed per
- *  pattern), its optional parts, a binding when it takes one, a form preset when it holds a form, its own entrance. */
-function sectionBranch(id, pattern) {
-    const slots = patternSlots(pattern);
-    const parts = patternOptionalParts(pattern);
-    const linkSlots = patternLinkSlots(pattern);
-    const slotList = slots.length
-        ? jsonListOf(jsonClosedObject({ [SitePlanWireKey.SlotName]: jsonOneOf(slots), [SitePlanWireKey.SlotText]: jsonText() }, [SitePlanWireKey.SlotName, SitePlanWireKey.SlotText]))
-        : NOTHING();
-    const branch = jsonShapedObject(SHAPE['section'], {
-        pattern: one$1(id),
-        slots: slotList,
-        links: linkSlots.length ? jsonClosedObject(Object.fromEntries(linkSlots.map(slot => [slot, jsonText()])), []) : NOTHING(),
-        binding: patternTakesBinding(pattern) ? jsonText() : NOTHING(),
-        without: parts.length ? jsonListOf(jsonOneOf(parts)) : NOTHING(),
-        form: patternHasForm(pattern) ? jsonOneOf(FORM_PRESETS.map(p => p.id)) : NOTHING(),
-        enter: jsonOneOf(ANIMATE_IDS),
-    }, 'section');
-    return { ...branch, description: `${id}: ${pattern.intent}` };
-}
-/** A page section: one branch per pattern. */
-function sectionJsonSchema() {
-    return jsonAnyOf(sectionPatternIds().map(id => sectionBranch(id, SITE_PATTERNS[id])));
-}
-/** A page. */
-function pageJsonSchema() {
-    const seo = jsonShapedObject(SHAPE['pageSeo'], { title: jsonText(), description: jsonText() }, 'pageSeo');
-    return jsonShapedObject(SHAPE['page'], {
-        key: jsonText(), name: jsonText(), route: jsonText(), isHome: jsonBoolean(), required: jsonBoolean(), inNav: jsonBoolean(),
-        archetype: jsonOneOf(Object.keys(PAGE_ARCHETYPES)), need: jsonOneOf(SITE_NEED_IDS), template: jsonText(), routeSource: jsonText(), seo, sections: jsonListOf(sectionJsonSchema()),
-    }, 'page');
-}
+const sectionPatterns = () => sectionPatternIds().map(id => SITE_PATTERNS[id]);
 const globalIds = (position) => Object.entries(SITE_PATTERNS).filter(([, p]) => p.global === position).map(([id]) => id);
-/** The Site Plan format, pinned to the owner's pick and this run. */
-function sitePlanJsonSchema(pin) {
-    const globals = jsonShapedObject(SHAPE['globals'], {
-        [GlobalSlot.Header]: jsonOneOf(globalIds(PatternGlobalPosition.Before)),
-        [GlobalSlot.Footer]: jsonOneOf(globalIds(PatternGlobalPosition.After)),
-    }, 'globals');
-    return jsonShapedObject(SHAPE['plan'], {
-        version: one$1(SITE_PLAN_VERSION),
-        source: sourceSchema(pin.source),
-        business: businessSchema(),
-        locale: jsonOneOf(Object.keys(SITE_LOCALES)),
-        design: pinnedDesign(pin.design),
-        contentTypes: jsonListOf(contentTypeJsonSchema()),
-        dataSources: jsonListOf(dataSourceJsonSchema()),
-        pages: jsonListOf(pageJsonSchema()),
-        globals,
-    }, 'plan');
-}
-// ── The wire → the plan ─────────────────────────────────────────────────────────────────────────────
-const isEmptyObject = (v) => isPlainObject(v) && Object.keys(v).length === 0;
-/** `[{ slot, text }]` → `{ slot: text }`; anything that is not that list is left for the gate to refuse. */
-function slotsFromWire(slots) {
-    if (!Array.isArray(slots))
-        return slots;
+function wireFieldJsonSchema() {
+    return shaped(PlanWireEntry.Field, { name: jsonText(), type: jsonText(), controller: jsonText(), required: jsonBoolean(), note: jsonText() });
+}
+function wireContentTypeJsonSchema() {
+    const roleKeys = shapeKeys(PLAN_WIRE_SHAPE.roles);
+    const value = shaped(PlanWireEntry.SeedValue, { field: jsonText(), value: jsonAnyOf([jsonText(), jsonListOf(jsonText())]) });
+    return shaped(PlanWireEntry.ContentType, {
+        name: jsonText(),
+        label: jsonText(),
+        roles: shaped(PlanWireEntry.Roles, Object.fromEntries(roleKeys.map(k => [k, jsonText()]))),
+        fields: jsonListOf(wireFieldJsonSchema()),
+        seed: shaped(PlanWireEntry.Seed, { count: jsonInteger(), sample: jsonBoolean(), isPublished: jsonBoolean(), values: jsonListOf(value) }),
+    });
+}
+function wireDataSourceJsonSchema() {
+    return shaped(PlanWireEntry.DataSource, {
+        alias: jsonText(),
+        type: jsonOneOf(Object.values(PlanDataSourceType)),
+        mode: orNone(Object.values(PlanDataSourceMode)),
+        contentType: jsonText(),
+        limit: jsonInteger(),
+        filterField: jsonText(),
+        routeParam: jsonText(),
+        of: jsonText(),
+        op: orNone(Object.values(RelativeOp)),
+        within: jsonText(),
+    });
+}
+function wireSectionJsonSchema() {
+    const patterns = sectionPatterns();
+    return shaped(PlanWireEntry.Section, {
+        pattern: jsonOneOf(sectionPatternIds()),
+        slots: jsonListOf(shaped(PlanWireEntry.SlotText, { slot: closedOrText(unique(patterns.flatMap(patternSlots))), text: jsonText() })),
+        links: jsonListOf(shaped(PlanWireEntry.SlotLink, { slot: closedOrText(unique(patterns.flatMap(patternLinkSlots))), route: jsonText() })),
+        binding: jsonText(),
+        without: jsonListOf(closedOrText(unique(patterns.flatMap(patternOptionalParts)))),
+        form: orNone(FORM_PRESETS.map(p => p.id)),
+        enter: orNone(ANIMATE_IDS),
+    });
+}
+function wirePageJsonSchema() {
+    return shaped(PlanWireEntry.Page, {
+        key: jsonText(),
+        name: jsonText(),
+        route: jsonText(),
+        inNav: jsonBoolean(),
+        archetype: orNone(Object.keys(PAGE_ARCHETYPES)),
+        need: orNone(SITE_NEED_IDS),
+        template: jsonText(),
+        routeSource: jsonText(),
+        seo: shaped(PlanWireEntry.PageSeo, { title: jsonText(), description: jsonText() }),
+        sections: jsonListOf(wireSectionJsonSchema()),
+    });
+}
+/** The format a model writes a plan in. The same for every studio and run: nothing in it is pinned. */
+function planWireJsonSchema() {
+    const gaps = planWireGaps();
+    if (gaps.length)
+        throw new PlanWireShapeError(`the plan wire neither carries nor derives ${gaps.join(', ')}`);
+    return shaped(PlanWireEntry.Plan, {
+        business: shaped(PlanWireEntry.Business, { name: jsonText(), tagline: jsonText() }),
+        contentTypes: jsonListOf(wireContentTypeJsonSchema()),
+        dataSources: jsonListOf(wireDataSourceJsonSchema()),
+        pages: jsonListOf(wirePageJsonSchema()),
+        globals: shaped(PlanWireEntry.Globals, {
+            [GlobalSlot.Header]: jsonOneOf(globalIds(PatternGlobalPosition.Before)),
+            [GlobalSlot.Footer]: jsonOneOf(globalIds(PatternGlobalPosition.After)),
+        }),
+    });
+}
+/** A value standing for "absent": `''` (or nothing at all). */
+const isNone = (v) => v === undefined || v === NONE;
+const optional = (name, v, none = isNone) => (none(v) ? {} : { [name]: v });
+const emptyList = (v) => v === undefined || (Array.isArray(v) && v.length === 0);
+/** `[{ <keyName>, <valueName> }]` → `{ key: value }`; anything else is left for the gate to refuse. */
+function listToMap(list, keyName, valueName) {
+    if (!Array.isArray(list))
+        return list;
     const out = {};
-    for (const entry of slots) {
-        if (!isPlainObject(entry) || typeof entry[SitePlanWireKey.SlotName] !== 'string')
-            return slots;
-        out[entry[SitePlanWireKey.SlotName]] = entry[SitePlanWireKey.SlotText];
+    for (const entry of list) {
+        if (!isPlainObject(entry) || typeof entry[keyName] !== 'string')
+            return list;
+        out[entry[keyName]] = entry[valueName];
     }
     return out;
 }
-/** A section off the wire: its slots back to a map; a key the pattern has nothing for (`{}`) dropped. */
-function sectionFromWire(section) {
-    if (!isPlainObject(section))
-        return section;
-    const out = { ...section };
-    for (const key of ['slots', 'links', 'binding', 'without', 'form'])
-        if (isEmptyObject(out[key]))
-            delete out[key];
-    if ('slots' in out)
-        out['slots'] = slotsFromWire(out['slots']);
-    return out;
+const mapToList = (map, keyName, valueName) => Object.entries(map ?? {}).map(([k, v]) => ({ [keyName]: k, [valueName]: v }));
+const each = (list, expand) => (Array.isArray(list) ? list.map(expand) : list);
+function expandWireField(wire) {
+    if (!isPlainObject(wire))
+        return wire;
+    const { required, note, ...rest } = wire;
+    return { ...rest, ...optional('required', required, v => v === undefined || v === false), ...optional('note', note) };
 }
-/** A content type off the wire: its seed's `values` list back to field keys. */
-function contentTypeFromWire(type) {
-    if (!isPlainObject(type) || !isPlainObject(type['seed']))
-        return type;
-    const { [SitePlanWireKey.SeedValues]: values, ...seed } = type['seed'];
-    if (Array.isArray(values)) {
-        for (const entry of values) {
-            if (isPlainObject(entry) && typeof entry[SitePlanWireKey.SeedField] === 'string')
-                seed[entry[SitePlanWireKey.SeedField]] = entry[SitePlanWireKey.SeedValue];
-        }
+function expandWireContentType(wire) {
+    if (!isPlainObject(wire))
+        return wire;
+    const { roles, fields, seed, ...rest } = wire;
+    const out = { ...rest, roles: isPlainObject(roles) ? Object.fromEntries(Object.entries(roles).filter(([, v]) => !isNone(v))) : roles, fields: each(fields, expandWireField) };
+    if (!isPlainObject(seed))
+        return seed === undefined ? out : { ...out, seed };
+    const { values, ...fixed } = seed;
+    if (fixed['count'] === 0 && emptyList(values))
+        return out;
+    const map = listToMap(values ?? [], 'field', 'value');
+    return { ...out, seed: isPlainObject(map) ? { ...fixed, ...map } : { ...fixed, values } };
+}
+function expandWireDataSource(wire) {
+    if (!isPlainObject(wire))
+        return wire;
+    const { alias, type, mode, contentType, limit, filterField, routeParam, of, op, within, ...rest } = wire;
+    if (type === PlanDataSourceType.Cms) {
+        const filter = isNone(filterField) && isNone(routeParam) ? {} : { filterByRouteParam: { field: filterField, routeParam } };
+        return { ...rest, alias, type, mode, contentType, ...optional('limit', limit, v => v === undefined || v === 0), ...filter };
     }
-    else if (values !== undefined)
-        seed[SitePlanWireKey.SeedValues] = values;
-    return { ...type, seed };
+    if (type === PlanDataSourceType.Relative)
+        return { ...rest, alias, type, of, op, within };
+    return wire;
 }
-function pageFromWire(page) {
-    if (!isPlainObject(page) || !Array.isArray(page['sections']))
-        return page;
-    return { ...page, sections: page['sections'].map(sectionFromWire) };
+function expandWireSection(wire) {
+    if (!isPlainObject(wire))
+        return wire;
+    const { slots, links, binding, without, form, enter, ...rest } = wire;
+    return {
+        ...rest,
+        ...optional('slots', listToMap(slots, 'slot', 'text'), v => emptyList(slots) || v === undefined),
+        ...optional('links', listToMap(links, 'slot', 'route'), v => emptyList(links) || v === undefined),
+        ...optional('binding', binding),
+        ...optional('without', without, emptyList),
+        ...optional('form', form),
+        ...optional('enter', enter),
+    };
 }
-/** The design off the wire: an empty optional object (a choice the pick does not carry) dropped. */
-function designFromWire(design) {
-    if (!isPlainObject(design))
-        return design;
-    return Object.fromEntries(Object.entries(design).filter(([, v]) => !isEmptyObject(v)));
+function expandWirePage(wire) {
+    if (!isPlainObject(wire))
+        return wire;
+    const { archetype, need, template, routeSource, seo, sections, ...rest } = wire;
+    const words = isPlainObject(seo) ? { ...optional('title', seo['title']), ...optional('description', seo['description']) } : seo;
+    return {
+        ...rest,
+        ...(wire['route'] === '/' ? { isHome: true } : {}),
+        ...optional('archetype', archetype),
+        ...optional('need', need),
+        ...optional('template', template),
+        ...optional('routeSource', routeSource),
+        ...optional('seo', words, v => v === undefined || (isPlainObject(v) && Object.keys(v).length === 0)),
+        sections: each(sections, expandWireSection),
+    };
+}
+function expandWireBusiness(wire, facts) {
+    if (!isPlainObject(wire))
+        return wire;
+    const { tagline, ...rest } = wire;
+    return { ...rest, ...optional('tagline', tagline), ...(facts && Object.keys(facts).length ? { facts: { ...facts } } : {}) };
 }
 /**
- * A model's answer → a Site Plan: the two listed maps back to maps, nothing else touched. Never repairs — whatever the
- * answer got wrong is still wrong, for `validateSitePlan` to refuse with a path.
+ * A model's plan (the wire) + what the generation decides (the look, the run, the language, the owner's facts) → the
+ * Site Plan. Pure. Translates, never repairs: whatever the answer got wrong is still wrong, for `validateSitePlan`.
  */
-function sitePlanFromWire(wire) {
+function expandPlanWire(wire, context) {
     if (!isPlainObject(wire))
         return wire;
-    const out = { ...wire };
-    if (Array.isArray(out['contentTypes']))
-        out['contentTypes'] = out['contentTypes'].map(contentTypeFromWire);
-    if (Array.isArray(out['pages']))
-        out['pages'] = out['pages'].map(pageFromWire);
-    if ('design' in out)
-        out['design'] = designFromWire(out['design']);
-    return out;
+    const { business, contentTypes, dataSources, pages, ...rest } = wire;
+    return {
+        ...rest,
+        version: SITE_PLAN_VERSION,
+        source: { ...context.source },
+        business: expandWireBusiness(business, context.facts),
+        ...(context.locale ? { locale: context.locale } : {}),
+        design: { ...context.design },
+        contentTypes: each(contentTypes, expandWireContentType),
+        dataSources: each(dataSources, expandWireDataSource),
+        pages: each(pages, expandWirePage),
+    };
 }
-/** The plan → the wire (what a re-ask shows the model, and what the plan edits' prompt carries). */
-function sitePlanToWire(plan) {
-    const slotsToWire = (slots) => Object.entries(slots ?? {}).map(([slot, text]) => ({ [SitePlanWireKey.SlotName]: slot, [SitePlanWireKey.SlotText]: text }));
+// ── The plan → the wire ────────────────────────────────────────────────────────────────────────────────────────────
+function fieldToWire(field) {
+    return { name: field.name, type: field.type, controller: field.controller, required: field.required ?? false, note: field.note ?? NONE };
+}
+function contentTypeToWire(type) {
+    const roles = Object.fromEntries(shapeKeys(PLAN_WIRE_SHAPE.roles).map(role => [role, type.roles[role] ?? NONE]));
+    const { count = 0, sample = false, isPublished = false, ...values } = type.seed ?? {};
     return {
-        ...plan,
-        contentTypes: plan.contentTypes.map(t => {
-            if (!t.seed)
-                return t;
-            const { count, sample, isPublished, ...values } = t.seed;
-            return { ...t, seed: { count, sample, isPublished, [SitePlanWireKey.SeedValues]: Object.entries(values).map(([field, value]) => ({ [SitePlanWireKey.SeedField]: field, [SitePlanWireKey.SeedValue]: value })) } };
-        }),
-        pages: plan.pages.map(p => ({ ...p, sections: p.sections.map(s => (s.slots ? { ...s, slots: slotsToWire(s.slots) } : s)) })),
+        name: type.name, label: type.label, roles, fields: type.fields.map(fieldToWire),
+        seed: { count, sample, isPublished, values: mapToList(values, 'field', 'value') },
+    };
+}
+function dataSourceToWire(source) {
+    const blank = { alias: source.alias, type: source.type, mode: NONE, contentType: NONE, limit: 0, filterField: NONE, routeParam: NONE, of: NONE, op: NONE, within: NONE };
+    if (source.type === PlanDataSourceType.Relative)
+        return { ...blank, of: source.of, op: source.op, within: source.within };
+    return {
+        ...blank, mode: source.mode, contentType: source.contentType, limit: source.limit ?? 0,
+        filterField: source.filterByRouteParam?.field ?? NONE, routeParam: source.filterByRouteParam?.routeParam ?? NONE,
+    };
+}
+function sectionToWire(section) {
+    return {
+        pattern: section.pattern, slots: mapToList(section.slots, 'slot', 'text'), links: mapToList(section.links, 'slot', 'route'),
+        binding: section.binding ?? NONE, without: [...(section.without ?? [])], form: section.form ?? NONE, enter: section.enter ?? NONE,
+    };
+}
+function pageToWire(page) {
+    return {
+        key: page.key, name: page.name, route: page.route, inNav: page.inNav ?? false, archetype: page.archetype ?? NONE, need: page.need ?? NONE,
+        template: page.template ?? NONE, routeSource: page.routeSource ?? NONE,
+        seo: { title: page.seo?.title ?? NONE, description: page.seo?.description ?? NONE }, sections: page.sections.map(sectionToWire),
+    };
+}
+/** The plan → the wire: what a model would have written (the plan edits' prompt shows it; fakes and evals write it). */
+function planToWire(plan) {
+    return {
+        business: { name: plan.business.name, tagline: plan.business.tagline ?? NONE },
+        contentTypes: plan.contentTypes.map(contentTypeToWire),
+        dataSources: plan.dataSources.map(dataSourceToWire),
+        pages: plan.pages.map(pageToWire),
+        globals: { ...plan.globals },
     };
 }
 
+/**
+ * What a structured-output request costs the provider's grammar compiler, counted the way the Claude API counts it
+ * (platform.claude.com/docs/en/build-with-claude/structured-outputs, "Schema complexity limits", read 2026-10-27):
+ * "Total optional parameters across all strict tool schemas and JSON output schemas. Each parameter not listed in
+ * `required` counts toward this limit" (24); "Total parameters that use `anyOf` or type arrays (for example,
+ * `"type": ["string", "null"]`) across all strict schemas" (16); "Maximum number of tools with `strict: true`" (20).
+ * The limits are per REQUEST — every strict schema in it together. The ONE counter: the specs hold every schema iox-cms
+ * sends to it, and the fake Claude API refuses with it exactly as Claude does — the plan stage once sent 213 optional
+ * parameters and every suite stayed green because the fake accepted anything (vectoriox/iox-cms#45).
+ */
+const STRICT_SCHEMA_LIMITS = { strictTools: 20, optional: 24, unions: 16 };
+/** What a schema iox-cms sends may use — half of each limit, so a step can gain a field (or a strict tool) without a 400. */
+const STRICT_SCHEMA_BUDGET = { optional: 12, unions: 8 };
+/** The keywords the docs list as not supported ("Numerical constraints", "String constraints", "Array constraints beyond `minItems` of 0 or 1"). */
+const UNSUPPORTED_KEYWORDS = [
+    'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf', 'minLength', 'maxLength', 'maxItems', 'uniqueItems', 'contains',
+    'minContains', 'maxContains', 'prefixItems', 'patternProperties', 'propertyNames', 'dependentSchemas', 'if', 'then', 'else', 'not',
+];
+const NESTED_LISTS = ['anyOf', 'allOf', 'oneOf'];
+const NESTED_MAPS = ['properties', '$defs', 'definitions'];
+const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+function count(node, path, out) {
+    if (!isObject(node))
+        return;
+    const at = (key) => (path ? `${path}.${key}` : key);
+    if (Array.isArray(node['anyOf']) || Array.isArray(node['type']))
+        out.unions++;
+    const properties = isObject(node['properties']) ? node['properties'] : null;
+    if (node['type'] === 'object' || properties) {
+        const required = new Set(Array.isArray(node['required']) ? node['required'] : []);
+        out.optional += Object.keys(properties ?? {}).filter(key => !required.has(key)).length;
+        if (node['additionalProperties'] !== false)
+            out.unsupported.push(`${at('additionalProperties')}: must be false`);
+    }
+    for (const key of UNSUPPORTED_KEYWORDS)
+        if (key in node)
+            out.unsupported.push(`${at(key)}: not supported`);
+    if ('minItems' in node && node['minItems'] !== 0 && node['minItems'] !== 1)
+        out.unsupported.push(`${at('minItems')}: only 0 or 1`);
+    if (Array.isArray(node['enum']) && node['enum'].some(v => v !== null && typeof v === 'object'))
+        out.unsupported.push(`${at('enum')}: complex types`);
+    if (typeof node['$ref'] === 'string' && !node['$ref'].startsWith('#'))
+        out.unsupported.push(`${at('$ref')}: external`);
+    for (const key of NESTED_MAPS) {
+        if (isObject(node[key]))
+            for (const [name, child] of Object.entries(node[key]))
+                count(child, at(`${key}.${name}`), out);
+    }
+    for (const key of NESTED_LISTS) {
+        if (Array.isArray(node[key]))
+            node[key].forEach((child, i) => count(child, at(`${key}[${i}]`), out));
+    }
+    if (isObject(node['items']))
+        count(node['items'], at('items'), out);
+    if (isObject(node['additionalProperties']))
+        count(node['additionalProperties'], at('additionalProperties'), out);
+}
+/** The cost of ONE request's strict schemas together: its JSON output format and its strict tools' input schemas. */
+function strictSchemaComplexity(schemas, strictTools = 0) {
+    const out = { optional: 0, unions: 0, strictTools, unsupported: [] };
+    schemas.forEach((schema, i) => count(schema, schemas.length > 1 ? `[${i}]` : '', out));
+    return out;
+}
+/**
+ * The 400 the Claude API answers a request over its limits with, or null. The optional-parameter message is the one
+ * Claude answered on 2026-10-27, verbatim; the union, strict-tool and unsupported messages follow its shape (not yet
+ * captured).
+ */
+function strictSchemaRefusal(complexity) {
+    const refuse = (message) => ({ status: 400, type: 'invalid_request_error', message });
+    if (complexity.unsupported.length)
+        return refuse(`Invalid schema: ${complexity.unsupported.join('; ')}`);
+    if (complexity.strictTools > STRICT_SCHEMA_LIMITS.strictTools) {
+        return refuse(`Too many strict tools (${complexity.strictTools}). Reduce the number of tools with strict: true (limit: ${STRICT_SCHEMA_LIMITS.strictTools}).`);
+    }
+    if (complexity.optional > STRICT_SCHEMA_LIMITS.optional) {
+        return refuse(`Schemas contains too many optional parameters (${complexity.optional}), which would make grammar compilation inefficient. Reduce the number of optional parameters in your tool schemas (limit: ${STRICT_SCHEMA_LIMITS.optional}).`);
+    }
+    if (complexity.unions > STRICT_SCHEMA_LIMITS.unions) {
+        return refuse(`Schemas contains too many parameters with union types (${complexity.unions}), which would make grammar compilation inefficient. Reduce the number of parameters with union types in your tool schemas (limit: ${STRICT_SCHEMA_LIMITS.unions}).`);
+    }
+    return null;
+}
+
 /**
  * Changing a plan by sentence (AI plan §3d "The Plan prompt box", M1-5; reused by M2 after a build): the CLOSED list
  * of operations (N-D6) a model may write against the current plan, and the ONE pure `applyPlanEdits` that carries them
@@ -13933,7 +14196,7 @@ const setSections = (d, at, sections) => { d.pages[at] = { ...d.pages[at], secti
 /** One handler per op — a data table, never an if-chain. */
 const APPLY = {
     [PlanEditOp.AddPage]: (d, e, c, path, changed) => {
-        const page = { ...e.page, sections: (e.page.sections ?? []).map(sectionFromWire) };
+        const page = e.page;
         if (pageIndex(d, page.key) >= 0)
             return c.add(PlanEditIssueCode.Duplicate, `${path}.page.key`, `page "${page.key}" is already in the plan`);
         const after = e.after === undefined ? d.pages.length - 1 : findPage(d, e.after, c, `${path}.after`);
@@ -13992,7 +14255,7 @@ const APPLY = {
             return;
         const sections = [...d.pages[at].sections];
         const index = e.at === undefined ? sections.length : clamp(e.at, sections.length);
-        sections.splice(index, 0, sectionFromWire(e.section));
+        sections.splice(index, 0, e.section);
         setSections(d, at, sections);
         changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Added, page: d.pages[at].key, index });
     },
@@ -14045,7 +14308,7 @@ const APPLY = {
         changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Changed, page: d.pages[at].key, index: e.index });
     },
     [PlanEditOp.AddContentType]: (d, e, c, path, changed) => {
-        const type = contentTypeFromWire(e.contentType);
+        const type = e.contentType;
         if (d.contentTypes.some(t => t.name === type.name))
             return c.add(PlanEditIssueCode.Duplicate, `${path}.contentType.name`, `content type "${type.name}" is already in the plan`);
         d.contentTypes.push(type);
@@ -14120,53 +14383,150 @@ const PLAN_EDITS_ANSWER_SHAPE = {
     edits: 'edit[] — applied in order, all or none; empty when cannot',
     reason: "string — when cannot, ONE short line for the owner in their language (what to do instead); else ''",
 };
-const one = (value) => jsonOneOf([value]);
-/** The schema of each op's value types (what `PLAN_EDIT_SHAPE` names). */
-function opSchema(op) {
-    const entry = PLAN_EDIT_SHAPE[op];
-    const valueOf = (key) => {
-        const text = entry[key] ?? entry[`${key}?`];
-        if (key === 'op')
-            return one(op);
-        if (key === 'pattern')
-            return jsonOneOf(sectionPatternIds());
-        const head = text.split(' ')[0];
-        const table = {
-            page: pageJsonSchema, section: sectionJsonSchema, contentType: contentTypeJsonSchema, field: fieldJsonSchema,
-            'dataSource[]': () => jsonListOf(dataSourceJsonSchema()), integer: jsonInteger, string: jsonText,
-        };
-        if (text.startsWith('string | string[]'))
-            return jsonAnyOf([jsonText(), jsonListOf(jsonText())]);
-        return (table[head] ?? jsonText)();
-    };
-    return jsonShapedObject(entry, Object.fromEntries(shapeKeys(entry).map(key => [key, valueOf(key)])), op);
+const NO_INDEX = -1;
+/** A list holding exactly one object: none → absent, one → it (expanded), more → the list (the gate refuses it). */
+const oneOf = (schema, expand, toWire, what) => ({
+    text: `${what}[] — exactly one when the op takes it`,
+    none: [],
+    schema: () => jsonListOf(schema()),
+    expand: v => (Array.isArray(v) ? (v.length === 0 ? undefined : v.length === 1 ? expand(v[0]) : v) : v),
+    toWire: v => [toWire(v)],
+});
+const textKey = (text) => ({ text: `string — ${text}`, none: '', schema: jsonText });
+const indexKey = (text) => ({ text: `integer — ${text}`, none: NO_INDEX, schema: jsonInteger });
+const EDIT_WIRE = {
+    page: textKey('a page key'),
+    name: textKey('renamePage: its new name (the menu label)'),
+    route: textKey('renamePage: its new route'),
+    after: textKey('addPage: the key of the page it follows in the menu'),
+    into: textKey('mergePages: the page that stays'),
+    from: textKey('mergePages: the page whose sections move into it, then removed'),
+    index: indexKey('the section, 0-based on its page'),
+    to: indexKey('movePage / moveSection: the new 0-based place'),
+    at: indexKey('addSection: its 0-based place on the page'),
+    pattern: { text: 'string — swapPattern: the section pattern it becomes', none: '', schema: () => jsonOneOf(['', ...sectionPatternIds()]) },
+    slot: textKey("setSlot: one of the pattern's slots"),
+    text: textKey("setSlot: the words, in the owner's language and voice"),
+    binding: textKey('setSectionData: the list source the section repeats'),
+    contentType: textKey('addField: a content type of the plan'),
+    newPage: oneOf(wirePageJsonSchema, expandWirePage, pageToWire, 'page'),
+    newSection: oneOf(wireSectionJsonSchema, expandWireSection, sectionToWire, 'section'),
+    newContentType: oneOf(wireContentTypeJsonSchema, expandWireContentType, contentTypeToWire, 'contentType'),
+    dataSources: {
+        text: 'dataSource[] — addContentType: the list / single sources its pages read', none: [],
+        schema: () => jsonListOf(wireDataSourceJsonSchema()),
+        expand: v => (Array.isArray(v) ? v.map(expandWireDataSource) : v),
+        toWire: (v) => v.map(dataSourceToWire),
+    },
+    newField: oneOf(wireFieldJsonSchema, expandWireField, fieldToWire, 'field'),
+    sample: { text: "string | string[] — addField: the samples' value for it", none: '', schema: () => jsonAnyOf([jsonText(), jsonListOf(jsonText())]) },
+};
+/** Each op's keys (`PLAN_EDIT_SHAPE`) → the wire key that carries it. */
+const PLAN_EDIT_WIRE_KEYS = {
+    [PlanEditOp.AddPage]: { page: 'newPage', after: 'after' },
+    [PlanEditOp.RemovePage]: { page: 'page' },
+    [PlanEditOp.RenamePage]: { page: 'page', name: 'name', route: 'route' },
+    [PlanEditOp.MergePages]: { into: 'into', from: 'from' },
+    [PlanEditOp.MovePage]: { page: 'page', to: 'to' },
+    [PlanEditOp.AddSection]: { page: 'page', section: 'newSection', at: 'at' },
+    [PlanEditOp.RemoveSection]: { page: 'page', index: 'index' },
+    [PlanEditOp.MoveSection]: { page: 'page', from: 'index', to: 'to' },
+    [PlanEditOp.SwapPattern]: { page: 'page', index: 'index', pattern: 'pattern' },
+    [PlanEditOp.SetSlot]: { page: 'page', index: 'index', slot: 'slot', text: 'text' },
+    [PlanEditOp.AddContentType]: { contentType: 'newContentType', dataSources: 'dataSources' },
+    [PlanEditOp.AddField]: { contentType: 'contentType', field: 'newField', sample: 'sample' },
+    [PlanEditOp.SetSectionData]: { page: 'page', index: 'index', binding: 'binding' },
+};
+const isEditWireNone = (wireKey, v) => {
+    const none = EDIT_WIRE[wireKey].none;
+    return v === undefined || (Array.isArray(none) ? Array.isArray(v) && v.length === 0 : v === none) || (wireKey === 'sample' && Array.isArray(v) && v.length === 0);
+};
+const noneText = (none) => (Array.isArray(none) ? '[]' : typeof none === 'string' ? "''" : String(none));
+/** The flat edit's shape table: every key required, each with its none. */
+const PLAN_EDIT_WIRE_SHAPE = {
+    op: `${OPS.map(op => `'${op}'`).join(' | ')} — which keys below are read`,
+    ...Object.fromEntries(Object.entries(EDIT_WIRE).map(([k, spec]) => [k, `${spec.text} — ${noneText(spec.none)} when the op does not read it`])),
+};
+/** Per op, the wire keys it reads, in `PLAN_EDIT_SHAPE`'s words (`?` = may hold its none) — what the model reads. */
+function planEditWireOps() {
+    return Object.fromEntries(OPS.map(op => {
+        const entry = PLAN_EDIT_SHAPE[op];
+        const keys = PLAN_EDIT_WIRE_KEYS[op];
+        return [op, Object.fromEntries(Object.entries(keys).map(([planKey, wireKey]) => {
+                const optionalKey = `${planKey}?` in entry;
+                return [`${wireKey}${optionalKey ? '?' : ''}`, entry[optionalKey ? `${planKey}?` : planKey]];
+            }))];
+    }));
 }
-/** The format a sentence's answer is written in: the outcome, the edits (one `anyOf` branch per op), the reason. */
+/** Op keys no wire key carries, or wire keys that do not exist — always empty (a spec and the builder hold it). */
+function planEditWireGaps() {
+    const gaps = [];
+    for (const op of OPS) {
+        const keys = PLAN_EDIT_WIRE_KEYS[op] ?? {};
+        for (const planKey of shapeKeys(PLAN_EDIT_SHAPE[op])) {
+            if (planKey === 'op')
+                continue;
+            if (!keys[planKey])
+                gaps.push(`${op}.${planKey}`);
+            else if (!EDIT_WIRE[keys[planKey]])
+                gaps.push(`${op}.${planKey} → ${keys[planKey]}`);
+        }
+        for (const planKey of Object.keys(keys))
+            if (!shapeKeys(PLAN_EDIT_SHAPE[op]).includes(planKey))
+                gaps.push(`${op}.${planKey} (not an op key)`);
+    }
+    return gaps;
+}
+/** The format a sentence's answer is written in: the outcome, the flat edits, the reason. */
 function planEditsJsonSchema() {
+    const gaps = planEditWireGaps();
+    if (gaps.length)
+        throw new PlanWireShapeError(`the plan edits wire does not carry ${gaps.join(', ')}`);
+    const edit = jsonShapedObject(PLAN_EDIT_WIRE_SHAPE, {
+        op: jsonOneOf(OPS),
+        ...Object.fromEntries(Object.entries(EDIT_WIRE).map(([k, spec]) => [k, spec.schema()])),
+    }, 'edit');
     return jsonShapedObject(PLAN_EDITS_ANSWER_SHAPE, {
         outcome: jsonOneOf(Object.values(PlanEditsOutcome)),
-        edits: jsonListOf(jsonAnyOf(OPS.map(op => opSchema(op)))),
+        edits: jsonListOf(edit),
         reason: jsonText(),
     }, 'planEdits');
 }
-/** A model's answer → edits (sections and content types off the wire); never repaired. */
+/** One flat edit → the op's edit: the keys it reads, a none left out where the op may go without it. Never repaired. */
+function expandWireEdit(wire) {
+    if (!isPlainObject(wire))
+        return wire;
+    const keys = PLAN_EDIT_WIRE_KEYS[wire['op']];
+    if (!keys)
+        return wire;
+    const entry = PLAN_EDIT_SHAPE[wire['op']];
+    const out = Object.fromEntries(Object.entries(wire).filter(([k]) => k === 'op' || !(k in EDIT_WIRE)));
+    for (const [planKey, wireKey] of Object.entries(keys)) {
+        const raw = wire[wireKey];
+        if (`${planKey}?` in entry && isEditWireNone(wireKey, raw))
+            continue;
+        const value = EDIT_WIRE[wireKey].expand ? EDIT_WIRE[wireKey].expand(raw) : raw;
+        if (value !== undefined)
+            out[planKey] = value;
+    }
+    return out;
+}
+/** An edit → the flat wire edit (what a model would write — fakes and specs write it). */
+function planEditToWire(edit) {
+    const out = { op: edit.op, ...Object.fromEntries(Object.entries(EDIT_WIRE).map(([k, spec]) => [k, Array.isArray(spec.none) ? [] : spec.none])) };
+    for (const [planKey, wireKey] of Object.entries(PLAN_EDIT_WIRE_KEYS[edit.op])) {
+        const value = edit[planKey];
+        if (value === undefined)
+            continue;
+        out[wireKey] = EDIT_WIRE[wireKey].toWire ? EDIT_WIRE[wireKey].toWire(value) : value;
+    }
+    return out;
+}
+/** A model's answer → edits (each flat edit expanded); never repaired. */
 function planEditsFromWire(answer) {
     if (!isPlainObject(answer) || !Array.isArray(answer['edits']))
         return answer;
-    const edits = answer['edits'].map(raw => {
-        if (!isPlainObject(raw))
-            return raw;
-        const e = { ...raw };
-        if (isPlainObject(e['page']) && Array.isArray(e['page']['sections'])) {
-            e['page'] = { ...e['page'], sections: e['page']['sections'].map(sectionFromWire) };
-        }
-        if (isPlainObject(e['section']))
-            e['section'] = sectionFromWire(e['section']);
-        if (isPlainObject(e['contentType']))
-            e['contentType'] = contentTypeFromWire(e['contentType']);
-        return e;
-    });
-    return { ...answer, edits };
+    return { ...answer, edits: answer['edits'].map(expandWireEdit) };
 }
 
 /**
@@ -14745,5 +15105,5 @@ function addStockCredits(footer, credits) {
  * Generated bundle index. Do not edit.
  */
 
-export { ACTIVE_BUILD_STATUSES, AI_REFUSAL_NEXT, AI_REFUSAL_STATUS, AI_STEPS, AI_STEP_LABELS, AI_STEP_NEEDS, AI_STEP_TYPICAL_TOKENS, AiCallStatus, AiCapability, AiFeature, AiGenerationStage, AiKeyMode, AiLimit, AiNextKind, AiProviderId, AiRefusalCode, AiStep, BAR_ITEMS_MAX, BAR_ITEMS_MIN, BASELINE_ROLES, BUILD_STEPS, BaselineRole, BindScope, BuildNoticeCode, BuildStep, CONTENT_ROLE_MEANINGS, CREDITS_PER_USD, CardBindTarget, CheckSeverity, ComposeError, ComposeIssueCode, ContentRole, ContentTypeAction, CreatedKind, DANGLING_LINK_CODES, DEFAULT_PHONE_MENU_BREAKPOINT, DEFAULT_SITE_LOCALE, ENTRANCE_EASING, ENTRANCE_ORIGIN_LOOK, ENTRANCE_TRIGGER, EntrancePart, EntranceSide, FACT_KEYS, FINAL_GENERATION_STAGES, FINDING_SEVERITY, GlobalSlot, HEBREW_PREFIXES, JSON_SCHEMA_BANNED_KEYWORDS, JsonSchemaShapeError, KeptReason, NAV_PART_LABELS, NAV_SHAPE_COPY, NEUTRAL_STYLE_PROPS, NODE_BASELINES, NO_TOKENS, NavPagesSource, NavRole, NavShape, NavShapeError, PAGE_ARCHETYPES, PLAN_EDITS_ANSWER_SHAPE, PLAN_EDITS_SCHEMA_NAME, PLAN_EDIT_SHAPE, PRICING_PATTERN, PUBLISH_BLOCKING_PLACEHOLDERS, PageDataKind, PathIssueCollector, PatternDirective, PatternGlobalPosition, PatternOpens, PatternPlaceholder, PatternRecipe, PhoneMenuBreakpoint, PlaceholderKind, PlanChangeAction, PlanChangeKind, PlanDataSourceMode, PlanDataSourceType, PlanEditIssueCode, PlanEditOp, PlanEditsOutcome, PlanWordIssueCode, PreflightRefusalCode, PublishRefusalCode, REQUIRED_CONTENT_ROLES, RelativeOp, SAMPLE_IMAGE_REF, SITE_CHECKS, SITE_FACT_LABELS, SITE_HEADER_PATTERN, SITE_LIBRARY, SITE_LOCALES, SITE_NEED_IDS, SITE_PATTERNS, SITE_PLAN_SCHEMA_NAME, SITE_PLAN_VERSION, SITE_TEMPLATES, SPEC_SITE_ARCHETYPES, SPEC_SITE_COPY_LENGTHS, SPEC_SITE_DENSITY_COPY, SPEC_SITE_FACTS, SPEC_SITE_LIBRARY, SPEC_SITE_LOCALES, SPEC_SITE_NEED_IDS, SPEC_SITE_PATTERNS, SPEC_SITE_PLAN_SHAPE, SPEC_SITE_REQUIRED_ROLES, SPEC_SITE_ROLES, SPEC_SITE_TEMPLATES, STOCK_FAMILIES, STOCK_PROVIDER_TERMS, STUDIO_TEMPLATE, SiteBuildKind, SiteBuildStatus, SiteCheckId, SiteFindingCode, SiteLocale, SitePlanError, SitePlanIssueCode, SitePlanSourceKind, SitePlanWireKey, SiteTemplateError, SiteTemplateId, StepState, StockProviderId, addBarItem, addStockCredits, applyPlanEdits, applyStockPhotos, archetypeIssues, assertStyleSlots, assertValidSitePlan, auditSite, barIconForRoute, blocksPublish, buildKeys, buildStepFacts, builtHomePageId, composeNavHeader, composeSection, composeSite, contentTypeFromWire, contentTypeJsonSchema, contentTypePreviewFields, copyLengthOf, costUsd, createSerializedNode, creditsOfUsd, dataSourceJsonSchema, describePlanData, describeShapeKey, entranceAction, entranceInteraction, estimateStepCredits, failedBuildStep, fieldJsonSchema, findNavRoot, isActiveBuild, isNonEmptyString, isPlainObject, isRtlLocale, jsonAnyOf, jsonBoolean, jsonClosedObject, jsonInteger, jsonListOf, jsonOneOf, jsonSchemaKeywords, jsonSchemaObjects, jsonShapedObject, jsonText, modelCanDo, moveBarItem, navPages, navShapeBreakpoint, navShapeOf, nextSourceOf, nodeBindPaths, pageJsonSchema, parsePatternPath, parseSampleImageRef, pathAt, patternById, patternHasForm, patternLinkSlots, patternManifest, patternNeedsBinding, patternNodes, patternOptionalParts, patternRoleNeeds, patternScopes, patternSlotBudgets, patternSlots, patternTakesBinding, phoneMenuPages, planEditsFromWire, planEditsJsonSchema, planEntrances, planFromTemplate, planNavShape, planStockPhotos, planWordIssues, publishRefusal, publishVerdict, releasedLayoutDefaults, removeBarItem, requiredAcknowledgements, requiredShapeKeys, roleField, routeMatches, routeParams, sampleImageRef, sectionEntrances, sectionFromWire, sectionJsonSchema, sectionPatternIds, setStyleProps, shapeKeys, showcaseGlobals, showcasePages, showcasePlans, siteNavPages, sitePlanFromWire, sitePlanJsonSchema, sitePlanToWire, slotBudget, stockCopyKey, stockCreditLine, stockCreditLines, stockCreditNode, stockCreditNodeId, stockSlots, validatePlanEdits, validateSitePlan, walkSerialized, wordPattern, writtenTexts };
+export { ACTIVE_BUILD_STATUSES, AI_REFUSAL_NEXT, AI_REFUSAL_STATUS, AI_STEPS, AI_STEP_LABELS, AI_STEP_NEEDS, AI_STEP_TYPICAL_TOKENS, AiCallStatus, AiCapability, AiFeature, AiGenerationStage, AiKeyMode, AiLimit, AiNextKind, AiProviderId, AiRefusalCode, AiStep, BAR_ITEMS_MAX, BAR_ITEMS_MIN, BASELINE_ROLES, BUILD_STEPS, BaselineRole, BindScope, BuildNoticeCode, BuildStep, CONTENT_ROLE_MEANINGS, CREDITS_PER_USD, CardBindTarget, CheckSeverity, ComposeError, ComposeIssueCode, ContentRole, ContentTypeAction, CreatedKind, DANGLING_LINK_CODES, DEFAULT_PHONE_MENU_BREAKPOINT, DEFAULT_SITE_LOCALE, ENTRANCE_EASING, ENTRANCE_ORIGIN_LOOK, ENTRANCE_TRIGGER, EntrancePart, EntranceSide, FACT_KEYS, FINAL_GENERATION_STAGES, FINDING_SEVERITY, GlobalSlot, HEBREW_PREFIXES, JSON_SCHEMA_BANNED_KEYWORDS, JsonSchemaShapeError, KeptReason, NAV_PART_LABELS, NAV_SHAPE_COPY, NEUTRAL_STYLE_PROPS, NODE_BASELINES, NO_TOKENS, NavPagesSource, NavRole, NavShape, NavShapeError, PAGE_ARCHETYPES, PLAN_EDITS_ANSWER_SHAPE, PLAN_EDITS_SCHEMA_NAME, PLAN_EDIT_SHAPE, PLAN_EDIT_WIRE_KEYS, PLAN_EDIT_WIRE_SHAPE, PLAN_WIRE_DERIVED, PLAN_WIRE_SCHEMA_NAME, PLAN_WIRE_SHAPE, PRICING_PATTERN, PUBLISH_BLOCKING_PLACEHOLDERS, PageDataKind, PathIssueCollector, PatternDirective, PatternGlobalPosition, PatternOpens, PatternPlaceholder, PatternRecipe, PhoneMenuBreakpoint, PlaceholderKind, PlanChangeAction, PlanChangeKind, PlanDataSourceMode, PlanDataSourceType, PlanEditIssueCode, PlanEditOp, PlanEditsOutcome, PlanWireEntry, PlanWireShapeError, PlanWordIssueCode, PreflightRefusalCode, PublishRefusalCode, REQUIRED_CONTENT_ROLES, RelativeOp, SAMPLE_IMAGE_REF, SITE_CHECKS, SITE_FACT_LABELS, SITE_HEADER_PATTERN, SITE_LIBRARY, SITE_LOCALES, SITE_NEED_IDS, SITE_PATTERNS, SITE_PLAN_VERSION, SITE_TEMPLATES, SPEC_SITE_ARCHETYPES, SPEC_SITE_COPY_LENGTHS, SPEC_SITE_DENSITY_COPY, SPEC_SITE_FACTS, SPEC_SITE_LIBRARY, SPEC_SITE_LOCALES, SPEC_SITE_NEED_IDS, SPEC_SITE_PATTERNS, SPEC_SITE_PLAN_SHAPE, SPEC_SITE_REQUIRED_ROLES, SPEC_SITE_ROLES, SPEC_SITE_TEMPLATES, STOCK_FAMILIES, STOCK_PROVIDER_TERMS, STRICT_SCHEMA_BUDGET, STRICT_SCHEMA_LIMITS, STUDIO_TEMPLATE, SiteBuildKind, SiteBuildStatus, SiteCheckId, SiteFindingCode, SiteLocale, SitePlanError, SitePlanIssueCode, SitePlanSourceKind, SiteTemplateError, SiteTemplateId, StepState, StockProviderId, addBarItem, addStockCredits, applyPlanEdits, applyStockPhotos, archetypeIssues, assertStyleSlots, assertValidSitePlan, auditSite, barIconForRoute, blocksPublish, buildKeys, buildStepFacts, builtHomePageId, composeNavHeader, composeSection, composeSite, contentTypePreviewFields, contentTypeToWire, copyLengthOf, costUsd, createSerializedNode, creditsOfUsd, dataSourceToWire, describePlanData, describeShapeKey, entranceAction, entranceInteraction, estimateStepCredits, expandPlanWire, expandWireContentType, expandWireDataSource, expandWireEdit, expandWireField, expandWirePage, expandWireSection, failedBuildStep, fieldToWire, findNavRoot, isActiveBuild, isNonEmptyString, isPlainObject, isRtlLocale, jsonAnyOf, jsonBoolean, jsonClosedObject, jsonInteger, jsonListOf, jsonOneOf, jsonSchemaKeywords, jsonSchemaObjects, jsonShapedObject, jsonText, modelCanDo, moveBarItem, navPages, navShapeBreakpoint, navShapeOf, nextSourceOf, nodeBindPaths, pageToWire, parsePatternPath, parseSampleImageRef, pathAt, patternById, patternHasForm, patternLinkSlots, patternManifest, patternNeedsBinding, patternNodes, patternOptionalParts, patternRoleNeeds, patternScopes, patternSlotBudgets, patternSlots, patternTakesBinding, phoneMenuPages, planEditToWire, planEditWireGaps, planEditWireOps, planEditsFromWire, planEditsJsonSchema, planEntrances, planFromTemplate, planNavShape, planStockPhotos, planToWire, planWireGaps, planWireJsonSchema, planWordIssues, publishRefusal, publishVerdict, releasedLayoutDefaults, removeBarItem, requiredAcknowledgements, requiredShapeKeys, roleField, routeMatches, routeParams, sampleImageRef, sectionEntrances, sectionPatternIds, sectionToWire, setStyleProps, shapeKeys, showcaseGlobals, showcasePages, showcasePlans, siteNavPages, slotBudget, stockCopyKey, stockCreditLine, stockCreditLines, stockCreditNode, stockCreditNodeId, stockSlots, strictSchemaComplexity, strictSchemaRefusal, validatePlanEdits, validateSitePlan, walkSerialized, wireContentTypeJsonSchema, wireDataSourceJsonSchema, wireFieldJsonSchema, wirePageJsonSchema, wireSectionJsonSchema, wordPattern, writtenTexts };
 //# sourceMappingURL=vectoriox-iox-ui-generation-core.mjs.map