@floegence/flowersec-core 0.17.2 → 0.19.0

package/dist/observability/observer.d.ts

@@ -2,12 +2,33 @@ import type { ClientPath } from "../client.js";
 export type ConnectResult = "ok" | "fail";
 export type ConnectReason = "websocket_error" | "websocket_closed" | "timeout" | "canceled";
 export type AttachResult = "ok" | "fail";
-export type AttachReason = "send_failed" | "too_many_connections" | "expected_attach" | "invalid_attach" | "invalid_token" | "channel_mismatch" | "role_mismatch" | "init_exp_mismatch" | "idle_timeout_mismatch" | "token_replay" | "replace_rate_limited" | "attach_failed" | "timeout" | "canceled";
+export type AttachReason = "send_failed" | "too_many_connections" | "expected_attach" | "invalid_attach" | "invalid_token" | "channel_mismatch" | "role_mismatch" | "init_exp_mismatch" | "idle_timeout_mismatch" | "token_replay" | "tenant_mismatch" | "policy_denied" | "policy_error" | "replace_rate_limited" | "attach_failed" | "timeout" | "canceled";
 export type HandshakeResult = "ok" | "fail";
 export type HandshakeReason = "auth_tag_mismatch" | "handshake_failed" | "invalid_suite" | "invalid_version" | "timestamp_after_init_exp" | "timestamp_out_of_skew" | "timeout" | "canceled";
 export type WsCloseKind = "local" | "peer_or_error";
 export type WsErrorReason = "error" | "recv_buffer_exceeded" | "unexpected_text_frame" | "unexpected_message_type";
 export type RpcCallResult = "ok" | "rpc_error" | "handler_not_found" | "transport_error" | "canceled";
