better-call 0.0.0-experimental.01ff4b77

package/dist/fn.mjs

@@ -0,0 +1,350 @@
+import { ControlFlow, FnError, UnexpectedError, ValidationError } from "./error.mjs";
+import { asType, isVar, outputContract, vTypes, validate } from "./schema.mjs";
+import { collectMergeSeeds, collectUsable, isFn, isNamespace, isOn, isVarExtension, matchesTarget, on, resolveModules } from "./module.mjs";
+import { contextScope, getCell, readVar, readVarThrough, viewMergeVar, writeVar } from "./var.mjs";
+//#region src/fn.ts
+const isThenable = (value) => typeof value?.then === "function";
+const STORE = Symbol("var-store");
+const ACTIVE = Symbol("active-plugins");
+const EXTS = Symbol("active-var-extensions");
+const READONLY = Symbol("readonly-lock");
+const WITH = Symbol("with-overrides");
+const defineFn = (key, options, declared) => {
+	const modules = resolveModules(options.use ?? []);
+	const own = [];
+	const ownExts = [];
+	const scanMembers = (mod) => {
+		for (const value of Object.values(mod)) if (isOn(value) && !own.includes(value)) own.push(value);
+		else if (isVarExtension(value)) ownExts.push(value);
+		else if (isNamespace(value)) scanMembers(value);
+	};
+	for (const mod of modules) scanMembers(mod);
+	const usable = collectUsable(modules);
+	const mergeSeeds = collectMergeSeeds(modules);
+	const tupleInput = Array.isArray(options.input) ? options.input : void 0;
+	const declaredErrors = options.errors;
+	const outputValidation = outputContract(options.output).validation;
+	const errorTypes = declaredErrors ? Object.fromEntries(Object.entries(declaredErrors).map(([tag, schema]) => [tag, asType(schema)])) : void 0;
+	const inputVars = [];
+	const declaredInput = options.input;
+	const wholeVar = declaredInput && isVar(declaredInput) ? declaredInput.name : void 0;
+	if (declaredInput && !wholeVar) {
+		for (const [field, def] of Object.entries(declaredInput)) if (isVar(def)) inputVars.push([field, def.name]);
+	}
+	if (options.readonly) {
+		if (options.provides?.length) throw new ValidationError(`${key}.readonly`, "a readonly fn cannot declare provides - it promises writes");
+		if (wholeVar !== void 0 || inputVars.length > 0) throw new ValidationError(`${key}.readonly`, "a readonly fn cannot bind input to vars - that is a write");
+	}
+	const callable = (...callArgs) => {
+		const input = tupleInput ? callArgs.slice(0, tupleInput.length) : callArgs[0];
+		const parent = tupleInput ? callArgs[tupleInput.length] : callArgs[1];
+		const cells = parent?.[STORE] ?? {};
+		if (!parent?.[STORE]) for (const [name, value] of Object.entries(mergeSeeds)) {
+			const cell = getCell(cells, name);
+			cell.value = value;
+			cell.accumulate = true;
+		}
+		const lockedBy = options.readonly ? key : parent?.[READONLY];
+		const inherited = parent?.[ACTIVE] ?? [];
+		const active = own.length === 0 ? inherited : [...inherited, ...own.filter((e) => !inherited.includes(e))];
+		const chain = active.filter((entry) => matchesTarget(entry.target, key));
+		const withFns = parent?.[WITH];
+		const inheritedExts = parent?.[EXTS] ?? [];
+		const exts = ownExts.length === 0 ? inheritedExts : [...inheritedExts, ...ownExts.filter((e) => !inheritedExts.includes(e))];
+		let ctx;
+		const frame = {
+			cells,
+			key,
+			lockedBy,
+			entries: active
+		};
+		const extendValue = (name, raw, value) => {
+			let merged = value;
+			for (const ext of exts) {
+				if (ext.name !== name) continue;
+				const extra = validate(asType(ext.schema), raw, `${key}.${name}`);
+				merged = {
+					...merged,
+					...extra
+				};
+			}
+			return merged;
+		};
+		let parsed;
+		if (tupleInput) {
+			const issues = [];
+			parsed = tupleInput.map((def, index) => {
+				try {
+					return validate(asType(def), input[index], `${key}[${index}]`);
+				} catch (thrown) {
+					if (!(thrown instanceof ValidationError)) throw thrown;
+					issues.push(...thrown.issues);
+					return;
+				}
+			});
+			const firstIssue = issues[0];
+			if (firstIssue) throw new ValidationError(firstIssue.path, firstIssue.message, issues);
+		} else parsed = options.input === void 0 ? input : validate(asType(options.input), input, key);
+		for (const entry of chain) {
+			if (!entry.extend?.input || tupleInput) continue;
+			const extra = validate(asType(entry.extend.input), input, `${key}.on`);
+			parsed = {
+				...parsed ?? {},
+				...extra
+			};
+		}
+		if (wholeVar !== void 0 && parsed !== void 0) {
+			parsed = extendValue(wholeVar, input, parsed);
+			writeVar(frame, wholeVar, parsed);
+		}
+		for (const [field, name] of inputVars) {
+			const raw = input?.[field];
+			const value = parsed?.[field];
+			if (value === void 0) continue;
+			const merged = extendValue(name, raw, value);
+			parsed[field] = merged;
+			writeVar(frame, name, merged);
+		}
+		const base = {
+			input: parsed,
+			error: (tag, data) => {
+				const schema = errorTypes?.[tag];
+				if (!schema) throw new ValidationError(`${key}.errors.${tag}`, errorTypes ? `"${tag}" is not a declared error of "${key}"` : `"${key}" declares no errors`);
+				return new FnError(tag, validate(schema, data ?? {}, `${key}.errors.${tag}`), key);
+			},
+			[STORE]: cells,
+			[ACTIVE]: active,
+			[EXTS]: exts,
+			[READONLY]: lockedBy,
+			[WITH]: withFns,
+			fn: builderFn(key === "anonymous" ? "" : key, { use: options.use ?? [] }),
+			types: vTypes
+		};
+		ctx = contextScope(frame, base);
+		const bindUsable = (target, map, overrides) => {
+			for (const [name, used] of Object.entries(map)) {
+				const override = overrides?.[name];
+				if (isVar(used)) {
+					const varName = used.name;
+					Object.defineProperty(target, name, {
+						get: () => viewMergeVar(varName, readVarThrough(frame, varName), ctx),
+						set: (value) => writeVar(frame, varName, value),
+						enumerable: true,
+						configurable: true
+					});
+					continue;
+				}
+				if (typeof used === "object" && used !== null && "$models" in used && typeof used.$adapter === "function") {
+					target[name] = override !== void 0 ? override : used;
+					continue;
+				}
+				if (!isFn(used)) {
+					const group = {};
+					bindUsable(group, used, isFn(override) ? void 0 : override);
+					target[name] = group;
+					continue;
+				}
+				if (override !== void 0) {
+					target[name] = isFn(override) ? (i) => override(i, ctx) : override;
+					continue;
+				}
+				const usedArity = used.$arity;
+				target[name] = usedArity === void 0 ? (i) => used(i, ctx) : (...args) => {
+					const padded = args.slice(0, usedArity);
+					while (padded.length < usedArity) padded.push(void 0);
+					return used(...padded, ctx);
+				};
+			}
+		};
+		bindUsable(base, usable, withFns);
+		const missing = (name) => {
+			const value = readVar(cells, name);
+			return value === void 0 || value === null;
+		};
+		const checkRequires = () => {
+			for (const name of options.requires ?? []) if (missing(name)) throw new ValidationError(`${key}.requires.${name}`, `required var "${name}" is not set${parent === void 0 ? " - called without a parent context" : ""}`);
+		};
+		let bodyRan = false;
+		const declaredTracked = (c) => {
+			bodyRan = true;
+			return declared(c);
+		};
+		const body = chain.reduceRight((next, entry) => (c) => entry.handler(c, () => next(c)), declaredTracked);
+		const finish = (result) => {
+			if (outputValidation !== void 0) validate(asType(outputValidation), result, `${key}.output`);
+			if (bodyRan) {
+				for (const name of options.provides ?? []) if (missing(name)) throw new ValidationError(`${key}.provides.${name}`, `declared to provide "${name}" but it was left unset`);
+			}
+			return result;
+		};
+		const decorate = (thrown) => {
+			if (thrown instanceof ControlFlow) return thrown;
+			if (thrown instanceof FnError || thrown instanceof UnexpectedError) {
+				if (thrown.trail[thrown.trail.length - 1] !== key) thrown.trail.push(key);
+				return thrown;
+			}
+			return errorTypes ? new UnexpectedError(thrown, key) : thrown;
+		};
+		const run = () => {
+			checkRequires();
+			let result;
+			try {
+				result = body(ctx);
+			} catch (thrown) {
+				throw decorate(thrown);
+			}
+			return isThenable(result) ? result.then(finish, (thrown) => {
+				throw decorate(thrown);
+			}) : finish(result);
+		};
+		return run();
+	};
+	/** `.try`: declared errors as a value, everything else still throws. */
+	const tryCall = (...callArgs) => {
+		const settle = (thrown) => {
+			if (thrown instanceof FnError) return {
+				ok: false,
+				error: thrown
+			};
+			throw thrown;
+		};
+		try {
+			const result = callable(...callArgs);
+			return isThenable(result) ? result.then((value) => ({
+				ok: true,
+				value
+			}), settle) : {
+				ok: true,
+				value: result
+			};
+		} catch (thrown) {
+			return settle(thrown);
+		}
+	};
+	/**
+	* `.with`: a hand-built context. Keys naming one of this fn's `use`
+	* fns become OVERRIDES (carried by the subtree via `WITH`); everything
+	* else SEEDS a var in a fresh store. A parent given to the bound call
+	* is forked - its cells are copied, so seeds and writes inside never
+	* leak back into it.
+	*/
+	const withCall = (context) => {
+		const makeParent = (given) => {
+			const source = given?.[STORE] ?? {};
+			const cells = Object.fromEntries(Object.entries(source).map(([name, cell]) => [name, { ...cell }]));
+			const seedFrame = {
+				cells,
+				key: `${key}.with`,
+				lockedBy: void 0,
+				entries: []
+			};
+			const overrides = { ...given?.[WITH] };
+			const applyWith = (map, entries, target) => {
+				for (const [name, value] of Object.entries(entries)) {
+					const member = map?.[name];
+					if (member === void 0) writeVar(seedFrame, name, value);
+					else if (isVar(member)) writeVar(seedFrame, member.name, value);
+					else if (isFn(member) || typeof value !== "object" || !value) target[name] = value;
+					else {
+						const existing = target[name];
+						const sub = existing && typeof existing === "object" ? existing : {};
+						target[name] = sub;
+						applyWith(member, value, sub);
+					}
+				}
+			};
+			applyWith(usable, context, overrides);
+			return {
+				[STORE]: cells,
+				[ACTIVE]: given?.[ACTIVE],
+				[EXTS]: given?.[EXTS],
+				[READONLY]: given?.[READONLY],
+				[WITH]: Object.keys(overrides).length > 0 ? overrides : void 0
+			};
+		};
+		const rewrite = (callArgs) => {
+			if (tupleInput) {
+				const padded = callArgs.slice(0, tupleInput.length);
+				while (padded.length < tupleInput.length) padded.push(void 0);
+				return [...padded, makeParent(callArgs[tupleInput.length])];
+			}
+			return [callArgs[0], makeParent(callArgs[1])];
+		};
+		const bound = (...callArgs) => callable(...rewrite(callArgs));
+		bound.try = (...callArgs) => tryCall(...rewrite(callArgs));
+		return bound;
+	};
+	return Object.assign(callable, {
+		$fn: true,
+		key,
+		provides: options.provides ?? [],
+		try: tryCall,
+		with: withCall,
+		...tupleInput ? { $arity: tupleInput.length } : {},
+		$schema: {
+			...options.input !== void 0 ? { input: options.input } : {},
+			...options.output !== void 0 ? { output: options.output } : {},
+			...declaredErrors ? { errors: declaredErrors } : {},
+			...options.requires?.length ? { requires: options.requires } : {},
+			...options.idempotent === true ? { idempotent: true } : {}
+		}
+	});
+};
+/**
+* The builder half of `v.fn`: no handler yet, so calls accumulate. Keys
+* CONCATENATE ("auth" then ".create" -> "auth.create"), `use`/`requires`/
+* `provides` merge, other options child-wins - and the returned `.fn`
+* follows the same one rule recursively: a handler terminates, anything
+* else keeps building.
+*/
+const mergeOptions = (base, child) => ({
+	...base,
+	...child,
+	use: [...base.use ?? [], ...child.use ?? []],
+	requires: [...base.requires ?? [], ...child.requires ?? []],
+	provides: [...base.provides ?? [], ...child.provides ?? []],
+	...base.errors || child.errors ? { errors: {
+		...base.errors ?? {},
+		...child.errors ?? {}
+	} } : {}
+});
+const builderFn = (baseKey, base) => {
+	const build = (...args) => {
+		const hasKey = typeof args[0] === "string";
+		const childKey = hasKey ? args[0] : "";
+		const rest = hasKey ? args.slice(1) : args;
+		const first = rest[0];
+		const handler = typeof first === "function" ? first : rest[1];
+		const childOptions = typeof first === "function" ? {} : first ?? {};
+		const key = baseKey + childKey;
+		const options = mergeOptions(base, childOptions);
+		if (typeof handler !== "function") return {
+			fn: builderFn(key, options),
+			$fnSchema: {
+				input: options.input,
+				output: options.output
+			},
+			on: (target, a, b) => on(typeof target === "string" && !target.startsWith("var.") && !target.startsWith("scope.") ? key + target : target, a, b)
+		};
+		return defineFn(key || "anonymous", options, handler);
+	};
+	return Object.assign(build, {
+		$fnSchema: {
+			input: base.input,
+			output: base.output
+		},
+		type: (signature = {}) => ({
+			$fnSchema: {
+				input: signature.input,
+				output: signature.output
+			},
+			...signature.optional ? { optional: true } : {},
+			...signature.default !== void 0 ? { default: signature.default } : {}
+		})
+	});
+};
+const fnImpl = builderFn("", {});
+//#endregion
+export { fnImpl };
+
+//# sourceMappingURL=fn.mjs.map

