@mergedapp/feature-flags 0.1.3

package/dist/cjs/openfeature/server-provider.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergedOpenFeatureServerProvider = void 0;
+exports.createOpenFeatureServerProvider = createOpenFeatureServerProvider;
+const server_sdk_1 = require("@openfeature/server-sdk");
+const remote_evaluator_js_1 = require("../remote-evaluator.js");
+const shared_js_1 = require("./shared.js");
+class MergedOpenFeatureServerProvider {
+    events = new server_sdk_1.OpenFeatureEventEmitter();
+    metadata;
+    runsOn = "server";
+    config;
+    evaluator;
+    evaluationCache = new Map();
+    constructor(config) {
+        this.config = config;
+        this.evaluator = new remote_evaluator_js_1.RemoteFeatureFlagEvaluator(config);
+        this.metadata = {
+            name: config.metadataName ?? "@mergedapp/feature-flags/openfeature-server",
+        };
+    }
+    async initialize() {
+        this.events.emit("PROVIDER_READY");
+    }
+    async onClose() {
+        this.evaluationCache.clear();
+        return;
+    }
+    async resolveBooleanEvaluation(flagKey, defaultValue, context, logger) {
+        return this.resolveEvaluation({
+            context,
+            defaultValue,
+            expectedType: "BOOLEAN",
+            flagKey,
+            logger,
+        });
+    }
+    async resolveStringEvaluation(flagKey, defaultValue, context, logger) {
+        return this.resolveEvaluation({
+            context,
+            defaultValue,
+            expectedType: "STRING",
+            flagKey,
+            logger,
+        });
+    }
+    async resolveNumberEvaluation(flagKey, defaultValue, context, logger) {
+        return this.resolveEvaluation({
+            context,
+            defaultValue,
+            expectedType: "NUMBER",
+            flagKey,
+            logger,
+        });
+    }
+    async resolveObjectEvaluation(flagKey, defaultValue, context, logger) {
+        return this.resolveEvaluation({
+            context,
+            defaultValue,
+            expectedType: "OBJECT",
+            flagKey,
+            logger,
+        });
+    }
+    async resolveEvaluation(params) {
+        try {
+            const mappedContext = (0, shared_js_1.resolveOpenFeatureContext)({ config: this.config, context: params.context });
+            const cacheKey = JSON.stringify(mappedContext ?? null);
+            let evaluationPromise = this.evaluationCache.get(cacheKey);
+            if (!evaluationPromise) {
+                evaluationPromise = this.evaluator.evaluate(mappedContext).finally(() => {
+                    this.evaluationCache.delete(cacheKey);
+                });
+                this.evaluationCache.set(cacheKey, evaluationPromise);
+            }
+            const evaluation = await evaluationPromise;
+            const flag = (0, shared_js_1.findEvaluatedFlag)(evaluation.flags, params.flagKey, this.config.flagIds);
+            if (!flag) {
+                return (0, shared_js_1.resolveMissingFlagEvaluation)({
+                    defaultValue: params.defaultValue,
+                    flagKey: params.flagKey,
+                    logger: params.logger,
+                });
+            }
+            if (!(0, shared_js_1.matchesExpectedType)(flag, params.expectedType)) {
+                return (0, shared_js_1.resolveTypeMismatchEvaluation)({
+                    actualFlag: flag,
+                    defaultValue: params.defaultValue,
+                    expectedType: params.expectedType,
+                    logger: params.logger,
+                });
+            }
+            return (0, shared_js_1.resolveSuccessfulEvaluation)({
+                defaultValue: params.defaultValue,
+                flag,
+            });
+        }
+        catch (error) {
+            params.logger.error(`Failed evaluating feature flag (${params.flagKey}).`, error);
+            throw error;
+        }
+    }
+}
+exports.MergedOpenFeatureServerProvider = MergedOpenFeatureServerProvider;
+function createOpenFeatureServerProvider(config) {
+    return new MergedOpenFeatureServerProvider(config);
+}

