@spinabot/brigade 0.1.1 → 1.0.0

package/dist/process/lanes.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Command lanes — cooperative parallelism for the Brigade gateway.
+ *
+ * Public surface every Brigade caller imports from. Internally the actual
+ * FIFO + generation-counter + drain-helpers implementation lives in
+ * `./command-queue.ts` — this module is a thin re-export + naming-stable
+ * adapter so the upstream lift could land without renaming every Brigade
+ * caller (`enqueueInLane`, `getLaneQueueSize`, `resetLanesForTests`,
+ * `CommandLane.{Main,Cron,Subagent,Nested}`).
+ *
+ * Lane model:
+ *
+ *   - `Main`      — the operator's primary turn lane. TUI / connect-mode
+ *                   prompts + direct-RPC calls land here. Strictly FIFO.
+ *   - `Cron`      — manual cron-fire work (operator clicking "run now").
+ *                   Timer-driven fires bypass this lane and run directly
+ *                   in their own per-instance lock.
+ *   - `Subagent`  — sub-agent spawns. Parent's `Main` lane keeps moving
+ *                   while a sub-agent runs.
+ *   - `Nested`    — sub-agents OF sub-agents, or work spawned from inside
+ *                   a cron turn. Prevents nested deadlock when a Cron-lane
+ *                   task tries to enqueue more Cron-lane work.
+ *   - `session:<key>` — per-session lanes for channel-routed turns. Two
+ *                   different DMs (WhatsApp A and WhatsApp B) get
+ *                   different lanes and run concurrently. Inside a single
+ *                   peer's lane work is still FIFO so messages 1, 2, 3
+ *                   process in order.
+ *
+ * Same-lane tasks queue and run one at a time. Different-lane tasks run
+ * concurrently. The lane is a string for extensibility — adding a new
+ * well-known lane is a string-literal addition; per-session lanes use
+ * `session:<sessionKey>` keys built on the fly.
+ *
+ * Concurrency budget: every lane defaults to `maxConcurrent: 1`. Use
+ * `setCommandLaneConcurrency(lane, n)` from `./command-queue.js` to lift
+ * the cap (e.g. for parallel-account inbound processing on a channel).
+ */
+/** Well-known lane ids. */
+export declare const CommandLane: {
+    readonly Main: "main";
+    readonly Cron: "cron";
+    readonly Subagent: "subagent";
+    readonly Nested: "nested";
+};
+export type CommandLane = (typeof CommandLane)[keyof typeof CommandLane];
+export type CommandLaneId = (typeof CommandLane)[keyof typeof CommandLane] | string;
+/** Upstream-parity aliases for lift-and-paste compatibility. */
+export declare const AGENT_LANE_MAIN: "main";
+export declare const AGENT_LANE_CRON: "cron";
+export declare const AGENT_LANE_SUBAGENT: "subagent";
+export declare const AGENT_LANE_NESTED: "nested";
+/**
+ * Compute the per-session lane id for a session key. Channel-routed turns
+ * pass `session:<sessionKey>` so each peer gets its own FIFO queue;
+ * different peers run concurrently.
+ */
+export declare function sessionLane(sessionKey: string): string;
+/**
+ * Per-parent sub-agent lane id. Each parent session gets its own FIFO
+ * lane (`subagent:<parentSessionKey>`) so spawns from different parents
+ * never block one another. The PROCESS-WIDE in-flight cap lives outside
+ * the lane engine — see `agents/subagent-budget.ts` for the semaphore the
+ * gateway pushes `resolveSubagentMaxConcurrent(cfg)` into.
+ */
+export declare function subagentLane(parentSessionKey: string | undefined | null): string;
+/**
+ * Per-parent A2A / nested lane id. Same shape as `subagentLane` but keyed
+ * for cross-session sends originated by the same caller so a chatty caller
+ * doesn't starve siblings.
+ */
+export declare function nestedLane(parentSessionKey: string | undefined | null): string;
+/**
+ * Run `work` on the named lane. Resolves with the work's result. Backed
+ * by the generation-aware engine in `./command-queue.js` — same FIFO
+ * semantics as before, but a `resetAllLanes()` call (e.g. from a config
+ * reload) no longer leaks stale active-task IDs that would block future
+ * pumps.
+ *
+ * Concurrency:
+ *   - Two `enqueueInLane(lane, ...)` calls on the SAME lane: the second
+ *     awaits the first (when `maxConcurrent: 1`, the default).
+ *   - Two calls on DIFFERENT lanes: run concurrently.
+ */
+export declare function enqueueInLane<T>(lane: CommandLaneId, work: () => Promise<T>): Promise<T>;
+/**
+ * Combined depth (queued + active) of a lane. Used by the heartbeat
+ * runner: if `Main` has pending work, skip the heartbeat and let it run
+ * naturally. Returns 0 when the lane has never been used.
+ */
+export declare function getLaneQueueSize(lane: CommandLaneId): number;
+/**
+ * Cancel every queued (not yet active) entry on a lane. Used by `/stop`
+ * + by graceful-shutdown to refuse pending work. Active tasks keep
+ * running. Returns the number of entries removed.
+ */
+export declare function clearLane(lane: CommandLaneId): number;
+/** Test-only — hard reset of every lane's state. */
+export declare function resetLanesForTests(): void;
+/** Re-export the lower-level engine for callers that need maxConcurrent /
+ *  drain-await / draining-flag control. */
+export { CommandLaneClearedError, GatewayDrainingError, enqueueCommand, enqueueCommandInLane, getActiveTaskCount, getTotalQueueSize, markGatewayDraining, resetAllLanes, setCommandLaneConcurrency, waitForActiveTasks, } from "./command-queue.js";
+//# sourceMappingURL=lanes.d.ts.map