package/dist/fn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.mjs","names":["onImpl"],"sources":["../src/fn.ts"],"sourcesContent":["import {\n\tControlFlow,\n\tFnError,\n\ttype Issue,\n\tUnexpectedError,\n\tValidationError,\n} from \"./error\";\nimport {\n\ttype ApplyOns,\n\tcollectMergeSeeds,\n\tcollectUsable,\n\ttype InputVarExtra,\n\ttype InputVarExtraOut,\n\tisFn,\n\tisNamespace,\n\tisOn,\n\tisVarExtension,\n\ttype Module,\n\ttype ModuleFns,\n\tmatchesTarget,\n\ttype OnEntry,\n\ton as onImpl,\n\tresolveModules,\n\ttype TargetMatches,\n\ttype VarExtension,\n\ttype VarGetContext,\n\ttype VarSetContext,\n\ttype WithDerived,\n} from \"./module\";\nimport {\n\tasType,\n\ttype InferArgs,\n\ttype InferInput,\n\tisVar,\n\ttype OutputSchemaOf,\n\toutputContract,\n\ttype TypeDefination,\n\tvalidate,\n\tvTypes,\n} from \"./schema\";\nimport type { ResolvedVars, ScopeOf, VarName, VarScope } from \"./scope\";\nimport type { LiteralString, Prettify } from \"./types\";\nimport {\n\ttype Cells,\n\tcontextScope,\n\ttype Frame,\n\tgetCell,\n\treadVar,\n\treadVarThrough,\n\ttype VarDefination,\n\tviewMergeVar,\n\twriteVar,\n} from \"./var\";\n\nexport type ParentContext = Record<string, any>;\n\n/**\n * `{}` assignable to `A`, and `A` is not an open index signature\n * (`Record<string, …>` / `v.object()` with no shape). Those accept any\n * object, so omitting the arg is not the same as sending one.\n */\ntype EmptyExtendsArgs<A> =\n\tRecord<never, never> extends A\n\t\t? string extends keyof A\n\t\t\t? false\n\t\t\t: true\n\t\t: false;\n\n/**\n * Callers may omit a non-tuple input when the schema is optional or\n * defaulted, or every field is already optional to send.\n */\ntype InputOmittable<A, I> = I extends { $var: true; schema?: infer S }\n\t? InputOmittable<A, NonNullable<S>>\n\t: I extends TypeDefination<any, any, infer D>\n\t\t? [D] extends [never]\n\t\t\t? EmptyExtendsArgs<A>\n\t\t\t: true\n\t\t: EmptyExtendsArgs<A>;\n\n/** The call shape: a TUPLE input spreads - one parameter per position,\n * the parent context last. No input, or an omittable one, takes\n * `(input?, parent?)`; required inputs stay required. */\ntype CallArgs<A, I> = I extends readonly unknown[]\n\t? A extends readonly unknown[]\n\t\t? [...A] | [...A, ParentContext]\n\t\t: never\n\t: [A] extends [void]\n\t\t? [input?: undefined, parent?: ParentContext]\n\t\t: InputOmittable<A, I> extends true\n\t\t\t? [input?: A, parent?: ParentContext]\n\t\t\t: [input: A, parent?: ParentContext];\n\n/** The union of a fn's DECLARED errors, as thrown values. */\nexport type FnErrorsOf<Er> = {\n\t[T in keyof Er & string]: FnError<T, InferInput<Er[T]>>;\n}[keyof Er & string];\n\n/** The declared-error union of a fn - for typing catch sites. */\nexport type FnErrors<F> =\n\tF extends FnDefination<any, any, any, any, any, infer Er>\n\t\t? FnErrorsOf<Er>\n\t\t: never;\n\n/** Non-distributive `never` guard first: a naked `R extends Promise`\n * distributes over `never` into `never`, and `[never] extends [Promise<_>]`\n * is also true (bottom type). Always-throwing bodies need a sync result. */\ntype TryResult<R, Er> = [R] extends [never]\n\t? { ok: true; value: never } | { ok: false; error: FnErrorsOf<Er> }\n\t: R extends Promise<infer V>\n\t\t? Promise<{ ok: true; value: V } | { ok: false; error: FnErrorsOf<Er> }>\n\t\t: { ok: true; value: R } | { ok: false; error: FnErrorsOf<Er> };\n\n/** No declared errors - the default error channel. */\ntype NoErrors = Record<never, never>;\n\n/** The `use` half of `.with`: fn overrides by name, recursing into\n * GROUPS so a nested binding can be overridden too. A var alias takes a\n * SEED for the var it points at. */\ntype WithFns<U> = {\n\t[K in keyof U]?: U[K] extends FnDefination<any, any, any, any, any, any>\n\t\t? BoundFn<U[K]>\n\t\t: U[K] extends VarDefination<any, infer T, any, any>\n\t\t\t? T\n\t\t\t: WithFns<U[K]>;\n};\n\n/** The context `.with` accepts: any var of the fn's WHOLE chain scope\n * (the builder's `use` included, not just the fn's own), plus any `use`\n * fn as an override - and nothing else. Kept as PLAIN mapped types: with\n * `RV`/`U` unknown both halves collapse to `{}`, which keeps every\n * `extends FnDefination<any, ...>` structural check passing.\n *\n * Prefer {@link WithSeed} for values stored on {@link FnDefination} - it\n * is what `v.fn` returns, and stays declaration-emit safe. */\nexport type WithContext<RV, U> = { [K in keyof RV]?: RV[K] } & WithFns<U>;\n\n/** Storage (or the FnEntries slice of one): `$models` plus callable\n * `$adapter`. Nested under a module as `{ db }`, it must not flow into\n * `.with` seeds - model schemas alone blow past declaration serialize\n * limits. ModuleFns keeps collections; WithSeed still drops storage. */\ntype StorageLike = {\n\t$models: object;\n\t$adapter: (...args: never[]) => unknown;\n};\n\n/** Flatten `use` members to `.with` overrides: bound call signatures, var\n * alias values, nested groups. Storage is dropped (mount-only). */\ntype WithFnsSeed<U> = {\n\t[K in keyof U as U[K] extends StorageLike\n\t\t? never\n\t\t: K]?: U[K] extends FnDefination<any, any, any, any, any, any>\n\t\t? BoundFn<U[K]>\n\t\t: U[K] extends VarDefination<any, infer T, any, any>\n\t\t\t? T\n\t\t\t: WithFnsSeed<U[K]>;\n};\n\n/**\n * Flat `.with` seed map stored on exported fns. Evaluating ScopeOf /\n * ModuleFns here (instead of embedding those wrappers as type arguments)\n * keeps declaration emit small: `.d.ts` shows leaf var shapes and bound\n * call signatures, not `ScopeOf<ResolvedVars<entire module graph>>`.\n */\nexport type WithSeed<RV, U> = Prettify<\n\t{ [K in keyof RV]?: RV[K] } & WithFnsSeed<U>\n>;\n\n/** What `v.fn` / `e.fn` returns: contract params plus a flat {@link WithSeed}\n * for `.with`, never the raw ScopeOf / ModuleFns graph. */\ntype PublicFn<\n\tA,\n\tR,\n\tK extends string,\n\tI,\n\tP extends readonly string[],\n\tEr,\n\tRV,\n\tU,\n\tO = unknown,\n> = FnDefination<A, R, K, I, P, Er, WithSeed<RV, U>, O>;\n\n/** What `.with` returns: the same callable, context baked in. */\nexport interface BoundCall<A, R, I, Er> {\n\t(...args: CallArgs<A, I>): R;\n\ttry(...args: CallArgs<A, I>): TryResult<R, Er>;\n}\n\nexport interface FnDefination<\n\tA,\n\tR,\n\tK extends string = string,\n\tI = unknown,\n\tP extends readonly string[] = readonly string[],\n\tEr = NoErrors,\n\t/** `.with` seed map ({@link WithSeed}). Defaults keep structural\n\t * `extends FnDefination<any, ...>` checks passing. */\n\tW = unknown,\n\tO = unknown,\n> {\n\t(...args: CallArgs<A, I>): R;\n\t/**\n\t * Call with DECLARED errors caught as a value: `{ ok: true, value }`\n\t * or `{ ok: false, error }`, narrowed by `error.tag`. Only tagged,\n\t * expected errors become results - defects and contract violations\n\t * still throw, exactly as they should.\n\t */\n\ttry(...args: CallArgs<A, I>): TryResult<R, Er>;\n\t/**\n\t * Call with a HAND-BUILT context. Keys naming a var SEED that var in a\n\t * fresh scope; keys naming a `use` fn OVERRIDE that binding for the\n\t * whole subtree below. Both are typed from the fn's chain - what the\n\t * BUILDER mounted counts, so `signOut.with({ user })` type-checks even\n\t * though `signOut` itself never says `use: [user]`. A parent passed to\n\t * the bound call is FORKED: its vars are copied in, never written back.\n\t */\n\twith(context: W): BoundCall<A, R, I, Er>;\n\t/** Brand, so a plugin module can be scanned for its fns. */\n\treadonly $fn: true;\n\t/** The name interceptors target - literal, so `ApplyOn` can match it. */\n\treadonly key: K;\n\t/** The declared contract, retained AS WRITTEN for runtime\n\t * introspection (tool cards, docs renderers): the raw input/output\n\t * schemas, error tag map, and required vars. Optional so structural\n\t * `extends FnDefination` checks keep passing for hand-built fns. */\n\treadonly $schema?: {\n\t\tinput?: unknown;\n\t\toutput?: unknown;\n\t\terrors?: Record<string, unknown>;\n\t\trequires?: readonly string[];\n\t\t/** Declared idempotence - same args, same result, safe to repeat. */\n\t\tidempotent?: boolean;\n\t};\n\t/** Vars this fn promises to set when ITS OWN body runs - the literal\n\t * list, readable by graph tooling at both type and runtime level. */\n\treadonly provides: P;\n\t/** Phantom: the raw declared input, so extensions of the vars it\n\t * references can widen used-fn call sites. Never set at runtime. */\n\treadonly $input?: I;\n\t/** Phantom: the raw declared output, the counterpart of `$input` - the\n\t * schema as written, for type-level introspection. Never set at runtime. */\n\treadonly $output?: O;\n\t/** Phantom: declared error tags -> payload schemas. */\n\treadonly $errors?: Er;\n}\n\nexport type ArgsOf<I> = I extends readonly unknown[]\n\t? { -readonly [K in keyof I]: InferArgs<I[K]> }\n\t: unknown extends I\n\t\t? void\n\t\t: InferArgs<I>;\n\n/**\n * Call args of a declaring fn: the declared input, plus whatever mounted\n * `v.extend` / same-name shadows add for vars that input references.\n * Mirrors {@link ApplyOn} so `input: user` + `use: [userWithEmail]` types\n * the door the same way a used call site would.\n */\nexport type WidenedArgs<I, ExtPL> =\n\tunknown extends InputVarExtra<ExtPL, I>\n\t\t? ArgsOf<I>\n\t\t: Prettify<\n\t\t\t\t([ArgsOf<I>] extends [void] ? unknown : ArgsOf<I>) &\n\t\t\t\t\tInputVarExtra<ExtPL, I>\n\t\t\t>;\n\nexport type OptionType<\n\tI,\n\tO,\n\tP,\n\tQ,\n\tPL,\n\tRO extends boolean = boolean,\n\tEr = any,\n> = {\n\t/**\n\t * The fn's DECLARED failures: tag -> payload schema. The THIRD\n\t * contract door - input validates on entry, output on exit, errors at\n\t * `throw c.error(tag, data)`. Once declared, any UNTAGGED throw\n\t * escaping the body is a defect and comes out as `UnexpectedError` -\n\t * callers can tell a domain refusal from a bug without string\n\t * matching.\n\t */\n\terrors?: Er;\n\t/**\n\t * A readonly fn cannot write vars - not in its handler, not in\n\t * anything it calls, not from interceptors mounted on it. Enforced at\n\t * the type level (vars readonly on `c`, declared writers uncallable)\n\t * and at runtime (the whole subtree's store locks).\n\t */\n\treadonly?: RO;\n\t/**\n\t * Declared idempotence: calling with the same args always produces the\n\t * same result and repeating the call is harmless - a read, a lookup, a\n\t * pure computation. Part of the retained contract (`$schema`), so\n\t * hosts may DEDUPE calls: the script engine serves repeated\n\t * same-args calls to an idempotent fn from one dispatch per session.\n\t * Note this is a different promise than `readonly` (writes no vars) -\n\t * an fn can be readonly and still hit a non-idempotent API.\n\t */\n\tidempotent?: boolean;\n\tinput?: I;\n\t/**\n\t * The fn's return contract. A bare schema is BOTH the signature and\n\t * the exit check; the wrapper `{ def?, validation? }` splits them -\n\t * `{ def }` documents the return (tool cards, handler typing) without\n\t * runtime validation, `validation` is the schema the exit check runs\n\t * (defaults to none in the wrapper form).\n\t */\n\toutput?: O;\n\t/** Vars this fn guarantees to set. Checked on exit. */\n\tprovides?: P;\n\t/** Vars that must already be set. Checked on entry, before the body. */\n\trequires?: Q;\n\t/**\n\t * Module namespaces to pull in. Their vars come into scope, their fns\n\t * land directly on `c` already bound to this context (a plain-record\n\t * member nests as a NAMESPACE: `c.cookies.setCookie`), and their `on`\n\t * entries stay active for everything below.\n\t */\n\tuse?: PL;\n};\n\n/** A used fn, with the parent context already applied. A tuple-input fn\n * keeps its positional signature. Omittable inputs match {@link CallArgs}. */\ntype BoundFn<F> =\n\tF extends FnDefination<infer A, infer R, string, infer I, any, any>\n\t\t? I extends readonly unknown[]\n\t\t\t? A extends readonly unknown[]\n\t\t\t\t? (...args: [...A]) => R\n\t\t\t\t: never\n\t\t\t: [A] extends [void]\n\t\t\t\t? () => R\n\t\t\t\t: InputOmittable<A, I> extends true\n\t\t\t\t\t? (input?: A) => R\n\t\t\t\t\t: (input: A) => R\n\t\t: never;\n\n/** Keys of a usable map whose member is a VAR alias. */\ntype UseVarKeys<U> = {\n\t[K in keyof U]: U[K] extends VarDefination<any, any, any, any> ? K : never;\n}[keyof U];\n\n/**\n * VarDefination surface keys. ModuleFns intersects a merge var with\n * same-key namespace helpers (`VarDef & { createUser }`); stripping these\n * leaves the helper group for {@link UseApi}.\n */\ntype VarSurfaceKeys =\n\t| \"$var\"\n\t| \"name\"\n\t| \"default\"\n\t| \"schema\"\n\t| \"type\"\n\t| \"$source\"\n\t| \"$attrs\"\n\t| \"$merge\"\n\t| \"customize\";\n\ntype MergeHelpersOnVar<V> = Omit<V, VarSurfaceKeys>;\n\n/** Bound helpers intersected onto a merge var in ModuleFns, if any. */\ntype UseApiMergeExtras<V> = V extends { $merge: true }\n\t? [keyof MergeHelpersOnVar<V>] extends [never]\n\t\t? never\n\t\t: UseApi<MergeHelpersOnVar<V>>\n\t: never;\n\n/**\n * A var alias' surface: the var's VALUE, plus same-key namespace helpers\n * when the var is `merge: true` (mirrors {@link collectMergeSeeds} /\n * {@link viewMergeVar}).\n */\ntype UseVarValue<V> =\n\tV extends VarDefination<any, infer T, any, any>\n\t\t? UseApiMergeExtras<V> extends infer H\n\t\t\t? [H] extends [never]\n\t\t\t\t? T\n\t\t\t\t: Prettify<T & H>\n\t\t\t: T\n\t\t: never;\n\n/**\n * Fold merge-var helpers from the usable map `U` onto scope values keyed\n * by DECLARED name (so `c.vt_merge_db.byTag` types when the export key\n * was `db`).\n */\ntype MergeIntoScope<RV, U> = {\n\t[K in keyof RV]: HelpersForDeclaredName<K & string, U> extends infer H\n\t\t? [H] extends [never]\n\t\t\t? RV[K]\n\t\t\t: Prettify<RV[K] & H>\n\t\t: RV[K];\n};\n\ntype HelpersForDeclaredName<N extends string, U> = {\n\t[K in keyof U]: U[K] extends VarDefination<N, any, any, any>\n\t\t? UseApiMergeExtras<U[K]>\n\t\t: never;\n}[keyof U];\n\nexport type UseApi<U> = Prettify<\n\t{\n\t\t[K in Exclude<keyof U, UseVarKeys<U>>]: U[K] extends FnDefination<\n\t\t\tany,\n\t\t\tany,\n\t\t\tany,\n\t\t\tany,\n\t\t\tany,\n\t\t\tany\n\t\t>\n\t\t\t? BoundFn<U[K]>\n\t\t\t: U[K] extends StorageLike\n\t\t\t\t? U[K]\n\t\t\t\t: UseApi<U[K]>;\n\t} & { [K in UseVarKeys<U>]: UseVarValue<U[K]> }\n>;\n\n/** Used fns inside a readonly fn: declared writers become uncallable,\n * with the reason on hover instead of a generic type error; var aliases\n * become readonly properties. */\ntype ReadUseApi<U> = Prettify<\n\t{\n\t\t[K in Exclude<keyof U, UseVarKeys<U>>]: U[K] extends FnDefination<\n\t\t\tany,\n\t\t\tany,\n\t\t\tany,\n\t\t\tany,\n\t\t\tinfer P,\n\t\t\tany\n\t\t>\n\t\t\t? P extends readonly []\n\t\t\t\t? BoundFn<U[K]>\n\t\t\t\t: `writes \"${P[number] & string}\" - not callable from a readonly fn`\n\t\t\t: U[K] extends StorageLike\n\t\t\t\t? U[K]\n\t\t\t\t: ReadUseApi<U[K]>;\n\t} & { readonly [K in UseVarKeys<U>]: UseVarValue<U[K]> }\n>;\n\nexport type Context<\n\tI,\n\tRV,\n\tRequired,\n\tU = unknown,\n\tFnApi = Fn,\n\tRO extends boolean = false,\n\tErrs = NoErrors,\n\t/** Modules that widen var-bound input (this fn's `use` + builder chain). */\n\tExtPL = unknown,\n> = {\n\tinput: unknown extends InputVarExtraOut<ExtPL, I>\n\t\t? InferInput<I>\n\t\t: Prettify<InferInput<I> & InputVarExtraOut<ExtPL, I>>;\n\t/**\n\t * Mint a DECLARED error - tag-checked, payload validated at creation:\n\t * `throw c.error(\"invalid_credentials\", { attempts: 3 })`. Only tags\n\t * from this fn's `errors` exist; the payload validates like input.\n\t */\n\terror: <T extends keyof Errs & string>(\n\t\ttag: T,\n\t\t...data: Record<never, never> extends InferArgs<Errs[T]>\n\t\t\t? [data?: InferArgs<Errs[T]>]\n\t\t\t: [data: InferArgs<Errs[T]>]\n\t) => FnError<T, InferInput<Errs[T]>>;\n\t/** Define fns from inside: this fn's scope and key carry over, so\n\t * anything built here is typed exactly like a chained builder. */\n\tfn: FnApi;\n\t/** The schema constructors (string, number, object, ...). */\n\ttypes: typeof vTypes;\n} & /** Every var in scope, directly on `c`: read `c.session`, write by\n * plain assignment (`c.session = {...}`). Every var is a readonly\n * property on a readonly fn. Merge vars also expose same-key helpers\n * folded from `U` (declared-name access). */ VarScope<\n\tMergeIntoScope<RV, U>,\n\tRequired,\n\tRO\n> &\n\t/** Fns from `use`, directly on `c` and already threaded with this\n\t * context: `c.createUser({...})`. */\n\t(RO extends true ? ReadUseApi<U> : UseApi<U>);\n\nexport type InferReturn<O> = unknown extends O\n\t? unknown\n\t: InferInput<OutputSchemaOf<O>>;\n\nexport interface Fn<\n\tBase = unknown,\n\tBaseFns = unknown,\n\tBasePL extends readonly Module[] = [],\n\tPrefix extends string = \"\",\n> {\n\t/**\n\t * The builder FN is a schema too: `create: v.fn` (never called) declares\n\t * \"any function\" - typed `(...args: any[]) => any`, runtime checks only\n\t * `typeof value === \"function\"`.\n\t */\n\treadonly $fnSchema: { input?: unknown; output?: unknown };\n\t/**\n\t * \"A fn with THIS signature\", as a schema: `create: v.fn.type({ input,\n\t * output })` types the field as that fn and validates what a signature\n\t * CAN be validated for - the value is a function, and a plain closure\n\t * gets the declared input checked at its door on every call.\n\t *\n\t * `optional` / `default` work like on `v.string()` etc., so a prop in\n\t * `v.object({...})` can be a fn type and still omittable.\n\t *\n\t * This exists apart from a handler-less `v.fn({ input, output })` for\n\t * INLINE use: `v.fn`'s handler overloads return a callable, which makes\n\t * TypeScript defer any inline `v.fn(...)` call inside another generic\n\t * call's arguments (higher-order inference) - the enclosing `v.object`/\n\t * `v.var` then loses its shape inference entirely. `v.fn.type` returns a\n\t * plain carrier, so it composes inline anywhere.\n\t */\n\treadonly type: <\n\t\tI = unknown,\n\t\tO = unknown,\n\t\tD = never,\n\t\tOpt extends boolean = false,\n\t>(signature?: {\n\t\tinput?: I;\n\t\toutput?: O;\n\t\tdefault?: D;\n\t\toptional?: Opt;\n\t}) => { readonly $fnSchema: { input?: I; output?: O } } & ([Opt] extends [\n\t\ttrue,\n\t]\n\t\t? { readonly optional: true }\n\t\t: unknown) &\n\t\t([D] extends [never] ? unknown : { readonly default: D });\n\n\t/* ---- a handler TERMINATES: these four produce a callable fn ---- */\n\t<R>(\n\t\tfn: (\n\t\t\tctx: Context<\n\t\t\t\tunknown,\n\t\t\t\tScopeOf<[], Base, BasePL>,\n\t\t\t\tnever,\n\t\t\t\tBaseFns,\n\t\t\t\tFn<Base, BaseFns, BasePL, Prefix>\n\t\t\t>,\n\t\t) => R,\n\t): PublicFn<\n\t\tvoid,\n\t\tR,\n\t\tPrefix extends \"\" ? string : Prefix,\n\t\tunknown,\n\t\treadonly string[],\n\t\tNoErrors,\n\t\tScopeOf<[], Base, BasePL>,\n\t\tBaseFns\n\t>;\n\t<K extends LiteralString, R>(\n\t\tkey: K,\n\t\tfn: (\n\t\t\tctx: Context<\n\t\t\t\tunknown,\n\t\t\t\tScopeOf<[], Base, BasePL>,\n\t\t\t\tnever,\n\t\t\t\tBaseFns,\n\t\t\t\tFn<Base, BaseFns, BasePL, `${Prefix}${K}`>\n\t\t\t>,\n\t\t) => R,\n\t): PublicFn<\n\t\tvoid,\n\t\tR,\n\t\t`${Prefix}${K}`,\n\t\tunknown,\n\t\treadonly string[],\n\t\tNoErrors,\n\t\tScopeOf<[], Base, BasePL>,\n\t\tBaseFns\n\t>;\n\n\t<\n\t\tconst I,\n\t\tO,\n\t\tR extends InferReturn<O> | Promise<InferReturn<O>>,\n\t\tconst PL extends readonly Module[] = [],\n\t\tconst P extends readonly VarName<ScopeOf<PL, Base>>[] = readonly [],\n\t\tconst Q extends readonly VarName<ScopeOf<PL, Base>>[] = readonly [],\n\t\tRO extends boolean = false,\n\t\tEr extends Record<string, unknown> = NoErrors,\n\t>(\n\t\toptions: OptionType<I, O, P, Q, PL, RO, Er>,\n\t\tfn: (\n\t\t\tctx: Context<\n\t\t\t\tI,\n\t\t\t\tScopeOf<PL, Base, readonly [...BasePL, ...PL]>,\n\t\t\t\tWithDerived<PL, BasePL, Q[number]>,\n\t\t\t\tApplyOns<ModuleFns<PL>, PL> & BaseFns,\n\t\t\t\tFn<\n\t\t\t\t\tBase & ResolvedVars<PL>,\n\t\t\t\t\tApplyOns<ModuleFns<PL>, PL> & BaseFns,\n\t\t\t\t\treadonly [...BasePL, ...PL],\n\t\t\t\t\tPrefix\n\t\t\t\t>,\n\t\t\t\tRO,\n\t\t\t\tEr,\n\t\t\t\treadonly [...BasePL, ...PL]\n\t\t\t>,\n\t\t) => R,\n\t): PublicFn<\n\t\tWidenedArgs<I, readonly [...BasePL, ...PL]>,\n\t\tR,\n\t\tPrefix extends \"\" ? string : Prefix,\n\t\tI,\n\t\tP,\n\t\tEr,\n\t\tScopeOf<PL, Base, readonly [...BasePL, ...PL]>,\n\t\tApplyOns<ModuleFns<PL>, PL> & BaseFns,\n\t\tO\n\t>;\n\t<\n\t\tK extends LiteralString,\n\t\tconst I,\n\t\tO,\n\t\tR extends InferReturn<O> | Promise<InferReturn<O>>,\n\t\tconst PL extends readonly Module[] = [],\n\t\tconst P extends readonly VarName<ScopeOf<PL, Base>>[] = readonly [],\n\t\tconst Q extends readonly VarName<ScopeOf<PL, Base>>[] = readonly [],\n\t\tRO extends boolean = false,\n\t\tEr extends Record<string, unknown> = NoErrors,\n\t>(\n\t\tkey: K,\n\t\toptions: OptionType<I, O, P, Q, PL, RO, Er>,\n\t\tfn: (\n\t\t\tctx: Context<\n\t\t\t\tI,\n\t\t\t\tScopeOf<PL, Base, readonly [...BasePL, ...PL]>,\n\t\t\t\tWithDerived<PL, BasePL, Q[number]>,\n\t\t\t\tApplyOns<ModuleFns<PL>, PL> & BaseFns,\n\t\t\t\tFn<\n\t\t\t\t\tBase & ResolvedVars<PL>,\n\t\t\t\t\tApplyOns<ModuleFns<PL>, PL> & BaseFns,\n\t\t\t\t\treadonly [...BasePL, ...PL],\n\t\t\t\t\t`${Prefix}${K}`\n\t\t\t\t>,\n\t\t\t\tRO,\n\t\t\t\tEr,\n\t\t\t\treadonly [...BasePL, ...PL]\n\t\t\t>,\n\t\t) => R,\n\t): PublicFn<\n\t\tWidenedArgs<I, readonly [...BasePL, ...PL]>,\n\t\tR,\n\t\t`${Prefix}${K}`,\n\t\tI,\n\t\tP,\n\t\tEr,\n\t\tScopeOf<PL, Base, readonly [...BasePL, ...PL]>,\n\t\tApplyOns<ModuleFns<PL>, PL> & BaseFns,\n\t\tO\n\t>;\n\n\t/* ---- NO handler: a builder. Keys concatenate, `use` accumulates,\n\t   and its `.fn` follows the same rule recursively. ---- */\n\t<K extends LiteralString>(\n\t\tkey: K,\n\t): Instance<Base, BaseFns, BasePL, `${Prefix}${K}`>;\n\t<\n\t\tI,\n\t\tO,\n\t\tconst PL extends readonly Module[] = [],\n\t\tconst P extends readonly VarName<ScopeOf<PL, Base>>[] = readonly [],\n\t\tconst Q extends readonly VarName<ScopeOf<PL, Base>>[] = readonly [],\n\t>(\n\t\toptions: OptionType<I, O, P, Q, PL>,\n\t): Instance<\n\t\tBase & ResolvedVars<PL>,\n\t\tBaseFns & ApplyOns<ModuleFns<PL>, PL>,\n\t\treadonly [...BasePL, ...PL],\n\t\tPrefix,\n\t\tI,\n\t\tO\n\t>;\n\t<\n\t\tK extends LiteralString,\n\t\tI,\n\t\tO,\n\t\tconst PL extends readonly Module[] = [],\n\t\tconst P extends readonly VarName<ScopeOf<PL, Base>>[] = readonly [],\n\t\tconst Q extends readonly VarName<ScopeOf<PL, Base>>[] = readonly [],\n\t>(\n\t\tkey: K,\n\t\toptions: OptionType<I, O, P, Q, PL>,\n\t): Instance<\n\t\tBase & ResolvedVars<PL>,\n\t\tBaseFns & ApplyOns<ModuleFns<PL>, PL>,\n\t\treadonly [...BasePL, ...PL],\n\t\t`${Prefix}${K}`,\n\t\tI,\n\t\tO\n\t>;\n}\n\nconst isThenable = (value: any): value is Promise<unknown> =>\n\ttypeof value?.then === \"function\";\n\nconst STORE = Symbol(\"var-store\");\nconst ACTIVE = Symbol(\"active-plugins\");\nconst EXTS = Symbol(\"active-var-extensions\");\nconst READONLY = Symbol(\"readonly-lock\");\nconst WITH = Symbol(\"with-overrides\");\n\nconst defineFn = (\n\tkey: string,\n\toptions: OptionType<any, any, any, any, any>,\n\tdeclared: (c: any) => any,\n) => {\n\tconst modules = resolveModules((options.use ?? []) as Module[]);\n\n\t// Interceptors and var extensions this fn brings, from its modules -\n\t// nested GROUPS included. The SAME entry mounted twice (two views of\n\t// one storage, a module and its re-export) applies once - identity\n\t// dedup, like inheritance.\n\tconst own: OnEntry<string>[] = [];\n\tconst ownExts: VarExtension<string, any>[] = [];\n\tconst scanMembers = (mod: Record<string, unknown>) => {\n\t\tfor (const value of Object.values(mod)) {\n\t\t\tif (isOn(value) && !own.includes(value)) own.push(value);\n\t\t\telse if (isVarExtension(value)) ownExts.push(value);\n\t\t\telse if (isNamespace(value)) scanMembers(value);\n\t\t}\n\t};\n\tfor (const mod of modules) scanMembers(mod);\n\n\tconst usable = collectUsable(modules);\n\tconst mergeSeeds = collectMergeSeeds(modules);\n\n\t// A tuple input means POSITIONAL args: the callable takes one arg per\n\t// declared position, then the parent context.\n\tconst tupleInput = Array.isArray(options.input)\n\t\t? (options.input as unknown[])\n\t\t: undefined;\n\n\t// Declared errors: tag -> payload schema, the THIRD contract door\n\t// (input on entry, output on exit, errors at throw). Declaring any\n\t// also flips the defect rule on: untagged throws come out wrapped.\n\tconst declaredErrors = options.errors as Record<string, unknown> | undefined;\n\n\t// Only the VALIDATION half of the output contract is checked on exit -\n\t// a `{ def }`-only output is a documented promise, never a check.\n\tconst outputValidation = outputContract(options.output).validation;\n\tconst errorTypes = declaredErrors\n\t\t? Object.fromEntries(\n\t\t\t\tObject.entries(declaredErrors).map(([tag, schema]) => [\n\t\t\t\t\ttag,\n\t\t\t\t\tasType(schema),\n\t\t\t\t]),\n\t\t\t)\n\t\t: undefined;\n\n\t// Input that references vars: a var FIELD sets that var from the field\n\t// value; a whole-var input (`input: user`) sets it from the whole args.\n\t// For a tuple the \"fields\" are the positions (\"0\", \"1\", ...).\n\tconst inputVars: Array<[field: string, name: string]> = [];\n\tconst declaredInput = options.input as Record<string, any> | undefined;\n\tconst wholeVar: string | undefined =\n\t\tdeclaredInput && isVar(declaredInput)\n\t\t\t? (declaredInput as { name: string }).name\n\t\t\t: undefined;\n\tif (declaredInput && !wholeVar) {\n\t\tfor (const [field, def] of Object.entries(declaredInput)) {\n\t\t\tif (isVar(def)) inputVars.push([field, def.name]);\n\t\t}\n\t}\n\n\t// Contradictions caught at DEFINITION, not first call: a readonly fn\n\t// promising to set vars, or binding input into vars, makes no sense.\n\tif (options.readonly) {\n\t\tif (options.provides?.length) {\n\t\t\tthrow new ValidationError(\n\t\t\t\t`${key}.readonly`,\n\t\t\t\t\"a readonly fn cannot declare provides - it promises writes\",\n\t\t\t);\n\t\t}\n\t\tif (wholeVar !== undefined || inputVars.length > 0) {\n\t\t\tthrow new ValidationError(\n\t\t\t\t`${key}.readonly`,\n\t\t\t\t\"a readonly fn cannot bind input to vars - that is a write\",\n\t\t\t);\n\t\t}\n\t}\n\n\tconst callable = (...callArgs: any[]) => {\n\t\tconst input: unknown = tupleInput\n\t\t\t? callArgs.slice(0, tupleInput.length)\n\t\t\t: callArgs[0];\n\t\tconst parent: any = tupleInput ? callArgs[tupleInput.length] : callArgs[1];\n\t\tconst cells: Cells = parent?.[STORE] ?? {};\n\t\t// Root scope: fold merge-var contributions from `use` into cells\n\t\t// before anything reads them (storage default + helper namespaces).\n\t\tif (!parent?.[STORE]) {\n\t\t\tfor (const [name, value] of Object.entries(mergeSeeds)) {\n\t\t\t\tconst cell = getCell(cells, name);\n\t\t\t\tcell.value = value;\n\t\t\t\tcell.accumulate = true;\n\t\t\t}\n\t\t}\n\t\t// The lock travels the whole subtree: once any frame above is\n\t\t// readonly, every write below throws - handlers, nested fns,\n\t\t// interceptors, input-var seeding, all of it.\n\t\tconst lockedBy: string | undefined = options.readonly\n\t\t\t? key\n\t\t\t: parent?.[READONLY];\n\n\t\t// The active set travels down the call tree, so a fn that declares\n\t\t// plugins keeps them in force for everything it calls with `c`.\n\t\t// Deduped by identity: an instance mounts its modules on every fn,\n\t\t// so a nested call would otherwise stack the same entry twice.\n\t\tconst inherited: OnEntry<string>[] = parent?.[ACTIVE] ?? [];\n\t\tconst active =\n\t\t\town.length === 0\n\t\t\t\t? inherited\n\t\t\t\t: [...inherited, ...own.filter((e) => !inherited.includes(e))];\n\t\tconst chain = active.filter((entry) => matchesTarget(entry.target, key));\n\n\t\t// Fn overrides from `.with`, travelling down like the active set: a\n\t\t// mocked `use` fn stays mocked for the whole subtree.\n\t\tconst withFns: Record<string, unknown> | undefined = parent?.[WITH];\n\n\t\tconst inheritedExts: VarExtension<string, any>[] = parent?.[EXTS] ?? [];\n\t\tconst exts =\n\t\t\townExts.length === 0\n\t\t\t\t? inheritedExts\n\t\t\t\t: [\n\t\t\t\t\t\t...inheritedExts,\n\t\t\t\t\t\t...ownExts.filter((e) => !inheritedExts.includes(e)),\n\t\t\t\t\t];\n\n\t\tlet ctx: any;\n\t\tconst frame: Frame = {\n\t\t\tcells,\n\t\t\tkey,\n\t\t\tlockedBy,\n\t\t\tentries: active,\n\t\t};\n\n\t\t// Widen a var-referencing input with the mounted extensions of that\n\t\t// var: their fields validate off the same raw value and merge in.\n\t\tconst extendValue = (name: string, raw: unknown, value: unknown) => {\n\t\t\tlet merged = value;\n\t\t\tfor (const ext of exts) {\n\t\t\t\tif (ext.name !== name) continue;\n\t\t\t\tconst extra = validate(asType(ext.schema), raw, `${key}.${name}`);\n\t\t\t\tmerged = { ...(merged as Record<string, unknown>), ...extra };\n\t\t\t}\n\t\t\treturn merged;\n\t\t};\n\n\t\t// Tuple positions validate like object fields: every bad position\n\t\t// reports, together, in one error.\n\t\tlet parsed: any;\n\t\tif (tupleInput) {\n\t\t\tconst issues: Issue[] = [];\n\t\t\tparsed = tupleInput.map((def, index) => {\n\t\t\t\ttry {\n\t\t\t\t\treturn validate(\n\t\t\t\t\t\tasType(def),\n\t\t\t\t\t\t(input as unknown[])[index],\n\t\t\t\t\t\t`${key}[${index}]`,\n\t\t\t\t\t);\n\t\t\t\t} catch (thrown) {\n\t\t\t\t\tif (!(thrown instanceof ValidationError)) throw thrown;\n\t\t\t\t\tissues.push(...thrown.issues);\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t});\n\t\t\tconst firstIssue = issues[0];\n\t\t\tif (firstIssue) {\n\t\t\t\tthrow new ValidationError(firstIssue.path, firstIssue.message, issues);\n\t\t\t}\n\t\t} else {\n\t\t\tparsed =\n\t\t\t\toptions.input === undefined\n\t\t\t\t\t? input\n\t\t\t\t\t: validate(asType(options.input), input, key);\n\t\t}\n\n\t\t// Mounted extensions widen the accepted input: each validates its\n\t\t// own fields off the same raw input and merges onto `parsed`.\n\t\t// Extensions extend RECORD inputs - positional args have no field\n\t\t// to merge into, so a tuple fn skips them.\n\t\tfor (const entry of chain) {\n\t\t\tif (!entry.extend?.input || tupleInput) continue;\n\t\t\tconst extra = validate(asType(entry.extend.input), input, `${key}.on`);\n\t\t\tparsed = { ...((parsed as Record<string, unknown>) ?? {}), ...extra };\n\t\t}\n\n\t\t// A whole-var input IS the var: the merged value becomes both the\n\t\t// parsed input and the var for the rest of the call tree.\n\t\tif (wholeVar !== undefined && parsed !== undefined) {\n\t\t\tparsed = extendValue(wholeVar, input, parsed);\n\t\t\twriteVar(frame, wholeVar, parsed);\n\t\t}\n\n\t\t// An absent field leaves the var alone, so its default (or whatever\n\t\t// a parent already set) survives. Only `undefined` counts as absent -\n\t\t// an explicit `null` is a value and does overwrite.\n\t\tfor (const [field, name] of inputVars) {\n\t\t\tconst raw = (input as Record<string, unknown>)?.[field];\n\t\t\tconst value = (parsed as Record<string, unknown>)?.[field];\n\t\t\tif (value === undefined) continue;\n\t\t\tconst merged = extendValue(name, raw, value);\n\t\t\t(parsed as Record<string, unknown>)[field] = merged;\n\t\t\twriteVar(frame, name, merged);\n\t\t}\n\n\t\t// The context's FIXED surface; everything not on it is a var, read\n\t\t// and written straight on `c` through the proxy below.\n\t\tconst base: any = {\n\t\t\tinput: parsed,\n\t\t\t// Mint a declared error: tag must be declared, payload validates\n\t\t\t// at creation - an error is a contract too.\n\t\t\terror: (tag: string, data?: unknown) => {\n\t\t\t\tconst schema = errorTypes?.[tag];\n\t\t\t\tif (!schema) {\n\t\t\t\t\tthrow new ValidationError(\n\t\t\t\t\t\t`${key}.errors.${tag}`,\n\t\t\t\t\t\terrorTypes\n\t\t\t\t\t\t\t? `\"${tag}\" is not a declared error of \"${key}\"`\n\t\t\t\t\t\t\t: `\"${key}\" declares no errors`,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\treturn new FnError(\n\t\t\t\t\ttag,\n\t\t\t\t\tvalidate(schema, data ?? {}, `${key}.errors.${tag}`),\n\t\t\t\t\tkey,\n\t\t\t\t);\n\t\t\t},\n\t\t\t[STORE]: cells,\n\t\t\t[ACTIVE]: active,\n\t\t\t[EXTS]: exts,\n\t\t\t[READONLY]: lockedBy,\n\t\t\t[WITH]: withFns,\n\t\t\tfn: builderFn(key === \"anonymous\" ? \"\" : key, {\n\t\t\t\tuse: options.use ?? [],\n\t\t\t}),\n\t\t\ttypes: vTypes,\n\t\t};\n\t\tctx = contextScope(frame, base);\n\t\t// Used fns land DIRECTLY on the context (`c.createUser(...)`), bound\n\t\t// to `ctx` so they share this store and active set without the caller\n\t\t// having to thread `c` by hand. A GROUP binds recursively and lands\n\t\t// as a namespace (`c.cookie.setCookie(...)`); a VAR member becomes a\n\t\t// live ALIAS under its export name (`c.cookie.options` reads and\n\t\t// writes the var, hooks and readonly lock included). A tuple-input\n\t\t// fn gets its args padded to full arity so the context always lands\n\t\t// in the parent slot, however many args the caller actually passed.\n\t\tconst bindUsable = (\n\t\t\ttarget: any,\n\t\t\tmap: Record<string, unknown>,\n\t\t\toverrides: Record<string, unknown> | undefined,\n\t\t) => {\n\t\t\tfor (const [name, used] of Object.entries(map)) {\n\t\t\t\tconst override = overrides?.[name];\n\t\t\t\tif (isVar(used)) {\n\t\t\t\t\tconst varName = (used as { name: string }).name;\n\t\t\t\t\tObject.defineProperty(target, name, {\n\t\t\t\t\t\tget: () =>\n\t\t\t\t\t\t\tviewMergeVar(varName, readVarThrough(frame, varName), ctx),\n\t\t\t\t\t\tset: (value: unknown) => writeVar(frame, varName, value),\n\t\t\t\t\t\tenumerable: true,\n\t\t\t\t\t\tconfigurable: true,\n\t\t\t\t\t});\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t// Storage mounts whole - do not walk `$models` as a namespace.\n\t\t\t\tif (\n\t\t\t\t\ttypeof used === \"object\" &&\n\t\t\t\t\tused !== null &&\n\t\t\t\t\t\"$models\" in used &&\n\t\t\t\t\ttypeof (used as { $adapter?: unknown }).$adapter === \"function\"\n\t\t\t\t) {\n\t\t\t\t\ttarget[name] = override !== undefined ? override : used;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (!isFn(used)) {\n\t\t\t\t\tconst group: any = {};\n\t\t\t\t\tbindUsable(\n\t\t\t\t\t\tgroup,\n\t\t\t\t\t\tused as Record<string, unknown>,\n\t\t\t\t\t\tisFn(override) ? undefined : (override as any),\n\t\t\t\t\t);\n\t\t\t\t\ttarget[name] = group;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t// A `.with` override REPLACES the binding - a fn override still\n\t\t\t\t// joins this context, a plain function is called as given.\n\t\t\t\tif (override !== undefined) {\n\t\t\t\t\ttarget[name] = isFn(override)\n\t\t\t\t\t\t? (i?: unknown) => (override as any)(i, ctx)\n\t\t\t\t\t\t: override;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst usedArity = (used as { $arity?: number }).$arity;\n\t\t\t\ttarget[name] =\n\t\t\t\t\tusedArity === undefined\n\t\t\t\t\t\t? (i?: unknown) => (used as any)(i, ctx)\n\t\t\t\t\t\t: (...args: unknown[]) => {\n\t\t\t\t\t\t\t\tconst padded = args.slice(0, usedArity);\n\t\t\t\t\t\t\t\twhile (padded.length < usedArity) padded.push(undefined);\n\t\t\t\t\t\t\t\treturn (used as any)(...padded, ctx);\n\t\t\t\t\t\t\t};\n\t\t\t}\n\t\t};\n\t\tbindUsable(base, usable, withFns);\n\n\t\tconst missing = (name: string) => {\n\t\t\tconst value = readVar(cells, name);\n\t\t\treturn value === undefined || value === null;\n\t\t};\n\t\tconst checkRequires = () => {\n\t\t\tfor (const name of options.requires ?? []) {\n\t\t\t\tif (missing(name)) {\n\t\t\t\t\tthrow new ValidationError(\n\t\t\t\t\t\t`${key}.requires.${name}`,\n\t\t\t\t\t\t`required var \"${name}\" is not set${parent === undefined ? \" - called without a parent context\" : \"\"}`,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\t// Interceptors replace the BODY. `provides` is only enforced when\n\t\t// the DECLARED body actually ran: an interceptor that returns\n\t\t// without `next()` visibly takes the contract over - that is a\n\t\t// veto, not a bug - while an author whose own body forgets to set\n\t\t// a promised var still fails loudly.\n\t\tlet bodyRan = false;\n\t\tconst declaredTracked = (c: any) => {\n\t\t\tbodyRan = true;\n\t\t\treturn declared(c);\n\t\t};\n\t\tconst body = chain.reduceRight<(c: any) => any>(\n\t\t\t(next, entry) => (c) => entry.handler(c, () => next(c)),\n\t\t\tdeclaredTracked,\n\t\t);\n\n\t\t// Exit contracts run after the body, whether or not it was async.\n\t\tconst finish = (result: unknown) => {\n\t\t\tif (outputValidation !== undefined) {\n\t\t\t\tvalidate(asType(outputValidation), result, `${key}.output`);\n\t\t\t}\n\t\t\tif (bodyRan) {\n\t\t\t\tfor (const name of options.provides ?? []) {\n\t\t\t\t\tif (missing(name)) {\n\t\t\t\t\t\tthrow new ValidationError(\n\t\t\t\t\t\t\t`${key}.provides.${name}`,\n\t\t\t\t\t\t\t`declared to provide \"${name}\" but it was left unset`,\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn result;\n\t\t};\n\n\t\t// Errors crossing this frame: tagged errors and defects collect the\n\t\t// TRAIL (origin fn first, then every frame outward). Once a fn\n\t\t// declares `errors`, anything untagged escaping its body is a\n\t\t// DEFECT - wrapped with the cause kept - so a domain refusal and a\n\t\t// bug are never the same shape.\n\t\tconst decorate = (thrown: unknown): unknown => {\n\t\t\t// Redirects and other transport control must cross frames that\n\t\t\t// declare `errors` without becoming UnexpectedError.\n\t\t\tif (thrown instanceof ControlFlow) return thrown;\n\t\t\tif (thrown instanceof FnError || thrown instanceof UnexpectedError) {\n\t\t\t\tif (thrown.trail[thrown.trail.length - 1] !== key) {\n\t\t\t\t\tthrown.trail.push(key);\n\t\t\t\t}\n\t\t\t\treturn thrown;\n\t\t\t}\n\t\t\treturn errorTypes ? new UnexpectedError(thrown, key) : thrown;\n\t\t};\n\n\t\tconst run = () => {\n\t\t\tcheckRequires();\n\t\t\tlet result: unknown;\n\t\t\ttry {\n\t\t\t\tresult = body(ctx);\n\t\t\t} catch (thrown) {\n\t\t\t\tthrow decorate(thrown);\n\t\t\t}\n\t\t\t// A sync handler stays sync: only chain when something is thenable.\n\t\t\treturn isThenable(result)\n\t\t\t\t? result.then(finish, (thrown) => {\n\t\t\t\t\t\tthrow decorate(thrown);\n\t\t\t\t\t})\n\t\t\t\t: finish(result);\n\t\t};\n\n\t\treturn run();\n\t};\n\n\t/** `.try`: declared errors as a value, everything else still throws. */\n\tconst tryCall = (...callArgs: any[]) => {\n\t\tconst settle = (thrown: unknown) => {\n\t\t\tif (thrown instanceof FnError) {\n\t\t\t\treturn { ok: false as const, error: thrown };\n\t\t\t}\n\t\t\tthrow thrown;\n\t\t};\n\t\ttry {\n\t\t\tconst result = callable(...callArgs);\n\t\t\treturn isThenable(result)\n\t\t\t\t? result.then((value) => ({ ok: true as const, value }), settle)\n\t\t\t\t: { ok: true as const, value: result };\n\t\t} catch (thrown) {\n\t\t\treturn settle(thrown);\n\t\t}\n\t};\n\n\t/**\n\t * `.with`: a hand-built context. Keys naming one of this fn's `use`\n\t * fns become OVERRIDES (carried by the subtree via `WITH`); everything\n\t * else SEEDS a var in a fresh store. A parent given to the bound call\n\t * is forked - its cells are copied, so seeds and writes inside never\n\t * leak back into it.\n\t */\n\tconst withCall = (context: Record<string, unknown>) => {\n\t\tconst makeParent = (given: any) => {\n\t\t\tconst source: Cells = given?.[STORE] ?? {};\n\t\t\tconst cells: Cells = Object.fromEntries(\n\t\t\t\tObject.entries(source).map(([name, cell]) => [name, { ...cell }]),\n\t\t\t);\n\t\t\tconst seedFrame: Frame = {\n\t\t\t\tcells,\n\t\t\t\tkey: `${key}.with`,\n\t\t\t\tlockedBy: undefined,\n\t\t\t\tentries: [],\n\t\t\t};\n\t\t\tconst overrides: Record<string, unknown> = { ...given?.[WITH] };\n\t\t\t// Walk the given context against the usable tree: a fn member is\n\t\t\t// an OVERRIDE, a var member (top-level or inside a group) SEEDS\n\t\t\t// the var under its DECLARED name, a group recurses, and anything\n\t\t\t// unknown seeds a var by the given key.\n\t\t\tconst applyWith = (\n\t\t\t\tmap: Record<string, unknown> | undefined,\n\t\t\t\tentries: Record<string, unknown>,\n\t\t\t\ttarget: Record<string, unknown>,\n\t\t\t) => {\n\t\t\t\tfor (const [name, value] of Object.entries(entries)) {\n\t\t\t\t\tconst member = map?.[name];\n\t\t\t\t\tif (member === undefined) {\n\t\t\t\t\t\twriteVar(seedFrame, name, value);\n\t\t\t\t\t} else if (isVar(member)) {\n\t\t\t\t\t\twriteVar(seedFrame, (member as { name: string }).name, value);\n\t\t\t\t\t} else if (isFn(member) || typeof value !== \"object\" || !value) {\n\t\t\t\t\t\ttarget[name] = value;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconst existing = target[name];\n\t\t\t\t\t\tconst sub =\n\t\t\t\t\t\t\texisting && typeof existing === \"object\"\n\t\t\t\t\t\t\t\t? (existing as Record<string, unknown>)\n\t\t\t\t\t\t\t\t: {};\n\t\t\t\t\t\ttarget[name] = sub;\n\t\t\t\t\t\tapplyWith(\n\t\t\t\t\t\t\tmember as Record<string, unknown>,\n\t\t\t\t\t\t\tvalue as Record<string, unknown>,\n\t\t\t\t\t\t\tsub,\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\tapplyWith(usable, context, overrides);\n\t\t\treturn {\n\t\t\t\t[STORE]: cells,\n\t\t\t\t[ACTIVE]: given?.[ACTIVE],\n\t\t\t\t[EXTS]: given?.[EXTS],\n\t\t\t\t[READONLY]: given?.[READONLY],\n\t\t\t\t[WITH]: Object.keys(overrides).length > 0 ? overrides : undefined,\n\t\t\t};\n\t\t};\n\t\tconst rewrite = (callArgs: any[]) => {\n\t\t\tif (tupleInput) {\n\t\t\t\tconst padded = callArgs.slice(0, tupleInput.length);\n\t\t\t\twhile (padded.length < tupleInput.length) padded.push(undefined);\n\t\t\t\treturn [...padded, makeParent(callArgs[tupleInput.length])];\n\t\t\t}\n\t\t\treturn [callArgs[0], makeParent(callArgs[1])];\n\t\t};\n\t\tconst bound = (...callArgs: any[]) => callable(...rewrite(callArgs));\n\t\tbound.try = (...callArgs: any[]) => tryCall(...rewrite(callArgs));\n\t\treturn bound;\n\t};\n\n\treturn Object.assign(callable, {\n\t\t$fn: true as const,\n\t\tkey,\n\t\tprovides: (options.provides ?? []) as readonly string[],\n\t\ttry: tryCall,\n\t\twith: withCall,\n\t\t// Positional arg count, so used-fn bindings know where ctx goes.\n\t\t...(tupleInput ? { $arity: tupleInput.length } : {}),\n\t\t// The declared contract, as written - introspectable by hosts that\n\t\t// render the fn to an authorizer or an authoring model.\n\t\t$schema: {\n\t\t\t...(options.input !== undefined ? { input: options.input } : {}),\n\t\t\t...(options.output !== undefined ? { output: options.output } : {}),\n\t\t\t...(declaredErrors ? { errors: declaredErrors } : {}),\n\t\t\t...(options.requires?.length\n\t\t\t\t? { requires: options.requires as readonly string[] }\n\t\t\t\t: {}),\n\t\t\t...(options.idempotent === true ? { idempotent: true } : {}),\n\t\t},\n\t});\n};\n\n/* --------------------------------- create --------------------------------- */\n\n/** Every target worth suggesting on a builder's `on`: the mounted fns'\n * keys (prefix-stripped, so they are valid RELATIVE targets), the scope's\n * var-write events by name, and the two wildcards. Arbitrary strings stay\n * legal - these only feed completion. */\ntype OnTargetSuggest<Base, BaseFns, Prefix extends string> =\n\t| FnTargetSuggest<BaseFns, Prefix>\n\t| `var.set.${keyof ScopeOf<[], Base> & string}`\n\t| \"var.set.*\"\n\t| `var.get.${keyof ScopeOf<[], Base> & string}`\n\t| \"var.get.*\"\n\t| \"*\";\n\ntype FnTargetSuggest<Fns, Prefix extends string> = {\n\t[K in keyof Fns]: Fns[K] extends FnDefination<\n\t\tany,\n\t\tany,\n\t\tinfer FK,\n\t\tany,\n\t\tany,\n\t\tany\n\t>\n\t\t? FK extends `${Prefix}${infer Rest}`\n\t\t\t? Rest\n\t\t\t: never\n\t\t: never;\n}[keyof Fns];\n\ntype VarNameOfT<T extends string> = T extends `var.${\"set\" | \"get\"}.${infer N}`\n\t? N extends `${string}*${string}`\n\t\t? string\n\t\t: N\n\t: string;\n\n/** The scope's value for a var-event target - `unknown` when inexact. */\ntype VarValueOfT<T extends string, Base> =\n\tVarNameOfT<T> extends keyof ScopeOf<[], Base>\n\t\t? ScopeOf<[], Base>[VarNameOfT<T>]\n\t\t: unknown;\n\n/** The fns among `Fns` whose key the (already prefixed) target hits. */\ntype MatchedFn<Fns, T extends string> = {\n\t[K in keyof Fns]: Fns[K] extends FnDefination<\n\t\tany,\n\t\tany,\n\t\tinfer FK,\n\t\tany,\n\t\tany,\n\t\tany\n\t>\n\t\t? TargetMatches<T, FK & string> extends true\n\t\t\t? Fns[K]\n\t\t\t: never\n\t\t: never;\n}[keyof Fns];\n\n/** The intercepted input: the matched fn's (a union under wildcards),\n * or an open record when the target names nothing the builder knows. */\ntype MatchedInput<F> = [F] extends [never]\n\t? Record<string, any>\n\t: F extends FnDefination<any, any, any, infer I, any, any>\n\t\t? InferInput<I>\n\t\t: never;\n\n/** What `next()` resolves to: the matched fn's own result. */\ntype MatchedResult<F> = [F] extends [never]\n\t? any\n\t: F extends FnDefination<any, infer R, any, any, any, any>\n\t\t? Awaited<R>\n\t\t: never;\n\n/** What a builder-scoped `on` handler sees: vars and `use` fns directly\n * on `c` from the builder, `input` from the TARGET fn when known. */\ntype OnContext<Base, BaseFns, F, Ext = unknown> = {\n\tinput: MatchedInput<F> & (unknown extends Ext ? unknown : InferInput<Ext>);\n\ttypes: typeof vTypes;\n\tfn: unknown;\n} & VarScope<ScopeOf<[], Base>, never> &\n\tUseApi<BaseFns>;\n\n/** `v.on`, scoped: string targets get the builder's key prefix; the\n * handler's `c` and `next()` are typed against the matched target fn. */\nexport interface InstanceOn<Base, BaseFns, Prefix extends string> {\n\t/** A fn REFERENCE targets its own key - never prefixed, fully typed\n\t * from the fn itself plus the builder's scope. */\n\t<F extends FnDefination<any, any, string, any, any, any>>(\n\t\ttarget: F,\n\t\thandler: (\n\t\t\tc: OnContext<Base, BaseFns, F>,\n\t\t\tnext: () => Promise<MatchedResult<F>>,\n\t\t) => any,\n\t): OnEntry<F[\"key\"]>;\n\t/** Var-write events: never prefixed (vars are global), and `value`\n\t * is typed from the builder's scope when the target is exact. */\n\t<\n\t\tT extends\n\t\t\t| `var.set.${keyof ScopeOf<[], Base> & string}`\n\t\t\t| \"var.set.*\"\n\t\t\t| `var.set.${string}`,\n\t>(\n\t\ttarget: T,\n\t\thandler: (\n\t\t\tc: VarSetContext<VarNameOfT<T>> & { value: VarValueOfT<T, Base> },\n\t\t\tnext: () => void,\n\t\t) => void,\n\t): OnEntry<T>;\n\t/** Var-read events: `next()` yields the stored value and the handler's\n\t * return becomes the read result - typed from the scope when exact. */\n\t<\n\t\tT extends\n\t\t\t| `var.get.${keyof ScopeOf<[], Base> & string}`\n\t\t\t| \"var.get.*\"\n\t\t\t| `var.get.${string}`,\n\t>(\n\t\ttarget: T,\n\t\thandler: (\n\t\t\tc: VarGetContext<VarNameOfT<T>>,\n\t\t\tnext: () => VarValueOfT<T, Base>,\n\t\t) => VarValueOfT<T, Base>,\n\t): OnEntry<T>;\n\t(\n\t\ttarget: RegExp,\n\t\thandler: (\n\t\t\tc: OnContext<Base, BaseFns, never>,\n\t\t\tnext: () => Promise<any>,\n\t\t) => any,\n\t): OnEntry<string>;\n\t<N extends OnTargetSuggest<Base, BaseFns, Prefix> | LiteralString>(\n\t\ttarget: N,\n\t\thandler: (\n\t\t\tc: OnContext<Base, BaseFns, MatchedFn<BaseFns, `${Prefix}${N}`>>,\n\t\t\tnext: () => Promise<MatchedResult<MatchedFn<BaseFns, `${Prefix}${N}`>>>,\n\t\t) => any,\n\t): OnEntry<`${Prefix}${N}`>;\n\t<const Ext>(\n\t\ttarget: RegExp,\n\t\textend: { input: Ext },\n\t\thandler: (\n\t\t\tc: OnContext<Base, BaseFns, never, Ext>,\n\t\t\tnext: () => Promise<any>,\n\t\t) => any,\n\t): OnEntry<string, Ext>;\n\t<N extends OnTargetSuggest<Base, BaseFns, Prefix> | LiteralString, const Ext>(\n\t\ttarget: N,\n\t\textend: { input: Ext },\n\t\thandler: (\n\t\t\tc: OnContext<Base, BaseFns, MatchedFn<BaseFns, `${Prefix}${N}`>, Ext>,\n\t\t\tnext: () => Promise<MatchedResult<MatchedFn<BaseFns, `${Prefix}${N}`>>>,\n\t\t) => any,\n\t): OnEntry<`${Prefix}${N}`, Ext>;\n}\n\nexport type Instance<\n\tBase,\n\tBaseFns,\n\tPL extends readonly Module[] = [],\n\tPrefix extends string = \"\",\n\tI = unknown,\n\tO = unknown,\n> = {\n\t/** Same as `v.fn`, with this builder's key prefix and options baked in. */\n\tfn: Fn<Base, BaseFns, PL, Prefix>;\n\t/**\n\t * A handler-less builder doubles as an input SCHEMA: used as `input`\n\t * (or an input field) it declares \"a FN from `input` to `output`\" -\n\t * the value crossing is the fn itself. Carries the declared schemas\n\t * for inference here and validation at runtime (see `isFnSchema`).\n\t */\n\treadonly $fnSchema: { input?: I; output?: O };\n\t/** Same as `v.on`, with the prefix on string targets and the handler\n\t * typed against the matched target fn. */\n\ton: InstanceOn<Base, BaseFns, Prefix>;\n\t/**\n\t * The context a handler on this builder receives - a TYPE carrier for\n\t * `typeof f.ctx` (helper signatures, plugin contracts). Every handler\n\t * context on this builder is assignable to it: `input` and `fn` are\n\t * loosened since they vary per fn. A real context only exists per\n\t * invocation, so this is `undefined` at runtime.\n\t */\n\treadonly ctx: Context<\n\t\tunknown,\n\t\tScopeOf<[], Base, PL>,\n\t\tnever,\n\t\tBaseFns,\n\t\tunknown\n\t>;\n};\n\n/**\n * The builder half of `v.fn`: no handler yet, so calls accumulate. Keys\n * CONCATENATE (\"auth\" then \".create\" -> \"auth.create\"), `use`/`requires`/\n * `provides` merge, other options child-wins - and the returned `.fn`\n * follows the same one rule recursively: a handler terminates, anything\n * else keeps building.\n */\nconst mergeOptions = (\n\tbase: Record<string, any>,\n\tchild: Record<string, any>,\n) => ({\n\t...base,\n\t...child,\n\tuse: [...(base.use ?? []), ...(child.use ?? [])],\n\trequires: [...(base.requires ?? []), ...(child.requires ?? [])],\n\tprovides: [...(base.provides ?? []), ...(child.provides ?? [])],\n\t// Error declarations accumulate tag-wise, child wins per tag. Only\n\t// materialized when declared somewhere - an empty `errors` would flip\n\t// the defect-wrapping rule on for every fn.\n\t...(base.errors || child.errors\n\t\t? { errors: { ...(base.errors ?? {}), ...(child.errors ?? {}) } }\n\t\t: {}),\n});\n\nconst builderFn = (baseKey: string, base: Record<string, any>) => {\n\tconst build = (...args: any[]) => {\n\t\tconst hasKey = typeof args[0] === \"string\";\n\t\tconst childKey: string = hasKey ? args[0] : \"\";\n\t\tconst rest = hasKey ? args.slice(1) : args;\n\t\tconst first = rest[0];\n\t\tconst handler = typeof first === \"function\" ? first : rest[1];\n\t\tconst childOptions = typeof first === \"function\" ? {} : (first ?? {});\n\t\tconst key = baseKey + childKey;\n\t\tconst options = mergeOptions(base, childOptions);\n\t\tif (typeof handler !== \"function\") {\n\t\t\treturn {\n\t\t\t\tfn: builderFn(key, options),\n\t\t\t\t// A handler-less builder doubles as an input schema: \"a fn\n\t\t\t\t// from `input` to `output`\" (see `isFnSchema`).\n\t\t\t\t$fnSchema: {\n\t\t\t\t\tinput: (options as OptionType<any, any, any, any, any>).input,\n\t\t\t\t\toutput: (options as OptionType<any, any, any, any, any>).output,\n\t\t\t\t},\n\t\t\t\ton: (target: any, a?: any, b?: any) =>\n\t\t\t\t\t(onImpl as any)(\n\t\t\t\t\t\t// var and scope events live in a global namespace - no prefix.\n\t\t\t\t\t\ttypeof target === \"string\" &&\n\t\t\t\t\t\t\t!target.startsWith(\"var.\") &&\n\t\t\t\t\t\t\t!target.startsWith(\"scope.\")\n\t\t\t\t\t\t\t? key + target\n\t\t\t\t\t\t\t: target,\n\t\t\t\t\t\ta,\n\t\t\t\t\t\tb,\n\t\t\t\t\t),\n\t\t\t};\n\t\t}\n\t\treturn defineFn(key || \"anonymous\", options, handler);\n\t};\n\t// The builder FN doubles as a schema itself: bare `v.fn` (never called)\n\t// declares \"any function\", `v.fn.type({ input, output })` a specific\n\t// signature, and a chained builder's `.fn` carries whatever input/output\n\t// it has accumulated - same contract as the handler-less builder object\n\t// (see `isFnSchema`).\n\treturn Object.assign(build, {\n\t\t$fnSchema: { input: base.input, output: base.output },\n\t\ttype: (\n\t\t\tsignature: {\n\t\t\t\tinput?: unknown;\n\t\t\t\toutput?: unknown;\n\t\t\t\toptional?: boolean;\n\t\t\t\tdefault?: unknown;\n\t\t\t} = {},\n\t\t) => ({\n\t\t\t$fnSchema: { input: signature.input, output: signature.output },\n\t\t\t...(signature.optional ? { optional: true as const } : {}),\n\t\t\t...(signature.default !== undefined\n\t\t\t\t? { default: signature.default }\n\t\t\t\t: {}),\n\t\t}),\n\t});\n};\n\nexport const fnImpl = builderFn(\"\", {});\n"],"mappings":"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"}

