@gaganref/confect-test 10.3.1-fork.9 → 10.3.1-fork.90

package/dist/internal/Clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Clock.js","names":["Globals.host"],"sources":["../../src/internal/Clock.ts"],"sourcesContent":["/**\n * Convex pins `Date` inside a query or mutation to the time it started, and its\n * scheduler reads `Date.now()` for `runAfter`. The kernel wraps the realm's\n * `Date` so it answers a kernel invocation's time inside one and the host's\n * everywhere else. It sets no host timer.\n */\n\nimport * as Globals from \"./Globals.js\";\n\ntype DateConstructor = typeof globalThis.Date;\n\ninterface State {\n  /**\n   * Each wrapper the kernel installed, and the `Date` it wraps.\n   */\n  readonly bases: WeakMap<DateConstructor, DateConstructor>;\n  readonly pinned: () => number | undefined;\n  /**\n   * Whether a kernel invocation is running, without reading its time.\n   */\n  readonly inside: () => boolean;\n}\n\nconst key = Symbol.for(\"@confect/test/Clock\");\n\ntype Global = { [key]?: State; Date: DateConstructor };\n\nconst wrap = (\n  base: DateConstructor,\n  pinned: () => number | undefined,\n): DateConstructor => {\n  const proxy: DateConstructor = new Proxy(base, {\n    get: (target, property) =>\n      property === \"now\"\n        ? () => pinned() ?? target.now()\n        : Reflect.get(target, property, target),\n    construct: (target, args, newTarget) => {\n      const at = args.length === 0 ? pinned() : undefined;\n      return Reflect.construct(\n        target,\n        at === undefined ? args : [at],\n        newTarget === proxy ? target : newTarget,\n      );\n    },\n    apply: (target, self, args) => {\n      const at = pinned();\n      return at === undefined\n        ? Reflect.apply(target, self, args)\n        : new target(at).toString();\n    },\n  });\n  return proxy;\n};\n\n/**\n * Wrap the realm's current `Date`, unless the kernel already did. `pinned`\n * answers the running invocation's time, or `undefined` outside one, and\n * `inside` says whether one is running. The first install's callbacks answer\n * for every later one, as with `globalThis.Convex`. A test that fakes `Date`\n * replaces the wrapper while the fake is installed, and the next install wraps\n * the `Date` the test restores.\n */\nexport const install = (\n  pinned: () => number | undefined,\n  inside: () => boolean,\n) => {\n  const global = globalThis as Global;\n  const state = (global[key] ??= { bases: new WeakMap(), pinned, inside });\n  const current = global.Date;\n  if (state.bases.has(current)) return;\n  const wrapper = wrap(current, () => state.pinned());\n  state.bases.set(wrapper, current);\n  global.Date = wrapper;\n};\n\n/**\n * Whether `date` is the kernel's wrapper inside a running kernel invocation, so\n * it already answers that invocation's time on the kernel's clock.\n */\nexport const answersInvocation = (date: DateConstructor): boolean => {\n  const state = (globalThis as Global)[key];\n  return state !== undefined && state.bases.has(date) && state.inside();\n};\n\n/**\n * The host's time in milliseconds, never a kernel invocation's: the real clock,\n * or a test's fake one while it is installed. It reads the test environment's\n * `Date`, never the copy a bound handler pinned.\n */\nexport const hostNow = (): number =>\n  Globals.host(() => {\n    const global = globalThis as Global;\n    const current = global.Date;\n    return (global[key]?.bases.get(current) ?? current).now();\n  });\n"],"mappings":";;;;;;;;AAuBA,MAAM,MAAM,OAAO,IAAI,qBAAqB;AAI5C,MAAM,QACJ,MACA,WACoB;CACpB,MAAM,QAAyB,IAAI,MAAM,MAAM;EAC7C,MAAM,QAAQ,aACZ,aAAa,cACH,OAAO,KAAK,OAAO,IAAI,IAC7B,QAAQ,IAAI,QAAQ,UAAU,MAAM;EAC1C,YAAY,QAAQ,MAAM,cAAc;GACtC,MAAM,KAAK,KAAK,WAAW,IAAI,OAAO,IAAI,KAAA;GAC1C,OAAO,QAAQ,UACb,QACA,OAAO,KAAA,IAAY,OAAO,CAAC,EAAE,GAC7B,cAAc,QAAQ,SAAS,SACjC;EACF;EACA,QAAQ,QAAQ,MAAM,SAAS;GAC7B,MAAM,KAAK,OAAO;GAClB,OAAO,OAAO,KAAA,IACV,QAAQ,MAAM,QAAQ,MAAM,IAAI,IAChC,IAAI,OAAO,EAAE,CAAC,CAAC,SAAS;EAC9B;CACF,CAAC;CACD,OAAO;AACT;;;;;;;;;AAUA,MAAa,WACX,QACA,WACG;CACH,MAAM,SAAS;CACf,MAAM,QAAS,OAAO,SAAS;EAAE,uBAAO,IAAI,QAAQ;EAAG;EAAQ;CAAO;CACtE,MAAM,UAAU,OAAO;CACvB,IAAI,MAAM,MAAM,IAAI,OAAO,GAAG;CAC9B,MAAM,UAAU,KAAK,eAAe,MAAM,OAAO,CAAC;CAClD,MAAM,MAAM,IAAI,SAAS,OAAO;CAChC,OAAO,OAAO;AAChB;;;;;AAMA,MAAa,qBAAqB,SAAmC;CACnE,MAAM,QAAS,WAAsB;CACrC,OAAO,UAAU,KAAA,KAAa,MAAM,MAAM,IAAI,IAAI,KAAK,MAAM,OAAO;AACtE;;;;;;AAOA,MAAa,gBACXA,WAAmB;CACjB,MAAM,SAAS;CACf,MAAM,UAAU,OAAO;CACvB,QAAQ,OAAO,IAAI,EAAE,MAAM,IAAI,OAAO,KAAK,QAAA,CAAS,IAAI;AAC1D,CAAC"}

