@formancy/builder-core 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -1,5 +1,122 @@
+import { FieldDef, FormSchema, LayoutNode, LogicRule, SpecVersion, Text } from "@formancy/spec";
 import { SchemaError } from "@formancy/spec/validate";
-import { FieldDef, FormSchema, LogicRule } from "@formancy/spec";
+//#region src/authoring.d.ts
+/**
+ * Writing a form from an instruction, and refusing to hand back one that does not work.
+ *
+ * The answer is **checked, and the model is told what was wrong with it and asked
+ * again**: the format has a published JSON Schema and the expressions type-check, so
+ * both failures come back as sentences a model can act on — `no such overload: double *
+ * int … write 4.0` — rather than as a stack trace. Nothing reaches the editor until it
+ * would work.
+ *
+ * **The model is the host's.** `AskModel` is supplied exactly as `Uploader` is: no
+ * vendor, no API key, no network call and no opinion about who pays for tokens.
+ */
+/** One turn with whatever model the host has. Text in, text out. */
+type AskModel = (prompt: AuthoringPrompt) => Promise<string>;
+interface AuthoringPrompt {
+  /** What the model is, and the rules of the format. Stable across turns. */
+  readonly system: string;
+  /** The instruction, plus whatever went wrong last time. */
+  readonly user: string;
+}
+/**
+ * Why an attempt was rejected, in the words the model is given back.
+ *
+ * `logic` is the engine refusing to open the document at all — a misspelled
+ * field, a cycle, a condition that is not certain to be a bool — and
+ * `expression` is one it would open whose rule then never does anything.
+ */
+interface AuthoringProblem {
+  readonly kind: 'not-json' | 'invalid-document' | 'logic' | 'expression';
+  readonly detail: string;
+}
+type AuthoringResult = {
+  readonly ok: true;
+  readonly document: FormSchema;
+  readonly attempts: number;
+} | {
+  readonly ok: false;
+  readonly attempts: number;
+  readonly problems: readonly AuthoringProblem[];
+  /** The last thing the model said, so a person can see what went wrong. */
+  readonly lastAnswer: string;
+};
+interface AuthoringOptions {
+  /**
+   * How many times to ask. Three by default: the first answer, one correction,
+   * and one more for the mistake the correction introduced. Past that a model
+   * is usually circling rather than converging, and a person reading four
+   * failed attempts is better served by the first error than the fourth.
+   */
+  readonly attempts?: number;
+  /**
+   * The document being edited, when there is one. Its presence changes the
+   * instruction from "write a form" to "change this form", which is a
+   * different request and produces a different answer.
+   */
+  readonly current?: FormSchema;
+}
+export declare function authorForm(ask: AskModel, instruction: string, options?: AuthoringOptions): Promise<AuthoringResult>;
+//#endregion
+//#region src/layout.d.ts
+/**
+ * Navigating an arrangement.
+ *
+ * A layout node has no key. A field is `contact.email` wherever it sits; a row
+ * is "the second thing inside the third thing", and every insert or removal
+ * renumbers its neighbours. So a layout address is an index path, and these
+ * helpers exist because reading one wrong is silent — you edit a different
+ * node and the document stays valid.
+ *
+ * Kept apart from the field commands rather than folded in beside them,
+ * because the two addressing schemes look alike and are not: `['a','b']` is a
+ * key path into the model and `[0, 1]` is a position path into one layout, and
+ * a function that took either would be a function that could confuse them.
+ */
+/** Where a layout node goes: which arrangement, which container, which slot. */
+interface LayoutLocation {
+  /** The layout's name. Arrangements are asked for by name, never by index. */
+  layout: string;
+  /** Index path of the container, root-first. `[]` is the layout itself. */
+  parent: readonly number[];
+  index: number;
+}
+/** A layout node's address. `path` is never empty — that would be the layout. */
+interface LayoutAddress {
+  layout: string;
+  path: readonly number[];
+}
+/** The kinds that hold other nodes. A `field` node is a leaf. */
+export declare const LAYOUT_CONTAINER_KINDS: readonly ["section", "row", "column"];
+type LayoutContainerKind = (typeof LAYOUT_CONTAINER_KINDS)[number];
+export declare function isLayoutContainer(node: LayoutNode): node is Extract<LayoutNode, {
+  children: LayoutNode[];
+}>;
+/** The named layout's top-level node list, or undefined if there is no such layout. */
+export declare function nodesOfLayout(document: FormSchema, name: string): LayoutNode[] | undefined;
+/**
+ * The child list of the container at `parent` — the layout's own list for `[]`.
+ *
+ * Undefined rather than empty when the path points at a field or at nothing,
+ * so a caller cannot insert into a leaf and get an array nobody reads back.
+ */
+declare function childrenAt(document: FormSchema, layout: string, parent: readonly number[]): LayoutNode[] | undefined;
+/** The node at `path`, or undefined. An empty path addresses no node. */
+declare function nodeAt(document: FormSchema, layout: string, path: readonly number[]): LayoutNode | undefined;
+/** Every container's index path in one layout, the layout itself first. */
+declare function containerPaths(document: FormSchema, layout: string): number[][];
+/** Whether `maybeAncestor` is `path` itself or encloses it. */
+declare function encloses(maybeAncestor: readonly number[], path: readonly number[]): boolean;
+/**
+ * A human name for one layout node, for a tree row and for an announcement.
+ *
+ * A row has nothing to call itself, so it is named by what it holds: "Row with
+ * First name and Last name" is findable in a list of six rows and "Row" is not.
+ */
+declare function describeNode(node: LayoutNode, nameOfPath: (path: string) => string): string;
+//#endregion
 //#region src/session.d.ts
 /**
  * The headless document engine under the form builder.
@@ -56,6 +173,18 @@ interface BuilderSession {
   };
   /** One notification per accepted command, undo or redo. */
   subscribe(listener: () => void): () => void;
+  /**
+   * Take a whole document, as ONE undoable edit.
+   *
+   * For a change that is not an edit to the document so much as a different
+   * document — a form written from an instruction, or a paste into the
+   * schema editor. It goes through the same validator every other command
+   * does, so a session can never come to hold something invalid, and it lands
+   * on the undo stack as a single step: Ctrl+Z after "write me a contact form"
+   * puts back what was there before, which is the only behaviour anybody
+   * would expect.
+   */
+  replaceDocument(next: FormSchema): CommandOutcome;
   insertField(location: Location, def: FieldDef): CommandOutcome;
   removeField(keyPath: readonly string[]): CommandOutcome;
   moveField(from: readonly string[], to: Location): CommandOutcome;
@@ -69,8 +198,77 @@ interface BuilderSession {
    * definition) or an existing field being moved (pass its key path).
    */
   validTargets(what: FieldDef | readonly string[]): Location[];
+  addLayout(name: string): CommandOutcome;
+  removeLayout(name: string): CommandOutcome;
+  insertLayoutNode(location: LayoutLocation, node: LayoutNode): CommandOutcome;
+  removeLayoutNode(address: LayoutAddress): CommandOutcome;
+  /** Replace a container with its children, in order, where it stood. */
+  unwrapLayoutNode(address: LayoutAddress): CommandOutcome;
+  /**
+   * Put several nodes inside a new container, where the earliest of them stood.
+   *
+   * The inverse of `unwrapLayoutNode`, and what "drop this field beside that
+   * one" compiles to. The addresses need NOT be siblings — the field being
+   * dragged is usually somewhere else — and the new container's children follow
+   * the order the addresses are given in, because the side somebody dropped on
+   * is what decides which field ends up on the left.
+   *
+   * One command rather than a move plus a wrap, so one gesture is one undo. A
+   * gesture that takes three presses of undo to reverse is one people stop
+   * trusting.
+   */
+  wrapLayoutNodes(layout: string, addresses: ReadonlyArray<readonly number[]>, container: LayoutNode,
+  /**
+   * Which of the addresses the new container takes the position of.
+   *
+   * Defaults to the earliest in document order, which is right when there is
+   * no reason to prefer one. A DROP has one: the new row belongs where the
+   * thing dropped ON was, not where the thing being dragged came from --
+   * otherwise dragging a field out of a row and onto a top-level field nests
+   * the new row inside the old one, which is not what anybody aimed at.
+   *
+   * Separate from the order of `addresses` because the two are independent:
+   * dropping on the left makes the dragged node the first child while the
+   * position still comes from the target, which is the second address.
+   */
+  positionOf?: readonly number[]): CommandOutcome;
+  moveLayoutNode(from: LayoutAddress, to: LayoutLocation): CommandOutcome;
+  setLayoutNodeLabel(address: LayoutAddress, label: Text | undefined): CommandOutcome;
+  /**
+   * Set any property the format gives a layout node, or remove it with `undefined`.
+   *
+   * Generic on purpose: the builder's panel is generated from the JSON Schema, so a
+   * command per property would have to be remembered every time the format grows one.
+   * `span` arrived and had no way to be set at all
+   * ([0074](../../../docs/decisions/0074-a-table-child-may-span.md)); so had a table's
+   * `columns` and a section's `label`, since the day layouts existed.
+   *
+   * `kind`, `children` and `path` are refused: the first is what the node IS, the
+   * second is structure the tree edits, and the third is which answer a placement
+   * places — all three have their own commands that keep the document consistent.
+   *
+   * Like every command here it is attempted against the validator, so an illegal value
+   * leaves the document where it was rather than requiring the panel to know the rules.
+   */
+  setLayoutNodeProperty(address: LayoutAddress, property: string, value: unknown): CommandOutcome;
+  /**
+   * Every position a layout node may legally occupy: a new node (pass it) or
+   * an existing one being moved (pass its index path).
+   */
+  validLayoutTargets(layout: string, what: LayoutNode | readonly number[]): LayoutLocation[];
+  /** Data paths the named layout does not place. Empty for an unknown layout. */
+  unplacedFields(layout: string): string[];
+  /**
+   * Move the document to a newer spec version.
+   *
+   * One line of document change, undoable like any other command, and the
+   * reason it is a command at all: the builder offers the newer field types
+   * only to a document that allows them, so somebody who wants one has to be
+   * able to say yes from inside the builder rather than by editing JSON.
+   */
+  upgradeSpec(to?: SpecVersion): CommandOutcome;
 }
 export declare function createBuilderSession(initial: FormSchema): BuilderSession;
 //#endregion
-export type { BuilderSession, CommandOutcome, Location, Refusal };
+export { type AskModel, type AuthoringOptions, type AuthoringProblem, type AuthoringPrompt, type AuthoringResult, type BuilderSession, type CommandOutcome, type LayoutAddress, type LayoutContainerKind, type LayoutLocation, type Location, type Refusal, describeNode as describeLayoutNode, childrenAt as layoutChildrenAt, containerPaths as layoutContainerPaths, encloses as layoutEncloses, nodeAt as layoutNodeAt };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/session.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;UA0BiB;EACf;;EAEA;EACA;;KAGU;EAAmB;EAAU,UAAU;IAAe;;UAGjD;EACf;EACA;;UAGe;;EAEf,YAAY;;EAEZ,kBAAkB;;EAElB;EACA;EACA;EACA;EACA;;EAEA;IAAgB;IAAgB,QAAQ;;;EAExC,UAAU;EAEV,YAAY,UAAU,UAAU,KAAK,WAAW;EAChD,YAAY,6BAA6B;EACzC,UAAU,yBAAyB,IAAI,WAAW;EAClD,YAAY,4BAA4B,iBAAiB;EACzD,iBAAiB,4BAA4B,kBAAkB,iBAAiB;EAChF,QAAQ,MAAM,YAAY;EAC1B,WAAW,eAAe,MAAM,YAAY;EAC5C,WAAW,gBAAgB;;;;;EAM3B,aAAa,MAAM,+BAA+B;;wBAKpC,qBAAqB,SAAS,aAAa"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/authoring.ts","../src/layout.ts","../src/session.ts"],"mappings":";;;;;;;;;;;;;;;;KAmBY,YAAY,QAAQ,oBAAoB;UAEnC;;WAEN;;WAEA;;;;;;;;;UAUM;WACN;WACA;;KAGC;WACG;WAAmB,UAAU;WAAqB;;WAElD;WACA;WACA,mBAAmB;;WAEnB;;UAGE;;;;;;;WAON;;;;;;WAMA,UAAU;;wBAKC,WACpB,KAAK,UACL,qBACA,UAAS,mBACR,QAAQ;;;;;;;;;;;;;;;;;;UCrDM;;EAEf;;EAEA;EACA;;;UAIe;EACf;EACA;;;qBAIW;KAED,8BAA8B;wBAE1B,kBACd,MAAM,aACL,QAAQ,QAAQ;EAAc,UAAU;;;wBAQ3B,cAAc,UAAU,YAAY,eAAe;;;;;;;iBAUnD,WACd,UAAU,YACV,gBACA,4BACC;;iBAYa,OACd,UAAU,YACV,gBACA,0BACC;;iBAOa,eAAe,UAAU,YAAY;;iBAkBrC,SAAS,kCAAkC;;;;;;;iBAe3C,aAAa,MAAM,YAAY,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;UCjF3C;EACf;;EAEA;EACA;;KAGU;EAAmB;EAAU,UAAU;IAAe;;UAGjD;EACf;EACA;;UAGe;;EAEf,YAAY;;EAEZ,kBAAkB;;EAElB;EACA;EACA;EACA;EACA;;EAEA;IAAgB;IAAgB,QAAQ;;;EAExC,UAAU;;;;;;;;;;;;EAaV,gBAAgB,MAAM,aAAa;EAEnC,YAAY,UAAU,UAAU,KAAK,WAAW;EAChD,YAAY,6BAA6B;EACzC,UAAU,yBAAyB,IAAI,WAAW;EAClD,YAAY,4BAA4B,iBAAiB;EACzD,iBAAiB,4BAA4B,kBAAkB,iBAAiB;EAChF,QAAQ,MAAM,YAAY;EAC1B,WAAW,eAAe,MAAM,YAAY;EAC5C,WAAW,gBAAgB;;;;;EAM3B,aAAa,MAAM,+BAA+B;EAIlD,UAAU,eAAe;EACzB,aAAa,eAAe;EAC5B,iBAAiB,UAAU,gBAAgB,MAAM,aAAa;EAC9D,iBAAiB,SAAS,gBAAgB;;EAE1C,iBAAiB,SAAS,gBAAgB;;;;;;;;;;;;;;EAc1C,gBACE,gBACA,WAAW,kCACX,WAAW,YAcX;;;;;;;;;;;;;;EAAA,iCACC;EACH,eAAe,MAAM,eAAe,IAAI,iBAAiB;EACzD,mBAAmB,SAAS,eAAe,OAAO,mBAAmB;;;;;;;;;;;;;;;;;EAiBrE,sBACE,SAAS,eACT,kBACA,iBACC;;;;;EAMH,mBAAmB,gBAAgB,MAAM,iCAAiC;;EAG1E,eAAe;;;;;;;;;EAUf,YAAY,KAAK,cAAc;;wBAcjB,qBAAqB,SAAS,aAAa"}