package/dist/process/lanes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lanes.d.ts","sourceRoot":"","sources":["../../src/process/lanes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AASH,2BAA2B;AAC3B,eAAO,MAAM,WAAW;;;;;CAKd,CAAC;AACX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AACzE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,GAAG,MAAM,CAAC;AAEpF,gEAAgE;AAChE,eAAO,MAAM,eAAe,QAAmB,CAAC;AAChD,eAAO,MAAM,eAAe,QAAmB,CAAC;AAChD,eAAO,MAAM,mBAAmB,YAAuB,CAAC;AACxD,eAAO,MAAM,iBAAiB,UAAqB,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAGhF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAG9E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAExF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAErD;AAED,oDAAoD;AACpD,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;2CAC2C;AAC3C,OAAO,EACN,uBAAuB,EACvB,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,yBAAyB,EACzB,kBAAkB,GAClB,MAAM,oBAAoB,CAAC"}

package/dist/process/lanes.js

@@ -0,0 +1,117 @@
+/**
+ * Command lanes — cooperative parallelism for the Brigade gateway.
+ *
+ * Public surface every Brigade caller imports from. Internally the actual
+ * FIFO + generation-counter + drain-helpers implementation lives in
+ * `./command-queue.ts` — this module is a thin re-export + naming-stable
+ * adapter so the upstream lift could land without renaming every Brigade
+ * caller (`enqueueInLane`, `getLaneQueueSize`, `resetLanesForTests`,
+ * `CommandLane.{Main,Cron,Subagent,Nested}`).
+ *
+ * Lane model:
+ *
+ *   - `Main`      — the operator's primary turn lane. TUI / connect-mode
+ *                   prompts + direct-RPC calls land here. Strictly FIFO.
+ *   - `Cron`      — manual cron-fire work (operator clicking "run now").
+ *                   Timer-driven fires bypass this lane and run directly
+ *                   in their own per-instance lock.
+ *   - `Subagent`  — sub-agent spawns. Parent's `Main` lane keeps moving
+ *                   while a sub-agent runs.
+ *   - `Nested`    — sub-agents OF sub-agents, or work spawned from inside
+ *                   a cron turn. Prevents nested deadlock when a Cron-lane
+ *                   task tries to enqueue more Cron-lane work.
+ *   - `session:<key>` — per-session lanes for channel-routed turns. Two
+ *                   different DMs (WhatsApp A and WhatsApp B) get
+ *                   different lanes and run concurrently. Inside a single
+ *                   peer's lane work is still FIFO so messages 1, 2, 3
+ *                   process in order.
+ *
+ * Same-lane tasks queue and run one at a time. Different-lane tasks run
+ * concurrently. The lane is a string for extensibility — adding a new
+ * well-known lane is a string-literal addition; per-session lanes use
+ * `session:<sessionKey>` keys built on the fly.
+ *
+ * Concurrency budget: every lane defaults to `maxConcurrent: 1`. Use
+ * `setCommandLaneConcurrency(lane, n)` from `./command-queue.js` to lift
+ * the cap (e.g. for parallel-account inbound processing on a channel).
+ */
+import { clearCommandLane, enqueueCommandInLane, getQueueSize, resetCommandQueueStateForTest, } from "./command-queue.js";
+/** Well-known lane ids. */
+export const CommandLane = {
+    Main: "main",
+    Cron: "cron",
+    Subagent: "subagent",
+    Nested: "nested",
+};
+/** Upstream-parity aliases for lift-and-paste compatibility. */
+export const AGENT_LANE_MAIN = CommandLane.Main;
+export const AGENT_LANE_CRON = CommandLane.Cron;
+export const AGENT_LANE_SUBAGENT = CommandLane.Subagent;
+export const AGENT_LANE_NESTED = CommandLane.Nested;
+/**
+ * Compute the per-session lane id for a session key. Channel-routed turns
+ * pass `session:<sessionKey>` so each peer gets its own FIFO queue;
+ * different peers run concurrently.
+ */
+export function sessionLane(sessionKey) {
+    return `session:${sessionKey}`;
+}
+/**
+ * Per-parent sub-agent lane id. Each parent session gets its own FIFO
+ * lane (`subagent:<parentSessionKey>`) so spawns from different parents
+ * never block one another. The PROCESS-WIDE in-flight cap lives outside
+ * the lane engine — see `agents/subagent-budget.ts` for the semaphore the
+ * gateway pushes `resolveSubagentMaxConcurrent(cfg)` into.
+ */
+export function subagentLane(parentSessionKey) {
+    const trimmed = (parentSessionKey ?? "").trim();
+    return trimmed ? `subagent:${trimmed}` : CommandLane.Subagent;
+}
+/**
+ * Per-parent A2A / nested lane id. Same shape as `subagentLane` but keyed
+ * for cross-session sends originated by the same caller so a chatty caller
+ * doesn't starve siblings.
+ */
+export function nestedLane(parentSessionKey) {
+    const trimmed = (parentSessionKey ?? "").trim();
+    return trimmed ? `nested:${trimmed}` : CommandLane.Nested;
+}
+/**
+ * Run `work` on the named lane. Resolves with the work's result. Backed
+ * by the generation-aware engine in `./command-queue.js` — same FIFO
+ * semantics as before, but a `resetAllLanes()` call (e.g. from a config
+ * reload) no longer leaks stale active-task IDs that would block future
+ * pumps.
+ *
+ * Concurrency:
+ *   - Two `enqueueInLane(lane, ...)` calls on the SAME lane: the second
+ *     awaits the first (when `maxConcurrent: 1`, the default).
+ *   - Two calls on DIFFERENT lanes: run concurrently.
+ */
+export function enqueueInLane(lane, work) {
+    return enqueueCommandInLane(lane, work);
+}
+/**
+ * Combined depth (queued + active) of a lane. Used by the heartbeat
+ * runner: if `Main` has pending work, skip the heartbeat and let it run
+ * naturally. Returns 0 when the lane has never been used.
+ */
+export function getLaneQueueSize(lane) {
+    return getQueueSize(lane);
+}
+/**
+ * Cancel every queued (not yet active) entry on a lane. Used by `/stop`
+ * + by graceful-shutdown to refuse pending work. Active tasks keep
+ * running. Returns the number of entries removed.
+ */
+export function clearLane(lane) {
+    return clearCommandLane(lane);
+}
+/** Test-only — hard reset of every lane's state. */
+export function resetLanesForTests() {
+    resetCommandQueueStateForTest();
+}
+/** Re-export the lower-level engine for callers that need maxConcurrent /
+ *  drain-await / draining-flag control. */
+export { CommandLaneClearedError, GatewayDrainingError, enqueueCommand, enqueueCommandInLane, getActiveTaskCount, getTotalQueueSize, markGatewayDraining, resetAllLanes, setCommandLaneConcurrency, waitForActiveTasks, } from "./command-queue.js";
+//# sourceMappingURL=lanes.js.map

