@yefengr/remote-pi 0.7.0

package/dist/protocol/codec.js

@@ -0,0 +1,49 @@
+const SERVER_TYPES = new Set([
+    "pair_ok",
+    "pair_error",
+    "user_input",
+    "queued_message_state",
+    "agent_chunk",
+    "agent_done",
+    "agent_message",
+    "tool_request",
+    "tool_result",
+    "error",
+    "cancelled",
+    "pong",
+    "bye",
+    "session_history",
+    // Plan/57 — interactive extension prompt (ask_user via pi-ask).
+    "extension_ui_request",
+]);
+export class DecodeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "DecodeError";
+    }
+}
+export function encodeClient(msg) {
+    return JSON.stringify(msg) + "\n";
+}
+export function decodeServer(line) {
+    let obj;
+    try {
+        obj = JSON.parse(line.trim());
+    }
+    catch (e) {
+        throw new DecodeError("invalid_message", `not JSON: ${e.message}`);
+    }
+    if (!obj ||
+        typeof obj !== "object" ||
+        typeof obj.type !== "string") {
+        throw new DecodeError("invalid_message", "missing 'type'");
+    }
+    const t = obj.type;
+    if (!SERVER_TYPES.has(t)) {
+        throw new DecodeError("unsupported_type", `unknown type: ${t}`);
+    }
+    return obj;
+}
+//# sourceMappingURL=codec.js.map

package/dist/protocol/codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.js","sourceRoot":"","sources":["../../src/protocol/codec.ts"],"names":[],"mappings":"AAEA,MAAM,YAAY,GAAG,IAAI,GAAG,CAAwB;IAClD,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,sBAAsB;IACtB,aAAa;IACb,YAAY;IACZ,eAAe;IACf,cAAc;IACd,aAAa;IACb,OAAO;IACP,WAAW;IACX,MAAM;IACN,KAAK;IACL,iBAAiB;IACjB,gEAAgE;IAChE,sBAAsB;CACvB,CAAC,CAAC;AAEH,MAAM,OAAO,WAAY,SAAQ,KAAK;IAElB;IADlB,YACkB,IAA4C,EAC5D,OAAe;QAEf,KAAK,CAAC,OAAO,CAAC,CAAC;QAHC,SAAI,GAAJ,IAAI,CAAwC;QAI5D,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;IAC5B,CAAC;CACF;AAED,MAAM,UAAU,YAAY,CAAC,GAAkB;IAC7C,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,IAAI,GAAY,CAAC;IACjB,IAAI,CAAC;QACH,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAChC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,IAAI,WAAW,CAAC,iBAAiB,EAAE,aAAc,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC;IAChF,CAAC;IACD,IACE,CAAC,GAAG;QACJ,OAAO,GAAG,KAAK,QAAQ;QACvB,OAAQ,GAA+B,CAAC,IAAI,KAAK,QAAQ,EACzD,CAAC;QACD,MAAM,IAAI,WAAW,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,CAAC;IAC7D,CAAC;IACD,MAAM,CAAC,GAAI,GAA+B,CAAC,IAAc,CAAC;IAC1D,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAA0B,CAAC,EAAE,CAAC;QAClD,MAAM,IAAI,WAAW,CAAC,kBAAkB,EAAE,iBAAiB,CAAC,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,GAAoB,CAAC;AAC9B,CAAC"}

package/dist/protocol/types.d.ts

