experimental-a2 0.8.1 → 0.9.0

package/dist/actor.d.ts

@@ -0,0 +1,176 @@
+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-CKY3_lbw.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-BACubf4x.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

package/dist/actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor.d.ts","names":[],"sources":["../src/actor.ts"],"mappings":";;;;;;;;;;;;;;;;KA6GY,aAAa,UAAU,eAAe,gBAAgB,iBAC5D,KAAK,aAAa,IAAI,OAAO,YAAY,cAAc;EAEvD;EACA,SACE,KAAK,uBAAuB,IAC5B,OAAO,YAAY,cACT;;;;;;;;;;;;;;;;iBAiBF,WAAW,KAAK,GAC9B,SAAS,KAAK,KAAK,OAAO,aAAa;EACpC;EAAkB,SAAS,KAAK,KAAK,OAAO,aAAa;;KAIlD,aAAa,UAAU;;EAEjC;;EAEA,OAAO;;;;;EAKP,aAAa,WAAW,cAAc,aAAa,GAAG;EACtD,QAAQ;EACR,YAAY;EACZ,YAAY;MACR,gBAAgB;EAChB;;;;;;;;;;;;EAYA;;;;;;;KAQM;WAEG;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;;WAGA;WACA;WACA;WACA,QAAQ,SAAS;;KAGpB,kBAAkB,UAAU;;EAEtC,aAAa,WAAW,6BAA6B;;;;;;;;;;;;EAYrD,QAAQ,OAAO;;KAGL;;EAEV;;KAGU,mBAAmB;;EAE7B;;KAGU,gBAAgB;;EAE1B,OAAO;;EAEP;;KAGG,WACH,UAAU,eACV,gBAAgB,0BACH,YAAY,MAErB,QAAQ,YAAY,IACpB,UAAU,qBACP,QAAQ,gBAAgB,gBAE3B,OAAO,YAAY,IACnB,UAAU,qBACP,QAAQ,gBAAgB;KAE5B,WACH,UAAU,eACV,gBAAgB,0BACH,YAAY,MAErB,QAAQ,YAAY,IACpB,UAAU,qBACP;EAAU;EAAY;MAEzB,OAAO,YAAY,IACnB,UAAU,qBACP;EAAU;EAAY;;;KAGnB,YAAY,UAAU;WACvB;;;;;;WAMA,kBAAkB,WAAW,cAAc,WAAW,GAAG;;WAEzD,kBAAkB,WAAW,cAAc,WAAW,GAAG;;WAEzD,aAAa,QAAQ,gBAAgB;;;;;;;;;;WAUrC,QACP,SAAS,SACT,UAAU,kBAAkB,OACzB,QAAQ;;WAEJ,SAAS,QAAQ;;KAGhB,gBAAgB,UAAU;WAC3B;;;;;;WAMA,WAAW;;WAEX,UAAU,SAAS;;WAEnB,QAAQ,SAAS;;WAEjB,SAAS,QAAQ,qBAAqB,aAAa;EAC5D,MAAM,aAAa,YAAY;;;;;;;iBAsDjB,MAAM,UAAU,eAC9B,SAAS,aAAa,KACrB,gBAAgB"}

package/dist/actor.js

