@floegence/flowersec-core 0.19.7 → 0.19.9

package/dist/e2ee/handshake.js

@@ -33,6 +33,12 @@ function ioWriteOpts(signal) {
     throwIfAborted(signal, "handshake aborted");
     return signal != null ? { signal } : {};
 }
+function normalizeClockSkewSeconds(clockSkewSeconds) {
+    if (!Number.isFinite(clockSkewSeconds) || !Number.isSafeInteger(clockSkewSeconds) || clockSkewSeconds < 0) {
+        throw new Error("invalid clock_skew");
+    }
+    return clockSkewSeconds;
+}
 function randomBytes(n) {
     const out = new Uint8Array(n);
     crypto.getRandomValues(out);
@@ -228,6 +234,7 @@ export class ServerHandshakeCache {
 export async function serverHandshake(transport, cache, opts) {
     if (opts.initExpireAtUnixS <= 0)
         throw new Error("missing init_exp");
+    const clockSkewSeconds = normalizeClockSkewSeconds(opts.clockSkewSeconds);
     const deadlineMs = handshakeDeadlineMs(opts.timeoutMs);
     const initFrame = await transport.readBinary(ioReadOpts(opts.signal, deadlineMs));
     const decodedInit = decodeHandshakeFrame(initFrame, opts.maxHandshakePayload);
@@ -279,9 +286,9 @@ export async function serverHandshake(transport, cache, opts) {
     if (ack.handshake_id !== entry.handshakeId)
         throw new Error("handshake_id mismatch");
     const now = Math.floor(Date.now() / 1000);
-    if (Math.abs(now - ack.timestamp_unix_s) > opts.clockSkewSeconds)
+    if (Math.abs(now - ack.timestamp_unix_s) > clockSkewSeconds)
         throw new E2EEHandshakeError("timestamp_out_of_skew", "timestamp skew");
-    if (ack.timestamp_unix_s > opts.initExpireAtUnixS + opts.clockSkewSeconds)
+    if (ack.timestamp_unix_s > opts.initExpireAtUnixS + clockSkewSeconds)
         throw new E2EEHandshakeError("timestamp_after_init_exp", "timestamp after init_exp");
     const th = transcriptHash({
         version: PROTOCOL_VERSION,

package/dist/e2ee/record.js

@@ -5,6 +5,12 @@ const te = new TextEncoder();
 // RecordError marks record parsing or cryptographic failures.
 export class RecordError extends Error {
 }
+// maxRecordSeq is the sequence boundary where a key epoch must stop before uint64 wrap.
+const maxRecordSeq = (1n << 64n) - 1n;
+function assertRecordSeq(seq) {
+    if (seq < 0n || seq > maxRecordSeq)
+        throw new RecordError("record seq out of range");
+}
 // maxPlaintextBytes returns the payload cap derived from a record size limit.
 export function maxPlaintextBytes(maxRecordBytes) {
     if (maxRecordBytes <= 0)
@@ -17,6 +23,7 @@ export function encryptRecord(key, noncePrefix, flags, seq, plaintext, maxRecord
         throw new RecordError("key must be 32 bytes");
     if (noncePrefix.length !== 4)
         throw new RecordError("noncePrefix must be 4 bytes");
+    assertRecordSeq(seq);
     const cipherLen = plaintext.length + 16;
     if (cipherLen > 0xffffffff)
         throw new RecordError("record too large");

package/dist/e2ee/secureChannel.d.ts

@@ -76,6 +76,7 @@ export declare class SecureChannel {
     private wakeSendWaiters;
     private rejectQueuedSenders;
     private failSend;
+    private reserveSendSeq;
     private sendLoop;
     private readLoop;
 }

package/dist/e2ee/secureChannel.js

@@ -1,6 +1,13 @@
 import { RECORD_FLAG_APP, RECORD_FLAG_PING, RECORD_FLAG_REKEY } from "./constants.js";
 import { decryptRecord, encryptRecord, maxPlaintextBytes } from "./record.js";
 import { deriveRekeyKey } from "./kdf.js";
+const maxRecordSeq = (1n << 64n) - 1n;
+class RecordSeqExhaustedError extends Error {
+    constructor() {
+        super("record seq exhausted");
+        this.name = "RecordSeqExhaustedError";
+    }
+}
 // SecureChannel encrypts/decrypts records and buffers application payloads.
 export class SecureChannel {
     // Underlying transport for encrypted record frames.
@@ -183,6 +190,16 @@ export class SecureChannel {
         this.rejectQueuedSenders(err);
         this.wakeSendWaiters();
     }
+    reserveSendSeq() {
+        if (this.sendSeq >= maxRecordSeq) {
+            const err = new RecordSeqExhaustedError();
+            this.failSend(err);
+            throw err;
+        }
+        const seq = this.sendSeq;
+        this.sendSeq++;
+        return seq;
+    }
     async sendLoop() {
         while (true) {
             const req = await this.nextSend();
@@ -199,15 +216,15 @@ export class SecureChannel {
             try {
                 let frame;
                 if (req.kind === "app") {
-                    const seq = this.sendSeq++;
+                    const seq = this.reserveSendSeq();
                     frame = encryptRecord(this.sendKey, this.sendNoncePrefix, RECORD_FLAG_APP, seq, req.payload ?? new Uint8Array(), this.maxRecordBytes);
                 }
                 else if (req.kind === "ping") {
-                    const seq = this.sendSeq++;
+                    const seq = this.reserveSendSeq();
                     frame = encryptRecord(this.sendKey, this.sendNoncePrefix, RECORD_FLAG_PING, seq, new Uint8Array(), this.maxRecordBytes);
                 }
                 else {
-                    const seq = this.sendSeq++;
+                    const seq = this.reserveSendSeq();
                     frame = encryptRecord(this.sendKey, this.sendNoncePrefix, RECORD_FLAG_REKEY, seq, new Uint8Array(), this.maxRecordBytes);
                     // Update the send key after enqueuing the rekey frame.
                     this.sendKey = deriveRekeyKey(this.rekeyBase, this.transcriptHash, seq, this.sendDir);
@@ -228,6 +245,9 @@ export class SecureChannel {
             while (!this.closed) {
                 const frame = await this.transport.readBinary();
                 const { flags, seq, plaintext } = decryptRecord(this.recvKey, this.recvNoncePrefix, frame, this.recvSeq, this.maxRecordBytes);
+                if (seq >= maxRecordSeq) {
+                    throw new RecordSeqExhaustedError();
+                }
                 this.recvSeq = seq + 1n;
                 if (flags === RECORD_FLAG_APP) {
                     if (this.maxBufferedBytes > 0 && this.recvQueueBytes + plaintext.length > this.maxBufferedBytes) {

package/dist/proxy/appWindow.d.ts

@@ -6,6 +6,7 @@ export type RegisterProxyAppWindowOptions = Readonly<{
     controllerWindow?: Window | null;
     targetWindow?: Window;
     maxWsFrameBytes?: number;
+    capabilityNonce?: string;
 }>;
 export type ProxyAppWindowHandle = Readonly<{
     runtime: Readonly<{

package/dist/proxy/appWindow.js

@@ -40,6 +40,17 @@ function postFetchError(port, message) {
         // Best-effort.
     }
 }
+function normalizeCapabilityNonce(value) {
+    if (value == null)
+        return "";
+    const s = String(value);
+    if (s === "")
+        return "";
+    if (s.trim() !== s || /[\s\u0000-\u001f\u007f]/.test(s)) {
+        throw new Error("capabilityNonce must not contain whitespace or control characters");
+    }
+    return s;
+}
 export function registerProxyAppWindow(opts) {
     const controllerOrigin = String(opts.controllerOrigin ?? "").trim();
     if (controllerOrigin === "") {
@@ -47,6 +58,7 @@ export function registerProxyAppWindow(opts) {
     }
     const targetWindow = resolveTargetWindow(opts.targetWindow);
     const controllerWindow = resolveControllerWindow(targetWindow, opts.controllerWindow);
+    const capabilityNonce = normalizeCapabilityNonce(opts.capabilityNonce);
     const sw = targetWindow.navigator?.serviceWorker;
     const onServiceWorkerMessage = (ev) => {
         const data = ev.data;
@@ -58,7 +70,11 @@ export function registerProxyAppWindow(opts) {
         if (!port)
             return;
         try {
-            controllerWindow.postMessage({ type: PROXY_WINDOW_FETCH_MSG_TYPE, req: data.req }, controllerOrigin, [port]);
+            controllerWindow.postMessage({
+                type: PROXY_WINDOW_FETCH_MSG_TYPE,
+                req: data.req,
+                ...(capabilityNonce === "" ? {} : { capabilityNonce }),
+            }, controllerOrigin, [port]);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -117,6 +133,7 @@ export function registerProxyAppWindow(opts) {
                         type: PROXY_WINDOW_WS_OPEN_MSG_TYPE,
                         path,
                         ...(wsOpts.protocols === undefined ? {} : { protocols: wsOpts.protocols }),
+                        ...(capabilityNonce === "" ? {} : { capabilityNonce }),
                     }, controllerOrigin, [channel.port2]);
                 }
                 catch (error) {

package/dist/proxy/bootstrap.d.ts

@@ -33,6 +33,7 @@ export type ConnectTunnelProxyControllerBrowserOptions = Readonly<{
     allowedOrigins: RegisterProxyControllerWindowOptions["allowedOrigins"];
     targetWindow?: RegisterProxyControllerWindowOptions["targetWindow"];
     expectedSource?: RegisterProxyControllerWindowOptions["expectedSource"];
+    capabilityNonce?: RegisterProxyControllerWindowOptions["capabilityNonce"];
 }>;
 export type ConnectTunnelProxyControllerBrowserHandle = Readonly<{
     client: Client;
@@ -45,6 +46,7 @@ export type ConnectArtifactProxyControllerBrowserOptions = Readonly<{
     allowedOrigins?: RegisterProxyControllerWindowOptions["allowedOrigins"];
     targetWindow?: RegisterProxyControllerWindowOptions["targetWindow"];
     expectedSource?: RegisterProxyControllerWindowOptions["expectedSource"];
+    capabilityNonce?: RegisterProxyControllerWindowOptions["capabilityNonce"];
 }>;
 export declare function connectTunnelProxyBrowser(grant: ChannelInitGrant, opts: ConnectTunnelProxyBrowserOptions): Promise<ConnectTunnelProxyBrowserHandle>;
 export declare function connectArtifactProxyBrowser(artifact: ConnectArtifact, opts?: ConnectArtifactProxyBrowserOptions): Promise<ConnectTunnelProxyBrowserHandle>;

package/dist/proxy/bootstrap.js

@@ -80,6 +80,7 @@ function connectProxyControllerClient(client, opts) {
             allowedOrigins: opts.allowedOrigins,
             ...(opts.targetWindow === undefined ? {} : { targetWindow: opts.targetWindow }),
             ...(opts.expectedSource === undefined ? {} : { expectedSource: opts.expectedSource }),
+            ...(opts.capabilityNonce === undefined ? {} : { capabilityNonce: opts.capabilityNonce }),
         });
     }
     catch (error) {
@@ -123,5 +124,6 @@ export async function connectArtifactProxyControllerBrowser(artifact, opts = {})
         allowedOrigins: opts.allowedOrigins ?? scope.controllerBridge.allowedOrigins,
         ...(opts.targetWindow === undefined ? {} : { targetWindow: opts.targetWindow }),
         ...(opts.expectedSource === undefined ? {} : { expectedSource: opts.expectedSource }),
+        ...(opts.capabilityNonce === undefined ? {} : { capabilityNonce: opts.capabilityNonce }),
     });
 }

package/dist/proxy/controllerWindow.d.ts

@@ -4,6 +4,7 @@ export type RegisterProxyControllerWindowOptions = Readonly<{
     allowedOrigins: readonly string[];
     targetWindow?: Window;
     expectedSource?: Window | null;
+    capabilityNonce?: string;
 }>;
 export type ProxyControllerWindowHandle = Readonly<{
     dispose: () => void;

package/dist/proxy/controllerWindow.js

@@ -16,6 +16,29 @@ function cloneChunk(chunk) {
     out.set(chunk);
     return out.buffer;
 }
+function normalizeCapabilityNonce(value) {
+    if (value == null)
+        return "";
+    const s = String(value);
+    if (s === "")
+        return "";
+    if (s.trim() !== s || /[\s\u0000-\u001f\u007f]/.test(s)) {
+        throw new Error("capabilityNonce must not contain whitespace or control characters");
+    }
+    return s;
+}
+function requireBridgeCapability(expectedSource, capabilityNonce) {
+    if (expectedSource == null && capabilityNonce === "") {
+        throw new Error("expectedSource or capabilityNonce is required");
+    }
+}
+function hasExpectedCapability(data, capabilityNonce) {
+    if (capabilityNonce === "")
+        return true;
+    if (data == null || typeof data !== "object")
+        return false;
+    return data.capabilityNonce === capabilityNonce;
+}
 function bridgeWebSocket(runtime, msg, port) {
     const ac = new AbortController();
     let streamClosed = false;
@@ -88,6 +111,8 @@ export function registerProxyControllerWindow(opts) {
     if (allowedOrigins.length === 0) {
         throw new Error("allowedOrigins is required");
     }
+    const capabilityNonce = normalizeCapabilityNonce(opts.capabilityNonce);
+    requireBridgeCapability(opts.expectedSource, capabilityNonce);
     const targetWindow = opts.targetWindow ?? globalThis.window;
     if (targetWindow == null) {
         throw new Error("targetWindow is not available");
@@ -100,6 +125,8 @@ export function registerProxyControllerWindow(opts) {
         const data = ev.data;
         if (data == null || typeof data !== "object")
             return;
+        if (!hasExpectedCapability(data, capabilityNonce))
+            return;
         const type = typeof data.type === "string" ? data.type : "";
         const port = ev.ports?.[0];
         if (!port)

package/dist/proxy/integration.d.ts

@@ -1,6 +1,6 @@
 import type { Client } from "../client.js";
 import { type ProxyPresetInput, type ResolvedProxyPreset } from "./preset.js";
-import { type ProxyRuntime } from "./runtime.js";
+import { type ProxyRuntime, type ProxyRuntimePathPolicy } from "./runtime.js";
 import { type ProxyServiceWorkerScriptOptions } from "./serviceWorker.js";
 export type ProxyIntegrationMonitorOptions = Readonly<{
     enabled?: boolean;
@@ -34,6 +34,9 @@ export type RegisterProxyIntegrationOptions = Readonly<{
         maxBodyBytes?: number;
         maxWsFrameBytes?: number;
         timeoutMs?: number;
+        pathPolicy?: ProxyRuntimePathPolicy;
+        externalOrigin?: string;
+        runtimeRegistrationToken?: string;
     }>;
     serviceWorker: ProxyIntegrationServiceWorkerOptions;
     plugins?: readonly ProxyIntegrationPlugin[];

package/dist/proxy/integration.js

@@ -181,6 +181,9 @@ function buildRuntimeOptions(preset, runtime) {
         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,
+        ...(runtime?.pathPolicy === undefined ? {} : { pathPolicy: runtime.pathPolicy }),
+        ...(runtime?.externalOrigin === undefined ? {} : { externalOrigin: runtime.externalOrigin }),
+        ...(runtime?.runtimeRegistrationToken === undefined ? {} : { runtimeRegistrationToken: runtime.runtimeRegistrationToken }),
     };
 }
 function bindRuntimeGlobal(runtime, key) {
@@ -252,7 +255,10 @@ export async function registerProxyIntegration(input) {
         maxRepairAttempts,
         controllerTimeoutMs,
     });
-    await ensureServiceWorkerRuntimeRegistered({ timeoutMs: controllerTimeoutMs });
+    await ensureServiceWorkerRuntimeRegistered({
+        timeoutMs: controllerTimeoutMs,
+        ...(runtimeOpts.runtimeRegistrationToken === undefined ? {} : { runtimeRegistrationToken: runtimeOpts.runtimeRegistrationToken }),
+    });
     if (expectedScriptPathSuffix !== "") {
         const ok = await waitForControllerSuffix(expectedScriptPathSuffix, controllerTimeoutMs);
         if (!ok) {

package/dist/proxy/runtime.d.ts

@@ -28,6 +28,12 @@ export type ProxyRuntime = Readonly<{
         protocol: string;
     }>>;
 }>;
+export type ProxyRuntimePathPolicy = Readonly<{
+    allowedPathPrefixes?: readonly string[];
+    deniedPathPrefixes?: readonly string[];
+    allowedWebSocketPathPrefixes?: readonly string[];
+    deniedWebSocketPathPrefixes?: readonly string[];
+}>;
 export type ProxyRuntimeOptions = Readonly<{
     client: Client;
     maxJsonFrameBytes?: number;
@@ -39,9 +45,13 @@ export type ProxyRuntimeOptions = Readonly<{
     extraResponseHeaders?: readonly string[];
     extraWsHeaders?: readonly string[];
     cookieJar?: CookieJar;
+    pathPolicy?: ProxyRuntimePathPolicy;
+    externalOrigin?: string;
+    runtimeRegistrationToken?: string;
 }>;
 export type EnsureServiceWorkerRuntimeRegisteredOptions = Readonly<{
     timeoutMs?: number;
+    runtimeRegistrationToken?: string;
 }>;
 export declare function createProxyRuntime(opts: ProxyRuntimeOptions): ProxyRuntime;
 export declare function ensureServiceWorkerRuntimeRegistered(opts?: EnsureServiceWorkerRuntimeRegisteredOptions): Promise<void>;

package/dist/proxy/runtime.js

@@ -5,6 +5,9 @@ import { readU32be, u32be } from "../utils/bin.js";
 import { CookieJar } from "./cookieJar.js";
 import { DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CHUNK_BYTES, DEFAULT_MAX_WS_FRAME_BYTES, PROXY_KIND_HTTP1, PROXY_KIND_WS, PROXY_PROTOCOL_VERSION } from "./constants.js";
 import { filterRequestHeaders, filterResponseHeaders, filterWsOpenHeaders } from "./headerPolicy.js";
+class ProxyRuntimePolicyError extends Error {
+    status = 403;
+}
 function randomB64u(bytes) {
     const b = new Uint8Array(bytes);
     if (globalThis.crypto?.getRandomValues) {
@@ -28,10 +31,13 @@ function pathOnly(path) {
         throw new Error("path must not include scheme/host");
     return p;
 }
-function cookiePathFromRequestPath(path) {
+function requestPathname(path) {
     const q = path.indexOf("?");
     return q >= 0 ? path.slice(0, q) : path;
 }
+function cookiePathFromRequestPath(path) {
+    return requestPathname(path);
+}
 function normalizeTimeoutMs(timeoutMs) {
     const v = Math.floor(timeoutMs ?? 0);
     if (v < 0)
@@ -59,6 +65,56 @@ function normalizeExternalOrigin(externalOriginRaw) {
     }
     return parsed.origin;
 }
+function normalizeOptionalToken(name, input) {
+    if (input == null)
+        return undefined;
+    const s = String(input);
+    if (s === "")
+        return undefined;
+    if (s.trim() !== s || /[\s\u0000-\u001f\u007f]/.test(s)) {
+        throw new Error(`${name} must not contain whitespace or control characters`);
+    }
+    return s;
+}
+function normalizePathPolicyPrefixes(name, input) {
+    const out = [];
+    if (input == null || input.length === 0)
+        return out;
+    for (const raw of input) {
+        const s = pathOnly(String(raw ?? ""));
+        if (s.includes("?"))
+            throw new Error(`${name} must not include query`);
+        if (!out.includes(s))
+            out.push(s);
+    }
+    return out;
+}
+function normalizePathPolicy(policy) {
+    return {
+        allowedPathPrefixes: normalizePathPolicyPrefixes("pathPolicy.allowedPathPrefixes", policy?.allowedPathPrefixes),
+        deniedPathPrefixes: normalizePathPolicyPrefixes("pathPolicy.deniedPathPrefixes", policy?.deniedPathPrefixes),
+        allowedWebSocketPathPrefixes: normalizePathPolicyPrefixes("pathPolicy.allowedWebSocketPathPrefixes", policy?.allowedWebSocketPathPrefixes),
+        deniedWebSocketPathPrefixes: normalizePathPolicyPrefixes("pathPolicy.deniedWebSocketPathPrefixes", policy?.deniedWebSocketPathPrefixes),
+    };
+}
+function assertPathPolicyAllows(kind, path, policy) {
+    const pathname = requestPathname(path);
+    const denied = kind === "websocket" ? [...policy.deniedPathPrefixes, ...policy.deniedWebSocketPathPrefixes] : policy.deniedPathPrefixes;
+    for (const prefix of denied) {
+        if (pathname.startsWith(prefix))
+            throw new ProxyRuntimePolicyError(`${kind} path is denied by proxy runtime policy`);
+    }
+    const allowed = kind === "websocket" && policy.allowedWebSocketPathPrefixes.length > 0
+        ? policy.allowedWebSocketPathPrefixes
+        : policy.allowedPathPrefixes;
+    if (allowed.length === 0)
+        return;
+    for (const prefix of allowed) {
+        if (pathname.startsWith(prefix))
+            return;
+    }
+    throw new ProxyRuntimePolicyError(`${kind} path is not allowed by proxy runtime policy`);
+}
 function normalizeMaxBytes(name, v, defaultValue) {
     if (v == null)
         return defaultValue;
@@ -117,8 +173,14 @@ export function createProxyRuntime(opts) {
     const extraRequestHeaders = opts.extraRequestHeaders ?? [];
     const extraResponseHeaders = opts.extraResponseHeaders ?? [];
     const extraWsHeaders = opts.extraWsHeaders ?? [];
+    const pathPolicy = normalizePathPolicy(opts.pathPolicy);
+    const externalOriginOverride = normalizeExternalOrigin(opts.externalOrigin);
+    const runtimeRegistrationToken = normalizeOptionalToken("runtimeRegistrationToken", opts.runtimeRegistrationToken);
     const registerRuntime = () => {
-        void ensureServiceWorkerRuntimeRegistered({ timeoutMs: 2_000 }).catch(() => {
+        void ensureServiceWorkerRuntimeRegistered({
+            timeoutMs: 2_000,
+            ...(runtimeRegistrationToken === undefined ? {} : { runtimeRegistrationToken }),
+        }).catch(() => {
             // Best-effort: controllerchange will retry once the active Service Worker is ready.
         });
     };
@@ -150,8 +212,9 @@ export function createProxyRuntime(opts) {
         void (async () => {
             try {
                 const path = pathOnly(req.path);
+                assertPathPolicyAllows("http", path, pathPolicy);
                 const requestID = req.id.trim() !== "" ? req.id : randomB64u(18);
-                const externalOrigin = normalizeExternalOrigin(req.external_origin);
+                const externalOrigin = externalOriginOverride ?? normalizeExternalOrigin(req.external_origin);
                 stream = await client.openStream(PROXY_KIND_HTTP1, { signal: ac.signal });
                 const reader = createByteReader(stream, { signal: ac.signal });
                 const filteredReqHeaders = filterRequestHeaders(req.headers, { extraAllowed: extraRequestHeaders });
@@ -201,7 +264,8 @@ export function createProxyRuntime(opts) {
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);
-                port.postMessage({ type: "flowersec-proxy:response_error", status: 502, message: msg });
+                const status = e instanceof ProxyRuntimePolicyError ? e.status : 502;
+                port.postMessage({ type: "flowersec-proxy:response_error", status, message: msg });
                 try {
                     stream?.reset(new Error(msg));
                 }
@@ -221,6 +285,7 @@ export function createProxyRuntime(opts) {
     };
     async function openWebSocketStream(pathRaw, wsOpts = {}) {
         const path = pathOnly(pathRaw);
+        assertPathPolicyAllows("websocket", path, pathPolicy);
         const openOpts = wsOpts.signal ? { signal: wsOpts.signal } : undefined;
         const stream = await client.openStream(PROXY_KIND_WS, openOpts);
         const reader = createByteReader(stream, openOpts);
@@ -261,6 +326,7 @@ export async function ensureServiceWorkerRuntimeRegistered(opts = {}) {
     if (!ctl || typeof ctl.postMessage !== "function")
         return;
     const timeoutMs = Math.max(0, Math.floor(opts.timeoutMs ?? 2_000));
+    const runtimeRegistrationToken = normalizeOptionalToken("runtimeRegistrationToken", opts.runtimeRegistrationToken);
     const ch = new MessageChannel();
     await new Promise((resolve, reject) => {
         let done = false;
@@ -306,7 +372,10 @@ export async function ensureServiceWorkerRuntimeRegistered(opts = {}) {
             }, timeoutMs);
         }
         try {
-            ctl.postMessage({ type: "flowersec-proxy:register-runtime" }, [ch.port2]);
+            ctl.postMessage({
+                type: "flowersec-proxy:register-runtime",
+                ...(runtimeRegistrationToken === undefined ? {} : { token: runtimeRegistrationToken }),
+            }, [ch.port2]);
         }
         catch (error) {
             finish(error);

package/dist/proxy/serviceWorker.d.ts

@@ -33,6 +33,8 @@ export type ProxyServiceWorkerScriptOptions = Readonly<{
     forwardFetchMessageTypes?: readonly string[];
     windowTarget?: "registered_runtime" | "request_client";
     windowClientMessageType?: string;
+    runtimeRegistrationToken?: string;
+    runtimeClientPathPrefix?: string;
     conflictHints?: Readonly<{
         keepScriptPathSuffixes?: readonly string[];
     }>;

package/dist/proxy/serviceWorker.js

@@ -61,6 +61,18 @@ function normalizeMessageTypeList(name, input) {
     }
     return Array.from(new Set(out));
 }
+function normalizeOptionalToken(name, input) {
+    if (input == null)
+        return "";
+    const s = String(input);
+    if (s === "")
+        return "";
+    if (s.trim() !== s)
+        throw new Error(`${name} must not contain leading or trailing whitespace`);
+    if (/[\s\u0000-\u001f\u007f]/.test(s))
+        throw new Error(`${name} must not contain whitespace or control characters`);
+    return s;
+}
 const defaultMaxInjectHTMLBytes = 2 * 1024 * 1024;
 function normalizeMaxBytes(name, v, defaultValue) {
     if (v == null)
@@ -108,6 +120,8 @@ export function createProxyServiceWorkerScript(opts = {}) {
             throw new Error("windowClientMessageType must not contain newline");
         return normalized;
     })();
+    const runtimeRegistrationToken = normalizeOptionalToken("runtimeRegistrationToken", opts.runtimeRegistrationToken);
+    const runtimeClientPathPrefix = normalizePathPrefix("runtimeClientPathPrefix", opts.runtimeClientPathPrefix);
     const injectHTML = opts.injectHTML ?? null;
     // Injection mode defaults to inline_module when injectHTML is provided.
     const injectMode = injectHTML?.mode ?? "inline_module";
@@ -165,6 +179,8 @@ const MAX_INJECT_HTML_BYTES = ${JSON.stringify(maxInjectHTMLBytes)};
 const FORWARD_FETCH_MESSAGE_TYPES = new Set(${JSON.stringify(forwardFetchMessageTypes)});
 const WINDOW_TARGET = ${JSON.stringify(windowTarget)};
 const WINDOW_CLIENT_MESSAGE_TYPE = ${JSON.stringify(windowClientMessageType)};
+const RUNTIME_REGISTRATION_TOKEN = ${JSON.stringify(runtimeRegistrationToken)};
+const RUNTIME_CLIENT_PATH_PREFIX = ${JSON.stringify(runtimeClientPathPrefix)};
 const CONFLICT_HINT_KEEP_SCRIPT_SUFFIXES = ${JSON.stringify(keepScriptPathSuffixes)};
 
 const INJECT_STRIP_HEADER_NAMES = new Set(["content-length", "etag", "last-modified", "content-md5"]);
@@ -186,13 +202,40 @@ self.addEventListener("message", (event) => {
   if (!data || typeof data !== "object") return;
   const msgType = typeof data.type === "string" ? data.type : "";
   if (msgType === "flowersec-proxy:register-runtime") {
-    const ok = Boolean(event.source && typeof event.source.id === "string");
-    if (ok) runtimeClientId = event.source.id;
-    const port = event.ports && event.ports[0];
-    if (port) {
-      try { port.postMessage({ type: "flowersec-proxy:register-runtime-ack", ok }); } catch {}
-      try { port.close(); } catch {}
-    }
+    event.waitUntil((async () => {
+      const sourceId = event.source && typeof event.source.id === "string" ? event.source.id : "";
+      let ok = sourceId !== "";
+      if (ok && RUNTIME_REGISTRATION_TOKEN) {
+        ok = typeof data.token === "string" && data.token === RUNTIME_REGISTRATION_TOKEN;
+      }
+      if (ok && RUNTIME_CLIENT_PATH_PREFIX) {
+        const c = await self.clients.get(sourceId);
+        if (!c || typeof c.url !== "string") {
+          ok = false;
+        } else {
+          try {
+            const u = new URL(c.url);
+            ok = u.origin === self.location.origin && u.pathname.startsWith(RUNTIME_CLIENT_PATH_PREFIX);
+          } catch {
+            ok = false;
+          }
+        }
+      }
+      if (ok && runtimeClientId && runtimeClientId !== sourceId) {
+        const existing = await self.clients.get(runtimeClientId);
+        if (existing) {
+          ok = false;
+        } else {
+          runtimeClientId = null;
+        }
+      }
+      if (ok) runtimeClientId = sourceId;
+      const port = event.ports && event.ports[0];
+      if (port) {
+        try { port.postMessage({ type: "flowersec-proxy:register-runtime-ack", ok }); } catch {}
+        try { port.close(); } catch {}
+      }
+    })());
     return;
   }
   if (!FORWARD_FETCH_MESSAGE_TYPES.has(msgType)) return;

package/dist/proxy/windowBridgeProtocol.d.ts

@@ -23,11 +23,13 @@ export type ProxyWindowFetchForwardMsg = Readonly<{
 export type ProxyWindowFetchMsg = Readonly<{
     type: typeof PROXY_WINDOW_FETCH_MSG_TYPE;
     req: ProxyWindowFetchRequest;
+    capabilityNonce?: string;
 }>;
 export type ProxyWindowWsOpenMsg = Readonly<{
     type: typeof PROXY_WINDOW_WS_OPEN_MSG_TYPE;
     path: string;
     protocols?: readonly string[];
+    capabilityNonce?: string;
 }>;
 export type ProxyWindowWsOpenAckMsg = Readonly<{
     type: typeof PROXY_WINDOW_WS_OPEN_ACK_MSG_TYPE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/flowersec-core",
-  "version": "0.19.7",
+  "version": "0.19.9",
   "description": "Flowersec core TypeScript library (browser-friendly E2EE + multiplexing over WebSocket).",
   "license": "MIT",
   "repository": {