better-call 0.0.0-experimental.01ff4b77

package/dist/index.d.mts

@@ -0,0 +1,50 @@
+import { ControlFlow, FnError, Issue, UnexpectedError, ValidationError } from "./error.mjs";
+import { LiteralString, Prettify } from "./types.mjs";
+import { AttrBag, InferArgs, InferInput, InferOutput, InferType, TypeDefination, attrsOf, vTypes, withAttrs } from "./schema.mjs";
+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.mjs";
+import { ResolvedVars, RowInScope, ScopeOf, VarName, VarScope } from "./scope.mjs";
+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.mjs";
+import { Context, Fn, FnDefination, FnErrors, Instance, OptionType, ParentContext, UseApi, WidenedArgs, WithContext, WithSeed } from "./fn.mjs";
+import { NameOfVar, ValueOfVar, VarCustomizer, VarDefination, VarMap } from "./var.mjs";
+//#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.mts.map

package/dist/index.mjs

@@ -0,0 +1,24 @@
+import { ControlFlow, FnError, UnexpectedError, ValidationError } from "./error.mjs";
+import { attrsOf, vTypes, withAttrs } from "./schema.mjs";
+import { collectFns, collectUsable, extendVar, isFn, isNamespace, isOn, isVarExtension, on } from "./module.mjs";
+import { deriveVar, makeVar } from "./var.mjs";
+import { fnImpl } from "./fn.mjs";
+import { conditionsOf, fieldsFromSchema, isStorage, makeStorage, matchesWhere, memoryAdapter, resolveModelFields } from "./storage.mjs";
+//#region src/index.ts
+const v = {
+	fn: fnImpl,
+	var: makeVar,
+	record: ((name, options = {}) => makeVar(name, {
+		...options,
+		accessor: true
+	})),
+	derive: deriveVar,
+	storage: makeStorage,
+	on,
+	extend: extendVar,
+	...vTypes
+};
+//#endregion
+export { ControlFlow, FnError, UnexpectedError, ValidationError, attrsOf, collectFns, collectUsable, conditionsOf, fieldsFromSchema, isFn, isNamespace, isOn, isStorage, isVarExtension, matchesWhere, memoryAdapter, resolveModelFields, v, withAttrs };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"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,IAAI;CACJ,KAAK;CACL,UAAU,MAAc,UAAe,CAAC,MACvC,QAAQ,MAAM;EAAE,GAAG;EAAS,UAAU;CAAK,CAAC;CAC7C,QAAQ;CACR,SAAS;CACT;CACA,QAAQ;CACR,GAAG;AACJ"}

package/dist/module.cjs

@@ -0,0 +1,176 @@
+const require_schema = require("./schema.cjs");
+//#region src/module.ts
+/**
+* Does an `on` target hit fn key `key`? Exact match, `*` wildcards
+* ("*", "sign_up.*", "/sign-up/*" - a `*` spans anything), a RegExp, or a
+* list (any member hitting counts).
+*/
+const matchesTarget = (target, key) => {
+	if (Array.isArray(target)) return target.some((member) => matchesTarget(member, key));
+	if (target instanceof RegExp) return target.test(key);
+	const name = target;
+	if (name === key) return true;
+	if (!name.includes("*")) return false;
+	const pattern = name.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(`^${pattern}$`).test(key);
+};
+const isFn = (value) => typeof value === "function" && value?.$fn === true;
+/**
+* Guard the module list: modules are plain records, and passing a bare
+* fn/var/extension/`on` entry is almost always a mistake (a bare fn would
+* otherwise look like a factory and get CALLED). Fail loudly instead.
+*/
+const resolveModules = (modules) => modules.map((mod) => {
+	if (isFn(mod) || require_schema.isVar(mod) || isVarExtension(mod) || isOn(mod)) {
+		const bare = mod;
+		const name = bare.key ?? bare.name ?? (bare.target !== void 0 ? String(bare.target) : "member");
+		throw new Error(`modules are objects - wrap the member: use([{ ${name} }]), not use([${name}])`);
+	}
+	return mod ?? {};
+});
+/** Collect every exported fn from a set of plugin modules. */
+const collectFns = (modules) => {
+	const fns = {};
+	for (const mod of resolveModules(modules)) for (const [name, value] of Object.entries(mod)) if (isFn(value)) fns[name] = value;
+	return fns;
+};
+/**
+* A plain-record member that GROUPS other members - not itself branded
+* (fn, var, on entry, var extension) but holding at least one such member,
+* transitively. Storages stay opaque values (their `$models` are not a
+* nested module group).
+*/
+const isNamespace = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	if (require_schema.isVar(value) || isOn(value) || isVarExtension(value)) return false;
+	if ("$models" in value && typeof value.$adapter === "function") return false;
+	return Object.values(value).some((m) => isFn(m) || require_schema.isVar(m) || isOn(m) || isVarExtension(m) || isNamespace(m));
+};
+/**
+* Every exported fn AND var, with plain-record GROUPS kept as nested
+* namespaces: `use: [{ cookie: { setCookie } }]` lands the fn on
+* `c.cookie.setCookie`. A var member becomes an ALIAS under its export
+* name (`{ cookie: { options: cookieOptions } }` -> `c.cookie.options`
+* reads/writes the var). Storage mounts whole (`c.db.user.findOne`).
+* Groups holding nothing (however deep) drop out.
+*
+* A `merge: true` var keeps its slot when a later module exports a
+* namespace under the same key - those helpers are folded into the var
+* value by {@link collectMergeSeeds}, not bound as a rival namespace.
+*/
+const collectUsable = (modules) => {
+	const isStorageValue = (value) => typeof value === "object" && value !== null && "$models" in value && typeof value.$adapter === "function";
+	const isMergeVar = (value) => require_schema.isVar(value) && value.$merge === true;
+	const isGroup = (value) => value !== null && typeof value === "object" && !isFn(value) && !require_schema.isVar(value) && !isStorageValue(value);
+	const walk = (mod) => {
+		const out = {};
+		for (const [name, value] of Object.entries(mod)) if (isFn(value) || require_schema.isVar(value) || isStorageValue(value)) out[name] = value;
+		else if (isNamespace(value)) {
+			const nested = walk(value);
+			if (Object.keys(nested).length > 0) out[name] = nested;
+		}
+		return out;
+	};
+	const assign = (target, name, value) => {
+		const existing = target[name];
+		if (isMergeVar(existing) && isGroup(value)) return;
+		if (isMergeVar(value) && isGroup(existing)) {
+			target[name] = value;
+			return;
+		}
+		if (isGroup(existing) && isGroup(value)) {
+			const group = { ...existing };
+			for (const [k, v] of Object.entries(value)) assign(group, k, v);
+			target[name] = group;
+			return;
+		}
+		target[name] = value;
+	};
+	const fns = {};
+	for (const mod of resolveModules(modules)) for (const [name, value] of Object.entries(walk(mod))) assign(fns, name, value);
+	return fns;
+};
+/**
+* Initial values for `merge: true` vars: walk `use` modules in order and
+* shallow-merge (1) each merge-var's `default` and (2) namespaces exported
+* under the same key as a merge var. Later leaf keys win.
+*/
+const collectMergeSeeds = (modules) => {
+	const resolved = resolveModules(modules);
+	const seeds = {};
+	const keyToVar = /* @__PURE__ */ new Map();
+	const isMergeVar = (value) => require_schema.isVar(value) && value.$merge === true;
+	const mergeInto = (name, contribution) => {
+		if (contribution === void 0) return;
+		const current = seeds[name];
+		if (contribution !== null && typeof contribution === "object" && !Array.isArray(contribution) && current !== null && typeof current === "object" && !Array.isArray(current)) seeds[name] = {
+			...current,
+			...contribution
+		};
+		else seeds[name] = contribution;
+	};
+	const index = (mod) => {
+		for (const [key, value] of Object.entries(mod)) if (isMergeVar(value)) keyToVar.set(key, value.name);
+		else if (isNamespace(value)) index(value);
+	};
+	for (const mod of resolved) index(mod);
+	const contribute = (mod) => {
+		for (const [key, value] of Object.entries(mod)) {
+			if (isMergeVar(value)) {
+				mergeInto(value.name, value.default);
+				continue;
+			}
+			if (isNamespace(value)) {
+				const varName = keyToVar.get(key);
+				if (varName) mergeInto(varName, value);
+				else contribute(value);
+			}
+		}
+	};
+	for (const mod of resolved) contribute(mod);
+	return seeds;
+};
+const isOn = (value) => value?.$on === true;
+function on(target, extendOrHandler, maybeHandler) {
+	const resolveOne = (member) => isFn(member) ? member.key : member;
+	const resolved = Array.isArray(target) ? target.map(resolveOne) : resolveOne(target);
+	return typeof extendOrHandler === "function" ? {
+		$on: true,
+		target: resolved,
+		handler: extendOrHandler
+	} : {
+		$on: true,
+		target: resolved,
+		extend: extendOrHandler,
+		handler: maybeHandler
+	};
+}
+const isVarExtension = (value) => value?.$varExtend === true;
+function extendVar(target, schema) {
+	return typeof target === "string" ? {
+		$varExtend: true,
+		name: target,
+		schema
+	} : {
+		$varExtend: true,
+		name: target.name,
+		schema,
+		base: target
+	};
+}
+//#endregion
+exports.collectFns = collectFns;
+exports.collectMergeSeeds = collectMergeSeeds;
+exports.collectUsable = collectUsable;
+exports.extendVar = extendVar;
+exports.isFn = isFn;
+exports.isNamespace = isNamespace;
+exports.isOn = isOn;
+exports.isVarExtension = isVarExtension;
+exports.matchesTarget = matchesTarget;
+exports.on = on;
+exports.resolveModules = resolveModules;
+
+//# sourceMappingURL=module.cjs.map