package/dist/internal/ConvexTest.d.ts

@@ -0,0 +1,66 @@
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import * as Execution from "./Execution.js";
+import type * as Kernel from "./Kernel.js";
+import type * as Scheduling from "./Scheduling.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>;
+    /**
+     * Move the kernel's clock forward, running each job due on the way at its
+     * deadline.
+     */
+    readonly advance: (ms: number) => Promise<void>;
+    /**
+     * The pending jobs, earliest deadline first.
+     */
+    readonly jobs: () => ReadonlyArray<Scheduling.Job>;
+    /**
+     * Run the jobs due now. No future deadline is crossed.
+     */
+    readonly finishInProgressScheduledFunctions: () => Promise<void>;
+    /**
+     * Run jobs at their deadlines until only standing jobs remain, or fail with
+     * `DrainBudgetExceeded` after `maxIterations` jobs. The kernel keeps its own
+     * clock, so it never calls `advanceTimers`.
+     */
+    readonly finishAllScheduledFunctions: (advanceTimers?: () => void, maxIterations?: number) => Promise<void>;
+}
+/**
+ * How a kit registers a component beyond its schema and modules.
+ */
+export interface RegisterOptions {
+    /**
+     * The component's functions, as `module:export`, that schedule their own next
+     * run, such as the crons component's `public:rescheduler`. A job that runs
+     * one, or that one schedules, is never drain work.
+     */
+    readonly standing?: ReadonlyArray<string>;
+}
+/**
+ * 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. Scheduled
+ * functions run on the kernel's clock, never on a host timer.
+ */
+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;AAE3C,OAAO,KAAK,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAEnD,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;IAC1D;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,aAAa,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IACnD;;OAEG;IACH,QAAQ,CAAC,kCAAkC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE;;;;OAIG;IACH,QAAQ,CAAC,2BAA2B,EAAE,CACpC,aAAa,CAAC,EAAE,MAAM,IAAI,EAC1B,aAAa,CAAC,EAAE,MAAM,KACnB,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC3C;AA4CD;;;;;;;;;;GAUG;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,CAoCL"}

package/dist/internal/ConvexTest.js

@@ -0,0 +1,62 @@
+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)),
+	advance: (ms) => world.advance(ms),
+	jobs: () => world.jobs(),
+	finishInProgressScheduledFunctions: () => world.advance(0),
+	finishAllScheduledFunctions: (_advanceTimers, maxIterations) => world.drain(maxIterations)
+});
+/**
+* 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. Scheduled
+* functions run on the kernel's clock, never on a host timer.
+*/
+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, options) => {
+			world.register(componentPath, componentSchema, componentModules, options?.standing);
+			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\";\nimport type * as Scheduling from \"./Scheduling.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   * Move the kernel's clock forward, running each job due on the way at its\n   * deadline.\n   */\n  readonly advance: (ms: number) => Promise<void>;\n  /**\n   * The pending jobs, earliest deadline first.\n   */\n  readonly jobs: () => ReadonlyArray<Scheduling.Job>;\n  /**\n   * Run the jobs due now. No future deadline is crossed.\n   */\n  readonly finishInProgressScheduledFunctions: () => Promise<void>;\n  /**\n   * Run jobs at their deadlines until only standing jobs remain, or fail with\n   * `DrainBudgetExceeded` after `maxIterations` jobs. The kernel keeps its own\n   * clock, so it never calls `advanceTimers`.\n   */\n  readonly finishAllScheduledFunctions: (\n    advanceTimers?: () => void,\n    maxIterations?: number,\n  ) => Promise<void>;\n}\n\n/**\n * How a kit registers a component beyond its schema and modules.\n */\nexport interface RegisterOptions {\n  /**\n   * The component's functions, as `module:export`, that schedule their own next\n   * run, such as the crons component's `public:rescheduler`. A job that runs\n   * one, or that one schedules, is never drain work.\n   */\n  readonly standing?: ReadonlyArray<string>;\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  advance: (ms: number) => world.advance(ms),\n  jobs: () => world.jobs(),\n  finishInProgressScheduledFunctions: () => world.advance(0),\n  finishAllScheduledFunctions: (\n    _advanceTimers?: () => void,\n    maxIterations?: number,\n  ) => world.drain(maxIterations),\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. Scheduled\n * functions run on the kernel's clock, never on a host timer.\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      options?: RegisterOptions,\n    ) => {\n      world.register(\n        componentPath,\n        componentSchema,\n        componentModules,\n        options?.standing,\n      );\n      return (componentsGeneric() as any)[componentPath];\n    },\n  };\n}\n"],"mappings":";;;;AA+DA,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,UAAU,OAAe,MAAM,QAAQ,EAAE;CACzC,YAAY,MAAM,KAAK;CACvB,0CAA0C,MAAM,QAAQ,CAAC;CACzD,8BACE,gBACA,kBACG,MAAM,MAAM,aAAa;AAChC;;;;;;;;;;;;AAaA,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,kBACA,YACG;GACH,MAAM,SACJ,eACA,iBACA,kBACA,SAAS,QACX;GACA,OAAQ,kBAAkB,CAAC,CAAS;EACtC;CACF;AACF"}

