@floegence/flowersec-core 0.17.2 → 0.18.0

package/dist/proxy/index.d.ts

@@ -1,7 +1,8 @@
 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";

package/dist/proxy/index.js

@@ -1,7 +1,7 @@
 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";

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;

package/dist/proxy/preset.js

@@ -0,0 +1,133 @@
+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,
+    },
+});
+export const CODESERVER_PROXY_PRESET_MANIFEST = Object.freeze({
+    v: 1,
+    preset_id: "codeserver",
+    deprecated: true,
+    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: 32 * 1024 * 1024,
+    },
+});
+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),
+    });
+}
+export function resolveNamedProxyPreset(name) {
+    switch (String(name ?? "").trim()) {
+        case "":
+        case "default":
+            return DEFAULT_PROXY_PRESET_MANIFEST;
+        case "codeserver":
+            return CODESERVER_PROXY_PRESET_MANIFEST;
+        default:
+            throw new Error(`unknown proxy preset: ${name}`);
+    }
+}
+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/profiles.d.ts

@@ -1,3 +1,4 @@
+import { type ProxyPresetManifest } from "./preset.js";
 export type ProxyProfile = Readonly<{
     maxJsonFrameBytes: number;
     maxChunkBytes: number;
@@ -21,3 +22,4 @@ export declare const PROXY_PROFILE_CODESERVER: Readonly<{
     timeoutMs: number;
 }>;
 export declare function resolveProxyProfile(profile?: ProxyProfileName | Partial<ProxyProfile>): ProxyProfile;
+export declare function profileToPresetManifest(profile?: ProxyProfileName | Partial<ProxyProfile>): ProxyPresetManifest;

package/dist/proxy/profiles.js

@@ -1,20 +1,16 @@
-import { DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CHUNK_BYTES, DEFAULT_MAX_WS_FRAME_BYTES } from "./constants.js";
-const DEFAULT_PROFILE = Object.freeze({
-    // Keep aligned with runtime defaults.
-    maxJsonFrameBytes: 0,
-    maxChunkBytes: DEFAULT_MAX_CHUNK_BYTES,
-    maxBodyBytes: DEFAULT_MAX_BODY_BYTES,
-    maxWsFrameBytes: DEFAULT_MAX_WS_FRAME_BYTES,
-    timeoutMs: 0,
-});
-const CODESERVER_PROFILE = Object.freeze({
-    maxJsonFrameBytes: 0,
-    maxChunkBytes: DEFAULT_MAX_CHUNK_BYTES,
-    maxBodyBytes: DEFAULT_MAX_BODY_BYTES,
-    // Keep aligned with redeven/redeven-agent production profile.
-    maxWsFrameBytes: 32 * 1024 * 1024,
-    timeoutMs: 0,
-});
+import { CODESERVER_PROXY_PRESET_MANIFEST, DEFAULT_PROXY_PRESET_MANIFEST, resolveProxyPreset, } from "./preset.js";
+function toLegacyProfile(manifest) {
+    const resolved = resolveProxyPreset(manifest);
+    return Object.freeze({
+        maxJsonFrameBytes: resolved.limits.max_json_frame_bytes,
+        maxChunkBytes: resolved.limits.max_chunk_bytes,
+        maxBodyBytes: resolved.limits.max_body_bytes,
+        maxWsFrameBytes: resolved.limits.max_ws_frame_bytes,
+        timeoutMs: resolved.limits.timeout_ms ?? 0,
+    });
+}
+const DEFAULT_PROFILE = toLegacyProfile(DEFAULT_PROXY_PRESET_MANIFEST);
+const CODESERVER_PROFILE = toLegacyProfile(CODESERVER_PROXY_PRESET_MANIFEST);
 export const PROXY_PROFILE_DEFAULT = DEFAULT_PROFILE;
 export const PROXY_PROFILE_CODESERVER = CODESERVER_PROFILE;
 function normalizeSafeInt(name, value) {
@@ -52,3 +48,30 @@ export function resolveProxyProfile(profile) {
         timeoutMs: normalizeSafeInt("timeoutMs", profile.timeoutMs ?? base.timeoutMs),
     });
 }