@@ -0,0 +1,393 @@
+export type PairErrorCode = "token_expired" | "token_consumed" | "token_unknown" | "internal_error";
+export type StreamingBehavior = "steer";
+export type QueuedMessageItem = {
+    id: string;
+    text: string;
+    editable: boolean;
+    created_at: number;
+};
+export type ExtensionUiMethod = "select" | "confirm" | "input" | "editor" | "notify";
+export type AskQuestionWireType = "single" | "multi" | "preview";
+export interface AskOptionWire {
+    value: string;
+    label: string;
+    description?: string;
+    /** Preview-pane content (preview questions only). */
+    preview?: string;
+    /** pi-ask addition: option allows freeform custom entry. */
+    freeform?: boolean;
+}
+export interface AskQuestionWire {
+    id: string;
+    label: string;
+    prompt: string;
+    type: AskQuestionWireType;
+    required: boolean;
+    /** pi-ask addition: type actually presented after live toggle / policy. */
+    presentedType?: AskQuestionWireType;
+    /** pi-ask addition: type originally requested by the model. */
+    requestedType?: AskQuestionWireType;
+    options: AskOptionWire[];
+}
+/** Optional pi-ask enrichment on an extension_ui_request — lets the app render
+ *  the full flow (multi/preview/notes) instead of the degraded SDK select. A
+ *  flow maps to ONE request carrying every question; the app renders a
+ *  full-screen modal and submits ONE response with all answers (pi-ask resolves
+ *  a flow in a single submit). When `ask` is absent the SDK method/options
+ *  drive rendering (future generic prompts). */
+export interface AskEnrichmentWire {
+    flow_id: string;
+    tool_call_id: string | null;
+    /** pi-ask RemoteAskSource: "tool" | "answer" | "answer:again" | "ask:replay". */
+    source: string;
+    title: string | null;
+    questions: AskQuestionWire[];
+}
+/** pi-ask RemoteAskAnswer — one question's answered parts.
+ *
+ *  CASING EXCEPTION: inside the `ask` envelope the keys mirror pi-ask's own
+ *  schema VERBATIM (camelCase: `presentedType`, `requestedType`, `customText`,
+ *  `optionNotes`) so the bridge can forward the response to pi-ask's submit
+ *  event without a remap pass. The snake_case convention of this protocol
+ *  applies at the frame level (`flow_id`, `tool_call_id`, `notify_type`). */
+export interface AskAnswerWire {
+    values?: string[];
+    customText?: string;
+    note?: string;
+    optionNotes?: Record<string, string>;
+}
+/** Optional pi-ask enrichment on an extension_ui_response — carries the
+ *  structured answer so multi/preview/notes survive the round-trip. */
+export type AskResponseEnrichmentWire = {
+    flow_id: string;
+    kind: "answer";
+    mode?: "submit" | "elaborate";
+    answers: Record<string, AskAnswerWire>;
+} | {
+    flow_id: string;
+    kind: "cancel";
+};
+/** ServerMessage: interactive extension prompt. Mirrors RpcExtensionUIRequest
+ *  (select/confirm/input/editor/notify). The `ask` envelope is present when the
+ *  prompt originates from a pi-ask flow, carrying the full question schema. */
+export type ExtensionUiRequestWire = {
+    type: "extension_ui_request";
+    id: string;
+    method: "select";
+    title: string;
+    options: string[];
+    ask?: AskEnrichmentWire;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "confirm";
+    title: string;
+    message: string;
+    ask?: AskEnrichmentWire;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "input";
+    title: string;
+    placeholder?: string;
+    ask?: AskEnrichmentWire;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "editor";
+    title: string;
+    prefill?: string;
+    ask?: AskEnrichmentWire;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "notify";
+    message: string;
+    notify_type?: "info" | "warning" | "error";
+};
+/** ClientMessage: response to an extension_ui_request. Mirrors
+ *  RpcExtensionUIResponse (value / confirmed / cancelled). The `ask` envelope
+ *  carries pi-ask's structured answer when the app rendered the rich flow. */
+export type ExtensionUiResponseWire = {
+    type: "extension_ui_response";
+    id: string;
+    value: string;
+    ask?: AskResponseEnrichmentWire;
+} | {
+    type: "extension_ui_response";
+    id: string;
+    confirmed: boolean;
+    ask?: AskResponseEnrichmentWire;
+} | {
+    type: "extension_ui_response";
+    id: string;
+    cancelled: true;
+    ask?: AskResponseEnrichmentWire;
+} | {
+    type: "extension_ui_response";
+    id: string;
+    ask: AskResponseEnrichmentWire;
+};
+export type ClientMessage = {
+    type: "pair_request";
+    id: string;
+    token: string;
+    device_name: string;
+} | {
+    type: "user_message";
+    id: string;
+    text: string;
+    images?: WireImage[];
+    streaming_behavior?: StreamingBehavior;
+} | {
+    type: "queued_message_set";
+    id: string;
+    text: string;
+} | {
+    type: "queued_message_clear";
+    id: string;
+    target_id?: string;
+} | {
+    type: "approve_tool";
+    id: string;
+    tool_call_id: string;
+    decision: "allow" | "deny";
+} | {
+    type: "cancel";
+    id: string;
+    target_id: string;
+} | {
+    type: "ping";
+    id: string;
+} | {
+    type: "session_sync";
+    id: string;
+    limit?: number;
+} | {
+    type: "session_new";
+    id: string;
+} | {
+    type: "session_compact";
+    id: string;
+} | {
+    type: "model_set";
+    id: string;
+    provider: string;
+    model_id: string;
+} | {
+    type: "thinking_set";
+    id: string;
+    level: ThinkingLevel;
+} | {
+    type: "list_models";
+    id: string;
+} | ExtensionUiResponseWire;
+/**
+ * Plan/30 — one inline image attachment on a `user_message`. Mirrors the
+ * SDK's `ImageContent` ({@link https }) split across the wire: `data` is the
+ * base64-encoded (compressed) image bytes, `mime` its content type
+ * (e.g. `"image/jpeg"`). The Pi maps `{ data, mime }` → the SDK's
+ * `{ type:"image", data, mimeType }` before handing it to the model.
+ */
+export interface WireImage {
+    /** Base64-encoded image bytes (compressed app-side). */
+    data: string;
+    /** MIME type, e.g. `"image/jpeg"`. Maps to the SDK's `mimeType`. */
+    mime: string;
+}
+export type Usage = {
+    input_tokens: number;
+    output_tokens: number;
+};
+export type KnownErrorCode = "tool_approval_required" | "invalid_message" | "unsupported_type" | "too_large" | "rate_limited" | "timeout" | "internal_error";
+export type ErrorCode = KnownErrorCode | (string & {});
+export type SessionHistoryEvent = {
+    ts: number;
+    type: "user_input";
+    id: string;
+    text: string;
+    images?: WireImage[];
+} | {
+    ts: number;
+    type: "tool_request";
+    tool_call_id: string;
+    tool: string;
+    args: Record<string, unknown>;
+} | {
+    ts: number;
+    type: "tool_result";
+    tool_call_id: string;
+    result?: unknown;
+    error?: string;
+} | {
+    ts: number;
+    type: "agent_message";
+    in_reply_to: string;
+    text: string;
+    usage?: Usage;
+} | {
+    ts: number;
+    type: "compaction";
+    summary: string;
+    tokens_before: number;
+};
+export type ServerMessage = {
+    type: "pair_ok";
+    in_reply_to: string;
+    session_name: string;
+    session_started_at: number;
+    room_id: string;
+    /**
+     * Plan/27 Wave A: identifies the host coding agent driving this
+     * pi-extension instance. `name` is hardcoded to "Pi coding agent"
+     * today; future Pi forks (Claude Code, OpenCode) populate their own
+     * here. `version` is the pi-extension `package.json` version.
+     * Optional in the wire schema so app-side parsing tolerates older
+     * Pi builds that predate this field — every new pairing emits both.
+     */
+    harness?: {
+        name: string;
+        version: string;
+    };
+    /**
+     * Plan/27 Wave A: `os.hostname()` of the machine the Pi runs on.
+     * App displays it in the device list so the user can distinguish
+     * two paired PCs that happen to share a nickname or sit in the
+     * same project folder.
+     */
+    hostname?: string;
+} | {
+    type: "pair_error";
+    in_reply_to: string;
+    code: PairErrorCode;
+    message: string;
+} | {
+    type: "user_input";
+    id: string;
+    text: string;
+    streaming_behavior?: StreamingBehavior;
+} | {
+    type: "user_message";
+    id: string;
+    text: string;
+    images?: WireImage[];
+    streaming_behavior?: StreamingBehavior;
+} | {
+    type: "queued_message_state";
+    id?: string;
+    text?: string;
+    items?: QueuedMessageItem[];
+} | {
+    type: "steer_consumed";
+    id: string;
+} | {
+    type: "agent_chunk";
+    in_reply_to: string;
+    delta: string;
+} | {
+    type: "agent_done";
+    in_reply_to: string;
+    usage?: Usage;
+} | {
+    type: "agent_message";
+    in_reply_to: string;
+    text: string;
+    usage?: Usage;
+} | {
+    type: "compaction";
+    summary: string;
+    tokens_before: number;
+    ts?: number;
+} | {
+    type: "tool_request";
+    tool_call_id: string;
+    tool: string;
+    args: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    tool_call_id: string;
+    result?: unknown;
+    error?: string;
+} | {
+    type: "error";
+    in_reply_to?: string;
+    code: ErrorCode;
+    message: string;
+} | {
+    type: "cancelled";
+    in_reply_to: string;
+    target_id: string;
+} | {
+    type: "pong";
+    in_reply_to: string;
+} | {
+    type: "bye";
+    reason: ByeReason;
+} | {
+    type: "session_history";
+    in_reply_to: string;
+    session_started_at: number;
+    events: SessionHistoryEvent[];
+    eos: boolean;
+    truncated: boolean;
+} | {
+    type: "action_ok";
+    in_reply_to: string;
+    action: ActionName;
+} | {
+    type: "action_error";
+    in_reply_to: string;
+    action: ActionName;
+    error: string;
+} | {
+    type: "models_list";
+    in_reply_to: string;
+    models: WireModel[];
+    current?: WireModel;
+} | ExtensionUiRequestWire;
+/**
+ * Plan/28 — Stable names for the typed actions the app can request. Kept
+ * as a closed string union so a switch in either side gets exhaustiveness
+ * checking from the compiler.
+ */
+export type ActionName = "session_new" | "session_compact" | "model_set" | "thinking_set";
+/**
+ * Plan/28 — Mirror of the SDK's `ThinkingLevel` (defined in
+ * `@earendil-works/pi-agent-core/types`). Re-declared locally so the wire
+ * protocol owns its own enum and we don't leak SDK-internal types onto
+ * the app's network surface.
+ *
+ * Note: `"xhigh"` is only honored by select model families — the SDK uses
+ * each `Model.thinkingLevelMap` to decide if the requested level is
+ * supported, falling back to a sensible neighbour when not. The app
+ * surfaces all 6 buttons but can grey out unsupported ones using the
+ * model's metadata if the picker fetches it later.
+ */
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+/**
+ * Plan/28 — Wire shape for one model entry in the app's model picker.
+ *
+ * Subset of the SDK's `Model<Api>` interface — only the fields the app
+ * actually renders. Cost / max-tokens / API class are left off the wire
+ * deliberately; if the app's picker grows to need them, they get added
+ * here and to the handler's mapping in `index.ts` in one diff.
+ */
+export interface WireModel {
+    /** Stable identifier inside the provider's catalog. E.g. `"claude-opus-4-7"`. */
+    id: string;
+    /** Display name for the picker row. E.g. `"Claude Opus 4.7"`. */
+    name: string;
+    /** Provider slug. E.g. `"anthropic"`, `"openai"`. */
+    provider: string;
+    /** Whether the model supports the thinking surface (`reasoning: true`
+     *  in the SDK). Useful so the app can decide whether the thinking
+     *  segmented control should be enabled when this model is selected. */
+    reasoning: boolean;
+    /** Context window in tokens, for display in the picker subtitle. */
+    context_window: number;
+    /** Plan/30: true when the model accepts image input (SDK `Model.input`
+     *  includes `"image"`). The app uses it to enable/disable the attach
+     *  button — a text-only model greys out image attachments. */
+    vision: boolean;
+}
+export type ByeReason = "peer_stop" | "session_replaced" | "shutdown";