package/dist/process/lanes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lanes.js","sourceRoot":"","sources":["../../src/process/lanes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,EACN,gBAAgB,EAChB,oBAAoB,EACpB,YAAY,EACZ,6BAA6B,GAC7B,MAAM,oBAAoB,CAAC;AAE5B,2BAA2B;AAC3B,MAAM,CAAC,MAAM,WAAW,GAAG;IAC1B,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,MAAM,EAAE,QAAQ;CACP,CAAC;AAIX,gEAAgE;AAChE,MAAM,CAAC,MAAM,eAAe,GAAG,WAAW,CAAC,IAAI,CAAC;AAChD,MAAM,CAAC,MAAM,eAAe,GAAG,WAAW,CAAC,IAAI,CAAC;AAChD,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC,QAAQ,CAAC;AACxD,MAAM,CAAC,MAAM,iBAAiB,GAAG,WAAW,CAAC,MAAM,CAAC;AAEpD;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,UAAkB;IAC7C,OAAO,WAAW,UAAU,EAAE,CAAC;AAChC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,gBAA2C;IACvE,MAAM,OAAO,GAAG,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAChD,OAAO,OAAO,CAAC,CAAC,CAAC,YAAY,OAAO,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC;AAC/D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,gBAA2C;IACrE,MAAM,OAAO,GAAG,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAChD,OAAO,OAAO,CAAC,CAAC,CAAC,UAAU,OAAO,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAAI,IAAmB,EAAE,IAAsB;IAC3E,OAAO,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAmB;IACnD,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;AAC3B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,IAAmB;IAC5C,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,kBAAkB;IACjC,6BAA6B,EAAE,CAAC;AACjC,CAAC;AAED;2CAC2C;AAC3C,OAAO,EACN,uBAAuB,EACvB,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,yBAAyB,EACzB,kBAAkB,GAClB,MAAM,oBAAoB,CAAC"}

