@aglyn/plugins-ai 1.0.0-beta.229 → 1.0.0-beta.231

package/src/lib/runtime/ai-doctrine-validators.d.ts

@@ -382,6 +382,53 @@ export declare function detectAdHocWidths(tree: AiDoctrineTree, outputKind: AiOu
  * absent, and only what was written can name them.
  */
 export declare function detectUnresponsiveGrids(tree: AiDoctrineTree, outputKind: AiOutputKind, written?: (id: string) => unknown): AiDoctrineViolation[];
+/**
+ * Rule 12's `grid-item-size`, settled before the check reads it where it has
+ * one answer (AGL-3596), as `aiSettlePlanRefs` settles a plan. The re-ask for
+ * it states the very size to write, and a production Home page was refused and
+ * refunded after its re-ask still left a container's items unsized: the model
+ * breaks a different rule each run, and a rule whose answer the validator
+ * already knows is applied rather than asked for.
+ *
+ * For every Grid container, its items are read exactly as
+ * `detectUnresponsiveGrids` counts them, a Box or a Stack holding nothing but
+ * sized Grid items lending its items to the container:
+ *
+ * - an item whose size is missing, or is not full width on a phone, takes the
+ *   size the model wrote as an object of breakpoints where that one is full
+ *   width on a phone, and otherwise the size the re-ask would ask for
+ *   (`gridItemSizeFor`);
+ * - an element that is no Grid, directly in the container, is wrapped in a new
+ *   Grid item of that size, minted the way the palette validator mints ids;
+ * - a container of several items none of which steps down to columns at a
+ *   larger width takes that size on every item, which is what the re-ask asks;
+ * - a `container` written as the text "true" in any case or spacing
+ *   (`grid-container-text`) is true, since it can mean nothing else.
+ *
+ * A size that is already full width on a phone is kept. Nothing else rule 12
+ * names is touched: a Grid that is not a container may be meant as a row or as
+ * a stack (`grid-not-container`, `grid-as-stack`), and a sized item inside a
+ * Box (`grid-item-outside-container`) is moved only by changing the Box.
+ *
+ * `written` is the node as the model wrote it, by an id of `tree`, as
+ * `detectUnresponsiveGrids` reads it, for a tree the palette validator has
+ * read; a tree as the model wrote it is read as it stands, which is how the
+ * tree check settles a layout, a template or a component (`aiSettleWrittenGridItems`).
+ * A tree with nothing to settle comes back
+ * as the same object, so settling is idempotent. A node that is changed is
+ * copied, never edited in place.
+ */
+export declare function aiSettleGridItems<T extends AiDoctrineTree>(tree: T, options?: {
+    written?: (id: string) => unknown;
+    mintId?: () => string;
+}): T;
+/**
+ * `aiSettleGridItems` on a tree as the model wrote it, before the palette
+ * validator reads it (AGL-3596): the tree check every kind but a page section
+ * goes through stores what the validator makes of its answer, so the answer
+ * is settled first. Anything that is no flat node map comes back as it was.
+ */
+export declare function aiSettleWrittenGridItems(input: unknown): unknown;
 /** Whether an element is one rule 10 holds to a destination: a Button or a Screen Link. */
 export declare function isAiLinkElement(componentId: unknown): boolean;
 /**
@@ -576,6 +623,41 @@ export declare function estimateAiOutputLoad(score: AiOutputScore, outputKind: A
  * validator drops anything, so a re-ask can quote the node at fault.
  */
 export declare function detectDisagreeingNodes(input: unknown): AiDoctrineViolation[];
+/**
+ * A node map that does not agree with itself, settled where it has one
+ * reading (AGL-3596), before `detectDisagreeingNodes` reads it. A guided
+ * start's Home page stopped on each of these after its re-ask, and each is
+ * one line the model left out, not a choice it made.
+ *
+ * - A name listed under `nodes` that the map never holds is taken out of the
+ *   list: there is nothing written to place there.
+ * - An element written and listed by nobody goes where the model said it
+ *   goes, when its own `parentId` names an element the tree reaches that can
+ *   hold it. Failing that, a single such element goes in the single element
+ *   the tree reaches that can hold elements and holds none, which is the shape
+ *   of a row whose item was written beside it. Failing both, it is dropped,
+ *   with everything under it: nothing on the page holds it, and none of it
+ *   would ever be shown.
+ * - A repeated item (`repeat`) is the exception: dropping it would lose every
+ *   card it draws, so one that cannot be placed is left for the re-ask.
+ *
+ * Reads and returns the tree as the model wrote it; an input with nothing to
+ * settle comes back as the same object.
+ */
+export declare function aiSettleDisagreeingNodes(input: unknown): unknown;
+/**
+ * A heading written past the headline ceiling, settled where it has one
+ * reading (AGL-3596). The palette validator cuts such a line where the
+ * ceiling falls, mid-word, and the check refuses the cut (rule 14,
+ * `copy-cut-at-ceiling`); live guided starts' heroes stopped on it after
+ * their re-ask. A heading whose first sentence or clause ends within the
+ * ceiling is a whole line already, so it is kept to that, its later words
+ * dropped: "Free inspections after a storm, with photos of every shingle we
+ * replace and a written…" becomes "Free inspections after a storm". A heading
+ * with no such boundary, or whose part within is a stub, is left for the
+ * re-ask. Reads and returns the tree as the model wrote it.
+ */
+export declare function aiSettleCutHeadings(input: unknown): unknown;
 export interface AiDoctrineTreeReport {
     ok: boolean;
     /** The palette validator's result: the tree to store, its repairs and its id map. */
@@ -621,6 +703,25 @@ export declare const AI_SPLIT_LIST_MIN_SECTIONS = 2;
  * are two lists, and rule 8 counts each within its own section (AGL-3061).
  */
 export declare function detectPlanSplitLists(plan: AiBuildPlan, inventory: AiSiteInventory | null, capabilities?: AiPlanCapabilities | null): AiDoctrineViolation[];
+/**
+ * A `new:` reference that spells a creation differently — `new:cake-order-form`
+ * for "Cake order form" (a live bakery plan, 2026-10-07) — is pointed at that
+ * creation before the rules read the plan, when exactly one creation matches
+ * it with case, spaces and punctuation ignored. Two that match, or none, are
+ * left for the rules to ask about.
+ */
+export declare function aiSettlePlanRefs(plan: AiBuildPlan): AiBuildPlan;
+/**
+ * A page that names no layout, on a site where only one layout can frame it,
+ * is put in that layout before the rules read the plan (2026-10-07). The
+ * model sometimes leaves one page's layout empty — a live run's bookkeeper
+ * plan did, beside a layout it created — and rule 2 refused the whole plan
+ * for a choice with one answer. That answer exists only on a site with no
+ * layout whose plan creates exactly one, which is every guided start. Where
+ * the site has a layout of its own, a page that names none may mean another,
+ * so the rule still asks.
+ */
+export declare function aiSettlePlanLayouts(plan: AiBuildPlan, inventory: AiSiteInventory | null, capabilities?: AiPlanCapabilities | null): AiBuildPlan;
 /**
  * Rule 2 (plan): every screen declares a layout, no section is a copy of a
  * layout region, and no section places a layout, which frames a whole screen