@gaganref/confect-test 10.3.1-fork.88 → 10.3.1-fork.89

package/dist/internal/Attempt.d.ts

@@ -0,0 +1,77 @@
+import type { Attempt as AttemptNumber } from "./Invocation.js";
+import * as Kernel from "./Kernel.js";
+import type { DocumentId, StoredDocument } from "./KernelValues.js";
+import type * as ReadSet from "./ReadSet.js";
+/**
+ * One frame of an attempt at a query or mutation: the committed state the
+ * attempt started from, its caller's frame and its own pending writes. The
+ * outermost frame belongs to the top-level function. Each nested mutation opens
+ * a child frame, which merges into its caller's frame when it returns and is
+ * dropped when it fails. Reads belong to the whole attempt and are never
+ * dropped: a failed nested mutation's reads stay in the attempt.
+ *
+ * Each frame has its own lifetime. A frame takes reads and writes until it is
+ * closed. A mutation's frame closes once its function has returned and no
+ * syscall it started is still running, so a write a detached fiber makes after
+ * the handler settled still lands in it, as on the binary. A nested mutation's
+ * frame closes before it merges into its caller's, so no write reaches it after
+ * its writes became its caller's.
+ *
+ * A frame belongs to one invocation, which alone writes to it, so a caller's
+ * write made while its nested mutation is in flight stays the caller's.
+ * `Kernel.apply` publishes the outermost frame's writes.
+ */
+export declare class KernelAttempt {
+    readonly snapshot: Kernel.State;
+    readonly number: AttemptNumber;
+    private readonly parent?;
+    private readonly overlay;
+    private readonly life;
+    private readonly allReads;
+    constructor(snapshot: Kernel.State, number?: AttemptNumber, parent?: KernelAttempt | undefined);
+    get reads(): ReadonlyArray<ReadSet.Read>;
+    get closed(): boolean;
+    readDocument(componentPath: string, id: DocumentId): void;
+    /**
+     * Record a read of an interval. The returned function advances how far the
+     * query examined it.
+     */
+    readInterval(read: Omit<ReadSet.IntervalRead, "through">): (through: ReadSet.Key | "end") => void;
+    /**
+     * A syscall began. `end` runs when it settles.
+     */
+    begin(): () => void;
+    /**
+     * Resolves once a whole turn of the event loop passes with no syscall of this
+     * frame running or started. A nested call is a syscall of its caller's frame
+     * until it has drained.
+     */
+    drained(): Promise<void>;
+    close(): void;
+    /**
+     * The pending writes this frame sees, from the outermost frame to this one.
+     */
+    private overlays;
+    get(componentPath: string, id: DocumentId): StoredDocument | null;
+    /**
+     * The table as this frame sees it, committed rows under every pending write
+     * from the outermost frame to this one.
+     */
+    scan(componentPath: string, tableName: string): Array<StoredDocument>;
+    write(componentPath: string, id: DocumentId, doc: StoredDocument | null): void;
+    /**
+     * A nested mutation begins, in a frame of its own. Dropping a failed one is
+     * forgetting it.
+     */
+    child(): KernelAttempt;
+    /**
+     * A nested mutation returned and its frame closed. Its writes become its
+     * caller's.
+     */
+    merge(): void;
+    /**
+     * The outermost frame's writes, for `Kernel.apply`.
+     */
+    writes(): Array<Kernel.Write>;
+}
+//# sourceMappingURL=Attempt.d.ts.map

package/dist/internal/Attempt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Attempt.d.ts","sourceRoot":"","sources":["../../src/internal/Attempt.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEpE,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAC;AAiB7C;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,aAAa;IAMtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK;IAC/B,QAAQ,CAAC,MAAM,EAAE,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgD;IACrE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAE/C,YACW,QAAQ,EAAE,MAAM,CAAC,KAAK,EACtB,MAAM,GAAE,aAAiB,EACjB,MAAM,CAAC,EAAE,aAAa,YAAA,EAGxC;IAED,IAAI,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAEvC;IAED,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,QAEjD;IAED;;;OAGG;IACH,YAAY,CACV,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,SAAS,CAAC,GAC1C,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,GAAG,KAAK,KAAK,IAAI,CAMxC;IAED;;OAEG;IACH,KAAK,IAAI,MAAM,IAAI,CAOlB;IAED;;;;OAIG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAOvB;IAED,KAAK,SAEJ;IAED;;OAEG;IACH,OAAO,CAAC,QAAQ;IAMhB,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAG,cAAc,GAAG,IAAI,CAMhE;IAED;;;OAGG;IACH,IAAI,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC,cAAc,CAAC,CAapE;IAED,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,cAAc,GAAG,IAAI,QAItE;IAED;;;OAGG;IACH,KAAK,IAAI,aAAa,CAErB;IAED;;;OAGG;IACH,KAAK,SASJ;IAED;;OAEG;IACH,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAI5B;CACF"}

