@vectoriox/iox-ui 5.60.0 → 5.62.0

package/src/generation-core/plan-edits.ts

@@ -3,9 +3,10 @@ import {
 } from './json-schema';
 import { patternById, patternOptionalParts, patternSlots, patternTakesBinding } from './patterns';
 import {
-    contentTypeFromWire, contentTypeJsonSchema, dataSourceJsonSchema, fieldJsonSchema, pageJsonSchema, sectionFromWire, sectionJsonSchema,
-    sectionPatternIds,
-} from './site-plan-schema';
+    contentTypeToWire, dataSourceToWire, expandWireContentType, expandWireDataSource, expandWireField, expandWirePage, expandWireSection, fieldToWire,
+    pageToWire, PLAN_PARTS, PlanPart, PlanWireShapeError, sectionPatternIds, sectionToWire, wireContentTypeJsonSchema, wireDataSourceJsonSchema,
+    wireFieldJsonSchema, WireOptions, wirePageJsonSchema, wireSectionJsonSchema,
+} from './plan-wire';
 import {
     ContentFieldPlan, ContentTypePlan, DataSourcePlan, PagePlan, PageSectionPlan, PlanDataSourceMode, PlanDataSourceType, SitePlan,
 } from './site-plan.model';
@@ -67,10 +68,35 @@ export const PLAN_EDIT_SHAPE: Readonly<Record<`${PlanEditOp}`, ShapeEntry>> = {
     [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.
+ */
+export const PLAN_EDIT_OP_PART: Readonly<Record<`${PlanEditOp}`, PlanPart>> = {
+    [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. */
+export function planEditOps(part: PlanPart): PlanEditOp[] {
+    return Object.values(PlanEditOp).filter(op => PLAN_EDIT_OP_PART[op] === part);
+}
+
 export enum PlanChangeKind {
     Page = 'page',
     Section = 'section',
@@ -206,10 +232,14 @@ function findSection(d: Draft, pageAt: number, index: unknown, c: Collector, pat
 
 const setSections = (d: Draft, at: number, sections: PageSectionPlan[]) => { 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: ReadonlyArray<PlanChange>, kind: PlanChangeKind, at: { page?: string; name?: string }) =>
+    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: Readonly<Record<`${PlanEditOp}`, Apply>> = {
     [PlanEditOp.AddPage]: (d, e, c, path, changed) => {
-        const page = { ...(e.page as PagePlan), sections: (e.page.sections ?? []).map(sectionFromWire) } as PagePlan;
+        const page = e.page as PagePlan;
         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;
@@ -257,9 +287,9 @@ const APPLY: Readonly<Record<`${PlanEditOp}`, Apply>> = {
         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) as PageSectionPlan);
+        sections.splice(index, 0, e.section as PageSectionPlan);
         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`);
@@ -304,7 +334,7 @@ const APPLY: Readonly<Record<`${PlanEditOp}`, Apply>> = {
         changed.push({ kind: PlanChangeKind.Section, action: PlanChangeAction.Changed, page: d.pages[at].key, index: e.index });
     },
     [PlanEditOp.AddContentType]: (d, e, c, path, changed) => {
-        const type = contentTypeFromWire(e.contentType) as ContentTypePlan;
+        const type = e.contentType as ContentTypePlan;
         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 });
@@ -319,9 +349,9 @@ const APPLY: Readonly<Record<`${PlanEditOp}`, Apply>> = {
         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;
+        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`);
@@ -360,7 +390,11 @@ export function applyPlanEdits(plan: SitePlan, edits: ReadonlyArray<PlanEdit>):
 
 // ── The format a model writes edits in ─────────────────────────────────────────────────────────────────
 
-export const PLAN_EDITS_SCHEMA_NAME = 'plan_edits';
+/** Each part's answer format name. */
+export const PLAN_EDITS_PART_SCHEMA_NAMES: Readonly<Record<PlanPart, string>> = {
+    [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). */
 export enum PlanEditsOutcome {
@@ -375,54 +409,219 @@ export interface PlanEditsAnswer {
     reason: string;
 }
 
-/** The answer's own keys, explained. */
-export const PLAN_EDITS_ANSWER_SHAPE: ShapeEntry = {
-    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.
+ */
+export const PLAN_EDITS_ANSWER_SHAPES: Readonly<Record<PlanPart, ShapeEntry>> = {
+    [PlanPart.Structure]: {
+        outcome: "'edits' | 'cannot' — cannot: no operation of either part (below) can do what the sentence asks",
+        edits: 'edit[] — the content types and fields the sentence adds, in order; empty when it adds none, or cannot',
+        reason: "string — when cannot, ONE short line for the owner in their language (what to do instead); else ''",
+    },
+    [PlanPart.Pages]: {
+        edits: 'edit[] — the page and section edits, in order, made after the structure edits (already applied); empty when none',
+    },
 };
 
-const one = (value: string): JsonSchema => jsonOneOf([value]);
-
-/** The schema of each op's value types (what `PLAN_EDIT_SHAPE` names). */
-function opSchema(op: `${PlanEditOp}`): JsonSchema {
-    const entry = PLAN_EDIT_SHAPE[op];
-    const valueOf = (key: string): JsonSchema => {
-        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: Record<string, () => JsonSchema> = {
-            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)();
+/**
+ * ONE flat edit per part on the wire (vectoriox/iox-cms#45, #47): an object whose keys are ALL required — the 13 ops as
+ * `anyOf` branches came to 395 optional parameters against the Claude API's 24, and one flat edit for all of them to 95
+ * properties, a grammar Claude refuses (≤ 60). `op` says which keys are read (`PLAN_EDIT_WIRE_KEYS`, from
+ * `PLAN_EDIT_SHAPE`); every other key holds its none. A new page, section, content type or field travels as a list of
+ * exactly one, in the plan wire's format — and an added page or content type travels WITHOUT its children: each of its
+ * sections is an `addSection` after it, each of its fields an `addField` (a new type's samples ride on its `seed`).
+ */
+interface EditWireKey {
+    text: string;
+    none: unknown;
+    schema(): JsonSchema;
+    /** The wire value → the edit's (default: as written). */
+    expand?(value: unknown): unknown;
+    /** The edit's value → the wire's (default: as is). */
+    toWire?(value: any): unknown;
+}
+
+const NO_INDEX = -1;
+/** A new page or content type on the wire: its children are edits of their own. */
+const CHILDLESS: WireOptions = { children: false };
+
+/** A list holding exactly one object: none → absent, one → it (expanded), more → the list (the gate refuses it). */
+const oneOf = (schema: () => JsonSchema, expand: (v: unknown) => unknown, toWire: (v: any) => unknown, what: string): EditWireKey => ({
+    text: `${what}[] — exactly one when the op takes it`,
+    none: [],
+    schema: () => jsonListOf(schema()),
+    expand: v => (Array.isArray(v) ? (v.length === 0 ? undefined : v.length === 1 ? expand(v[0]) : v) : v),
+    toWire: v => [toWire(v)],
+});
+
+const textKey = (text: string): EditWireKey => ({ text: `string — ${text}`, none: '', schema: jsonText });
+const indexKey = (text: string): EditWireKey => ({ text: `integer — ${text}`, none: NO_INDEX, schema: jsonInteger });
+
+const EDIT_WIRE: Readonly<Record<string, EditWireKey>> = {
+    page: textKey('a page key'),
+    name: textKey('renamePage: its new name (the menu label)'),
+    route: textKey('renamePage: its new route'),
+    after: textKey('addPage: the key of the page it follows in the menu'),
+    into: textKey('mergePages: the page that stays'),
+    from: textKey('mergePages: the page whose sections move into it, then removed'),
+    index: indexKey('the section, 0-based on its page (addSection: the place the new one goes)'),
+    to: indexKey('movePage / moveSection: the new 0-based place'),
+    pattern: { text: 'string — swapPattern: the section pattern it becomes', none: '', schema: () => jsonOneOf(['', ...sectionPatternIds()]) },
+    slot: textKey("setSlot: one of the pattern's slots"),
+    text: textKey("setSlot: the words, in the owner's language and voice"),
+    binding: textKey('setSectionData: the list source the section repeats'),
+    contentType: textKey('addField: a content type of the plan'),
+    newPage: {
+        ...oneOf(() => wirePageJsonSchema(CHILDLESS), v => expandWirePage(v, CHILDLESS), p => pageToWire(p, CHILDLESS), 'page'),
+        text: 'page[] — exactly one when the op takes it, WITHOUT sections: each is an addSection after it',
+    },
+    newSection: oneOf(wireSectionJsonSchema, expandWireSection, sectionToWire, 'section'),
+    newContentType: {
+        ...oneOf(() => wireContentTypeJsonSchema(CHILDLESS), v => expandWireContentType(v, CHILDLESS), t => contentTypeToWire(t, CHILDLESS), 'contentType'),
+        text: "contentType[] — exactly one when the op takes it, WITHOUT fields: each is an addField after it (the samples' values stay in its seed)",
+    },
+    dataSources: {
+        text: 'dataSource[] — addContentType: the list / single sources its pages read', none: [],
+        schema: () => jsonListOf(wireDataSourceJsonSchema()),
+        expand: v => (Array.isArray(v) ? v.map(expandWireDataSource) : v),
+        toWire: (v: DataSourcePlan[]) => v.map(dataSourceToWire),
+    },
+    newField: oneOf(wireFieldJsonSchema, expandWireField, fieldToWire, 'field'),
+    sample: { text: "string | string[] — addField: the samples' value for it", none: '', schema: () => jsonAnyOf([jsonText(), jsonListOf(jsonText())]) },
+};
+
+/** Each op's keys (`PLAN_EDIT_SHAPE`) → the wire key that carries it. */
+export const PLAN_EDIT_WIRE_KEYS: Readonly<Record<`${PlanEditOp}`, Readonly<Record<string, string>>>> = {
+    [PlanEditOp.AddPage]: { page: 'newPage', after: 'after' },
+    [PlanEditOp.RemovePage]: { page: 'page' },
+    [PlanEditOp.RenamePage]: { page: 'page', name: 'name', route: 'route' },
+    [PlanEditOp.MergePages]: { into: 'into', from: 'from' },
+    [PlanEditOp.MovePage]: { page: 'page', to: 'to' },
+    [PlanEditOp.AddSection]: { page: 'page', section: 'newSection', at: 'index' },
+    [PlanEditOp.RemoveSection]: { page: 'page', index: 'index' },
+    [PlanEditOp.MoveSection]: { page: 'page', from: 'index', to: 'to' },
+    [PlanEditOp.SwapPattern]: { page: 'page', index: 'index', pattern: 'pattern' },
+    [PlanEditOp.SetSlot]: { page: 'page', index: 'index', slot: 'slot', text: 'text' },
+    [PlanEditOp.AddContentType]: { contentType: 'newContentType', dataSources: 'dataSources' },
+    [PlanEditOp.AddField]: { contentType: 'contentType', field: 'newField', sample: 'sample' },
+    [PlanEditOp.SetSectionData]: { page: 'page', index: 'index', binding: 'binding' },
+};
+
+/** The wire keys a part's edit carries: every key its ops read, in `EDIT_WIRE` order. */
+export function planEditWireKeys(part: PlanPart): string[] {
+    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: string, v: unknown) => {
+    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: unknown) => (Array.isArray(none) ? '[]' : typeof none === 'string' ? "''" : String(none));
+const opsText = (part: PlanPart) => planEditOps(part).map(op => `'${op}'`).join(' | ');
+
+/** A part's flat edit, as a shape table: every key required, each with its none. */
+export function planEditWireShape(part: PlanPart): ShapeEntry {
+    return {
+        op: `${opsText(part)} — which keys below are read`,
+        ...Object.fromEntries(planEditWireKeys(part).map(k => [k, `${EDIT_WIRE[k].text} — ${noneText(EDIT_WIRE[k].none)} when the op does not read it`])),
     };
-    return jsonShapedObject(entry, Object.fromEntries(shapeKeys(entry).map(key => [key, valueOf(key)])), op);
 }
 
-/** The format a sentence's answer is written in: the outcome, the edits (one `anyOf` branch per op), the reason. */
-export function planEditsJsonSchema(): JsonSchema {
-    return jsonShapedObject(PLAN_EDITS_ANSWER_SHAPE, {
-        outcome: jsonOneOf(Object.values(PlanEditsOutcome)),
-        edits: jsonListOf(jsonAnyOf(OPS.map(op => opSchema(op as PlanEditOp)))),
-        reason: jsonText(),
-    }, 'planEdits');
+/** Per op of a part, the wire keys it reads, in `PLAN_EDIT_SHAPE`'s words (`?` = may hold its none) — what the model reads. */
+export function planEditWireOps(part: PlanPart): Record<string, Record<string, string>> {
+    return Object.fromEntries(planEditOps(part).map(op => {
+        const entry = PLAN_EDIT_SHAPE[op];
+        const keys = PLAN_EDIT_WIRE_KEYS[op];
+        return [op, Object.fromEntries(Object.entries(keys).map(([planKey, wireKey]) => {
+            const optionalKey = `${planKey}?` in entry;
+            return [`${wireKey}${optionalKey ? '?' : ''}`, entry[optionalKey ? `${planKey}?` : planKey]];
+        }))];
+    }));
+}
+
+/** Op keys no wire key carries, or wire keys that do not exist — always empty (a spec and the builder hold it). */
+export function planEditWireGaps(): string[] {
+    const gaps: string[] = [];
+    for (const op of OPS) {
+        const keys = PLAN_EDIT_WIRE_KEYS[op as PlanEditOp] ?? {};
+        for (const planKey of shapeKeys(PLAN_EDIT_SHAPE[op as PlanEditOp])) {
+            if (planKey === 'op') continue;
+            if (!keys[planKey]) gaps.push(`${op}.${planKey}`);
+            else if (!EDIT_WIRE[keys[planKey]]) gaps.push(`${op}.${planKey} → ${keys[planKey]}`);
+        }
+        for (const planKey of Object.keys(keys)) if (!shapeKeys(PLAN_EDIT_SHAPE[op as PlanEditOp]).includes(planKey)) gaps.push(`${op}.${planKey} (not an op key)`);
+    }
+    return gaps;
+}
+
+const ANSWER_SCHEMAS: Readonly<Record<string, (part: PlanPart) => JsonSchema>> = {
+    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). */
+export function planEditsJsonSchema(part: PlanPart): JsonSchema {
+    const gaps = planEditWireGaps();
+    if (gaps.length) throw new PlanWireShapeError(`the plan edits wire does not carry ${gaps.join(', ')}`);
+    const shape = PLAN_EDITS_ANSWER_SHAPES[part];
+    return jsonShapedObject(shape, Object.fromEntries(shapeKeys(shape).map(k => [k, ANSWER_SCHEMAS[k](part)])), `planEdits ${part}`);
+}
+
+/** One flat edit → the op's edit: the keys it reads, a none left out where the op may go without it. Never repaired. */
+export function expandWireEdit(wire: unknown): PlanEdit | unknown {
+    if (!isPlainObject(wire)) return wire;
+    const keys = PLAN_EDIT_WIRE_KEYS[wire['op'] as PlanEditOp];
+    if (!keys) return wire;
+    const entry = PLAN_EDIT_SHAPE[wire['op'] as PlanEditOp];
+    const out: PlainObject = Object.fromEntries(Object.entries(wire).filter(([k]) => k === 'op' || !(k in EDIT_WIRE)));
+    for (const [planKey, wireKey] of Object.entries(keys)) {
+        const raw = wire[wireKey];
+        if (`${planKey}?` in entry && isEditWireNone(wireKey, raw)) continue;
+        const value = EDIT_WIRE[wireKey].expand ? EDIT_WIRE[wireKey].expand!(raw) : raw;
+        if (value !== undefined) out[planKey] = value;
+    }
+    return out;
+}
+
+/** An edit's own keys → its flat wire edit, in its part's keys. */
+function flatEdit(edit: PlanEdit): PlainObject {
+    const part = PLAN_EDIT_OP_PART[edit.op];
+    const out: PlainObject = { 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 as unknown as PlainObject)[planKey];
+        if (value === undefined) continue;
+        out[wireKey] = EDIT_WIRE[wireKey].toWire ? EDIT_WIRE[wireKey].toWire!(value) : value;
+    }
+    return out;
 }
 
-/** A model's answer → edits (sections and content types off the wire); never repaired. */
+/** The children an added page or content type travels without, as the edits that add them after it. */
+function childEdits(edit: PlanEdit): PlanEdit[] {
+    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). */
+export function planEditToWire(edit: PlanEdit): PlainObject[] {
+    return [flatEdit(edit), ...childEdits(edit).map(flatEdit)];
+}
+
+/** Edits → each part's flat wire edits, in order (what each part's answer would hold). */
+export function planEditsToWire(edits: ReadonlyArray<PlanEdit>): Record<PlanPart, PlainObject[]> {
+    const out = Object.fromEntries(PLAN_PARTS.map(part => [part, [] as PlainObject[]])) as Record<PlanPart, PlainObject[]>;
+    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. */
 export function planEditsFromWire(answer: unknown): PlanEditsAnswer | unknown {
     if (!isPlainObject(answer) || !Array.isArray(answer['edits'])) return answer;
-    const edits = (answer['edits'] as unknown[]).map(raw => {
-        if (!isPlainObject(raw)) return raw;
-        const e: PlainObject = { ...raw };
-        if (isPlainObject(e['page']) && Array.isArray((e['page'] as PlainObject)['sections'])) {
-            e['page'] = { ...(e['page'] as PlainObject), sections: ((e['page'] as PlainObject)['sections'] as unknown[]).map(sectionFromWire) };
-        }
-        if (isPlainObject(e['section'])) e['section'] = sectionFromWire(e['section']);
-        if (isPlainObject(e['contentType'])) e['contentType'] = contentTypeFromWire(e['contentType']);
-        return e;
-    });
-    return { ...answer, edits };
+    return { ...answer, edits: (answer['edits'] as unknown[]).map(expandWireEdit) };
 }