okengine 0.9.1 → 0.10.1

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

@@ -0,0 +1,207 @@
+/**
+ * Boot-level proof: compiled/inferred effects reaching a REAL running app's
+ * capability token — not an isolated compiler-only or kernel-only test.
+ *
+ * Before this file existed, `flow({...})` with no hand-declared `effects`
+ * always minted an OPEN capability token (every access allowed, no gate at
+ * all) in every environment, including `docker` / `prod` — `extractManifest`
+ * inference only ever fed the static `manifest.oke.json` artifact (Console,
+ * docs, publish), never the live boot path. Confirmed via real `oke()` boot
+ * + `app.fetch()`, not assumption.
+ *
+ * Also documents the sql:<table> (compiler inference) vs sql:<store-name>
+ * (kernel `gatedSqlHandle`) naming mismatch this stamping bridge surfaces:
+ * once inference actually reaches the runtime, a flow relying on it for a
+ * real `fx.store(db).insert(table)` write must not throw `UNDECLARED_WRITE`
+ * for touching the exact table it declared.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { gate } from "../elements/gate.ts";
+import { field, id, now, store } from "../elements/store.ts";
+import { oke } from "./app.ts";
+import { resetNoEffectsWarnForTests } from "./boot.ts";
+import { flow, resetFlowSeq } from "./flow.ts";
+import { on, resetBindings } from "./on.ts";
+import { createTestApp } from "../test/create-test-app.ts";
+import { http } from "./triggers.ts";
+
+afterEach(() => {
+  resetBindings();
+  resetFlowSeq();
+  resetNoEffectsWarnForTests();
+});
+
+const notes = store.schema.table("notes", {
+  id: field.text().primaryKey().defaultFn(id),
+  title: field.text().notNull(),
+  createdAt: field.integer().notNull().defaultFn(now),
+});
+
+const CreateIn = z.object({ id: z.string(), title: z.string() });
+const CreateOut = z.object({ ok: z.boolean() });
+
+function buildUnannotatedCreateFlow(db: ReturnType<typeof store.sql>) {
+  return on(
+    http.post("/notes").gate(gate.public),
+    flow({
+      name: "notes.create",
+      in: CreateIn,
+      out: CreateOut,
+      // Deliberately no `effects` — the "let the compiler infer it" case.
+      do: async (input, fx) => {
+        await fx.store(db).insert(notes).values({ id: input.id, title: input.title, createdAt: 1 });
+        return { ok: true };
+      },
+    }),
+  );
+}
+
+describe("boot-level: undeclared-effects flow, no manifest / rootDir", () => {
+  test("local / test: open token — real insert succeeds (documented dev-loop fallback)", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const db = store.sql("app", { schema: { notes } });
+    // `on(...)` (inside buildUnannotatedCreateFlow) must run BEFORE `oke(...)`
+    // is constructed — oke() synchronously drains the global on() registry
+    // at construction time; a binding created only as .adopt()'s argument
+    // (after oke() already ran) never gets wired to a route.
+    const create = buildUnannotatedCreateFlow(db);
+    const app = oke({ name: "stamp-open", gate: { policies: [gate.public] } }).adopt({ create });
+    Object.assign(app.$options, { stores: [db] });
+    await createTestApp(app); // createTestApp always boots env: "test"
+
+    const res = await app.fetch(
+      new Request("http://localhost/notes", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: "x1", title: "hi" }),
+      }),
+    );
+    expect(res.status).toBe(200);
+  });
+
+  test("docker: hard fail at boot — OKE1008, never an open token in a deploy-shaped env", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const db = store.sql("app", { schema: { notes } });
+    const create = buildUnannotatedCreateFlow(db);
+    const app = oke({ name: "stamp-docker", gate: { policies: [gate.public] } }).adopt({ create });
+
+    await expect(
+      app.boot({ env: "docker", stores: [db], unguardedHttp: "allow", startScheduler: false }),
+    ).rejects.toThrow(/OKE1008/);
+  });
+
+  test("prod: hard fail at boot — same posture as docker", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const db = store.sql("app", { schema: { notes } });
+    const create = buildUnannotatedCreateFlow(db);
+    const app = oke({ name: "stamp-prod", gate: { policies: [gate.public] } }).adopt({ create });
+
+    await expect(
+      app.boot({ env: "prod", stores: [db], unguardedHttp: "allow", startScheduler: false }),
+    ).rejects.toThrow(/OKE1008/);
+  });
+});
+
+describe("boot-level: table-ref resolution stays backward compatible", () => {
+  test("older store-level effects (sql:<store>) still cover a schema-table op — every existing template's convention", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const db = store.sql("app", { schema: { notes } });
+    const create = on(
+      http.post("/notes").gate(gate.public),
+      flow({
+        name: "notes.create",
+        in: CreateIn,
+        out: CreateOut,
+        // The convention every template/test predates Direction B with —
+        // store-level, not table-level. Must keep working unchanged.
+        effects: { writes: ["sql:app"] },
+        do: async (input, fx) => {
+          await fx
+            .store(db)
+            .insert(notes)
+            .values({ id: input.id, title: input.title, createdAt: 1 });
+          return { ok: true };
+        },
+      }),
+    );
+    const app = oke({ name: "stamp-back-compat", gate: { policies: [gate.public] } }).adopt({
+      create,
+    });
+    Object.assign(app.$options, { stores: [db] });
+    await createTestApp(app);
+
+    const res = await app.fetch(
+      new Request("http://localhost/notes", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: "x1", title: "hi" }),
+      }),
+    );
+    expect(res.status).toBe(200);
+  });
+});
+
+describe("boot-level: undeclared-effects flow, rootDir stamping from a real source tree", () => {
+  test("real fx.store(db).insert(table) write succeeds once inference is stamped onto the capability token", async () => {
+    resetBindings();
+    resetFlowSeq();
+    const dir = await mkdtemp(join(tmpdir(), "oke-stamp-"));
+    try {
+      await mkdir(join(dir, "flows", "notes"), { recursive: true });
+      // A real source file with NO manual `effects:` — extractManifest infers
+      // `writes: ["sql:notes"]` for this from the real `fx.store(db).insert`
+      // call, exactly like the kernel test flow above.
+      await writeFile(
+        join(dir, "flows", "notes", "index.ts"),
+        `
+import { on, flow, http, gate } from "okengine";
+// Unresolved bindings are fine — extraction is AST-only, never executed.
+// What matters is the literal shape: fx.store(db).insert(notes) so the
+// same table-name inference that produced "sql:notes" earlier fires here.
+const db = {} as any;
+const notes = {} as any;
+export const create = on(
+  http.post("/notes").gate(gate.public),
+  flow({
+    name: "notes.create",
+    do: async (input, fx) => {
+      await fx.store(db).insert(notes).values({ id: input.id, title: input.title, createdAt: 1 });
+      return { ok: true };
+    },
+  }),
+);
+`,
+      );
+
+      const db = store.sql("app", { schema: { notes } });
+      const create = buildUnannotatedCreateFlow(db);
+      const app = oke({ name: "stamp-rootdir", gate: { policies: [gate.public] } }).adopt({
+        create,
+      });
+      Object.assign(app.$options, { stores: [db] });
+      await createTestApp(app, { boot: { rootDir: dir } });
+
+      const res = await app.fetch(
+        new Request("http://localhost/notes", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ id: "x1", title: "hi" }),
+        }),
+      );
+      const body = (await res.json()) as { data: unknown; error: { message?: string } | null };
+      expect(res.status, body.error?.message ?? "").toBe(200);
+      expect(body.data).toEqual({ ok: true });
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/kernel/errors.ts

@@ -142,6 +142,17 @@ export const OKE_ERRORS = {
     cause: 'Flow "{flow}" calls "{resource}" without declaring it.',
     fix: 'Add "{resource}" to this flow\'s effects.calls.',
   },
+  /**
+   * Flow has no declared `effects` and no Manifest-derived effects were
+   * available to stamp at boot (docker / prod — never a silent open token).
+   */
+  NO_EFFECTS_DECLARED: {
+    code: 1008,
+    cause: 'Flow "{flow}" has no declared effects and no Manifest to derive them from.',
+    fix:
+      "Add explicit `effects` to this flow, or boot with a Manifest (`oke build`) / " +
+      "`rootDir` so effects can be derived. docker/prod refuse an open capability token.",
+  },
   /**
    * Emit target has no subscriber (unified-theory §21).
    * Thrown at emit when `optional` is false and nobody is subscribed.

package/src/kernel/flow.ts

@@ -73,6 +73,20 @@ export interface FlowOptions<I = unknown, O = unknown, E extends FlowErrorMap =
    * (`oke doctor --diff` / CI gate).
    */
   readonly breaking?: boolean;
