@vectoriox/iox-ui 5.59.1 → 5.61.0

package/generation-core/index.d.ts

@@ -5897,57 +5897,129 @@ declare enum AiCallStatus {
 }
 
 /**
- * The structured-output format a model writes a Site Plan in (AI plan §3d step 4, M1-3) — built from the SAME shape
- * table `validateSitePlan` reads (`SPEC_SITE_PLAN_SHAPE`) and the SAME pattern library, so the plan a model is told
- * about is the plan the gate refuses. ONE source: a key the table gains breaks this builder until it is written here.
+ * The plan WIRE (AI plan M1-3, vectoriox/iox-cms#45): what a model writes when it plans a site — a compact format inside
+ * the Claude API's structured-output limits (≤ 24 optional parameters and ≤ 16 unions per request; `strict-schema.ts`).
+ * The Site Plan itself (`SPEC_SITE_PLAN_SHAPE`) has 213 optional keys once every pattern is a branch, so the model never
+ * writes it: it writes this, and ONE pure `expandPlanWire` turns it into the Site Plan that `validateSitePlan` and the
+ * stage's gate judge exactly as before.
  *
- * 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).
+ * - **Every key required.** A plan key that may be absent is written with its stated "none" — `''`, `0`, `false`, `[]`.
+ * - **Closed lists as enums** (patterns, page types, needs, slots, parts, forms, entrances, header/footer), from the
+ *   contract — never per-pattern branches: the gate refuses a slot or a part the chosen pattern does not have, with its path.
+ * - **Maps as lists:** slots `[{ slot, text }]`, links `[{ slot, route }]`, seed values `[{ field, value }]`, roles fixed.
+ * - **One data source object** for both kinds; `type` says which keys are read (the other kind's hold their none).
+ * - **What the model does not decide is not on the wire** (`PLAN_WIRE_DERIVED`): the look (the owner's pick), the run,
+ *   the language (the reading's), the facts (the owner's own, verbatim), the version, the home page (the page at `/`).
+ *   So the format is the same for every studio and every run — one compiled grammar, cached by the provider.
+ *
+ * ONE source: every wire key names the plan keys it carries (`refs`) and is described in the plan table's own words, and
+ * every plan key is either carried or derived (`planWireGaps()`); a key the plan shape gains breaks the builder until it
+ * is placed. The expanders translate, never repair: a value the model got wrong stays wrong, for the gate to refuse.
  */