package/dist/internal/Attempt.js

@@ -0,0 +1,154 @@
+import { tableNameFromId } from "./KernelValues.js";
+import { get, rows } from "./Kernel.js";
+import { setImmediate } from "node:timers/promises";
+//#region src/internal/Attempt.ts
+/**
+* One frame of an attempt at a query or mutation: the committed state the
+* attempt started from, its caller's frame and its own pending writes. The
+* outermost frame belongs to the top-level function. Each nested mutation opens
+* a child frame, which merges into its caller's frame when it returns and is
+* dropped when it fails. Reads belong to the whole attempt and are never
+* dropped: a failed nested mutation's reads stay in the attempt.
+*
+* Each frame has its own lifetime. A frame takes reads and writes until it is
+* closed. A mutation's frame closes once its function has returned and no
+* syscall it started is still running, so a write a detached fiber makes after
+* the handler settled still lands in it, as on the binary. A nested mutation's
+* frame closes before it merges into its caller's, so no write reaches it after
+* its writes became its caller's.
+*
+* A frame belongs to one invocation, which alone writes to it, so a caller's
+* write made while its nested mutation is in flight stays the caller's.
+* `Kernel.apply` publishes the outermost frame's writes.
+*/
+var KernelAttempt = class KernelAttempt {
+	snapshot;
+	number;
+	parent;
+	overlay = /* @__PURE__ */ new Map();
+	life = {
+		running: 0,
+		started: 0,
+		open: true
+	};
+	allReads;
+	constructor(snapshot, number = 1, parent) {
+		this.snapshot = snapshot;
+		this.number = number;
+		this.parent = parent;
+		this.allReads = parent?.allReads ?? [];
+	}
+	get reads() {
+		return this.allReads;
+	}
+	get closed() {
+		return !this.life.open;
+	}
+	readDocument(componentPath, id) {
+		this.allReads.push({
+			kind: "document",
+			componentPath,
+			id
+		});
+	}
+	/**
+	* Record a read of an interval. The returned function advances how far the
+	* query examined it.
+	*/
+	readInterval(read) {
+		const interval = {
+			...read,
+			through: null
+		};
+		this.allReads.push(interval);
+		return (through) => {
+			interval.through = through;
+		};
+	}
+	/**
+	* A syscall began. `end` runs when it settles.
+	*/
+	begin() {
+		const life = this.life;
+		life.running++;
+		life.started++;
+		return () => {
+			life.running--;
+		};
+	}
+	/**
+	* Resolves once a whole turn of the event loop passes with no syscall of this
+	* frame running or started. A nested call is a syscall of its caller's frame
+	* until it has drained.
+	*/
+	drained() {
+		const before = this.life.started;
+		return setImmediate().then(() => this.life.running === 0 && this.life.started === before ? void 0 : this.drained());
+	}
+	close() {
+		this.life.open = false;
+	}
+	/**
+	* The pending writes this frame sees, from the outermost frame to this one.
+	*/
+	overlays() {
+		return this.parent === void 0 ? [this.overlay] : [...this.parent.overlays(), this.overlay];
+	}
+	get(componentPath, id) {
+		for (const overlay of this.overlays().toReversed()) {
+			const write = overlay.get(componentPath)?.get(id);
+			if (write !== void 0) return write;
+		}
+		return get(this.snapshot, componentPath, id)?.doc ?? null;
+	}
+	/**
+	* The table as this frame sees it, committed rows under every pending write
+	* from the outermost frame to this one.
+	*/
+	scan(componentPath, tableName) {
+		const ids = /* @__PURE__ */ new Set();
+		for (const row of rows(this.snapshot, componentPath, tableName)) ids.add(row.doc._id);
+		for (const overlay of this.overlays()) for (const id of overlay.get(componentPath)?.keys() ?? []) if (tableNameFromId(id) === tableName) ids.add(id);
+		const docs = [];
+		for (const id of ids) {
+			const doc = this.get(componentPath, id);
+			if (doc !== null) docs.push(doc);
+		}
+		return docs;
+	}
+	write(componentPath, id, doc) {
+		const writes = this.overlay.get(componentPath) ?? /* @__PURE__ */ new Map();
+		this.overlay.set(componentPath, writes);
+		writes.set(id, doc);
+	}
+	/**
+	* A nested mutation begins, in a frame of its own. Dropping a failed one is
+	* forgetting it.
+	*/
+	child() {
+		return new KernelAttempt(this.snapshot, this.number, this);
+	}
+	/**
+	* A nested mutation returned and its frame closed. Its writes become its
+	* caller's.
+	*/
+	merge() {
+		if (this.parent === void 0) throw new Error("The outermost frame of an attempt has no caller.");
+		if (this.life.open) throw new Error("A nested mutation's frame merges only once closed.");
+		for (const [componentPath, writes] of this.overlay) for (const [id, doc] of writes) this.parent.write(componentPath, id, doc);
+	}
+	/**
+	* The outermost frame's writes, for `Kernel.apply`.
+	*/
+	writes() {
+		return Array.from(this.overlay, ([componentPath, writes]) => Array.from(writes, ([id, doc]) => ({
+			componentPath,
+			id,
+			doc
+		}))).flat();
+	}
+};
+//#endregion
+export { KernelAttempt };
+
+//# sourceMappingURL=Attempt.js.map

