okengine 0.18.4 → 0.19.0

package/src/kernel/external-effects.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Gate tests for EffectEntry.external + fx.fetch + driver-reported egress.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { openOpenaiCompatible } from "../drivers/ai-openai-compatible.ts";
+import { openAnthropic } from "../drivers/ai-anthropic.ts";
+import { connectPglite } from "../drivers/pglite.ts";
+import { createChannelRuntime } from "../elements/channel/runtime.ts";
+import { createFxContext } from "./fx.ts";
+import { withDryRun } from "./dry-run.ts";
+
+describe("EffectEntry.external — optional / additive", () => {
+  test("ledger entries without external stay five-field shaped", async () => {
+    const { fx, ledger } = createFxContext({
+      flow: "local.read",
+      effects: { reads: ["sql:notes"] },
+    });
+    await (fx.store("sql:notes") as { get(key: string): Promise<unknown> }).get("n1");
+    const entry = ledger.entries[0];
+    expect(entry).toMatchObject({
+      kind: "read",
+      resource: "sql:notes",
+      reversibility: "none",
+    });
+    expect(entry?.external).toBeUndefined();
+  });
+});
+
+describe("fx.fetch", () => {
+  test("records fetch kind with third-party host from URL", async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async () => new Response("ok", { status: 200 })) as unknown as typeof fetch;
+    try {
+      const { fx, ledger } = createFxContext({
+        flow: "stripe.pull",
+        effects: { fetches: ["api.stripe.com"] },
+      });
+      const res = await fx.fetch("https://api.stripe.com/v1/charges");
+      expect(res.status).toBe(200);
+      expect(ledger.entries).toHaveLength(1);
+      expect(ledger.entries[0]).toMatchObject({
+        kind: "fetch",
+        resource: "api.stripe.com",
+        reversibility: "irreversible",
+        external: { host: "api.stripe.com", kind: "third-party" },
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("undeclared host throws UNDECLARED_FETCH", async () => {
+    const { fx } = createFxContext({
+      flow: "stripe.pull",
+      effects: { fetches: ["api.example.com"] },
+    });
+    await expect(fx.fetch("https://api.stripe.com/v1")).rejects.toMatchObject({
+      code: 1008,
+    });
+  });
+
+  test("dry-run stubs fetch without contacting the network", async () => {
+    let called = false;
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async () => {
+      called = true;
+      return new Response("nope");
+    }) as unknown as typeof fetch;
+    try {
+      const { fx, ledger } = createFxContext({
+        flow: "stripe.pull",
+        effects: { fetches: ["api.stripe.com"] },
+      });
+      const { wouldHaveFired } = await withDryRun(async () => {
+        await fx.fetch("https://api.stripe.com/v1");
+      });
+      expect(called).toBe(false);
+      expect(wouldHaveFired).toEqual([{ kind: "fetch", resource: "api.stripe.com" }]);
+      expect(ledger.entries[0]?.external).toMatchObject({
+        host: "api.stripe.com",
+        kind: "third-party",
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe("Channel failover — winning provider on EffectEntry", () => {
+  test("send stamps external.provider from the winning attempt, not the primary binding", async () => {
+    const { channel } = await import("../elements/channel.ts");
+    const { driverFromTransport, failingTransport, okTransport } =
+      await import("../elements/channel/test-helpers.ts");
+    const smtp = {
+      ...driverFromTransport("smtp", failingTransport("smtp")),
+      external: {
+        host: "mail.example.internal",
+        provider: "smtp",
+        kind: "infrastructure" as const,
+      },
+    };
+    const resend = {
+      ...driverFromTransport("resend", okTransport("resend")),
+      external: {
+        host: "api.resend.com",
+        provider: "resend",
+        kind: "third-party" as const,
+      },
+    };
+    const channelRuntime = createChannelRuntime({
+      templates: [channel.template("welcome", { medium: "email" })],
+      drivers: [smtp, resend],
+      catalog: { welcome: { en: { subject: "Hi", text: "Hello" } } },
+    });
+    const { fx, ledger } = createFxContext({
+      flow: "mail.send",
+      effects: { sends: ["welcome"] },
+      channelRuntime,
+    });
+    await fx.send("welcome", { to: "a@b.com", via: ["smtp", "resend"] });
+    const send = ledger.entries.find((e) => e.kind === "send");
+    expect(send?.external?.provider).toBe("resend");
+    expect(send?.external?.host).toBe("api.resend.com");
+    expect(send?.external?.kind).toBe("third-party");
+  });
+});
+
+describe("Store — in-process PGlite never carries external", () => {
+  test("pglite connection omits external", async () => {
+    const conn = await connectPglite({ url: "memory://" });
+    expect(conn.driverId).toBe("pglite");
+    expect(conn.external).toBeUndefined();
+    await conn.close?.();
+  });
+});
+
+describe("AI — infrastructure vs third-party", () => {
+  test("self-hosted openai-compatible reports infrastructure when opened with that kind", async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async () =>
+      new Response(
+        JSON.stringify({
+          choices: [{ message: { content: "hi" } }],
+          model: "llama3",
+          usage: { prompt_tokens: 1, completion_tokens: 1 },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      )) as unknown as typeof fetch;
+    try {
+      const client = await openOpenaiCompatible({
+        baseUrl: "http://127.0.0.1:11434/v1",
+        external: { kind: "infrastructure", provider: "local" },
+      });
+      const result = await client.complete({
+        messages: [{ role: "user", content: "hi" }],
+      });
+      expect(result.external).toEqual({
+        host: "127.0.0.1",
+        kind: "infrastructure",
+        provider: "local",
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("anthropic cloud reports third-party", async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async () =>
+      new Response(
+        JSON.stringify({
+          content: [{ type: "text", text: "hi" }],
+          model: "claude",
+          usage: { input_tokens: 1, output_tokens: 1 },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      )) as unknown as typeof fetch;
+    try {
+      const client = await openAnthropic({
+        apiKey: "sk-test",
+        baseUrl: "https://api.anthropic.com",
+      });
+      const result = await client.complete({
+        messages: [{ role: "user", content: "hi" }],
+      });
+      expect(result.external).toEqual({
+        host: "api.anthropic.com",
+        kind: "third-party",
+        provider: "anthropic",
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});

package/src/kernel/flow.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, test, beforeEach } from "bun:test";
+import { clock } from "../elements/clock/declare.ts";
+import { field, store } from "../elements/store.ts";
 import { oke } from "./app.ts";
 import { flow, isFlow, resetFlowSeq } from "./flow.ts";
 import { on, resetBindings } from "./on.ts";
-import { every, http, internal, table } from "./triggers.ts";
+import { http, internal } from "./triggers.ts";
 
 beforeEach(() => {
   resetBindings();
@@ -71,8 +73,9 @@ describe("five trigger kinds", () => {
       }),
     );
 
+    const hourly = clock("hourly", { every: "1h" });
     on(
-      every("1h"),
+      hourly,
       flow("t.every", {
         do: () => {
           seen.push("every");
@@ -89,8 +92,14 @@ describe("five trigger kinds", () => {
       }),
     );
 
+    const db = store.sql("main");
+    const orders = store.schema.table("orders", {
+      id: field.text().primaryKey(),
+      status: field.text(),
+    });
+
     on(
-      table("orders").changed("status"),
+      db.table(orders).changed("status"),
       flow("t.cdc", {
         do: (p: { before: { status: string }; after: { status: string } }) => {
           seen.push(`cdc:${p.before.status}->${p.after.status}`);
@@ -114,7 +123,7 @@ describe("five trigger kinds", () => {
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ data: { code: "abc" }, error: null });
 
-    await app.dispatchEvery("1h");
+    await app.dispatchEvery("hourly");
     await app.dispatchSignal("link-clicked", { code: "sa" });
     await app.dispatchCdc(
       "orders",

package/src/kernel/flow.ts

@@ -1,13 +1,14 @@
 /**
  * `flow` — the one species of backend behavior.
  *
- * A Flow is a typed contract (`in` / `out` / `errors`) plus a `do` body.
- * Triggers are attached by {@link on}; a flow with no trigger is still a
- * Flow and is callable via `fx.call` (unified-theory §4, Linkly ⑤).
+ * A Flow is a `do` body plus runtime options. Invoke contracts (`in` / `out` /
+ * `errors` / `breaking`) are authored on the exposure (`http.*`, `call`,
+ * `mcp.tool`) and stamped onto the FlowDef for Manifest / validation.
+ * Triggers are attached by {@link on}; {@link call} is the call-only sugar.
  */
 
 import type { Effects, FlowPlane, Slo } from "../manifest/types.ts";
-import type { InferSchemaOutput, SchemaInput } from "../validation/standard-schema.ts";
+import type { SchemaInput } from "../validation/standard-schema.ts";
 import type { FxRetryOptions } from "./concurrency.ts";
 import type { FlowFailure } from "./errors.ts";
 import type { Fx } from "./fx.ts";
@@ -22,7 +23,7 @@ export type StandardSchemaResult<Output> =
   | { readonly value: Output; readonly issues?: undefined }
   | { readonly issues: ReadonlyArray<{ readonly message: string }> };
 
-/** Map of declared flow-boundary error names to their schemas. */
+/** Map of declared boundary error names to their schemas. */
 export type FlowErrorMap = Readonly<Record<string, SchemaInput>>;
 
 /**
@@ -36,22 +37,12 @@ export type FlowHandler<I = unknown, O = unknown> = (
   fx: Fx,
 ) => O | FlowFailure | Promise<O | FlowFailure>;
 
-/** Options for {@link flow}. */
-export interface FlowOptions<I = unknown, O = unknown, E extends FlowErrorMap = FlowErrorMap> {
-  /** Input schema (Standard Schema when present). */
-  readonly in?: SchemaInput;
-  /** Output schema (Standard Schema when present). */
-  readonly out?: SchemaInput;
-  /** Declared typed errors. */
-  readonly errors?: E;
+/** Runtime / behavior options for {@link flow} (no invoke contract). */
+export interface FlowOptions<I = unknown, O = unknown> {
   /** Declared effects (capability token). Inferred later by AoT. */
   readonly effects?: Effects;
   /** Journal every effect call. */
   readonly durable?: boolean;
-  /**
-   * Retry the whole `do` body on thrown errors (same journal session when
-   * durable). Prefer {@link Fx.retry} inside {@link Fx.step} for fine control.
-   */
   /**
    * Retry the whole `do` body on thrown errors (same journal session when
    * durable). Prefer {@link Fx.retry} inside {@link Fx.step} for fine control.
@@ -70,11 +61,6 @@ export interface FlowOptions<I = unknown, O = unknown, E extends FlowErrorMap =
    * Cross-plane invocation is a compile error.
    */
   readonly plane?: FlowPlane;
-  /**
-   * Acknowledge intentional Manifest contract breaks for this flow
-   * (`oke doctor --diff` / CI gate).
-   */
-  readonly breaking?: boolean;
   /**
    * Compensation phase after terminal failure on a durable flow.
    * Runs under the same journal session after auto per-step `{ undo }`
@@ -96,42 +82,32 @@ export interface FlowOptions<I = unknown, O = unknown, E extends FlowErrorMap =
    * Default `true` when `gate.auth.tenant` is on.
    */
   readonly tenantScoped?: boolean;
+  /**
+   * Mark this HTTP flow as returning `text/event-stream` via `fx.json.stream`
+   * (not signal live). Stamps `$routes.stream` for the typed client.
+   */
+  readonly stream?: true;
   /** The behavior. */
   readonly do: FlowHandler<I, O>;
 }
 
 /**
- * Infer validated input from a flow options bag.
- *
- * @typeParam Opts - {@link FlowOptions} / call-site object
- */
-export type InferFlowIn<Opts> = Opts extends { readonly in: infer S }
-  ? InferSchemaOutput<S>
-  : Opts extends { readonly do: FlowHandler<infer I, infer _O> }
-    ? I
-    : unknown;
-
-/**
- * Infer success output from a flow options bag.
+ * Infer validated input from a flow options bag (handler signature).
  *
  * @typeParam Opts - {@link FlowOptions} / call-site object
  */
-export type InferFlowOut<Opts> = Opts extends { readonly out: infer S }
-  ? InferSchemaOutput<S>
-  : Opts extends { readonly do: FlowHandler<infer _I, infer O> }
-    ? O
-    : unknown;
+export type InferFlowIn<Opts> = Opts extends { readonly do: FlowHandler<infer I, infer _O> }
+  ? I
+  : unknown;
 
 /**
- * Infer the error schema map from a flow options bag.
+ * Infer success output from a flow options bag (handler signature).
  *
  * @typeParam Opts - {@link FlowOptions} / call-site object
  */
-export type InferFlowErrors<Opts> = Opts extends {
-  readonly errors: infer E extends FlowErrorMap;
-}
-  ? E
-  : {};
+export type InferFlowOut<Opts> = Opts extends { readonly do: FlowHandler<infer _I, infer O> }
+  ? O
+  : unknown;
 
 /**
  * Phantom brand for the bound trigger type parameter. Optional so
@@ -142,6 +118,9 @@ declare const triggerPhantom: unique symbol;
 /**
  * A Flow definition — one species, trigger-agnostic until {@link on} binds.
  *
+ * `in` / `out` / `errors` / `breaking` are **projections** stamped from the
+ * exposure (`http.*` / `call` / `mcp.tool` / signal schema), not authored here.
+ *
  * @typeParam I - Input type
  * @typeParam O - Output type
  * @typeParam E - Error map (schemas)
@@ -166,12 +145,12 @@ export interface FlowDef<
   readonly name: string;
   /** Unit scope — derived from `name`'s first dot segment (e.g. `"auth.refresh"` → `"auth"`). */
   readonly unit: string | undefined;
-  /** Input schema. */
-  readonly in: SchemaInput | undefined;
-  /** Output schema. */
-  readonly out: SchemaInput | undefined;
-  /** Declared errors. */
-  readonly errors: E | undefined;
+  /** Input schema (stamped from exposure). */
+  in: SchemaInput | undefined;
+  /** Output schema (stamped from exposure). */
+  out: SchemaInput | undefined;
+  /** Declared errors (stamped from exposure). */
+  errors: E | undefined;
   /** Declared effects. */
   readonly effects: Effects | undefined;
   /** Durability flag. */
@@ -193,13 +172,17 @@ export interface FlowDef<
   readonly slo: Slo | undefined;
   /** Plane (user vs operator). */
   readonly plane: FlowPlane | undefined;
-  /** Intentional contract-break acknowledgement for Manifest Diff. */
-  readonly breaking: boolean;
+  /** Intentional contract-break acknowledgement (stamped from exposure). */
+  breaking: boolean;
   /**
    * When `false`, this flow is tenant-unaware (no tenant-role scope union).
    * Default `true` when `gate.auth.tenant` is on.
    */
   readonly tenantScoped: boolean | undefined;
+  /**
+   * True when this HTTP flow returns SSE via `fx.json.stream` (not live signal).
+   */
+  readonly stream: true | undefined;
   /**
    * Optional compensation phase after terminal durable failure.
    * See {@link FlowOptions.compensate}.
@@ -253,38 +236,53 @@ export interface FlowDef<
 export const flowBrand: unique symbol = Symbol("oke.flow");
 
 /**
- * Define a Flow — the one species of backend behavior.
- *
- * Input / output types are inferred from Standard Schema `in` / `out` when
- * present; otherwise from the `do` handler signature.
+ * Define a Flow — behavior only. Author invoke contracts on `http.*` /
+ * {@link call} / `mcp.tool`, not here.
  *
  * A nameless `flow({ do })` is stamped `unit.export` by the file-tree
  * generator, {@link unit}, or `.adopt()`. Explicit `flow("notes.get", {…})`
  * still wins.
  *
- * @param options - Contract and handler (name stamped later)
+ * @param options - Runtime options and handler (name stamped later)
  */
-export function flow<Opts extends FlowOptions<any, any, any>>(
+export function flow<Opts extends FlowOptions<any, any>>(
   options: Opts,
-): FlowDef<InferFlowIn<Opts>, InferFlowOut<Opts>, InferFlowErrors<Opts>>;
+): FlowDef<InferFlowIn<Opts>, InferFlowOut<Opts>>;
 /**
  * @param name - Stable name (used by `fx.call` and the Manifest)
- * @param options - Contract and handler
+ * @param options - Runtime options and handler
  */
-export function flow<Opts extends FlowOptions<any, any, any>>(
+export function flow<Opts extends FlowOptions<any, any>>(
   name: string,
   options: Opts & { readonly name?: never },
-): FlowDef<InferFlowIn<Opts>, InferFlowOut<Opts>, InferFlowErrors<Opts>>;
+): FlowDef<InferFlowIn<Opts>, InferFlowOut<Opts>>;
 export function flow(
-  nameOrOptions: string | FlowOptions<any, any, any>,
-  maybeOptions?: FlowOptions<any, any, any> & { readonly name?: never },
+  nameOrOptions: string | FlowOptions<any, any>,
+  maybeOptions?: FlowOptions<any, any> & { readonly name?: never },
 ): FlowDef {
   const named = typeof nameOrOptions === "string";
   const name = named ? nameOrOptions : "";
-  const options = (named ? maybeOptions : nameOrOptions) as FlowOptions<any, any, any> | undefined;
+  const options = (named ? maybeOptions : nameOrOptions) as FlowOptions<any, any> | undefined;
   if (!options || typeof options.do !== "function") {
     throw new TypeError("flow() expected an options bag with a do handler");
   }
+  // Reject legacy contract keys so misuse fails loud at definition time.
+  const legacy = options as FlowOptions<any, any> & {
+    in?: unknown;
+    out?: unknown;
+    errors?: unknown;
+    breaking?: unknown;
+  };
+  if (
+    legacy.in !== undefined ||
+    legacy.out !== undefined ||
+    legacy.errors !== undefined ||
+    legacy.breaking !== undefined
+  ) {
+    throw new TypeError(
+      "flow() no longer accepts in/out/errors/breaking — author the contract on http.*/call/mcp.tool",
+    );
+  }
 
   const triggers: Trigger[] = [];
   const hooks: Partial<Record<HookStage, HookFn[]>> = {};
@@ -297,9 +295,9 @@ export function flow(
     [flowBrand]: true,
     name,
     unit,
-    in: options.in,
-    out: options.out,
-    errors: (options.errors ?? undefined) as FlowErrorMap | undefined,
+    in: undefined,
+    out: undefined,
+    errors: undefined,
     effects: options.effects,
     durable: options.durable ?? false,
     retry: options.retry,
@@ -308,8 +306,9 @@ export function flow(
     cache: options.cache,
     slo: options.slo,
     plane: options.plane,
-    breaking: options.breaking ?? false,
+    breaking: false,
     tenantScoped: options.tenantScoped,
+    stream: options.stream,
     compensate: options.compensate as FlowDef["compensate"],
     do: options.do as FlowHandler,
     triggers,
@@ -323,7 +322,6 @@ export function flow(
     },
     plug(pluginDef) {
       pendingPlugins.push(pluginDef);
-      // Decorations accumulate on the interface; runtime object is unchanged.
       return def as never;
     },
   };

package/src/kernel/fx-ask-telemetry.test.ts

@@ -8,12 +8,12 @@ import { z } from "zod";
 import { ai, createAiRuntime } from "../elements/ai.ts";
 import { collectWideEvent } from "../runs/collect.ts";
 import { createEffectLedger } from "./effects.ts";
-import { flow } from "./flow.ts";
+import { call } from "./call.ts";
 import { createFx } from "./fx.ts";
 import { createRunTelemetry } from "./run-telemetry.ts";
 import { internal } from "./triggers.ts";
 
-const triageFlow = flow("support.triage", {
+const triageFlow = call("support.triage", {
   in: z.object({}),
   do: () => ({ ok: true }),
 });

package/src/kernel/fx-dead-letters.test.ts

@@ -6,7 +6,7 @@ import { createFx, createFxContext, signalReadRef } from "./fx.ts";
 
 describe("fx.deadLetters", () => {
   test("returns dead-lettered messages for a declared signal read", async () => {
-    const notify = signal("notify", { delivery: "once", retries: 0, deadLetter: true });
+    const notify = signal.once("notify", { retries: 0, deadLetter: true });
     const runtime = openRuntime(notify);
     const bus = await runtime.start();
     await bus.subscribe("notify", "c1", async () => {
@@ -33,8 +33,8 @@ describe("fx.deadLetters", () => {
   });
 
   test("undeclared and cross-signal reads throw OKE1001", async () => {
-    const notify = signal("notify", { delivery: "once", retries: 0, deadLetter: true });
-    const other = signal("other", { delivery: "once", retries: 0, deadLetter: true });
+    const notify = signal.once("notify", { retries: 0, deadLetter: true });
+    const other = signal.once("other", { retries: 0, deadLetter: true });
     const runtime = openRuntime(notify);
     const fx = createFx({
       flow: "notifications.failed",

package/src/kernel/fx-fetch.ts

@@ -0,0 +1,55 @@
+/**
+ * `fx.fetch` body — lazy chunk so Store-only / edge graphs that never call
+ * outbound HTTP do not pay for host parsing + dry-run stub strings.
+ */
+
+import type { EffectExternal } from "./effects.ts";
+import { isDryRun, recordWouldHaveFired } from "./dry-run.ts";
+
+/**
+ * Hostname for `fx.fetch` capability / ledger resource.
+ *
+ * @param href - Absolute URL string
+ */
+export function hostFromFetchUrl(href: string): string {
+  try {
+    const host = new URL(href).hostname;
+    if (host) return host;
+  } catch {
+    /* fall through */
+  }
+  throw new Error(`fx.fetch: invalid URL "${href}" — expected an absolute URL with a hostname`);
+}
+
+type Gated = <T>(
+  kind: "fetch",
+  resource: string,
+  body: () => T | Promise<T>,
+  externalOf?:
+    | EffectExternal
+    | ((result: T | undefined, error: unknown) => EffectExternal | undefined),
+) => Promise<T>;
+
+/**
+ * Capability-gated outbound HTTP (always `external.kind: "third-party"`).
+ *
+ * @param gated - Flow `gated` helper
+ * @param url - Absolute URL
+ * @param init - Fetch init
+ */
+export function runFxFetch(gated: Gated, url: string | URL, init?: RequestInit): Promise<Response> {
+  const href = typeof url === "string" ? url : url.href;
+  const host = hostFromFetchUrl(href);
+  return gated(
+    "fetch",
+    host,
+    async () => {
+      if (isDryRun()) {
+        recordWouldHaveFired("fetch", host);
+        return new Response(null, { status: 204 });
+      }
+      return globalThis.fetch(url, init);
+    },
+    { host, kind: "third-party" },
+  );
+}

package/src/kernel/fx-live-stream.ts

@@ -108,13 +108,13 @@ export function createLiveStream(options: CreateLiveStreamOptions): LiveStreamRe
 }
 
 /**
- * Map OKE1014 to HTTP 410 `{ error: { code: "LiveResumeGap" } }`.
+ * Map OKE1210 to HTTP 410 `{ error: { code: "LiveResumeGap" } }`.
  *
  * @param err - Thrown value
  */
 export function encodeGap(err: unknown): Response | undefined {
   const o = err as { code?: unknown; params?: { signal?: string; afterId?: string } };
-  if (o?.code !== 1014) return;
+  if (o?.code !== 1210) return;
   return Response.json(
     {
       data: null,

package/src/kernel/fx-live.test.ts

@@ -8,14 +8,14 @@ import { createFx, createFxContext, isSseFrame, signalReadRef } from "./fx.ts";
 
 describe("fx.live", () => {
   test("undeclared signal read throws OKE1001", async () => {
-    const orderStatus = signal("order-status", { delivery: "live", optional: true });
+    const orderStatus = signal.live("order-status", { optional: true });
     const runtime = openRuntime(orderStatus);
     const fx = createFx({
       flow: "orders.events",
       effects: { reads: [signalReadRef("order-status")] },
       signalRuntime: runtime,
     });
-    const other = signal("other-status", { delivery: "live", optional: true });
+    const other = signal.live("other-status", { optional: true });
     let err: unknown;
     try {
       const stream = fx.live(other);
@@ -44,7 +44,7 @@ describe("fx.live", () => {
   });
 
   test("ALS abort unsubscribes the live handler", async () => {
-    const orderStatus = signal("order-status", { delivery: "live", optional: true });
+    const orderStatus = signal.live("order-status", { optional: true });
     const runtime = openRuntime(orderStatus);
     const bus = await runtime.start();
     const { fx } = createFxContext({
@@ -74,7 +74,7 @@ describe("fx.live", () => {
   });
 
   test("yields branded SSE frames with id + payload", async () => {
-    const orderStatus = signal("order-status", { delivery: "live", optional: true });
+    const orderStatus = signal.live("order-status", { optional: true });
     const runtime = openRuntime(orderStatus);
     const bus = await runtime.start();
     await runtime.emit("order-status", { orderId: "ord_1", status: "placed" });
@@ -102,7 +102,7 @@ describe("fx.live", () => {
   });
 
   test("afterId skips already-delivered events", async () => {
-    const orderStatus = signal("order-status", { delivery: "live", optional: true });
+    const orderStatus = signal.live("order-status", { optional: true });
     const runtime = openRuntime(orderStatus);
     const bus = await runtime.start();
     await runtime.emit("order-status", { orderId: "ord_1", status: "placed" });
@@ -130,8 +130,8 @@ describe("fx.live", () => {
     await runtime.close();
   });
 
-  test("ready throws OKE1014 for a missing afterId", async () => {
-    const orderStatus = signal("order-status", { delivery: "live", optional: true });
+  test("ready throws OKE1210 for a missing afterId", async () => {
+    const orderStatus = signal.live("order-status", { optional: true });
     const runtime = openRuntime(orderStatus);
     const fx = createFx({
       flow: "orders.events",
@@ -139,7 +139,7 @@ describe("fx.live", () => {
       signalRuntime: runtime,
     });
     const stream = fx.live(orderStatus, { afterId: "missing" });
-    await expect(stream.ready?.()).rejects.toMatchObject({ code: 1014 });
+    await expect(stream.ready?.()).rejects.toMatchObject({ code: 1210 });
     const res = await encodeExecuteResult({ output: stream });
     expect(res.status).toBe(410);
     expect(await res.json()).toMatchObject({