feat: checkout-saga demo site + five day-scale recipes - #10
Open
cansirin wants to merge 12 commits into
Open
Conversation
A self-contained wrangler project showing a Cmd loop authored as Effect programs (`@demlik/tea/effect`) running inside a Durable Object, with the payment retry ladder kept as reducer STATE rather than `Schedule` state inside a fiber. The proof: `POST /order/crash` calls `ctx.abort()` mid-retry. The isolate, the ManagedRuntime and every in-flight fiber die. The persisted State and the armed DO alarm survive, the alarm wakes a fresh isolate, and the saga finishes `settled` with no further requests. Plain Effect cannot do this — its `Schedule` state lives in the process that just died. Two bridge/library fixes the example forced out: - `LoweringOptions.runtime` was typed `EffectRunner<R | TeaEnv>`, which is unsatisfiable in practice: `effectCell` provides the two tea services itself, `EffectRunner`'s parameter is contravariant, and so the `ManagedRuntime<R, never>` built from the app's Layer was not assignable. Every consumer would have needed a cast. Now `EffectRunner<R>`. - `work-queue`'s `globalThis.crypto` does not compile for a consumer on a Workers tsconfig (no DOM lib — the global is `const`, not a property of `typeof globalThis`). Read it structurally instead. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The demo only proved half its point: with one lane on screen, "it resumed" looks indistinguishable from "nothing happened". Add the control. Lane A (`NaiveOrderDO`) runs the same checkout, same flaky provider, same 2.5s/5s ladder — written the ordinary way, with no tea. The status row is persisted, but the ladder itself is a `for` loop binding and an `await sleep(delay)` in one isolate's memory, which is what an Effect `Schedule` or a p-retry loop gives you. Uncrashed it settles exactly like lane B, so the comparison is fair. Crashed, its row says "paying, attempt 2, retrying in 5000ms" forever, and `loopAlive: false` / `frozen: true` is the honest admission that nobody is coming. `/both/<action>` fans one explosion out to both lanes so a viewer watches a single `ctx.abort()` kill one order and not the other. Page rewrite, still no framework: - Per-lane retry ladder as attempt dots (failed / pending / ok) plus a live countdown to nextRetryAt, and a "last progress Ns ago" that climbs forever on the dead lane. - The kill button is now unmissable and entirely client-side on click: page flash + shake, button disables and relabels (killing… → isolate destroyed), a red "💥 isolate destroyed" divider spliced into both event feeds at the client-side crash instant, and both cards drop into a dead state BEFORE any server response. The divergence then plays out through polling — lane B flips to a green "resumed from storage at attempt N", lane A hardens to "nothing is coming — the retry died with the process". - No more silent no-ops: killing with nothing in flight says "start an order first", and a failed crash request says so. - Polling is 500ms only while a saga is in flight, 2s when idle, and stops outright once both lanes are terminal-or-frozen. The quiet is the point. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ople
Two problems, one root cause and one taste correction.
The crash presentation did not survive a re-render. `crashedAt` lived in a
closure variable and the button label, dead-state classes and feed divider
were set imperatively inside the kill handler — so the next 500ms poll
re-rendered from server state and quietly erased every trace that anything
had exploded. A reload erased it harder. The demo about state that outlives
the process was itself losing state the moment anything re-rendered.
So the crash gets written down. `crashedAt` persists in sessionStorage keyed
by order id, and every visual is now derived from (crashedAt, server state)
on each render rather than mutated once:
- the divider is spliced back into each feed at its chronological position,
with post-crash rows tinted green;
- dead-state styling holds until a lane actually progresses past the crash
(lane A: never; lane B: until its log advances);
- lane B's "✅ resumed from storage at attempt N" is derived, so it persists;
- the kill button's "☠️ isolate destroyed" is derived too, with the
transient "killing…" expressed as a timestamp rather than a one-shot
mutation so recomputing is always safe.
`crashedAt` anchors to the newest SERVER-stamped event seen at kill time, not
to the browser clock, so the divider cannot misfile events under clock skew.
The ~10-15s gap while the Durable Object alarm wakes a fresh isolate used to
render as nothing happening. Lane B now says so: "⏳ isolate destroyed —
waiting for the Durable Object alarm to wake a fresh one…", replaced by the
green resumed banner the moment it comes back.
And per founder feedback, the theatrics are gone: no page shake, no full-page
flash, no animation on the kill click. The information carries it — label,
divider, card state, banners. The only motion left is the slow pending pulse,
and a prefers-reduced-motion block now yields all of it.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…able
Four fixes from a live drive-through, plus deploy-readiness and reader docs.
Restarting an order was silently broken. Two independent causes:
- `start` no-opped on any non-terminal saga, and an order killed mid-retry
is still "paying" as far as State knows. Pressing Start again did nothing
while the naive lane restarted from scratch, so the two lanes ended up on
different rungs — a demo that looks broken rather than convincing. An
explicit start now always restarts; only a genuine double-click (a second
start within 1.5s of the first one's own log entries) is ignored, which the
reducer can tell apart using the log's timestamps without holding a clock.
- The naive lane answered `/start` by reading its row while the
fire-and-forget loop was still landing its first write, so start replied
with an empty, idle order — "start wiped my lanes". It now lands the
opening row before responding, and reports attempt 1 immediately so both
lanes agree from the very first response.
Also hardened: a failed boot is no longer memoized. Caching the rejected
promise turned one bad boot into a permanently poisoned object that answered
503 until the runtime recycled the isolate — which matches the 503 window seen
before the lanes came back empty.
The kill window was unusably tight. A ~7s saga meant sniping the button
mid-sentence. The provider now declines three attempts on a 3s/6s/12s ladder,
so a presenter has ~20s to talk over. FLAKY_ATTEMPTS and the policy live in the
machine module and are imported by the Effect layer and the naive lane, so the
two lanes cannot drift into an unfair race.
The feed divider could misfile events. `/both/crash` now returns the worker's
own timestamp and the page anchors `crashedAt` to it — the same clock that
stamps the event log, so the divider lands exactly between the last pre-crash
event and the first post-crash one. The client clock is only a provisional
anchor for the instant before the response arrives.
Every Start now mints a fresh order id (shown in the input), so a run always
begins on a clean Durable Object instead of inheriting a previous run's saga,
armed alarm and leftover local state. The id persists across a reload, so
reloading still shows the run you were watching, crash chrome and all. The box
stays editable for the oos- path.
Deploy-readiness: the worker is named `demlik-checkout-saga` and both DO classes
are declared `new_sqlite_classes` in a single v1 migration — SQLite-backed DOs
are what the free tier supports, and this worker has never been deployed, so
there is no backend to migrate away from. Verified with `wrangler deploy
--dry-run`. Anyone with pre-existing `wrangler dev` state must delete
`.wrangler/` first; the config says so.
For the reader: a collapsible "How this works" section on the page covering what
the two lanes are, what `ctx.abort()` really does, and where Effect fits (with
the note that Effect deliberately does NOT own the retrying — a Schedule lives
in the process, and the process is the thing that dies), a footer linking the
source, and a README covering the demo, local setup, a file tour and pointers
into the parts worth reading.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The state strip advertised six phases while only two ever visibly lit up. Reserving was instantaneous and refunding/failed hid behind a typed `oos-` id, so the strip raised a question the demo never answered. Reserving and refunding are now real phases with real duration, and — the part that matters — durable duration. Both external calls became two round trips with a wait between them: `reserve` lodges the request, `reserve_confirm` collects the warehouse's answer 4s later; `refund` submits, `refund_confirm` clears it 3s later. The wait itself is one `dueAt` field in State plus one DO alarm, with the PHASE deciding what the wait means. That is what turns "killed while reserving" from an instantaneous blip into a case the saga has to survive — and it does, from a fresh isolate, in whichever phase it died. The refund path is now a first-class scenario instead of a trick. Two buttons: "Start: order that settles" (three declines, 3s/6s/12s, then stock) and "Start: order that gets refunded" (clears on the second try so the interesting part arrives sooner, then out of stock). The oos- convention survives as the internal scenario flag, but the buttons mint the id and nobody types it. Across the two runs the order visits all six states. The naive lane implements the same two waits as in-memory sleeps, so the comparison stays fair — uncrashed, both lanes still settle identically. Killed, its frozen caption is now phase-aware, because WHAT was lost depends on where it died: frozen while paying is a customer who never got charged, frozen while refunding is a customer whose money is sitting in limbo with nothing scheduled to return it. `strandedMoney` (frozen with a payment already captured) is the expensive case and the UI says so. Verified live: killed at +8.3s, inside the refund window, the tea lane confirmed and cleared the refund at +10.0s from an isolate that did not exist when the refund was submitted, while the naive lane's log simply stops (`phase: refunding, refunded: false, strandedMoney: true`) and stays that way. Same shape for a kill during reserving. Docs: a "the worst moment to be killed is during the refund" paragraph, and a fourth section, "Where tea fits in", covering the substrate's own story — the reducer as `(state, msg) -> [state, cmds]`, the saga as a value rather than the position of a paused function, effects as data the reducer requests, the save-before-effects ordering that makes a fresh isolate's resume exact, and the retry battery's inspectable policy state feeding the very attempt dots on the page. The Effect section stays about Effect. Tests: 9, including three resume-from-serialized-state tests that kill the runtime mid-ladder, mid-reservation and mid-refund, plus stale/duplicate tick idempotence. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Five self-contained recipes showing one real-world durable-process shape each as a pure tea machine: a durable agent run (budget cap, provider retry ladder, open-ended human approval), a 21-day dunning ladder, an expense approval chain whose state doubles as its audit log, a cancellable onboarding drip, and a per-device desired-vs-reported reconcile loop. Where the checkout-saga demo compresses days into seconds to be watched, these are the shapes at their real time scale — none of them can live in a process, so every wait is a number in state and a `tick` Msg carries `now`. Every suite includes a resume-from-serialized-state test: JSON out, fresh runtime in, drive to completion. Also fixes `LoweringOptions.runtime` in the Effect bridge, which asked for `EffectRunner<R | TeaEnv>` when `effectCell` provides `TeaCtx` / `TeaDispatch` itself — so the obvious call site, `ManagedRuntime.make(AppLayer)`, would not assign. The bridge's own tests never caught it because the root tsconfig excludes `*.test.ts`. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Brings in the five recipe machines (durable-agent-run, dunning, approval-chain, onboarding-drip, fleet-reconcile) plus their harness and README — 28 tests, green after the merge. Two conflicts, both trivial: - `src/effect/to-interpret.ts` — both branches independently found and fixed the same bug: `LoweringOptions.runtime` was typed `EffectRunner<R | TeaEnv>`, which no `ManagedRuntime` can satisfy because the parameter is contravariant. Same one-line resolution on both sides; kept once, with this branch's longer explanation of why. - `examples/tsconfig.json` — the two excludes are independent, so they union. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
An embedded git worktree under examples/checkout-saga/.claude/ got swept into the merge commit. Remove it and ignore the path. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The recipe machines were library-grade but invisible — five directories of
tests proving things nobody could see. They now have panels on the same worker
as the checkout hero, at /recipes.
The hosting is deliberately generic. ONE `RecipeDO` class runs whichever
machine its own name points at (`recipe:<id>:<instance>`), so adding a recipe
is a registry entry — no new DO class, no new migration. `registry.ts` puts all
five behind one small surface (phase, facts, chips, narrative, actions, apply)
and the page draws any of them with the same helpers. Five bespoke panels would
have been five times the code for no extra argument, so the panels are plainer
than the hero on purpose.
TIME TRAVEL IS A BUTTON, and honestly labelled. Every recipe is pure over
`now` — the reducer receives `at` on the Msg and never reads a clock — so ⏩
dispatches the exact `tick` a Durable Object alarm would have delivered, with
the timestamp it would have carried. The host holds a PERSISTED clock skew
rather than faking one timestamp, so the whole instance stays on one timeline:
fast-forward four days, approve, and the audit log says four days. Each panel
says "in production these ⏩ buttons are Durable Object alarms".
Every panel has 💥 kill via `ctx.abort()`, reusing the checkout page's
crash machinery (persisted `crashedAt`, keyed per recipe instance, all chrome
derived so a poll or reload cannot erase it). The event feed is persisted in the
DO for the same reason — the crash divider needs something to sit between.
Verified live, both required flows:
- agent-run: start → ⏩ next retry → parks at awaiting-approval with $0.32
spent → 💥 kill → fresh isolate still shows awaiting-approval with
`dueAt: null` (nothing scheduled, which is the point) → approve → step 3
runs and the run completes at $0.47. The approval wait has no timer to
lose, so the kill costs nothing.
- dunning: start → ⏩ ⏩ ⏩ ⏩ walks day 1, day 3, day 7, grace, downgraded
with the clock 14 days ahead and the retry calendar rendered as chips.
One real bug found and fixed while wiring the feed: it diffed the adapter's
narrative by INDEX, but some adapters derive their narrative freshly from
current state rather than appending — fleet-reconcile's "2 push attempts
failed" replaces "1 push attempt failed" at the same position, and dunning's
grace line gives way to its downgrade line. An index diff saw no growth, so it
dropped the new line and left the stale one on screen (dunning never showed
"grace expired — account downgraded"). Matching on content instead appends the
new line and keeps the old one as history, which is what a feed should do.
Bundle is 2.2 MiB raw / 441 KiB gzip, `wrangler deploy --dry-run` clean with
all three DO classes. The checkout hero is untouched and still diverges
correctly on a kill mid-refund.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…plied upstream Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
There was a problem hiding this comment.
Pull request overview
This PR adds a Cloudflare Workers Durable Object demo (“checkout-saga”) plus a new examples/recipes set of five day-scale state machines (with resume-from-serialized-state tests) to showcase durable workflow patterns built on @demlik/tea. It also includes two small core fixes discovered while building these consumers (Effect bridge runtime typing and Workers crypto typing in work-queue), and wires up separate typecheck/test entrypoints for the new examples.
Changes:
- Add the
examples/checkout-sagademo worker (two-lane saga +/recipesUI + generic Recipe DO host). - Add
examples/recipes(five durable workflow recipes + shared harness + vitest/tsconfig + tests). - Fix Effect bridge
LoweringOptions.runtimetyping and work-queuecryptotyping; add scripts to typecheck/test recipes separately.
Reviewed changes
Copilot reviewed 35 out of 37 changed files in this pull request and generated 2 comments.
Show a summary per file
| File | Description |
|---|---|
| src/work-queue/index.ts | Makes ID generation compatible with Workers typings by avoiding globalThis.crypto property access. |
| src/effect/to-interpret.ts | Fixes LoweringOptions.runtime to accept EffectRunner<R> (avoids contravariance assignment issues). |
| package.json | Adds typecheck:recipes and test:recipes scripts. |
| examples/tsconfig.json | Excludes checkout-saga and recipes from the shared examples TS project. |
| examples/recipes/vitest.config.ts | Adds a Vitest config scoped to recipes tests. |
| examples/recipes/tsconfig.json | Adds a recipes TS config (Node types, ES2022 lib, includes tests). |
| examples/recipes/README.md | Documents the five recipes, the “no sleep” convention, and how to run tests/typecheck. |
| examples/recipes/harness.ts | Adds shared test harness utilities (memStore, collect). |
| examples/recipes/onboarding-drip/onboarding-drip.test.ts | Adds onboarding-drip tests including resume-from-serialized-state coverage. |
| examples/recipes/onboarding-drip/machine.ts | Implements onboarding drip recipe machine (pure schedule walker with cancellation). |
| examples/recipes/fleet-reconcile/machine.ts | Implements per-device desired-vs-reported reconcile loop recipe with backoff and timeouts. |
| examples/recipes/fleet-reconcile/fleet-reconcile.test.ts | Adds fleet-reconcile tests including resume-from-serialized-state coverage. |
| examples/recipes/durable-agent-run/services.ts | Adds Effect service + typed failure and a deterministic fake for the agent-run recipe. |
| examples/recipes/durable-agent-run/machine.ts | Implements durable agent run recipe machine (retry ladder + human approval wait + budget ledger). |
| examples/recipes/durable-agent-run/handlers.ts | Adds Effect-authored Cmd handlers lowered via toInterpret for the agent-run recipe. |
| examples/recipes/durable-agent-run/durable-agent-run.test.ts | Adds agent-run tests including resume-from-serialized-state coverage. |
| examples/recipes/dunning/machine.ts | Implements dunning ladder recipe machine (day 1/3/7 retries + grace + downgrade). |
| examples/recipes/dunning/dunning.test.ts | Adds dunning tests including resume-from-serialized-state coverage. |
| examples/recipes/approval-chain/machine.ts | Implements approval-chain recipe machine (ordered approvers + reminder/escalation + audit log state). |
| examples/recipes/approval-chain/approval-chain.test.ts | Adds approval-chain tests including resume-from-serialized-state coverage. |
| examples/checkout-saga/wrangler.jsonc | Adds Wrangler config (DO bindings + sqlite-backed migrations + observability). |
| examples/checkout-saga/vitest.config.ts | Adds Vitest config scoped to checkout-saga tests. |
| examples/checkout-saga/tsconfig.json | Adds a Workers-oriented TS config for the demo project. |
| examples/checkout-saga/test/machine.test.ts | Adds checkout saga tests (two scenarios + reducer edges + multiple resume-from-storage cases). |
| examples/checkout-saga/src/worker.ts | Implements the Worker + DO hosts + HTTP routing for both saga lanes and recipe panels. |
| examples/checkout-saga/src/services.ts | Adds Effect services + tagged errors + fake layer for the checkout saga demo. |
| examples/checkout-saga/src/recipes/registry.ts | Registers and adapts the five recipes behind a uniform surface for the generic Recipe DO + UI. |
| examples/checkout-saga/src/recipes/page.ts | Adds the /recipes HTML page that renders all recipe panels from the registry. |
| examples/checkout-saga/src/recipes/do.ts | Implements the generic Recipe Durable Object (virtual clock skew + persisted feed + alarm wiring). |
| examples/checkout-saga/src/page.ts | Adds the main checkout demo UI page (two lanes + crash chrome + “how it works” sections). |
| examples/checkout-saga/src/naive.ts | Implements the control (naive) lane whose retry/waits live in-process via sleeps. |
| examples/checkout-saga/src/machine.ts | Implements the pure checkout saga machine (all waits expressed as persisted dueAt). |
| examples/checkout-saga/src/handlers.ts | Implements Effect-authored saga Cmd handlers lowered via toInterpret. |
| examples/checkout-saga/README.md | Documents the demo, scenarios, local run steps, curl driving, and file map. |
| examples/checkout-saga/package.json | Adds per-example package metadata and scripts for dev/typecheck/test. |
| .gitignore | Ignores Wrangler local state and Claude-related local/worktree paths. |
Files not reviewed (1)
- examples/checkout-saga/pnpm-lock.yaml: Generated file
Suppressed comments (1)
examples/checkout-saga/src/recipes/registry.ts:720
fleet-reconcile’spush_configinterpret stampspush_ok/push_failedwithDate.now(). Because the recipes host supports a persisted virtual clock (⏩ skew), using the real platform clock here makes retries/backoff deadlines and audit timestamps drift relative to the instance’s virtual timeline.
push_config: async (cmd) => {
const attempt = self?.getState().attempt ?? 0;
const at = Date.now();
return attempt < PUSH_FAILURES
💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.
Comment on lines
+271
to
+273
| const inner = new URL( | ||
| `https://recipe/${action === "state" ? "act" : action}`, | ||
| ); |
Comment on lines
+255
to
+259
| charge: async () => | ||
| ({ | ||
| type: "charge_declined", | ||
| reason: "card declined (insufficient funds)", | ||
| at: self?.getState().dueAt ?? Date.now(), |
The site burned through the free-tier daily Durable Object request quota and the edge started answering 1101 for every DO-backed call. Two of our own behaviours caused it, and a third made the outage look like a broken site. **Polling had no off switch.** /recipes started five poll loops on load and kept every one of them running forever at 1s, whether or not anything was happening; the hero polled at 500ms active and 2s idle indefinitely. Five idle panels cost five requests a second, all day, to learn nothing. The rule is now: poll only while something will happen ON ITS OWN, and soon. A panel that is idle, finished, parked on a human approval, or waiting on a deadline three days out changes only when someone clicks — and a click re-renders from the action's own response, so those panels make zero requests. The hero stops the moment both lanes are terminal-or-frozen or neither is in flight. Measured against the real local worker, with nothing running: 1 request on load for the hero, 5 for recipes, and then nothing at all — 0 requests over the following 8 seconds on both pages. Clicking start re-arms polling; parking on the approval disarms it again. The fast poll existed for the countdown, which never needed the network. It is now interpolated client-side at 250ms from the last known deadline, so the timer is smoother than before while costing nothing. **A failing backend rendered as an empty page.** Over quota the EDGE answers, not the worker, with the body "error code: 1101" — so `r.json()` threw, the catch swallowed it, and the code re-polled anyway: a hot retry loop against a backend already refusing us, presented as a blank UI. Responses are now validated (status, JSON-parseability, expected shape), a failure keeps the last-known render, and both pages show a warning bar plus, on /recipes, the same warning inside every panel: "Can't reach the demo backend — if this persists, the free-tier daily limit may be hit (resets at midnight UTC)." Buttons that need the server are disabled and carry that reason on hover, rather than being omitted — a panel with no buttons reads as broken markup, a disabled button with a tooltip reads as a backend that is down. That meant teaching each adapter its own opening label (`startLabel`), because a cold load with every request failing has no state to derive labels from. A failure does NOT reschedule a poll; the buttons are how a viewer retries. Verified in a real DOM against both pages, with fetch stubbed to answer exactly like the 1101 edge: bar visible on both, 5 of 5 panel banners, 4/4 and 10/10 buttons shown-but-disabled with the reason attached, on a first load with every request failing. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
5 tasks
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
What
Everything built on top of the bridge (#9), stacked so this PR shows only its own diff:
examples/checkout-saga/— the live demo at https://demlik-checkout-saga.can-835.workers.dev: a durable order saga in a Durable Object with Effect handlers viatoInterpret, side by side with a naive in-memory lane. The red button callsctx.abort()for real; the tea lane resumes from storage (including completing a refund submitted by an isolate that no longer exists), the naive lane strands the money. All six states visibly reachable across two scenarios. Four "How this works" reader sections.examples/recipes/— five day-scale machines with resume-from-serialized tests: durable-agent-run (Effect bridge; human-approval pause with no timer), dunning (day 1/3/7 ladder), approval-chain (state as audit log), onboarding-drip, fleet-reconcile. Pure overnow— weeks-long machines test in milliseconds./recipeson the demo site — all five clickable: server-derived action buttons, ⏩ time-travel (honest: in production these are DO alarms), 💥 kill per panel with persisted crash chrome.LoweringOptions.runtimecontravariance bug (found independently by both consumers), andglobalThis.cryptoin work-queue breaking Workers-tsconfig consumers.Testing
49 tests green (12 bridge + 9 saga + 28 recipes), typecheck + biome clean, deployed and verified end to end in a real browser: kill mid-refund, kill mid-approval-wait → approve → run completes.
Review notes
wrangler.jsoncmigrations are split v1/v2 because v1 was already applied to the deployed worker.🤖 Generated with Claude Code