experimental-a2 0.10.0 → 0.12.0

package/dist/actor-react.js.map

@@ -1 +1 @@
-{"version":3,"file":"actor-react.js","names":[],"sources":["../src/actor-react.ts"],"sourcesContent":["'use client'\n/**\n * experimental-a2/actor/react — use an actor from React: live state\n * plus typed calls, one hook. A thin wrapper: the state pump follows\n * the SSE that `handle.fetch` serves (frontier resume, reconnection,\n * heartbeat watchdog — both ends library code), and `call` is\n * `createActorClient`'s typed surface (the framework-agnostic\n * primitive for everything that isn't React).\n *\n * ```tsx\n * // server component\n * const initial = await vault.actor(id).state()\n * // client component — typed by the server module, erased at build\n * const { state, call, connection } = useActor<typeof vault>({\n *   api: `/vault/${id}`, // your route: auth, then handle.fetch\n *   id,\n *   initial,\n * })\n * await call.withdraw({ amount: 60 }) // ActorRefusedError on refusal\n * ```\n *\n * The fold is library code (last write wins over state commits), so no\n * reducers, schemas, or contracts appear in browser code. Live, not\n * optimistic: handlers are server code deciding against serialized\n * fresh state, so a local guess would be wrong exactly when the actor\n * matters. On a view-projected mount, pass the projected shape as the\n * second type argument — `useActor<typeof vault, PublicVault>` — and\n * `initial`, `state`, and call answers all carry it.\n */\n\nimport { ACTOR_STATE_EVENT, openPresenceDefs } from './actor-shared.ts'\nimport type { ActorPresenceMap, ActorPresenceValues } from './actor-shared.ts'\nimport {\n  createActorClient,\n  type ActorClientCall,\n  type ActorStateOf,\n  type AnyActorDefinition,\n} from './actor-client.ts'\nimport { createClient } from './client.ts'\nimport type { A2Client, Connection } from './client.ts'\nimport type { ContractEvent, EventDefs, PresenceDefs } from './contract.ts'\nimport type { Reducer } from './reducer.ts'\nimport { useSession } from './react.ts'\n\n/** The server-to-client handoff: `await def.actor(id).state()`. */\nexport type ActorSnapshot<S> = { state: S; index: number }\n\nexport type UseActorOptions<View> = {\n  /** The route whose handler delegates to `handle.fetch` for this instance. */\n  api: string\n  /** The instance id. */\n  id: string\n  /** The server-rendered fold — the stream resumes after `index`. */\n  initial: ActorSnapshot<View>\n  /** This client's presence identity — required to call `setPresence`. */\n  participant?: string\n}\n\n/** The definition's presence vocabulary, `never` when undeclared. */\ntype PresenceOf<D extends AnyActorDefinition> = D extends {\n  protocol?: infer P\n}\n  ? NonNullable<P> extends { presence: infer Values extends object }\n    ? Values\n    : never\n  : never\n\nexport type UseActorResult<D extends AnyActorDefinition, View> = {\n  /** The actor's state, live: every commit streams in and replaces it. */\n  state: View\n  /** The stream frontier. */\n  index: number\n  connection: Connection\n  /** Typed calls over POST — the response is the answer. */\n  call: ActorClientCall<D, View>\n  /** The state-commit feed this browser has observed. */\n  events: ContractEvent<EventDefs>[]\n  /**\n   * The replicated presence map: participant → field → latest value.\n   * Peer-authored — render values like user input. Empty (and\n   * `setPresence` untyped-callable-with-nothing) when the protocol\n   * declares no presence.\n   */\n  presence: ActorPresenceMap<PresenceOf<D>>\n  /**\n   * Announce this client's presence fields (throttled, resent on\n   * reconnect; `null` clears a field). Requires `participant`.\n   */\n  setPresence: (values: ActorPresenceValues<PresenceOf<D>>) => void\n}\n\n/**\n * The follower fold, untyped on purpose: the state type comes from the\n * caller's `initial` handoff, and the fold never inspects state.\n * `initialState` is never rendered — `initial` is required, so every\n * session hydrates before it connects.\n */\nconst followerReducer: Reducer<EventDefs, unknown, PresenceDefs> = {\n  name: 'a2.actor.follower.v1',\n  events: {},\n  // The open vocabulary ('*' catch-all): the browser cannot know a\n  // server-defined field list, so the server stays the authority and\n  // the protocol types honest callers at compile time.\n  presence: openPresenceDefs,\n  fold: (state, event) =>\n    event.type === ACTOR_STATE_EVENT\n      ? (event.payload as { state: unknown }).state\n      : state,\n  initialState: undefined,\n  stateSchema: undefined,\n}\n\nconst clients = new Map<string, A2Client<EventDefs, unknown, PresenceDefs>>()\n\n/** Use one actor instance: live state plus typed calls. No provider. */\nexport function useActor<D extends AnyActorDefinition, View = ActorStateOf<D>>(\n  options: UseActorOptions<View>,\n): UseActorResult<D, View> {\n  const { api } = options\n  let client = clients.get(api)\n  if (!client) {\n    client = createClient({ reducer: followerReducer, api })\n    clients.set(api, client)\n  }\n  const session = useSession(client, options.id, {\n    hydrate: options.initial,\n    ...(options.participant === undefined\n      ? {}\n      : { participant: options.participant }),\n  })\n  const { call } = createActorClient<D, View>({ api })\n  return {\n    state: session.state as View,\n    index: session.index,\n    connection: session.connection,\n    call,\n    events: session.events,\n    presence: session.presence as ActorPresenceMap<PresenceOf<D>>,\n    setPresence: session.setPresence as (\n      values: ActorPresenceValues<PresenceOf<D>>,\n    ) => void,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,MAAM,kBAA6D;CACjE,MAAM;CACN,QAAQ,CAAC;CAIT,UAAU;CACV,OAAO,OAAO,UACZ,MAAM,SAAA,mBACD,MAAM,QAA+B,QACtC;CACN,cAAc,KAAA;CACd,aAAa,KAAA;AACf;AAEA,MAAM,0BAAU,IAAI,IAAwD;;AAG5E,SAAgB,SACd,SACyB;CACzB,MAAM,EAAE,QAAQ;CAChB,IAAI,SAAS,QAAQ,IAAI,GAAG;CAC5B,IAAI,CAAC,QAAQ;EACX,SAAS,aAAa;GAAE,SAAS;GAAiB;EAAI,CAAC;EACvD,QAAQ,IAAI,KAAK,MAAM;CACzB;CACA,MAAM,UAAU,WAAW,QAAQ,QAAQ,IAAI;EAC7C,SAAS,QAAQ;EACjB,GAAI,QAAQ,gBAAgB,KAAA,IACxB,CAAC,IACD,EAAE,aAAa,QAAQ,YAAY;CACzC,CAAC;CACD,MAAM,EAAE,SAAS,kBAA2B,EAAE,IAAI,CAAC;CACnD,OAAO;EACL,OAAO,QAAQ;EACf,OAAO,QAAQ;EACf,YAAY,QAAQ;EACpB;EACA,QAAQ,QAAQ;EAChB,UAAU,QAAQ;EAClB,aAAa,QAAQ;CAGvB;AACF"}
+{"version":3,"file":"actor-react.js","names":[],"sources":["../src/actor-react.ts"],"sourcesContent":["'use client'\n/**\n * experimental-a2/actor/react — use an actor from React: live state\n * plus typed calls, one hook. A thin wrapper: the state pump follows\n * the SSE that `handle.fetch` serves (frontier resume, reconnection,\n * heartbeat watchdog — both ends library code), and `call` is\n * `createActorClient`'s typed surface (the framework-agnostic\n * primitive for everything that isn't React).\n *\n * ```tsx\n * // server component\n * const initial = await vault.actor(id).state()\n * // client component — typed by the server module, erased at build\n * const { state, call, connection } = useActor<typeof vault>({\n *   api: `/vault/${id}`, // your route: auth, then handle.fetch\n *   id,\n *   initial,\n * })\n * await call.withdraw({ amount: 60 }) // ActorRefusedError on refusal\n * ```\n *\n * The fold is library code (last write wins over state commits), so no\n * reducers, schemas, or contracts appear in browser code. Live, not\n * optimistic: handlers are server code deciding against serialized\n * fresh state, so a local guess would be wrong exactly when the actor\n * matters. On a view-projected mount, pass the projected shape as the\n * second type argument — `useActor<typeof vault, PublicVault>` — and\n * `initial`, `state`, and call answers all carry it.\n */\n\nimport { ACTOR_STATE_EVENT, openPresenceDefs } from './actor-shared.ts'\nimport type { ActorPresenceMap, ActorPresenceValues } from './actor-shared.ts'\nimport {\n  createActorClient,\n  type ActorClientCall,\n  type ActorStateOf,\n  type AnyActorDefinition,\n} from './actor-client.ts'\nimport { createClient } from './client.ts'\nimport type { A2Client, Connection } from './client.ts'\nimport type { ContractEvent, EventDefs, PresenceDefs } from './contract.ts'\nimport type { Reducer } from './reducer.ts'\nimport { useSession } from './react.ts'\nimport { useMemo } from 'react'\n\n/** The server-to-client handoff: `await def.actor(id).state()`. */\nexport type ActorSnapshot<S> = { state: S; index: number }\n\nexport type UseActorOptions<View> = {\n  /** The route whose handler delegates to `handle.fetch` for this instance. */\n  api: string\n  /** The instance id. */\n  id: string\n  /** The server-rendered fold — the stream resumes after `index`. */\n  initial: ActorSnapshot<View>\n  /** This client's presence identity — required to call `setPresence`. */\n  participant?: string\n}\n\n/** The definition's presence vocabulary, `never` when undeclared. */\ntype PresenceOf<D extends AnyActorDefinition> = D extends {\n  protocol?: infer P\n}\n  ? NonNullable<P> extends { presence: infer Values extends object }\n    ? Values\n    : never\n  : never\n\nexport type UseActorResult<D extends AnyActorDefinition, View> = {\n  /** The live view, advanced by call answers, refreshes, and stream commits. */\n  state: View\n  /** The latest adopted state index. */\n  index: number\n  connection: Connection\n  /** Typed calls over POST — the response is the answer. */\n  call: ActorClientCall<D, View>\n  refresh: () => Promise<ActorSnapshot<View>>\n  /** The state-commit feed this browser has observed. */\n  events: ContractEvent<EventDefs>[]\n  /**\n   * The replicated presence map: participant → field → latest value.\n   * Peer-authored — render values like user input. Empty (and\n   * `setPresence` untyped-callable-with-nothing) when the protocol\n   * declares no presence.\n   */\n  presence: ActorPresenceMap<PresenceOf<D>>\n  /**\n   * Announce this client's presence fields (throttled, resent on\n   * reconnect; `null` clears a field). Requires `participant`.\n   */\n  setPresence: (values: ActorPresenceValues<PresenceOf<D>>) => void\n}\n\n/**\n * The follower fold, untyped on purpose: the state type comes from the\n * caller's `initial` handoff, and the fold never inspects state.\n * `initialState` is never rendered — `initial` is required, so every\n * session hydrates before it connects.\n */\nconst followerReducer: Reducer<EventDefs, unknown, PresenceDefs> = {\n  name: 'a2.actor.follower.v1',\n  events: {},\n  // The open vocabulary ('*' catch-all): the browser cannot know a\n  // server-defined field list, so the server stays the authority and\n  // the protocol types honest callers at compile time.\n  presence: openPresenceDefs,\n  fold: (state, event) =>\n    event.type === ACTOR_STATE_EVENT\n      ? (event.payload as { state: unknown }).state\n      : state,\n  initialState: undefined,\n  stateSchema: undefined,\n}\n\nconst clients = new Map<string, A2Client<EventDefs, unknown, PresenceDefs>>()\n\n/** Use one actor instance: live state plus typed calls. No provider. */\nexport function useActor<D extends AnyActorDefinition, View = ActorStateOf<D>>(\n  options: UseActorOptions<View>,\n): UseActorResult<D, View> {\n  const { api } = options\n  let client = clients.get(api)\n  if (!client) {\n    client = createClient({ reducer: followerReducer, api })\n    clients.set(api, client)\n  }\n  const session = useSession(client, options.id, {\n    hydrate: options.initial,\n    ...(options.participant === undefined\n      ? {}\n      : { participant: options.participant }),\n  })\n  const { call, state: refresh } = useMemo(\n    () =>\n      createActorClient<D, View>({\n        api,\n        onSnapshot: ({ state, index }) => {\n          client.session(options.id, {\n            initialState: state,\n            initialIndex: index,\n          })\n        },\n      }),\n    [api, client, options.id],\n  )\n  return {\n    state: session.state as View,\n    index: session.index,\n    connection: session.connection,\n    call,\n    refresh,\n    events: session.events,\n    presence: session.presence as ActorPresenceMap<PresenceOf<D>>,\n    setPresence: session.setPresence as (\n      values: ActorPresenceValues<PresenceOf<D>>,\n    ) => void,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGA,MAAM,kBAA6D;CACjE,MAAM;CACN,QAAQ,CAAC;CAIT,UAAU;CACV,OAAO,OAAO,UACZ,MAAM,SAAA,mBACD,MAAM,QAA+B,QACtC;CACN,cAAc,KAAA;CACd,aAAa,KAAA;AACf;AAEA,MAAM,0BAAU,IAAI,IAAwD;;AAG5E,SAAgB,SACd,SACyB;CACzB,MAAM,EAAE,QAAQ;CAChB,IAAI,SAAS,QAAQ,IAAI,GAAG;CAC5B,IAAI,CAAC,QAAQ;EACX,SAAS,aAAa;GAAE,SAAS;GAAiB;EAAI,CAAC;EACvD,QAAQ,IAAI,KAAK,MAAM;CACzB;CACA,MAAM,UAAU,WAAW,QAAQ,QAAQ,IAAI;EAC7C,SAAS,QAAQ;EACjB,GAAI,QAAQ,gBAAgB,KAAA,IACxB,CAAC,IACD,EAAE,aAAa,QAAQ,YAAY;CACzC,CAAC;CACD,MAAM,EAAE,MAAM,OAAO,YAAY,cAE7B,kBAA2B;EACzB;EACA,aAAa,EAAE,OAAO,YAAY;GAChC,OAAO,QAAQ,QAAQ,IAAI;IACzB,cAAc;IACd,cAAc;GAChB,CAAC;EACH;CACF,CAAC,GACH;EAAC;EAAK;EAAQ,QAAQ;CAAE,CAC1B;CACA,OAAO;EACL,OAAO,QAAQ;EACf,OAAO,QAAQ;EACf,YAAY,QAAQ;EACpB;EACA;EACA,QAAQ,QAAQ;EAChB,UAAU,QAAQ;EAClB,aAAa,QAAQ;CAGvB;AACF"}

package/dist/actor.d.ts

@@ -1,176 +1,2 @@
-import { i as Contract, s as EventDefs, t as Reducer } from "./reducer-DJKWm3cp.js";
-import { t as A2Store } from "./store-DGHeBtIQ.js";
-import { m as Session, n as A2Server, t as A2Scheduler } from "./server-DgCrSuhB.js";
-import { i as A2Telemetry } from "./telemetry-CpeclqB2.js";
-import { a as ActorPresenceOf, c as ActorRefusedError, d as ActorSend, i as ActorPresenceMap, l as ActorScheduleOptions, n as ActorConcurrentContext, o as ActorPresenceValues, r as ActorContext, s as ActorProtocol, t as ActorClientEventDefs, u as ActorScheduleSend } from "./actor-shared-USo5MyuF.js";
-//#region src/actor.d.ts
-/**
- * One event's handler: ordinary server code. Serial by default — read
- * `ctx.state`, perform I/O, mutate `ctx.state`, one atomic commit at
- * return. `{ concurrent: true, handle }` opts the handler out of the
- * lane for slow I/O: state becomes a snapshot read and mutations
- * happen by sending events. The input is typed by the protocol; the
- * wire hands handlers parsed JSON, so a wire-exposed event guards its
- * input in its first line (`schema.parse(input)` if you like schemas —
- * userland either way).
- */
-type ActorHandler<D extends ActorProtocol, K extends keyof D["events"]> = ((ctx: ActorContext<D>, input: D["events"][K]) => void | Promise<void>) | {
-  concurrent: true;
-  handle: (ctx: ActorConcurrentContext<D>, input: D["events"][K]) => void | Promise<void>;
-};
-/**
- * Mark a handler concurrent — off the lane, in parallel with the lane
- * and with other concurrent handlers, `ctx.state()` a snapshot read.
- * Sugar for the structural `{ concurrent: true, handle }` form:
- *
- * ```ts
- * handlers: {
- *   transfer: concurrent(async (ctx, input) => {
- *     await bank.transfer(input, { idempotencyKey: input.ref })
- *     ctx.send.settle({ ref: input.ref })
- *   }),
- * }
- * ```
- */
-declare function concurrent<Ctx, I>(handle: (ctx: Ctx, input: I) => void | Promise<void>): {
-  concurrent: true;
-  handle: (ctx: Ctx, input: I) => void | Promise<void>;
-};
-type ActorOptions<D extends ActorProtocol> = {
-  /** Identity — prefixes storage keys; one contract per actor definition. */
-  name: string;
-  /** The initial state — checked against the protocol, a plain JSON tree. */
-  state: D["state"];
-  /**
-   * One handler per declared event — completeness and payload shapes
-   * are compile-checked against the protocol.
-   */
-  handlers: { [K in keyof D["events"]]: ActorHandler<D, K>; };
-  store?: A2Store;
-  scheduler?: A2Scheduler;
-  telemetry?: A2Telemetry;
-} & ([ActorPresenceOf<D>] extends [never] ? {
-  presence?: never;
-} : {
-  /**
-   * The wire bit for the protocol's `presence` vocabulary — types
-   * erase, so the runtime needs one value to arm the presence
-   * lanes (frames on GET, envelopes on POST). Required exactly
-   * when the protocol declares `presence`; the vocabulary itself
-   * is typed there. Values are validated to the JSON floor and
-   * pass through `authorize` as `{ type: 'presence' }` operations;
-   * meaning stays with your renderers — treat values as user
-   * input.
-   */
-  presence: true;
-});
-/**
- * One HTTP operation `handle.fetch` is about to serve — the actor
- * mirror of core's `A2Operation`. `authorize` sees it before any
- * write or subscription; returning `false` answers 403.
- */
-type ActorOperation = {
-  readonly type: "stream";
-  readonly id: string;
-  readonly startAfter: number;
-} | {
-  readonly type: "call";
-  readonly id: string;
-  readonly event: string;
-  readonly input: unknown;
-  readonly messageId?: string;
-} | {
-  readonly type: "presence";
-  readonly id: string;
-  readonly participant: string;
-  readonly values: Readonly<Record<string, unknown>>;
-};
-type ActorFetchOptions<D extends ActorProtocol> = {
-  /** Per-operation policy — authentication happened in your route. */
-  authorize?: (operation: ActorOperation) => boolean | Promise<boolean>;
-  /**
-   * Request-time projection: what this mount's audience sees. Applied
-   * to every state frame on the stream AND to call answers (the two
-   * untrusted lanes must agree, or the call lane leaks what the
-   * stream hides). The definition stays audience-agnostic — different
-   * routes project the same actor differently, and per-viewer views
-   * are just closures over the route's auth. Output is held to the
-   * JSON-tree floor like everything else. Transport-agnostic: applied
-   * at frame emission, so any wire the door speaks emits projected
-   * frames. Absent, the full state ships (the trusted default).
-   */
-  view?: (state: D["state"]) => unknown;
-};
-type ActorSendOptions = {
-  /** Explicit message id — makes retries of this send idempotent. */
-  id?: string;
-};
-type ActorCallOptions = ActorSendOptions & {
-  /** How long to await the answer before rejecting the wait (default 30s). */
-  timeoutMs?: number;
-};
-type ActorCallResult<S> = {
-  /** The actor's state after this message was processed. */
-  state: S;
-  /** Log index of the state commit that answered this message. */
-  index: number;
-};
-type CallMethod<D extends ActorProtocol, K extends keyof D["events"]> = {} extends D["events"][K] ? (input?: D["events"][K], options?: ActorCallOptions) => Promise<ActorCallResult<D["state"]>> : (input: D["events"][K], options?: ActorCallOptions) => Promise<ActorCallResult<D["state"]>>;
-type SendMethod<D extends ActorProtocol, K extends keyof D["events"]> = {} extends D["events"][K] ? (input?: D["events"][K], options?: ActorSendOptions) => Promise<{
-  id: string;
-  index: number;
-}> : (input: D["events"][K], options?: ActorSendOptions) => Promise<{
-  id: string;
-  index: number;
-}>;
-/** One instance: typed calls and sends, reads, the managed door, the escape hatch. */
-type ActorHandle<D extends ActorProtocol> = {
-  readonly id: string;
-  /**
-   * Send the event and await its answer: the state after the handler
-   * ran, or a rejection with `ActorRefusedError`. Serial events only —
-   * concurrent handlers produce no answer to await; `send` them.
-   */
-  readonly call: { readonly [K in keyof D["events"]]: CallMethod<D, K>; };
-  /** Cast: validate, append the event durably, return without waiting. */
-  readonly send: { readonly [K in keyof D["events"]]: SendMethod<D, K>; };
-  /** Snapshot read — never queues behind pending messages. */
-  readonly state: () => Promise<ActorCallResult<D["state"]>>;
-  /**
-   * The managed door — the actor mirror of `server.fetch`, bound to
-   * this instance. GET streams the state plane (`a2.actor.state`
-   * commits only, `?index` resume, heartbeat, deadline rotation);
-   * POST is the call lane `createActorClient` speaks (`{ event,
-   * input, messageId? }` → the answer, 409 for a refusal). Your route
-   * authenticates and picks the instance; `authorize` sees every
-   * operation. Custom endpoints are route code around this call.
-   */
-  readonly fetch: (request: Request, options?: ActorFetchOptions<D>) => Promise<Response>;
-  /** Escape hatch: the raw A2 session (history, stream, schedule). */
-  readonly session: Session<EventDefs>;
-};
-type ActorDefinition<D extends ActorProtocol> = {
-  readonly name: string;
-  /**
-   * Type-only carrier of the protocol, so clients deriving from
-   * `typeof def` can see the vocabularies (`experimental-a2/actor/react`
-   * types `presence` from it). Never a runtime value.
-   */
-  readonly protocol?: D;
-  /** The assembled contract — declared events plus the reserved a2.actor.* pair. */
-  readonly contract: Contract<EventDefs>;
-  /** The underlying A2 server — `server.fetch` mounts the full session wire. */
-  readonly server: A2Server<EventDefs>;
-  /** The state fold — same identity as the client's follower fold. */
-  readonly reducer: Reducer<ActorClientEventDefs<D["state"]>, D["state"]>;
-  actor(id: string): ActorHandle<D>;
-};
-/**
- * Define and serve an actor over its protocol: a named, durable
- * instance-per-id with serialized state handlers, concurrent I/O
- * handlers, and typed self-sends.
- */
-declare function actor<D extends ActorProtocol>(options: ActorOptions<D>): ActorDefinition<D>;
-//#endregion
-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 };
-//# sourceMappingURL=actor.d.ts.map
+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-DJi3RsNu.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,6 +1,6 @@
 import { t as contract } from "./contract-48bUMgcL.js";
 import { n as NonRetriableError, t as A2Error } from "./errors-DCk6ch5n.js";
-import { a as parsePresenceSibling, i as sseResponse, r as setServerFetchHooks, t as createServer } from "./server-DlLyvaSH.js";
+import { a as sseResponse, i as setServerFetchHooks, o as parsePresenceSibling, t as createServer } from "./server-BeNADlCI.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-DI7J5upy.js";
 //#region src/actor.ts
 /**
@@ -324,6 +324,17 @@ function actor(options) {
 			const authorized = async (operation) => await fetchOptions?.authorize?.(Object.freeze(operation)) !== false;
 			if (request.method === "GET") {
 				const url = new URL(request.url);
+				if (url.searchParams.has("snapshot")) {
+					if (!await authorized({
+						type: "state",
+						id
+					})) return forbidden();
+					const result = await readState();
+					return Response.json({
+						state: fetchOptions?.view ? applyView(fetchOptions.view, result.state) : result.state,
+						index: result.index
+					}, { headers: { "cache-control": "private, no-store" } });
+				}
 				const raw = Number(url.searchParams.get("index"));
 				const startAfter = Number.isSafeInteger(raw) && raw >= 0 ? raw : 0;
 				if (!await authorized({
@@ -387,7 +398,7 @@ function actor(options) {
 				return Response.json(fetchOptions?.view ? {
 					state: applyView(fetchOptions.view, result.state),
 					index: result.index
-				} : result);
+				} : result, { headers: { "cache-control": "private, no-store" } });
 			} catch (error) {
 				if (error instanceof ActorRefusedError) return Response.json({
 					error: error.message,

package/dist/actor.js.map

@@ -1 +1 @@
-{"version":3,"file":"actor.js","names":["contract","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 { contract 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 { createServer } from './server.ts'\nimport { setServerFetchHooks } from './server-fetch.ts'\nimport { sseResponse } from './sse.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 * write or subscription; returning `false` answers 403.\n */\nexport type ActorOperation =\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\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`. Serial events only —\n   * concurrent handlers produce no answer to await; `send` 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 only, `?index` resume, heartbeat, deadline rotation);\n   * POST is the call lane `createActorClient` speaks (`{ event,\n   * input, messageId? }` → the answer, 409 for a refusal). 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 — same identity as the client's follower fold. */\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 } = 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        }\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 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 session.history({ gte: cursor })\n        for (const event of tail) {\n          if (event.type === ACTOR_STATE_EVENT) {\n            const payload = event.payload as ActorStatePayload<D['state']>\n            if (payload.message === message.id) {\n              return { state: payload.state, index: event.index }\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 } = await session.state(serverReducer)\n      return { state, index }\n    }\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        | 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        // 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 only, `?index`\n    // resume), POST is the call lane (`{ event, input, messageId? }`\n    // → the answer, 409 for a refusal). Authentication happens in the\n    // surrounding route; 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        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(\n          fetchOptions?.view\n            ? {\n                state: applyView(fetchOptions.view, result.state),\n                index: result.index,\n              }\n            : result,\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 (\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqIA,SAAgB,WACd,QAC4E;CAC5E,OAAO;EAAE,YAAY;EAAM;CAAO;AACpC;AAqKA,MAAM,qCAAqB,IAAI,IAAI;CAAC;CAAa;CAAe;AAAW,CAAC;AAE5E,MAAM,kBACJ,SAAS,KAAK,EAAE,OAAO,kCAAkC,GAAG,EAAE,QAAQ,IAAI,CAAC;AAE7E,MAAM,kBAAkB;AACxB,MAAM,eAAe;;AAGrB,MAAM,kBAA6C,EACjD,aAAa;CACX,SAAS;CACT,QAAQ;CACR,SAAS,OAAO;EACd,IAAI,UAAU,KAAA,KAAa,UAAU,MAAM,OAAO,EAAE,OAAO,CAAC,EAAE;EAC9D,IAAI,CAAC,WAAW,KAAK,GACnB,OAAO,EACL,QAAQ,CAAC,EAAE,SAAS,wCAAwC,CAAC,EAC/D;EAEF,OAAO,EAAE,MAAM;CACjB;AACF,EACF;AAEA,MAAM,iBAAiB,UACrB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAEvD,MAAM,SAAS,OACb,IAAI,SAAS,YAAY,WAAW,SAAS,EAAE,CAAC;;;;;;AAoBlD,SAAgB,MACd,SACoB;CACpB,MAAM,EAAE,SAAS;CAEjB,MAAM,kCAAkB,IAAI,IAAkC;CAC9D,MAAM,SAA2C;GAC9C,oBAAoB,iBAAiB;GACrC,qBAAqB;CACxB;CACA,KAAK,MAAM,CAAC,WAAW,QAAQ,OAAO,QACpC,QAAQ,QACV,GAAG;EACD,IAAI,mBAAmB,IAAI,SAAS,GAClC,MAAM,IAAI,UACR,UAAU,KAAK,MAAM,UAAU,yDACjC;EAEF,IAAI,UAAU,WAAW,KAAK,GAC5B,MAAM,IAAI,UACR,UAAU,KAAK,gDACjB;EAEF,gBAAgB,IACd,WACA,OAAO,QAAQ,aACX;GACE,MAAM;GACN,QAAQ;EAIV,IACA;GACE,MAAM;GACN,QAAQ,IAAI;EAId,CACN;EACA,OAAO,aAAa;CACtB;CAEA,MAAM,UAAU,aAAa;EAAE;EAAM,OAAO,QAAQ;CAAM,CAAC;CAI3D,MAAM,gBAAgB;CAMtB,MAAM,gBACJ,aAKmC;EACnC,MAAM,UAAmC,CAAC;EAC1C,KAAK,MAAM,aAAa,gBAAgB,KAAK,GAC3C,OAAO,eAAe,SAAS,WAAW;GACxC,QAAQ,OAAgB,oBAA0C;IAChE,MAAM,EAAE,MAAM,UAAU,GAAG,WAAW;IACtC,OAAO,SAAS,YAAY,WAAW,QAAQ;KAC7C,MAAM;KACN,SAAS,SAAS,CAAC;IACrB,CAAC;GACH;GACA,YAAY;GACZ,cAAc;GACd,UAAU;EACZ,CAAC;EAEH,OAAO;CACT;CAKA,MAAM,YACJ,WAC2B;EAC3B,MAAM,OAAgC,CAAC;EACvC,KAAK,MAAM,aAAa,gBAAgB,KAAK,GAC3C,OAAO,eAAe,MAAM,WAAW;GACrC,QAAQ,UAAoB;IAC1B,OAAO,KAAK;KAAE,MAAM;KAAW,SAAS,SAAS,CAAC;IAAE,CAAC;GACvD;GACA,YAAY;GACZ,cAAc;GACd,UAAU;EACZ,CAAC;EAEH,OAAO;CACT;CAEA,MAAM,WAAoD,CAAC;CAC3D,KAAK,MAAM,CAAC,WAAW,QAAQ,iBAAiB;EAC9C,IAAI,IAAI,SAAS,cAAc;GAK7B,SAAS,aAAa,OAAO,QAAQ;IACnC,MAAM,QAA8C,CAAC;IACrD,IAAI;KACF,MAAM,IAAI,OACR;MACE,IAAI,IAAI,MAAM;MACd,SAAS,IAAI;MACb,QAAQ,IAAI;MACZ,MAAM,SAAS,KAAK;MACpB,UAAU,cAAc,UAAU,QAAQ,UACxC,IAAI,QAAQ,SACV,UACA,QACA,KACF,CACF;MACA,OAAO,YAAY;OACjB,MAAM,EAAE,OAAO,UAAU,MAAM,IAAI,QAAQ,MACzC,eACA,EAAE,SAAS,SAAS,CACtB;OACA,OAAO;QAAE;QAAO;OAAM;MACxB;KACF,GACA,IAAI,MAAM,OACZ;IACF,SAAS,OAAO;KACd,IAAI,EAAE,iBAAiB,oBAAoB,MAAM;KAMjD,MAAM,UAA8B;MAClC,SAAS,IAAI,MAAM;MACnB,OAAO;MACP,OAAO,cAAc,KAAK;KAC5B;KACA,OAAO;MAAE,MAAM;MAAoB;KAAQ;IAC7C;IAGA,OAAO;GACT;GACA;EACF;EACA,SAAS,aAAa;GAMpB,MAAM;GACN,SAAS,OAAO,QAAQ;IAOtB,MAAM,EAAE,UAAU,MAAM,IAAI,QAAQ,MAAM,eAAe,EACvD,SAAS,SACX,CAAC;IACD,MAAM,QAAQ,gBAAgB,KAAK;IACnC,MAAM,QAA8C,CAAC;IACrD,IAAI;KACF,MAAM,IAAI,OACR;MACE,OAAO;MACP,IAAI,IAAI,MAAM;MACd,SAAS,IAAI;MACb,QAAQ,IAAI;MACZ,MAAM,SAAS,KAAK;MACpB,UAAU,cAAc,UAAU,QAAQ,UACxC,IAAI,QAAQ,SACV,UACA,QACA,KACF,CACF;KACF,GACA,IAAI,MAAM,OACZ;IACF,SAAS,OAAO;KASd,IAAI,EAAE,iBAAiB,oBAAoB,MAAM;KACjD,MAAM,UAA8B;MAClC,SAAS,IAAI,MAAM;MACnB,OAAO;MACP,OAAO,cAAc,KAAK;KAC5B;KACA,OAAO;MAAE,MAAM;MAAoB;KAAQ;IAC7C;IAMA,MAAM,UAAyC;KAC7C,OAAO;KACP,OAAO;KACP,SAAS,IAAI,MAAM;IACrB;IACA,OAAO,CAAC,GAAG,OAAO;KAAE,MAAM;KAAmB;IAAQ,CAAC;GACxD;EACF;CACF;CAEA,MAAM,kBAAmB,QAAmC,aAAa;CAIzE,MAAMA,aAAW,kBACbC,SAAe;EAAE;EAAM;EAAQ,UAAU;CAAiB,CAAC,IAC3DA,SAAe;EAAE;EAAM;CAAO,CAAC;CACnC,MAAM,SAAS,aAAa;EAC1B,UAAA;EACA;EACA,GAAI,QAAQ,QAAQ,EAAE,OAAO,QAAQ,MAAM,IAAI,CAAC;EAChD,GAAI,QAAQ,YAAY,EAAE,WAAW,QAAQ,UAAU,IAAI,CAAC;EAC5D,GAAI,QAAQ,YAAY,EAAE,WAAW,QAAQ,UAAU,IAAI,CAAC;CAC9D,CAAC;CAID,oBAAoB,QAAQ,EAC1B,kBAAkB,EAAE,QAAQ,aAAa;EACvC,KAAK,MAAM,SAAS,QAClB,IAAI,MAAM,KAAK,WAAW,WAAW,GACnC,MAAM,IAAI,UACR,IAAI,MAAM,KAAK,0DACjB;CAGN,EACF,CAAC;CAED,MAAM,cAAc,OAA+B;EACjD,MAAM,UAAU,OAAO,QAAQ,EAAE;EAEjC,MAAM,YAAY,OAChB,WACA,OACA,gBAC2C;GAC3C,MAAM,CAAC,WAAW,MAAM,QAAQ,OAAO;IACrC,MAAM;IACN,SAAS,SAAS,CAAC;IACnB,GAAI,aAAa,KAAK,EAAE,IAAI,YAAY,GAAG,IAAI,CAAC;GAClD,CAAC;GACD,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,0BAA0B;GACxD,OAAO;IAAE,IAAI,QAAQ;IAAI,OAAO,QAAQ;GAAM;EAChD;EAEA,MAAM,YAAY,OAChB,WACA,OACA,gBACyC;GACzC,IAAI,gBAAgB,IAAI,SAAS,CAAC,EAAE,SAAS,cAC3C,MAAM,IAAI,UACR,UAAU,KAAK,MAAM,UAAU,kEACjC;GAEF,MAAM,UAAU,MAAM,UAAU,WAAW,OAAO,WAAW;GAC7D,MAAM,WAAW,KAAK,IAAI,KAAK,aAAa,aAAa;GACzD,IAAI,SAAS,QAAQ,QAAQ;GAC7B,SAAS;IAGP,MAAM,OAAO,MAAM,EAAE;IACrB,MAAM,OAAO,MAAM,QAAQ,QAAQ,EAAE,KAAK,OAAO,CAAC;IAClD,KAAK,MAAM,SAAS,MAAM;KACxB,IAAI,MAAM,SAAA,kBAA4B;MACpC,MAAM,UAAU,MAAM;MACtB,IAAI,QAAQ,YAAY,QAAQ,IAC9B,OAAO;OAAE,OAAO,QAAQ;OAAO,OAAO,MAAM;MAAM;KAEtD;KACA,IAAI,MAAM,SAAA,mBAA6B;MACrC,MAAM,UAAU,MAAM;MACtB,IAAI,QAAQ,YAAY,QAAQ,IAC9B,MAAM,IAAI,kBAAkB,WAAW,QAAQ,IAAI,QAAQ,KAAK;KAEpE;IACF;IACA,MAAM,OAAO,KAAK,KAAK,SAAS;IAChC,IAAI,MAAM,SAAS,KAAK,QAAQ;IAChC,IAAI,KAAK,IAAI,KAAK,UAChB,MAAM,IAAI,MACR,UAAU,KAAK,4BAA4B,UAAU,aAAa,QAAQ,GAAG,EAC/E;IAEF,MAAM,MAAM,YAAY;GAC1B;EACF;EAEA,MAAM,YAAY,YAAkD;GAClE,MAAM,EAAE,OAAO,UAAU,MAAM,QAAQ,MAAM,aAAa;GAC1D,OAAO;IAAE;IAAO;GAAM;EACxB;EAEA,MAAM,aACJ,MACA,UACY;GACZ,MAAM,SAAS,KAAK,KAAK;GACzB,IAAI,CAAC,WAAW,MAAM,GACpB,MAAM,IAAI,UACR,UAAU,KAAK,2DACjB;GAEF,OAAO;EACT;EAEA,MAAM,eAAe,iBACnB,YACA,MACA;GAMA,MAAM,SAIF,kBAEE,QAMA,OAAO;IAAE;IAAY,UAAU;GAAK,CAAC,IACvC,QAAQ,OAAO,EAAE,WAAW,CAAC;GACjC,WAAW,MAAM,QAAQ,QAAQ;IAC/B,IAAI,EAAE,UAAU,OAAO;KACrB,MAAM;KACN;IACF;IACA,MAAM,QAAQ;IAId,IAAI,MAAM,SAAA,kBAA4B;IACtC,IAAI,CAAC,MAAM;KACT,MAAM;KACN;IACF;IACA,MAAM,UAAU,MAAM;IACtB,MAAM;KACJ,GAAG;KACH,SAAS;MAAE,GAAG;MAAS,OAAO,UAAU,MAAM,QAAQ,KAAK;KAAE;IAC/D;GACF;EACF;EAOA,MAAM,cAAc,OAClB,SACA,iBACsB;GACtB,MAAM,aAAa,OAAO,cACvB,MAAM,cAAc,YAAY,OAAO,OAAO,SAAS,CAAC,MAAO;GAElE,IAAI,QAAQ,WAAW,OAAO;IAC5B,MAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;IAC/B,MAAM,MAAM,OAAO,IAAI,aAAa,IAAI,OAAO,CAAC;IAChD,MAAM,aAAa,OAAO,cAAc,GAAG,KAAK,OAAO,IAAI,MAAM;IACjE,IAAI,CAAE,MAAM,WAAW;KAAE,MAAM;KAAU;KAAI;IAAW,CAAC,GACvD,OAAO,UAAU;IAEnB,OAAO,YAAY,aAAa,YAAY,cAAc,IAAI,CAAC;GACjE;GACA,IAAI,QAAQ,WAAW,QACrB,OAAO,IAAI,SAAS,MAAM;IACxB,QAAQ;IACR,SAAS,EAAE,OAAO,YAAY;GAChC,CAAC;GAEH,IAAI;GACJ,IAAI;IACF,OAAO,MAAM,QAAQ,KAAK;GAC5B,QAAQ;IACN,OAAO,SAAS,KAAK,EAAE,OAAO,oBAAoB,GAAG,EAAE,QAAQ,IAAI,CAAC;GACtE;GACA,MAAM,SACJ,OAAO,SAAS,YAAY,SAAS,OAChC,OACD,CAAC;GACP,IAAI,cAAc,QAAQ;IAIxB,IAAI,CAAC,iBACH,OAAO,SAAS,KACd,EAAE,OAAO,UAAU,KAAK,wBAAwB,GAChD,EAAE,QAAQ,IAAI,CAChB;IAEF,MAAM,eAAe,OAAO;IAC5B,IACE,iBAAiB,KAAA,MAChB,CAAC,MAAM,QAAQ,YAAY,KAAK,aAAa,SAAS,IAEvD,OAAO,SAAS,KACd,EAAE,OAAO,+CAA+C,GACxD,EAAE,QAAQ,IAAI,CAChB;IAEF,IAAI;IACJ,IAAI;KACF,MAAM,SAAS,qBAAqB,OAAO,WAAW;KACtD,IAAI,CAAC,QAAQ,MAAM,IAAI,UAAU,4BAA4B;KAC7D,QAAQ;IACV,SAAS,OAAO;KACd,OAAO,SAAS,KAAK,EAAE,OAAO,cAAc,KAAK,EAAE,GAAG,EAAE,QAAQ,IAAI,CAAC;IACvE;IACA,IACE,CAAE,MAAM,WAAW;KACjB,MAAM;KACN;KACA,aAAa,MAAM;KACnB,QAAQ,MAAM;IAChB,CAAC,GAED,OAAO,UAAU;IAEnB,IAAI;KACF,MACE,QAGA,YAAY,KAAK;IACrB,SAAS,OAAO;KACd,IACE,iBAAiB,YAChB,MAAM,SAAS,qBACd,MAAM,SAAS,2BAEjB,OAAO,SAAS,KAAK,EAAE,OAAO,MAAM,QAAQ,GAAG,EAAE,QAAQ,IAAI,CAAC;KAEhE,MAAM;IACR;IACA,OAAO,SAAS,KAAK,CAAC,CAAC;GACzB;GACA,MAAM,YAAY,OAAO;GACzB,IACE,OAAO,cAAc,YACrB,gBAAgB,IAAI,SAAS,CAAC,EAAE,SAAS,UAEzC,OAAO,SAAS,KAAK,EAAE,OAAO,gBAAgB,GAAG,EAAE,QAAQ,IAAI,CAAC;GAElE,MAAM,YAAY,OAAO;GACzB,IAAI,cAAc,KAAA,KAAa,OAAO,cAAc,UAClD,OAAO,SAAS,KAAK,EAAE,OAAO,oBAAoB,GAAG,EAAE,QAAQ,IAAI,CAAC;GAEtE,MAAM,QAAQ,OAAO;GACrB,IACE,CAAE,MAAM,WAAW;IACjB,MAAM;IACN;IACA,OAAO;IACP;IACA,GAAI,cAAc,KAAA,IAAY,CAAC,IAAI,EAAE,UAAU;GACjD,CAAC,GAED,OAAO,UAAU;GAEnB,IAAI;IACF,MAAM,SAAS,MAAM,UACnB,WACA,OACA,cAAc,KAAA,IAAY,KAAA,IAAY,EAAE,IAAI,UAAU,CACxD;IACA,OAAO,SAAS,KACd,cAAc,OACV;KACE,OAAO,UAAU,aAAa,MAAM,OAAO,KAAK;KAChD,OAAO,OAAO;IAChB,IACA,MACN;GACF,SAAS,OAAO;IACd,IAAI,iBAAiB,mBACnB,OAAO,SAAS,KACd;KACE,OAAO,MAAM;KACb,OAAO,MAAM;KACb,WAAW,MAAM;IACnB,GACA,EAAE,QAAQ,IAAI,CAChB;IAEF,IACE,iBAAiB,YAChB,MAAM,SAAS,qBACd,MAAM,SAAS,uBAEjB,OAAO,SAAS,KAAK,EAAE,OAAO,MAAM,QAAQ,GAAG,EAAE,QAAQ,IAAI,CAAC;IAEhE,MAAM;GACR;EACF;EAEA,MAAM,OAAgC,CAAC;EACvC,MAAM,OAAgC,CAAC;EACvC,KAAK,MAAM,aAAa,gBAAgB,KAAK,GAAG;GAC9C,OAAO,eAAe,MAAM,WAAW;IACrC,QAAQ,OAAiB,gBACvB,UAAU,WAAW,OAAO,WAAW;IACzC,YAAY;IACZ,cAAc;IACd,UAAU;GACZ,CAAC;GACD,OAAO,eAAe,MAAM,WAAW;IACrC,QAAQ,OAAiB,gBACvB,UAAU,WAAW,OAAO,WAAW;IACzC,YAAY;IACZ,cAAc;IACd,UAAU;GACZ,CAAC;EACH;EAUA,OAAO;GAPL;GACA;GACM;GACA;GACN,OAAO;GACP,OAAO;EAEG;CACd;CAEA,OAAO;EACL;EACA,UAAA;EACA;EACA;EACA,OAAO;CACT;AACF"}
+{"version":3,"file":"actor.js","names":["contract","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 { contract 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 { createServer } from './server.ts'\nimport { setServerFetchHooks } from './server-fetch.ts'\nimport { sseResponse } from './sse.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\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`. Serial events only —\n   * concurrent handlers produce no answer to await; `send` 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 only, `?index` resume, heartbeat, deadline rotation);\n   * POST is the call lane `createActorClient` speaks (`{ event,\n   * input, messageId? }` → the answer, 409 for a refusal). 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 — same identity as the client's follower fold. */\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 } = 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        }\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 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 session.history({ gte: cursor })\n        for (const event of tail) {\n          if (event.type === ACTOR_STATE_EVENT) {\n            const payload = event.payload as ActorStatePayload<D['state']>\n            if (payload.message === message.id) {\n              return { state: payload.state, index: event.index }\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 } = await session.state(serverReducer)\n      return { state, index }\n    }\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        | 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        // 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 only, `?index`\n    // resume), POST is the call lane (`{ event, input, messageId? }`\n    // → the answer, 409 for a refusal). Authentication happens in the\n    // surrounding route; 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          const result = await readState()\n          return Response.json(\n            {\n              state: fetchOptions?.view\n                ? applyView(fetchOptions.view, result.state)\n                : result.state,\n              index: result.index,\n            },\n            { headers: { 'cache-control': 'private, no-store' } },\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(\n          fetchOptions?.view\n            ? {\n                state: applyView(fetchOptions.view, result.state),\n                index: result.index,\n              }\n            : result,\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 (\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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"}

