@masons/runtime-broker 0.1.0

package/dist/broker/ipc-server.js

@@ -0,0 +1,263 @@
+import { createServer } from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+import { PLUGIN_VERSION } from "../version.js";
+import { handleInitialize, IPC_PROTOCOL_VERSION, SERVER_CAPABILITIES, } from "./version-handshake.js";
+export class BrokerHttpError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.name = "BrokerHttpError";
+        this.status = status;
+        this.code = code;
+    }
+}
+export async function startIPCServer(opts) {
+    const { bearerToken, handlers, logger, onChannelOpened, onChannelClosed } = opts;
+    const http = createServer((req, res) => {
+        void routeHttp(req, res, bearerToken, handlers, logger);
+    });
+    const wss = new WebSocketServer({ noServer: true });
+    http.on("upgrade", (req, socket, head) => {
+        if (req.url !== "/v1/stream") {
+            socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        if (!authorizedRequest(req, bearerToken)) {
+            socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        const pid = readPluginPid(req);
+        if (pid === null) {
+            socket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            onChannelOpened?.(pid, ws);
+            ws.once("close", () => onChannelClosed?.(pid, ws));
+            wss.emit("connection", ws, req);
+        });
+    });
+    await new Promise((resolve, reject) => {
+        http.once("error", reject);
+        http.listen(0, "127.0.0.1", () => {
+            http.off("error", reject);
+            resolve();
+        });
+    });
+    const addr = http.address();
+    const ipcUrl = `http://127.0.0.1:${addr.port}`;
+    logger.info("ipc_server_listening", { ipcUrl });
+    return {
+        ipcUrl,
+        port: addr.port,
+        async close() {
+            await closeServer(http, wss);
+        },
+    };
+}
+async function routeHttp(req, res, bearerToken, handlers, logger) {
+    const url = req.url ?? "";
+    const method = req.method ?? "GET";
+    if (method === "GET" && url === "/health") {
+        sendJson(res, 200, {
+            ok: true,
+            version: PLUGIN_VERSION,
+            protocol_version: IPC_PROTOCOL_VERSION,
+            capabilities: SERVER_CAPABILITIES,
+        });
+        return;
+    }
+    if (!authorizedRequest(req, bearerToken)) {
+        sendJson(res, 401, { error: "unauthorized" });
+        return;
+    }
+    try {
+        if (method === "POST" && url === "/v1/initialize") {
+            const body = await readJson(req);
+            const result = handleInitialize(body);
+            sendJson(res, result.status, result.body);
+            return;
+        }
+        if (method === "POST" && url === "/v1/endpoint/register") {
+            const body = await readJson(req);
+            const out = await handlers.registerEndpoint(body, null);
+            sendJson(res, 200, out);
+            return;
+        }
+        const heartbeatMatch = /^\/v1\/endpoint\/([^/]+)\/heartbeat$/.exec(url);
+        if (method === "POST" && heartbeatMatch && heartbeatMatch[1]) {
+            await handlers.heartbeatEndpoint(decodeURIComponent(heartbeatMatch[1]));
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        const reattachMatch = /^\/v1\/endpoint\/([^/]+)\/reattach$/.exec(url);
+        if (method === "POST" && reattachMatch && reattachMatch[1]) {
+            const body = await readJson(req);
+            const pid = typeof body.plugin_pid === "number" ? body.plugin_pid : Number.NaN;
+            if (!Number.isFinite(pid) || pid <= 0) {
+                throw new BrokerHttpError(400, "plugin_pid_invalid", "plugin_pid is required and must be a positive number");
+            }
+            const out = await handlers.reattachEndpoint(decodeURIComponent(reattachMatch[1]), pid, null);
+            sendJson(res, 200, out);
+            return;
+        }
+        const unregisterMatch = /^\/v1\/endpoint\/([^/]+)$/.exec(url);
+        if (method === "DELETE" && unregisterMatch && unregisterMatch[1]) {
+            await handlers.unregisterEndpoint(decodeURIComponent(unregisterMatch[1]));
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        if (method === "POST" && url === "/v1/send") {
+            const body = await readJson(req);
+            const out = await handlers.send(body);
+            sendJson(res, 200, out);
+            return;
+        }
+        if (method === "GET" && url === "/v1/undispatched") {
+            const items = await handlers.listUndispatched();
+            sendJson(res, 200, { items });
+            return;
+        }
+        if (method === "POST" && url === "/v1/dispatch") {
+            const body = await readJson(req);
+            const uid = typeof body.undispatched_id === "string"
+                ? body.undispatched_id
+                : undefined;
+            const tid = typeof body.target_endpoint_id === "string"
+                ? body.target_endpoint_id
+                : undefined;
+            if (!uid || !tid) {
+                throw new BrokerHttpError(400, "dispatch_body_invalid", "POST /v1/dispatch requires { undispatched_id, target_endpoint_id }");
+            }
+            await handlers.dispatch(uid, tid);
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        const taskHintMatch = /^\/v1\/endpoint\/([^/]+)\/task-hint$/.exec(url);
+        if (method === "POST" && taskHintMatch && taskHintMatch[1]) {
+            const endpointId = decodeURIComponent(taskHintMatch[1]);
+            const body = await readJson(req);
+            const pid = typeof body.plugin_pid === "number" ? body.plugin_pid : Number.NaN;
+            if (!Number.isFinite(pid) || pid <= 0) {
+                throw new BrokerHttpError(400, "plugin_pid_invalid", "plugin_pid is required and must be a positive number");
+            }
+            const hint = typeof body.task_hint === "string" ? body.task_hint : undefined;
+            if (hint === undefined) {
+                throw new BrokerHttpError(400, "task_hint_invalid", "task_hint is required and must be a string");
+            }
+            await handlers.setTaskHint({
+                endpoint_id: endpointId,
+                plugin_pid: pid,
+                task_hint: hint,
+            });
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        sendJson(res, 404, { error: "not_found", path: url });
+    }
+    catch (err) {
+        if (err instanceof BrokerHttpError) {
+            logger.info("ipc_route_rejected", {
+                url,
+                method,
+                status: err.status,
+                code: err.code,
+                message: err.message,
+            });
+            sendJson(res, err.status, { error: err.code, message: err.message });
+            return;
+        }
+        logger.error("ipc_route_error", {
+            url,
+            method,
+            err: err instanceof Error ? err.message : String(err),
+        });
+        sendJson(res, 500, {
+            error: "internal_error",
+            message: err instanceof Error ? err.message : "unknown",
+        });
+    }
+}
+function authorizedRequest(req, bearerToken) {
+    const header = req.headers.authorization;
+    if (typeof header !== "string")
+        return false;
+    const trimmed = header.startsWith("Bearer ")
+        ? header.slice("Bearer ".length)
+        : header;
+    return constantTimeEquals(trimmed, bearerToken);
+}
+function readPluginPid(req) {
+    const raw = req.headers["x-plugin-pid"];
+    const str = Array.isArray(raw) ? raw[0] : raw;
+    if (!str)
+        return null;
+    const n = Number.parseInt(str, 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+}
+function constantTimeEquals(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let mismatch = 0;
+    for (let i = 0; i < a.length; i++) {
+        mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return mismatch === 0;
+}
+async function readJson(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        const MAX = 1 * 1024 * 1024;
+        req.on("data", (chunk) => {
+            const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            total += buf.length;
+            if (total > MAX) {
+                reject(new Error("request body too large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(buf);
+        });
+        req.on("end", () => {
+            try {
+                const raw = Buffer.concat(chunks).toString("utf8");
+                resolve(raw.length === 0 ? {} : JSON.parse(raw));
+            }
+            catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(body));
+}
+async function closeServer(http, wss) {
+    await new Promise((resolve) => {
+        wss.close(() => resolve());
+    });
+    await new Promise((resolve, reject) => {
+        http.close((err) => (err ? reject(err) : resolve()));
+    });
+}
+export function pushToPlugin(ws, event) {
+    if (ws.readyState !== WebSocket.OPEN)
+        return;
+    ws.send(JSON.stringify(event));
+}
+export function parsePluginFrame(data) {
+    try {
+        return JSON.parse(data.toString());
+    }
+    catch {
+        return null;
+    }
+}

package/dist/broker/logger.d.ts

@@ -0,0 +1,10 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export interface BrokerLogger {
+    debug(msg: string, fields?: Record<string, unknown>): void;
+    info(msg: string, fields?: Record<string, unknown>): void;
+    warn(msg: string, fields?: Record<string, unknown>): void;
+    error(msg: string, fields?: Record<string, unknown>): void;
+}
+export declare function createBrokerLogger(logDir: string): BrokerLogger;
+export declare function createNullLogger(): BrokerLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/broker/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/broker/logger.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC3D,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1D,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1D,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC5D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CA6B/D;AAGD,wBAAgB,gBAAgB,IAAI,YAAY,CAO/C"}

package/dist/broker/logger.js

@@ -0,0 +1,34 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+export function createBrokerLogger(logDir) {
+    mkdirSync(logDir, { recursive: true, mode: 0o700 });
+    const path = join(logDir, `broker-${process.pid}.log`);
+    const write = (level, msg, fields) => {
+        const line = JSON.stringify({
+            ts: new Date().toISOString(),
+            level,
+            pid: process.pid,
+            msg,
+            ...fields,
+        });
+        try {
+            appendFileSync(path, `${line}\n`);
+        }
+        catch {
+        }
+    };
+    return {
+        debug: (msg, fields) => write("debug", msg, fields),
+        info: (msg, fields) => write("info", msg, fields),
+        warn: (msg, fields) => write("warn", msg, fields),
+        error: (msg, fields) => write("error", msg, fields),
+    };
+}
+export function createNullLogger() {
+    return {
+        debug: () => { },
+        info: () => { },
+        warn: () => { },
+        error: () => { },
+    };
+}

package/dist/broker/network-presence-changed-event-types.d.ts

@@ -0,0 +1,8 @@
+export interface NetworkPresenceChangedEvent {
+    type: "network_presence_changed";
+    version: 1;
+    state: "online" | "reconnecting" | "offline";
+    ts: number;
+    reason?: string;
+}
+//# sourceMappingURL=network-presence-changed-event-types.d.ts.map

package/dist/broker/network-presence-changed-event-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-presence-changed-event-types.d.ts","sourceRoot":"","sources":["../../src/broker/network-presence-changed-event-types.ts"],"names":[],"mappings":"AAqCA,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,0BAA0B,CAAC;IAGjC,OAAO,EAAE,CAAC,CAAC;IAEX,KAAK,EAAE,QAAQ,GAAG,cAAc,GAAG,SAAS,CAAC;IAG7C,EAAE,EAAE,MAAM,CAAC;IAMX,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/broker/network-presence-changed-event-types.js

@@ -0,0 +1 @@
+export {};

package/dist/broker/network-presence-emitter.d.ts

@@ -0,0 +1,22 @@
+import type { BrokerLogger } from "./logger.js";
+import type { NetworkPresenceChangedEvent } from "./network-presence-changed-event-types.js";
+import type { EmitOutcome, RuntimeEndpointPort } from "./runtime-endpoint-port.js";
+export declare const DEFAULT_PRESENCE_EMITTER_CAPACITY = 128;
+export declare const DEFAULT_PRESENCE_EMITTER_BACKOFF_INITIAL_MS = 500;
+export declare const DEFAULT_PRESENCE_EMITTER_BACKOFF_MAX_MS = 30000;
+export declare const DEFAULT_PRESENCE_EMITTER_MAX_RETRIES = 5;
+export interface NetworkPresenceEmitterOptions {
+    capacity?: number;
+    backoffInitialMs?: number;
+    backoffMaxMs?: number;
+    maxRetries?: number;
+}
+export interface NetworkPresenceEmitter {
+    enqueue(event: NetworkPresenceChangedEvent): boolean;
+    size(): number;
+    capacity(): number;
+    shutdown(): Promise<void>;
+}
+export declare function createNetworkPresenceEmitter(post: (event: NetworkPresenceChangedEvent) => Promise<EmitOutcome>, logger: BrokerLogger, opts?: NetworkPresenceEmitterOptions): NetworkPresenceEmitter;
+export declare function postNetworkPresenceChangedViaPort(apiPort: RuntimeEndpointPort): (event: NetworkPresenceChangedEvent) => Promise<EmitOutcome>;
+//# sourceMappingURL=network-presence-emitter.d.ts.map

package/dist/broker/network-presence-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-presence-emitter.d.ts","sourceRoot":"","sources":["../../src/broker/network-presence-emitter.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2CAA2C,CAAC;AAC7F,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAM,iCAAiC,MAAM,CAAC;AACrD,eAAO,MAAM,2CAA2C,MAAM,CAAC;AAC/D,eAAO,MAAM,uCAAuC,QAAS,CAAC;AAC9D,eAAO,MAAM,oCAAoC,IAAI,CAAC;AAEtD,MAAM,WAAW,6BAA6B;IAE5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,sBAAsB;IAIrC,OAAO,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO,CAAC;IAErD,IAAI,IAAI,MAAM,CAAC;IAEf,QAAQ,IAAI,MAAM,CAAC;IAGnB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,CAAC,KAAK,EAAE,2BAA2B,KAAK,OAAO,CAAC,WAAW,CAAC,EAClE,MAAM,EAAE,YAAY,EACpB,IAAI,GAAE,6BAAkC,GACvC,sBAAsB,CAyIxB;AAcD,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,mBAAmB,GAC3B,CAAC,KAAK,EAAE,2BAA2B,KAAK,OAAO,CAAC,WAAW,CAAC,CAW9D"}

package/dist/broker/network-presence-emitter.js

@@ -0,0 +1,150 @@
+export const DEFAULT_PRESENCE_EMITTER_CAPACITY = 128;
+export const DEFAULT_PRESENCE_EMITTER_BACKOFF_INITIAL_MS = 500;
+export const DEFAULT_PRESENCE_EMITTER_BACKOFF_MAX_MS = 30_000;
+export const DEFAULT_PRESENCE_EMITTER_MAX_RETRIES = 5;
+export function createNetworkPresenceEmitter(post, logger, opts = {}) {
+    const cap = opts.capacity ?? DEFAULT_PRESENCE_EMITTER_CAPACITY;
+    const initialBackoff = opts.backoffInitialMs ?? DEFAULT_PRESENCE_EMITTER_BACKOFF_INITIAL_MS;
+    const maxBackoff = opts.backoffMaxMs ?? DEFAULT_PRESENCE_EMITTER_BACKOFF_MAX_MS;
+    const maxRetries = opts.maxRetries ?? DEFAULT_PRESENCE_EMITTER_MAX_RETRIES;
+    if (cap <= 0)
+        throw new Error(`capacity must be positive: ${cap}`);
+    if (initialBackoff <= 0)
+        throw new Error(`backoffInitialMs must be positive: ${initialBackoff}`);
+    if (maxBackoff < initialBackoff)
+        throw new Error(`backoffMaxMs must be >= backoffInitialMs`);
+    if (maxRetries < 0)
+        throw new Error(`maxRetries must be non-negative: ${maxRetries}`);
+    const queue = [];
+    let draining = false;
+    let stopped = false;
+    let activeDrain = null;
+    let wakeSleep = null;
+    const sleep = (ms) => new Promise((resolve) => {
+        const t = setTimeout(() => {
+            wakeSleep = null;
+            resolve();
+        }, ms);
+        t.unref?.();
+        wakeSleep = () => {
+            clearTimeout(t);
+            wakeSleep = null;
+            resolve();
+        };
+    });
+    const drain = async () => {
+        while (!stopped && queue.length > 0) {
+            const event = queue[0];
+            if (!event)
+                break;
+            let attempts = 0;
+            while (true) {
+                if (stopped)
+                    return;
+                let outcome;
+                try {
+                    outcome = await post(event);
+                }
+                catch (err) {
+                    outcome = {
+                        ok: false,
+                        terminal: false,
+                        detail: err instanceof Error ? err.message : String(err),
+                    };
+                }
+                if (outcome.ok)
+                    break;
+                if (outcome.terminal) {
+                    logger.warn("network_presence_changed_drop_terminal", {
+                        state: event.state,
+                        ts: event.ts,
+                        reason: event.reason,
+                        status: outcome.status,
+                        detail: outcome.detail,
+                    });
+                    break;
+                }
+                attempts++;
+                if (attempts > maxRetries) {
+                    logger.warn("network_presence_changed_drop_max_retries", {
+                        state: event.state,
+                        ts: event.ts,
+                        attempts,
+                        status: outcome.status,
+                        detail: outcome.detail,
+                    });
+                    break;
+                }
+                const backoff = Math.min(initialBackoff * 2 ** (attempts - 1), maxBackoff);
+                logger.info("network_presence_changed_retry", {
+                    state: event.state,
+                    ts: event.ts,
+                    attempt: attempts,
+                    backoff_ms: backoff,
+                    status: outcome.status,
+                });
+                await sleep(backoff);
+            }
+            queue.shift();
+        }
+        draining = false;
+    };
+    const kick = () => {
+        if (draining || stopped)
+            return;
+        draining = true;
+        activeDrain = drain().catch((err) => {
+            logger.error("network_presence_changed_drain_unexpected_error", {
+                err: err instanceof Error ? err.message : String(err),
+            });
+            draining = false;
+        });
+    };
+    return {
+        enqueue(event) {
+            if (stopped)
+                return true;
+            let evicted = false;
+            if (queue.length >= cap) {
+                const old = queue.shift();
+                if (old) {
+                    logger.warn("network_presence_changed_queue_overflow", {
+                        dropped_state: old.state,
+                        dropped_ts: old.ts,
+                        size: queue.length,
+                        capacity: cap,
+                    });
+                    evicted = true;
+                }
+            }
+            queue.push(event);
+            kick();
+            return !evicted;
+        },
+        size() {
+            return queue.length;
+        },
+        capacity() {
+            return cap;
+        },
+        async shutdown() {
+            stopped = true;
+            wakeSleep?.();
+            if (activeDrain) {
+                await activeDrain.catch(() => { });
+            }
+        },
+    };
+}
+export function postNetworkPresenceChangedViaPort(apiPort) {
+    return async (event) => {
+        if (!apiPort.emitNetworkPresenceChanged) {
+            return {
+                ok: false,
+                terminal: true,
+                detail: "emitNetworkPresenceChanged not implemented on this apiPort",
+            };
+        }
+        return apiPort.emitNetworkPresenceChanged(event);
+    };
+}

package/dist/broker/network-presence.d.ts

@@ -0,0 +1,31 @@
+export declare const DEFAULT_PRESENCE_GRACE_MS: number;
+export type NetworkPresence = "online" | "reconnecting" | "offline";
+export type PresenceEvent = {
+    type: "connector_connected";
+} | {
+    type: "connector_disconnected";
+} | {
+    type: "presence_grace_expired";
+} | {
+    type: "shutdown";
+};
+export type PresenceEffect = {
+    type: "start_grace_timer";
+    deadline_ms: number;
+} | {
+    type: "cancel_grace_timer";
+} | {
+    type: "emit_presence";
+    presence: NetworkPresence;
+    reason: string;
+};
+export interface PresenceTransitionResult {
+    next: NetworkPresence;
+    effects: readonly PresenceEffect[];
+    ignored?: boolean;
+}
+export interface PresenceTransitionOptions {
+    graceMs?: number;
+}
+export declare function transitionPresence(current: NetworkPresence, event: PresenceEvent, opts?: PresenceTransitionOptions): PresenceTransitionResult;
+//# sourceMappingURL=network-presence.d.ts.map

package/dist/broker/network-presence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-presence.d.ts","sourceRoot":"","sources":["../../src/broker/network-presence.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,yBAAyB,QAAiB,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,cAAc,GAAG,SAAS,CAAC;AAEpE,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,qBAAqB,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,wBAAwB,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,wBAAwB,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAEzB,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,oBAAoB,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzE,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IACnC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAOD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,aAAa,EACpB,IAAI,GAAE,yBAA8B,GACnC,wBAAwB,CAgH1B"}

package/dist/broker/network-presence.js

@@ -0,0 +1,109 @@
+export const DEFAULT_PRESENCE_GRACE_MS = 10 * 60 * 1000;
+export function transitionPresence(current, event, opts = {}) {
+    const graceMs = opts.graceMs ?? DEFAULT_PRESENCE_GRACE_MS;
+    switch (current) {
+        case "offline": {
+            switch (event.type) {
+                case "connector_connected":
+                    return {
+                        next: "online",
+                        effects: [
+                            {
+                                type: "emit_presence",
+                                presence: "online",
+                                reason: "connector_connected",
+                            },
+                        ],
+                    };
+                case "shutdown":
+                    return {
+                        next: "offline",
+                        effects: [
+                            {
+                                type: "emit_presence",
+                                presence: "offline",
+                                reason: "broker_shutdown",
+                            },
+                        ],
+                    };
+                case "connector_disconnected":
+                case "presence_grace_expired":
+                    return { next: "offline", effects: [], ignored: true };
+            }
+            return { next: current, effects: [], ignored: true };
+        }
+        case "online": {
+            switch (event.type) {
+                case "connector_disconnected":
+                    return {
+                        next: "reconnecting",
+                        effects: [
+                            { type: "start_grace_timer", deadline_ms: graceMs },
+                            {
+                                type: "emit_presence",
+                                presence: "reconnecting",
+                                reason: "connector_disconnected",
+                            },
+                        ],
+                    };
+                case "shutdown":
+                    return {
+                        next: "offline",
+                        effects: [
+                            {
+                                type: "emit_presence",
+                                presence: "offline",
+                                reason: "broker_shutdown",
+                            },
+                        ],
+                    };
+                case "connector_connected":
+                case "presence_grace_expired":
+                    return { next: "online", effects: [], ignored: true };
+            }
+            return { next: current, effects: [], ignored: true };
+        }
+        case "reconnecting": {
+            switch (event.type) {
+                case "connector_connected":
+                    return {
+                        next: "online",
+                        effects: [
+                            { type: "cancel_grace_timer" },
+                            {
+                                type: "emit_presence",
+                                presence: "online",
+                                reason: "connector_reconnected",
+                            },
+                        ],
+                    };
+                case "presence_grace_expired":
+                    return {
+                        next: "offline",
+                        effects: [
+                            {
+                                type: "emit_presence",
+                                presence: "offline",
+                                reason: "grace_timeout",
+                            },
+                        ],
+                    };
+                case "shutdown":
+                    return {
+                        next: "offline",
+                        effects: [
+                            { type: "cancel_grace_timer" },
+                            {
+                                type: "emit_presence",
+                                presence: "offline",
+                                reason: "broker_shutdown",
+                            },
+                        ],
+                    };
+                case "connector_disconnected":
+                    return { next: "reconnecting", effects: [], ignored: true };
+            }
+            return { next: current, effects: [], ignored: true };
+        }
+    }
+}

package/dist/broker/paths.d.ts

@@ -0,0 +1,11 @@
+export interface BrokerPathOptions {
+    userDataDir?: string;
+}
+export interface BrokerPaths {
+    discoveryFile: string;
+    discoveryDir: string;
+    logDir: string;
+    buffersDir: string;
+}
+export declare function resolveBrokerPaths(principal: string, runtimeToken: string, opts?: BrokerPathOptions): BrokerPaths;
+//# sourceMappingURL=paths.d.ts.map

package/dist/broker/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/broker/paths.ts"],"names":[],"mappings":"AAgCA,MAAM,WAAW,iBAAiB;IAEhC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAE1B,aAAa,EAAE,MAAM,CAAC;IAEtB,YAAY,EAAE,MAAM,CAAC;IAErB,MAAM,EAAE,MAAM,CAAC;IAQf,UAAU,EAAE,MAAM,CAAC;CACpB;AASD,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,IAAI,GAAE,iBAAsB,GAC3B,WAAW,CAgCb"}