@vectoriox/iox-ui 5.54.0 → 5.55.0

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

@@ -7567,7 +7567,7 @@ var SiteTemplateId;
 const STUDIO_TEMPLATE = SITE_TEMPLATES[SiteTemplateId.Studio];
 class SiteTemplateError extends Error {
 }
-const clone$3 = (value) => JSON.parse(JSON.stringify(value));
+const clone$4 = (value) => JSON.parse(JSON.stringify(value));
 /**
  * The template as a Site Plan (`source.kind: template`), with the customer's business and look. A
  * required page cannot be left out, and an unknown key is refused — nothing is guessed.
@@ -7584,12 +7584,12 @@ function planFromTemplate(template, input) {
     return {
         version: SITE_PLAN_VERSION,
         source: { kind: SitePlanSourceKind.Template, templateId: template.id, templateVersion: template.version },
-        business: clone$3(input.business),
-        design: clone$3(input.design),
-        contentTypes: clone$3(template.contentTypes),
-        dataSources: clone$3(template.dataSources),
-        pages: clone$3(template.pages.filter(p => !omit.has(p.key))),
-        globals: clone$3(template.globals),
+        business: clone$4(input.business),
+        design: clone$4(input.design),
+        contentTypes: clone$4(template.contentTypes),
+        dataSources: clone$4(template.dataSources),
+        pages: clone$4(template.pages.filter(p => !omit.has(p.key))),
+        globals: clone$4(template.globals),
     };
 }
 
@@ -7598,7 +7598,7 @@ function planFromTemplate(template, input) {
  *  wrong — never something to work around. */
 class ComposeError extends Error {
 }
-const clone$2 = (value) => JSON.parse(JSON.stringify(value));
+const clone$3 = (value) => JSON.parse(JSON.stringify(value));
 /**
  * A NEW node of `type`, as the builder creates one (ComponentRegistryService.createConfig, serialized):
  * the type's constructor defaults, its text colour released to `inherit` (NEW_NODE_STYLE_DEFAULTS), then
@@ -7613,8 +7613,8 @@ function createSerializedNode(id, type, props = {}, elementStyle, options = {})
     const node = {
         id,
         type,
-        props: { ...clone$2(baseline.props), ...props },
-        styleProps: clone$2(baseline.styleProps),
+        props: { ...clone$3(baseline.props), ...props },
+        styleProps: clone$3(baseline.styleProps),
         bindings: [],
         interactions: [],
     };
@@ -7665,16 +7665,16 @@ function walkSerialized(nodes, visit, ancestors = []) {
  * own field names) whose key lists the gate READS — so the shape a model is told about is the shape refused —
  * and a collector that records each refusal at its dotted path. Generic over each gate's issue-code enum.
  */
-const OPTIONAL_MARK = '?';
+const OPTIONAL_MARK$1 = '?';
 const DYNAMIC_KEY = /^\[[^\]]+\]\??$/;
 const isDynamic = (key) => DYNAMIC_KEY.test(key);
 /** Every fixed key an object of the shape may carry. */
 function shapeKeys(entry) {
-    return Object.keys(entry).filter(k => !isDynamic(k)).map(k => (k.endsWith(OPTIONAL_MARK) ? k.slice(0, -1) : k));
+    return Object.keys(entry).filter(k => !isDynamic(k)).map(k => (k.endsWith(OPTIONAL_MARK$1) ? k.slice(0, -1) : k));
 }
 /** The keys an object of the shape must carry. */
 function requiredShapeKeys(entry) {
-    return Object.keys(entry).filter(k => !isDynamic(k) && !k.endsWith(OPTIONAL_MARK));
+    return Object.keys(entry).filter(k => !isDynamic(k) && !k.endsWith(OPTIONAL_MARK$1));
 }
 const isPlainObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const isNonEmptyString = (v) => typeof v === 'string' && v.trim() !== '';
@@ -7729,6 +7729,83 @@ class PathIssueCollector {
     }
 }
 
