@vectoriox/iox-ui 5.60.0 → 5.62.0

package/generation-core/index.d.ts

@@ -5724,6 +5724,122 @@ interface BuildStepFacts {
 }
 declare function buildStepFacts(plan: SitePlan, actions?: Readonly<Record<string, `${ContentTypeAction}`>>): BuildStepFacts;
 
+/**
+ * The plan WIRE (AI plan M1-3, vectoriox/iox-cms#45, #47): what a model writes when it plans a site — a compact format
+ * inside the Claude API's structured-output limits (≤ 24 optional parameters and ≤ 16 unions per request, and a compiled
+ * grammar under the size Claude refuses — measured as ≤ 60 properties; `strict-schema.ts`). The Site Plan itself
+ * (`SPEC_SITE_PLAN_SHAPE`) has 213 optional keys once every pattern is a branch, so the model never writes it: it writes
+ * this, and ONE pure `expandPlanWire` turns it into the Site Plan that `validateSitePlan` and the stage's gate judge
+ * exactly as before.
+ *
+ * - **Written in two PARTS, one request each** (#47 — the whole plan in one format was 64 properties): the **structure** (the business,
+ *   the content types, the data sources) and then the **pages** (the pages, the header and footer), written knowing the
+ *   structure. Every top-level key belongs to exactly one part (`part` below); `expandPlanWire` puts the parts together.
+ *
+ * - **Every key required.** A plan key that may be absent is written with its stated "none" — `''`, `0`, `false`, `[]`.
+ * - **Closed lists as enums** (patterns, page types, needs, slots, parts, forms, entrances, header/footer), from the
+ *   contract — never per-pattern branches: the gate refuses a slot or a part the chosen pattern does not have, with its path.
+ * - **Maps as lists:** slots `[{ slot, text }]`, links `[{ slot, route }]`, seed values `[{ field, value }]`, roles `[{ role, field }]`.
+ * - **One data source object** for both kinds; `type` says which keys are read (the other kind's hold their none).
+ * - **What the model does not decide is not on the wire** (`PLAN_WIRE_DERIVED`): the look (the owner's pick), the run,
+ *   the language (the reading's), the facts (the owner's own, verbatim), the version, the home page (the page at `/`).
+ *   So the format is the same for every studio and every run — one compiled grammar, cached by the provider.
+ *
+ * ONE source: every wire key names the plan keys it carries (`refs`) and is described in the plan table's own words, and
+ * every plan key is either carried or derived (`planWireGaps()`); a key the plan shape gains breaks the builder until it
+ * is placed. The expanders translate, never repair: a value the model got wrong stays wrong, for the gate to refuse.
+ */
+/** The plan's parts, in the order they are written: the pages bind to the structure's sources and types. */
+declare enum PlanPart {
+    Structure = "structure",
+    Pages = "pages"
+}
+declare const PLAN_PARTS: ReadonlyArray<PlanPart>;
+/** Each part's format name (a request names the format it asks for). */
+declare const PLAN_WIRE_PART_SCHEMA_NAMES: Readonly<Record<PlanPart, string>>;
+declare enum PlanWireEntry {
+    Plan = "plan",
+    Business = "business",
+    ContentType = "contentType",
+    RoleField = "roleField",
+    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>>;
+/** Each part's top-level keys, from the ONE wire table. */
+declare const PLAN_PART_KEYS: Readonly<Record<PlanPart, ReadonlyArray<string>>>;
+/**
+ * The part a plan path is the answer of (`contentTypes[1].seed.title` → structure, `pages[0].sections[2]` → pages). A
+ * path no part writes — the root (the composer), or a key the generation decides — is the LAST part's: it is written
+ * knowing everything before it.
+ */
+declare function planPartOfPath(path: string): PlanPart;
+/** 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 {
+}
+/** The patterns a page section may use (every non-global one), in library order. */
+declare function sectionPatternIds(): string[];
+declare function wireFieldJsonSchema(): JsonSchema;
+/** What an object of the wire travels without when its children are written as their own entries (a plan edit's). */
+interface WireOptions {
+    /** false: a content type without its `fields`, a page without its `sections` (each added by an edit after it). */
+    children?: boolean;
+}
+declare function wireContentTypeJsonSchema(options?: WireOptions): JsonSchema;
+declare function wireDataSourceJsonSchema(): JsonSchema;
+declare function wireSectionJsonSchema(): JsonSchema;
+declare function wirePageJsonSchema(options?: WireOptions): JsonSchema;
+/** The plan's top-level shape for one part (its keys only) — what that part's request shows and is built from. */
+declare function planWirePartShape(part: PlanPart): ShapeEntry;
+/**
+ * The format a model writes one part of a plan in — one request each (vectoriox/iox-cms#47). The same for every studio
+ * and run: nothing in it is pinned, so the provider compiles each part's grammar once.
+ */
+declare function planWirePartJsonSchema(part: PlanPart): 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, options?: WireOptions): ContentTypePlan | unknown;
+declare function expandWireDataSource(wire: unknown): DataSourcePlan | unknown;
+declare function expandWireSection(wire: unknown): PageSectionPlan | unknown;
+declare function expandWirePage(wire: unknown, options?: WireOptions): PagePlan | unknown;
+/** A plan on the wire, by part — what each request answered. A part not written yet is absent. */
+type PlanWireParts = Partial<Record<PlanPart, unknown>>;
+/**
+ * A model's plan (its parts, on the wire) + what the generation decides (the look, the run, the language, the owner's
+ * facts) → the Site Plan. Pure. Translates, never repairs: whatever an answer got wrong is still wrong, for
+ * `validateSitePlan` — a part that is not an object is the result itself, a part not written yet leaves its keys out
+ * (the validator then names them, at their own paths).
+ */
+declare function expandPlanWire(parts: PlanWireParts, context: PlanWireContext): SitePlan | unknown;
+declare function fieldToWire(field: ContentFieldPlan): PlainObject;
+declare function contentTypeToWire(type: ContentTypePlan, options?: WireOptions): PlainObject;
+declare function dataSourceToWire(source: DataSourcePlan): PlainObject;
+declare function sectionToWire(section: PageSectionPlan): PlainObject;
+declare function pageToWire(page: PagePlan, options?: WireOptions): PlainObject;
+/** One part of the plan on the wire: what that part's request would have answered. */
+declare function planPartToWire(plan: SitePlan, part: PlanPart): PlainObject;
+/** The plan → the wire, by part: what a model would have written (the change prompt shows it; fakes and evals write it). */
+declare function planToWire(plan: SitePlan): Record<PlanPart, PlainObject>;
+
 /**
  * The AI pipeline's WIRE vocabulary (AI plan §3c, §3n, M0): what iox-cms's `ai` API answers and what every client
  * of it reads — the steps a model works on, who pays (IOX credits or the studio's own key), a model of the vetted
@@ -5760,7 +5876,18 @@ declare enum AiCapability {
     ImageOutput = "imageOutput"
 }
 declare const AI_STEP_NEEDS: Readonly<Record<AiStep, ReadonlyArray<AiCapability>>>;
-/** Tokens a typical use of a step reads and writes (plan §3d "Where credits go") — what a shown estimate is made of. */
+/**
+ * The steps a model answers in the plan's parts, one request per part (vectoriox/iox-cms#47 — the whole plan's format
+ * compiles to a grammar Claude refuses), and the tokens a typical request of each part reads and writes. Each part reads
+ * the same instructions; the pages read the structure too and write most of the words.
+ */
+declare const AI_STEP_PART_TOKENS: Readonly<Partial<Record<AiStep, Readonly<Record<PlanPart, AiTokenCounts>>>>>;
+/** The parts a step is asked in, in order — none for a step asked in one request. */
+declare function aiStepParts(step: AiStep): ReadonlyArray<PlanPart>;
+/**
+ * Tokens a typical use of a step reads and writes (plan §3d "Where credits go") — what a shown estimate is made of. A
+ * step asked in parts is every part's request together, so the estimate (and a generation's start gate) counts them all.
+ */
 declare const AI_STEP_TYPICAL_TOKENS: Readonly<Record<AiStep, AiTokenCounts>>;
 /** Tokens by the class a provider prices them in. */
 interface AiTokenCounts {
@@ -5806,6 +5933,8 @@ declare const NO_TOKENS: Readonly<AiTokenCounts>;
 declare function costUsd(tokens: AiTokenCounts, price: AiTokenPrice): number;
 /** Dollars → credits, kept to a millionth of a credit (a short read costs a fraction of one). */
 declare function creditsOfUsd(usd: number): number;
+/** What a typical request of `step` reads and writes — one part's when the step is asked in parts, else the whole step's. */
+declare function typicalStepTokens(step: AiStep, part?: PlanPart): AiTokenCounts;
 /** The credits a typical use of `step` costs on a model of `price` — never typed, always computed (§3d). */
 declare function estimateStepCredits(step: AiStep, price: AiTokenPrice, tokens?: AiTokenCounts): number;
 /** Can `model` do `step`? The step's needs against the model's capabilities. */
@@ -5897,57 +6026,67 @@ 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.
+ * What a structured-output request costs the provider's grammar compiler, counted the way the Claude API counts it
+ * (platform.claude.com/docs/en/build-with-claude/structured-outputs, "Schema complexity limits", read 2026-10-27):
+ * "Total optional parameters across all strict tool schemas and JSON output schemas. Each parameter not listed in
+ * `required` counts toward this limit" (24); "Total parameters that use `anyOf` or type arrays (for example,
+ * `"type": ["string", "null"]`) across all strict schemas" (16); "Maximum number of tools with `strict: true`" (20).
+ * The limits are per REQUEST — every strict schema in it together. The ONE counter: the specs hold every schema iox-cms
+ * sends to it, and the fake Claude API refuses with it exactly as Claude does — the plan stage once sent 213 optional
+ * parameters and every suite stayed green because the fake accepted anything (vectoriox/iox-cms#45).
  *
- * Two maps of the shape are written as LISTS on the wire, because no strict mode can say "any key": a section's
- * `slots` (`[{ slot, text }]`, the slot names closed per pattern) and a seed's field values (`values: [{ field,
- * value }]`). `sitePlanFromWire` turns them back; nothing else differs. Every section is one `anyOf` branch per
- * pattern — its id, its declared slots, its optional parts, a binding only when it takes one — and the design, the
- * source and the version are PINNED to the owner's pick and this run (one-value enums), so the provider cannot let
- * a model change the look. The gate still checks both (`plan.design` deep-equals the pick).
+ * Beyond those, Claude refuses a grammar it compiles too large — a limit the docs name ("additional internal limits on
+ * the compiled grammar size") without a number. MEASURED against the API on 2026-10-27 (vectoriox/iox-cms#47): the
+ * total number of properties decides it, not enums or descriptions — 64 and 61 properties refused, 53 and fewer
+ * accepted (53 already took ~9 s to compile). So 60 is the line we refuse above, and 40 is what we send.
  */
-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 STRICT_SCHEMA_LIMITS: {
+    readonly strictTools: 20;
+    readonly optional: 24;
+    readonly unions: 16;
+    /** MEASURED, not documented (2026-10-27): the smallest refused request held 61 properties, the largest accepted 53. */
+    readonly properties: 60;
+};
+/**
+ * What one request iox-cms sends may use: half of each documented limit, so a step can gain a field (or a strict tool)
+ * without a 400 — and 40 properties, a third under the measured grammar line, where compiling stays a few seconds.
+ */
+declare const STRICT_SCHEMA_BUDGET: {
+    readonly optional: 12;
+    readonly unions: 8;
+    readonly properties: 40;
+};
+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;
+    /** Every key of every object's `properties`, at every depth — what the compiled grammar's size follows. */
+    properties: number;
+    /** Objects that declare `properties`. */
+    objects: 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;
 }
-/** 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;
+/** Claude's words for a grammar it compiles too large (2026-10-27, the plan stage — vectoriox/iox-cms#47), verbatim. */
+declare const GRAMMAR_TOO_LARGE_MESSAGE = "The compiled grammar is too large, which would cause performance issues. Simplify your tool schemas or reduce the number of strict tools.";
 /**
- * A model's answer → a Site Plan: the two listed maps back to maps, nothing else touched. Never repairs — whatever the
- * answer got wrong is still wrong, for `validateSitePlan` to refuse with a path.
+ * The 400 the Claude API answers a request over its limits with, or null. The optional-parameter and the grammar-size
+ * messages are the ones Claude answered on 2026-10-27, verbatim; the union, strict-tool and unsupported messages follow
+ * their shape (not yet captured). The documented limits are checked first: a request over one of them never reaches the
+ * grammar compiler.
  */
-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 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
@@ -6037,6 +6176,13 @@ type PlanEdit = {
  * A page is named by its `key`; a section by its 0-based `index` on that page.
  */
 declare const PLAN_EDIT_SHAPE: Readonly<Record<`${PlanEditOp}`, ShapeEntry>>;
+/**
+ * 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.
+ */
+declare const PLAN_EDIT_OP_PART: Readonly<Record<`${PlanEditOp}`, PlanPart>>;
+/** The ops written in one part, in `PlanEditOp` order. */
+declare function planEditOps(part: PlanPart): PlanEditOp[];
 declare enum PlanChangeKind {
     Page = "page",
     Section = "section",
@@ -6092,7 +6238,8 @@ declare function validatePlanEdits(edits: unknown): {
  * The result still has to pass `validateSitePlan`.
  */
 declare function applyPlanEdits(plan: SitePlan, edits: ReadonlyArray<PlanEdit>): PlanEditResult;
-declare const PLAN_EDITS_SCHEMA_NAME = "plan_edits";
+/** Each part's answer format name. */
+declare const PLAN_EDITS_PART_SCHEMA_NAMES: Readonly<Record<PlanPart, string>>;
 /** A sentence's answer: the edits, or why the ops cannot say it (one line, in the owner's language). */
 declare enum PlanEditsOutcome {
     Edits = "edits",
@@ -6104,11 +6251,30 @@ interface PlanEditsAnswer {
     /** `cannot`: the one line the owner reads. `edits`: empty. */
     reason: string;
 }
-/** 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. */
-declare function planEditsJsonSchema(): JsonSchema;
-/** A model's answer → edits (sections and content types off the wire); never repaired. */
+/**
+ * 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.
+ */
+declare const PLAN_EDITS_ANSWER_SHAPES: Readonly<Record<PlanPart, ShapeEntry>>;
+/** 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 wire keys a part's edit carries: every key its ops read, in `EDIT_WIRE` order. */
+declare function planEditWireKeys(part: PlanPart): string[];
+/** A part's flat edit, as a shape table: every key required, each with its none. */
+declare function planEditWireShape(part: PlanPart): ShapeEntry;
+/** Per op of a part, the wire keys it reads, in `PLAN_EDIT_SHAPE`'s words (`?` = may hold its none) — what the model reads. */
+declare function planEditWireOps(part: PlanPart): 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 one part of a sentence's answer is written in — one request each (vectoriox/iox-cms#47). */
+declare function planEditsJsonSchema(part: PlanPart): JsonSchema;
+/** 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 edits a model would write for it: itself, then its children (fakes and specs write them). */
+declare function planEditToWire(edit: PlanEdit): PlainObject[];
+/** Edits → each part's flat wire edits, in order (what each part's answer would hold). */
+declare function planEditsToWire(edits: ReadonlyArray<PlanEdit>): Record<PlanPart, PlainObject[]>;
+/** A model's answer (either part's) → edits (each flat edit expanded); never repaired. */
 declare function planEditsFromWire(answer: unknown): PlanEditsAnswer | unknown;
 
 /**
@@ -6388,5 +6554,5 @@ declare function stockCreditNode(index: number, credit: StockLink): SerializedNo
 /** Append the credit lines to the footer root (once each). Returns how many it added. */
 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, STOCK_PROVIDER_TERMS, STUDIO_TEMPLATE, SiteBuildKind, SiteBuildStatus, SiteCheckId, SiteFindingCode, SiteLocale, SitePlanError, SitePlanIssueCode, SitePlanSourceKind, SitePlanWireKey, SiteTemplateError, SiteTemplateId, StepState, StockProviderId, addBarItem, addStockCredits, applyPlanEdits, applyStockPhotos, archetypeIssues, assertStyleSlots, assertValidSitePlan, auditSite, barIconForRoute, blocksPublish, buildKeys, buildStepFacts, builtHomePageId, composeNavHeader, composeSection, composeSite, contentTypeFromWire, contentTypeJsonSchema, contentTypePreviewFields, copyLengthOf, costUsd, createSerializedNode, creditsOfUsd, dataSourceJsonSchema, describePlanData, describeShapeKey, entranceAction, entranceInteraction, estimateStepCredits, failedBuildStep, fieldJsonSchema, findNavRoot, isActiveBuild, isNonEmptyString, isPlainObject, isRtlLocale, jsonAnyOf, jsonBoolean, jsonClosedObject, jsonInteger, jsonListOf, jsonOneOf, jsonSchemaKeywords, jsonSchemaObjects, jsonShapedObject, jsonText, modelCanDo, moveBarItem, navPages, navShapeBreakpoint, navShapeOf, nextSourceOf, nodeBindPaths, pageJsonSchema, parsePatternPath, parseSampleImageRef, pathAt, patternById, patternHasForm, patternLinkSlots, patternManifest, patternNeedsBinding, patternNodes, patternOptionalParts, patternRoleNeeds, patternScopes, patternSlotBudgets, patternSlots, patternTakesBinding, phoneMenuPages, planEditsFromWire, planEditsJsonSchema, planEntrances, planFromTemplate, planNavShape, planStockPhotos, planWordIssues, publishRefusal, publishVerdict, releasedLayoutDefaults, removeBarItem, requiredAcknowledgements, requiredShapeKeys, roleField, routeMatches, routeParams, sampleImageRef, sectionEntrances, sectionFromWire, sectionJsonSchema, sectionPatternIds, setStyleProps, shapeKeys, showcaseGlobals, showcasePages, showcasePlans, siteNavPages, sitePlanFromWire, sitePlanJsonSchema, sitePlanToWire, slotBudget, stockCopyKey, stockCreditLine, stockCreditLines, stockCreditNode, stockCreditNodeId, stockSlots, validatePlanEdits, validateSitePlan, walkSerialized, wordPattern, writtenTexts };
-export 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, StockLink, StockPhoto, StockPlacement, StockProviderTerms, 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_PART_TOKENS, AI_STEP_TYPICAL_TOKENS, AiCallStatus, AiCapability, AiFeature, AiGenerationStage, AiKeyMode, AiLimit, AiNextKind, AiProviderId, AiRefusalCode, AiStep, BAR_ITEMS_MAX, BAR_ITEMS_MIN, BASELINE_ROLES, BUILD_STEPS, BaselineRole, BindScope, BuildNoticeCode, BuildStep, CONTENT_ROLE_MEANINGS, CREDITS_PER_USD, CardBindTarget, CheckSeverity, ComposeError, ComposeIssueCode, ContentRole, ContentTypeAction, CreatedKind, DANGLING_LINK_CODES, DEFAULT_PHONE_MENU_BREAKPOINT, DEFAULT_SITE_LOCALE, ENTRANCE_EASING, ENTRANCE_ORIGIN_LOOK, ENTRANCE_TRIGGER, EntrancePart, EntranceSide, FACT_KEYS, FINAL_GENERATION_STAGES, FINDING_SEVERITY, GRAMMAR_TOO_LARGE_MESSAGE, GlobalSlot, HEBREW_PREFIXES, JSON_SCHEMA_BANNED_KEYWORDS, JsonSchemaShapeError, KeptReason, NAV_PART_LABELS, NAV_SHAPE_COPY, NEUTRAL_STYLE_PROPS, NODE_BASELINES, NO_TOKENS, NavPagesSource, NavRole, NavShape, NavShapeError, PAGE_ARCHETYPES, PLAN_EDITS_ANSWER_SHAPES, PLAN_EDITS_PART_SCHEMA_NAMES, PLAN_EDIT_OP_PART, PLAN_EDIT_SHAPE, PLAN_EDIT_WIRE_KEYS, PLAN_PARTS, PLAN_PART_KEYS, PLAN_WIRE_DERIVED, PLAN_WIRE_PART_SCHEMA_NAMES, PLAN_WIRE_SHAPE, PRICING_PATTERN, PUBLISH_BLOCKING_PLACEHOLDERS, PageDataKind, PathIssueCollector, PatternDirective, PatternGlobalPosition, PatternOpens, PatternPlaceholder, PatternRecipe, PhoneMenuBreakpoint, PlaceholderKind, PlanChangeAction, PlanChangeKind, PlanDataSourceMode, PlanDataSourceType, PlanEditIssueCode, PlanEditOp, PlanEditsOutcome, PlanPart, PlanWireEntry, PlanWireShapeError, PlanWordIssueCode, PreflightRefusalCode, PublishRefusalCode, REQUIRED_CONTENT_ROLES, RelativeOp, SAMPLE_IMAGE_REF, SITE_CHECKS, SITE_FACT_LABELS, SITE_HEADER_PATTERN, SITE_LIBRARY, SITE_LOCALES, SITE_NEED_IDS, SITE_PATTERNS, SITE_PLAN_VERSION, SITE_TEMPLATES, SPEC_SITE_ARCHETYPES, SPEC_SITE_COPY_LENGTHS, SPEC_SITE_DENSITY_COPY, SPEC_SITE_FACTS, SPEC_SITE_LIBRARY, SPEC_SITE_LOCALES, SPEC_SITE_NEED_IDS, SPEC_SITE_PATTERNS, SPEC_SITE_PLAN_SHAPE, SPEC_SITE_REQUIRED_ROLES, SPEC_SITE_ROLES, SPEC_SITE_TEMPLATES, STOCK_FAMILIES, STOCK_PROVIDER_TERMS, STRICT_SCHEMA_BUDGET, STRICT_SCHEMA_LIMITS, STUDIO_TEMPLATE, SiteBuildKind, SiteBuildStatus, SiteCheckId, SiteFindingCode, SiteLocale, SitePlanError, SitePlanIssueCode, SitePlanSourceKind, SiteTemplateError, SiteTemplateId, StepState, StockProviderId, addBarItem, addStockCredits, aiStepParts, applyPlanEdits, applyStockPhotos, archetypeIssues, assertStyleSlots, assertValidSitePlan, auditSite, barIconForRoute, blocksPublish, buildKeys, buildStepFacts, builtHomePageId, composeNavHeader, composeSection, composeSite, contentTypePreviewFields, contentTypeToWire, copyLengthOf, costUsd, createSerializedNode, creditsOfUsd, dataSourceToWire, describePlanData, describeShapeKey, entranceAction, entranceInteraction, estimateStepCredits, expandPlanWire, expandWireContentType, expandWireDataSource, expandWireEdit, expandWireField, expandWirePage, expandWireSection, failedBuildStep, fieldToWire, findNavRoot, isActiveBuild, isNonEmptyString, isPlainObject, isRtlLocale, jsonAnyOf, jsonBoolean, jsonClosedObject, jsonInteger, jsonListOf, jsonOneOf, jsonSchemaKeywords, jsonSchemaObjects, jsonShapedObject, jsonText, modelCanDo, moveBarItem, navPages, navShapeBreakpoint, navShapeOf, nextSourceOf, nodeBindPaths, pageToWire, parsePatternPath, parseSampleImageRef, pathAt, patternById, patternHasForm, patternLinkSlots, patternManifest, patternNeedsBinding, patternNodes, patternOptionalParts, patternRoleNeeds, patternScopes, patternSlotBudgets, patternSlots, patternTakesBinding, phoneMenuPages, planEditOps, planEditToWire, planEditWireGaps, planEditWireKeys, planEditWireOps, planEditWireShape, planEditsFromWire, planEditsJsonSchema, planEditsToWire, planEntrances, planFromTemplate, planNavShape, planPartOfPath, planPartToWire, planStockPhotos, planToWire, planWireGaps, planWirePartJsonSchema, planWirePartShape, planWordIssues, publishRefusal, publishVerdict, releasedLayoutDefaults, removeBarItem, requiredAcknowledgements, requiredShapeKeys, roleField, routeMatches, routeParams, sampleImageRef, sectionEntrances, sectionPatternIds, sectionToWire, setStyleProps, shapeKeys, showcaseGlobals, showcasePages, showcasePlans, siteNavPages, slotBudget, stockCopyKey, stockCreditLine, stockCreditLines, stockCreditNode, stockCreditNodeId, stockSlots, strictSchemaComplexity, strictSchemaRefusal, typicalStepTokens, validatePlanEdits, validateSitePlan, walkSerialized, wireContentTypeJsonSchema, wireDataSourceJsonSchema, wireFieldJsonSchema, wirePageJsonSchema, wireSectionJsonSchema, wordPattern, writtenTexts };
+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, PlanWireParts, 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, WireOptions, WrittenText };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectoriox/iox-ui",
-  "version": "5.60.0",
+  "version": "5.62.0",
   "peerDependencies": {
     "@angular/common": ">=20.0.0",
     "@angular/core": ">=20.0.0",

package/src/generation-core/ai-run.ts

@@ -1,3 +1,5 @@
+import { PLAN_PARTS, PlanPart } from './plan-wire';
+
 /**
  * The AI pipeline's WIRE vocabulary (AI plan §3c, §3n, M0): what iox-cms's `ai` API answers and what every client
  * of it reads — the steps a model works on, who pays (IOX credits or the studio's own key), a model of the vetted
@@ -54,11 +56,41 @@ export const AI_STEP_NEEDS: Readonly<Record<AiStep, ReadonlyArray<AiCapability>>
     [AiStep.NameStructures]: [AiCapability.StructuredOutput],
 };
 
-/** Tokens a typical use of a step reads and writes (plan §3d "Where credits go") — what a shown estimate is made of. */
+/**
+ * The steps a model answers in the plan's parts, one request per part (vectoriox/iox-cms#47 — the whole plan's format
+ * compiles to a grammar Claude refuses), and the tokens a typical request of each part reads and writes. Each part reads
+ * the same instructions; the pages read the structure too and write most of the words.
+ */
+export const AI_STEP_PART_TOKENS: Readonly<Partial<Record<AiStep, Readonly<Record<PlanPart, AiTokenCounts>>>>> = {
+    [AiStep.PlanSite]: {
+        [PlanPart.Structure]: { input: 10_000, output: 1_500, cacheWrite: 0, cacheRead: 0 },
+        [PlanPart.Pages]: { input: 12_000, output: 5_500, cacheWrite: 0, cacheRead: 0 },
+    },
+    [AiStep.ChangePlan]: {
+        [PlanPart.Structure]: { input: 6_000, output: 300, cacheWrite: 0, cacheRead: 0 },
+        [PlanPart.Pages]: { input: 6_500, output: 400, cacheWrite: 0, cacheRead: 0 },
+    },
+};
+
+/** The parts a step is asked in, in order — none for a step asked in one request. */
+export function aiStepParts(step: AiStep): ReadonlyArray<PlanPart> {
+    return AI_STEP_PART_TOKENS[step] ? PLAN_PARTS : [];
+}
+
+const addTokens = (a: AiTokenCounts, b: AiTokenCounts): AiTokenCounts => ({
+    input: a.input + b.input, output: a.output + b.output, cacheWrite: a.cacheWrite + b.cacheWrite, cacheRead: a.cacheRead + b.cacheRead,
+    ...(a.imageOutput !== undefined || b.imageOutput !== undefined ? { imageOutput: (a.imageOutput ?? 0) + (b.imageOutput ?? 0) } : {}),
+});
+const partsTotal = (step: AiStep): AiTokenCounts => PLAN_PARTS.map(part => AI_STEP_PART_TOKENS[step]![part]).reduce(addTokens);
+
+/**
+ * Tokens a typical use of a step reads and writes (plan §3d "Where credits go") — what a shown estimate is made of. A
+ * step asked in parts is every part's request together, so the estimate (and a generation's start gate) counts them all.
+ */
 export const AI_STEP_TYPICAL_TOKENS: Readonly<Record<AiStep, AiTokenCounts>> = {
     [AiStep.ReadMessage]: { input: 8_800, output: 1_500, cacheWrite: 0, cacheRead: 0 },
-    [AiStep.PlanSite]: { input: 12_000, output: 7_000, cacheWrite: 0, cacheRead: 0 },
-    [AiStep.ChangePlan]: { input: 6_000, output: 500, cacheWrite: 0, cacheRead: 0 },
+    [AiStep.PlanSite]: partsTotal(AiStep.PlanSite),
+    [AiStep.ChangePlan]: partsTotal(AiStep.ChangePlan),
     // a 1 K picture is 1,120 image tokens (Google's figure for Nano Banana 2) — I-D4
     [AiStep.MakePictures]: { input: 0, output: 0, cacheWrite: 0, cacheRead: 0, imageOutput: 1_120 },
     [AiStep.NameStructures]: { input: 80_000, output: 10_000, cacheWrite: 0, cacheRead: 0 },
@@ -126,6 +158,11 @@ export function creditsOfUsd(usd: number): number {
     return Math.round(usd * CREDITS_PER_USD * CREDIT_PRECISION) / CREDIT_PRECISION;
 }
 
+/** What a typical request of `step` reads and writes — one part's when the step is asked in parts, else the whole step's. */
+export function typicalStepTokens(step: AiStep, part?: PlanPart): AiTokenCounts {
+    return (part && AI_STEP_PART_TOKENS[step]?.[part]) || AI_STEP_TYPICAL_TOKENS[step];
+}
+
 /** The credits a typical use of `step` costs on a model of `price` — never typed, always computed (§3d). */
 export function estimateStepCredits(step: AiStep, price: AiTokenPrice, tokens: AiTokenCounts = AI_STEP_TYPICAL_TOKENS[step]): number {
     return creditsOfUsd(costUsd(tokens, price));