@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/file-explorer/service.js

@@ -0,0 +1,308 @@
+import { constants, promises as fs } from "fs";
+import path from "path";
+import { UPLOAD_CHUNK_SIZE_BYTES } from "@hyperdrive.bot/paseo-protocol/binary-frames/chunk-size";
+import { expandUserPath, resolvePathFromBase } from "../path-utils.js";
+const TEXT_MIME_TYPES = {
+    ".json": "application/json",
+};
+const DEFAULT_TEXT_MIME_TYPE = "text/plain";
+const FILE_TYPE_SAMPLE_BYTES = 8192;
+const READ_FILE_OPEN_FLAGS = process.platform === "win32" ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NOFOLLOW;
+const ACCESS_OUTSIDE_WORKSPACE_MESSAGE = "Access outside of workspace is not allowed";
+const IMAGE_MIME_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+};
+export async function listDirectoryEntries({ root, relativePath = ".", }) {
+    const directoryPath = await resolveScopedPath({ root, relativePath });
+    const stats = await fs.stat(directoryPath.resolvedPath);
+    if (!stats.isDirectory()) {
+        throw new Error("Requested path is not a directory");
+    }
+    const dirents = await fs.readdir(directoryPath.resolvedPath, { withFileTypes: true });
+    const entriesWithNulls = await Promise.all(dirents.map(async (dirent) => {
+        const targetPath = path.join(directoryPath.requestedPath, dirent.name);
+        const kind = dirent.isDirectory() ? "directory" : "file";
+        try {
+            return await buildEntryPayload({
+                root,
+                targetPath,
+                name: dirent.name,
+                kind,
+            });
+        }
+        catch (error) {
+            // Directories can contain dangling links (e.g. AGENTS.md -> CLAUDE.md).
+            // Skip entries whose targets disappeared instead of failing the whole listing.
+            if (isMissingEntryError(error) || isOutsideWorkspaceError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }));
+    const entries = entriesWithNulls.filter((entry) => entry !== null);
+    entries.sort((a, b) => {
+        const modifiedComparison = new Date(b.modifiedAt).getTime() - new Date(a.modifiedAt).getTime();
+        if (modifiedComparison !== 0) {
+            return modifiedComparison;
+        }
+        return a.name.localeCompare(b.name);
+    });
+    return {
+        path: normalizeRelativePath({ root, targetPath: directoryPath.requestedPath }),
+        entries,
+    };
+}
+export async function readExplorerFile({ root, relativePath, }) {
+    const file = await readExplorerFileBytes({ root, relativePath });
+    if (file.kind === "image") {
+        return {
+            path: file.path,
+            kind: file.kind,
+            encoding: "base64",
+            content: Buffer.from(file.bytes).toString("base64"),
+            mimeType: file.mimeType,
+            size: file.size,
+            modifiedAt: file.modifiedAt,
+        };
+    }
+    if (file.kind === "binary") {
+        return {
+            path: file.path,
+            kind: file.kind,
+            encoding: "none",
+            mimeType: file.mimeType,
+            size: file.size,
+            modifiedAt: file.modifiedAt,
+        };
+    }
+    return {
+        path: file.path,
+        kind: file.kind,
+        encoding: "utf-8",
+        content: Buffer.from(file.bytes).toString("utf-8"),
+        mimeType: file.mimeType,
+        size: file.size,
+        modifiedAt: file.modifiedAt,
+    };
+}
+export async function readExplorerFileBytes({ root, relativePath, }) {
+    const filePath = await resolveScopedPath({ root, relativePath });
+    const handle = await openFileForRead(filePath.resolvedPath);
+    try {
+        const stats = await handle.stat();
+        if (!stats.isFile()) {
+            throw new Error("Requested path is not a file");
+        }
+        const ext = path.extname(filePath.resolvedPath).toLowerCase();
+        const basePayload = {
+            path: normalizeRelativePath({ root, targetPath: filePath.requestedPath }),
+            size: stats.size,
+            modifiedAt: stats.mtime.toISOString(),
+        };
+        const buffer = await handle.readFile();
+        if (ext in IMAGE_MIME_TYPES) {
+            return {
+                ...basePayload,
+                kind: "image",
+                encoding: "binary",
+                bytes: buffer,
+                mimeType: IMAGE_MIME_TYPES[ext],
+            };
+        }
+        if (isLikelyBinary(buffer)) {
+            return {
+                ...basePayload,
+                kind: "binary",
+                encoding: "binary",
+                bytes: buffer,
+                mimeType: "application/octet-stream",
+            };
+        }
+        return {
+            ...basePayload,
+            kind: "text",
+            encoding: "utf-8",
+            bytes: buffer,
+            mimeType: textMimeTypeForExtension(ext),
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Open a file for a streaming binary download. Mirrors `readExplorerFileBytes`'s
+ * mime/kind/encoding detection but NEVER loads the whole file: it classifies the
+ * file from a bounded detection prefix and returns the still-open handle so the
+ * caller can stream chunk-sized positioned reads (see `encodeFileDownloadFrames`).
+ *
+ * The returned handle is the caller's to close — the success path transfers
+ * ownership; only the error path closes it here to avoid leaking a descriptor.
+ *
+ * @returns the open file handle, FileBegin metadata, and the workspace-relative path.
+ * @throws if the path resolves outside the workspace or is not a regular file.
+ */
+export async function openExplorerFileForDownload({ root, relativePath, }) {
+    const filePath = await resolveScopedPath({ root, relativePath });
+    const handle = await openFileForRead(filePath.resolvedPath);
+    try {
+        const stats = await handle.stat();
+        if (!stats.isFile()) {
+            throw new Error("Requested path is not a file");
+        }
+        const ext = path.extname(filePath.resolvedPath).toLowerCase();
+        const normalizedPath = normalizeRelativePath({ root, targetPath: filePath.requestedPath });
+        const baseMetadata = {
+            size: stats.size,
+            modifiedAt: stats.mtime.toISOString(),
+        };
+        if (ext in IMAGE_MIME_TYPES) {
+            return {
+                handle,
+                path: normalizedPath,
+                metadata: { ...baseMetadata, mime: IMAGE_MIME_TYPES[ext], encoding: "binary" },
+            };
+        }
+        // Detection-only read: classify the file from a bounded prefix (≤ one chunk)
+        // instead of `handle.readFile()`-ing the whole file, which would defeat the
+        // streaming download path.
+        const detectionLength = Math.min(stats.size, UPLOAD_CHUNK_SIZE_BYTES);
+        let detectionBytes = Buffer.alloc(0);
+        if (detectionLength > 0) {
+            const prefix = Buffer.allocUnsafe(detectionLength);
+            const { bytesRead } = await handle.read(prefix, 0, detectionLength, 0);
+            detectionBytes = bytesRead < prefix.length ? prefix.subarray(0, bytesRead) : prefix;
+        }
+        if (isLikelyBinary(detectionBytes)) {
+            return {
+                handle,
+                path: normalizedPath,
+                metadata: { ...baseMetadata, mime: "application/octet-stream", encoding: "binary" },
+            };
+        }
+        return {
+            handle,
+            path: normalizedPath,
+            metadata: { ...baseMetadata, mime: textMimeTypeForExtension(ext), encoding: "utf-8" },
+        };
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+}
+export async function getDownloadableFileInfo({ root, relativePath }) {
+    const filePath = await resolveScopedPath({ root, relativePath });
+    const handle = await openFileForRead(filePath.resolvedPath);
+    try {
+        const stats = await handle.stat();
+        if (!stats.isFile()) {
+            throw new Error("Requested path is not a file");
+        }
+        const ext = path.extname(filePath.resolvedPath).toLowerCase();
+        let mimeType = "application/octet-stream";
+        if (ext in IMAGE_MIME_TYPES) {
+            mimeType = IMAGE_MIME_TYPES[ext];
+        }
+        else {
+            const sample = Buffer.alloc(FILE_TYPE_SAMPLE_BYTES);
+            const { bytesRead } = await handle.read(sample, 0, sample.length, 0);
+            const chunk = bytesRead < sample.length ? sample.subarray(0, bytesRead) : sample;
+            if (!isLikelyBinary(chunk)) {
+                mimeType = textMimeTypeForExtension(ext);
+            }
+        }
+        return {
+            path: normalizeRelativePath({ root, targetPath: filePath.requestedPath }),
+            absolutePath: filePath.resolvedPath,
+            fileName: path.basename(filePath.requestedPath),
+            mimeType,
+            size: stats.size,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function resolveScopedPath({ root, relativePath = ".", }) {
+    const normalizedRoot = expandUserPath(root);
+    const requestedPath = resolvePathFromBase(normalizedRoot, relativePath);
+    const relative = path.relative(normalizedRoot, requestedPath);
+    if (relative !== "" && (relative.startsWith("..") || path.isAbsolute(relative))) {
+        throw new Error(ACCESS_OUTSIDE_WORKSPACE_MESSAGE);
+    }
+    const realRoot = await fs.realpath(normalizedRoot);
+    try {
+        const realPath = await fs.realpath(requestedPath);
+        const realRelative = path.relative(realRoot, realPath);
+        if (realRelative !== "" && (realRelative.startsWith("..") || path.isAbsolute(realRelative))) {
+            throw new Error(ACCESS_OUTSIDE_WORKSPACE_MESSAGE);
+        }
+        return { requestedPath, resolvedPath: realPath };
+    }
+    catch (error) {
+        if (isMissingEntryError(error)) {
+            return { requestedPath, resolvedPath: requestedPath };
+        }
+        throw error;
+    }
+}
+async function openFileForRead(filePath) {
+    return fs.open(filePath, READ_FILE_OPEN_FLAGS);
+}
+async function buildEntryPayload({ root, targetPath, name, kind, }) {
+    const entryPath = await resolveScopedPath({
+        root,
+        relativePath: normalizeRelativePath({ root, targetPath }),
+    });
+    const stats = await fs.stat(entryPath.resolvedPath);
+    return {
+        name,
+        path: normalizeRelativePath({ root, targetPath }),
+        kind,
+        size: stats.size,
+        modifiedAt: stats.mtime.toISOString(),
+    };
+}
+function isMissingEntryError(error) {
+    const code = error?.code;
+    return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
+}
+function isOutsideWorkspaceError(error) {
+    return error instanceof Error && error.message === ACCESS_OUTSIDE_WORKSPACE_MESSAGE;
+}
+function normalizeRelativePath({ root, targetPath }) {
+    const normalizedRoot = expandUserPath(root);
+    const normalizedTarget = expandUserPath(targetPath);
+    const relative = path.relative(normalizedRoot, normalizedTarget);
+    return relative === "" ? "." : relative.split(path.sep).join("/");
+}
+function textMimeTypeForExtension(ext) {
+    return TEXT_MIME_TYPES[ext] ?? DEFAULT_TEXT_MIME_TYPE;
+}
+function isLikelyBinary(buffer) {
+    if (buffer.length === 0) {
+        return false;
+    }
+    let suspicious = 0;
+    for (let idx = 0; idx < buffer.length; idx += 1) {
+        const byte = buffer[idx];
+        if (byte === 0) {
+            return true;
+        }
+        const isControl = byte < 32 &&
+            byte !== 9 && // tab
+            byte !== 10 && // newline
+            byte !== 13; // carriage return
+        if (isControl || byte === 127) {
+            suspicious += 1;
+        }
+    }
+    return suspicious / buffer.length > 0.3;
+}
+//# sourceMappingURL=service.js.map

package/dist/server/server/file-upload/index.d.ts

@@ -0,0 +1,27 @@
+import { type FileTransferFrame } from "@hyperdrive.bot/paseo-protocol/binary-frames/index";
+import type { FileUploadRequest, FileUploadResponse } from "../messages.js";
+interface FileUploadStoreOptions {
+    paseoHome: string;
+    staleUploadTimeoutMs?: number;
+}
+export declare class FileUploadStore {
+    private static readonly defaultStaleUploadTimeoutMs;
+    private readonly paseoHome;
+    private readonly staleUploadTimeoutMs;
+    private readonly pending;
+    constructor(options: FileUploadStoreOptions);
+    beginUpload(request: FileUploadRequest): void;
+    receiveFrame(frame: FileTransferFrame): Promise<FileUploadResponse | null>;
+    private applyFrame;
+    private startWriting;
+    private writeChunk;
+    private completeUpload;
+    private createStaleUploadTimeout;
+    private refreshStaleUploadTimeout;
+    private expireStaleUpload;
+    private clearPendingUpload;
+    private removeFailedUpload;
+    private removeUploadDirectory;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/file-upload/index.js

@@ -0,0 +1,158 @@
+import { appendFile, mkdir, rm, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { FileTransferOpcode, } from "@hyperdrive.bot/paseo-protocol/binary-frames/index";
+import { getErrorMessage } from "@hyperdrive.bot/paseo-protocol/error-utils";
+export class FileUploadStore {
+    constructor(options) {
+        this.pending = new Map();
+        this.paseoHome = options.paseoHome;
+        this.staleUploadTimeoutMs =
+            options.staleUploadTimeoutMs ?? FileUploadStore.defaultStaleUploadTimeoutMs;
+    }
+    beginUpload(request) {
+        const existingUpload = this.pending.get(request.requestId);
+        if (existingUpload) {
+            this.clearPendingUpload(existingUpload);
+            void existingUpload.queue.then(() => this.removeUploadDirectory(existingUpload));
+        }
+        const fileName = sanitizeFileName(request.fileName);
+        const attempt = existingUpload ? existingUpload.attempt + 1 : 1;
+        const id = buildUploadId(request.requestId, attempt);
+        const uploadDir = join(this.paseoHome, "uploads", id);
+        const upload = {
+            requestId: request.requestId,
+            id,
+            attempt,
+            fileName,
+            mimeType: request.mimeType,
+            size: request.size,
+            path: join(uploadDir, fileName),
+            receivedBytes: 0,
+            started: false,
+            staleTimeout: this.createStaleUploadTimeout(request.requestId),
+            queue: Promise.resolve(),
+        };
+        this.pending.set(request.requestId, upload);
+    }
+    async receiveFrame(frame) {
+        const upload = this.pending.get(frame.requestId);
+        if (!upload) {
+            return null;
+        }
+        this.refreshStaleUploadTimeout(upload);
+        const operation = upload.queue.then(() => this.applyFrame(upload, frame));
+        upload.queue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async applyFrame(upload, frame) {
+        if (this.pending.get(upload.requestId) !== upload) {
+            return null;
+        }
+        try {
+            if (frame.opcode === FileTransferOpcode.FileBegin) {
+                await this.startWriting(upload);
+                return null;
+            }
+            if (frame.opcode === FileTransferOpcode.FileChunk) {
+                await this.writeChunk(upload, frame.payload);
+                return null;
+            }
+            return await this.completeUpload(upload);
+        }
+        catch (error) {
+            await this.removeFailedUpload(upload);
+            return buildUploadResponse(upload, getErrorMessage(error));
+        }
+    }
+    async startWriting(upload) {
+        await mkdir(join(this.paseoHome, "uploads", upload.id), { recursive: true });
+        await writeFile(upload.path, new Uint8Array());
+        upload.started = true;
+    }
+    async writeChunk(upload, bytes) {
+        if (!upload.started) {
+            throw new Error("Upload chunks arrived before file begin.");
+        }
+        const nextReceivedBytes = upload.receivedBytes + bytes.byteLength;
+        if (nextReceivedBytes > upload.size) {
+            throw new Error(`Upload exceeded declared size: expected ${upload.size}, received ${nextReceivedBytes}.`);
+        }
+        await appendFile(upload.path, bytes);
+        upload.receivedBytes += bytes.byteLength;
+    }
+    async completeUpload(upload) {
+        this.clearPendingUpload(upload);
+        if (upload.receivedBytes !== upload.size) {
+            await this.removeUploadDirectory(upload);
+            return buildUploadResponse(upload, `Upload size mismatch: expected ${upload.size}, received ${upload.receivedBytes}.`);
+        }
+        return buildUploadResponse(upload, null);
+    }
+    createStaleUploadTimeout(requestId) {
+        const timeout = setTimeout(() => {
+            this.expireStaleUpload(requestId);
+        }, this.staleUploadTimeoutMs);
+        timeout.unref?.();
+        return timeout;
+    }
+    refreshStaleUploadTimeout(upload) {
+        clearTimeout(upload.staleTimeout);
+        upload.staleTimeout = this.createStaleUploadTimeout(upload.requestId);
+    }
+    expireStaleUpload(requestId) {
+        const upload = this.pending.get(requestId);
+        if (!upload) {
+            return;
+        }
+        this.clearPendingUpload(upload);
+        const cleanup = upload.queue.then(() => this.removeUploadDirectory(upload), () => this.removeUploadDirectory(upload));
+        upload.queue = cleanup.then(() => undefined, () => undefined);
+    }
+    clearPendingUpload(upload) {
+        clearTimeout(upload.staleTimeout);
+        if (this.pending.get(upload.requestId) === upload) {
+            this.pending.delete(upload.requestId);
+        }
+    }
+    async removeFailedUpload(upload) {
+        this.clearPendingUpload(upload);
+        await this.removeUploadDirectory(upload);
+    }
+    async removeUploadDirectory(upload) {
+        await rm(join(this.paseoHome, "uploads", upload.id), { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+FileUploadStore.defaultStaleUploadTimeoutMs = 10 * 60 * 1000;
+function buildUploadResponse(upload, error) {
+    return {
+        type: "file.upload.response",
+        payload: {
+            requestId: upload.requestId,
+            file: error
+                ? null
+                : {
+                    type: "uploaded_file",
+                    id: upload.id,
+                    fileName: upload.fileName,
+                    mimeType: upload.mimeType,
+                    size: upload.size,
+                    path: upload.path,
+                },
+            error,
+        },
+    };
+}
+function sanitizeUploadId(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "_") || "file";
+}
+function buildUploadId(requestId, attempt) {
+    const baseId = `upload_${sanitizeUploadId(requestId)}`;
+    return attempt === 1 ? baseId : `${baseId}_${attempt}`;
+}
+function sanitizeFileName(value) {
+    const name = basename(value)
+        .replace(/[^a-zA-Z0-9._ -]/g, "_")
+        .trim();
+    return name.length > 0 && name !== "." && name !== ".." ? name : "upload";
+}
+//# sourceMappingURL=index.js.map

package/dist/server/server/hostnames.d.ts

@@ -0,0 +1,13 @@
+export type HostnamesConfig = true | string[] | undefined;
+/**
+ * Vite-style hostname allowlist check, adapted to raw Host headers.
+ *
+ * Semantics:
+ * - `hostnames === true` => allow any host.
+ * - `hostnames === []` or `undefined` => allow localhost, *.localhost, and all IPs.
+ * - `hostnames === ['.example.com', 'myhost']` => allow those *in addition* to defaults.
+ */
+export declare function isHostnameAllowed(hostHeader: string | undefined, hostnames: HostnamesConfig): boolean;
+export declare function mergeHostnames(values: Array<HostnamesConfig>): HostnamesConfig;
+export declare function parseHostnamesEnv(raw: string | undefined): HostnamesConfig;
+//# sourceMappingURL=hostnames.d.ts.map

package/dist/server/server/hostnames.js

@@ -0,0 +1,94 @@
+import net from "node:net";
+function normalizeHostname(hostname) {
+    return hostname.trim().toLowerCase();
+}
+function parseHostnameFromHostHeader(hostHeader) {
+    const trimmed = hostHeader.trim();
+    if (!trimmed)
+        return null;
+    // IPv6 in brackets: [::1]:6767
+    if (trimmed.startsWith("[")) {
+        const end = trimmed.indexOf("]");
+        if (end === -1)
+            return null;
+        return normalizeHostname(trimmed.slice(1, end));
+    }
+    // IPv4/hostname with optional port: localhost:6767
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+        return normalizeHostname(trimmed);
+    }
+    return normalizeHostname(trimmed.slice(0, colonIndex));
+}
+function matchesHostnamePattern(hostname, pattern) {
+    const normalizedPattern = normalizeHostname(pattern);
+    if (!normalizedPattern)
+        return false;
+    if (normalizedPattern.startsWith(".")) {
+        const base = normalizedPattern.slice(1);
+        if (!base)
+            return false;
+        return hostname === base || hostname.endsWith(`.${base}`);
+    }
+    return hostname === normalizedPattern;
+}
+function isDefaultAllowedHostname(hostname) {
+    // Vite-style defaults: localhost, *.localhost, and all IP addresses.
+    if (hostname === "localhost")
+        return true;
+    if (hostname.endsWith(".localhost"))
+        return true;
+    if (net.isIP(hostname) !== 0)
+        return true;
+    return false;
+}
+/**
+ * Vite-style hostname allowlist check, adapted to raw Host headers.
+ *
+ * Semantics:
+ * - `hostnames === true` => allow any host.
+ * - `hostnames === []` or `undefined` => allow localhost, *.localhost, and all IPs.
+ * - `hostnames === ['.example.com', 'myhost']` => allow those *in addition* to defaults.
+ */
+export function isHostnameAllowed(hostHeader, hostnames) {
+    const hostname = hostHeader ? parseHostnameFromHostHeader(hostHeader) : null;
+    if (!hostname)
+        return false;
+    if (hostnames === true)
+        return true;
+    // Defaults are always allowed.
+    if (isDefaultAllowedHostname(hostname))
+        return true;
+    const patterns = hostnames ?? [];
+    for (const pattern of patterns) {
+        if (matchesHostnamePattern(hostname, pattern))
+            return true;
+    }
+    return false;
+}
+export function mergeHostnames(values) {
+    let merged = [];
+    for (const value of values) {
+        if (value === true)
+            return true;
+        if (!value)
+            continue;
+        merged = merged.concat(value);
+    }
+    const deduped = Array.from(new Set(merged.map((v) => v.trim()).filter((v) => v.length > 0)));
+    return deduped;
+}
+export function parseHostnamesEnv(raw) {
+    if (!raw)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.toLowerCase() === "true")
+        return true;
+    return trimmed
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+//# sourceMappingURL=hostnames.js.map

package/dist/server/server/json-utils.d.ts

@@ -0,0 +1,11 @@
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * Coerce arbitrary values into JSON-safe structures.
+ * Unlike the previous implementation, this never throws on undefined—
+ * it replaces unsupported values (undefined, functions, symbols) with null
+ * so responses always make it back to the client.
+ */
+export declare function ensureValidJson<T>(value: T): T;
+//# sourceMappingURL=json-utils.d.ts.map

package/dist/server/server/json-utils.js

@@ -0,0 +1,45 @@
+/**
+ * Coerce arbitrary values into JSON-safe structures.
+ * Unlike the previous implementation, this never throws on undefined—
+ * it replaces unsupported values (undefined, functions, symbols) with null
+ * so responses always make it back to the client.
+ */
+export function ensureValidJson(value) {
+    const seen = new WeakSet();
+    const sanitize = (current) => {
+        if (current === null || current === undefined) {
+            return null;
+        }
+        if (typeof current === "string" || typeof current === "number") {
+            return current;
+        }
+        if (typeof current === "boolean") {
+            return current;
+        }
+        if (typeof current === "bigint") {
+            return current.toString();
+        }
+        if (current instanceof Date) {
+            return current.toISOString();
+        }
+        if (Array.isArray(current)) {
+            return current.map((item) => sanitize(item));
+        }
+        if (typeof current === "object") {
+            if (seen.has(current)) {
+                throw new Error("Cannot serialize circular structure to JSON");
+            }
+            seen.add(current);
+            const obj = {};
+            for (const [key, val] of Object.entries(current)) {
+                obj[key] = sanitize(val);
+            }
+            seen.delete(current);
+            return obj;
+        }
+        // functions, symbols, undefined, etc.
+        return null;
+    };
+    return sanitize(value);
+}
+//# sourceMappingURL=json-utils.js.map

package/dist/server/server/lifecycle-reasons.d.ts

@@ -0,0 +1,4 @@
+export declare const CLIENT_SHUTDOWN_RPC_REASON = "client_shutdown_rpc";
+export declare const DEFAULT_CLIENT_RESTART_RPC_REASON = "client_restart_rpc";
+export declare function normalizeClientRestartRpcReason(reason: string | undefined): string;
+//# sourceMappingURL=lifecycle-reasons.d.ts.map

package/dist/server/server/lifecycle-reasons.js

@@ -0,0 +1,6 @@
+export const CLIENT_SHUTDOWN_RPC_REASON = "client_shutdown_rpc";
+export const DEFAULT_CLIENT_RESTART_RPC_REASON = "client_restart_rpc";
+export function normalizeClientRestartRpcReason(reason) {
+    return reason?.trim() || DEFAULT_CLIENT_RESTART_RPC_REASON;
+}
+//# sourceMappingURL=lifecycle-reasons.js.map