package/dist/internal/Attempt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Attempt.js","names":["Kernel.get","Kernel.rows"],"sources":["../../src/internal/Attempt.ts"],"sourcesContent":["// oxlint-disable-next-line effecttsgo/node-builtin-import -- The drain waits a real turn of the event loop. Fake timers in a test replace the global `setImmediate`, not this one.\nimport { setImmediate } from \"node:timers/promises\";\nimport type { Attempt as AttemptNumber } from \"./Invocation.js\";\nimport * as Kernel from \"./Kernel.js\";\nimport type { DocumentId, StoredDocument } from \"./KernelValues.js\";\nimport { tableNameFromId } from \"./KernelValues.js\";\nimport type * as ReadSet from \"./ReadSet.js\";\n\n/**\n * Pending writes, keyed by component path, then document ID. `null` deletes.\n */\ntype Overlay = Map<string, Map<DocumentId, StoredDocument | null>>;\n\n/**\n * How long one frame takes syscalls: those it has running, those it has\n * started, and whether it still takes them.\n */\ninterface Life {\n  running: number;\n  started: number;\n  open: boolean;\n}\n\n/**\n * One frame of an attempt at a query or mutation: the committed state the\n * attempt started from, its caller's frame and its own pending writes. The\n * outermost frame belongs to the top-level function. Each nested mutation opens\n * a child frame, which merges into its caller's frame when it returns and is\n * dropped when it fails. Reads belong to the whole attempt and are never\n * dropped: a failed nested mutation's reads stay in the attempt.\n *\n * Each frame has its own lifetime. A frame takes reads and writes until it is\n * closed. A mutation's frame closes once its function has returned and no\n * syscall it started is still running, so a write a detached fiber makes after\n * the handler settled still lands in it, as on the binary. A nested mutation's\n * frame closes before it merges into its caller's, so no write reaches it after\n * its writes became its caller's.\n *\n * A frame belongs to one invocation, which alone writes to it, so a caller's\n * write made while its nested mutation is in flight stays the caller's.\n * `Kernel.apply` publishes the outermost frame's writes.\n */\nexport class KernelAttempt {\n  private readonly overlay: Overlay = new Map();\n  private readonly life: Life = { running: 0, started: 0, open: true };\n  private readonly allReads: Array<ReadSet.Read>;\n\n  constructor(\n    readonly snapshot: Kernel.State,\n    readonly number: AttemptNumber = 1,\n    private readonly parent?: KernelAttempt,\n  ) {\n    this.allReads = parent?.allReads ?? [];\n  }\n\n  get reads(): ReadonlyArray<ReadSet.Read> {\n    return this.allReads;\n  }\n\n  get closed(): boolean {\n    return !this.life.open;\n  }\n\n  readDocument(componentPath: string, id: DocumentId) {\n    this.allReads.push({ kind: \"document\", componentPath, id });\n  }\n\n  /**\n   * Record a read of an interval. The returned function advances how far the\n   * query examined it.\n   */\n  readInterval(\n    read: Omit<ReadSet.IntervalRead, \"through\">,\n  ): (through: ReadSet.Key | \"end\") => void {\n    const interval: ReadSet.IntervalRead = { ...read, through: null };\n    this.allReads.push(interval);\n    return (through) => {\n      interval.through = through;\n    };\n  }\n\n  /**\n   * A syscall began. `end` runs when it settles.\n   */\n  begin(): () => void {\n    const life = this.life;\n    life.running++;\n    life.started++;\n    return () => {\n      life.running--;\n    };\n  }\n\n  /**\n   * Resolves once a whole turn of the event loop passes with no syscall of this\n   * frame running or started. A nested call is a syscall of its caller's frame\n   * until it has drained.\n   */\n  drained(): Promise<void> {\n    const before = this.life.started;\n    return setImmediate().then(() =>\n      this.life.running === 0 && this.life.started === before\n        ? undefined\n        : this.drained(),\n    );\n  }\n\n  close() {\n    this.life.open = false;\n  }\n\n  /**\n   * The pending writes this frame sees, from the outermost frame to this one.\n   */\n  private overlays(): Array<Overlay> {\n    return this.parent === undefined\n      ? [this.overlay]\n      : [...this.parent.overlays(), this.overlay];\n  }\n\n  get(componentPath: string, id: DocumentId): StoredDocument | null {\n    for (const overlay of this.overlays().toReversed()) {\n      const write = overlay.get(componentPath)?.get(id);\n      if (write !== undefined) return write;\n    }\n    return Kernel.get(this.snapshot, componentPath, id)?.doc ?? null;\n  }\n\n  /**\n   * The table as this frame sees it, committed rows under every pending write\n   * from the outermost frame to this one.\n   */\n  scan(componentPath: string, tableName: string): Array<StoredDocument> {\n    const ids = new Set<DocumentId>();\n    for (const row of Kernel.rows(this.snapshot, componentPath, tableName))\n      ids.add(row.doc._id);\n    for (const overlay of this.overlays())\n      for (const id of overlay.get(componentPath)?.keys() ?? [])\n        if (tableNameFromId(id) === tableName) ids.add(id);\n    const docs: Array<StoredDocument> = [];\n    for (const id of ids) {\n      const doc = this.get(componentPath, id);\n      if (doc !== null) docs.push(doc);\n    }\n    return docs;\n  }\n\n  write(componentPath: string, id: DocumentId, doc: StoredDocument | null) {\n    const writes = this.overlay.get(componentPath) ?? new Map();\n    this.overlay.set(componentPath, writes);\n    writes.set(id, doc);\n  }\n\n  /**\n   * A nested mutation begins, in a frame of its own. Dropping a failed one is\n   * forgetting it.\n   */\n  child(): KernelAttempt {\n    return new KernelAttempt(this.snapshot, this.number, this);\n  }\n\n  /**\n   * A nested mutation returned and its frame closed. Its writes become its\n   * caller's.\n   */\n  merge() {\n    if (this.parent === undefined) {\n      throw new Error(\"The outermost frame of an attempt has no caller.\");\n    }\n    if (this.life.open) {\n      throw new Error(\"A nested mutation's frame merges only once closed.\");\n    }\n    for (const [componentPath, writes] of this.overlay)\n      for (const [id, doc] of writes) this.parent.write(componentPath, id, doc);\n  }\n\n  /**\n   * The outermost frame's writes, for `Kernel.apply`.\n   */\n  writes(): Array<Kernel.Write> {\n    return Array.from(this.overlay, ([componentPath, writes]) =>\n      Array.from(writes, ([id, doc]) => ({ componentPath, id, doc })),\n    ).flat();\n  }\n}\n"],"mappings":"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"}