+const OPTIONAL_MARK = '?';
+class JsonSchemaShapeError extends Error {
+}
+const jsonText = () => ({ type: 'string' });
+const jsonBoolean = () => ({ type: 'boolean' });
+const jsonInteger = () => ({ type: 'integer' });
+const jsonOneOf = (values) => ({ type: 'string', enum: [...values] });
+const jsonListOf = (items) => ({ type: 'array', items });
+const jsonAnyOf = (options) => ({ anyOf: [...options] });
+/** A closed object with exactly these properties. */
+function jsonClosedObject(properties, required, description) {
+    return {
+        type: 'object',
+        properties,
+        required: [...required],
+        additionalProperties: false,
+        ...(description ? { description } : {}),
+    };
+}
+/** The table's own words for a key (`key` or `key?`). */
+function describeShapeKey(entry, key) {
+    return String(entry[key] ?? entry[`${key}${OPTIONAL_MARK}`] ?? '');
+}
+/**
+ * An object of one shape-table entry: exactly its fixed keys, its required keys required, each described by the
+ * table; an entry's `[name]` keys are not object keys — `dynamic` writes them as one list. Throws when the properties
+ * given are not the table's keys.
+ */
+function jsonShapedObject(entry, properties, name = 'shape', dynamic) {
+    const expected = [...shapeKeys(entry)].sort();
+    const given = Object.keys(properties).sort();
+    if (expected.join() !== given.join()) {
+        throw new JsonSchemaShapeError(`${name}: the format's keys (${given.join(', ')}) are not the shape table's (${expected.join(', ')})`);
+    }
+    const dynamicKey = Object.keys(entry).find(k => /^\[[^\]]+\]\??$/.test(k));
+    if (!!dynamic !== !!dynamicKey)
+        throw new JsonSchemaShapeError(`${name}: ${dynamicKey ? `its ${dynamicKey} keys need a list on the wire` : 'it has no [name] keys to list'}`);
+    const described = Object.fromEntries(Object.entries(properties).map(([key, schema]) => [key, { ...schema, description: describeShapeKey(entry, key) }]));
+    if (dynamic && dynamicKey)
+        described[dynamic.key] = { ...dynamic.schema, description: `${dynamicKey}: ${entry[dynamicKey]}` };
+    return jsonClosedObject(described, requiredShapeKeys(entry));
+}
+/** Every keyword a schema uses — what a spec checks against the strict subset. */
+function jsonSchemaKeywords(node, out = new Set()) {
+    if (Array.isArray(node))
+        node.forEach(n => jsonSchemaKeywords(n, out));
+    else if (node && typeof node === 'object') {
+        for (const [k, v] of Object.entries(node)) {
+            out.add(k);
+            if (k === 'properties')
+                Object.values(v).forEach(p => jsonSchemaKeywords(p, out));
+            else if (k !== 'enum' && k !== 'required' && k !== 'description')
+                jsonSchemaKeywords(v, out);
+        }
+    }
+    return out;
+}
+/** The keywords the strict subset never uses. */
+const JSON_SCHEMA_BANNED_KEYWORDS = [
+    'minLength', 'maxLength', 'minimum', 'maximum', 'minItems', 'maxItems', 'pattern', 'oneOf', '$ref', 'const', 'format',
+];
+/** Every object node of a schema (through properties, items and anyOf). */
+function jsonSchemaObjects(node, out = []) {
+    if (!node || typeof node !== 'object')
+        return out;
+    const n = node;
+    if (n['type'] === 'object')
+        out.push(n);
+    for (const p of Object.values(n['properties'] ?? {}))
+        jsonSchemaObjects(p, out);
+    if (n['items'])
+        jsonSchemaObjects(n['items'], out);
+    for (const option of n['anyOf'] ?? [])
+        jsonSchemaObjects(option, out);
+    return out;
+}
+
 /**
  * The Site Plan validator — the gate in front of the composer. The wizard's plan and (later) the AI's
  * plan go through the SAME checks: an unknown pattern, a slot the pattern does not declare, a source
@@ -7776,20 +7853,20 @@ 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 = 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 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 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 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 GLOBAL_POSITION = {
     [GlobalSlot.Header]: PatternGlobalPosition.Before,
     [GlobalSlot.Footer]: PatternGlobalPosition.After,
@@ -7801,11 +7878,11 @@ const has = (table, key) => Object.prototype.hasOwnProperty.call(table, key);
 function routeParams(route) {
     return [...route.matchAll(ROUTE_PARAM$1)].map(m => m[1]);
 }
-class Collector extends PathIssueCollector {
+let Collector$1 = class Collector extends PathIssueCollector {
     constructor() {
         super('plan', { shape: SitePlanIssueCode.Shape, unknownKey: SitePlanIssueCode.UnknownKey, duplicate: SitePlanIssueCode.Duplicate });
     }
-}
+};
 function validateSource(c, source) {
     if (!isPlainObject(source))
         return c.add(SitePlanIssueCode.Shape, 'source', 'must be an object');
@@ -8143,7 +8220,7 @@ function validateGlobals(c, globals) {
 }
 /** Check a Site Plan against the plan shape and the pattern library. Never throws, never repairs. */
 function validateSitePlan(plan) {
-    const c = new Collector();
+    const c = new Collector$1();
     if (!isPlainObject(plan)) {
         c.add(SitePlanIssueCode.Shape, '', 'a site plan is an object');
         return { valid: false, issues: c.issues };
@@ -8506,7 +8583,7 @@ function bar(kit, root, pages, shape, count, drawerId, at) {
     return b;
 }
 // ── the edit ────────────────────────────────────────────────────────────────────────────────
-const clone$1 = (v) => JSON.parse(JSON.stringify(v));
+const clone$2 = (v) => JSON.parse(JSON.stringify(v));
 function removeRole(node, role) {
     let removed = null;
     const visit = (n) => {
@@ -8558,7 +8635,7 @@ function clampBarCount(n, shape) {
 function planNavShape(globals, shape, options = {}, navId) {
     if (!Object.values(NavShape).includes(shape))
         throw new NavShapeError(`unknown phone menu shape "${shape}"`);
-    const out = clone$1(globals);
+    const out = clone$2(globals);
     const root = findNavRoot(out, navId);
     if (!root)
         throw new NavShapeError('no Navigation bar among the globals');
@@ -8678,7 +8755,7 @@ function nameParts(root) {
  * bar does not link to yet (Home when every page is there). Refused at five (Q2). Input not mutated.
  */
 function addBarItem(globals, options = {}) {
-    const out = clone$1(globals);
+    const out = clone$2(globals);
     const root = findNavRoot(out);
     const b = find(out, NavRole.Bar);
     if (!root || !b)
@@ -8698,7 +8775,7 @@ function addBarItem(globals, options = {}) {
     return { globals: out, added: true };
 }
 function barOf(globals) {
-    const out = clone$1(globals);
+    const out = clone$2(globals);
     const b = find(out, NavRole.Bar);
     return { out, kids: b ? (b.children ?? (b.children = [])) : null };
 }
@@ -8839,7 +8916,7 @@ const COMPOSED = { releaseLayoutDefaults: true };
 const TEXT_VARIABLE = /\{(year|business\.name)\}/g;
 /** What `page.*` may read on a node stamped for a navigation page. */
 const STAMPED_PAGE_FIELDS = new Set(['name', 'route']);
-const clone = (value) => JSON.parse(JSON.stringify(value));
+const clone$1 = (value) => JSON.parse(JSON.stringify(value));
 /** 32-bit FNV-1a, base 36 — a short stable id fragment. */
 function stableHash(text) {
     let h = 0x811c9dc5;
@@ -9612,10 +9689,10 @@ function composeSite(plan, context) {
             globals = planNavShape(globals, shape, {}, slot).globals;
     }
     return {
-        source: clone(plan.source),
-        business: clone(plan.business),
-        design: resolveDesignChoices(clone(plan.design)),
-        schemas: clone(plan.contentTypes),
+        source: clone$1(plan.source),
+        business: clone$1(plan.business),
+        design: resolveDesignChoices(clone$1(plan.design)),
+        schemas: clone$1(plan.contentTypes),
         items: Object.fromEntries(plan.contentTypes.map(t => [t.name, composeItems(t)])),
         dataSources: plan.dataSources.map(composeDataSource),
         pages,
@@ -9731,13 +9808,13 @@ const ENTRANCE_TRIGGER = 'viewportEnter';
 const ENTRANCE_EASING = 'ease-out';
 const LEVELS = SPEC_AXES.animations;
 const FAMILIES = SPEC_AXES.animationFamilies;
-const NOTHING = { content: null, parts: {} };
+const NOTHING$1 = { 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;
+        return NOTHING$1;
     if (lv.parts.content && allow.includes(EntrancePart.Content))
         return { content: lv.parts.content, parts: {} };
     const parts = {};
@@ -10009,6 +10086,14 @@ var AiStep;
     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) {
@@ -10028,7 +10113,8 @@ 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.MakePictures]: { input: 1_120, output: 0, 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). */
@@ -10042,7 +10128,8 @@ function costUsd(tokens, price) {
     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.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) {
@@ -10122,6 +10209,724 @@ var AiCallStatus;
     AiCallStatus["Interrupted"] = "interrupted";
 })(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.
+ *
+ * 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).
+ */
+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 });
+    return jsonShapedObject(SHAPE['contentType'], {
+        name: jsonText(), label: jsonText(), previewTextField: jsonText(), previewImageField: jsonText(), 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), its optional parts, a binding when it takes one. */
+function sectionBranch(id, pattern) {
+    const slots = patternSlots(pattern);
+    const parts = patternOptionalParts(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,
+        binding: patternTakesBinding(pattern) ? jsonText() : NOTHING(),
+        without: parts.length ? jsonListOf(jsonOneOf(parts)) : NOTHING(),
+    }, 'section');
+    return { ...branch, description: `${id}: ${pattern.label}` };
+}
+/** A page section: one branch per pattern. */
+function sectionJsonSchema() {
+    return jsonAnyOf(sectionPatternIds().map(id => sectionBranch(id, SITE_PATTERNS[id])));
+}
+/** A page. */
+function pageJsonSchema() {
+    return jsonShapedObject(SHAPE['page'], {
+        key: jsonText(), name: jsonText(), route: jsonText(), isHome: jsonBoolean(), required: jsonBoolean(), inNav: jsonBoolean(),
+        template: jsonText(), routeSource: jsonText(), 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(),
+        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];
+    }
+    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', 'binding', 'without'])
+        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];
+        }
+    }
+    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)));
+}
+/**
+ * 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.
+ */
+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)) })),
+    };
+}
+
+/**
+ * Changing a plan by sentence (AI plan §3d "The Plan prompt box", M1-5; reused by M2 after a build): the CLOSED list
+ * of operations (N-D6) a model may write against the current plan, and the ONE pure `applyPlanEdits` that carries them
+ * out. Nothing is written until Build, so an edit is a plan → plan function; the result goes through
+ * `validateSitePlan` like any plan. Pages are named by `key`, sections by their index on the page. A set of edits is
+ * applied whole or not at all: one edit that cannot apply refuses the set, with a path, and the plan is unchanged.
+ */
+var PlanEditOp;
+(function (PlanEditOp) {
+    PlanEditOp["AddPage"] = "addPage";
+    PlanEditOp["RemovePage"] = "removePage";
+    PlanEditOp["RenamePage"] = "renamePage";
+    PlanEditOp["MergePages"] = "mergePages";
+    /** Its place in the menu (the plan's page order). */
+    PlanEditOp["MovePage"] = "movePage";
+    PlanEditOp["AddSection"] = "addSection";
+    PlanEditOp["RemoveSection"] = "removeSection";
+    PlanEditOp["MoveSection"] = "moveSection";
+    PlanEditOp["SwapPattern"] = "swapPattern";
+    PlanEditOp["SetSlot"] = "setSlot";
+    PlanEditOp["AddContentType"] = "addContentType";
+    PlanEditOp["AddField"] = "addField";
+    PlanEditOp["SetSectionData"] = "setSectionData";
+})(PlanEditOp || (PlanEditOp = {}));
+/**
+ * Every op's keys, explained — what the format is built from and what `validatePlanEdits` reads (`key?` optional).
+ * A page is named by its `key`; a section by its 0-based `index` on that page.
+ */
+const PLAN_EDIT_SHAPE = {
+    [PlanEditOp.AddPage]: { op: "'addPage'", page: 'page — a whole new page (a unique key and route)', 'after?': 'string — the key of the page it follows in the menu; absent: last' },
+    [PlanEditOp.RemovePage]: { op: "'removePage'", page: 'string — the key of the page to remove (never the home page)' },
+    [PlanEditOp.RenamePage]: { op: "'renamePage'", page: 'string — a page key', 'name?': 'string — its new name (the menu label)', 'route?': 'string — its new route' },
+    [PlanEditOp.MergePages]: { op: "'mergePages'", into: 'string — the page that stays', from: 'string — the page whose sections move into it, then removed' },
+    [PlanEditOp.MovePage]: { op: "'movePage'", page: 'string — a page key', to: 'integer — its new 0-based place in the menu' },
+    [PlanEditOp.AddSection]: { op: "'addSection'", page: 'string — a page key', section: 'section', 'at?': 'integer — its 0-based place on the page; absent: last' },
+    [PlanEditOp.RemoveSection]: { op: "'removeSection'", page: 'string — a page key', index: 'integer — the section' },
+    [PlanEditOp.MoveSection]: { op: "'moveSection'", page: 'string — a page key', from: 'integer — the section', to: 'integer — its new place' },
+    [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.SetSectionData]: { op: "'setSectionData'", page: 'string — a page key', index: 'integer — the section', binding: 'string — the list source the section repeats' },
+};
+var PlanChangeKind;
+(function (PlanChangeKind) {
+    PlanChangeKind["Page"] = "page";
+    PlanChangeKind["Section"] = "section";
+    PlanChangeKind["ContentType"] = "contentType";
+    PlanChangeKind["Field"] = "field";
+    PlanChangeKind["DataSource"] = "dataSource";
+})(PlanChangeKind || (PlanChangeKind = {}));
+var PlanChangeAction;
+(function (PlanChangeAction) {
+    PlanChangeAction["Added"] = "added";
+    PlanChangeAction["Removed"] = "removed";
+    PlanChangeAction["Changed"] = "changed";
+    PlanChangeAction["Moved"] = "moved";
+})(PlanChangeAction || (PlanChangeAction = {}));
+var PlanEditIssueCode;
+(function (PlanEditIssueCode) {
+    PlanEditIssueCode["Shape"] = "shape";
+    PlanEditIssueCode["UnknownKey"] = "unknown-key";
+    PlanEditIssueCode["Duplicate"] = "duplicate";
+    PlanEditIssueCode["UnknownOp"] = "unknown-op";
+    PlanEditIssueCode["UnknownPage"] = "unknown-page";
+    PlanEditIssueCode["UnknownSection"] = "unknown-section";
+    PlanEditIssueCode["UnknownPattern"] = "unknown-pattern";
+    PlanEditIssueCode["UnknownSlot"] = "unknown-slot";
+    PlanEditIssueCode["UnknownContentType"] = "unknown-content-type";
+    PlanEditIssueCode["UnknownDataSource"] = "unknown-data-source";
+    /** The home page stays (a plan has exactly one). */
+    PlanEditIssueCode["HomePage"] = "home-page";
+    /** A template page (one item per route) and a plain page cannot be merged. */
+    PlanEditIssueCode["MergeTemplate"] = "merge-template";
+})(PlanEditIssueCode || (PlanEditIssueCode = {}));
+class Collector extends PathIssueCollector {
+    constructor() {
+        super('plan edit', { shape: PlanEditIssueCode.Shape, unknownKey: PlanEditIssueCode.UnknownKey, duplicate: PlanEditIssueCode.Duplicate });
+    }
+}
+const OPS = Object.values(PlanEditOp);
+/** A page's own header section (`page-header.simple`) — what a merge leaves behind with the page it named. */
+const PAGE_HEADER_FAMILY = 'header';
+const clone = (v) => JSON.parse(JSON.stringify(v));
+const clamp = (n, max) => Math.max(0, Math.min(Math.trunc(n), max));
+/** The edits' structure: a known op, its keys (`PLAN_EDIT_SHAPE`), integers where an index is. Never repairs. */
+function validatePlanEdits(edits) {
+    const c = new Collector();
+    if (!Array.isArray(edits)) {
+        c.add(PlanEditIssueCode.Shape, 'edits', 'must be an array');
+        return { valid: false, issues: c.issues };
+    }
+    edits.forEach((raw, i) => {
+        const path = `edits[${i}]`;
+        if (!isPlainObject(raw))
+            return c.add(PlanEditIssueCode.Shape, path, 'must be an object');
+        const op = raw['op'];
+        if (typeof op !== 'string' || !OPS.includes(op))
+            return c.add(PlanEditIssueCode.UnknownOp, `${path}.op`, `must be one of ${OPS.join(', ')}`);
+        const entry = PLAN_EDIT_SHAPE[op];
+        c.keys(raw, shapeKeys(entry), path);
+        for (const [key, text] of Object.entries(entry)) {
+            const optional = key.endsWith('?');
+            const name = optional ? key.slice(0, -1) : key;
+            const v = raw[name];
+            if (v === undefined) {
+                if (!optional)
+                    c.add(PlanEditIssueCode.Shape, `${path}.${name}`, 'is required');
+                continue;
+            }
+            if (text.startsWith('string | string[]')) {
+                if (typeof v !== 'string' && !(Array.isArray(v) && v.every(x => typeof x === 'string')))
+                    c.add(PlanEditIssueCode.Shape, `${path}.${name}`, 'must be a string or a list of strings');
+            }
+            else if (text.startsWith('string') && !isNonEmptyString(v))
+                c.add(PlanEditIssueCode.Shape, `${path}.${name}`, 'must be a non-empty string');
+            if (text.startsWith('integer') && !Number.isInteger(v))
+                c.add(PlanEditIssueCode.Shape, `${path}.${name}`, 'must be a whole number');
+            if (['page', 'section', 'contentType', 'field'].includes(text.split(' ')[0]) && !isPlainObject(v))
+                c.add(PlanEditIssueCode.Shape, `${path}.${name}`, 'must be an object');
+            if (text.startsWith('dataSource[]') && !Array.isArray(v))
+                c.add(PlanEditIssueCode.Shape, `${path}.${name}`, 'must be an array');
+        }
+    });
+    return { valid: c.issues.length === 0, issues: c.issues };
+}
+/** The aliases a page reads (its route source and its sections' bindings). */
+function aliasesOf(pages) {
+    const out = new Set();
+    for (const page of pages) {
+        if (page.routeSource)
+            out.add(page.routeSource);
+        for (const s of page.sections)
+            if (s.binding)
+                out.add(s.binding);
+    }
+    return out;
+}
+/** A relative source (`project.next`'s) is read while its subject is, and keeps the list it walks. */
+function withDependencies(aliases, sources) {
+    const out = new Set(aliases);
+    for (const s of sources) {
+        if (s.type === PlanDataSourceType.Relative && aliases.has(s.of)) {
+            out.add(s.alias);
+            out.add(s.within);
+        }
+    }
+    return out;
+}
+const pageIndex = (d, key) => d.pages.findIndex(p => p.key === key);
+function findPage(d, key, c, path) {
+    const at = pageIndex(d, key);
+    if (at < 0)
+        c.add(PlanEditIssueCode.UnknownPage, path, `no page "${String(key)}" in the plan (${d.pages.map(p => p.key).join(', ')})`);
+    return at;
+}
+function findSection(d, pageAt, index, c, path) {
+    const ok = Number.isInteger(index) && index >= 0 && index < d.pages[pageAt].sections.length;
+    if (!ok)
+        c.add(PlanEditIssueCode.UnknownSection, path, `page "${d.pages[pageAt].key}" has sections 0–${d.pages[pageAt].sections.length - 1}`);
+    return ok;
+}
+const setSections = (d, at, sections) => { d.pages[at] = { ...d.pages[at], sections }; };
+/** 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) };
+        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`);
+        if (after < 0 && e.after !== undefined)
+            return;
+        d.pages.splice(after + 1, 0, page);
+        changed.push({ kind: PlanChangeKind.Page, action: PlanChangeAction.Added, page: page.key, name: page.name });
+    },
+    [PlanEditOp.RemovePage]: (d, e, c, path, changed) => {
+        const at = findPage(d, e.page, c, `${path}.page`);
+        if (at < 0)
+            return;
+        if (d.pages[at].isHome)
+            return c.add(PlanEditIssueCode.HomePage, `${path}.page`, 'the home page stays — rename or change it instead');
+        const [gone] = d.pages.splice(at, 1);
+        changed.push({ kind: PlanChangeKind.Page, action: PlanChangeAction.Removed, page: gone.key, name: gone.name });
+    },
+    [PlanEditOp.RenamePage]: (d, e, c, path, changed) => {
+        const at = findPage(d, e.page, c, `${path}.page`);
+        if (at < 0)
+            return;
+        d.pages[at] = { ...d.pages[at], ...(e.name !== undefined ? { name: e.name } : {}), ...(e.route !== undefined ? { route: e.route } : {}) };
+        changed.push({ kind: PlanChangeKind.Page, action: PlanChangeAction.Changed, page: d.pages[at].key, name: d.pages[at].name });
+    },
+    [PlanEditOp.MergePages]: (d, e, c, path, changed) => {
+        const into = findPage(d, e.into, c, `${path}.into`);
+        const from = findPage(d, e.from, c, `${path}.from`);
+        if (into < 0 || from < 0)
+            return;
+        if (into === from)
+            return c.add(PlanEditIssueCode.Duplicate, `${path}.from`, 'a page is merged into another page');
+        const a = d.pages[into];
+        const b = d.pages[from];
+        if (!!a.template !== !!b.template)
+            return c.add(PlanEditIssueCode.MergeTemplate, `${path}.from`, 'a page per item and a plain page cannot be merged');
+        if (b.isHome)
+            return c.add(PlanEditIssueCode.HomePage, `${path}.from`, 'the home page stays — merge the other page into it');
+        const moved = b.sections.filter((s, i) => !(i === 0 && patternById(s.pattern)?.family === PAGE_HEADER_FAMILY));
+        setSections(d, into, [...a.sections, ...moved]);
+        moved.forEach((_, k) => changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Added, page: a.key, index: a.sections.length + k }));
+        d.pages.splice(from, 1);
+        changed.push({ kind: PlanChangeKind.Page, action: PlanChangeAction.Changed, page: a.key, name: a.name });
+        changed.push({ kind: PlanChangeKind.Page, action: PlanChangeAction.Removed, page: b.key, name: b.name });
+    },
+    [PlanEditOp.MovePage]: (d, e, c, path, changed) => {
+        const at = findPage(d, e.page, c, `${path}.page`);
+        if (at < 0)
+            return;
+        const [page] = d.pages.splice(at, 1);
+        d.pages.splice(clamp(e.to, d.pages.length), 0, page);
+        changed.push({ kind: PlanChangeKind.Page, action: PlanChangeAction.Moved, page: page.key, name: page.name });
+    },
+    [PlanEditOp.AddSection]: (d, e, c, path, changed) => {
+        const at = findPage(d, e.page, c, `${path}.page`);
+        if (at < 0)
+            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));
+        setSections(d, at, sections);
+        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`);
+        if (at < 0 || !findSection(d, at, e.index, c, `${path}.index`))
+            return;
+        setSections(d, at, d.pages[at].sections.filter((_, i) => i !== e.index));
+        changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Removed, page: d.pages[at].key, index: e.index });
+    },
+    [PlanEditOp.MoveSection]: (d, e, c, path, changed) => {
+        const at = findPage(d, e.page, c, `${path}.page`);
+        if (at < 0 || !findSection(d, at, e.from, c, `${path}.from`))
+            return;
+        const sections = [...d.pages[at].sections];
+        const [section] = sections.splice(e.from, 1);
+        const to = clamp(e.to, sections.length);
+        sections.splice(to, 0, section);
+        setSections(d, at, sections);
+        changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Moved, page: d.pages[at].key, index: to });
+    },
+    [PlanEditOp.SwapPattern]: (d, e, c, path, changed) => {
+        const at = findPage(d, e.page, c, `${path}.page`);
+        if (at < 0 || !findSection(d, at, e.index, c, `${path}.index`))
+            return;
+        const next = patternById(e.pattern);
+        if (!next || next.global)
+            return c.add(PlanEditIssueCode.UnknownPattern, `${path}.pattern`, `no section pattern "${String(e.pattern)}"`);
+        const old = d.pages[at].sections[e.index];
+        const slots = Object.fromEntries(Object.entries(old.slots ?? {}).filter(([slot]) => patternSlots(next).includes(slot)));
+        const without = (old.without ?? []).filter(w => patternOptionalParts(next).includes(w));
+        const section = {
+            pattern: e.pattern,
+            ...(Object.keys(slots).length ? { slots } : {}),
+            ...(old.binding && patternTakesBinding(next) ? { binding: old.binding } : {}),
+            ...(without.length ? { without } : {}),
+        };
+        setSections(d, at, d.pages[at].sections.map((s, i) => (i === e.index ? section : s)));
+        changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Changed, page: d.pages[at].key, index: e.index });
+    },
+    [PlanEditOp.SetSlot]: (d, e, c, path, changed) => {
+        const at = findPage(d, e.page, c, `${path}.page`);
+        if (at < 0 || !findSection(d, at, e.index, c, `${path}.index`))
+            return;
+        const section = d.pages[at].sections[e.index];
+        const declared = patternSlots(patternById(section.pattern));
+        if (!declared.includes(e.slot))
+            return c.add(PlanEditIssueCode.UnknownSlot, `${path}.slot`, `"${section.pattern}" has no slot "${e.slot}" (${declared.join(', ') || 'none'})`);
+        setSections(d, at, d.pages[at].sections.map((s, i) => (i === e.index ? { ...s, slots: { ...(s.slots ?? {}), [e.slot]: e.text } } : s)));
+        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);
+        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);
+        changed.push({ kind: PlanChangeKind.ContentType, action: PlanChangeAction.Added, name: type.name });
+        for (const [k, source] of (e.dataSources ?? []).entries()) {
+            if (d.dataSources.some(s => s.alias === source.alias)) {
+                c.add(PlanEditIssueCode.Duplicate, `${path}.dataSources[${k}].alias`, `data source "${source.alias}" is already in the plan`);
+                continue;
+            }
+            d.dataSources.push(source);
+            changed.push({ kind: PlanChangeKind.DataSource, action: PlanChangeAction.Added, name: source.alias });
+        }
+    },
+    [PlanEditOp.AddField]: (d, e, c, path, changed) => {
+        const at = d.contentTypes.findIndex(t => t.name === e.contentType);
+        if (at < 0)
+            return c.add(PlanEditIssueCode.UnknownContentType, `${path}.contentType`, `no content type "${String(e.contentType)}" in the plan`);
+        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;
+        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}` });
+    },
+    [PlanEditOp.SetSectionData]: (d, e, c, path, changed) => {
+        const at = findPage(d, e.page, c, `${path}.page`);
+        if (at < 0 || !findSection(d, at, e.index, c, `${path}.index`))
+            return;
+        const source = d.dataSources.find(s => s.alias === e.binding);
+        if (!source || source.type !== PlanDataSourceType.Cms || source.mode !== PlanDataSourceMode.Query) {
+            return c.add(PlanEditIssueCode.UnknownDataSource, `${path}.binding`, `no list source "${String(e.binding)}" in the plan`);
+        }
+        setSections(d, at, d.pages[at].sections.map((s, i) => (i === e.index ? { ...s, binding: e.binding } : s)));
+        changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Changed, page: d.pages[at].key, index: e.index });
+    },
+};
+/**
+ * Apply a set of edits to a plan — all of them, or none (any issue refuses the set and returns the plan unchanged). The
+ * sources only removed pages and sections read are dropped with them; sources nothing read before are kept.
+ * The result still has to pass `validateSitePlan`.
+ */
+function applyPlanEdits(plan, edits) {
+    const structure = validatePlanEdits(edits);
+    if (!structure.valid)
+        return { plan, changed: [], issues: structure.issues };
+    const draft = { pages: clone([...plan.pages]), contentTypes: clone([...plan.contentTypes]), dataSources: clone([...plan.dataSources]) };
+    const c = new Collector();
+    const changed = [];
+    edits.forEach((edit, i) => APPLY[edit.op](draft, edit, c, `edits[${i}]`, changed));
+    if (c.issues.length)
+        return { plan, changed: [], issues: c.issues };
+    const before = withDependencies(aliasesOf(plan.pages), plan.dataSources);
+    const after = withDependencies(aliasesOf(draft.pages), draft.dataSources);
+    const added = new Set(changed.filter(ch => ch.kind === PlanChangeKind.DataSource).map(ch => ch.name));
+    const dataSources = draft.dataSources.filter(s => after.has(s.alias) || !before.has(s.alias) || added.has(s.alias));
+    for (const s of draft.dataSources)
+        if (!dataSources.includes(s))
+            changed.push({ kind: PlanChangeKind.DataSource, action: PlanChangeAction.Removed, name: s.alias });
+    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';
+/** 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 ''",
+};
+const one = (value) => jsonOneOf([value]);
+/** The schema of each op's value types (what `PLAN_EDIT_SHAPE` names). */
+function opSchema(op) {
+    const entry = PLAN_EDIT_SHAPE[op];
+    const valueOf = (key) => {
+        const text = entry[key] ?? entry[`${key}?`];
+        if (key === 'op')
+            return one(op);
+        if (key === 'pattern')
+            return jsonOneOf(sectionPatternIds());
+        const head = text.split(' ')[0];
+        const table = {
+            page: pageJsonSchema, section: sectionJsonSchema, contentType: contentTypeJsonSchema, field: fieldJsonSchema,
+            'dataSource[]': () => jsonListOf(dataSourceJsonSchema()), integer: jsonInteger, string: jsonText,
+        };
+        if (text.startsWith('string | string[]'))
+            return jsonAnyOf([jsonText(), jsonListOf(jsonText())]);
+        return (table[head] ?? jsonText)();
+    };
+    return jsonShapedObject(entry, Object.fromEntries(shapeKeys(entry).map(key => [key, valueOf(key)])), op);
+}
+/** 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');
+}
+/** A model's answer → edits (sections and content types off the wire); 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 };
+}
+
+/**
+ * The plan stage's word checks (AI plan §3d / §3h, M1-3): every text a model WROTE into a plan — the tagline, page
+ * names, section slots, content-type labels, sample values — scanned for the words the owner and their kind of
+ * business must not use (`avoidWords`, the analysis's + the type's `words`), and for a fact the owner never gave
+ * (an email, phone number, price or opening time that is not one of the owner's own facts). A finding is a refusal
+ * with a path — the model rewrites; nothing here repairs a word. Pure.
+ */
+var PlanWordIssueCode;
+(function (PlanWordIssueCode) {
+    /** A word the owner (or their kind of business) must not use. */
+    PlanWordIssueCode["AvoidWord"] = "avoid-word";
+    /** Something that looks like a fact — an email, phone, price or time — that is not one of the owner's facts. */
+    PlanWordIssueCode["InventedFact"] = "invented-fact";
+    /** `business.facts` holds a fact the owner did not give, or not in the owner's words. */
+    PlanWordIssueCode["FactNotTheOwners"] = "fact-not-the-owners";
+})(PlanWordIssueCode || (PlanWordIssueCode = {}));
+/** Every text in a plan a model writes (never ids, routes, field names or pattern ids). */
+function writtenTexts(plan) {
+    const out = [];
+    const add = (path, text) => { if (typeof text === 'string' && text.trim())
+        out.push({ path, text }); };
+    add('business.tagline', plan.business?.tagline);
+    plan.pages?.forEach((page, p) => {
+        add(`pages[${p}].name`, page.name);
+        page.sections?.forEach((section, s) => {
+            for (const [slot, text] of Object.entries(section.slots ?? {}))
+                add(`pages[${p}].sections[${s}].slots.${slot}`, text);
+        });
+    });
+    plan.contentTypes?.forEach((type, t) => {
+        add(`contentTypes[${t}].label`, type.label);
+        for (const [field, value] of Object.entries(type.seed ?? {})) {
+            const values = Array.isArray(value) ? value : [value];
+            values.forEach((v, k) => add(`contentTypes[${t}].seed.${field}${Array.isArray(value) ? `[${k}]` : ''}`, v));
+        }
+    });
+    return out;
+}
+const HEBREW = /[֐-׿]/;
+/** Hebrew joins up to two one-letter words (and, the, in, to, from, that, as) to the next: "והטוב" holds "טוב". */
+const HEBREW_PREFIXES = '[והבלמשכ]{0,2}';
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const normalise = (s) => s.normalize('NFKC').toLowerCase();
+/** A word (or phrase) as a whole-word pattern; Hebrew allows its one-letter prefixes. */
+function wordPattern(word) {
+    const w = escape(normalise(word.trim())).replace(/\s+/g, '\\s+');
+    const prefix = HEBREW.test(word) ? HEBREW_PREFIXES : '';
+    return new RegExp(`(?<![\\p{L}\\p{N}])${prefix}${w}(?![\\p{L}\\p{N}])`, 'u');
+}
+/** What a fact looks like when a model writes one — each judged against the owner's facts. */
+const FACT_SHAPES = [
+    { kind: 'email', pattern: /[\p{L}\p{N}._%+-]+@[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)+/gu, key: m => m.toLowerCase() },
+    { kind: 'phone', pattern: /\+?\d[\d\s().-]{6,}\d/g, key: m => m.replace(/\D/g, '') },
+    { kind: 'price', pattern: /(?:[$€£₪]\s?\d[\d,.]*|\d[\d,.]*\s?(?:[$€£₪]|ש"ח|NIS|USD|EUR|GBP))/gu, key: m => m.replace(/[^\d]/g, '') },
+    { kind: 'time', pattern: /(?<!\d)\d{1,2}[:.]\d{2}(?!\d)/g, key: m => m.replace(/\D/g, '') },
+];
+const MIN_PHONE_DIGITS = 8;
+/** "2019 – 2024" is two years, not a phone number. */
+const YEAR_RANGE = /^\s*\d{4}\s*[-–]\s*\d{4}\s*$/;
+function ownedKeys(facts) {
+    const keys = new Set();
+    for (const value of Object.values(facts)) {
+        if (typeof value !== 'string')
+            continue;
+        for (const shape of FACT_SHAPES)
+            for (const m of value.match(shape.pattern) ?? [])
+                keys.add(`${shape.kind}:${shape.key(m)}`);
+    }
+    return keys;
+}
+/** The words to avoid and the facts never given, in every written text of the plan. */
+function planWordIssues(plan, ctx) {
+    const issues = [];
+    const avoid = [...new Set(ctx.avoidWords.map(w => w.trim()).filter(Boolean))].map(w => ({ word: w, pattern: wordPattern(w) }));
+    const owned = ownedKeys(ctx.facts);
+    for (const { path, text } of writtenTexts(plan)) {
+        const words = normalise(text);
+        for (const a of avoid)
+            if (a.pattern.test(words))
+                issues.push({ code: PlanWordIssueCode.AvoidWord, path, message: `uses "${a.word}" — a word this site must not use` });
+        for (const shape of FACT_SHAPES) {
+            for (const m of text.match(shape.pattern) ?? []) {
+                const key = shape.key(m);
+                if (shape.kind === 'phone' && (key.length < MIN_PHONE_DIGITS || YEAR_RANGE.test(m)))
+                    continue;
+                if (!owned.has(`${shape.kind}:${key}`))
+                    issues.push({ code: PlanWordIssueCode.InventedFact, path, message: `"${m.trim()}" looks like a ${shape.kind} the owner never gave — leave it out` });
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(plan.business?.facts ?? {})) {
+        const own = ctx.facts[key];
+        if (!FACT_KEYS.includes(key))
+            continue;
+        if (typeof own !== 'string' || normalise(own).trim() !== normalise(String(value)).trim()) {
+            issues.push({ code: PlanWordIssueCode.FactNotTheOwners, path: `business.facts.${key}`, message: own ? `must be the owner's own words: "${own}"` : 'the owner did not give it — leave it out (it becomes a placeholder)' });
+        }
+    }
+    return issues;
+}
+
 /**
  * @vectoriox/iox-ui/generation-core — the shared, FRAMEWORK-FREE site-plan core (design-system plan
  * §6b, W1): the Site Plan shape + its validator, the pattern library and the Studio template (both
@@ -10138,5 +10943,5 @@ var AiCallStatus;
  * Generated bundle index. Do not edit.
  */
 
-export { ACTIVE_BUILD_STATUSES, AI_REFUSAL_NEXT, AI_REFUSAL_STATUS, AI_STEPS, AI_STEP_NEEDS, AI_STEP_TYPICAL_TOKENS, AiCallStatus, AiCapability, AiGenerationStage, AiKeyMode, AiNextKind, AiProviderId, AiRefusalCode, AiStep, BAR_ITEMS_MAX, BAR_ITEMS_MIN, BASELINE_ROLES, BUILD_STEPS, BaselineRole, BindScope, BuildNoticeCode, BuildStep, CREDITS_PER_USD, CardBindTarget, ComposeError, ComposeIssueCode, ContentTypeAction, CreatedKind, DANGLING_LINK_CODES, DEFAULT_PHONE_MENU_BREAKPOINT, ENTRANCE_EASING, ENTRANCE_ORIGIN_LOOK, ENTRANCE_TRIGGER, EntrancePart, FACT_KEYS, FINAL_GENERATION_STAGES, GlobalSlot, KeptReason, NAV_PART_LABELS, NAV_SHAPE_COPY, NEUTRAL_STYLE_PROPS, NODE_BASELINES, NO_TOKENS, NavPagesSource, NavRole, NavShape, NavShapeError, PRICING_PATTERN, PUBLISH_BLOCKING_PLACEHOLDERS, PageDataKind, PathIssueCollector, PatternDirective, PatternGlobalPosition, PatternOpens, PatternPlaceholder, PatternRecipe, PhoneMenuBreakpoint, PlaceholderKind, PlanDataSourceMode, PlanDataSourceType, PreflightRefusalCode, RelativeOp, SAMPLE_IMAGE_REF, SITE_FACT_LABELS, SITE_HEADER_PATTERN, SITE_PATTERNS, SITE_PLAN_VERSION, SITE_TEMPLATES, SPEC_SITE_FACTS, SPEC_SITE_LIBRARY, SPEC_SITE_PATTERNS, SPEC_SITE_PLAN_SHAPE, SPEC_SITE_TEMPLATES, STUDIO_TEMPLATE, SiteBuildKind, SiteBuildStatus, SitePlanError, SitePlanIssueCode, SitePlanSourceKind, SiteTemplateError, SiteTemplateId, StepState, addBarItem, altSourceScopes, assertStyleSlots, assertValidSitePlan, barIconForRoute, blocksPublish, buildKeys, buildStepFacts, builtHomePageId, composeNavHeader, composeSection, composeSite, costUsd, createSerializedNode, creditsOfUsd, describePlanData, entranceAction, entranceInteraction, estimateStepCredits, failedBuildStep, findNavRoot, isActiveBuild, isNonEmptyString, isPlainObject, modelCanDo, moveBarItem, navPages, navShapeBreakpoint, navShapeOf, nextSourceOf, nodeBindPaths, parseSampleImageRef, pathAt, patternById, patternNeedsBinding, patternNodes, patternOptionalParts, patternScopes, patternSlots, patternTakesBinding, phoneMenuPages, planFromTemplate, planNavShape, releasedLayoutDefaults, removeBarItem, requiredShapeKeys, routeParams, sampleImageRef, sectionEntrances, setStyleProps, shapeKeys, siteNavPages, staggerDelay, validateSitePlan, walkSerialized };
+export { ACTIVE_BUILD_STATUSES, AI_REFUSAL_NEXT, AI_REFUSAL_STATUS, AI_STEPS, AI_STEP_LABELS, AI_STEP_NEEDS, AI_STEP_TYPICAL_TOKENS, AiCallStatus, AiCapability, AiGenerationStage, AiKeyMode, AiNextKind, AiProviderId, AiRefusalCode, AiStep, BAR_ITEMS_MAX, BAR_ITEMS_MIN, BASELINE_ROLES, BUILD_STEPS, BaselineRole, BindScope, BuildNoticeCode, BuildStep, CREDITS_PER_USD, CardBindTarget, ComposeError, ComposeIssueCode, ContentTypeAction, CreatedKind, DANGLING_LINK_CODES, DEFAULT_PHONE_MENU_BREAKPOINT, ENTRANCE_EASING, ENTRANCE_ORIGIN_LOOK, ENTRANCE_TRIGGER, EntrancePart, FACT_KEYS, FINAL_GENERATION_STAGES, GlobalSlot, JSON_SCHEMA_BANNED_KEYWORDS, JsonSchemaShapeError, KeptReason, NAV_PART_LABELS, NAV_SHAPE_COPY, NEUTRAL_STYLE_PROPS, NODE_BASELINES, NO_TOKENS, NavPagesSource, NavRole, NavShape, NavShapeError, 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, RelativeOp, SAMPLE_IMAGE_REF, SITE_FACT_LABELS, SITE_HEADER_PATTERN, SITE_PATTERNS, SITE_PLAN_SCHEMA_NAME, SITE_PLAN_VERSION, SITE_TEMPLATES, SPEC_SITE_FACTS, SPEC_SITE_LIBRARY, SPEC_SITE_PATTERNS, SPEC_SITE_PLAN_SHAPE, SPEC_SITE_TEMPLATES, STUDIO_TEMPLATE, SiteBuildKind, SiteBuildStatus, SitePlanError, SitePlanIssueCode, SitePlanSourceKind, SitePlanWireKey, SiteTemplateError, SiteTemplateId, StepState, addBarItem, altSourceScopes, applyPlanEdits, assertStyleSlots, assertValidSitePlan, barIconForRoute, blocksPublish, buildKeys, buildStepFacts, builtHomePageId, composeNavHeader, composeSection, composeSite, contentTypeFromWire, contentTypeJsonSchema, costUsd, createSerializedNode, creditsOfUsd, dataSourceJsonSchema, describePlanData, describeShapeKey, entranceAction, entranceInteraction, estimateStepCredits, failedBuildStep, fieldJsonSchema, findNavRoot, isActiveBuild, isNonEmptyString, isPlainObject, jsonAnyOf, jsonBoolean, jsonClosedObject, jsonInteger, jsonListOf, jsonOneOf, jsonSchemaKeywords, jsonSchemaObjects, jsonShapedObject, jsonText, modelCanDo, moveBarItem, navPages, navShapeBreakpoint, navShapeOf, nextSourceOf, nodeBindPaths, pageJsonSchema, parseSampleImageRef, pathAt, patternById, patternNeedsBinding, patternNodes, patternOptionalParts, patternScopes, patternSlots, patternTakesBinding, phoneMenuPages, planEditsFromWire, planEditsJsonSchema, planFromTemplate, planNavShape, planWordIssues, releasedLayoutDefaults, removeBarItem, requiredShapeKeys, routeParams, sampleImageRef, sectionEntrances, sectionFromWire, sectionJsonSchema, sectionPatternIds, setStyleProps, shapeKeys, siteNavPages, sitePlanFromWire, sitePlanJsonSchema, sitePlanToWire, staggerDelay, validatePlanEdits, validateSitePlan, walkSerialized, wordPattern, writtenTexts };
 //# sourceMappingURL=vectoriox-iox-ui-generation-core.mjs.map