package/dist/index.mjs

@@ -1,10 +1,214 @@
+import { CURRENT_SPEC_VERSION, LAYOUT_LEAF_KINDS, authoringBriefing, canonicalize, layoutChildren, unreferencedPaths } from "@formancy/spec";
 import { validateSchema } from "@formancy/spec/validate";
+import { engineRefusal, expressionProblems } from "@formancy/core";
+//#region src/authoring.ts
+const DEFAULT_ATTEMPTS = 3;
+async function authorForm(ask, instruction, options = {}) {
+	const limit = Math.max(1, options.attempts ?? DEFAULT_ATTEMPTS);
+	const system = authoringBriefing();
+	const problems = [];
+	let lastAnswer = "";
+	for (let attempt = 1; attempt <= limit; attempt += 1) {
+		const answer = await ask({
+			system,
+			user: userPrompt(instruction, options.current, problems)
+		});
+		lastAnswer = answer;
+		const parsed = readDocument(answer);
+		if (parsed === void 0) {
+			problems.push({
+				kind: "not-json",
+				detail: "That was not JSON. Answer with the document alone: no commentary, no code fence."
+			});
+			continue;
+		}
+		const validated = validateSchema(parsed);
+		if (!validated.valid) {
+			problems.push({
+				kind: "invalid-document",
+				detail: validated.errors.map((error) => `${error.path}: ${error.message}`).join("\n")
+			});
+			continue;
+		}
+		const refusal = engineRefusal(parsed);
+		if (refusal !== void 0) {
+			problems.push({
+				kind: "logic",
+				detail: refusal
+			});
+			continue;
+		}
+		const silent = expressionProblems(parsed);
+		if (silent.length > 0) {
+			problems.push({
+				kind: "expression",
+				detail: silent.map((problem) => problem.message).join("\n")
+			});
+			continue;
+		}
+		return {
+			ok: true,
+			document: parsed,
+			attempts: attempt
+		};
+	}
+	return {
+		ok: false,
+		attempts: limit,
+		problems,
+		lastAnswer
+	};
+}
+/**
+* The instruction, and what went wrong last time.
+*
+* Only the most recent problem is repeated. A model given three rounds of
+* accumulated complaints starts fixing the first one again.
+*/
+function userPrompt(instruction, current, problems) {
+	const parts = [];
+	if (current !== void 0) {
+		parts.push("Here is the current document. Change it as asked and answer with the whole thing:");
+		parts.push(canonicalize(current));
+		parts.push("");
+	}
+	parts.push(instruction);
+	const last = problems.at(-1);
+	if (last !== void 0) {
+		parts.push("");
+		parts.push("Your previous answer was rejected. Fix exactly this and answer again:");
+		parts.push(last.detail);
+	}
+	return parts.join("\n");
+}
+/**
+* The document out of whatever the model said.
+*
+* Models put JSON in code fences and add a sentence in front of it however
+* firmly they are told not to, and refusing those answers would spend a turn
+* on formatting rather than on the form. So a fence is stripped and, failing
+* that, the outermost braces are taken. Anything looser would start accepting
+* prose that happens to contain a bracket.
+*/
+function readDocument(answer) {
+	const candidates = [
+		/```(?:json)?\s*([\s\S]*?)```/.exec(answer)?.[1],
+		answer,
+		betweenBraces(answer)
+	];
+	for (const candidate of candidates) {
+		if (candidate === void 0) continue;
+		try {
+			const parsed = JSON.parse(candidate.trim());
+			if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+		} catch {}
+	}
+}
+function betweenBraces(answer) {
+	const start = answer.indexOf("{");
+	const end = answer.lastIndexOf("}");
+	return start === -1 || end <= start ? void 0 : answer.slice(start, end + 1);
+}
+//#endregion
+//#region src/layout.ts
+/** The kinds that hold other nodes. A `field` node is a leaf. */
+const LAYOUT_CONTAINER_KINDS = [
+	"section",
+	"row",
+	"column"
+];
+function isLayoutContainer(node) {
+	return !LAYOUT_LEAF_KINDS.has(node.kind);
+}
+/** The named layout's top-level node list, or undefined if there is no such layout. */
+function nodesOfLayout(document, name) {
+	return document.layouts?.find((layout) => layout.name === name)?.nodes;
+}
+/**
+* The child list of the container at `parent` — the layout's own list for `[]`.
+*
+* Undefined rather than empty when the path points at a field or at nothing,
+* so a caller cannot insert into a leaf and get an array nobody reads back.
+*/
+function childrenAt(document, layout, parent) {
+	let nodes = nodesOfLayout(document, layout);
+	if (nodes === void 0) return void 0;
+	for (const step of parent) {
+		const node = nodes[step];
+		if (node === void 0 || !isLayoutContainer(node)) return void 0;
+		nodes = node.children;
+	}
+	return nodes;
+}
+/** The node at `path`, or undefined. An empty path addresses no node. */
+function nodeAt(document, layout, path) {
+	if (path.length === 0) return void 0;
+	return childrenAt(document, layout, path.slice(0, -1))?.[path[path.length - 1]];
+}
+/** Every container's index path in one layout, the layout itself first. */
+function containerPaths(document, layout) {
+	const nodes = nodesOfLayout(document, layout);
+	if (nodes === void 0) return [];
+	const paths = [[]];
+	const walk = (children, prefix) => {
+		for (const [index, node] of children.entries()) {
+			if (!isLayoutContainer(node)) continue;
+			const here = [...prefix, index];
+			paths.push(here);
+			walk(node.children, here);
+		}
+	};
+	walk(nodes, []);
+	return paths;
+}
+/** Whether `maybeAncestor` is `path` itself or encloses it. */
+function encloses(maybeAncestor, path) {
+	if (maybeAncestor.length > path.length) return false;
+	return maybeAncestor.every((step, at) => path[at] === step);
+}
+function samePath(a, b) {
+	return a.length === b.length && a.every((step, at) => b[at] === step);
+}
+/**
+* A human name for one layout node, for a tree row and for an announcement.
+*
+* A row has nothing to call itself, so it is named by what it holds: "Row with
+* First name and Last name" is findable in a list of six rows and "Row" is not.
+*/
+function describeNode(node, nameOfPath) {
+	if (node.kind === "field") return nameOfPath(node.path);
+	if (node.kind === "qrcode") return `Code for ${nameOfPath(node.path)}`;
+	const label = typeof node.label === "string" ? node.label : void 0;
+	const kind = node.kind[0].toUpperCase() + node.kind.slice(1);
+	if (label !== void 0) return `${kind} “${label}”`;
+	const inside = layoutChildren(node).map((child) => shortNameOf(child, nameOfPath));
+	if (inside.length === 0) return `Empty ${node.kind}`;
+	return `${kind} with ${listOf(inside)}`;
+}
+function shortNameOf(node, nameOfPath) {
+	if (node.kind === "field") return nameOfPath(node.path);
+	if (node.kind === "qrcode") return `code for ${nameOfPath(node.path)}`;
+	const label = typeof node.label === "string" ? node.label : void 0;
+	return label === void 0 ? `a ${node.kind}` : `the “${label}” ${node.kind}`;
+}
+function listOf(items) {
+	if (items.length === 1) return items[0];
+	if (items.length === 2) return `${items[0]} and ${items[1]}`;
+	return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+//#endregion
 //#region src/session.ts
 const CONTAINER_TYPES = /* @__PURE__ */ new Set([
 	"group",
 	"page",
 	"repeater"
 ]);
+/** Document order: earlier position first, and a parent before its child. */
+function comparePaths(a, b) {
+	const depth = Math.min(a.length, b.length);
+	for (let at = 0; at < depth; at += 1) if (a[at] !== b[at]) return a[at] - b[at];
+	return a.length - b.length;
+}
 function createBuilderSession(initial) {
 	const opened = deepFreeze(copy(initial));
 	const verdict = verdictFor(opened);
@@ -88,6 +292,13 @@ function createBuilderSession(initial) {
 			listeners.add(listener);
 			return () => listeners.delete(listener);
 		},
+		replaceDocument(next) {
+			return attempt((draft) => {
+				const mutable = draft;
+				for (const key of Object.keys(mutable)) delete mutable[key];
+				Object.assign(draft, copy(next));
+			});
+		},
 		insertField(location, def) {
 			return attempt((draft) => {
 				const container = containerAt(draft, location.parent);
@@ -99,7 +310,9 @@ function createBuilderSession(initial) {
 			return attempt((draft) => {
 				const found = locate(draft, keyPath);
 				if (found === void 0) return refuse("/model/fields", `No field at "${keyPath.join(".")}".`);
+				const dataPath = dataPathOf(draft, keyPath);
 				found.siblings.splice(found.index, 1);
+				if (dataPath !== void 0) unplaceEverywhere(draft, dataPath);
 			});
 		},
 		moveField(from, to) {
@@ -119,9 +332,12 @@ function createBuilderSession(initial) {
 				if (found === void 0) return refuse("/model/fields", `No field at "${keyPath.join(".")}".`);
 				const field = found.siblings[found.index];
 				const baseline = baselineByCurrentKey.get(field.key) ?? field.key;
+				const before = dataPathOf(draft, keyPath);
 				field.key = newKey;
 				if (newKey === baseline) delete field.renamedFrom;
 				else field.renamedFrom = baseline;
+				const after = dataPathOf(draft, [...keyPath.slice(0, -1), newKey]);
+				if (before !== void 0 && after !== void 0) repathEverywhere(draft, before, after);
 				baselineByCurrentKey.set(newKey, baseline);
 			});
 		},
@@ -154,12 +370,189 @@ function createBuilderSession(initial) {
 				rules.splice(index, 1);
 			});
 		},
+		addLayout(name) {
+			return attempt((draft) => {
+				draft.layouts = draft.layouts ?? [];
+				draft.layouts.push({
+					name,
+					nodes: []
+				});
+			});
+		},
+		removeLayout(name) {
+			return attempt((draft) => {
+				const at = draft.layouts?.findIndex((layout) => layout.name === name) ?? -1;
+				if (at === -1 || draft.layouts === void 0) return refuse("/layouts", `No layout called "${name}".`);
+				draft.layouts.splice(at, 1);
+				if (draft.layouts.length === 0) delete draft.layouts;
+			});
+		},
+		insertLayoutNode(location, node) {
+			return attempt((draft) => {
+				const container = childrenAt(draft, location.layout, location.parent);
+				if (container === void 0) return noSuchContainer(location);
+				container.splice(clampIndex(location.index, container.length), 0, copy(node));
+			});
+		},
+		removeLayoutNode(address) {
+			return attempt((draft) => {
+				const found = locateLayout(draft, address);
+				if (found === void 0) return noSuchNode(address);
+				found.siblings.splice(found.index, 1);
+			});
+		},
+		unwrapLayoutNode(address) {
+			return attempt((draft) => {
+				const found = locateLayout(draft, address);
+				if (found === void 0) return noSuchNode(address);
+				const node = found.siblings[found.index];
+				if (!isLayoutContainer(node)) return refuse(layoutPointer(address), "A field node places one field. There is nothing inside it to keep.");
+				found.siblings.splice(found.index, 1, ...node.children);
+			});
+		},
+		wrapLayoutNodes(layout, addresses, container, positionOf) {
+			if (addresses.length < 2) return refuse(`/layouts/${layout}`, "Wrapping needs at least two nodes. Use insertLayoutNode for one.");
+			if (!isLayoutContainer(container)) return refuse(`/layouts/${layout}`, "The wrapper has to be a container. A field node cannot hold anything.");
+			for (let outer = 0; outer < addresses.length; outer += 1) for (let inner = 0; inner < addresses.length; inner += 1) {
+				if (outer === inner) continue;
+				const a = addresses[outer];
+				const b = addresses[inner];
+				if (samePath(a, b)) return refuse(layoutPointer({
+					layout,
+					path: a
+				}), "That node is listed twice. Each one can only go in once.");
+				if (encloses(a, b)) return refuse(layoutPointer({
+					layout,
+					path: a
+				}), "Cannot wrap a container together with something inside it.");
+			}
+			return attempt((draft) => {
+				const taken = [];
+				for (const path of addresses) {
+					const found = locateLayout(draft, {
+						layout,
+						path
+					});
+					if (found === void 0) return noSuchNode({
+						layout,
+						path
+					});
+					taken.push(found.siblings[found.index]);
+				}
+				const anchorPath = positionOf !== void 0 && addresses.some((path) => samePath(path, positionOf)) ? positionOf : [...addresses].sort(comparePaths)[0];
+				const home = locateLayout(draft, {
+					layout,
+					path: anchorPath
+				});
+				if (home === void 0) return noSuchNode({
+					layout,
+					path: anchorPath
+				});
+				const parent = home.siblings;
+				const at = home.index;
+				for (const path of [...addresses].sort(comparePaths).reverse()) {
+					const found = locateLayout(draft, {
+						layout,
+						path
+					});
+					if (found === void 0) return noSuchNode({
+						layout,
+						path
+					});
+					found.siblings.splice(found.index, 1);
+				}
+				parent.splice(Math.min(at, parent.length), 0, {
+					...container,
+					children: taken
+				});
+			});
+		},
+		moveLayoutNode(from, to) {
+			if (from.layout !== to.layout) return refuse(layoutPointer(from), `Cannot move between the "${from.layout}" and "${to.layout}" layouts. Remove it from one and place it in the other.`);
+			if (encloses(from.path, to.parent)) return refuse(layoutPointer(from), "Cannot move this inside itself or one of its own children.");
+			return attempt((draft) => {
+				const found = locateLayout(draft, from);
+				if (found === void 0) return noSuchNode(from);
+				const [moved] = found.siblings.splice(found.index, 1);
+				const container = childrenAt(draft, to.layout, shiftAfterLift(to.parent, from.path));
+				if (container === void 0) return noSuchContainer(to);
+				container.splice(clampIndex(to.index, container.length), 0, moved);
+			});
+		},
+		setLayoutNodeLabel(address, label) {
+			return attempt((draft) => {
+				const found = locateLayout(draft, address);
+				if (found === void 0) return noSuchNode(address);
+				const node = found.siblings[found.index];
+				if (!isLayoutContainer(node)) return refuse(layoutPointer(address), "A field node takes its name from the field it places.");
+				if (label === void 0) delete node.label;
+				else node.label = copy(label);
+			});
+		},
+		setLayoutNodeProperty(address, property, value) {
+			return attempt((draft) => {
+				const found = locateLayout(draft, address);
+				if (found === void 0) return noSuchNode(address);
+				if (STRUCTURAL_LAYOUT_PROPERTIES.has(property)) return refuse(`${layoutPointer(address)}/${property}`, `"${property}" is not a setting. It is what the node is, or where it sits, and the arrangement's own commands change it.`);
+				if (property === "__proto__" || property === "prototype" || property === "constructor") return refuse(`${layoutPointer(address)}/${property}`, `"${property}" is not allowed as a layout node setting name.`);
+				const node = found.siblings[found.index];
+				if (value === void 0) Reflect.deleteProperty(node, property);
+				else Object.defineProperty(node, property, {
+					value: copy(value),
+					writable: true,
+					enumerable: true,
+					configurable: true
+				});
+			});
+		},
+		validLayoutTargets(layout, what) {
+			const movingPath = Array.isArray(what) ? what : void 0;
+			const probe = movingPath === void 0 ? what : nodeAt(present, layout, movingPath);
+			if (probe === void 0) return [];
+			if (nodesOfLayout(present, layout) === void 0) return [];
+			const targets = [];
+			for (const parent of containerPaths(present, layout)) {
+				if (movingPath !== void 0 && encloses(movingPath, parent)) continue;
+				const draft = copy(present);
+				if (movingPath !== void 0) {
+					const found = locateLayout(draft, {
+						layout,
+						path: movingPath
+					});
+					if (found === void 0) continue;
+					found.siblings.splice(found.index, 1);
+				}
+				const container = childrenAt(draft, layout, shiftAfterLift(parent, movingPath));
+				if (container === void 0) continue;
+				container.push(copy(probe));
+				if (!verdictFor(draft).valid) continue;
+				container.pop();
+				for (let index = 0; index <= container.length; index += 1) {
+					if (movingPath !== void 0 && sameLayoutPath(parent, movingPath.slice(0, -1)) && index === movingPath[movingPath.length - 1]) continue;
+					targets.push({
+						layout,
+						parent,
+						index
+					});
+				}
+			}
+			return targets;
+		},
+		unplacedFields(layout) {
+			return unreferencedPaths(present, layout) ?? [];
+		},
+		upgradeSpec(to = CURRENT_SPEC_VERSION) {
+			return attempt((draft) => {
+				if (draft.specVersion > to) return refuse("/specVersion", `This form is written against spec ${draft.specVersion} and cannot go back to ${to}: whatever the newer version added has nowhere to go, so it would be data loss rather than a change.`);
+				draft.specVersion = to;
+			});
+		},
 		validTargets(what) {
 			const movingPath = Array.isArray(what) ? what : void 0;
 			const probe = movingPath === void 0 ? what : locate(present, movingPath)?.siblings[locate(present, movingPath).index];
 			if (probe === void 0) return [];
 			const targets = [];
-			for (const parent of containerPaths(present)) {
+			for (const parent of containerPaths$1(present)) {
 				if (movingPath !== void 0 && isPrefix(movingPath, parent)) continue;
 				const draft = copy(present);
 				if (movingPath !== void 0) {
@@ -170,9 +563,10 @@ function createBuilderSession(initial) {
 				const container = containerAt(draft, parent);
 				if (container === void 0) continue;
 				container.push(movingPath === void 0 ? withUniqueKey(copy(probe), draft) : copy(probe));
-				if (verdictFor(draft).valid) targets.push({
+				if (!verdictFor(draft).valid) continue;
+				for (let index = 0; index < container.length; index += 1) targets.push({
 					parent,
-					index: container.length - 1
+					index
 				});
 			}
 			return targets;
@@ -205,7 +599,7 @@ function locate(document, keyPath) {
 	}
 }
 /** Every container's key path, root first. */
-function containerPaths(document) {
+function containerPaths$1(document) {
 	const paths = [[]];
 	const walk = (fields, prefix) => {
 		for (const field of fields) {
@@ -218,6 +612,123 @@ function containerPaths(document) {
 	walk(document.model.fields, []);
 	return paths;
 }
+/**
+* The data path of a field, which is not its key path.
+*
+* A page contributes no segment — a layout arranges what a person sees, and
+* `page1.email` is not what the engine calls that answer. Undefined when the
+* key path reaches nothing, or passes through something that holds no fields.
+*/
+/**
+* Layout node properties that are not settings.
+*
+* `kind` is what the node IS — writing a new one would turn a table into a section
+* without moving its children. `children` is structure, which the tree edits. `path`
+* is which answer a placement places, chosen when the placement is added and governed
+* by the one-place-per-field rule.
+*/
+const STRUCTURAL_LAYOUT_PROPERTIES = /* @__PURE__ */ new Set([
+	"kind",
+	"children",
+	"path"
+]);
+function dataPathOf(document, keyPath) {
+	const segments = [];
+	let fields = document.model.fields;
+	for (const [depth, key] of keyPath.entries()) {
+		const field = fields.find((candidate) => candidate.key === key);
+		if (field === void 0) return void 0;
+		if (field.type !== "page") segments.push(key);
+		if (depth === keyPath.length - 1) return segments.join(".");
+		fields = field.fields ?? [];
+	}
+}
+/** Whether `path` is `prefix` itself or a field inside it. */
+function underPath(path, prefix) {
+	return path === prefix || path.startsWith(`${prefix}.`);
+}
+/** Drop every layout node placing `dataPath`, or anything inside it. */
+function unplaceEverywhere(draft, dataPath) {
+	for (const layout of draft.layouts ?? []) layout.nodes = pruned(layout.nodes, dataPath);
+}
+function pruned(nodes, dataPath) {
+	const kept = [];
+	for (const node of nodes) {
+		if (node.kind === "field" || node.kind === "qrcode") {
+			if (!underPath(node.path, dataPath)) kept.push(node);
+			continue;
+		}
+		kept.push({
+			...node,
+			children: pruned(layoutChildren(node), dataPath)
+		});
+	}
+	return kept;
+}
+/** Point every layout node at the new path, including fields inside a group. */
+function repathEverywhere(draft, before, after) {
+	const walk = (nodes) => {
+		for (const [index, node] of nodes.entries()) {
+			if (node.kind === "field" || node.kind === "qrcode") {
+				if (underPath(node.path, before)) nodes[index] = {
+					...node,
+					path: after + node.path.slice(before.length)
+				};
+				continue;
+			}
+			walk(layoutChildren(node));
+		}
+	};
+	for (const layout of draft.layouts ?? []) walk(layout.nodes);
+}
+function locateLayout(document, address) {
+	if (address.path.length === 0) return void 0;
+	const siblings = childrenAt(document, address.layout, address.path.slice(0, -1));
+	if (siblings === void 0) return void 0;
+	const index = address.path[address.path.length - 1];
+	if (index < 0 || index >= siblings.length) return void 0;
+	return {
+		siblings,
+		index
+	};
+}
+function layoutPointer(address) {
+	return `/layouts/${address.layout}/nodes/${address.path.join("/")}`;
+}
+function noSuchNode(address) {
+	return {
+		ok: false,
+		path: layoutPointer(address),
+		message: `Nothing at that position in the "${address.layout}" layout.`
+	};
+}
+function noSuchContainer(location) {
+	return {
+		ok: false,
+		path: `/layouts/${location.layout}/nodes/${location.parent.join("/")}`,
+		message: location.parent.length === 0 ? `No layout called "${location.layout}".` : `Nothing at that position in the "${location.layout}" layout holds other nodes.`
+	};
+}
+/**
+* A container path, re-read after a node has been lifted out.
+*
+* Both paths index the document as it stood. If the lifted node shared a
+* container with an ancestor of this path and sat before it, that ancestor has
+* shifted up one — and walking the unshifted path now arrives at a different
+* node entirely, which is the silent kind of wrong.
+*/
+function shiftAfterLift(parent, lifted) {
+	if (lifted === void 0) return [...parent];
+	const depth = lifted.length - 1;
+	if (parent.length <= depth) return [...parent];
+	for (let at = 0; at < depth; at += 1) if (parent[at] !== lifted[at]) return [...parent];
+	const shifted = [...parent];
+	if (shifted[depth] > lifted[depth]) shifted[depth] = shifted[depth] - 1;
+	return shifted;
+}
+function sameLayoutPath(a, b) {
+	return a.length === b.length && a.every((step, at) => b[at] === step);
+}
 function isPrefix(prefix, candidate) {
 	if (prefix.length > candidate.length) return false;
 	return prefix.every((segment, index) => candidate[index] === segment);
@@ -278,6 +789,6 @@ function deepFreeze(value) {
 	return Object.freeze(value);
 }
 //#endregion
-export { createBuilderSession };
+export { LAYOUT_CONTAINER_KINDS, authorForm, createBuilderSession, describeNode as describeLayoutNode, isLayoutContainer, childrenAt as layoutChildrenAt, containerPaths as layoutContainerPaths, encloses as layoutEncloses, nodeAt as layoutNodeAt, nodesOfLayout };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/session.ts"],"sourcesContent":["import type { FieldDef, FormSchema, LogicRule } from '@formancy/spec'\nimport { validateSchema } from '@formancy/spec/validate'\nimport type { SchemaError } from '@formancy/spec/validate'\n\n/**\n * The headless document engine under the form builder.\n *\n * Three rules shape everything here.\n *\n * **A session may never hold a document the validator rejects.** Commands are\n * applied to a copy, validated, and only then committed; a command that would\n * produce an invalid document is refused with the validator's own\n * author-facing message and the held document is untouched. That is why\n * `canPublish()` is true by construction rather than by hope — and why legality\n * is decided by *trying* a command rather than by a second implementation of\n * the validator's rules, which would drift from it.\n *\n * **The document is frozen and copied at every boundary.** A builder UI is a\n * projection of this state, and a projection that can reach in and mutate the\n * model is how undo stops working.\n *\n * **Commands, never gestures.** Insert, move, remove, rename, set. WCAG 2.2\n * requires every drag operation to have a keyboard equivalent, so the keyboard\n * path is the API and a drag layer is sugar over it — not the other way round,\n * which is how the keyboard path ends up an afterthought nobody finishes.\n */\nexport interface Refusal {\n  ok: false\n  /** JSON Pointer into the document, as the validator reports it. */\n  path: string\n  message: string\n}\n\nexport type CommandOutcome = { ok: true; document: FormSchema } | Refusal\n\n/** Where a field goes: the key path of its container, and a position in it. */\nexport interface Location {\n  parent: readonly string[]\n  index: number\n}\n\nexport interface BuilderSession {\n  /** The current document: frozen, and never the caller's object. */\n  document(): FormSchema\n  /** A mutable deep copy, safe to hand to anything. */\n  exportDocument(): FormSchema\n  /** Increments once per accepted command, undo or redo. */\n  revision(): number\n  canUndo(): boolean\n  canRedo(): boolean\n  undo(): boolean\n  redo(): boolean\n  /** The validator's verdict on the held document. Valid by construction. */\n  canPublish(): { valid: boolean; errors: SchemaError[] }\n  /** One notification per accepted command, undo or redo. */\n  subscribe(listener: () => void): () => void\n\n  insertField(location: Location, def: FieldDef): CommandOutcome\n  removeField(keyPath: readonly string[]): CommandOutcome\n  moveField(from: readonly string[], to: Location): CommandOutcome\n  renameField(keyPath: readonly string[], newKey: string): CommandOutcome\n  setFieldProperty(keyPath: readonly string[], property: string, value: unknown): CommandOutcome\n  addRule(rule: LogicRule): CommandOutcome\n  updateRule(index: number, rule: LogicRule): CommandOutcome\n  removeRule(index: number): CommandOutcome\n\n  /**\n   * Every location a field may legally land: a palette entry (pass a\n   * definition) or an existing field being moved (pass its key path).\n   */\n  validTargets(what: FieldDef | readonly string[]): Location[]\n}\n\nconst CONTAINER_TYPES = new Set(['group', 'page', 'repeater'])\n\nexport function createBuilderSession(initial: FormSchema): BuilderSession {\n  const opened = deepFreeze(copy(initial))\n  const verdict = verdictFor(opened)\n  if (!verdict.valid) {\n    // Opening an invalid document would make every later refusal ambiguous:\n    // the caller could not tell whether their command broke the form or merely\n    // failed to fix it.\n    throw new Error(\n      `Cannot open this document in a builder session: ${verdict.errors\n        .map((error) => `${error.path} ${error.message}`)\n        .join('; ')}`,\n    )\n  }\n\n  /**\n   * The keys every field had when the session opened. A rename declares\n   * `renamedFrom` against THIS, never against the previous key: chaining\n   * would point a migration at an interim key no submission ever used.\n   */\n  const baselineKeys = new Map<FieldDef, string>()\n  indexBaseline(opened.model.fields, baselineKeys)\n\n  const past: FormSchema[] = []\n  const future: FormSchema[] = []\n  let present: FormSchema = opened\n  let revision = 0\n  const listeners = new Set<() => void>()\n\n  /** Identity survives edits by data path, so a renamed field keeps its\n   *  baseline. Keyed by the path a field had in the baseline document. */\n  const baselineByCurrentKey = new Map<string, string>()\n  seedBaselineByKey(opened.model.fields, baselineByCurrentKey)\n\n  function commit(candidate: FormSchema): CommandOutcome {\n    const check = verdictFor(candidate)\n    if (!check.valid) {\n      const first = check.errors[0]!\n      return { ok: false, path: first.path, message: first.message }\n    }\n    past.push(present)\n    // A new command abandons the redo branch: redoing onto a different history\n    // would replay an edit against a document it was never made against.\n    future.length = 0\n    present = deepFreeze(candidate)\n    revision += 1\n    for (const listener of [...listeners]) listener()\n    return { ok: true, document: present }\n  }\n\n  function refuse(path: string, message: string): Refusal {\n    return { ok: false, path, message }\n  }\n\n  /** Apply `edit` to a working copy and commit if the validator agrees. */\n  function attempt(edit: (draft: FormSchema) => Refusal | undefined): CommandOutcome {\n    const draft = copy(present)\n    const problem = edit(draft)\n    if (problem !== undefined) return problem\n    return commit(draft)\n  }\n\n  return {\n    document: () => present,\n    exportDocument: () => copy(present),\n    revision: () => revision,\n    canUndo: () => past.length > 0,\n    canRedo: () => future.length > 0,\n\n    undo() {\n      const previous = past.pop()\n      if (previous === undefined) return false\n      future.push(present)\n      present = previous\n      revision += 1\n      for (const listener of [...listeners]) listener()\n      return true\n    },\n\n    redo() {\n      const next = future.pop()\n      if (next === undefined) return false\n      past.push(present)\n      present = next\n      revision += 1\n      for (const listener of [...listeners]) listener()\n      return true\n    },\n\n    canPublish: () => verdictFor(present),\n\n    subscribe(listener) {\n      listeners.add(listener)\n      return () => listeners.delete(listener)\n    },\n\n    insertField(location, def) {\n      return attempt((draft) => {\n        const container = containerAt(draft, location.parent)\n        if (container === undefined) {\n          return refuse('/model/fields', `No container at \"${location.parent.join('.')}\".`)\n        }\n        container.splice(clampIndex(location.index, container.length), 0, copy(def))\n        return undefined\n      })\n    },\n\n    removeField(keyPath) {\n      return attempt((draft) => {\n        const found = locate(draft, keyPath)\n        if (found === undefined) return refuse('/model/fields', `No field at \"${keyPath.join('.')}\".`)\n        found.siblings.splice(found.index, 1)\n        return undefined\n      })\n    },\n\n    moveField(from, to) {\n      if (isPrefix(from, to.parent)) {\n        return refuse(\n          '/model/fields',\n          `Cannot move \"${from.join('.')}\" inside itself or one of its own children.`,\n        )\n      }\n      return attempt((draft) => {\n        const found = locate(draft, from)\n        if (found === undefined) return refuse('/model/fields', `No field at \"${from.join('.')}\".`)\n        const [moved] = found.siblings.splice(found.index, 1)\n        const container = containerAt(draft, to.parent)\n        if (container === undefined) {\n          return refuse('/model/fields', `No container at \"${to.parent.join('.')}\".`)\n        }\n        container.splice(clampIndex(to.index, container.length), 0, moved!)\n        return undefined\n      })\n    },\n\n    renameField(keyPath, newKey) {\n      return attempt((draft) => {\n        const found = locate(draft, keyPath)\n        if (found === undefined) return refuse('/model/fields', `No field at \"${keyPath.join('.')}\".`)\n        const field = found.siblings[found.index]!\n        const baseline = baselineByCurrentKey.get(field.key) ?? field.key\n\n        field.key = newKey\n        if (newKey === baseline) {\n          // Back where it started: there is nothing to migrate, and leaving a\n          // renamedFrom pointing at the current key is itself invalid.\n          delete field.renamedFrom\n        } else {\n          field.renamedFrom = baseline\n        }\n        baselineByCurrentKey.set(newKey, baseline)\n        return undefined\n      })\n    },\n\n    setFieldProperty(keyPath, property, value) {\n      return attempt((draft) => {\n        const found = locate(draft, keyPath)\n        if (found === undefined) return refuse('/model/fields', `No field at \"${keyPath.join('.')}\".`)\n        const field = found.siblings[found.index]! as unknown as Record<string, unknown>\n        if (value === undefined) delete field[property]\n        else field[property] = copy(value)\n        return undefined\n      })\n    },\n\n    addRule(rule) {\n      return attempt((draft) => {\n        draft.logic = draft.logic ?? { rules: [] }\n        draft.logic.rules.push(copy(rule))\n        return undefined\n      })\n    },\n\n    updateRule(index, rule) {\n      return attempt((draft) => {\n        const rules = draft.logic?.rules\n        if (rules === undefined || index < 0 || index >= rules.length) {\n          return refuse('/logic/rules', `No rule at index ${index}.`)\n        }\n        rules[index] = copy(rule)\n        return undefined\n      })\n    },\n\n    removeRule(index) {\n      return attempt((draft) => {\n        const rules = draft.logic?.rules\n        if (rules === undefined || index < 0 || index >= rules.length) {\n          return refuse('/logic/rules', `No rule at index ${index}.`)\n        }\n        rules.splice(index, 1)\n        return undefined\n      })\n    },\n\n    validTargets(what) {\n      const movingPath = Array.isArray(what) ? (what as readonly string[]) : undefined\n      const probe: FieldDef =\n        movingPath === undefined\n          ? (what as FieldDef)\n          : (locate(present, movingPath)?.siblings[locate(present, movingPath)!.index] as FieldDef)\n      if (probe === undefined) return []\n\n      const targets: Location[] = []\n      for (const parent of containerPaths(present)) {\n        // A container cannot be moved into itself or its own descendants.\n        if (movingPath !== undefined && isPrefix(movingPath, parent)) continue\n\n        // Legality is decided by TRYING the edit against the validator, so\n        // these rules can never drift from the ones publish enforces.\n        const draft = copy(present)\n        if (movingPath !== undefined) {\n          const found = locate(draft, movingPath)\n          if (found === undefined) continue\n          found.siblings.splice(found.index, 1)\n        }\n        const container = containerAt(draft, parent)\n        if (container === undefined) continue\n        container.push(movingPath === undefined ? withUniqueKey(copy(probe), draft) : copy(probe))\n\n        if (verdictFor(draft).valid) targets.push({ parent, index: container.length - 1 })\n      }\n      return targets\n    },\n  }\n}\n\n// ---------------------------------------------------------------- navigation\n\ninterface Located {\n  siblings: FieldDef[]\n  index: number\n}\n\n/** The child list of the container at `keyPath` — the root list for []. */\nfunction containerAt(document: FormSchema, keyPath: readonly string[]): FieldDef[] | undefined {\n  if (keyPath.length === 0) return document.model.fields\n  const found = locate(document, keyPath)\n  if (found === undefined) return undefined\n  const field = found.siblings[found.index]!\n  if (!CONTAINER_TYPES.has(field.type)) return undefined\n  field.fields = field.fields ?? []\n  return field.fields\n}\n\nfunction locate(document: FormSchema, keyPath: readonly string[]): Located | undefined {\n  if (keyPath.length === 0) return undefined\n  let siblings: FieldDef[] = document.model.fields\n  for (let depth = 0; depth < keyPath.length; depth++) {\n    const index = siblings.findIndex((field) => field.key === keyPath[depth])\n    if (index === -1) return undefined\n    if (depth === keyPath.length - 1) return { siblings, index }\n    const next = siblings[index]!.fields\n    if (next === undefined) return undefined\n    siblings = next\n  }\n  return undefined\n}\n\n/** Every container's key path, root first. */\nfunction containerPaths(document: FormSchema): string[][] {\n  const paths: string[][] = [[]]\n  const walk = (fields: readonly FieldDef[], prefix: string[]): void => {\n    for (const field of fields) {\n      if (!CONTAINER_TYPES.has(field.type)) continue\n      const here = [...prefix, field.key]\n      paths.push(here)\n      walk(field.fields ?? [], here)\n    }\n  }\n  walk(document.model.fields, [])\n  return paths\n}\n\nfunction isPrefix(prefix: readonly string[], candidate: readonly string[]): boolean {\n  if (prefix.length > candidate.length) return false\n  return prefix.every((segment, index) => candidate[index] === segment)\n}\n\nfunction clampIndex(index: number, length: number): number {\n  if (!Number.isInteger(index) || index < 0) return 0\n  return Math.min(index, length)\n}\n\n/** A palette probe must not fail purely because its placeholder key is taken —\n *  validTargets answers \"may this SHAPE go here\", not \"is this key free\". */\nfunction withUniqueKey(def: FieldDef, document: FormSchema): FieldDef {\n  const taken = new Set<string>()\n  const walk = (fields: readonly FieldDef[]): void => {\n    for (const field of fields) {\n      taken.add(field.key)\n      walk(field.fields ?? [])\n    }\n  }\n  walk(document.model.fields)\n\n  let candidate = def.key\n  let counter = 1\n  while (taken.has(candidate)) candidate = `${def.key}_${counter++}`\n  return { ...def, key: candidate }\n}\n\n// ------------------------------------------------------------------ baseline\n\nfunction indexBaseline(fields: readonly FieldDef[], into: Map<FieldDef, string>): void {\n  for (const field of fields) {\n    into.set(field, field.key)\n    indexBaseline(field.fields ?? [], into)\n  }\n}\n\nfunction seedBaselineByKey(fields: readonly FieldDef[], into: Map<string, string>): void {\n  for (const field of fields) {\n    // A field opened with a renamedFrom already declared keeps pointing there:\n    // that is the key the collected answers actually live under.\n    into.set(field.key, field.renamedFrom ?? field.key)\n    seedBaselineByKey(field.fields ?? [], into)\n  }\n}\n\n// --------------------------------------------------------------------- utils\n\nfunction verdictFor(document: FormSchema): { valid: boolean; errors: SchemaError[] } {\n  const result = validateSchema(document)\n  return result.valid ? { valid: true, errors: [] } : { valid: false, errors: result.errors }\n}\n\n/** JSON round-trip: a form document is JSON by definition, and this package\n *  runs without structuredClone in its lib on purpose. */\nfunction copy<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value)) as T\n}\n\nfunction deepFreeze<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value\n  for (const nested of Object.values(value as Record<string, unknown>)) deepFreeze(nested)\n  return Object.freeze(value)\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["layoutChildrenAt","layoutNodeAt","layoutContainerPaths","containerPaths"],"sources":["../src/authoring.ts","../src/layout.ts","../src/session.ts"],"sourcesContent":["import { authoringBriefing, canonicalize } from '@formancy/spec'\nimport { validateSchema } from '@formancy/spec/validate'\nimport type { FormSchema } from '@formancy/spec'\nimport { engineRefusal, expressionProblems } from '@formancy/core'\n\n/**\n * Writing a form from an instruction, and refusing to hand back one that does not work.\n *\n * The answer is **checked, and the model is told what was wrong with it and asked\n * again**: the format has a published JSON Schema and the expressions type-check, so\n * both failures come back as sentences a model can act on — `no such overload: double *\n * int … write 4.0` — rather than as a stack trace. Nothing reaches the editor until it\n * would work.\n *\n * **The model is the host's.** `AskModel` is supplied exactly as `Uploader` is: no\n * vendor, no API key, no network call and no opinion about who pays for tokens.\n */\n\n/** One turn with whatever model the host has. Text in, text out. */\nexport type AskModel = (prompt: AuthoringPrompt) => Promise<string>\n\nexport interface AuthoringPrompt {\n  /** What the model is, and the rules of the format. Stable across turns. */\n  readonly system: string\n  /** The instruction, plus whatever went wrong last time. */\n  readonly user: string\n}\n\n/**\n * Why an attempt was rejected, in the words the model is given back.\n *\n * `logic` is the engine refusing to open the document at all — a misspelled\n * field, a cycle, a condition that is not certain to be a bool — and\n * `expression` is one it would open whose rule then never does anything.\n */\nexport interface AuthoringProblem {\n  readonly kind: 'not-json' | 'invalid-document' | 'logic' | 'expression'\n  readonly detail: string\n}\n\nexport type AuthoringResult =\n  | { readonly ok: true; readonly document: FormSchema; readonly attempts: number }\n  | {\n      readonly ok: false\n      readonly attempts: number\n      readonly problems: readonly AuthoringProblem[]\n      /** The last thing the model said, so a person can see what went wrong. */\n      readonly lastAnswer: string\n    }\n\nexport interface AuthoringOptions {\n  /**\n   * How many times to ask. Three by default: the first answer, one correction,\n   * and one more for the mistake the correction introduced. Past that a model\n   * is usually circling rather than converging, and a person reading four\n   * failed attempts is better served by the first error than the fourth.\n   */\n  readonly attempts?: number\n  /**\n   * The document being edited, when there is one. Its presence changes the\n   * instruction from \"write a form\" to \"change this form\", which is a\n   * different request and produces a different answer.\n   */\n  readonly current?: FormSchema\n}\n\nconst DEFAULT_ATTEMPTS = 3\n\nexport async function authorForm(\n  ask: AskModel,\n  instruction: string,\n  options: AuthoringOptions = {},\n): Promise<AuthoringResult> {\n  const limit = Math.max(1, options.attempts ?? DEFAULT_ATTEMPTS)\n  const system = authoringBriefing()\n  const problems: AuthoringProblem[] = []\n  let lastAnswer = ''\n\n  for (let attempt = 1; attempt <= limit; attempt += 1) {\n    const answer = await ask({ system, user: userPrompt(instruction, options.current, problems) })\n    lastAnswer = answer\n\n    const parsed = readDocument(answer)\n    if (parsed === undefined) {\n      problems.push({\n        kind: 'not-json',\n        detail: 'That was not JSON. Answer with the document alone: no commentary, no code fence.',\n      })\n      continue\n    }\n\n    const validated = validateSchema(parsed)\n    if (!validated.valid) {\n      problems.push({\n        kind: 'invalid-document',\n        detail: validated.errors.map((error) => `${error.path}: ${error.message}`).join('\\n'),\n      })\n      continue\n    }\n\n    // The engine's own compile, which is what the preview and the server run.\n    // Without it a document with one misspelled field name passed this loop,\n    // landed in the editor, and the preview could not open it.\n    const refusal = engineRefusal(parsed as FormSchema)\n    if (refusal !== undefined) {\n      problems.push({ kind: 'logic', detail: refusal })\n      continue\n    }\n\n    const silent = expressionProblems(parsed as FormSchema)\n    if (silent.length > 0) {\n      // The failure worth the whole loop. These compile and then evaluate to\n      // nothing, so the form would publish cleanly and quietly do nothing.\n      problems.push({\n        kind: 'expression',\n        detail: silent.map((problem) => problem.message).join('\\n'),\n      })\n      continue\n    }\n\n    return { ok: true, document: parsed as FormSchema, attempts: attempt }\n  }\n\n  return { ok: false, attempts: limit, problems, lastAnswer }\n}\n\n/**\n * The instruction, and what went wrong last time.\n *\n * Only the most recent problem is repeated. A model given three rounds of\n * accumulated complaints starts fixing the first one again.\n */\nfunction userPrompt(\n  instruction: string,\n  current: FormSchema | undefined,\n  problems: readonly AuthoringProblem[],\n): string {\n  const parts: string[] = []\n\n  if (current !== undefined) {\n    parts.push('Here is the current document. Change it as asked and answer with the whole thing:')\n    // Canonical, so the model is not distracted by key order that means\n    // nothing, and two identical documents look identical to it.\n    parts.push(canonicalize(current))\n    parts.push('')\n  }\n\n  parts.push(instruction)\n\n  const last = problems.at(-1)\n  if (last !== undefined) {\n    parts.push('')\n    parts.push('Your previous answer was rejected. Fix exactly this and answer again:')\n    parts.push(last.detail)\n  }\n\n  return parts.join('\\n')\n}\n\n/**\n * The document out of whatever the model said.\n *\n * Models put JSON in code fences and add a sentence in front of it however\n * firmly they are told not to, and refusing those answers would spend a turn\n * on formatting rather than on the form. So a fence is stripped and, failing\n * that, the outermost braces are taken. Anything looser would start accepting\n * prose that happens to contain a bracket.\n */\nfunction readDocument(answer: string): unknown {\n  const fenced = /```(?:json)?\\s*([\\s\\S]*?)```/.exec(answer)\n  const candidates = [fenced?.[1], answer, betweenBraces(answer)]\n\n  for (const candidate of candidates) {\n    if (candidate === undefined) continue\n    try {\n      const parsed: unknown = JSON.parse(candidate.trim())\n      // A bare string or number is valid JSON and is not a document; letting\n      // one through would report it as an invalid document rather than as an\n      // answer that was not one.\n      if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed\n    } catch {\n      // Try the next reading.\n    }\n  }\n  return undefined\n}\n\nfunction betweenBraces(answer: string): string | undefined {\n  const start = answer.indexOf('{')\n  const end = answer.lastIndexOf('}')\n  return start === -1 || end <= start ? undefined : answer.slice(start, end + 1)\n}\n","import { LAYOUT_LEAF_KINDS, layoutChildren } from '@formancy/spec'\nimport type { FormSchema, LayoutNode } from '@formancy/spec'\n\n/**\n * Navigating an arrangement.\n *\n * A layout node has no key. A field is `contact.email` wherever it sits; a row\n * is \"the second thing inside the third thing\", and every insert or removal\n * renumbers its neighbours. So a layout address is an index path, and these\n * helpers exist because reading one wrong is silent — you edit a different\n * node and the document stays valid.\n *\n * Kept apart from the field commands rather than folded in beside them,\n * because the two addressing schemes look alike and are not: `['a','b']` is a\n * key path into the model and `[0, 1]` is a position path into one layout, and\n * a function that took either would be a function that could confuse them.\n */\n\n/** Where a layout node goes: which arrangement, which container, which slot. */\nexport interface LayoutLocation {\n  /** The layout's name. Arrangements are asked for by name, never by index. */\n  layout: string\n  /** Index path of the container, root-first. `[]` is the layout itself. */\n  parent: readonly number[]\n  index: number\n}\n\n/** A layout node's address. `path` is never empty — that would be the layout. */\nexport interface LayoutAddress {\n  layout: string\n  path: readonly number[]\n}\n\n/** The kinds that hold other nodes. A `field` node is a leaf. */\nexport const LAYOUT_CONTAINER_KINDS = ['section', 'row', 'column'] as const\n\nexport type LayoutContainerKind = (typeof LAYOUT_CONTAINER_KINDS)[number]\n\nexport function isLayoutContainer(\n  node: LayoutNode,\n): node is Extract<LayoutNode, { children: LayoutNode[] }> {\n  // `!LAYOUT_LEAF_KINDS.has(kind)`, not `kind !== 'field'`. The old spelling was true\n  // while `field` was the only childless node, and `qrcode` is the second — so it\n  // claimed a code has children and every caller of this predicate believed it.\n  return !LAYOUT_LEAF_KINDS.has(node.kind)\n}\n\n/** The named layout's top-level node list, or undefined if there is no such layout. */\nexport function nodesOfLayout(document: FormSchema, name: string): LayoutNode[] | undefined {\n  return document.layouts?.find((layout) => layout.name === name)?.nodes\n}\n\n/**\n * The child list of the container at `parent` — the layout's own list for `[]`.\n *\n * Undefined rather than empty when the path points at a field or at nothing,\n * so a caller cannot insert into a leaf and get an array nobody reads back.\n */\nexport function childrenAt(\n  document: FormSchema,\n  layout: string,\n  parent: readonly number[],\n): LayoutNode[] | undefined {\n  let nodes: LayoutNode[] | undefined = nodesOfLayout(document, layout)\n  if (nodes === undefined) return undefined\n  for (const step of parent) {\n    const node: LayoutNode | undefined = nodes[step]\n    if (node === undefined || !isLayoutContainer(node)) return undefined\n    nodes = node.children\n  }\n  return nodes\n}\n\n/** The node at `path`, or undefined. An empty path addresses no node. */\nexport function nodeAt(\n  document: FormSchema,\n  layout: string,\n  path: readonly number[],\n): LayoutNode | undefined {\n  if (path.length === 0) return undefined\n  const siblings = childrenAt(document, layout, path.slice(0, -1))\n  return siblings?.[path[path.length - 1]!]\n}\n\n/** Every container's index path in one layout, the layout itself first. */\nexport function containerPaths(document: FormSchema, layout: string): number[][] {\n  const nodes = nodesOfLayout(document, layout)\n  if (nodes === undefined) return []\n\n  const paths: number[][] = [[]]\n  const walk = (children: readonly LayoutNode[], prefix: number[]): void => {\n    for (const [index, node] of children.entries()) {\n      if (!isLayoutContainer(node)) continue\n      const here = [...prefix, index]\n      paths.push(here)\n      walk(node.children, here)\n    }\n  }\n  walk(nodes, [])\n  return paths\n}\n\n/** Whether `maybeAncestor` is `path` itself or encloses it. */\nexport function encloses(maybeAncestor: readonly number[], path: readonly number[]): boolean {\n  if (maybeAncestor.length > path.length) return false\n  return maybeAncestor.every((step, at) => path[at] === step)\n}\n\nexport function samePath(a: readonly number[], b: readonly number[]): boolean {\n  return a.length === b.length && a.every((step, at) => b[at] === step)\n}\n\n/**\n * A human name for one layout node, for a tree row and for an announcement.\n *\n * A row has nothing to call itself, so it is named by what it holds: \"Row with\n * First name and Last name\" is findable in a list of six rows and \"Row\" is not.\n */\nexport function describeNode(node: LayoutNode, nameOfPath: (path: string) => string): string {\n  if (node.kind === 'field') return nameOfPath(node.path)\n  // A code is named by what it encodes, not by being a code: \"Code for Booking\n  // reference\" is findable in a tree and \"Code\" is not — the same reasoning a row is\n  // named by what it holds.\n  if (node.kind === 'qrcode') return `Code for ${nameOfPath(node.path)}`\n\n  const label = typeof node.label === 'string' ? node.label : undefined\n  const kind = node.kind[0]!.toUpperCase() + node.kind.slice(1)\n  if (label !== undefined) return `${kind} “${label}”`\n\n  // One level down, and no further. Recursing all the way produced \"Section\n  // with Row with First name and Last name and Email\", where the reader has\n  // no way to tell which \"and\" separates what. A nested container is named as\n  // what it is; its own row in the tree says what is in it.\n  const inside = layoutChildren(node).map((child) => shortNameOf(child, nameOfPath))\n  if (inside.length === 0) return `Empty ${node.kind}`\n  return `${kind} with ${listOf(inside)}`\n}\n\nfunction shortNameOf(node: LayoutNode, nameOfPath: (path: string) => string): string {\n  if (node.kind === 'field') return nameOfPath(node.path)\n  if (node.kind === 'qrcode') return `code for ${nameOfPath(node.path)}`\n  const label = typeof node.label === 'string' ? node.label : undefined\n  return label === undefined ? `a ${node.kind}` : `the “${label}” ${node.kind}`\n}\n\nfunction listOf(items: readonly string[]): string {\n  if (items.length === 1) return items[0]!\n  if (items.length === 2) return `${items[0]!} and ${items[1]!}`\n  return `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]!}`\n}\n","import type { FieldDef, FormSchema, LayoutNode, LogicRule, SpecVersion, Text } from '@formancy/spec'\nimport { CURRENT_SPEC_VERSION, unreferencedPaths, LAYOUT_LEAF_KINDS, layoutChildren} from '@formancy/spec'\nimport { validateSchema } from '@formancy/spec/validate'\nimport type { SchemaError } from '@formancy/spec/validate'\nimport {\n  childrenAt as layoutChildrenAt,\n  containerPaths as layoutContainerPaths,\n  encloses,\n  isLayoutContainer,\n  nodeAt as layoutNodeAt,\n  nodesOfLayout,\n  samePath,\n} from './layout.js'\nimport type { LayoutAddress, LayoutLocation } from './layout.js'\n\n/**\n * The headless document engine under the form builder.\n *\n * Three rules shape everything here.\n *\n * **A session may never hold a document the validator rejects.** Commands are\n * applied to a copy, validated, and only then committed; a command that would\n * produce an invalid document is refused with the validator's own\n * author-facing message and the held document is untouched. That is why\n * `canPublish()` is true by construction rather than by hope — and why legality\n * is decided by *trying* a command rather than by a second implementation of\n * the validator's rules, which would drift from it.\n *\n * **The document is frozen and copied at every boundary.** A builder UI is a\n * projection of this state, and a projection that can reach in and mutate the\n * model is how undo stops working.\n *\n * **Commands, never gestures.** Insert, move, remove, rename, set. WCAG 2.2\n * requires every drag operation to have a keyboard equivalent, so the keyboard\n * path is the API and a drag layer is sugar over it — not the other way round,\n * which is how the keyboard path ends up an afterthought nobody finishes.\n */\nexport interface Refusal {\n  ok: false\n  /** JSON Pointer into the document, as the validator reports it. */\n  path: string\n  message: string\n}\n\nexport type CommandOutcome = { ok: true; document: FormSchema } | Refusal\n\n/** Where a field goes: the key path of its container, and a position in it. */\nexport interface Location {\n  parent: readonly string[]\n  index: number\n}\n\nexport interface BuilderSession {\n  /** The current document: frozen, and never the caller's object. */\n  document(): FormSchema\n  /** A mutable deep copy, safe to hand to anything. */\n  exportDocument(): FormSchema\n  /** Increments once per accepted command, undo or redo. */\n  revision(): number\n  canUndo(): boolean\n  canRedo(): boolean\n  undo(): boolean\n  redo(): boolean\n  /** The validator's verdict on the held document. Valid by construction. */\n  canPublish(): { valid: boolean; errors: SchemaError[] }\n  /** One notification per accepted command, undo or redo. */\n  subscribe(listener: () => void): () => void\n\n  /**\n   * Take a whole document, as ONE undoable edit.\n   *\n   * For a change that is not an edit to the document so much as a different\n   * document — a form written from an instruction, or a paste into the\n   * schema editor. It goes through the same validator every other command\n   * does, so a session can never come to hold something invalid, and it lands\n   * on the undo stack as a single step: Ctrl+Z after \"write me a contact form\"\n   * puts back what was there before, which is the only behaviour anybody\n   * would expect.\n   */\n  replaceDocument(next: FormSchema): CommandOutcome\n\n  insertField(location: Location, def: FieldDef): CommandOutcome\n  removeField(keyPath: readonly string[]): CommandOutcome\n  moveField(from: readonly string[], to: Location): CommandOutcome\n  renameField(keyPath: readonly string[], newKey: string): CommandOutcome\n  setFieldProperty(keyPath: readonly string[], property: string, value: unknown): CommandOutcome\n  addRule(rule: LogicRule): CommandOutcome\n  updateRule(index: number, rule: LogicRule): CommandOutcome\n  removeRule(index: number): CommandOutcome\n\n  /**\n   * Every location a field may legally land: a palette entry (pass a\n   * definition) or an existing field being moved (pass its key path).\n   */\n  validTargets(what: FieldDef | readonly string[]): Location[]\n\n  // --- the arrangement, which is a second document over the same model ---\n\n  addLayout(name: string): CommandOutcome\n  removeLayout(name: string): CommandOutcome\n  insertLayoutNode(location: LayoutLocation, node: LayoutNode): CommandOutcome\n  removeLayoutNode(address: LayoutAddress): CommandOutcome\n  /** Replace a container with its children, in order, where it stood. */\n  unwrapLayoutNode(address: LayoutAddress): CommandOutcome\n  /**\n   * Put several nodes inside a new container, where the earliest of them stood.\n   *\n   * The inverse of `unwrapLayoutNode`, and what \"drop this field beside that\n   * one\" compiles to. The addresses need NOT be siblings — the field being\n   * dragged is usually somewhere else — and the new container's children follow\n   * the order the addresses are given in, because the side somebody dropped on\n   * is what decides which field ends up on the left.\n   *\n   * One command rather than a move plus a wrap, so one gesture is one undo. A\n   * gesture that takes three presses of undo to reverse is one people stop\n   * trusting.\n   */\n  wrapLayoutNodes(\n    layout: string,\n    addresses: ReadonlyArray<readonly number[]>,\n    container: LayoutNode,\n    /**\n     * Which of the addresses the new container takes the position of.\n     *\n     * Defaults to the earliest in document order, which is right when there is\n     * no reason to prefer one. A DROP has one: the new row belongs where the\n     * thing dropped ON was, not where the thing being dragged came from --\n     * otherwise dragging a field out of a row and onto a top-level field nests\n     * the new row inside the old one, which is not what anybody aimed at.\n     *\n     * Separate from the order of `addresses` because the two are independent:\n     * dropping on the left makes the dragged node the first child while the\n     * position still comes from the target, which is the second address.\n     */\n    positionOf?: readonly number[],\n  ): CommandOutcome\n  moveLayoutNode(from: LayoutAddress, to: LayoutLocation): CommandOutcome\n  setLayoutNodeLabel(address: LayoutAddress, label: Text | undefined): CommandOutcome\n  /**\n   * Set any property the format gives a layout node, or remove it with `undefined`.\n   *\n   * Generic on purpose: the builder's panel is generated from the JSON Schema, so a\n   * command per property would have to be remembered every time the format grows one.\n   * `span` arrived and had no way to be set at all\n   * ([0074](../../../docs/decisions/0074-a-table-child-may-span.md)); so had a table's\n   * `columns` and a section's `label`, since the day layouts existed.\n   *\n   * `kind`, `children` and `path` are refused: the first is what the node IS, the\n   * second is structure the tree edits, and the third is which answer a placement\n   * places — all three have their own commands that keep the document consistent.\n   *\n   * Like every command here it is attempted against the validator, so an illegal value\n   * leaves the document where it was rather than requiring the panel to know the rules.\n   */\n  setLayoutNodeProperty(\n    address: LayoutAddress,\n    property: string,\n    value: unknown,\n  ): CommandOutcome\n\n  /**\n   * Every position a layout node may legally occupy: a new node (pass it) or\n   * an existing one being moved (pass its index path).\n   */\n  validLayoutTargets(layout: string, what: LayoutNode | readonly number[]): LayoutLocation[]\n\n  /** Data paths the named layout does not place. Empty for an unknown layout. */\n  unplacedFields(layout: string): string[]\n\n  /**\n   * Move the document to a newer spec version.\n   *\n   * One line of document change, undoable like any other command, and the\n   * reason it is a command at all: the builder offers the newer field types\n   * only to a document that allows them, so somebody who wants one has to be\n   * able to say yes from inside the builder rather than by editing JSON.\n   */\n  upgradeSpec(to?: SpecVersion): CommandOutcome\n}\n\nconst CONTAINER_TYPES = new Set(['group', 'page', 'repeater'])\n\n/** Document order: earlier position first, and a parent before its child. */\nfunction comparePaths(a: readonly number[], b: readonly number[]): number {\n  const depth = Math.min(a.length, b.length)\n  for (let at = 0; at < depth; at += 1) {\n    if (a[at] !== b[at]) return a[at]! - b[at]!\n  }\n  return a.length - b.length\n}\n\nexport function createBuilderSession(initial: FormSchema): BuilderSession {\n  const opened = deepFreeze(copy(initial))\n  const verdict = verdictFor(opened)\n  if (!verdict.valid) {\n    // Opening an invalid document would make every later refusal ambiguous:\n    // the caller could not tell whether their command broke the form or merely\n    // failed to fix it.\n    throw new Error(\n      `Cannot open this document in a builder session: ${verdict.errors\n        .map((error) => `${error.path} ${error.message}`)\n        .join('; ')}`,\n    )\n  }\n\n  /**\n   * The keys every field had when the session opened. A rename declares\n   * `renamedFrom` against THIS, never against the previous key: chaining\n   * would point a migration at an interim key no submission ever used.\n   */\n  const baselineKeys = new Map<FieldDef, string>()\n  indexBaseline(opened.model.fields, baselineKeys)\n\n  const past: FormSchema[] = []\n  const future: FormSchema[] = []\n  let present: FormSchema = opened\n  let revision = 0\n  const listeners = new Set<() => void>()\n\n  /** Identity survives edits by data path, so a renamed field keeps its\n   *  baseline. Keyed by the path a field had in the baseline document. */\n  const baselineByCurrentKey = new Map<string, string>()\n  seedBaselineByKey(opened.model.fields, baselineByCurrentKey)\n\n  function commit(candidate: FormSchema): CommandOutcome {\n    const check = verdictFor(candidate)\n    if (!check.valid) {\n      const first = check.errors[0]!\n      return { ok: false, path: first.path, message: first.message }\n    }\n    past.push(present)\n    // A new command abandons the redo branch: redoing onto a different history\n    // would replay an edit against a document it was never made against.\n    future.length = 0\n    present = deepFreeze(candidate)\n    revision += 1\n    for (const listener of [...listeners]) listener()\n    return { ok: true, document: present }\n  }\n\n  function refuse(path: string, message: string): Refusal {\n    return { ok: false, path, message }\n  }\n\n  /** Apply `edit` to a working copy and commit if the validator agrees. */\n  function attempt(edit: (draft: FormSchema) => Refusal | undefined): CommandOutcome {\n    const draft = copy(present)\n    const problem = edit(draft)\n    if (problem !== undefined) return problem\n    return commit(draft)\n  }\n\n  return {\n    document: () => present,\n    exportDocument: () => copy(present),\n    revision: () => revision,\n    canUndo: () => past.length > 0,\n    canRedo: () => future.length > 0,\n\n    undo() {\n      const previous = past.pop()\n      if (previous === undefined) return false\n      future.push(present)\n      present = previous\n      revision += 1\n      for (const listener of [...listeners]) listener()\n      return true\n    },\n\n    redo() {\n      const next = future.pop()\n      if (next === undefined) return false\n      past.push(present)\n      present = next\n      revision += 1\n      for (const listener of [...listeners]) listener()\n      return true\n    },\n\n    canPublish: () => verdictFor(present),\n\n    subscribe(listener) {\n      listeners.add(listener)\n      return () => listeners.delete(listener)\n    },\n\n    replaceDocument(next) {\n      return attempt((draft) => {\n        // Assigned key by key rather than returned, because `attempt` commits\n        // the draft it was given and a new object would be dropped.\n        const mutable = draft as unknown as Record<string, unknown>\n        for (const key of Object.keys(mutable)) delete mutable[key]\n        Object.assign(draft, copy(next))\n        return undefined\n      })\n    },\n\n    insertField(location, def) {\n      return attempt((draft) => {\n        const container = containerAt(draft, location.parent)\n        if (container === undefined) {\n          return refuse('/model/fields', `No container at \"${location.parent.join('.')}\".`)\n        }\n        container.splice(clampIndex(location.index, container.length), 0, copy(def))\n        return undefined\n      })\n    },\n\n    removeField(keyPath) {\n      return attempt((draft) => {\n        const found = locate(draft, keyPath)\n        if (found === undefined) return refuse('/model/fields', `No field at \"${keyPath.join('.')}\".`)\n        // Read before the removal: afterwards the path cannot be resolved.\n        const dataPath = dataPathOf(draft, keyPath)\n        found.siblings.splice(found.index, 1)\n        // A layout node placing a field that no longer exists is invalid, so\n        // without this the command is simply refused and a form author cannot\n        // delete a field at all once it has been arranged. Pruning it here is\n        // not a convenience: an arrangement is a view of the model, and it\n        // cannot outlive what it is a view of.\n        if (dataPath !== undefined) unplaceEverywhere(draft, dataPath)\n        return undefined\n      })\n    },\n\n    moveField(from, to) {\n      if (isPrefix(from, to.parent)) {\n        return refuse(\n          '/model/fields',\n          `Cannot move \"${from.join('.')}\" inside itself or one of its own children.`,\n        )\n      }\n      return attempt((draft) => {\n        const found = locate(draft, from)\n        if (found === undefined) return refuse('/model/fields', `No field at \"${from.join('.')}\".`)\n        const [moved] = found.siblings.splice(found.index, 1)\n        const container = containerAt(draft, to.parent)\n        if (container === undefined) {\n          return refuse('/model/fields', `No container at \"${to.parent.join('.')}\".`)\n        }\n        container.splice(clampIndex(to.index, container.length), 0, moved!)\n        return undefined\n      })\n    },\n\n    renameField(keyPath, newKey) {\n      return attempt((draft) => {\n        const found = locate(draft, keyPath)\n        if (found === undefined) return refuse('/model/fields', `No field at \"${keyPath.join('.')}\".`)\n        const field = found.siblings[found.index]!\n        const baseline = baselineByCurrentKey.get(field.key) ?? field.key\n\n        const before = dataPathOf(draft, keyPath)\n        field.key = newKey\n        if (newKey === baseline) {\n          // Back where it started: there is nothing to migrate, and leaving a\n          // renamedFrom pointing at the current key is itself invalid.\n          delete field.renamedFrom\n        } else {\n          field.renamedFrom = baseline\n        }\n        // Every arrangement follows the rename. A layout addresses fields by\n        // data path, so leaving them behind would make the document invalid\n        // and the rename impossible — for exactly the fields most likely to\n        // need one, the ones somebody has already arranged.\n        const after = dataPathOf(draft, [...keyPath.slice(0, -1), newKey])\n        if (before !== undefined && after !== undefined) repathEverywhere(draft, before, after)\n        baselineByCurrentKey.set(newKey, baseline)\n        return undefined\n      })\n    },\n\n    setFieldProperty(keyPath, property, value) {\n      return attempt((draft) => {\n        const found = locate(draft, keyPath)\n        if (found === undefined) return refuse('/model/fields', `No field at \"${keyPath.join('.')}\".`)\n        const field = found.siblings[found.index]! as unknown as Record<string, unknown>\n        if (value === undefined) delete field[property]\n        else field[property] = copy(value)\n        return undefined\n      })\n    },\n\n    addRule(rule) {\n      return attempt((draft) => {\n        draft.logic = draft.logic ?? { rules: [] }\n        draft.logic.rules.push(copy(rule))\n        return undefined\n      })\n    },\n\n    updateRule(index, rule) {\n      return attempt((draft) => {\n        const rules = draft.logic?.rules\n        if (rules === undefined || index < 0 || index >= rules.length) {\n          return refuse('/logic/rules', `No rule at index ${index}.`)\n        }\n        rules[index] = copy(rule)\n        return undefined\n      })\n    },\n\n    removeRule(index) {\n      return attempt((draft) => {\n        const rules = draft.logic?.rules\n        if (rules === undefined || index < 0 || index >= rules.length) {\n          return refuse('/logic/rules', `No rule at index ${index}.`)\n        }\n        rules.splice(index, 1)\n        return undefined\n      })\n    },\n\n    // ------------------------------------------------------------- layouts\n\n    addLayout(name) {\n      return attempt((draft) => {\n        draft.layouts = draft.layouts ?? []\n        draft.layouts.push({ name, nodes: [] })\n        return undefined\n      })\n    },\n\n    removeLayout(name) {\n      return attempt((draft) => {\n        const at = draft.layouts?.findIndex((layout) => layout.name === name) ?? -1\n        if (at === -1 || draft.layouts === undefined) {\n          return refuse('/layouts', `No layout called \"${name}\".`)\n        }\n        draft.layouts.splice(at, 1)\n        // An empty list and no list at all mean the same thing to a renderer,\n        // and only one of them survives a round trip unchanged.\n        if (draft.layouts.length === 0) delete draft.layouts\n        return undefined\n      })\n    },\n\n    insertLayoutNode(location, node) {\n      return attempt((draft) => {\n        const container = layoutChildrenAt(draft, location.layout, location.parent)\n        if (container === undefined) return noSuchContainer(location)\n        container.splice(clampIndex(location.index, container.length), 0, copy(node))\n        return undefined\n      })\n    },\n\n    removeLayoutNode(address) {\n      return attempt((draft) => {\n        const found = locateLayout(draft, address)\n        if (found === undefined) return noSuchNode(address)\n        found.siblings.splice(found.index, 1)\n        return undefined\n      })\n    },\n\n    unwrapLayoutNode(address) {\n      return attempt((draft) => {\n        const found = locateLayout(draft, address)\n        if (found === undefined) return noSuchNode(address)\n        const node = found.siblings[found.index]!\n        if (!isLayoutContainer(node)) {\n          return refuse(\n            layoutPointer(address),\n            'A field node places one field. There is nothing inside it to keep.',\n          )\n        }\n        found.siblings.splice(found.index, 1, ...node.children)\n        return undefined\n      })\n    },\n\n    wrapLayoutNodes(layout, addresses, container, positionOf) {\n      if (addresses.length < 2) {\n        return refuse(\n          `/layouts/${layout}`,\n          'Wrapping needs at least two nodes. Use insertLayoutNode for one.',\n        )\n      }\n\n      if (!isLayoutContainer(container)) {\n        return refuse(\n          `/layouts/${layout}`,\n          'The wrapper has to be a container. A field node cannot hold anything.',\n        )\n      }\n\n      for (let outer = 0; outer < addresses.length; outer += 1) {\n        for (let inner = 0; inner < addresses.length; inner += 1) {\n          if (outer === inner) continue\n          const a = addresses[outer]!\n          const b = addresses[inner]!\n          if (samePath(a, b)) {\n            // Spliced out once and inserted twice would place one field in two\n            // positions, which stays syntactically fine and fails at publish.\n            return refuse(\n              layoutPointer({ layout, path: a }),\n              'That node is listed twice. Each one can only go in once.',\n            )\n          }\n          if (encloses(a, b)) {\n            return refuse(\n              layoutPointer({ layout, path: a }),\n              'Cannot wrap a container together with something inside it.',\n            )\n          }\n        }\n      }\n\n      return attempt((draft) => {\n        // Collected before anything is removed, because every removal renumbers\n        // the addresses after it -- the whole difficulty of editing a document\n        // whose nodes have no keys.\n        const taken: LayoutNode[] = []\n        for (const path of addresses) {\n          const found = locateLayout(draft, { layout, path })\n          if (found === undefined) return noSuchNode({ layout, path })\n          taken.push(found.siblings[found.index]!)\n        }\n\n        // Where the wrapper goes, read now while the addresses still mean what\n        // the caller meant. `at` when given -- a drop wants the target's place,\n        // not the dragged node's -- and otherwise the earliest in document\n        // order, which is the sensible default when nothing prefers one.\n        const anchorPath =\n          positionOf !== undefined && addresses.some((path) => samePath(path, positionOf))\n            ? positionOf\n            : [...addresses].sort(comparePaths)[0]!\n        const home = locateLayout(draft, { layout, path: anchorPath })\n        if (home === undefined) return noSuchNode({ layout, path: anchorPath })\n        const parent = home.siblings\n        const at = home.index\n\n        // Removed deepest-last so that removing one cannot invalidate the\n        // address of another still to be removed.\n        for (const path of [...addresses].sort(comparePaths).reverse()) {\n          const found = locateLayout(draft, { layout, path })\n          if (found === undefined) return noSuchNode({ layout, path })\n          found.siblings.splice(found.index, 1)\n        }\n\n        parent.splice(Math.min(at, parent.length), 0, { ...container, children: taken })\n        return undefined\n      })\n    },\n\n    moveLayoutNode(from, to) {\n      // A field has one place per arrangement, so moving it across layouts\n      // would silently unplace it where it came from — a deletion wearing the\n      // word \"move\". Two commands, deliberately, so the second is deliberate.\n      if (from.layout !== to.layout) {\n        return refuse(\n          layoutPointer(from),\n          `Cannot move between the \"${from.layout}\" and \"${to.layout}\" layouts. Remove it from one and place it in the other.`,\n        )\n      }\n      if (encloses(from.path, to.parent)) {\n        return refuse(\n          layoutPointer(from),\n          'Cannot move this inside itself or one of its own children.',\n        )\n      }\n\n      return attempt((draft) => {\n        const found = locateLayout(draft, from)\n        if (found === undefined) return noSuchNode(from)\n        const [moved] = found.siblings.splice(found.index, 1)\n        // `to.parent` addresses the container as the CALLER sees it, before\n        // anything is lifted — so it is corrected here, once, in the one place\n        // that knows the lift has happened. `to.index`, by contrast, already\n        // counts positions after the lift, the same convention moveField uses.\n        // Splitting it this way is what lets the self-containment check above\n        // compare two paths in the same frame of reference.\n        const container = layoutChildrenAt(draft, to.layout, shiftAfterLift(to.parent, from.path))\n        if (container === undefined) return noSuchContainer(to)\n        container.splice(clampIndex(to.index, container.length), 0, moved!)\n        return undefined\n      })\n    },\n\n    setLayoutNodeLabel(address, label) {\n      return attempt((draft) => {\n        const found = locateLayout(draft, address)\n        if (found === undefined) return noSuchNode(address)\n        const node = found.siblings[found.index]!\n        if (!isLayoutContainer(node)) {\n          return refuse(layoutPointer(address), 'A field node takes its name from the field it places.')\n        }\n        if (label === undefined) delete node.label\n        else node.label = copy(label)\n        return undefined\n      })\n    },\n\n    setLayoutNodeProperty(address, property, value) {\n      return attempt((draft) => {\n        const found = locateLayout(draft, address)\n        if (found === undefined) return noSuchNode(address)\n        if (STRUCTURAL_LAYOUT_PROPERTIES.has(property)) {\n          return refuse(\n            `${layoutPointer(address)}/${property}`,\n            `\"${property}\" is not a setting. It is what the node is, or where it sits, and the arrangement's own commands change it.`,\n          )\n        }\n        if (property === '__proto__' || property === 'prototype' || property === 'constructor') {\n          return refuse(\n            `${layoutPointer(address)}/${property}`,\n            `\"${property}\" is not allowed as a layout node setting name.`,\n          )\n        }\n        const node = found.siblings[found.index]! as unknown as Record<string, unknown>\n        if (value === undefined) Reflect.deleteProperty(node, property)\n        else {\n          Object.defineProperty(node, property, {\n            value: copy(value) as unknown,\n            writable: true,\n            enumerable: true,\n            configurable: true,\n          })\n        }\n        return undefined\n      })\n    },\n\n    validLayoutTargets(layout, what) {\n      const movingPath = Array.isArray(what) ? (what as readonly number[]) : undefined\n      const probe =\n        movingPath === undefined ? (what as LayoutNode) : layoutNodeAt(present, layout, movingPath)\n      if (probe === undefined) return []\n      if (nodesOfLayout(present, layout) === undefined) return []\n\n      const targets: LayoutLocation[] = []\n      for (const parent of layoutContainerPaths(present, layout)) {\n        // Nothing may be moved into itself or its own descendants.\n        if (movingPath !== undefined && encloses(movingPath, parent)) continue\n\n        // Legality is decided by TRYING the edit against the validator, the\n        // same way field moves are, so these rules cannot drift from the ones\n        // publish enforces — a field already placed elsewhere is refused here\n        // because the validator refuses it there.\n        const draft = copy(present)\n        if (movingPath !== undefined) {\n          const found = locateLayout(draft, { layout, path: movingPath })\n          if (found === undefined) continue\n          found.siblings.splice(found.index, 1)\n        }\n        // `parent` is the container as the caller sees it. Finding it in the\n        // lifted draft needs the correction; handing it back does not, because\n        // a Location addresses the document the caller is looking at.\n        const container = layoutChildrenAt(draft, layout, shiftAfterLift(parent, movingPath))\n        if (container === undefined) continue\n        container.push(copy(probe))\n        if (!verdictFor(draft).valid) continue\n        container.pop()\n\n        // Every position, not just the end: offering only the end makes the\n        // keyboard path weaker than a drag, which is what SC 2.5.7 forbids.\n        for (let index = 0; index <= container.length; index += 1) {\n          // Within the container it came from, the slot it already occupies is\n          // not a move. After the lift, that is the index it was lifted from.\n          if (\n            movingPath !== undefined &&\n            sameLayoutPath(parent, movingPath.slice(0, -1)) &&\n            index === movingPath[movingPath.length - 1]\n          ) {\n            continue\n          }\n          targets.push({ layout, parent, index })\n        }\n      }\n      return targets\n    },\n\n    unplacedFields(layout) {\n      return unreferencedPaths(present, layout) ?? []\n    },\n\n    upgradeSpec(to = CURRENT_SPEC_VERSION) {\n      return attempt((draft) => {\n        if (draft.specVersion > to) {\n          return refuse(\n            '/specVersion',\n            `This form is written against spec ${draft.specVersion} and cannot go back to ${to}: whatever the newer version added has nowhere to go, so it would be data loss rather than a change.`,\n          )\n        }\n        draft.specVersion = to\n        return undefined\n      })\n    },\n\n    validTargets(what) {\n      const movingPath = Array.isArray(what) ? (what as readonly string[]) : undefined\n      const probe: FieldDef =\n        movingPath === undefined\n          ? (what as FieldDef)\n          : (locate(present, movingPath)?.siblings[locate(present, movingPath)!.index] as FieldDef)\n      if (probe === undefined) return []\n\n      const targets: Location[] = []\n      for (const parent of containerPaths(present)) {\n        // A container cannot be moved into itself or its own descendants.\n        if (movingPath !== undefined && isPrefix(movingPath, parent)) continue\n\n        // Legality is decided by TRYING the edit against the validator, so\n        // these rules can never drift from the ones publish enforces.\n        const draft = copy(present)\n        if (movingPath !== undefined) {\n          const found = locate(draft, movingPath)\n          if (found === undefined) continue\n          found.siblings.splice(found.index, 1)\n        }\n        const container = containerAt(draft, parent)\n        if (container === undefined) continue\n        container.push(movingPath === undefined ? withUniqueKey(copy(probe), draft) : copy(probe))\n\n        // Legality is tested once per container, at the end, and then every\n        // position in that container is offered. Nothing the validator checks\n        // depends on where among its siblings a field sits — duplicate keys,\n        // nesting depth and rule targets are all position-blind — so testing\n        // each index separately would run the validator n times to learn the\n        // same thing.\n        //\n        // Offering only the last position would be cheaper still, and was what\n        // this did first. It also made the keyboard path weaker than a drag:\n        // you could move a field to the end of a group but never between two\n        // of its fields, which is not the equivalent function WCAG 2.2 SC\n        // 2.5.7 asks for.\n        if (!verdictFor(draft).valid) continue\n        for (let index = 0; index < container.length; index += 1) {\n          targets.push({ parent, index })\n        }\n      }\n      return targets\n    },\n  }\n}\n\n// ---------------------------------------------------------------- navigation\n\ninterface Located {\n  siblings: FieldDef[]\n  index: number\n}\n\n/** The child list of the container at `keyPath` — the root list for []. */\nfunction containerAt(document: FormSchema, keyPath: readonly string[]): FieldDef[] | undefined {\n  if (keyPath.length === 0) return document.model.fields\n  const found = locate(document, keyPath)\n  if (found === undefined) return undefined\n  const field = found.siblings[found.index]!\n  if (!CONTAINER_TYPES.has(field.type)) return undefined\n  field.fields = field.fields ?? []\n  return field.fields\n}\n\nfunction locate(document: FormSchema, keyPath: readonly string[]): Located | undefined {\n  if (keyPath.length === 0) return undefined\n  let siblings: FieldDef[] = document.model.fields\n  for (let depth = 0; depth < keyPath.length; depth++) {\n    const index = siblings.findIndex((field) => field.key === keyPath[depth])\n    if (index === -1) return undefined\n    if (depth === keyPath.length - 1) return { siblings, index }\n    const next = siblings[index]!.fields\n    if (next === undefined) return undefined\n    siblings = next\n  }\n  return undefined\n}\n\n/** Every container's key path, root first. */\nfunction containerPaths(document: FormSchema): string[][] {\n  const paths: string[][] = [[]]\n  const walk = (fields: readonly FieldDef[], prefix: string[]): void => {\n    for (const field of fields) {\n      if (!CONTAINER_TYPES.has(field.type)) continue\n      const here = [...prefix, field.key]\n      paths.push(here)\n      walk(field.fields ?? [], here)\n    }\n  }\n  walk(document.model.fields, [])\n  return paths\n}\n\n// ----------------------------------------------- keeping layouts in step\n\n/**\n * The data path of a field, which is not its key path.\n *\n * A page contributes no segment — a layout arranges what a person sees, and\n * `page1.email` is not what the engine calls that answer. Undefined when the\n * key path reaches nothing, or passes through something that holds no fields.\n */\n/**\n * Layout node properties that are not settings.\n *\n * `kind` is what the node IS — writing a new one would turn a table into a section\n * without moving its children. `children` is structure, which the tree edits. `path`\n * is which answer a placement places, chosen when the placement is added and governed\n * by the one-place-per-field rule.\n */\nconst STRUCTURAL_LAYOUT_PROPERTIES = new Set(['kind', 'children', 'path'])\n\nfunction dataPathOf(document: FormSchema, keyPath: readonly string[]): string | undefined {\n  const segments: string[] = []\n  let fields: readonly FieldDef[] = document.model.fields\n\n  for (const [depth, key] of keyPath.entries()) {\n    const field = fields.find((candidate) => candidate.key === key)\n    if (field === undefined) return undefined\n    if (field.type !== 'page') segments.push(key)\n    if (depth === keyPath.length - 1) return segments.join('.')\n    fields = field.fields ?? []\n  }\n  return undefined\n}\n\n/** Whether `path` is `prefix` itself or a field inside it. */\nfunction underPath(path: string, prefix: string): boolean {\n  return path === prefix || path.startsWith(`${prefix}.`)\n}\n\n/** Drop every layout node placing `dataPath`, or anything inside it. */\nfunction unplaceEverywhere(draft: FormSchema, dataPath: string): void {\n  for (const layout of draft.layouts ?? []) {\n    layout.nodes = pruned(layout.nodes, dataPath)\n  }\n}\n\nfunction pruned(nodes: readonly LayoutNode[], dataPath: string): LayoutNode[] {\n  const kept: LayoutNode[] = []\n  for (const node of nodes) {\n    if (node.kind === 'field' || node.kind === 'qrcode') {\n      // A code goes when the answer it encodes goes, exactly as its placement does:\n      // what would remain is a node drawing a picture of nothing, and the validator\n      // would then refuse the document the builder had just produced.\n      if (!underPath(node.path, dataPath)) kept.push(node)\n      continue\n    }\n    // The container stays even when it empties. Removing one field should not\n    // silently take a row with it and rearrange everything beside it.\n    kept.push({ ...node, children: pruned(layoutChildren(node) as LayoutNode[], dataPath) })\n  }\n  return kept\n}\n\n/** Point every layout node at the new path, including fields inside a group. */\nfunction repathEverywhere(draft: FormSchema, before: string, after: string): void {\n  const walk = (nodes: LayoutNode[]): void => {\n    for (const [index, node] of nodes.entries()) {\n      if (node.kind === 'field' || node.kind === 'qrcode') {\n        // A code follows a rename. A declared rename keeps the answer, so a code of it\n        // must keep encoding the same answer -- leaving the old path behind would turn\n        // a rename into a silently broken code.\n        if (underPath(node.path, before)) {\n          nodes[index] = { ...node, path: after + node.path.slice(before.length) }\n        }\n        continue\n      }\n      walk(layoutChildren(node) as LayoutNode[])\n    }\n  }\n  for (const layout of draft.layouts ?? []) walk(layout.nodes)\n}\n\n// ----------------------------------------------------------- layout helpers\n\ninterface LocatedNode {\n  siblings: LayoutNode[]\n  index: number\n}\n\nfunction locateLayout(document: FormSchema, address: LayoutAddress): LocatedNode | undefined {\n  if (address.path.length === 0) return undefined\n  const siblings = layoutChildrenAt(document, address.layout, address.path.slice(0, -1))\n  if (siblings === undefined) return undefined\n  const index = address.path[address.path.length - 1]!\n  if (index < 0 || index >= siblings.length) return undefined\n  return { siblings, index }\n}\n\nfunction layoutPointer(address: LayoutAddress): string {\n  return `/layouts/${address.layout}/nodes/${address.path.join('/')}`\n}\n\nfunction noSuchNode(address: LayoutAddress): Refusal {\n  return {\n    ok: false,\n    path: layoutPointer(address),\n    message: `Nothing at that position in the \"${address.layout}\" layout.`,\n  }\n}\n\nfunction noSuchContainer(location: LayoutLocation): Refusal {\n  return {\n    ok: false,\n    path: `/layouts/${location.layout}/nodes/${location.parent.join('/')}`,\n    message:\n      location.parent.length === 0\n        ? `No layout called \"${location.layout}\".`\n        : `Nothing at that position in the \"${location.layout}\" layout holds other nodes.`,\n  }\n}\n\n/**\n * A container path, re-read after a node has been lifted out.\n *\n * Both paths index the document as it stood. If the lifted node shared a\n * container with an ancestor of this path and sat before it, that ancestor has\n * shifted up one — and walking the unshifted path now arrives at a different\n * node entirely, which is the silent kind of wrong.\n */\nfunction shiftAfterLift(\n  parent: readonly number[],\n  lifted: readonly number[] | undefined,\n): number[] {\n  if (lifted === undefined) return [...parent]\n  const depth = lifted.length - 1\n  if (parent.length <= depth) return [...parent]\n  // Only when the lift happened in an ancestor's own container.\n  for (let at = 0; at < depth; at += 1) if (parent[at] !== lifted[at]) return [...parent]\n\n  const shifted = [...parent]\n  if (shifted[depth]! > lifted[depth]!) shifted[depth] = shifted[depth]! - 1\n  return shifted\n}\n\nfunction sameLayoutPath(a: readonly number[], b: readonly number[]): boolean {\n  return a.length === b.length && a.every((step, at) => b[at] === step)\n}\n\nfunction isPrefix(prefix: readonly string[], candidate: readonly string[]): boolean {\n  if (prefix.length > candidate.length) return false\n  return prefix.every((segment, index) => candidate[index] === segment)\n}\n\nfunction clampIndex(index: number, length: number): number {\n  if (!Number.isInteger(index) || index < 0) return 0\n  return Math.min(index, length)\n}\n\n/** A palette probe must not fail purely because its placeholder key is taken —\n *  validTargets answers \"may this SHAPE go here\", not \"is this key free\". */\nfunction withUniqueKey(def: FieldDef, document: FormSchema): FieldDef {\n  const taken = new Set<string>()\n  const walk = (fields: readonly FieldDef[]): void => {\n    for (const field of fields) {\n      taken.add(field.key)\n      walk(field.fields ?? [])\n    }\n  }\n  walk(document.model.fields)\n\n  let candidate = def.key\n  let counter = 1\n  while (taken.has(candidate)) candidate = `${def.key}_${counter++}`\n  return { ...def, key: candidate }\n}\n\n// ------------------------------------------------------------------ baseline\n\nfunction indexBaseline(fields: readonly FieldDef[], into: Map<FieldDef, string>): void {\n  for (const field of fields) {\n    into.set(field, field.key)\n    indexBaseline(field.fields ?? [], into)\n  }\n}\n\nfunction seedBaselineByKey(fields: readonly FieldDef[], into: Map<string, string>): void {\n  for (const field of fields) {\n    // A field opened with a renamedFrom already declared keeps pointing there:\n    // that is the key the collected answers actually live under.\n    into.set(field.key, field.renamedFrom ?? field.key)\n    seedBaselineByKey(field.fields ?? [], into)\n  }\n}\n\n// --------------------------------------------------------------------- utils\n\nfunction verdictFor(document: FormSchema): { valid: boolean; errors: SchemaError[] } {\n  const result = validateSchema(document)\n  return result.valid ? { valid: true, errors: [] } : { valid: false, errors: result.errors }\n}\n\n/** JSON round-trip: a form document is JSON by definition, and this package\n *  runs without structuredClone in its lib on purpose. */\nfunction copy<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value)) as T\n}\n\nfunction deepFreeze<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value\n  for (const nested of Object.values(value as Record<string, unknown>)) deepFreeze(nested)\n  return Object.freeze(value)\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formancy/builder-core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The headless form-builder document engine: schema editing as commands with undo, selection and valid-target computation.",
   "license": "Apache-2.0",
   "type": "module",
@@ -17,7 +17,8 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@formancy/spec": "0.1.0"
+    "@formancy/core": "0.2.0",
+    "@formancy/spec": "0.2.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
@@ -26,7 +27,8 @@
     "tsdown": "^0.23.0",
     "typescript": "~6.0.3",
     "unrun": "^0.3.1",
-    "vitest": "^5.0.1"
+    "vitest": "^5.0.1",
+    "@vitest/coverage-v8": "^5.0.1"
   },
   "publishConfig": {
     "access": "public"
@@ -40,6 +42,7 @@
   "bugs": "https://github.com/sharkysan/formancy.ai/issues",
   "scripts": {
     "build": "tsdown",
+    "test:coverage": "vitest run --coverage",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "check:pkg": "publint && attw --pack . --profile esm-only"