-declare const SITE_PLAN_SCHEMA_NAME = "site_plan";
-/** The wire keys of the two maps written as lists. */
-declare enum SitePlanWireKey {
-    SlotName = "slot",
-    SlotText = "text",
-    SeedValues = "values",
-    SeedField = "field",
-    SeedValue = "value"
-}
-interface SitePlanSchemaPin {
-    /** The owner's pick, verbatim — every design key becomes a one-value enum. */
-    design: DesignChoices;
-    /** This generation. */
-    source: SitePlanSource;
+declare const PLAN_WIRE_SCHEMA_NAME = "site_plan";
+declare enum PlanWireEntry {
+    Plan = "plan",
+    Business = "business",
+    ContentType = "contentType",
+    Roles = "roles",
+    Field = "field",
+    Seed = "seed",
+    SeedValue = "seedValue",
+    DataSource = "dataSource",
+    Page = "page",
+    PageSeo = "pageSeo",
+    Section = "section",
+    SlotText = "slotText",
+    SlotLink = "slotLink",
+    Globals = "globals"
+}
+/** The plan keys the model does not write, and where the expander takes each from. */
+declare const PLAN_WIRE_DERIVED: Readonly<Record<string, string>>;
+/** The wire's shape table, in the plan table's words — what the model reads, and what the format is built from. */
+declare const PLAN_WIRE_SHAPE: Readonly<Record<`${PlanWireEntry}`, ShapeEntry>>;
+/** Plan keys neither carried by a wire key nor derived — always empty (a spec and the builder hold it). */
+declare function planWireGaps(): string[];
+declare class PlanWireShapeError extends Error {
 }
-/** A content type's field. */
-declare function fieldJsonSchema(): JsonSchema;
-/** A content type, its seed's field values as a list (`values: [{ field, value }]`). */
-declare function contentTypeJsonSchema(): JsonSchema;
-/** A data source: a cms list / single item, or a relative one. */
-declare function dataSourceJsonSchema(): JsonSchema;
 /** The patterns a page section may use (every non-global one), in library order. */
 declare function sectionPatternIds(): string[];
-/** A page section: one branch per pattern. */
-declare function sectionJsonSchema(): JsonSchema;
-/** A page. */
-declare function pageJsonSchema(): JsonSchema;
-/** The Site Plan format, pinned to the owner's pick and this run. */
-declare function sitePlanJsonSchema(pin: SitePlanSchemaPin): JsonSchema;
-/** A section off the wire: its slots back to a map; a key the pattern has nothing for (`{}`) dropped. */
-declare function sectionFromWire(section: unknown): unknown;
-/** A content type off the wire: its seed's `values` list back to field keys. */
-declare function contentTypeFromWire(type: unknown): unknown;
+declare function wireFieldJsonSchema(): JsonSchema;
+declare function wireContentTypeJsonSchema(): JsonSchema;
+declare function wireDataSourceJsonSchema(): JsonSchema;
+declare function wireSectionJsonSchema(): JsonSchema;
+declare function wirePageJsonSchema(): JsonSchema;
+/** The format a model writes a plan in. The same for every studio and run: nothing in it is pinned. */
+declare function planWireJsonSchema(): JsonSchema;
+/** What the plan takes from the generation, not from the model. */
+interface PlanWireContext {
+    design: DesignChoices;
+    source: SitePlanSource;
+    /** The owner's own facts (the analysis's, as corrected), verbatim. */
+    facts?: Readonly<Partial<Record<FactKey, string>>>;
+    locale?: `${SiteLocale}`;
+}
+declare function expandWireField(wire: unknown): ContentFieldPlan | unknown;
+declare function expandWireContentType(wire: unknown): ContentTypePlan | unknown;
+declare function expandWireDataSource(wire: unknown): DataSourcePlan | unknown;
+declare function expandWireSection(wire: unknown): PageSectionPlan | unknown;
+declare function expandWirePage(wire: unknown): PagePlan | unknown;
 /**
- * A model's answer → a Site Plan: the two listed maps back to maps, nothing else touched. Never repairs — whatever the
- * answer got wrong is still wrong, for `validateSitePlan` to refuse with a path.
+ * A model's plan (the wire) + what the generation decides (the look, the run, the language, the owner's facts) → the
+ * Site Plan. Pure. Translates, never repairs: whatever the answer got wrong is still wrong, for `validateSitePlan`.
  */
-declare function sitePlanFromWire(wire: unknown): SitePlan | unknown;
-/** The plan → the wire (what a re-ask shows the model, and what the plan edits' prompt carries). */
-declare function sitePlanToWire(plan: SitePlan): PlainObject;
+declare function expandPlanWire(wire: unknown, context: PlanWireContext): SitePlan | unknown;
+declare function fieldToWire(field: ContentFieldPlan): PlainObject;
+declare function contentTypeToWire(type: ContentTypePlan): PlainObject;
+declare function dataSourceToWire(source: DataSourcePlan): PlainObject;
+declare function sectionToWire(section: PageSectionPlan): PlainObject;
+declare function pageToWire(page: PagePlan): PlainObject;
+/** The plan → the wire: what a model would have written (the plan edits' prompt shows it; fakes and evals write it). */
+declare function planToWire(plan: SitePlan): PlainObject;
+
+/**
+ * What a structured-output request costs the provider's grammar compiler, counted the way the Claude API counts it
+ * (platform.claude.com/docs/en/build-with-claude/structured-outputs, "Schema complexity limits", read 2026-10-27):
+ * "Total optional parameters across all strict tool schemas and JSON output schemas. Each parameter not listed in
+ * `required` counts toward this limit" (24); "Total parameters that use `anyOf` or type arrays (for example,
+ * `"type": ["string", "null"]`) across all strict schemas" (16); "Maximum number of tools with `strict: true`" (20).
+ * The limits are per REQUEST — every strict schema in it together. The ONE counter: the specs hold every schema iox-cms
+ * sends to it, and the fake Claude API refuses with it exactly as Claude does — the plan stage once sent 213 optional
+ * parameters and every suite stayed green because the fake accepted anything (vectoriox/iox-cms#45).
+ */
+declare const STRICT_SCHEMA_LIMITS: {
+    readonly strictTools: 20;
+    readonly optional: 24;
+    readonly 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. */
+declare const STRICT_SCHEMA_BUDGET: {
+    readonly optional: 12;
+    readonly unions: 8;
+};
+interface StrictSchemaComplexity {
+    /** Properties not listed in their object's `required`, every object of every schema. */
+    optional: number;
+    /** Nodes using `anyOf` or a type array. */
+    unions: number;
+    /** Tools with `strict: true` (a JSON output format is not a tool). */
+    strictTools: number;
+    /** What the strict mode does not support, each with its path (`pages.items.properties.route: minLength`). */
+    unsupported: string[];
+}
+/** The cost of ONE request's strict schemas together: its JSON output format and its strict tools' input schemas. */
+declare function strictSchemaComplexity(schemas: ReadonlyArray<JsonSchema>, strictTools?: number): StrictSchemaComplexity;
+/** A refusal shaped like the Claude API's (HTTP 400, `invalid_request_error`). */
+interface StrictSchemaRefusal {
+    status: 400;
+    type: 'invalid_request_error';
+    message: string;
+}
+/**
+ * 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).
+ */
+declare function strictSchemaRefusal(complexity: StrictSchemaComplexity): StrictSchemaRefusal | null;
 
 /**
  * Changing a plan by sentence (AI plan §3d "The Plan prompt box", M1-5; reused by M2 after a build): the CLOSED list
@@ -6106,9 +6178,21 @@ interface PlanEditsAnswer {
 }
 /** The answer's own keys, explained. */
 declare const PLAN_EDITS_ANSWER_SHAPE: ShapeEntry;
-/** The format a sentence's answer is written in: the outcome, the edits (one `anyOf` branch per op), the reason. */
+/** Each op's keys (`PLAN_EDIT_SHAPE`) → the wire key that carries it. */
+declare const PLAN_EDIT_WIRE_KEYS: Readonly<Record<`${PlanEditOp}`, Readonly<Record<string, string>>>>;
+/** The flat edit's shape table: every key required, each with its none. */
+declare const PLAN_EDIT_WIRE_SHAPE: ShapeEntry;
+/** Per op, the wire keys it reads, in `PLAN_EDIT_SHAPE`'s words (`?` = may hold its none) — what the model reads. */
+declare function planEditWireOps(): Record<string, Record<string, string>>;
+/** Op keys no wire key carries, or wire keys that do not exist — always empty (a spec and the builder hold it). */
+declare function planEditWireGaps(): string[];
+/** The format a sentence's answer is written in: the outcome, the flat edits, the reason. */
 declare function planEditsJsonSchema(): JsonSchema;
-/** A model's answer → edits (sections and content types off the wire); never repaired. */
+/** One flat edit → the op's edit: the keys it reads, a none left out where the op may go without it. Never repaired. */
+declare function expandWireEdit(wire: unknown): PlanEdit | unknown;
+/** An edit → the flat wire edit (what a model would write — fakes and specs write it). */
+declare function planEditToWire(edit: PlanEdit): PlainObject;
+/** A model's answer → edits (each flat edit expanded); never repaired. */
 declare function planEditsFromWire(answer: unknown): PlanEditsAnswer | unknown;
 
 /**
@@ -6296,29 +6380,47 @@ declare function publishVerdict(audit: SiteAudit, acknowledged?: ReadonlyArray<s
  * into the studio's own storage (never hot-linked), placed only in an EMPTY picture slot of a section that may show
  * one — never the owner's work (a collection, a detail page, a gallery: what the nine portfolio types sell is theirs),
  * never a person (testimonials, the team), never anywhere when the business type says `stock: false`. Its alt text is
- * the provider's description of what it shows (never a claim), and the credit line its licence requires is placed in
- * the footer. Pure: the build step does the copying.
+ * the provider's description of what it shows (never a claim), and the credit line its licence requires — when it
+ * requires one — is placed in the footer. Pure: the build step does the copying.
  */
 /** Where a stock photo comes from (the library's provider). */
 declare enum StockProviderId {
-    Magnific = "magnific"
+    Magnific = "magnific",
+    Pixabay = "pixabay"
+}
+/** Words and the address they link to. */
+interface StockLink {
+    line: string;
+    url: string;
 }
-/** What a picture's licence asks of the site that shows it. */
+/** What a provider's terms ask of IOX, per provider — the ONE place a credit line is decided. */
+interface StockProviderTerms {
+    name: string;
+    /** The line a site showing one of its pictures must carry (in the footer), or null when its licence asks none. */
+    credit: StockLink | null;
+    /** What to show wherever its SEARCH RESULTS are displayed — the operator's review of the library, never a site. */
+    sourceNotice: StockLink;
+}
+/**
+ * The providers' terms (AI plan §3g, I2; read 2026-10-25 / 2026-10-27). Magnific's free licence requires "Designed by
+ * Magnific", linked, next to the resource or in the site's footer. Pixabay's Content License: "You do not need to credit
+ * Pixabay or the contributor" — but its API asks to "show your users where the images and videos are from, whenever
+ * search results are displayed", which only the operator's review does.
+ */
+declare const STOCK_PROVIDER_TERMS: Readonly<Record<StockProviderId, StockProviderTerms>>;
+/** Where a picture came from and under which licence — recorded with every library photo and every studio copy. */
 interface StockCredit {
     provider: `${StockProviderId}`;
     /** The provider's id of the picture. */
     resourceId: string;
     /** The provider's page for it. */
     sourceUrl: string;
-    /** The provider's own title — what the picture shows. */
+    /** The provider's own words for what the picture shows (Magnific's title, Pixabay's tags). */
     title: string;
     author: string;
-    /** `freemium` — the free licence (premium pictures never enter the library). */
+    /** The licence it is used under, as the provider names it (Magnific `freemium`, Pixabay `content-license`). */
     licence: string;
     licenceUrl: string;
-    /** The words the licence requires, and where they link. */
-    line: string;
-    lineUrl: string;
 }
 /** One picture of the platform library (`iox-stock/<type>/`), as its manifest lists it. */
 interface StockPhoto {
@@ -6356,26 +6458,19 @@ declare function applyStockPhotos(trees: ReadonlyArray<SerializedNode>, placed:
     url: string;
     alt: string;
 }>): number;
-/** The credit lines a set of photos needs — one per distinct line (a free Magnific photo: "Designed by Magnific"). */
-declare function stockCreditLines(photos: ReadonlyArray<Pick<StockPhoto, 'credit'>>): Array<{
-    line: string;
-    url: string;
-}>;
+/** The line a picture's licence requires on the site, or null when it requires none (`STOCK_PROVIDER_TERMS`). */
+declare function stockCreditLine(credit: Pick<StockCredit, 'provider'>): StockLink | null;
+/** The credit lines a set of photos needs — one per distinct line, none for a provider whose licence asks none. */
+declare function stockCreditLines(photos: ReadonlyArray<Pick<StockPhoto, 'credit'>>): StockLink[];
 /** The footer node id of a credit line (stable — a build that runs twice finds it). */
 declare const stockCreditNodeId: (index: number) => string;
 /**
  * The credit line, as the builder would create a Link (a plain node the owner may move or restyle): the licence's words,
  * linking where it asks, opening in a new tab. Placed at the end of the footer — the place the licence names for a site.
  */
-declare function stockCreditNode(index: number, credit: {
-    line: string;
-    url: string;
-}): SerializedNode;
+declare function stockCreditNode(index: number, credit: StockLink): SerializedNode;
 /** Append the credit lines to the footer root (once each). Returns how many it added. */
-declare function addStockCredits(footer: SerializedNode, credits: ReadonlyArray<{
-    line: string;
-    url: string;
-}>): number;
+declare function addStockCredits(footer: SerializedNode, credits: ReadonlyArray<StockLink>): number;
 
-export { ACTIVE_BUILD_STATUSES, AI_REFUSAL_NEXT, AI_REFUSAL_STATUS, AI_STEPS, AI_STEP_LABELS, AI_STEP_NEEDS, AI_STEP_TYPICAL_TOKENS, AiCallStatus, AiCapability, AiFeature, AiGenerationStage, AiKeyMode, AiLimit, AiNextKind, AiProviderId, AiRefusalCode, AiStep, BAR_ITEMS_MAX, BAR_ITEMS_MIN, BASELINE_ROLES, BUILD_STEPS, BaselineRole, BindScope, BuildNoticeCode, BuildStep, CONTENT_ROLE_MEANINGS, CREDITS_PER_USD, CardBindTarget, CheckSeverity, ComposeError, ComposeIssueCode, ContentRole, ContentTypeAction, CreatedKind, DANGLING_LINK_CODES, DEFAULT_PHONE_MENU_BREAKPOINT, DEFAULT_SITE_LOCALE, ENTRANCE_EASING, ENTRANCE_ORIGIN_LOOK, ENTRANCE_TRIGGER, EntrancePart, EntranceSide, FACT_KEYS, FINAL_GENERATION_STAGES, FINDING_SEVERITY, GlobalSlot, HEBREW_PREFIXES, JSON_SCHEMA_BANNED_KEYWORDS, JsonSchemaShapeError, KeptReason, NAV_PART_LABELS, NAV_SHAPE_COPY, NEUTRAL_STYLE_PROPS, NODE_BASELINES, NO_TOKENS, NavPagesSource, NavRole, NavShape, NavShapeError, PAGE_ARCHETYPES, PLAN_EDITS_ANSWER_SHAPE, PLAN_EDITS_SCHEMA_NAME, PLAN_EDIT_SHAPE, PRICING_PATTERN, PUBLISH_BLOCKING_PLACEHOLDERS, PageDataKind, PathIssueCollector, PatternDirective, PatternGlobalPosition, PatternOpens, PatternPlaceholder, PatternRecipe, PhoneMenuBreakpoint, PlaceholderKind, PlanChangeAction, PlanChangeKind, PlanDataSourceMode, PlanDataSourceType, PlanEditIssueCode, PlanEditOp, PlanEditsOutcome, PlanWordIssueCode, PreflightRefusalCode, PublishRefusalCode, REQUIRED_CONTENT_ROLES, RelativeOp, SAMPLE_IMAGE_REF, SITE_CHECKS, SITE_FACT_LABELS, SITE_HEADER_PATTERN, SITE_LIBRARY, SITE_LOCALES, SITE_NEED_IDS, SITE_PATTERNS, SITE_PLAN_SCHEMA_NAME, SITE_PLAN_VERSION, SITE_TEMPLATES, SPEC_SITE_ARCHETYPES, SPEC_SITE_COPY_LENGTHS, SPEC_SITE_DENSITY_COPY, SPEC_SITE_FACTS, SPEC_SITE_LIBRARY, SPEC_SITE_LOCALES, SPEC_SITE_NEED_IDS, SPEC_SITE_PATTERNS, SPEC_SITE_PLAN_SHAPE, SPEC_SITE_REQUIRED_ROLES, SPEC_SITE_ROLES, SPEC_SITE_TEMPLATES, STOCK_FAMILIES, STUDIO_TEMPLATE, SiteBuildKind, SiteBuildStatus, SiteCheckId, SiteFindingCode, SiteLocale, SitePlanError, SitePlanIssueCode, SitePlanSourceKind, SitePlanWireKey, SiteTemplateError, SiteTemplateId, StepState, StockProviderId, addBarItem, addStockCredits, applyPlanEdits, applyStockPhotos, archetypeIssues, assertStyleSlots, assertValidSitePlan, auditSite, barIconForRoute, blocksPublish, buildKeys, buildStepFacts, builtHomePageId, composeNavHeader, composeSection, composeSite, contentTypeFromWire, contentTypeJsonSchema, contentTypePreviewFields, copyLengthOf, costUsd, createSerializedNode, creditsOfUsd, dataSourceJsonSchema, describePlanData, describeShapeKey, entranceAction, entranceInteraction, estimateStepCredits, failedBuildStep, fieldJsonSchema, findNavRoot, isActiveBuild, isNonEmptyString, isPlainObject, isRtlLocale, jsonAnyOf, jsonBoolean, jsonClosedObject, jsonInteger, jsonListOf, jsonOneOf, jsonSchemaKeywords, jsonSchemaObjects, jsonShapedObject, jsonText, modelCanDo, moveBarItem, navPages, navShapeBreakpoint, navShapeOf, nextSourceOf, nodeBindPaths, pageJsonSchema, parsePatternPath, parseSampleImageRef, pathAt, patternById, patternHasForm, patternLinkSlots, patternManifest, patternNeedsBinding, patternNodes, patternOptionalParts, patternRoleNeeds, patternScopes, patternSlotBudgets, patternSlots, patternTakesBinding, phoneMenuPages, planEditsFromWire, planEditsJsonSchema, planEntrances, planFromTemplate, planNavShape, planStockPhotos, planWordIssues, publishRefusal, publishVerdict, releasedLayoutDefaults, removeBarItem, requiredAcknowledgements, requiredShapeKeys, roleField, routeMatches, routeParams, sampleImageRef, sectionEntrances, sectionFromWire, sectionJsonSchema, sectionPatternIds, setStyleProps, shapeKeys, showcaseGlobals, showcasePages, showcasePlans, siteNavPages, sitePlanFromWire, sitePlanJsonSchema, sitePlanToWire, slotBudget, stockCopyKey, stockCreditLines, stockCreditNode, stockCreditNodeId, stockSlots, validatePlanEdits, validateSitePlan, walkSerialized, wordPattern, writtenTexts };
-export type { AddBarItemResult, AiEntitlementsView, AiMeter, AiModelEntry, AiRefusal, AiTokenCounts, AiTokenPrice, AuditPage, AuditPlaceholder, BarItemsEditResult, BuildNotice, BuildStepError, BuildStepFacts, BuildStepRecord, CmsDataSourcePlan, ComposeContext, ComposeIssue, ComposedDataSource, ComposedItem, ComposedNavHeader, ComposedPage, ComposedPlaceholder, ComposedRoute, ComposedSection, ComposedSite, ContentFieldPlan, ContentRoles, ContentSeedPlan, ContentTypePlan, CreateNodeOptions, CreatedRecord, DataSourcePlan, DynamicKeysAsList, EntranceAction, EntranceActionOptions, EntranceInteraction, EntranceMark, EntranceSpec, EntranceStamp, FactKey, JsonSchema, NavHeaderInput, NavHeaderOptions, NavPage, NavShapeOptions, NavShapeResult, NodeBaseline, PageArchetype, PageArchetypeId, PageArchetypeSlot, PageData, PageDataLine, PagePlan, PageSectionPlan, PageSeoPlan, PathIssue, PatternManifestEntry, PatternNode, PatternPath, PatternRoleNeed, PlainObject, PlanChange, PlanEdit, PlanEditIssue, PlanEditResult, PlanEditsAnswer, PlanEntrancesInput, PlanWordContext, PlanWordIssue, PreflightRefusal, PublishRefusal, RelativeDataSourcePlan, SectionEntrances, SectionInput, SectionOptions, SerializedBinding, SerializedNode, SerializedResponsive, ShapeEntry, ShapeIssueCodes, ShowcaseInput, SiteAudit, SiteAuditOptions, SiteAuditSnapshot, SiteBuildRun, SiteBusiness, SiteCheck, SiteFinding, SiteNeedId, SitePageRef, SitePattern, SitePlan, SitePlanIssue, SitePlanSchemaPin, SitePlanSource, SitePlanValidation, SiteTemplate, StockCredit, StockPhoto, StockPlacement, StockSlot, TemplatePlanInput, UndoKept, UndoPreview, UndoRecord, WrittenText };
+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 type { AddBarItemResult, AiEntitlementsView, AiMeter, AiModelEntry, AiRefusal, AiTokenCounts, AiTokenPrice, AuditPage, AuditPlaceholder, BarItemsEditResult, BuildNotice, BuildStepError, BuildStepFacts, BuildStepRecord, CmsDataSourcePlan, ComposeContext, ComposeIssue, ComposedDataSource, ComposedItem, ComposedNavHeader, ComposedPage, ComposedPlaceholder, ComposedRoute, ComposedSection, ComposedSite, ContentFieldPlan, ContentRoles, ContentSeedPlan, ContentTypePlan, CreateNodeOptions, CreatedRecord, DataSourcePlan, DynamicKeysAsList, EntranceAction, EntranceActionOptions, EntranceInteraction, EntranceMark, EntranceSpec, EntranceStamp, FactKey, JsonSchema, NavHeaderInput, NavHeaderOptions, NavPage, NavShapeOptions, NavShapeResult, NodeBaseline, PageArchetype, PageArchetypeId, PageArchetypeSlot, PageData, PageDataLine, PagePlan, PageSectionPlan, PageSeoPlan, PathIssue, PatternManifestEntry, PatternNode, PatternPath, PatternRoleNeed, PlainObject, PlanChange, PlanEdit, PlanEditIssue, PlanEditResult, PlanEditsAnswer, PlanEntrancesInput, PlanWireContext, PlanWordContext, PlanWordIssue, PreflightRefusal, PublishRefusal, RelativeDataSourcePlan, SectionEntrances, SectionInput, SectionOptions, SerializedBinding, SerializedNode, SerializedResponsive, ShapeEntry, ShapeIssueCodes, ShowcaseInput, SiteAudit, SiteAuditOptions, SiteAuditSnapshot, SiteBuildRun, SiteBusiness, SiteCheck, SiteFinding, SiteNeedId, SitePageRef, SitePattern, SitePlan, SitePlanIssue, SitePlanSource, SitePlanValidation, SiteTemplate, StockCredit, StockLink, StockPhoto, StockPlacement, StockProviderTerms, StockSlot, StrictSchemaComplexity, StrictSchemaRefusal, TemplatePlanInput, UndoKept, UndoPreview, UndoRecord, WrittenText };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectoriox/iox-ui",
-  "version": "5.59.1",
+  "version": "5.61.0",
   "peerDependencies": {
     "@angular/common": ">=20.0.0",
     "@angular/core": ">=20.0.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, PlanWireShapeError, sectionPatternIds, sectionToWire, wireContentTypeJsonSchema, wireDataSourceJsonSchema, wireFieldJsonSchema,
+    wirePageJsonSchema, wireSectionJsonSchema,
+} from './plan-wire';
 import {
     ContentFieldPlan, ContentTypePlan, DataSourcePlan, PagePlan, PageSectionPlan, PlanDataSourceMode, PlanDataSourceType, SitePlan,
 } from './site-plan.model';
@@ -209,7 +210,7 @@ const setSections = (d: Draft, at: number, sections: PageSectionPlan[]) => { d.p
 /** 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,7 +258,7 @@ 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 });
     },
@@ -304,7 +305,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 });
@@ -382,47 +383,164 @@ export const PLAN_EDITS_ANSWER_SHAPE: ShapeEntry = {
     reason: "string — when cannot, ONE short line for the owner in their language (what to do instead); else ''",
 };
 
-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)();
-    };
-    return jsonShapedObject(entry, Object.fromEntries(shapeKeys(entry).map(key => [key, valueOf(key)])), op);
+/**
+ * ONE edit on the wire (vectoriox/iox-cms#45): a flat object whose keys are ALL required — the 13 ops as `anyOf`
+ * branches, each embedding whole pages, sections and content types, came to 395 optional parameters against the Claude
+ * API's 24. `op` says which keys are read (`PLAN_EDIT_WIRE_KEYS`, from `PLAN_EDIT_SHAPE`); every other key holds its
+ * none. A whole page, section, content type or field travels as a list of exactly one, in the plan wire's format.
+ */
+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 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'),
+    to: indexKey('movePage / moveSection: the new 0-based place'),
+    at: indexKey('addSection: its 0-based place on the page'),
+    pattern: { text: 'string — swapPattern: the section pattern it becomes', none: '', schema: () => jsonOneOf(['', ...sectionPatternIds()]) },
+    slot: textKey("setSlot: one of the pattern's slots"),
+    text: textKey("setSlot: the words, in the owner's language and voice"),
+    binding: textKey('setSectionData: the list source the section repeats'),
+    contentType: textKey('addField: a content type of the plan'),
+    newPage: oneOf(wirePageJsonSchema, expandWirePage, pageToWire, 'page'),
+    newSection: oneOf(wireSectionJsonSchema, expandWireSection, sectionToWire, 'section'),
+    newContentType: oneOf(wireContentTypeJsonSchema, expandWireContentType, contentTypeToWire, 'contentType'),
+    dataSources: {
+        text: 'dataSource[] — addContentType: the list / single sources its pages read', none: [],
+        schema: () => jsonListOf(wireDataSourceJsonSchema()),
+        expand: v => (Array.isArray(v) ? v.map(expandWireDataSource) : v),
+        toWire: (v: 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: 'at' },
+    [PlanEditOp.RemoveSection]: { page: 'page', index: 'index' },
+    [PlanEditOp.MoveSection]: { page: 'page', from: 'index', to: 'to' },
+    [PlanEditOp.SwapPattern]: { page: 'page', index: 'index', pattern: 'pattern' },
+    [PlanEditOp.SetSlot]: { page: 'page', index: 'index', slot: 'slot', text: 'text' },
+    [PlanEditOp.AddContentType]: { contentType: 'newContentType', dataSources: 'dataSources' },
+    [PlanEditOp.AddField]: { contentType: 'contentType', field: 'newField', sample: 'sample' },
+    [PlanEditOp.SetSectionData]: { page: 'page', index: 'index', binding: 'binding' },
+};
+
+const isEditWireNone = (wireKey: 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));
+
+/** The flat edit's shape table: every key required, each with its none. */
+export const PLAN_EDIT_WIRE_SHAPE: ShapeEntry = {
+    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. */
+export function planEditWireOps(): Record<string, Record<string, string>> {
+    return Object.fromEntries(OPS.map(op => {
+        const entry = PLAN_EDIT_SHAPE[op as PlanEditOp];
+        const keys = PLAN_EDIT_WIRE_KEYS[op as PlanEditOp];
+        return [op, Object.fromEntries(Object.entries(keys).map(([planKey, wireKey]) => {
+            const optionalKey = `${planKey}?` in entry;
+            return [`${wireKey}${optionalKey ? '?' : ''}`, entry[optionalKey ? `${planKey}?` : planKey]];
+        }))];
+    }));
 }
 
-/** The format a sentence's answer is written in: the outcome, the edits (one `anyOf` branch per op), the reason. */
+/** Op keys no wire key carries, or wire keys that do not exist — always empty (a spec and the builder hold it). */
+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;
+}
+
+/** The format a sentence's answer is written in: the outcome, the flat edits, the reason. */
 export function planEditsJsonSchema(): JsonSchema {
+    const gaps = planEditWireGaps();
+    if (gaps.length) throw new PlanWireShapeError(`the plan edits wire does not carry ${gaps.join(', ')}`);
+    const edit = jsonShapedObject(PLAN_EDIT_WIRE_SHAPE, {
+        op: jsonOneOf(OPS),
+        ...Object.fromEntries(Object.entries(EDIT_WIRE).map(([k, spec]) => [k, spec.schema()])),
+    }, 'edit');
     return jsonShapedObject(PLAN_EDITS_ANSWER_SHAPE, {
         outcome: jsonOneOf(Object.values(PlanEditsOutcome)),
-        edits: jsonListOf(jsonAnyOf(OPS.map(op => opSchema(op as PlanEditOp)))),
+        edits: jsonListOf(edit),
         reason: jsonText(),
     }, 'planEdits');
 }
 
-/** A model's answer → edits (sections and content types off the wire); never repaired. */
+/** One flat edit → the op's edit: the keys it reads, a none left out where the op may go without it. Never repaired. */
+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 → the flat wire edit (what a model would write — fakes and specs write it). */
+export function planEditToWire(edit: PlanEdit): PlainObject {
+    const out: PlainObject = { op: edit.op, ...Object.fromEntries(Object.entries(EDIT_WIRE).map(([k, spec]) => [k, Array.isArray(spec.none) ? [] : spec.none])) };
+    for (const [planKey, wireKey] of Object.entries(PLAN_EDIT_WIRE_KEYS[edit.op])) {
+        const value = (edit 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 (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) };
 }