experimental-a2 0.19.0 → 0.21.1

package/src/actor.ts

@@ -82,7 +82,14 @@ import { setServerFetchHooks } from './server-fetch.ts'
 import { sseResponse } from './sse.ts'
 import { isSessionCleared, sessionClearedError } from './session-clear.ts'
 import type { SessionCleared } from './session-clear.ts'
-import type { A2Scheduler, A2Server, HandlerEntry, Session } from './server.ts'
+import type {
+  A2Scheduler,
+  A2Server,
+  ConsumerContext,
+  ConsumerResult,
+  Session,
+} from './server.ts'
+import { runtimeConsumer } from './runtime-consumer.ts'
 import type { A2Store } from './store.ts'
 import type { StandardSchemaV1 } from './standard-schema.ts'
 import type { A2Telemetry } from './telemetry.ts'
@@ -460,14 +467,16 @@ export function actor<D extends ActorProtocol>(
     return send as ActorSend<D['events']>
   }
 
-  const handlers: Record<string, HandlerEntry<EventDefs>> = {}
+  type Run = (ctx: ConsumerContext<EventDefs>) => ConsumerResult<EventDefs>
+  const concurrentRuns = new Map<string, Run>()
+  const serialRuns = new Map<string, Run>()
   for (const [eventName, def] of handlersByEvent) {
     if (def.kind === 'concurrent') {
       // No lane: concurrent handlers run in parallel — with the lane
       // and with each other. They cannot write state (no draft to
       // commit), so no serialization is needed for correctness; slow
       // I/O lives here without blocking the actor.
-      handlers[eventName] = async (ctx) => {
+      concurrentRuns.set(eventName, async (ctx) => {
         const sends: { type: string; payload: unknown }[] = []
         try {
           await def.handle(
@@ -509,78 +518,70 @@ export function actor<D extends ActorProtocol>(
         }
         // Sends commit atomically with settlement; re-runs converge on
         // the same deterministic message ids.
-        return sends
-      }
+        return sends as never
+      })
       continue
     }
-    handlers[eventName] = {
-      // One lane for every serial handler of one instance: the next
-      // message starts only after the previous one completed, and
-      // completion commits the state event atomically —
-      // read-modify-write on `ctx.state` is safe by exclusion, not by
-      // liveness.
-      lane: ACTOR_LANE,
-      handler: async (ctx) => {
-        // Explicitly 'latest', not the event-relative default: prior
-        // lane messages commit *after* this message was appended, so
-        // their state commits carry higher indexes than the trigger —
-        // an event-relative read would miss them and lose updates.
-        // 'latest' is deterministic here because the lane makes this
-        // attempt the only possible writer while it runs.
-        const { state, clearIndex } = await ctx.session.state(serverReducer, {
-          through: 'latest',
-        })
-        const draft = structuredClone(state)
-        const sends: { type: string; payload: unknown }[] = []
-        try {
-          await def.handle(
-            {
-              state: draft,
-              id: ctx.event.id,
-              attempt: ctx.attempt,
-              signal: ctx.signal,
-              send: makeSend(sends),
-              schedule: makeSchedule((taskName, timing, event) =>
-                ctx.session.schedule(
-                  taskName,
-                  timing as Parameters<typeof ctx.session.schedule>[1],
-                  event,
-                ),
+    serialRuns.set(eventName, async (ctx) => {
+      // Explicitly 'latest', not the event-relative default: prior
+      // lane messages commit *after* this message was appended, so
+      // their state commits carry higher indexes than the trigger —
+      // an event-relative read would miss them and lose updates.
+      // 'latest' is deterministic here because the lane makes this
+      // attempt the only possible writer while it runs.
+      const { state, clearIndex } = await ctx.session.state(serverReducer, {
+        through: 'latest',
+      })
+      const draft = structuredClone(state)
+      const sends: { type: string; payload: unknown }[] = []
+      try {
+        await def.handle(
+          {
+            state: draft,
+            id: ctx.event.id,
+            attempt: ctx.attempt,
+            signal: ctx.signal,
+            send: makeSend(sends),
+            schedule: makeSchedule((taskName, timing, event) =>
+              ctx.session.schedule(
+                taskName,
+                timing as Parameters<typeof ctx.session.schedule>[1],
+                event,
               ),
-            },
-            ctx.event.payload,
-          )
-        } catch (error) {
-          // A NonRetriableError is an answer: settle the message,
-          // record the refusal, deliver it to the waiting caller —
-          // no retry, no failure budget spent (buffered sends are
-          // discarded with the draft: refusals are total). Every
-          // other throw is an ordinary A2 handler failure: rethrown
-          // into core's retry machinery (backoff, ten-failure
-          // budget, dead letter) — including surrendered lease
-          // aborts, which core recognizes by identity.
-          if (!(error instanceof NonRetriableError)) throw error
-          const payload: ActorFailedPayload = {
-            message: ctx.event.id,
-            event: eventName,
-            error: describeError(error),
-          }
-          return { type: ACTOR_FAILED_EVENT, payload }
-        }
-        // One returned batch: buffered sends plus the state commit —
-        // committed atomically with completion, so a reserve and its
-        // trigger can never half-happen. The state event stays the
-        // outcome marker a waiting call resolves on. (Unconditional
-        // for now; a dirty check is a compatible later optimization.)
-        const payload: ActorStatePayload<D['state']> = {
-          state: draft,
-          event: eventName,
+            ),
+          },
+          ctx.event.payload,
+        )
+      } catch (error) {
+        // A NonRetriableError is an answer: settle the message,
+        // record the refusal, deliver it to the waiting caller —
+        // no retry, no failure budget spent (buffered sends are
+        // discarded with the draft: refusals are total). Every
+        // other throw is an ordinary A2 handler failure: rethrown
+        // into core's retry machinery (backoff, ten-failure
+        // budget, dead letter) — including surrendered lease
+        // aborts, which core recognizes by identity.
+        if (!(error instanceof NonRetriableError)) throw error
+        const payload: ActorFailedPayload = {
           message: ctx.event.id,
-          ...(clearIndex === undefined ? {} : { clearIndex }),
+          event: eventName,
+          error: describeError(error),
         }
-        return [...sends, { type: ACTOR_STATE_EVENT, payload }]
-      },
-    }
+        return { type: ACTOR_FAILED_EVENT, payload }
+      }
+      // One returned batch: buffered sends plus the state commit —
+      // committed atomically with completion, so a reserve and its
+      // trigger can never half-happen. The state event stays the
+      // outcome marker a waiting call resolves on. (Unconditional
+      // for now; a dirty check is a compatible later optimization.)
+      const payload: ActorStatePayload<D['state']> = {
+        state: draft,
+        event: eventName,
+        message: ctx.event.id,
+        ...(clearIndex === undefined ? {} : { clearIndex }),
+      }
+      return [...sends, { type: ACTOR_STATE_EVENT, payload }] as never
+    })
   }
 
   const presenceEnabled = (options as { presence?: unknown }).presence === true
@@ -590,9 +591,38 @@ export function actor<D extends ActorProtocol>(
   const contract = presenceEnabled
     ? createContract({ name, events, presence: openPresenceDefs })
     : createContract({ name, events })
+  // Serial messages share one lane per instance: the next starts only after
+  // the previous one completed, and completion commits the state event
+  // atomically, so read-modify-write on `ctx.state` is safe by exclusion,
+  // not by liveness. The lane is a function, so each message is queued on
+  // it as it's appended. Concurrent messages run alongside it and each
+  // other: they write no state.
+  const serialTypes = [...serialRuns.keys()]
+  const concurrentTypes = [...concurrentRuns.keys()]
+  const consumers = [
+    ...(serialTypes.length === 0
+      ? []
+      : [
+          runtimeConsumer({
+            contract,
+            name: 'a2.actor',
+            types: serialTypes,
+            lane: () => ACTOR_LANE,
+          }).run((ctx) => serialRuns.get(ctx.event.type)!(ctx as never)),
+        ]),
+    ...(concurrentTypes.length === 0
+      ? []
+      : [
+          runtimeConsumer({
+            contract,
+            name: 'a2.actor.concurrent',
+            types: concurrentTypes,
+          }).run((ctx) => concurrentRuns.get(ctx.event.type)!(ctx as never)),
+        ]),
+  ]
   const server = createServer({
     contract,
-    handlers,
+    consumers,
     ...(options.store ? { store: options.store } : {}),
     ...(options.scheduler ? { scheduler: options.scheduler } : {}),
     ...(options.telemetry ? { telemetry: options.telemetry } : {}),