jsonisch 0.1.0

package/dist/form-ref-BEri3JKv.js

@@ -0,0 +1,1123 @@
+//#region src/core/field/walk-field-store.ts
+/**
+* Walks through the field store and all nested children, calling the
+* callback for each field store in depth-first order. The callback may
+* return `true` to stop the walk early, in which case `walkFieldStore`
+* returns `true` as well.
+*
+* The walk reads array `items` reactively, so a reactive caller subscribes
+* to structural changes naturally. Imperative callers that must not
+* subscribe should wrap the call in `untrack`.
+*
+* @param internalFieldStore The field store to walk.
+* @param callback The callback to invoke for each field store. Return `true` to stop the walk early.
+*
+* @returns Whether the walk was stopped early by the callback.
+*/
+function walkFieldStore(internalFieldStore, callback) {
+	if (callback(internalFieldStore)) return true;
+	if (internalFieldStore.kind === "array") {
+		for (let index = 0; index < internalFieldStore.items.value.length; index++) if (walkFieldStore(internalFieldStore.children[index], callback)) return true;
+	} else if (internalFieldStore.kind === "object") {
+		for (const key in internalFieldStore.children) if (walkFieldStore(internalFieldStore.children[key], callback)) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/core/field/get-field-bool.ts
+/**
+* Returns whether the specified boolean property is true for the field
+* store or any of its nested children.
+*
+* @param internalFieldStore The field store to check.
+* @param type The boolean property type to check.
+*
+* @returns Whether the property is true.
+*/
+function getFieldBool(internalFieldStore, type) {
+	return walkFieldStore(internalFieldStore, (fieldStore) => Boolean(fieldStore[type].value));
+}
+
+//#endregion
+//#region src/core/control.ts
+/**
+* Derived from the closed set so the union and the lookup can never drift
+* apart. An unknown name resolves to `undefined` and falls through to the
+* format/type inference — never to a different kind.
+*/
+const controlKinds = new Set([
+	"text",
+	"textarea",
+	"number",
+	"boolean",
+	"date",
+	"address",
+	"email",
+	"email-array",
+	"phone",
+	"phone-array",
+	"link-array",
+	"currency",
+	"percent",
+	"interest-rate",
+	"ein",
+	"ssn",
+	"us-state",
+	"legal-id",
+	"select",
+	"multiselect",
+	"formula",
+	"estimate",
+	"amount-or-percent",
+	"line-item",
+	"object-array",
+	"hidden"
+]);
+/**
+* Reads the explicit control of a node from the `x-ui.control` namespace —
+* the only explicit channel. Hosts with schemas in another dialect (e.g.
+* the origin app's `x-field-type`) translate before handing schemas over.
+*/
+function readExplicitControl(schema) {
+	const ui = schema["x-ui"];
+	if (!ui || typeof ui !== "object") return void 0;
+	const control = ui.control;
+	return typeof control === "string" && controlKinds.has(control) ? control : void 0;
+}
+/**
+* Returns whether the node's `type` includes the given JSON-Schema type.
+*/
+function hasType(schema, type) {
+	return Array.isArray(schema.type) ? schema.type.includes(type) : schema.type === type;
+}
+/**
+* Reads the relation config of a node from the `x-relation` namespace or the
+* flat vendor `x-relation-target`/`x-relation-multiple` keys (the sibling-key
+* form the canonical `$ref: schema://…` shape also uses for its extras).
+*/
+function readRelation(schema) {
+	const ns = schema["x-relation"];
+	if (ns && typeof ns === "object") {
+		const obj = ns;
+		if (typeof obj.target !== "string") return void 0;
+		return { multiple: typeof obj.multiple === "boolean" ? obj.multiple : void 0 };
+	}
+	if (typeof schema["x-relation-target"] !== "string") return void 0;
+	const multiple = schema["x-relation-multiple"];
+	return { multiple: typeof multiple === "boolean" ? multiple : void 0 };
+}
+/**
+* Decides which UI widget kind a JSON-Schema node renders as.
+*
+* Precedence:
+*   1. Relations — `$ref`, array-of-`$ref`, or `x-relation`/flat
+*      `x-relation-target`. Single → select, many → multiselect.
+*   2. Explicit `x-ui.control`, plus the `estimate: true` attribute
+*      promoting a formula to an estimate.
+*   3. `format` — JSON-Schema standard widget hints on strings.
+*   4. `type` — JSON-Schema primitive fallback.
+*
+* @param schema The JSON-Schema node.
+*
+* @returns The control kind.
+*/
+function inferControl(schema) {
+	if (typeof schema.$ref === "string") return "select";
+	const items = Array.isArray(schema.items) ? void 0 : schema.items;
+	if (hasType(schema, "array") && typeof items?.$ref === "string") return "multiselect";
+	const relation = readRelation(schema);
+	if (relation) return relation.multiple ?? hasType(schema, "array") ? "multiselect" : "select";
+	const explicit = readExplicitControl(schema);
+	if (explicit) {
+		if (explicit === "formula" && schema.estimate === true) return "estimate";
+		return explicit;
+	}
+	if (hasType(schema, "string")) {
+		switch (schema.format) {
+			case "date": return "date";
+			case "email": return "email";
+			case "phone": return "phone";
+			case "ein": return "ein";
+			case "us-state": return "us-state";
+			case "currency": return "currency";
+			case "percent": return "percent";
+		}
+		return "text";
+	}
+	if (hasType(schema, "number") || hasType(schema, "integer")) return "number";
+	if (hasType(schema, "boolean")) return "boolean";
+	if (hasType(schema, "array")) {
+		if (schema.uniqueItems === true && Array.isArray(items?.oneOf)) return "multiselect";
+		if (items && hasType(items, "object") && typeof items.properties === "object") return "object-array";
+		return "text";
+	}
+	return "text";
+}
+
+//#endregion
+//#region src/core/signal.ts
+/**
+* The currently active listener, if any. Reads while it is set subscribe it.
+*/
+let currentListener;
+/**
+* Runs a function with the given listener active, restoring the previous
+* listener afterwards (throw included). This is the ONLY way to activate a
+* listener — a set-and-forget global (the v1 `setListener`) let one
+* component's tracking window leak into whatever rendered next; the scoped
+* form makes that structurally impossible.
+*
+* @param listener The listener to activate (or `undefined` to suspend
+* tracking, the `untrack` case).
+* @param fn The function whose signal reads subscribe the listener.
+*
+* @returns The return value of the function.
+*/
+function withListener(listener, fn) {
+	const previousListener = currentListener;
+	currentListener = listener;
+	try {
+		return fn();
+	} finally {
+		currentListener = previousListener;
+	}
+}
+/**
+* Returns the currently active listener, if any.
+*
+* Advanced/internal: exposed for tests that verify subscription bookkeeping.
+*/
+function getListener() {
+	return currentListener;
+}
+/**
+* Creates a tracker: the non-React primitive the react adapter's snapshot
+* store is built on. `onInvalidate` fires when any signal read during the
+* last `read` changes (deferred and de-duplicated by an active `batch`).
+*
+* @param onInvalidate Called when a tracked signal changes.
+*
+* @returns The created tracker.
+*/
+function createTracker(onInvalidate) {
+	const listener = {
+		notify: onInvalidate,
+		subscriptions: /* @__PURE__ */ new Set()
+	};
+	return {
+		read: (fn) => withListener(listener, fn),
+		dispose: () => {
+			for (const subscribers of listener.subscriptions) subscribers.delete(listener);
+			listener.subscriptions.clear();
+		}
+	};
+}
+/**
+* Plain-listener notifications collected while a batch is active.
+*/
+let batchQueue;
+/**
+* Current batch nesting depth.
+*/
+let batchDepth = 0;
+/**
+* Subscribes the active listener (if any) to the given subscriber set.
+*/
+function track(subscribers) {
+	if (currentListener) {
+		subscribers.add(currentListener);
+		currentListener.subscriptions.add(subscribers);
+	}
+}
+/**
+* Consumes and notifies a subscriber set (one-shot semantics).
+*
+* Invalidation hooks run first and always synchronously, so computed
+* staleness propagates through the whole graph before any plain listener is
+* notified. Plain notifications are deferred into the batch queue when a
+* batch is active.
+*/
+function notifySubscribers(subscribers) {
+	const snapshot = [...subscribers];
+	for (const subscriber of snapshot) subscriber.subscriptions.delete(subscribers);
+	subscribers.clear();
+	for (const subscriber of snapshot) subscriber.invalidate?.();
+	for (const subscriber of snapshot) if (batchQueue) batchQueue.add(subscriber);
+	else subscriber.notify();
+}
+function createSignal(initialValue) {
+	const subscribers = /* @__PURE__ */ new Set();
+	let value = initialValue;
+	return {
+		get value() {
+			track(subscribers);
+			return value;
+		},
+		set value(nextValue) {
+			if (!Object.is(nextValue, value)) {
+				value = nextValue;
+				notifySubscribers(subscribers);
+			}
+		}
+	};
+}
+/**
+* Creates a lazy, cached, read-only signal derived from other signals.
+*
+* The compute function runs on first read and again after any signal it read
+* during its last run changes (dependencies are re-tracked on every run, so
+* conditional reads narrow or widen the dependency set). Subscribers of the
+* computed are notified when it is invalidated; the fresh value is produced
+* on the next read.
+*
+* @param compute The function deriving the value.
+*
+* @returns The created read-only signal.
+*/
+function computed(compute) {
+	const subscribers = /* @__PURE__ */ new Set();
+	let cache;
+	let stale = true;
+	let computing = false;
+	const self = {
+		notify: () => {},
+		subscriptions: /* @__PURE__ */ new Set(),
+		invalidate() {
+			if (!stale) {
+				stale = true;
+				notifySubscribers(subscribers);
+			}
+		}
+	};
+	return { get value() {
+		if (computing) throw new Error("Cycle detected: a computed signal's compute function reads its own value");
+		track(subscribers);
+		if (stale) {
+			for (const sourceSubscribers of self.subscriptions) sourceSubscribers.delete(self);
+			self.subscriptions.clear();
+			computing = true;
+			try {
+				cache = withListener(self, compute);
+			} finally {
+				computing = false;
+			}
+			stale = false;
+		}
+		return cache;
+	} };
+}
+/**
+* Batches signal writes: plain listener notifications (e.g. component
+* re-renders) are collected, de-duplicated, and delivered once when the
+* outermost batch ends. Computed invalidation is NOT deferred, so reads
+* inside the batch observe the written values.
+*
+* @param fn The function to execute in the batch.
+*
+* @returns The return value of the function.
+*/
+function batch(fn) {
+	batchDepth++;
+	batchQueue ??= /* @__PURE__ */ new Set();
+	try {
+		return fn();
+	} finally {
+		batchDepth--;
+		if (batchDepth === 0) {
+			const queue = batchQueue;
+			batchQueue = void 0;
+			for (const listener of queue) listener.notify();
+		}
+	}
+}
+/**
+* Executes a function without tracking signal reads as subscriptions.
+*
+* @param fn The function to execute untracked.
+*
+* @returns The return value of the function.
+*/
+function untrack(fn) {
+	return withListener(void 0, fn);
+}
+
+//#endregion
+//#region src/core/framework.ts
+/**
+* Counter backing `createId`.
+*/
+let idCounter = 0;
+/**
+* Creates a unique ID (stable array item identity for keying and
+* reorder-aware state transfer).
+*
+* @returns The unique ID.
+*/
+function createId() {
+	return `${idCounter++}`;
+}
+
+//#endregion
+//#region src/core/plugin/driver.ts
+/**
+* The members a plugin object may carry. Anything else is a typo'd hook
+* name and throws at `createFormStore` instead of silently never running.
+*/
+const KNOWN_MEMBERS = new Set([
+	"name",
+	"key",
+	"dependsOn",
+	"wire",
+	"build",
+	"buildScope",
+	"reseedScope",
+	"resetField",
+	"syncInput",
+	"syncInitial",
+	"rebase",
+	"transferField",
+	"swapField",
+	"fieldIsDirty",
+	"encodeValue",
+	"isDirty",
+	"fieldSnapshot"
+]);
+/**
+* The hooks the driver precomputes implementer lists for (the per-field
+* ones run in loops; scanning all plugins per field would be quadratic).
+*/
+const HOOK_NAMES = [
+	"buildScope",
+	"reseedScope",
+	"resetField",
+	"syncInput",
+	"syncInitial",
+	"rebase",
+	"transferField",
+	"swapField",
+	"fieldIsDirty",
+	"encodeValue",
+	"isDirty",
+	"fieldSnapshot"
+];
+/**
+* Wraps a hook dispatch for error attribution: a throwing plugin surfaces
+* as `Error running "build" for jsonisch plugin "derivation": …` instead of
+* an anonymous stack out of `createFormStore`.
+*/
+function attributed(plugin, hook, run) {
+	try {
+		return run();
+	} catch (error) {
+		throw new Error(`Error running "${hook}" for jsonisch plugin "${plugin.name}": ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+}
+/**
+* Flattens and validates the `plugins` config into the driver: falsy
+* entries and one level of nesting are accepted; names and keys must be
+* unique; `dependsOn` keys must belong to EARLIER plugins (a missing or
+* later dependency is a startup error naming both plugins); every member
+* must be a known hook with the right shape.
+*/
+function resolvePlugins(input) {
+	const plugins = [];
+	for (const entry of (input ?? []).flat()) {
+		if (!entry) continue;
+		plugins.push(entry);
+	}
+	const names = /* @__PURE__ */ new Set();
+	const keys = /* @__PURE__ */ new Map();
+	for (const plugin of plugins) {
+		if (typeof plugin !== "object" || typeof plugin.name !== "string" || !plugin.name) throw new Error("A jsonisch plugin must be an object with a name");
+		if (names.has(plugin.name)) throw new Error(`Duplicate jsonisch plugin name "${plugin.name}"`);
+		names.add(plugin.name);
+		if (!plugin.key || typeof plugin.key !== "object") throw new Error(`Jsonisch plugin "${plugin.name}" has no key`);
+		if (keys.has(plugin.key)) throw new Error(`Jsonisch plugins "${keys.get(plugin.key)}" and "${plugin.name}" share the same key`);
+		if (typeof plugin.build !== "function") throw new Error(`Jsonisch plugin "${plugin.name}" has no build hook`);
+		for (const member of Object.keys(plugin)) if (!KNOWN_MEMBERS.has(member)) throw new Error(`Unknown member "${member}" on jsonisch plugin "${plugin.name}" — a typo'd hook never runs, so it throws instead`);
+		for (const dependency of plugin.dependsOn ?? []) if (keys.get(dependency) === void 0) throw new Error(`Jsonisch plugin "${plugin.name}" requires plugin "${dependency.name}" earlier in the plugins array`);
+		keys.set(plugin.key, plugin.name);
+	}
+	const hooks = {};
+	for (const hook of HOOK_NAMES) hooks[hook] = plugins.filter((plugin) => typeof plugin[hook] === "function");
+	const envelopes = /* @__PURE__ */ new Map();
+	for (const plugin of plugins) for (const control of plugin.wire?.envelopeControls ?? []) {
+		if (envelopes.has(control)) throw new Error(`Two jsonisch plugins declare an envelope for the "${control}" control`);
+		envelopes.set(control, plugin.wire);
+	}
+	return {
+		plugins,
+		hooks,
+		envelopes
+	};
+}
+/**
+* The `PluginCtx` for one plugin on one form (state read fresh off the
+* store, so hooks always see the current container).
+*/
+function ctxOf(form, plugin) {
+	return {
+		form,
+		state: form.pluginState.get(plugin.key)
+	};
+}
+/**
+* Runs every plugin's `build` in array order, storing each state container
+* under its key. Runs BEFORE the walk (see `JsonischPlugin.build`).
+*/
+function dispatchBuild(form, config) {
+	for (const plugin of form.pluginDriver.plugins) form.pluginState.set(plugin.key, attributed(plugin, "build", () => plugin.build(form, config)));
+}
+/**
+* Wires one object scope (the root after the walk, or an array-item object
+* as the walk creates it), in plugin array order.
+*/
+function dispatchBuildScope(form, scope, raw) {
+	for (const plugin of form.pluginDriver?.hooks.buildScope ?? []) attributed(plugin, "buildScope", () => plugin.buildScope(ctxOf(form, plugin), scope, raw));
+}
+/**
+* Re-seeds an existing row scope that adopts a different row.
+*/
+function dispatchReseedScope(form, scope, raw) {
+	for (const plugin of form.pluginDriver?.hooks.reseedScope ?? []) attributed(plugin, "reseedScope", () => plugin.reseedScope(ctxOf(form, plugin), scope, raw));
+}
+/**
+* Rebases one object scope's plugin state on fresh raw data — the root
+* from `applyBaseline`, rows from the baseline-rebase walk. Runs AFTER the
+* scope's value rebase.
+*/
+function dispatchRebase(form, scope, raw) {
+	for (const plugin of form.pluginDriver?.hooks.rebase ?? []) attributed(plugin, "rebase", () => plugin.rebase(ctxOf(form, plugin), scope, raw));
+}
+/**
+* Restores one value leaf's plugin state to its decode-time baseline, from
+* inside reset's walk.
+*/
+function dispatchResetField(form, store) {
+	for (const plugin of form.pluginDriver?.hooks.resetField ?? []) attributed(plugin, "resetField", () => plugin.resetField(ctxOf(form, plugin), store));
+}
+/**
+* Asks plugins to take a live leaf write (`setFieldInput`). Returns
+* `true` when a plugin wrote `store.input` so core must not write it
+* again — otherwise the envelope.value and the number would fork.
+*/
+function dispatchSyncInput(form, store, input) {
+	let handled = false;
+	for (const plugin of form.pluginDriver?.hooks.syncInput ?? []) if (attributed(plugin, "syncInput", () => plugin.syncInput(ctxOf(form, plugin), store, input))) handled = true;
+	return handled;
+}
+/**
+* Re-decodes each plugin's start baseline from the same raw
+* `reset({ initialInput })` just wrote into `initialInput`.
+*/
+function dispatchSyncInitial(form, store, raw) {
+	for (const plugin of form.pluginDriver?.hooks.syncInitial ?? []) attributed(plugin, "syncInitial", () => plugin.syncInitial(ctxOf(form, plugin), store, raw));
+}
+/**
+* Transfers per-field plugin state between two value stores (item-state
+* copy during array inserts/removes/moves).
+*/
+function dispatchTransferField(form, from, to) {
+	for (const plugin of form.pluginDriver?.hooks.transferField ?? []) attributed(plugin, "transferField", () => plugin.transferField(ctxOf(form, plugin), from, to));
+}
+/**
+* Swaps per-field plugin state between two value stores.
+*/
+function dispatchSwapField(form, first, second) {
+	for (const plugin of form.pluginDriver?.hooks.swapField ?? []) attributed(plugin, "swapField", () => plugin.swapField(ctxOf(form, plugin), first, second));
+}
+/**
+* Whether any plugin's form-level state is dirty. Runs inside the
+* `isDirty` aggregate computed, so it reads EVERY implementer — never
+* short-circuits: an unran handler contributes no signal reads and would
+* deafen the projection.
+*/
+function pluginsDirty(form) {
+	let dirty = false;
+	for (const plugin of form.pluginDriver?.hooks.isDirty ?? []) if (attributed(plugin, "isDirty", () => plugin.isDirty(ctxOf(form, plugin)))) dirty = true;
+	return dirty;
+}
+/**
+* Whether THIS value leaf's plugin state is dirty (must serialize). Reads
+* every implementer for the same no-short-circuit reason as `pluginsDirty`
+* — callers may sit inside computeds.
+*/
+function fieldPluginDirty(form, store) {
+	let dirty = false;
+	for (const plugin of form.pluginDriver?.hooks.fieldIsDirty ?? []) if (attributed(plugin, "fieldIsDirty", () => plugin.fieldIsDirty(ctxOf(form, plugin), store))) dirty = true;
+	return dirty;
+}
+/**
+* Whether any value leaf in the subtree has dirty plugin state — the
+* plugin half of the dirty walks that decide payload emission (a mode flip
+* with an unchanged value must still produce a payload). Reads array
+* `items` (not raw `children`, which may hold stale stores past the end
+* after a shrink), so a reactive caller subscribes to structural changes.
+*/
+function hasPluginDirtyField(form, store) {
+	if (store.kind === "value") return fieldPluginDirty(form, store);
+	if (store.kind === "array") {
+		const length = store.items.value.length;
+		let dirty$1 = false;
+		for (let index = 0; index < length; index++) {
+			const child = store.children[index];
+			if (child && hasPluginDirtyField(form, child)) dirty$1 = true;
+		}
+		return dirty$1;
+	}
+	let dirty = false;
+	for (const key in store.children) if (hasPluginDirtyField(form, store.children[key])) dirty = true;
+	return dirty;
+}
+/**
+* Encodes one dirty value leaf's payload entry: asks the `encodeValue`
+* implementers to wrap it (the LOS-573 envelope). Exactly one plugin may
+* claim a field; with no claim the outgoing value is emitted as-is.
+*
+* @param form The form store.
+* @param store The value leaf being encoded.
+* @param valueOut The outgoing value (`undefined` when only plugin state
+* is dirty).
+*
+* @returns The wire entry to emit.
+*/
+function encodeFieldValue(form, store, valueOut) {
+	let claimed;
+	let result = valueOut;
+	for (const plugin of form.pluginDriver?.hooks.encodeValue ?? []) {
+		const wrapped = attributed(plugin, "encodeValue", () => plugin.encodeValue(ctxOf(form, plugin), store, valueOut));
+		if (wrapped === void 0) continue;
+		if (claimed !== void 0) throw new Error(`Jsonisch plugins "${claimed}" and "${plugin.name}" both encode the "${store.name}" field`);
+		claimed = plugin.name;
+		result = wrapped;
+	}
+	return result;
+}
+/**
+* Merges every plugin's `fieldSnapshot` contribution for one field into a
+* single flat object — the fastify-decorate collision rule: a key already
+* claimed (by another plugin, or by a core field member via `reserved`)
+* throws instead of silently shadowing. Runs inside the react adapter's
+* tracked read, so contributions' signal reads subscribe the component.
+*
+* @param form The form store.
+* @param store The field store being snapshotted.
+* @param path The field's path (for callback contributions).
+* @param reserved The core snapshot member names no plugin may claim.
+*
+* @returns The merged plugin members, flat.
+*/
+function dispatchFieldSnapshot(form, store, path, reserved) {
+	const slots = {};
+	const claimedBy = /* @__PURE__ */ new Map();
+	for (const plugin of form.pluginDriver?.hooks.fieldSnapshot ?? []) {
+		const contribution = attributed(plugin, "fieldSnapshot", () => plugin.fieldSnapshot(ctxOf(form, plugin), store, path));
+		for (const key of Object.keys(contribution)) {
+			if (reserved.has(key)) throw new Error(`Jsonisch plugin "${plugin.name}" contributes the fieldSnapshot key "${key}", which is a core field member`);
+			const owner = claimedBy.get(key);
+			if (owner !== void 0) throw new Error(`Jsonisch plugins "${owner}" and "${plugin.name}" both contribute the fieldSnapshot key "${key}"`);
+			claimedBy.set(key, plugin.name);
+			slots[key] = contribution[key];
+		}
+	}
+	return slots;
+}
+/**
+* Unwraps a raw persisted leaf entry through the form's envelope wire
+* contracts: an envelope-control leaf resolves its value half, everything
+* else passes through. The single decode seam shared by the walk, reset,
+* and the baseline rebase — a leaf can never round-trip to two different
+* values.
+*/
+function unwrapLeafInput(form, control, raw) {
+	const wire = form.pluginDriver?.envelopes.get(control);
+	if (!wire?.unwrap || raw === void 0) return raw;
+	return wire.unwrap(raw).value;
+}
+
+//#endregion
+//#region src/core/schema-utils.ts
+/**
+* Keys that must never become field names or object keys in any store or
+* output — assigning them on a plain object mutates its prototype chain
+* instead of creating an own property (OWASP CWE-915). Applies to schema
+* property names AND record keys, so neither a malicious schema nor a
+* malicious record can pollute.
+*/
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* Returns whether a key is safe to use as an object property name.
+*/
+function isSafeKey(key) {
+	return !UNSAFE_KEYS.has(key);
+}
+/**
+* Reads an own property of a record, or `undefined`. A declared key like
+* `"toString"` must resolve to a record value or nothing, never to an
+* inherited prototype member.
+*/
+function readOwn(source, key) {
+	return source != null && typeof source === "object" && Object.prototype.hasOwnProperty.call(source, key) ? source[key] : void 0;
+}
+/**
+* Returns the node's JSON-Schema types as a list (`type` may be a union
+* like `["string", "null"]`).
+*/
+function typeList(schema) {
+	if (schema.type === void 0) return [];
+	return Array.isArray(schema.type) ? schema.type : [schema.type];
+}
+/**
+* Returns the node's primary (non-`"null"`) JSON-Schema type, if any.
+*/
+function primaryType(schema) {
+	return typeList(schema).find((type) => type !== "null");
+}
+/**
+* Resolves the presence sentinel a container (array/object) input maps to:
+* the nullish value itself when the field accepts it, `true` otherwise.
+* The single rule shared by the walk, reset, and setInput so a container
+* value can never round-trip to two different states.
+*/
+function containerPresence(nullish, input) {
+	return nullish && input == null ? input : true;
+}
+/**
+* Resolves a value-leaf input, falling back to the configured empty input
+* for the field's type when no input is provided (e.g. `""` for a required
+* string, so an untouched empty field matches the DOM). Nullish fields keep
+* `undefined`/`null` as they accept it. The single rule shared by the walk
+* and reset so a reset field can never disagree with a freshly mounted one.
+*/
+function resolveValueInput(emptyInput, schema, nullish, input) {
+	const primary = primaryType(schema);
+	return input === void 0 && !nullish && primary !== void 0 ? emptyInput[primary] : input;
+}
+
+//#endregion
+//#region src/core/field/initialize-field-store.ts
+/**
+* Initializes a field store recursively based on the JSON-Schema structure:
+* `properties` → object store, single-schema `items` → array store,
+* everything else → value store. The schema is the allow-list — only
+* declared property keys create nodes, so undeclared `initialInput` keys
+* never enter form state.
+*
+* @param internalFormStore The form store providing the empty input config.
+* @param internalFieldStore The partial field store to initialize.
+* @param schema The JSON-Schema node defining the field structure.
+* @param initialInput The initial input value.
+* @param path The path to the field in the form.
+* @param optional Whether the parent declares this field optional (not in
+* its `required` list).
+*/
+function initializeFieldStore(internalFormStore, internalFieldStore, schema, initialInput, path, optional = false) {
+	const types = typeList(schema);
+	const nullish = optional || types.includes("null");
+	const primary = primaryType(schema);
+	internalFieldStore.schema = schema;
+	internalFieldStore.name = String(path[path.length - 1] ?? "");
+	internalFieldStore.path = path;
+	internalFieldStore.control = inferControl(schema);
+	internalFieldStore.isNullish = nullish;
+	const initialElements = [];
+	internalFieldStore.initialElements = initialElements;
+	internalFieldStore.elements = initialElements;
+	const validationErrors = createSignal(null);
+	internalFieldStore.validationErrors = validationErrors;
+	internalFieldStore.errors = validationErrors;
+	internalFieldStore.isTouched = createSignal(false);
+	internalFieldStore.isEdited = createSignal(false);
+	internalFieldStore.isDirty = createSignal(false);
+	if (schema.properties && typeof schema.properties === "object") {
+		const objectStore = internalFieldStore;
+		objectStore.kind = "object";
+		objectStore.children ??= Object.create(null);
+		const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+		for (const key of Object.keys(schema.properties)) {
+			if (!isSafeKey(key)) continue;
+			objectStore.children[key] ??= {};
+			initializeFieldStore(internalFormStore, objectStore.children[key], schema.properties[key], readOwn(initialInput, key), [...path, key], !required.has(key));
+		}
+		const objectInput = containerPresence(nullish, initialInput);
+		objectStore.initialInput = createSignal(objectInput);
+		objectStore.startInput = createSignal(objectInput);
+		objectStore.input = createSignal(objectInput);
+		if (typeof path[path.length - 1] === "number") dispatchBuildScope(internalFormStore, objectStore, initialInput);
+		return;
+	}
+	if ((primary === "array" || primary === void 0) && schema.items !== void 0 && !isOpaqueObject(schema.items)) {
+		if (Array.isArray(schema.items)) throw new Error(`Tuple "items" schemas are not supported (at ${JSON.stringify(path)})`);
+		const arrayStore = internalFieldStore;
+		arrayStore.kind = "array";
+		arrayStore.itemSchema = schema.items;
+		arrayStore.children ??= [];
+		if (Array.isArray(initialInput)) for (let index = 0; index < initialInput.length; index++) {
+			arrayStore.children[index] = {};
+			initializeFieldStore(internalFormStore, arrayStore.children[index], schema.items, initialInput[index], [...path, index]);
+		}
+		const arrayInput = containerPresence(nullish, initialInput);
+		arrayStore.initialInput = createSignal(arrayInput);
+		arrayStore.startInput = createSignal(arrayInput);
+		arrayStore.input = createSignal(arrayInput);
+		const initialItems = Array.isArray(initialInput) ? initialInput.map(() => createId()) : [];
+		arrayStore.initialItems = createSignal(initialItems);
+		arrayStore.startItems = createSignal(initialItems);
+		arrayStore.items = createSignal(initialItems);
+		return;
+	}
+	if (primary !== void 0 || types.includes("null") || typeof schema.$ref === "string" || schema.enum !== void 0 || schema.oneOf !== void 0 || schema.const !== void 0) {
+		const valueStore = internalFieldStore;
+		valueStore.kind = "value";
+		const valueInput = resolveValueInput(internalFormStore.emptyInput, schema, nullish, unwrapLeafInput(internalFormStore, internalFieldStore.control, initialInput));
+		valueStore.initialInput = createSignal(valueInput);
+		valueStore.startInput = createSignal(valueInput);
+		valueStore.input = createSignal(valueInput);
+		return;
+	}
+	throw new Error(`Unsupported schema without "type", "properties", "items", "$ref", "enum", "oneOf" or "const" (at ${JSON.stringify(path)})`);
+}
+/**
+* Returns whether a single item schema is an opaque object shape: object-
+* typed with no declared `properties` — no allow-list to walk into, so the
+* parent array stays a value leaf holding the whole array.
+*/
+function isOpaqueObject(items) {
+	if (Array.isArray(items)) return false;
+	if (!typeList(items).includes("object")) return false;
+	if (items.properties === void 0 || typeof items.properties !== "object") return true;
+	return Object.keys(items.properties).length === 0;
+}
+
+//#endregion
+//#region src/core/form/create-form-store.ts
+/**
+* The default empty input of a form. Required string fields start as an
+* empty string, while every other type starts as `undefined`.
+*/
+const DEFAULT_EMPTY_INPUT = { string: "" };
+/**
+* The default root-record alias (`FormConfig.rootRecordAlias`). The
+* store's resolved value is the one home at runtime; this default
+* exists so store-less readers (`computeBag`) resolve identically.
+*/
+const DEFAULT_ROOT_RECORD_ALIAS = "record";
+/**
+* Creates a new internal form store from the provided configuration: walks
+* the JSON-Schema once and builds the field-store tree (`kind:
+* array|object|value`), with the schema as the allow-list — `initialInput`
+* keys not declared in the schema never enter form state.
+*
+* Plugins are resolved and their state containers created BEFORE the walk,
+* so the walk can dispatch `buildScope` for every array-item object it
+* creates (a row wired by the walk behaves exactly like one built later by
+* an insert). The ROOT scope is dispatched after the walk, in plugin array
+* order — for the standard trio that means envelopes (the estimate pin's
+* mode signal) before derivation before visibility.
+*
+* @param config The form configuration.
+*
+* @returns The internal form store.
+*/
+function createFormStore(config) {
+	if (!config.schema.properties || typeof config.schema.properties !== "object") throw new Error("The form schema must be an \"object\" schema with \"properties\"");
+	const store = {};
+	store.emptyInput = {
+		...DEFAULT_EMPTY_INPUT,
+		...config.emptyInput
+	};
+	store.rootRecordAlias = config.rootRecordAlias ?? DEFAULT_ROOT_RECORD_ALIAS;
+	store.validator = config.validator;
+	store.validate = config.validate ?? "submit";
+	store.revalidate = config.revalidate ?? "input";
+	store.validators = 0;
+	store.pluginDriver = resolvePlugins(config.plugins);
+	store.pluginState = /* @__PURE__ */ new Map();
+	store.isSubmitting = createSignal(false);
+	store.isSubmitted = createSignal(false);
+	store.isValidating = createSignal(false);
+	store.offFormValues = createSignal(config.offFormValues ?? {});
+	const form = store;
+	dispatchBuild(form, config);
+	initializeFieldStore(form, store, config.schema, config.initialInput, []);
+	dispatchBuildScope(form, form, config.initialInput);
+	store.aggregates = {
+		isTouched: computed(() => getFieldBool(form, "isTouched")),
+		isEdited: computed(() => getFieldBool(form, "isEdited")),
+		isDirty: computed(() => {
+			const fieldsDirty = getFieldBool(form, "isDirty");
+			const pluginDirty = pluginsDirty(form);
+			return fieldsDirty || pluginDirty;
+		}),
+		isValid: computed(() => !getFieldBool(form, "validationErrors"))
+	};
+	return form;
+}
+
+//#endregion
+//#region src/core/dirty.ts
+/**
+* Returns whether a value is semantically empty: `undefined`, `null`, the
+* empty string, or `NaN` (what a cleared number input parses to). These are
+* all "no value entered" and must never make a field dirty against each
+* other — the core semantic-dirty promise.
+*/
+function isEmptyish(value) {
+	return value === void 0 || value === null || value === "" || typeof value === "number" && Number.isNaN(value);
+}
+/**
+* Returns whether a value is a plain object (prototype `Object.prototype`
+* or `null`, e.g. from `JSON.parse`). Class instances, Dates, Maps etc. are
+* NOT plain — comparing them by enumerable keys would call any two Dates
+* equal.
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || proto === Object.prototype;
+}
+/**
+* Deep structural equality for leaf values. Value leaves can hold arrays and
+* plain objects (e.g. multiselect relation arrays, `items`-less array
+* fields), which are recreated on every edit, so identity comparison is not
+* enough. Dates compare by time; other non-plain objects only by identity.
+*/
+function isDeepEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, index) => isDeepEqual(item, b[index]));
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		return aKeys.length === bKeys.length && aKeys.every((key) => Object.prototype.hasOwnProperty.call(b, key) && isDeepEqual(a[key], b[key]));
+	}
+	return false;
+}
+/**
+* Semantic, empty-aware equality between two leaf inputs: equal when both
+* are semantically empty (`null` ≡ `undefined` ≡ `""` ≡ `NaN`) or deeply
+* structurally equal.
+*/
+function isSemanticEqual(a, b) {
+	if (isEmptyish(a) && isEmptyish(b)) return true;
+	return isDeepEqual(a, b);
+}
+/**
+* Semantic equality between two container presence sentinels: `true` only
+* equals `true`; `null` and `undefined` (absent container) are equivalent.
+*/
+function isPresenceEqual(a, b) {
+	return Object.is(a, b) || a == null && b == null;
+}
+
+//#endregion
+//#region src/core/field/get-field-store.ts
+/**
+* Returns the chain of field stores along the specified path, from the form
+* root (inclusive) to the target field (inclusive). Throws on a path
+* segment that does not resolve to a declared field — the schema is the
+* allow-list, so navigating to an undeclared key is a caller bug, never a
+* silent no-op. Array segments are bounded by the CURRENT item count:
+* stale child stores kept past the end of a shrunk array (for baseline
+* reuse on regrow) are not addressable.
+*
+* @param internalFormStore The form store to traverse.
+* @param path The path to the field store.
+*
+* @returns The store chain, `[root, …, target]`.
+*/
+function getFieldStoreChain(internalFormStore, path) {
+	let internalFieldStore = internalFormStore;
+	const chain = [internalFieldStore];
+	for (const key of path) {
+		let child;
+		if (internalFieldStore.kind === "object" && typeof key === "string") child = Object.prototype.hasOwnProperty.call(internalFieldStore.children, key) ? internalFieldStore.children[key] : void 0;
+		else if (internalFieldStore.kind === "array" && typeof key === "number" && Number.isInteger(key) && key >= 0 && key < internalFieldStore.items.value.length) child = internalFieldStore.children[key];
+		if (!child) throw new Error(`No field at path ${JSON.stringify(path)} — segment ${JSON.stringify(key)} is not declared in the schema`);
+		internalFieldStore = child;
+		chain.push(child);
+	}
+	return chain;
+}
+/**
+* Returns the field store at the specified path. See `getFieldStoreChain`
+* for the resolution and throw semantics.
+*
+* @param internalFormStore The form store to traverse.
+* @param path The path to the field store.
+*
+* @returns The field store.
+*/
+function getFieldStore(internalFormStore, path) {
+	const chain = getFieldStoreChain(internalFormStore, path);
+	return chain[chain.length - 1];
+}
+
+//#endregion
+//#region src/core/field/focus-field-element.ts
+/**
+* Focuses the first focusable element of a field store. The elements are
+* tried in order and the first one that actually receives focus wins, so
+* detached, disabled or hidden elements are skipped. The browser decides
+* focusability, which is read back via the element's root `activeElement`
+* so elements in a shadow root or another document are handled correctly.
+*
+* Hint: a `display: none` or `hidden` element is correctly skipped in real
+* browsers, but jsdom has no layout and focuses it anyway, so that case
+* cannot be covered by unit tests.
+*
+* @param internalFieldStore The field store to focus.
+*
+* @returns Whether an element was focused.
+*/
+function focusFieldElement(internalFieldStore) {
+	for (const element of internalFieldStore.elements) {
+		element.focus();
+		if (element.getRootNode().activeElement === element) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/core/field/get-field-input.ts
+/**
+* Returns the current input of the field store. For arrays and objects,
+* recursively collects input from all children (the tree is the allow-list:
+* only declared fields can ever appear in the result). Returns `null` or
+* `undefined` for nullish container inputs, or the leaf value for value
+* fields.
+*
+* @param internalFieldStore The field store to get input from.
+*
+* @returns The field input.
+*/
+function getFieldInput(internalFieldStore) {
+	if (internalFieldStore.kind === "array") {
+		if (internalFieldStore.input.value) {
+			const value = [];
+			for (let index = 0; index < internalFieldStore.items.value.length; index++) value[index] = getFieldInput(internalFieldStore.children[index]);
+			return value;
+		}
+		return internalFieldStore.input.value;
+	}
+	if (internalFieldStore.kind === "object") {
+		if (internalFieldStore.input.value) {
+			const value = {};
+			for (const key in internalFieldStore.children) value[key] = getFieldInput(internalFieldStore.children[key]);
+			return value;
+		}
+		return internalFieldStore.input.value;
+	}
+	return internalFieldStore.input.value;
+}
+
+//#endregion
+//#region src/core/form/validate-form-input.ts
+/**
+* The message used for an issue the validator produced without one.
+*/
+const FALLBACK_MESSAGE = "Invalid value";
+/**
+* Decodes one JSON-Pointer segment (`~1` → `/`, `~0` → `~`).
+*/
+function decodePointerSegment(segment) {
+	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+/**
+* Resolves the field store an issue routes to: walk the pointer segments
+* from the root as far as the tree can follow them and return the deepest
+* reached store. An unroutable remainder (undeclared key, index past the
+* current item count, a pointer into a value leaf's interior) lands the
+* issue on the nearest addressable ancestor — errors must surface even for
+* fields that are not currently rendered or declared exactly as pointed.
+*/
+function resolveIssueTarget(internalFormStore, issue) {
+	const pointer = issue.instancePath ?? "";
+	const segments = pointer === "" ? [] : pointer.slice(1).split("/");
+	if (issue.keyword === "required" && typeof issue.params?.missingProperty === "string") segments.push(issue.params.missingProperty);
+	let store = internalFormStore;
+	for (const rawSegment of segments) {
+		const segment = decodePointerSegment(rawSegment);
+		let child;
+		if (store.kind === "object") child = Object.prototype.hasOwnProperty.call(store.children, segment) ? store.children[segment] : void 0;
+		else if (store.kind === "array" && /^\d+$/.test(segment)) {
+			const index = Number(segment);
+			if (index < store.items.value.length) child = store.children[index];
+		}
+		if (!child) break;
+		store = child;
+	}
+	return store;
+}
+/**
+* Validates the form input using the injected validator. Runs the validator
+* against the current tree input, routes each issue's `instancePath` to its
+* field store's `errors` signal (accumulating multiple issues per field,
+* clearing every other field), and optionally focuses the first field with
+* an error. A form without a validator always validates successfully.
+*
+* @param internalFormStore The form store to validate.
+* @param config The validation configuration.
+*
+* @returns The validation result.
+*/
+function validateFormInput(internalFormStore, config) {
+	internalFormStore.validators++;
+	internalFormStore.isValidating.value = true;
+	try {
+		const output = untrack(() => getFieldInput(internalFormStore));
+		const issues = internalFormStore.validator?.(output);
+		let fieldErrors;
+		if (issues && issues.length > 0) {
+			fieldErrors = /* @__PURE__ */ new Map();
+			untrack(() => {
+				for (const issue of issues) {
+					const target = resolveIssueTarget(internalFormStore, issue);
+					const message = issue.message || FALLBACK_MESSAGE;
+					const existing = fieldErrors.get(target);
+					if (existing) existing.push(message);
+					else fieldErrors.set(target, [message]);
+				}
+			});
+		}
+		let shouldFocus = config?.shouldFocus ?? false;
+		batch(() => {
+			untrack(() => {
+				walkFieldStore(internalFormStore, (internalFieldStore) => {
+					const errors = fieldErrors?.get(internalFieldStore) ?? null;
+					internalFieldStore.validationErrors.value = errors;
+					if (shouldFocus && errors && internalFieldStore.path.length > 0 && focusFieldElement(internalFieldStore)) shouldFocus = false;
+				});
+			});
+			internalFormStore.validators--;
+			internalFormStore.isValidating.value = internalFormStore.validators > 0;
+		});
+		return {
+			success: !fieldErrors,
+			output
+		};
+	} catch (error) {
+		batch(() => {
+			internalFormStore.validators--;
+			internalFormStore.isValidating.value = internalFormStore.validators > 0;
+		});
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/methods/form-ref.ts
+/**
+* Unwraps a `FormRef` to the internal form store.
+*/
+function internalOf(form) {
+	return "internal" in form ? form.internal : form;
+}
+
+//#endregion
+export { unwrapLeafInput as A, getFieldBool as B, dispatchSyncInitial as C, fieldPluginDirty as D, encodeFieldValue as E, createTracker as F, getListener as I, untrack as L, batch as M, computed as N, hasPluginDirtyField as O, createSignal as P, withListener as R, dispatchSwapField as S, dispatchTransferField as T, walkFieldStore as V, resolveValueInput as _, getFieldStore as a, dispatchReseedScope as b, isPresenceEqual as c, DEFAULT_ROOT_RECORD_ALIAS as d, createFormStore as f, readOwn as g, isSafeKey as h, focusFieldElement as i, createId as j, pluginsDirty as k, isSemanticEqual as l, containerPresence as m, validateFormInput as n, getFieldStoreChain as o, initializeFieldStore as p, getFieldInput as r, isEmptyish as s, internalOf as t, DEFAULT_EMPTY_INPUT as u, dispatchFieldSnapshot as v, dispatchSyncInput as w, dispatchResetField as x, dispatchRebase as y, inferControl as z };