experimental-a2 0.20.0 → 0.21.1

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 0.21.1
+
+### Patch Changes
+
+- 65ab0df: Under `fx()` and `pi()`, steering that hands off before any of the turn's model calls finished, as after a pause during the first one, now joins the turn's prompt. The turn's first model call sees it, and under `fx()` its files go with the prompt instead of failing the turn. Before, the engine got it only after that call, as steering, so the model answered without it once.
+
+## 0.21.0
+
+### Minor Changes
+
+- a80ad79: `session.consume(consumer, { through?, signal? })` runs a consumer with a string lane on a session, in the calling invocation, until it has handled every event it takes through `through` (default: the head), and returns `{ index }`. Use it to read your writes before querying a table a consumer keeps, to start a backfill right away with `{ through: 0 }`, or in one consumer to wait for another's table to reach its trigger. The server's own consumer shares its cursor with background work, and `consume` waits for whichever invocation holds it; a consumer the server doesn't run is pulled only by `consume` and keeps its place between calls. A dead-lettered head throws `CONSUMER_DEAD_LETTERED`. Custom stores implement `wakeLog`, which creates or wakes one log consumer's cursor without an append, and writes nothing for a session with nothing after its latest clear. A consumer with `backfill` can't use `abortOn`: defining one throws a `TypeError`, since checking cancellation while replaying history would read the rest of the log for every event.
+- 2cbb952: Consumers: `consumer({ contract, name, types?, lane?, backfill?, abortOn? }).run(fn)` defines a named reader of every session's log, registered with `createServer({ consumers })`. Several consumers can react to one event, each with its own durable cursor, lanes, retries, and dead letters; a consumer with a string lane runs everything it takes in log order and can start from the beginning of the log with `backfill: true`. Dead letters now carry their `consumer`, and `session.redrive()` takes `{ consumer, index }`. The store contract moves dispatch bookkeeping from event rows to cursors: custom adapters implement `cursors()` and the cursor-keyed claim, completion, failure, and redrive methods. Let earlier deployments finish their work first: on Postgres, then apply the new `sql/postgres/schema.sql` while none of them is running. On Postgres and Redis every event is kept, and work an earlier release's handlers hadn't finished is dropped; Redis reads an earlier release's sessions under the same `keyPrefix`, and its old dispatch keys stay until you delete them. SQLite starts fresh: a file from an earlier release throws `STORE_NOT_CONFIGURED`, so delete it or pass another `path`. Upgrade steps for each store: https://www.a2.dev/upgrades/0-21.
+- 59a655d: `handlers` are gone: consumers are the one way to react to events. `createServer({ handlers })`, the `handler()` helper, and the `Handler`, `HandlerEntry`, and `Lane` types are removed; write each reaction in `createServer({ consumers })`, inline as `{ name, types?, lane?, run }` on the server's contract, or as `consumer({ contract, name, types?, lane? }).run(fn)` to define one on its own. An inline `run` narrows `event` to its `types`; `agent({ consumers })` takes both forms too. A handler table whose types shared a lane becomes one consumer that takes those types, with a lane function returning that lane. `agent({ handlers })` is now `agent({ consumers })`. `HandlerContext` is now `ConsumerContext`, `HandlerAppend` is `ConsumerAppend`, `ToolHandlerContext` is `ToolConsumerContext`, `handlerContext()` is `consumerContext()`, and `runWithHandlerContext` is `runWithConsumerContext`. A consumer of an AI event type runs beside the agent's own, so `agent()` no longer rejects app code on those types. `session.redrive()` takes only `{ consumer, index }`. Actors (`actor({ handlers })` keeps its name) and the AI runtime run on A2's own consumers, named under the reserved `a2.` prefix: `a2.actor` and `a2.actor.concurrent`, and `a2.ai.metadata`, `a2.ai.control`, `a2.ai.model`, and `a2.ai.tools`. Their event ids are unchanged. The `a2.append.source` telemetry attribute reads `consumer` where it read `handler`. Every rename, old to new: https://www.a2.dev/upgrades/0-21.
+
+  Lag telemetry: every `a2.event` span carries `a2.event.age_ms`, how old the event was when its run started, and `a2.event.lag`, how many events the session had appended after it when it was claimed. Group them by `a2.event.consumer` to see how far each consumer is behind. Claim results from a store may now report the session's `head`, which every built-in store does.
+
+  `server.fetch` refuses a pushed event `id` longer than 256 characters, or shaped like a UUIDv5, with `INVALID_PAYLOAD`. A2 derives the ids of what consumers append, return, and schedule as UUIDv5s from inputs a caller can know, so a caller who pushed one first could take its place: dead-letter the consumer, or turn a scheduled event into a no-op. Client ids from `crypto.randomUUID()` (v4) and `idempotentId()` (v8) are unaffected.
+
+- 59a655d: The Postgres store checks nothing up front. It no longer reads a schema version before its first query, and `schema.sql` drops the `a2_schema` table. A query that finds one of A2's tables or columns missing, or that its role can't use, throws `STORE_NOT_CONFIGURED`, naming the files to apply or the grants to make. A store with `listenConnectionString` still looks for its triggers, since a missing one fails no query: its first subscription throws `STORE_NOT_CONFIGURED` until `notifications.sql` is applied. When to apply the new `schema.sql`: https://www.a2.dev/upgrades/0-21.
+
+  `sql/postgres/drizzle-schema.ts` shows A2's tables as Drizzle definitions: an example of one way to fit them into a Drizzle project, so your own migrations create them. `schema.sql` also works as a migration as it ships: a breakpoint comment ends each statement, so a tool that sends one statement per query, like Drizzle on PGlite, applies it unchanged.
+
+- af3cb3e: The Postgres store runs each append, claim, completion, `session.consume` poll, and redrive in one round trip, through a new function in `schema.sql`, `a2_batch`. A session's lock is held only while the database runs the call, not across round trips from your app, so one busy session keeps up on a database a few milliseconds away. A completion that moves its lane or log cursor to the next event takes no session lock at all, and neither does a `consume` poll that finds nothing new.
+
+  Apply the new `schema.sql` before you deploy. It adds the function and changes no table, and the deployment that is running keeps working against it. Deployed first, writes throw `STORE_NOT_CONFIGURED` naming `schema.sql`, and the next call after you apply it succeeds. With Drizzle, add the function as a custom migration (`drizzle-kit generate --custom`), copied from `schema.sql`: Drizzle can't declare functions. The function needs `read committed`, Postgres's default isolation level; under a stricter default it throws `STORE_NOT_CONFIGURED`.
+
+  Two fixes ride along. A drain whose last runs finish while it is claiming now claims again, instead of stopping with their cursors' next events unclaimed until the next append or scheduler watchdog. And on Postgres, a claim that waited on a cursor while its completion moved it to a newer event now returns that event; before, it held the head without running it, until a takeover counted the claim as a failed attempt.
+
+  A payload Postgres can't store, one with a NUL character (`\u0000`), now throws `INVALID_PAYLOAD` with nothing written, instead of `STORE_UNAVAILABLE`, which said to retry.
+
+### Patch Changes
+
+- 59a655d: Docs: an Upgrades section, `docs/upgrades/`, with one page per release that needs steps from you, from 0.17 through 0.21. `docs/server/05-sql-projections.mdx` keeps tables in your own database from A2's logs: it claims each event with one upsert on a position row, first in the transaction, and covers reading your writes, live views, SQLite, lag, and rebuilds.
+
 ## 0.20.0
 
 ### Minor Changes

package/README.md

@@ -1,7 +1,7 @@
 # experimental-a2
 
 A2 syncs your immutable event log, from server to browser. Each session has an
-event log, derived state, handlers, timers, and a live client.
+event log, derived state, consumers, timers, and a live client.
 
 ## Read the package
 

package/dist/{actor-C7b-1arn.d.ts → actor-HnGmrOZZ.d.ts}

