experimental-a2 0.16.1 → 0.18.0

package/src/store.ts

@@ -65,6 +65,8 @@ export type StoredEvent = Event & {
   lastError: string | null
   /** Adapter clock time recorded when dead-lettered; null otherwise. */
   failedAt: Date | null
+  /** Latest clear marker, on claimed events of a cleared session. */
+  clearIndex?: number
 }
 
 /**
@@ -91,6 +93,8 @@ export type StoreStateRead = {
   snapshot: { index: number; state: unknown } | null
   /** Immutable events strictly after `snapshot.index`, or the full log on a miss. */
   events: Event[]
+  /** Latest clear marker; omitted when the session was never cleared. */
+  clearIndex?: number
 }
 
 export type StoreSnapshotWrite = {
@@ -153,6 +157,37 @@ export type StoreAppendResult = {
   hasPending: boolean
 }
 
+export type StoreClearOptions = {
+  sessionId: string
+  ifLastIndex?: number
+  /** The clearing handler's dispatch, fenced like a handler append. */
+  cause?: EventCause
+}
+
+export type StoreClearResult = {
+  cleared: boolean
+  /** The head after the operation. */
+  index: number
+  /** The latest clear marker after the operation, or 0. */
+  clearIndex: number
+}
+
+export type StoreReclaimResult = { deleted: number; done: boolean }
+
+export type StoreRedriveOptions = {
+  sessionId: string
+  index: number
+  /** `retry` clears the dead letter; `skip` settles it without a handler. */
+  action: 'retry' | 'skip'
+}
+
+export type StoreRedriveResult = {
+  /** Whether the event was dead-lettered and this operation resolved it. */
+  redriven: boolean
+  /** Whether the session contains an event without a completion marker. */
+  hasPending: boolean
+}
+
 /**
  * An injectable clock. Adapters take one so tests can drive claim
  * expiry, failure timestamps, and (later) stuck-session detection
@@ -193,8 +228,51 @@ export interface A2Store {
    * `claimAvailable` — an unlocked read of the parent admits write skew.
    * The idempotent-replay path runs first, so a batch whose ids all exist
    * replays regardless of the current attempt.
+   *
+   * Clearing stores (a2-implementation.md §17.2) fence one level earlier:
+   * a `cause` at or below the latest clear marker throws
+   * `SUPERSEDED_ATTEMPT`, an `originIndex` there throws `SESSION_CLEARED`,
+   * and ids whose rows lie below the marker are free to reuse.
+   */
+  append(
+    sessionId: string,
+    events: AppendEvent[],
+    options?: { originIndex?: number },
+  ): Promise<StoreAppendResult>
+
+  /**
+   * Optional with `reclaim`. Serialized with `append`: checks
+   * `ifLastIndex` against the head and the latest marker, then appends a
+   * settled clear marker at the next index without touching existing
+   * rows. Afterwards every event at or below the marker is superseded.
+   */
+  clear?(options: StoreClearOptions): Promise<StoreClearResult>
+
+  /**
+   * Deletes one bounded batch of rows below the latest clear marker, with
+   * their bookkeeping, id records, and cached folds. `done` once nothing
+   * remains below it. Never waits on a lock that other operations hold.
+   */
+  reclaim?(sessionId: string): Promise<StoreReclaimResult>
+
+  /**
+   * Optional with `redrive`. The session's dead-lettered events above the
+   * latest clear marker, oldest first.
+   */
+  deadLetters?(sessionId: string): Promise<StoredEvent[]>
+
+  /**
+   * Optional with `deadLetters`. Atomically resolves one dead-lettered event
+   * above the latest clear marker; any other event is untouched and reports
+   * `redriven: false`. `retry` clears `failedAt` and `failureCount`, so the
+   * event is claimable again with a fresh failure budget, keeping its claim
+   * history and last failure. `skip` records `processedAt` with no
+   * `processedByAttempt` or `returnedEventIds` and exposes the next event in
+   * its lane. Both serialize with `claimAvailable` and the handler-append
+   * parent fence; `skip` also serializes with lane promotion in `append` and
+   * `completeAttempt`. `hasPending` is read in the same step.
    */
-  append(sessionId: string, events: AppendEvent[]): Promise<StoreAppendResult>
+  redrive?(options: StoreRedriveOptions): Promise<StoreRedriveResult>
 
   /** Events for one session, oldest first. Bounds form `(afterIndex, throughIndex]`. */
   read(

package/src/stream-buffer.ts

@@ -0,0 +1,43 @@
+import type { Event } from './store.ts'
+
+/**
+ * An event as a store returned it, its payload still the JSON text A2's
+ * store wrote with `JSON.stringify`. For payloads built from ordinary objects,
+ * parsing and re-serializing that text yields the same text, so the SSE lane
+ * can write it into a frame unchanged.
+ */
+export type SerializedEvent = {
+  id: string
+  type: string
+  payloadJson: string
+  index: number
+  sessionId: string
+  createdAtMs: number
+}
+
+export type HeldEvent = Event | SerializedEvent
+
+export const isSerializedEvent = (event: object): event is SerializedEvent =>
+  'payloadJson' in event
+
+export const parseSerializedEvent = (event: SerializedEvent): Event => ({
+  id: event.id,
+  type: event.type,
+  payload: JSON.parse(event.payloadJson),
+  index: event.index,
+  sessionId: event.sessionId,
+  createdAt: new Date(event.createdAtMs),
+})
+
+/**
+ * The next event a stream iterator already holds, removed without
+ * awaiting its `next()`, which then continues after it; `undefined` when
+ * it holds none. Call only while no `next()` is pending. The SSE encoder
+ * writes these with the event `next()` just returned, so a buffered
+ * backlog leaves in few writes.
+ */
+export const bufferedEvents: WeakMap<object, () => HeldEvent | undefined> =
+  new WeakMap()
+
+export const takeBuffered = (iterator: object): HeldEvent | undefined =>
+  bufferedEvents.get(iterator)?.()

package/src/telemetry.ts

@@ -10,7 +10,20 @@ export type A2AttributeValue = string | number | boolean
 
 /** The spans a2 emits today. The catalogue grows with the surface. */
 export type A2SpanName =
-  'a2.append' | 'a2.drain' | 'a2.event' | 'a2.state' | 'a2.snapshot'
+  | 'a2.append'
+  | 'a2.drain'
+  | 'a2.event'
+  | 'a2.claim'
+  | 'a2.commit'
+  | 'a2.state'
+  | 'a2.snapshot'
+  | 'a2.redrive'
+  | 'a2.ai.control'
+  | 'a2.ai.ack'
+  | 'a2.ai.generate'
+  | 'a2.ai.context'
+  | 'a2.ai.compaction'
+  | 'a2.ai.tool'
 
 export type A2SpanHandle = {
   /** Attach or update an attribute mid-span (e.g. the outcome). */

package/src/wire.ts

@@ -8,6 +8,12 @@
 import { A2Error, type A2ErrorCode, type A2ServerErrorCode } from './errors.ts'
 import { nullProtoRecord } from './internal.ts'
 import type { Event } from './store.ts'
+import {
+  isSerializedEvent,
+  takeBuffered,
+  type HeldEvent,
+  type SerializedEvent,
+} from './stream-buffer.ts'
 import type {
   PresenceMap,
   PresencePatch,
@@ -36,6 +42,128 @@ export function eventToWire(event: Event): WireEvent {
   }
 }
 
+// Consecutive frames usually repeat a stream's session, an event type, and
+// the timestamp of events appended together; each keeps its last encoding.
+const lastEncoding = <T>(encode: (value: T) => string) => {
+  let last: T | undefined
+  let text = ''
+  return (value: T): string => {
+    if (value !== last) {
+      text = encode(value)
+      last = value
+    }
+    return text
+  }
+}
+const isoJson = lastEncoding((ms: number) =>
+  JSON.stringify(new Date(ms).toISOString()),
+)
+const sessionJson = lastEncoding((id: string) => JSON.stringify(id))
+const typeJson = lastEncoding((type: string) => JSON.stringify(type))
+
+/**
+ * `JSON.stringify(eventToWire(event))` for the parsed event, built around the
+ * stored payload text instead of parsing and re-serializing it.
+ */
+export function serializedEventToWireJson(event: SerializedEvent): string {
+  return `{"id":${JSON.stringify(event.id)},"type":${typeJson(event.type)},"payload":${event.payloadJson},"index":${event.index},"sessionId":${sessionJson(event.sessionId)},"createdAt":${isoJson(event.createdAtMs)}}`
+}
+
+/**
+ * Wire version 2: what a client opts into with `wire=2` on the stream URL.
+ * Live events travel in batches, without the `sessionId` the connection
+ * already names, with `createdAt` as epoch milliseconds. Any other value,
+ * or none, selects version 1.
+ */
+export type WireVersion = 1 | 2
+
+export function wireVersion(value: string | null): WireVersion {
+  return value === '2' ? 2 : 1
+}
+
+/**
+ * Events already held by a stream join one write while it is shorter than
+ * this many characters, so a write can exceed it by the event that crosses it.
+ */
+export const EVENT_WRITE_CHARS: number = 64 * 1024
+
+/** Stream items that are events, as opposed to snapshot or presence frames. */
+export function isStreamEvent(item: object): item is HeldEvent {
+  return !('kind' in item) && !('snapshot' in item) && !('participant' in item)
+}
+
+/**
+ * `first` and the events `iterator` already holds, encoded, until the batch
+ * reaches `EVENT_WRITE_CHARS`; `last` is the batch's final event.
+ */
+export function heldEventBatch(options: {
+  first: HeldEvent
+  iterator: object
+  encode: (event: HeldEvent) => string
+}): { events: string[]; last: HeldEvent } {
+  const { iterator, encode } = options
+  let last = options.first
+  const events = [encode(last)]
+  let chars = events[0]!.length
+  while (chars < EVENT_WRITE_CHARS) {
+    const held = takeBuffered(iterator)
+    if (!held) break
+    const json = encode(held)
+    events.push(json)
+    chars += json.length + 1
+    last = held
+  }
+  return { events, last }
+}
+
+/** A version 2 live event: `WireEvent` minus `sessionId`, ms timestamp. */
+export type CompactWireEvent = {
+  id: string
+  type: string
+  payload: unknown
+  index: number
+  createdAt: number
+}
+
+/** One version 2 event as JSON, splicing a held row's stored payload. */
+export function compactEventJson(event: HeldEvent): string {
+  if (!isSerializedEvent(event))
+    return JSON.stringify({
+      id: event.id,
+      type: event.type,
+      payload: event.payload,
+      index: event.index,
+      createdAt: event.createdAt.getTime(),
+    })
+  return `{"id":${JSON.stringify(event.id)},"type":${typeJson(event.type)},"payload":${event.payloadJson},"index":${event.index},"createdAt":${event.createdAtMs}}`
+}
+
+export function isCompactWireEvent(value: unknown): value is CompactWireEvent {
+  if (value === null || typeof value !== 'object') return false
+  const v = value as Record<string, unknown>
+  return (
+    typeof v['id'] === 'string' &&
+    typeof v['type'] === 'string' &&
+    typeof v['index'] === 'number' &&
+    typeof v['createdAt'] === 'number' &&
+    Number.isFinite(v['createdAt'])
+  )
+}
+
+export function eventFromCompactWire(
+  wire: CompactWireEvent,
+  sessionId: string,
+): Event {
+  return {
+    id: wire.id,
+    type: wire.type,
+    payload: wire.payload,
+    index: wire.index,
+    sessionId,
+    createdAt: new Date(wire.createdAt),
+  }
+}
+
 export function eventFromWire(wire: WireEvent): Event {
   return {
     id: wire.id,
@@ -180,6 +308,7 @@ const ERROR_STATUS: Record<A2ServerErrorCode, number> = {
   UNKNOWN_EVENT_TYPE: 400,
   PARTIAL_DUPLICATE_BATCH: 400,
   SUPERSEDED_ATTEMPT: 409,
+  SESSION_CLEARED: 409,
   CLAIM_EXPIRED: 409,
   STORE_UNAVAILABLE: 503,
   STORE_NOT_CONFIGURED: 500,
@@ -249,8 +378,57 @@ const isServerErrorCode = (code: string): code is A2ServerErrorCode =>
  * guard) come back `null`. `sessionId` is present on frames from a
  * multiplexed socket and absent on a single-session one.
  */
+export type StateSnapshotFrame = {
+  kind: 'snapshot'
+  sessionId: string
+  name: string
+  index: number
+  state: unknown
+  stateUndefined?: true
+  /** The session's latest clear marker, when it has been cleared. */
+  clearIndex?: number
+}
+
+export function stateSnapshotToWire(
+  frame: StateSnapshotFrame,
+): StateSnapshotFrame {
+  return frame.state === undefined
+    ? { ...frame, state: null, stateUndefined: true }
+    : frame
+}
+
+export function isStateSnapshotFrame(
+  value: unknown,
+): value is StateSnapshotFrame {
+  if (value === null || typeof value !== 'object') return false
+  const frame = value as Record<string, unknown>
+  return (
+    frame['kind'] === 'snapshot' &&
+    typeof frame['sessionId'] === 'string' &&
+    typeof frame['name'] === 'string' &&
+    frame['name'].length > 0 &&
+    typeof frame['index'] === 'number' &&
+    Number.isSafeInteger(frame['index']) &&
+    frame['index'] >= 0 &&
+    Object.hasOwn(frame, 'state') &&
+    (!Object.hasOwn(frame, 'stateUndefined') ||
+      (frame['stateUndefined'] === true && frame['state'] === null)) &&
+    (!Object.hasOwn(frame, 'clearIndex') ||
+      (typeof frame['clearIndex'] === 'number' &&
+        Number.isSafeInteger(frame['clearIndex']) &&
+        frame['clearIndex'] > 0 &&
+        frame['clearIndex'] <= frame['index']))
+  )
+}
+
+export type SubscriptionStart =
+  | { index: number; bootstrap?: never; reducer?: string }
+  | { bootstrap: true; reducer: string; index?: never }
+
 export type SocketDownFrame =
+  | StateSnapshotFrame
   | { kind: 'event'; event: WireEvent }
+  | { kind: 'events'; events: CompactWireEvent[]; sessionId?: string }
   | { kind: 'presence'; patch: WirePresencePatch; sessionId?: string }
   | {
       kind: 'presence-snapshot'
@@ -259,10 +437,11 @@ export type SocketDownFrame =
     }
   | { kind: 'ack'; req: number; events: WireEvent[]; sessionId?: string }
   | { kind: 'ack'; req: number; error: A2Error; sessionId?: string }
-  | { kind: 'subscribed'; sessionId: string }
+  | { kind: 'subscribed'; sessionId: string; attempt?: number }
   | {
       kind: 'unsubscribed'
       sessionId: string
+      attempt?: number
       reason?: string
       error?: A2Error
     }
@@ -291,11 +470,19 @@ export type SocketPresenceFrame = {
   sessionId?: string
 }
 
+/** One session lane in a subscribe frame. The server echoes `attempt`
+ * on that lane's `subscribed`/`unsubscribed` answers, so a client that
+ * re-subscribed before an answer arrived can tell the answers apart. */
+export type SocketSubscribeEntry = {
+  id: string
+  attempt?: number
+} & SubscriptionStart
+
 /** Open per-session lanes on a multiplexed socket. `index` is each
  * session's exclusive resume frontier — `stream({ startAfter })`. */
 export type SocketSubscribeFrame = {
   kind: 'subscribe'
-  sessions: Array<{ id: string; index: number }>
+  sessions: SocketSubscribeEntry[]
 }
 
 export type SocketUnsubscribeFrame = {
@@ -316,10 +503,11 @@ export const SOCKET_PING_FRAME: string = JSON.stringify({ kind: 'ping' })
  * multiplexed socket presence frames carry the `sessionId` tag; events
  * already carry theirs in the wire event. */
 export function socketFrameFor(
-  item: Event | PresencePatch | PresenceSnapshot,
+  item: Event | PresencePatch | PresenceSnapshot | StateSnapshotFrame,
   sessionId?: string,
 ): string {
   const tag = sessionId === undefined ? {} : { sessionId }
+  if ('kind' in item) return JSON.stringify(stateSnapshotToWire(item))
   if ('snapshot' in item) {
     return JSON.stringify({
       kind: 'presence-snapshot',
@@ -337,6 +525,14 @@ export function socketFrameFor(
   return JSON.stringify({ kind: 'event', ...eventToWire(item) })
 }
 
+/** A version 2 batch frame from compact event JSON; a multiplexed
+ * socket names the batch's session once. */
+export function socketEventsFor(events: string[], sessionId?: string): string {
+  const tag =
+    sessionId === undefined ? '' : `"sessionId":${JSON.stringify(sessionId)},`
+  return `{"kind":"events",${tag}"events":[${events.join(',')}]}`
+}
+
 export function socketAckFor(
   req: number,
   events: Event[],
@@ -363,25 +559,39 @@ export function socketErrorAckFor(
   })
 }
 
-export function socketSubscribedFor(sessionId: string): string {
-  return JSON.stringify({ kind: 'subscribed', sessionId })
+export function socketSubscribedFor(options: {
+  sessionId: string
+  attempt?: number | undefined
+}): string {
+  const { sessionId, attempt } = options
+  return JSON.stringify({
+    kind: 'subscribed',
+    sessionId,
+    ...(attempt === undefined ? {} : { attempt }),
+  })
 }
 
 /** The subscription-over notice: with a `reason` the server rejected
  * or lost the session's stream, without one it ended cleanly. */
-export function socketUnsubscribedFor(
-  sessionId: string,
-  reason?: string,
-  error?: A2Error,
-): string {
+export function socketUnsubscribedFor(options: {
+  sessionId: string
+  attempt?: number | undefined
+  reason?: string
+  error?: A2Error
+}): string {
+  const { sessionId, attempt, reason, error } = options
   return JSON.stringify({
     kind: 'unsubscribed',
     sessionId,
+    ...(attempt === undefined ? {} : { attempt }),
     ...(reason === undefined ? {} : { reason }),
     ...(error === undefined ? {} : errorToWire(error)),
   })
 }
 
+const isAttempt = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isSafeInteger(value) && value >= 0
+
 export function parseSocketFrame(data: string): SocketDownFrame | null {
   let parsed: unknown
   try {
@@ -394,6 +604,10 @@ export function parseSocketFrame(data: string): SocketDownFrame | null {
   }
   const frame = parsed as Record<string, unknown>
   switch (frame['kind']) {
+    case 'snapshot':
+      if (!isStateSnapshotFrame(parsed))
+        throw new A2Error('INVALID_PAYLOAD', 'invalid bootstrap snapshot')
+      return parsed
     case 'ping':
       return { kind: 'ping' }
     case 'event': {
@@ -404,6 +618,13 @@ export function parseSocketFrame(data: string): SocketDownFrame | null {
         event: { id, type, payload, index, sessionId, createdAt },
       }
     }
+    case 'events': {
+      // Dropping a batch would leave a gap the frontier then skips past.
+      const events = frame['events']
+      if (!Array.isArray(events) || !events.every(isCompactWireEvent))
+        throw new A2Error('INVALID_PAYLOAD', 'invalid event batch')
+      return { kind: 'events', events, ...sessionTag(frame) }
+    }
     case 'presence': {
       if (!isWirePresencePatch(parsed)) return null
       const { participant, values, seen, at } = parsed
@@ -422,13 +643,19 @@ export function parseSocketFrame(data: string): SocketDownFrame | null {
       }
     }
     case 'subscribed': {
-      const sessionId = frame['sessionId']
+      const { sessionId, attempt } = frame
       if (typeof sessionId !== 'string') return null
-      return { kind: 'subscribed', sessionId }
+      if (attempt !== undefined && !isAttempt(attempt)) return null
+      return {
+        kind: 'subscribed',
+        sessionId,
+        ...(attempt === undefined ? {} : { attempt }),
+      }
     }
     case 'unsubscribed': {
-      const sessionId = frame['sessionId']
+      const { sessionId, attempt } = frame
       if (typeof sessionId !== 'string') return null
+      if (attempt !== undefined && !isAttempt(attempt)) return null
       const reason = frame['reason']
       const error =
         errorFromWire(parsed) ??
@@ -441,6 +668,7 @@ export function parseSocketFrame(data: string): SocketDownFrame | null {
       return {
         kind: 'unsubscribed',
         sessionId,
+        ...(attempt === undefined ? {} : { attempt }),
         ...(typeof reason === 'string' ? { reason } : {}),
         ...(error === null ? {} : { error }),
       }

package/dist/actor-ohPC-81x.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"actor-ohPC-81x.d.ts","names":[],"sources":["../src/actor-shared.ts","../src/actor.ts"],"mappings":";;;;;;;;;;;cAgCa,0BAA0B;;WAE5B;;WAEA;EACT,YAAY,eAAe,mBAAmB;;;;;;;;;KAepC;EACV;EACA;;;;;;;EAOA;;;KAIU,gBAAgB,UAAU,iBAAiB;EACrD,gBAAgB;IAEd;;KAIQ,oBAAoB,QAC7B,WAAW,cAAc,EAAE;;;;;;KAQlB,iBAAiB;GAExB,yBAAA,WAAW;IAAgB,OAAO,EAAE;IAAI;IAAc,IAAI;;;;;;;;;;;;KAanD,UAAU,iBACV,WAAW,eAAe,EAAE,MACjC,QAAQ,EAAE,eACV,OAAO,EAAE;;;;;;;;;KAWJ,uBAAuB;EAAmB;;;;;;;;;;;;KAY1C,kBAAkB,iBAClB,WAAW,eAAe,EAAE,MACjC,OAAO,EAAE,gBAAgB,SAAS,yBAAyB,iBAC3D,OAAO,EAAE,IAAI,SAAS,yBAAyB;;KAI1C,aAAa,UAAU;;EAEjC,OAAO;;EAEP;;EAEA;;EAEA,QAAQ;;EAER,MAAM,UAAU;;EAEhB,UAAU,kBAAkB;;;;;;;;KASlB,uBAAuB,UAAU;;EAE3C;;EAEA;;EAEA,QAAQ;;EAER,SAAS;IAAU,OAAO;IAAY;;;EAEtC,MAAM,UAAU;;EAEhB,UAAU,kBAAkB;;KAGlB,kBAAkB;EAC5B,OAAO;;EAEP;;EAEA;;;KAWU,qBAAqB;EAC/B,kBAAkB,iBAAiB,kBAAkB;;;;;;;;;;;;;;KCzE3C,aAAa,UAAU,eAAe,gBAAgB,iBAC5D,KAAK,aAAa,IAAI,OAAO,YAAY,cAAc;EAEvD;EACA,SACE,KAAK,uBAAuB,IAC5B,OAAO,YAAY,cACT;;;;;;;;;;;;;;;;iBAiBF,WAAW,KAAK,GAC9B,SAAS,KAAK,KAAK,OAAO,aAAa;EACpC;EAAkB,SAAS,KAAK,KAAK,OAAO,aAAa;;KAIlD,aAAa,UAAU;;EAEjC;;EAEA,OAAO;;;;;EAKP,aAAa,WAAW,cAAc,aAAa,GAAG;EACtD,QAAQ;EACR,YAAY;EACZ,YAAY;MACR,gBAAgB;EAChB;;;;;;;;;;;;EAYA;;;;;;;KAQM;WACG;WAAwB;;WAExB;WACA;WACA;;WAGA;WACA;WACA;WACA;WACA;;WAGA;WACA;WACA;WACA,QAAQ,SAAS;;KAGpB,kBAAkB,UAAU;;EAEtC,aAAa,WAAW,6BAA6B;;;;;;;;;;;;EAYrD,QAAQ,OAAO;;KAGL;;EAEV;;KAGU,mBAAmB;;EAE7B;;KAGU,gBAAgB;;EAE1B,OAAO;;EAEP;;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-shared-B5tJfzt-.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actor-shared-B5tJfzt-.js","names":["createContract"],"sources":["../src/actor-shared.ts"],"sourcesContent":["/**\n * Internal shared vocabulary of the actor module — the reserved event\n * envelopes, the protocol and context types, the state fold. Not an\n * entry point: the public surfaces are experimental-a2/actor (server),\n * /actor/client, and /actor/react.\n *\n * An actor is a durable mailbox with memory: one session per instance,\n * events processed one at a time (a lane) unless a handler opts out\n * with `concurrent: true`, state materialized as `a2.actor.state`\n * events committed atomically with each handler's completion.\n */\n\nimport { contract as createContract } from './contract.ts'\nimport type { Reducer } from './reducer.ts'\nimport type { ScheduleTiming } from './server.ts'\nimport type { StandardSchemaV1 } from './standard-schema.ts'\n\n/** Event type of a committed state change — one per completed serial handler. */\nexport const ACTOR_STATE_EVENT = 'a2.actor.state'\n/** Event type of a refusal — a handler that answered by throwing NonRetriableError. */\nexport const ACTOR_FAILED_EVENT = 'a2.actor.failed'\n/** The per-instance lane every serial handler shares — the state's write lock. */\nexport const ACTOR_LANE = 'a2.actor'\n/** Reducer identity — bump when the fold's meaning changes. */\nexport const ACTOR_REDUCER_NAME = 'a2.actor.v1'\n\n/**\n * A handler answered by throwing `NonRetriableError`: the event\n * settled, the state did not change. Isomorphic — the server raises it\n * from calls and `fetch()` serializes it as a 409; the client's `call`\n * proxy revives it from that response.\n */\nexport class ActorRefusedError extends Error {\n  /** The refused event's name. */\n  readonly event: string\n  /** The refused event's message id. */\n  readonly messageId: string\n  constructor(event: string, messageId: string, message: string) {\n    super(message)\n    this.name = 'ActorRefusedError'\n    this.event = event\n    this.messageId = messageId\n  }\n}\n\n/**\n * The declaration an actor is defined over: its state shape and its\n * event vocabulary, as types. Core A2 contracts are schemas because\n * the wire is untrusted; actor protocols are types because your\n * server is trusted — same contract-first design language, dialed to\n * the trust level.\n */\nexport type ActorProtocol = {\n  state: object\n  events: object\n  /**\n   * Optional third vocabulary: presence field → value type. Ephemeral\n   * audience state (who is here, cursors), replicated to subscribers\n   * and never stored in the log. Declaring it requires `presence:\n   * true` in the actor options — the wire bit types cannot carry.\n   */\n  presence?: object\n}\n\n/** The protocol's presence vocabulary, `never` when undeclared. */\nexport type ActorPresenceOf<D extends ActorProtocol> = D extends {\n  presence: infer P extends object\n}\n  ? P\n  : never\n\n/** A `setPresence` patch: changed fields, `null` clears one. */\nexport type ActorPresenceValues<P> = {\n  [F in keyof P & string]?: P[F] | null\n}\n\n/**\n * The replicated presence map: participant → field → latest value,\n * last write wins per field. Values are peer-authored — render them\n * like user input.\n */\nexport type ActorPresenceMap<P> = {\n  [participant: string]: {\n    [F in keyof P & string]?: { value: P[F]; seen: number; at: Date }\n  }\n}\n\n/**\n * The typed self-send surface: one method per declared event —\n * `ctx.send.transfer({ ref, amount })`. Buffered, not immediate: every\n * send requested during a handler commits atomically with that\n * handler's completion (a serial handler's state commit, a concurrent\n * handler's settlement), riding core's returned-events semantics — so\n * a reserve-and-trigger can never half-happen, and re-runs converge on\n * the same deterministic message ids.\n */\nexport type ActorSend<E> = {\n  readonly [K in keyof E]: {} extends E[K]\n    ? (input?: E[K]) => void\n    : (input: E[K]) => void\n}\n\n/**\n * Timing for a scheduled event: exactly `{ delay: '5d' }` or\n * `{ at: Date }` (core §6 semantics — relative delays anchor to the\n * triggering message's durable `createdAt`, so re-runs resolve the\n * same due time). `name` overrides the timer's identity — it defaults\n * to the target event name, scoped to the triggering message, so one\n * handler run gets one timer per target event unless named apart.\n */\nexport type ActorScheduleOptions = ScheduleTiming & { name?: string }\n\n/**\n * The typed durable-timer surface: one method per declared event —\n * `ctx.schedule.refund({ ref: ctx.id }, { delay: '1h' })`. Unlike\n * `send`, scheduling is immediate, not buffered: it awaits provider\n * acceptance at call time (a timer is provider-side, not a log row),\n * so a handler that schedules and then refuses has still armed the\n * timer. That is safe by the guarded-delivery idiom — the stale timer\n * fires into an idempotent no-op — but it is the one exception to\n * \"refusals are total\". Requires a configured `scheduler`.\n */\nexport type ActorScheduleSend<E> = {\n  readonly [K in keyof E]: {} extends E[K]\n    ? (input: E[K] | undefined, options: ActorScheduleOptions) => Promise<void>\n    : (input: E[K], options: ActorScheduleOptions) => Promise<void>\n}\n\n/** What a serial handler receives alongside its typed input. */\nexport type ActorContext<D extends ActorProtocol> = {\n  /** Mutable draft, committed atomically with the handler's completion. */\n  state: D['state']\n  /** The message id — stable across re-runs; the idempotency key for external I/O. */\n  id: string\n  /** Durable 1-based dispatch ordinal of this message. */\n  attempt: number\n  /** The ordinary A2 handler signal — fires on claim expiry or supersession. */\n  signal: AbortSignal\n  /** Typed buffered self-send — committed atomically with the state commit. */\n  send: ActorSend<D['events']>\n  /** Typed durable timers — immediate provider handoff, see ActorScheduleSend. */\n  schedule: ActorScheduleSend<D['events']>\n}\n\n/**\n * What a `concurrent: true` handler receives. No draft — concurrent\n * handlers run off the lane, in parallel, so state is a snapshot read\n * (honest about staleness) and mutations happen by sending events\n * whose serial handlers decide against fresh state.\n */\nexport type ActorConcurrentContext<D extends ActorProtocol> = {\n  /** The message id — stable across re-runs; the idempotency key for external I/O. */\n  id: string\n  /** Durable 1-based dispatch ordinal of this message. */\n  attempt: number\n  /** The ordinary A2 handler signal — fires on claim expiry or supersession. */\n  signal: AbortSignal\n  /** Snapshot read — observational; the world moves while this runs. */\n  state(): Promise<{ state: D['state']; index: number }>\n  /** Typed buffered self-send — committed atomically with settlement. */\n  send: ActorSend<D['events']>\n  /** Typed durable timers — immediate provider handoff, see ActorScheduleSend. */\n  schedule: ActorScheduleSend<D['events']>\n}\n\nexport type ActorStatePayload<S> = {\n  state: S\n  /** The event whose handler committed this state. */\n  event: string\n  /** The message (invocation event) id this state answers. */\n  message: string\n}\n\nexport type ActorFailedPayload = {\n  /** The message (invocation event) id this refusal answers. */\n  message: string\n  event: string\n  error: string\n}\n\n/** The event vocabulary a client needs to follow an actor's state. */\nexport type ActorClientEventDefs<S> = {\n  'a2.actor.state': StandardSchemaV1<ActorStatePayload<S>>\n}\n\ntype SchemaResult<T> = StandardSchemaV1.Result<T>\n\nconst issue = <T>(message: string): SchemaResult<T> => ({\n  issues: [{ message }],\n})\n\nconst schema = <T>(\n  label: string,\n  parse: (value: unknown) => SchemaResult<T>,\n): StandardSchemaV1<T> => ({\n  '~standard': {\n    version: 1,\n    vendor: 'a2',\n    validate(value) {\n      try {\n        return parse(value)\n      } catch (error) {\n        return issue(\n          `${label}: ${error instanceof Error ? error.message : String(error)}`,\n        )\n      }\n    },\n  },\n})\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null && !Array.isArray(value)\n\n/** True for plain JSON trees — what the log can store without loss. */\nexport function isJsonTree(\n  value: unknown,\n  seen: Set<object> = new Set(),\n): boolean {\n  if (\n    value === null ||\n    typeof value === 'string' ||\n    typeof value === 'boolean'\n  ) {\n    return true\n  }\n  if (typeof value === 'number') return Number.isFinite(value)\n  if (typeof value !== 'object') return false\n  if (seen.has(value)) return false\n  seen.add(value)\n  const valid = Array.isArray(value)\n    ? value.every((item) => isJsonTree(item, seen))\n    : Object.getPrototypeOf(value) === Object.prototype &&\n      Object.values(value).every(\n        (item) => item === undefined || isJsonTree(item, seen),\n      )\n  seen.delete(value)\n  return valid\n}\n\n/** Per-field ceiling for presence values — presence is a cursor, not a document. */\nexport const PRESENCE_VALUE_MAX_BYTES = 8_192\n\n/**\n * The open presence vocabulary: the '*' catch-all validates any field\n * name against the JSON floor. The protocol types the vocabulary at\n * compile time; the route's `authorize` sees every set before\n * acceptance; renderers treat values as user input. Meaning has three\n * guards — this schema only owns the bytes.\n */\nexport const openPresenceDefs: Readonly<\n  Record<string, StandardSchemaV1<unknown>>\n> = Object.freeze({\n  '*': {\n    '~standard': {\n      version: 1,\n      vendor: 'a2',\n      validate: (value: unknown) => {\n        if (!isJsonTree(value)) {\n          return {\n            issues: [{ message: 'presence values must be plain JSON trees' }],\n          }\n        }\n        if (JSON.stringify(value).length > PRESENCE_VALUE_MAX_BYTES) {\n          return {\n            issues: [\n              {\n                message: `presence values are capped at ${PRESENCE_VALUE_MAX_BYTES} bytes`,\n              },\n            ],\n          }\n        }\n        return { value }\n      },\n    },\n  } satisfies StandardSchemaV1<unknown>,\n})\n\n/**\n * The `a2.actor.state` envelope: provenance plus the state, held to a\n * plain JSON tree (a `Date` or `Map` in state fails loudly at commit,\n * never silently coerces in the log).\n */\nexport function actorStateSchema<S>(): StandardSchemaV1<ActorStatePayload<S>> {\n  return schema(ACTOR_STATE_EVENT, (value) => {\n    if (\n      !isRecord(value) ||\n      typeof value['event'] !== 'string' ||\n      typeof value['message'] !== 'string'\n    ) {\n      return issue(`invalid ${ACTOR_STATE_EVENT} payload`)\n    }\n    const state = value['state']\n    if (!isJsonTree(state)) {\n      return issue('the actor state must be a plain JSON tree')\n    }\n    return {\n      value: {\n        state: state as S,\n        event: value['event'],\n        message: value['message'],\n      },\n    }\n  })\n}\n\nexport const actorFailedSchema: StandardSchemaV1<ActorFailedPayload> = schema(\n  ACTOR_FAILED_EVENT,\n  (value) => {\n    if (\n      !isRecord(value) ||\n      typeof value['message'] !== 'string' ||\n      typeof value['event'] !== 'string' ||\n      typeof value['error'] !== 'string'\n    ) {\n      return issue(`invalid ${ACTOR_FAILED_EVENT} payload`)\n    }\n    return {\n      value: {\n        message: value['message'],\n        event: value['event'],\n        error: value['error'],\n      },\n    }\n  },\n)\n\nexport type ActorReducerOptions<S> = {\n  /** The actor's name — must match the server-side definition. */\n  name: string\n  /** The initial state — a plain JSON tree, the fold's seed. */\n  state: S\n}\n\n/**\n * The library fold over an actor's state commits — last write wins.\n * Pure library code: a browser bundle folds an actor's live state with\n * no user code, so the actor definition itself stays server-only\n * (import the server module's type for typing, this reducer for data).\n */\nexport function actorReducer<S>(\n  options: ActorReducerOptions<S>,\n): Reducer<ActorClientEventDefs<S>, S> {\n  if (!isJsonTree(options.state)) {\n    throw new TypeError(\n      `actor '${options.name}': the initial state must be a plain JSON tree`,\n    )\n  }\n  const events: ActorClientEventDefs<S> = {\n    [ACTOR_STATE_EVENT]: actorStateSchema(),\n  }\n  return createContract({ name: options.name, events })\n    .reducer({ name: ACTOR_REDUCER_NAME, initialState: options.state })\n    .fold((state, event) =>\n      event.type === ACTOR_STATE_EVENT ? event.payload.state : state,\n    )\n}\n"],"mappings":"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"}

package/dist/ai-CrEf6p_W.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-CrEf6p_W.d.ts","names":[],"sources":["../src/ai-control.ts","../src/ai-client-state.ts","../src/ai-projector.ts","../src/ai-progress-batches.ts","../src/ai-message-projection.ts","../src/ai-stored-state.ts","../src/ai.ts"],"mappings":";;;;KAcY,UAAU,UAAU,YAAY;EAC1C;EACA,SAAS;EACT;EACA;;KAGU,eAAe,UAAU,YAAY;EAC3C;EAAgB,SAAS;EAAG;;EAC5B;EAAgB,SAAS;;EACzB;EAAgB;EAAiB;;EACjC;EAAkB;;EAElB;EACA;EACA;EACA;;EAEA;EAAgB;EAAgB;;EAChC;EAAiB;EAAgB,SAAS;EAAG;;EAC7C;EAAiB;;EACjB;;EACA;EAAuB,QAAQ;;EAC/B;EAAoB,UAAU;;EAC9B;EAAiB,UAAU;;EAC3B;EAAyB,SAAS;;EAClC;EAAiB,SAAS;;EAC1B;EAAqB,SAAS;;KAExB;EACV;EACA;EACA;EACA;;KAUU,WAAW,UAAU,YAAY;EAC3C;EACA,OAAO,UAAU;EACjB;;KA+BU;EAAa;EAAc;EAAY;;KACvC;EACV;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;;KAGE;EACV;EACA;EACA,MAAM;EACN,YAAY;;KAYF;EACV;EACA;EACA;EACA;IAAW;IAAe;IAAqB;;EAC/C;IAAS;IAAc;;;KAGb;EACV,SAAS;EACT;IACE;IACA;IACA,OAAO;IACP;IACA;IACA;IACA,eAAe;IACf;IACA;;;;;KCpIQ,aAAa,UAAU,aAAa,QAC9C,eAAe;EAEb;;KAYQ,oBAAoB,UAAU;EACxC;EACA,SAAS,aAAa;;;;KCjBnB;EACH;EACA;EACA;EACA;EACA;EACA;EACA;;KAmHU;EACV,MAAM;EACN,WAAW;EACX,OAAO,eAAe;;;;KChIZ;EAAkB;EAAe,QAAQ;;KAChD,aAAa;EAAoB,MAAM;EAAY,OAAO;;KAEnD;EACV;EACA,MAAM;EACN,QAAQ,MAAM;;;;KCcJ,kBAAkB,UAAU,aAAa,KACnD,2BAA2B;;;KChBxB,2CACgC;GAA2B,cAAA;;KAC3D;EAAY;;KACZ;EACC,OAAO;;EACP;EAAgB,OAAO,eAAe;;EACtC,QAAQ,eAAe;EAAO;;KAE/B;EACH,QAAQ;EACR;EACA,UAAU;EACV,QAAQ;;KAGE;EACV;EACA,QAAQ;EACR,YAAY;EACZ,QAAQ;;KAGE;EACV,UAAU;EACV,mBACG,kBAAkB;IAAe,YAAY;;EAChD,QAAQ;EACR,QAAQ;;cAGG;KAED,gBACV,UAAU,WACV,UAAU,gBACR,QAAQ,GAAG,eAAe,sBAAsB;YACxC,iBAAiB,QAAQ,GAAG;EACtC,KAAK,OAAO,gBAAgB;EAC5B,SAAS,OAAO,IAAI;;;;KC6BV;KAGA;KAEA;EAA0B,WAAW;;KACrC;EAAyB;;KACzB,sBAAsB,UAAU;EAC1C,SAAS;;EAET;;KAEU;EAA4B;;KACnC;EACH;EACA;;EAEA;;KAEU,4BAA4B;EAEhC;EAAsB;;EACtB;EAAmB;;KAEf;EACV;IAAY;IAAgB;;EAC5B;EACA,QAAQ;EACR;EACA;;KAEU;EACV;EACA;EACA;;KAEU,wBAAwB;KACxB;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA,QAAQ;;KAEE;EACV;EACA;EACA;EACA;EACA,eAAe;EACf,QAAQ;EACR;;KAEU;EACV;EACA;EACA;EACA;EACA;;EAEA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA;;KAEU;EACV;EACA;EACA;EACA;EACA;EACA,WAAW;;KAED;EACV;EACA;EACA;EACA;EACA;EACA,OAAO;;KAEG;EACV;EACA;;KAEU;EAAkC;;KAClC;EACV;EACA,QAAQ;;KAEE;EACN;;EACA;EAAoB,QAAQ;;EAC5B;;KAEM;EACV;EACA;EACA;EACA;EACA;EACA;;KAEU,2BAA2B,UAAU;EAC/C;EACA;EACA;EACA,UAAU;EACV;EACA;EACA,QAAQ;;KAGE,YAAY,UAAU,cAAY;EAC5C,wBAAwB,iBAAiB,eAAe;EACxD,wBAAwB,iBAAiB;EACzC,sBAAsB,iBAAiB;EACvC,oBAAoB,iBAAiB;EACrC,+BAA+B,iBAAiB;EAChD,wBAAwB;IACtB;IACA;;EAEF,sBAAsB,i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"}