package/dist/process/session-lane.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Per-session command lane resolvers.
+ *
+ * Brand-scrubbed analogue of the upstream `src/agents/pi-embedded-runner/lanes.ts`.
+ * The functions are pure string mappers used by the gateway dispatcher,
+ * the embedded runner, and the cron scheduler to translate a raw key
+ * (sessionKey or lane name) into the canonical lane id that the FIFO
+ * engine in `./command-queue.ts` keys on.
+ *
+ * Three mappers, one rule each:
+ *
+ *   - `resolveSessionLane(key)` → `session:<key>` for channel/session-scoped
+ *      lanes (per-peer isolation across WhatsApp DMs, Slack channels, etc.).
+ *      Empty / whitespace-only keys fall back to the well-known `Main` lane
+ *      so an unsourced inbound never collides with a sibling session.
+ *
+ *   - `resolveGlobalLane(lane?)` → one of the well-known lane ids on
+ *      `CommandLane`. Special-cases `Cron`: a cron task already holds the
+ *      `Cron` lane slot, so any operation enqueued from inside that turn
+ *      MUST go to `Nested` to avoid self-deadlock.
+ *
+ *   - `resolveEmbeddedSessionLane(key)` → identical to `resolveSessionLane`
+ *      today; kept as a separate symbol so the embedded-runner call site
+ *      stays explicit about which side of the split it's running on. If
+ *      the two ever diverge (e.g. embedded gets its own pool), this is the
+ *      single place to fork.
+ */
+export declare function resolveSessionLane(key: string): string;
+export declare function resolveGlobalLane(lane?: string): string;
+export declare function resolveEmbeddedSessionLane(key: string): string;
+//# sourceMappingURL=session-lane.d.ts.map

package/dist/process/session-lane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-lane.d.ts","sourceRoot":"","sources":["../../src/process/session-lane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAQvD;AAED,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9D"}

package/dist/process/session-lane.js

@@ -0,0 +1,45 @@
+/**
+ * Per-session command lane resolvers.
+ *
+ * Brand-scrubbed analogue of the upstream `src/agents/pi-embedded-runner/lanes.ts`.
+ * The functions are pure string mappers used by the gateway dispatcher,
+ * the embedded runner, and the cron scheduler to translate a raw key
+ * (sessionKey or lane name) into the canonical lane id that the FIFO
+ * engine in `./command-queue.ts` keys on.
+ *
+ * Three mappers, one rule each:
+ *
+ *   - `resolveSessionLane(key)` → `session:<key>` for channel/session-scoped
+ *      lanes (per-peer isolation across WhatsApp DMs, Slack channels, etc.).
+ *      Empty / whitespace-only keys fall back to the well-known `Main` lane
+ *      so an unsourced inbound never collides with a sibling session.
+ *
+ *   - `resolveGlobalLane(lane?)` → one of the well-known lane ids on
+ *      `CommandLane`. Special-cases `Cron`: a cron task already holds the
+ *      `Cron` lane slot, so any operation enqueued from inside that turn
+ *      MUST go to `Nested` to avoid self-deadlock.
+ *
+ *   - `resolveEmbeddedSessionLane(key)` → identical to `resolveSessionLane`
+ *      today; kept as a separate symbol so the embedded-runner call site
+ *      stays explicit about which side of the split it's running on. If
+ *      the two ever diverge (e.g. embedded gets its own pool), this is the
+ *      single place to fork.
+ */
+import { CommandLane } from "./lanes.js";
+export function resolveSessionLane(key) {
+    const cleaned = key.trim() || CommandLane.Main;
+    return cleaned.startsWith("session:") ? cleaned : `session:${cleaned}`;
+}
+export function resolveGlobalLane(lane) {
+    const cleaned = lane?.trim();
+    // Cron jobs hold the cron lane slot; inner operations must use nested to
+    // avoid deadlock.
+    if (cleaned === CommandLane.Cron) {
+        return CommandLane.Nested;
+    }
+    return cleaned ? cleaned : CommandLane.Main;
+}
+export function resolveEmbeddedSessionLane(key) {
+    return resolveSessionLane(key);
+}
+//# sourceMappingURL=session-lane.js.map