+  /**
+   * Compensation phase after terminal failure on a durable flow.
+   * Runs under the same journal session before `commit("failed")`.
+   * Bodies must use distinct `fx.step("undo:…")` names — never reuse
+   * forward step names. Never called on retryable attempts or sleep park.
+   */
+  readonly compensate?: (
+    ctx: {
+      readonly input: I;
+      readonly error: unknown;
+      readonly completedSteps: readonly string[];
+    },
+    fx: import("./fx.ts").Fx,
+  ) => unknown | Promise<unknown>;
   /** The behavior. */
   readonly do: FlowHandler<I, O>;
 }
@@ -165,6 +179,20 @@ export interface FlowDef<
   readonly plane: FlowPlane | undefined;
   /** Intentional contract-break acknowledgement for Manifest Diff. */
   readonly breaking: boolean;
+  /**
+   * Optional compensation phase after terminal durable failure.
+   * See {@link FlowOptions.compensate}.
+   */
+  readonly compensate:
+    | ((
+        ctx: {
+          readonly input: I;
+          readonly error: unknown;
+          readonly completedSteps: readonly string[];
+        },
+        fx: import("./fx.ts").Fx,
+      ) => unknown | Promise<unknown>)
+    | undefined;
   /** Handler body. */
   readonly do: FlowHandler<I, O>;
   /** Triggers bound via {@link on} (zero or more). */