package/dist/cjs/openfeature/server.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergedOpenFeatureServerProvider = exports.createOpenFeatureServerProvider = exports.mergeFeatureFlagEvaluationContexts = exports.createDefaultOpenFeatureContextMapper = exports.DEFAULT_TARGETING_KEY_ATTRIBUTE = exports.createStaticContextHook = exports.createLoggingHook = void 0;
+var hooks_js_1 = require("./hooks.js");
+Object.defineProperty(exports, "createLoggingHook", { enumerable: true, get: function () { return hooks_js_1.createLoggingHook; } });
+Object.defineProperty(exports, "createStaticContextHook", { enumerable: true, get: function () { return hooks_js_1.createStaticContextHook; } });
+var context_js_1 = require("./context.js");
+Object.defineProperty(exports, "DEFAULT_TARGETING_KEY_ATTRIBUTE", { enumerable: true, get: function () { return context_js_1.DEFAULT_TARGETING_KEY_ATTRIBUTE; } });
+Object.defineProperty(exports, "createDefaultOpenFeatureContextMapper", { enumerable: true, get: function () { return context_js_1.createDefaultOpenFeatureContextMapper; } });
+Object.defineProperty(exports, "mergeFeatureFlagEvaluationContexts", { enumerable: true, get: function () { return context_js_1.mergeFeatureFlagEvaluationContexts; } });
+var server_provider_js_1 = require("./server-provider.js");
+Object.defineProperty(exports, "createOpenFeatureServerProvider", { enumerable: true, get: function () { return server_provider_js_1.createOpenFeatureServerProvider; } });
+Object.defineProperty(exports, "MergedOpenFeatureServerProvider", { enumerable: true, get: function () { return server_provider_js_1.MergedOpenFeatureServerProvider; } });

package/dist/cjs/openfeature/shared.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOpenFeatureContext = resolveOpenFeatureContext;
+exports.createOpenFeatureMetadata = createOpenFeatureMetadata;
+exports.findEvaluatedFlag = findEvaluatedFlag;
+exports.resolveSuccessfulEvaluation = resolveSuccessfulEvaluation;
+exports.resolveMissingFlagEvaluation = resolveMissingFlagEvaluation;
+exports.resolveTypeMismatchEvaluation = resolveTypeMismatchEvaluation;
+exports.matchesExpectedType = matchesExpectedType;
+const core_1 = require("@openfeature/core");
+const context_js_1 = require("./context.js");
+function resolveOpenFeatureContext(params) {
+    const mapper = params.config.contextMapper ??
+        (0, context_js_1.createDefaultOpenFeatureContextMapper)({
+            targetingKeyAttribute: params.config.targetingKeyAttribute,
+        });
+    return (0, context_js_1.mergeFeatureFlagEvaluationContexts)(params.config.evaluationContext ?? null, params.context ? mapper(params.context) : null);
+}
+function createOpenFeatureMetadata(params) {
+    return {
+        id: params.flag.id,
+        name: params.flag.name,
+        type: params.flag.type,
+        teamId: params.flag.teamId ?? "",
+        enabled: params.flag.enabled,
+        source: params.runtimeStatus?.source ?? "network",
+        isStale: params.runtimeStatus?.isStale ?? false,
+    };
+}
+function findEvaluatedFlag(flags, flagKey, flagIds) {
+    const resolvedId = flagIds?.[flagKey];
+    if (resolvedId) {
+        const matchedByResolvedId = flags.find((flag) => flag.id === resolvedId);
+        if (matchedByResolvedId) {
+            return matchedByResolvedId;
+        }
+    }
+    return flags.find((flag) => flag.id === flagKey) ?? flags.find((flag) => flag.name === flagKey);
+}
+function resolveSuccessfulEvaluation(params) {
+    return {
+        value: params.flag.value,
+        variant: params.flag.name,
+        flagMetadata: createOpenFeatureMetadata(params),
+        reason: resolveResolutionReason(params),
+    };
+}
+function resolveResolutionReason(params) {
+    if (!params.flag.enabled) {
+        return core_1.StandardResolutionReasons.DISABLED;
+    }
+    if (params.runtimeStatus?.isStale) {
+        return core_1.StandardResolutionReasons.STALE;
+    }
+    if (params.runtimeStatus?.source === "persisted") {
+        return core_1.StandardResolutionReasons.CACHED;
+    }
+    return core_1.StandardResolutionReasons.TARGETING_MATCH;
+}
+function resolveMissingFlagEvaluation(params) {
+    params.logger?.warn(`Feature flag (${params.flagKey}) was not found.`);
+    return {
+        value: params.defaultValue,
+        reason: core_1.StandardResolutionReasons.ERROR,
+        errorCode: core_1.ErrorCode.FLAG_NOT_FOUND,
+        errorMessage: `Feature flag (${params.flagKey}) was not found.`,
+    };
+}
+function resolveTypeMismatchEvaluation(params) {
+    const message = `Feature flag (${params.actualFlag.name}) resolved as ${params.actualFlag.type}, expected ${params.expectedType}.`;
+    params.logger?.warn(message);
+    return {
+        value: params.defaultValue,
+        variant: params.actualFlag.name,
+        flagMetadata: createOpenFeatureMetadata({ flag: params.actualFlag }),
+        reason: core_1.StandardResolutionReasons.ERROR,
+        errorCode: core_1.ErrorCode.TYPE_MISMATCH,
+        errorMessage: message,
+    };
+}
+function matchesExpectedType(flag, expectedType) {
+    return flag.type === expectedType;
+}

