@floegence/flowersec-core 0.27.0 → 2.0.0

package/dist/proxy/portStream.js

@@ -1,256 +0,0 @@
-import { PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE, PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE, PROXY_WINDOW_STREAM_END_MSG_TYPE, PROXY_WINDOW_STREAM_RESET_MSG_TYPE, PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE, } from "./windowBridgeProtocol.js";
-function cloneChunk(chunk) {
-    const out = new Uint8Array(chunk.byteLength);
-    out.set(chunk);
-    return out.buffer;
-}
-function validWriteId(value) {
-    return Number.isSafeInteger(value) && Number(value) > 0;
-}
-export function createMessagePortBackedStream(port, opts = {}) {
-    let closed = false;
-    let acceptingWrites = true;
-    let error = null;
-    const queue = [];
-    const waiters = [];
-    let pendingInboundWriteId = null;
-    let pendingOutboundAcknowledgement = null;
-    let nextWriteId = 1;
-    let writeTail = Promise.resolve();
-    let queuedWriteBytes = 0;
-    const maxBufferedBytes = opts.maxBufferedBytes ?? 4 * (1 << 20);
-    let terminalNotified = false;
-    const notifyTerminal = () => {
-        if (terminalNotified)
-            return;
-        terminalNotified = true;
-        opts.onTerminal?.();
-    };
-    const closePort = () => {
-        try {
-            port.close();
-        }
-        catch {
-            // Best-effort.
-        }
-    };
-    const drainWaiters = (value) => {
-        for (const waiter of waiters.splice(0))
-            waiter(value);
-    };
-    const terminateWithError = (err, notifyPeer) => {
-        if (error != null)
-            return;
-        error = err;
-        closed = true;
-        acceptingWrites = false;
-        queue.length = 0;
-        pendingInboundWriteId = null;
-        drainWaiters(err);
-        pendingOutboundAcknowledgement?.reject(err);
-        pendingOutboundAcknowledgement = null;
-        if (notifyPeer) {
-            try {
-                port.postMessage({
-                    type: PROXY_WINDOW_STREAM_RESET_MSG_TYPE,
-                    message: err.message,
-                });
-            }
-            catch {
-                // The local error remains authoritative.
-            }
-        }
-        closePort();
-        notifyTerminal();
-    };
-    const failProtocol = (message) => {
-        terminateWithError(new Error(`proxy Window stream protocol error: ${message}`), true);
-    };
-    const finishClosed = () => {
-        if (closed)
-            return;
-        if (pendingInboundWriteId != null) {
-            failProtocol("stream ended before the pending chunk was acknowledged");
-            return;
-        }
-        closed = true;
-        acceptingWrites = false;
-        const closeError = new Error("stream is closed");
-        pendingOutboundAcknowledgement?.reject(closeError);
-        pendingOutboundAcknowledgement = null;
-        drainWaiters(null);
-        closePort();
-        notifyTerminal();
-    };
-    const acknowledgeRead = (item) => {
-        if (closed)
-            return;
-        if (pendingInboundWriteId !== item.writeId) {
-            failProtocol("read acknowledgement does not match the pending chunk");
-            throw error;
-        }
-        pendingInboundWriteId = null;
-        try {
-            port.postMessage({
-                type: PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE,
-                writeId: item.writeId,
-            });
-        }
-        catch (cause) {
-            const err = cause instanceof Error ? cause : new Error(String(cause));
-            terminateWithError(err, false);
-            throw err;
-        }
-    };
-    port.onmessage = (ev) => {
-        if (closed)
-            return;
-        const data = ev.data;
-        if (data == null || typeof data !== "object")
-            return;
-        const type = typeof data.type === "string" ? data.type : "";
-        switch (type) {
-            case PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE: {
-                const msg = data;
-                if (!(msg.data instanceof ArrayBuffer) || !validWriteId(msg.writeId)) {
-                    failProtocol("invalid stream chunk");
-                    return;
-                }
-                if (pendingInboundWriteId != null || queue.length > 0) {
-                    failProtocol("received more than one unacknowledged chunk");
-                    return;
-                }
-                pendingInboundWriteId = msg.writeId;
-                const item = { chunk: new Uint8Array(msg.data), writeId: msg.writeId };
-                const waiter = waiters.shift();
-                if (waiter == null) {
-                    queue.push(item);
-                }
-                else {
-                    waiter(item);
-                }
-                return;
-            }
-            case PROXY_WINDOW_STREAM_END_MSG_TYPE:
-            case PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE:
-                finishClosed();
-                return;
-            case PROXY_WINDOW_STREAM_WRITE_ACK_MSG_TYPE: {
-                const writeId = data.writeId;
-                const pending = pendingOutboundAcknowledgement;
-                if (!validWriteId(writeId) || pending == null || pending.writeId !== writeId) {
-                    failProtocol("unexpected stream write acknowledgement");
-                    return;
-                }
-                pendingOutboundAcknowledgement = null;
-                pending.resolve();
-                return;
-            }
-            case PROXY_WINDOW_STREAM_RESET_MSG_TYPE: {
-                const message = String(data.message ?? "stream reset");
-                terminateWithError(new Error(message), false);
-                return;
-            }
-            default:
-                return;
-        }
-    };
-    port.start?.();
-    return {
-        async read() {
-            if (error != null)
-                throw error;
-            const queued = queue.shift();
-            if (queued != null) {
-                acknowledgeRead(queued);
-                return queued.chunk;
-            }
-            if (closed)
-                return null;
-            const value = await new Promise((resolve) => {
-                waiters.push(resolve);
-            });
-            if (value instanceof Error)
-                throw value;
-            if (value == null)
-                return null;
-            acknowledgeRead(value);
-            return value.chunk;
-        },
-        async write(chunk) {
-            if (error != null)
-                throw error;
-            if (!acceptingWrites || closed)
-                throw new Error("stream is closed");
-            const nextQueuedWriteBytes = queuedWriteBytes + chunk.byteLength;
-            if (!Number.isSafeInteger(nextQueuedWriteBytes) || nextQueuedWriteBytes > maxBufferedBytes) {
-                throw new Error("proxy WebSocket outbound buffer exceeded");
-            }
-            queuedWriteBytes = nextQueuedWriteBytes;
-            const ab = cloneChunk(chunk);
-            const operation = writeTail.then(async () => {
-                if (error != null)
-                    throw error;
-                if (closed)
-                    throw new Error("stream is closed");
-                if (!Number.isSafeInteger(nextWriteId)) {
-                    failProtocol("stream write identifier space exhausted");
-                    throw error;
-                }
-                if (pendingOutboundAcknowledgement != null) {
-                    failProtocol("multiple outbound chunks are awaiting acknowledgement");
-                    throw error;
-                }
-                const writeId = nextWriteId++;
-                await new Promise((resolve, reject) => {
-                    pendingOutboundAcknowledgement = { writeId, resolve, reject };
-                    try {
-                        port.postMessage({
-                            type: PROXY_WINDOW_STREAM_CHUNK_MSG_TYPE,
-                            data: ab,
-                            writeId,
-                        }, [ab]);
-                    }
-                    catch (cause) {
-                        pendingOutboundAcknowledgement = null;
-                        const postError = cause instanceof Error ? cause : new Error(String(cause));
-                        terminateWithError(postError, false);
-                        reject(postError);
-                    }
-                });
-            });
-            writeTail = operation.catch(() => { });
-            try {
-                await operation;
-            }
-            finally {
-                queuedWriteBytes = Math.max(0, queuedWriteBytes - chunk.byteLength);
-            }
-        },
-        async close() {
-            if (closed)
-                return;
-            acceptingWrites = false;
-            await writeTail;
-            if (error != null)
-                throw error;
-            if (closed)
-                return;
-            closed = true;
-            queue.length = 0;
-            pendingInboundWriteId = null;
-            drainWaiters(null);
-            try {
-                port.postMessage({ type: PROXY_WINDOW_STREAM_CLOSE_MSG_TYPE });
-            }
-            finally {
-                closePort();
-                notifyTerminal();
-            }
-        },
-        reset(err) {
-            const resetError = err instanceof Error ? err : new Error(String(err));
-            terminateWithError(resetError, true);
-        },
-    };
-}