@@ -236,6 +264,16 @@ export function flow<Opts extends FlowOptions<any, any, any>>(
     slo: options.slo,
     plane: options.plane,
     breaking: options.breaking ?? false,
+    compensate: options.compensate as
+      | ((
+          ctx: {
+            readonly input: InferFlowIn<Opts>;
+            readonly error: unknown;
+            readonly completedSteps: readonly string[];
+          },
+          fx: import("./fx.ts").Fx,
+        ) => unknown | Promise<unknown>)
+      | undefined,
     do: options.do as FlowHandler<InferFlowIn<Opts>, InferFlowOut<Opts>>,
     triggers,
     $trigger: undefined,

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

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { createRunsRuntime } from "../runs/runtime.ts";
+import type { WideEvent } from "../runs/types.ts";
+import { createFxContext } from "./fx.ts";
+
+describe("fx.runs", () => {
+  test("window + checkSlo over bound runs runtime", async () => {
+    const runs = createRunsRuntime({ driver: "memory" });
+    await runs.open();
+    const now = Date.now();
+    const event: WideEvent = {
+      id: "r1",
+      flow: "checkout.create",
+      trigger: "http",
+      plane: "user",
+      gates: [],
+      cache: "none",
+      error: null,
+      effects: [],
+      logs: [],
+      durationMs: 250,
+      startedAt: now - 1_000,
+      endedAt: now,
+      dimensions: {},
+    };
+    await runs.append(event);
+
+    const { fx } = createFxContext({
+      flow: "ops.slo-check",
+      effects: { reads: ["runs"] },
+      runsRuntime: runs,
+      now: () => now,
+    });
+
+    const stats = await fx.runs.window("checkout.create", 5 * 60_000);
+    expect(stats.total).toBe(1);
+    expect(stats.p95Ms).toBe(250);
+
+    const breaches = await fx.runs.checkSlo(
+      "checkout.create",
+      { latency: { p95: "100ms" } },
+      5 * 60_000,
+    );
+    expect(breaches).toHaveLength(1);
+    expect(breaches[0]!.kind).toBe("latency_p95");
+
+    await runs.close();
+  });
+});

package/src/kernel/fx.test.ts

@@ -120,6 +120,20 @@ describe("fx — wholesale swap", () => {
       store() {
         throw new Error("store must not be used");
       },
+      runs: {
+        query: async () => {
+          throw new Error("runs must not be used");
+        },
+        all: async () => {
+          throw new Error("runs must not be used");
+        },
+        window: async () => {
+          throw new Error("runs must not be used");
+        },
+        checkSlo: async () => {
+          throw new Error("runs must not be used");
+        },
+      },
       async emit(signal) {
         calls.push(`emit:${typeof signal === "string" ? signal : signal.name}`);
       },

package/src/kernel/fx.ts

@@ -10,6 +10,7 @@
  */
 
 import type { Effects, ResourceRef } from "../manifest/types.ts";
+import { schemaTableName, sqlTableRef } from "../manifest/sql-resource.ts";
 import type {
   FilesStoreDecl,
   FilesStoreFxHandle,
@@ -52,9 +53,20 @@ import {
 import { maskRedactedDeep, Redacted } from "./redacted.ts";
 import type { JournalSession } from "./journal.ts";
 import type { RunTelemetry } from "./run-telemetry.ts";
+import type { RunsRuntime } from "../runs/runtime.ts";
+import type { RunsRow, WideEvent } from "../runs/types.ts";
+import {
+  evaluateSloBreaches,
+  windowStatsForFlow,
+  type RunWindowStats,
+  type SloBreach,
+} from "../runs/window.ts";
 import { translate, type MessageCatalogs } from "../i18n/messages.ts";
 import type { AppMessageKey, MessageValues } from "../i18n/types.ts";
 
+/** Resource ref Flows declare to read the Runs store via {@link Fx.runs}. */
+export const RUNS_RESOURCE = "runs";
+
 export type { FxRetryOptions, FxThunk } from "./concurrency.ts";
 
 /** Named ref: plain string or `{ name }` element handle. */
@@ -327,6 +339,45 @@ export interface FxJson {
   with<T>(data: T, meta: Record<string, unknown>): JsonResult<T>;
 }
 
+/**
+ * Flow-facing read door to the Runs wide-event store.
+ *
+ * Declare `effects: { reads: ["runs"] }`. Powers native SLO checkers
+ * (Clock + Channel) without a parallel `fx.metric` API.
+ */
+export interface FxRuns {
+  /**
+   * Run SQL against the Runs store (`FROM runs` for files/memory).
+   *
+   * @param sql - Driver SQL
+   */
+  query(sql: string): Promise<RunsRow[]>;
+  /** Materialise all visible wide events (small stores / tests). */
+  all(): Promise<WideEvent[]>;
+  /**
+   * Rolling P95 / success-rate stats for one flow over a window.
+   *
+   * @param flow - Flow name
+   * @param windowMs - Lookback window (default 5 minutes)
+   */
+  window(flow: string, windowMs?: number): Promise<RunWindowStats>;
+  /**
+   * Evaluate Manifest-style SLO thresholds against a rolling window.
+   *
+   * @param flow - Flow name
+   * @param slo - Availability / latency thresholds
+   * @param windowMs - Lookback window (default 5 minutes)
+   */
+  checkSlo(
+    flow: string,
+    slo: {
+      readonly availability?: string;
+      readonly latency?: { readonly p95?: string; readonly p99?: string };
+    },
+    windowMs?: number,
+  ): Promise<readonly SloBreach[]>;
+}
+
 /**
  * The `fx` context object — v1 surface.
  *
@@ -362,6 +413,11 @@ export interface Fx {
    * @param input - Input payload
    */
   call(flow: NamedRef, input?: unknown): Promise<unknown>;
+  /**
+   * Query the Runs wide-event store (records `read` on `"runs"`).
+   * Requires a bound runs runtime and `effects.reads` including `"runs"`.
+   */
+  readonly runs: FxRuns;
   /** Clock surface. */
   readonly clock: FxClock;
   /**
@@ -589,6 +645,11 @@ export interface CreateFxOptions {
    * configured driver (postgres = same transaction as store writes).
    */
   readonly signalRuntime?: SignalRuntime;
+  /**
+   * Optional runs runtime. When set, `fx.runs` queries wide events for
+   * native SLO checkers (Clock + Channel alerting).
+   */
+  readonly runsRuntime?: RunsRuntime;
   /**
    * Optional vault runtime. When set, `fx.vault` reads through it and
    * `fx.log` redacts loaded secret values automatically.
@@ -610,6 +671,11 @@ export interface CreateFxOptions {
    * with zero flow instrumentation.
    */
   readonly runTelemetry?: RunTelemetry;
+  /**
+   * This invocation's WideEvent / run id. Stamped onto `fx.emit` messages
+   * as `parentRunId` so consuming Flows can join the trace chain.
+   */
+  readonly runId?: string;
   /** Reveal PII through the store runtime (requires `pii:reveal` upstream). */
   readonly revealPii?: boolean;
   /**
@@ -787,6 +853,34 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         );
       }
     };
+    /**
+     * Gate a table-scoped SQL operation. Prefers the precise `sql:<table>`
+     * ref (matches what the compiler's AST inference derives from the same
+     * call site — {@link "../manifest/sql-resource.ts"}); falls back to the
+     * store-level ref when the table ref isn't declared — every flow that
+     * hand-declared the older `effects: { writes: ["sql:<store>"] }`
+     * convention (every existing template, `upsert-app.test.ts`, …) must
+     * keep working unchanged. Ledger / journal record whichever ref the
+     * capability check actually matched, not always the coarser one.
+     *
+     * @param kind - Effect kind
+     * @param table - Table argument passed to a `SqlStoreHandle` method
+     * @param body - Work to run under the gate
+     */
+    const gatedTable = <T>(
+      kind: Parameters<CapabilityToken["assert"]>[0],
+      table: unknown,
+      body: () => T | Promise<T>,
+    ): Promise<T> => {
+      const name = schemaTableName(table);
+      if (name !== undefined) {
+        const perTable = sqlTableRef(name);
+        if (perTable !== ref && capability.allows(kind, perTable)) {
+          return gated(kind, perTable, body);
+        }
+      }
+      return gated(kind, ref, body);
+    };
 
     return {
       ref,
@@ -805,7 +899,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
               limit?: number;
               offset?: number;
             }): Promise<SqlRow[]> =>
-              gated("read", ref, async () => {
+              gatedTable("read", table, async () => {
                 const h = await ensure();
                 const from = h.select(columns).from(table);
                 const filtered = plan.where === undefined ? from : from.where(plan.where);
@@ -855,14 +949,14 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         return {
           values(row) {
             const runExecute = () =>
-              gated("write", ref, async () => {
+              gatedTable("write", table, async () => {
                 refuseDryRunWrite();
                 const h = await ensure();
                 await h.insert(table).values(row).execute();
               });
             return {
               returning() {
-                return gated("write", ref, async () => {
+                return gatedTable("write", table, async () => {
                   refuseDryRunWrite();
                   const h = await ensure();
                   return h.insert(table).values(row).returning();
@@ -881,7 +975,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
           set(row) {
             return {
               where(where) {
-                return gated("write", ref, async () => {
+                return gatedTable("write", table, async () => {
                   refuseDryRunWrite();
                   const h = await ensure();
                   return h.update(table).set(row).where(where);
@@ -892,14 +986,14 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         };
       },
       findById(table, id) {
-        return gated("read", ref, async () => {
+        return gatedTable("read", table, async () => {
           const h = await ensure();
           return h.findById(table, id);
         });
       },
       delete(table: Parameters<SqlStoreHandle["delete"]>[0], id?: string) {
         if (id !== undefined) {
-          return gated("write", ref, async () => {
+          return gatedTable("write", table, async () => {
             refuseDryRunWrite();
             const h = await ensure();
             return h.delete(table, id);
@@ -907,7 +1001,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         }
         return {
           where(where: unknown) {
-            return gated("write", ref, async () => {
+            return gatedTable("write", table, async () => {
               refuseDryRunWrite();
               const h = await ensure();
               return h.delete(table).where(where);
@@ -916,20 +1010,20 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         };
       },
       exists(table, idOrWhere) {
-        return gated("read", ref, async () => {
+        return gatedTable("read", table, async () => {
           const h = await ensure();
           return h.exists(table, idOrWhere);
         });
       },
       upsert(table, matchOn, values, upsertOptions) {
-        return gated("write", ref, async () => {
+        return gatedTable("write", table, async () => {
           refuseDryRunWrite();
           const h = await ensure();
           return h.upsert(table, matchOn, values, upsertOptions);
         });
       },
       increment(table, id, column, by) {
-        return gated("write", ref, async () => {
+        return gatedTable("write", table, async () => {
           refuseDryRunWrite();
           const h = await ensure();
           return h.increment(table, id, column, by);
@@ -942,19 +1036,19 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         });
       },
       count(table, where) {
-        return gated("read", ref, async () => {
+        return gatedTable("read", table, async () => {
           const h = await ensure();
           return h.count(table, where);
         });
       },
       page(table, pageOptions) {
-        return gated("read", ref, async () => {
+        return gatedTable("read", table, async () => {
           const h = await ensure();
           return h.page(table, pageOptions);
         });
       },
       ensureTable(table) {
-        return gated("write", ref, async () => {
+        return gatedTable("write", table, async () => {
           refuseDryRunWrite();
           const h = await ensure();
           return h.ensureTable(table);
@@ -1135,13 +1229,58 @@ export function createFxContext(options: CreateFxOptions): FxContext {
     },
   };
 
+  const runsSurface: FxRuns = {
+    query(sql) {
+      return gated("read", RUNS_RESOURCE, async () => {
+        if (!options.runsRuntime) {
+          throw new Error("fx.runs.query requires a bound runs runtime (oke({ runs }))");
+        }
+        return options.runsRuntime.query(sql);
+      });
+    },
+    all() {
+      return gated("read", RUNS_RESOURCE, async () => {
+        if (!options.runsRuntime) {
+          throw new Error("fx.runs.all requires a bound runs runtime (oke({ runs }))");
+        }
+        return options.runsRuntime.all();
+      });
+    },
+    async window(flowName, windowMs = 5 * 60_000) {
+      return gated("read", RUNS_RESOURCE, async () => {
+        if (!options.runsRuntime) {
+          throw new Error("fx.runs.window requires a bound runs runtime (oke({ runs }))");
+        }
+        const events = await options.runsRuntime.all();
+        return windowStatsForFlow(events, flowName, now(), windowMs);
+      });
+    },
+    async checkSlo(flowName, slo, windowMs = 5 * 60_000) {
+      return gated("read", RUNS_RESOURCE, async () => {
+        if (!options.runsRuntime) {
+          throw new Error("fx.runs.checkSlo requires a bound runs runtime (oke({ runs }))");
+        }
+        const events = await options.runsRuntime.all();
+        const stats = windowStatsForFlow(events, flowName, now(), windowMs);
+        return evaluateSloBreaches(stats, slo);
+      });
+    },
+  };
+
   const fx: Fx = {
     store: storeHandle,
+    runs: runsSurface,
     emit(signal, payload, emitOptions) {
       const name = resolveName(signal);
       return gated("emit", name, async () => {
         if (options.signalRuntime) {
-          await options.signalRuntime.emit(name, payload, emitOptions);
+          const merged: SignalEmitOptions = {
+            ...emitOptions,
+            ...(options.runId !== undefined && emitOptions?.parentRunId === undefined
+              ? { parentRunId: options.runId }
+              : {}),
+          };
+          await options.signalRuntime.emit(name, payload, merged);
         }
       });
     },