@superblocksteam/vite-plugin-file-sync 1.99.99-next.2 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

package/dist/server-rpc/index.js

@@ -0,0 +1,344 @@
+import { getErrorMeta } from "../util/logger.js";
+import { connectToISocketRPCServer, } from "./client.js";
+import { runWithRequestAbortSignal } from "./request-abort-context.js";
+import { recordRpcInvalidate, } from "./rpc-invalidate-metrics.js";
+/** Socket error code for "the server never answered this request". */
+const NO_RESPONSE_TIMEOUT_CODE = 7;
+/** Close reason recorded on requests abandoned by a forced shutdown. */
+const FORCED_SHUTDOWN_REASON = "rpc client forced shutdown";
+export function isNoResponseTimeoutError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "number" &&
+        error.code === NO_RESPONSE_TIMEOUT_CODE);
+}
+export class AutoConnectingRpcClient {
+    superblocksBaseUrl;
+    authToken;
+    _tracer;
+    tokenManager;
+    _logger;
+    _rpcClient = null;
+    _isShuttingDown = false;
+    _closePromise = null;
+    _connectPromise = null;
+    _connectEpoch = 0;
+    _activeOperations = 0;
+    _socketCloseCode;
+    /**
+     * Client currently inside `closeWithTimeout` after `_rpcClient` was nulled.
+     * Lets an invalidate that races a plain close() still reject pendings — a
+     * plain `ISocket.close()` uses INTENTIONAL_CLOSE_CODE and does not.
+     */
+    _closingClient = null;
+    constructor(superblocksBaseUrl, authToken, _tracer, tokenManager, _logger) {
+        this.superblocksBaseUrl = superblocksBaseUrl;
+        this.authToken = authToken;
+        this._tracer = _tracer;
+        this.tokenManager = tokenManager;
+        this._logger = _logger;
+        this.tokenManager.on("tokenUpdated", (event) => {
+            this.getLogger().info(`[ai-service] Token refresh triggered socket reconnection`);
+            // Fire-and-forget reconnection, so guard the whole chain. Both close() and
+            // the eager getRpcClient() can reject — most notably getRpcClient() throws
+            // after exhausting its connect retries, which is likely precisely during an
+            // in-place restart when the server is briefly unreachable. An unguarded
+            // rejection here would surface as a process-fatal unhandledRejection and
+            // wedge the pod; instead, log it and let the next call() reconnect lazily
+            // (APPS-4797 / APPS-4667).
+            void this.reconnectAfterTokenUpdate(event.token).catch((error) => {
+                this.getLogger().warn(`[rpc-client] token-refresh reconnection failed; will reconnect lazily on next call`, getErrorMeta(error));
+            });
+        });
+    }
+    async reconnectAfterTokenUpdate(token) {
+        await this.close();
+        this.authToken = token;
+        await this.getRpcClient();
+    }
+    getLogger() {
+        return this._logger;
+    }
+    get socketCloseCode() {
+        return this._socketCloseCode;
+    }
+    get authTokenValue() {
+        return this.authToken;
+    }
+    get baseUrl() {
+        return this.superblocksBaseUrl;
+    }
+    async waitUntilReady() {
+        if (this._closePromise) {
+            await this._closePromise;
+        }
+    }
+    async getRpcClient() {
+        await this.waitUntilReady();
+        if (this._rpcClient) {
+            return this._rpcClient;
+        }
+        // Single-flight: concurrent callers resuming off the same close()/reconnect
+        // share one connect attempt so we never open (and leak) a second socket.
+        if (!this._connectPromise) {
+            this._connectPromise = this.connect().finally(() => {
+                this._connectPromise = null;
+            });
+        }
+        return this._connectPromise;
+    }
+    async connect() {
+        // Snapshot the epoch so a connect that began before a close()/reconnect is
+        // not adopted afterward. Without this a socket opened with a pre-refresh
+        // token could finish after close() and be handed to post-close callers,
+        // defeating the very token refresh this reconnect is performing.
+        const epoch = this._connectEpoch;
+        let client = null;
+        let connectionAttempts = 0;
+        while (connectionAttempts < 3) {
+            try {
+                // This can fail if the initial WS connection fails due to a network issue, so we retry up to 3 times
+                client = await connectToISocketRPCServer({
+                    superblocksBaseUrl: this.superblocksBaseUrl,
+                    token: this.authToken,
+                    tracer: this._tracer,
+                    onClose: (event) => {
+                        this.getLogger().info(`[rpc-client] socket closed with code: ${event.code}`);
+                        this._socketCloseCode = event.code;
+                        // Only clear the shared handle if this socket is still the active
+                        // one; a superseded (stale) socket closing must not null a newer
+                        // client that a concurrent reconnect already installed.
+                        if (this._rpcClient === client) {
+                            this._rpcClient = null;
+                        }
+                    },
+                });
+            }
+            catch (error) {
+                connectionAttempts++;
+                console.error(`Failed on attempt ${connectionAttempts} to get connection:`, error.message);
+            }
+            if (client) {
+                break;
+            }
+            // Wait 5 seconds before retrying
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+        if (!client) {
+            throw new Error("Failed to connect to socket after 3 attempts");
+        }
+        if (epoch !== this._connectEpoch) {
+            // A close() landed while we were connecting. Tear down this now-stale
+            // socket and surface a transient error so callers reconnect fresh with
+            // the current token instead of reusing the pre-refresh connection.
+            try {
+                await client.close();
+            }
+            catch {
+                // Best-effort teardown; the socket is already being discarded.
+            }
+            throw new Error("RPC client is shutting down");
+        }
+        this._rpcClient = client;
+        return client;
+    }
+    /**
+     * Executes an RPC operations with lifecycle management.
+     */
+    async call(operation, options) {
+        // Resolve the client first (which itself waits through any in-flight
+        // close()/reconnect). We only claim an active-operation slot once we hold a
+        // live client, so waiting on close() never blocks doClose()'s drain loop —
+        // that self-deadlock previously stalled callers until the 5s force-shutdown.
+        const client = await this.getRpcClient();
+        this._activeOperations++;
+        try {
+            return await runWithRequestAbortSignal(options?.signal, () => operation(client));
+        }
+        catch (error) {
+            if (isNoResponseTimeoutError(error)) {
+                this.invalidate("no_response_timeout", client);
+            }
+            throw error;
+        }
+        finally {
+            this._activeOperations--;
+        }
+    }
+    /**
+     * Force-close the shared RPC socket so the next call() reconnects, rejecting
+     * whatever was still pending on it.
+     * When `client` is provided, only acts if that handle is still one we own —
+     * the active socket, or one a concurrent close is currently tearing down.
+     * Anything else is a socket a reconnect already replaced, and closing it
+     * would take down the healthy replacement instead.
+     */
+    invalidate(reason, client) {
+        if (client !== undefined &&
+            this._rpcClient !== client &&
+            this._closingClient !== client) {
+            recordRpcInvalidate({ reason, outcome: "skipped_stale_client" });
+            this.warnStructured("[rpc-client] skipping invalidate; timed-out client already replaced", { "rpc.invalidate.reason": reason });
+            return;
+        }
+        recordRpcInvalidate({ reason, outcome: "invalidated" });
+        this.warnStructured("[rpc-client] invalidating RPC client", {
+            "rpc.invalidate.reason": reason,
+        });
+        void this.closeInternal(reason).catch((error) => {
+            this.getLogger().warn(`[rpc-client] invalidate close failed; will reconnect lazily on next call`, getErrorMeta(error));
+        });
+    }
+    warnStructured(message, attributes) {
+        const logger = this.getLogger();
+        if (logger.warnStructured) {
+            logger.warnStructured(message, attributes);
+            return;
+        }
+        logger.warn(message, attributes);
+    }
+    close() {
+        return this.closeInternal();
+    }
+    /**
+     * @param rejectPendingReason when set, the socket is torn down with
+     * `closeAndRejectPendingRequests` instead of `close()`. See {@link doClose}.
+     */
+    closeInternal(rejectPendingReason) {
+        if (this._closePromise && rejectPendingReason !== undefined) {
+            // A close() is already running — most likely a token-refresh reconnect,
+            // which intentionally leaves pending requests alone. Joining it would
+            // silently drop this invalidation's whole point, so reject here instead.
+            // The in-flight close may already have nulled `_rpcClient` before awaiting
+            // client.close(); rejectPendingRequests falls back to `_closingClient` so
+            // pendings still settle (plain close uses INTENTIONAL_CLOSE_CODE and does
+            // not reject them). The promise returned below belongs to that other close
+            // and deliberately does not wait on this: the rejection lands once the
+            // handle is read, and callers only need the socket gone.
+            void this.rejectPendingRequests(rejectPendingReason).catch((error) => {
+                this.getLogger().warn(`[rpc-client] rejecting pending requests failed; reconnecting on next call`, getErrorMeta(error));
+            });
+        }
+        if (!this._closePromise) {
+            // Advance the epoch and abandon any in-flight connect reference: a new
+            // getRpcClient() after this close starts a fresh connect (with the
+            // current token) rather than adopting the connect that was racing us.
+            // The abandoned connect self-discards its socket via the epoch check.
+            this._connectEpoch++;
+            this._connectPromise = null;
+            this._closePromise = this.doClose(rejectPendingReason).finally(() => {
+                this._closePromise = null;
+            });
+        }
+        return this._closePromise;
+    }
+    /**
+     * @param rejectPendingReason set by the invalidate path. `ISocket.close()`
+     * closes with `INTENTIONAL_CLOSE_CODE`, and the socket's own close listener
+     * deliberately skips its reject-pending loop for that code — so a plain
+     * close() leaves every request already in flight (facts, chat load, lock
+     * service) to expire on its own 5-minute `noResponseTimeout`, which is the
+     * multi-minute wedge this teardown exists to remove.
+     * `closeAndRejectPendingRequests` settles them now. Token refresh and
+     * shutdown keep the plain close so in-flight calls on a healthy socket can
+     * finish; anything that fails to drain is rejected below regardless.
+     */
+    async doClose(rejectPendingReason) {
+        this._isShuttingDown = true;
+        // Wait for active operations to finish with timeout
+        const maxWaitTime = 5_000;
+        const startTime = Date.now();
+        if (rejectPendingReason !== undefined) {
+            // Reject before draining, not after: on a half-open socket the active
+            // operations are exactly the ones that will never settle, so draining
+            // first would burn the full 5s budget and then close underneath them.
+            // Rejecting first is also what lets the loop below drain at all.
+            await this.rejectPendingRequests(rejectPendingReason);
+        }
+        while (this._activeOperations > 0 && Date.now() - startTime < maxWaitTime) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        if (this._activeOperations > 0) {
+            this.getLogger().warn(`[rpc-client] Forced shutdown of RPC client with ${this._activeOperations} active operations`);
+            // Reaching the deadline means we are about to close a socket that still
+            // has work on it. Operations on a healthy socket drain inside the loop
+            // above, so the survivors are wedged ones — most often facts or lock
+            // calls, which carry no abort signal and no caller-side bound. A plain
+            // close() would leave them unreachable (INTENTIONAL_CLOSE_CODE skips the
+            // socket's own reject loop) until their 5-minute no-response timeout, so
+            // settle them here regardless of how this close was requested.
+            await this.rejectPendingRequests(FORCED_SHUTDOWN_REASON);
+        }
+        if (this._rpcClient) {
+            const client = this._rpcClient;
+            // Drop the handle before awaiting close(): callers now block on
+            // `_closePromise` (which only clears once this method resolves), so a
+            // socket close() that hangs would otherwise wedge every subsequent RPC
+            // call indefinitely. Bounding it degrades a stuck socket to a fresh
+            // reconnect on the next call() instead of a permanent hang.
+            // Stash on `_closingClient` so a concurrent invalidate can still reject
+            // pendings — plain close() uses INTENTIONAL_CLOSE_CODE and will not.
+            this._rpcClient = null;
+            this._closingClient = client;
+            try {
+                await this.closeWithTimeout(client, maxWaitTime);
+            }
+            finally {
+                if (this._closingClient === client) {
+                    this._closingClient = null;
+                }
+            }
+        }
+        this._isShuttingDown = false;
+    }
+    /**
+     * Drop the active (or in-flight-closing) handle and settle everything pending
+     * on it now. No-op when there is no client to reject on.
+     */
+    async rejectPendingRequests(reason) {
+        const client = this._rpcClient ?? this._closingClient;
+        if (!client) {
+            return;
+        }
+        if (this._rpcClient === client) {
+            this._rpcClient = null;
+        }
+        if (this._closingClient === client) {
+            this._closingClient = null;
+        }
+        try {
+            client.closeAndRejectPendingRequests(reason);
+        }
+        catch (error) {
+            this.getLogger().warn(`[rpc-client] rejecting pending requests failed; closing the socket instead`, getErrorMeta(error));
+            // The handle is already dropped, so nothing else will close this socket.
+            await this.closeWithTimeout(client, 5_000);
+        }
+    }
+    async closeWithTimeout(client, timeoutMs) {
+        let timer;
+        try {
+            await Promise.race([
+                Promise.resolve(client.close()),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => {
+                        this.getLogger().warn(`[rpc-client] socket close() exceeded ${timeoutMs}ms; abandoning it and reconnecting on next call`);
+                        resolve();
+                    }, timeoutMs);
+                }),
+            ]);
+        }
+        catch (error) {
+            // Best-effort teardown; the handle is already cleared so the next call
+            // reconnects regardless of how close() failed.
+            this.getLogger().warn(`[rpc-client] socket close() failed; reconnecting on next call`, getErrorMeta(error));
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/server-rpc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/server-rpc/index.ts"],"names":[],"mappings":"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"}

package/dist/server-rpc/request-abort-context.d.ts

@@ -0,0 +1,3 @@
+export declare function runWithRequestAbortSignal<T>(signal: AbortSignal | undefined, fn: () => T): T;
+export declare function getRequestAbortSignal(): AbortSignal | undefined;
+//# sourceMappingURL=request-abort-context.d.ts.map

package/dist/server-rpc/request-abort-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-abort-context.d.ts","sourceRoot":"","sources":["../../src/server-rpc/request-abort-context.ts"],"names":[],"mappings":"AAoBA,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAEH;AAED,wBAAgB,qBAAqB,IAAI,WAAW,GAAG,SAAS,CAE/D"}

package/dist/server-rpc/request-abort-context.js

@@ -0,0 +1,23 @@
+/**
+ * Threads a caller's AbortSignal to the socket without putting
+ * `node:async_hooks` in `@superblocksteam/shared` (browser bundles import it).
+ *
+ * Contract this depends on: `ISocket.request()` must read its `getAbortSignal`
+ * callback synchronously, inside the same async context as the operation passed
+ * to `AutoConnectingRpcClient.call`. It does today — the read happens in the
+ * `new Promise` executor. If the socket ever defers it to a later tick,
+ * `getStore()` returns undefined and cancellation silently stops working;
+ * `server-rpc/index.test.ts` ("call({ signal }) cancels an in-flight RPC when
+ * aborted") drives a real ISocket and fails if that happens. A request made
+ * outside any `runWithRequestAbortSignal` scope simply gets `undefined`, which
+ * the socket treats as "no signal".
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+const requestAbortSignalStorage = new AsyncLocalStorage();
+export function runWithRequestAbortSignal(signal, fn) {
+    return requestAbortSignalStorage.run(signal, fn);
+}
+export function getRequestAbortSignal() {
+    return requestAbortSignalStorage.getStore();
+}
+//# sourceMappingURL=request-abort-context.js.map

package/dist/server-rpc/request-abort-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-abort-context.js","sourceRoot":"","sources":["../../src/server-rpc/request-abort-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,yBAAyB,GAAG,IAAI,iBAAiB,EAEpD,CAAC;AAEJ,MAAM,UAAU,yBAAyB,CACvC,MAA+B,EAC/B,EAAW;IAEX,OAAO,yBAAyB,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,yBAAyB,CAAC,QAAQ,EAAE,CAAC;AAC9C,CAAC"}

package/dist/server-rpc/rpc-invalidate-metrics.d.ts

@@ -0,0 +1,20 @@
+/**
+ * What made the client suspect the socket was dead: `no_response_timeout` is
+ * the socket's own no-response error; `chat_push_timeout` is the local
+ * per-push bound in `ChatSessionStore.PUSH_TIMEOUT_MS` elapsing first.
+ */
+export declare const RPC_INVALIDATE_REASONS: readonly ["chat_push_timeout", "no_response_timeout"];
+export type RpcInvalidateReason = (typeof RPC_INVALIDATE_REASONS)[number];
+/**
+ * `invalidated` means the socket was torn down; `skipped_stale_client` means a
+ * concurrent reconnect had already replaced the handle the timed-out call used,
+ * so the healthy replacement was left alone.
+ */
+export declare const RPC_INVALIDATE_OUTCOMES: readonly ["invalidated", "skipped_stale_client"];
+export type RpcInvalidateOutcome = (typeof RPC_INVALIDATE_OUTCOMES)[number];
+export declare function recordRpcInvalidate(input: {
+    reason: RpcInvalidateReason;
+    outcome: RpcInvalidateOutcome;
+}): void;
+export declare function _resetRpcInvalidateMetricsForTesting(): void;
+//# sourceMappingURL=rpc-invalidate-metrics.d.ts.map

package/dist/server-rpc/rpc-invalidate-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-invalidate-metrics.d.ts","sourceRoot":"","sources":["../../src/server-rpc/rpc-invalidate-metrics.ts"],"names":[],"mappings":"AAyBA;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,uDAGzB,CAAC;AACX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,kDAG1B,CAAC;AACX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAqD5E,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,EAAE,oBAAoB,CAAC;CAC/B,GAAG,IAAI,CAEP;AAED,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D"}

package/dist/server-rpc/rpc-invalidate-metrics.js

@@ -0,0 +1,86 @@
+/**
+ * Shared-socket invalidation metrics.
+ *
+ * Half-open recovery is self-healing: when it works, nothing shows up in a
+ * customer report and nothing shows up in a log-based monitor except a single
+ * warn line. This counter is the signal that says the recovery path is firing
+ * in prod at all, and how often each trigger fires — which is exactly what was
+ * missing while a wedged socket sat there for sixteen minutes.
+ *
+ * Wiring follows `chat-push-metrics.ts`: the meter resolves lazily from the
+ * OTel global and the instrument re-binds when the global MeterProvider
+ * changes (tests swap providers per case). Zero-config process singleton — no
+ * DI plumbing.
+ *
+ * Metric:
+ *
+ *   - `superblocks.clark.rpc.invalidations` counter
+ *     {rpc.invalidate.reason, rpc.invalidate.outcome}
+ *
+ * Cardinality budget: reason ≤ 2 × outcome ≤ 2 → 4 worst-case series. Both
+ * labels are compile-time closed unions supplied by Superblocks-owned call
+ * sites (never derived from user input or error text).
+ */
+import { metrics } from "@opentelemetry/api";
+/**
+ * What made the client suspect the socket was dead: `no_response_timeout` is
+ * the socket's own no-response error; `chat_push_timeout` is the local
+ * per-push bound in `ChatSessionStore.PUSH_TIMEOUT_MS` elapsing first.
+ */
+export const RPC_INVALIDATE_REASONS = [
+    "chat_push_timeout",
+    "no_response_timeout",
+];
+/**
+ * `invalidated` means the socket was torn down; `skipped_stale_client` means a
+ * concurrent reconnect had already replaced the handle the timed-out call used,
+ * so the healthy replacement was left alone.
+ */
+export const RPC_INVALIDATE_OUTCOMES = [
+    "invalidated",
+    "skipped_stale_client",
+];
+const METER_NAME = "superblocks.clark.rpc";
+const METRIC_INVALIDATIONS = "superblocks.clark.rpc.invalidations";
+const ATTR_REASON = "rpc.invalidate.reason";
+const ATTR_OUTCOME = "rpc.invalidate.outcome";
+class RpcInvalidateMetrics {
+    cachedMeter;
+    cachedCounter;
+    /**
+     * Lazy instrument factory. Re-creates the counter when the global
+     * MeterProvider changes (a stale instrument bound to a replaced provider
+     * silently drops data).
+     */
+    getCounter() {
+        const meter = metrics.getMeter(METER_NAME);
+        if (meter === this.cachedMeter && this.cachedCounter) {
+            return this.cachedCounter;
+        }
+        this.cachedMeter = meter;
+        this.cachedCounter = meter.createCounter(METRIC_INVALIDATIONS, {
+            description: "Times the live-edit → server RPC socket was force-closed because it looked half-open.",
+            unit: "{invalidation}",
+        });
+        return this.cachedCounter;
+    }
+    record(input) {
+        this.getCounter().add(1, {
+            [ATTR_REASON]: input.reason,
+            [ATTR_OUTCOME]: input.outcome,
+        });
+    }
+    /** Drop cached instrument bindings (tests swap the global provider). */
+    _resetForTesting() {
+        this.cachedMeter = undefined;
+        this.cachedCounter = undefined;
+    }
+}
+const rpcInvalidateMetrics = new RpcInvalidateMetrics();
+export function recordRpcInvalidate(input) {
+    rpcInvalidateMetrics.record(input);
+}
+export function _resetRpcInvalidateMetricsForTesting() {
+    rpcInvalidateMetrics._resetForTesting();
+}
+//# sourceMappingURL=rpc-invalidate-metrics.js.map

package/dist/server-rpc/rpc-invalidate-metrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-invalidate-metrics.js","sourceRoot":"","sources":["../../src/server-rpc/rpc-invalidate-metrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,OAAO,EAAc,MAAM,oBAAoB,CAAC;AAEzD;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,mBAAmB;IACnB,qBAAqB;CACb,CAAC;AAGX;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,aAAa;IACb,sBAAsB;CACd,CAAC;AAGX,MAAM,UAAU,GAAG,uBAAuB,CAAC;AAE3C,MAAM,oBAAoB,GAAG,qCAAqC,CAAC;AAEnE,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAC5C,MAAM,YAAY,GAAG,wBAAwB,CAAC;AAI9C,MAAM,oBAAoB;IAChB,WAAW,CAAoB;IAC/B,aAAa,CAAsB;IAE3C;;;;OAIG;IACK,UAAU;QAChB,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC3C,IAAI,KAAK,KAAK,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACrD,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC,oBAAoB,EAAE;YAC7D,WAAW,EACT,uFAAuF;YACzF,IAAI,EAAE,gBAAgB;SACvB,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,MAAM,CAAC,KAGN;QACC,IAAI,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE;YACvB,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,MAAM;YAC3B,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC,OAAO;SAC9B,CAAC,CAAC;IACL,CAAC;IAED,wEAAwE;IACxE,gBAAgB;QACd,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;QAC7B,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;IACjC,CAAC;CACF;AAED,MAAM,oBAAoB,GAAG,IAAI,oBAAoB,EAAE,CAAC;AAExD,MAAM,UAAU,mBAAmB,CAAC,KAGnC;IACC,oBAAoB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACrC,CAAC;AAED,MAAM,UAAU,oCAAoC;IAClD,oBAAoB,CAAC,gBAAgB,EAAE,CAAC;AAC1C,CAAC"}

package/dist/snapshot-routes.d.ts

@@ -0,0 +1,18 @@
+import type { ViteDevServer } from "vite";
+import { type SnapshotManager } from "./ai-service/recording/snapshot-manager.js";
+import type { createSocketManager } from "./socket-manager.js";
+import { type Logger } from "./util/logger.js";
+interface SnapshotRoutesOptions {
+    getIsInitialized: () => boolean;
+    appRootDir: string;
+    snapshotManager?: SnapshotManager;
+    socketManager: ReturnType<typeof createSocketManager>;
+    logger: Logger;
+    /** When provided, integration IDs are analyzed during restore. */
+    getAvailableIntegrationIds?: () => Promise<Set<string>>;
+    /** Gate all snapshot endpoints behind this flag. */
+    isSessionManagementEnabled: boolean;
+}
+export declare function registerSnapshotRoutes(server: ViteDevServer, options: SnapshotRoutesOptions): void;
+export {};
+//# sourceMappingURL=snapshot-routes.d.ts.map

package/dist/snapshot-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-routes.d.ts","sourceRoot":"","sources":["../src/snapshot-routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAE1C,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE7D,UAAU,qBAAqB;IAC7B,gBAAgB,EAAE,MAAM,OAAO,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,aAAa,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,0BAA0B,CAAC,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,oDAAoD;IACpD,0BAA0B,EAAE,OAAO,CAAC;CACrC;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,qBAAqB,GAC7B,IAAI,CAqVN"}