@vectoriox/iox-ui 5.61.0 → 5.62.0

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

@@ -10826,7 +10826,7 @@ 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 ROLE_KEYS$1 = shapeKeys(SHAPE['roles']);
 const PAGE_SEO_KEYS = shapeKeys(SHAPE['pageSeo']);
 const ARRAY_TYPE = 'array';
 const FIELD_KEYS = shapeKeys(SHAPE['field']);
@@ -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)) {
@@ -13381,179 +13381,21 @@ function buildStepFacts(plan, actions = {}) {
 }
 
 /**
- * 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
- * list with its price per token class, the one cost → credits rule (1 credit = 1 US cent of what the AI cost, D4),
- * the refusals (board 11) and a generation's stages. ONE definition: iox-cms meters and refuses with it, the
- * Settings ▸ AI screen and the wizard show it. Pure types, enums and helpers; no transport, no prices typed here.
- * The step and capability spellings are the control plane's (`GET /instances/me/entitlements`, AI plan "M0 control
- * plane — the instance-route contract") — the platform has ONE spelling of each.
- */
-var AiProviderId;
-(function (AiProviderId) {
-    AiProviderId["Anthropic"] = "anthropic";
-    AiProviderId["OpenRouter"] = "openrouter";
-})(AiProviderId || (AiProviderId = {}));
-/** Who pays: the platform's credits, or the studio's own provider key (metered for display, never charged). */
-var AiKeyMode;
-(function (AiKeyMode) {
-    AiKeyMode["Platform"] = "platform";
-    AiKeyMode["Own"] = "own";
-})(AiKeyMode || (AiKeyMode = {}));
-/** The steps a model works on (board 9's rows), in screen order. */
-var AiStep;
-(function (AiStep) {
-    AiStep["ReadMessage"] = "analysis";
-    AiStep["PlanSite"] = "plan";
-    AiStep["ChangePlan"] = "planEdit";
-    AiStep["MakePictures"] = "image";
-    AiStep["NameStructures"] = "scanNaming";
-})(AiStep || (AiStep = {}));
-const AI_STEPS = Object.values(AiStep);
-/** Each step's name on the wire (the control plane's `label`, the console) — the screens translate their own. */
-const AI_STEP_LABELS = {
-    [AiStep.ReadMessage]: 'Read your message',
-    [AiStep.PlanSite]: 'Plan the site',
-    [AiStep.ChangePlan]: 'Change the plan',
-    [AiStep.MakePictures]: 'Make pictures',
-    [AiStep.NameStructures]: 'Name repeated structures',
-};
-/** What a model must be able to do for a step to run on it. */
-var AiCapability;
-(function (AiCapability) {
-    AiCapability["StructuredOutput"] = "structuredOutputs";
-    AiCapability["ImageInput"] = "imageInput";
-    AiCapability["ImageOutput"] = "imageOutput";
-})(AiCapability || (AiCapability = {}));
-const AI_STEP_NEEDS = {
-    [AiStep.ReadMessage]: [AiCapability.StructuredOutput, AiCapability.ImageInput],
-    [AiStep.PlanSite]: [AiCapability.StructuredOutput],
-    [AiStep.ChangePlan]: [AiCapability.StructuredOutput],
-    [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. */
-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 },
-    // 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 },
-};
-/** 1 credit = 1 US cent of what the AI actually cost (decision D4). */
-const CREDITS_PER_USD = 100;
-const TOKENS_PER_PRICE_UNIT = 1_000_000;
-const CREDIT_PRECISION = 1e6;
-const NO_TOKENS = Object.freeze({ input: 0, output: 0, cacheWrite: 0, cacheRead: 0 });
-/** What `tokens` cost at `price`, in US dollars. */
-function costUsd(tokens, price) {
-    const perToken = (perMillion, fallback) => (perMillion ?? fallback) / TOKENS_PER_PRICE_UNIT;
-    return tokens.input * perToken(price.input, 0)
-        + tokens.output * perToken(price.output, 0)
-        + tokens.cacheWrite * perToken(price.cacheWrite, price.input)
-        + tokens.cacheRead * perToken(price.cacheRead, price.input)
-        + (tokens.imageOutput ?? 0) * perToken(price.imageOutput, price.output);
-}
-/** Dollars → credits, kept to a millionth of a credit (a short read costs a fraction of one). */
-function creditsOfUsd(usd) {
-    return Math.round(usd * CREDITS_PER_USD * CREDIT_PRECISION) / CREDIT_PRECISION;
-}
-/** 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));
-}
-/** Can `model` do `step`? The step's needs against the model's capabilities. */
-function modelCanDo(model, step) {
-    return AI_STEP_NEEDS[step].every(need => model.capabilities.includes(need));
-}
-/** Why AI did not run (board 11). The server refuses with these BEFORE any model call. */
-var AiRefusalCode;
-(function (AiRefusalCode) {
-    AiRefusalCode["NotInPlan"] = "ai.notInPlan";
-    AiRefusalCode["OutOfCredits"] = "ai.outOfCredits";
-    AiRefusalCode["CapReached"] = "ai.capReached";
-    AiRefusalCode["NotConnected"] = "ai.notConnected";
-    AiRefusalCode["KeyInvalid"] = "ai.keyInvalid";
-    AiRefusalCode["PlanUnknown"] = "ai.planUnknown";
-})(AiRefusalCode || (AiRefusalCode = {}));
-/** The HTTP status each refusal answers with (board 11). */
-const AI_REFUSAL_STATUS = {
-    [AiRefusalCode.NotInPlan]: 403,
-    [AiRefusalCode.OutOfCredits]: 402,
-    [AiRefusalCode.CapReached]: 402,
-    [AiRefusalCode.NotConnected]: 409,
-    [AiRefusalCode.KeyInvalid]: 409,
-    [AiRefusalCode.PlanUnknown]: 503,
-};
-/** What a refusal offers next. */
-var AiNextKind;
-(function (AiNextKind) {
-    /** Ask IOX (a prefilled email to the operator, until a plan can be bought — D2). */
-    AiNextKind["Contact"] = "contact";
-    /** Open Settings ▸ AI. */
-    AiNextKind["Settings"] = "settings";
-    /** Try again later, or with less. */
-    AiNextKind["Retry"] = "retry";
-})(AiNextKind || (AiNextKind = {}));
-const AI_REFUSAL_NEXT = {
-    [AiRefusalCode.NotInPlan]: AiNextKind.Contact,
-    [AiRefusalCode.OutOfCredits]: AiNextKind.Contact,
-    [AiRefusalCode.CapReached]: AiNextKind.Retry,
-    [AiRefusalCode.NotConnected]: AiNextKind.Settings,
-    [AiRefusalCode.KeyInvalid]: AiNextKind.Settings,
-    [AiRefusalCode.PlanUnknown]: AiNextKind.Retry,
-};
-/** The plan entitlements AI reads (the control plane's `features` / `limits` keys) — ONE spelling. */
-var AiFeature;
-(function (AiFeature) {
-    AiFeature["SiteGeneration"] = "aiSiteGeneration";
-})(AiFeature || (AiFeature = {}));
-var AiLimit;
-(function (AiLimit) {
-    AiLimit["CreditsPerMonth"] = "aiCreditsPerMonth";
-    AiLimit["CreditsPerGeneration"] = "aiCreditsPerGeneration";
-})(AiLimit || (AiLimit = {}));
-/** A generation's stages (§3d). The runner works while `task` is set; otherwise the owner has the next move. */
-var AiGenerationStage;
-(function (AiGenerationStage) {
-    AiGenerationStage["Reading"] = "reading";
-    AiGenerationStage["Analysis"] = "analysis";
-    AiGenerationStage["Design"] = "design";
-    AiGenerationStage["Plan"] = "plan";
-    AiGenerationStage["Build"] = "build";
-    AiGenerationStage["Done"] = "done";
-    AiGenerationStage["Failed"] = "failed";
-    AiGenerationStage["Cancelled"] = "cancelled";
-})(AiGenerationStage || (AiGenerationStage = {}));
-/** The stages nothing advances any more. */
-const FINAL_GENERATION_STAGES = [AiGenerationStage.Done, AiGenerationStage.Failed, AiGenerationStage.Cancelled];
-/** How one model call ended — a ledger row's status. */
-var AiCallStatus;
-(function (AiCallStatus) {
-    /** Written before the call: a reservation at the estimate until the call settles. */
-    AiCallStatus["Started"] = "started";
-    AiCallStatus["Ok"] = "ok";
-    /** The answer came back and the shared validator refused it (with a path). */
-    AiCallStatus["Invalid"] = "invalid";
-    /** The model declined (a provider refusal) — charged what the provider reports. */
-    AiCallStatus["Refused"] = "refused";
-    AiCallStatus["Error"] = "error";
-    /** The process died during the call: charged at the estimate, since what it cost was never reported. */
-    AiCallStatus["Interrupted"] = "interrupted";
-})(AiCallStatus || (AiCallStatus = {}));
-
-/**
- * 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.
+ * 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 fixed.
+ * - **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 `/`).
@@ -13563,13 +13405,24 @@ var AiCallStatus;
  * 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 PLAN_WIRE_SCHEMA_NAME = 'site_plan';
+/** 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["Roles"] = "roles";
+    PlanWireEntry["RoleField"] = "roleField";
     PlanWireEntry["Field"] = "field";
     PlanWireEntry["Seed"] = "seed";
     PlanWireEntry["SeedValue"] = "seedValue";
@@ -13583,13 +13436,17 @@ var PlanWireEntry;
 })(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: 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: 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'),
@@ -13598,17 +13455,13 @@ const WIRE_KEYS = {
     contentType: {
         name: key('contentType.name'),
         label: key('contentType.label'),
-        roles: key('contentType.roles'),
+        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' },
     },
-    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', "''"),
+    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'),
@@ -13697,6 +13550,19 @@ const wireText = (spec) => {
 };
 /** 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)));
@@ -13729,13 +13595,23 @@ const globalIds = (position) => Object.entries(SITE_PATTERNS).filter(([, p]) =>
 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);
+/** 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 shaped(PlanWireEntry.ContentType, {
+    return shapedAs(PlanWireEntry.ContentType, options, {
         name: jsonText(),
         label: jsonText(),
-        roles: shaped(PlanWireEntry.Roles, Object.fromEntries(roleKeys.map(k => [k, 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) }),
     });
@@ -13766,8 +13642,8 @@ function wireSectionJsonSchema() {
         enter: orNone(ANIMATE_IDS),
     });
 }
-function wirePageJsonSchema() {
-    return shaped(PlanWireEntry.Page, {
+function wirePageJsonSchema(options = {}) {
+    return shapedAs(PlanWireEntry.Page, options, {
         key: jsonText(),
         name: jsonText(),
         route: jsonText(),
@@ -13780,21 +13656,32 @@ function wirePageJsonSchema() {
         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 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(', ')}`);
-    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)),
-        }),
-    });
+    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;
@@ -13820,11 +13707,11 @@ function expandWireField(wire) {
     const { required, note, ...rest } = wire;
     return { ...rest, ...optional('required', required, v => v === undefined || v === false), ...optional('note', note) };
 }
-function expandWireContentType(wire) {
+function expandWireContentType(wire, options = {}) {
     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) };
+    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;
@@ -13859,10 +13746,10 @@ function expandWireSection(wire) {
         ...optional('enter', enter),
     };
 }
-function expandWirePage(wire) {
+function expandWirePage(wire, options = {}) {
     if (!isPlainObject(wire))
         return wire;
-    const { archetype, need, template, routeSource, seo, sections, ...rest } = 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,
@@ -13882,12 +13769,17 @@ function expandWireBusiness(wire, facts) {
     return { ...rest, ...optional('tagline', tagline), ...(facts && Object.keys(facts).length ? { facts: { ...facts } } : {}) };
 }
 /**
- * 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`.
+ * 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(wire, context) {
-    if (!isPlainObject(wire))
-        return wire;
+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,
@@ -13905,11 +13797,12 @@ function expandPlanWire(wire, context) {
 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]));
+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, fields: type.fields.map(fieldToWire),
+        name: type.name, label: type.label, roles, ...(options.children === false ? {} : { fields: type.fields.map(fieldToWire) }),
         seed: { count, sample, isPublished, values: mapToList(values, 'field', 'value') },
     };
 }
@@ -13928,24 +13821,224 @@ function sectionToWire(section) {
         binding: section.binding ?? NONE, without: [...(section.without ?? [])], form: section.form ?? NONE, enter: section.enter ?? NONE,
     };
 }
-function pageToWire(page) {
+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 }, sections: page.sections.map(sectionToWire),
+        seo: { title: page.seo?.title ?? NONE, description: page.seo?.description ?? NONE },
+        ...(options.children === false ? {} : { 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). */
+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 {
-        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 },
-    };
+    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
+ * list with its price per token class, the one cost → credits rule (1 credit = 1 US cent of what the AI cost, D4),
+ * the refusals (board 11) and a generation's stages. ONE definition: iox-cms meters and refuses with it, the
+ * Settings ▸ AI screen and the wizard show it. Pure types, enums and helpers; no transport, no prices typed here.
+ * The step and capability spellings are the control plane's (`GET /instances/me/entitlements`, AI plan "M0 control
+ * plane — the instance-route contract") — the platform has ONE spelling of each.
+ */
+var AiProviderId;
+(function (AiProviderId) {
+    AiProviderId["Anthropic"] = "anthropic";
+    AiProviderId["OpenRouter"] = "openrouter";
+})(AiProviderId || (AiProviderId = {}));
+/** Who pays: the platform's credits, or the studio's own provider key (metered for display, never charged). */
+var AiKeyMode;
+(function (AiKeyMode) {
+    AiKeyMode["Platform"] = "platform";
+    AiKeyMode["Own"] = "own";
+})(AiKeyMode || (AiKeyMode = {}));
+/** The steps a model works on (board 9's rows), in screen order. */
+var AiStep;
+(function (AiStep) {
+    AiStep["ReadMessage"] = "analysis";
+    AiStep["PlanSite"] = "plan";
+    AiStep["ChangePlan"] = "planEdit";
+    AiStep["MakePictures"] = "image";
+    AiStep["NameStructures"] = "scanNaming";
+})(AiStep || (AiStep = {}));
+const AI_STEPS = Object.values(AiStep);
+/** Each step's name on the wire (the control plane's `label`, the console) — the screens translate their own. */
+const AI_STEP_LABELS = {
+    [AiStep.ReadMessage]: 'Read your message',
+    [AiStep.PlanSite]: 'Plan the site',
+    [AiStep.ChangePlan]: 'Change the plan',
+    [AiStep.MakePictures]: 'Make pictures',
+    [AiStep.NameStructures]: 'Name repeated structures',
+};
+/** What a model must be able to do for a step to run on it. */
+var AiCapability;
+(function (AiCapability) {
+    AiCapability["StructuredOutput"] = "structuredOutputs";
+    AiCapability["ImageInput"] = "imageInput";
+    AiCapability["ImageOutput"] = "imageOutput";
+})(AiCapability || (AiCapability = {}));
+const AI_STEP_NEEDS = {
+    [AiStep.ReadMessage]: [AiCapability.StructuredOutput, AiCapability.ImageInput],
+    [AiStep.PlanSite]: [AiCapability.StructuredOutput],
+    [AiStep.ChangePlan]: [AiCapability.StructuredOutput],
+    [AiStep.MakePictures]: [AiCapability.ImageOutput],
+    [AiStep.NameStructures]: [AiCapability.StructuredOutput],
+};
+/**
+ * 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]: 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 },
+};
+/** 1 credit = 1 US cent of what the AI actually cost (decision D4). */
+const CREDITS_PER_USD = 100;
+const TOKENS_PER_PRICE_UNIT = 1_000_000;
+const CREDIT_PRECISION = 1e6;
+const NO_TOKENS = Object.freeze({ input: 0, output: 0, cacheWrite: 0, cacheRead: 0 });
+/** What `tokens` cost at `price`, in US dollars. */
+function costUsd(tokens, price) {
+    const perToken = (perMillion, fallback) => (perMillion ?? fallback) / TOKENS_PER_PRICE_UNIT;
+    return tokens.input * perToken(price.input, 0)
+        + tokens.output * perToken(price.output, 0)
+        + tokens.cacheWrite * perToken(price.cacheWrite, price.input)
+        + tokens.cacheRead * perToken(price.cacheRead, price.input)
+        + (tokens.imageOutput ?? 0) * perToken(price.imageOutput, price.output);
+}
+/** Dollars → credits, kept to a millionth of a credit (a short read costs a fraction of one). */
+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));
+}
+/** Can `model` do `step`? The step's needs against the model's capabilities. */
+function modelCanDo(model, step) {
+    return AI_STEP_NEEDS[step].every(need => model.capabilities.includes(need));
+}
+/** Why AI did not run (board 11). The server refuses with these BEFORE any model call. */
+var AiRefusalCode;
+(function (AiRefusalCode) {
+    AiRefusalCode["NotInPlan"] = "ai.notInPlan";
+    AiRefusalCode["OutOfCredits"] = "ai.outOfCredits";
+    AiRefusalCode["CapReached"] = "ai.capReached";
+    AiRefusalCode["NotConnected"] = "ai.notConnected";
+    AiRefusalCode["KeyInvalid"] = "ai.keyInvalid";
+    AiRefusalCode["PlanUnknown"] = "ai.planUnknown";
+})(AiRefusalCode || (AiRefusalCode = {}));
+/** The HTTP status each refusal answers with (board 11). */
+const AI_REFUSAL_STATUS = {
+    [AiRefusalCode.NotInPlan]: 403,
+    [AiRefusalCode.OutOfCredits]: 402,
+    [AiRefusalCode.CapReached]: 402,
+    [AiRefusalCode.NotConnected]: 409,
+    [AiRefusalCode.KeyInvalid]: 409,
+    [AiRefusalCode.PlanUnknown]: 503,
+};
+/** What a refusal offers next. */
+var AiNextKind;
+(function (AiNextKind) {
+    /** Ask IOX (a prefilled email to the operator, until a plan can be bought — D2). */
+    AiNextKind["Contact"] = "contact";
+    /** Open Settings ▸ AI. */
+    AiNextKind["Settings"] = "settings";
+    /** Try again later, or with less. */
+    AiNextKind["Retry"] = "retry";
+})(AiNextKind || (AiNextKind = {}));
+const AI_REFUSAL_NEXT = {
+    [AiRefusalCode.NotInPlan]: AiNextKind.Contact,
+    [AiRefusalCode.OutOfCredits]: AiNextKind.Contact,
+    [AiRefusalCode.CapReached]: AiNextKind.Retry,
+    [AiRefusalCode.NotConnected]: AiNextKind.Settings,
+    [AiRefusalCode.KeyInvalid]: AiNextKind.Settings,
+    [AiRefusalCode.PlanUnknown]: AiNextKind.Retry,
+};
+/** The plan entitlements AI reads (the control plane's `features` / `limits` keys) — ONE spelling. */
+var AiFeature;
+(function (AiFeature) {
+    AiFeature["SiteGeneration"] = "aiSiteGeneration";
+})(AiFeature || (AiFeature = {}));
+var AiLimit;
+(function (AiLimit) {
+    AiLimit["CreditsPerMonth"] = "aiCreditsPerMonth";
+    AiLimit["CreditsPerGeneration"] = "aiCreditsPerGeneration";
+})(AiLimit || (AiLimit = {}));
+/** A generation's stages (§3d). The runner works while `task` is set; otherwise the owner has the next move. */
+var AiGenerationStage;
+(function (AiGenerationStage) {
+    AiGenerationStage["Reading"] = "reading";
+    AiGenerationStage["Analysis"] = "analysis";
+    AiGenerationStage["Design"] = "design";
+    AiGenerationStage["Plan"] = "plan";
+    AiGenerationStage["Build"] = "build";
+    AiGenerationStage["Done"] = "done";
+    AiGenerationStage["Failed"] = "failed";
+    AiGenerationStage["Cancelled"] = "cancelled";
+})(AiGenerationStage || (AiGenerationStage = {}));
+/** The stages nothing advances any more. */
+const FINAL_GENERATION_STAGES = [AiGenerationStage.Done, AiGenerationStage.Failed, AiGenerationStage.Cancelled];
+/** How one model call ended — a ledger row's status. */
+var AiCallStatus;
+(function (AiCallStatus) {
+    /** Written before the call: a reservation at the estimate until the call settles. */
+    AiCallStatus["Started"] = "started";
+    AiCallStatus["Ok"] = "ok";
+    /** The answer came back and the shared validator refused it (with a path). */
+    AiCallStatus["Invalid"] = "invalid";
+    /** The model declined (a provider refusal) — charged what the provider reports. */
+    AiCallStatus["Refused"] = "refused";
+    AiCallStatus["Error"] = "error";
+    /** The process died during the call: charged at the estimate, since what it cost was never reported. */
+    AiCallStatus["Interrupted"] = "interrupted";
+})(AiCallStatus || (AiCallStatus = {}));
+
 /**
  * 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):
@@ -13955,10 +14048,24 @@ function planToWire(plan) {
  * 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).
+ *
+ * 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 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_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 };
+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',
@@ -13977,6 +14084,9 @@ function count(node, path, out) {
     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`);
     }
@@ -14005,14 +14115,17 @@ function count(node, path, 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: [] };
+    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.';
 /**
- * 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).
+ * 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 strictSchemaRefusal(complexity) {
     const refuse = (message) => ({ status: 400, type: 'invalid_request_error', message });
@@ -14027,6 +14140,8 @@ function strictSchemaRefusal(complexity) {
     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;
 }
 
@@ -14070,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";
@@ -14193,6 +14331,8 @@ 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) => {
@@ -14257,7 +14397,8 @@ const APPLY = {
         const index = e.at === undefined ? sections.length : clamp(e.at, sections.length);
         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`);
@@ -14329,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`);
@@ -14370,20 +14512,34 @@ 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 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`,
@@ -14401,17 +14557,22 @@ const EDIT_WIRE = {
     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'),
+    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'),
-    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'),
+    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, expandWireContentType, contentTypeToWire, 'contentType'),
+    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()),
@@ -14428,7 +14589,7 @@ const PLAN_EDIT_WIRE_KEYS = {
     [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.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' },
@@ -14437,19 +14598,27 @@ const PLAN_EDIT_WIRE_KEYS = {
     [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));
-/** 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 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`])),
+    };
+}
+/** 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]) => {
@@ -14477,20 +14646,21 @@ function planEditWireGaps() {
     }
     return gaps;
 }
-/** The format a sentence's answer is written in: the outcome, the flat edits, the reason. */
-function planEditsJsonSchema() {
+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 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(edit),
-        reason: jsonText(),
-    }, 'planEdits');
+    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) {
@@ -14511,9 +14681,10 @@ function expandWireEdit(wire) {
     }
     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])) };
+/** 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)
@@ -14522,7 +14693,26 @@ function planEditToWire(edit) {
     }
     return out;
 }
-/** A model's answer → edits (each flat edit expanded); 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;
@@ -15105,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, 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 };
+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