package/dist/process/session-lane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-lane.js","sourceRoot":"","sources":["../../src/process/session-lane.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,MAAM,UAAU,kBAAkB,CAAC,GAAW;IAC7C,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,WAAW,CAAC,IAAI,CAAC;IAC/C,OAAO,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,OAAO,EAAE,CAAC;AACxE,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,IAAa;IAC9C,MAAM,OAAO,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC;IAC7B,yEAAyE;IACzE,kBAAkB;IAClB,IAAI,OAAO,KAAK,WAAW,CAAC,IAAI,EAAE,CAAC;QAClC,OAAO,WAAW,CAAC,MAAM,CAAC;IAC3B,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,GAAW;IACrD,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC;AAChC,CAAC"}

package/dist/protocol/errors.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Protocol error catalogue (Step 24).
+ *
+ * Brand-scrubbed analogue of upstream's `src/gateway/protocol/schema/error-codes.ts`.
+ * Six structured codes cover every condition the gateway responds to —
+ * intentionally small so the client-side switch never grows unbounded.
+ *
+ * Convention: codes are SCREAMING_SNAKE_CASE strings, NOT numbers. The
+ * `errorShape(code, message, opts)` helper centralises the construction
+ * pattern so every emit site has the same shape.
+ */
+import type { ProtocolErrorShape } from "./messages.js";
+export declare const ErrorCodes: {
+    /** Gateway expected paired-device auth but the request had none. */
+    readonly NOT_LINKED: "NOT_LINKED";
+    /** Caller is not paired with this gateway yet. */
+    readonly NOT_PAIRED: "NOT_PAIRED";
+    /** Agent turn timed out — caller may retry with `retryable: true`. */
+    readonly AGENT_TIMEOUT: "AGENT_TIMEOUT";
+    /** Request shape failed validation. */
+    readonly INVALID_REQUEST: "INVALID_REQUEST";
+    /** Approval lookup by id missed (id never existed or already resolved). */
+    readonly APPROVAL_NOT_FOUND: "APPROVAL_NOT_FOUND";
+    /** Subsystem is loading / draining; caller may retry shortly. */
+    readonly UNAVAILABLE: "UNAVAILABLE";
+};
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+export interface ErrorShapeOptions {
+    details?: unknown;
+    retryable?: boolean;
+    retryAfterMs?: number;
+}
+/** Helper to construct a typed `ProtocolErrorShape` from one of the known codes. */
+export declare function errorShape(code: ErrorCode, message: string, opts?: ErrorShapeOptions): ProtocolErrorShape;
+//# sourceMappingURL=errors.d.ts.map

package/dist/protocol/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/protocol/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,eAAO,MAAM,UAAU;IACtB,oEAAoE;;IAEpE,kDAAkD;;IAElD,sEAAsE;;IAEtE,uCAAuC;;IAEvC,2EAA2E;;IAE3E,iEAAiE;;CAExD,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAErE,MAAM,WAAW,iBAAiB;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,oFAAoF;AACpF,wBAAgB,UAAU,CACzB,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,iBAAsB,GAC1B,kBAAkB,CAQpB"}

package/dist/protocol/errors.js

@@ -0,0 +1,36 @@
+/**
+ * Protocol error catalogue (Step 24).
+ *
+ * Brand-scrubbed analogue of upstream's `src/gateway/protocol/schema/error-codes.ts`.
+ * Six structured codes cover every condition the gateway responds to —
+ * intentionally small so the client-side switch never grows unbounded.
+ *
+ * Convention: codes are SCREAMING_SNAKE_CASE strings, NOT numbers. The
+ * `errorShape(code, message, opts)` helper centralises the construction
+ * pattern so every emit site has the same shape.
+ */
+export const ErrorCodes = {
+    /** Gateway expected paired-device auth but the request had none. */
+    NOT_LINKED: "NOT_LINKED",
+    /** Caller is not paired with this gateway yet. */
+    NOT_PAIRED: "NOT_PAIRED",
+    /** Agent turn timed out — caller may retry with `retryable: true`. */
+    AGENT_TIMEOUT: "AGENT_TIMEOUT",
+    /** Request shape failed validation. */
+    INVALID_REQUEST: "INVALID_REQUEST",
+    /** Approval lookup by id missed (id never existed or already resolved). */
+    APPROVAL_NOT_FOUND: "APPROVAL_NOT_FOUND",
+    /** Subsystem is loading / draining; caller may retry shortly. */
+    UNAVAILABLE: "UNAVAILABLE",
+};
+/** Helper to construct a typed `ProtocolErrorShape` from one of the known codes. */
+export function errorShape(code, message, opts = {}) {
+    return {
+        code,
+        message,
+        ...(opts.details !== undefined ? { details: opts.details } : {}),
+        ...(opts.retryable !== undefined ? { retryable: opts.retryable } : {}),
+        ...(opts.retryAfterMs !== undefined ? { retryAfterMs: opts.retryAfterMs } : {}),
+    };
+}
+//# sourceMappingURL=errors.js.map