package/dist/protocol/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/protocol/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/protocol/types.ts"],"names":[],"mappings":""}

package/dist/protocol/v2/codec.d.ts

@@ -0,0 +1,26 @@
+import type { ClientFrame, JsonValue, MarkerV2, ServerFrame, TimelineEvent, TimelinePartial } from "./schemas.js";
+export type DecodeErrorCode = "invalid" | "unsupported" | "version" | "schema" | "size" | "direction";
+export declare class DecodeError extends Error {
+    readonly code: DecodeErrorCode;
+    readonly name = "DecodeError";
+    constructor(code: DecodeErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function getUtf8ByteLengthV2(value: unknown): number;
+export declare function decodeClientFrameV2(raw: unknown): ClientFrame;
+export declare function decodeServerFrameV2(raw: unknown): ServerFrame;
+export declare function encodeClientFrameV2(frame: ClientFrame): string;
+export declare function encodeServerFrameV2(frame: ServerFrame): string;
+export declare function validateFragmentSizeV2(fragment: unknown): number;
+export declare function validateHistoryChunkSizeV2(chunk: unknown): number;
+export declare function validateWindowSizeV2(events: readonly unknown[]): number;
+export declare function validateEncodedSizeV2(value: unknown, maxBytes?: number): number;
+export declare function parseTimelineEventV2(raw: unknown): TimelineEvent;
+export declare function parseTimelinePartialV2(raw: unknown): TimelinePartial;
+export declare function parseMarkerV2(raw: unknown): MarkerV2;
+export { HistoryFragmentSchema, TimelineEventFragmentSchema, SessionHistoryChunkSchema } from "./schemas.js";
+export declare const validateTimelineEventFragmentV2: typeof validateFragmentSizeV2;
+export declare const validateSessionHistoryChunkV2: typeof validateHistoryChunkSizeV2;
+export declare const validateTimelineWindowV2: typeof validateWindowSizeV2;
+export type JsonValueV2 = JsonValue;

package/dist/protocol/v2/codec.js

@@ -0,0 +1,207 @@
+import { ClientFrameSchema, ClientFrameTypes, MAX_FRAME_BYTES, MAX_FRAGMENT_DECODE_BYTES, MAX_HISTORY_CHUNK_BYTES, MAX_WINDOW_DECODE_BYTES, MarkerSchemaV2, ServerFrameSchema, ServerFrameTypes, HistoryFragmentSchema, SessionHistoryChunkSchema, TimelineEventFragmentSchema, TimelineEventSchema, TimelinePartialSchema, } from "./schemas.js";
+export class DecodeError extends Error {
+    code;
+    name = "DecodeError";
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function byteLength(value) {
+    return textEncoder.encode(value).byteLength;
+}
+export function getUtf8ByteLengthV2(value) {
+    try {
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined)
+            throw new Error("value is not JSON serializable");
+        return byteLength(encoded);
+    }
+    catch (error) {
+        throw new DecodeError("invalid", "value is not JSON serializable", { cause: error });
+    }
+}
+function parseRaw(raw, maxBytes = MAX_WINDOW_DECODE_BYTES) {
+    if (typeof raw === "string") {
+        const bytes = byteLength(raw);
+        if (bytes > maxBytes) {
+            throw new DecodeError("size", `raw value exceeds ${maxBytes} bytes`);
+        }
+        try {
+            return { value: JSON.parse(raw), bytes };
+        }
+        catch (error) {
+            throw new DecodeError("invalid", "raw string is not valid JSON", { cause: error });
+        }
+    }
+    if (raw instanceof Uint8Array) {
+        if (raw.byteLength > maxBytes) {
+            throw new DecodeError("size", `raw value exceeds ${maxBytes} bytes`);
+        }
+        try {
+            return { value: JSON.parse(textDecoder.decode(raw)), bytes: raw.byteLength };
+        }
+        catch (error) {
+            throw new DecodeError("invalid", "raw bytes are not valid UTF-8 JSON", { cause: error });
+        }
+    }
+    if (isRecord(raw)) {
+        const bytes = getUtf8ByteLengthV2(raw);
+        if (bytes > maxBytes) {
+            throw new DecodeError("size", `raw value exceeds ${maxBytes} bytes`);
+        }
+        return { value: raw, bytes };
+    }
+    throw new DecodeError("invalid", "raw frame must be an object, JSON string, or Uint8Array");
+}
+function schemaMessage(error) {
+    return error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+}
+function checkProtocolVersion(value) {
+    if (value.protocol_version !== 2) {
+        throw new DecodeError("version", "protocol_version must be 2");
+    }
+}
+function checkFrameBytes(value, bytes) {
+    if (bytes > MAX_FRAME_BYTES) {
+        throw new DecodeError("size", `${String(value.type)} exceeds ${MAX_FRAME_BYTES} encoded UTF-8 bytes`);
+    }
+}
+function parseFrame(raw, direction) {
+    const { value, bytes } = parseRaw(raw, MAX_FRAME_BYTES);
+    if (!isRecord(value) || typeof value.type !== "string") {
+        throw new DecodeError("invalid", "frame must contain a string type");
+    }
+    const clientKnown = ClientFrameTypes.has(value.type);
+    const serverKnown = ServerFrameTypes.has(value.type);
+    if (!clientKnown && !serverKnown)
+        throw new DecodeError("unsupported", `unknown frame type: ${value.type}`);
+    if (direction === "client" && !clientKnown)
+        throw new DecodeError("direction", `${value.type} is a server frame`);
+    if (direction === "server" && !serverKnown)
+        throw new DecodeError("direction", `${value.type} is a client frame`);
+    checkProtocolVersion(value);
+    const result = direction === "client" ? ClientFrameSchema.safeParse(value) : ServerFrameSchema.safeParse(value);
+    if (!result.success)
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    checkFrameBytes(value, bytes);
+    if (value.type === "timeline_event_fragment")
+        validateFragmentSizeV2(value);
+    if (value.type === "session_history_chunk")
+        validateHistoryChunkSizeV2(value);
+    return result.data;
+}
+export function decodeClientFrameV2(raw) {
+    return parseFrame(raw, "client");
+}
+export function decodeServerFrameV2(raw) {
+    return parseFrame(raw, "server");
+}
+function encodeFrame(frame, direction) {
+    const parsed = parseFrame(frame, direction);
+    const encoded = JSON.stringify(parsed);
+    if (encoded === undefined)
+        throw new DecodeError("invalid", "frame is not JSON serializable");
+    return encoded;
+}
+export function encodeClientFrameV2(frame) {
+    return encodeFrame(frame, "client");
+}
+export function encodeServerFrameV2(frame) {
+    return encodeFrame(frame, "server");
+}
+function decodeBase64Bytes(value) {
+    try {
+        return Uint8Array.from(Buffer.from(value, "base64"));
+    }
+    catch (error) {
+        throw new DecodeError("schema", "data_base64 is not valid base64", { cause: error });
+    }
+}
+export function validateFragmentSizeV2(fragment) {
+    const realtimeResult = TimelineEventFragmentSchema.safeParse(fragment);
+    const historyResult = HistoryFragmentSchema.safeParse(fragment);
+    if (!realtimeResult.success && !historyResult.success) {
+        throw new DecodeError("schema", schemaMessage(realtimeResult.error), { cause: realtimeResult.error });
+    }
+    const dataBase64 = realtimeResult.success
+        ? realtimeResult.data.data_base64
+        : historyResult.success
+            ? historyResult.data.data_base64
+            : undefined;
+    if (dataBase64 === undefined)
+        throw new DecodeError("schema", "fragment data is missing");
+    const bytes = decodeBase64Bytes(dataBase64).byteLength;
+    if (bytes > MAX_FRAGMENT_DECODE_BYTES) {
+        throw new DecodeError("size", `fragment exceeds ${MAX_FRAGMENT_DECODE_BYTES} decoded bytes`);
+    }
+    return bytes;
+}
+export function validateHistoryChunkSizeV2(chunk) {
+    const result = SessionHistoryChunkSchema.safeParse(chunk);
+    if (!result.success)
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    const parsed = result.data;
+    const bytes = getUtf8ByteLengthV2(parsed);
+    if (bytes > MAX_HISTORY_CHUNK_BYTES) {
+        throw new DecodeError("size", `history chunk exceeds ${MAX_HISTORY_CHUNK_BYTES} encoded UTF-8 bytes`);
+    }
+    for (const fragment of parsed.fragments)
+        validateFragmentSizeV2(fragment);
+    return bytes;
+}
+export function validateWindowSizeV2(events) {
+    let total = 0;
+    for (const event of events) {
+        const result = TimelineEventSchema.safeParse(event);
+        if (!result.success)
+            throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+        total += getUtf8ByteLengthV2(result.data);
+        if (total > MAX_WINDOW_DECODE_BYTES) {
+            throw new DecodeError("size", `decoded window exceeds ${MAX_WINDOW_DECODE_BYTES} bytes`);
+        }
+    }
+    return total;
+}
+export function validateEncodedSizeV2(value, maxBytes = MAX_WINDOW_DECODE_BYTES) {
+    const bytes = getUtf8ByteLengthV2(value);
+    if (bytes > maxBytes)
+        throw new DecodeError("size", `encoded value exceeds ${maxBytes} bytes`);
+    return bytes;
+}
+export function parseTimelineEventV2(raw) {
+    const { value } = parseRaw(raw);
+    const result = TimelineEventSchema.safeParse(value);
+    if (!result.success)
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    const event = result.data;
+    validateEncodedSizeV2(event, MAX_WINDOW_DECODE_BYTES);
+    return event;
+}
+export function parseTimelinePartialV2(raw) {
+    const { value } = parseRaw(raw);
+    const result = TimelinePartialSchema.safeParse(value);
+    if (!result.success)
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    validateEncodedSizeV2(result.data, MAX_HISTORY_CHUNK_BYTES);
+    return result.data;
+}
+export function parseMarkerV2(raw) {
+    const { value } = parseRaw(raw);
+    const result = MarkerSchemaV2.safeParse(value);
+    if (!result.success)
+        throw new DecodeError("schema", schemaMessage(result.error), { cause: result.error });
+    validateEncodedSizeV2(result.data, MAX_FRAGMENT_DECODE_BYTES);
+    return result.data;
+}
+// These aliases keep validation available without exposing scanner or production wiring.
+export { HistoryFragmentSchema, TimelineEventFragmentSchema, SessionHistoryChunkSchema } from "./schemas.js";
+export const validateTimelineEventFragmentV2 = validateFragmentSizeV2;
+export const validateSessionHistoryChunkV2 = validateHistoryChunkSizeV2;
+export const validateTimelineWindowV2 = validateWindowSizeV2;
+//# sourceMappingURL=codec.js.map