package/dist/ai-server.d.ts

@@ -1,5 +1,5 @@
 import { a as ContractEvent, s as EventDefs } from "./reducer-DJKWm3cp.js";
-import { n as A2Server, p as ServerOptions } from "./server-DgCrSuhB.js";
+import { n as A2Server, p as ServerOptions } from "./server-DjZZa1wr.js";
 import { AIEventDefs, AIState, AgentDefinition, AgentToolContext, AgentToolEventDefs } from "./ai.js";
 import { Instructions, LanguageModel, TextStreamPart, ToolSet, ToolSet as ToolSet$1, UIMessage, UIMessageChunk, streamText } from "ai";
 //#region src/ai-sdk-step.d.ts

package/dist/ai-server.js

@@ -1,6 +1,6 @@
 import { t as A2Error } from "./errors-DCk6ch5n.js";
-import { f as consumeSchedulerSendFailure, p as installAmbientToolScopeStorage } from "./internal-DRXJ56EI.js";
-import { r as setServerFetchHooks, t as createServer } from "./server-DlLyvaSH.js";
+import { f as consumeSchedulerSendFailure, p as installAmbientToolScopeStorage } from "./internal-Dq2qYxou.js";
+import { i as setServerFetchHooks, t as createServer } from "./server-BeNADlCI.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { convertToModelMessages, stepCountIs, streamText, toUIMessageStream } from "ai";
 //#region src/ai-sdk-step.ts

package/dist/ai.d.ts

@@ -1,5 +1,5 @@
 import { h as StandardSchemaV1, i as Contract, r as AppendInput, s as EventDefs, t as Reducer } from "./reducer-DJKWm3cp.js";
-import { s as HandlerContext } from "./server-DgCrSuhB.js";
+import { s as HandlerContext } from "./server-DjZZa1wr.js";
 import { FinishReason, JSONValue, LanguageModelUsage, UIMessage, UIMessageChunk } from "ai";
 //#region src/ai.d.ts
 type AgentStatus = "idle" | "generating" | "waiting" | "failed" | "closed";

package/dist/ai.js

@@ -1,6 +1,6 @@
 import { n as validateSync, t as assertSyncSchema } from "./validate-XKT4FSNn.js";
 import { t as contract } from "./contract-48bUMgcL.js";
-import { l as ambientToolScopeStorage } from "./internal-DRXJ56EI.js";
+import { l as ambientToolScopeStorage } from "./internal-Dq2qYxou.js";
 //#region src/ai-projector.ts
 const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const cloneMessage = (messageId, base) => structuredClone(base ?? {