package/dist/internal/Execution.d.ts

@@ -0,0 +1,247 @@
+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";
+import * as Scheduling from "./Scheduling.js";
+type Modules = Record<string, () => Promise<any>>;
+/**
+ * One registered component: its schema, its function modules, each loaded once
+ * when the world opens, and its standing sources.
+ */
+interface Component {
+    readonly path: string;
+    readonly schema: KernelQuery.KernelSchema | null;
+    readonly loaders: ReadonlyMap<string, () => Promise<any>>;
+    readonly loaded: Map<string, any>;
+    /**
+     * The functions, as `module:export`, that schedule their own next run. A job
+     * that runs one, or that one schedules, is never drain work.
+     */
+    readonly standing: ReadonlySet<string>;
+}
+/**
+ * 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;
+    /**
+     * The latest deadline time has been advanced to. The clock never reads
+     * earlier.
+     */
+    private floor;
+    private readonly targets;
+    constructor(schema: SchemaDefinition<GenericSchema, boolean> | null | undefined, modules: Modules, runtime?: Kernel.KernelRuntime);
+    register(componentPath: string, schema: SchemaDefinition<GenericSchema, boolean>, modules: Modules, standing?: ReadonlyArray<string>): void;
+    /**
+     * Load every registered module of every component, once, before any function
+     * runs, then check that each standing source names an exported function.
+     */
+    open(): Promise<void>;
+    /**
+     * Refuse a standing source no module of its component exports.
+     */
+    private checkStanding;
+    /**
+     * The kernel's time: the runtime's, never earlier than the latest deadline
+     * time was advanced to.
+     */
+    now(): number;
+    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>;
+    /**
+     * The committed pending jobs, earliest deadline first.
+     */
+    jobs(): ReadonlyArray<Scheduling.Job>;
+    /**
+     * Move the clock forward `ms`, running every job whose deadline falls on the
+     * way, in deadline order, each starting at its deadline. Jobs those jobs
+     * schedule inside the window run too. `advance(0)` runs what is due now and
+     * crosses no future deadline.
+     */
+    advance(ms: number, budget?: number): Promise<void>;
+    /**
+     * Run jobs, earliest deadline first and each at its deadline, until only
+     * standing jobs are pending. Every job run counts against `budget`.
+     */
+    drain(budget?: number): Promise<void>;
+    /**
+     * Run the first of `select(pending)` until it is empty, moving the clock to
+     * each job's deadline as it starts.
+     */
+    private walk;
+    private raiseFloor;
+    /**
+     * Run one pending job as its own request, moving its row through in progress
+     * to success or failed. `walk` picks it from the committed pending jobs and
+     * starts it in the same turn, so no cancel can land in between. The job runs
+     * as a fresh invocation of the world that scheduled it, whatever invocation
+     * the drain itself runs under.
+     */
+    private runJob;
+    /**
+     * Write through a fresh attempt and publish it at once, as the scheduler does
+     * for an action's schedule and a job's state. Nothing runs between the
+     * snapshot and the commit, so no other commit can conflict with it.
+     */
+    private commitNow;
+    /**
+     * Publish `writes` as the next commit, at the runtime's timestamp for it. No
+     * writes publish nothing and ask the runtime for no timestamp, which answers
+     * the latest commit's.
+     */
+    private publishWrites;
+    /**
+     * Write a pending job into `attempt`, so the job exists only once that
+     * attempt publishes. A job that a standing function schedules, or that runs
+     * one, is standing.
+     */
+    private scheduleJob;
+    /**
+     * Cancel a job that has not finished. A finished job stays as it ended.
+     */
+    private cancelJob;
+    private isStanding;
+    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;
+    /**
+     * A new document's creation time: `at`, or just past the latest one, so no
+     * two documents share one.
+     */
+    private creationTime;
+    private existing;
+    private fields;
+    private patch;
+    private replace;
+    private remove;
+}
+/**
+ * Whether `globalThis.Convex` is the kernel's, and no other backend installed
+ * one behind it.
+ */
+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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"}