package/dist/module.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.cjs","names":["isVar"],"sources":["../src/module.ts"],"sourcesContent":["import type { FnDefination } from \"./fn\";\nimport { type InferArgs, type InferInput, isVar, type vTypes } from \"./schema\";\nimport type { WidenSchemaFns } from \"./scope\";\nimport type {\n\tLiteralString,\n\tMembers,\n\tPrettify,\n\tUnionToIntersection,\n} from \"./types\";\nimport type { VarDefination } from \"./var\";\n\n/** Storage (or a slice): `$models` plus callable `$adapter`. Kept opaque\n * in {@link ModuleFns} so collections stay on `c.db`, not walked as groups.\n * Matches runtime detection (`$adapter` required) so a plain namespace that\n * happens to have a `$models` key is still walked for nested fns/vars. */\ntype StorageLike = {\n\t$models: object;\n\t$adapter: (...args: never[]) => unknown;\n};\n\nexport type Interceptor = (c: any, next: () => Promise<any>) => any;\n\n/**\n * What a GLOBAL `v.on` handler sees. Without a builder there is no scope\n * to infer, but the context's shape is always the same - so the default\n * is structured with loose leaves, never `any`: `c.input.code` works,\n * `c.tpyo` does not. Mount the entry on a builder's `on` for real types.\n */\nexport type OnDefaultContext = {\n\tinput: Record<string, any>;\n\ttypes: typeof vTypes;\n\tfn: unknown;\n\t/** Vars and used fns live directly on `c` - untyped here; mount the\n\t * entry on a builder's `on` for real types. */\n\t[key: string]: any;\n};\n\nexport type OnEntry<N extends string, Ext = unknown> = {\n\t$on: true;\n\t/** Exact key, a `*` wildcard pattern, a RegExp, or a LIST of any of\n\t * those - one handler mounted on several events at once. */\n\ttarget: N | RegExp | readonly (string | RegExp)[];\n\t/** Extra input fields this mount adds to the target fn. */\n\textend?: { input?: Ext };\n\thandler: Interceptor;\n};\n\n/**\n * Does an `on` target hit fn key `key`? Exact match, `*` wildcards\n * (\"*\", \"sign_up.*\", \"/sign-up/*\" - a `*` spans anything), a RegExp, or a\n * list (any member hitting counts).\n */\nexport const matchesTarget = (\n\ttarget: string | RegExp | readonly (string | RegExp)[],\n\tkey: string,\n): boolean => {\n\tif (Array.isArray(target)) {\n\t\treturn (target as readonly (string | RegExp)[]).some((member) =>\n\t\t\tmatchesTarget(member, key),\n\t\t);\n\t}\n\tif (target instanceof RegExp) return target.test(key);\n\t// Array.isArray cannot narrow a readonly array out of the union.\n\tconst name = target as string;\n\tif (name === key) return true;\n\tif (!name.includes(\"*\")) return false;\n\tconst pattern = name\n\t\t.replace(/[.+?^${}()|[\\]\\\\]/g, \"\\\\$&\")\n\t\t.replace(/\\*/g, \".*\");\n\treturn new RegExp(`^${pattern}$`).test(key);\n};\n\n/**\n * The type-level half of `matchesTarget`, for input extensions: exact\n * keys and single-`*` patterns narrow call sites; RegExp targets (typed\n * `string`) intercept and validate at runtime but cannot narrow.\n */\nexport type TargetMatches<N, K extends string> = N extends \"*\"\n\t? true\n\t: N extends `${infer Pre}*${infer Suf}`\n\t\t? K extends `${Pre}${string}`\n\t\t\t? Suf extends \"\"\n\t\t\t\t? true\n\t\t\t\t: K extends `${string}${Suf}`\n\t\t\t\t\t? true\n\t\t\t\t\t: false\n\t\t\t: false\n\t\t: N extends K\n\t\t\t? true\n\t\t\t: false;\n\n/**\n * A module is the unit of composition: a RECORD of members - vars, fns,\n * `on` entries, var extensions - usually just what a file exports\n * (`import * as twoFactor`) or a curated bundle. \"Plugin\" is not a\n * concept, only a usage: mounting someone else's module. Always an\n * object, never a bare member: `use: [{ createUser }]`, not\n * `use: [createUser]`. The `never` marks reject bare members at the type\n * level; `resolveModules` rejects them at runtime.\n */\nexport type Module = Record<string, unknown> & {\n\t$var?: never;\n\t$varExtend?: never;\n\t/** Rejects a bare `on` ENTRY (`$on: true`) while letting a storage\n\t * through - its `$on` is the hook-mounting METHOD, not the brand. */\n\t$on?: (...args: never[]) => unknown;\n\t$fn?: never;\n};\n\n/** A module member that can NEST other members: a plain record that is\n * not itself branded. Fn defs are callable, so they never match. Storage\n * stays opaque (collections are not a nested module group). */\ntype GroupMember<V> = V extends\n\t| { $var: true }\n\t| { $on: true }\n\t| { $varExtend: true }\n\t| StorageLike\n\t| ((...args: any[]) => any)\n\t| readonly unknown[]\n\t? never\n\t: V extends Record<string, unknown>\n\t\t? V\n\t\t: never;\n\ntype VarEntryUnion<M> = {\n\t[K in keyof M]: M[K] extends VarDefination<infer N, infer T, any, any>\n\t\t? { [P in N]: T }\n\t\t: M[K] extends VarExtension<infer N, any, infer BT>\n\t\t\t? unknown extends BT\n\t\t\t\t? never\n\t\t\t\t: { [P in N]: BT }\n\t\t\t: [GroupMember<M[K]>] extends [never]\n\t\t\t\t? never\n\t\t\t\t: VarEntryUnion<GroupMember<M[K]>>;\n}[keyof M];\n\n/**\n * Vars a module exports, keyed by their DECLARED name, not export name.\n * Distributes over `M`: without that, a union of modules collapses to\n * `keyof A & keyof B` and every var is lost. The `[never]` guard matters\n * too - `UnionToIntersection<never>` is `unknown`, and one var-less module\n * in the union would absorb every other module's vars into `unknown`.\n */\nexport type VarsFrom<M> = M extends unknown\n\t? [VarEntryUnion<M>] extends [never]\n\t\t? never\n\t\t: UnionToIntersection<VarEntryUnion<M>>\n\t: never;\n\nexport type ModuleVars<PL> = UnionToIntersection<VarsFrom<Members<PL>>>;\n\n/** Depth budget for nested groups: unbranded records can be arbitrarily\n * deep (schema shapes, values), so the walk stops after a few levels\n * instead of blowing the instantiation limit. */\ntype GroupDepth = [never, 0, 1, 2];\n\n/** A nested GROUP's fns: only real groups holding at least one fn\n * (within the depth budget) survive - everything else drops from the\n * surface. */\ntype GroupFns<V, D extends number> = [D] extends [never]\n\t? never\n\t: [GroupMember<V>] extends [never]\n\t\t? never\n\t\t: [keyof FnEntries<GroupMember<V>, D>] extends [never]\n\t\t\t? never\n\t\t\t: FnEntries<GroupMember<V>, D>;\n\ntype FnEntries<M, D extends number = 3> = {\n\t[K in keyof M as M[K] extends FnDefination<any, any, any, any, any, any>\n\t\t? K\n\t\t: M[K] extends VarDefination<any, any, any, any>\n\t\t\t? K\n\t\t\t: M[K] extends StorageLike\n\t\t\t\t? K\n\t\t\t\t: [GroupFns<M[K], GroupDepth[D]>] extends [never]\n\t\t\t\t\t? never\n\t\t\t\t\t: K]: M[K] extends FnDefination<any, any, any, any, any, any>\n\t\t? M[K]\n\t\t: M[K] extends VarDefination<any, any, any, any>\n\t\t\t? M[K]\n\t\t\t: M[K] extends StorageLike\n\t\t\t\t? M[K]\n\t\t\t\t: GroupFns<M[K], GroupDepth[D]>;\n};\n\n/** Fns and vars a module exports, keyed by EXPORT name. A plain-record\n * member is a GROUP: its members stay nested under the member's name\n * (`use: [{ cookie: { setCookie } }]` -> `c.cookie.setCookie`). A var\n * member is an ALIAS onto the var - `{ cookie: { options: cookieOptions } }`\n * reads and writes the `cookieOptions` var through `c.cookie.options`. */\nexport type FnsFrom<M> = M extends unknown ? FnEntries<M> : never;\n\nexport type ModuleFns<PL> = UnionToIntersection<FnsFrom<Members<PL>>>;\n\nexport const isFn = (value: any): value is FnDefination<any, any> =>\n\ttypeof value === \"function\" && value?.$fn === true;\n\n/**\n * Guard the module list: modules are plain records, and passing a bare\n * fn/var/extension/`on` entry is almost always a mistake (a bare fn would\n * otherwise look like a factory and get CALLED). Fail loudly instead.\n */\nexport const resolveModules = (\n\tmodules: readonly Module[],\n): Record<string, unknown>[] =>\n\tmodules.map((mod) => {\n\t\tif (isFn(mod) || isVar(mod) || isVarExtension(mod) || isOn(mod)) {\n\t\t\tconst bare = mod as { key?: string; name?: string; target?: unknown };\n\t\t\tconst name =\n\t\t\t\tbare.key ??\n\t\t\t\tbare.name ??\n\t\t\t\t(bare.target !== undefined ? String(bare.target) : \"member\");\n\t\t\tthrow new Error(\n\t\t\t\t`modules are objects - wrap the member: use([{ ${name} }]), not use([${name}])`,\n\t\t\t);\n\t\t}\n\t\treturn (mod ?? {}) as Record<string, unknown>;\n\t});\n\n/** Collect every exported fn from a set of plugin modules. */\nexport const collectFns = (\n\tmodules: readonly Module[],\n): Record<string, FnDefination<any, any>> => {\n\tconst fns: Record<string, FnDefination<any, any>> = {};\n\tfor (const mod of resolveModules(modules)) {\n\t\tfor (const [name, value] of Object.entries(mod)) {\n\t\t\tif (isFn(value)) fns[name] = value;\n\t\t}\n\t}\n\treturn fns;\n};\n\n/**\n * A plain-record member that GROUPS other members - not itself branded\n * (fn, var, on entry, var extension) but holding at least one such member,\n * transitively. Storages stay opaque values (their `$models` are not a\n * nested module group).\n */\nexport const isNamespace = (\n\tvalue: unknown,\n): value is Record<string, unknown> => {\n\tif (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n\t\treturn false;\n\t}\n\tconst proto = Object.getPrototypeOf(value);\n\tif (proto !== Object.prototype && proto !== null) return false;\n\tif (isVar(value) || isOn(value) || isVarExtension(value)) return false;\n\t// Storage: `$models` + `$adapter` - not a namespace of module members.\n\tif (\n\t\t\"$models\" in value &&\n\t\ttypeof (value as { $adapter?: unknown }).$adapter === \"function\"\n\t) {\n\t\treturn false;\n\t}\n\treturn Object.values(value).some(\n\t\t(m) =>\n\t\t\tisFn(m) || isVar(m) || isOn(m) || isVarExtension(m) || isNamespace(m),\n\t);\n};\n\n/**\n * Every exported fn AND var, with plain-record GROUPS kept as nested\n * namespaces: `use: [{ cookie: { setCookie } }]` lands the fn on\n * `c.cookie.setCookie`. A var member becomes an ALIAS under its export\n * name (`{ cookie: { options: cookieOptions } }` -> `c.cookie.options`\n * reads/writes the var). Storage mounts whole (`c.db.user.findOne`).\n * Groups holding nothing (however deep) drop out.\n *\n * A `merge: true` var keeps its slot when a later module exports a\n * namespace under the same key - those helpers are folded into the var\n * value by {@link collectMergeSeeds}, not bound as a rival namespace.\n */\nexport const collectUsable = (\n\tmodules: readonly Module[],\n): Record<string, unknown> => {\n\tconst isStorageValue = (value: unknown) =>\n\t\ttypeof value === \"object\" &&\n\t\tvalue !== null &&\n\t\t\"$models\" in value &&\n\t\ttypeof (value as { $adapter?: unknown }).$adapter === \"function\";\n\tconst isMergeVar = (value: unknown) =>\n\t\tisVar(value) && (value as { $merge?: boolean }).$merge === true;\n\tconst isGroup = (value: unknown) =>\n\t\tvalue !== null &&\n\t\ttypeof value === \"object\" &&\n\t\t!isFn(value) &&\n\t\t!isVar(value) &&\n\t\t!isStorageValue(value);\n\tconst walk = (mod: Record<string, unknown>): Record<string, unknown> => {\n\t\tconst out: Record<string, unknown> = {};\n\t\tfor (const [name, value] of Object.entries(mod)) {\n\t\t\tif (isFn(value) || isVar(value) || isStorageValue(value)) {\n\t\t\t\tout[name] = value;\n\t\t\t} else if (isNamespace(value)) {\n\t\t\t\tconst nested = walk(value);\n\t\t\t\tif (Object.keys(nested).length > 0) out[name] = nested;\n\t\t\t}\n\t\t}\n\t\treturn out;\n\t};\n\tconst assign = (\n\t\ttarget: Record<string, unknown>,\n\t\tname: string,\n\t\tvalue: unknown,\n\t) => {\n\t\tconst existing = target[name];\n\t\tif (isMergeVar(existing) && isGroup(value)) return;\n\t\tif (isMergeVar(value) && isGroup(existing)) {\n\t\t\ttarget[name] = value;\n\t\t\treturn;\n\t\t}\n\t\tif (isGroup(existing) && isGroup(value)) {\n\t\t\tconst group = { ...(existing as Record<string, unknown>) };\n\t\t\tfor (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n\t\t\t\tassign(group, k, v);\n\t\t\t}\n\t\t\ttarget[name] = group;\n\t\t\treturn;\n\t\t}\n\t\ttarget[name] = value;\n\t};\n\tconst fns: Record<string, unknown> = {};\n\tfor (const mod of resolveModules(modules)) {\n\t\tfor (const [name, value] of Object.entries(walk(mod))) {\n\t\t\tassign(fns, name, value);\n\t\t}\n\t}\n\treturn fns;\n};\n\n/**\n * Initial values for `merge: true` vars: walk `use` modules in order and\n * shallow-merge (1) each merge-var's `default` and (2) namespaces exported\n * under the same key as a merge var. Later leaf keys win.\n */\nexport const collectMergeSeeds = (\n\tmodules: readonly Module[],\n): Record<string, unknown> => {\n\tconst resolved = resolveModules(modules);\n\tconst seeds: Record<string, unknown> = {};\n\tconst keyToVar = new Map<string, string>();\n\n\tconst isMergeVar = (\n\t\tvalue: unknown,\n\t): value is VarDefination<string, unknown> & {\n\t\t$merge: true;\n\t\tdefault?: unknown;\n\t\tname: string;\n\t} => isVar(value) && (value as { $merge?: boolean }).$merge === true;\n\n\tconst mergeInto = (name: string, contribution: unknown) => {\n\t\tif (contribution === undefined) return;\n\t\tconst current = seeds[name];\n\t\tif (\n\t\t\tcontribution !== null &&\n\t\t\ttypeof contribution === \"object\" &&\n\t\t\t!Array.isArray(contribution) &&\n\t\t\tcurrent !== null &&\n\t\t\ttypeof current === \"object\" &&\n\t\t\t!Array.isArray(current)\n\t\t) {\n\t\t\tseeds[name] = {\n\t\t\t\t...(current as Record<string, unknown>),\n\t\t\t\t...(contribution as Record<string, unknown>),\n\t\t\t};\n\t\t} else {\n\t\t\tseeds[name] = contribution;\n\t\t}\n\t};\n\n\tconst index = (mod: Record<string, unknown>) => {\n\t\tfor (const [key, value] of Object.entries(mod)) {\n\t\t\tif (isMergeVar(value)) {\n\t\t\t\tkeyToVar.set(key, value.name);\n\t\t\t} else if (isNamespace(value)) {\n\t\t\t\tindex(value);\n\t\t\t}\n\t\t}\n\t};\n\tfor (const mod of resolved) index(mod);\n\n\tconst contribute = (mod: Record<string, unknown>) => {\n\t\tfor (const [key, value] of Object.entries(mod)) {\n\t\t\tif (isMergeVar(value)) {\n\t\t\t\tmergeInto(value.name, value.default);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (isNamespace(value)) {\n\t\t\t\tconst varName = keyToVar.get(key);\n\t\t\t\tif (varName) mergeInto(varName, value);\n\t\t\t\telse contribute(value);\n\t\t\t}\n\t\t}\n\t};\n\tfor (const mod of resolved) contribute(mod);\n\n\treturn seeds;\n};\n\nexport const isOn = (value: any): value is OnEntry<string> =>\n\tvalue?.$on === true;\n\n/**\n * Mount onto another fn by name. The handler replaces that fn's body and\n * receives `next` - call it to delegate, or don't.\n *\n * Sounder than a before/after hook: it has the target's signature, runs\n * INSIDE the target's contract checks (so skipping `next` still has to\n * satisfy `provides`), and composes as a stack.\n *\n * The middle argument extends the target's INPUT: those fields are\n * validated alongside the fn's own, land on `c.input`, and - through\n * `ApplyOns` - become required at every call site that mounts this entry.\n */\n/** The var name a `var.set.…`/`var.get.…` target addresses - literal when\n * exact. */\ntype VarNameOf<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/** What a `var.set.…` handler receives. Writes are synchronous, so the\n * handler must be too - call `next()` to let the write land, skip it to\n * cancel, throw to abort. */\nexport type VarSetContext<N extends string = string> = {\n\t/** The var being written. */\n\tname: N;\n\t/** The incoming value. */\n\tvalue: unknown;\n\t/** The fn frame performing the write. */\n\tfn: string;\n\t/** Every other property reads the scope's vars directly. */\n\t[key: string]: unknown;\n};\n\n/** What a `var.get.…` handler receives. Reads are synchronous, so the\n * handler must be too - `next()` yields the stored value and whatever the\n * handler returns becomes the read result. */\nexport type VarGetContext<N extends string = string> = {\n\t/** The var being read. */\n\tname: N;\n\t/** The fn frame performing the read. */\n\tfn: string;\n\t/** Every other property reads the scope's vars (raw - no get hooks). */\n\t[key: string]: unknown;\n};\n\ntype FnInputOf<F> =\n\tF extends FnDefination<any, any, any, infer I, any, any>\n\t\t? InferInput<I>\n\t\t: never;\n\ntype FnResultOf<F> =\n\tF extends FnDefination<any, infer R, any, any, any, any> ? Awaited<R> : never;\n\nexport function on<T extends \"var.set.*\" | `var.set.${string}`>(\n\ttarget: T,\n\thandler: (c: VarSetContext<VarNameOf<T>>, next: () => void) => void,\n): OnEntry<T>;\nexport function on<T extends \"var.get.*\" | `var.get.${string}`>(\n\ttarget: T,\n\thandler: (c: VarGetContext<VarNameOf<T>>, next: () => unknown) => unknown,\n): OnEntry<T>;\nexport function on<F extends FnDefination<any, any, string, any, any, any>>(\n\ttarget: F,\n\thandler: (\n\t\tc: Omit<OnDefaultContext, \"input\"> & { input: FnInputOf<F> },\n\t\tnext: () => Promise<FnResultOf<F>>,\n\t) => any,\n): OnEntry<F[\"key\"]>;\nexport function on<\n\tF extends FnDefination<any, any, string, any, any, any>,\n\tconst Ext,\n>(\n\ttarget: F,\n\textend: { input: Ext },\n\thandler: (\n\t\tc: Omit<OnDefaultContext, \"input\"> & {\n\t\t\tinput: FnInputOf<F> & InferInput<Ext>;\n\t\t},\n\t\tnext: () => Promise<FnResultOf<F>>,\n\t) => any,\n): OnEntry<F[\"key\"], Ext>;\nexport function on(\n\ttargets: readonly (\n\t\t| LiteralString\n\t\t| RegExp\n\t\t| FnDefination<any, any, string, any, any, any>\n\t)[],\n\thandler: (c: OnDefaultContext, next: () => Promise<any>) => any,\n): OnEntry<string>;\nexport function on(\n\ttarget: RegExp,\n\thandler: (c: OnDefaultContext, next: () => Promise<any>) => any,\n): OnEntry<string>;\nexport function on<N extends \"*\" | LiteralString>(\n\ttarget: N,\n\thandler: (c: OnDefaultContext, next: () => Promise<any>) => any,\n): OnEntry<N>;\nexport function on<const Ext>(\n\ttarget: RegExp,\n\textend: { input: Ext },\n\thandler: (\n\t\tc: Omit<OnDefaultContext, \"input\"> & {\n\t\t\tinput: InferInput<Ext> & Record<string, any>;\n\t\t},\n\t\tnext: () => Promise<any>,\n\t) => any,\n): OnEntry<string, Ext>;\nexport function on<N extends LiteralString, const Ext>(\n\ttarget: N,\n\textend: { input: Ext },\n\thandler: (\n\t\tc: Omit<OnDefaultContext, \"input\"> & {\n\t\t\tinput: InferInput<Ext> & Record<string, any>;\n\t\t},\n\t\tnext: () => Promise<any>,\n\t) => any,\n): OnEntry<N, Ext>;\nexport function on(\n\ttarget:\n\t\t| string\n\t\t| RegExp\n\t\t| FnDefination<any, any, string, any, any, any>\n\t\t| readonly (\n\t\t\t\t| string\n\t\t\t\t| RegExp\n\t\t\t\t| FnDefination<any, any, string, any, any, any>\n\t\t  )[],\n\textendOrHandler: any,\n\tmaybeHandler?: any,\n): OnEntry<string, any> {\n\t// A fn reference targets its own key - no string to typo. A LIST\n\t// resolves member-wise: one handler, several events.\n\tconst resolveOne = (member: unknown) =>\n\t\tisFn(member)\n\t\t\t? (member as { key: string }).key\n\t\t\t: (member as string | RegExp);\n\tconst resolved = (\n\t\tArray.isArray(target) ? target.map(resolveOne) : resolveOne(target)\n\t) as string | RegExp | readonly (string | RegExp)[];\n\treturn typeof extendOrHandler === \"function\"\n\t\t? { $on: true, target: resolved, handler: extendOrHandler }\n\t\t: {\n\t\t\t\t$on: true,\n\t\t\t\ttarget: resolved,\n\t\t\t\textend: extendOrHandler,\n\t\t\t\thandler: maybeHandler,\n\t\t\t};\n}\n\n/* ----------------------------- var extension ------------------------------ */\n\nexport type VarExtension<N extends string, S, BaseT = unknown> = {\n\t$varExtend: true;\n\tname: N;\n\tschema: S;\n\t/** The var being extended, when handed by reference. */\n\tbase?: VarDefination<N, BaseT, any, any>;\n};\n\nexport const isVarExtension = (\n\tvalue: any,\n): value is VarExtension<string, any> => value?.$varExtend === true;\n\n/**\n * Extend a var's shape from a module. Where `customize` mints a NEW var\n * definition to re-export, an extension is a mountable value: every scope\n * or fn that `use`s the module containing it sees the var widened, and\n * nothing that doesn't mount it is affected.\n *\n * Handed the var by REFERENCE, the extension carries it: mounting just\n * the extension brings the var itself, merged by its declared key - no\n * need to also mount the base var.\n */\nexport function extendVar<N extends LiteralString, S, BaseT>(\n\ttarget: VarDefination<N, BaseT, any, any>,\n\tschema: S,\n): VarExtension<N, S, BaseT>;\nexport function extendVar<N extends LiteralString, S>(\n\ttarget: N,\n\tschema: S,\n): VarExtension<N, S>;\nexport function extendVar(\n\ttarget: VarDefination<string, any, any, any> | string,\n\tschema: any,\n): VarExtension<string, any, any> {\n\treturn typeof target === \"string\"\n\t\t? { $varExtend: true, name: target, schema }\n\t\t: { $varExtend: true, name: target.name, schema, base: target };\n}\n\ntype VarExtEntry<M, K extends string> = M extends unknown\n\t? {\n\t\t\t[P in keyof M]: M[P] extends VarExtension<K, infer S>\n\t\t\t\t? InferInput<S>\n\t\t\t\t: never;\n\t\t}[keyof M]\n\t: never;\n\n/**\n * Shape additions modules in `PL` mount on var `K`. Resolves to `unknown`\n * when none - which intersects away harmlessly.\n */\nexport type VarExtensionsFor<PL, K extends string> = UnionToIntersection<\n\tVarExtEntry<Members<PL>, K>\n>;\n\ntype VarExtArgsEntry<M, K extends string> = M extends unknown\n\t? {\n\t\t\t[P in keyof M]: M[P] extends VarExtension<K, infer S>\n\t\t\t\t? InferArgs<S>\n\t\t\t\t: never;\n\t\t}[keyof M]\n\t: never;\n\n/** The ARGS side of the same extensions - what a caller must send. */\nexport type VarExtensionArgsFor<PL, K extends string> = UnionToIntersection<\n\tVarExtArgsEntry<Members<PL>, K>\n>;\n\n/** The args side of every VAR named `K` a module set declares - a\n * `customize`d re-export shadows by NAME, so mounting it counts as a\n * declaration about the same var. Schema-less vars contribute nothing. */\ntype VarShadowArgsEntry<M, K extends string> = M extends unknown\n\t? {\n\t\t\t[P in keyof M]: M[P] extends VarDefination<K, any, infer S, any>\n\t\t\t\t? unknown extends S\n\t\t\t\t\t? never\n\t\t\t\t\t: [NonNullable<S>] extends [never]\n\t\t\t\t\t\t? never\n\t\t\t\t\t\t: InferArgs<NonNullable<S>>\n\t\t\t\t: never;\n\t\t}[keyof M]\n\t: never;\n\n/**\n * Everything a module set says about var `K`'s ARGS side: extensions\n * mounted on it, intersected with every same-name var declaration. This is\n * what widens a fn schema whose input references `K` (see `WidenSchemaFns`)\n * - `unknown` when the scope adds nothing, which intersects away.\n */\nexport type VarArgsInScope<PL, K extends string> = VarExtensionArgsFor<PL, K> &\n\t([VarShadowArgsEntry<Members<PL>, K>] extends [never]\n\t\t? unknown\n\t\t: UnionToIntersection<VarShadowArgsEntry<Members<PL>, K>>);\n\ntype VarFieldKeys<I> = {\n\t[K in keyof I]: I[K] extends { $var: true } ? K : never;\n}[keyof I];\n\n/** Optional props put `undefined` in the key union; strip it so \"no var\n * fields\" still reads as `never` and InputVarExtra stays `unknown`. */\ntype VarFields<I> = Exclude<VarFieldKeys<I>, undefined>;\n\n/**\n * Extra args a fn must accept because its INPUT references vars that `PL`\n * extends. Whole-var input (`input: user`) merges at the top level; a var\n * used as a field widens that field. `unknown` when nothing applies.\n */\nexport type InputVarExtra<PL, I> = I extends {\n\t$var: true;\n\tname: infer N extends string;\n}\n\t? VarExtensionArgsFor<PL, N>\n\t: [VarFields<I>] extends [never]\n\t\t? unknown\n\t\t: {\n\t\t\t\t[K in keyof I as I[K] extends { $var: true }\n\t\t\t\t\t? K\n\t\t\t\t\t: never]: I[K] extends {\n\t\t\t\t\t$var: true;\n\t\t\t\t\tname: infer N extends string;\n\t\t\t\t}\n\t\t\t\t\t? VarExtensionArgsFor<PL, N>\n\t\t\t\t\t: unknown;\n\t\t\t};\n\n/**\n * Same merge as {@link InputVarExtra}, on the PARSED side - what the\n * handler sees on `c.input` after mounted extensions have been applied.\n */\nexport type InputVarExtraOut<PL, I> = I extends {\n\t$var: true;\n\tname: infer N extends string;\n}\n\t? VarExtensionsFor<PL, N>\n\t: [VarFields<I>] extends [never]\n\t\t? unknown\n\t\t: {\n\t\t\t\t[K in keyof I as I[K] extends { $var: true }\n\t\t\t\t\t? K\n\t\t\t\t\t: never]: I[K] extends {\n\t\t\t\t\t$var: true;\n\t\t\t\t\tname: infer N extends string;\n\t\t\t\t}\n\t\t\t\t\t? VarExtensionsFor<PL, N>\n\t\t\t\t\t: unknown;\n\t\t\t};\n\n/* ------------------------------- extension -------------------------------- */\n\ntype ExtEntryArgs<M, K extends string> = M extends unknown\n\t? {\n\t\t\t[P in keyof M]: M[P] extends OnEntry<infer N, infer E>\n\t\t\t\t? unknown extends E\n\t\t\t\t\t? never\n\t\t\t\t\t: TargetMatches<N, K> extends true\n\t\t\t\t\t\t? InferArgs<E>\n\t\t\t\t\t\t: never\n\t\t\t\t: never;\n\t\t}[keyof M]\n\t: never;\n\n/** Args added onto fn `K` by every extending `on` entry in `PL`. */\nexport type ExtendedArgs<PL, K extends string> = UnionToIntersection<\n\tExtEntryArgs<Members<PL>, K>\n>;\n\n/**\n * Rewrite a fn's type with the input extensions the module set `PL`\n * mounts on it. This is how a plugin's extra field becomes REQUIRED at\n * the call site, even though the fn itself never declared it. Storage\n * members get the same scope rewrite as a db var's value ({@link\n * WidenSchemaFns}): collections re-resolve row/`Where` types against\n * mounted `v.extend` / customize.\n */\nexport type ApplyOn<F, PL> = F extends StorageLike\n\t? WidenSchemaFns<F, PL>\n\t: F extends FnDefination<\n\t\t\t\tinfer A,\n\t\t\t\tinfer R,\n\t\t\t\tinfer K,\n\t\t\t\tinfer I,\n\t\t\t\tinfer P,\n\t\t\t\tinfer Er,\n\t\t\t\tinfer W,\n\t\t\t\tinfer O\n\t\t\t>\n\t\t? unknown extends ExtendedArgs<PL, K & string> & InputVarExtra<PL, I>\n\t\t\t? F\n\t\t\t: FnDefination<\n\t\t\t\t\tPrettify<\n\t\t\t\t\t\t([A] extends [void] ? unknown : A) &\n\t\t\t\t\t\t\tExtendedArgs<PL, K & string> &\n\t\t\t\t\t\t\tInputVarExtra<PL, I>\n\t\t\t\t\t>,\n\t\t\t\t\tR,\n\t\t\t\t\tK & string,\n\t\t\t\t\tI,\n\t\t\t\t\tP,\n\t\t\t\t\tEr,\n\t\t\t\t\tW,\n\t\t\t\t\tO\n\t\t\t\t>\n\t\t: F;\n\nexport type ApplyOns<Fns, PL> = { [P in keyof Fns]: ApplyOn<Fns[P], PL> };\n\n/* -------------------------------- derived --------------------------------- */\n\ntype DerivedNamesEntry<Mod, Q> = Mod extends unknown\n\t? {\n\t\t\t[K in keyof Mod]: Mod[K] extends VarDefination<\n\t\t\t\tinfer N,\n\t\t\t\tany,\n\t\t\t\tany,\n\t\t\t\tinfer Src\n\t\t\t>\n\t\t\t\t? [Src] extends [never]\n\t\t\t\t\t? never\n\t\t\t\t\t: Src extends Q\n\t\t\t\t\t\t? N\n\t\t\t\t\t\t: never\n\t\t\t\t: never;\n\t\t}[keyof Mod]\n\t: never;\n\n/**\n * Expand a `requires` set with every var DERIVED from a required source:\n * requiring `request` makes `method`, `path`, ... non-null too, because\n * they are computed from it.\n */\nexport type WithDerived<PL, BasePL, Q> =\n\t| Q\n\t| DerivedNamesEntry<Members<PL> | Members<BasePL>, Q>;\n"],"mappings":"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"}