package/dist/protocol/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/protocol/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,MAAM,CAAC,MAAM,UAAU,GAAG;IACzB,oEAAoE;IACpE,UAAU,EAAE,YAAY;IACxB,kDAAkD;IAClD,UAAU,EAAE,YAAY;IACxB,sEAAsE;IACtE,aAAa,EAAE,eAAe;IAC9B,uCAAuC;IACvC,eAAe,EAAE,iBAAiB;IAClC,2EAA2E;IAC3E,kBAAkB,EAAE,oBAAoB;IACxC,iEAAiE;IACjE,WAAW,EAAE,aAAa;CACjB,CAAC;AAUX,oFAAoF;AACpF,MAAM,UAAU,UAAU,CACzB,IAAe,EACf,OAAe,EACf,OAA0B,EAAE;IAE5B,OAAO;QACN,IAAI;QACJ,OAAO;QACP,GAAG,CAAC,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAChE,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACtE,GAAG,CAAC,IAAI,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC/E,CAAC;AACH,CAAC"}

package/dist/protocol/handshake.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Connect-frame + capability negotiation (Step 24).
+ *
+ * Brand-scrubbed analogue of upstream's connect/hello flow. Defines the
+ * THREE moving parts of the handshake:
+ *
+ *   - `PROTOCOL_VERSION`  — single integer; bumped only on breaking changes
+ *   - `ConnectParams`     — what the client sends in its first frame
+ *   - `HelloOk`           — server's reply confirming version + features
+ *
+ * Brigade's gateway accepts clients of multiple types (TUI, web UI,
+ * mobile, in-process agent tools). The shapes here are agnostic to
+ * transport — the same types describe an in-process call and a remote
+ * WebSocket.
+ */
+export declare const PROTOCOL_VERSION: 1;
+export declare const GatewayClientIds: {
+    readonly TUI: "brigade-tui";
+    readonly WEB_UI: "brigade-web";
+    readonly WEBCHAT: "brigade-webchat";
+    readonly CLI: "cli";
+    readonly GATEWAY_CLIENT: "gateway-client";
+    readonly MACOS_APP: "brigade-macos";
+    readonly IOS_APP: "brigade-ios";
+    readonly ANDROID_APP: "brigade-android";
+    readonly NODE_HOST: "node-host";
+    readonly TEST: "test";
+    readonly PROBE: "brigade-probe";
+};
+export type GatewayClientId = (typeof GatewayClientIds)[keyof typeof GatewayClientIds];
+export declare const GatewayClientModes: {
+    readonly WEBCHAT: "webchat";
+    readonly CLI: "cli";
+    readonly UI: "ui";
+    readonly BACKEND: "backend";
+    readonly NODE: "node";
+    readonly PROBE: "probe";
+    readonly TEST: "test";
+};
+export type GatewayClientMode = (typeof GatewayClientModes)[keyof typeof GatewayClientModes];
+export interface GatewayClientInfo {
+    id: GatewayClientId;
+    displayName?: string;
+    version: string;
+    platform: string;
+    deviceFamily?: string;
+    modelIdentifier?: string;
+    mode: GatewayClientMode;
+    instanceId?: string;
+}
+export declare const OperatorScopes: {
+    readonly ADMIN: "admin";
+    readonly APPROVALS: "approvals";
+    readonly PAIRING: "pairing";
+    readonly READ: "read";
+    readonly TALK_SECRETS: "talk-secrets";
+    readonly WRITE: "write";
+};
+export type OperatorScope = (typeof OperatorScopes)[keyof typeof OperatorScopes];
+export interface ConnectParams {
+    minProtocol: number;
+    maxProtocol: number;
+    client: GatewayClientInfo;
+    caps?: readonly string[];
+    commands?: readonly string[];
+    permissions?: Record<string, boolean>;
+    role?: "operator" | "node" | "device" | string;
+    scopes?: readonly OperatorScope[];
+    auth?: {
+        token?: string;
+        bootstrapToken?: string;
+        deviceToken?: string;
+        password?: string;
+    };
+    locale?: string;
+    userAgent?: string;
+}
+export interface HelloOk {
+    type: "hello-ok";
+    protocol: number;
+    server: {
+        version: string;
+        connId: string;
+    };
+    features: {
+        methods: readonly string[];
+        events: readonly string[];
+    };
+    policy: {
+        maxPayload: number;
+        maxBufferedBytes: number;
+        tickIntervalMs: number;
+    };
+    auth?: {
+        deviceToken?: string;
+        role?: string;
+        scopes?: readonly OperatorScope[];
+        issuedAtMs?: number;
+    };
+}
+//# sourceMappingURL=handshake.d.ts.map

