pantheon-opencode 1.5.0-beta.2 → 1.5.0-beta.3

package/src/pantheon/compaction-handoff.ts

@@ -0,0 +1,304 @@
+/**
+ * Compaction handoff coordinator.
+ *
+ * Coordinates the handoff of a compaction checkpoint from in-memory state to
+ * durable persistence. The coordinator is deliberately dependency-free: it
+ * does not import plugin, board, MCP, hooks, or provider modules.
+ */
+
+export interface HandoffRecord {
+  digest: string
+  payload: string
+  version: number
+  sessionId: string
+  leaseToken: string
+}
+
+export interface PersistencePort {
+  prepare(input: HandoffRecord): Promise<void>
+  read(sessionId: string, key: string): Promise<HandoffRecord | null>
+  commit(sessionId: string, key: string, record: HandoffRecord): Promise<void>
+}
+
+export interface MemoryPort {
+  publishImmutable(sessionId: string, key: string, record: HandoffRecord): Promise<void>
+  readByIdempotencyKey(key: string): Promise<HandoffRecord | null>
+}
+
+export type HandoffStatus =
+  | 'COMMITTED'
+  | 'UNAVAILABLE'
+  | 'CONFLICT'
+  | 'NOT_SUPPORTED'
+  | 'INVALID_INPUT'
+
+/** Maximum allowed integer version value. */
+export const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER
+
+/** Maximum encoded payload size in bytes (128 KiB). */
+export const MAX_PAYLOAD_BYTES = 65_536
+
+/** Maximum length of URL-safe identifiers. */
+export const MAX_ID_LENGTH = 128
+
+const URL_SAFE_PATTERN = /^[A-Za-z0-9._~-]+$/
+const DIGEST_PATTERN = /^[a-f0-9]{64}$/
+
+/** Validate a URL-safe identifier: 1-128 chars, no control characters. */
+function isValidIdentifier(value: unknown): value is string {
+  if (typeof value !== 'string') {
+    return false
+  }
+  if (value.length < 1 || value.length > MAX_ID_LENGTH) {
+    return false
+  }
+  if (value.length > 0 && !URL_SAFE_PATTERN.test(value)) {
+    return false
+  }
+  return true
+}
+
+/** Validate a lease token: 1-128 chars, no control characters. */
+function isValidLeaseToken(value: unknown): value is string {
+  if (typeof value !== 'string') {
+    return false
+  }
+  if (value.length < 1 || value.length > MAX_ID_LENGTH) {
+    return false
+  }
+  for (const char of value) {
+    const code = char.charCodeAt(0)
+    if (code < 0x20 || code === 0x7f) {
+      return false
+    }
+  }
+  return true
+}
+
+/** Validate a positive integer version within the safe integer range. */
+function isValidVersion(value: unknown): value is number {
+  return (
+    typeof value === 'number' && Number.isInteger(value) && value > 0 && value <= MAX_SAFE_INTEGER
+  )
+}
+
+/** Validate a 64-character lowercase hex digest. */
+function isValidDigest(value: unknown): value is string {
+  return typeof value === 'string' && DIGEST_PATTERN.test(value)
+}
+
+/**
+ * Validate that a payload is UTF-8 encodable and contains no NUL or control
+ * characters (tab, LF, and CR are permitted).
+ */
+function isValidPayload(value: unknown): value is string {
+  if (typeof value !== 'string') {
+    return false
+  }
+  if (value.length < 1 || value.length > MAX_PAYLOAD_BYTES) {
+    return false
+  }
+
+  const bytes = Buffer.byteLength(value, 'utf8')
+  if (bytes < 1 || bytes > MAX_PAYLOAD_BYTES) {
+    return false
+  }
+  if (value.includes('\0')) {
+    return false
+  }
+
+  for (const char of value) {
+    const code = char.charCodeAt(0)
+    if (code < 0x20 && code !== 0x09 && code !== 0x0a && code !== 0x0d) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * Compute the digest over the exact UTF-8 encoded bytes of a payload.
+ */
+export function computeDigest(payload: string): string {
+  const bytes = Buffer.from(payload, 'utf8')
+  let hash = ''
+  for (const byte of bytes) {
+    hash += byte.toString(16).padStart(2, '0')
+  }
+  return hash
+}
+
+/** Create a result describing a failed validation. */
+function invalid(message: string): { status: 'INVALID_INPUT'; message: string } {
+  return { status: 'INVALID_INPUT', message }
+}
+
+/** Create a result describing a missing dependency. */
+function notSupported(): { status: 'NOT_SUPPORTED' } {
+  return { status: 'NOT_SUPPORTED' }
+}
+
+/** Create a result describing a conflict. */
+function conflict(message: string): { status: 'CONFLICT'; message: string } {
+  return { status: 'CONFLICT', message }
+}
+
+/** Create a result describing an unavailable memory port. */
+function unavailable(message: string): { status: 'UNAVAILABLE'; message: string } {
+  return { status: 'UNAVAILABLE', message }
+}
+
+/** Create a successful committed result. */
+function committed(digest: string): { status: 'COMMITTED'; digest: string } {
+  return { status: 'COMMITTED', digest }
+}
+
+/**
+ * Compaction handoff coordinator.
+ *
+ * The coordinator drives the handoff FSM:
+ *
+ *   no record -> prepare -> PREPARED -> memory.publishImmutable
+ *   -> memory.readByIdempotencyKey -> persistence.commit -> COMMITTED
+ *
+ * It never retries after memory becomes unavailable; the PREPARED state is
+ * left intact for a later explicit attempt.
+ */
+export class CompactionHandoffCoordinator {
+  private readonly persistence: PersistencePort | undefined
+  private readonly memory: MemoryPort | undefined
+
+  constructor(persistence?: PersistencePort, memory?: MemoryPort) {
+    this.persistence = persistence
+    this.memory = memory
+  }
+
+  /**
+   * Attempt to hand off a compaction checkpoint.
+   *
+   * Returns immediately with INVALID_INPUT if any argument fails validation.
+   * Returns NOT_SUPPORTED if either required port is missing.
+   * Returns CONFLICT for digest or lease/version mismatches.
+   * Returns UNAVAILABLE if the memory port cannot publish/read the record.
+   * Returns COMMITTED when the record is durably committed.
+   */
+  async prepare(
+    sessionId: string,
+    idempotencyKey: string,
+    leaseToken: string,
+    version: number,
+    digest: string,
+    payload: string,
+  ): Promise<{ status: HandoffStatus; key?: string; digest?: string; message?: string }> {
+    // Validation first: no port calls are made before this block completes.
+    if (
+      !isValidIdentifier(sessionId) ||
+      !isValidIdentifier(idempotencyKey) ||
+      !isValidLeaseToken(leaseToken) ||
+      !isValidVersion(version) ||
+      !isValidDigest(digest) ||
+      !isValidPayload(payload)
+    ) {
+      return invalid('Invalid handoff input')
+    }
+
+    if (this.persistence === undefined || this.memory === undefined) {
+      return notSupported()
+    }
+
+    const _key = `${sessionId}:${idempotencyKey}`
+
+    // Check for an existing committed record before preparing a new one.
+    const existingRecord = await this.persistence.read(sessionId, idempotencyKey)
+    if (existingRecord !== null) {
+      if (existingRecord.digest === digest && existingRecord.sessionId === sessionId) {
+        // Idempotent replay: same digest and session. Verify lease/version match.
+        if (existingRecord.leaseToken !== leaseToken || existingRecord.version !== version) {
+          return conflict('Stale lease or version')
+        }
+
+        // Verify the record is also in memory. If missing, try to recover by publishing once.
+        let memoryRecord: HandoffRecord | null = null
+        try {
+          memoryRecord = await this.memory.readByIdempotencyKey(idempotencyKey)
+        } catch {
+          return unavailable('Memory port unavailable')
+        }
+
+        if (memoryRecord === null) {
+          // Recovery: memory lost the record but persistence has it. Publish once.
+          try {
+            await this.memory.publishImmutable(sessionId, idempotencyKey, existingRecord)
+          } catch (_error) {
+            return unavailable('Memory port unavailable')
+          }
+          try {
+            memoryRecord = await this.memory.readByIdempotencyKey(idempotencyKey)
+          } catch (_error) {
+            return unavailable('Memory port unavailable')
+          }
+        }
+
+        if (memoryRecord === null) {
+          return unavailable('Record not found in memory')
+        }
+
+        await this.persistence.commit(sessionId, idempotencyKey, existingRecord)
+        return committed(memoryRecord.digest)
+      }
+      // Different digest or session: conflict.
+      return conflict('Digest or session mismatch')
+    }
+
+    // Phase 1: prepare in persistence (PREPARED).
+    await this.persistence.prepare({ digest, payload, version, sessionId, leaseToken })
+
+    // Phase 2: publish the record to memory. If memory is unavailable, the
+    // coordinator stays in PREPARED and never retries automatically.
+    try {
+      await this.memory.publishImmutable(sessionId, idempotencyKey, {
+        digest,
+        payload,
+        version,
+        sessionId,
+        leaseToken,
+      })
+    } catch (_error) {
+      return unavailable('Memory port unavailable')
+    }
+
+    // Phase 3: read back from memory by idempotency key.
+    let memoryRecord: HandoffRecord | null = null
+    try {
+      memoryRecord = await this.memory.readByIdempotencyKey(idempotencyKey)
+    } catch (_error) {
+      return unavailable('Memory port unavailable')
+    }
+
+    if (memoryRecord === null) {
+      return unavailable('Record not found in memory')
+    }
+
+    // Stale lease or version check.
+    if (memoryRecord.leaseToken !== leaseToken || memoryRecord.version !== version) {
+      return conflict('Stale lease or version')
+    }
+
+    // Idempotent replay: same key and session is a success.
+    // The memory record is authoritative for recovery after crash.
+    if (memoryRecord.sessionId === sessionId) {
+      // Phase 4: commit to persistence.
+      try {
+        await this.persistence.commit(sessionId, idempotencyKey, memoryRecord)
+      } catch (_error) {
+        return conflict('Persistence commit failed')
+      }
+      return committed(memoryRecord.digest)
+    }
+
+    // Same key, different digest or session: conflict.
+    return conflict('Digest or session mismatch')
+  }
+}
+
+export default CompactionHandoffCoordinator

package/src/pantheon/provider-capabilities.ts

@@ -0,0 +1,221 @@
+/**
+ * Exact provider usage contract and the independent V1/V2 capability probes.
+ *
+ * This module deliberately does not inspect credentials, call a provider, read
+ * the TUI, calculate percentages, or derive token counts from text. A provider
+ * is supported only when it supplies the complete numeric contract below.
+ *
+ * @module provider-capabilities
+ */
+
+/** The only capability statuses exposed by the usage contract. */
+export const USAGE_STATUS = {
+  SUPPORTED: 'SUPPORTED',
+  UNSUPPORTED: 'UNSUPPORTED',
+} as const
+
+export type UsageStatus = (typeof USAGE_STATUS)[keyof typeof USAGE_STATUS]
+
+/** Exact token counters supplied by the provider. No totals are inferred. */
+export interface ExactProviderUsage {
+  inputTokens: number
+  outputTokens: number
+}
+
+/** Exact context limit supplied by the provider. */
+export interface ExactProviderLimit {
+  contextTokens: number
+}
+
+/**
+ * Minimum complete provider payload accepted by either capability probe.
+ * `resetAt`, when present, is an exact non-negative numeric provider value;
+ * date strings and other reset representations are unsupported.
+ */
+export interface ExactProviderUsageData {
+  sessionId: string
+  providerId: string
+  modelId: string
+  usage: ExactProviderUsage
+  limit: ExactProviderLimit
+  resetAt?: number
+}
+
+/** Stream event metadata required for de-duplication and freshness ordering. */
+export interface ProviderUsageEvent extends ExactProviderUsageData {
+  eventId: string
+  partId: string
+  /** Optional provider sequence. When supplied, it must be an integer. */
+  sequence?: number
+  /** Optional provider observation time in milliseconds or another numeric scale. */
+  observedAt?: number
+}
+
+/** A complete snapshot that has passed the exact contract validation. */
+export interface ProviderUsageSnapshot extends ProviderUsageEvent {}
+
+export type CapabilityProbeVersion = 'v1' | 'v2'
+
+export type CapabilityProbeReason =
+  | 'MISSING_SESSION_ID'
+  | 'MISSING_PROVIDER_ID'
+  | 'MISSING_MODEL_ID'
+  | 'MISSING_USAGE'
+  | 'MISSING_LIMIT'
+  | 'INVALID_USAGE'
+  | 'INVALID_LIMIT'
+  | 'INVALID_RESET'
+
+export type ProviderCapabilityResult =
+  | {
+      apiVersion: CapabilityProbeVersion
+      status: typeof USAGE_STATUS.SUPPORTED
+      data: ExactProviderUsageData
+    }
+  | {
+      apiVersion: CapabilityProbeVersion
+      status: typeof USAGE_STATUS.UNSUPPORTED
+      reason: CapabilityProbeReason
+    }
+
+type UnknownRecord = Record<string, unknown>
+
+function isRecord(value: unknown): value is UnknownRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0
+}
+
+function isFiniteNonNegativeNumber(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0
+}
+
+function hasOnlyKeys(value: UnknownRecord, allowed: readonly string[]): boolean {
+  return Object.keys(value).every((key) => allowed.includes(key))
+}
+
+function unsupported(
+  apiVersion: CapabilityProbeVersion,
+  reason: CapabilityProbeReason,
+): ProviderCapabilityResult {
+  return { apiVersion, status: USAGE_STATUS.UNSUPPORTED, reason }
+}
+
+/**
+ * Validate the complete exact payload without coercion or estimation.
+ *
+ * This is intentionally shared only as a validator. V1 and V2 entry points
+ * below remain separate capability probes and do not fall back to one another.
+ */
+function probeExactData(
+  apiVersion: CapabilityProbeVersion,
+  input: unknown,
+): ProviderCapabilityResult {
+  if (!isRecord(input)) return unsupported(apiVersion, 'MISSING_SESSION_ID')
+
+  if (!isNonEmptyString(input.sessionId)) {
+    return unsupported(apiVersion, 'MISSING_SESSION_ID')
+  }
+  if (!isNonEmptyString(input.providerId)) {
+    return unsupported(apiVersion, 'MISSING_PROVIDER_ID')
+  }
+  if (!isNonEmptyString(input.modelId)) {
+    return unsupported(apiVersion, 'MISSING_MODEL_ID')
+  }
+  if (!isRecord(input.usage)) return unsupported(apiVersion, 'MISSING_USAGE')
+  if (!isRecord(input.limit)) return unsupported(apiVersion, 'MISSING_LIMIT')
+  if (!hasOnlyKeys(input.usage, ['inputTokens', 'outputTokens'])) {
+    return unsupported(apiVersion, 'INVALID_USAGE')
+  }
+  if (!hasOnlyKeys(input.limit, ['contextTokens'])) {
+    return unsupported(apiVersion, 'INVALID_LIMIT')
+  }
+
+  const usage = input.usage
+  if (!isFiniteNonNegativeNumber(usage.inputTokens)) {
+    return unsupported(apiVersion, 'INVALID_USAGE')
+  }
+  if (!isFiniteNonNegativeNumber(usage.outputTokens)) {
+    return unsupported(apiVersion, 'INVALID_USAGE')
+  }
+
+  const limit = input.limit
+  if (!isFiniteNonNegativeNumber(limit.contextTokens)) {
+    return unsupported(apiVersion, 'INVALID_LIMIT')
+  }
+
+  let resetAt: number | undefined
+  if ('reset' in input) return unsupported(apiVersion, 'INVALID_RESET')
+  if ('resetAt' in input) {
+    const value = input.resetAt
+    if (!isFiniteNonNegativeNumber(value)) return unsupported(apiVersion, 'INVALID_RESET')
+    resetAt = value
+  }
+
+  const data: ExactProviderUsageData = {
+    sessionId: input.sessionId,
+    providerId: input.providerId,
+    modelId: input.modelId,
+    usage: {
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+    },
+    limit: { contextTokens: limit.contextTokens },
+  }
+  if (resetAt !== undefined) data.resetAt = resetAt
+
+  return { apiVersion, status: USAGE_STATUS.SUPPORTED, data }
+}
+
+/**
+ * Probe the V1 exact payload shape supplied by a caller.
+ *
+ * V1 does not inherit V2 capability, credentials, cache, or lifecycle data.
+ * The caller must pass the exact payload after its host-specific extraction.
+ */
+export function probeV1Capability(input: unknown): ProviderCapabilityResult {
+  return probeExactData('v1', input)
+}
+
+/**
+ * Probe the V2 exact payload shape supplied by a caller.
+ *
+ * V2 is intentionally independent from V1: no V1 event, retry, cache, or
+ * fallback value is consulted when the exact payload is absent.
+ */
+export function probeV2Capability(input: unknown): ProviderCapabilityResult {
+  return probeExactData('v2', input)
+}
+
+/** Validate one complete stream event using the same exact data contract. */
+export function validateProviderUsageEvent(input: unknown): ProviderUsageEvent | null {
+  if (!isRecord(input)) return null
+  if (!isNonEmptyString(input.eventId) || !isNonEmptyString(input.partId)) return null
+
+  const data = probeExactData('v1', input)
+  if (data.status !== USAGE_STATUS.SUPPORTED) return null
+
+  let sequence: number | undefined
+  if ('sequence' in input) {
+    const value = input.sequence
+    if (!isFiniteNonNegativeNumber(value) || !Number.isInteger(value)) return null
+    sequence = value
+  }
+  let observedAt: number | undefined
+  if ('observedAt' in input) {
+    const value = input.observedAt
+    if (!isFiniteNonNegativeNumber(value)) return null
+    observedAt = value
+  }
+
+  const event: ProviderUsageEvent = {
+    ...data.data,
+    eventId: input.eventId,
+    partId: input.partId,
+  }
+  if (sequence !== undefined) event.sequence = sequence
+  if (observedAt !== undefined) event.observedAt = observedAt
+  return event
+}

package/src/pantheon/provider-stream-tracker.ts

@@ -0,0 +1,182 @@
+/**
+ * Pure provider stream usage tracker.
+ *
+ * The tracker stores only complete exact provider snapshots. It has no timers,
+ * polling, persistence, TUI dependency, provider client, credential fallback,
+ * token/cost estimation, or compaction/FSM integration.
+ *
+ * @module provider-stream-tracker
+ */
+
+import {
+  type ProviderUsageEvent,
+  type ProviderUsageSnapshot,
+  USAGE_STATUS,
+  type UsageStatus,
+  validateProviderUsageEvent,
+} from './provider-capabilities.ts'
+
+export type TrackerUpdateReason = 'PUBLISHED' | 'DUPLICATE' | 'STALE' | 'OUT_OF_SCOPE' | 'INVALID'
+
+export interface ProviderStreamTrackerOptions {
+  /** Optional exact stream scope. Events from another stream are unsupported. */
+  sessionId?: string
+  providerId?: string
+  modelId?: string
+  /** Injectable sink called only after a complete snapshot is stored. */
+  onSnapshot?: (snapshot: ProviderUsageSnapshot) => void
+}
+
+export interface ProviderStreamTrackerResult {
+  status: UsageStatus
+  published: boolean
+  reason: TrackerUpdateReason
+  snapshot?: ProviderUsageSnapshot
+}
+
+export interface ProviderStreamTracker {
+  /** Ingest one raw event without coercion or heuristic recovery. */
+  ingest(input: unknown): ProviderStreamTrackerResult
+  /** Read one complete snapshot for an isolated session/provider/model stream. */
+  getSnapshot(
+    sessionId: string,
+    providerId: string,
+    modelId: string,
+  ): ProviderUsageSnapshot | undefined
+  /** Read all complete snapshots, each isolated by stream identity. */
+  snapshots(): ProviderUsageSnapshot[]
+  /** Remove all in-memory stream state. */
+  clear(): void
+}
+
+interface StreamState {
+  snapshot: ProviderUsageSnapshot
+  eventIds: Set<string>
+  partIds: Set<string>
+  orderKind?: 'sequence' | 'observedAt'
+  orderValue?: number
+}
+
+function streamKey(sessionId: string, providerId: string, modelId: string): string {
+  return JSON.stringify([sessionId, providerId, modelId])
+}
+
+function copySnapshot(snapshot: ProviderUsageSnapshot): ProviderUsageSnapshot {
+  const copy: ProviderUsageSnapshot = {
+    eventId: snapshot.eventId,
+    partId: snapshot.partId,
+    sessionId: snapshot.sessionId,
+    providerId: snapshot.providerId,
+    modelId: snapshot.modelId,
+    usage: { ...snapshot.usage },
+    limit: { ...snapshot.limit },
+  }
+  if (snapshot.resetAt !== undefined) copy.resetAt = snapshot.resetAt
+  if (snapshot.sequence !== undefined) copy.sequence = snapshot.sequence
+  if (snapshot.observedAt !== undefined) copy.observedAt = snapshot.observedAt
+  return copy
+}
+
+function result(
+  status: UsageStatus,
+  reason: TrackerUpdateReason,
+  snapshot?: ProviderUsageSnapshot,
+): ProviderStreamTrackerResult {
+  return snapshot === undefined
+    ? { status, published: false, reason }
+    : { status, published: true, reason, snapshot: copySnapshot(snapshot) }
+}
+
+function isInScope(event: ProviderUsageEvent, options: ProviderStreamTrackerOptions): boolean {
+  return (
+    (options.sessionId === undefined || options.sessionId === event.sessionId) &&
+    (options.providerId === undefined || options.providerId === event.providerId) &&
+    (options.modelId === undefined || options.modelId === event.modelId)
+  )
+}
+
+function isStale(event: ProviderUsageEvent, state: StreamState): boolean {
+  if (event.sequence !== undefined) {
+    if (state.orderKind === 'sequence' && state.orderValue !== undefined) {
+      return event.sequence <= state.orderValue
+    }
+    return false
+  }
+
+  if (event.observedAt !== undefined) {
+    if (state.orderKind === 'observedAt' && state.orderValue !== undefined) {
+      return event.observedAt <= state.orderValue
+    }
+    return state.orderKind === 'sequence'
+  }
+
+  return state.orderKind !== undefined
+}
+
+function updateOrder(event: ProviderUsageEvent, state: StreamState): void {
+  if (event.sequence !== undefined) {
+    state.orderKind = 'sequence'
+    state.orderValue = event.sequence
+  } else if (event.observedAt !== undefined) {
+    state.orderKind = 'observedAt'
+    state.orderValue = event.observedAt
+  }
+}
+
+/**
+ * Create an in-memory tracker. With no scope options, multiple streams are
+ * tracked independently by their session/provider/model identity.
+ */
+export function createProviderStreamTracker(
+  options: ProviderStreamTrackerOptions = {},
+): ProviderStreamTracker {
+  const streams = new Map<string, StreamState>()
+
+  return {
+    ingest(input: unknown): ProviderStreamTrackerResult {
+      const event = validateProviderUsageEvent(input)
+      if (event === null) return result(USAGE_STATUS.UNSUPPORTED, 'INVALID')
+      if (!isInScope(event, options)) return result(USAGE_STATUS.UNSUPPORTED, 'OUT_OF_SCOPE')
+
+      const key = streamKey(event.sessionId, event.providerId, event.modelId)
+      const state = streams.get(key)
+      if (state?.eventIds.has(event.eventId) || state?.partIds.has(event.partId)) {
+        return result(USAGE_STATUS.SUPPORTED, 'DUPLICATE')
+      }
+
+      if (state !== undefined && isStale(event, state)) {
+        state.eventIds.add(event.eventId)
+        state.partIds.add(event.partId)
+        return result(USAGE_STATUS.SUPPORTED, 'STALE')
+      }
+
+      const nextState: StreamState = state ?? {
+        snapshot: event,
+        eventIds: new Set<string>(),
+        partIds: new Set<string>(),
+      }
+      nextState.snapshot = event
+      nextState.eventIds.add(event.eventId)
+      nextState.partIds.add(event.partId)
+      updateOrder(event, nextState)
+      streams.set(key, nextState)
+
+      const snapshot = copySnapshot(event)
+      options.onSnapshot?.(snapshot)
+      return result(USAGE_STATUS.SUPPORTED, 'PUBLISHED', snapshot)
+    },
+
+    getSnapshot(sessionId: string, providerId: string, modelId: string) {
+      const state = streams.get(streamKey(sessionId, providerId, modelId))
+      return state === undefined ? undefined : copySnapshot(state.snapshot)
+    },
+
+    snapshots() {
+      return [...streams.values()].map((state) => copySnapshot(state.snapshot))
+    },
+
+    clear() {
+      streams.clear()
+    },
+  }
+}