@vectoriox/iox-ui 5.60.0 → 5.62.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$1 = 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,
@@ -10984,8 +10984,8 @@ function validateRoles(c, roles, path, typeName, fields, fieldTypes) {
     }
     const out = {};
     for (const [role, field] of Object.entries(roles)) {
-        if (!ROLE_KEYS.includes(role)) {
-            c.add(SitePlanIssueCode.UnknownRole, `${path}.${role}`, `"${role}" is not a role (${ROLE_KEYS.join(', ')})`);
+        if (!ROLE_KEYS$1.includes(role)) {
+            c.add(SitePlanIssueCode.UnknownRole, `${path}.${role}`, `"${role}" is not a role (${ROLE_KEYS$1.join(', ')})`);
             continue;
         }
         if (typeof field !== 'string' || !fields.has(field)) {
@@ -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) {
@@ -13380,6 +13380,471 @@ function buildStepFacts(plan, actions = {}) {
     };
 }
 
+/**
+ * The plan WIRE (AI plan M1-3, vectoriox/iox-cms#45, #47): 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, and a compiled
+ * grammar under the size Claude refuses — measured as ≤ 60 properties; `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.
+ *
+ * - **Written in two PARTS, one request each** (#47 — the whole plan in one format was 64 properties): the **structure** (the business,
+ *   the content types, the data sources) and then the **pages** (the pages, the header and footer), written knowing the
+ *   structure. Every top-level key belongs to exactly one part (`part` below); `expandPlanWire` puts the parts together.
+ *
+ * - **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 `[{ role, field }]`.
+ * - **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.
+ *
+ * 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.
+ */
+/** The plan's parts, in the order they are written: the pages bind to the structure's sources and types. */
+var PlanPart;
+(function (PlanPart) {
+    PlanPart["Structure"] = "structure";
+    PlanPart["Pages"] = "pages";
+})(PlanPart || (PlanPart = {}));
+const PLAN_PARTS = [PlanPart.Structure, PlanPart.Pages];
+/** Each part's format name (a request names the format it asks for). */
+const PLAN_WIRE_PART_SCHEMA_NAMES = {
+    [PlanPart.Structure]: 'site_plan_structure',
+    [PlanPart.Pages]: 'site_plan_pages',
+};
+var PlanWireEntry;
+(function (PlanWireEntry) {
+    PlanWireEntry["Plan"] = "plan";
+    PlanWireEntry["Business"] = "business";
+    PlanWireEntry["ContentType"] = "contentType";
+    PlanWireEntry["RoleField"] = "roleField";
+    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 inPart = (part, spec) => ({ ...spec, part });
+/** The roles a content type's fields play (`roles` of the plan shape), in the plan shape's order. */
+const ROLE_KEYS = shapeKeys(PLAN_SHAPE['roles']);
+const roleWords = ROLE_KEYS.map(role => `${role}: ${describeShapeKey(PLAN_SHAPE['roles'], role).replace(/^string — /, '')}`).join('; ');
+const WIRE_KEYS = {
+    plan: {
+        business: inPart(PlanPart.Structure, key('plan.business')),
+        contentTypes: inPart(PlanPart.Structure, key('plan.contentTypes')),
+        dataSources: inPart(PlanPart.Structure, { refs: ['plan.dataSources'], text: 'dataSource[] — merged by alias into the org library' }),
+        pages: inPart(PlanPart.Pages, key('plan.pages')),
+        globals: inPart(PlanPart.Pages, key('plan.globals')),
+    },
+    business: {
+        name: key('business.name'),
+        tagline: key('business.tagline', "''"),
+    },
+    contentType: {
+        name: key('contentType.name'),
+        label: key('contentType.label'),
+        roles: { refs: ['contentType.roles'], text: `roleField[] — ${describeShapeKey(PLAN_SHAPE['contentType'], 'roles').replace(/^roles — /, '')}; a role no field plays is left out` },
+        fields: key('contentType.fields'),
+        seed: { refs: ['contentType.seed'], text: 'seed — the sample items', none: 'count 0 and no values' },
+    },
+    roleField: {
+        role: { refs: ROLE_KEYS.map(role => `roles.${role}`), text: `${ROLE_KEYS.map(r => `'${r}'`).join(' | ')} — ${roleWords}` },
+        field: { refs: ['roles.title'], text: 'string — the field of the type that plays it' },
+    },
+    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)]))]));
+/** Each part's top-level keys, from the ONE wire table. */
+const PLAN_PART_KEYS = Object.fromEntries(PLAN_PARTS.map(part => [part, Object.entries(WIRE_KEYS.plan).filter(([, spec]) => spec.part === part).map(([k]) => k)]));
+/** The keys of a shape entry, but these. */
+const shapeWithout = (entry, keys) => Object.fromEntries(Object.entries(entry).filter(([k]) => !keys.includes(k.replace(/\?$/, ''))));
+/**
+ * The part a plan path is the answer of (`contentTypes[1].seed.title` → structure, `pages[0].sections[2]` → pages). A
+ * path no part writes — the root (the composer), or a key the generation decides — is the LAST part's: it is written
+ * knowing everything before it.
+ */
+function planPartOfPath(path) {
+    const top = path.split(/[.[]/, 1)[0];
+    return PLAN_PARTS.find(part => PLAN_PART_KEYS[part].includes(top)) ?? PLAN_PARTS[PLAN_PARTS.length - 1];
+}
+/** 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);
+}
+const sectionPatterns = () => sectionPatternIds().map(id => SITE_PATTERNS[id]);
+const globalIds = (position) => Object.entries(SITE_PATTERNS).filter(([, p]) => p.global === position).map(([id]) => id);
+function wireFieldJsonSchema() {
+    return shaped(PlanWireEntry.Field, { name: jsonText(), type: jsonText(), controller: jsonText(), required: jsonBoolean(), note: jsonText() });
+}
+/** The keys an entry leaves out under `options`. */
+const CHILD_KEYS = { contentType: 'fields', page: 'sections' };
+const childless = (entry, options) => (options.children === false && CHILD_KEYS[entry] ? [CHILD_KEYS[entry]] : []);
+/** The shape an entry is written in, under `options`. */
+function wireEntryShape(entry, options = {}) {
+    return shapeWithout(PLAN_WIRE_SHAPE[entry], childless(entry, options));
+}
+const shapedAs = (entry, options, properties) => {
+    const left = childless(entry, options);
+    return jsonShapedObject(wireEntryShape(entry, options), Object.fromEntries(Object.entries(properties).filter(([k]) => !left.includes(k))), `wire ${entry}`);
+};
+function wireContentTypeJsonSchema(options = {}) {
+    const value = shaped(PlanWireEntry.SeedValue, { field: jsonText(), value: jsonAnyOf([jsonText(), jsonListOf(jsonText())]) });
+    return shapedAs(PlanWireEntry.ContentType, options, {
+        name: jsonText(),
+        label: jsonText(),
+        roles: jsonListOf(shaped(PlanWireEntry.RoleField, { role: jsonOneOf(ROLE_KEYS), field: 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(options = {}) {
+    return shapedAs(PlanWireEntry.Page, options, {
+        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()),
+    });
+}
+const PLAN_TOP_SCHEMAS = {
+    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)),
+    }),
+};
+/** The plan's top-level shape for one part (its keys only) — what that part's request shows and is built from. */
+function planWirePartShape(part) {
+    return Object.fromEntries(Object.entries(PLAN_WIRE_SHAPE.plan).filter(([k]) => PLAN_PART_KEYS[part].includes(k)));
+}
+/**
+ * The format a model writes one part of a plan in — one request each (vectoriox/iox-cms#47). The same for every studio
+ * and run: nothing in it is pinned, so the provider compiles each part's grammar once.
+ */
+function planWirePartJsonSchema(part) {
+    const gaps = planWireGaps();
+    if (gaps.length)
+        throw new PlanWireShapeError(`the plan wire neither carries nor derives ${gaps.join(', ')}`);
+    const missing = Object.keys(WIRE_KEYS.plan).filter(k => !PLAN_TOP_SCHEMAS[k] || !WIRE_KEYS.plan[k].part);
+    if (missing.length)
+        throw new PlanWireShapeError(`the plan wire's ${missing.join(', ')} has no part or no format`);
+    return jsonShapedObject(planWirePartShape(part), Object.fromEntries(PLAN_PART_KEYS[part].map(k => [k, PLAN_TOP_SCHEMAS[k]()])), `wire plan ${part}`);
+}
+/** 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 list) {
+        if (!isPlainObject(entry) || typeof entry[keyName] !== 'string')
+            return list;
+        out[entry[keyName]] = entry[valueName];
+    }
+    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) };
+}
+function expandWireContentType(wire, options = {}) {
+    if (!isPlainObject(wire))
+        return wire;
+    const { roles, fields, seed, ...rest } = options.children === false ? { fields: [], ...wire } : wire;
+    const out = { ...rest, roles: listToMap(roles, 'role', 'field'), 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 };
+    }
+    if (type === PlanDataSourceType.Relative)
+        return { ...rest, alias, type, of, op, within };
+    return wire;
+}
+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),
+    };
+}
+function expandWirePage(wire, options = {}) {
+    if (!isPlainObject(wire))
+        return wire;
+    const { archetype, need, template, routeSource, seo, sections, ...rest } = options.children === false ? { sections: [], ...wire } : 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 plan (its parts, on the wire) + what the generation decides (the look, the run, the language, the owner's
+ * facts) → the Site Plan. Pure. Translates, never repairs: whatever an answer got wrong is still wrong, for
+ * `validateSitePlan` — a part that is not an object is the result itself, a part not written yet leaves its keys out
+ * (the validator then names them, at their own paths).
+ */
+function expandPlanWire(parts, context) {
+    const written = PLAN_PARTS.filter(part => parts[part] !== undefined).map(part => parts[part]);
+    const odd = written.find(value => !isPlainObject(value));
+    if (odd !== undefined)
+        return odd;
+    const wire = Object.assign({}, ...written);
+    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 ────────────────────────────────────────────────────────────────────────────────────────────
+function fieldToWire(field) {
+    return { name: field.name, type: field.type, controller: field.controller, required: field.required ?? false, note: field.note ?? NONE };
+}
+function contentTypeToWire(type, options = {}) {
+    const played = type.roles;
+    const roles = ROLE_KEYS.filter(role => played[role]).map(role => ({ role, field: played[role] }));
+    const { count = 0, sample = false, isPublished = false, ...values } = type.seed ?? {};
+    return {
+        name: type.name, label: type.label, roles, ...(options.children === false ? {} : { 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, options = {}) {
+    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 },
+        ...(options.children === false ? {} : { sections: page.sections.map(sectionToWire) }),
+    };
+}
+const PLAN_TO_WIRE = {
+    business: plan => ({ name: plan.business.name, tagline: plan.business.tagline ?? NONE }),
+    contentTypes: plan => plan.contentTypes.map(type => contentTypeToWire(type)),
+    dataSources: plan => plan.dataSources.map(dataSourceToWire),
+    pages: plan => plan.pages.map(page => pageToWire(page)),
+    globals: plan => ({ ...plan.globals }),
+};
+/** One part of the plan on the wire: what that part's request would have answered. */
+function planPartToWire(plan, part) {
+    return Object.fromEntries(PLAN_PART_KEYS[part].map(k => [k, PLAN_TO_WIRE[k](plan)]));
+}
+/** The plan → the wire, by part: what a model would have written (the change prompt shows it; fakes and evals write it). */
+function planToWire(plan) {
+    return Object.fromEntries(PLAN_PARTS.map(part => [part, planPartToWire(plan, part)]));
+}
+
 /**
  * The AI pipeline's WIRE vocabulary (AI plan §3c, §3n, M0): what iox-cms's `ai` API answers and what every client
  * of it reads — the steps a model works on, who pays (IOX credits or the studio's own key), a model of the vetted
@@ -13432,11 +13897,38 @@ const AI_STEP_NEEDS = {
     [AiStep.MakePictures]: [AiCapability.ImageOutput],
     [AiStep.NameStructures]: [AiCapability.StructuredOutput],
 };
-/** Tokens a typical use of a step reads and writes (plan §3d "Where credits go") — what a shown estimate is made of. */
+/**
+ * The steps a model answers in the plan's parts, one request per part (vectoriox/iox-cms#47 — the whole plan's format
+ * compiles to a grammar Claude refuses), and the tokens a typical request of each part reads and writes. Each part reads
+ * the same instructions; the pages read the structure too and write most of the words.
+ */
+const AI_STEP_PART_TOKENS = {
+    [AiStep.PlanSite]: {
+        [PlanPart.Structure]: { input: 10_000, output: 1_500, cacheWrite: 0, cacheRead: 0 },
+        [PlanPart.Pages]: { input: 12_000, output: 5_500, cacheWrite: 0, cacheRead: 0 },
+    },
+    [AiStep.ChangePlan]: {
+        [PlanPart.Structure]: { input: 6_000, output: 300, cacheWrite: 0, cacheRead: 0 },
+        [PlanPart.Pages]: { input: 6_500, output: 400, cacheWrite: 0, cacheRead: 0 },
+    },
+};
+/** The parts a step is asked in, in order — none for a step asked in one request. */
+function aiStepParts(step) {
+    return AI_STEP_PART_TOKENS[step] ? PLAN_PARTS : [];
+}
+const addTokens = (a, b) => ({
+    input: a.input + b.input, output: a.output + b.output, cacheWrite: a.cacheWrite + b.cacheWrite, cacheRead: a.cacheRead + b.cacheRead,
+    ...(a.imageOutput !== undefined || b.imageOutput !== undefined ? { imageOutput: (a.imageOutput ?? 0) + (b.imageOutput ?? 0) } : {}),
+});
+const partsTotal = (step) => PLAN_PARTS.map(part => AI_STEP_PART_TOKENS[step][part]).reduce(addTokens);
+/**
+ * Tokens a typical use of a step reads and writes (plan §3d "Where credits go") — what a shown estimate is made of. A
+ * step asked in parts is every part's request together, so the estimate (and a generation's start gate) counts them all.
+ */
 const AI_STEP_TYPICAL_TOKENS = {
     [AiStep.ReadMessage]: { input: 8_800, output: 1_500, cacheWrite: 0, cacheRead: 0 },
-    [AiStep.PlanSite]: { input: 12_000, output: 7_000, cacheWrite: 0, cacheRead: 0 },
-    [AiStep.ChangePlan]: { input: 6_000, output: 500, cacheWrite: 0, cacheRead: 0 },
+    [AiStep.PlanSite]: partsTotal(AiStep.PlanSite),
+    [AiStep.ChangePlan]: partsTotal(AiStep.ChangePlan),
     // a 1 K picture is 1,120 image tokens (Google's figure for Nano Banana 2) — I-D4
     [AiStep.MakePictures]: { input: 0, output: 0, cacheWrite: 0, cacheRead: 0, imageOutput: 1_120 },
     [AiStep.NameStructures]: { input: 80_000, output: 10_000, cacheWrite: 0, cacheRead: 0 },
@@ -13459,6 +13951,10 @@ function costUsd(tokens, price) {
 function creditsOfUsd(usd) {
     return Math.round(usd * CREDITS_PER_USD * CREDIT_PRECISION) / CREDIT_PRECISION;
 }
+/** What a typical request of `step` reads and writes — one part's when the step is asked in parts, else the whole step's. */
+function typicalStepTokens(step, part) {
+    return (part && AI_STEP_PART_TOKENS[step]?.[part]) || AI_STEP_TYPICAL_TOKENS[step];
+}
 /** The credits a typical use of `step` costs on a model of `price` — never typed, always computed (§3d). */
 function estimateStepCredits(step, price, tokens = AI_STEP_TYPICAL_TOKENS[step]) {
     return creditsOfUsd(costUsd(tokens, price));
@@ -13544,227 +14040,109 @@ 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.
+ * 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).
  *
- * 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).
+ * Beyond those, Claude refuses a grammar it compiles too large — a limit the docs name ("additional internal limits on
+ * the compiled grammar size") without a number. MEASURED against the API on 2026-10-27 (vectoriox/iox-cms#47): the
+ * total number of properties decides it, not enums or descriptions — 64 and 61 properties refused, 53 and fewer
+ * accepted (53 already took ~9 s to compile). So 60 is the line we refuse above, and 40 is what we send.
  */
-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]);
-}
-/** 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 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;
-    const out = {};
-    for (const entry of slots) {
-        if (!isPlainObject(entry) || typeof entry[SitePlanWireKey.SlotName] !== 'string')
-            return slots;
-        out[entry[SitePlanWireKey.SlotName]] = entry[SitePlanWireKey.SlotText];
+const STRICT_SCHEMA_LIMITS = {
+    strictTools: 20,
+    optional: 24,
+    unions: 16,
+    /** MEASURED, not documented (2026-10-27): the smallest refused request held 61 properties, the largest accepted 53. */
+    properties: 60,
+};
+/**
+ * What one request iox-cms sends may use: half of each documented limit, so a step can gain a field (or a strict tool)
+ * without a 400 — and 40 properties, a third under the measured grammar line, where compiling stays a few seconds.
+ */
+const STRICT_SCHEMA_BUDGET = { optional: 12, unions: 8, properties: 40 };
+/** 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;
+        out.properties += Object.keys(properties ?? {}).length;
+        if (properties)
+            out.objects++;
+        if (node['additionalProperties'] !== false)
+            out.unsupported.push(`${at('additionalProperties')}: must be false`);
     }
-    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;
-}
-/** 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];
-        }
+    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);
     }
-    else if (values !== undefined)
-        seed[SitePlanWireKey.SeedValues] = values;
-    return { ...type, seed };
-}
-function pageFromWire(page) {
-    if (!isPlainObject(page) || !Array.isArray(page['sections']))
-        return page;
-    return { ...page, sections: page['sections'].map(sectionFromWire) };
-}
-/** 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)));
+    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, properties: 0, objects: 0, unsupported: [] };
+    schemas.forEach((schema, i) => count(schema, schemas.length > 1 ? `[${i}]` : '', out));
+    return out;
 }
+/** Claude's words for a grammar it compiles too large (2026-10-27, the plan stage — vectoriox/iox-cms#47), verbatim. */
+const GRAMMAR_TOO_LARGE_MESSAGE = 'The compiled grammar is too large, which would cause performance issues. Simplify your tool schemas or reduce the number of strict tools.';
 /**
- * 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.
+ * The 400 the Claude API answers a request over its limits with, or null. The optional-parameter and the grammar-size
+ * messages are the ones Claude answered on 2026-10-27, verbatim; the union, strict-tool and unsupported messages follow
+ * their shape (not yet captured). The documented limits are checked first: a request over one of them never reaches the
+ * grammar compiler.
  */
-function sitePlanFromWire(wire) {
-    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;
-}
-/** 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 }));
-    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)) })),
-    };
+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}).`);
+    }
+    if (complexity.properties > STRICT_SCHEMA_LIMITS.properties)
+        return refuse(GRAMMAR_TOO_LARGE_MESSAGE);
+    return null;
 }
 
 /**
@@ -13807,9 +14185,32 @@ const PLAN_EDIT_SHAPE = {
     [PlanEditOp.SwapPattern]: { op: "'swapPattern'", page: 'string — a page key', index: 'integer — the section', pattern: 'string — the pattern it becomes (its slots kept where the new one has them)' },
     [PlanEditOp.SetSlot]: { op: "'setSlot'", page: 'string — a page key', index: 'integer — the section', slot: "string — one of the pattern's slots", text: "string — the words, in the owner's language and voice" },
     [PlanEditOp.AddContentType]: { op: "'addContentType'", contentType: 'contentType — a unique name', 'dataSources?': 'dataSource[] — the list / single sources its pages read' },
-    [PlanEditOp.AddField]: { op: "'addField'", contentType: 'string — a content type of the plan', field: 'field', 'sample?': "string | string[] — the samples' value for it" },
+    [PlanEditOp.AddField]: { op: "'addField'", contentType: 'string — a content type of the plan', field: 'field', 'sample?': "string | string[] — the samples' value for it; absent: what the type's seed already holds for it, else ''" },
     [PlanEditOp.SetSectionData]: { op: "'setSectionData'", page: 'string — a page key', index: 'integer — the section', binding: 'string — the list source the section repeats' },
 };
+/**
+ * The plan part each op changes (vectoriox/iox-cms#47): a sentence is answered in the plan's two parts, one request each —
+ * the structure's edits first, then the pages' written knowing them.
+ */
+const PLAN_EDIT_OP_PART = {
+    [PlanEditOp.AddPage]: PlanPart.Pages,
+    [PlanEditOp.RemovePage]: PlanPart.Pages,
+    [PlanEditOp.RenamePage]: PlanPart.Pages,
+    [PlanEditOp.MergePages]: PlanPart.Pages,
+    [PlanEditOp.MovePage]: PlanPart.Pages,
+    [PlanEditOp.AddSection]: PlanPart.Pages,
+    [PlanEditOp.RemoveSection]: PlanPart.Pages,
+    [PlanEditOp.MoveSection]: PlanPart.Pages,
+    [PlanEditOp.SwapPattern]: PlanPart.Pages,
+    [PlanEditOp.SetSlot]: PlanPart.Pages,
+    [PlanEditOp.SetSectionData]: PlanPart.Pages,
+    [PlanEditOp.AddContentType]: PlanPart.Structure,
+    [PlanEditOp.AddField]: PlanPart.Structure,
+};
+/** The ops written in one part, in `PlanEditOp` order. */
+function planEditOps(part) {
+    return Object.values(PlanEditOp).filter(op => PLAN_EDIT_OP_PART[op] === part);
+}
 var PlanChangeKind;
 (function (PlanChangeKind) {
     PlanChangeKind["Page"] = "page";
@@ -13930,10 +14331,12 @@ function findSection(d, pageAt, index, c, path) {
     return ok;
 }
 const setSections = (d, at, sections) => { d.pages[at] = { ...d.pages[at], sections }; };
+/** A child added to a page or type the same edits added is part of that addition — the map marks the parent only. */
+const addedHere = (changed, kind, at) => changed.some(ch => ch.kind === kind && ch.action === PlanChangeAction.Added && (kind === PlanChangeKind.Page ? ch.page === at.page : ch.name === at.name));
 /** 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,9 +14395,10 @@ 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 });
+        if (!addedHere(changed, PlanChangeKind.Page, { page: d.pages[at].key }))
+            changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Added, page: d.pages[at].key, index });
     },
     [PlanEditOp.RemoveSection]: (d, e, c, path, changed) => {
         const at = findPage(d, e.page, c, `${path}.page`);
@@ -14045,7 +14449,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);
@@ -14066,9 +14470,10 @@ const APPLY = {
         const type = d.contentTypes[at];
         if (type.fields.some(f => f.name === e.field.name))
             return c.add(PlanEditIssueCode.Duplicate, `${path}.field.name`, `"${type.name}" already has a field "${e.field.name}"`);
-        const seed = type.seed ? { ...type.seed, [e.field.name]: e.sample ?? '' } : undefined;
+        const seed = type.seed ? { ...type.seed, [e.field.name]: e.sample ?? type.seed[e.field.name] ?? '' } : undefined;
         d.contentTypes[at] = { ...type, fields: [...type.fields, e.field], ...(seed ? { seed } : {}) };
-        changed.push({ kind: PlanChangeKind.Field, action: PlanChangeAction.Added, name: `${type.name}.${e.field.name}` });
+        if (!addedHere(changed, PlanChangeKind.ContentType, { name: type.name }))
+            changed.push({ kind: PlanChangeKind.Field, action: PlanChangeAction.Added, name: `${type.name}.${e.field.name}` });
     },
     [PlanEditOp.SetSectionData]: (d, e, c, path, changed) => {
         const at = findPage(d, e.page, c, `${path}.page`);
@@ -14107,66 +14512,211 @@ function applyPlanEdits(plan, edits) {
     return { plan: { ...plan, pages: draft.pages, contentTypes: draft.contentTypes, dataSources }, changed, issues: [] };
 }
 // ── The format a model writes edits in ─────────────────────────────────────────────────────────────────
-const PLAN_EDITS_SCHEMA_NAME = 'plan_edits';
+/** Each part's answer format name. */
+const PLAN_EDITS_PART_SCHEMA_NAMES = {
+    [PlanPart.Structure]: 'plan_structure_edits',
+    [PlanPart.Pages]: 'plan_page_edits',
+};
 /** A sentence's answer: the edits, or why the ops cannot say it (one line, in the owner's language). */
 var PlanEditsOutcome;
 (function (PlanEditsOutcome) {
     PlanEditsOutcome["Edits"] = "edits";
     PlanEditsOutcome["Cannot"] = "cannot";
 })(PlanEditsOutcome || (PlanEditsOutcome = {}));
-/** The answer's own keys, explained. */
-const PLAN_EDITS_ANSWER_SHAPE = {
-    outcome: "'edits' | 'cannot' — cannot: the operations cannot do what the sentence asks",
-    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 ''",
+/**
+ * Each part's answer, explained. The structure is asked first, so it says whether the sentence is a plan change at all
+ * (`outcome`); the pages are asked only when it is, and write only their edits.
+ */
+const PLAN_EDITS_ANSWER_SHAPES = {
+    [PlanPart.Structure]: {
+        outcome: "'edits' | 'cannot' — cannot: no operation of either part (below) can do what the sentence asks",
+        edits: 'edit[] — the content types and fields the sentence adds, in order; empty when it adds none, or cannot',
+        reason: "string — when cannot, ONE short line for the owner in their language (what to do instead); else ''",
+    },
+    [PlanPart.Pages]: {
+        edits: 'edit[] — the page and section edits, in order, made after the structure edits (already applied); empty when none',
+    },
 };
-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)();
+const NO_INDEX = -1;
+/** A new page or content type on the wire: its children are edits of their own. */
+const CHILDLESS = { children: false };
+/** 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 (addSection: the place the new one goes)'),
+    to: indexKey('movePage / moveSection: the new 0-based place'),
+    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(CHILDLESS), v => expandWirePage(v, CHILDLESS), p => pageToWire(p, CHILDLESS), 'page'),
+        text: 'page[] — exactly one when the op takes it, WITHOUT sections: each is an addSection after it',
+    },
+    newSection: oneOf(wireSectionJsonSchema, expandWireSection, sectionToWire, 'section'),
+    newContentType: {
+        ...oneOf(() => wireContentTypeJsonSchema(CHILDLESS), v => expandWireContentType(v, CHILDLESS), t => contentTypeToWire(t, CHILDLESS), 'contentType'),
+        text: "contentType[] — exactly one when the op takes it, WITHOUT fields: each is an addField after it (the samples' values stay in its seed)",
+    },
+    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: 'index' },
+    [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' },
+};
+/** The wire keys a part's edit carries: every key its ops read, in `EDIT_WIRE` order. */
+function planEditWireKeys(part) {
+    const read = new Set(planEditOps(part).flatMap(op => Object.values(PLAN_EDIT_WIRE_KEYS[op])));
+    return Object.keys(EDIT_WIRE).filter(k => read.has(k));
+}
+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));
+const opsText = (part) => planEditOps(part).map(op => `'${op}'`).join(' | ');
+/** A part's flat edit, as a shape table: every key required, each with its none. */
+function planEditWireShape(part) {
+    return {
+        op: `${opsText(part)} — which keys below are read`,
+        ...Object.fromEntries(planEditWireKeys(part).map(k => [k, `${EDIT_WIRE[k].text} — ${noneText(EDIT_WIRE[k].none)} when the op does not read it`])),
     };
-    return jsonShapedObject(entry, Object.fromEntries(shapeKeys(entry).map(key => [key, valueOf(key)])), op);
 }
-/** The format a sentence's answer is written in: the outcome, the edits (one `anyOf` branch per op), the reason. */
-function planEditsJsonSchema() {
-    return jsonShapedObject(PLAN_EDITS_ANSWER_SHAPE, {
-        outcome: jsonOneOf(Object.values(PlanEditsOutcome)),
-        edits: jsonListOf(jsonAnyOf(OPS.map(op => opSchema(op)))),
-        reason: jsonText(),
-    }, 'planEdits');
+/** Per op of a part, the wire keys it reads, in `PLAN_EDIT_SHAPE`'s words (`?` = may hold its none) — what the model reads. */
+function planEditWireOps(part) {
+    return Object.fromEntries(planEditOps(part).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]];
+            }))];
+    }));
+}
+/** 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;
+}
+const ANSWER_SCHEMAS = {
+    outcome: () => jsonOneOf(Object.values(PlanEditsOutcome)),
+    reason: () => jsonText(),
+    edits: part => jsonListOf(jsonShapedObject(planEditWireShape(part), {
+        op: jsonOneOf(planEditOps(part)),
+        ...Object.fromEntries(planEditWireKeys(part).map(k => [k, EDIT_WIRE[k].schema()])),
+    }, `edit ${part}`)),
+};
+/** The format one part of a sentence's answer is written in — one request each (vectoriox/iox-cms#47). */
+function planEditsJsonSchema(part) {
+    const gaps = planEditWireGaps();
+    if (gaps.length)
+        throw new PlanWireShapeError(`the plan edits wire does not carry ${gaps.join(', ')}`);
+    const shape = PLAN_EDITS_ANSWER_SHAPES[part];
+    return jsonShapedObject(shape, Object.fromEntries(shapeKeys(shape).map(k => [k, ANSWER_SCHEMAS[k](part)])), `planEdits ${part}`);
+}
+/** 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's own keys → its flat wire edit, in its part's keys. */
+function flatEdit(edit) {
+    const part = PLAN_EDIT_OP_PART[edit.op];
+    const out = { op: edit.op, ...Object.fromEntries(planEditWireKeys(part).map(k => [k, Array.isArray(EDIT_WIRE[k].none) ? [] : EDIT_WIRE[k].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 (sections and content types off the wire); never repaired. */
+/** The children an added page or content type travels without, as the edits that add them after it. */
+function childEdits(edit) {
+    if (edit.op === PlanEditOp.AddPage)
+        return edit.page.sections.map(section => ({ op: PlanEditOp.AddSection, page: edit.page.key, section }));
+    if (edit.op === PlanEditOp.AddContentType)
+        return edit.contentType.fields.map(field => ({ op: PlanEditOp.AddField, contentType: edit.contentType.name, field }));
+    return [];
+}
+/** An edit → the flat wire edits a model would write for it: itself, then its children (fakes and specs write them). */
+function planEditToWire(edit) {
+    return [flatEdit(edit), ...childEdits(edit).map(flatEdit)];
+}
+/** Edits → each part's flat wire edits, in order (what each part's answer would hold). */
+function planEditsToWire(edits) {
+    const out = Object.fromEntries(PLAN_PARTS.map(part => [part, []]));
+    for (const edit of edits)
+        out[PLAN_EDIT_OP_PART[edit.op]].push(...planEditToWire(edit));
+    return out;
+}
+/** A model's answer (either part's) → 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 +15295,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_PART_TOKENS, 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, GRAMMAR_TOO_LARGE_MESSAGE, 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_SHAPES, PLAN_EDITS_PART_SCHEMA_NAMES, PLAN_EDIT_OP_PART, PLAN_EDIT_SHAPE, PLAN_EDIT_WIRE_KEYS, PLAN_PARTS, PLAN_PART_KEYS, PLAN_WIRE_DERIVED, PLAN_WIRE_PART_SCHEMA_NAMES, PLAN_WIRE_SHAPE, PRICING_PATTERN, PUBLISH_BLOCKING_PLACEHOLDERS, PageDataKind, PathIssueCollector, PatternDirective, PatternGlobalPosition, PatternOpens, PatternPlaceholder, PatternRecipe, PhoneMenuBreakpoint, PlaceholderKind, PlanChangeAction, PlanChangeKind, PlanDataSourceMode, PlanDataSourceType, PlanEditIssueCode, PlanEditOp, PlanEditsOutcome, PlanPart, 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, aiStepParts, 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, planEditOps, planEditToWire, planEditWireGaps, planEditWireKeys, planEditWireOps, planEditWireShape, planEditsFromWire, planEditsJsonSchema, planEditsToWire, planEntrances, planFromTemplate, planNavShape, planPartOfPath, planPartToWire, planStockPhotos, planToWire, planWireGaps, planWirePartJsonSchema, planWirePartShape, 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, typicalStepTokens, validatePlanEdits, validateSitePlan, walkSerialized, wireContentTypeJsonSchema, wireDataSourceJsonSchema, wireFieldJsonSchema, wirePageJsonSchema, wireSectionJsonSchema, wordPattern, writtenTexts };
 //# sourceMappingURL=vectoriox-iox-ui-generation-core.mjs.map