tardie 0.22.1 → 0.22.2-rc.258

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardie",
-  "version": "0.22.1",
+  "version": "0.22.2-rc.258",
   "license": "MIT",
   "author": "Clavia, Inc.",
   "description": "A durable agent harness. State is a pure function of the log.",
@@ -16,7 +16,7 @@
     "access": "public"
   },
   "tardigrade": {
-    "sourceTree": "7ad7583338cc8d69829a810313b4f1d5dd7ec1a3"
+    "sourceTree": "a86f7a006f44eb41fcc97c3ebae698b8fc0db60a"
   },
   "files": [
     "src",

package/src/bun/host.ts

@@ -19,7 +19,7 @@ import type { ThreadAllocation } from "tardie/core/actor/allocation"
 import { formatThreadAddress, parseThreadAddress, type ThreadAddress, type ProviderEndpoint } from "tardie/core/transport/endpoint"
 import type { Link } from "tardie/core/transport/link"
 import { actorEventKeyOf, actorThreadsOf, type ActorThreadRecord, type ThreadRegistered, type ThreadRequested } from "tardie/core/actor"
-import { alarmFired, earliestDeadlineOf } from "tardie/core/interaction/timeout"
+import { alarmFired, deadlineCancellationEventsAt, earliestDeadlineOf } from "tardie/core/interaction/timeout"
 import { methodIngressKeyOf } from "tardie/core/interaction/invocation"
 import { type ActorMethods } from "tardie/core/actor/method"
 import {
@@ -595,7 +595,12 @@ export const createBunHost = async <R = never>(options: BunHostOptions<R>): Prom
       const active = await runtimeOf(thread)
       if (active.alarm?.deadlineAt !== deadlineAt) return
       delete active.alarm
-      await appendTo(thread, [alarmFired({ scheduledFor: deadlineAt, at })])
+      // synchronizeAlarm commits each alarm with its crossed deadline cancellations (host.test.ts, "an alarm commits its deadline cancellation atomically").
+      const log = await active.runtime.runPromise(active.store.read)
+      await appendTo(thread, [
+        alarmFired({ scheduledFor: deadlineAt, at }),
+        ...(methods === undefined ? [] : deadlineCancellationEventsAt(log, methods, at))
+      ])
       driver.mark(thread)
       await drive()
     })

package/src/cloudflare/host.ts

@@ -12,7 +12,7 @@ import { ThreadAllocator, reserveRootThread } from "tardie/core/actor/allocation
 import { initializingThreadAllocator } from "tardie/host/allocation"
 import { formatThreadAddress, type ThreadAddress, type ProviderEndpoint } from "tardie/core/transport/endpoint"
 import type { Link } from "tardie/core/transport/link"