package/dist/proxy/preset.d.ts

@@ -1,29 +0,0 @@
-export type ProxyPresetLimits = Readonly<{
-    max_json_frame_bytes?: number;
-    max_chunk_bytes?: number;
-    max_body_bytes?: number;
-    max_ws_frame_bytes?: number;
-    timeout_ms?: number;
-}>;
-export type ProxyPresetManifest = Readonly<{
-    v: 1;
-    preset_id: string;
-    deprecated?: boolean;
-    limits: ProxyPresetLimits;
-}>;
-export type ResolvedProxyPreset = Readonly<{
-    v: 1;
-    preset_id: string;
-    deprecated: boolean;
-    limits: Readonly<{
-        max_json_frame_bytes: number;
-        max_chunk_bytes: number;
-        max_body_bytes: number;
-        max_ws_frame_bytes: number;
-        timeout_ms?: number;
-    }>;
-}>;
-export declare const DEFAULT_PROXY_PRESET_MANIFEST: ProxyPresetManifest;
-export type ProxyPresetInput = ProxyPresetManifest | Partial<ProxyPresetLimits>;
-export declare function assertProxyPresetManifest(value: unknown): ProxyPresetManifest;
-export declare function resolveProxyPreset(input?: ProxyPresetInput): ResolvedProxyPreset;