package/dist/internal/ConvexTest.d.ts

@@ -0,0 +1,34 @@
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import * as Execution from "./Execution.js";
+import type * as Kernel from "./Kernel.js";
+type Modules = Record<string, () => Promise<any>>;
+/**
+ * What the kernel adds to convex-test's surface, typed. The shim itself returns
+ * `any`, as convex-test's callers expect.
+ */
+export interface KernelControls {
+    readonly query: (reference: any, args?: any) => Promise<any>;
+    readonly mutation: (reference: any, args?: any) => Promise<any>;
+    readonly action: (reference: any, args?: any) => Promise<any>;
+    readonly prepare: (reference: any, args?: any) => Promise<Execution.HeldAttempt>;
+    readonly apply: (id: string) => Promise<Execution.KernelApply>;
+    readonly held: () => ReadonlyArray<Execution.HeldAttempt>;
+}
+/**
+ * The test kernel under convex-test's `convexTest` signature. The fork's kernel
+ * lane aliases `convex-test` to this module, so every suite that calls
+ * `convexTest` directly, and `TestConfect` itself, runs on the kernel.
+ *
+ * Beyond convex-test, `prepare` runs a mutation to its commit point and holds
+ * it, and `apply` validates and publishes a held attempt. `mutation` applies
+ * each attempt it prepares at once and prepares the next on a conflict, up to
+ * attempt 5. `runtime` supplies the clock and commit timestamps.
+ */
+export declare function convexTest(schemaOrOptions?: SchemaDefinition<GenericSchema, boolean> | {
+    readonly schema?: SchemaDefinition<GenericSchema, boolean>;
+    readonly modules?: Modules;
+    readonly transactionLimits?: unknown;
+    readonly runtime?: Kernel.KernelRuntime;
+}, modules?: Modules): any;
+export {};
+//# sourceMappingURL=ConvexTest.d.ts.map