+export type DiagnosticEvent = Readonly<{
+    v: 1;
+    namespace: "connect";
+    path: ClientPath | "auto";
+    stage: "validate" | "normalize" | "scope" | "connect" | "attach" | "handshake" | "close" | "reconnect";
+    code_domain: "error" | "event";
+    code: string;
+    result: "ok" | "fail" | "retry" | "skip";
+    elapsed_ms: number;
+    attempt_seq: number;
+    trace_id?: string;
+    session_id?: string;
+}>;
+type ObserverContext = Readonly<{
+    path?: ClientPath | "auto";
+    traceId?: string;
+    sessionId?: string;
+    attemptSeq?: number;
+    attemptStartMs?: number;
+    maxQueuedItems?: number;
+}>;
 export type ClientObserver = {
     onConnect(path: ClientPath, result: ConnectResult, reason: ConnectReason | undefined, elapsedSeconds: number): void;
     onAttach(result: AttachResult, reason: AttachReason | undefined): void;
@@ -16,8 +37,13 @@ export type ClientObserver = {
     onWsError(reason: WsErrorReason): void;
     onRpcCall(result: RpcCallResult, elapsedSeconds: number): void;
     onRpcNotify(): void;
+    onDiagnosticEvent(event: DiagnosticEvent): void;
 };
 export type ClientObserverLike = Partial<ClientObserver>;
+type DiagnosticEventInput = Omit<DiagnosticEvent, "v" | "namespace" | "elapsed_ms" | "attempt_seq" | "trace_id" | "session_id" | "path"> & Partial<Pick<DiagnosticEvent, "path">>;
 export declare const NoopObserver: ClientObserver;
-export declare function normalizeObserver(observer?: ClientObserverLike): ClientObserver;
+export declare function withObserverContext(observer: ClientObserverLike | undefined, context: ObserverContext): ClientObserverLike | undefined;
+export declare function emitObserverDiagnostic(observer: ClientObserverLike | undefined, event: DiagnosticEventInput): void;
+export declare function normalizeObserver(observer?: ClientObserverLike, context?: ObserverContext): ClientObserver;
 export declare function nowSeconds(): number;
+export {};

package/dist/observability/observer.js

@@ -1,3 +1,6 @@
+const OBSERVER_CONTEXT = Symbol.for("floegence.flowersec.observer_context");
+const NORMALIZED_OBSERVER = Symbol.for("floegence.flowersec.normalized_observer");
+const DEFAULT_MAX_QUEUED_ITEMS = 64;
 export const NoopObserver = {
     onConnect: () => { },
     onAttach: () => { },
@@ -5,24 +8,304 @@ export const NoopObserver = {
     onWsClose: () => { },
     onWsError: () => { },
     onRpcCall: () => { },
-    onRpcNotify: () => { }
+    onRpcNotify: () => { },
+    onDiagnosticEvent: () => { },
 };
-export function normalizeObserver(observer) {
+function getObserverContext(observer) {
+    const context = observer?.[OBSERVER_CONTEXT];
+    if (context == null || typeof context !== "object")
+        return {};
+    return context;
+}
+function safeInvoke(fn) {
+    if (fn == null)
+        return;
+    try {
+        fn();
+    }
+    catch {
+        // Best effort only; observability must not affect connect semantics.
+    }
+}
+function hasAnyHandlers(observer) {
     if (observer == null)
-        return NoopObserver;
+        return false;
+    return (observer.onConnect != null ||
+        observer.onAttach != null ||
+        observer.onHandshake != null ||
+        observer.onWsClose != null ||
+        observer.onWsError != null ||
+        observer.onRpcCall != null ||
+        observer.onRpcNotify != null ||
+        observer.onDiagnosticEvent != null);
+}
+function buildDiagnosticEvent(context, event) {
+    return Object.freeze({
+        v: 1,
+        namespace: "connect",
+        path: event.path ?? context.path ?? "auto",
+        stage: event.stage,
+        code_domain: event.code_domain,
+        code: event.code,
+        result: event.result,
+        elapsed_ms: Math.max(0, Math.floor(nowMilliseconds() - (context.attemptStartMs ?? nowMilliseconds()))),
+        attempt_seq: Math.max(1, Math.floor(context.attemptSeq ?? 1)),
+        ...(context.traceId === undefined ? {} : { trace_id: context.traceId }),
+        ...(context.sessionId === undefined
+            ? {}
+            : { session_id: context.sessionId }),
+    });
+}
+function mapConnectDiagnostic(path, result, reason) {
+    if (result === "ok") {
+        return {
+            path,
+            stage: "connect",
+            code_domain: "event",
+            code: "connect_ok",
+            result: "ok",
+        };
+    }
+    return {
+        path,
+        stage: "connect",
+        code_domain: "error",
+        code: reason === "timeout" || reason === "canceled" ? reason : "dial_failed",
+        result: "fail",
+    };
+}
+function mapAttachDiagnostic(result, reason, path) {
+    if (result === "ok") {
+        return {
+            path,
+            stage: "attach",
+            code_domain: "event",
+            code: "attach_ok",
+            result: "ok",
+        };
+    }
     return {
-        onConnect: observer.onConnect ?? NoopObserver.onConnect,
-        onAttach: observer.onAttach ?? NoopObserver.onAttach,
-        onHandshake: observer.onHandshake ?? NoopObserver.onHandshake,
-        onWsClose: observer.onWsClose ?? NoopObserver.onWsClose,
-        onWsError: observer.onWsError ?? NoopObserver.onWsError,
-        onRpcCall: observer.onRpcCall ?? NoopObserver.onRpcCall,
-        onRpcNotify: observer.onRpcNotify ?? NoopObserver.onRpcNotify
+        path,
+        stage: "attach",
+        code_domain: "error",
+        code: reason === "send_failed" ? "attach_failed" : (reason ?? "attach_failed"),
+        result: "fail",
     };
 }
+function mapHandshakeDiagnostic(path, result, reason) {
+    if (result === "ok") {
+        return {
+            path,
+            stage: "handshake",
+            code_domain: "event",
+            code: "handshake_ok",
+            result: "ok",
+        };
+    }
+    return {
+        path,
+        stage: "handshake",
+        code_domain: "error",
+        code: reason ?? "handshake_failed",
+        result: "fail",
+    };
+}
+function mapWsCloseDiagnostic(kind, path) {
+    return {
+        path,
+        stage: "close",
+        code_domain: "event",
+        code: kind === "local" ? "ws_close_local" : "ws_close_peer_or_error",
+        result: "skip",
+    };
+}
+function mapWsErrorDiagnostic(path) {
+    return {
+        path,
+        stage: "close",
+        code_domain: "event",
+        code: "ws_error",
+        result: "skip",
+    };
+}
+class ObserverDispatcher {
+    [NORMALIZED_OBSERVER] = true;
+    [OBSERVER_CONTEXT];
+    queue = [];
+    observer;
+    maxQueuedItems;
+    draining = false;
+    overflowQueued = false;
+    constructor(observer, context) {
+        this.observer = observer;
+        this[OBSERVER_CONTEXT] = context;
+        this.maxQueuedItems = Math.max(4, Math.floor(context.maxQueuedItems ?? DEFAULT_MAX_QUEUED_ITEMS));
+    }
+    onConnect(path, result, reason, elapsedSeconds) {
+        const diagnostic = mapConnectDiagnostic(path, result, reason);
+        this.enqueueCombined(() => this.observer.onConnect?.(path, result, reason, elapsedSeconds), diagnostic, result === "fail");
+    }
+    onAttach(result, reason) {
+        const diagnostic = mapAttachDiagnostic(result, reason, this[OBSERVER_CONTEXT].path ?? "auto");
+        this.enqueueCombined(() => this.observer.onAttach?.(result, reason), diagnostic, result === "fail");
+    }
+    onHandshake(path, result, reason, elapsedSeconds) {
+        const diagnostic = mapHandshakeDiagnostic(path, result, reason);
+        this.enqueueCombined(() => this.observer.onHandshake?.(path, result, reason, elapsedSeconds), diagnostic, result === "fail");
+    }
+    onWsClose(kind, code) {
+        const diagnostic = mapWsCloseDiagnostic(kind, this[OBSERVER_CONTEXT].path ?? "auto");
+        this.enqueueCombined(() => this.observer.onWsClose?.(kind, code), diagnostic, false);
+    }
+    onWsError(reason) {
+        const diagnostic = mapWsErrorDiagnostic(this[OBSERVER_CONTEXT].path ?? "auto");
+        this.enqueueCombined(() => this.observer.onWsError?.(reason), diagnostic, false);
+    }
+    onRpcCall(result, elapsedSeconds) {
+        this.enqueueCombined(() => this.observer.onRpcCall?.(result, elapsedSeconds), undefined, false);
+    }
+    onRpcNotify() {
+        this.enqueueCombined(() => this.observer.onRpcNotify?.(), undefined, false);
+    }
+    onDiagnosticEvent(event) {
+        this.enqueueCombined(() => this.observer.onDiagnosticEvent?.(event), undefined, event.result === "fail");
+    }
+    emitDiagnosticEvent(event) {
+        const diagnostic = buildDiagnosticEvent(this[OBSERVER_CONTEXT], event);
+        this.enqueue({
+            kind: event.code === "diagnostics_overflow"
+                ? "overflow"
+                : event.result === "fail"
+                    ? "terminal"
+                    : "normal",
+            deliver: () => this.observer.onDiagnosticEvent?.(diagnostic),
+        });
+    }
+    enqueueCombined(callback, diagnostic, terminal) {
+        if (callback == null && diagnostic == null)
+            return;
+        const event = diagnostic == null
+            ? undefined
+            : buildDiagnosticEvent(this[OBSERVER_CONTEXT], diagnostic);
+        this.enqueue({
+            kind: terminal ? "terminal" : "normal",
+            deliver: () => {
+                safeInvoke(callback);
+                if (event != null) {
+                    safeInvoke(() => this.observer.onDiagnosticEvent?.(event));
+                }
+            },
+        });
+    }
+    enqueue(item) {
+        if (this.queue.length >= this.maxQueuedItems) {
+            if (!this.makeRoom(item.kind)) {
+                return;
+            }
+        }
+        if (item.kind === "overflow") {
+            if (this.overflowQueued)
+                return;
+            this.overflowQueued = true;
+        }
+        this.queue.push(item);
+        this.scheduleDrain();
+    }
+    makeRoom(kind) {
+        const removableIndex = this.queue.findIndex((entry) => entry.kind === "normal");
+        if (removableIndex >= 0) {
+            this.queue.splice(removableIndex, 1);
+            if (kind === "normal") {
+                this.queueOverflowEvent();
+            }
+            return true;
+        }
+        if (kind === "normal") {
+            return false;
+        }
+        if (this.queue.length > 0) {
+            const shifted = this.queue.shift();
+            if (shifted?.kind === "overflow")
+                this.overflowQueued = false;
+            return true;
+        }
+        return true;
+    }
+    queueOverflowEvent() {
+        if (this.overflowQueued || this.observer.onDiagnosticEvent == null)
+            return;
+        this.enqueue({
+            kind: "overflow",
+            deliver: () => {
+                this.overflowQueued = false;
+                safeInvoke(() => this.observer.onDiagnosticEvent?.(buildDiagnosticEvent(this[OBSERVER_CONTEXT], {
+                    stage: "reconnect",
+                    code_domain: "event",
+                    code: "diagnostics_overflow",
+                    result: "skip",
+                })));
+            },
+        });
+    }
+    scheduleDrain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        queueMicrotask(() => this.drainOne());
+    }
+    drainOne() {
+        this.draining = false;
+        const item = this.queue.shift();
+        if (item == null)
+            return;
+        if (item.kind === "overflow") {
+            this.overflowQueued = false;
+        }
+        safeInvoke(item.deliver);
+        if (this.queue.length > 0) {
+            this.scheduleDrain();
+        }
+    }
+}
+export function withObserverContext(observer, context) {
+    if (observer == null && Object.keys(context).length === 0)
+        return observer;
+    const previous = getObserverContext(observer);
+    return Object.assign({}, observer ?? {}, {
+        [OBSERVER_CONTEXT]: {
+            ...previous,
+            ...context,
+        },
+    });
+}
+export function emitObserverDiagnostic(observer, event) {
+    const normalized = normalizeObserver(observer);
+    if (normalized.emitDiagnosticEvent) {
+        normalized.emitDiagnosticEvent(event);
+        return;
+    }
+    safeInvoke(() => normalized.onDiagnosticEvent(buildDiagnosticEvent(getObserverContext(observer), event)));
+}
+export function normalizeObserver(observer, context = {}) {
+    if (observer?.[NORMALIZED_OBSERVER] === true) {
+        return observer;
+    }
+    if (!hasAnyHandlers(observer))
+        return NoopObserver;
+    return new ObserverDispatcher(observer ?? {}, {
+        attemptSeq: 1,
+        attemptStartMs: nowMilliseconds(),
+        ...getObserverContext(observer),
+        ...context,
+    });
+}
 export function nowSeconds() {
-    if (typeof performance !== "undefined" && typeof performance.now === "function") {
-        return performance.now() / 1000;
+    return nowMilliseconds() / 1000;
+}
+function nowMilliseconds() {
+    if (typeof performance !== "undefined" &&
+        typeof performance.now === "function") {
+        return performance.now();
     }
-    return Date.now() / 1000;
+    return Date.now();
 }

package/dist/proxy/bootstrap.d.ts

@@ -1,13 +1,14 @@
 import type { Client } from "../client.js";
-import type { TunnelConnectBrowserOptions } from "../browser/connect.js";
+import type { ConnectArtifact } from "../connect/artifact.js";
+import type { ConnectBrowserOptions, TunnelConnectBrowserOptions } from "../browser/connect.js";
 import type { ChannelInitGrant } from "../gen/flowersec/controlplane/v1.gen.js";
-import { type ProxyIntegrationPlugin, type ProxyIntegrationServiceWorkerOptions, type RegisterProxyIntegrationOptions } from "./integration.js";
+import { type ProxyIntegrationPlugin, type RegisterProxyIntegrationOptions, type ProxyIntegrationServiceWorkerOptions } from "./integration.js";
 import { type RegisterProxyControllerWindowOptions } from "./controllerWindow.js";
-import type { ProxyProfile, ProxyProfileName } from "./profiles.js";
+import type { ProxyPresetInput } from "./preset.js";
 import { type ProxyRuntime } from "./runtime.js";
 export type ConnectTunnelProxyBrowserOptions = Readonly<{
     connect?: TunnelConnectBrowserOptions;
-    profile?: ProxyProfileName | Partial<ProxyProfile>;
+    preset?: ProxyPresetInput;
     runtimeGlobalKey?: string;
     runtime?: RegisterProxyIntegrationOptions["runtime"];
     serviceWorker: ProxyIntegrationServiceWorkerOptions;
@@ -18,6 +19,14 @@ export type ConnectTunnelProxyBrowserHandle = Readonly<{
     runtime: ProxyRuntime;
     dispose: () => Promise<void>;
 }>;
+export type ConnectArtifactProxyBrowserOptions = Readonly<{
+    connect?: ConnectBrowserOptions;
+    preset?: ProxyPresetInput;
+    runtimeGlobalKey?: string;
+    runtime?: RegisterProxyIntegrationOptions["runtime"];
+    serviceWorker?: ProxyIntegrationServiceWorkerOptions;
+    plugins?: readonly ProxyIntegrationPlugin[];
+}>;
 export type ConnectTunnelProxyControllerBrowserOptions = Readonly<{
     connect?: TunnelConnectBrowserOptions;
     runtime?: RegisterProxyIntegrationOptions["runtime"];
@@ -30,5 +39,14 @@ export type ConnectTunnelProxyControllerBrowserHandle = Readonly<{
     runtime: ProxyRuntime;
     dispose: () => void;
 }>;
+export type ConnectArtifactProxyControllerBrowserOptions = Readonly<{
+    connect?: ConnectBrowserOptions;
+    runtime?: RegisterProxyIntegrationOptions["runtime"];
+    allowedOrigins?: RegisterProxyControllerWindowOptions["allowedOrigins"];
+    targetWindow?: RegisterProxyControllerWindowOptions["targetWindow"];
+    expectedSource?: RegisterProxyControllerWindowOptions["expectedSource"];
+}>;
 export declare function connectTunnelProxyBrowser(grant: ChannelInitGrant, opts: ConnectTunnelProxyBrowserOptions): Promise<ConnectTunnelProxyBrowserHandle>;
+export declare function connectArtifactProxyBrowser(artifact: ConnectArtifact, opts?: ConnectArtifactProxyBrowserOptions): Promise<ConnectTunnelProxyBrowserHandle>;
 export declare function connectTunnelProxyControllerBrowser(grant: ChannelInitGrant, opts: ConnectTunnelProxyControllerBrowserOptions): Promise<ConnectTunnelProxyControllerBrowserHandle>;
+export declare function connectArtifactProxyControllerBrowser(artifact: ConnectArtifact, opts?: ConnectArtifactProxyControllerBrowserOptions): Promise<ConnectTunnelProxyControllerBrowserHandle>;

package/dist/proxy/bootstrap.js

@@ -1,13 +1,34 @@
-import { connectTunnelBrowser } from "../browser/connect.js";
+import { connectBrowser, connectTunnelBrowser } from "../browser/connect.js";
 import { registerProxyIntegration, } from "./integration.js";
 import { registerProxyControllerWindow } from "./controllerWindow.js";
+import { extractProxyRuntimeScopeV1, resolvePresetInputFromScope, resolveRuntimeLimitsFromScope, resolveRuntimePresetLimits, } from "./runtimeScope.js";
 import { createProxyRuntime } from "./runtime.js";
-export async function connectTunnelProxyBrowser(grant, opts) {
-    const client = await connectTunnelBrowser(grant, opts.connect ?? {});
+function scopeRuntimeToIntegrationOptions(scope, opts) {
+    const runtimeLimits = resolveRuntimeLimitsFromScope(scope, opts.runtime);
+    const presetFromScope = resolvePresetInputFromScope(scope, opts.preset);
+    const presetFromLimits = presetFromScope ?? resolveRuntimePresetLimits(scope);
+    const serviceWorker = opts.serviceWorker ?? (scope.mode === "service_worker" ? {
+        scriptUrl: scope.serviceWorker.scriptUrl,
+        scope: scope.serviceWorker.scope,
+    } : undefined);
+    if (!serviceWorker) {
+        throw new Error("service worker config is required for proxy runtime mode");
+    }
+    return {
+        ...(presetFromLimits === undefined ? {} : { preset: presetFromLimits }),
+        ...(opts.runtimeGlobalKey === undefined ? {} : { runtimeGlobalKey: opts.runtimeGlobalKey }),
+        ...(runtimeLimits === undefined ? {} : { runtime: runtimeLimits }),
+        serviceWorker,
+        ...(opts.plugins === undefined ? {} : { plugins: opts.plugins }),
+    };
+}
+async function connectProxyBrowserClient(client, opts) {
+    const compat = opts;
     const integrationInput = {
         client,
         serviceWorker: opts.serviceWorker,
-        ...(opts.profile === undefined ? {} : { profile: opts.profile }),
+        ...(opts.preset === undefined ? {} : { preset: opts.preset }),
+        ...(compat.profile === undefined ? {} : { profile: compat.profile }),
         ...(opts.runtimeGlobalKey === undefined ? {} : { runtimeGlobalKey: opts.runtimeGlobalKey }),
         ...(opts.runtime === undefined ? {} : { runtime: opts.runtime }),
         ...(opts.plugins === undefined ? {} : { plugins: opts.plugins }),
@@ -46,8 +67,7 @@ export async function connectTunnelProxyBrowser(grant, opts) {
         },
     };
 }
-export async function connectTunnelProxyControllerBrowser(grant, opts) {
-    const client = await connectTunnelBrowser(grant, opts.connect ?? {});
+function connectProxyControllerClient(client, opts) {
     let runtime = null;
     let controller = null;
     try {
@@ -80,3 +100,28 @@ export async function connectTunnelProxyControllerBrowser(grant, opts) {
         },
     };
 }
+export async function connectTunnelProxyBrowser(grant, opts) {
+    const client = await connectTunnelBrowser(grant, opts.connect ?? {});
+    return await connectProxyBrowserClient(client, opts);
+}
+export async function connectArtifactProxyBrowser(artifact, opts = {}) {
+    const scope = extractProxyRuntimeScopeV1(artifact, "service_worker");
+    const client = await connectBrowser(artifact, opts.connect ?? {});
+    const nextOpts = scopeRuntimeToIntegrationOptions(scope, opts);
+    return await connectProxyBrowserClient(client, nextOpts);
+}
+export async function connectTunnelProxyControllerBrowser(grant, opts) {
+    const client = await connectTunnelBrowser(grant, opts.connect ?? {});
+    return connectProxyControllerClient(client, opts);
+}
+export async function connectArtifactProxyControllerBrowser(artifact, opts = {}) {
+    const scope = extractProxyRuntimeScopeV1(artifact, "controller_bridge");
+    const client = await connectBrowser(artifact, opts.connect ?? {});
+    const runtime = resolveRuntimeLimitsFromScope(scope, opts.runtime);
+    return connectProxyControllerClient(client, {
+        ...(runtime === undefined ? {} : { runtime }),
+        allowedOrigins: opts.allowedOrigins ?? scope.controllerBridge.allowedOrigins,
+        ...(opts.targetWindow === undefined ? {} : { targetWindow: opts.targetWindow }),
+        ...(opts.expectedSource === undefined ? {} : { expectedSource: opts.expectedSource }),
+    });
+}

package/dist/proxy/index.d.ts

@@ -1,13 +1,15 @@
 export * from "./constants.js";
 export * from "./types.js";
 export * from "./cookieJar.js";
-export * from "./profiles.js";
+export type { ProxyPresetInput, ProxyPresetLimits, ProxyPresetManifest, ResolvedProxyPreset } from "./preset.js";
+export { DEFAULT_PROXY_PRESET_MANIFEST, assertProxyPresetManifest, resolveProxyPreset } from "./preset.js";
 export * from "./runtime.js";
 export * from "./serviceWorker.js";
 export { registerServiceWorkerAndEnsureControl } from "./registerServiceWorker.js";
 export * from "./integration.js";
 export * from "./controllerGuard.js";
 export * from "./bootstrap.js";
+export * from "./runtimeScope.js";
 export * from "./controllerWindow.js";
 export * from "./appWindow.js";
 export * from "./wsPatch.js";

package/dist/proxy/index.js

@@ -1,13 +1,14 @@
 export * from "./constants.js";
 export * from "./types.js";
 export * from "./cookieJar.js";
-export * from "./profiles.js";
+export { DEFAULT_PROXY_PRESET_MANIFEST, assertProxyPresetManifest, resolveProxyPreset } from "./preset.js";
 export * from "./runtime.js";
 export * from "./serviceWorker.js";
 export { registerServiceWorkerAndEnsureControl } from "./registerServiceWorker.js";
 export * from "./integration.js";
 export * from "./controllerGuard.js";
 export * from "./bootstrap.js";
+export * from "./runtimeScope.js";
 export * from "./controllerWindow.js";
 export * from "./appWindow.js";
 export * from "./wsPatch.js";

package/dist/proxy/integration.d.ts

@@ -1,5 +1,5 @@
 import type { Client } from "../client.js";
-import { type ProxyProfile, type ProxyProfileName } from "./profiles.js";
+import { type ProxyPresetInput, type ResolvedProxyPreset } from "./preset.js";
 import { type ProxyRuntime } from "./runtime.js";
 import { type ProxyServiceWorkerScriptOptions } from "./serviceWorker.js";
 export type ProxyIntegrationMonitorOptions = Readonly<{
@@ -26,7 +26,7 @@ export type ProxyIntegrationServiceWorkerOptions = Readonly<{
 }>;
 export type RegisterProxyIntegrationOptions = Readonly<{
     client: Client;
-    profile?: ProxyProfileName | Partial<ProxyProfile>;
+    preset?: ProxyPresetInput;
     runtimeGlobalKey?: string;
     runtime?: Readonly<{
         maxJsonFrameBytes?: number;
@@ -41,7 +41,7 @@ export type RegisterProxyIntegrationOptions = Readonly<{
 export type ProxyIntegrationContext = Readonly<{
     runtime: ProxyRuntime;
     options: RegisterProxyIntegrationOptions;
-    profile: ProxyProfile;
+    preset: ResolvedProxyPreset;
 }>;
 export type ControllerMismatchContext = Readonly<{
     expectedScriptPathSuffix: string;

package/dist/proxy/integration.js

@@ -1,4 +1,5 @@
-import { resolveProxyProfile } from "./profiles.js";
+import { profileToPresetManifest } from "./profiles.js";
+import { resolveProxyPreset } from "./preset.js";
 import { registerServiceWorkerAndEnsureControl } from "./registerServiceWorker.js";
 import { createProxyRuntime } from "./runtime.js";
 import { createProxyServiceWorkerScript } from "./serviceWorker.js";
@@ -163,13 +164,23 @@ function shouldIgnoreMismatch(plugins, ctx) {
     }
     return false;
 }
-function buildRuntimeOptions(profile, runtime) {
+function resolveIntegrationPreset(opts) {
+    if (opts.preset !== undefined && opts.profile !== undefined) {
+        throw new Error("preset and deprecated profile cannot be used together");
+    }
+    if (opts.preset !== undefined)
+        return resolveProxyPreset(opts.preset);
+    if (opts.profile !== undefined)
+        return resolveProxyPreset(profileToPresetManifest(opts.profile));
+    return resolveProxyPreset();
+}
+function buildRuntimeOptions(preset, runtime) {
     return {
-        maxJsonFrameBytes: runtime?.maxJsonFrameBytes ?? profile.maxJsonFrameBytes,
-        maxChunkBytes: runtime?.maxChunkBytes ?? profile.maxChunkBytes,
-        maxBodyBytes: runtime?.maxBodyBytes ?? profile.maxBodyBytes,
-        maxWsFrameBytes: runtime?.maxWsFrameBytes ?? profile.maxWsFrameBytes,
-        timeoutMs: runtime?.timeoutMs ?? profile.timeoutMs,
+        maxJsonFrameBytes: runtime?.maxJsonFrameBytes ?? preset.limits.max_json_frame_bytes,
+        maxChunkBytes: runtime?.maxChunkBytes ?? preset.limits.max_chunk_bytes,
+        maxBodyBytes: runtime?.maxBodyBytes ?? preset.limits.max_body_bytes,
+        maxWsFrameBytes: runtime?.maxWsFrameBytes ?? preset.limits.max_ws_frame_bytes,
+        timeoutMs: runtime?.timeoutMs ?? preset.limits.timeout_ms ?? 0,
     };
 }
 function bindRuntimeGlobal(runtime, key) {
@@ -221,8 +232,8 @@ export function createProxyIntegrationServiceWorkerScript(opts = {}) {
 export async function registerProxyIntegration(input) {
     const plugins = input.plugins ?? [];
     const opts = applyPluginMutations(input, plugins);
-    const profile = resolveProxyProfile(opts.profile);
-    const runtimeOpts = buildRuntimeOptions(profile, opts.runtime);
+    const preset = resolveIntegrationPreset(opts);
+    const runtimeOpts = buildRuntimeOptions(preset, opts.runtime);
     const runtime = createProxyRuntime({ ...runtimeOpts, client: opts.client });
     const releaseRuntimeGlobal = bindRuntimeGlobal(runtime, opts.runtimeGlobalKey);
     const swCfg = opts.serviceWorker;
@@ -285,7 +296,7 @@ export async function registerProxyIntegration(input) {
     const ctx = {
         runtime,
         options: opts,
-        profile,
+        preset,
     };
     for (const plugin of plugins) {
         await plugin.onRegistered?.(ctx);

package/dist/proxy/preset.d.ts

@@ -0,0 +1,31 @@
+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 declare const CODESERVER_PROXY_PRESET_MANIFEST: ProxyPresetManifest;
+export type ProxyPresetInput = ProxyPresetManifest | Partial<ProxyPresetLimits>;
+export declare function assertProxyPresetManifest(value: unknown): ProxyPresetManifest;
+export declare function resolveNamedProxyPreset(name: string): ProxyPresetManifest;
+export declare function resolveProxyPreset(input?: ProxyPresetInput): ResolvedProxyPreset;