okengine 0.19.9 → 0.21.0

package/src/client/transport.ts

@@ -83,15 +83,7 @@ export function createTransport(base: string, opts: ClientOptions = {}): Transpo
         } catch (err) {
           const transient = isTransient(err);
           if (!transient || attempt >= retries) {
-            return {
-              data: null,
-              error: {
-                code: "TransportError",
-                data: {
-                  message: err instanceof Error ? err.message : String(err),
-                },
-              },
-            };
+            return transportEnvelope(err instanceof Error ? err.message : String(err));
           }
           await sleep(delay);
           delay *= backoff;
@@ -102,6 +94,25 @@ export function createTransport(base: string, opts: ClientOptions = {}): Transpo
   };
 }
 
+/**
+ * Build a {@link ClientEnvelope} for a transport / protocol failure.
+ *
+ * Guarantees `error.message === error.data.message`.
+ *
+ * @param message - Human-readable failure text
+ * @param status - Optional HTTP status
+ */
+function transportEnvelope(message: string, status?: number): ClientEnvelope {
+  return {
+    data: null,
+    error: {
+      code: "TransportError",
+      message,
+      data: status !== undefined ? { message, status } : { message },
+    },
+  };
+}
+
 function normalizeCallOpts(
   headersOrOpts: ClientHeaders | TransportCallOptions | undefined,
 ): TransportCallOptions {
@@ -277,29 +288,14 @@ async function decode(res: Response): Promise<ClientEnvelope> {
   const text = await res.text();
   if (!text) {
     if (res.ok) return { data: undefined, error: null };
-    return {
-      data: null,
-      error: {
-        code: "TransportError",
-        data: { message: `HTTP ${res.status}`, status: res.status },
-      },
-    };
+    return transportEnvelope(`HTTP ${res.status}`, res.status);
   }
 
   let json: unknown;
   try {
     json = JSON.parse(text);
   } catch {
-    return {
-      data: null,
-      error: {
-        code: "TransportError",
-        data: {
-          message: `Invalid JSON (${res.status})`,
-          status: res.status,
-        },
-      },
-    };
+    return transportEnvelope(`Invalid JSON (${res.status})`, res.status);
   }
 
   if (json !== null && typeof json === "object" && "data" in json && "error" in json) {
@@ -310,26 +306,14 @@ async function decode(res: Response): Promise<ClientEnvelope> {
     return { data: json, error: null };
   }
 
-  return {
-    data: null,
-    error: {
-      code: "TransportError",
-      data: { message: `HTTP ${res.status}`, status: res.status },
-    },
-  };
+  return transportEnvelope(`HTTP ${res.status}`, res.status);
 }
 
 async function decodeBinary(res: Response, mode: "blob" | "arrayBuffer"): Promise<ClientEnvelope> {
   if (!res.ok) {
     const structured = await decodeIfEnvelopeClone(res);
     if (structured) return structured;
-    return {
-      data: null,
-      error: {
-        code: "TransportError",
-        data: { message: `HTTP ${res.status}`, status: res.status },
-      },
-    };
+    return transportEnvelope(`HTTP ${res.status}`, res.status);
   }
   const data = mode === "blob" ? await res.blob() : await res.arrayBuffer();
   return { data, error: null };

package/src/client/types.ts

@@ -5,6 +5,8 @@
  * Local / separate-repo: augment {@link Register} so `createClient(url)` needs no import.
  */
 
+import type { BuiltinErrorMap } from "../kernel/builtin-errors.ts";
+
 /**
  * One flow's client contract. `in` / `out` / `errors` are phantom (type-only).
  *
@@ -125,7 +127,8 @@ export interface TransportError {
     readonly message: string;
     readonly status?: number;
   };
-  readonly message?: string;
+  /** Same string as {@link TransportError.data.message}. */
+  readonly message: string;
 }
 
 /** Next / previous list request — TanStack `pageParam` / URL bag. */
@@ -431,12 +434,20 @@ type ContractIn<C> = "in" extends keyof C
 /** Pull output from a contract shape. */
 type ContractOut<C> = "out" extends keyof C ? NonNullable<C["out"]> : unknown;
 
-/** Pull error map from a contract shape. */
+/**
+ * Pull error map from a contract shape. Built-in codes are always on; declared
+ * keys win. A missing `errors` bag (phantom `Record<string, unknown>`) is
+ * treated as unspecified — not as an index signature that wipes the builtins.
+ */
 type ContractErrors<C> = "errors" extends keyof C
-  ? NonNullable<C["errors"]> extends Record<string, unknown>
-    ? NonNullable<C["errors"]>
-    : Record<string, never>
-  : Record<string, never>;
+  ? NonNullable<C["errors"]> extends infer E
+    ? E extends Record<string, unknown>
+      ? string extends keyof E
+        ? BuiltinErrorMap
+        : Omit<BuiltinErrorMap, keyof E> & E
+      : BuiltinErrorMap
+    : BuiltinErrorMap
+  : BuiltinErrorMap;
 
 /**
  * Typed client proxy derived from a route map.

package/src/client-react/browser.test.ts

@@ -0,0 +1,23 @@
+/**
+ * Browser graph for `okengine/client-react` — Vite SPAs import `Can` from the
+ * barrel, which also loads `useLiveQuery`.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { join } from "node:path";
+
+describe("client-react browser graph", () => {
+  test("browser bundle does not pull node:async_hooks", async () => {
+    const result = await Bun.build({
+      entrypoints: [join(import.meta.dir, "index.ts")],
+      target: "browser",
+      format: "esm",
+      minify: false,
+      external: ["react", "react/jsx-runtime", "react-dom"],
+    });
+    expect(result.success).toBe(true);
+    const text = (await Promise.all(result.outputs.map((output) => output.text()))).join("\n");
+    expect(text).not.toContain("node:async_hooks");
+    expect(text).not.toContain("realtime-bind");
+  });
+});

package/src/client-react/live-resource.ts

@@ -219,8 +219,12 @@ function sseError(status: number, body: string): Error {
     try {
       const json: unknown = JSON.parse(body);
       if (json !== null && typeof json === "object" && "error" in json) {
-        const err = (json as { error?: { code?: string; data?: { message?: string } } }).error;
-        message = err?.data?.message ?? err?.code ?? message;
+        const err = (
+          json as {
+            error?: { code?: string; message?: string; data?: { message?: string } };
+          }
+        ).error;
+        message = err?.message ?? err?.data?.message ?? err?.code ?? message;
       }
     } catch {
       message = body.slice(0, 200);

package/src/client-react/use-live-query.ts

@@ -23,7 +23,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { transportOf } from "../client/create.ts";
 import type { ClientCall, ClientResult } from "../client/types.ts";
-import { MUTATION_ID_HEADER } from "../kernel/realtime-bind.ts";
+import { MUTATION_ID_HEADER } from "../kernel/mutation-id.ts";
 import {
   applyOptimisticPatch,
   clearOptimisticPatch,

package/src/compiler/flow-path.test.ts

@@ -67,6 +67,7 @@ describe("pathFromFlowFile", () => {
     expect(pathFromFlowFile("notes/list.test.ts")).toBeUndefined();
     expect(pathFromFlowFile("notes/_lib/util.ts")).toBeUndefined();
     expect(pathFromFlowFile("src/flows/generated.ts")).toBeUndefined();
+    expect(pathFromFlowFile("src/flows/index.ts")).toBeUndefined();
   });
 
   test("accepts a source path under src/flows/", () => {

package/src/compiler/flow-path.ts

@@ -17,7 +17,7 @@ export const RESERVED_LEAVES: ReadonlySet<string> = new Set([
   "route",
 ]);
 
-/** Filenames that are never routes. */
+/** Filenames that are never HTTP routes (`signals.ts` may still export `on()` consumers). */
 export const SKIP_FLOW_FILENAMES: ReadonlySet<string> = new Set([
   "generated.ts",
   "shapes.ts",

package/src/compiler/generate-adopt.test.ts

@@ -69,7 +69,7 @@ describe("generateAdoptBarrel", () => {
         'export const create = "notes-flow";\n',
       );
       const result = await generateAdoptBarrel({ rootDir: root });
-      const generatedPath = join(root, "src/flows/generated.ts");
+      const generatedPath = join(root, "src/flows/index.ts");
       await mkdir(join(root, "node_modules/okengine"), { recursive: true });
       await writeFile(
         join(root, "node_modules/okengine/package.json"),
@@ -173,12 +173,66 @@ describe("generateAdoptBarrel", () => {
     }
   });
 
+  test("writeAdoptBarrel unlinks leftover generated.ts", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-prev-"));
+    try {
+      await mkdir(join(root, "src/flows"), { recursive: true });
+      const prev = join(root, "src/flows/generated.ts");
+      await writeFile(prev, "// old\n");
+      expect((await writeAdoptBarrel(root, "// new\n")).written).toBe(true);
+      expect(await Bun.file(join(root, "src/flows/index.ts")).text()).toBe("// new\n");
+      expect(await Bun.file(prev).exists()).toBe(false);
+      await writeFile(prev, "// leftover\n");
+      expect((await writeAdoptBarrel(root, "// new\n")).written).toBe(false);
+      expect(await Bun.file(prev).exists()).toBe(false);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
   test("import specifiers stay POSIX when the walked path used backslash", () => {
     const spec = importSpecifierFromWalked("notes\\[id]\\get.ts");
     expect(spec).toBe("./notes/[id]/get.ts");
     expect(spec.includes("\\")).toBe(false);
   });
 
+  test("signals.ts on() consumers join the unit; signal.once decls do not", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-adopt-signals-"));
+    try {
+      await mkdir(join(root, "src/flows/links"), { recursive: true });
+      await writeFile(
+        join(root, "src/flows/links/create.ts"),
+        "export const create = on(http.post(), flow({ do: () => 1 }));\n",
+      );
+      await writeFile(
+        join(root, "src/flows/links/signals.ts"),
+        [
+          'export const linkCreated = signal.once("link-created");',
+          "export const onCreated = on(",
+          "  linkCreated,",
+          '  flow("links.onCreated", { do: () => 1 }),',
+          ");",
+          "export const onClicked = on(",
+          "  linkClicked,",
+          '  flow("links.onClicked", { do: () => 1 }),',
+          ");",
+        ].join("\n"),
+      );
+      await writeFile(join(root, "src/flows/links/shapes.ts"), "export const LinkOut = 1;\n");
+      const result = await generateAdoptBarrel({ rootDir: root });
+      expect(result.source).toContain('from "./links/signals.ts"');
+      expect(result.source).toContain("links_signals.onCreated");
+      expect(result.source).toContain("links_signals.onClicked");
+      expect(result.source).toContain('"/links/on-created"');
+      expect(result.source).toContain('"/links/on-clicked"');
+      expect(result.source).not.toContain("linkCreated");
+      expect(result.source).not.toContain("LinkOut");
+      expect(result.source).not.toContain("shapes.ts");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
   test("[...slug] unit adds the * client-key comment", async () => {
     const root = await mkdtemp(join(tmpdir(), "oke-adopt-gen-"));
     try {

package/src/compiler/generate-adopt.ts

@@ -51,15 +51,24 @@ const CATCHALL_COMMENT =
   '// Catch-all param is "*" — call api.docs.get({ "*": "a/b/c" }), not { slug }.\n';
 
 /** Filename of the on-disk `.adopt()` barrel under the flows directory. */
-export const ADOPT_BARREL_FILE = "generated.ts";
+export const ADOPT_BARREL_FILE = "index.ts";
+
+/** Previous barrel filename — unlinked after writing {@link ADOPT_BARREL_FILE}. */
+export const PREV_ADOPT_BARREL_FILE = "generated.ts";
 
 /** A folder name usable as an `export * as <name>` binding. */
 const VALID_UNIT_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 
 const EXPORT_CONST = /^export const ([A-Za-z_$][A-Za-z0-9_$]*)\b/gm;
 
+/** `export const onCreated = on(` — consumers colocated with `signal.once` in `signals.ts`. */
+const EXPORT_ON = /^export const ([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*on\s*\(/gm;
+
 const EXPLICIT_FLOW_UNIT = /flow\(\s*["']([A-Za-z_$][A-Za-z0-9_$]*)\./g;
 
+/** Skip-list file that may still export `on()` consumers (not `signal.once` decls). */
+const SIGNALS_FILE = "signals.ts";
+
 /**
  * Generate-time failure (mixed barrel + tree, export collision, unit drift).
  */
@@ -86,9 +95,28 @@ interface WalkedFlowFile {
 }
 
 /**
- * Write the adopt barrel atomically: `generated.ts.tmp` → rename to
- * `generated.ts`. Skips the write when bytes are unchanged so the `src/`
- * watcher + bun `--hot` do not loop.
+ * True when `rel` is the adopt barrel (or its `.tmp`) at the flows root —
+ * not a unit `index.ts`.
+ *
+ * @param rel - Watcher or source path (POSIX or Windows)
+ */
+export function isAdoptBarrelRelPath(rel: string): boolean {
+  const posix = toPosixPath(rel);
+  const marker = "flows/";
+  const idx = posix.lastIndexOf(marker);
+  const after = idx >= 0 ? posix.slice(idx + marker.length) : posix;
+  return (
+    after === ADOPT_BARREL_FILE ||
+    after === `${ADOPT_BARREL_FILE}.tmp` ||
+    after === PREV_ADOPT_BARREL_FILE ||
+    after === `${PREV_ADOPT_BARREL_FILE}.tmp`
+  );
+}
+
+/**
+ * Write the adopt barrel atomically: `index.ts.tmp` → rename to
+ * `index.ts`. Skips the write when bytes are unchanged so the `src/`
+ * watcher + bun `--hot` do not loop. Unlinks leftover `generated.ts`.
  *
  * @param rootDir - Project root
  * @param source - Full barrel source from {@link generateAdoptBarrel}
@@ -103,25 +131,44 @@ export async function writeAdoptBarrel(
   const target = join(dir, ADOPT_BARREL_FILE);
   const tmp = `${target}.tmp`;
   await mkdir(dir, { recursive: true });
+  let written = true;
   try {
     const existing = await readFile(target, "utf8");
-    if (existing === source) return { written: false };
+    if (existing === source) written = false;
   } catch {
     // missing — write
   }
-  await writeFile(tmp, source);
-  try {
-    await rename(tmp, target);
-  } catch {
-    // Windows cannot rename onto an existing path (EEXIST / EPERM).
-    await writeFile(target, source);
+  if (written) {
+    await writeFile(tmp, source);
     try {
-      await unlink(tmp);
+      await rename(tmp, target);
     } catch {
-      // tmp already replaced or removed
+      // Windows cannot rename onto an existing path (EEXIST / EPERM).
+      await writeFile(target, source);
+      try {
+        await unlink(tmp);
+      } catch {
+        // tmp already replaced or removed
+      }
+    }
+  }
+  await unlinkPrevAdoptBarrel(dir);
+  return { written };
+}
+
+/**
+ * Remove leftover `generated.ts` after the barrel moved to `index.ts`.
+ *
+ * @param dir - Absolute flows directory
+ */
+async function unlinkPrevAdoptBarrel(dir: string): Promise<void> {
+  for (const name of [PREV_ADOPT_BARREL_FILE, `${PREV_ADOPT_BARREL_FILE}.tmp`]) {
+    try {
+      await unlink(join(dir, name));
+    } catch {
+      // absent
     }
   }
-  return { written: true };
 }
 
 /**
@@ -225,6 +272,7 @@ export async function generateAdoptBarrel(
 
 /**
  * Walk a unit folder for route files (skip-list applied).
+ * `signals.ts` is included only for `export const … = on(` consumers.
  *
  * @param unitAbs - Absolute unit directory
  */
@@ -246,10 +294,11 @@ async function listFlowFiles(unitAbs: string): Promise<WalkedFlowFile[]> {
         continue;
       }
       if (!posixName.endsWith(".ts") && !posixName.endsWith(".tsx")) continue;
-      if (isSkipFlowFile(posixName)) continue;
+      if (isSkipFlowFile(posixName) && posixName !== SIGNALS_FILE) continue;
       const relFile = rel ? `${rel}/${posixName}` : posixName;
       const source = await readFile(join(dir, d.name), "utf8");
-      const exports = listExportedConsts(source);
+      const exports =
+        posixName === SIGNALS_FILE ? listExportedOnConsts(source) : listExportedConsts(source);
       const relPosix = toPosixPath(relFile);
       // Barrel `index.ts` counts even with no `export const` (`export {}` / re-exports).
       if (exports.length === 0 && relPosix !== "index.ts") continue;
@@ -282,6 +331,31 @@ export function listExportedConsts(source: string): string[] {
   return names;
 }
 
+/**
+ * Collect `export const name = on(` bindings (skip `signal.once` decls).
+ *
+ * @param source - TypeScript source
+ */
+export function listExportedOnConsts(source: string): string[] {
+  const names: string[] = [];
+  EXPORT_ON.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = EXPORT_ON.exec(source))) {
+    const name = match[1];
+    if (name) names.push(name);
+  }
+  return names;
+}
+
+/**
+ * camelCase export → kebab filename (`onCreated` → `on-created`).
+ *
+ * @param name - `export const` binding
+ */
+function camelToKebab(name: string): string {
+  return name.replace(/[A-Z]/g, (ch) => `-${ch.toLowerCase()}`).replace(/^-/, "");
+}
+
 /**
  * Emit import + stamped namespace for a tree unit.
  *
@@ -309,10 +383,6 @@ function emitTreeUnit(
     const alias = importAlias(unit, file.relFromUnit);
     importLines.push(`import * as ${alias} from ${JSON.stringify(spec)};`);
 
-    const inferred =
-      pathFromFlowFile(`${unit}/${file.relFromUnit}`) ??
-      pathFromFlowFile(`src/flows/${unit}/${file.relFromUnit}`);
-
     for (const exp of file.exports) {
       const prev = used.get(exp);
       if (prev !== undefined) {
@@ -322,7 +392,7 @@ function emitTreeUnit(
       }
       used.set(exp, file.relFromUnit);
       const flowName = nameFromFlowFile(`${unit}/${file.relFromUnit}`, exp) ?? `${unit}.${exp}`;
-      const pathLit = JSON.stringify(inferred ?? "/");
+      const pathLit = JSON.stringify(httpPathForExport(unit, file.relFromUnit, exp));
       fieldLines.push(
         `  ${exp}: stampHttpPath(stampFlowName(${alias}.${exp}, ${JSON.stringify(flowName)}), ${pathLit}),`,
       );
@@ -340,6 +410,26 @@ function emitTreeUnit(
   return { lines, catchAll };
 }
 
+/**
+ * HTTP path stamp for one export.
+ *
+ * Skip-list files (`signals.ts`) have no file-tree path — fall back to
+ * `unit` + kebab export so `onCreated` in `links/signals.ts` stamps
+ * `/links/on-created` like a dedicated `on-created.ts` would.
+ *
+ * @param unit - Folder name
+ * @param relFromUnit - POSIX relative path
+ * @param exp - `export const` binding
+ */
+function httpPathForExport(unit: string, relFromUnit: string, exp: string): string {
+  return (
+    pathFromFlowFile(`${unit}/${relFromUnit}`) ??
+    pathFromFlowFile(`src/flows/${unit}/${relFromUnit}`) ??
+    pathFromFlowFile(`${unit}/${camelToKebab(exp)}.ts`) ??
+    "/"
+  );
+}
+
 /**
  * Fail when `flow("other.x")` lives under a different unit folder.
  *

package/src/compiler/response.ts

@@ -4,11 +4,10 @@
  * Shared by AoT and dynamic so responses stay byte-identical.
  */
 
-import type { FlowFailure } from "../kernel/errors.ts";
+import { fail, type FlowFailure } from "../kernel/errors.ts";
 import type { JsonResult, JsonStreamResult, SseFrame } from "../kernel/fx.ts";
 import { isFlowFailure } from "../kernel/hooks.ts";
 import { lazyRequire } from "../kernel/lazy-require.ts";
-import { VALIDATION_ERROR_CODE } from "../validation/standard-schema.ts";
 
 /** Successful envelope. */
 export interface SuccessEnvelope {
@@ -26,24 +25,12 @@ export interface FailureEnvelope {
 /**
  * HTTP status for a flow-boundary failure.
  *
- * Gate denials use the status the Gates simulator promises:
- * `Unauthorized` → 401 · `Forbidden` → 403 · `RateLimited` → 429.
+ * Built-in codes use {@link httpStatusForFailure}. Domain codes default to 400.
  *
  * @param failure - Typed failure
  */
 export function statusForFailure(failure: FlowFailure): number {
-  switch (failure.error.code) {
-    case VALIDATION_ERROR_CODE:
-      return 422;
-    case "Unauthorized":
-      return 401;
-    case "Forbidden":
-      return 403;
-    case "RateLimited":
-      return 429;
-    default:
-      return 400;
-  }
+  return loadBuiltinErrors().httpStatusForFailure(failure.error.code, failure.error.data);
 }
 
 /**
@@ -87,6 +74,14 @@ function loadFxLiveStream(): typeof import("../kernel/fx-live-stream.ts") {
   return lazyRequire(`${import.meta.dir}/../kernel`, ["fx", "live", "stream"].join("-"));
 }
 
+function loadBuiltinErrors(): typeof import("../kernel/builtin-errors.ts") {
+  return lazyRequire(`${import.meta.dir}/../kernel`, ["builtin", "errors"].join("-"));
+}
+
+function loadStoreErrors(): typeof import("../elements/store/store-errors.ts") {
+  return lazyRequire(`${import.meta.dir}/../elements/store`, ["store", "errors"].join("-"));
+}
+
 function loadFxJson(): {
   isJsonResult: (value: unknown) => value is JsonResult;
   isJsonStreamResult: (value: unknown) => value is JsonStreamResult;
@@ -123,18 +118,13 @@ export async function encodeExecuteResult(result: {
         ? loadFxLiveStream().encodeGap(result.error)
         : undefined;
     if (gap) return gap;
+    const storeMapped = loadStoreErrors().storeErrorToFailure(result.error, {
+      retryable: "unavailable",
+    });
+    if (storeMapped) return encodeFailure(storeMapped);
     // Unhandled throws must never look like success (`undefined` → 204).
-    return Response.json(
-      {
-        data: null,
-        error: {
-          code: "InternalError",
-          data: {},
-          message: result.error instanceof Error ? result.error.message : "internal error",
-        },
-      } satisfies FailureEnvelope,
-      { status: 500 },
-    );
+    // Catalog message only — never copy the thrown `Error.message`.
+    return encodeFailure(fail("InternalError", {}));
   }
   if (loadFxJson().isJsonStreamResult(result.output) && result.output.ready) {
     const early = await loadFxLiveStream().awaitLiveReady(result.output);

package/src/config/index.ts

@@ -214,14 +214,16 @@ export interface DbConfig {
   /**
    * Abstract schema declare module (`store.schema.table` exports).
    * When present, `oke db` emits Drizzle into {@link generated} before sync.
-   * Default `"src/db/schema.decl.ts"` (legacy `"src/schema.decl.ts"` still resolved).
+   * Default: `src/db/schema.ts` if that file exists, else
+   * `src/db/schema.decl.ts`, else `src/db/schema/index.ts`, else legacy
+   * `src/schema.decl.ts`. Set this to override discovery.
    */
   readonly declare?: string;
   /**
    * Generated Drizzle schema path written from abstract decls.
-   * Default `"src/db/schema.drizzle.ts"` (prior `"src/db/schema.generated.ts"`;
-   * legacy `"src/schema.generated.ts"`).
-   * Point `drizzle.config.ts` `schema` at this file when using the abstract path.
+   * Default `"src/db/drizzle/index.ts"`. Older single files still resolve
+   * when `generated` is set. Point `drizzle.config.ts` `schema` at this
+   * barrel when using the abstract path.
    */
   readonly generated?: string;
   /**

package/src/console/server/invoke-user-flow.test.ts

@@ -34,17 +34,23 @@ const MANIFEST = {
 } as Manifest;
 
 function execute(over: Partial<ExecuteResult>): ExecuteResult {
-  return {
+  const result = {
     output: undefined,
     failure: undefined,
     response: undefined,
     ctx: {} as ExecuteResult["ctx"],
     fx: {} as ExecuteResult["fx"],
-    cache: "none",
+    cache: "none" as const,
     durationMs: 0,
     runId: "run_test",
     ...over,
   };
+  return {
+    ...result,
+    get error() {
+      return result.ctx.error;
+    },
+  };
 }
 
 describe("invokeResultFromExecute", () => {