package/dist/cjs/openfeature/web-provider.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergedOpenFeatureWebProvider = void 0;
+exports.createOpenFeatureWebProvider = createOpenFeatureWebProvider;
+const web_sdk_1 = require("@openfeature/web-sdk");
+const client_js_1 = require("../client.js");
+const shared_js_1 = require("./shared.js");
+class MergedOpenFeatureWebProvider {
+    events = new web_sdk_1.OpenFeatureEventEmitter();
+    metadata;
+    runsOn = "client";
+    client;
+    ownsClient;
+    config;
+    currentFlagsSignature = "";
+    unsubscribe = null;
+    constructor(config) {
+        this.config = config;
+        this.ownsClient = !config.client;
+        this.client =
+            config.client ??
+                new client_js_1.MergedFeatureFlags({
+                    apiUrl: config.apiUrl,
+                    clientKey: config.clientKey,
+                    environmentId: config.environmentId,
+                    organizationId: config.organizationId,
+                    teamId: config.teamId,
+                    publicKey: config.publicKey,
+                    evaluationContext: config.evaluationContext,
+                    refreshInterval: config.refreshInterval,
+                });
+        this.metadata = {
+            name: config.metadataName ?? "@mergedapp/feature-flags/openfeature-web",
+        };
+    }
+    async initialize(context) {
+        if (context) {
+            this.client.setEvaluationContext((0, shared_js_1.resolveOpenFeatureContext)({ config: this.config, context }));
+        }
+        await this.client.initialize();
+        let previousFlags = this.client.getAllFlags();
+        this.currentFlagsSignature = serializeFlags(previousFlags);
+        this.unsubscribe = this.client.subscribe(() => {
+            const nextFlags = this.client.getAllFlags();
+            const nextSignature = serializeFlags(nextFlags);
+            if (nextSignature !== this.currentFlagsSignature) {
+                this.currentFlagsSignature = nextSignature;
+                this.events.emit(web_sdk_1.ClientProviderEvents.ConfigurationChanged, {
+                    flagsChanged: getChangedFlagNames(previousFlags, nextFlags),
+                });
+                previousFlags = nextFlags;
+            }
+        });
+    }
+    async onClose() {
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+        if (this.ownsClient) {
+            this.client.destroy();
+        }
+    }
+    async onContextChange(_oldContext, newContext) {
+        this.client.setEvaluationContext((0, shared_js_1.resolveOpenFeatureContext)({ config: this.config, context: newContext }));
+        await this.client.refresh();
+    }
+    resolveBooleanEvaluation(flagKey, defaultValue, _context) {
+        return this.resolveEvaluation({
+            defaultValue,
+            expectedType: "BOOLEAN",
+            flagKey,
+        });
+    }
+    resolveStringEvaluation(flagKey, defaultValue, _context) {
+        return this.resolveEvaluation({
+            defaultValue,
+            expectedType: "STRING",
+            flagKey,
+        });
+    }
+    resolveNumberEvaluation(flagKey, defaultValue, _context) {
+        return this.resolveEvaluation({
+            defaultValue,
+            expectedType: "NUMBER",
+            flagKey,
+        });
+    }
+    resolveObjectEvaluation(flagKey, defaultValue, _context) {
+        return this.resolveEvaluation({
+            defaultValue,
+            expectedType: "OBJECT",
+            flagKey,
+        });
+    }
+    resolveEvaluation(params) {
+        const flag = (0, shared_js_1.findEvaluatedFlag)(this.client.getAllFlags(), params.flagKey, this.config.flagIds);
+        if (!flag) {
+            return {
+                ...(0, shared_js_1.resolveMissingFlagEvaluation)(params),
+                reason: this.client.getStatus().source === "defaults" ? web_sdk_1.StandardResolutionReasons.DEFAULT : undefined,
+            };
+        }
+        if (!(0, shared_js_1.matchesExpectedType)(flag, params.expectedType)) {
+            return (0, shared_js_1.resolveTypeMismatchEvaluation)({
+                actualFlag: flag,
+                defaultValue: params.defaultValue,
+                expectedType: params.expectedType,
+            });
+        }
+        return {
+            ...(0, shared_js_1.resolveSuccessfulEvaluation)({
+                defaultValue: params.defaultValue,
+                flag,
+                runtimeStatus: this.client.getStatus(),
+            }),
+        };
+    }
+}
+exports.MergedOpenFeatureWebProvider = MergedOpenFeatureWebProvider;
+function serializeFlags(flags) {
+    return JSON.stringify(flags.map((flag) => ({
+        enabled: flag.enabled,
+        id: flag.id,
+        name: flag.name,
+        type: flag.type,
+        value: flag.value,
+    })));
+}
+function getChangedFlagNames(previousFlags, nextFlags) {
+    const previousById = new Map(previousFlags.map((flag) => [flag.id, serializeComparableFlag(flag)]));
+    const nextById = new Map(nextFlags.map((flag) => [flag.id, serializeComparableFlag(flag)]));
+    const changed = new Set();
+    for (const [id, nextEntry] of nextById) {
+        const previousEntry = previousById.get(id);
+        if (!previousEntry ||
+            previousEntry.flag.enabled !== nextEntry.flag.enabled ||
+            previousEntry.flag.name !== nextEntry.flag.name ||
+            previousEntry.serializedValue !== nextEntry.serializedValue) {
+            changed.add(nextEntry.flag.name);
+        }
+    }
+    for (const [id, previousEntry] of previousById) {
+        if (!nextById.has(id)) {
+            changed.add(previousEntry.flag.name);
+        }
+    }
+    return Array.from(changed);
+}
+function serializeComparableFlag(flag) {
+    return {
+        flag,
+        serializedValue: JSON.stringify(flag.value),
+    };
+}
+function createOpenFeatureWebProvider(config) {
+    return new MergedOpenFeatureWebProvider(config);
+}