package/dist/internal/ConvexTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvexTest.d.ts","sourceRoot":"","sources":["../../src/internal/ConvexTest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEjB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAC;AAG3C,KAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAElD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAC7D,QAAQ,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAChE,QAAQ,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IAC9D,QAAQ,CAAC,OAAO,EAAE,CAChB,SAAS,EAAE,GAAG,EACd,IAAI,CAAC,EAAE,GAAG,KACP,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,aAAa,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;CAC3D;AAyCD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,eAAe,CAAC,EACZ,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,GACxC;IACE,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC3D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,aAAa,CAAC;CACzC,EACL,OAAO,CAAC,EAAE,OAAO,GAChB,GAAG,CA8BL"}

package/dist/internal/ConvexTest.js

@@ -0,0 +1,59 @@
+import { rowPending } from "./KernelRefusal.js";
+import { World, anonymous, withIdentity } from "./Execution.js";
+import { componentsGeneric } from "convex/server";
+//#region src/internal/ConvexTest.ts
+const isSchemaDefinition = (value) => value !== null && typeof value === "object" && "tables" in value && typeof value.tables === "object";
+const accessor = (world, caller) => ({
+	query: (reference, args) => world.query(caller, reference, args),
+	mutation: (reference, args) => world.mutation(caller, reference, args),
+	action: (reference, args) => world.action(caller, reference, args),
+	prepare: (reference, args) => world.prepare(caller, reference, args),
+	apply: (id) => world.apply(id),
+	held: () => world.held(),
+	run: (handler) => world.run(caller, "", handler),
+	runInComponent: (componentPath, handler) => world.run(caller, componentPath, handler),
+	withIdentity: (identity) => accessor(world, withIdentity(caller, identity)),
+	withRequestMetadata: (metadata) => accessor(world, {
+		...caller,
+		ip: metadata.ip ?? null,
+		userAgent: metadata.userAgent ?? null
+	}),
+	fetch: () => Promise.reject(rowPending("HTTP routes", 6)),
+	jwks: () => Promise.reject(rowPending("JWT verification", 6)),
+	finishInProgressScheduledFunctions: () => Promise.reject(rowPending("the scheduler", 5)),
+	finishAllScheduledFunctions: () => Promise.reject(rowPending("the scheduler", 5))
+});
+/**
+* The test kernel under convex-test's `convexTest` signature. The fork's kernel
+* lane aliases `convex-test` to this module, so every suite that calls
+* `convexTest` directly, and `TestConfect` itself, runs on the kernel.
+*
+* Beyond convex-test, `prepare` runs a mutation to its commit point and holds
+* it, and `apply` validates and publishes a held attempt. `mutation` applies
+* each attempt it prepares at once and prepares the next on a conflict, up to
+* attempt 5. `runtime` supplies the clock and commit timestamps.
+*/
+function convexTest(schemaOrOptions, modules) {
+	let schema;
+	let runtime;
+	if (isSchemaDefinition(schemaOrOptions)) schema = schemaOrOptions;
+	else if (schemaOrOptions !== void 0) {
+		if (schemaOrOptions.transactionLimits !== void 0) throw rowPending("transaction limits", 6);
+		schema = schemaOrOptions.schema;
+		modules = schemaOrOptions.modules;
+		runtime = schemaOrOptions.runtime;
+	}
+	if (modules === void 0) throw new Error("The test kernel needs the modules map: pass `import.meta.glob(...)` as the second argument.");
+	const world = new World(schema, modules, runtime);
+	return {
+		...accessor(world, anonymous),
+		registerComponent: (componentPath, componentSchema, componentModules) => {
+			world.register(componentPath, componentSchema, componentModules);
+			return componentsGeneric()[componentPath];
+		}
+	};
+}
+//#endregion
+export { convexTest };
+
+//# sourceMappingURL=ConvexTest.js.map