package/dist/proxy/preset.js

@@ -1,111 +0,0 @@
-import { DEFAULT_MAX_JSON_FRAME_BYTES } from "../framing/jsonframe.js";
-import { DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CHUNK_BYTES, DEFAULT_MAX_WS_FRAME_BYTES } from "./constants.js";
-const PRESET_ID_RE = /^[a-z][a-z0-9._-]{0,63}$/;
-const DEFAULT_LIMITS = Object.freeze({
-    max_json_frame_bytes: DEFAULT_MAX_JSON_FRAME_BYTES,
-    max_chunk_bytes: DEFAULT_MAX_CHUNK_BYTES,
-    max_body_bytes: DEFAULT_MAX_BODY_BYTES,
-    max_ws_frame_bytes: DEFAULT_MAX_WS_FRAME_BYTES,
-});
-export const DEFAULT_PROXY_PRESET_MANIFEST = Object.freeze({
-    v: 1,
-    preset_id: "default",
-    limits: {
-        max_json_frame_bytes: DEFAULT_MAX_JSON_FRAME_BYTES,
-        max_chunk_bytes: DEFAULT_MAX_CHUNK_BYTES,
-        max_body_bytes: DEFAULT_MAX_BODY_BYTES,
-        max_ws_frame_bytes: DEFAULT_MAX_WS_FRAME_BYTES,
-    },
-});
-function isRecord(v) {
-    return typeof v === "object" && v != null && !Array.isArray(v);
-}
-function assertNoUnknownFields(kind, value, allowed) {
-    const allowedSet = new Set(allowed);
-    for (const key of Object.keys(value)) {
-        if (!allowedSet.has(key))
-            throw new Error(`bad ${kind}.${key}`);
-    }
-}
-function assertPositiveInt(name, value) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-        throw new Error(`${name} must be a positive safe integer`);
-    }
-    return value;
-}
-function assertLimits(value) {
-    if (!isRecord(value))
-        throw new Error("bad ProxyPresetManifest.limits");
-    assertNoUnknownFields("ProxyPresetManifest.limits", value, [
-        "max_json_frame_bytes",
-        "max_chunk_bytes",
-        "max_body_bytes",
-        "max_ws_frame_bytes",
-        "timeout_ms",
-    ]);
-    const out = {};
-    if (value.max_json_frame_bytes !== undefined)
-        out.max_json_frame_bytes = assertPositiveInt("max_json_frame_bytes", value.max_json_frame_bytes);
-    if (value.max_chunk_bytes !== undefined)
-        out.max_chunk_bytes = assertPositiveInt("max_chunk_bytes", value.max_chunk_bytes);
-    if (value.max_body_bytes !== undefined)
-        out.max_body_bytes = assertPositiveInt("max_body_bytes", value.max_body_bytes);
-    if (value.max_ws_frame_bytes !== undefined)
-        out.max_ws_frame_bytes = assertPositiveInt("max_ws_frame_bytes", value.max_ws_frame_bytes);
-    if (value.timeout_ms !== undefined)
-        out.timeout_ms = assertPositiveInt("timeout_ms", value.timeout_ms);
-    return Object.freeze(out);
-}
-export function assertProxyPresetManifest(value) {
-    if (!isRecord(value))
-        throw new Error("bad ProxyPresetManifest");
-    assertNoUnknownFields("ProxyPresetManifest", value, ["v", "preset_id", "deprecated", "limits"]);
-    if (value.v !== 1)
-        throw new Error("bad ProxyPresetManifest.v");
-    if (typeof value.preset_id !== "string" || !PRESET_ID_RE.test(value.preset_id)) {
-        throw new Error("bad ProxyPresetManifest.preset_id");
-    }
-    if (value.deprecated !== undefined && typeof value.deprecated !== "boolean") {
-        throw new Error("bad ProxyPresetManifest.deprecated");
-    }
-    return Object.freeze({
-        v: 1,
-        preset_id: value.preset_id,
-        ...(value.deprecated === undefined ? {} : { deprecated: value.deprecated }),
-        limits: assertLimits(value.limits),
-    });
-}
-function toResolved(manifest) {
-    return Object.freeze({
-        v: 1,
-        preset_id: manifest.preset_id,
-        deprecated: manifest.deprecated === true,
-        limits: Object.freeze({
-            max_json_frame_bytes: manifest.limits.max_json_frame_bytes ?? DEFAULT_LIMITS.max_json_frame_bytes,
-            max_chunk_bytes: manifest.limits.max_chunk_bytes ?? DEFAULT_LIMITS.max_chunk_bytes,
-            max_body_bytes: manifest.limits.max_body_bytes ?? DEFAULT_LIMITS.max_body_bytes,
-            max_ws_frame_bytes: manifest.limits.max_ws_frame_bytes ?? DEFAULT_LIMITS.max_ws_frame_bytes,
-            ...(manifest.limits.timeout_ms === undefined ? {} : { timeout_ms: manifest.limits.timeout_ms }),
-        }),
-    });
-}
-export function resolveProxyPreset(input) {
-    if (input == null)
-        return toResolved(DEFAULT_PROXY_PRESET_MANIFEST);
-    if (isRecord(input) && ("v" in input || "presetId" in input || "limits" in input)) {
-        return toResolved(assertProxyPresetManifest(input));
-    }
-    const limits = assertLimits(input);
-    return Object.freeze({
-        v: 1,
-        preset_id: "custom",
-        deprecated: false,
-        limits: Object.freeze({
-            max_json_frame_bytes: limits.max_json_frame_bytes ?? DEFAULT_LIMITS.max_json_frame_bytes,
-            max_chunk_bytes: limits.max_chunk_bytes ?? DEFAULT_LIMITS.max_chunk_bytes,
-            max_body_bytes: limits.max_body_bytes ?? DEFAULT_LIMITS.max_body_bytes,
-            max_ws_frame_bytes: limits.max_ws_frame_bytes ?? DEFAULT_LIMITS.max_ws_frame_bytes,
-            ...(limits.timeout_ms === undefined ? {} : { timeout_ms: limits.timeout_ms }),
-        }),
-    });
-}