package/dist/protocol/handshake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handshake.d.ts","sourceRoot":"","sources":["../../src/protocol/handshake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,gBAAgB,EAAG,CAAU,CAAC;AAI3C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAYnB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAEvF,eAAO,MAAM,kBAAkB;;;;;;;;CAQrB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE7F,MAAM,WAAW,iBAAiB;IACjC,EAAE,EAAE,eAAe,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,eAAO,MAAM,cAAc;;;;;;;CAOjB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAIjF,MAAM,WAAW,aAAa;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/C,MAAM,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;IAClC,IAAI,CAAC,EAAE;QACN,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAID,MAAM,WAAW,OAAO;IACvB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE;QACP,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;KACf,CAAC;IACF,QAAQ,EAAE;QACT,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;QAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;KAC1B,CAAC;IACF,MAAM,EAAE;QACP,UAAU,EAAE,MAAM,CAAC;QACnB,gBAAgB,EAAE,MAAM,CAAC;QACzB,cAAc,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,IAAI,CAAC,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;QAClC,UAAU,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACF"}

package/dist/protocol/handshake.js

@@ -0,0 +1,49 @@
+/**
+ * Connect-frame + capability negotiation (Step 24).
+ *
+ * Brand-scrubbed analogue of upstream's connect/hello flow. Defines the
+ * THREE moving parts of the handshake:
+ *
+ *   - `PROTOCOL_VERSION`  — single integer; bumped only on breaking changes
+ *   - `ConnectParams`     — what the client sends in its first frame
+ *   - `HelloOk`           — server's reply confirming version + features
+ *
+ * Brigade's gateway accepts clients of multiple types (TUI, web UI,
+ * mobile, in-process agent tools). The shapes here are agnostic to
+ * transport — the same types describe an in-process call and a remote
+ * WebSocket.
+ */
+export const PROTOCOL_VERSION = 1;
+/* ─── Client identity ───────────────────────────────────────────── */
+export const GatewayClientIds = {
+    TUI: "brigade-tui",
+    WEB_UI: "brigade-web",
+    WEBCHAT: "brigade-webchat",
+    CLI: "cli",
+    GATEWAY_CLIENT: "gateway-client",
+    MACOS_APP: "brigade-macos",
+    IOS_APP: "brigade-ios",
+    ANDROID_APP: "brigade-android",
+    NODE_HOST: "node-host",
+    TEST: "test",
+    PROBE: "brigade-probe",
+};
+export const GatewayClientModes = {
+    WEBCHAT: "webchat",
+    CLI: "cli",
+    UI: "ui",
+    BACKEND: "backend",
+    NODE: "node",
+    PROBE: "probe",
+    TEST: "test",
+};
+/* ─── Operator scopes ───────────────────────────────────────────── */
+export const OperatorScopes = {
+    ADMIN: "admin",
+    APPROVALS: "approvals",
+    PAIRING: "pairing",
+    READ: "read",
+    TALK_SECRETS: "talk-secrets",
+    WRITE: "write",
+};
+//# sourceMappingURL=handshake.js.map

package/dist/protocol/handshake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handshake.js","sourceRoot":"","sources":["../../src/protocol/handshake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAU,CAAC;AAE3C,uEAAuE;AAEvE,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC/B,GAAG,EAAE,aAAa;IAClB,MAAM,EAAE,aAAa;IACrB,OAAO,EAAE,iBAAiB;IAC1B,GAAG,EAAE,KAAK;IACV,cAAc,EAAE,gBAAgB;IAChC,SAAS,EAAE,eAAe;IAC1B,OAAO,EAAE,aAAa;IACtB,WAAW,EAAE,iBAAiB;IAC9B,SAAS,EAAE,WAAW;IACtB,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,eAAe;CACb,CAAC;AAIX,MAAM,CAAC,MAAM,kBAAkB,GAAG;IACjC,OAAO,EAAE,SAAS;IAClB,GAAG,EAAE,KAAK;IACV,EAAE,EAAE,IAAI;IACR,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;CACH,CAAC;AAeX,uEAAuE;AAEvE,MAAM,CAAC,MAAM,cAAc,GAAG;IAC7B,KAAK,EAAE,OAAO;IACd,SAAS,EAAE,WAAW;IACtB,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,YAAY,EAAE,cAAc;IAC5B,KAAK,EAAE,OAAO;CACL,CAAC"}