package/dist/cjs/openfeature/web.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergedOpenFeatureWebProvider = exports.createOpenFeatureWebProvider = exports.mergeFeatureFlagEvaluationContexts = exports.createDefaultOpenFeatureContextMapper = exports.DEFAULT_TARGETING_KEY_ATTRIBUTE = exports.createStaticContextHook = exports.createLoggingHook = void 0;
+var hooks_js_1 = require("./hooks.js");
+Object.defineProperty(exports, "createLoggingHook", { enumerable: true, get: function () { return hooks_js_1.createLoggingHook; } });
+Object.defineProperty(exports, "createStaticContextHook", { enumerable: true, get: function () { return hooks_js_1.createStaticContextHook; } });
+var context_js_1 = require("./context.js");
+Object.defineProperty(exports, "DEFAULT_TARGETING_KEY_ATTRIBUTE", { enumerable: true, get: function () { return context_js_1.DEFAULT_TARGETING_KEY_ATTRIBUTE; } });
+Object.defineProperty(exports, "createDefaultOpenFeatureContextMapper", { enumerable: true, get: function () { return context_js_1.createDefaultOpenFeatureContextMapper; } });
+Object.defineProperty(exports, "mergeFeatureFlagEvaluationContexts", { enumerable: true, get: function () { return context_js_1.mergeFeatureFlagEvaluationContexts; } });
+var web_provider_js_1 = require("./web-provider.js");
+Object.defineProperty(exports, "createOpenFeatureWebProvider", { enumerable: true, get: function () { return web_provider_js_1.createOpenFeatureWebProvider; } });
+Object.defineProperty(exports, "MergedOpenFeatureWebProvider", { enumerable: true, get: function () { return web_provider_js_1.MergedOpenFeatureWebProvider; } });

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/persistence.js