@@ -0,0 +1,437 @@
+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-CBET-jSz.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
+/**
+* experimental-a2/actor — durable actors over the log. Server-only
+* (handlers are server code); the browser condition resolves to a
+* throwing stub, and the browser surfaces are experimental-a2/actor/client
+* and experimental-a2/actor/react.
+*
+* An actor is defined over a protocol — its state shape and event
+* vocabulary, as types — and one complete `handlers` bag:
+*
+* ```ts
+* interface Counter {
+*   state: { count: number }
+*   events: { increment: object; add: { by: number } }
+* }
+* const counter = actor<Counter>({
+*   name: 'counter',
+*   state: { count: 0 },
+*   handlers: {
+*     increment: (ctx) => {
+*       ctx.state.count++
+*     },
+*     add: (ctx, input) => {
+*       ctx.state.count += input.by
+*     },
+*   },
+* })
+* ```
+*
+* Handlers are serial by default: one at a time per instance (a lane —
+* the state's write lock), `ctx.state` a mutable draft committed
+* atomically with completion. A handler holding slow I/O opts out of
+* the lane with `{ concurrent: true, handle }`: it runs in parallel,
+* reads state as a snapshot, and mutates by sending events whose
+* serial handlers decide against fresh state. `ctx.send.eventName(...)`
+* is typed by the protocol and buffered — committed atomically with
+* the handler's completion, so a reserve and its trigger can never
+* half-happen.
+*
+* A thrown `NonRetriableError` is an answer (settled, delivered to a
+* waiting caller); any other error retries like every A2 handler
+* failure; a crash re-runs against the same pre-state. Everything
+* compiles to contract + reducer + laned handlers + returned events —
+* no new store operations, no new wire.
+*/
+/**
+* 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 })
+*   }),
+* }
+* ```
+*/
+function concurrent(handle) {
+	return {
+		concurrent: true,
+		handle
+	};
+}
+const UNSAFE_EVENT_NAMES = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const forbidden = () => Response.json({ error: "the operation is not authorized" }, { status: 403 });
+const CALL_TIMEOUT_MS = 3e4;
+const CALL_POLL_MS = 25;
+/** Declared events accept any JSON tree; `undefined` normalizes to `{}`. */
+const jsonInputSchema = { "~standard": {
+	version: 1,
+	vendor: "a2",
+	validate(value) {
+		if (value === void 0 || value === null) return { value: {} };
+		if (!isJsonTree(value)) return { issues: [{ message: "event input must be a plain JSON tree" }] };
+		return { value };
+	}
+} };
+const describeError = (error) => error instanceof Error ? error.message : String(error);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* 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.
+*/
+function actor(options) {
+	const { name } = options;
+	const handlersByEvent = /* @__PURE__ */ new Map();
+	const events = {
+		[ACTOR_STATE_EVENT]: actorStateSchema(),
+		[ACTOR_FAILED_EVENT]: actorFailedSchema
+	};
+	for (const [eventName, def] of Object.entries(options.handlers)) {
+		if (UNSAFE_EVENT_NAMES.has(eventName)) throw new TypeError(`actor '${name}': '${eventName}' collides with object plumbing and cannot name an event`);
+		if (eventName.startsWith("a2.")) throw new TypeError(`actor '${name}': event names starting with 'a2.' are reserved`);
+		handlersByEvent.set(eventName, typeof def === "function" ? {
+			kind: "serial",
+			handle: def
+		} : {
+			kind: "concurrent",
+			handle: def.handle
+		});
+		events[eventName] = jsonInputSchema;
+	}
+	const reducer = actorReducer({
+		name,
+		state: options.state
+	});
+	const serverReducer = reducer;
+	const makeSchedule = (schedule) => {
+		const surface = {};
+		for (const eventName of handlersByEvent.keys()) Object.defineProperty(surface, eventName, {
+			value: (input, scheduleOptions) => {
+				const { name: taskName, ...timing } = scheduleOptions;
+				return schedule(taskName ?? eventName, timing, {
+					type: eventName,
+					payload: input ?? {}
+				});
+			},
+			enumerable: true,
+			configurable: true,
+			writable: false
+		});
+		return surface;
+	};
+	const makeSend = (buffer) => {
+		const send = {};
+		for (const eventName of handlersByEvent.keys()) Object.defineProperty(send, eventName, {
+			value: (input) => {
+				buffer.push({
+					type: eventName,
+					payload: input ?? {}
+				});
+			},
+			enumerable: true,
+			configurable: true,
+			writable: false
+		});
+		return send;
+	};
+	const handlers = {};
+	for (const [eventName, def] of handlersByEvent) {
+		if (def.kind === "concurrent") {
+			handlers[eventName] = async (ctx) => {
+				const sends = [];
+				try {
+					await def.handle({
+						id: ctx.event.id,
+						attempt: ctx.attempt,
+						signal: ctx.signal,
+						send: makeSend(sends),
+						schedule: makeSchedule((taskName, timing, event) => ctx.session.schedule(taskName, timing, event)),
+						state: async () => {
+							const { state, index } = await ctx.session.state(serverReducer, { through: "latest" });
+							return {
+								state,
+								index
+							};
+						}
+					}, ctx.event.payload);
+				} catch (error) {
+					if (!(error instanceof NonRetriableError)) throw error;
+					const payload = {
+						message: ctx.event.id,
+						event: eventName,
+						error: describeError(error)
+					};
+					return {
+						type: ACTOR_FAILED_EVENT,
+						payload
+					};
+				}
+				return sends;
+			};
+			continue;
+		}
+		handlers[eventName] = {
+			lane: ACTOR_LANE,
+			handler: async (ctx) => {
+				const { state } = await ctx.session.state(serverReducer, { through: "latest" });
+				const draft = structuredClone(state);
+				const sends = [];
+				try {
+					await def.handle({
+						state: draft,
+						id: ctx.event.id,
+						attempt: ctx.attempt,
+						signal: ctx.signal,
+						send: makeSend(sends),
+						schedule: makeSchedule((taskName, timing, event) => ctx.session.schedule(taskName, timing, event))
+					}, ctx.event.payload);
+				} catch (error) {
+					if (!(error instanceof NonRetriableError)) throw error;
+					const payload = {
+						message: ctx.event.id,
+						event: eventName,
+						error: describeError(error)
+					};
+					return {
+						type: ACTOR_FAILED_EVENT,
+						payload
+					};
+				}
+				const payload = {
+					state: draft,
+					event: eventName,
+					message: ctx.event.id
+				};
+				return [...sends, {
+					type: ACTOR_STATE_EVENT,
+					payload
+				}];
+			}
+		};
+	}
+	const presenceEnabled = options.presence === true;
+	const contract$1 = presenceEnabled ? contract({
+		name,
+		events,
+		presence: openPresenceDefs
+	}) : contract({
+		name,
+		events
+	});
+	const server = createServer({
+		contract: contract$1,
+		handlers,
+		...options.store ? { store: options.store } : {},
+		...options.scheduler ? { scheduler: options.scheduler } : {},
+		...options.telemetry ? { telemetry: options.telemetry } : {}
+	});
+	setServerFetchHooks(server, { validateIngress: ({ events: pushed }) => {
+		for (const event of pushed) if (event.type.startsWith("a2.actor.")) throw new TypeError(`'${event.type}' is reserved — only a handler's completion can author it`);
+	} });
+	const makeHandle = (id) => {
+		const session = server.session(id);
+		const sendEvent = async (eventName, input, sendOptions) => {
+			const [message] = await session.append({
+				type: eventName,
+				payload: input ?? {},
+				...sendOptions?.id ? { id: sendOptions.id } : {}
+			});
+			if (!message) throw new Error("append returned no event");
+			return {
+				id: message.id,
+				index: message.index
+			};
+		};
+		const callEvent = async (eventName, input, callOptions) => {
+			if (handlersByEvent.get(eventName)?.kind === "concurrent") throw new TypeError(`actor '${name}': '${eventName}' is concurrent — it produces no answer to await; send it instead`);
+			const message = await sendEvent(eventName, input, callOptions);
+			const deadline = Date.now() + (callOptions?.timeoutMs ?? CALL_TIMEOUT_MS);
+			let cursor = message.index + 1;
+			for (;;) {
+				await server.drain(id);
+				const tail = await session.history({ gte: cursor });
+				for (const event of tail) {
+					if (event.type === "a2.actor.state") {
+						const payload = event.payload;
+						if (payload.message === message.id) return {
+							state: payload.state,
+							index: event.index
+						};
+					}
+					if (event.type === "a2.actor.failed") {
+						const payload = event.payload;
+						if (payload.message === message.id) throw new ActorRefusedError(eventName, message.id, payload.error);
+					}
+				}
+				const last = tail[tail.length - 1];
+				if (last) cursor = last.index + 1;
+				if (Date.now() >= deadline) throw new Error(`actor '${name}': timed out waiting for '${eventName}' (message ${message.id})`);
+				await sleep(CALL_POLL_MS);
+			}
+		};
+		const readState = async () => {
+			const { state, index } = await session.state(serverReducer);
+			return {
+				state,
+				index
+			};
+		};
+		const applyView = (view, state) => {
+			const viewed = view(state);
+			if (!isJsonTree(viewed)) throw new TypeError(`actor '${name}': the view returned a value that is not a plain JSON tree`);
+			return viewed;
+		};
+		const streamStates = async function* (startAfter, view) {
+			const source = presenceEnabled ? session.stream({
+				startAfter,
+				presence: true
+			}) : session.stream({ startAfter });
+			for await (const item of source) {
+				if (!("type" in item)) {
+					yield item;
+					continue;
+				}
+				const event = item;
+				if (event.type !== "a2.actor.state") continue;
+				if (!view) {
+					yield event;
+					continue;
+				}
+				const payload = event.payload;
+				yield {
+					...event,
+					payload: {
+						...payload,
+						state: applyView(view, payload.state)
+					}
+				};
+			}
+		};
+		const handleFetch = async (request, fetchOptions) => {
+			const authorized = async (operation) => await fetchOptions?.authorize?.(Object.freeze(operation)) !== false;
+			if (request.method === "GET") {
+				const url = new URL(request.url);
+				const raw = Number(url.searchParams.get("index"));
+				const startAfter = Number.isSafeInteger(raw) && raw >= 0 ? raw : 0;
+				if (!await authorized({
+					type: "stream",
+					id,
+					startAfter
+				})) return forbidden();
+				return sseResponse(streamStates(startAfter, fetchOptions?.view));
+			}
+			if (request.method !== "POST") return new Response(null, {
+				status: 405,
+				headers: { allow: "GET, POST" }
+			});
+			let body;
+			try {
+				body = await request.json();
+			} catch {
+				return Response.json({ error: "invalid JSON body" }, { status: 400 });
+			}
+			const record = typeof body === "object" && body !== null ? body : {};
+			if ("presence" in record) {
+				if (!presenceEnabled) return Response.json({ error: `actor '${name}' declares no presence` }, { status: 400 });
+				const pushedEvents = record["events"];
+				if (pushedEvents !== void 0 && (!Array.isArray(pushedEvents) || pushedEvents.length > 0)) return Response.json({ error: "the actor wire takes calls, not event pushes" }, { status: 400 });
+				let patch;
+				try {
+					const parsed = parsePresenceSibling(record["presence"]);
+					if (!parsed) throw new TypeError("presence must be an object");
+					patch = parsed;
+				} catch (error) {
+					return Response.json({ error: describeError(error) }, { status: 400 });
+				}
+				if (!await authorized({
+					type: "presence",
+					id,
+					participant: patch.participant,
+					values: patch.values
+				})) return forbidden();
+				try {
+					await session.setPresence(patch);
+				} catch (error) {
+					if (error instanceof A2Error && (error.code === "INVALID_PAYLOAD" || error.code === "UNKNOWN_PRESENCE_FIELD")) return Response.json({ error: error.message }, { status: 400 });
+					throw error;
+				}
+				return Response.json([]);
+			}
+			const eventName = record["event"];
+			if (typeof eventName !== "string" || handlersByEvent.get(eventName)?.kind !== "serial") return Response.json({ error: "unknown event" }, { status: 400 });
+			const messageId = record["messageId"];
+			if (messageId !== void 0 && typeof messageId !== "string") return Response.json({ error: "invalid messageId" }, { status: 400 });
+			const input = record["input"];
+			if (!await authorized({
+				type: "call",
+				id,
+				event: eventName,
+				input,
+				...messageId === void 0 ? {} : { messageId }
+			})) return forbidden();
+			try {
+				const result = await callEvent(eventName, input, messageId === void 0 ? void 0 : { id: messageId });
+				return Response.json(fetchOptions?.view ? {
+					state: applyView(fetchOptions.view, result.state),
+					index: result.index
+				} : result);
+			} catch (error) {
+				if (error instanceof ActorRefusedError) return Response.json({
+					error: error.message,
+					event: error.event,
+					messageId: error.messageId
+				}, { status: 409 });
+				if (error instanceof A2Error && (error.code === "INVALID_PAYLOAD" || error.code === "UNKNOWN_EVENT_TYPE")) return Response.json({ error: error.message }, { status: 400 });
+				throw error;
+			}
+		};
+		const call = {};
+		const send = {};
+		for (const eventName of handlersByEvent.keys()) {
+			Object.defineProperty(call, eventName, {
+				value: (input, callOptions) => callEvent(eventName, input, callOptions),
+				enumerable: true,
+				configurable: true,
+				writable: false
+			});
+			Object.defineProperty(send, eventName, {
+				value: (input, sendOptions) => sendEvent(eventName, input, sendOptions),
+				enumerable: true,
+				configurable: true,
+				writable: false
+			});
+		}
+		return {
+			id,
+			session,
+			call,
+			send,
+			state: readState,
+			fetch: handleFetch
+		};
+	};
+	return {
+		name,
+		contract: contract$1,
+		server,
+		reducer,
+		actor: makeHandle
+	};
+}
+//#endregion
+export { ActorRefusedError, actor, concurrent };
+
+//# sourceMappingURL=actor.js.map