+export function profileToPresetManifest(profile) {
+    if (profile == null)
+        return DEFAULT_PROXY_PRESET_MANIFEST;
+    if (typeof profile === "string") {
+        switch (profile) {
+            case "default":
+                return DEFAULT_PROXY_PRESET_MANIFEST;
+            case "codeserver":
+                return CODESERVER_PROXY_PRESET_MANIFEST;
+            default:
+                throw new Error(`unknown proxy profile: ${profile}`);
+        }
+    }
+    const resolved = resolveProxyProfile(profile);
+    return Object.freeze({
+        v: 1,
+        preset_id: "legacy-profile",
+        deprecated: true,
+        limits: {
+            ...(resolved.maxJsonFrameBytes > 0 ? { max_json_frame_bytes: resolved.maxJsonFrameBytes } : {}),
+            ...(resolved.maxChunkBytes > 0 ? { max_chunk_bytes: resolved.maxChunkBytes } : {}),
+            ...(resolved.maxBodyBytes > 0 ? { max_body_bytes: resolved.maxBodyBytes } : {}),
+            ...(resolved.maxWsFrameBytes > 0 ? { max_ws_frame_bytes: resolved.maxWsFrameBytes } : {}),
+            ...(resolved.timeoutMs > 0 ? { timeout_ms: resolved.timeoutMs } : {}),
+        },
+    });
+}

package/dist/reconnect/index.d.ts

@@ -1,5 +1,5 @@
 import type { Client } from "../client.js";
-import type { ClientObserverLike } from "../observability/observer.js";
+import { type ClientObserverLike } from "../observability/observer.js";
 export type ConnectionStatus = "disconnected" | "connecting" | "connected" | "error";
 export type AutoReconnectConfig = Readonly<{
     enabled?: boolean;

package/dist/reconnect/index.js

@@ -1,3 +1,4 @@
+import { withObserverContext } from "../observability/observer.js";
 function normalizeAutoReconnect(cfg) {
     if (!cfg?.enabled) {
         return {
@@ -59,6 +60,7 @@ export function createReconnectManager() {
     let retryTimer = null;
     let retryResolve = null;
     let attemptAbort = null;
+    let attemptSeq = 0;
     const cancelRetrySleep = () => {
         if (retryTimer) {
             clearTimeout(retryTimer);
@@ -90,6 +92,7 @@ export function createReconnectManager() {
         active = null;
         activeConnectPromise = null;
         token += 1;
+        attemptSeq = 0;
         if (s.client) {
             try {
                 s.client.close();
@@ -138,9 +141,9 @@ export function createReconnectManager() {
             // connectWithRetry updates state; keep errors observable via state().
         });
     };
-    const createObserver = (t, cfg) => {
+    const createObserver = (t, cfg, currentAttemptSeq) => {
         const user = cfg.observer;
-        return {
+        return withObserverContext({
             onConnect: (...args) => user?.onConnect?.(...args),
             onAttach: (...args) => user?.onAttach?.(...args),
             onHandshake: (...args) => user?.onHandshake?.(...args),
@@ -156,12 +159,14 @@ export function createReconnectManager() {
             },
             onRpcCall: (...args) => user?.onRpcCall?.(...args),
             onRpcNotify: (...args) => user?.onRpcNotify?.(...args),
-        };
+        }, {
+            attemptSeq: currentAttemptSeq,
+        });
     };
-    const connectOnce = async (t, cfg) => {
+    const connectOnce = async (t, cfg, currentAttemptSeq) => {
         abortActiveAttempt();
         attemptAbort = new AbortController();
-        return await cfg.connectOnce({ signal: attemptAbort.signal, observer: createObserver(t, cfg) ?? {} });
+        return await cfg.connectOnce({ signal: attemptAbort.signal, observer: createObserver(t, cfg, currentAttemptSeq) ?? {} });
     };
     const connectWithRetry = async (t, cfg) => {
         const ar = normalizeAutoReconnect(cfg.autoReconnect);
@@ -172,8 +177,9 @@ export function createReconnectManager() {
             if (active !== cfg)
                 return;
             attempts += 1;
+            attemptSeq += 1;
             try {
-                const client = await connectOnce(t, cfg);
+                const client = await connectOnce(t, cfg, attemptSeq);
                 if (t !== token) {
                     try {
                         client.close();
@@ -218,6 +224,7 @@ export function createReconnectManager() {
         token += 1;
         const t = token;
         active = cfg;
+        attemptSeq = 0;
         if (s.client) {
             try {
                 s.client.close();

package/package.json

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