package/dist/module.d.cts

@@ -0,0 +1,283 @@
+import { LiteralString, Members, Prettify, UnionToIntersection } from "./types.cjs";
+import { InferArgs, InferInput, vTypes } from "./schema.cjs";
+import { WidenSchemaFns } from "./scope.cjs";
+import { FnDefination } from "./fn.cjs";
+import { VarDefination } from "./var.cjs";
+//#region src/module.d.ts
+/** Storage (or a slice): `$models` plus callable `$adapter`. Kept opaque
+ * in {@link ModuleFns} so collections stay on `c.db`, not walked as groups.
+ * Matches runtime detection (`$adapter` required) so a plain namespace that
+ * happens to have a `$models` key is still walked for nested fns/vars. */
+type StorageLike = {
+  $models: object;
+  $adapter: (...args: never[]) => unknown;
+};
+type Interceptor = (c: any, next: () => Promise<any>) => any;
+/**
+ * What a GLOBAL `v.on` handler sees. Without a builder there is no scope
+ * to infer, but the context's shape is always the same - so the default
+ * is structured with loose leaves, never `any`: `c.input.code` works,
+ * `c.tpyo` does not. Mount the entry on a builder's `on` for real types.
+ */
+type OnDefaultContext = {
+  input: Record<string, any>;
+  types: typeof vTypes;
+  fn: unknown;
+  /** Vars and used fns live directly on `c` - untyped here; mount the
+   * entry on a builder's `on` for real types. */
+  [key: string]: any;
+};
+type OnEntry<N extends string, Ext = unknown> = {
+  $on: true;
+  /** Exact key, a `*` wildcard pattern, a RegExp, or a LIST of any of
+   * those - one handler mounted on several events at once. */
+  target: N | RegExp | readonly (string | RegExp)[];
+  /** Extra input fields this mount adds to the target fn. */
+  extend?: {
+    input?: Ext;
+  };
+  handler: Interceptor;
+};
+/**
+ * The type-level half of `matchesTarget`, for input extensions: exact
+ * keys and single-`*` patterns narrow call sites; RegExp targets (typed
+ * `string`) intercept and validate at runtime but cannot narrow.
+ */
+type TargetMatches<N, K extends string> = N extends "*" ? true : N extends `${infer Pre}*${infer Suf}` ? K extends `${Pre}${string}` ? Suf extends "" ? true : K extends `${string}${Suf}` ? true : false : false : N extends K ? true : false;
+/**
+ * A module is the unit of composition: a RECORD of members - vars, fns,
+ * `on` entries, var extensions - usually just what a file exports
+ * (`import * as twoFactor`) or a curated bundle. "Plugin" is not a
+ * concept, only a usage: mounting someone else's module. Always an
+ * object, never a bare member: `use: [{ createUser }]`, not
+ * `use: [createUser]`. The `never` marks reject bare members at the type
+ * level; `resolveModules` rejects them at runtime.
+ */
+type Module = Record<string, unknown> & {
+  $var?: never;
+  $varExtend?: never;
+  /** Rejects a bare `on` ENTRY (`$on: true`) while letting a storage
+   * through - its `$on` is the hook-mounting METHOD, not the brand. */
+  $on?: (...args: never[]) => unknown;
+  $fn?: never;
+};
+/** A module member that can NEST other members: a plain record that is
+ * not itself branded. Fn defs are callable, so they never match. Storage
+ * stays opaque (collections are not a nested module group). */
+type GroupMember<V> = V extends {
+  $var: true;
+} | {
+  $on: true;
+} | {
+  $varExtend: true;
+} | StorageLike | ((...args: any[]) => any) | readonly unknown[] ? never : V extends Record<string, unknown> ? V : never;
+type VarEntryUnion<M> = { [K in keyof M]: M[K] extends VarDefination<infer N, infer T, any, any> ? { [P in N]: T; } : M[K] extends VarExtension<infer N, any, infer BT> ? unknown extends BT ? never : { [P in N]: BT; } : [GroupMember<M[K]>] extends [never] ? never : VarEntryUnion<GroupMember<M[K]>>; }[keyof M];
+/**
+ * Vars a module exports, keyed by their DECLARED name, not export name.
+ * Distributes over `M`: without that, a union of modules collapses to
+ * `keyof A & keyof B` and every var is lost. The `[never]` guard matters
+ * too - `UnionToIntersection<never>` is `unknown`, and one var-less module
+ * in the union would absorb every other module's vars into `unknown`.
+ */
+type VarsFrom<M> = M extends unknown ? [VarEntryUnion<M>] extends [never] ? never : UnionToIntersection<VarEntryUnion<M>> : never;
+type ModuleVars<PL> = UnionToIntersection<VarsFrom<Members<PL>>>;
+/** Depth budget for nested groups: unbranded records can be arbitrarily
+ * deep (schema shapes, values), so the walk stops after a few levels
+ * instead of blowing the instantiation limit. */
+type GroupDepth = [never, 0, 1, 2];
+/** A nested GROUP's fns: only real groups holding at least one fn
+ * (within the depth budget) survive - everything else drops from the
+ * surface. */
+type GroupFns<V, D extends number> = [D] extends [never] ? never : [GroupMember<V>] extends [never] ? never : [keyof FnEntries<GroupMember<V>, D>] extends [never] ? never : FnEntries<GroupMember<V>, D>;
+type FnEntries<M, D extends number = 3> = { [K in keyof M as M[K] extends FnDefination<any, any, any, any, any, any> ? K : M[K] extends VarDefination<any, any, any, any> ? K : M[K] extends StorageLike ? K : [GroupFns<M[K], GroupDepth[D]>] extends [never] ? never : K]: M[K] extends FnDefination<any, any, any, any, any, any> ? M[K] : M[K] extends VarDefination<any, any, any, any> ? M[K] : M[K] extends StorageLike ? M[K] : GroupFns<M[K], GroupDepth[D]>; };
+/** Fns and vars a module exports, keyed by EXPORT name. A plain-record
+ * member is a GROUP: its members stay nested under the member's name
+ * (`use: [{ cookie: { setCookie } }]` -> `c.cookie.setCookie`). A var
+ * member is an ALIAS onto the var - `{ cookie: { options: cookieOptions } }`
+ * reads and writes the `cookieOptions` var through `c.cookie.options`. */
+type FnsFrom<M> = M extends unknown ? FnEntries<M> : never;
+type ModuleFns<PL> = UnionToIntersection<FnsFrom<Members<PL>>>;
+declare const isFn: (value: any) => value is FnDefination<any, any>;
+/** Collect every exported fn from a set of plugin modules. */
+declare const collectFns: (modules: readonly Module[]) => Record<string, FnDefination<any, any>>;
+/**
+ * A plain-record member that GROUPS other members - not itself branded
+ * (fn, var, on entry, var extension) but holding at least one such member,
+ * transitively. Storages stay opaque values (their `$models` are not a
+ * nested module group).
+ */
+declare const isNamespace: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Every exported fn AND var, with plain-record GROUPS kept as nested
+ * namespaces: `use: [{ cookie: { setCookie } }]` lands the fn on
+ * `c.cookie.setCookie`. A var member becomes an ALIAS under its export
+ * name (`{ cookie: { options: cookieOptions } }` -> `c.cookie.options`
+ * reads/writes the var). Storage mounts whole (`c.db.user.findOne`).
+ * Groups holding nothing (however deep) drop out.
+ *
+ * A `merge: true` var keeps its slot when a later module exports a
+ * namespace under the same key - those helpers are folded into the var
+ * value by {@link collectMergeSeeds}, not bound as a rival namespace.
+ */
+declare const collectUsable: (modules: readonly Module[]) => Record<string, unknown>;
+declare const isOn: (value: any) => value is OnEntry<string>;
+/**
+ * Mount onto another fn by name. The handler replaces that fn's body and
+ * receives `next` - call it to delegate, or don't.
+ *
+ * Sounder than a before/after hook: it has the target's signature, runs
+ * INSIDE the target's contract checks (so skipping `next` still has to
+ * satisfy `provides`), and composes as a stack.
+ *
+ * The middle argument extends the target's INPUT: those fields are
+ * validated alongside the fn's own, land on `c.input`, and - through
+ * `ApplyOns` - become required at every call site that mounts this entry.
+ */
+/** The var name a `var.set.…`/`var.get.…` target addresses - literal when
+ * exact. */
+type VarNameOf<T extends string> = T extends `var.${"set" | "get"}.${infer N}` ? N extends `${string}*${string}` ? string : N : string;
+/** What a `var.set.…` handler receives. Writes are synchronous, so the
+ * handler must be too - call `next()` to let the write land, skip it to
+ * cancel, throw to abort. */
+type VarSetContext<N extends string = string> = {
+  /** The var being written. */
+  name: N;
+  /** The incoming value. */
+  value: unknown;
+  /** The fn frame performing the write. */
+  fn: string;
+  /** Every other property reads the scope's vars directly. */
+  [key: string]: unknown;
+};
+/** What a `var.get.…` handler receives. Reads are synchronous, so the
+ * handler must be too - `next()` yields the stored value and whatever the
+ * handler returns becomes the read result. */
+type VarGetContext<N extends string = string> = {
+  /** The var being read. */
+  name: N;
+  /** The fn frame performing the read. */
+  fn: string;
+  /** Every other property reads the scope's vars (raw - no get hooks). */
+  [key: string]: unknown;
+};
+type FnInputOf<F> = F extends FnDefination<any, any, any, infer I, any, any> ? InferInput<I> : never;
+type FnResultOf<F> = F extends FnDefination<any, infer R, any, any, any, any> ? Awaited<R> : never;
+declare function on<T extends "var.set.*" | `var.set.${string}`>(target: T, handler: (c: VarSetContext<VarNameOf<T>>, next: () => void) => void): OnEntry<T>;
+declare function on<T extends "var.get.*" | `var.get.${string}`>(target: T, handler: (c: VarGetContext<VarNameOf<T>>, next: () => unknown) => unknown): OnEntry<T>;
+declare function on<F extends FnDefination<any, any, string, any, any, any>>(target: F, handler: (c: Omit<OnDefaultContext, "input"> & {
+  input: FnInputOf<F>;
+}, next: () => Promise<FnResultOf<F>>) => any): OnEntry<F["key"]>;
+declare function on<F extends FnDefination<any, any, string, any, any, any>, const Ext>(target: F, extend: {
+  input: Ext;
+}, handler: (c: Omit<OnDefaultContext, "input"> & {
+  input: FnInputOf<F> & InferInput<Ext>;
+}, next: () => Promise<FnResultOf<F>>) => any): OnEntry<F["key"], Ext>;
+declare function on(targets: readonly (LiteralString | RegExp | FnDefination<any, any, string, any, any, any>)[], handler: (c: OnDefaultContext, next: () => Promise<any>) => any): OnEntry<string>;
+declare function on(target: RegExp, handler: (c: OnDefaultContext, next: () => Promise<any>) => any): OnEntry<string>;
+declare function on<N extends "*" | LiteralString>(target: N, handler: (c: OnDefaultContext, next: () => Promise<any>) => any): OnEntry<N>;
+declare function on<const Ext>(target: RegExp, extend: {
+  input: Ext;
+}, handler: (c: Omit<OnDefaultContext, "input"> & {
+  input: InferInput<Ext> & Record<string, any>;
+}, next: () => Promise<any>) => any): OnEntry<string, Ext>;
+declare function on<N extends LiteralString, const Ext>(target: N, extend: {
+  input: Ext;
+}, handler: (c: Omit<OnDefaultContext, "input"> & {
+  input: InferInput<Ext> & Record<string, any>;
+}, next: () => Promise<any>) => any): OnEntry<N, Ext>;
+type VarExtension<N extends string, S, BaseT = unknown> = {
+  $varExtend: true;
+  name: N;
+  schema: S;
+  /** The var being extended, when handed by reference. */
+  base?: VarDefination<N, BaseT, any, any>;
+};
+declare const isVarExtension: (value: any) => value is VarExtension<string, any>;
+/**
+ * Extend a var's shape from a module. Where `customize` mints a NEW var
+ * definition to re-export, an extension is a mountable value: every scope
+ * or fn that `use`s the module containing it sees the var widened, and
+ * nothing that doesn't mount it is affected.
+ *
+ * Handed the var by REFERENCE, the extension carries it: mounting just
+ * the extension brings the var itself, merged by its declared key - no
+ * need to also mount the base var.
+ */
+declare function extendVar<N extends LiteralString, S, BaseT>(target: VarDefination<N, BaseT, any, any>, schema: S): VarExtension<N, S, BaseT>;
+declare function extendVar<N extends LiteralString, S>(target: N, schema: S): VarExtension<N, S>;
+type VarExtEntry<M, K extends string> = M extends unknown ? { [P in keyof M]: M[P] extends VarExtension<K, infer S> ? InferInput<S> : never; }[keyof M] : never;
+/**
+ * Shape additions modules in `PL` mount on var `K`. Resolves to `unknown`
+ * when none - which intersects away harmlessly.
+ */
+type VarExtensionsFor<PL, K extends string> = UnionToIntersection<VarExtEntry<Members<PL>, K>>;
+type VarExtArgsEntry<M, K extends string> = M extends unknown ? { [P in keyof M]: M[P] extends VarExtension<K, infer S> ? InferArgs<S> : never; }[keyof M] : never;
+/** The ARGS side of the same extensions - what a caller must send. */
+type VarExtensionArgsFor<PL, K extends string> = UnionToIntersection<VarExtArgsEntry<Members<PL>, K>>;
+/** The args side of every VAR named `K` a module set declares - a
+ * `customize`d re-export shadows by NAME, so mounting it counts as a
+ * declaration about the same var. Schema-less vars contribute nothing. */
+type VarShadowArgsEntry<M, K extends string> = M extends unknown ? { [P in keyof M]: M[P] extends VarDefination<K, any, infer S, any> ? unknown extends S ? never : [NonNullable<S>] extends [never] ? never : InferArgs<NonNullable<S>> : never; }[keyof M] : never;
+/**
+ * Everything a module set says about var `K`'s ARGS side: extensions
+ * mounted on it, intersected with every same-name var declaration. This is
+ * what widens a fn schema whose input references `K` (see `WidenSchemaFns`)
+ * - `unknown` when the scope adds nothing, which intersects away.
+ */
+type VarArgsInScope<PL, K extends string> = VarExtensionArgsFor<PL, K> & ([VarShadowArgsEntry<Members<PL>, K>] extends [never] ? unknown : UnionToIntersection<VarShadowArgsEntry<Members<PL>, K>>);
+type VarFieldKeys<I> = { [K in keyof I]: I[K] extends {
+  $var: true;
+} ? K : never; }[keyof I];
+/** Optional props put `undefined` in the key union; strip it so "no var
+ * fields" still reads as `never` and InputVarExtra stays `unknown`. */
+type VarFields<I> = Exclude<VarFieldKeys<I>, undefined>;
+/**
+ * Extra args a fn must accept because its INPUT references vars that `PL`
+ * extends. Whole-var input (`input: user`) merges at the top level; a var
+ * used as a field widens that field. `unknown` when nothing applies.
+ */
+type InputVarExtra<PL, I> = I extends {
+  $var: true;
+  name: infer N extends string;
+} ? VarExtensionArgsFor<PL, N> : [VarFields<I>] extends [never] ? unknown : { [K in keyof I as I[K] extends {
+  $var: true;
+} ? K : never]: I[K] extends {
+  $var: true;
+  name: infer N extends string;
+} ? VarExtensionArgsFor<PL, N> : unknown; };
+/**
+ * Same merge as {@link InputVarExtra}, on the PARSED side - what the
+ * handler sees on `c.input` after mounted extensions have been applied.
+ */
+type InputVarExtraOut<PL, I> = I extends {
+  $var: true;
+  name: infer N extends string;
+} ? VarExtensionsFor<PL, N> : [VarFields<I>] extends [never] ? unknown : { [K in keyof I as I[K] extends {
+  $var: true;
+} ? K : never]: I[K] extends {
+  $var: true;
+  name: infer N extends string;
+} ? VarExtensionsFor<PL, N> : unknown; };
+type ExtEntryArgs<M, K extends string> = M extends unknown ? { [P in keyof M]: M[P] extends OnEntry<infer N, infer E> ? unknown extends E ? never : TargetMatches<N, K> extends true ? InferArgs<E> : never : never; }[keyof M] : never;
+/** Args added onto fn `K` by every extending `on` entry in `PL`. */
+type ExtendedArgs<PL, K extends string> = UnionToIntersection<ExtEntryArgs<Members<PL>, K>>;
+/**
+ * Rewrite a fn's type with the input extensions the module set `PL`
+ * mounts on it. This is how a plugin's extra field becomes REQUIRED at
+ * the call site, even though the fn itself never declared it. Storage
+ * members get the same scope rewrite as a db var's value ({@link
+ * WidenSchemaFns}): collections re-resolve row/`Where` types against
+ * mounted `v.extend` / customize.
+ */
+type ApplyOn<F, PL> = F extends StorageLike ? WidenSchemaFns<F, PL> : F extends FnDefination<infer A, infer R, infer K, infer I, infer P, infer Er, infer W, infer O> ? unknown extends ExtendedArgs<PL, K & string> & InputVarExtra<PL, I> ? F : FnDefination<Prettify<([A] extends [void] ? unknown : A) & ExtendedArgs<PL, K & string> & InputVarExtra<PL, I>>, R, K & string, I, P, Er, W, O> : F;
+type ApplyOns<Fns, PL> = { [P in keyof Fns]: ApplyOn<Fns[P], PL>; };
+type DerivedNamesEntry<Mod, Q> = Mod extends unknown ? { [K in keyof Mod]: Mod[K] extends VarDefination<infer N, any, any, infer Src> ? [Src] extends [never] ? never : Src extends Q ? N : never : never; }[keyof Mod] : never;
+/**
+ * Expand a `requires` set with every var DERIVED from a required source:
+ * requiring `request` makes `method`, `path`, ... non-null too, because
+ * they are computed from it.
+ */
+type WithDerived<PL, BasePL, Q> = Q | DerivedNamesEntry<Members<PL> | Members<BasePL>, Q>;
+//#endregion
+export { ApplyOn, ApplyOns, ExtendedArgs, FnsFrom, InputVarExtra, InputVarExtraOut, Interceptor, Module, ModuleFns, ModuleVars, OnDefaultContext, OnEntry, TargetMatches, VarArgsInScope, VarExtension, VarExtensionArgsFor, VarExtensionsFor, VarGetContext, VarSetContext, VarsFrom, WithDerived, collectFns, collectUsable, extendVar, isFn, isNamespace, isOn, isVarExtension, on };
+//# sourceMappingURL=module.d.cts.map