@@ -0,0 +1,249 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCanonicalValue = serializeCanonicalValue;
+exports.createDefaultFeatureFlagRuntimeStatus = createDefaultFeatureFlagRuntimeStatus;
+exports.buildSnapshotScopeParts = buildSnapshotScopeParts;
+exports.createPersistedFeatureFlagSnapshot = createPersistedFeatureFlagSnapshot;
+exports.doesSnapshotMatchScope = doesSnapshotMatchScope;
+exports.isBrowserPersistenceAvailable = isBrowserPersistenceAvailable;
+exports.createLocalStorageFeatureFlagSnapshotStore = createLocalStorageFeatureFlagSnapshotStore;
+exports.createFileFeatureFlagSnapshotStore = createFileFeatureFlagSnapshotStore;
+exports.resolveSnapshotStore = resolveSnapshotStore;
+exports.getSnapshotKeyPrefix = getSnapshotKeyPrefix;
+exports.decodeJwtPayload = decodeJwtPayload;
+const DEFAULT_SNAPSHOT_KEY_PREFIX = "merged-feature-flags";
+const SNAPSHOT_SCHEMA_VERSION = 1;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+let nodeModulePromise = null;
+async function getNodeModules() {
+    if (!nodeModulePromise) {
+        nodeModulePromise = Promise.all([
+            Promise.resolve().then(() => __importStar(require("node:crypto"))),
+            Promise.resolve().then(() => __importStar(require("node:fs/promises"))),
+            Promise.resolve().then(() => __importStar(require("node:os"))),
+            Promise.resolve().then(() => __importStar(require("node:path"))),
+        ]).then(([crypto, fs, os, path]) => ({ crypto, fs, os, path }));
+    }
+    return nodeModulePromise;
+}
+function normalizeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeValue(item));
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => [key, normalizeValue(entryValue)]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+function serializeCanonicalValue(value) {
+    return JSON.stringify(normalizeValue(value));
+}
+function createDefaultFeatureFlagRuntimeStatus() {
+    return {
+        source: "defaults",
+        isStale: false,
+        lastSuccessfulRefreshAt: null,
+        tokenExpiresAt: null,
+        lastError: null,
+    };
+}
+async function sha256Hex(value) {
+    if (globalThis.crypto?.subtle) {
+        const digest = await globalThis.crypto.subtle.digest("SHA-256", textEncoder.encode(value));
+        return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    }
+    const { crypto } = await getNodeModules();
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+async function buildSnapshotScopeParts(params) {
+    const contextHash = await sha256Hex(serializeCanonicalValue(params.config.evaluationContext ?? null));
+    const clientKeyFingerprint = await sha256Hex(params.config.clientKey);
+    const prefix = params.keyPrefix?.trim() || DEFAULT_SNAPSHOT_KEY_PREFIX;
+    const scopeMaterial = serializeCanonicalValue({
+        apiUrl: params.config.apiUrl.replace(/\/$/, ""),
+        organizationId: params.config.organizationId.trim(),
+        environmentId: params.config.environmentId.trim(),
+        teamId: params.config.teamId?.trim() || null,
+        clientKeyFingerprint,
+        contextHash,
+    });
+    return {
+        scopeKey: `${prefix}:${await sha256Hex(scopeMaterial)}`,
+        organizationId: params.config.organizationId.trim(),
+        environmentId: params.config.environmentId.trim(),
+        teamId: params.config.teamId?.trim() || null,
+        clientKeyFingerprint,
+        contextHash,
+    };
+}
+function buildSnapshotRecord(params) {
+    return {
+        schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+        scopeKey: params.scope.scopeKey,
+        organizationId: params.scope.organizationId,
+        environmentId: params.scope.environmentId,
+        teamId: params.scope.teamId,
+        clientKeyFingerprint: params.scope.clientKeyFingerprint,
+        contextHash: params.scope.contextHash,
+        token: params.token,
+        publicKeyPem: params.publicKeyPem,
+        fetchedAt: params.fetchedAt,
+        tokenExpiresAt: params.tokenExpiresAt,
+    };
+}
+function createPersistedFeatureFlagSnapshot(params) {
+    return buildSnapshotRecord(params);
+}
+function doesSnapshotMatchScope(params) {
+    return (params.snapshot.schemaVersion === SNAPSHOT_SCHEMA_VERSION &&
+        params.snapshot.scopeKey === params.scope.scopeKey &&
+        params.snapshot.organizationId === params.scope.organizationId &&
+        params.snapshot.environmentId === params.scope.environmentId &&
+        params.snapshot.teamId === params.scope.teamId &&
+        params.snapshot.clientKeyFingerprint === params.scope.clientKeyFingerprint &&
+        params.snapshot.contextHash === params.scope.contextHash);
+}
+function isBrowserPersistenceAvailable() {
+    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+function createLocalStorageFeatureFlagSnapshotStore() {
+    return {
+        async load(key) {
+            if (!isBrowserPersistenceAvailable()) {
+                return null;
+            }
+            try {
+                const raw = window.localStorage.getItem(key);
+                return raw ? JSON.parse(raw) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        async save(key, snapshot) {
+            if (!isBrowserPersistenceAvailable()) {
+                return;
+            }
+            try {
+                window.localStorage.setItem(key, JSON.stringify(snapshot));
+            }
+            catch {
+            }
+        },
+        async remove(key) {
+            if (!isBrowserPersistenceAvailable()) {
+                return;
+            }
+            try {
+                window.localStorage.removeItem(key);
+            }
+            catch {
+            }
+        },
+    };
+}
+function sanitizeKeyForFilename(key) {
+    return encodeURIComponent(key);
+}
+function createFileFeatureFlagSnapshotStore(params) {
+    return {
+        async load(key) {
+            const { fs, os, path } = await getNodeModules();
+            const rootDirectory = params?.rootDirectory ?? path.join(os.tmpdir(), DEFAULT_SNAPSHOT_KEY_PREFIX);
+            const filePath = path.join(rootDirectory, `${sanitizeKeyForFilename(key)}.json`);
+            try {
+                const raw = await fs.readFile(filePath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        },
+        async save(key, snapshot) {
+            const { fs, os, path } = await getNodeModules();
+            const rootDirectory = params?.rootDirectory ?? path.join(os.tmpdir(), DEFAULT_SNAPSHOT_KEY_PREFIX);
+            const filePath = path.join(rootDirectory, `${sanitizeKeyForFilename(key)}.json`);
+            const tempFilePath = path.join(rootDirectory, `${sanitizeKeyForFilename(key)}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+            await fs.mkdir(rootDirectory, { recursive: true });
+            await fs.writeFile(tempFilePath, JSON.stringify(snapshot), "utf-8");
+            await fs.rename(tempFilePath, filePath);
+        },
+        async remove(key) {
+            const { fs, os, path } = await getNodeModules();
+            const rootDirectory = params?.rootDirectory ?? path.join(os.tmpdir(), DEFAULT_SNAPSHOT_KEY_PREFIX);
+            const filePath = path.join(rootDirectory, `${sanitizeKeyForFilename(key)}.json`);
+            try {
+                await fs.rm(filePath, { force: true });
+            }
+            catch {
+            }
+        },
+    };
+}
+async function resolveSnapshotStore(params) {
+    const persistence = params.config.snapshotPersistence;
+    if (persistence === false) {
+        return null;
+    }
+    if (persistence?.store) {
+        return persistence.store;
+    }
+    if (isBrowserPersistenceAvailable()) {
+        return createLocalStorageFeatureFlagSnapshotStore();
+    }
+    return createFileFeatureFlagSnapshotStore();
+}
+function getSnapshotKeyPrefix(params) {
+    const persistence = params.config.snapshotPersistence;
+    return persistence?.keyPrefix?.trim() || DEFAULT_SNAPSHOT_KEY_PREFIX;
+}
+function decodeJwtPayload(token) {
+    const segments = token.split(".");
+    if (segments.length !== 3) {
+        throw new Error("JWT must contain exactly three segments.");
+    }
+    const payloadSegment = segments[1];
+    const normalized = payloadSegment.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+    const payloadBytes = typeof atob === "function"
+        ? Uint8Array.from(atob(padded), (character) => character.charCodeAt(0))
+        : Uint8Array.from(Buffer.from(padded, "base64"));
+    return JSON.parse(textDecoder.decode(payloadBytes));
+}