@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/pi-intercom/broker/connection.d.ts

@@ -0,0 +1,29 @@
+import net from "node:net";
+export declare function connectBrokerSocket(): Promise<net.Socket>;
+interface ConnectionHandlers {
+    readonly message: (message: unknown) => void;
+    readonly error: (error: Readonly<Error>) => void;
+    readonly closed: (error: Readonly<Error>, expected: boolean) => void;
+}
+/** One socket owns registration, read/error listeners, and graceful shutdown. */
+export declare class BrokerConnection {
+    private registered;
+    private closing;
+    private failure;
+    private registration;
+    private registrationTimer;
+    private readonly reader;
+    readonly socket: net.Socket;
+    private readonly handlers;
+    constructor(socket: net.Socket, handlers: ConnectionHandlers);
+    start(registration: unknown): Promise<void>;
+    confirmRegistration(): void;
+    private clearRegistration;
+    private failRegistration;
+    private protocolError;
+    private readonly onError;
+    private readonly onClose;
+    isActive(): boolean;
+    disconnect(): Promise<void>;
+}
+export {};

package/dist/pi-intercom/broker/connection.js

@@ -1,6 +1,6 @@
 import net from "node:net";
 import { errorMessage } from "../../shared/unknown.js";
-import { getBrokerSocketPath, getLegacyBrokerSocketPath, isOwnedBrokerSocket } from "./paths.js";
+import { getBrokerSocketPath, isOwnedBrokerSocket } from "./paths.js";
 import { createMessageReader, writeMessage } from "./framing.js";
 function connectSocket(socketPath, timeoutMs = 500) {
     return new Promise((resolve, reject) => {
@@ -26,24 +26,11 @@ function connectSocket(socketPath, timeoutMs = 500) {
     });
 }
 export async function connectBrokerSocket() {
-    const preferred = getBrokerSocketPath();
-    const legacy = getLegacyBrokerSocketPath();
-    const candidates = [preferred, ...(legacy !== preferred ? [legacy] : [])];
-    let lastError;
-    for (const candidate of candidates) {
-        if (!isOwnedBrokerSocket(candidate)) {
-            continue;
-        }
-        try {
-            // Preferred and legacy sockets must be tried in order, never connected concurrently.
-            // oxlint-disable-next-line no-await-in-loop
-            return await connectSocket(candidate);
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(errorMessage(error));
-        }
+    const socketPath = getBrokerSocketPath();
+    if (!isOwnedBrokerSocket(socketPath)) {
+        throw new Error(`Intercom broker socket is unavailable: ${socketPath}`);
     }
-    throw lastError ?? new Error(`Intercom broker socket is unavailable: ${preferred}`);
+    return await connectSocket(socketPath);
 }
 /** One socket owns registration, read/error listeners, and graceful shutdown. */
 export class BrokerConnection {

package/dist/pi-intercom/broker/framing.d.ts

@@ -0,0 +1,17 @@
+import type { Socket } from "net";
+export declare const MAX_FRAME_SIZE_BYTES: number;
+export declare function intercomMessageSizeBytes(msg: unknown): number;
+export declare function validateIntercomMessageSize(msg: unknown): Error | null;
+/**
+ * Write a length-prefixed message to a socket.
+ * Format: 4-byte big-endian length + JSON payload
+ */
+export declare function writeMessage(socket: Socket, msg: unknown): void;
+/** Write serialized JSON; false means Node accepted it but the caller should wait for drain. */
+export declare function writeFrame(socket: Socket, json: string, limit?: number): boolean;
+/**
+ * Create a message reader that handles partial reads.
+ * Calls onMessage for each complete message received.
+ * Protocol or handler errors are reported to onError so the caller can close the socket.
+ */
+export declare function createMessageReader(onMessage: (msg: unknown) => void, onError: (error: Readonly<Error>) => void, limit?: number): (data: Buffer) => void;

package/dist/pi-intercom/broker/framing.js

@@ -14,15 +14,18 @@ export function validateIntercomMessageSize(msg) {
  * Format: 4-byte big-endian length + JSON payload
  */
 export function writeMessage(socket, msg) {
-    const json = JSON.stringify(msg);
+    writeFrame(socket, JSON.stringify(msg));
+}
+/** Write serialized JSON; false means Node accepted it but the caller should wait for drain. */
+export function writeFrame(socket, json, limit = MAX_FRAME_SIZE_BYTES) {
     const size = Buffer.byteLength(json, "utf-8");
-    if (size > MAX_FRAME_SIZE_BYTES) {
-        throw new Error(`Intercom message too large (${size} bytes; max ${MAX_FRAME_SIZE_BYTES})`);
+    if (size > limit) {
+        throw new Error(`Intercom message too large (${size} bytes; max ${limit})`);
     }
     const payload = Buffer.from(json, "utf-8");
     const header = Buffer.alloc(4);
     header.writeUInt32BE(payload.length, 0);
-    socket.write(Buffer.concat([header, payload]));
+    return socket.write(Buffer.concat([header, payload]));
 }
 /** Retain fragments until a header or payload is complete; copy each fragmented value once. */
 class MessageBuffer {
@@ -77,7 +80,7 @@ class MessageBuffer {
  * Calls onMessage for each complete message received.
  * Protocol or handler errors are reported to onError so the caller can close the socket.
  */
-export function createMessageReader(onMessage, onError) {
+export function createMessageReader(onMessage, onError, limit = MAX_FRAME_SIZE_BYTES) {
     const buffer = new MessageBuffer();
     let length;
     return (data) => {
@@ -85,8 +88,8 @@ export function createMessageReader(onMessage, onError) {
         while (buffer.length >= (length ?? 4)) {
             if (length === undefined) {
                 length = buffer.read(4).readUInt32BE(0);
-                if (length > MAX_FRAME_SIZE_BYTES) {
-                    onError(new Error(`Intercom frame too large (${length} bytes; max ${MAX_FRAME_SIZE_BYTES})`));
+                if (length > limit) {
+                    onError(new Error(`Intercom frame too large (${length} bytes; max ${limit})`));
                     buffer.clear();
                     length = undefined;
                     return;

package/dist/pi-intercom/broker/guard.js

@@ -0,0 +1,23 @@
+/** Guarded commands use an exact main, never convenience names or a replacement context. */
+export function guardedDeliveryError(sessions, to, message) {
+    const guard = message.guard;
+    if (!guard) {
+        return null;
+    }
+    const registered = sessions.get(to);
+    if (!registered || to !== guard.peerId) {
+        return "Guarded target not found";
+    }
+    const target = registered.info;
+    if (target.guardedDelivery !== 1) {
+        return "Recipient does not support guarded delivery";
+    }
+    if (target.parentSessionId !== undefined ||
+        target.rootSessionId !== guard.rootSessionId ||
+        target.incarnation !== guard.incarnation ||
+        target.applicationGuard !== guard.applicationGuard) {
+        return "Guarded target changed";
+    }
+    const mains = [...sessions.values()].filter(({ info }) => info.rootSessionId === guard.rootSessionId && info.parentSessionId === undefined);
+    return mains.length === 1 ? null : "Guarded root is ambiguous";
+}

package/dist/pi-intercom/broker/last.d.ts

@@ -0,0 +1,26 @@
+import type net from "node:net";
+import { type UnknownRecord } from "../../shared/unknown.ts";
+import { type LastMessageQuery, type LastMessageResult, type SessionInfo, type ReceiptQuery, type ReceiptResult } from "../types.ts";
+export type NativeReadQuery = LastMessageQuery | ReceiptQuery;
+export type NativeReadResult = LastMessageResult | ReceiptResult;
+export declare function isNativeReadQuery(value: unknown): value is NativeReadQuery;
+export declare function isReceiptResult(value: unknown): value is ReceiptResult;
+export declare function isNativeReadResult(value: unknown): value is NativeReadResult;
+export declare function isLastMessageResult(value: unknown): value is LastMessageResult;
+interface LastPeer {
+    readonly socket: net.Socket;
+    readonly info: SessionInfo;
+    readonly lastMessages: boolean;
+    readonly receiptReads: boolean;
+}
+/** Correlation belongs to the broker, not the requester or the recipient's model queue. */
+export declare class LastMessageRelay {
+    private readonly pending;
+    private readonly sessions;
+    constructor(sessions: ReadonlyMap<string, LastPeer>);
+    request(fromId: string, message: UnknownRecord): void;
+    respond(fromId: string, message: UnknownRecord): void;
+    disconnected(sessionId: string): void;
+    private finish;
+}
+export {};

package/dist/pi-intercom/broker/last.js

@@ -0,0 +1,198 @@
+import { randomUUID } from "node:crypto";
+import { isRecord } from "../../shared/unknown.js";
+import { isDeliveryGuard, isPublicationReplyHint, isLastMessageQuery, isReceiptQuery, LAST_MESSAGE_PAGE_LIMIT, normalizeSessionInfo, } from "../types.js";
+import { finiteNumber, nonNegativeInteger, optionalLabel, safeLabel } from "../validation.js";
+import { validateIntercomMessageSize, writeMessage } from "./framing.js";
+import { messageSender } from "./snapshots.js";
+import { findSessions } from "./targets.js";
+export function isNativeReadQuery(value) {
+    return isReceiptQuery(value) || isLastMessageQuery(value);
+}
+function isNativeReceipt(value) {
+    if (!isReceiptQuery(value) || !isRecord(value) || !isRecord(value.sender)) {
+        return false;
+    }
+    return (value.version === 1 &&
+        safeLabel(value.sender.peerId) &&
+        [value.sender.rootSessionId, value.sender.incarnation].every(optionalLabel) &&
+        typeof value.textSha256 === "string" &&
+        /^[a-f0-9]{64}$/.test(value.textSha256) &&
+        receiptPublication(value) &&
+        receiptFacts(value));
+}
+function receiptPublication(value) {
+    return (typeof value.delivery === "string" &&
+        ["queue", "steer", "passive"].includes(value.delivery) &&
+        (value.guard === undefined || isDeliveryGuard(value.guard)) &&
+        (value.replyHint === undefined || isPublicationReplyHint(value.replyHint)));
+}
+function receiptFacts(value) {
+    return (safeLabel(value.checkpointEntryId) &&
+        finiteNumber(value.receivedAt) &&
+        [value.queued, value.nativeHandoff, value.discarded].every((field) => typeof field === "boolean") &&
+        (value.placementEntryId === null || safeLabel(value.placementEntryId)));
+}
+export function isReceiptResult(value) {
+    return isRecord(value) && (typeof value.error === "string" || isNativeReceipt(value.receipt));
+}
+export function isNativeReadResult(value) {
+    return isReceiptResult(value) || isLastMessageResult(value);
+}
+function pageIdentity(value) {
+    return (normalizeSessionInfo(value.session) !== null &&
+        (value.entryId === null || (typeof value.entryId === "string" && value.entryId.length > 0)) &&
+        typeof value.text === "string" &&
+        value.text.length <= LAST_MESSAGE_PAGE_LIMIT);
+}
+function pageOffsets(value) {
+    if (!nonNegativeInteger(value.offset) ||
+        !nonNegativeInteger(value.totalLength) ||
+        typeof value.text !== "string") {
+        return false;
+    }
+    const end = value.offset + value.text.length;
+    if (value.entryId === null) {
+        return end === 0 && value.totalLength === 0 && value.nextOffset === undefined;
+    }
+    if (value.nextOffset === undefined) {
+        return end === value.totalLength;
+    }
+    return value.nextOffset === end && end < value.totalLength && value.text.length > 0;
+}
+export function isLastMessageResult(value) {
+    return (isRecord(value) &&
+        (typeof value.error === "string" || (pageIdentity(value) && pageOffsets(value))));
+}
+function unavailable(targets, name, pending, query) {
+    if (targets.length === 0) {
+        return "Session not found";
+    }
+    if (targets.length > 1) {
+        return `Multiple sessions named "${name}" are connected. Use the session ID instead.`;
+    }
+    if (!targets[0].lastMessages) {
+        return "Recipient does not support last-message reads; reload its extension.";
+    }
+    if ("messageId" in query &&
+        (!targets[0].receiptReads || targets[0].info.rootSessionId !== query.rootSessionId)) {
+        return "publication_unavailable";
+    }
+    if (pending >= 128) {
+        return "Too many pending last-message reads; retry after they settle.";
+    }
+    return undefined;
+}
+function matchesPage(result, pending, fromId) {
+    if ("error" in result) {
+        return true;
+    }
+    if ("messageId" in pending.query) {
+        return ("receipt" in result &&
+            result.receipt.messageId === pending.query.messageId &&
+            result.receipt.rootSessionId === pending.query.rootSessionId);
+    }
+    if ("receipt" in result) {
+        return false;
+    }
+    return matchesLastPage(result, pending.query, fromId);
+}
+function matchesLastPage(result, query, fromId) {
+    return (result.session.id === fromId &&
+        result.offset === (query.offset ?? 0) &&
+        (query.entryId === undefined || result.entryId === query.entryId) &&
+        result.text.length <= (query.limit ?? LAST_MESSAGE_PAGE_LIMIT));
+}
+/** Correlation belongs to the broker, not the requester or the recipient's model queue. */
+export class LastMessageRelay {
+    pending = new Map();
+    sessions;
+    constructor(sessions) {
+        this.sessions = sessions;
+    }
+    request(fromId, message) {
+        if (typeof message.requestId !== "string" ||
+            typeof message.to !== "string" ||
+            !isNativeReadQuery(message.query)) {
+            throw new Error("Invalid last message request");
+        }
+        const targets = findSessions(this.sessions, message.to, fromId);
+        const target = targets[0];
+        const from = this.sessions.get(fromId);
+        if (!from) {
+            return;
+        }
+        const token = randomUUID();
+        const frame = {
+            type: "last_request",
+            requestId: token,
+            from: messageSender(from.info),
+            query: message.query,
+        };
+        const error = unavailable(targets, message.to, this.pending.size, message.query) ??
+            validateIntercomMessageSize(frame)?.message;
+        if (error !== undefined) {
+            writeMessage(from.socket, {
+                type: "last_response",
+                requestId: message.requestId,
+                result: { error },
+            });
+            return;
+        }
+        const timer = setTimeout(() => this.finish(token, { error: "Last-message read timed out" }), 5000);
+        timer.unref();
+        this.pending.set(token, {
+            fromId,
+            toId: target.info.id,
+            requestId: message.requestId,
+            query: message.query,
+            timer,
+        });
+        try {
+            writeMessage(target.socket, frame);
+        }
+        catch {
+            this.finish(token, { error: "Recipient disconnected before last-message read" });
+        }
+    }
+    respond(fromId, message) {
+        if (typeof message.requestId !== "string") {
+            throw new Error("Invalid last message response");
+        }
+        const pending = this.pending.get(message.requestId);
+        if (!pending || pending.toId !== fromId) {
+            return;
+        }
+        const result = message.result;
+        this.finish(message.requestId, isNativeReadResult(result) && matchesPage(result, pending, fromId)
+            ? result
+            : { error: "Recipient returned an invalid last-message page" });
+    }
+    disconnected(sessionId) {
+        for (const [token, pending] of this.pending) {
+            if (pending.fromId === sessionId || pending.toId === sessionId) {
+                this.finish(token, { error: "Peer disconnected during last-message read" });
+            }
+        }
+    }
+    finish(token, result) {
+        const pending = this.pending.get(token);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(token);
+        const from = this.sessions.get(pending.fromId);
+        if (!from) {
+            return;
+        }
+        const frame = { type: "last_response", requestId: pending.requestId, result };
+        const invalid = validateIntercomMessageSize(frame);
+        writeMessage(from.socket, invalid
+            ? {
+                type: "last_response",
+                requestId: pending.requestId,
+                result: { error: invalid.message },
+            }
+            : frame);
+    }
+}

package/dist/pi-intercom/broker/paths.d.ts

@@ -0,0 +1,13 @@
+/** Old agent-directory namespaces are inspected for migration, never used for routing. */
+export declare function getPreviousBrokerSocketPaths(): readonly string[];
+export declare function isOwnedBrokerSocket(socketPath: string): boolean;
+/** A deployment can explicitly opt out of same-user discovery with a private runtime directory. */
+export declare function getBrokerRuntimeDir(): string;
+/** Read-only child observation endpoints share the runtime policy, not the broker namespace.
+ * The endpoint name is a short token digest because the private runtime directory also counts
+ * toward the Unix-socket path limit; a full token made nested test/deployment roots overflow. */
+export declare function agentObservationSocketPath(token: string): string;
+export declare function getBrokerSocketPath(): string;
+/** Create or verify an owned, non-symlink, private socket directory. */
+export declare function preparePrivateSocketPath(socketPath: string): string;
+export declare function prepareBrokerSocketPath(): string;

package/dist/pi-intercom/broker/paths.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { getPiAgentDir } from "../agent-dir.js";
 const MAX_UNIX_SOCKET_PATH_BYTES = 100;
 function agentDigest(agentDir, uid) {
@@ -10,8 +10,17 @@ function agentDigest(agentDir, uid) {
         .digest("hex")
         .slice(0, 16);
 }
-export function getLegacyBrokerSocketPath(agentDir = getPiAgentDir()) {
-    return join(tmpdir(), `pi-intercom-${agentDigest(agentDir)}.sock`);
+/** Old agent-directory namespaces are inspected for migration, never used for routing. */
+export function getPreviousBrokerSocketPaths() {
+    const agentDir = getPiAgentDir();
+    const suffix = `pi-intercom-${agentDigest(agentDir, process.getuid?.())}`;
+    const preferred = join(tmpdir(), suffix, "broker.sock");
+    return [
+        Buffer.byteLength(preferred) <= MAX_UNIX_SOCKET_PATH_BYTES
+            ? preferred
+            : join("/tmp", suffix, "broker.sock"),
+        join(tmpdir(), `pi-intercom-${agentDigest(agentDir)}.sock`),
+    ];
 }
 export function isOwnedBrokerSocket(socketPath) {
     try {
@@ -23,23 +32,56 @@ export function isOwnedBrokerSocket(socketPath) {
         return false;
     }
 }
-export function getBrokerSocketPath(agentDir = getPiAgentDir()) {
+function defaultRuntimeRoot() {
+    if (process.platform !== "android") {
+        return "/tmp";
+    }
+    return process.env.PREFIX === undefined ? tmpdir() : join(process.env.PREFIX, "tmp");
+}
+function runtimeDirectory(socketName, sibling = "") {
+    const configured = process.env.PI_INTERCOM_RUNTIME_DIR;
     const uid = process.getuid?.();
-    const suffix = `pi-intercom-${agentDigest(agentDir, uid)}`;
-    const preferred = join(tmpdir(), suffix, "broker.sock");
-    return Buffer.byteLength(preferred) <= MAX_UNIX_SOCKET_PATH_BYTES
-        ? preferred
-        : join("/tmp", suffix, "broker.sock");
+    if (uid === undefined) {
+        throw new Error("Intercom requires Unix user IDs and Unix domain sockets.");
+    }
+    const base = configured ?? join(defaultRuntimeRoot(), `pi-intercom-${uid}`);
+    const directory = isAbsolute(base) && sibling !== "" ? `${resolve(base)}${sibling}` : base;
+    if (!isAbsolute(directory) ||
+        directory.includes("\0") ||
+        Buffer.byteLength(join(directory, socketName)) > MAX_UNIX_SOCKET_PATH_BYTES) {
+        throw new Error("PI_INTERCOM_RUNTIME_DIR must be an absolute short Unix socket directory.");
+    }
+    return directory;
 }
-export function prepareBrokerSocketPath() {
-    const socketPath = getBrokerSocketPath();
-    const brokerDir = dirname(socketPath);
-    fs.mkdirSync(brokerDir, { recursive: true, mode: 0o700 });
-    const stat = fs.lstatSync(brokerDir);
+/** A deployment can explicitly opt out of same-user discovery with a private runtime directory. */
+export function getBrokerRuntimeDir() {
+    return runtimeDirectory("broker.sock");
+}
+/** Read-only child observation endpoints share the runtime policy, not the broker namespace.
+ * The endpoint name is a short token digest because the private runtime directory also counts
+ * toward the Unix-socket path limit; a full token made nested test/deployment roots overflow. */
+export function agentObservationSocketPath(token) {
+    if (!/^[a-zA-Z0-9_-]{1,64}$/.test(token)) {
+        throw new Error("Invalid actor token.");
+    }
+    const name = `obs-${createHash("sha256").update(token).digest("hex").slice(0, 16)}.sock`;
+    return join(runtimeDirectory(name, "-agents"), name);
+}
+export function getBrokerSocketPath() {
+    return join(getBrokerRuntimeDir(), "broker.sock");
+}
+/** Create or verify an owned, non-symlink, private socket directory. */
+export function preparePrivateSocketPath(socketPath) {
+    const directory = dirname(socketPath);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(directory);
     const uid = process.getuid?.();
     if (!stat.isDirectory() || stat.isSymbolicLink() || (uid !== undefined && stat.uid !== uid)) {
-        throw new Error(`Unsafe intercom socket directory: ${brokerDir}`);
+        throw new Error(`Unsafe intercom socket directory: ${directory}`);
     }
-    fs.chmodSync(brokerDir, 0o700);
+    fs.chmodSync(directory, 0o700);
     return socketPath;
 }
+export function prepareBrokerSocketPath() {
+    return preparePrivateSocketPath(getBrokerSocketPath());
+}

package/dist/pi-intercom/broker/pid.js

@@ -73,6 +73,10 @@ export function brokerPidRecord() {
     return `${process.pid}\n${identity !== undefined ? `${identity}\n` : ""}`;
 }
 export function isBrokerPidReused(pid, record) {
+    return isLinuxProcessReplaced(pid, record.slice(record.indexOf("\n") + 1));
+}
+/** True only when a live Linux PID provably names a different process than the identity. */
+export function isLinuxProcessReplaced(pid, identity) {
     const current = readLinuxProcess(pid);
     if (!current) {
         return false;
@@ -80,7 +84,7 @@ export function isBrokerPidReused(pid, record) {
     if (current.tgid !== pid) {
         return true;
     }
-    const saved = IDENTITY.exec(record.slice(record.indexOf("\n") + 1).trim());
+    const saved = IDENTITY.exec(identity.trim());
     const actual = IDENTITY.exec(current.identity ?? "");
     if (!saved || !actual) {
         return false;

package/dist/pi-intercom/broker/server-connection.js

@@ -0,0 +1,37 @@
+import { randomUUID } from "node:crypto";
+import { createMessageReader } from "./framing.js";
+import { assertMainParent } from "./targets.js";
+import { isSessionRegistration } from "../types.js";
+export function registeredSessionInfo(msg, sessions) {
+    if (!isSessionRegistration(msg.session)) {
+        throw new Error("Invalid register message");
+    }
+    assertMainParent(msg.session, sessions);
+    const requestedId = typeof msg.requestedId === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(msg.requestedId)
+        ? msg.requestedId
+        : undefined;
+    const id = requestedId !== undefined && !sessions.has(requestedId) ? requestedId : randomUUID();
+    return {
+        ...msg.session,
+        id,
+        guardedDelivery: msg.guardedDelivery === 1 ? msg.session.guardedDelivery : undefined,
+        lastSeen: msg.session.lastSeen ?? Date.now(),
+    };
+}
+/** A server connection owns its registration identity until the socket closes. */
+export function acceptBrokerConnection(socket, handleMessage, disconnected) {
+    let sessionId = null;
+    socket.on("data", createMessageReader((message) => handleMessage(socket, message, sessionId, (id) => {
+        sessionId = id;
+    }), (error) => {
+        socket.destroy(error);
+    }));
+    socket.on("close", () => {
+        if (sessionId !== null) {
+            disconnected(sessionId);
+        }
+    });
+    socket.on("error", (error) => {
+        console.error("Socket error:", error);
+    });
+}

package/dist/pi-intercom/broker/snapshot-reader.d.ts

@@ -0,0 +1,9 @@
+import { type SessionSnapshot } from "../types.ts";
+/** Multipart frames build a private cache; only a complete validated snapshot escapes. */
+export declare class SnapshotReader {
+    private readonly sessions;
+    private readonly receipts;
+    private addSession;
+    append(sessions: readonly unknown[], receipts: unknown): void;
+    finish(): SessionSnapshot;
+}

package/dist/pi-intercom/broker/snapshots.d.ts

@@ -0,0 +1,29 @@
+import { type SessionInfo, type TopicUpdate, type Message, type BrokerMessage, type TopicSubscription, type SendResult } from "../types.ts";
+/** Direct messages and old clients receive identity, not potentially large topic state. */
+export declare function messageSender(info: SessionInfo): SessionInfo;
+export declare function snapshotFrames(requestId: string, infos: readonly SessionInfo[], stream: boolean): BrokerMessage[];
+interface PreparedTopicChange {
+    readonly topic?: TopicUpdate;
+    readonly subscription?: TopicSubscription;
+    readonly unsubscribe?: string;
+    readonly publication?: TopicUpdate;
+    readonly restore: boolean;
+    readonly changed: boolean;
+    readonly bytes: number;
+}
+/** Keep committed records indexed; restores validate only new bytes and cached envelope maxima. */
+export declare class TopicSnapshot {
+    private readonly topics;
+    private readonly subscriptions;
+    constructor(info: SessionInfo);
+    subscription(topic: string): TopicSubscription | undefined;
+    prepare(change: unknown, supported: boolean): PreparedTopicChange;
+    private preparePublication;
+    snapshot(info: SessionInfo, prepared?: PreparedTopicChange): SessionInfo;
+    validateRestore(info: SessionInfo, prepared: PreparedTopicChange, requestId: string): void;
+    commit(prepared: PreparedTopicChange): void;
+}
+export declare function deliveryAcknowledgement(receipt: SendResult): BrokerMessage;
+export declare function shouldReplaceDelivery(message: Message, info: SessionInfo): boolean;
+export declare function publicationMessage(publication: TopicUpdate, awaitRelease: boolean): Message;
+export {};