package/dist/protocol/messages.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Wire-level message envelope union (Step 24).
+ *
+ * Brand-scrubbed analogue of upstream's `src/gateway/protocol/schema/frames.ts`.
+ * Defines the FOUR top-level frame shapes that travel over the gateway
+ * WebSocket (or any in-process equivalent transport):
+ *
+ *   - `req`   — request from client to server with method + params + id
+ *   - `res`   — response from server to client with ok + payload | error
+ *   - `event` — server-pushed event with stream name + payload + seq
+ *   - `tick`  — server keepalive carrying timestamp (for stall detection)
+ *
+ * Brigade's `gateway-call.ts` (Step 18) consumes these types through the
+ * `GatewayCaller` interface; this file is the schema-level source of truth.
+ *
+ * Naming + shape match upstream verbatim so the dev-tools network panel
+ * is portable between the reference and Brigade traces.
+ */
+/** Structured error returned in `res.error`. */
+export interface ProtocolErrorShape {
+    code: string;
+    message: string;
+    details?: unknown;
+    retryable?: boolean;
+    retryAfterMs?: number;
+}
+/** Client → server: request a method invocation. */
+export interface RequestFrame {
+    type: "req";
+    id: string;
+    method: string;
+    params?: unknown;
+}
+/** Server → client: paired response to a request. */
+export interface ResponseFrame {
+    type: "res";
+    id: string;
+    ok: boolean;
+    payload?: unknown;
+    error?: ProtocolErrorShape;
+}
+/** Server → client: pushed event with optional seq + state-version. */
+export interface EventFrame {
+    type: "event";
+    event: string;
+    payload?: unknown;
+    seq?: number;
+    stateVersion?: StateVersion;
+}
+/** Server → client: low-cost keepalive carrying server timestamp. */
+export interface TickFrame {
+    type: "tick";
+    ts: number;
+}
+/** Server → client: graceful shutdown notice. */
+export interface ShutdownFrame {
+    type: "shutdown";
+    reason: string;
+    restartExpectedMs?: number;
+}
+/** Discriminated union of every top-level frame. */
+export type GatewayFrame = RequestFrame | ResponseFrame | EventFrame | TickFrame | ShutdownFrame;
+/** Optional state-version carried on event frames (clients can detect drift). */
+export interface StateVersion {
+    domain: string;
+    version: number;
+}
+//# sourceMappingURL=messages.d.ts.map

package/dist/protocol/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/protocol/messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,gDAAgD;AAChD,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,oDAAoD;AACpD,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,qDAAqD;AACrD,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,KAAK,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC3B;AAED,uEAAuE;AACvE,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,YAAY,CAAC;CAC5B;AAED,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACX;AAED,iDAAiD;AACjD,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,oDAAoD;AACpD,MAAM,MAAM,YAAY,GACrB,YAAY,GACZ,aAAa,GACb,UAAU,GACV,SAAS,GACT,aAAa,CAAC;AAEjB,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CAChB"}

package/dist/protocol/messages.js

@@ -0,0 +1,20 @@
+/**
+ * Wire-level message envelope union (Step 24).
+ *
+ * Brand-scrubbed analogue of upstream's `src/gateway/protocol/schema/frames.ts`.
+ * Defines the FOUR top-level frame shapes that travel over the gateway
+ * WebSocket (or any in-process equivalent transport):
+ *
+ *   - `req`   — request from client to server with method + params + id
+ *   - `res`   — response from server to client with ok + payload | error
+ *   - `event` — server-pushed event with stream name + payload + seq
+ *   - `tick`  — server keepalive carrying timestamp (for stall detection)
+ *
+ * Brigade's `gateway-call.ts` (Step 18) consumes these types through the
+ * `GatewayCaller` interface; this file is the schema-level source of truth.
+ *
+ * Naming + shape match upstream verbatim so the dev-tools network panel
+ * is portable between the reference and Brigade traces.
+ */
+export {};
+//# sourceMappingURL=messages.js.map

package/dist/protocol/messages.js.map

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