Transcript event bytes

Design; broadcast message slice implemented. Preserve the transcript owner's canonical JSON and carry encoded payloads through readers and transports. Decode only for consumers that need message fields. This complements conversation transcript ownership: one writer remains authoritative, independent of how its events are transported.

Current allocations

These locations identify the current ownership boundaries, rather than implying that every event visits every path. Line numbers refer to the implementation at this proposal's introduction.

Representation and lifecycle

Ingestion owns normalization and validation of external input. After normalization, encode the canonical event once, preserving property order, text, and existing storage semantics. Keep a small record with session identity, sequence, parent, kind, encoded JSON, and byte length. This is a process representation, not a new schema or persistent format. SQLite's existing JSON/compressed payload columns remain authoritative. Existing compression still requires output allocation.

The committed receipt publishes the encoded event plus the fields its consumers actually need. Actor replicas retain the same immutable encoding, bounded by existing event/byte limits and actor generation. Append receipts advance that version; rewrite/reset replace affected entries; actor retirement releases them. There is no independent cache, freshness probe, or second transcript authority. A consumer that edits replay/context data materializes its own object at that editing boundary. Do not eagerly build both object and byte graphs for forwarding.

Across worker boundaries, transfer a dedicated ArrayBuffer when the sender gives up ownership. A transfer detaches the sender's buffer: do not transfer the actor's retained buffer or a pooled Buffer backing store. Concurrent retention/fanout needs an explicit read-only shared representation or one transport-owned copy; avoid claiming that transfer alone makes multi-reader distribution zero-copy. Lane 1062 owns that contract. SQLite/native transport, compression, WebSocket framing and the kernel can still copy bytes.

Authorize each history page or subscriber using current owner-held facts before sending. Encoded content never certifies disclosure authority. Encode the common message once, then combine it with the audience's projected metadata. A complete frame can be shared only when audience, sequence and recipient stamps match. Ancestor receipts and backpressure settlement remain connection-owned.

First slice and remaining work

The transcript publisher certifies ownership of the message graph for synchronous fanout. Its recipient projection lazily encodes the message field into UTF-8 once for that session.message publication. Broadcast omits that object from its fresh envelope and inserts the encoded field while assembling a text WebSocket frame. This removes the recursive stringify replacer, long-string map, and per-recipient traversal/escaping of message contents. Ordinary broadcasts and custom projections retain their ordinary JSON semantics, including getters, mutations between recipients, and toJSON. The encoding expires with the publication, so there is no invalidation policy to maintain.

This slice still encodes the message independently of SQLite and copies bytes into each distinct recipient frame. Next, carry the committed encoding to this boundary and to replicas, then migrate history forwarding with lane 1062. Keep provider-copy work (1061) and immutable-data admission (1065) separate; their files are outside this slice. No schema change is required.

Measure sampled allocated bytes including collected objects, GC time, event counts, and main-thread CPU on identical synthetic fixtures. Report sampling noise and native Buffer allocation limits; lower retained heap alone is not allocation proof. Tests cover recipient isolation, Unicode escaping, text frames, sequence numbers, serialization failures and transport retirement.