-import { alarmFired, earliestDeadlineOf } from "tardie/core/interaction/timeout"
+import { alarmFired, deadlineCancellationEventsAt, earliestDeadlineOf } from "tardie/core/interaction/timeout"
 import { methodIngressKeyOf } from "tardie/core/interaction/invocation"
 import { type ActorMethods } from "tardie/core/actor/method"
 import {
@@ -230,12 +230,16 @@ export async function createCloudflareThreadHost<R = never>(options: CloudflareT
   const nextMethodDeadline = async (): Promise<number | undefined> => {
     return earliestDeadlineOf(await Effect.runPromise(events.read), methods)
   }
+  // recordAlarm commits each alarm with its crossed deadline cancellations (test/actor.workers.ts, "an alarm commits its deadline cancellation atomically").
   const recordAlarm = async (at: number): Promise<void> => {
-    const deadline = earliestDeadlineOf(await Effect.runPromise(events.read), methods)
+    const log = await Effect.runPromise(events.read)
+    const deadline = earliestDeadlineOf(log, methods)
     if (deadline !== undefined && deadline <= at) {
-      const result = await Effect.runPromise(events.append([alarmFired({ scheduledFor: deadline, at })]))
+      const result = await Effect.runPromise(store.append([
+        alarmFired({ scheduledFor: deadline, at }),
+        ...(methods === undefined ? [] : deadlineCancellationEventsAt(log, methods, at))
+      ]))
       if (result.appended > 0) driver.mark(options.thread)
-      await Effect.runPromise(syncCommit(result))
     } else {
       await options.storage.sync()
     }

package/src/core/interaction/timeout.ts

@@ -10,7 +10,7 @@ import { type ActorInvocationContext, invocationKey, sameInvocation, type Invoca
 
 import { recordedDispatchOf, terminalInvocationRefOf, terminalStorageKey, type RecordedDispatch } from "./records-compat"
 
-import { cancellationStateOf, initialMethodStates, reduceMethodStates } from "./state"
+import { cancellationStateOf, initialMethodStates, reduceMethodStates, type ActorMethodView } from "./state"
 import { type ActorMethods } from "../actor/method"
 
 export interface AlarmFiredFields {
@@ -142,6 +142,42 @@ const deadlineCancellationTransition = (invocation: InvocationRef, deadlineAt: n
   })]
 })
 
+// deadlineCancellationsAt selects crossed deadlines for running cancellable invocations (timeout.test.ts, "cancellation selection projects one cancellation from an eligible invocation").
+const deadlineCancellationsAt = (
+  log: ReadonlyArray<Event>,
+  methods: ActorMethods,
+  at: number
+): ReadonlyArray<InvocationDeadline> => {
+  const views = new Map<string, ActorMethodView<unknown>>()
+  return invocationDeadlinesOf(log).flatMap(({ invocation, deadlineAt }) => {
+    if (deadlineAt > at) return []
+    const method = methods[invocation.method]
+    if (method === undefined || method.cancellation === undefined || invocationSettled(log, invocation)) return []
+    let view = views.get(invocation.method)
+    if (view === undefined) {
+      view = replayProjection(method.projection, log)
+      views.set(invocation.method, view)
+    }
+    return cancellationStateOf(method, view, invocation) !== "running" ? [] : [{ invocation, deadlineAt }]
+  })
+}
+
+// deadlineCancellationEventsAt constructs durable requests for selected deadline cancellations (test/actor.workers.ts, "an alarm commits its deadline cancellation atomically").
+export const deadlineCancellationEventsAt = (
+  log: ReadonlyArray<Event>,
+  methods: ActorMethods,
+  at: number
+): ReadonlyArray<Event> =>
+  deadlineCancellationsAt(log, methods, at).map(({ invocation, deadlineAt }) =>
+    cancellationRequested({
+      request: `deadline/${invocation.method}/${invocation.id}/${invocation.epoch}/${deadlineAt}`,
+      invocation,
+      cause: "deadline",
+      deadlineAt,
+      at
+    })
+  )
+
 // methodTimeoutDerivation turns alarm facts into method terminals without reading a clock.
 export const methodTimeoutDerivation: CompleteTransitionDerivation = (log) => {
   const terminal = terminalCalls(log)
@@ -153,18 +189,15 @@ export const methodTimeoutDerivation: CompleteTransitionDerivation = (log) => {
   })
 }
 
-// methodDeadlineCancellationDerivation turns an accepted invocation deadline into the same durable cancellation used by callers.
+// methodDeadlineCancellationDerivation repairs missing cancellations from recorded alarms (timeout.test.ts, "legacy recovery derives an alarm's missing cancellation exactly once").
 export const methodDeadlineCancellationDerivation = (methods: ActorMethods): CompleteTransitionDerivation => (log) => {
-  const alarms = alarmsOf(log)
-  return invocationDeadlinesOf(log).flatMap(({ invocation, deadlineAt }) => {
-    const cancellation = methods[invocation.method]?.cancellation
-    if (cancellation === undefined || invocationSettled(log, invocation)) return []
-    const alarm = alarmFor(alarms, deadlineAt)
-    const method = methods[invocation.method]
-    if (alarm === undefined || method === undefined ||
-      cancellationStateOf(method, replayProjection(method.projection, log), invocation) !== "running") return []
-    return [deadlineCancellationTransition(invocation, deadlineAt)]
-  })
+  const latestAlarmAt = alarmsOf(log).reduce<number | undefined>(
+    (latest, alarm) => latest === undefined ? alarm.at : Math.max(latest, alarm.at),
+    undefined
+  )
+  if (latestAlarmAt === undefined) return []
+  return deadlineCancellationsAt(log, methods, latestAlarmAt)
+    .map(({ invocation, deadlineAt }) => deadlineCancellationTransition(invocation, deadlineAt))
 }
 
 /** @deprecated Use methodTimeoutDerivation. This compatibility name describes a complete-history transition derivation. */