@redflow/client 0.0.1 → 0.0.3

package/tests/redflow.e2e.test.ts

@@ -42,10 +42,7 @@ test("manual run: succeeds and records steps", async () => {
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow(
-    {
-      name: "manual-success",
-      queue: "q1",
+  const wf = defineWorkflow("manual-success", {queue: "q1",
       schema: z.object({ n: z.number().int() }),
     },
     async ({ input, step }) => {
@@ -63,7 +60,7 @@ test("manual run: succeeds and records steps", async () => {
   });
 
   const handle = await wf.run({ n: 1 });
-  const result = await handle.result({ timeoutMs: 3000, pollMs: 50 });
+  const result = await handle.result({ timeoutMs: 3000 });
   expect(result).toEqual({ ok: true, b: 3 });
 
   const steps = await client.getRunSteps(handle.id);
@@ -74,13 +71,13 @@ test("manual run: succeeds and records steps", async () => {
   redis.close();
 });
 
-test("availableAt: scheduled -> promoted -> executed", async () => {
+test("runAt: scheduled -> promoted -> executed", async () => {
   const prefix = testPrefix();
   const redis = new RedisClient(redisServer.url);
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow({ name: "delayed", queue: "q2" }, async ({ step }) => {
+  const wf = defineWorkflow("delayed", {queue: "q2" }, async ({ step }) => {
     await step.run({ name: "do" }, async () => true);
     return { ok: true };
   });
@@ -93,11 +90,11 @@ test("availableAt: scheduled -> promoted -> executed", async () => {
   });
 
   const runAt = new Date(Date.now() + 1200);
-  const handle = await wf.run({}, { availableAt: runAt });
+  const handle = await wf.run({}, { runAt });
   const state1 = await client.getRun(handle.id);
   expect(state1?.status).toBe("scheduled");
 
-  const result = await handle.result({ timeoutMs: 4000, pollMs: 50 });
+  const result = await handle.result({ timeoutMs: 4000 });
   expect(result).toEqual({ ok: true });
 
   const state2 = await client.getRun(handle.id);
@@ -109,16 +106,13 @@ test("availableAt: scheduled -> promoted -> executed", async () => {
   redis.close();
 });
 
-test("availableAt: cleared after retry exhaustion final failure", async () => {
+test("runAt: cleared after retry exhaustion final failure", async () => {
   const prefix = testPrefix();
   const redis = new RedisClient(redisServer.url);
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow(
-    {
-      name: "retry-failure-clears-available-at",
-      queue: "q2_retry_fail",
+  const wf = defineWorkflow("retry-failure-clears-available-at", {queue: "q2_retry_fail",
       retries: { maxAttempts: 2 },
     },
     async () => {
@@ -134,7 +128,7 @@ test("availableAt: cleared after retry exhaustion final failure", async () => {
   });
 
   const handle = await wf.run({});
-  await expect(handle.result({ timeoutMs: 8000, pollMs: 50 })).rejects.toThrow("Run failed");
+  await expect(handle.result({ timeoutMs: 8000 })).rejects.toThrow("Run failed");
 
   const state = await client.getRun(handle.id);
   expect(state?.status).toBe("failed");
@@ -151,10 +145,7 @@ test("NonRetriableError: skips retries and fails immediately on attempt 1", asyn
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow(
-    {
-      name: "non-retriable-error-wf",
-      queue: "q_non_retriable",
+  const wf = defineWorkflow("non-retriable-error-wf", {queue: "q_non_retriable",
       retries: { maxAttempts: 3 },
     },
     async () => {
@@ -170,7 +161,7 @@ test("NonRetriableError: skips retries and fails immediately on attempt 1", asyn
   });
 
   const handle = await wf.run({});
-  await expect(handle.result({ timeoutMs: 8000, pollMs: 50 })).rejects.toThrow("Run failed");
+  await expect(handle.result({ timeoutMs: 8000 })).rejects.toThrow("Run failed");
 
   const state = await client.getRun(handle.id);
   expect(state?.status).toBe("failed");
@@ -194,10 +185,7 @@ test("onFailure: called after retry exhaustion with correct context", async () =
 
   let failureCtx: any = null;
 
-  const wf = defineWorkflow(
-    {
-      name: "on-failure-retry-exhaustion",
-      queue: "q_on_failure_1",
+  const wf = defineWorkflow("on-failure-retry-exhaustion", {queue: "q_on_failure_1",
       retries: { maxAttempts: 2 },
       onFailure: (ctx) => {
         failureCtx = ctx;
@@ -216,7 +204,7 @@ test("onFailure: called after retry exhaustion with correct context", async () =
   });
 
   const handle = await wf.run({ some: "data" });
-  await expect(handle.result({ timeoutMs: 8000, pollMs: 50 })).rejects.toThrow("Run failed");
+  await expect(handle.result({ timeoutMs: 8000 })).rejects.toThrow("Run failed");
 
   expect(failureCtx).not.toBeNull();
   expect(failureCtx.error).toBeInstanceOf(Error);
@@ -240,10 +228,7 @@ test("onFailure: called immediately with NonRetriableError", async () => {
 
   let failureCtx: any = null;
 
-  const wf = defineWorkflow(
-    {
-      name: "on-failure-non-retriable",
-      queue: "q_on_failure_2",
+  const wf = defineWorkflow("on-failure-non-retriable", {queue: "q_on_failure_2",
       retries: { maxAttempts: 5 },
       onFailure: (ctx) => {
         failureCtx = ctx;
@@ -262,7 +247,7 @@ test("onFailure: called immediately with NonRetriableError", async () => {
   });
 
   const handle = await wf.run({});
-  await expect(handle.result({ timeoutMs: 8000, pollMs: 50 })).rejects.toThrow("Run failed");
+  await expect(handle.result({ timeoutMs: 8000 })).rejects.toThrow("Run failed");
 
   expect(failureCtx).not.toBeNull();
   expect(failureCtx.error).toBeInstanceOf(NonRetriableError);
@@ -280,10 +265,7 @@ test("onFailure: NOT called on cancellation", async () => {
 
   let onFailureCalled = false;
 
-  const wf = defineWorkflow(
-    {
-      name: "on-failure-not-on-cancel",
-      queue: "q_on_failure_3",
+  const wf = defineWorkflow("on-failure-not-on-cancel", {queue: "q_on_failure_3",
       onFailure: () => {
         onFailureCalled = true;
       },
@@ -339,11 +321,8 @@ test("cron: creates runs and executes workflow", async () => {
 
   const counterKey = `${prefix}:t:cronCount`;
 
-  defineWorkflow(
-    {
-      name: "cron-wf",
-      queue: "q4",
-      triggers: { cron: [{ expression: "*/1 * * * * *", input: { x: 1 } }] },
+  defineWorkflow("cron-wf", {queue: "q4",
+      cron: [{ expression: "*/1 * * * * *", input: { x: 1 } }],
     },
     async ({ step }) => {
       await step.run({ name: "tick" }, async () => {
@@ -394,12 +373,12 @@ test("step.runWorkflow: auto idempotency and override are forwarded to child run
     return await originalRunByName.call(this, workflowName, input, options);
   }) as RedflowClient["runByName"];
 
-  const child = defineWorkflow({ name: "child-rw-forward", queue: "q_rw_child" }, async ({ input }) => input);
+  const child = defineWorkflow("child-rw-forward", {queue: "q_rw_child" }, async ({ input }) => input);
 
   const encodePart = (value: string) => `${value.length}:${value}`;
   let expectedAutoIdempotencyKey = "";
 
-  const parent = defineWorkflow({ name: "parent-rw-forward", queue: "q_rw_parent" }, async ({ run, step }) => {
+  const parent = defineWorkflow("parent-rw-forward", {queue: "q_rw_parent" }, async ({ run, step }) => {
     expectedAutoIdempotencyKey =
       `stepwf:${encodePart(run.id)}:${encodePart("child-auto")}:${encodePart(child.name)}`;
 
@@ -419,7 +398,7 @@ test("step.runWorkflow: auto idempotency and override are forwarded to child run
 
   try {
     const handle = await parent.run({});
-    const out = await handle.result({ timeoutMs: 5000, pollMs: 50 });
+    const out = await handle.result({ timeoutMs: 5000 });
     expect(out).toEqual({
       auto: { n: 1 },
       custom: { n: 2 },
@@ -444,7 +423,7 @@ test("step.runWorkflow: child workflow executes once across parent retries", asy
   const childCountKey = `${prefix}:t:child-runWorkflow-count`;
   const failOnceKey = `${prefix}:t:parent-runWorkflow-fail-once`;
 
-  const child = defineWorkflow({ name: "child-rw-retry", queue: "q_rw_retry_child" }, async ({ step }) => {
+  const child = defineWorkflow("child-rw-retry", {queue: "q_rw_retry_child" }, async ({ step }) => {
     await step.run({ name: "count-child" }, async () => {
       await redis.incr(childCountKey);
       return true;
@@ -453,10 +432,7 @@ test("step.runWorkflow: child workflow executes once across parent retries", asy
     return { ok: true };
   });
 
-  const parent = defineWorkflow(
-    {
-      name: "parent-rw-retry",
-      queue: "q_rw_retry_parent",
+  const parent = defineWorkflow("parent-rw-retry", {queue: "q_rw_retry_parent",
       retries: { maxAttempts: 2 },
     },
     async ({ step }) => {
@@ -484,7 +460,7 @@ test("step.runWorkflow: child workflow executes once across parent retries", asy
   });
 
   const handle = await parent.run({});
-  const out = await handle.result({ timeoutMs: 8000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 8000 });
   expect(out).toEqual({ ok: true });
 
   const childCount = Number((await redis.get(childCountKey)) ?? "0");
@@ -510,10 +486,7 @@ test("step.runWorkflow: same queue avoids self-deadlock with concurrency 1", asy
   const childFailOnceKey = `${prefix}:t:child-rw-fail-once`;
   const childCountKey = `${prefix}:t:child-rw-count`;
 
-  const child = defineWorkflow(
-    {
-      name: "child-rw-single-worker",
-      queue: "q_rw_single",
+  const child = defineWorkflow("child-rw-single-worker", {queue: "q_rw_single",
       retries: { maxAttempts: 2 },
     },
     async ({ step }) => {
@@ -531,7 +504,7 @@ test("step.runWorkflow: same queue avoids self-deadlock with concurrency 1", asy
     },
   );
 
-  const parent = defineWorkflow({ name: "parent-rw-single-worker", queue: "q_rw_single" }, async ({ step }) => {
+  const parent = defineWorkflow("parent-rw-single-worker", {queue: "q_rw_single" }, async ({ step }) => {
     return await step.runWorkflow({ name: "call-child" }, child, {});
   });
 
@@ -544,7 +517,7 @@ test("step.runWorkflow: same queue avoids self-deadlock with concurrency 1", asy
   });
 
   const handle = await parent.run({});
-  const out = await handle.result({ timeoutMs: 10_000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 10_000 });
   expect(out).toEqual({ ok: true });
 
   const childCount = Number((await redis.get(childCountKey)) ?? "0");
@@ -559,241 +532,48 @@ test("step.runWorkflow: same queue avoids self-deadlock with concurrency 1", asy
   redis.close();
 }, { timeout: 20_000 });
 
-test("step.emitEvent: auto idempotency and override are forwarded", async () => {
+test("step.emitWorkflow: supports workflow name strings", async () => {
   const prefix = testPrefix();
   const redis = new RedisClient(redisServer.url);
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const observedIdempotencyKeys: string[] = [];
-  const originalEmitEvent: RedflowClient["emitEvent"] = RedflowClient.prototype.emitEvent;
-
-  RedflowClient.prototype.emitEvent = (async function (
-    this: RedflowClient,
-    name: string,
-    payload: unknown,
-    options?: Parameters<RedflowClient["emitEvent"]>[2],
-  ): Promise<Awaited<ReturnType<RedflowClient["emitEvent"]>>> {
-    if (name === "step.emit.forward" || name === "step.emit.forward.custom") {
-      observedIdempotencyKeys.push(options?.idempotencyKey ?? "");
-    }
-    return await originalEmitEvent.call(this, name, payload, options);
-  }) as RedflowClient["emitEvent"];
-
-  defineWorkflow(
-    { name: "step-emit-consumer-a", queue: "q_emit_a", triggers: { events: ["step.emit.forward"] } },
-    async () => ({ ok: true }),
-  );
-
-  defineWorkflow(
-    { name: "step-emit-consumer-b", queue: "q_emit_b", triggers: { events: ["step.emit.forward.custom"] } },
-    async () => ({ ok: true }),
-  );
-
-  const encodePart = (value: string) => `${value.length}:${value}`;
-  let expectedAutoIdempotencyKey = "";
-
-  const parent = defineWorkflow({ name: "step-emit-parent-forward", queue: "q_emit_parent" }, async ({ run, step }) => {
-    expectedAutoIdempotencyKey =
-      `stepev:${encodePart(run.id)}:${encodePart("emit-auto")}:${encodePart("step.emit.forward")}`;
+  defineWorkflow("child-emit-by-name", { queue: "q_emit_name_child" }, async ({ input }) => {
+    return { ok: true, input };
+  });
 
-    const auto = await step.emitEvent({ name: "emit-auto", event: "step.emit.forward" }, { ok: 1 });
-    const custom = await step.emitEvent(
-      { name: "emit-custom", event: "step.emit.forward.custom", idempotencyKey: "evt-custom" },
-      { ok: 2 },
+  const parent = defineWorkflow("parent-emit-by-name", { queue: "q_emit_name_parent" }, async ({ step }) => {
+    const childRunId = await step.emitWorkflow(
+      { name: "emit-child-by-name" },
+      "child-emit-by-name",
+      { value: 1 },
     );
 
-    return {
-      autoCount: auto.length,
-      customCount: custom.length,
-    };
+    return { childRunId };
   });
 
   const worker = await startWorker({
     redis,
     prefix,
-    queues: ["q_emit_parent", "q_emit_a", "q_emit_b"],
+    queues: ["q_emit_name_parent", "q_emit_name_child"],
     concurrency: 2,
     runtime: { leaseMs: 500 },
   });
 
   try {
-    const handle = await parent.run({});
-    const out = await handle.result({ timeoutMs: 5000, pollMs: 50 });
-    expect(out).toEqual({ autoCount: 1, customCount: 1 });
+    const parentHandle = await parent.run({});
+    const parentOut = await parentHandle.result({ timeoutMs: 8000 });
+    expect(typeof parentOut.childRunId).toBe("string");
 
-    expect(observedIdempotencyKeys.length).toBe(2);
-    expect(observedIdempotencyKeys[0]).toBe(expectedAutoIdempotencyKey);
-    expect(observedIdempotencyKeys[1]).toBe("evt-custom");
+    const childOut = await client.makeRunHandle(parentOut.childRunId).result({ timeoutMs: 8000 });
+    expect(childOut).toEqual({ ok: true, input: { value: 1 } });
   } finally {
-    RedflowClient.prototype.emitEvent = originalEmitEvent;
     await worker.stop();
     redis.close();
   }
-}, { timeout: 15_000 });
-
-test("step.emitEvent: emitted workflows execute once across parent retries", async () => {
-  const prefix = testPrefix();
-  const redis = new RedisClient(redisServer.url);
-  const client = createClient({ redis, prefix });
-  setDefaultClient(client);
-
-  const counterKey = `${prefix}:t:step-emit-once`;
-  const failOnceKey = `${prefix}:t:step-emit-parent-fail`;
-
-  defineWorkflow(
-    {
-      name: "step-emit-consumer-once",
-      queue: "q_emit_retry_consumer",
-      triggers: { events: ["step.emit.once"] },
-    },
-    async ({ step }) => {
-      await step.run({ name: "count" }, async () => {
-        await redis.incr(counterKey);
-        return true;
-      });
-      return { ok: true };
-    },
-  );
-
-  const parent = defineWorkflow(
-    {
-      name: "step-emit-parent-retry",
-      queue: "q_emit_retry_parent",
-      retries: { maxAttempts: 2 },
-    },
-    async ({ step }) => {
-      const runIds = await step.emitEvent({ name: "emit-once", event: "step.emit.once" }, { v: 1 });
-
-      await step.run({ name: "fail-once" }, async () => {
-        const seen = await redis.get(failOnceKey);
-        if (!seen) {
-          await redis.set(failOnceKey, "1");
-          throw new Error("fail once");
-        }
-        return true;
-      });
-
-      return { emitted: runIds.length };
-    },
-  );
-
-  const worker = await startWorker({
-    redis,
-    prefix,
-    queues: ["q_emit_retry_parent", "q_emit_retry_consumer"],
-    concurrency: 2,
-    runtime: { leaseMs: 500 },
-  });
-
-  const handle = await parent.run({});
-  const out = await handle.result({ timeoutMs: 8000, pollMs: 50 });
-  expect(out).toEqual({ emitted: 1 });
-
-  await waitFor(
-    async () => Number((await redis.get(counterKey)) ?? "0") >= 1,
-    { timeoutMs: 5000, label: "step.emitEvent consumer run" },
-  );
-
-  await new Promise((r) => setTimeout(r, 200));
-  const counter = Number((await redis.get(counterKey)) ?? "0");
-  expect(counter).toBe(1);
-
-  const consumerRuns = await client.listRuns({ workflow: "step-emit-consumer-once", limit: 10 });
-  expect(consumerRuns.length).toBe(1);
-
-  const parentState = await client.getRun(handle.id);
-  expect(parentState?.status).toBe("succeeded");
-  expect(parentState?.attempt).toBe(2);
-
-  await worker.stop();
-  redis.close();
-}, { timeout: 15_000 });
-
-test("step.scheduleEvent: scheduled workflows execute once across parent retries", async () => {
-  const prefix = testPrefix();
-  const redis = new RedisClient(redisServer.url);
-  const client = createClient({ redis, prefix });
-  setDefaultClient(client);
-
-  const counterKey = `${prefix}:t:step-schedule-once`;
-  const failOnceKey = `${prefix}:t:step-schedule-parent-fail`;
-
-  defineWorkflow(
-    {
-      name: "step-schedule-consumer-once",
-      queue: "q_schedule_retry_consumer",
-      triggers: { events: ["step.schedule.once"] },
-    },
-    async ({ step }) => {
-      await step.run({ name: "count" }, async () => {
-        await redis.incr(counterKey);
-        return true;
-      });
-      return { ok: true };
-    },
-  );
-
-  const parent = defineWorkflow(
-    {
-      name: "step-schedule-parent-retry",
-      queue: "q_schedule_retry_parent",
-      retries: { maxAttempts: 2 },
-    },
-    async ({ step }) => {
-      const runIds = await step.scheduleEvent(
-        {
-          name: "schedule-once",
-          event: "step.schedule.once",
-          schedule: { availableAt: new Date(Date.now() + 250) },
-        },
-        { v: 1 },
-      );
-
-      await step.run({ name: "fail-once" }, async () => {
-        const seen = await redis.get(failOnceKey);
-        if (!seen) {
-          await redis.set(failOnceKey, "1");
-          throw new Error("fail once");
-        }
-        return true;
-      });
-
-      return { emitted: runIds.length };
-    },
-  );
-
-  const worker = await startWorker({
-    redis,
-    prefix,
-    queues: ["q_schedule_retry_parent", "q_schedule_retry_consumer"],
-    concurrency: 2,
-    runtime: { leaseMs: 500 },
-  });
-
-  const handle = await parent.run({});
-  const out = await handle.result({ timeoutMs: 8000, pollMs: 50 });
-  expect(out).toEqual({ emitted: 1 });
-
-  await waitFor(
-    async () => Number((await redis.get(counterKey)) ?? "0") >= 1,
-    { timeoutMs: 6000, label: "step.scheduleEvent consumer run" },
-  );
+}, { timeout: 20_000 });
 
-  await new Promise((r) => setTimeout(r, 250));
-  const counter = Number((await redis.get(counterKey)) ?? "0");
-  expect(counter).toBe(1);
 
-  const consumerRuns = await client.listRuns({ workflow: "step-schedule-consumer-once", limit: 10 });
-  expect(consumerRuns.length).toBe(1);
-
-  const parentState = await client.getRun(handle.id);
-  expect(parentState?.status).toBe("succeeded");
-  expect(parentState?.attempt).toBe(2);
-
-  await worker.stop();
-  redis.close();
-}, { timeout: 15_000 });
 
 test("retries: step results are cached across attempts", async () => {
   const prefix = testPrefix();
@@ -804,10 +584,7 @@ test("retries: step results are cached across attempts", async () => {
   const step1CountKey = `${prefix}:t:step1Count`;
   const failOnceKey = `${prefix}:t:failOnce`;
 
-  const wf = defineWorkflow(
-    {
-      name: "retry-wf",
-      queue: "q5",
+  const wf = defineWorkflow("retry-wf", {queue: "q5",
       retries: { maxAttempts: 2 },
     },
     async ({ step }) => {
@@ -837,7 +614,7 @@ test("retries: step results are cached across attempts", async () => {
   });
 
   const handle = await wf.run({});
-  const out = await handle.result({ timeoutMs: 8000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 8000 });
   expect(out).toEqual({ ok: true });
 
   const step1Count = Number((await redis.get(step1CountKey)) ?? "0");
@@ -859,10 +636,7 @@ test("retries: run queued before worker start keeps workflow maxAttempts", async
 
   const failOnceKey = `${prefix}:t:retry-before-sync`;
 
-  const wf = defineWorkflow(
-    {
-      name: "retry-before-sync",
-      queue: "q5_before_sync",
+  const wf = defineWorkflow("retry-before-sync", {queue: "q5_before_sync",
       retries: { maxAttempts: 2 },
     },
     async () => {
@@ -887,7 +661,7 @@ test("retries: run queued before worker start keeps workflow maxAttempts", async
     runtime: { leaseMs: 500 },
   });
 
-  const out = await handle.result({ timeoutMs: 8000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 8000 });
   expect(out).toEqual({ ok: true });
 
   const state = await client.getRun(handle.id);
@@ -905,7 +679,7 @@ test("step timeout: run fails and error is recorded", async () => {
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow({ name: "timeout-wf", queue: "q6" }, async ({ step }) => {
+  const wf = defineWorkflow("timeout-wf", {queue: "q6" }, async ({ step }) => {
     await step.run({ name: "slow", timeoutMs: 80 }, async () => {
       await new Promise((r) => setTimeout(r, 250));
       return true;
@@ -949,7 +723,7 @@ test("cancellation: scheduled/queued/running", async () => {
 
   const touchedKey = `${prefix}:t:touched`;
 
-  const wf = defineWorkflow({ name: "cancel-wf", queue: "q7" }, async ({ step }) => {
+  const wf = defineWorkflow("cancel-wf", {queue: "q7" }, async ({ step }) => {
     await step.run({ name: "hold" }, async () => {
       await new Promise((r) => setTimeout(r, 600));
       return true;
@@ -970,7 +744,7 @@ test("cancellation: scheduled/queued/running", async () => {
       runtime: { leaseMs: 300 },
     });
 
-    const handle = await wf.run({}, { availableAt: new Date(Date.now() + 300) });
+    const handle = await wf.run({}, { runAt: new Date(Date.now() + 300) });
     const canceled = await client.cancelRun(handle.id, { reason: "test" });
     expect(canceled).toBe(true);
 
@@ -1042,7 +816,7 @@ test("cancel race: queued cancel before start does not execute handler", async (
   const queue = "q7_race";
   const sideEffectsKey = `${prefix}:t:cancelRaceSideEffects`;
 
-  const wf = defineWorkflow({ name: "cancel-race-wf", queue }, async () => {
+  const wf = defineWorkflow("cancel-race-wf", {queue }, async () => {
     await redis.incr(sideEffectsKey);
     return { ok: true };
   });
@@ -1195,7 +969,7 @@ test("idempotencyKey: same key returns same run id and executes once", async ()
 
   const countKey = `${prefix}:t:idemCount`;
 
-  const wf = defineWorkflow({ name: "idem-wf", queue: "q9" }, async ({ step }) => {
+  const wf = defineWorkflow("idem-wf", {queue: "q9" }, async ({ step }) => {
     await step.run({ name: "do" }, async () => {
       await redis.incr(countKey);
       return true;
@@ -1213,7 +987,7 @@ test("idempotencyKey: same key returns same run id and executes once", async ()
   const [h1, h2] = await Promise.all([wf.run({}, { idempotencyKey: "k" }), wf.run({}, { idempotencyKey: "k" })]);
   expect(h1.id).toBe(h2.id);
 
-  const out = await h1.result({ timeoutMs: 4000, pollMs: 50 });
+  const out = await h1.result({ timeoutMs: 4000 });
   expect(out).toEqual({ ok: true });
 
   // Give the worker a moment to potentially pick duplicates.
@@ -1233,7 +1007,7 @@ test("idempotencyKey: delayed TTL refresh cannot fork duplicate runs", async ()
 
   const countKey = `${prefix}:t:idem-race-fix-count`;
 
-  const wf = defineWorkflow({ name: "idem-race-fix", queue: "q9_race_fix" }, async ({ step }) => {
+  const wf = defineWorkflow("idem-race-fix", {queue: "q9_race_fix" }, async ({ step }) => {
     await step.run({ name: "do" }, async () => {
       await redis.incr(countKey);
       return true;
@@ -1267,8 +1041,8 @@ test("idempotencyKey: delayed TTL refresh cannot fork duplicate runs", async ()
     expect(h1.id).toBe(h2.id);
 
     const [out1, out2] = await Promise.all([
-      h1.result({ timeoutMs: 5000, pollMs: 50 }),
-      h2.result({ timeoutMs: 5000, pollMs: 50 }),
+      h1.result({ timeoutMs: 5000 }),
+      h2.result({ timeoutMs: 5000 }),
     ]);
     expect(out1).toEqual({ ok: true });
     expect(out2).toEqual({ ok: true });
@@ -1288,7 +1062,7 @@ test("enqueue: producer-side zadd failure does not leave runs orphaned", async (
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow({ name: "enqueue-atomic", queue: "q_enqueue_atomic" }, async () => ({ ok: true }));
+  const wf = defineWorkflow("enqueue-atomic", {queue: "q_enqueue_atomic" }, async () => ({ ok: true }));
   await client.syncRegistry(getDefaultRegistry());
 
   const originalZadd = redis.zadd.bind(redis);
@@ -1316,7 +1090,7 @@ test("enqueue: producer-side zadd failure does not leave runs orphaned", async (
   });
 
   try {
-    const out = await handle.result({ timeoutMs: 6000, pollMs: 50 });
+    const out = await handle.result({ timeoutMs: 6000 });
     expect(out).toEqual({ ok: true });
   } finally {
     await worker.stop();
@@ -1330,8 +1104,8 @@ test("idempotencyKey: delimiter-like workflow/key pairs do not collide", async (
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wfA = defineWorkflow({ name: "idem:a", queue: "q9a" }, async () => ({ workflow: "idem:a" }));
-  const wfB = defineWorkflow({ name: "idem:a:b", queue: "q9b" }, async () => ({ workflow: "idem:a:b" }));
+  const wfA = defineWorkflow("idem:a", {queue: "q9a" }, async () => ({ workflow: "idem:a" }));
+  const wfB = defineWorkflow("idem:a:b", {queue: "q9b" }, async () => ({ workflow: "idem:a:b" }));
 
   const worker = await startWorker({
     redis,
@@ -1349,8 +1123,8 @@ test("idempotencyKey: delimiter-like workflow/key pairs do not collide", async (
   expect(h1.id).not.toBe(h2.id);
 
   const [out1, out2] = await Promise.all([
-    h1.result({ timeoutMs: 5000, pollMs: 50 }),
-    h2.result({ timeoutMs: 5000, pollMs: 50 }),
+    h1.result({ timeoutMs: 5000 }),
+    h2.result({ timeoutMs: 5000 }),
   ]);
 
   expect(out1).toEqual({ workflow: "idem:a" });
@@ -1368,7 +1142,7 @@ test("idempotencyTtl: short TTL expires and allows a new run with same key", asy
 
   const countKey = `${prefix}:t:idemTtlCount`;
 
-  const wf = defineWorkflow({ name: "idem-ttl-wf", queue: "q_idem_ttl" }, async ({ step }) => {
+  const wf = defineWorkflow("idem-ttl-wf", {queue: "q_idem_ttl" }, async ({ step }) => {
     await step.run({ name: "count" }, async () => {
       await redis.incr(countKey);
       return true;
@@ -1385,7 +1159,7 @@ test("idempotencyTtl: short TTL expires and allows a new run with same key", asy
 
   // First run with 1-second TTL
   const h1 = await wf.run({}, { idempotencyKey: "ttl-key", idempotencyTtl: 1 });
-  const out1 = await h1.result({ timeoutMs: 5000, pollMs: 50 });
+  const out1 = await h1.result({ timeoutMs: 5000 });
   expect(out1).toEqual({ ok: true });
 
   // Same key within TTL — returns existing run
@@ -1399,7 +1173,7 @@ test("idempotencyTtl: short TTL expires and allows a new run with same key", asy
   const h3 = await wf.run({}, { idempotencyKey: "ttl-key", idempotencyTtl: 1 });
   expect(h3.id).not.toBe(h1.id);
 
-  const out3 = await h3.result({ timeoutMs: 5000, pollMs: 50 });
+  const out3 = await h3.result({ timeoutMs: 5000 });
   expect(out3).toEqual({ ok: true });
 
   // Handler executed twice (once per unique run)
@@ -1410,157 +1184,13 @@ test("idempotencyTtl: short TTL expires and allows a new run with same key", asy
   redis.close();
 });
 
-test("emitEvent idempotency: same key across different events does not collide", async () => {
-  const prefix = testPrefix();
-  const redis = new RedisClient(redisServer.url);
-  const client = createClient({ redis, prefix });
-  setDefaultClient(client);
-
-  const countKey = `${prefix}:t:evtScopeCount`;
-
-  defineWorkflow(
-    {
-      name: "evt-idem-scope",
-      queue: "q10_scope",
-      triggers: { events: ["dup.event.a", "dup.event.b"] },
-    },
-    async ({ step }) => {
-      await step.run({ name: "count" }, async () => {
-        await redis.incr(countKey);
-        return true;
-      });
-      return { ok: true };
-    },
-  );
-
-  const worker = await startWorker({
-    redis,
-    prefix,
-    queues: ["q10_scope"],
-    runtime: { leaseMs: 500 },
-  });
-
-  const runIdsA = await client.emitEvent("dup.event.a", { a: 1 }, { idempotencyKey: "evt_shared" });
-  const runIdsB = await client.emitEvent("dup.event.b", { b: 1 }, { idempotencyKey: "evt_shared" });
-
-  expect(runIdsA.length).toBe(1);
-  expect(runIdsB.length).toBe(1);
-  expect(runIdsA[0]).not.toBe(runIdsB[0]);
-
-  await Promise.all([
-    client.makeRunHandle(runIdsA[0]!).result({ timeoutMs: 5000, pollMs: 50 }),
-    client.makeRunHandle(runIdsB[0]!).result({ timeoutMs: 5000, pollMs: 50 }),
-  ]);
-
-  const cnt = Number((await redis.get(countKey)) ?? "0");
-  expect(cnt).toBe(2);
-
-  await worker.stop();
-  redis.close();
-});
-
-test("scheduleEvent: delayed fan-out is idempotent", async () => {
-  const prefix = testPrefix();
-  const redis = new RedisClient(redisServer.url);
-  const client = createClient({ redis, prefix });
-  setDefaultClient(client);
-
-  const event = "schedule.event";
-  const countKey = `${prefix}:t:schedule-event-count`;
-
-  defineWorkflow(
-    { name: "schedule-consumer", queue: "q10_schedule", triggers: { events: [event] } },
-    async ({ step }) => {
-      await step.run({ name: "count" }, async () => {
-        await redis.incr(countKey);
-        return true;
-      });
-      return { ok: true };
-    },
-  );
-
-  const worker = await startWorker({
-    redis,
-    prefix,
-    queues: ["q10_schedule"],
-    runtime: { leaseMs: 500 },
-  });
-
-  try {
-    const availableAt = new Date(Date.now() + 1200);
-    const [runIds1, runIds2] = await Promise.all([
-      client.scheduleEvent(event, { x: 1 }, { availableAt, idempotencyKey: "sched-shared" }),
-      client.scheduleEvent(event, { x: 1 }, { availableAt, idempotencyKey: "sched-shared" }),
-    ]);
-
-    expect(runIds1.length).toBe(1);
-    expect(runIds2.length).toBe(1);
-    expect(runIds1[0]).toBe(runIds2[0]);
-
-    const runId = runIds1[0]!;
-    const stateBefore = await client.getRun(runId);
-    expect(stateBefore?.status).toBe("scheduled");
-
-    const out = await client.makeRunHandle(runId).result({ timeoutMs: 7000, pollMs: 50 });
-    expect(out).toEqual({ ok: true });
-
-    const stateAfter = await client.getRun(runId);
-    expect((stateAfter?.startedAt ?? 0) + 40).toBeGreaterThanOrEqual(availableAt.getTime());
-
-    const count = Number((await redis.get(countKey)) ?? "0");
-    expect(count).toBe(1);
-  } finally {
-    await worker.stop();
-    redis.close();
-  }
-});
-
-test("emitEvent: stale subscribers are pruned and do not break fan-out", async () => {
-  const prefix = testPrefix();
-  const redis = new RedisClient(redisServer.url);
-  const client = createClient({ redis, prefix });
-  setDefaultClient(client);
-
-  const event = "stale.subscribers.event";
-  defineWorkflow(
-    { name: "stale-subscriber-live", queue: "q10_stale_subs", triggers: { events: [event] } },
-    async () => ({ ok: true }),
-  );
-
-  const worker = await startWorker({
-    redis,
-    prefix,
-    queues: ["q10_stale_subs"],
-    runtime: { leaseMs: 500 },
-  });
-
-  try {
-    await redis.sadd(keys.eventWorkflows(prefix, event), "stale-subscriber-ghost");
-
-    const runIds = await client.emitEvent(event, { v: 1 });
-    expect(runIds.length).toBe(1);
-
-    const subscribers = await redis.smembers(keys.eventWorkflows(prefix, event));
-    expect(subscribers.includes("stale-subscriber-ghost")).toBe(false);
-
-    const out = await client.makeRunHandle(runIds[0]!).result({ timeoutMs: 5000, pollMs: 50 });
-    expect(out).toEqual({ ok: true });
-  } finally {
-    await worker.stop();
-    redis.close();
-  }
-});
-
 test("input validation: invalid input fails once and is not retried", async () => {
   const prefix = testPrefix();
   const redis = new RedisClient(redisServer.url);
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  defineWorkflow(
-    {
-      name: "validate-wf",
-      queue: "q11",
+  defineWorkflow("validate-wf", {queue: "q11",
       schema: z.object({ x: z.number() }),
       retries: { maxAttempts: 3 },
     },
@@ -1649,7 +1279,7 @@ test("cancel during step: run becomes canceled and step error kind is canceled",
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow({ name: "cancel-mid-step", queue: "q12" }, async ({ step }) => {
+  const wf = defineWorkflow("cancel-mid-step", {queue: "q12" }, async ({ step }) => {
     await step.run({ name: "slow" }, async () => {
       await new Promise((r) => setTimeout(r, 2000));
       return true;
@@ -1692,7 +1322,7 @@ test("cancel during step: run becomes canceled and step error kind is canceled",
   expect((steps[0]?.error as any)?.kind).toBe("canceled");
 
   // `result()` should reject with CanceledError.
-  await expect(handle.result({ timeoutMs: 1000, pollMs: 50 })).rejects.toBeInstanceOf(CanceledError);
+  await expect(handle.result({ timeoutMs: 1000 })).rejects.toBeInstanceOf(CanceledError);
 
   await worker.stop();
   redis.close();
@@ -1707,7 +1337,7 @@ test("terminal run re-queued is ignored (no re-execution)", async () => {
   const queue = "q13";
   const countKey = `${prefix}:t:termCount`;
 
-  const wf = defineWorkflow({ name: "term-wf", queue }, async ({ step }) => {
+  const wf = defineWorkflow("term-wf", {queue }, async ({ step }) => {
     await step.run({ name: "do" }, async () => {
       await redis.incr(countKey);
       return true;
@@ -1724,7 +1354,7 @@ test("terminal run re-queued is ignored (no re-execution)", async () => {
   });
 
   const handle = await wf.run({});
-  const out = await handle.result({ timeoutMs: 4000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 4000 });
   expect(out).toEqual({ ok: true });
 
   const cnt1 = Number((await redis.get(countKey)) ?? "0");
@@ -1754,7 +1384,7 @@ test("lease+reaper: long running step is not duplicated", async () => {
   const queue = "q14";
   const countKey = `${prefix}:t:leaseCount`;
 
-  const wf = defineWorkflow({ name: "lease-wf", queue }, async ({ step }) => {
+  const wf = defineWorkflow("lease-wf", {queue }, async ({ step }) => {
     await step.run({ name: "long" }, async () => {
       await redis.incr(countKey);
       await new Promise((r) => setTimeout(r, 700));
@@ -1772,7 +1402,7 @@ test("lease+reaper: long running step is not duplicated", async () => {
   });
 
   const handle = await wf.run({});
-  const out = await handle.result({ timeoutMs: 8000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 8000 });
   expect(out).toEqual({ ok: true });
 
   const cnt = Number((await redis.get(countKey)) ?? "0");
@@ -1796,11 +1426,8 @@ test(
   const queue = "q15";
   const counterKey = `${prefix}:t:cronLockCount`;
 
-  defineWorkflow(
-    {
-      name: "cron-lock-wf",
-      queue,
-      triggers: { cron: [{ expression: "*/1 * * * * *" }] },
+  defineWorkflow("cron-lock-wf", {queue,
+      cron: [{ expression: "*/1 * * * * *" }],
     },
     async ({ step }) => {
       await step.run({ name: "tick" }, async () => {
@@ -1839,10 +1466,7 @@ test(
     const childFailOnceKey = `${prefix}:t:childFailOnce`;
     const parentBeforeKey = `${prefix}:t:parentBefore`;
 
-    const child = defineWorkflow(
-      {
-        name: "child-wf",
-        queue: "q_child",
+    const child = defineWorkflow("child-wf", {queue: "q_child",
         retries: { maxAttempts: 2 },
       },
       async ({ step, run }) => {
@@ -1864,10 +1488,7 @@ test(
       },
     );
 
-    const parent = defineWorkflow(
-      {
-        name: "parent-wf",
-        queue: "q_parent",
+    const parent = defineWorkflow("parent-wf", {queue: "q_parent",
       },
       async ({ step }) => {
         await step.run({ name: "before" }, async () => {
@@ -1877,7 +1498,7 @@ test(
 
         const childOut = await step.run({ name: "child" }, async () => {
           const h = await child.run({});
-          return await h.result({ timeoutMs: 10_000, pollMs: 50 });
+          return await h.result({ timeoutMs: 10_000 });
         });
 
         return { ok: true, child: childOut };
@@ -1893,7 +1514,7 @@ test(
     });
 
     const handle = await parent.run({});
-    const out = await handle.result({ timeoutMs: 15_000, pollMs: 50 });
+    const out = await handle.result({ timeoutMs: 15_000 });
     expect(out.ok).toBe(true);
     expect(out.child.ok).toBe(true);
     expect(out.child.attempt).toBe(2);
@@ -1925,7 +1546,7 @@ test(
     setDefaultClient(client);
 
     const queue = "q_status";
-    const wf = defineWorkflow({ name: "status-wf", queue }, async ({ step }) => {
+    const wf = defineWorkflow("status-wf", {queue }, async ({ step }) => {
       await step.run({ name: "sleep" }, async () => {
         await new Promise((r) => setTimeout(r, 350));
         return true;
@@ -1956,7 +1577,7 @@ test(
     const queuedMembers2 = await redis.zrange(queuedIndex, 0, -1);
     expect(queuedMembers2.includes(handle.id)).toBe(false);
 
-    const out = await handle.result({ timeoutMs: 8000, pollMs: 50 });
+    const out = await handle.result({ timeoutMs: 8000 });
     expect(out).toEqual({ ok: true });
 
     const succeededMembers = await redis.zrange(`${prefix}:runs:status:succeeded`, 0, -1);
@@ -1971,7 +1592,7 @@ test(
 );
 
 test(
-  "production: registry sync updates triggers (events move, cron removed)",
+  "production: registry sync updates cron definitions",
   async () => {
     const prefix = testPrefix();
     const redis = new RedisClient(redisServer.url);
@@ -1979,27 +1600,13 @@ test(
     setDefaultClient(client);
 
     const name = "update-wf";
-    const eventA = "evt.a";
-    const eventB = "evt.b";
-
-    defineWorkflow(
-      {
-        name,
-        queue: "q_update",
-        triggers: {
-          events: [eventA],
-          cron: [{ expression: "*/1 * * * * *" }],
-        },
-      },
-      async () => ({ ok: true }),
-    );
 
-    await client.syncRegistry(getDefaultRegistry());
+    defineWorkflow(name, {
+      queue: "q_update",
+      cron: [{ expression: "*/1 * * * * *" }],
+    }, async () => ({ ok: true }));
 
-    const subsA1 = await redis.smembers(`${prefix}:event:${eventA}:workflows`);
-    const subsB1 = await redis.smembers(`${prefix}:event:${eventB}:workflows`);
-    expect(subsA1.includes(name)).toBe(true);
-    expect(subsB1.includes(name)).toBe(false);
+    await client.syncRegistry(getDefaultRegistry());
 
     const workflowKey = `${prefix}:workflow:${name}`;
     const cronIdsJson = await redis.hget(workflowKey, "cronIdsJson");
@@ -2011,25 +1618,14 @@ test(
     const cronNext = await redis.zrange(`${prefix}:cron:next`, 0, -1);
     expect(cronNext.includes(cronId)).toBe(true);
 
-    // Simulate a new deployment: same workflow name, different triggers.
+    // Simulate a new deployment: same workflow name, cron removed.
     __unstableResetDefaultRegistryForTests();
-    defineWorkflow(
-      {
-        name,
-        queue: "q_update",
-        triggers: { events: [eventB] },
-      },
-      async () => ({ ok: true }),
-    );
+    defineWorkflow(name, {
+      queue: "q_update",
+    }, async () => ({ ok: true }));
 
     await client.syncRegistry(getDefaultRegistry());
 
-    const subsA2 = await redis.smembers(`${prefix}:event:${eventA}:workflows`);
-    const subsB2 = await redis.smembers(`${prefix}:event:${eventB}:workflows`);
-    expect(subsA2.includes(name)).toBe(false);
-    expect(subsB2.includes(name)).toBe(true);
-
-    // Old cron removed.
     expect(await redis.hget(`${prefix}:cron:def`, cronId)).toBeNull();
     const cronNext2 = await redis.zrange(`${prefix}:cron:next`, 0, -1);
     expect(cronNext2.includes(cronId)).toBe(false);
@@ -2051,10 +1647,7 @@ test(
     const t1Key = `${prefix}:t:attempt1`;
     const t2Key = `${prefix}:t:attempt2`;
 
-    const wf = defineWorkflow(
-      {
-        name: "backoff-wf",
-        queue,
+    const wf = defineWorkflow("backoff-wf", {queue,
         retries: { maxAttempts: 2 },
       },
       async ({ run }) => {
@@ -2073,7 +1666,7 @@ test(
     });
 
     const handle = await wf.run({});
-    const out = await handle.result({ timeoutMs: 15_000, pollMs: 50 });
+    const out = await handle.result({ timeoutMs: 15_000 });
     expect(out).toEqual({ ok: true });
 
     const t1 = Number((await redis.get(t1Key)) ?? "0");
@@ -2103,11 +1696,8 @@ test(
     const queue = "q_failover";
     const counterKey = `${prefix}:t:cronFailoverCount`;
 
-    defineWorkflow(
-      {
-        name: "cron-failover-wf",
-        queue,
-        triggers: { cron: [{ expression: "*/1 * * * * *" }] },
+    defineWorkflow("cron-failover-wf", {queue,
+        cron: [{ expression: "*/1 * * * * *" }],
       },
       async ({ step }) => {
         await step.run({ name: "tick" }, async () => {
@@ -2149,8 +1739,8 @@ test("listRuns: status + workflow filters are applied together", async () => {
 
   const queue = "q_filters";
 
-  const succeeds = defineWorkflow({ name: "filters-success", queue }, async () => ({ ok: true }));
-  const fails = defineWorkflow({ name: "filters-fail", queue }, async () => {
+  const succeeds = defineWorkflow("filters-success", {queue }, async () => ({ ok: true }));
+  const fails = defineWorkflow("filters-fail", {queue }, async () => {
     throw new Error("expected failure");
   });
 
@@ -2159,7 +1749,7 @@ test("listRuns: status + workflow filters are applied together", async () => {
   const successHandle = await succeeds.run({});
   const failHandle = await fails.run({});
 
-  await successHandle.result({ timeoutMs: 4000, pollMs: 50 });
+  await successHandle.result({ timeoutMs: 4000 });
   await waitFor(
     async () => (await client.getRun(failHandle.id))?.status === "failed",
     { timeoutMs: 6000, label: "failed run" },
@@ -2193,20 +1783,14 @@ test("cron trigger ids: same custom id in two workflows does not collide", async
   const redis = new RedisClient(redisServer.url);
   const client = createClient({ redis, prefix });
 
-  defineWorkflow(
-    {
-      name: "cron-id-a",
-      queue: "qa",
-      triggers: { cron: [{ id: "shared", expression: "*/5 * * * * *" }] },
+  defineWorkflow("cron-id-a", {queue: "qa",
+      cron: [{ id: "shared", expression: "*/5 * * * * *" }],
     },
     async () => ({ ok: true }),
   );
 
-  defineWorkflow(
-    {
-      name: "cron-id-b",
-      queue: "qb",
-      triggers: { cron: [{ id: "shared", expression: "*/5 * * * * *" }] },
+  defineWorkflow("cron-id-b", {queue: "qb",
+      cron: [{ id: "shared", expression: "*/5 * * * * *" }],
     },
     async () => ({ ok: true }),
   );
@@ -2233,11 +1817,8 @@ test("syncRegistry: cron trigger with explicit null input preserves null payload
 
   const workflowName = "cron-null-input";
 
-  defineWorkflow(
-    {
-      name: workflowName,
-      queue: "q-cron-null",
-      triggers: { cron: [{ id: "null-input", expression: "*/5 * * * * *", input: null }] },
+  defineWorkflow(workflowName, {queue: "q-cron-null",
+      cron: [{ id: "null-input", expression: "*/5 * * * * *", input: null }],
     },
     async () => ({ ok: true }),
   );
@@ -2267,11 +1848,8 @@ test("syncRegistry: invalid cron expression removes existing next schedule for s
   const workflowKey = `${prefix}:workflow:${workflowName}`;
   const cronNextKey = `${prefix}:cron:next`;
 
-  defineWorkflow(
-    {
-      name: workflowName,
-      queue: "q-cron-invalid",
-      triggers: { cron: [{ id: "stable", expression: "*/5 * * * * *" }] },
+  defineWorkflow(workflowName, {queue: "q-cron-invalid",
+      cron: [{ id: "stable", expression: "*/5 * * * * *" }],
     },
     async () => ({ ok: true }),
   );
@@ -2286,11 +1864,8 @@ test("syncRegistry: invalid cron expression removes existing next schedule for s
   expect(before.includes(cronId)).toBe(true);
 
   __unstableResetDefaultRegistryForTests();
-  defineWorkflow(
-    {
-      name: workflowName,
-      queue: "q-cron-invalid",
-      triggers: { cron: [{ id: "stable", expression: "not a valid cron" }] },
+  defineWorkflow(workflowName, {queue: "q-cron-invalid",
+      cron: [{ id: "stable", expression: "not a valid cron" }],
     },
     async () => ({ ok: true }),
   );
@@ -2303,19 +1878,15 @@ test("syncRegistry: invalid cron expression removes existing next schedule for s
   redis.close();
 });
 
-test("syncRegistry: removes stale workflow metadata (events + cron)", async () => {
+test("syncRegistry: removes stale workflow metadata (cron)", async () => {
   const prefix = testPrefix();
   const redis = new RedisClient(redisServer.url);
   const client = createClient({ redis, prefix });
 
   const workflowName = "stale-workflow";
-  const eventName = "stale.event";
 
-  defineWorkflow(
-    {
-      name: workflowName,
-      queue: "q-stale",
-      triggers: { events: [eventName], cron: [{ id: "stale", expression: "*/10 * * * * *" }] },
+  defineWorkflow(workflowName, {queue: "q-stale",
+      cron: [{ id: "stale", expression: "*/10 * * * * *" }],
     },
     async () => ({ ok: true }),
   );
@@ -2327,7 +1898,6 @@ test("syncRegistry: removes stale workflow metadata (events + cron)", async () =
   expect(cronIds.length).toBe(1);
   const cronId = cronIds[0]!;
 
-  expect((await redis.smembers(`${prefix}:event:${eventName}:workflows`)).includes(workflowName)).toBe(true);
   expect(await redis.hget(`${prefix}:cron:def`, cronId)).not.toBeNull();
 
   // Force stale age beyond grace period and sync an empty registry.
@@ -2336,7 +1906,6 @@ test("syncRegistry: removes stale workflow metadata (events + cron)", async () =
   await client.syncRegistry(getDefaultRegistry());
 
   expect((await redis.smembers(`${prefix}:workflows`)).includes(workflowName)).toBe(false);
-  expect((await redis.smembers(`${prefix}:event:${eventName}:workflows`)).includes(workflowName)).toBe(false);
   expect(await redis.hget(workflowKey, "queue")).toBeNull();
   expect(await redis.hget(`${prefix}:cron:def`, cronId)).toBeNull();
   const cronNext = await redis.zrange(`${prefix}:cron:next`, 0, -1);
@@ -2351,22 +1920,16 @@ test("syncRegistry: stale cleanup is isolated by owner", async () => {
   const client = createClient({ redis, prefix });
 
   __unstableResetDefaultRegistryForTests();
-  defineWorkflow(
-    {
-      name: "owner-a-wf",
-      queue: "qa",
-      triggers: { events: ["owner.a"], cron: [{ id: "a", expression: "*/30 * * * * *" }] },
+  defineWorkflow("owner-a-wf", {queue: "qa",
+      cron: [{ id: "a", expression: "*/30 * * * * *" }],
     },
     async () => ({ ok: true }),
   );
   await client.syncRegistry(getDefaultRegistry(), { owner: "svc-a" });
 
   __unstableResetDefaultRegistryForTests();
-  defineWorkflow(
-    {
-      name: "owner-b-wf",
-      queue: "qb",
-      triggers: { events: ["owner.b"], cron: [{ id: "b", expression: "*/30 * * * * *" }] },
+  defineWorkflow("owner-b-wf", {queue: "qb",
+      cron: [{ id: "b", expression: "*/30 * * * * *" }],
     },
     async () => ({ ok: true }),
   );
@@ -2392,7 +1955,7 @@ test("cancelRun: terminal runs are unchanged", async () => {
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow({ name: "cancel-terminal", queue: "q_cancel_terminal" }, async () => ({ ok: true }));
+  const wf = defineWorkflow("cancel-terminal", {queue: "q_cancel_terminal" }, async () => ({ ok: true }));
 
   const worker = await startWorker({
     redis,
@@ -2402,7 +1965,7 @@ test("cancelRun: terminal runs are unchanged", async () => {
   });
 
   const handle = await wf.run({});
-  await handle.result({ timeoutMs: 4000, pollMs: 50 });
+  await handle.result({ timeoutMs: 4000 });
 
   const before = await client.getRun(handle.id);
   const canceled = await client.cancelRun(handle.id, { reason: "late" });
@@ -2423,10 +1986,7 @@ test("output serialization: non-JSON output fails once and is not stuck", async
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow(
-    {
-      name: "serialization-fail",
-      queue: "q_serial",
+  const wf = defineWorkflow("serialization-fail", {queue: "q_serial",
       retries: { maxAttempts: 3 },
     },
     async () => ({ bad: 1n }),
@@ -2467,10 +2027,7 @@ test("retry step sequence: new steps keep monotonic order after cached steps", a
 
   const failOnceKey = `${prefix}:t:seq-fail-once`;
 
-  const wf = defineWorkflow(
-    {
-      name: "seq-retry",
-      queue: "q_seq",
+  const wf = defineWorkflow("seq-retry", {queue: "q_seq",
       retries: { maxAttempts: 2 },
     },
     async ({ step }) => {
@@ -2498,7 +2055,7 @@ test("retry step sequence: new steps keep monotonic order after cached steps", a
   });
 
   const handle = await wf.run({});
-  await handle.result({ timeoutMs: 12_000, pollMs: 50 });
+  await handle.result({ timeoutMs: 12_000 });
 
   const rawSteps = await redis.hgetall(`${prefix}:run:${handle.id}:steps`);
   const seq1 = safeJsonParse<any>(rawSteps.step1 ?? null).seq;
@@ -2520,7 +2077,7 @@ test("listRuns: negative offset is clamped to zero", async () => {
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow({ name: "offset-wf", queue: "q_offset" }, async () => ({ ok: true }));
+  const wf = defineWorkflow("offset-wf", {queue: "q_offset" }, async () => ({ ok: true }));
   const worker = await startWorker({
     redis,
     prefix,
@@ -2529,13 +2086,13 @@ test("listRuns: negative offset is clamped to zero", async () => {
   });
 
   const h1 = await wf.run({});
-  await h1.result({ timeoutMs: 4000, pollMs: 50 });
+  await h1.result({ timeoutMs: 4000 });
   await new Promise((r) => setTimeout(r, 5));
   const h2 = await wf.run({});
-  await h2.result({ timeoutMs: 4000, pollMs: 50 });
+  await h2.result({ timeoutMs: 4000 });
   await new Promise((r) => setTimeout(r, 5));
   const h3 = await wf.run({});
-  await h3.result({ timeoutMs: 4000, pollMs: 50 });
+  await h3.result({ timeoutMs: 4000 });
 
   const fromZero = await client.listRuns({ workflow: "offset-wf", limit: 1, offset: 0 });
   const fromNegative = await client.listRuns({ workflow: "offset-wf", limit: 1, offset: -1 });
@@ -2577,10 +2134,7 @@ test("error serialization: non-serializable thrown values do not wedge a run", a
   const client = createClient({ redis, prefix });
   setDefaultClient(client);
 
-  const wf = defineWorkflow(
-    {
-      name: "throw-bigint",
-      queue: "q_bigint",
+  const wf = defineWorkflow("throw-bigint", {queue: "q_bigint",
       retries: { maxAttempts: 2 },
     },
     async () => {
@@ -2619,20 +2173,14 @@ test("cron trigger ids: delimiter-like custom ids do not collide", async () => {
   const redis = new RedisClient(redisServer.url);
   const client = createClient({ redis, prefix });
 
-  defineWorkflow(
-    {
-      name: "wf:a",
-      queue: "qa",
-      triggers: { cron: [{ id: "b:c", expression: "*/5 * * * * *" }] },
+  defineWorkflow("wf:a", {queue: "qa",
+      cron: [{ id: "b:c", expression: "*/5 * * * * *" }],
     },
     async () => ({ ok: true }),
   );
 
-  defineWorkflow(
-    {
-      name: "wf:a:b",
-      queue: "qb",
-      triggers: { cron: [{ id: "c", expression: "*/5 * * * * *" }] },
+  defineWorkflow("wf:a:b", {queue: "qb",
+      cron: [{ id: "c", expression: "*/5 * * * * *" }],
     },
     async () => ({ ok: true }),
   );
@@ -2669,7 +2217,7 @@ test("idempotencyKey: stale pointer is recovered instead of returning missing ru
   const workflowName = "idem-recover";
   const idem = "stale-key";
 
-  const wf = defineWorkflow({ name: workflowName, queue }, async () => ({ ok: true }));
+  const wf = defineWorkflow(workflowName, {queue }, async () => ({ ok: true }));
 
   const worker = await startWorker({
     redis,
@@ -2685,7 +2233,7 @@ test("idempotencyKey: stale pointer is recovered instead of returning missing ru
   const handle = await wf.run({}, { idempotencyKey: idem });
   expect(handle.id).not.toBe(staleRunId);
 
-  const out = await handle.result({ timeoutMs: 5000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 5000 });
   expect(out).toEqual({ ok: true });
 
   const resolved = await redis.get(idempotencyRedisKey);
@@ -2706,7 +2254,7 @@ test("idempotencyKey: partial existing run is repaired and executed", async () =
   const idem = "partial-key";
   const countKey = `${prefix}:t:idem-partial-count`;
 
-  const wf = defineWorkflow({ name: workflowName, queue }, async ({ step }) => {
+  const wf = defineWorkflow(workflowName, {queue }, async ({ step }) => {
     await step.run({ name: "do" }, async () => {
       await redis.incr(countKey);
       return true;
@@ -2742,7 +2290,7 @@ test("idempotencyKey: partial existing run is repaired and executed", async () =
   const handle = await wf.run({}, { idempotencyKey: idem });
   expect(handle.id).toBe(runId);
 
-  const out = await handle.result({ timeoutMs: 6000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 6000 });
   expect(out).toEqual({ ok: true });
 
   const count = Number((await redis.get(countKey)) ?? "0");
@@ -2757,16 +2305,11 @@ test("syncRegistry: duplicate custom cron ids in one workflow are rejected", asy
   const redis = new RedisClient(redisServer.url);
   const client = createClient({ redis, prefix });
 
-  defineWorkflow(
-    {
-      name: "dup-custom-cron-id",
-      queue: "q_dup_cron_id",
-      triggers: {
-        cron: [
-          { id: "same", expression: "*/5 * * * * *", input: { n: 1 } },
-          { id: "same", expression: "*/7 * * * * *", input: { n: 2 } },
-        ],
-      },
+  defineWorkflow("dup-custom-cron-id", {queue: "q_dup_cron_id",
+      cron: [
+        { id: "same", expression: "*/5 * * * * *", input: { n: 1 } },
+        { id: "same", expression: "*/7 * * * * *", input: { n: 2 } },
+      ],
     },
     async () => ({ ok: true }),
   );
@@ -2783,7 +2326,7 @@ test("scheduled promoter: stale scheduled entry does not resurrect terminal run"
   setDefaultClient(client);
 
   const queue = "q_sched_guard";
-  const wf = defineWorkflow({ name: "sched-guard", queue }, async ({ step }) => {
+  const wf = defineWorkflow("sched-guard", {queue }, async ({ step }) => {
     await step.run({ name: "once" }, async () => true);
     return { ok: true };
   });
@@ -2796,7 +2339,7 @@ test("scheduled promoter: stale scheduled entry does not resurrect terminal run"
   });
 
   const handle = await wf.run({});
-  const out = await handle.result({ timeoutMs: 5000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 5000 });
   expect(out).toEqual({ ok: true });
 
   const firstState = await client.getRun(handle.id);
@@ -2824,11 +2367,8 @@ test(
     const workflowName = "cron-retry";
     const counterKey = `${prefix}:t:cron-retry-count`;
 
-    defineWorkflow(
-      {
-        name: workflowName,
-        queue,
-        triggers: { cron: [{ expression: "*/1 * * * * *" }] },
+    defineWorkflow(workflowName, {queue,
+        cron: [{ expression: "*/1 * * * * *" }],
       },
       async ({ step }) => {
         await step.run({ name: "tick" }, async () => {
@@ -2893,11 +2433,8 @@ test(
     const counterKey = `${prefix}:t:cronStaleCount`;
     const cronLockKey = keys.lockCron(prefix);
 
-    defineWorkflow(
-      {
-        name: workflowName,
-        queue,
-        triggers: { cron: [{ expression: "*/1 * * * * *" }] },
+    defineWorkflow(workflowName, {queue,
+        cron: [{ expression: "*/1 * * * * *" }],
       },
       async ({ step }) => {
         await step.run({ name: "tick" }, async () => {
@@ -2950,8 +2487,8 @@ test("workflow names ending with ':runs' do not collide with workflow run indexe
   setDefaultClient(client);
 
   const queue = "q_keyspace";
-  const base = defineWorkflow({ name: "keyspace-base", queue }, async () => ({ ok: "base" }));
-  defineWorkflow({ name: "keyspace-base:runs", queue }, async () => ({ ok: "suffix" }));
+  const base = defineWorkflow("keyspace-base", {queue }, async () => ({ ok: "base" }));
+  defineWorkflow("keyspace-base:runs", {queue }, async () => ({ ok: "suffix" }));
 
   expect(keys.workflow(prefix, "keyspace-base:runs")).not.toBe(keys.workflowRuns(prefix, "keyspace-base"));
 
@@ -2963,7 +2500,7 @@ test("workflow names ending with ':runs' do not collide with workflow run indexe
   });
 
   const handle = await base.run({});
-  const out = await handle.result({ timeoutMs: 5000, pollMs: 50 });
+  const out = await handle.result({ timeoutMs: 5000 });
   expect(out).toEqual({ ok: "base" });
 
   const suffixMeta = await client.getWorkflowMeta("keyspace-base:runs");
@@ -2980,7 +2517,7 @@ test("cancelRun race: near-finish cancellation settles as canceled", async () =>
   setDefaultClient(client);
 
   const queue = "q_cancel_late";
-  const wf = defineWorkflow({ name: "cancel-late", queue }, async ({ step }) => {
+  const wf = defineWorkflow("cancel-late", {queue }, async ({ step }) => {
     await step.run({ name: "short" }, async () => {
       await new Promise((r) => setTimeout(r, 100));
       return true;
@@ -3025,7 +2562,7 @@ test("cancelRun race: near-finish cancellation settles as canceled", async () =>
     const canceled = await cancelPromise;
     expect(canceled).toBe(true);
 
-    await expect(handle.result({ timeoutMs: 8000, pollMs: 50 })).rejects.toBeInstanceOf(CanceledError);
+    await expect(handle.result({ timeoutMs: 8000 })).rejects.toBeInstanceOf(CanceledError);
 
     const state = await client.getRun(handle.id);
     expect(state?.status).toBe("canceled");
@@ -3044,7 +2581,7 @@ test("cancelRun race: cancellation requested during finalize wins over success",
   setDefaultClient(client);
 
   const queue = "q_cancel_finalize_race";
-  const wf = defineWorkflow({ name: "cancel-finalize-race", queue }, async () => {
+  const wf = defineWorkflow("cancel-finalize-race", {queue }, async () => {
     return { ok: true };
   });
 
@@ -3089,7 +2626,7 @@ test("cancelRun race: cancellation requested during finalize wins over success",
       { timeoutMs: 6000, label: "run canceled in finalize race" },
     );
 
-    await expect(handle.result({ timeoutMs: 1000, pollMs: 50 })).rejects.toBeInstanceOf(CanceledError);
+    await expect(handle.result({ timeoutMs: 1000 })).rejects.toBeInstanceOf(CanceledError);
 
     const state = await client.getRun(handle.id);
     expect(state?.status).toBe("canceled");
@@ -3109,7 +2646,7 @@ test(
     setDefaultClient(client);
 
     const queue = "q_stop_abort";
-    const wf = defineWorkflow({ name: "stop-abort", queue }, async () => {
+    const wf = defineWorkflow("stop-abort", {queue }, async () => {
       await new Promise<never>(() => {});
     });
 
@@ -3151,4 +2688,4 @@ test(
     }
   },
   { timeout: 20_000 },
-);
+);