better-call 0.0.0-experimental.06264e12

package/dist/module.cjs

@@ -0,0 +1,111 @@
+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 and other `$`-surfaced objects fail the member
+* test and stay opaque values.
+*/
+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;
+	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). Groups holding nothing (however deep) drop out.
+*/
+const collectUsable = (modules) => {
+	const walk = (mod) => {
+		const out = {};
+		for (const [name, value] of Object.entries(mod)) if (isFn(value) || require_schema.isVar(value)) out[name] = value;
+		else if (isNamespace(value)) {
+			const nested = walk(value);
+			if (Object.keys(nested).length > 0) out[name] = nested;
+		}
+		return out;
+	};
+	const fns = {};
+	for (const mod of resolveModules(modules)) Object.assign(fns, walk(mod));
+	return fns;
+};
+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.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 {\n\tLiteralString,\n\tMembers,\n\tPrettify,\n\tUnionToIntersection,\n} from \"./types\";\nimport type { VarDefination } from \"./var\";\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. */\ntype GroupMember<V> = V extends\n\t| { $var: true }\n\t| { $on: true }\n\t| { $varExtend: true }\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: [GroupFns<M[K], GroupDepth[D]>] extends [never]\n\t\t\t\t? never\n\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: 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 and other `$`-surfaced objects fail the member\n * test and stay opaque values.\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\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). Groups holding nothing (however deep) drop out.\n */\nexport const collectUsable = (\n\tmodules: readonly Module[],\n): Record<string, unknown> => {\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)) {\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 fns: Record<string, unknown> = {};\n\tfor (const mod of resolveModules(modules)) Object.assign(fns, walk(mod));\n\treturn fns;\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/**\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: [VarFieldKeys<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/* ------------------------------- 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.\n */\nexport type ApplyOn<F, PL> =\n\tF extends FnDefination<\n\t\tinfer A,\n\t\tinfer R,\n\t\tinfer K,\n\t\tinfer I,\n\t\tinfer P,\n\t\tinfer Er,\n\t\tinfer W,\n\t\tinfer O\n\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,249 @@
+import { LiteralString, Members, Prettify, UnionToIntersection } from "./types.cjs";
+import { InferArgs, InferInput, vTypes } from "./schema.cjs";
+import { VarDefination } from "./var.cjs";
+import { FnDefination } from "./fn.cjs";
+//#region src/module.d.ts
+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. */
+type GroupMember<V> = V extends {
+  $var: true;
+} | {
+  $on: true;
+} | {
+  $varExtend: true;
+} | ((...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 : [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] : 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 and other `$`-surfaced objects fail the member
+ * test and stay opaque values.
+ */
+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). Groups holding nothing (however deep) drop out.
+ */
+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];
+/**
+ * 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> : [VarFieldKeys<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; };
+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.
+ */
+type ApplyOn<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, 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