@@ -1,7 +1,7 @@
-import { s as Contract, t as Reducer, u as EventDefs, v as StandardSchemaV1 } from "./reducer-CqA59Q6U.js";
-import { t as A2Store } from "./store-CyLUy86v.js";
-import { h as Session, n as A2Server, p as ScheduleTiming, t as A2Scheduler } from "./server-DYAATFuT.js";
-import { i as A2Telemetry } from "./telemetry-Cyfqo6Qt.js";
+import { s as Contract, t as Reducer, u as EventDefs, v as StandardSchemaV1 } from "./reducer-CYPHsSmd.js";
+import { t as A2Store } from "./store-Z2qjw50n.js";
+import { g as ScheduleTiming, n as A2Server, t as A2Scheduler, y as Session } from "./server-BshFZ0eL.js";
+import { i as A2Telemetry } from "./telemetry-CWwsh-Gx.js";
 //#region src/actor-shared.d.ts
 /**
  * A handler answered by throwing `NonRetriableError`: the event
@@ -317,4 +317,4 @@ type ActorDefinition<D extends ActorProtocol> = {
 declare function actor<D extends ActorProtocol>(options: ActorOptions<D>): ActorDefinition<D>;
 //#endregion
 export { ActorProtocol as _, ActorHandle as a, ActorScheduleSend as b, ActorOptions as c, concurrent as d, ActorConcurrentContext as f, ActorPresenceValues as g, ActorPresenceOf as h, ActorFetchOptions as i, ActorSendOptions as l, ActorPresenceMap as m, ActorCallResult as n, ActorHandler as o, ActorContext as p, ActorDefinition as r, ActorOperation as s, ActorCallOptions as t, actor as u, ActorRefusedError as v, ActorSend as x, ActorScheduleOptions as y };
-//# sourceMappingURL=actor-C7b-1arn.d.ts.map
+//# sourceMappingURL=actor-HnGmrOZZ.d.ts.map

package/dist/{actor-C7b-1arn.d.ts.map → actor-HnGmrOZZ.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"actor-C7b-1arn.d.ts","names":[],"sources":["../src/actor-shared.ts","../src/actor.ts"],"mappings":";;;;;;;;;;;cAiCa,0BAA0B;;WAE5B;;WAEA;EACT,YAAY,eAAe,mBAAmB;;;;;;;;;KAepC;EACV;EACA;;;;;;;EAOA;;;KAIU,gBAAgB,UAAU,iBAAiB;EACrD,gBAAgB;IAEd;;KAIQ,oBAAoB,QAC7B,WAAW,cAAc,EAAE;;;;;;KAQlB,iBAAiB;GAExB,yBAAA,WAAW;IAAgB,OAAO,EAAE;IAAI;IAAc,IAAI;;;;;;;;;;;;KAanD,UAAU,iBACV,WAAW,eAAe,EAAE,MACjC,QAAQ,EAAE,eACV,OAAO,EAAE;;;;;;;;;KAWJ,uBAAuB;EAAmB;;;;;;;;;;;;KAY1C,kBAAkB,iBAClB,WAAW,eAAe,EAAE,MACjC,OAAO,EAAE,gBAAgB,SAAS,yBAAyB,iBAC3D,OAAO,EAAE,IAAI,SAAS,yBAAyB;;KAI1C,aAAa,UAAU;;EAEjC,OAAO;;EAEP;;EAEA;;EAEA,QAAQ;;EAER,MAAM,UAAU;;EAEhB,UAAU,kBAAkB;;;;;;;;KASlB,uBAAuB,UAAU;;EAE3C;;EAEA;;EAEA,QAAQ;;EAER,SAAS;IAAU,OAAO;IAAY;;;EAEtC,MAAM,UAAU;;EAEhB,UAAU,kBAAkB;;KAGlB,kBAAkB;EAC5B,OAAO;;EAEP;;EAEA;;EAEA;;;KAWU,qBAAqB;EAC/B,kBAAkB,iBAAiB,kBAAkB;;;;;;;;;;;;;;KCzE3C,aAAa,UAAU,eAAe,gBAAgB,iBAC5D,KAAK,aAAa,IAAI,OAAO,YAAY,cAAc;EAEvD;EACA,SACE,KAAK,uBAAuB,IAC5B,OAAO,YAAY,cACT;;;;;;;;;;;;;;;;iBAiBF,WAAW,KAAK,GAC9B,SAAS,KAAK,KAAK,OAAO,aAAa;EACpC;EAAkB,SAAS,KAAK,KAAK,OAAO,aAAa;;KAIlD,aAAa,UAAU;;EAEjC;;EAEA,OAAO;;;;;EAKP,aAAa,WAAW,cAAc,aAAa,GAAG;EACtD,QAAQ;EACR,YAAY;EACZ,YAAY;MACR,gBAAgB;EAChB;;;;;;;;;;;;EAYA;;;;;;;KAQM;WACG;WAAwB;;WAExB;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;;WAGA;WACA;WACA;WACA,QAAQ,SAAS;;KAGpB,kBAAkB,UAAU;;EAEtC,aAAa,WAAW,6BAA6B;;;;;;;;;;;;EAYrD,QAAQ,OAAO;;KAGL;;EAEV;;KAGU,mBAAmB;;EAE7B;;KAGU,gBAAgB;;EAE1B,OAAO;;EAEP;;;;;EAKA;;KAGG,WACH,UAAU,eACV,gBAAgB,0BACH,YAAY,MAErB,QAAQ,YAAY,IACpB,UAAU,qBACP,QAAQ,gBAAgB,gBAE3B,OAAO,YAAY,IACnB,UAAU,qBACP,QAAQ,gBAAgB;KAE5B,WACH,UAAU,eACV,gBAAgB,0BACH,YAAY,MAErB,QAAQ,YAAY,IACpB,UAAU,qBACP;EAAU;EAAY;MAEzB,OAAO,YAAY,IACnB,UAAU,qBACP;EAAU;EAAY;;;KAGnB,YAAY,UAAU;WACvB;;;;;;;;WAQA,kBAAkB,WAAW,cAAc,WAAW,GAAG;;WAEzD,kBAAkB,WAAW,cAAc,WAAW,GAAG;;WAEzD,aAAa,QAAQ,gBAAgB;;;;;;;;;;;WAWrC,QACP,SAAS,SACT,UAAU,kBAAkB,OACzB,QAAQ;;WAEJ,SAAS,QAAQ;;KAGhB,gBAAgB,UAAU;WAC3B;;;;;;WAMA,WAAW;;WAEX,UAAU,SAAS;;WAEnB,QAAQ,SAAS;;WAEjB,SAAS,QAAQ,qBAAqB,aAAa;EAC5D,MAAM,aAAa,YAAY;;;;;;;iBAsDjB,MAAM,UAAU,eAC9B,SAAS,aAAa,KACrB,gBAAgB"}
+{"version":3,"file":"actor-HnGmrOZZ.d.ts","names":[],"sources":["../src/actor-shared.ts","../src/actor.ts"],"mappings":";;;;;;;;;;;cAiCa,0BAA0B;;WAE5B;;WAEA;EACT,YAAY,eAAe,mBAAmB;;;;;;;;;KAepC;EACV;EACA;;;;;;;EAOA;;;KAIU,gBAAgB,UAAU,iBAAiB;EACrD,gBAAgB;IAEd;;KAIQ,oBAAoB,QAC7B,WAAW,cAAc,EAAE;;;;;;KAQlB,iBAAiB;GAExB,yBAAA,WAAW;IAAgB,OAAO,EAAE;IAAI;IAAc,IAAI;;;;;;;;;;;;KAanD,UAAU,iBACV,WAAW,eAAe,EAAE,MACjC,QAAQ,EAAE,eACV,OAAO,EAAE;;;;;;;;;KAWJ,uBAAuB;EAAmB;;;;;;;;;;;;KAY1C,kBAAkB,iBAClB,WAAW,eAAe,EAAE,MACjC,OAAO,EAAE,gBAAgB,SAAS,yBAAyB,iBAC3D,OAAO,EAAE,IAAI,SAAS,yBAAyB;;KAI1C,aAAa,UAAU;;EAEjC,OAAO;;EAEP;;EAEA;;EAEA,QAAQ;;EAER,MAAM,UAAU;;EAEhB,UAAU,kBAAkB;;;;;;;;KASlB,uBAAuB,UAAU;;EAE3C;;EAEA;;EAEA,QAAQ;;EAER,SAAS;IAAU,OAAO;IAAY;;;EAEtC,MAAM,UAAU;;EAEhB,UAAU,kBAAkB;;KAGlB,kBAAkB;EAC5B,OAAO;;EAEP;;EAEA;;EAEA;;;KAWU,qBAAqB;EAC/B,kBAAkB,iBAAiB,kBAAkB;;;;;;;;;;;;;;KClE3C,aAAa,UAAU,eAAe,gBAAgB,iBAC5D,KAAK,aAAa,IAAI,OAAO,YAAY,cAAc;EAEvD;EACA,SACE,KAAK,uBAAuB,IAC5B,OAAO,YAAY,cACT;;;;;;;;;;;;;;;;iBAiBF,WAAW,KAAK,GAC9B,SAAS,KAAK,KAAK,OAAO,aAAa;EACpC;EAAkB,SAAS,KAAK,KAAK,OAAO,aAAa;;KAIlD,aAAa,UAAU;;EAEjC;;EAEA,OAAO;;;;;EAKP,aAAa,WAAW,cAAc,aAAa,GAAG;EACtD,QAAQ;EACR,YAAY;EACZ,YAAY;MACR,gBAAgB;EAChB;;;;;;;;;;;;EAYA;;;;;;;KAQM;WACG;WAAwB;;WAExB;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;;WAGA;WACA;WACA;WACA,QAAQ,SAAS;;KAGpB,kBAAkB,UAAU;;EAEtC,aAAa,WAAW,6BAA6B;;;;;;;;;;;;EAYrD,QAAQ,OAAO;;KAGL;;EAEV;;KAGU,mBAAmB;;EAE7B;;KAGU,gBAAgB;;EAE1B,OAAO;;EAEP;;;;;EAKA;;KAGG,WACH,UAAU,eACV,gBAAgB,0BACH,YAAY,MAErB,QAAQ,YAAY,IACpB,UAAU,qBACP,QAAQ,gBAAgB,gBAE3B,OAAO,YAAY,IACnB,UAAU,qBACP,QAAQ,gBAAgB;KAE5B,WACH,UAAU,eACV,gBAAgB,0BACH,YAAY,MAErB,QAAQ,YAAY,IACpB,UAAU,qBACP;EAAU;EAAY;MAEzB,OAAO,YAAY,IACnB,UAAU,qBACP;EAAU;EAAY;;;KAGnB,YAAY,UAAU;WACvB;;;;;;;;WAQA,kBAAkB,WAAW,cAAc,WAAW,GAAG;;WAEzD,kBAAkB,WAAW,cAAc,WAAW,GAAG;;WAEzD,aAAa,QAAQ,gBAAgB;;;;;;;;;;;WAWrC,QACP,SAAS,SACT,UAAU,kBAAkB,OACzB,QAAQ;;WAEJ,SAAS,QAAQ;;KAGhB,gBAAgB,UAAU;WAC3B;;;;;;WAMA,WAAW;;WAEX,UAAU,SAAS;;WAEnB,QAAQ,SAAS;;WAEjB,SAAS,QAAQ,qBAAqB,aAAa;EAC5D,MAAM,aAAa,YAAY;;;;;;;iBAsDjB,MAAM,UAAU,eAC9B,SAAS,aAAa,KACrB,gBAAgB"}

package/dist/actor-client.d.ts

@@ -1,4 +1,4 @@
-import { n as ActorCallResult, v as ActorRefusedError } from "./actor-C7b-1arn.js";
+import { n as ActorCallResult, v as ActorRefusedError } from "./actor-HnGmrOZZ.js";
 //#region src/actor-client.d.ts
 declare class ActorRequestError extends Error {
   readonly status: number | undefined;

package/dist/actor-client.js

@@ -1,5 +1,5 @@
-import { i as A2Error } from "./session-clear-DGI4jTQ5.js";
-import { i as ActorRefusedError } from "./actor-shared-t7w8xIKP.js";
+import { i as A2Error } from "./session-clear-wHd5GCpZ.js";
+import { i as ActorRefusedError } from "./actor-shared-DFET5q16.js";
 //#region src/actor-client.ts
 /**
 * experimental-a2/actor/client — typed calls to an actor over HTTP.

package/dist/actor-react.d.ts

@@ -1,7 +1,7 @@
-import { c as ContractEvent, u as EventDefs } from "./reducer-CqA59Q6U.js";
-import { g as ActorPresenceValues, m as ActorPresenceMap } from "./actor-C7b-1arn.js";
+import { c as ContractEvent, u as EventDefs } from "./reducer-CYPHsSmd.js";
+import { g as ActorPresenceValues, m as ActorPresenceMap } from "./actor-HnGmrOZZ.js";
 import { ActorClientCall, ActorStateOf, AnyActorDefinition } from "./actor-client.js";
-import { a as Connection } from "./client-h_DKFAjj.js";
+import { a as Connection } from "./client-CUMbS_38.js";
 //#region src/actor-react.d.ts
 /** The server-to-client handoff: `await def.actor(id).state()`. */
 type ActorSnapshot<S> = {

package/dist/actor-react.js

@@ -1,10 +1,10 @@
 "use client";
-import { n as isSessionCleared } from "./session-clear-DGI4jTQ5.js";
-import { r as foldsClearMarkers } from "./reducer-BAXc8JyF.js";
-import { n as internalContract } from "./contract-BYKASlCV.js";
-import { t as createClient } from "./client-BhHLoNKF.js";
+import { n as isSessionCleared } from "./session-clear-wHd5GCpZ.js";
+import { r as foldsClearMarkers } from "./reducer-CjmvZSAb.js";
+import { n as internalContract } from "./contract-CWukt01d.js";
+import { t as createClient } from "./client-9IeTsiAs.js";
 import { useSession } from "./react.js";
-import { l as openPresenceDefs } from "./actor-shared-t7w8xIKP.js";
+import { l as openPresenceDefs } from "./actor-shared-DFET5q16.js";
 import { createActorClient } from "./actor-client.js";
 import { useMemo } from "react";
 //#region src/actor-react.ts

package/dist/{actor-shared-t7w8xIKP.js → actor-shared-DFET5q16.js}

@@ -1,5 +1,5 @@
-import { a as reducer } from "./reducer-BAXc8JyF.js";
-import { n as internalContract } from "./contract-BYKASlCV.js";
+import { a as reducer } from "./reducer-CjmvZSAb.js";
+import { n as internalContract } from "./contract-CWukt01d.js";
 //#region src/actor-shared.ts
 /**
 * Internal shared vocabulary of the actor module — the reserved event
@@ -129,4 +129,4 @@ function actorReducer(options) {
 //#endregion
 export { actorFailedSchema as a, isJsonTree as c, ActorRefusedError as i, openPresenceDefs as l, ACTOR_LANE as n, actorReducer as o, ACTOR_STATE_EVENT as r, actorStateSchema as s, ACTOR_FAILED_EVENT as t };
 
-//# sourceMappingURL=actor-shared-t7w8xIKP.js.map
+//# sourceMappingURL=actor-shared-DFET5q16.js.map

package/dist/{actor-shared-t7w8xIKP.js.map → actor-shared-DFET5q16.js.map}

@@ -1 +1 @@
-{"version":3,"file":"actor-shared-t7w8xIKP.js","names":["createContract"],"sources":["../src/actor-shared.ts"],"sourcesContent":["import { reducer } from './reducer.ts'\n/**\n * Internal shared vocabulary of the actor module — the reserved event\n * envelopes, the protocol and context types, the state fold. Not an\n * entry point: the public surfaces are experimental-a2/actor (server),\n * /actor/client, and /actor/react.\n *\n * An actor is a durable mailbox with memory: one session per instance,\n * events processed one at a time (a lane) unless a handler opts out\n * with `concurrent: true`, state materialized as `a2.actor.state`\n * events committed atomically with each handler's completion.\n */\n\nimport { internalContract as createContract } from './contract.ts'\nimport type { Reducer } from './reducer.ts'\nimport type { ScheduleTiming } from './server.ts'\nimport type { StandardSchemaV1 } from './standard-schema.ts'\n\n/** Event type of a committed state change — one per completed serial handler. */\nexport const ACTOR_STATE_EVENT = 'a2.actor.state'\n/** Event type of a refusal — a handler that answered by throwing NonRetriableError. */\nexport const ACTOR_FAILED_EVENT = 'a2.actor.failed'\n/** The per-instance lane every serial handler shares — the state's write lock. */\nexport const ACTOR_LANE = 'a2.actor'\n/** Reducer identity — bump when the fold's meaning changes. */\nexport const ACTOR_REDUCER_NAME = 'a2.actor.v1'\n\n/**\n * A handler answered by throwing `NonRetriableError`: the event\n * settled, the state did not change. Isomorphic — the server raises it\n * from calls and `fetch()` serializes it as a 409; the client's `call`\n * proxy revives it from that response.\n */\nexport class ActorRefusedError extends Error {\n  /** The refused event's name. */\n  readonly event: string\n  /** The refused event's message id. */\n  readonly messageId: string\n  constructor(event: string, messageId: string, message: string) {\n    super(message)\n    this.name = 'ActorRefusedError'\n    this.event = event\n    this.messageId = messageId\n  }\n}\n\n/**\n * The declaration an actor is defined over: its state shape and its\n * event vocabulary, as types. Core A2 contracts are schemas because\n * the wire is untrusted; actor protocols are types because your\n * server is trusted — same contract-first design language, dialed to\n * the trust level.\n */\nexport type ActorProtocol = {\n  state: object\n  events: object\n  /**\n   * Optional third vocabulary: presence field → value type. Ephemeral\n   * audience state (who is here, cursors), replicated to subscribers\n   * and never stored in the log. Declaring it requires `presence:\n   * true` in the actor options — the wire bit types cannot carry.\n   */\n  presence?: object\n}\n\n/** The protocol's presence vocabulary, `never` when undeclared. */\nexport type ActorPresenceOf<D extends ActorProtocol> = D extends {\n  presence: infer P extends object\n}\n  ? P\n  : never\n\n/** A `setPresence` patch: changed fields, `null` clears one. */\nexport type ActorPresenceValues<P> = {\n  [F in keyof P & string]?: P[F] | null\n}\n\n/**\n * The replicated presence map: participant → field → latest value,\n * last write wins per field. Values are peer-authored — render them\n * like user input.\n */\nexport type ActorPresenceMap<P> = {\n  [participant: string]: {\n    [F in keyof P & string]?: { value: P[F]; seen: number; at: Date }\n  }\n}\n\n/**\n * The typed self-send surface: one method per declared event —\n * `ctx.send.transfer({ ref, amount })`. Buffered, not immediate: every\n * send requested during a handler commits atomically with that\n * handler's completion (a serial handler's state commit, a concurrent\n * handler's settlement), riding core's returned-events semantics — so\n * a reserve-and-trigger can never half-happen, and re-runs converge on\n * the same deterministic message ids.\n */\nexport type ActorSend<E> = {\n  readonly [K in keyof E]: {} extends E[K]\n    ? (input?: E[K]) => void\n    : (input: E[K]) => void\n}\n\n/**\n * Timing for a scheduled event: exactly `{ delay: '5d' }` or\n * `{ at: Date }` (core §6 semantics — relative delays anchor to the\n * triggering message's durable `createdAt`, so re-runs resolve the\n * same due time). `name` overrides the timer's identity — it defaults\n * to the target event name, scoped to the triggering message, so one\n * handler run gets one timer per target event unless named apart.\n */\nexport type ActorScheduleOptions = ScheduleTiming & { name?: string }\n\n/**\n * The typed durable-timer surface: one method per declared event —\n * `ctx.schedule.refund({ ref: ctx.id }, { delay: '1h' })`. Unlike\n * `send`, scheduling is immediate, not buffered: it awaits provider\n * acceptance at call time (a timer is provider-side, not a log row),\n * so a handler that schedules and then refuses has still armed the\n * timer. That is safe by the guarded-delivery idiom — the stale timer\n * fires into an idempotent no-op — but it is the one exception to\n * \"refusals are total\". Requires a configured `scheduler`.\n */\nexport type ActorScheduleSend<E> = {\n  readonly [K in keyof E]: {} extends E[K]\n    ? (input: E[K] | undefined, options: ActorScheduleOptions) => Promise<void>\n    : (input: E[K], options: ActorScheduleOptions) => Promise<void>\n}\n\n/** What a serial handler receives alongside its typed input. */\nexport type ActorContext<D extends ActorProtocol> = {\n  /** Mutable draft, committed atomically with the handler's completion. */\n  state: D['state']\n  /** The message id — stable across re-runs; the idempotency key for external I/O. */\n  id: string\n  /** Durable 1-based dispatch ordinal of this message. */\n  attempt: number\n  /** The ordinary A2 handler signal — fires on claim expiry or supersession. */\n  signal: AbortSignal\n  /** Typed buffered self-send — committed atomically with the state commit. */\n  send: ActorSend<D['events']>\n  /** Typed durable timers — immediate provider handoff, see ActorScheduleSend. */\n  schedule: ActorScheduleSend<D['events']>\n}\n\n/**\n * What a `concurrent: true` handler receives. No draft — concurrent\n * handlers run off the lane, in parallel, so state is a snapshot read\n * (honest about staleness) and mutations happen by sending events\n * whose serial handlers decide against fresh state.\n */\nexport type ActorConcurrentContext<D extends ActorProtocol> = {\n  /** The message id — stable across re-runs; the idempotency key for external I/O. */\n  id: string\n  /** Durable 1-based dispatch ordinal of this message. */\n  attempt: number\n  /** The ordinary A2 handler signal — fires on claim expiry or supersession. */\n  signal: AbortSignal\n  /** Snapshot read — observational; the world moves while this runs. */\n  state(): Promise<{ state: D['state']; index: number }>\n  /** Typed buffered self-send — committed atomically with settlement. */\n  send: ActorSend<D['events']>\n  /** Typed durable timers — immediate provider handoff, see ActorScheduleSend. */\n  schedule: ActorScheduleSend<D['events']>\n}\n\nexport type ActorStatePayload<S> = {\n  state: S\n  /** The event whose handler committed this state. */\n  event: string\n  /** The message (invocation event) id this state answers. */\n  message: string\n  /** The session's latest clear marker when this state was read. */\n  clearIndex?: number\n}\n\nexport type ActorFailedPayload = {\n  /** The message (invocation event) id this refusal answers. */\n  message: string\n  event: string\n  error: string\n}\n\n/** The event vocabulary a client needs to follow an actor's state. */\nexport type ActorClientEventDefs<S> = {\n  'a2.actor.state': StandardSchemaV1<ActorStatePayload<S>>\n}\n\ntype SchemaResult<T> = StandardSchemaV1.Result<T>\n\nconst issue = <T>(message: string): SchemaResult<T> => ({\n  issues: [{ message }],\n})\n\nconst schema = <T>(\n  label: string,\n  parse: (value: unknown) => SchemaResult<T>,\n): StandardSchemaV1<T> => ({\n  '~standard': {\n    version: 1,\n    vendor: 'a2',\n    validate(value) {\n      try {\n        return parse(value)\n      } catch (error) {\n        return issue(\n          `${label}: ${error instanceof Error ? error.message : String(error)}`,\n        )\n      }\n    },\n  },\n})\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\n/** True for plain JSON trees — what the log can store without loss. */\nexport function isJsonTree(\n  value: unknown,\n  seen: Set<object> = new Set(),\n): boolean {\n  if (\n    value === null ||\n    typeof value === 'string' ||\n    typeof value === 'boolean'\n  ) {\n    return true\n  }\n  if (typeof value === 'number') return Number.isFinite(value)\n  if (typeof value !== 'object') return false\n  if (seen.has(value)) return false\n  seen.add(value)\n  const valid = Array.isArray(value)\n    ? value.every((item) => isJsonTree(item, seen))\n    : Object.getPrototypeOf(value) === Object.prototype &&\n      Object.values(value).every(\n        (item) => item === undefined || isJsonTree(item, seen),\n      )\n  seen.delete(value)\n  return valid\n}\n\n/** Per-field ceiling for presence values — presence is a cursor, not a document. */\nexport const PRESENCE_VALUE_MAX_BYTES = 8_192\n\n/**\n * The open presence vocabulary: the '*' catch-all validates any field\n * name against the JSON floor. The protocol types the vocabulary at\n * compile time; the route's `authorize` sees every set before\n * acceptance; renderers treat values as user input. Meaning has three\n * guards — this schema only owns the bytes.\n */\nexport const openPresenceDefs: Readonly<\n  Record<string, StandardSchemaV1<unknown>>\n> = Object.freeze({\n  '*': {\n    '~standard': {\n      version: 1,\n      vendor: 'a2',\n      validate: (value: unknown) => {\n        if (!isJsonTree(value)) {\n          return {\n            issues: [{ message: 'presence values must be plain JSON trees' }],\n          }\n        }\n        if (JSON.stringify(value).length > PRESENCE_VALUE_MAX_BYTES) {\n          return {\n            issues: [\n              {\n                message: `presence values are capped at ${PRESENCE_VALUE_MAX_BYTES} bytes`,\n              },\n            ],\n          }\n        }\n        return { value }\n      },\n    },\n  } satisfies StandardSchemaV1<unknown>,\n})\n\n/**\n * The `a2.actor.state` envelope: provenance plus the state, held to a\n * plain JSON tree (a `Date` or `Map` in state fails loudly at commit,\n * never silently coerces in the log).\n */\nexport function actorStateSchema<S>(): StandardSchemaV1<ActorStatePayload<S>> {\n  return schema(ACTOR_STATE_EVENT, (value) => {\n    if (\n      !isRecord(value) ||\n      typeof value['event'] !== 'string' ||\n      typeof value['message'] !== 'string'\n    ) {\n      return issue(`invalid ${ACTOR_STATE_EVENT} payload`)\n    }\n    const state = value['state']\n    if (!isJsonTree(state)) {\n      return issue('the actor state must be a plain JSON tree')\n    }\n    const clearIndex = value['clearIndex']\n    if (\n      clearIndex !== undefined &&\n      (!Number.isSafeInteger(clearIndex) || (clearIndex as number) < 1)\n    ) {\n      return issue('the actor clearIndex must be a positive safe integer')\n    }\n    return {\n      value: {\n        state: state as S,\n        event: value['event'],\n        message: value['message'],\n        ...(clearIndex === undefined\n          ? {}\n          : { clearIndex: clearIndex as number }),\n      },\n    }\n  })\n}\n\nexport const actorFailedSchema: StandardSchemaV1<ActorFailedPayload> = schema(\n  ACTOR_FAILED_EVENT,\n  (value) => {\n    if (\n      !isRecord(value) ||\n      typeof value['message'] !== 'string' ||\n      typeof value['event'] !== 'string' ||\n      typeof value['error'] !== 'string'\n    ) {\n      return issue(`invalid ${ACTOR_FAILED_EVENT} payload`)\n    }\n    return {\n      value: {\n        message: value['message'],\n        event: value['event'],\n        error: value['error'],\n      },\n    }\n  },\n)\n\nexport type ActorReducerOptions<S> = {\n  /** The actor's name — must match the server-side definition. */\n  name: string\n  /** The initial state — a plain JSON tree, the fold's seed. */\n  state: S\n}\n\n/**\n * The library fold over an actor's state commits — last write wins.\n * Pure library code: a browser bundle folds an actor's live state with\n * no user code, so the actor definition itself stays server-only\n * (import the server module's type for typing, this reducer for data).\n */\nexport function actorReducer<S>(\n  options: ActorReducerOptions<S>,\n): Reducer<ActorClientEventDefs<S>, S> {\n  if (!isJsonTree(options.state)) {\n    throw new TypeError(\n      `actor '${options.name}': the initial state must be a plain JSON tree`,\n    )\n  }\n  const events: ActorClientEventDefs<S> = {\n    [ACTOR_STATE_EVENT]: actorStateSchema(),\n  }\n  return reducer({\n    contract: createContract({ name: options.name, events }),\n    name: ACTOR_REDUCER_NAME,\n    initialState: options.state,\n  }).fold((state, event) =>\n    event.type === ACTOR_STATE_EVENT ? event.payload.state : state,\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,MAAa,oBAAoB;;AAEjC,MAAa,qBAAqB;;AAElC,MAAa,aAAa;;AAE1B,MAAa,qBAAqB;;;;;;;AAQlC,IAAa,oBAAb,cAAuC,MAAM;;CAE3C;;CAEA;CACA,YAAY,OAAe,WAAmB,SAAiB;EAC7D,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,QAAQ;EACb,KAAK,YAAY;CACnB;AACF;AAkJA,MAAM,SAAY,aAAsC,EACtD,QAAQ,CAAC,EAAE,QAAQ,CAAC,EACtB;AAEA,MAAM,UACJ,OACA,WACyB,EACzB,aAAa;CACX,SAAS;CACT,QAAQ;CACR,SAAS,OAAO;EACd,IAAI;GACF,OAAO,MAAM,KAAK;EACpB,SAAS,OAAO;GACd,OAAO,MACL,GAAG,MAAM,IAAI,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GACpE;EACF;CACF;AACF,EACF;AAEA,MAAM,YAAY,UAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;;AAGrE,SAAgB,WACd,OACA,uBAAoB,IAAI,IAAI,GACnB;CACT,IACE,UAAU,QACV,OAAO,UAAU,YACjB,OAAO,UAAU,WAEjB,OAAO;CAET,IAAI,OAAO,UAAU,UAAU,OAAO,OAAO,SAAS,KAAK;CAC3D,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,KAAK,IAAI,KAAK,GAAG,OAAO;CAC5B,KAAK,IAAI,KAAK;CACd,MAAM,QAAQ,MAAM,QAAQ,KAAK,IAC7B,MAAM,OAAO,SAAS,WAAW,MAAM,IAAI,CAAC,IAC5C,OAAO,eAAe,KAAK,MAAM,OAAO,aACxC,OAAO,OAAO,KAAK,CAAC,CAAC,OAClB,SAAS,SAAS,KAAA,KAAa,WAAW,MAAM,IAAI,CACvD;CACJ,KAAK,OAAO,KAAK;CACjB,OAAO;AACT;;AAGA,MAAa,2BAA2B;;;;;;;;AASxC,MAAa,mBAET,OAAO,OAAO,EAChB,KAAK,EACH,aAAa;CACX,SAAS;CACT,QAAQ;CACR,WAAW,UAAmB;EAC5B,IAAI,CAAC,WAAW,KAAK,GACnB,OAAO,EACL,QAAQ,CAAC,EAAE,SAAS,2CAA2C,CAAC,EAClE;EAEF,IAAI,KAAK,UAAU,KAAK,CAAC,CAAC,SAAA,MACxB,OAAO,EACL,QAAQ,CACN,EACE,SAAS,iCAAiC,yBAAyB,QACrE,CACF,EACF;EAEF,OAAO,EAAE,MAAM;CACjB;AACF,EACF,EACF,CAAC;;;;;;AAOD,SAAgB,mBAA8D;CAC5E,OAAO,OAAO,oBAAoB,UAAU;EAC1C,IACE,CAAC,SAAS,KAAK,KACf,OAAO,MAAM,aAAa,YAC1B,OAAO,MAAM,eAAe,UAE5B,OAAO,MAAM,WAAW,kBAAkB,SAAS;EAErD,MAAM,QAAQ,MAAM;EACpB,IAAI,CAAC,WAAW,KAAK,GACnB,OAAO,MAAM,2CAA2C;EAE1D,MAAM,aAAa,MAAM;EACzB,IACE,eAAe,KAAA,MACd,CAAC,OAAO,cAAc,UAAU,KAAM,aAAwB,IAE/D,OAAO,MAAM,sDAAsD;EAErE,OAAO,EACL,OAAO;GACE;GACP,OAAO,MAAM;GACb,SAAS,MAAM;GACf,GAAI,eAAe,KAAA,IACf,CAAC,IACD,EAAc,WAAqB;EACzC,EACF;CACF,CAAC;AACH;AAEA,MAAa,oBAA0D,OACrE,qBACC,UAAU;CACT,IACE,CAAC,SAAS,KAAK,KACf,OAAO,MAAM,eAAe,YAC5B,OAAO,MAAM,aAAa,YAC1B,OAAO,MAAM,aAAa,UAE1B,OAAO,MAAM,WAAW,mBAAmB,SAAS;CAEtD,OAAO,EACL,OAAO;EACL,SAAS,MAAM;EACf,OAAO,MAAM;EACb,OAAO,MAAM;CACf,EACF;AACF,CACF;;;;;;;AAeA,SAAgB,aACd,SACqC;CACrC,IAAI,CAAC,WAAW,QAAQ,KAAK,GAC3B,MAAM,IAAI,UACR,UAAU,QAAQ,KAAK,+CACzB;CAEF,MAAM,SAAkC,GACrC,oBAAoB,iBAAiB,EACxC;CACA,OAAO,QAAQ;EACb,UAAUA,iBAAe;GAAE,MAAM,QAAQ;GAAM;EAAO,CAAC;EACvD,MAAM;EACN,cAAc,QAAQ;CACxB,CAAC,CAAC,CAAC,MAAM,OAAO,UACd,MAAM,SAAA,mBAA6B,MAAM,QAAQ,QAAQ,KAC3D;AACF"}
+{"version":3,"file":"actor-shared-DFET5q16.js","names":["createContract"],"sources":["../src/actor-shared.ts"],"sourcesContent":["import { reducer } from './reducer.ts'\n/**\n * Internal shared vocabulary of the actor module — the reserved event\n * envelopes, the protocol and context types, the state fold. Not an\n * entry point: the public surfaces are experimental-a2/actor (server),\n * /actor/client, and /actor/react.\n *\n * An actor is a durable mailbox with memory: one session per instance,\n * events processed one at a time (a lane) unless a handler opts out\n * with `concurrent: true`, state materialized as `a2.actor.state`\n * events committed atomically with each handler's completion.\n */\n\nimport { internalContract as createContract } from './contract.ts'\nimport type { Reducer } from './reducer.ts'\nimport type { ScheduleTiming } from './server.ts'\nimport type { StandardSchemaV1 } from './standard-schema.ts'\n\n/** Event type of a committed state change — one per completed serial handler. */\nexport const ACTOR_STATE_EVENT = 'a2.actor.state'\n/** Event type of a refusal — a handler that answered by throwing NonRetriableError. */\nexport const ACTOR_FAILED_EVENT = 'a2.actor.failed'\n/** The per-instance lane every serial handler shares — the state's write lock. */\nexport const ACTOR_LANE = 'a2.actor'\n/** Reducer identity — bump when the fold's meaning changes. */\nexport const ACTOR_REDUCER_NAME = 'a2.actor.v1'\n\n/**\n * A handler answered by throwing `NonRetriableError`: the event\n * settled, the state did not change. Isomorphic — the server raises it\n * from calls and `fetch()` serializes it as a 409; the client's `call`\n * proxy revives it from that response.\n */\nexport class ActorRefusedError extends Error {\n  /** The refused event's name. */\n  readonly event: string\n  /** The refused event's message id. */\n  readonly messageId: string\n  constructor(event: string, messageId: string, message: string) {\n    super(message)\n    this.name = 'ActorRefusedError'\n    this.event = event\n    this.messageId = messageId\n  }\n}\n\n/**\n * The declaration an actor is defined over: its state shape and its\n * event vocabulary, as types. Core A2 contracts are schemas because\n * the wire is untrusted; actor protocols are types because your\n * server is trusted — same contract-first design language, dialed to\n * the trust level.\n */\nexport type ActorProtocol = {\n  state: object\n  events: object\n  /**\n   * Optional third vocabulary: presence field → value type. Ephemeral\n   * audience state (who is here, cursors), replicated to subscribers\n   * and never stored in the log. Declaring it requires `presence:\n   * true` in the actor options — the wire bit types cannot carry.\n   */\n  presence?: object\n}\n\n/** The protocol's presence vocabulary, `never` when undeclared. */\nexport type ActorPresenceOf<D extends ActorProtocol> = D extends {\n  presence: infer P extends object\n}\n  ? P\n  : never\n\n/** A `setPresence` patch: changed fields, `null` clears one. */\nexport type ActorPresenceValues<P> = {\n  [F in keyof P & string]?: P[F] | null\n}\n\n/**\n * The replicated presence map: participant → field → latest value,\n * last write wins per field. Values are peer-authored — render them\n * like user input.\n */\nexport type ActorPresenceMap<P> = {\n  [participant: string]: {\n    [F in keyof P & string]?: { value: P[F]; seen: number; at: Date }\n  }\n}\n\n/**\n * The typed self-send surface: one method per declared event —\n * `ctx.send.transfer({ ref, amount })`. Buffered, not immediate: every\n * send requested during a handler commits atomically with that\n * handler's completion (a serial handler's state commit, a concurrent\n * handler's settlement), riding core's returned-events semantics — so\n * a reserve-and-trigger can never half-happen, and re-runs converge on\n * the same deterministic message ids.\n */\nexport type ActorSend<E> = {\n  readonly [K in keyof E]: {} extends E[K]\n    ? (input?: E[K]) => void\n    : (input: E[K]) => void\n}\n\n/**\n * Timing for a scheduled event: exactly `{ delay: '5d' }` or\n * `{ at: Date }` (core §6 semantics — relative delays anchor to the\n * triggering message's durable `createdAt`, so re-runs resolve the\n * same due time). `name` overrides the timer's identity — it defaults\n * to the target event name, scoped to the triggering message, so one\n * handler run gets one timer per target event unless named apart.\n */\nexport type ActorScheduleOptions = ScheduleTiming & { name?: string }\n\n/**\n * The typed durable-timer surface: one method per declared event —\n * `ctx.schedule.refund({ ref: ctx.id }, { delay: '1h' })`. Unlike\n * `send`, scheduling is immediate, not buffered: it awaits provider\n * acceptance at call time (a timer is provider-side, not a log row),\n * so a handler that schedules and then refuses has still armed the\n * timer. That is safe by the guarded-delivery idiom — the stale timer\n * fires into an idempotent no-op — but it is the one exception to\n * \"refusals are total\". Requires a configured `scheduler`.\n */\nexport type ActorScheduleSend<E> = {\n  readonly [K in keyof E]: {} extends E[K]\n    ? (input: E[K] | undefined, options: ActorScheduleOptions) => Promise<void>\n    : (input: E[K], options: ActorScheduleOptions) => Promise<void>\n}\n\n/** What a serial handler receives alongside its typed input. */\nexport type ActorContext<D extends ActorProtocol> = {\n  /** Mutable draft, committed atomically with the handler's completion. */\n  state: D['state']\n  /** The message id — stable across re-runs; the idempotency key for external I/O. */\n  id: string\n  /** Durable 1-based dispatch ordinal of this message. */\n  attempt: number\n  /** The ordinary A2 handler signal — fires on claim expiry or supersession. */\n  signal: AbortSignal\n  /** Typed buffered self-send — committed atomically with the state commit. */\n  send: ActorSend<D['events']>\n  /** Typed durable timers — immediate provider handoff, see ActorScheduleSend. */\n  schedule: ActorScheduleSend<D['events']>\n}\n\n/**\n * What a `concurrent: true` handler receives. No draft — concurrent\n * handlers run off the lane, in parallel, so state is a snapshot read\n * (honest about staleness) and mutations happen by sending events\n * whose serial handlers decide against fresh state.\n */\nexport type ActorConcurrentContext<D extends ActorProtocol> = {\n  /** The message id — stable across re-runs; the idempotency key for external I/O. */\n  id: string\n  /** Durable 1-based dispatch ordinal of this message. */\n  attempt: number\n  /** The ordinary A2 handler signal — fires on claim expiry or supersession. */\n  signal: AbortSignal\n  /** Snapshot read — observational; the world moves while this runs. */\n  state(): Promise<{ state: D['state']; index: number }>\n  /** Typed buffered self-send — committed atomically with settlement. */\n  send: ActorSend<D['events']>\n  /** Typed durable timers — immediate provider handoff, see ActorScheduleSend. */\n  schedule: ActorScheduleSend<D['events']>\n}\n\nexport type ActorStatePayload<S> = {\n  state: S\n  /** The event whose handler committed this state. */\n  event: string\n  /** The message (invocation event) id this state answers. */\n  message: string\n  /** The session's latest clear marker when this state was read. */\n  clearIndex?: number\n}\n\nexport type ActorFailedPayload = {\n  /** The message (invocation event) id this refusal answers. */\n  message: string\n  event: string\n  error: string\n}\n\n/** The event vocabulary a client needs to follow an actor's state. */\nexport type ActorClientEventDefs<S> = {\n  'a2.actor.state': StandardSchemaV1<ActorStatePayload<S>>\n}\n\ntype SchemaResult<T> = StandardSchemaV1.Result<T>\n\nconst issue = <T>(message: string): SchemaResult<T> => ({\n  issues: [{ message }],\n})\n\nconst schema = <T>(\n  label: string,\n  parse: (value: unknown) => SchemaResult<T>,\n): StandardSchemaV1<T> => ({\n  '~standard': {\n    version: 1,\n    vendor: 'a2',\n    validate(value) {\n      try {\n        return parse(value)\n      } catch (error) {\n        return issue(\n          `${label}: ${error instanceof Error ? error.message : String(error)}`,\n        )\n      }\n    },\n  },\n})\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\n/** True for plain JSON trees — what the log can store without loss. */\nexport function isJsonTree(\n  value: unknown,\n  seen: Set<object> = new Set(),\n): boolean {\n  if (\n    value === null ||\n    typeof value === 'string' ||\n    typeof value === 'boolean'\n  ) {\n    return true\n  }\n  if (typeof value === 'number') return Number.isFinite(value)\n  if (typeof value !== 'object') return false\n  if (seen.has(value)) return false\n  seen.add(value)\n  const valid = Array.isArray(value)\n    ? value.every((item) => isJsonTree(item, seen))\n    : Object.getPrototypeOf(value) === Object.prototype &&\n      Object.values(value).every(\n        (item) => item === undefined || isJsonTree(item, seen),\n      )\n  seen.delete(value)\n  return valid\n}\n\n/** Per-field ceiling for presence values — presence is a cursor, not a document. */\nexport const PRESENCE_VALUE_MAX_BYTES = 8_192\n\n/**\n * The open presence vocabulary: the '*' catch-all validates any field\n * name against the JSON floor. The protocol types the vocabulary at\n * compile time; the route's `authorize` sees every set before\n * acceptance; renderers treat values as user input. Meaning has three\n * guards — this schema only owns the bytes.\n */\nexport const openPresenceDefs: Readonly<\n  Record<string, StandardSchemaV1<unknown>>\n> = Object.freeze({\n  '*': {\n    '~standard': {\n      version: 1,\n      vendor: 'a2',\n      validate: (value: unknown) => {\n        if (!isJsonTree(value)) {\n          return {\n            issues: [{ message: 'presence values must be plain JSON trees' }],\n          }\n        }\n        if (JSON.stringify(value).length > PRESENCE_VALUE_MAX_BYTES) {\n          return {\n            issues: [\n              {\n                message: `presence values are capped at ${PRESENCE_VALUE_MAX_BYTES} bytes`,\n              },\n            ],\n          }\n        }\n        return { value }\n      },\n    },\n  } satisfies StandardSchemaV1<unknown>,\n})\n\n/**\n * The `a2.actor.state` envelope: provenance plus the state, held to a\n * plain JSON tree (a `Date` or `Map` in state fails loudly at commit,\n * never silently coerces in the log).\n */\nexport function actorStateSchema<S>(): StandardSchemaV1<ActorStatePayload<S>> {\n  return schema(ACTOR_STATE_EVENT, (value) => {\n    if (\n      !isRecord(value) ||\n      typeof value['event'] !== 'string' ||\n      typeof value['message'] !== 'string'\n    ) {\n      return issue(`invalid ${ACTOR_STATE_EVENT} payload`)\n    }\n    const state = value['state']\n    if (!isJsonTree(state)) {\n      return issue('the actor state must be a plain JSON tree')\n    }\n    const clearIndex = value['clearIndex']\n    if (\n      clearIndex !== undefined &&\n      (!Number.isSafeInteger(clearIndex) || (clearIndex as number) < 1)\n    ) {\n      return issue('the actor clearIndex must be a positive safe integer')\n    }\n    return {\n      value: {\n        state: state as S,\n        event: value['event'],\n        message: value['message'],\n        ...(clearIndex === undefined\n          ? {}\n          : { clearIndex: clearIndex as number }),\n      },\n    }\n  })\n}\n\nexport const actorFailedSchema: StandardSchemaV1<ActorFailedPayload> = schema(\n  ACTOR_FAILED_EVENT,\n  (value) => {\n    if (\n      !isRecord(value) ||\n      typeof value['message'] !== 'string' ||\n      typeof value['event'] !== 'string' ||\n      typeof value['error'] !== 'string'\n    ) {\n      return issue(`invalid ${ACTOR_FAILED_EVENT} payload`)\n    }\n    return {\n      value: {\n        message: value['message'],\n        event: value['event'],\n        error: value['error'],\n      },\n    }\n  },\n)\n\nexport type ActorReducerOptions<S> = {\n  /** The actor's name — must match the server-side definition. */\n  name: string\n  /** The initial state — a plain JSON tree, the fold's seed. */\n  state: S\n}\n\n/**\n * The library fold over an actor's state commits — last write wins.\n * Pure library code: a browser bundle folds an actor's live state with\n * no user code, so the actor definition itself stays server-only\n * (import the server module's type for typing, this reducer for data).\n */\nexport function actorReducer<S>(\n  options: ActorReducerOptions<S>,\n): Reducer<ActorClientEventDefs<S>, S> {\n  if (!isJsonTree(options.state)) {\n    throw new TypeError(\n      `actor '${options.name}': the initial state must be a plain JSON tree`,\n    )\n  }\n  const events: ActorClientEventDefs<S> = {\n    [ACTOR_STATE_EVENT]: actorStateSchema(),\n  }\n  return reducer({\n    contract: createContract({ name: options.name, events }),\n    name: ACTOR_REDUCER_NAME,\n    initialState: options.state,\n  }).fold((state, event) =>\n    event.type === ACTOR_STATE_EVENT ? event.payload.state : state,\n  )\n}\n"],"mappings":"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"}

package/dist/actor.d.ts

@@ -1,2 +1,2 @@
-import { _ as ActorProtocol, a as ActorHandle, b as ActorScheduleSend, c as ActorOptions, d as concurrent, f as ActorConcurrentContext, g as ActorPresenceValues, h as ActorPresenceOf, i as ActorFetchOptions, l as ActorSendOptions, m as ActorPresenceMap, n as ActorCallResult, o as ActorHandler, p as ActorContext, r as ActorDefinition, s as ActorOperation, t as ActorCallOptions, u as actor, v as ActorRefusedError, x as ActorSend, y as ActorScheduleOptions } from "./actor-C7b-1arn.js";
+import { _ as ActorProtocol, a as ActorHandle, b as ActorScheduleSend, c as ActorOptions, d as concurrent, f as ActorConcurrentContext, g as ActorPresenceValues, h as ActorPresenceOf, i as ActorFetchOptions, l as ActorSendOptions, m as ActorPresenceMap, n as ActorCallResult, o as ActorHandler, p as ActorContext, r as ActorDefinition, s as ActorOperation, t as ActorCallOptions, u as actor, v as ActorRefusedError, x as ActorSend, y as ActorScheduleOptions } from "./actor-HnGmrOZZ.js";
 export { ActorCallOptions, ActorCallResult, type ActorConcurrentContext, type ActorContext, ActorDefinition, ActorFetchOptions, ActorHandle, ActorHandler, ActorOperation, ActorOptions, type ActorPresenceMap, type ActorPresenceOf, type ActorPresenceValues, type ActorProtocol, ActorRefusedError, type ActorScheduleOptions, type ActorScheduleSend, type ActorSend, ActorSendOptions, actor, concurrent };

package/dist/actor.js

@@ -1,8 +1,9 @@
-import { a as NonRetriableError, i as A2Error, n as isSessionCleared, r as sessionClearedError } from "./session-clear-DGI4jTQ5.js";
-import { n as internalContract } from "./contract-BYKASlCV.js";
-import { v as serverInternals } from "./internal-CscSY7K_.js";
-import { c as parsePresenceSibling, o as setServerFetchHooks, s as sseResponse, t as createServer } from "./server-qyb5aJJG.js";
-import { a as actorFailedSchema, c as isJsonTree, i as ActorRefusedError, l as openPresenceDefs, n as ACTOR_LANE, o as actorReducer, r as ACTOR_STATE_EVENT, s as actorStateSchema, t as ACTOR_FAILED_EVENT } from "./actor-shared-t7w8xIKP.js";
+import { a as NonRetriableError, i as A2Error, n as isSessionCleared, r as sessionClearedError } from "./session-clear-wHd5GCpZ.js";
+import { n as internalContract } from "./contract-CWukt01d.js";
+import { b as serverInternals } from "./internal-Bc4PvfHk.js";
+import { c as parsePresenceSibling, n as createServer, o as setServerFetchHooks, s as sseResponse } from "./server-DvIB8kj5.js";
+import { t as runtimeConsumer } from "./runtime-consumer-BWmht60z.js";
+import { a as actorFailedSchema, c as isJsonTree, i as ActorRefusedError, l as openPresenceDefs, n as ACTOR_LANE, o as actorReducer, r as ACTOR_STATE_EVENT, s as actorStateSchema, t as ACTOR_FAILED_EVENT } from "./actor-shared-DFET5q16.js";
 //#region src/actor.ts
 /**
 * experimental-a2/actor — durable actors over the log. Server-only
@@ -148,10 +149,11 @@ function actor(options) {
 		});
 		return send;
 	};
-	const handlers = {};
+	const concurrentRuns = /* @__PURE__ */ new Map();
+	const serialRuns = /* @__PURE__ */ new Map();
 	for (const [eventName, def] of handlersByEvent) {
 		if (def.kind === "concurrent") {
-			handlers[eventName] = async (ctx) => {
+			concurrentRuns.set(eventName, async (ctx) => {
 				const sends = [];
 				try {
 					await def.handle({
@@ -181,48 +183,45 @@ function actor(options) {
 					};
 				}
 				return sends;
-			};
+			});
 			continue;
 		}
-		handlers[eventName] = {
-			lane: ACTOR_LANE,
-			handler: async (ctx) => {
-				const { state, clearIndex } = await ctx.session.state(serverReducer, { through: "latest" });
-				const draft = structuredClone(state);
-				const sends = [];
-				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, event))
-					}, ctx.event.payload);
-				} catch (error) {
-					if (!(error instanceof NonRetriableError)) throw error;
-					const payload = {
-						message: ctx.event.id,
-						event: eventName,
-						error: describeError(error)
-					};
-					return {
-						type: ACTOR_FAILED_EVENT,
-						payload
-					};
-				}
-				const payload = {
+		serialRuns.set(eventName, async (ctx) => {
+			const { state, clearIndex } = await ctx.session.state(serverReducer, { through: "latest" });
+			const draft = structuredClone(state);
+			const sends = [];
+			try {
+				await def.handle({
 					state: draft,
-					event: eventName,
+					id: ctx.event.id,
+					attempt: ctx.attempt,
+					signal: ctx.signal,
+					send: makeSend(sends),
+					schedule: makeSchedule((taskName, timing, event) => ctx.session.schedule(taskName, timing, event))
+				}, ctx.event.payload);
+			} catch (error) {
+				if (!(error instanceof NonRetriableError)) throw error;
+				const payload = {
 					message: ctx.event.id,
-					...clearIndex === void 0 ? {} : { clearIndex }
+					event: eventName,
+					error: describeError(error)
 				};
-				return [...sends, {
-					type: ACTOR_STATE_EVENT,
+				return {
+					type: ACTOR_FAILED_EVENT,
 					payload
-				}];
+				};
 			}
-		};
+			const payload = {
+				state: draft,
+				event: eventName,
+				message: ctx.event.id,
+				...clearIndex === void 0 ? {} : { clearIndex }
+			};
+			return [...sends, {
+				type: ACTOR_STATE_EVENT,
+				payload
+			}];
+		});
 	}
 	const presenceEnabled = options.presence === true;
 	const contract = presenceEnabled ? internalContract({
@@ -233,9 +232,21 @@ function actor(options) {
 		name,
 		events
 	});
+	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))], ...concurrentTypes.length === 0 ? [] : [runtimeConsumer({
+		contract,
+		name: "a2.actor.concurrent",
+		types: concurrentTypes
+	}).run((ctx) => concurrentRuns.get(ctx.event.type)(ctx))]];
 	const server = createServer({
 		contract,
-		handlers,
+		consumers,
 		...options.store ? { store: options.store } : {},
 		...options.scheduler ? { scheduler: options.scheduler } : {},
 		...options.telemetry ? { telemetry: options.telemetry } : {}

package/dist/actor.js.map

@@ -1 +1 @@
-{"version":3,"file":"actor.js","names":["createContract"],"sources":["../src/actor.ts"],"sourcesContent":["/**\n * experimental-a2/actor — durable actors over the log. Server-only\n * (handlers are server code); the browser condition resolves to a\n * throwing stub, and the browser surfaces are experimental-a2/actor/client\n * and experimental-a2/actor/react.\n *\n * An actor is defined over a protocol — its state shape and event\n * vocabulary, as types — and one complete `handlers` bag:\n *\n * ```ts\n * interface Counter {\n *   state: { count: number }\n *   events: { increment: object; add: { by: number } }\n * }\n * const counter = actor<Counter>({\n *   name: 'counter',\n *   state: { count: 0 },\n *   handlers: {\n *     increment: (ctx) => {\n *       ctx.state.count++\n *     },\n *     add: (ctx, input) => {\n *       ctx.state.count += input.by\n *     },\n *   },\n * })\n * ```\n *\n * Handlers are serial by default: one at a time per instance (a lane —\n * the state's write lock), `ctx.state` a mutable draft committed\n * atomically with completion. A handler holding slow I/O opts out of\n * the lane with `{ concurrent: true, handle }`: it runs in parallel,\n * reads state as a snapshot, and mutates by sending events whose\n * serial handlers decide against fresh state. `ctx.send.eventName(...)`\n * is typed by the protocol and buffered — committed atomically with\n * the handler's completion, so a reserve and its trigger can never\n * half-happen.\n *\n * A thrown `NonRetriableError` is an answer (settled, delivered to a\n * waiting caller); any other error retries like every A2 handler\n * failure; a crash re-runs against the same pre-state. Everything\n * compiles to contract + reducer + laned handlers + returned events —\n * no new store operations, no new wire.\n */\n\n// oxlint-disable no-await-in-loop -- a call awaits its answer: drain, read\n// the tail, repeat until the message settles. Sequential by nature.\n\nimport {\n  ACTOR_FAILED_EVENT,\n  ACTOR_LANE,\n  ACTOR_STATE_EVENT,\n  ActorRefusedError,\n  actorFailedSchema,\n  actorReducer,\n  actorStateSchema,\n  isJsonTree,\n  openPresenceDefs,\n} from './actor-shared.ts'\nimport type {\n  ActorClientEventDefs,\n  ActorConcurrentContext,\n  ActorContext,\n  ActorFailedPayload,\n  ActorPresenceOf,\n  ActorProtocol,\n  ActorScheduleOptions,\n  ActorScheduleSend,\n  ActorSend,\n  ActorStatePayload,\n} from './actor-shared.ts'\nimport { parsePresenceSibling } from './push-envelope.ts'\nimport type { ParsedPushPresence } from './push-envelope.ts'\nimport { internalContract as createContract } from './contract.ts'\nimport type { PresencePatch, PresenceSnapshot } from './contract.ts'\nimport type { Contract, EventDefs } from './contract.ts'\nimport type { Reducer } from './reducer.ts'\nimport { A2Error, NonRetriableError } from './errors.ts'\nimport { serverInternals } from './internal.ts'\nimport { createServer } from './server.ts'\nimport { setServerFetchHooks } from './server-fetch.ts'\nimport { sseResponse } from './sse.ts'\nimport { isSessionCleared, sessionClearedError } from './session-clear.ts'\nimport type { SessionCleared } from './session-clear.ts'\nimport type { A2Scheduler, A2Server, HandlerEntry, Session } from './server.ts'\nimport type { A2Store } from './store.ts'\nimport type { StandardSchemaV1 } from './standard-schema.ts'\nimport type { A2Telemetry } from './telemetry.ts'\n\nexport type {\n  ActorConcurrentContext,\n  ActorContext,\n  ActorPresenceMap,\n  ActorPresenceOf,\n  ActorPresenceValues,\n  ActorProtocol,\n  ActorScheduleOptions,\n  ActorScheduleSend,\n  ActorSend,\n} from './actor-shared.ts'\nexport { ActorRefusedError } from './actor-shared.ts'\n\n/**\n * One event's handler: ordinary server code. Serial by default — read\n * `ctx.state`, perform I/O, mutate `ctx.state`, one atomic commit at\n * return. `{ concurrent: true, handle }` opts the handler out of the\n * lane for slow I/O: state becomes a snapshot read and mutations\n * happen by sending events. The input is typed by the protocol; the\n * wire hands handlers parsed JSON, so a wire-exposed event guards its\n * input in its first line (`schema.parse(input)` if you like schemas —\n * userland either way).\n */\nexport type ActorHandler<D extends ActorProtocol, K extends keyof D['events']> =\n  | ((ctx: ActorContext<D>, input: D['events'][K]) => void | Promise<void>)\n  | {\n      concurrent: true\n      handle: (\n        ctx: ActorConcurrentContext<D>,\n        input: D['events'][K],\n      ) => void | Promise<void>\n    }\n\n/**\n * Mark a handler concurrent — off the lane, in parallel with the lane\n * and with other concurrent handlers, `ctx.state()` a snapshot read.\n * Sugar for the structural `{ concurrent: true, handle }` form:\n *\n * ```ts\n * handlers: {\n *   transfer: concurrent(async (ctx, input) => {\n *     await bank.transfer(input, { idempotencyKey: input.ref })\n *     ctx.send.settle({ ref: input.ref })\n *   }),\n * }\n * ```\n */\nexport function concurrent<Ctx, I>(\n  handle: (ctx: Ctx, input: I) => void | Promise<void>,\n): { concurrent: true; handle: (ctx: Ctx, input: I) => void | Promise<void> } {\n  return { concurrent: true, handle }\n}\n\nexport type ActorOptions<D extends ActorProtocol> = {\n  /** Identity — prefixes storage keys; one contract per actor definition. */\n  name: string\n  /** The initial state — checked against the protocol, a plain JSON tree. */\n  state: D['state']\n  /**\n   * One handler per declared event — completeness and payload shapes\n   * are compile-checked against the protocol.\n   */\n  handlers: { [K in keyof D['events']]: ActorHandler<D, K> }\n  store?: A2Store\n  scheduler?: A2Scheduler\n  telemetry?: A2Telemetry\n} & ([ActorPresenceOf<D>] extends [never]\n  ? { presence?: never }\n  : {\n      /**\n       * The wire bit for the protocol's `presence` vocabulary — types\n       * erase, so the runtime needs one value to arm the presence\n       * lanes (frames on GET, envelopes on POST). Required exactly\n       * when the protocol declares `presence`; the vocabulary itself\n       * is typed there. Values are validated to the JSON floor and\n       * pass through `authorize` as `{ type: 'presence' }` operations;\n       * meaning stays with your renderers — treat values as user\n       * input.\n       */\n      presence: true\n    })\n\n/**\n * One HTTP operation `handle.fetch` is about to serve — the actor\n * mirror of core's `A2Operation`. `authorize` sees it before any\n * read, write, or subscription; returning `false` answers 403.\n */\nexport type ActorOperation =\n  | { readonly type: 'state'; readonly id: string }\n  | {\n      readonly type: 'stream'\n      readonly id: string\n      readonly startAfter: number\n    }\n  | {\n      readonly type: 'call'\n      readonly id: string\n      readonly event: string\n      readonly input: unknown\n      readonly messageId?: string\n    }\n  | {\n      readonly type: 'presence'\n      readonly id: string\n      readonly participant: string\n      readonly values: Readonly<Record<string, unknown>>\n    }\n\nexport type ActorFetchOptions<D extends ActorProtocol> = {\n  /** Per-operation policy — authentication happened in your route. */\n  authorize?: (operation: ActorOperation) => boolean | Promise<boolean>\n  /**\n   * Request-time projection: what this mount's audience sees. Applied\n   * to every state frame on the stream AND to call answers (the two\n   * untrusted lanes must agree, or the call lane leaks what the\n   * stream hides). The definition stays audience-agnostic — different\n   * routes project the same actor differently, and per-viewer views\n   * are just closures over the route's auth. Output is held to the\n   * JSON-tree floor like everything else. Transport-agnostic: applied\n   * at frame emission, so any wire the door speaks emits projected\n   * frames. Absent, the full state ships (the trusted default).\n   */\n  view?: (state: D['state']) => unknown\n}\n\nexport type ActorSendOptions = {\n  /** Explicit message id — makes retries of this send idempotent. */\n  id?: string\n}\n\nexport type ActorCallOptions = ActorSendOptions & {\n  /** How long to await the answer before rejecting the wait (default 30s). */\n  timeoutMs?: number\n}\n\nexport type ActorCallResult<S> = {\n  /** The actor's state after this message was processed. */\n  state: S\n  /** Log index of the state commit that answered this message. */\n  index: number\n  /**\n   * The clear marker this state's lifetime began at, once the actor has been\n   * cleared. For a call answer it is the lifetime the handler read.\n   */\n  clearIndex?: number\n}\n\ntype CallMethod<\n  D extends ActorProtocol,\n  K extends keyof D['events'],\n> = {} extends D['events'][K]\n  ? (\n      input?: D['events'][K],\n      options?: ActorCallOptions,\n    ) => Promise<ActorCallResult<D['state']>>\n  : (\n      input: D['events'][K],\n      options?: ActorCallOptions,\n    ) => Promise<ActorCallResult<D['state']>>\n\ntype SendMethod<\n  D extends ActorProtocol,\n  K extends keyof D['events'],\n> = {} extends D['events'][K]\n  ? (\n      input?: D['events'][K],\n      options?: ActorSendOptions,\n    ) => Promise<{ id: string; index: number }>\n  : (\n      input: D['events'][K],\n      options?: ActorSendOptions,\n    ) => Promise<{ id: string; index: number }>\n\n/** One instance: typed calls and sends, reads, the managed door, the escape hatch. */\nexport type ActorHandle<D extends ActorProtocol> = {\n  readonly id: string\n  /**\n   * Send the event and await its answer: the state after the handler\n   * ran, or a rejection with `ActorRefusedError`. A clear before the call\n   * receives its answer rejects with `A2Error('SESSION_CLEARED')`. Serial\n   * events only — concurrent handlers produce no answer to await; `send`\n   * them.\n   */\n  readonly call: { readonly [K in keyof D['events']]: CallMethod<D, K> }\n  /** Cast: validate, append the event durably, return without waiting. */\n  readonly send: { readonly [K in keyof D['events']]: SendMethod<D, K> }\n  /** Snapshot read — never queues behind pending messages. */\n  readonly state: () => Promise<ActorCallResult<D['state']>>\n  /**\n   * The managed door — the actor mirror of `server.fetch`, bound to\n   * this instance. GET streams the state plane (`a2.actor.state`\n   * commits and clear resets, `?index` resume, heartbeat, deadline\n   * rotation); POST is the call lane `createActorClient` speaks\n   * (`{ event, input, messageId? }` → the answer, 409 for a refusal,\n   * 410 for a call cleared before its answer). Your route\n   * authenticates and picks the instance; `authorize` sees every\n   * operation. Custom endpoints are route code around this call.\n   */\n  readonly fetch: (\n    request: Request,\n    options?: ActorFetchOptions<D>,\n  ) => Promise<Response>\n  /** Escape hatch: the raw A2 session (history, stream, schedule). */\n  readonly session: Session<EventDefs>\n}\n\nexport type ActorDefinition<D extends ActorProtocol> = {\n  readonly name: string\n  /**\n   * Type-only carrier of the protocol, so clients deriving from\n   * `typeof def` can see the vocabularies (`experimental-a2/actor/react`\n   * types `presence` from it). Never a runtime value.\n   */\n  readonly protocol?: D\n  /** The assembled contract — declared events plus the reserved a2.actor.* pair. */\n  readonly contract: Contract<EventDefs>\n  /** The underlying A2 server — `server.fetch` mounts the full session wire. */\n  readonly server: A2Server<EventDefs>\n  /** The state fold over commits; a clear resets it to the initial state. */\n  readonly reducer: Reducer<ActorClientEventDefs<D['state']>, D['state']>\n  actor(id: string): ActorHandle<D>\n}\n\n// Object-mechanics names, not surface names: events live in their own\n// bags, so nothing else is reserved.\nconst UNSAFE_EVENT_NAMES = new Set(['__proto__', 'constructor', 'prototype'])\n\nconst forbidden = (): Response =>\n  Response.json({ error: 'the operation is not authorized' }, { status: 403 })\n\nconst CALL_TIMEOUT_MS = 30_000\nconst CALL_POLL_MS = 25\n\n/** Declared events accept any JSON tree; `undefined` normalizes to `{}`. */\nconst jsonInputSchema: StandardSchemaV1<unknown> = {\n  '~standard': {\n    version: 1,\n    vendor: 'a2',\n    validate(value) {\n      if (value === undefined || value === null) return { value: {} }\n      if (!isJsonTree(value)) {\n        return {\n          issues: [{ message: 'event input must be a plain JSON tree' }],\n        }\n      }\n      return { value }\n    },\n  },\n}\n\nconst describeError = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, ms))\n\ntype NormalizedHandler<D extends ActorProtocol> =\n  | {\n      kind: 'serial'\n      handle: (ctx: ActorContext<D>, input: unknown) => void | Promise<void>\n    }\n  | {\n      kind: 'concurrent'\n      handle: (\n        ctx: ActorConcurrentContext<D>,\n        input: unknown,\n      ) => void | Promise<void>\n    }\n\n/**\n * Define and serve an actor over its protocol: a named, durable\n * instance-per-id with serialized state handlers, concurrent I/O\n * handlers, and typed self-sends.\n */\nexport function actor<D extends ActorProtocol>(\n  options: ActorOptions<D>,\n): ActorDefinition<D> {\n  const { name } = options\n\n  const handlersByEvent = new Map<string, NormalizedHandler<D>>()\n  const events: Record<string, StandardSchemaV1> = {\n    [ACTOR_STATE_EVENT]: actorStateSchema(),\n    [ACTOR_FAILED_EVENT]: actorFailedSchema,\n  }\n  for (const [eventName, def] of Object.entries(\n    options.handlers as Record<string, ActorHandler<D, keyof D['events']>>,\n  )) {\n    if (UNSAFE_EVENT_NAMES.has(eventName)) {\n      throw new TypeError(\n        `actor '${name}': '${eventName}' collides with object plumbing and cannot name an event`,\n      )\n    }\n    if (eventName.startsWith('a2.')) {\n      throw new TypeError(\n        `actor '${name}': event names starting with 'a2.' are reserved`,\n      )\n    }\n    handlersByEvent.set(\n      eventName,\n      typeof def === 'function'\n        ? {\n            kind: 'serial',\n            handle: def as (\n              ctx: ActorContext<D>,\n              input: unknown,\n            ) => void | Promise<void>,\n          }\n        : {\n            kind: 'concurrent',\n            handle: def.handle as (\n              ctx: ActorConcurrentContext<D>,\n              input: unknown,\n            ) => void | Promise<void>,\n          },\n    )\n    events[eventName] = jsonInputSchema\n  }\n\n  const reducer = actorReducer({ name, state: options.state })\n  // The server's contract carries every event type; the reducer only\n  // folds state commits. Same fold, same identity — the widening is a\n  // typing formality.\n  const serverReducer = reducer as unknown as Reducer<EventDefs, D['state']>\n\n  // The typed durable-timer surface: immediate handoff to the\n  // configured scheduler through the handler session, so timer\n  // identity is scoped to the triggering message and re-runs address\n  // the same timer (core §6). Not buffered — see ActorScheduleSend.\n  const makeSchedule = (\n    schedule: (\n      name: string,\n      timing: { delay?: string; at?: Date },\n      event: { type: string; payload: unknown },\n    ) => Promise<void>,\n  ): ActorScheduleSend<D['events']> => {\n    const surface: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(surface, eventName, {\n        value: (input: unknown, scheduleOptions: ActorScheduleOptions) => {\n          const { name: taskName, ...timing } = scheduleOptions\n          return schedule(taskName ?? eventName, timing, {\n            type: eventName,\n            payload: input ?? {},\n          })\n        },\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n    return surface as ActorScheduleSend<D['events']>\n  }\n\n  // The typed self-send surface: per-invocation buffers behind one\n  // shared method record shape. defineProperty so event names like\n  // 'constructor'-adjacent identifiers can never touch prototypes.\n  const makeSend = (\n    buffer: { type: string; payload: unknown }[],\n  ): ActorSend<D['events']> => {\n    const send: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(send, eventName, {\n        value: (input?: unknown) => {\n          buffer.push({ type: eventName, payload: input ?? {} })\n        },\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n    return send as ActorSend<D['events']>\n  }\n\n  const handlers: Record<string, HandlerEntry<EventDefs>> = {}\n  for (const [eventName, def] of handlersByEvent) {\n    if (def.kind === 'concurrent') {\n      // No lane: concurrent handlers run in parallel — with the lane\n      // and with each other. They cannot write state (no draft to\n      // commit), so no serialization is needed for correctness; slow\n      // I/O lives here without blocking the actor.\n      handlers[eventName] = async (ctx) => {\n        const sends: { type: string; payload: unknown }[] = []\n        try {\n          await def.handle(\n            {\n              id: ctx.event.id,\n              attempt: ctx.attempt,\n              signal: ctx.signal,\n              send: makeSend(sends),\n              schedule: makeSchedule((taskName, timing, event) =>\n                ctx.session.schedule(\n                  taskName,\n                  timing as Parameters<typeof ctx.session.schedule>[1],\n                  event,\n                ),\n              ),\n              state: async () => {\n                const { state, index } = await ctx.session.state(\n                  serverReducer,\n                  { through: 'latest' },\n                )\n                return { state, index }\n              },\n            },\n            ctx.event.payload,\n          )\n        } catch (error) {\n          if (!(error instanceof NonRetriableError)) throw error\n          // A terminal failure is recorded for audit; nothing awaits a\n          // concurrent handler, so the marker is history, not an\n          // answer. Buffered sends are discarded — refusals are total,\n          // so compensate by completing (send then return), never by\n          // throwing.\n          const payload: ActorFailedPayload = {\n            message: ctx.event.id,\n            event: eventName,\n            error: describeError(error),\n          }\n          return { type: ACTOR_FAILED_EVENT, payload }\n        }\n        // Sends commit atomically with settlement; re-runs converge on\n        // the same deterministic message ids.\n        return sends\n      }\n      continue\n    }\n    handlers[eventName] = {\n      // One lane for every serial handler of one instance: the next\n      // message starts only after the previous one completed, and\n      // completion commits the state event atomically —\n      // read-modify-write on `ctx.state` is safe by exclusion, not by\n      // liveness.\n      lane: ACTOR_LANE,\n      handler: async (ctx) => {\n        // Explicitly 'latest', not the event-relative default: prior\n        // lane messages commit *after* this message was appended, so\n        // their state commits carry higher indexes than the trigger —\n        // an event-relative read would miss them and lose updates.\n        // 'latest' is deterministic here because the lane makes this\n        // attempt the only possible writer while it runs.\n        const { state, clearIndex } = await ctx.session.state(serverReducer, {\n          through: 'latest',\n        })\n        const draft = structuredClone(state)\n        const sends: { type: string; payload: unknown }[] = []\n        try {\n          await def.handle(\n            {\n              state: draft,\n              id: ctx.event.id,\n              attempt: ctx.attempt,\n              signal: ctx.signal,\n              send: makeSend(sends),\n              schedule: makeSchedule((taskName, timing, event) =>\n                ctx.session.schedule(\n                  taskName,\n                  timing as Parameters<typeof ctx.session.schedule>[1],\n                  event,\n                ),\n              ),\n            },\n            ctx.event.payload,\n          )\n        } catch (error) {\n          // A NonRetriableError is an answer: settle the message,\n          // record the refusal, deliver it to the waiting caller —\n          // no retry, no failure budget spent (buffered sends are\n          // discarded with the draft: refusals are total). Every\n          // other throw is an ordinary A2 handler failure: rethrown\n          // into core's retry machinery (backoff, ten-failure\n          // budget, dead letter) — including surrendered lease\n          // aborts, which core recognizes by identity.\n          if (!(error instanceof NonRetriableError)) throw error\n          const payload: ActorFailedPayload = {\n            message: ctx.event.id,\n            event: eventName,\n            error: describeError(error),\n          }\n          return { type: ACTOR_FAILED_EVENT, payload }\n        }\n        // One returned batch: buffered sends plus the state commit —\n        // committed atomically with completion, so a reserve and its\n        // trigger can never half-happen. The state event stays the\n        // outcome marker a waiting call resolves on. (Unconditional\n        // for now; a dirty check is a compatible later optimization.)\n        const payload: ActorStatePayload<D['state']> = {\n          state: draft,\n          event: eventName,\n          message: ctx.event.id,\n          ...(clearIndex === undefined ? {} : { clearIndex }),\n        }\n        return [...sends, { type: ACTOR_STATE_EVENT, payload }]\n      },\n    }\n  }\n\n  const presenceEnabled = (options as { presence?: unknown }).presence === true\n  // The '*' catch-all arms an open server-side vocabulary: the\n  // protocol types field names at compile time, the floor validates\n  // every value, and `authorize` sees every set. See openPresenceDefs.\n  const contract = presenceEnabled\n    ? createContract({ name, events, presence: openPresenceDefs })\n    : createContract({ name, events })\n  const server = createServer({\n    contract,\n    handlers,\n    ...(options.store ? { store: options.store } : {}),\n    ...(options.scheduler ? { scheduler: options.scheduler } : {}),\n    ...(options.telemetry ? { telemetry: options.telemetry } : {}),\n  })\n  // Single-writer discipline on the underlying session wire too: if an\n  // application mounts `def.server.fetch`, browsers may push declared\n  // events, never authored state or failure records.\n  setServerFetchHooks(server, {\n    validateIngress: ({ events: pushed }) => {\n      for (const event of pushed) {\n        if (event.type.startsWith('a2.actor.')) {\n          throw new TypeError(\n            `'${event.type}' is reserved — only a handler's completion can author it`,\n          )\n        }\n      }\n    },\n  })\n\n  const internals = serverInternals.get(server)!\n\n  const makeHandle = (id: string): ActorHandle<D> => {\n    const session = server.session(id)\n\n    const sendEvent = async (\n      eventName: string,\n      input: unknown,\n      sendOptions?: ActorSendOptions,\n    ): Promise<{ id: string; index: number }> => {\n      const [message] = await session.append({\n        type: eventName,\n        payload: input ?? {},\n        ...(sendOptions?.id ? { id: sendOptions.id } : {}),\n      })\n      if (!message) throw new Error('append returned no event')\n      return { id: message.id, index: message.index }\n    }\n\n    const callEvent = async (\n      eventName: string,\n      input: unknown,\n      callOptions?: ActorCallOptions,\n    ): Promise<ActorCallResult<D['state']>> => {\n      if (handlersByEvent.get(eventName)?.kind === 'concurrent') {\n        throw new TypeError(\n          `actor '${name}': '${eventName}' is concurrent — it produces no answer to await; send it instead`,\n        )\n      }\n      const message = await sendEvent(eventName, input, callOptions)\n      const deadline = Date.now() + (callOptions?.timeoutMs ?? CALL_TIMEOUT_MS)\n      let cursor = message.index + 1\n      for (;;) {\n        // Drain participates in processing (usually answering inline in\n        // this invocation); claims arbitrate if another process runs.\n        await server.drain(id)\n        const tail = await internals.historyWithMarkers(id, cursor)\n        for (const event of tail) {\n          // Reads start at the latest marker, so a clear after the message\n          // arrives before any answer from the next lifetime, including one\n          // from a message that reuses this id.\n          if (isSessionCleared(event)) {\n            throw sessionClearedError(\n              `actor '${name}': '${eventName}' (message ${message.id}) was cleared before the call received its answer`,\n            )\n          }\n          if (event.type === ACTOR_STATE_EVENT) {\n            const payload = event.payload as ActorStatePayload<D['state']>\n            if (payload.message === message.id) {\n              return {\n                state: payload.state,\n                index: event.index,\n                ...(payload.clearIndex === undefined\n                  ? {}\n                  : { clearIndex: payload.clearIndex }),\n              }\n            }\n          }\n          if (event.type === ACTOR_FAILED_EVENT) {\n            const payload = event.payload as ActorFailedPayload\n            if (payload.message === message.id) {\n              throw new ActorRefusedError(eventName, message.id, payload.error)\n            }\n          }\n        }\n        const last = tail[tail.length - 1]\n        if (last) cursor = last.index + 1\n        if (Date.now() >= deadline) {\n          throw new Error(\n            `actor '${name}': timed out waiting for '${eventName}' (message ${message.id})`,\n          )\n        }\n        await sleep(CALL_POLL_MS)\n      }\n    }\n\n    const readState = async (): Promise<ActorCallResult<D['state']>> => {\n      const { state, index, clearIndex } = await session.state(serverReducer)\n      return clearIndex === undefined\n        ? { state, index }\n        : { state, index, clearIndex }\n    }\n\n    /** A snapshot or call answer through the route's view. */\n    const projected = (\n      result: ActorCallResult<D['state']>,\n      view: ((state: D['state']) => unknown) | undefined,\n    ): ActorCallResult<unknown> =>\n      view ? { ...result, state: applyView(view, result.state) } : result\n\n    const applyView = (\n      view: (state: D['state']) => unknown,\n      state: D['state'],\n    ): unknown => {\n      const viewed = view(state)\n      if (!isJsonTree(viewed)) {\n        throw new TypeError(\n          `actor '${name}': the view returned a value that is not a plain JSON tree`,\n        )\n      }\n      return viewed\n    }\n\n    const streamStates = async function* (\n      startAfter: number,\n      view?: (state: D['state']) => unknown,\n    ) {\n      // With presence armed, the session interleaves presence items\n      // (snapshot, then patches) between log events. They are\n      // ephemeral audience data, not actor state: they pass through\n      // untouched — views project state, never peers — and they never\n      // advance the resume frontier.\n      const source: AsyncIterable<\n        | Awaited<ReturnType<typeof session.history>>[number]\n        | SessionCleared\n        | PresencePatch\n        | PresenceSnapshot\n      > = presenceEnabled\n        ? (\n            session as unknown as {\n              stream(options: {\n                startAfter: number\n                presence: true\n              }): AsyncIterable<PresencePatch | PresenceSnapshot>\n            }\n          ).stream({ startAfter, presence: true })\n        : session.stream({ startAfter })\n      for await (const item of source) {\n        if (!('type' in item)) {\n          yield item\n          continue\n        }\n        const event = item\n        if (isSessionCleared(event)) {\n          // The follower has no seed of its own: the marker carries the\n          // actor's initial state, projected like any commit.\n          const initial = structuredClone(options.state)\n          yield {\n            ...event,\n            payload: { state: view ? applyView(view, initial) : initial },\n          }\n          continue\n        }\n        // The state plane only: subscribers see what the actor is,\n        // never other callers' inputs. Refusals answer only their\n        // caller (the POST 409); the full mailbox stays server-side.\n        if (event.type !== ACTOR_STATE_EVENT) continue\n        if (!view) {\n          yield event\n          continue\n        }\n        const payload = event.payload as ActorStatePayload<D['state']>\n        yield {\n          ...event,\n          payload: { ...payload, state: applyView(view, payload.state) },\n        }\n      }\n    }\n\n    // The managed door — the actor mirror of `server.fetch`: GET is\n    // the state-plane SSE (`a2.actor.state` commits and clear resets,\n    // `?index` resume), POST is the call lane (`{ event, input,\n    // messageId? }` → the answer, 409 for a refusal, 410 for a cleared\n    // call). Authentication happens in the surrounding route;\n    // per-operation policy in `authorize`.\n    const handleFetch = async (\n      request: Request,\n      fetchOptions?: ActorFetchOptions<D>,\n    ): Promise<Response> => {\n      const authorized = async (operation: ActorOperation): Promise<boolean> =>\n        (await fetchOptions?.authorize?.(Object.freeze(operation))) !== false\n\n      if (request.method === 'GET') {\n        const url = new URL(request.url)\n        if (url.searchParams.has('snapshot')) {\n          if (!(await authorized({ type: 'state', id }))) return forbidden()\n          return Response.json(\n            projected(await readState(), fetchOptions?.view),\n            {\n              headers: { 'cache-control': 'private, no-store' },\n            },\n          )\n        }\n        const raw = Number(url.searchParams.get('index'))\n        const startAfter = Number.isSafeInteger(raw) && raw >= 0 ? raw : 0\n        if (!(await authorized({ type: 'stream', id, startAfter }))) {\n          return forbidden()\n        }\n        return sseResponse(streamStates(startAfter, fetchOptions?.view))\n      }\n      if (request.method !== 'POST') {\n        return new Response(null, {\n          status: 405,\n          headers: { allow: 'GET, POST' },\n        })\n      }\n      let body: unknown\n      try {\n        body = await request.json()\n      } catch {\n        return Response.json({ error: 'invalid JSON body' }, { status: 400 })\n      }\n      const record =\n        typeof body === 'object' && body !== null\n          ? (body as Record<string, unknown>)\n          : {}\n      if ('presence' in record) {\n        // A presence envelope — what the follower client's\n        // `setPresence` posts. Events never ride this lane: writes to\n        // the actor are calls.\n        if (!presenceEnabled) {\n          return Response.json(\n            { error: `actor '${name}' declares no presence` },\n            { status: 400 },\n          )\n        }\n        const pushedEvents = record['events']\n        if (\n          pushedEvents !== undefined &&\n          (!Array.isArray(pushedEvents) || pushedEvents.length > 0)\n        ) {\n          return Response.json(\n            { error: 'the actor wire takes calls, not event pushes' },\n            { status: 400 },\n          )\n        }\n        let patch: ParsedPushPresence\n        try {\n          const parsed = parsePresenceSibling(record['presence'])\n          if (!parsed) throw new TypeError('presence must be an object')\n          patch = parsed\n        } catch (error) {\n          return Response.json({ error: describeError(error) }, { status: 400 })\n        }\n        if (\n          !(await authorized({\n            type: 'presence',\n            id,\n            participant: patch.participant,\n            values: patch.values,\n          }))\n        ) {\n          return forbidden()\n        }\n        try {\n          await (\n            session as unknown as {\n              setPresence(patch: ParsedPushPresence): Promise<void>\n            }\n          ).setPresence(patch)\n        } catch (error) {\n          if (\n            error instanceof A2Error &&\n            (error.code === 'INVALID_PAYLOAD' ||\n              error.code === 'UNKNOWN_PRESENCE_FIELD')\n          ) {\n            return Response.json({ error: error.message }, { status: 400 })\n          }\n          throw error\n        }\n        return Response.json([])\n      }\n      const eventName = record['event']\n      if (\n        typeof eventName !== 'string' ||\n        handlersByEvent.get(eventName)?.kind !== 'serial'\n      ) {\n        return Response.json({ error: 'unknown event' }, { status: 400 })\n      }\n      const messageId = record['messageId']\n      if (messageId !== undefined && typeof messageId !== 'string') {\n        return Response.json({ error: 'invalid messageId' }, { status: 400 })\n      }\n      const input = record['input']\n      if (\n        !(await authorized({\n          type: 'call',\n          id,\n          event: eventName,\n          input,\n          ...(messageId === undefined ? {} : { messageId }),\n        }))\n      ) {\n        return forbidden()\n      }\n      try {\n        const result = await callEvent(\n          eventName,\n          input,\n          messageId === undefined ? undefined : { id: messageId },\n        )\n        return Response.json(projected(result, fetchOptions?.view), {\n          headers: { 'cache-control': 'private, no-store' },\n        })\n      } catch (error) {\n        if (error instanceof ActorRefusedError) {\n          return Response.json(\n            {\n              error: error.message,\n              event: error.event,\n              messageId: error.messageId,\n            },\n            { status: 409 },\n          )\n        }\n        if (error instanceof A2Error && error.code === 'SESSION_CLEARED') {\n          return Response.json(\n            { code: error.code, error: error.message },\n            { status: 410 },\n          )\n        }\n        if (\n          error instanceof A2Error &&\n          (error.code === 'INVALID_PAYLOAD' ||\n            error.code === 'UNKNOWN_EVENT_TYPE')\n        ) {\n          return Response.json({ error: error.message }, { status: 400 })\n        }\n        throw error\n      }\n    }\n\n    const call: Record<string, unknown> = {}\n    const send: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(call, eventName, {\n        value: (input?: unknown, callOptions?: ActorCallOptions) =>\n          callEvent(eventName, input, callOptions),\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n      Object.defineProperty(send, eventName, {\n        value: (input?: unknown, sendOptions?: ActorSendOptions) =>\n          sendEvent(eventName, input, sendOptions),\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n\n    const handle: ActorHandle<D> = {\n      id,\n      session,\n      call: call as ActorHandle<D>['call'],\n      send: send as ActorHandle<D>['send'],\n      state: readState,\n      fetch: handleFetch,\n    }\n    return handle\n  }\n\n  return {\n    name,\n    contract,\n    server,\n    reducer,\n    actor: makeHandle,\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"actor.js","names":["createContract"],"sources":["../src/actor.ts"],"sourcesContent":["/**\n * experimental-a2/actor — durable actors over the log. Server-only\n * (handlers are server code); the browser condition resolves to a\n * throwing stub, and the browser surfaces are experimental-a2/actor/client\n * and experimental-a2/actor/react.\n *\n * An actor is defined over a protocol — its state shape and event\n * vocabulary, as types — and one complete `handlers` bag:\n *\n * ```ts\n * interface Counter {\n *   state: { count: number }\n *   events: { increment: object; add: { by: number } }\n * }\n * const counter = actor<Counter>({\n *   name: 'counter',\n *   state: { count: 0 },\n *   handlers: {\n *     increment: (ctx) => {\n *       ctx.state.count++\n *     },\n *     add: (ctx, input) => {\n *       ctx.state.count += input.by\n *     },\n *   },\n * })\n * ```\n *\n * Handlers are serial by default: one at a time per instance (a lane —\n * the state's write lock), `ctx.state` a mutable draft committed\n * atomically with completion. A handler holding slow I/O opts out of\n * the lane with `{ concurrent: true, handle }`: it runs in parallel,\n * reads state as a snapshot, and mutates by sending events whose\n * serial handlers decide against fresh state. `ctx.send.eventName(...)`\n * is typed by the protocol and buffered — committed atomically with\n * the handler's completion, so a reserve and its trigger can never\n * half-happen.\n *\n * A thrown `NonRetriableError` is an answer (settled, delivered to a\n * waiting caller); any other error retries like every A2 handler\n * failure; a crash re-runs against the same pre-state. Everything\n * compiles to contract + reducer + laned handlers + returned events —\n * no new store operations, no new wire.\n */\n\n// oxlint-disable no-await-in-loop -- a call awaits its answer: drain, read\n// the tail, repeat until the message settles. Sequential by nature.\n\nimport {\n  ACTOR_FAILED_EVENT,\n  ACTOR_LANE,\n  ACTOR_STATE_EVENT,\n  ActorRefusedError,\n  actorFailedSchema,\n  actorReducer,\n  actorStateSchema,\n  isJsonTree,\n  openPresenceDefs,\n} from './actor-shared.ts'\nimport type {\n  ActorClientEventDefs,\n  ActorConcurrentContext,\n  ActorContext,\n  ActorFailedPayload,\n  ActorPresenceOf,\n  ActorProtocol,\n  ActorScheduleOptions,\n  ActorScheduleSend,\n  ActorSend,\n  ActorStatePayload,\n} from './actor-shared.ts'\nimport { parsePresenceSibling } from './push-envelope.ts'\nimport type { ParsedPushPresence } from './push-envelope.ts'\nimport { internalContract as createContract } from './contract.ts'\nimport type { PresencePatch, PresenceSnapshot } from './contract.ts'\nimport type { Contract, EventDefs } from './contract.ts'\nimport type { Reducer } from './reducer.ts'\nimport { A2Error, NonRetriableError } from './errors.ts'\nimport { serverInternals } from './internal.ts'\nimport { createServer } from './server.ts'\nimport { setServerFetchHooks } from './server-fetch.ts'\nimport { sseResponse } from './sse.ts'\nimport { isSessionCleared, sessionClearedError } from './session-clear.ts'\nimport type { SessionCleared } from './session-clear.ts'\nimport type {\n  A2Scheduler,\n  A2Server,\n  ConsumerContext,\n  ConsumerResult,\n  Session,\n} from './server.ts'\nimport { runtimeConsumer } from './runtime-consumer.ts'\nimport type { A2Store } from './store.ts'\nimport type { StandardSchemaV1 } from './standard-schema.ts'\nimport type { A2Telemetry } from './telemetry.ts'\n\nexport type {\n  ActorConcurrentContext,\n  ActorContext,\n  ActorPresenceMap,\n  ActorPresenceOf,\n  ActorPresenceValues,\n  ActorProtocol,\n  ActorScheduleOptions,\n  ActorScheduleSend,\n  ActorSend,\n} from './actor-shared.ts'\nexport { ActorRefusedError } from './actor-shared.ts'\n\n/**\n * One event's handler: ordinary server code. Serial by default — read\n * `ctx.state`, perform I/O, mutate `ctx.state`, one atomic commit at\n * return. `{ concurrent: true, handle }` opts the handler out of the\n * lane for slow I/O: state becomes a snapshot read and mutations\n * happen by sending events. The input is typed by the protocol; the\n * wire hands handlers parsed JSON, so a wire-exposed event guards its\n * input in its first line (`schema.parse(input)` if you like schemas —\n * userland either way).\n */\nexport type ActorHandler<D extends ActorProtocol, K extends keyof D['events']> =\n  | ((ctx: ActorContext<D>, input: D['events'][K]) => void | Promise<void>)\n  | {\n      concurrent: true\n      handle: (\n        ctx: ActorConcurrentContext<D>,\n        input: D['events'][K],\n      ) => void | Promise<void>\n    }\n\n/**\n * Mark a handler concurrent — off the lane, in parallel with the lane\n * and with other concurrent handlers, `ctx.state()` a snapshot read.\n * Sugar for the structural `{ concurrent: true, handle }` form:\n *\n * ```ts\n * handlers: {\n *   transfer: concurrent(async (ctx, input) => {\n *     await bank.transfer(input, { idempotencyKey: input.ref })\n *     ctx.send.settle({ ref: input.ref })\n *   }),\n * }\n * ```\n */\nexport function concurrent<Ctx, I>(\n  handle: (ctx: Ctx, input: I) => void | Promise<void>,\n): { concurrent: true; handle: (ctx: Ctx, input: I) => void | Promise<void> } {\n  return { concurrent: true, handle }\n}\n\nexport type ActorOptions<D extends ActorProtocol> = {\n  /** Identity — prefixes storage keys; one contract per actor definition. */\n  name: string\n  /** The initial state — checked against the protocol, a plain JSON tree. */\n  state: D['state']\n  /**\n   * One handler per declared event — completeness and payload shapes\n   * are compile-checked against the protocol.\n   */\n  handlers: { [K in keyof D['events']]: ActorHandler<D, K> }\n  store?: A2Store\n  scheduler?: A2Scheduler\n  telemetry?: A2Telemetry\n} & ([ActorPresenceOf<D>] extends [never]\n  ? { presence?: never }\n  : {\n      /**\n       * The wire bit for the protocol's `presence` vocabulary — types\n       * erase, so the runtime needs one value to arm the presence\n       * lanes (frames on GET, envelopes on POST). Required exactly\n       * when the protocol declares `presence`; the vocabulary itself\n       * is typed there. Values are validated to the JSON floor and\n       * pass through `authorize` as `{ type: 'presence' }` operations;\n       * meaning stays with your renderers — treat values as user\n       * input.\n       */\n      presence: true\n    })\n\n/**\n * One HTTP operation `handle.fetch` is about to serve — the actor\n * mirror of core's `A2Operation`. `authorize` sees it before any\n * read, write, or subscription; returning `false` answers 403.\n */\nexport type ActorOperation =\n  | { readonly type: 'state'; readonly id: string }\n  | {\n      readonly type: 'stream'\n      readonly id: string\n      readonly startAfter: number\n    }\n  | {\n      readonly type: 'call'\n      readonly id: string\n      readonly event: string\n      readonly input: unknown\n      readonly messageId?: string\n    }\n  | {\n      readonly type: 'presence'\n      readonly id: string\n      readonly participant: string\n      readonly values: Readonly<Record<string, unknown>>\n    }\n\nexport type ActorFetchOptions<D extends ActorProtocol> = {\n  /** Per-operation policy — authentication happened in your route. */\n  authorize?: (operation: ActorOperation) => boolean | Promise<boolean>\n  /**\n   * Request-time projection: what this mount's audience sees. Applied\n   * to every state frame on the stream AND to call answers (the two\n   * untrusted lanes must agree, or the call lane leaks what the\n   * stream hides). The definition stays audience-agnostic — different\n   * routes project the same actor differently, and per-viewer views\n   * are just closures over the route's auth. Output is held to the\n   * JSON-tree floor like everything else. Transport-agnostic: applied\n   * at frame emission, so any wire the door speaks emits projected\n   * frames. Absent, the full state ships (the trusted default).\n   */\n  view?: (state: D['state']) => unknown\n}\n\nexport type ActorSendOptions = {\n  /** Explicit message id — makes retries of this send idempotent. */\n  id?: string\n}\n\nexport type ActorCallOptions = ActorSendOptions & {\n  /** How long to await the answer before rejecting the wait (default 30s). */\n  timeoutMs?: number\n}\n\nexport type ActorCallResult<S> = {\n  /** The actor's state after this message was processed. */\n  state: S\n  /** Log index of the state commit that answered this message. */\n  index: number\n  /**\n   * The clear marker this state's lifetime began at, once the actor has been\n   * cleared. For a call answer it is the lifetime the handler read.\n   */\n  clearIndex?: number\n}\n\ntype CallMethod<\n  D extends ActorProtocol,\n  K extends keyof D['events'],\n> = {} extends D['events'][K]\n  ? (\n      input?: D['events'][K],\n      options?: ActorCallOptions,\n    ) => Promise<ActorCallResult<D['state']>>\n  : (\n      input: D['events'][K],\n      options?: ActorCallOptions,\n    ) => Promise<ActorCallResult<D['state']>>\n\ntype SendMethod<\n  D extends ActorProtocol,\n  K extends keyof D['events'],\n> = {} extends D['events'][K]\n  ? (\n      input?: D['events'][K],\n      options?: ActorSendOptions,\n    ) => Promise<{ id: string; index: number }>\n  : (\n      input: D['events'][K],\n      options?: ActorSendOptions,\n    ) => Promise<{ id: string; index: number }>\n\n/** One instance: typed calls and sends, reads, the managed door, the escape hatch. */\nexport type ActorHandle<D extends ActorProtocol> = {\n  readonly id: string\n  /**\n   * Send the event and await its answer: the state after the handler\n   * ran, or a rejection with `ActorRefusedError`. A clear before the call\n   * receives its answer rejects with `A2Error('SESSION_CLEARED')`. Serial\n   * events only — concurrent handlers produce no answer to await; `send`\n   * them.\n   */\n  readonly call: { readonly [K in keyof D['events']]: CallMethod<D, K> }\n  /** Cast: validate, append the event durably, return without waiting. */\n  readonly send: { readonly [K in keyof D['events']]: SendMethod<D, K> }\n  /** Snapshot read — never queues behind pending messages. */\n  readonly state: () => Promise<ActorCallResult<D['state']>>\n  /**\n   * The managed door — the actor mirror of `server.fetch`, bound to\n   * this instance. GET streams the state plane (`a2.actor.state`\n   * commits and clear resets, `?index` resume, heartbeat, deadline\n   * rotation); POST is the call lane `createActorClient` speaks\n   * (`{ event, input, messageId? }` → the answer, 409 for a refusal,\n   * 410 for a call cleared before its answer). Your route\n   * authenticates and picks the instance; `authorize` sees every\n   * operation. Custom endpoints are route code around this call.\n   */\n  readonly fetch: (\n    request: Request,\n    options?: ActorFetchOptions<D>,\n  ) => Promise<Response>\n  /** Escape hatch: the raw A2 session (history, stream, schedule). */\n  readonly session: Session<EventDefs>\n}\n\nexport type ActorDefinition<D extends ActorProtocol> = {\n  readonly name: string\n  /**\n   * Type-only carrier of the protocol, so clients deriving from\n   * `typeof def` can see the vocabularies (`experimental-a2/actor/react`\n   * types `presence` from it). Never a runtime value.\n   */\n  readonly protocol?: D\n  /** The assembled contract — declared events plus the reserved a2.actor.* pair. */\n  readonly contract: Contract<EventDefs>\n  /** The underlying A2 server — `server.fetch` mounts the full session wire. */\n  readonly server: A2Server<EventDefs>\n  /** The state fold over commits; a clear resets it to the initial state. */\n  readonly reducer: Reducer<ActorClientEventDefs<D['state']>, D['state']>\n  actor(id: string): ActorHandle<D>\n}\n\n// Object-mechanics names, not surface names: events live in their own\n// bags, so nothing else is reserved.\nconst UNSAFE_EVENT_NAMES = new Set(['__proto__', 'constructor', 'prototype'])\n\nconst forbidden = (): Response =>\n  Response.json({ error: 'the operation is not authorized' }, { status: 403 })\n\nconst CALL_TIMEOUT_MS = 30_000\nconst CALL_POLL_MS = 25\n\n/** Declared events accept any JSON tree; `undefined` normalizes to `{}`. */\nconst jsonInputSchema: StandardSchemaV1<unknown> = {\n  '~standard': {\n    version: 1,\n    vendor: 'a2',\n    validate(value) {\n      if (value === undefined || value === null) return { value: {} }\n      if (!isJsonTree(value)) {\n        return {\n          issues: [{ message: 'event input must be a plain JSON tree' }],\n        }\n      }\n      return { value }\n    },\n  },\n}\n\nconst describeError = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, ms))\n\ntype NormalizedHandler<D extends ActorProtocol> =\n  | {\n      kind: 'serial'\n      handle: (ctx: ActorContext<D>, input: unknown) => void | Promise<void>\n    }\n  | {\n      kind: 'concurrent'\n      handle: (\n        ctx: ActorConcurrentContext<D>,\n        input: unknown,\n      ) => void | Promise<void>\n    }\n\n/**\n * Define and serve an actor over its protocol: a named, durable\n * instance-per-id with serialized state handlers, concurrent I/O\n * handlers, and typed self-sends.\n */\nexport function actor<D extends ActorProtocol>(\n  options: ActorOptions<D>,\n): ActorDefinition<D> {\n  const { name } = options\n\n  const handlersByEvent = new Map<string, NormalizedHandler<D>>()\n  const events: Record<string, StandardSchemaV1> = {\n    [ACTOR_STATE_EVENT]: actorStateSchema(),\n    [ACTOR_FAILED_EVENT]: actorFailedSchema,\n  }\n  for (const [eventName, def] of Object.entries(\n    options.handlers as Record<string, ActorHandler<D, keyof D['events']>>,\n  )) {\n    if (UNSAFE_EVENT_NAMES.has(eventName)) {\n      throw new TypeError(\n        `actor '${name}': '${eventName}' collides with object plumbing and cannot name an event`,\n      )\n    }\n    if (eventName.startsWith('a2.')) {\n      throw new TypeError(\n        `actor '${name}': event names starting with 'a2.' are reserved`,\n      )\n    }\n    handlersByEvent.set(\n      eventName,\n      typeof def === 'function'\n        ? {\n            kind: 'serial',\n            handle: def as (\n              ctx: ActorContext<D>,\n              input: unknown,\n            ) => void | Promise<void>,\n          }\n        : {\n            kind: 'concurrent',\n            handle: def.handle as (\n              ctx: ActorConcurrentContext<D>,\n              input: unknown,\n            ) => void | Promise<void>,\n          },\n    )\n    events[eventName] = jsonInputSchema\n  }\n\n  const reducer = actorReducer({ name, state: options.state })\n  // The server's contract carries every event type; the reducer only\n  // folds state commits. Same fold, same identity — the widening is a\n  // typing formality.\n  const serverReducer = reducer as unknown as Reducer<EventDefs, D['state']>\n\n  // The typed durable-timer surface: immediate handoff to the\n  // configured scheduler through the handler session, so timer\n  // identity is scoped to the triggering message and re-runs address\n  // the same timer (core §6). Not buffered — see ActorScheduleSend.\n  const makeSchedule = (\n    schedule: (\n      name: string,\n      timing: { delay?: string; at?: Date },\n      event: { type: string; payload: unknown },\n    ) => Promise<void>,\n  ): ActorScheduleSend<D['events']> => {\n    const surface: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(surface, eventName, {\n        value: (input: unknown, scheduleOptions: ActorScheduleOptions) => {\n          const { name: taskName, ...timing } = scheduleOptions\n          return schedule(taskName ?? eventName, timing, {\n            type: eventName,\n            payload: input ?? {},\n          })\n        },\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n    return surface as ActorScheduleSend<D['events']>\n  }\n\n  // The typed self-send surface: per-invocation buffers behind one\n  // shared method record shape. defineProperty so event names like\n  // 'constructor'-adjacent identifiers can never touch prototypes.\n  const makeSend = (\n    buffer: { type: string; payload: unknown }[],\n  ): ActorSend<D['events']> => {\n    const send: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(send, eventName, {\n        value: (input?: unknown) => {\n          buffer.push({ type: eventName, payload: input ?? {} })\n        },\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n    return send as ActorSend<D['events']>\n  }\n\n  type Run = (ctx: ConsumerContext<EventDefs>) => ConsumerResult<EventDefs>\n  const concurrentRuns = new Map<string, Run>()\n  const serialRuns = new Map<string, Run>()\n  for (const [eventName, def] of handlersByEvent) {\n    if (def.kind === 'concurrent') {\n      // No lane: concurrent handlers run in parallel — with the lane\n      // and with each other. They cannot write state (no draft to\n      // commit), so no serialization is needed for correctness; slow\n      // I/O lives here without blocking the actor.\n      concurrentRuns.set(eventName, async (ctx) => {\n        const sends: { type: string; payload: unknown }[] = []\n        try {\n          await def.handle(\n            {\n              id: ctx.event.id,\n              attempt: ctx.attempt,\n              signal: ctx.signal,\n              send: makeSend(sends),\n              schedule: makeSchedule((taskName, timing, event) =>\n                ctx.session.schedule(\n                  taskName,\n                  timing as Parameters<typeof ctx.session.schedule>[1],\n                  event,\n                ),\n              ),\n              state: async () => {\n                const { state, index } = await ctx.session.state(\n                  serverReducer,\n                  { through: 'latest' },\n                )\n                return { state, index }\n              },\n            },\n            ctx.event.payload,\n          )\n        } catch (error) {\n          if (!(error instanceof NonRetriableError)) throw error\n          // A terminal failure is recorded for audit; nothing awaits a\n          // concurrent handler, so the marker is history, not an\n          // answer. Buffered sends are discarded — refusals are total,\n          // so compensate by completing (send then return), never by\n          // throwing.\n          const payload: ActorFailedPayload = {\n            message: ctx.event.id,\n            event: eventName,\n            error: describeError(error),\n          }\n          return { type: ACTOR_FAILED_EVENT, payload }\n        }\n        // Sends commit atomically with settlement; re-runs converge on\n        // the same deterministic message ids.\n        return sends as never\n      })\n      continue\n    }\n    serialRuns.set(eventName, async (ctx) => {\n      // Explicitly 'latest', not the event-relative default: prior\n      // lane messages commit *after* this message was appended, so\n      // their state commits carry higher indexes than the trigger —\n      // an event-relative read would miss them and lose updates.\n      // 'latest' is deterministic here because the lane makes this\n      // attempt the only possible writer while it runs.\n      const { state, clearIndex } = await ctx.session.state(serverReducer, {\n        through: 'latest',\n      })\n      const draft = structuredClone(state)\n      const sends: { type: string; payload: unknown }[] = []\n      try {\n        await def.handle(\n          {\n            state: draft,\n            id: ctx.event.id,\n            attempt: ctx.attempt,\n            signal: ctx.signal,\n            send: makeSend(sends),\n            schedule: makeSchedule((taskName, timing, event) =>\n              ctx.session.schedule(\n                taskName,\n                timing as Parameters<typeof ctx.session.schedule>[1],\n                event,\n              ),\n            ),\n          },\n          ctx.event.payload,\n        )\n      } catch (error) {\n        // A NonRetriableError is an answer: settle the message,\n        // record the refusal, deliver it to the waiting caller —\n        // no retry, no failure budget spent (buffered sends are\n        // discarded with the draft: refusals are total). Every\n        // other throw is an ordinary A2 handler failure: rethrown\n        // into core's retry machinery (backoff, ten-failure\n        // budget, dead letter) — including surrendered lease\n        // aborts, which core recognizes by identity.\n        if (!(error instanceof NonRetriableError)) throw error\n        const payload: ActorFailedPayload = {\n          message: ctx.event.id,\n          event: eventName,\n          error: describeError(error),\n        }\n        return { type: ACTOR_FAILED_EVENT, payload }\n      }\n      // One returned batch: buffered sends plus the state commit —\n      // committed atomically with completion, so a reserve and its\n      // trigger can never half-happen. The state event stays the\n      // outcome marker a waiting call resolves on. (Unconditional\n      // for now; a dirty check is a compatible later optimization.)\n      const payload: ActorStatePayload<D['state']> = {\n        state: draft,\n        event: eventName,\n        message: ctx.event.id,\n        ...(clearIndex === undefined ? {} : { clearIndex }),\n      }\n      return [...sends, { type: ACTOR_STATE_EVENT, payload }] as never\n    })\n  }\n\n  const presenceEnabled = (options as { presence?: unknown }).presence === true\n  // The '*' catch-all arms an open server-side vocabulary: the\n  // protocol types field names at compile time, the floor validates\n  // every value, and `authorize` sees every set. See openPresenceDefs.\n  const contract = presenceEnabled\n    ? createContract({ name, events, presence: openPresenceDefs })\n    : createContract({ name, events })\n  // Serial messages share one lane per instance: the next starts only after\n  // the previous one completed, and completion commits the state event\n  // atomically, so read-modify-write on `ctx.state` is safe by exclusion,\n  // not by liveness. The lane is a function, so each message is queued on\n  // it as it's appended. Concurrent messages run alongside it and each\n  // other: they write no state.\n  const serialTypes = [...serialRuns.keys()]\n  const concurrentTypes = [...concurrentRuns.keys()]\n  const consumers = [\n    ...(serialTypes.length === 0\n      ? []\n      : [\n          runtimeConsumer({\n            contract,\n            name: 'a2.actor',\n            types: serialTypes,\n            lane: () => ACTOR_LANE,\n          }).run((ctx) => serialRuns.get(ctx.event.type)!(ctx as never)),\n        ]),\n    ...(concurrentTypes.length === 0\n      ? []\n      : [\n          runtimeConsumer({\n            contract,\n            name: 'a2.actor.concurrent',\n            types: concurrentTypes,\n          }).run((ctx) => concurrentRuns.get(ctx.event.type)!(ctx as never)),\n        ]),\n  ]\n  const server = createServer({\n    contract,\n    consumers,\n    ...(options.store ? { store: options.store } : {}),\n    ...(options.scheduler ? { scheduler: options.scheduler } : {}),\n    ...(options.telemetry ? { telemetry: options.telemetry } : {}),\n  })\n  // Single-writer discipline on the underlying session wire too: if an\n  // application mounts `def.server.fetch`, browsers may push declared\n  // events, never authored state or failure records.\n  setServerFetchHooks(server, {\n    validateIngress: ({ events: pushed }) => {\n      for (const event of pushed) {\n        if (event.type.startsWith('a2.actor.')) {\n          throw new TypeError(\n            `'${event.type}' is reserved — only a handler's completion can author it`,\n          )\n        }\n      }\n    },\n  })\n\n  const internals = serverInternals.get(server)!\n\n  const makeHandle = (id: string): ActorHandle<D> => {\n    const session = server.session(id)\n\n    const sendEvent = async (\n      eventName: string,\n      input: unknown,\n      sendOptions?: ActorSendOptions,\n    ): Promise<{ id: string; index: number }> => {\n      const [message] = await session.append({\n        type: eventName,\n        payload: input ?? {},\n        ...(sendOptions?.id ? { id: sendOptions.id } : {}),\n      })\n      if (!message) throw new Error('append returned no event')\n      return { id: message.id, index: message.index }\n    }\n\n    const callEvent = async (\n      eventName: string,\n      input: unknown,\n      callOptions?: ActorCallOptions,\n    ): Promise<ActorCallResult<D['state']>> => {\n      if (handlersByEvent.get(eventName)?.kind === 'concurrent') {\n        throw new TypeError(\n          `actor '${name}': '${eventName}' is concurrent — it produces no answer to await; send it instead`,\n        )\n      }\n      const message = await sendEvent(eventName, input, callOptions)\n      const deadline = Date.now() + (callOptions?.timeoutMs ?? CALL_TIMEOUT_MS)\n      let cursor = message.index + 1\n      for (;;) {\n        // Drain participates in processing (usually answering inline in\n        // this invocation); claims arbitrate if another process runs.\n        await server.drain(id)\n        const tail = await internals.historyWithMarkers(id, cursor)\n        for (const event of tail) {\n          // Reads start at the latest marker, so a clear after the message\n          // arrives before any answer from the next lifetime, including one\n          // from a message that reuses this id.\n          if (isSessionCleared(event)) {\n            throw sessionClearedError(\n              `actor '${name}': '${eventName}' (message ${message.id}) was cleared before the call received its answer`,\n            )\n          }\n          if (event.type === ACTOR_STATE_EVENT) {\n            const payload = event.payload as ActorStatePayload<D['state']>\n            if (payload.message === message.id) {\n              return {\n                state: payload.state,\n                index: event.index,\n                ...(payload.clearIndex === undefined\n                  ? {}\n                  : { clearIndex: payload.clearIndex }),\n              }\n            }\n          }\n          if (event.type === ACTOR_FAILED_EVENT) {\n            const payload = event.payload as ActorFailedPayload\n            if (payload.message === message.id) {\n              throw new ActorRefusedError(eventName, message.id, payload.error)\n            }\n          }\n        }\n        const last = tail[tail.length - 1]\n        if (last) cursor = last.index + 1\n        if (Date.now() >= deadline) {\n          throw new Error(\n            `actor '${name}': timed out waiting for '${eventName}' (message ${message.id})`,\n          )\n        }\n        await sleep(CALL_POLL_MS)\n      }\n    }\n\n    const readState = async (): Promise<ActorCallResult<D['state']>> => {\n      const { state, index, clearIndex } = await session.state(serverReducer)\n      return clearIndex === undefined\n        ? { state, index }\n        : { state, index, clearIndex }\n    }\n\n    /** A snapshot or call answer through the route's view. */\n    const projected = (\n      result: ActorCallResult<D['state']>,\n      view: ((state: D['state']) => unknown) | undefined,\n    ): ActorCallResult<unknown> =>\n      view ? { ...result, state: applyView(view, result.state) } : result\n\n    const applyView = (\n      view: (state: D['state']) => unknown,\n      state: D['state'],\n    ): unknown => {\n      const viewed = view(state)\n      if (!isJsonTree(viewed)) {\n        throw new TypeError(\n          `actor '${name}': the view returned a value that is not a plain JSON tree`,\n        )\n      }\n      return viewed\n    }\n\n    const streamStates = async function* (\n      startAfter: number,\n      view?: (state: D['state']) => unknown,\n    ) {\n      // With presence armed, the session interleaves presence items\n      // (snapshot, then patches) between log events. They are\n      // ephemeral audience data, not actor state: they pass through\n      // untouched — views project state, never peers — and they never\n      // advance the resume frontier.\n      const source: AsyncIterable<\n        | Awaited<ReturnType<typeof session.history>>[number]\n        | SessionCleared\n        | PresencePatch\n        | PresenceSnapshot\n      > = presenceEnabled\n        ? (\n            session as unknown as {\n              stream(options: {\n                startAfter: number\n                presence: true\n              }): AsyncIterable<PresencePatch | PresenceSnapshot>\n            }\n          ).stream({ startAfter, presence: true })\n        : session.stream({ startAfter })\n      for await (const item of source) {\n        if (!('type' in item)) {\n          yield item\n          continue\n        }\n        const event = item\n        if (isSessionCleared(event)) {\n          // The follower has no seed of its own: the marker carries the\n          // actor's initial state, projected like any commit.\n          const initial = structuredClone(options.state)\n          yield {\n            ...event,\n            payload: { state: view ? applyView(view, initial) : initial },\n          }\n          continue\n        }\n        // The state plane only: subscribers see what the actor is,\n        // never other callers' inputs. Refusals answer only their\n        // caller (the POST 409); the full mailbox stays server-side.\n        if (event.type !== ACTOR_STATE_EVENT) continue\n        if (!view) {\n          yield event\n          continue\n        }\n        const payload = event.payload as ActorStatePayload<D['state']>\n        yield {\n          ...event,\n          payload: { ...payload, state: applyView(view, payload.state) },\n        }\n      }\n    }\n\n    // The managed door — the actor mirror of `server.fetch`: GET is\n    // the state-plane SSE (`a2.actor.state` commits and clear resets,\n    // `?index` resume), POST is the call lane (`{ event, input,\n    // messageId? }` → the answer, 409 for a refusal, 410 for a cleared\n    // call). Authentication happens in the surrounding route;\n    // per-operation policy in `authorize`.\n    const handleFetch = async (\n      request: Request,\n      fetchOptions?: ActorFetchOptions<D>,\n    ): Promise<Response> => {\n      const authorized = async (operation: ActorOperation): Promise<boolean> =>\n        (await fetchOptions?.authorize?.(Object.freeze(operation))) !== false\n\n      if (request.method === 'GET') {\n        const url = new URL(request.url)\n        if (url.searchParams.has('snapshot')) {\n          if (!(await authorized({ type: 'state', id }))) return forbidden()\n          return Response.json(\n            projected(await readState(), fetchOptions?.view),\n            {\n              headers: { 'cache-control': 'private, no-store' },\n            },\n          )\n        }\n        const raw = Number(url.searchParams.get('index'))\n        const startAfter = Number.isSafeInteger(raw) && raw >= 0 ? raw : 0\n        if (!(await authorized({ type: 'stream', id, startAfter }))) {\n          return forbidden()\n        }\n        return sseResponse(streamStates(startAfter, fetchOptions?.view))\n      }\n      if (request.method !== 'POST') {\n        return new Response(null, {\n          status: 405,\n          headers: { allow: 'GET, POST' },\n        })\n      }\n      let body: unknown\n      try {\n        body = await request.json()\n      } catch {\n        return Response.json({ error: 'invalid JSON body' }, { status: 400 })\n      }\n      const record =\n        typeof body === 'object' && body !== null\n          ? (body as Record<string, unknown>)\n          : {}\n      if ('presence' in record) {\n        // A presence envelope — what the follower client's\n        // `setPresence` posts. Events never ride this lane: writes to\n        // the actor are calls.\n        if (!presenceEnabled) {\n          return Response.json(\n            { error: `actor '${name}' declares no presence` },\n            { status: 400 },\n          )\n        }\n        const pushedEvents = record['events']\n        if (\n          pushedEvents !== undefined &&\n          (!Array.isArray(pushedEvents) || pushedEvents.length > 0)\n        ) {\n          return Response.json(\n            { error: 'the actor wire takes calls, not event pushes' },\n            { status: 400 },\n          )\n        }\n        let patch: ParsedPushPresence\n        try {\n          const parsed = parsePresenceSibling(record['presence'])\n          if (!parsed) throw new TypeError('presence must be an object')\n          patch = parsed\n        } catch (error) {\n          return Response.json({ error: describeError(error) }, { status: 400 })\n        }\n        if (\n          !(await authorized({\n            type: 'presence',\n            id,\n            participant: patch.participant,\n            values: patch.values,\n          }))\n        ) {\n          return forbidden()\n        }\n        try {\n          await (\n            session as unknown as {\n              setPresence(patch: ParsedPushPresence): Promise<void>\n            }\n          ).setPresence(patch)\n        } catch (error) {\n          if (\n            error instanceof A2Error &&\n            (error.code === 'INVALID_PAYLOAD' ||\n              error.code === 'UNKNOWN_PRESENCE_FIELD')\n          ) {\n            return Response.json({ error: error.message }, { status: 400 })\n          }\n          throw error\n        }\n        return Response.json([])\n      }\n      const eventName = record['event']\n      if (\n        typeof eventName !== 'string' ||\n        handlersByEvent.get(eventName)?.kind !== 'serial'\n      ) {\n        return Response.json({ error: 'unknown event' }, { status: 400 })\n      }\n      const messageId = record['messageId']\n      if (messageId !== undefined && typeof messageId !== 'string') {\n        return Response.json({ error: 'invalid messageId' }, { status: 400 })\n      }\n      const input = record['input']\n      if (\n        !(await authorized({\n          type: 'call',\n          id,\n          event: eventName,\n          input,\n          ...(messageId === undefined ? {} : { messageId }),\n        }))\n      ) {\n        return forbidden()\n      }\n      try {\n        const result = await callEvent(\n          eventName,\n          input,\n          messageId === undefined ? undefined : { id: messageId },\n        )\n        return Response.json(projected(result, fetchOptions?.view), {\n          headers: { 'cache-control': 'private, no-store' },\n        })\n      } catch (error) {\n        if (error instanceof ActorRefusedError) {\n          return Response.json(\n            {\n              error: error.message,\n              event: error.event,\n              messageId: error.messageId,\n            },\n            { status: 409 },\n          )\n        }\n        if (error instanceof A2Error && error.code === 'SESSION_CLEARED') {\n          return Response.json(\n            { code: error.code, error: error.message },\n            { status: 410 },\n          )\n        }\n        if (\n          error instanceof A2Error &&\n          (error.code === 'INVALID_PAYLOAD' ||\n            error.code === 'UNKNOWN_EVENT_TYPE')\n        ) {\n          return Response.json({ error: error.message }, { status: 400 })\n        }\n        throw error\n      }\n    }\n\n    const call: Record<string, unknown> = {}\n    const send: Record<string, unknown> = {}\n    for (const eventName of handlersByEvent.keys()) {\n      Object.defineProperty(call, eventName, {\n        value: (input?: unknown, callOptions?: ActorCallOptions) =>\n          callEvent(eventName, input, callOptions),\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n      Object.defineProperty(send, eventName, {\n        value: (input?: unknown, sendOptions?: ActorSendOptions) =>\n          sendEvent(eventName, input, sendOptions),\n        enumerable: true,\n        configurable: true,\n        writable: false,\n      })\n    }\n\n    const handle: ActorHandle<D> = {\n      id,\n      session,\n      call: call as ActorHandle<D>['call'],\n      send: send as ActorHandle<D>['send'],\n      state: readState,\n      fetch: handleFetch,\n    }\n    return handle\n  }\n\n  return {\n    name,\n    contract,\n    server,\n    reducer,\n    actor: makeHandle,\n  }\n}\n"],"mappings":"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"}