package/dist/internal/ConvexTest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvexTest.js","names":["Execution.withIdentity","KernelRefusal.rowPending","Execution.World","Execution.anonymous"],"sources":["../../src/internal/ConvexTest.ts"],"sourcesContent":["import type {\n  GenericSchema,\n  SchemaDefinition,\n  UserIdentity,\n} from \"convex/server\";\nimport { componentsGeneric } from \"convex/server\";\nimport * as Execution from \"./Execution.js\";\nimport type * as Kernel from \"./Kernel.js\";\nimport * as KernelRefusal from \"./KernelRefusal.js\";\n\ntype Modules = Record<string, () => Promise<any>>;\n\n/**\n * What the kernel adds to convex-test's surface, typed. The shim itself returns\n * `any`, as convex-test's callers expect.\n */\nexport interface KernelControls {\n  readonly query: (reference: any, args?: any) => Promise<any>;\n  readonly mutation: (reference: any, args?: any) => Promise<any>;\n  readonly action: (reference: any, args?: any) => Promise<any>;\n  readonly prepare: (\n    reference: any,\n    args?: any,\n  ) => Promise<Execution.HeldAttempt>;\n  readonly apply: (id: string) => Promise<Execution.KernelApply>;\n  readonly held: () => ReadonlyArray<Execution.HeldAttempt>;\n}\n\nconst isSchemaDefinition = (\n  value: unknown,\n): value is SchemaDefinition<GenericSchema, boolean> =>\n  value !== null &&\n  typeof value === \"object\" &&\n  \"tables\" in value &&\n  typeof (value as { tables: unknown }).tables === \"object\";\n\nconst accessor = (world: Execution.World, caller: Execution.Caller): any => ({\n  query: (reference: any, args?: any) => world.query(caller, reference, args),\n  mutation: (reference: any, args?: any) =>\n    world.mutation(caller, reference, args),\n  action: (reference: any, args?: any) => world.action(caller, reference, args),\n  prepare: (reference: any, args?: any) =>\n    world.prepare(caller, reference, args),\n  apply: (id: string) => world.apply(id),\n  held: () => world.held(),\n  run: (handler: (ctx: any) => any) => world.run(caller, \"\", handler),\n  runInComponent: (componentPath: string, handler: (ctx: any) => any) =>\n    world.run(caller, componentPath, handler),\n  withIdentity: (identity: Partial<UserIdentity>) =>\n    accessor(world, Execution.withIdentity(caller, identity)),\n  withRequestMetadata: (metadata: {\n    readonly ip?: string | null;\n    readonly userAgent?: string | null;\n  }) =>\n    accessor(world, {\n      ...caller,\n      ip: metadata.ip ?? null,\n      userAgent: metadata.userAgent ?? null,\n    }),\n  fetch: () => Promise.reject(KernelRefusal.rowPending(\"HTTP routes\", 6)),\n  jwks: () => Promise.reject(KernelRefusal.rowPending(\"JWT verification\", 6)),\n  finishInProgressScheduledFunctions: () =>\n    Promise.reject(KernelRefusal.rowPending(\"the scheduler\", 5)),\n  finishAllScheduledFunctions: () =>\n    Promise.reject(KernelRefusal.rowPending(\"the scheduler\", 5)),\n});\n\n/**\n * The test kernel under convex-test's `convexTest` signature. The fork's kernel\n * lane aliases `convex-test` to this module, so every suite that calls\n * `convexTest` directly, and `TestConfect` itself, runs on the kernel.\n *\n * Beyond convex-test, `prepare` runs a mutation to its commit point and holds\n * it, and `apply` validates and publishes a held attempt. `mutation` applies\n * each attempt it prepares at once and prepares the next on a conflict, up to\n * attempt 5. `runtime` supplies the clock and commit timestamps.\n */\nexport function convexTest(\n  schemaOrOptions?:\n    | SchemaDefinition<GenericSchema, boolean>\n    | {\n        readonly schema?: SchemaDefinition<GenericSchema, boolean>;\n        readonly modules?: Modules;\n        readonly transactionLimits?: unknown;\n        readonly runtime?: Kernel.KernelRuntime;\n      },\n  modules?: Modules,\n): any {\n  let schema: SchemaDefinition<GenericSchema, boolean> | undefined;\n  let runtime: Kernel.KernelRuntime | undefined;\n  if (isSchemaDefinition(schemaOrOptions)) {\n    schema = schemaOrOptions;\n  } else if (schemaOrOptions !== undefined) {\n    if (schemaOrOptions.transactionLimits !== undefined) {\n      throw KernelRefusal.rowPending(\"transaction limits\", 6);\n    }\n    schema = schemaOrOptions.schema;\n    modules = schemaOrOptions.modules;\n    runtime = schemaOrOptions.runtime;\n  }\n  if (modules === undefined) {\n    throw new Error(\n      \"The test kernel needs the modules map: pass `import.meta.glob(...)` as the second argument.\",\n    );\n  }\n  const world = new Execution.World(schema, modules, runtime);\n  return {\n    ...accessor(world, Execution.anonymous),\n    registerComponent: (\n      componentPath: string,\n      componentSchema: SchemaDefinition<GenericSchema, boolean>,\n      componentModules: Modules,\n    ) => {\n      world.register(componentPath, componentSchema, componentModules);\n      return (componentsGeneric() as any)[componentPath];\n    },\n  };\n}\n"],"mappings":";;;;AA4BA,MAAM,sBACJ,UAEA,UAAU,QACV,OAAO,UAAU,YACjB,YAAY,SACZ,OAAQ,MAA8B,WAAW;AAEnD,MAAM,YAAY,OAAwB,YAAmC;CAC3E,QAAQ,WAAgB,SAAe,MAAM,MAAM,QAAQ,WAAW,IAAI;CAC1E,WAAW,WAAgB,SACzB,MAAM,SAAS,QAAQ,WAAW,IAAI;CACxC,SAAS,WAAgB,SAAe,MAAM,OAAO,QAAQ,WAAW,IAAI;CAC5E,UAAU,WAAgB,SACxB,MAAM,QAAQ,QAAQ,WAAW,IAAI;CACvC,QAAQ,OAAe,MAAM,MAAM,EAAE;CACrC,YAAY,MAAM,KAAK;CACvB,MAAM,YAA+B,MAAM,IAAI,QAAQ,IAAI,OAAO;CAClE,iBAAiB,eAAuB,YACtC,MAAM,IAAI,QAAQ,eAAe,OAAO;CAC1C,eAAe,aACb,SAAS,OAAOA,aAAuB,QAAQ,QAAQ,CAAC;CAC1D,sBAAsB,aAIpB,SAAS,OAAO;EACd,GAAG;EACH,IAAI,SAAS,MAAM;EACnB,WAAW,SAAS,aAAa;CACnC,CAAC;CACH,aAAa,QAAQ,OAAOC,WAAyB,eAAe,CAAC,CAAC;CACtE,YAAY,QAAQ,OAAOA,WAAyB,oBAAoB,CAAC,CAAC;CAC1E,0CACE,QAAQ,OAAOA,WAAyB,iBAAiB,CAAC,CAAC;CAC7D,mCACE,QAAQ,OAAOA,WAAyB,iBAAiB,CAAC,CAAC;AAC/D;;;;;;;;;;;AAYA,SAAgB,WACd,iBAQA,SACK;CACL,IAAI;CACJ,IAAI;CACJ,IAAI,mBAAmB,eAAe,GACpC,SAAS;MACJ,IAAI,oBAAoB,KAAA,GAAW;EACxC,IAAI,gBAAgB,sBAAsB,KAAA,GACxC,MAAMA,WAAyB,sBAAsB,CAAC;EAExD,SAAS,gBAAgB;EACzB,UAAU,gBAAgB;EAC1B,UAAU,gBAAgB;CAC5B;CACA,IAAI,YAAY,KAAA,GACd,MAAM,IAAI,MACR,6FACF;CAEF,MAAM,QAAQ,IAAIC,MAAgB,QAAQ,SAAS,OAAO;CAC1D,OAAO;EACL,GAAG,SAAS,OAAOC,SAAmB;EACtC,oBACE,eACA,iBACA,qBACG;GACH,MAAM,SAAS,eAAe,iBAAiB,gBAAgB;GAC/D,OAAQ,kBAAkB,CAAC,CAAS;EACtC;CACF;AACF"}