package/dist/proxy/runtimeScope.d.ts

@@ -1,57 +0,0 @@
-import type { ConnectArtifact, ScopePayload } from "../connect/artifact.js";
-import { assertProxyPresetManifest, type ProxyPresetInput, type ProxyPresetLimits } from "./preset.js";
-export type ProxyPresetSnapshotV1 = ReturnType<typeof assertProxyPresetManifest>;
-type ProxyRuntimeScopeBaseV1 = Readonly<{
-    appBasePath?: string;
-    preset: Readonly<{
-        presetId: string;
-        snapshot?: ProxyPresetSnapshotV1;
-    }>;
-    limits?: Readonly<{
-        timeoutMs?: number;
-        maxJsonFrameBytes?: number;
-        maxChunkBytes?: number;
-        maxBodyBytes?: number;
-        maxWsFrameBytes?: number;
-    }>;
-}>;
-export type ProxyRuntimeServiceWorkerScopeV1 = ProxyRuntimeScopeBaseV1 & Readonly<{
-    mode: "service_worker";
-    serviceWorker: Readonly<{
-        scriptUrl: string;
-        scope: string;
-    }>;
-}>;
-export type ProxyRuntimeControllerBridgeScopeV1 = ProxyRuntimeScopeBaseV1 & Readonly<{
-    mode: "controller_bridge";
-    controllerBridge: Readonly<{
-        allowedOrigins: readonly string[];
-    }>;
-}>;
-export type ProxyRuntimeScopeV1 = ProxyRuntimeServiceWorkerScopeV1 | ProxyRuntimeControllerBridgeScopeV1;
-export declare function assertProxyRuntimeScopeV1(payload: ScopePayload): ProxyRuntimeScopeV1;
-export declare function extractProxyRuntimeScopeV1(artifact: ConnectArtifact, mode: ProxyRuntimeScopeV1["mode"]): ProxyRuntimeScopeV1;
-export declare function resolveRuntimeLimitsFromScope(scope: ProxyRuntimeScopeV1, overrides: Readonly<{
-    maxJsonFrameBytes?: number;
-    maxChunkBytes?: number;
-    maxBodyBytes?: number;
-    maxWsFrameBytes?: number;
-    maxWsBufferedAmountBytes?: number;
-    maxConcurrentHttpStreams?: number;
-    maxQueuedHttpRequests?: number;
-    maxQueuedHttpBodyBytes?: number;
-    timeoutMs?: number;
-}> | undefined): Readonly<{
-    maxJsonFrameBytes?: number;
-    maxChunkBytes?: number;
-    maxBodyBytes?: number;
-    maxWsFrameBytes?: number;
-    maxWsBufferedAmountBytes?: number;
-    maxConcurrentHttpStreams?: number;
-    maxQueuedHttpRequests?: number;
-    maxQueuedHttpBodyBytes?: number;
-    timeoutMs?: number;
-}> | undefined;
-export declare function resolvePresetInputFromScope(scope: ProxyRuntimeScopeV1, presetOverride: ProxyPresetInput | undefined): ProxyPresetInput | undefined;
-export declare function resolveRuntimePresetLimits(scope: ProxyRuntimeScopeV1): ProxyPresetLimits | undefined;
-export {};

