jsonisch 0.1.0

package/dist/plugin-Qka-vaO1.js

@@ -0,0 +1,1545 @@
+import { B as getFieldBool, D as fieldPluginDirty, E as encodeFieldValue, N as computed, O as hasPluginDirtyField, P as createSignal, _ as resolveValueInput, d as DEFAULT_ROOT_RECORD_ALIAS, g as readOwn, h as isSafeKey, l as isSemanticEqual, r as getFieldInput, s as isEmptyish, t as internalOf } from "./form-ref-BEri3JKv.js";
+
+//#region src/core/field/get-dirty-field-input.ts
+/**
+* Returns only the dirty input of the field store. Arrays are treated as
+* atomic and returned in full if any item is dirty, while object keys
+* without a dirty descendant are omitted. Returns `undefined` if no
+* descendant is dirty.
+*
+* Plugin state serializes THROUGH the field's own entry (the LOS-573
+* envelope): a dirty estimate/amount-or-percent leaf emits
+* kind envelope in place of its bare value — a mode flip
+* with an unchanged value still produces a payload. Inside an emitted
+* array every envelope leaf is wrapped COMPLETE, dirty or not: rows
+* persist wholesale, and a bare value would clobber the persisted meta
+* half of its envelope.
+*
+* @param internalFormStore The form store (plugin state lives here).
+* @param internalFieldStore The field store to get dirty input from.
+*
+* @returns The dirty input, or `undefined` if no descendant is dirty.
+*/
+function getDirtyFieldInput(internalFormStore, internalFieldStore) {
+	if (!getFieldBool(internalFieldStore, "isDirty") && !hasPluginDirtyField(internalFormStore, internalFieldStore)) return;
+	if (internalFieldStore.kind === "array") return encodeScopeValues(internalFormStore, internalFieldStore, getFieldInput(internalFieldStore));
+	if (internalFieldStore.kind === "object") {
+		if (internalFieldStore.input.value) {
+			const value = {};
+			for (const key in internalFieldStore.children) {
+				const child = internalFieldStore.children[key];
+				if (child.kind === "value") {
+					const valueDirty = getFieldBool(child, "isDirty");
+					const pluginDirty = fieldPluginDirty(internalFormStore, child);
+					if (!valueDirty && !pluginDirty) continue;
+					const encoded = encodeFieldValue(internalFormStore, child, valueDirty ? child.input.value : void 0);
+					if (valueDirty || encoded !== void 0) value[key] = encoded;
+				} else if (getFieldBool(child, "isDirty") || hasPluginDirtyField(internalFormStore, child)) value[key] = getDirtyFieldInput(internalFormStore, child);
+			}
+			return value;
+		}
+		return internalFieldStore.input.value;
+	}
+	return encodeFieldValue(internalFormStore, internalFieldStore, internalFieldStore.input.value);
+}
+/**
+* Wraps the envelope leaves of an emitted subtree value: rows and nested
+* objects keep their shape, but every value leaf claimed by a plugin's
+* `encodeValue` (estimate/amount-or-percent) is replaced with its COMPLETE
+* envelope — the whole-array emission convention. The supplied value is
+* never mutated.
+*/
+function encodeScopeValues(internalFormStore, internalFieldStore, value) {
+	if (!internalFieldStore) return value;
+	if (internalFieldStore.kind === "array" && Array.isArray(value)) return value.map((item, index) => encodeScopeValues(internalFormStore, internalFieldStore.children[index], item));
+	if (internalFieldStore.kind === "object" && value !== null && typeof value === "object" && !Array.isArray(value)) {
+		const row = { ...value };
+		for (const key in internalFieldStore.children) {
+			const child = internalFieldStore.children[key];
+			if (child.kind === "value") {
+				if (Object.prototype.hasOwnProperty.call(row, key) || fieldPluginDirty(internalFormStore, child)) {
+					const encoded = encodeFieldValue(internalFormStore, child, readOwn(row, key));
+					if (encoded !== void 0) row[key] = encoded;
+				}
+			} else if (Object.prototype.hasOwnProperty.call(row, key)) row[key] = encodeScopeValues(internalFormStore, child, row[key]);
+		}
+		return row;
+	}
+	return value;
+}
+
+//#endregion
+//#region src/plugins/envelopes/wire.ts
+/**
+* Returns whether a raw persisted entry is an envelope: an object whose
+* `kind` is `estimate` or `amount-or-percent`. Anything else — including
+* the bare scalars every non-envelope field persists — is a bare value.
+*/
+function isEnvelope(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return false;
+	const kind = raw.kind;
+	return kind === "estimate" || kind === "amount-or-percent";
+}
+/** Meta keys only — `kind` and `value` are the envelope's own halves. */
+function metaOf(raw) {
+	const meta = {};
+	for (const key of Object.keys(raw)) {
+		if (key === "kind" || key === "value") continue;
+		meta[key] = raw[key];
+	}
+	return meta;
+}
+/**
+* Wraps an estimate field's halves into its envelope. The value key is
+* OMITTED when `value` is `undefined` (formula mode ships
+* `{ kind: "estimate", mode: "formula" }` and lets the server recompute
+* author the value half).
+*/
+function wrapEstimate(value, meta) {
+	const envelope = {
+		kind: "estimate",
+		...meta
+	};
+	if (value !== void 0) envelope.value = value;
+	return envelope;
+}
+/**
+* Wraps an amount-or-percent field's halves into its envelope. Always
+* complete — an envelope is one bag key, so a partial write would clobber
+* the persisted other half.
+*/
+function wrapAmountOrPercent(value, meta) {
+	return {
+		kind: "amount-or-percent",
+		value,
+		...meta
+	};
+}
+/**
+* The envelopes plugin's STATIC wire contract — isomorphic by
+* construction: the server imports this same object for save routing
+* (`encodeDirty`), the recompute pass, and engine-less readers
+* (changelog, list pages), with no form store anywhere (D7).
+*
+* Envelope shape: estimate fields persist
+* `{ kind: "estimate", value?, mode, manualValue?, lastFlippedAt? }`,
+* amount-or-percent fields
+* `{ kind: "amount-or-percent", value, mode, basis? }`.
+* Wire `mode` uses settled names (`estimate`/`formula`, `amount`/`percent`).
+* Only these two controls grow the envelope; scalars stay bare.
+*/
+const envelopesWire = {
+	envelopeControls: ["estimate", "amount-or-percent"],
+	unwrap(raw) {
+		if (!isEnvelope(raw)) return {
+			value: raw,
+			meta: {}
+		};
+		return {
+			value: readOwn(raw, "value"),
+			meta: metaOf(raw)
+		};
+	},
+	encode(control, raw) {
+		if (control !== "estimate") return raw;
+		if (!isEnvelope(raw)) return void 0;
+		const meta = metaOf(raw);
+		if (meta.mode === "estimate") return raw;
+		return wrapEstimate(void 0, meta);
+	}
+};
+
+//#endregion
+//#region src/plugins/envelopes/envelope.ts
+/**
+* Schema-declared opening mode for an unpinned estimate field.
+* `"formula"` → formula-first; `"estimate"` / missing → manual-first.
+*/
+function schemaDefaultEstimateMode(schema) {
+	return schema?.["x-estimate-default-mode"] === "formula" ? "formula" : "estimate";
+}
+/**
+* Resolves an estimate field's live mode:
+*   - an explicit `formula` / `estimate` pin always wins
+*   - no pin + empty value + schema default `formula` → `formula` (LOS-823)
+*   - otherwise → `estimate` (manual-first, LOS-461: a stored unpinned
+*     value stays typeable so a schema default cannot clobber it)
+*/
+function resolveEstimateMode(meta, schema) {
+	if (meta.mode === "formula" || meta.mode === "estimate") return meta.mode;
+	if (schemaDefaultEstimateMode(schema) === "formula" && isEmptyish(meta.value)) return "formula";
+	return "estimate";
+}
+/**
+* Schema-declared opening unit for an unpinned amount-or-percent field.
+* Missing / anything other than `"percent"` → `amount` (amount-first).
+*/
+function schemaDefaultEntryMode(schema) {
+	return schema?.["x-hybrid-default-mode"] === "percent" ? "percent" : "amount";
+}
+/**
+* Resolves persisted amount-or-percent entry state:
+*   - an explicit `percent` / `amount` pin always wins
+*   - no pin + empty value + schema default `percent` → `percent` (LOS-824)
+*   - otherwise → `amount` (amount-first: a stored unpinned value stays
+*     dollars so imported/legacy amounts are not treated as percent-owned)
+* Percent basis falls back to the schema's declared default denominator.
+*/
+function resolveAmountOrPercentEntry(meta, schema, value) {
+	const schemaDefault = schema["x-hybrid-default-denominator"];
+	return {
+		entryMode: meta.mode === "percent" || meta.mode === "amount" ? meta.mode : schemaDefaultEntryMode(schema) === "percent" && isEmptyish(value) ? "percent" : "amount",
+		percentBasis: typeof meta.basis === "string" ? meta.basis : typeof schemaDefault === "string" && schemaDefault !== "" ? schemaDefault : void 0
+	};
+}
+function resolveEnvelopeValue(form, store, value) {
+	return resolveValueInput(form.emptyInput, store.schema, store.isNullish, value);
+}
+/**
+* Decodes one estimate field's raw (kind envelope or bare scalar) into
+* the in-memory envelope. `mode` is omitted when the wire never pinned
+* one — encode must not fabricate `{ mode: "estimate" }` for a virgin
+* field.
+*/
+function decodeEstimateEnvelope(form, store, raw) {
+	const { value, meta } = envelopesWire.unwrap(raw);
+	const estimateMeta = meta;
+	const envelope = {
+		kind: "estimate",
+		value: resolveEnvelopeValue(form, store, value)
+	};
+	if (estimateMeta.mode === "formula" || estimateMeta.mode === "estimate") return {
+		...envelope,
+		mode: estimateMeta.mode,
+		manualValue: estimateMeta.manualValue ?? null,
+		...estimateMeta.lastFlippedAt !== void 0 ? { lastFlippedAt: estimateMeta.lastFlippedAt } : {}
+	};
+	return {
+		...envelope,
+		manualValue: estimateMeta.manualValue ?? null,
+		...estimateMeta.lastFlippedAt !== void 0 ? { lastFlippedAt: estimateMeta.lastFlippedAt } : {}
+	};
+}
+/**
+* Decodes one amount-or-percent field's raw into the in-memory envelope
+* with entry state already resolved against the schema default.
+*/
+function decodeAmountOrPercentEnvelope(form, store, raw) {
+	const { value, meta } = envelopesWire.unwrap(raw);
+	const { entryMode, percentBasis } = resolveAmountOrPercentEntry(meta, store.schema, value);
+	return {
+		kind: "amount-or-percent",
+		value: resolveEnvelopeValue(form, store, value),
+		mode: entryMode,
+		...percentBasis !== void 0 ? { basis: percentBasis } : {}
+	};
+}
+function writeEnvelope(form, store, slot, next) {
+	const resolved = resolveEnvelopeValue(form, store, next.value);
+	if (slot.family === "estimate") slot.envelope.value = {
+		...next,
+		value: resolved
+	};
+	else slot.envelope.value = {
+		...next,
+		value: resolved
+	};
+	store.input.value = resolved;
+	store.isDirty.value = !isSemanticEqual(resolved, store.startInput.value);
+}
+function adoptEnvelope(live, start, incoming, schema) {
+	if (incoming.kind === "estimate") return adoptEstimate(live, start, incoming, schema);
+	return adoptAmountOrPercent(live, start, incoming);
+}
+function adoptEstimate(live, start, incoming, schema) {
+	const modeDirty = resolveEstimateMode(live, schema) !== resolveEstimateMode(start, schema);
+	const valueDirty = !isSemanticEqual(live.value, start.value);
+	return {
+		start: incoming,
+		live: {
+			...incoming,
+			...modeDirty ? {
+				mode: live.mode,
+				lastFlippedAt: live.lastFlippedAt,
+				manualValue: live.manualValue
+			} : {},
+			...valueDirty ? {
+				value: live.value,
+				...resolveEstimateMode(live, schema) === "estimate" ? { manualValue: live.manualValue } : {}
+			} : {}
+		}
+	};
+}
+function adoptAmountOrPercent(live, start, incoming) {
+	return {
+		start: incoming,
+		live: {
+			...incoming,
+			...live.mode !== start.mode ? { mode: live.mode } : {},
+			...live.basis !== start.basis ? { basis: live.basis } : {},
+			...!isSemanticEqual(live.value, start.value) ? { value: live.value } : {}
+		}
+	};
+}
+function bindAdopted(form, store, slot, adopted) {
+	if (slot.family === "estimate") {
+		slot.startEnvelope.value = adopted.start;
+		store.startInput.value = resolveEnvelopeValue(form, store, adopted.start.value);
+		writeEnvelope(form, store, slot, adopted.live);
+		return;
+	}
+	slot.startEnvelope.value = adopted.start;
+	store.startInput.value = resolveEnvelopeValue(form, store, adopted.start.value);
+	writeEnvelope(form, store, slot, adopted.live);
+}
+/**
+* Estimate keystroke: value (and, in estimate mode, `manualValue`) land
+* on the same envelope as the number.
+*/
+function syncEstimateInput(form, store, slot, input) {
+	const live = slot.envelope.value;
+	writeEnvelope(form, store, slot, {
+		...live,
+		value: input,
+		...resolveEstimateMode(live, store.schema) === "estimate" ? { manualValue: isEmptyish(input) ? null : input } : {}
+	});
+}
+/**
+* Amount-or-percent keystroke: value half only — entry state is untouched.
+*/
+function syncAmountOrPercentInput(form, store, slot, input) {
+	writeEnvelope(form, store, slot, {
+		...slot.envelope.value,
+		value: input
+	});
+}
+
+//#endregion
+//#region src/core/plugin/key.ts
+/**
+* The identity a plugin's state is stored under in the form store's
+* `pluginState` map (the ProseMirror pattern, minus its string-name
+* registry). The generic is a phantom — it exists only so `getState`
+* returns the right type; nothing is stored on the key itself.
+*
+* Keys are module-level singletons exported next to their plugin factory.
+* Cross-plugin reads go through the exported key (derivation imports
+* `envelopesKey`, never the envelopes implementation), and stay
+* `T | undefined` — a form without the owning plugin is a legal config.
+*/
+var PluginKey = class {
+	constructor(name) {
+		this.name = name;
+	}
+	/**
+	* Reads the owning plugin's state off a form store, or `undefined` when
+	* the plugin is not registered on this form.
+	*/
+	getState(form) {
+		return form.pluginState.get(this);
+	}
+};
+/**
+* A plugin key whose state is a per-field map keyed by field-store
+* IDENTITY. Field stores are position-fixed — array operations move signal
+* VALUES between stores, not the stores themselves — so per-field slots
+* must transfer with item state via the `transferField`/`swapField` hooks,
+* exactly like the input signals they sit next to.
+*/
+var FieldSlotKey = class extends PluginKey {
+	/**
+	* Reads one field's slot, or `undefined` when the plugin is absent or the
+	* field carries no slot (a bare scalar to this plugin).
+	*/
+	get(form, store) {
+		return this.getState(form)?.get(store);
+	}
+};
+
+//#endregion
+//#region src/plugins/envelopes/key.ts
+/**
+* The envelopes plugin's slot key. Other plugins read envelope state
+* through this identity (the derivation plugin pins on `mode`), never
+* through the envelopes implementation.
+*/
+const envelopesKey = new FieldSlotKey("envelopes");
+
+//#endregion
+//#region src/plugins/derivation/key.ts
+/**
+* The derivation plugin's slot key. The scope resolvers and the react
+* surface read derived state through this identity.
+*/
+const derivationKey = new FieldSlotKey("derivation");
+
+//#endregion
+//#region src/core/derivation/merge-collection-rows.ts
+/**
+* Merge a collection's canonical rows (the read model — full server rows
+* with calc fields pre-evaluated, delivered via `offFormValues`) with the
+* live form rows (the write model the user edits) for formula evaluation.
+*
+* Membership comes from the LIVE rows, so rows added or removed during the
+* form session are respected. Each live row is enriched from the canonical
+* row with the same `id`: live keys win (an explicit `null` means the user
+* cleared the field), canonical fills everything the live row doesn't
+* carry — core columns the write model never holds.
+*
+* One home for collection overlay (app re-exports this). The merged result
+* is for evaluation only; it is never written back into form state.
+*/
+function mergeCollectionRows(canonicalRows, liveRows) {
+	if (!Array.isArray(liveRows)) return [...canonicalRows];
+	const canonicalById = /* @__PURE__ */ new Map();
+	for (const row of canonicalRows) if (row && typeof row === "object" && "id" in row) canonicalById.set(row.id, row);
+	return liveRows.map((live) => {
+		if (!live || typeof live !== "object") return live;
+		const liveRow = live;
+		const canonical = canonicalById.get(liveRow.id);
+		if (!canonical) return liveRow;
+		const merged = { ...canonical };
+		for (const [key, value] of Object.entries(liveRow)) if (value !== void 0) merged[key] = value;
+		for (const key of Object.keys(merged)) if (merged[key] === void 0) delete merged[key];
+		return merged;
+	});
+}
+
+//#endregion
+//#region src/core/relation/relation-config.ts
+const SCHEMA_REF_PREFIX = "schema://";
+function refTarget(value) {
+	return typeof value === "string" && value.startsWith(SCHEMA_REF_PREFIX) ? value.slice(9) : void 0;
+}
+function str(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function bool(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function strArray(value) {
+	return Array.isArray(value) && value.every((s) => typeof s === "string") ? value : void 0;
+}
+function hasType(schema, type) {
+	return Array.isArray(schema.type) ? schema.type.includes(type) : schema.type === type;
+}
+/**
+* Reads the widget extras (role, traits filter, …) that ride as sibling
+* keys on both relation forms — `x-relation` namespace first, flat vendor
+* keys as fallback.
+*/
+function readExtras(record) {
+	const ns = record["x-relation"];
+	if (ns && typeof ns === "object") {
+		const obj = ns;
+		return {
+			role: str(obj.role),
+			parent: str(obj.parent),
+			multiple: bool(obj.multiple),
+			traits: strArray(obj.traits),
+			useMockData: bool(obj.useMockData)
+		};
+	}
+	return {
+		role: str(record["x-relation-role"]),
+		parent: str(record["x-relation-parent"]),
+		multiple: bool(record["x-relation-multiple"]),
+		traits: strArray(record["x-relation-traits"]),
+		useMockData: bool(record["x-use-mock-data"])
+	};
+}
+/**
+* Reads a node's relation config, or `undefined` for a plain enum
+* select/multiselect. Two schema forms:
+*   1. Canonical — `$ref: schema://<target>` (one) or array of that ref
+*      (many); widget extras ride as sibling keys.
+*   2. Vendor — `x-relation` namespace or flat `x-relation-target`;
+*      cardinality follows the node's `type` unless `multiple` overrides.
+*/
+function readRelationConfig(schema) {
+	const record = schema;
+	const { multiple, ...extras } = readExtras(record);
+	const items = Array.isArray(schema.items) ? void 0 : schema.items;
+	const nestedItems = items && typeof items.properties === "object" ? { items } : {};
+	const singleTarget = refTarget(schema.$ref);
+	if (singleTarget) return {
+		target: singleTarget,
+		many: false,
+		...extras
+	};
+	const itemTarget = refTarget(items?.$ref);
+	if (hasType(schema, "array") && itemTarget) return {
+		target: itemTarget,
+		many: true,
+		...extras
+	};
+	const ns = record["x-relation"];
+	const target = ns && typeof ns === "object" ? str(ns.target) : str(record["x-relation-target"]);
+	if (!target) return void 0;
+	return {
+		target,
+		many: multiple ?? hasType(schema, "array"),
+		...extras,
+		...nestedItems
+	};
+}
+/**
+* Maps a relation target to the party autocomplete's kind hint. The widget
+* only knows `entity` / `contact` / undefined (= search both); join-table
+* targets (`participant`, `party`) stay open.
+*/
+function targetToKind(target) {
+	return target === "entity" || target === "contact" ? target : void 0;
+}
+/**
+* The sibling field a contact picker is scoped to (`memberOfEntityId`).
+*
+* Explicit `x-relation-parent` always wins. When it is missing — the live
+* artifact schema never carried the key — a contact relation whose traits
+* include exactly one sibling entity relation's role is scoped to that
+* sibling (LOS-860: titleOfficer traits `["title-company"]` → titleCompany).
+* Two matches is ambiguous, so no parent is invented.
+*/
+function relationParentFieldName(schema, path, relation) {
+	if (relation.parent) return relation.parent;
+	if (targetToKind(relation.target) !== "contact") return void 0;
+	const traits = relation.traits ?? [];
+	if (traits.length === 0) return void 0;
+	const siblings = propertiesAtParent(schema, path);
+	if (!siblings) return void 0;
+	const fieldName = path[path.length - 1];
+	if (typeof fieldName !== "string") return void 0;
+	const matches = [];
+	for (const [key, node] of Object.entries(siblings)) {
+		if (key === fieldName) continue;
+		const sibling = readRelationConfig(node);
+		if (!sibling || targetToKind(sibling.target) !== "entity") continue;
+		if (sibling.role && traits.includes(sibling.role)) matches.push(key);
+	}
+	return matches.length === 1 ? matches[0] : void 0;
+}
+function propertiesAtParent(schema, path) {
+	let node = schema;
+	for (const segment of path.slice(0, -1)) if (typeof segment === "number") {
+		const items = Array.isArray(node.items) ? void 0 : node.items;
+		if (!items) return void 0;
+		node = items;
+	} else {
+		const next = node.properties?.[segment];
+		if (!next) return void 0;
+		node = next;
+	}
+	return node.properties;
+}
+/**
+* The row-identity keys a relation row carries beyond the stage-configured
+* nested fields — the autocomplete result contracts (`PartySearchResult` /
+* `AssetSearchResult`), which the ref readers/mergers in relation-widgets
+* enumerate. The store walk applies the schema as a recursive allow-list,
+* and a stage-injected item schema declares ONLY the nested tray keys — so
+* these must be declared too or decoded rows lose their identity (empty
+* autocompletes, no trays, and no `id` for the baseline's id-match array
+* rebase). Declared as `hidden` controls: they walk and encode, never
+* render.
+*/
+const HIDDEN_STRING = {
+	type: "string",
+	"x-ui": { control: "hidden" }
+};
+const PARTY_IDENTITY_PROPS = {
+	id: HIDDEN_STRING,
+	pubId: HIDDEN_STRING,
+	name: HIDDEN_STRING,
+	kind: HIDDEN_STRING,
+	members: {
+		type: "array",
+		"x-ui": { control: "hidden" }
+	}
+};
+const ASSET_IDENTITY_PROPS = {
+	id: HIDDEN_STRING,
+	label: HIDDEN_STRING,
+	propertyType: HIDDEN_STRING,
+	subtitle: HIDDEN_STRING,
+	address1: HIDDEN_STRING,
+	address2: HIDDEN_STRING,
+	city: HIDDEN_STRING,
+	region: HIDDEN_STRING,
+	postalCode: HIDDEN_STRING,
+	country: HIDDEN_STRING,
+	formattedAddress: HIDDEN_STRING
+};
+/**
+* The row-identity contract for a relation target. A relation whose item
+* schema declares NO properties never reaches `withRelationRowIdentity` —
+* its rows are a value leaf holding the whole object, with no allow-list to
+* thin them — so a host feeding such a relation from a canonical record
+* must project the rows against this same set itself.
+*/
+function relationRowIdentityProps(target) {
+	return target === "asset" ? ASSET_IDENTITY_PROPS : PARTY_IDENTITY_PROPS;
+}
+/**
+* Returns a schema whose multi-row relation item schemas additionally
+* declare the row-identity keys (stage-configured keys win on collision).
+* Apply to the STORE schema only — rendering iterates the configured keys
+* and skips hidden controls.
+*/
+function withRelationRowIdentity(schema) {
+	const properties = schema.properties ?? {};
+	let changed = false;
+	const nextProps = { ...properties };
+	for (const [key, property] of Object.entries(properties)) {
+		const relation = readRelationConfig(property);
+		if (!relation?.many || !relation.items?.properties) continue;
+		const identity = relationRowIdentityProps(relation.target);
+		nextProps[key] = {
+			...property,
+			items: {
+				...relation.items,
+				properties: {
+					...identity,
+					...relation.items.properties
+				}
+			}
+		};
+		changed = true;
+	}
+	return changed ? {
+		...schema,
+		properties: nextProps
+	} : schema;
+}
+
+//#endregion
+//#region src/plugins/derivation/row-scope.ts
+/**
+* Returns the INNERMOST array-item object store containing the field at the
+* given path, or `undefined` when the path is not inside an array row (a
+* root-level field, or a field under a plain nested object).
+*
+* Tolerant on purpose: an unresolvable segment stops the walk and returns
+* whatever row was found so far, so a stale path (a row removed mid-render)
+* degrades to a scope lookup instead of throwing.
+*
+* @param internalFormStore The form store.
+* @param path The path to the field.
+*
+* @returns The row store, or `undefined`.
+*/
+function findRowStore(internalFormStore, path) {
+	let current = internalFormStore;
+	let row;
+	for (const segment of path) if (current.kind === "object" && typeof segment === "string") {
+		const child = readOwn(current.children, segment);
+		if (!child) return row;
+		current = child;
+	} else if (current.kind === "array" && typeof segment === "number") {
+		const child = current.children[segment];
+		if (!child) return row;
+		current = child;
+		if (current.kind === "object") row = current;
+	} else return row;
+	return row;
+}
+/**
+* Resolves a row's CANONICAL record: the server row from `offFormValues`
+* that carries the full column set (core columns the write model never
+* holds, plus the server's pre-evaluated derived values). The row's
+* collection is read by walking the row's own path into `offFormValues`
+* (`["assets", 0]` → `offFormValues.assets`), and the row is matched by
+* `id` — index is not identity, rows reorder.
+*
+* Reads signals (`offFormValues`, the row's `id` input), so callers get
+* re-resolution for free inside a computed.
+*
+* @param internalFormStore The form store.
+* @param rowStore The array-item object store.
+*
+* @returns The canonical row, or `undefined`.
+*/
+function canonicalRowOf(internalFormStore, rowStore) {
+	const path = rowStore.path;
+	if (path.length < 2) return void 0;
+	let collection = internalFormStore.offFormValues.value;
+	for (let index = 0; index < path.length - 1; index++) {
+		collection = readOwn(collection, path[index]);
+		if (collection == null) return void 0;
+	}
+	if (!Array.isArray(collection)) return void 0;
+	const idStore = readOwn(rowStore.children, "id");
+	const rowId = idStore ? getFieldInput(idStore) : void 0;
+	return collection.find((candidate) => candidate && typeof candidate === "object" && candidate.id === rowId);
+}
+/**
+* Resolves a row-scope dependency once the LIVE row value is already in
+* hand — the precedence a per-row formula evaluates in:
+*
+*   1. the root-record alias (`form.rootRecordAlias`) from `offFormValues` (it
+*      wins outright: a row column named like the alias is never the
+*      root record),
+*   2. the live sibling value in the SAME row (an explicit `null` counts —
+*      only `undefined` means "the row does not hold this"),
+*   3. the canonical row's column.
+*
+* A row scope deliberately does NOT see root-level form fields or other
+* `offFormValues` keys: a row's formula is evaluated against its own record
+* plus the root record, exactly as the server evaluates it.
+*
+* @param internalFormStore The form store.
+* @param rowStore The array-item object store the formula lives in.
+* @param key The dependency identifier.
+* @param formValue The live value the row holds for `key`, or `undefined`.
+*
+* @returns The resolved value, or `undefined`.
+*/
+function resolveRowFallback(internalFormStore, rowStore, key, formValue) {
+	if (key === internalFormStore.rootRecordAlias) {
+		const handle = readOwn(internalFormStore.offFormValues.value, key);
+		if (handle && typeof handle === "object") return handle;
+	}
+	if (formValue !== void 0) return formValue;
+	return readOwn(canonicalRowOf(internalFormStore, rowStore), key);
+}
+/**
+* Resolves a single identifier in the scope of a row: the same precedence
+* `buildDerivation` evaluates a row formula's dependencies in, with the
+* live sibling read derived-aware (a sibling formula resolves through its
+* own derived signal, so the read is always fresh; an erroring sibling
+* resolves `undefined`, never a stale number).
+*
+* @param internalFormStore The form store.
+* @param rowStore The array-item object store.
+* @param key The identifier to resolve.
+*
+* @returns The resolved value, or `undefined`.
+*/
+function resolveRowScopeValue(internalFormStore, rowStore, key) {
+	const child = readOwn(rowStore.children, key);
+	let formValue;
+	if (child) {
+		const slot = child.kind === "value" ? derivationKey.get(internalFormStore, child) : void 0;
+		if (slot) {
+			const state = slot.derived.value;
+			formValue = state.error === null ? state.value : void 0;
+		} else formValue = getFieldInput(child);
+	}
+	return resolveRowFallback(internalFormStore, rowStore, key, formValue);
+}
+
+//#endregion
+//#region src/plugins/derivation/resolve-scope-value.ts
+/**
+* Resolves a single scalar key through the canonical scope precedence —
+* the same order the derivation plugin evaluates formula dependencies in:
+* the form value wins (a formula field resolves through its derived
+* signal, so the read is always fresh; an erroring formula resolves
+* `undefined`, never a stale number), `offFormValues` fills what the form
+* does not hold (an off-stage field still resolves from the canonical record).
+*
+* For widget-side scalar reads (e.g. an amount-or-percent field resolving
+* its percent basis). Collection overlay semantics stay inside the
+* derivation plugin — this helper is for scalars.
+*
+* @param internalFormStore The form store.
+* @param key The root-level field key to resolve.
+*
+* @returns The resolved value, or `undefined`.
+*/
+function resolveScopeValue(internalFormStore, key) {
+	const child = readOwn(internalFormStore.children, key);
+	let formValue;
+	if (child) {
+		const slot = child.kind === "value" ? derivationKey.get(internalFormStore, child) : void 0;
+		if (slot) {
+			const state = slot.derived.value;
+			formValue = state.error === null ? state.value : void 0;
+		} else formValue = getFieldInput(child);
+	}
+	return formValue === void 0 ? readOwn(internalFormStore.offFormValues.value, key) : formValue;
+}
+/**
+* Resolves a single scalar key in the scope of the field at `path` — the
+* path-aware sibling of `resolveScopeValue`, and the read a widget owned by
+* a field should use:
+*
+* - inside an array row, the ROW's scope (live siblings in the same row →
+*   the canonical row from `offFormValues` matched by `id` → the parent
+*   root record under the form's `rootRecordAlias`), so a per-row formula's inputs are ITS
+*   row's values;
+* - anywhere else, the document scope (`resolveScopeValue`).
+*
+* The same precedence the derivation graph evaluates the field's own
+* formula in, so a widget can never display an input the value was not
+* computed from.
+*
+* @param internalFormStore The form store.
+* @param path The path of the field whose scope to resolve in.
+* @param key The identifier to resolve.
+*
+* @returns The resolved value, or `undefined`.
+*/
+function resolveScopeValueAt(internalFormStore, path, key) {
+	const rowStore = findRowStore(internalFormStore, path);
+	return rowStore ? resolveRowScopeValue(internalFormStore, rowStore, key) : resolveScopeValue(internalFormStore, key);
+}
+
+//#endregion
+//#region src/core/visibility/resolve-conditionals.ts
+/**
+* Resolves the root schema's `allOf` `if/then/else` blocks into one
+* `VisibleWhen` per gated field key (first-match-wins per key).
+*
+* Supported condition shapes (the only ones in seed + prod schemas):
+*   - `{ const: x }`             → equals x
+*   - `{ enum: [x, y] }`         → one-of [x, y] (LOS-822 multi-value)
+*   - `{ contains: { const: x } }` → contains x (array-valued watchers)
+*
+* A `then` branch keeps the positive op; an `else` branch flips it
+* (`equals` → `not-equals`, `contains` → `not-contains`). Compound
+* conditions (AND across watched fields) are out of scope — the first
+* watched property of an `if` block decides.
+*
+* @param schema The root form schema.
+*
+* @returns The gated field keys mapped to their visibility rule.
+*/
+function resolveConditionals(schema) {
+	const out = {};
+	const allOf = schema.allOf;
+	if (!Array.isArray(allOf)) return out;
+	for (const blockRaw of allOf) {
+		if (!blockRaw || typeof blockRaw !== "object") continue;
+		const block = blockRaw;
+		const condition = parseIfCondition(block.if);
+		if (!condition) continue;
+		collectBranch(out, block.then, condition.positive);
+		collectBranch(out, block.else, condition.negative);
+	}
+	return out;
+}
+/**
+* Parses an `if` block's first watched property into the branch rules.
+*/
+function parseIfCondition(ifBlock) {
+	if (!ifBlock || typeof ifBlock !== "object") return null;
+	const props = ifBlock.properties;
+	if (!props || typeof props !== "object") return null;
+	const entries = Object.entries(props);
+	if (entries.length === 0) return null;
+	const [field, condRaw] = entries[0];
+	if (!condRaw || typeof condRaw !== "object") return null;
+	const cond = condRaw;
+	if ("const" in cond) return {
+		positive: {
+			field,
+			op: "equals",
+			value: cond.const
+		},
+		negative: {
+			field,
+			op: "not-equals",
+			value: cond.const
+		}
+	};
+	if (Array.isArray(cond.enum)) return {
+		positive: {
+			field,
+			op: "one-of",
+			value: cond.enum
+		},
+		negative: {
+			field,
+			op: "not-one-of",
+			value: cond.enum
+		}
+	};
+	if ("contains" in cond && cond.contains && typeof cond.contains === "object") {
+		const containsConst = cond.contains.const;
+		if (containsConst !== void 0) return {
+			positive: {
+				field,
+				op: "contains",
+				value: containsConst
+			},
+			negative: {
+				field,
+				op: "not-contains",
+				value: containsConst
+			}
+		};
+	}
+	return null;
+}
+/**
+* Records the branch's gated property keys under the given rule.
+*/
+function collectBranch(out, branch, visibleWhen) {
+	if (!branch || typeof branch !== "object") return;
+	const props = branch.properties;
+	if (!props || typeof props !== "object") return;
+	for (const key of Object.keys(props)) {
+		if (!isSafeKey(key) || readOwn(out, key) !== void 0) continue;
+		out[key] = visibleWhen;
+	}
+}
+
+//#endregion
+//#region src/plugins/visibility/plugin.ts
+/**
+* The visibility plugin's key. It keeps no state (rules and computeds live
+* on the field stores' base `visibleWhen`/`visible` members).
+*/
+const visibilityKey = new PluginKey("visibility");
+/**
+* The visibility plugin: every field gated by an `allOf` `if/then/else`
+* block on its OWN scope's schema gets a `visible` computed signal over the
+* watched field's resolved value. Two scope kinds (LOS-722 extended
+* visibility into rows — the spec's open question 3):
+*
+* - the root scope, whose rules come from the form schema's `allOf`;
+* - an array-row scope, whose rules come from the ITEMS schema's `allOf`
+*   (`buildNestedFieldItems` carries the related dataset's conditionals),
+*   evaluated against THAT row's values — row A's trigger never gates
+*   row B's field.
+*
+* Visibility gates RENDERING only: a hidden field keeps its state, stays
+* in the dirty diff, and rides the payload. Fields without a rule get no
+* signal — the public store reads that as always visible.
+*
+* Register AFTER derivation (array order): a WHEN watching a formula field
+* resolves through its derived slot. No hard `dependsOn` — a form without
+* a calc engine legitimately omits derivation, and the watched-value read
+* falls back to the field's input.
+*/
+function visibility() {
+	return {
+		name: "visibility",
+		key: visibilityKey,
+		build: () => null,
+		buildScope(ctx, scope) {
+			const form = ctx.form;
+			const isRoot = scope === form;
+			const rules = resolveConditionals(scope.schema);
+			for (const [key, visibleWhen] of Object.entries(rules)) {
+				const child = readOwn(scope.children, key);
+				if (!child || typeof child !== "object") continue;
+				const store = scope.children[key];
+				store.visibleWhen = visibleWhen;
+				store.visible = isRoot ? computed(() => evaluateVisibleWhen(form, visibleWhen)) : computed(() => evaluateRowVisibleWhen(form, scope, visibleWhen));
+			}
+		}
+	};
+}
+/**
+* Evaluates a visibility rule against the canonical scope: the form value
+* wins, `offFormValues` fills what the form does not hold — so a WHEN can
+* watch an off-stage record field, and (via the `record[key]` bracket form) a
+* root-record alias field from an asset schema (LOS-471).
+*/
+function evaluateVisibleWhen(internalFormStore, visibleWhen) {
+	return compareVisibleWhen(resolveWhenRef(internalFormStore, visibleWhen.field), visibleWhen);
+}
+/**
+* Evaluates a ROW field's visibility rule in its row's scope: the watched
+* value resolves through `resolveRowScopeValue` (live row sibling,
+* derived-aware → canonical row from `offFormValues`), so toggling row A's
+* trigger flips row A's gated field and no other row's. The bracket form
+* resolves its base through the same row precedence — `record[key]` reads off
+* the root-record alias exactly as it does at root (LOS-819).
+*/
+function evaluateRowVisibleWhen(internalFormStore, rowScope, visibleWhen) {
+	return compareVisibleWhen(resolveWhenRefWith((key) => resolveRowScopeValue(internalFormStore, rowScope, key), visibleWhen.field), visibleWhen);
+}
+function compareVisibleWhen(actual, visibleWhen) {
+	switch (visibleWhen.op) {
+		case "equals": return actual === visibleWhen.value;
+		case "not-equals": return actual !== visibleWhen.value;
+		case "one-of": return Array.isArray(visibleWhen.value) && visibleWhen.value.includes(actual);
+		case "not-one-of": return !Array.isArray(visibleWhen.value) || !visibleWhen.value.includes(actual);
+		case "contains": return Array.isArray(actual) && actual.includes(visibleWhen.value);
+		case "not-contains": return !Array.isArray(actual) || !actual.includes(visibleWhen.value);
+	}
+}
+/**
+* Resolves a watched-field reference at ROOT scope via the shared parser.
+*/
+function resolveWhenRef(internalFormStore, ref) {
+	return resolveWhenRefWith((key) => resolveScopeValue(internalFormStore, key), ref);
+}
+/**
+* Parses a watched-field reference over a scope's own key resolver. Two
+* shapes, mirroring the formula grammar: a plain key resolves through the
+* scope precedence; the bracket form `record[key]` reads `key` off the OBJECT
+* the scope resolves under the form's `rootRecordAlias`. An absent or
+* non-object handle resolves `undefined`, so an equals-gated field simply
+* stays hidden — e.g. in a host with no parent record in scope.
+*/
+function resolveWhenRefWith(resolve, ref) {
+	const open = ref.indexOf("[");
+	if (open > 0 && ref.endsWith("]")) {
+		const base = resolve(ref.slice(0, open));
+		if (base && typeof base === "object" && !Array.isArray(base)) return readOwn(base, ref.slice(open + 1, -1));
+		return;
+	}
+	return resolve(ref);
+}
+
+//#endregion
+//#region src/plugins/bagger/compute-scope.ts
+/**
+* canon is the record the domain's canonical loader returns; bagger
+* distributes it: schema-declared keys become form state through the
+* store's allow-list, the whole record becomes the off-form value bag.
+*
+* This module computes that off-form bag ("the shelf") as a pure function
+* of a schema and a canonical record — no store, no signals, so a later
+* task can call it identically from a plugin's `build` and from any
+* engine-less reader.
+*/
+const DEFAULT_BAG = "data";
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* The record keys that hold relation ROWS, from both classification
+* sources. The union is load-bearing in both directions:
+*
+* - `collectionsSchema` (the dataset schema) alone decides collections the
+*   walked schema does not configure. A stage that renders no assets tray
+*   still needs `assets` on the shelf as FLATTENED rows — left raw, every
+*   bag-resident key (`assignmentFee`) reads undefined per row and
+*   `SUM(assets[assignmentFee])` or a check silently computes 0.
+* - The walked schema alone declares relations the dataset schema lacks:
+*   registry-role slugs and fallback defs are synthesized per stage
+*   (`buildStageSchemaFromConfig`), so replacing rather than union-ing
+*   would drop those collections off the shelf.
+*/
+function collectionKeys(schema, collectionsSchema) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const properties of [schema.properties, collectionsSchema?.properties]) for (const [key, node] of Object.entries(properties ?? {})) if (readRelationConfig(node)?.many) keys.add(key);
+	return keys;
+}
+/**
+* Merges a source row's `x-column` fields with its bag column — bag wins,
+* per the `x-column` save-routing authority (AI.md: read = row spread over
+* its `data`). INTACT merge only, no envelope unwrapping: a later task
+* seeds form rows from this output, and unwrapping here would hand the
+* store already-flattened envelope values, reproducing the LOS-461
+* regression.
+*/
+function flattenSourceRow(row, bag) {
+	const bagValue = row[bag];
+	return isPlainObject(bagValue) ? {
+		...row,
+		...bagValue
+	} : { ...row };
+}
+/**
+* Unwraps every kind-envelope entry (estimate / amount-or-percent) in a
+* flattened row to its value half, in place on a shallow copy. Shelf-only:
+* the off-form bag is read-only display data, so it carries resolved
+* values, never the envelope's mode/meta half.
+*/
+function unwrapEnvelopes(flat) {
+	const unwrapped = { ...flat };
+	for (const key of Object.keys(unwrapped)) {
+		const raw = unwrapped[key];
+		if (isEnvelope(raw)) unwrapped[key] = envelopesWire.unwrap(raw).value;
+	}
+	return unwrapped;
+}
+/**
+* Computes the off-form value bag for a canonical record: every declared
+* scalar and relation collection, bag-merged and envelope-unwrapped, plus
+* an alias entry holding the whole computed scope (so a formula or
+* widget can address `record.termMonths` as readily as bare `termMonths`).
+*/
+function computeBag(schema, record, opts) {
+	const bag = opts?.bag ?? DEFAULT_BAG;
+	const alias = opts?.rootRecordAlias ?? DEFAULT_ROOT_RECORD_ALIAS;
+	const scope = unwrapEnvelopes(flattenSourceRow(record, bag));
+	for (const key of collectionKeys(schema, opts?.collectionsSchema)) {
+		const source = record[key];
+		if (isPlainObject(source)) continue;
+		scope[key] = Array.isArray(source) ? source.map((row) => unwrapEnvelopes(flattenSourceRow(row, bag))) : [];
+	}
+	scope[alias] = { ...scope };
+	return scope;
+}
+
+//#endregion
+//#region src/plugins/bagger/plugin.ts
+/**
+* canon is the record the domain's canonical loader returns; bagger
+* distributes it: schema-declared keys become form state through the
+* store's allow-list, the whole record becomes the off-form value bag.
+*
+* Two constraints:
+* - The shelf (`offFormValues`) unwraps kind envelopes (`computeBag`); the
+*   form side never does — row seeding reads a SECOND, intact row index
+*   built here from `flattenSourceRow`, so a seeded estimate keeps its
+*   `{ kind, value, mode }` envelope instead of collapsing to a bare
+*   number (LOS-461).
+* - `build` runs BEFORE the schema walk, so it may read only
+*   `config.schema` — `form.schema` (set by `initializeFieldStore`) is
+*   still undefined there. The shelf is written from the ROOT `buildScope`
+*   call instead, the one write point after the walk (dispatched in plugin
+*   array order — `create-form-store.ts`).
+*
+* A seeded envelope leaf (estimate / amount-or-percent) must never fork
+* its two halves: the envelopes plugin already built this leaf's slot
+* (empty) from the row's OWN raw before bagger runs in the same
+* `buildScope` dispatch, so seeding writes through the SAME decode
+* (`decodeEstimateEnvelope`/`decodeAmountOrPercentEnvelope`) and the SAME sole
+* writer (`writeEnvelope`) the walk itself uses — never a hand-built
+* envelope object landing straight in `input`.
+*/
+const baggerKey = new PluginKey("bagger");
+/**
+* Builds the id-keyed row index for one many:true relation field, from the
+* INTACT (non-unwrapped) flatten — the seeding source, never `computeBag`'s
+* unwrapped rows.
+*/
+function indexRows(rows, bag) {
+	const index = /* @__PURE__ */ new Map();
+	if (!Array.isArray(rows)) return index;
+	for (const row of rows) {
+		if (typeof row !== "object" || row === null) continue;
+		const flat = flattenSourceRow(row, bag);
+		const id = flat.id;
+		if (typeof id === "string") index.set(id, flat);
+	}
+	return index;
+}
+/**
+* Seeds one declared leaf with its canonical value as BASELINE: `input`,
+* `startInput`, AND `initialInput` — `reset()` restores a field from
+* `initialInput` (`methods/reset.ts`), so a seed that skipped it would
+* survive until the first reset and then blank out, the legacy-hydration
+* parity `reset` otherwise breaks (a legacy record merged canonical
+* values into the row BEFORE decode, so every channel already carried
+* them; seeding after the walk must land on the same three channels by
+* hand).
+*
+* An envelope-control leaf (estimate / amount-or-percent) does NOT get
+* its raw envelope object written into `input` — that would fork the
+* value half (a wrapped object landing in a number field) from the
+* envelopes plugin's own slot, which the walk already built empty from
+* this row's OWN raw earlier in the same `buildScope` dispatch. Instead
+* this decodes through the plugin's own functions
+* (`decodeEstimateEnvelope`/`decodeAmountOrPercentEnvelope`) and writes through its
+* sole writer (`writeEnvelope`), plus reassigns `slot.startEnvelope` —
+* the same field `rebase`'s `bindAdopted` reassigns when adopting a new
+* baseline (`envelope.ts`) — so the meta half (mode, manualValue) seeds
+* alongside the value half instead of staying at its empty default.
+*/
+function seedLeaf(ctx, child, rawValue) {
+	const slot = envelopesKey.get(ctx.form, child);
+	if (!slot) {
+		child.input.value = rawValue;
+		child.startInput.value = rawValue;
+		child.initialInput.value = rawValue;
+		return;
+	}
+	if (slot.family === "estimate") {
+		const decoded = decodeEstimateEnvelope(ctx.form, child, rawValue);
+		slot.startEnvelope.value = decoded;
+		child.startInput.value = decoded.value;
+		child.initialInput.value = decoded.value;
+		writeEnvelope(ctx.form, child, slot, decoded);
+	} else {
+		const decoded = decodeAmountOrPercentEnvelope(ctx.form, child, rawValue);
+		slot.startEnvelope.value = decoded;
+		child.startInput.value = decoded.value;
+		child.initialInput.value = decoded.value;
+		writeEnvelope(ctx.form, child, slot, decoded);
+	}
+}
+/**
+* Seeds one row scope's declared value leaves from its canonical source
+* row: a leaf with no live input yet (`input.value === undefined`) takes
+* the source row's value as baseline (`seedLeaf`). A row already holding
+* a value, or with no canonical match, is left untouched.
+*/
+function seedRow(ctx, scope, raw) {
+	const fieldKey = String(scope.path[0]);
+	const rowId = raw?.id ?? "";
+	const sourceRow = ctx.state.rowsByField.get(fieldKey)?.get(rowId);
+	if (!sourceRow) return;
+	for (const [key, child] of Object.entries(scope.children)) {
+		if (child.kind !== "value") continue;
+		if (child.input.value !== void 0) continue;
+		const rawValue = sourceRow[key];
+		if (rawValue === void 0) continue;
+		seedLeaf(ctx, child, rawValue);
+	}
+}
+/**
+* The bagger plugin: computes the off-form shelf once (`computeBag`) and
+* owns `offFormValues`, then seeds every relation row's declared keys from
+* its canonical row as an unedited baseline. Registration order:
+* `[envelopes(), bagger(record), derivation?, visibility()]` — envelopes
+* first so its slot already exists on every estimate/amount-or-percent leaf by the
+* time seeding runs (`dependsOn: [envelopesKey]` enforces this at
+* `createFormStore`).
+*/
+function bagger(record, opts) {
+	const bag = opts?.bag ?? "data";
+	return {
+		name: "bagger",
+		key: baggerKey,
+		dependsOn: [envelopesKey],
+		build(form, config) {
+			const schema = config.schema;
+			const scope = computeBag(schema, record, {
+				...opts,
+				rootRecordAlias: form.rootRecordAlias
+			});
+			const rowsByField = /* @__PURE__ */ new Map();
+			for (const key of collectionKeys(schema, opts?.collectionsSchema)) rowsByField.set(key, indexRows(record[key], bag));
+			return {
+				scope,
+				rowsByField
+			};
+		},
+		buildScope(ctx, scope, raw) {
+			if (scope === ctx.form) {
+				ctx.form.offFormValues.value = ctx.state.scope;
+				return;
+			}
+			seedRow(ctx, scope, raw);
+		},
+		reseedScope(ctx, scope, raw) {
+			seedRow(ctx, scope, raw);
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/checks/interpolate.ts
+/**
+* Eslint-style `{{ placeholder }}` interpolation (ANALYSIS-eslint.md §1.5).
+* An unsupplied placeholder is left literally in place rather than blanked.
+*/
+function interpolate(text, data) {
+	return text.replace(/\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g, (full, key) => {
+		if (!data || !Object.prototype.hasOwnProperty.call(data, key)) return full;
+		return String(data[key]);
+	});
+}
+
+//#endregion
+//#region src/plugins/checks/key.ts
+const checksKey = new PluginKey("checks");
+
+//#endregion
+//#region src/plugins/checks/formula.ts
+/** Shared messageId for parse/eval failures (plugin catch + host mapping). */
+const UNEVALUABLE_MESSAGE_ID = "unevaluable";
+/**
+* The one built-in check definition: a `bespoke.check` row is an *instance*
+* of this, not a definition of its own (ANALYSIS-eslint.md §2.6).
+*/
+function formulaCheck(engine) {
+	return {
+		meta: {
+			name: "formula",
+			messages: {
+				failed: "{{message}}",
+				[UNEVALUABLE_MESSAGE_ID]: "{{error}}"
+			},
+			defaultOptions: {
+				formula: "",
+				message: "Failed.",
+				targetFieldKeys: []
+			},
+			optionsSchema: {
+				type: "object",
+				required: ["formula"],
+				properties: {
+					formula: { type: "string" },
+					message: { type: "string" },
+					name: { type: "string" },
+					targetFieldKeys: {
+						type: "array",
+						items: { type: "string" }
+					}
+				}
+			}
+		},
+		create(context) {
+			const formula = context.options.formula;
+			const targetPaths = (context.options.targetFieldKeys ?? []).map((key) => [key]);
+			const parsed = engine.parse(formula);
+			const deps = parsed.ok ? engine.extractDependencies(parsed.node) : [];
+			const pathRefs = parsed.ok ? engine.extractPathRefs?.(parsed.node) ?? [] : [];
+			const collections = new Set(pathRefs.map((ref) => ref.collection));
+			return { evaluate() {
+				if (!parsed.ok) {
+					context.report({
+						messageId: UNEVALUABLE_MESSAGE_ID,
+						data: { error: parsed.error },
+						paths: targetPaths
+					});
+					return;
+				}
+				const scope = buildEvalScope(context.scope, deps, collections);
+				let out;
+				try {
+					out = engine.evaluate(parsed.node, scope);
+				} catch (err) {
+					context.report({
+						messageId: UNEVALUABLE_MESSAGE_ID,
+						data: { error: err instanceof Error ? err.message : String(err) },
+						paths: targetPaths
+					});
+					return;
+				}
+				if (out === null || out === void 0) return;
+				if (out) return;
+				context.report({
+					messageId: "failed",
+					data: { message: context.options.message ?? "Failed." },
+					paths: targetPaths
+				});
+			} };
+		}
+	};
+}
+/**
+* Eval bag for one formula run. Every dep goes through `scope.get` — pathRef
+* names are NOT forced through `rows()` (a `record[…]` root-record ref is a plain
+* object; rows would collapse it to `[]`). Collections absent from deps
+* still land via rows() for aggregate-only refs.
+*/
+function buildEvalScope(scope, deps, collections) {
+	const bag = {};
+	for (const dep of deps) bag[dep] = scope.get(dep);
+	for (const collection of collections) if (!(collection in bag)) bag[collection] = scope.rows(collection);
+	return bag;
+}
+
+//#endregion
+//#region src/plugins/checks/plugin.ts
+const SEVERITY_ORDER = {
+	error: 0,
+	warning: 1,
+	info: 2
+};
+/**
+* Checks plugin (LOS-605 / spec D8): eslint's contract on a form store.
+* Findings are a parallel channel — they never merge into `errors`.
+*
+* Register after derivation so a check that reads a formula field resolves
+* through its derived slot. Array order, not a hard `dependsOn` — a form
+* without a calc engine legitimately omits derivation.
+*
+* Always register (even with zero instances). Live instance edits go through
+* `replaceCheckInstances` so the host does not remount the form.
+*/
+function checks(config) {
+	return {
+		name: "checks",
+		key: checksKey,
+		build(form) {
+			const collections = createSignal(config.collections ?? Object.freeze({}));
+			const instances = createSignal(instanceComputeds(config, freezeScope(form, collections)));
+			const findings = computed(() => {
+				const all = [];
+				for (const slot of instances.value) all.push(...slot.value);
+				return [...all].sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] || a.id.localeCompare(b.id));
+			});
+			return {
+				findings,
+				hasBlockingFinding: computed(() => findings.value.some((finding) => finding.severity === "error")),
+				instances,
+				collections
+			};
+		}
+	};
+}
+/**
+* Re-registers check instances on a live form store (admin edits, late
+* prop arrival) without remounting. Swaps the per-instance computeds the
+* `findings` signal already reads.
+*/
+function replaceCheckInstances(form, config) {
+	const internal = internalOf(form);
+	const state = checksKey.getState(internal);
+	if (!state) throw new Error("replaceCheckInstances: checks plugin is not registered");
+	state.collections.value = config.collections ?? Object.freeze({});
+	const scope = freezeScope(internal, state.collections);
+	state.instances.value = instanceComputeds(config, scope);
+}
+function instanceComputeds(config, scope) {
+	return registerInstances(config, scope).map((runtime) => computed(() => evaluateInstance(runtime)));
+}
+function registerInstances(config, scope) {
+	const runtimes = [];
+	for (const instance of config.instances) {
+		if (instance.severity === "off") continue;
+		const definition = config.definitions[instance.check];
+		if (!definition) throw new Error(`Check instance "${instance.id}" (${instance.check}): unknown definition`);
+		const options = mergeAndValidateOptions(instance, definition);
+		const reports = [];
+		const context = {
+			id: instance.id,
+			checkId: instance.check,
+			options,
+			scope,
+			report(finding) {
+				reports.push(finding);
+			}
+		};
+		const handlers = definition.create(context);
+		runtimes.push({
+			id: instance.id,
+			checkId: instance.check,
+			severity: instance.severity,
+			definition,
+			options,
+			evaluate: () => handlers.evaluate(),
+			takeReports: () => {
+				const batch = reports.slice();
+				reports.length = 0;
+				return batch;
+			}
+		});
+	}
+	return runtimes;
+}
+function mergeAndValidateOptions(instance, definition) {
+	const defaults = definition.meta.defaultOptions && typeof definition.meta.defaultOptions === "object" ? definition.meta.defaultOptions : {};
+	const provided = instance.options && typeof instance.options === "object" ? instance.options : {};
+	const merged = {
+		...defaults,
+		...provided
+	};
+	const schema = definition.meta.optionsSchema;
+	if (schema === false) return Object.freeze(merged);
+	if (schema === void 0) {
+		if (Object.keys(provided).length > 0) throw new Error(`Check instance "${instance.id}" (${instance.check}): this check takes no options`);
+		return Object.freeze(merged);
+	}
+	const required = Array.isArray(schema.required) ? schema.required : [];
+	for (const key of required) {
+		const value = merged[key];
+		if (value === void 0 || value === null) throw new Error(`Check instance "${instance.id}" (${instance.check}): missing option "${key}"`);
+	}
+	const properties = schema.properties && typeof schema.properties === "object" ? schema.properties : {};
+	for (const [key, propSchema] of Object.entries(properties)) {
+		if (!Object.prototype.hasOwnProperty.call(merged, key)) continue;
+		const value = merged[key];
+		if (value === void 0) continue;
+		validateOptionType(instance, key, value, propSchema);
+	}
+	return Object.freeze(merged);
+}
+function validateOptionType(instance, key, value, propSchema) {
+	const named = `Check instance "${instance.id}" (${instance.check})`;
+	if (propSchema.type === "string") {
+		if (typeof value !== "string") throw new Error(`${named}: option "${key}" must be a string`);
+		return;
+	}
+	if (propSchema.type === "array") {
+		if (!Array.isArray(value)) throw new Error(`${named}: option "${key}" must be an array`);
+		if (propSchema.items?.type === "string") {
+			for (const entry of value) if (typeof entry !== "string") throw new Error(`${named}: option "${key}" must be an array of strings`);
+		}
+	}
+}
+/**
+* Live form / derived value only — offForm fill belongs to the derivation
+* closure in `get`, not here.
+*/
+function resolveLiveFormValue(form, key) {
+	const child = readOwn(form.children, key);
+	if (!child) return void 0;
+	const slot = child.kind === "value" ? derivationKey.get(form, child) : void 0;
+	if (slot) {
+		const state = slot.derived.value;
+		return state.error === null ? state.value : void 0;
+	}
+	return getFieldInput(child);
+}
+function freezeScope(form, collections) {
+	const get = (key) => {
+		const formValue = resolveLiveFormValue(form, key);
+		const offValue = readOwn(form.offFormValues.value, key);
+		const fromCollections = readOwn(collections.value, key);
+		const live = formValue === void 0 ? offValue : formValue;
+		if (Array.isArray(fromCollections) && Array.isArray(live)) return mergeCollectionRows(fromCollections, live);
+		if (Array.isArray(offValue) && Array.isArray(formValue)) return mergeCollectionRows(offValue, formValue);
+		return live;
+	};
+	const scope = {
+		get,
+		rows(collection) {
+			const value = get(collection);
+			return Array.isArray(value) ? value : [];
+		},
+		values() {
+			const bag = { ...form.offFormValues.value };
+			for (const key of Object.keys(form.children)) bag[key] = get(key);
+			for (const key of Object.keys(collections.value)) if (!(key in bag)) bag[key] = get(key);
+			return bag;
+		}
+	};
+	return Object.freeze(scope);
+}
+function evaluateInstance(runtime) {
+	try {
+		runtime.evaluate();
+	} catch (err) {
+		runtime.takeReports();
+		const targets = runtime.options.targetFieldKeys ?? [];
+		return findingsFromDescriptor(runtime, {
+			messageId: UNEVALUABLE_MESSAGE_ID,
+			data: { error: err instanceof Error ? err.message : String(err) },
+			paths: targets.map((key) => [key])
+		});
+	}
+	const reported = runtime.takeReports();
+	const findings = [];
+	for (const descriptor of reported) findings.push(...findingsFromDescriptor(runtime, descriptor));
+	return findings;
+}
+function findingsFromDescriptor(runtime, descriptor) {
+	const message = resolveMessage(runtime, descriptor);
+	const paths = descriptor.paths;
+	if (!paths || paths.length === 0) return [findingOf(runtime, {
+		...descriptor,
+		message,
+		path: []
+	})];
+	return paths.map((path) => findingOf(runtime, {
+		...descriptor,
+		message,
+		path
+	}));
+}
+function resolveMessage(runtime, descriptor) {
+	if (descriptor.message) return descriptor.message;
+	if (descriptor.messageId) {
+		const template = runtime.definition.meta.messages[descriptor.messageId];
+		if (template) return interpolate(template, descriptor.data);
+	}
+	return "Failed.";
+}
+function findingOf(runtime, parts) {
+	const options = runtime.options;
+	const name = typeof options.name === "string" && options.name.length > 0 ? options.name : runtime.checkId;
+	return {
+		id: runtime.id,
+		checkId: runtime.checkId,
+		name,
+		messageId: parts.messageId,
+		message: parts.message,
+		severity: runtime.severity,
+		path: parts.path ?? []
+	};
+}
+
+//#endregion
+export { bindAdopted as A, wrapEstimate as B, withRelationRowIdentity as C, FieldSlotKey as D, envelopesKey as E, syncEstimateInput as F, getDirtyFieldInput as H, writeEnvelope as I, envelopesWire as L, decodeEstimateEnvelope as M, resolveEstimateMode as N, PluginKey as O, syncAmountOrPercentInput as P, isEnvelope as R, targetToKind as S, derivationKey as T, encodeScopeValues as V, resolveRowFallback as _, checksKey as a, relationParentFieldName as b, collectionKeys as c, visibility as d, visibilityKey as f, findRowStore as g, canonicalRowOf as h, formulaCheck as i, decodeAmountOrPercentEnvelope as j, adoptEnvelope as k, computeBag as l, resolveScopeValueAt as m, replaceCheckInstances as n, bagger as o, resolveScopeValue as p, UNEVALUABLE_MESSAGE_ID as r, baggerKey as s, checks as t, flattenSourceRow as u, resolveRowScopeValue as v, mergeCollectionRows as w, relationRowIdentityProps as x, readRelationConfig as y, wrapAmountOrPercent as z };