package/dist/internal/Execution.d.ts

@@ -0,0 +1,167 @@
+import { type GenericSchema, type SchemaDefinition, type UserIdentity } from "convex/server";
+import { type Value } from "convex/values";
+import * as Invocation from "./Invocation.js";
+import * as Kernel from "./Kernel.js";
+import * as KernelQuery from "./KernelQuery.js";
+import * as KernelRefusal from "./KernelRefusal.js";
+import type * as ReadSet from "./ReadSet.js";
+type Modules = Record<string, () => Promise<any>>;
+/**
+ * One registered component: its schema and its function modules, each loaded
+ * once when the world opens.
+ */
+interface Component {
+    readonly path: string;
+    readonly schema: KernelQuery.KernelSchema | null;
+    readonly loaders: ReadonlyMap<string, () => Promise<any>>;
+    readonly loaded: Map<string, any>;
+}
+/**
+ * Who is calling: the identity and the request attributes a test accessor set.
+ */
+export interface Caller {
+    readonly identity: UserIdentity | null;
+    readonly token: string | null;
+    readonly ip: string | null;
+    readonly userAgent: string | null;
+}
+export declare const anonymous: Caller;
+export declare const withIdentity: (caller: Caller, identity: Partial<UserIdentity>) => Caller;
+/**
+ * How a prepared attempt's function ended.
+ */
+export type Outcome = {
+    readonly _tag: "returned";
+    readonly value: Value;
+} | {
+    readonly _tag: "failed";
+    readonly error: unknown;
+};
+/**
+ * A mutation attempt run to its commit point and held until `apply`.
+ */
+export interface HeldAttempt {
+    readonly id: string;
+    readonly request: string;
+    readonly number: Invocation.Attempt;
+    readonly snapshot: Kernel.Version;
+    readonly reads: ReadonlyArray<ReadSet.Read>;
+    readonly outcome: Outcome;
+}
+/**
+ * What `apply` did with a held attempt. A conflict discards the attempt and
+ * holds exactly one next attempt, run against the latest commit. Nothing is
+ * retried until that one is applied in turn.
+ */
+export type KernelApply = {
+    readonly kind: "applied";
+    readonly version: Kernel.Version;
+    readonly commitTs: bigint;
+    readonly result: Value;
+} | {
+    readonly kind: "conflict";
+    readonly next: HeldAttempt;
+} | {
+    readonly kind: "exhausted";
+    readonly error: KernelRefusal.OptimisticConcurrencyControlFailure;
+} | {
+    readonly kind: "refused";
+    readonly tag: string;
+    readonly error: unknown;
+};
+/**
+ * A test backend: its registered components and the kernel state they share.
+ */
+export declare class World {
+    private readonly runtime;
+    readonly components: Map<string, Component>;
+    state: Kernel.State;
+    private opened;
+    private nextDocId;
+    private lastCreationTime;
+    private nextQueryId;
+    private readonly queries;
+    private readonly holding;
+    private nextAttemptId;
+    constructor(schema: SchemaDefinition<GenericSchema, boolean> | null | undefined, modules: Modules, runtime?: Kernel.KernelRuntime);
+    register(componentPath: string, schema: SchemaDefinition<GenericSchema, boolean>, modules: Modules): void;
+    /**
+     * Load every registered module of every component, once, before any function
+     * runs.
+     */
+    open(): Promise<void>;
+    private component;
+    private resolve;
+    query(caller: Caller, reference: any, args: any): Promise<any>;
+    mutation(caller: Caller, reference: any, args: any): Promise<any>;
+    action(caller: Caller, reference: any, args: any): Promise<any>;
+    run(caller: Caller, componentPath: string, handler: (ctx: any) => any): Promise<any>;
+    /**
+     * Run a mutation to its commit point and hold it as attempt 1.
+     */
+    prepare(caller: Caller, reference: any, args: any): Promise<HeldAttempt>;
+    apply(id: string): Promise<KernelApply>;
+    /**
+     * The held attempts, oldest first.
+     */
+    held(): ReadonlyArray<HeldAttempt>;
+    private queryAt;
+    private mutationAt;
+    private actionAt;
+    private execution;
+    private runQuery;
+    private invokeMutation;
+    private runMutation;
+    /**
+     * Run one attempt of a top-level mutation against the latest commit, then
+     * hold it. The commit point is once the function has returned and every
+     * syscall it started has settled. A test invocation bound when the mutation
+     * was first called reaches each attempt's handler with that attempt's
+     * number.
+     */
+    private prepareMutation;
+    /**
+     * Validate a held attempt's reads against every commit since its snapshot,
+     * then publish its writes or prepare its next attempt. An attempt that wrote
+     * nothing publishes nothing and has nothing to validate. It answers its
+     * snapshot's version and commit timestamp.
+     */
+    private applyHeld;
+    /**
+     * Apply until the mutation publishes, is refused or is exhausted, as the
+     * binary retries a mutation that conflicts.
+     */
+    private publish;
+    private runAction;
+    private schema;
+    private view;
+    private generateId;
+    syscall(op: string, jsonArgs: string): string;
+    /**
+     * The binary queues a query's or mutation's async syscalls and runs them one
+     * at a time, oldest first (`start_async_syscall` and `run_inner` in
+     * `crates/isolate/src/environment/udf/mod.rs`, 1.49). A write and a nested
+     * call never share a batch (`AsyncSyscallBatch::can_push` in
+     * `async_syscall.rs`), and a nested call holds the queue until it has
+     * committed or rolled back its subtransaction (`run_udf` in
+     * `async_syscall.rs`). So a caller's write made after its nested call runs
+     * after that call, and a nested mutation sees every write made before it. An
+     * action's calls run side by side.
+     */
+    asyncSyscall(op: string, jsonArgs: string): Promise<string>;
+    private dispatchAsync;
+    jsSyscall(op: string): Promise<never>;
+    private get;
+    private insert;
+    private existing;
+    private fields;
+    private patch;
+    private replace;
+    private remove;
+}
+/**
+ * Whether `globalThis.Convex` is the kernel's, so no other backend answered.
+ */
+export declare const ownsConvexGlobal: () => boolean;
+export {};
+//# sourceMappingURL=Execution.d.ts.map

package/dist/internal/Execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Execution.d.ts","sourceRoot":"","sources":["../../src/internal/Execution.ts"],"names":[],"mappings":"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"}