package/dist/proxy/runtimeScope.js

@@ -1,218 +0,0 @@
-import { assertProxyPresetManifest, } from "./preset.js";
-const RUNTIME_SCOPE_NAME = "proxy.runtime";
-const PRESET_ID_RE = /^[a-z][a-z0-9._-]{0,63}$/;
-const MAX_RUNTIME_PAYLOAD_BYTES = 8 * 1024;
-const MAX_RUNTIME_DEPTH = 8;
-const MAX_RUNTIME_FIELDS = 64;
-const MAX_RUNTIME_SNAPSHOT_BYTES = 4 * 1024;
-function isRecord(value) {
-    return typeof value === "object" && value != null && !Array.isArray(value);
-}
-function assertNoUnknownFields(kind, value, allowed) {
-    const allowedSet = new Set(allowed);
-    for (const key of Object.keys(value)) {
-        if (!allowedSet.has(key))
-            throw new Error(`bad ${kind}.${key}`);
-    }
-}
-function assertPositiveInt(name, value) {
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-        throw new Error(`bad ${name}`);
-    }
-    return value;
-}
-function utf8Len(value) {
-    return new TextEncoder().encode(value).length;
-}
-function maxContainerDepth(value) {
-    if (Array.isArray(value)) {
-        let best = 1;
-        for (const entry of value)
-            best = Math.max(best, 1 + maxContainerDepth(entry));
-        return best;
-    }
-    if (isRecord(value)) {
-        let best = 1;
-        for (const entry of Object.values(value))
-            best = Math.max(best, 1 + maxContainerDepth(entry));
-        return best;
-    }
-    return 0;
-}
-function countFields(value) {
-    if (Array.isArray(value))
-        return value.reduce((total, entry) => total + countFields(entry), 0);
-    if (isRecord(value)) {
-        return Object.entries(value).reduce((total, [, entry]) => total + 1 + countFields(entry), 0);
-    }
-    return 0;
-}
-function assertRuntimePayloadEnvelope(payload) {
-    if (!isRecord(payload))
-        throw new Error("bad proxy.runtime.payload");
-    if (utf8Len(JSON.stringify(payload)) > MAX_RUNTIME_PAYLOAD_BYTES)
-        throw new Error("bad proxy.runtime.payload");
-    if (maxContainerDepth(payload) > MAX_RUNTIME_DEPTH)
-        throw new Error("bad proxy.runtime.payload");
-    if (countFields(payload) > MAX_RUNTIME_FIELDS)
-        throw new Error("bad proxy.runtime.payload");
-    return payload;
-}
-function assertServiceWorkerConfig(value) {
-    if (!isRecord(value))
-        throw new Error("bad proxy.runtime.serviceWorker");
-    assertNoUnknownFields("proxy.runtime.serviceWorker", value, ["scriptUrl", "scope"]);
-    const scriptUrl = String(value.scriptUrl ?? "").trim();
-    const scope = String(value.scope ?? "").trim();
-    if (scriptUrl === "")
-        throw new Error("bad proxy.runtime.serviceWorker.scriptUrl");
-    if (scope === "")
-        throw new Error("bad proxy.runtime.serviceWorker.scope");
-    return Object.freeze({ scriptUrl, scope });
-}
-function assertAllowedOrigins(value) {
-    if (!Array.isArray(value))
-        throw new Error("bad proxy.runtime.controllerBridge.allowedOrigins");
-    const out = [];
-    const seen = new Set();
-    for (const entry of value) {
-        const normalized = String(entry ?? "").trim();
-        if (normalized === "" || seen.has(normalized))
-            continue;
-        seen.add(normalized);
-        out.push(normalized);
-    }
-    if (out.length === 0)
-        throw new Error("bad proxy.runtime.controllerBridge.allowedOrigins");
-    return Object.freeze(out);
-}
-function assertControllerBridgeConfig(value) {
-    if (!isRecord(value))
-        throw new Error("bad proxy.runtime.controllerBridge");
-    assertNoUnknownFields("proxy.runtime.controllerBridge", value, ["allowedOrigins"]);
-    return Object.freeze({
-        allowedOrigins: assertAllowedOrigins(value.allowedOrigins),
-    });
-}
-function assertLimits(value) {
-    if (!isRecord(value))
-        throw new Error("bad proxy.runtime.limits");
-    assertNoUnknownFields("proxy.runtime.limits", value, [
-        "timeoutMs",
-        "maxJsonFrameBytes",
-        "maxChunkBytes",
-        "maxBodyBytes",
-        "maxWsFrameBytes",
-    ]);
-    const out = {};
-    if (value.timeoutMs !== undefined)
-        out.timeoutMs = assertPositiveInt("proxy.runtime.limits.timeoutMs", value.timeoutMs);
-    if (value.maxJsonFrameBytes !== undefined) {
-        out.maxJsonFrameBytes = assertPositiveInt("proxy.runtime.limits.maxJsonFrameBytes", value.maxJsonFrameBytes);
-    }
-    if (value.maxChunkBytes !== undefined)
-        out.maxChunkBytes = assertPositiveInt("proxy.runtime.limits.maxChunkBytes", value.maxChunkBytes);
-    if (value.maxBodyBytes !== undefined)
-        out.maxBodyBytes = assertPositiveInt("proxy.runtime.limits.maxBodyBytes", value.maxBodyBytes);
-    if (value.maxWsFrameBytes !== undefined)
-        out.maxWsFrameBytes = assertPositiveInt("proxy.runtime.limits.maxWsFrameBytes", value.maxWsFrameBytes);
-    return Object.freeze(out);
-}
-function assertPreset(value) {
-    if (!isRecord(value))
-        throw new Error("bad proxy.runtime.preset");
-    assertNoUnknownFields("proxy.runtime.preset", value, ["presetId", "snapshot"]);
-    const presetId = String(value.presetId ?? "").trim();
-    if (!PRESET_ID_RE.test(presetId))
-        throw new Error("bad proxy.runtime.preset.presetId");
-    if (value.snapshot === undefined) {
-        return Object.freeze({ presetId });
-    }
-    const snapshot = assertProxyPresetManifest(value.snapshot);
-    if (utf8Len(JSON.stringify(snapshot)) > MAX_RUNTIME_SNAPSHOT_BYTES)
-        throw new Error("bad proxy.runtime.preset.snapshot");
-    return Object.freeze({ presetId, snapshot });
-}
-export function assertProxyRuntimeScopeV1(payload) {
-    const value = assertRuntimePayloadEnvelope(payload);
-    assertNoUnknownFields("proxy.runtime", value, [
-        "mode",
-        "appBasePath",
-        "serviceWorker",
-        "controllerBridge",
-        "preset",
-        "limits",
-    ]);
-    const mode = value.mode;
-    if (mode !== "service_worker" && mode !== "controller_bridge") {
-        throw new Error("bad proxy.runtime.mode");
-    }
-    const appBasePath = value.appBasePath === undefined ? undefined : String(value.appBasePath ?? "").trim();
-    if (value.appBasePath !== undefined && appBasePath === "") {
-        throw new Error("bad proxy.runtime.appBasePath");
-    }
-    const preset = assertPreset(value.preset);
-    const limits = value.limits === undefined ? undefined : assertLimits(value.limits);
-    if (mode === "service_worker") {
-        if (value.controllerBridge !== undefined)
-            throw new Error("bad proxy.runtime.controllerBridge");
-        const serviceWorker = assertServiceWorkerConfig(value.serviceWorker);
-        return Object.freeze({
-            mode,
-            ...(appBasePath === undefined ? {} : { appBasePath }),
-            serviceWorker,
-            preset,
-            ...(limits === undefined ? {} : { limits }),
-        });
-    }
-    if (value.serviceWorker !== undefined)
-        throw new Error("bad proxy.runtime.serviceWorker");
-    const controllerBridge = assertControllerBridgeConfig(value.controllerBridge);
-    return Object.freeze({
-        mode,
-        ...(appBasePath === undefined ? {} : { appBasePath }),
-        controllerBridge,
-        preset,
-        ...(limits === undefined ? {} : { limits }),
-    });
-}
-export function extractProxyRuntimeScopeV1(artifact, mode) {
-    const scoped = artifact.scoped ?? [];
-    const entry = scoped.find((item) => item.scope === RUNTIME_SCOPE_NAME);
-    if (!entry) {
-        throw new Error("missing proxy.runtime@1 scope");
-    }
-    if (entry.scope_version !== 1) {
-        throw new Error(`unsupported proxy.runtime scope_version: ${entry.scope_version}`);
-    }
-    const scope = assertProxyRuntimeScopeV1(entry.payload);
-    if (scope.mode !== mode) {
-        throw new Error(`proxy.runtime mode mismatch: expected ${mode}`);
-    }
-    return scope;
-}
-export function resolveRuntimeLimitsFromScope(scope, overrides) {
-    const merged = {
-        ...(scope.limits ?? {}),
-        ...(overrides ?? {}),
-    };
-    return Object.keys(merged).length === 0 ? undefined : merged;
-}
-export function resolvePresetInputFromScope(scope, presetOverride) {
-    if (presetOverride !== undefined)
-        return presetOverride;
-    if (scope.preset.snapshot)
-        return scope.preset.snapshot;
-    throw new Error("proxy.runtime preset snapshot is required");
-}
-export function resolveRuntimePresetLimits(scope) {
-    if (scope.limits === undefined)
-        return undefined;
-    return Object.freeze({
-        ...(scope.limits.maxJsonFrameBytes === undefined ? {} : { max_json_frame_bytes: scope.limits.maxJsonFrameBytes }),
-        ...(scope.limits.maxChunkBytes === undefined ? {} : { max_chunk_bytes: scope.limits.maxChunkBytes }),
-        ...(scope.limits.maxBodyBytes === undefined ? {} : { max_body_bytes: scope.limits.maxBodyBytes }),
-        ...(scope.limits.maxWsFrameBytes === undefined ? {} : { max_ws_frame_bytes: scope.limits.maxWsFrameBytes }),
-        ...(scope.limits.timeoutMs === undefined ? {} : { timeout_ms: scope.limits.timeoutMs }),
-    });
-}