package/dist/index.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_error = require("./error.cjs");
+const require_schema = require("./schema.cjs");
+const require_module = require("./module.cjs");
+const require_var = require("./var.cjs");
+const require_fn = require("./fn.cjs");
+const require_storage = require("./storage.cjs");
+//#region src/index.ts
+const v = {
+	fn: require_fn.fnImpl,
+	var: require_var.makeVar,
+	record: ((name, options = {}) => require_var.makeVar(name, {
+		...options,
+		accessor: true
+	})),
+	derive: require_var.deriveVar,
+	storage: require_storage.makeStorage,
+	on: require_module.on,
+	extend: require_module.extendVar,
+	...require_schema.vTypes
+};
+//#endregion
+exports.ControlFlow = require_error.ControlFlow;
+exports.FnError = require_error.FnError;
+exports.UnexpectedError = require_error.UnexpectedError;
+exports.ValidationError = require_error.ValidationError;
+exports.attrsOf = require_schema.attrsOf;
+exports.collectFns = require_module.collectFns;
+exports.collectUsable = require_module.collectUsable;
+exports.conditionsOf = require_storage.conditionsOf;
+exports.fieldsFromSchema = require_storage.fieldsFromSchema;
+exports.isFn = require_module.isFn;
+exports.isNamespace = require_module.isNamespace;
+exports.isOn = require_module.isOn;
+exports.isStorage = require_storage.isStorage;
+exports.isVarExtension = require_module.isVarExtension;
+exports.matchesWhere = require_storage.matchesWhere;
+exports.memoryAdapter = require_storage.memoryAdapter;
+exports.resolveModelFields = require_storage.resolveModelFields;
+exports.v = v;
+exports.withAttrs = require_schema.withAttrs;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["fnImpl","makeVar","deriveVar","makeStorage","extendVar","vTypes"],"sources":["../src/index.ts"],"sourcesContent":["import { type Fn, fnImpl } from \"./fn\";\nimport { extendVar, on } from \"./module\";\n\nimport { type InferInput, vTypes } from \"./schema\";\nimport { makeStorage } from \"./storage\";\nimport type { LiteralString } from \"./types\";\nimport {\n\tderiveVar,\n\tmakeVar,\n\ttype NameOfVar,\n\ttype ValueOfVar,\n\ttype VarDefination,\n} from \"./var\";\n\ninterface V {\n\tfn: Fn;\n\tvar: <\n\t\tN extends LiteralString,\n\t\tS = undefined,\n\t\tD = undefined,\n\t\tconst M extends boolean | undefined = undefined,\n\t>(\n\t\tname: N,\n\t\toptions?: { default?: D; schema?: S; merge?: M },\n\t\t// A default the schema already covers (e.g. `{}` against an\n\t\t// all-optional shape) is absorbed; `default: null` still unions in.\n\t\t// `merge: true` - object contributions from `use` modules (same-name\n\t\t// defaults, same-key namespaces) shallow-merge onto the value;\n\t\t// writes accumulate the same way. Brand `$merge: true` so scope\n\t\t// types can fold those helpers onto the var.\n\t) => VarDefination<\n\t\tN,\n\t\t[S] extends [undefined]\n\t\t\t? D\n\t\t\t: InferInput<S> | ([D] extends [InferInput<S>] ? never : D),\n\t\tS\n\t> &\n\t\t(M extends true ? { $merge: true } : unknown);\n\t/** A var you accumulate into: `set()` merges instead of replacing. */\n\trecord: <N extends LiteralString, S = undefined>(\n\t\tname: N,\n\t\toptions?: { schema?: S },\n\t) => VarDefination<\n\t\tN,\n\t\t[S] extends [undefined] ? Record<string, unknown> : Partial<InferInput<S>>,\n\t\tS\n\t>;\n\t/**\n\t * A var computed from another. Reads run the getter against the current\n\t * source; `requires` on the SOURCE makes derived vars non-null too.\n\t */\n\tderive: <\n\t\tN extends LiteralString,\n\t\tSV extends VarDefination<any, any, any, any>,\n\t\tR,\n\t>(\n\t\tname: N,\n\t\tsource: SV,\n\t\tget: (value: NonNullable<ValueOfVar<SV>>) => R,\n\t) => VarDefination<\n\t\tN,\n\t\tR | Extract<ValueOfVar<SV>, null | undefined>,\n\t\tunknown,\n\t\tNameOfVar<SV>\n\t>;\n\t/**\n\t * MANY instances of a var, queryable: each named var becomes a\n\t * COLLECTION of rows shaped like its value - `db.user.create(row)`,\n\t * `db.user.findOne({ email })`, findMany/update/delete/count. The\n\t * adapter is the translation seam a real database implements;\n\t * `memoryAdapter()` is the built-in dummy.\n\t */\n\tstorage: typeof makeStorage;\n\ton: typeof on;\n\textend: typeof extendVar;\n\tstring: (typeof vTypes)[\"string\"];\n\tnumber: (typeof vTypes)[\"number\"];\n\tboolean: (typeof vTypes)[\"boolean\"];\n\tdate: (typeof vTypes)[\"date\"];\n\tobject: (typeof vTypes)[\"object\"];\n\tarray: (typeof vTypes)[\"array\"];\n\tunion: (typeof vTypes)[\"union\"];\n\tany: (typeof vTypes)[\"any\"];\n}\n\nexport const v: V = {\n\tfn: fnImpl as Fn,\n\tvar: makeVar as V[\"var\"],\n\trecord: ((name: string, options: any = {}) =>\n\t\tmakeVar(name, { ...options, accessor: true })) as V[\"record\"],\n\tderive: deriveVar as V[\"derive\"],\n\tstorage: makeStorage,\n\ton,\n\textend: extendVar,\n\t...vTypes,\n};\n\nexport {\n\tControlFlow,\n\tFnError,\n\ttype Issue,\n\tUnexpectedError,\n\tValidationError,\n} from \"./error\";\nexport type {\n\tContext,\n\tFn,\n\tFnDefination,\n\tFnErrors,\n\tInstance,\n\tOptionType,\n\tParentContext,\n\tUseApi,\n\tWidenedArgs,\n\tWithContext,\n\tWithSeed,\n} from \"./fn\";\nexport {\n\ttype ApplyOn,\n\ttype ApplyOns,\n\tcollectFns,\n\tcollectUsable,\n\ttype ExtendedArgs,\n\ttype InputVarExtra,\n\ttype InputVarExtraOut,\n\ttype Interceptor,\n\tisFn,\n\tisNamespace,\n\tisOn,\n\tisVarExtension,\n\ttype Module,\n\ttype ModuleFns,\n\ttype ModuleVars,\n\ttype OnDefaultContext,\n\ttype OnEntry,\n\ttype VarExtension,\n\ttype VarExtensionsFor,\n\ttype VarGetContext,\n\ttype VarSetContext,\n\ttype VarsFrom,\n} from \"./module\";\nexport {\n\ttype AttrBag,\n\tattrsOf,\n\ttype InferArgs,\n\ttype InferInput,\n\ttype InferOutput,\n\ttype InferType,\n\ttype TypeDefination,\n\twithAttrs,\n} from \"./schema\";\nexport type {\n\tResolvedVars,\n\tRowInScope,\n\tScopeOf,\n\tVarName,\n\tVarScope,\n} from \"./scope\";\nexport {\n\ttype Collection,\n\ttype Condition,\n\tconditionsOf,\n\ttype FieldMeta,\n\ttype FindManyOptions,\n\tfieldsFromSchema,\n\tisStorage,\n\ttype ModelConfig,\n\tmatchesWhere,\n\tmemoryAdapter,\n\tresolveModelFields,\n\ttype Storage,\n\ttype StorageAdapter,\n\ttype StorageApi,\n\ttype StorageHook,\n\ttype StorageHookContext,\n\ttype StorageModels,\n\ttype StorageOp,\n\ttype StorageTarget,\n\ttype Where,\n\ttype WhereOp,\n\ttype WhereOps,\n} from \"./storage\";\nexport type { LiteralString, Prettify } from \"./types\";\nexport type { VarCustomizer, VarDefination, VarMap } from \"./var\";\n"],"mappings":";;;;;;;;AAqFA,MAAa,IAAO;CACnB,IAAIA,WAAAA;CACJ,KAAKC,YAAAA;CACL,UAAU,MAAc,UAAe,CAAC,MACvCA,YAAAA,QAAQ,MAAM;EAAE,GAAG;EAAS,UAAU;CAAK,CAAC;CAC7C,QAAQC,YAAAA;CACR,SAASC,gBAAAA;CACT,IAAA,eAAA;CACA,QAAQC,eAAAA;CACR,GAAGC,eAAAA;AACJ"}

package/dist/index.d.cts

@@ -0,0 +1,50 @@
+import { ControlFlow, FnError, Issue, UnexpectedError, ValidationError } from "./error.cjs";
+import { LiteralString, Prettify } from "./types.cjs";
+import { AttrBag, InferArgs, InferInput, InferOutput, InferType, TypeDefination, attrsOf, vTypes, withAttrs } from "./schema.cjs";
+import { Collection, Condition, FieldMeta, FindManyOptions, ModelConfig, Storage, StorageAdapter, StorageApi, StorageHook, StorageHookContext, StorageModels, StorageOp, StorageTarget, Where, WhereOp, WhereOps, conditionsOf, fieldsFromSchema, isStorage, makeStorage, matchesWhere, memoryAdapter, resolveModelFields } from "./storage.cjs";
+import { ResolvedVars, RowInScope, ScopeOf, VarName, VarScope } from "./scope.cjs";
+import { ApplyOn, ApplyOns, ExtendedArgs, InputVarExtra, InputVarExtraOut, Interceptor, Module, ModuleFns, ModuleVars, OnDefaultContext, OnEntry, VarExtension, VarExtensionsFor, VarGetContext, VarSetContext, VarsFrom, collectFns, collectUsable, extendVar, isFn, isNamespace, isOn, isVarExtension, on } from "./module.cjs";
+import { Context, Fn, FnDefination, FnErrors, Instance, OptionType, ParentContext, UseApi, WidenedArgs, WithContext, WithSeed } from "./fn.cjs";
+import { NameOfVar, ValueOfVar, VarCustomizer, VarDefination, VarMap } from "./var.cjs";
+//#region src/index.d.ts
+interface V {
+  fn: Fn;
+  var: <N extends LiteralString, S = undefined, D = undefined, const M extends boolean | undefined = undefined>(name: N, options?: {
+    default?: D;
+    schema?: S;
+    merge?: M;
+  }) => VarDefination<N, [S] extends [undefined] ? D : InferInput<S> | ([D] extends [InferInput<S>] ? never : D), S> & (M extends true ? {
+    $merge: true;
+  } : unknown);
+  /** A var you accumulate into: `set()` merges instead of replacing. */
+  record: <N extends LiteralString, S = undefined>(name: N, options?: {
+    schema?: S;
+  }) => VarDefination<N, [S] extends [undefined] ? Record<string, unknown> : Partial<InferInput<S>>, S>;
+  /**
+   * A var computed from another. Reads run the getter against the current
+   * source; `requires` on the SOURCE makes derived vars non-null too.
+   */
+  derive: <N extends LiteralString, SV extends VarDefination<any, any, any, any>, R>(name: N, source: SV, get: (value: NonNullable<ValueOfVar<SV>>) => R) => VarDefination<N, R | Extract<ValueOfVar<SV>, null | undefined>, unknown, NameOfVar<SV>>;
+  /**
+   * MANY instances of a var, queryable: each named var becomes a
+   * COLLECTION of rows shaped like its value - `db.user.create(row)`,
+   * `db.user.findOne({ email })`, findMany/update/delete/count. The
+   * adapter is the translation seam a real database implements;
+   * `memoryAdapter()` is the built-in dummy.
+   */
+  storage: typeof makeStorage;
+  on: typeof on;
+  extend: typeof extendVar;
+  string: (typeof vTypes)["string"];
+  number: (typeof vTypes)["number"];
+  boolean: (typeof vTypes)["boolean"];
+  date: (typeof vTypes)["date"];
+  object: (typeof vTypes)["object"];
+  array: (typeof vTypes)["array"];
+  union: (typeof vTypes)["union"];
+  any: (typeof vTypes)["any"];
+}
+declare const v: V;
+//#endregion
+export { type ApplyOn, type ApplyOns, type AttrBag, type Collection, type Condition, type Context, ControlFlow, type ExtendedArgs, type FieldMeta, type FindManyOptions, type Fn, type FnDefination, FnError, type FnErrors, type InferArgs, type InferInput, type InferOutput, type InferType, type InputVarExtra, type InputVarExtraOut, type Instance, type Interceptor, type Issue, type LiteralString, type ModelConfig, type Module, type ModuleFns, type ModuleVars, type OnDefaultContext, type OnEntry, type OptionType, type ParentContext, type Prettify, type ResolvedVars, type RowInScope, type ScopeOf, type Storage, type StorageAdapter, type StorageApi, type StorageHook, type StorageHookContext, type StorageModels, type StorageOp, type StorageTarget, type TypeDefination, UnexpectedError, type UseApi, ValidationError, type VarCustomizer, type VarDefination, type VarExtension, type VarExtensionsFor, type VarGetContext, type VarMap, type VarName, type VarScope, type VarSetContext, type VarsFrom, type Where, type WhereOp, type WhereOps, type WidenedArgs, type WithContext, type WithSeed, attrsOf, collectFns, collectUsable, conditionsOf, fieldsFromSchema, isFn, isNamespace, isOn, isStorage, isVarExtension, matchesWhere, memoryAdapter, resolveModelFields, v, withAttrs };
+//# sourceMappingURL=index.d.cts.map