@cloudflare/flagship 0.0.0 → 0.0.1

package/dist/src-De-abNIr.cjs

@@ -0,0 +1,231 @@
+//#region src/types.ts
+/** Default base URL for the Flagship API. */
+const FLAGSHIP_DEFAULT_BASE_URL = "https://api.cloudflare.com";
+/**
+* Internal error codes produced by `FlagshipClient`.
+* These are mapped to OpenFeature `ErrorCode` values by the providers.
+*/
+let FlagshipErrorCode = /* @__PURE__ */ function(FlagshipErrorCode) {
+	/** HTTP or fetch-level failure (non-404/400 status, connection refused, etc.) */
+	FlagshipErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+	/** The request was aborted because the configured timeout elapsed. */
+	FlagshipErrorCode["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
+	/** The response body was not a valid evaluation response. */
+	FlagshipErrorCode["PARSE_ERROR"] = "PARSE_ERROR";
+	/** The evaluation context contained complex values that cannot be serialized to query parameters. */
+	FlagshipErrorCode["INVALID_CONTEXT"] = "INVALID_CONTEXT";
+	return FlagshipErrorCode;
+}({});
+/**
+* Error thrown by `FlagshipClient` for all abnormal conditions.
+* Carries a `code` for programmatic handling and an optional `cause` which
+* is the underlying `Response` object for HTTP errors, allowing callers to
+* inspect the status code (e.g. to distinguish 404 → `FLAG_NOT_FOUND`).
+*/
+var FlagshipError = class extends Error {
+	constructor(message, code, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		this.name = "FlagshipError";
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+//#endregion
+//#region src/context.ts
+/**
+* Utility for transforming OpenFeature evaluation context
+*/
+var ContextTransformer = class {
+	/**
+	* Transform OpenFeature evaluation context to query parameters
+	* for the Flagship API.
+	*
+	* Primitive values (`string`, `number`, `boolean`) and `Date` objects are
+	* serialized directly. Nested objects and arrays cannot be expressed as query
+	* parameters and are skipped.
+	*
+	* When a `droppedKeys` collector array is provided, skipped key names are
+	* pushed into it and **no** console warning is emitted — the caller is
+	* expected to handle the situation (e.g. throw `INVALID_CONTEXT`).
+	* When no collector is provided, a `console.warn` is emitted for each
+	* skipped key so the issue is still surfaced in development.
+	*
+	* @param context - OpenFeature evaluation context
+	* @param droppedKeys - Optional collector array; skipped key names are pushed here
+	*/
+	static toQueryParams(context, droppedKeys) {
+		const params = {};
+		for (const [key, value] of Object.entries(context)) {
+			if (value === void 0 || value === null) continue;
+			if (value instanceof Date) {
+				params[key] = value.toISOString();
+				continue;
+			}
+			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+				params[key] = String(value);
+				continue;
+			}
+			if (typeof value === "object") {
+				if (droppedKeys) droppedKeys.push(key);
+				else console.warn(`[Flagship] Context key "${key}" is a complex object/array and cannot be serialized to a query parameter. This value will be ignored during flag evaluation.`);
+				continue;
+			}
+		}
+		return params;
+	}
+	/**
+	* Build URL with query parameters from context.
+	*
+	* @param baseUrl - The base evaluation endpoint URL
+	* @param flagKey - The flag key to evaluate
+	* @param context - OpenFeature evaluation context
+	* @param droppedKeys - Optional collector array; skipped context key names are pushed here
+	*/
+	static buildUrl(baseUrl, flagKey, context, droppedKeys) {
+		const url = new URL(baseUrl);
+		url.searchParams.set("flagKey", flagKey);
+		const params = this.toQueryParams(context, droppedKeys);
+		for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+		return url.toString();
+	}
+};
+//#endregion
+//#region src/client.ts
+var FlagshipClient = class {
+	constructor(options) {
+		this.options = {
+			endpoint: resolveEndpoint(options),
+			fetchOptions: buildFetchOptions(options),
+			timeout: options.timeout || 5e3,
+			retries: Math.min(options.retries !== void 0 ? options.retries : 1, 10),
+			retryDelay: Math.min(options.retryDelay !== void 0 ? options.retryDelay : 1e3, 3e4)
+		};
+	}
+	/**
+	* Evaluate a flag with the given context.
+	*
+	* Throws a `FlagshipError` with `FlagshipErrorCode.INVALID_CONTEXT` if the
+	* evaluation context contains complex values (objects or arrays) that cannot
+	* be serialized to query parameters.
+	*/
+	async evaluate(flagKey, context) {
+		const droppedKeys = [];
+		const url = ContextTransformer.buildUrl(this.options.endpoint, flagKey, context, droppedKeys);
+		if (droppedKeys.length > 0) throw new FlagshipError(`Evaluation context contains complex values that cannot be serialized for flag "${flagKey}". Unsupported keys: ${droppedKeys.join(", ")}. Use primitive values (string, number, boolean) or Date objects.`, FlagshipErrorCode.INVALID_CONTEXT);
+		return this.fetchWithRetry(url, this.options.retries);
+	}
+	/**
+	* Fetch with retry logic. Only retries on transient network/server errors —
+	* 404 and 400 responses are terminal and propagated immediately.
+	*/
+	async fetchWithRetry(url, retriesLeft) {
+		try {
+			return await this.fetchWithTimeout(url, this.options.timeout);
+		} catch (error) {
+			if (error instanceof FlagshipError && error.cause instanceof Response) {
+				const status = error.cause.status;
+				if (status === 404 || status === 400) throw error;
+			}
+			if (retriesLeft > 0) {
+				await new Promise((resolve) => setTimeout(resolve, this.options.retryDelay));
+				return this.fetchWithRetry(url, retriesLeft - 1);
+			}
+			throw error;
+		}
+	}
+	/**
+	* Fetch with timeout using AbortController
+	*/
+	async fetchWithTimeout(url, timeout) {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeout);
+		try {
+			const response = await fetch(url, {
+				...this.options.fetchOptions,
+				signal: controller.signal
+			});
+			clearTimeout(timeoutId);
+			if (!response.ok) throw new FlagshipError(`HTTP ${response.status}: ${response.statusText}`, FlagshipErrorCode.NETWORK_ERROR, response);
+			const data = await response.json();
+			if (!data || typeof data !== "object" || !("flagKey" in data) || !("value" in data)) throw new FlagshipError("Invalid response format from Flagship API", FlagshipErrorCode.PARSE_ERROR);
+			return data;
+		} catch (error) {
+			clearTimeout(timeoutId);
+			if (error instanceof Error && error.name === "AbortError") throw new FlagshipError(`Request timeout after ${timeout}ms`, FlagshipErrorCode.TIMEOUT_ERROR, error);
+			if (error instanceof FlagshipError) throw error;
+			throw new FlagshipError(`Network error: ${error}`, FlagshipErrorCode.NETWORK_ERROR, error);
+		}
+	}
+};
+/**
+* Merge `authToken` and `fetchOptions` into a single `RequestInit`.
+*
+* Precedence for the `Authorization` header (highest → lowest):
+* 1. An explicit `Authorization` value inside `fetchOptions.headers`
+* 2. A value derived from `authToken`
+*
+* All other `fetchOptions` fields are spread as-is.
+*/
+function buildFetchOptions(options) {
+	const { authToken, fetchOptions = {} } = options;
+	if (!authToken) return fetchOptions;
+	const existingHeaders = new Headers(fetchOptions.headers);
+	if (!existingHeaders.has("Authorization")) existingHeaders.set("Authorization", `Bearer ${authToken}`);
+	return {
+		...fetchOptions,
+		headers: existingHeaders
+	};
+}
+function resolveEndpoint(options) {
+	const { appId, endpoint, baseUrl, accountId } = options;
+	if (appId && endpoint) throw new Error("Flagship: provide either \"appId\" or \"endpoint\", not both");
+	if (!appId && !endpoint) throw new Error("Flagship: either \"appId\" or \"endpoint\" is required");
+	if (endpoint) {
+		try {
+			new URL(endpoint);
+		} catch {
+			throw new Error(`Flagship: invalid endpoint URL: ${endpoint}`);
+		}
+		return endpoint;
+	}
+	if (!accountId) throw new Error("Flagship: \"accountId\" is required when using \"appId\"");
+	const resolved = `${(baseUrl || "https://api.cloudflare.com").replace(/\/+$/, "")}/client/v4/accounts/${encodeURIComponent(accountId)}/flagship/apps/${encodeURIComponent(appId)}/evaluate`;
+	try {
+		new URL(resolved);
+	} catch {
+		throw new Error(`Flagship: resolved endpoint is not a valid URL: ${resolved}`);
+	}
+	return resolved;
+}
+//#endregion
+Object.defineProperty(exports, "ContextTransformer", {
+	enumerable: true,
+	get: function() {
+		return ContextTransformer;
+	}
+});
+Object.defineProperty(exports, "FLAGSHIP_DEFAULT_BASE_URL", {
+	enumerable: true,
+	get: function() {
+		return FLAGSHIP_DEFAULT_BASE_URL;
+	}
+});
+Object.defineProperty(exports, "FlagshipClient", {
+	enumerable: true,
+	get: function() {
+		return FlagshipClient;
+	}
+});
+Object.defineProperty(exports, "FlagshipError", {
+	enumerable: true,
+	get: function() {
+		return FlagshipError;
+	}
+});
+Object.defineProperty(exports, "FlagshipErrorCode", {
+	enumerable: true,
+	get: function() {
+		return FlagshipErrorCode;
+	}
+});

package/dist/web.cjs

@@ -0,0 +1,148 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_src = require("./src-De-abNIr.cjs");
+let _openfeature_web_sdk = require("@openfeature/web-sdk");
+//#region src/client-provider.ts
+/**
+* OpenFeature provider for Flagship (client-side / browser).
+*
+* Fetches all flags listed in `prefetchFlags` during initialization and on
+* every context change, storing results in an in-memory cache. All
+* `resolve*` methods are synchronous, as required by the OpenFeature web SDK.
+*
+* A cache miss (flag key not in `prefetchFlags`, or fetch failed) returns
+* `ErrorCode.FLAG_NOT_FOUND` with the default value.
+*
+* @example
+* ```typescript
+* import { OpenFeature } from '@openfeature/web-sdk';
+* import { FlagshipClientProvider } from '@cloudflare/flagship/web';
+*
+* await OpenFeature.setProviderAndWait(
+*   new FlagshipClientProvider({
+*     appId: 'app-abc123',
+*     accountId: 'your-account-id',
+*     authToken: 'your-token',
+*     prefetchFlags: ['dark-mode', 'welcome-message'],
+*   })
+* );
+*
+* await OpenFeature.setContext({ targetingKey: 'user-123', plan: 'premium' });
+*
+* const client = OpenFeature.getClient();
+* const darkMode = client.getBooleanValue('dark-mode', false);
+* ```
+*/
+var FlagshipClientProvider = class {
+	constructor(options) {
+		this.runsOn = "client";
+		this.events = new _openfeature_web_sdk.OpenFeatureEventEmitter();
+		this.cache = /* @__PURE__ */ new Map();
+		this.currentStatus = _openfeature_web_sdk.ProviderStatus.NOT_READY;
+		this.metadata = { name: "Flagship Client Provider" };
+		this.client = new require_src.FlagshipClient(options);
+		this.prefetchFlags = options.prefetchFlags || [];
+		this.logging = options.logging ?? false;
+	}
+	get status() {
+		return this.currentStatus;
+	}
+	/**
+	* Fetches all `prefetchFlags` in parallel and populates the cache.
+	* Individual flag fetch failures are logged when `logging` is enabled but
+	* do not prevent the provider from reaching READY.
+	*/
+	async initialize(context = {}) {
+		await this.fetchAll(context, "initialization");
+		this.currentStatus = _openfeature_web_sdk.ProviderStatus.READY;
+		this.events.emit(_openfeature_web_sdk.ProviderEvents.Ready);
+	}
+	async onClose() {
+		this.cache.clear();
+		this.currentStatus = _openfeature_web_sdk.ProviderStatus.NOT_READY;
+	}
+	/**
+	* Invalidates the entire cache and re-fetches all `prefetchFlags` for the
+	* new context. Returning a Promise causes the SDK to automatically emit
+	* `ProviderEvents.Reconciling` while this method executes.
+	*/
+	async onContextChange(_oldContext, newContext = {}) {
+		this.cache.clear();
+		await this.fetchAll(newContext, "context change");
+	}
+	resolveBooleanEvaluation(flagKey, defaultValue, _context, logger) {
+		return this.resolveFromCache(flagKey, defaultValue, "boolean", logger);
+	}
+	resolveStringEvaluation(flagKey, defaultValue, _context, logger) {
+		return this.resolveFromCache(flagKey, defaultValue, "string", logger);
+	}
+	resolveNumberEvaluation(flagKey, defaultValue, _context, logger) {
+		return this.resolveFromCache(flagKey, defaultValue, "number", logger);
+	}
+	resolveObjectEvaluation(flagKey, defaultValue, _context, logger) {
+		return this.resolveFromCache(flagKey, defaultValue, "object", logger);
+	}
+	/**
+	* Fetches all `prefetchFlags` in parallel using `Promise.allSettled`.
+	* Failures are logged individually when `logging` is enabled.
+	*/
+	async fetchAll(context, phase) {
+		if (this.prefetchFlags.length === 0) return;
+		const results = await Promise.allSettled(this.prefetchFlags.map(async (flagKey) => {
+			const result = await this.client.evaluate(flagKey, context);
+			this.cache.set(flagKey, {
+				value: result.value,
+				reason: result.reason,
+				variant: result.variant
+			});
+		}));
+		if (this.logging) results.forEach((result, i) => {
+			if (result.status === "rejected") {
+				const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+				console.warn(`[Flagship] Failed to fetch flag "${this.prefetchFlags[i]}" during ${phase}: ${reason}`);
+			}
+		});
+	}
+	resolveFromCache(flagKey, defaultValue, expectedType, logger) {
+		const cached = this.cache.get(flagKey);
+		if (!cached) {
+			const msg = `Flag "${flagKey}" not found in cache. Add it to prefetchFlags to ensure it is fetched on initialization.`;
+			if (this.logging) logger.warn(`[Flagship] ${msg}`);
+			return {
+				value: defaultValue,
+				reason: "ERROR",
+				errorCode: _openfeature_web_sdk.ErrorCode.FLAG_NOT_FOUND,
+				errorMessage: msg
+			};
+		}
+		const actualType = this.getValueType(cached.value);
+		if (actualType !== expectedType) {
+			const msg = `Flag "${flagKey}" type mismatch: expected ${expectedType}, got ${actualType}`;
+			if (this.logging) logger.warn(`[Flagship] ${msg}`);
+			return {
+				value: defaultValue,
+				errorCode: _openfeature_web_sdk.ErrorCode.TYPE_MISMATCH,
+				errorMessage: msg,
+				reason: "ERROR"
+			};
+		}
+		return {
+			value: cached.value,
+			reason: "CACHED",
+			variant: cached.variant,
+			flagMetadata: {}
+		};
+	}
+	getValueType(value) {
+		if (typeof value === "boolean") return "boolean";
+		if (typeof value === "string") return "string";
+		if (typeof value === "number") return "number";
+		return "object";
+	}
+};
+//#endregion
+exports.ContextTransformer = require_src.ContextTransformer;
+exports.FLAGSHIP_DEFAULT_BASE_URL = require_src.FLAGSHIP_DEFAULT_BASE_URL;
+exports.FlagshipClient = require_src.FlagshipClient;
+exports.FlagshipClientProvider = FlagshipClientProvider;
+exports.FlagshipError = require_src.FlagshipError;
+exports.FlagshipErrorCode = require_src.FlagshipErrorCode;

package/dist/web.d.cts

@@ -0,0 +1,72 @@
+import { a as FlagshipClientProviderOptions, c as FlagshipEvaluationResponse, i as FLAGSHIP_DEFAULT_BASE_URL, l as FlagshipProviderOptions, n as ContextTransformer, o as FlagshipError, r as CachedFlag, s as FlagshipErrorCode, t as FlagshipClient } from "./index-D8YLMfBG.cjs";
+import { EvaluationContext, JsonValue, Logger, OpenFeatureEventEmitter, Provider, ProviderMetadata, ProviderStatus, ResolutionDetails } from "@openfeature/web-sdk";
+
+//#region src/client-provider.d.ts
+/**
+ * OpenFeature provider for Flagship (client-side / browser).
+ *
+ * Fetches all flags listed in `prefetchFlags` during initialization and on
+ * every context change, storing results in an in-memory cache. All
+ * `resolve*` methods are synchronous, as required by the OpenFeature web SDK.
+ *
+ * A cache miss (flag key not in `prefetchFlags`, or fetch failed) returns
+ * `ErrorCode.FLAG_NOT_FOUND` with the default value.
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/web-sdk';
+ * import { FlagshipClientProvider } from '@cloudflare/flagship/web';
+ *
+ * await OpenFeature.setProviderAndWait(
+ *   new FlagshipClientProvider({
+ *     appId: 'app-abc123',
+ *     accountId: 'your-account-id',
+ *     authToken: 'your-token',
+ *     prefetchFlags: ['dark-mode', 'welcome-message'],
+ *   })
+ * );
+ *
+ * await OpenFeature.setContext({ targetingKey: 'user-123', plan: 'premium' });
+ *
+ * const client = OpenFeature.getClient();
+ * const darkMode = client.getBooleanValue('dark-mode', false);
+ * ```
+ */
+declare class FlagshipClientProvider implements Provider {
+  readonly metadata: ProviderMetadata;
+  readonly runsOn: "client";
+  readonly events: OpenFeatureEventEmitter;
+  private cache;
+  private client;
+  private readonly prefetchFlags;
+  private readonly logging;
+  private currentStatus;
+  constructor(options: FlagshipClientProviderOptions);
+  get status(): ProviderStatus;
+  /**
+   * Fetches all `prefetchFlags` in parallel and populates the cache.
+   * Individual flag fetch failures are logged when `logging` is enabled but
+   * do not prevent the provider from reaching READY.
+   */
+  initialize(context?: EvaluationContext): Promise<void>;
+  onClose(): Promise<void>;
+  /**
+   * Invalidates the entire cache and re-fetches all `prefetchFlags` for the
+   * new context. Returning a Promise causes the SDK to automatically emit
+   * `ProviderEvents.Reconciling` while this method executes.
+   */
+  onContextChange(_oldContext: EvaluationContext, newContext?: EvaluationContext): Promise<void>;
+  resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, _context: EvaluationContext, logger: Logger): ResolutionDetails<boolean>;
+  resolveStringEvaluation(flagKey: string, defaultValue: string, _context: EvaluationContext, logger: Logger): ResolutionDetails<string>;
+  resolveNumberEvaluation(flagKey: string, defaultValue: number, _context: EvaluationContext, logger: Logger): ResolutionDetails<number>;
+  resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, _context: EvaluationContext, logger: Logger): ResolutionDetails<T>;
+  /**
+   * Fetches all `prefetchFlags` in parallel using `Promise.allSettled`.
+   * Failures are logged individually when `logging` is enabled.
+   */
+  private fetchAll;
+  private resolveFromCache;
+  private getValueType;
+}
+//#endregion
+export { type CachedFlag, ContextTransformer, FLAGSHIP_DEFAULT_BASE_URL, FlagshipClient, FlagshipClientProvider, type FlagshipClientProviderOptions, FlagshipError, FlagshipErrorCode, type FlagshipEvaluationResponse, type FlagshipProviderOptions };

package/dist/web.d.mts

@@ -0,0 +1,72 @@
+import { a as FlagshipClientProviderOptions, c as FlagshipEvaluationResponse, i as FLAGSHIP_DEFAULT_BASE_URL, l as FlagshipProviderOptions, n as ContextTransformer, o as FlagshipError, r as CachedFlag, s as FlagshipErrorCode, t as FlagshipClient } from "./index-C_sW3e_7.mjs";
+import { EvaluationContext, JsonValue, Logger, OpenFeatureEventEmitter, Provider, ProviderMetadata, ProviderStatus, ResolutionDetails } from "@openfeature/web-sdk";
+
+//#region src/client-provider.d.ts
+/**
+ * OpenFeature provider for Flagship (client-side / browser).
+ *
+ * Fetches all flags listed in `prefetchFlags` during initialization and on
+ * every context change, storing results in an in-memory cache. All
+ * `resolve*` methods are synchronous, as required by the OpenFeature web SDK.
+ *
+ * A cache miss (flag key not in `prefetchFlags`, or fetch failed) returns
+ * `ErrorCode.FLAG_NOT_FOUND` with the default value.
+ *
+ * @example
+ * ```typescript
+ * import { OpenFeature } from '@openfeature/web-sdk';
+ * import { FlagshipClientProvider } from '@cloudflare/flagship/web';
+ *
+ * await OpenFeature.setProviderAndWait(
+ *   new FlagshipClientProvider({
+ *     appId: 'app-abc123',
+ *     accountId: 'your-account-id',
+ *     authToken: 'your-token',
+ *     prefetchFlags: ['dark-mode', 'welcome-message'],
+ *   })
+ * );
+ *
+ * await OpenFeature.setContext({ targetingKey: 'user-123', plan: 'premium' });
+ *
+ * const client = OpenFeature.getClient();
+ * const darkMode = client.getBooleanValue('dark-mode', false);
+ * ```
+ */
+declare class FlagshipClientProvider implements Provider {
+  readonly metadata: ProviderMetadata;
+  readonly runsOn: "client";
+  readonly events: OpenFeatureEventEmitter;
+  private cache;
+  private client;
+  private readonly prefetchFlags;
+  private readonly logging;
+  private currentStatus;
+  constructor(options: FlagshipClientProviderOptions);
+  get status(): ProviderStatus;
+  /**
+   * Fetches all `prefetchFlags` in parallel and populates the cache.
+   * Individual flag fetch failures are logged when `logging` is enabled but
+   * do not prevent the provider from reaching READY.
+   */
+  initialize(context?: EvaluationContext): Promise<void>;
+  onClose(): Promise<void>;
+  /**
+   * Invalidates the entire cache and re-fetches all `prefetchFlags` for the
+   * new context. Returning a Promise causes the SDK to automatically emit
+   * `ProviderEvents.Reconciling` while this method executes.
+   */
+  onContextChange(_oldContext: EvaluationContext, newContext?: EvaluationContext): Promise<void>;
+  resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, _context: EvaluationContext, logger: Logger): ResolutionDetails<boolean>;
+  resolveStringEvaluation(flagKey: string, defaultValue: string, _context: EvaluationContext, logger: Logger): ResolutionDetails<string>;
+  resolveNumberEvaluation(flagKey: string, defaultValue: number, _context: EvaluationContext, logger: Logger): ResolutionDetails<number>;
+  resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, _context: EvaluationContext, logger: Logger): ResolutionDetails<T>;
+  /**
+   * Fetches all `prefetchFlags` in parallel using `Promise.allSettled`.
+   * Failures are logged individually when `logging` is enabled.
+   */
+  private fetchAll;
+  private resolveFromCache;
+  private getValueType;
+}
+//#endregion
+export { type CachedFlag, ContextTransformer, FLAGSHIP_DEFAULT_BASE_URL, FlagshipClient, FlagshipClientProvider, type FlagshipClientProviderOptions, FlagshipError, FlagshipErrorCode, type FlagshipEvaluationResponse, type FlagshipProviderOptions };

package/dist/web.mjs

@@ -0,0 +1,142 @@
+import { a as FlagshipErrorCode, i as FlagshipError, n as ContextTransformer, r as FLAGSHIP_DEFAULT_BASE_URL, t as FlagshipClient } from "./src-CiVDWmng.mjs";
+import { ErrorCode, OpenFeatureEventEmitter, ProviderEvents, ProviderStatus } from "@openfeature/web-sdk";
+//#region src/client-provider.ts
+/**
+* OpenFeature provider for Flagship (client-side / browser).
+*
+* Fetches all flags listed in `prefetchFlags` during initialization and on
+* every context change, storing results in an in-memory cache. All
+* `resolve*` methods are synchronous, as required by the OpenFeature web SDK.
+*
+* A cache miss (flag key not in `prefetchFlags`, or fetch failed) returns
+* `ErrorCode.FLAG_NOT_FOUND` with the default value.
+*
+* @example
+* ```typescript
+* import { OpenFeature } from '@openfeature/web-sdk';
+* import { FlagshipClientProvider } from '@cloudflare/flagship/web';
+*
+* await OpenFeature.setProviderAndWait(
+*   new FlagshipClientProvider({
+*     appId: 'app-abc123',
+*     accountId: 'your-account-id',
+*     authToken: 'your-token',
+*     prefetchFlags: ['dark-mode', 'welcome-message'],
+*   })
+* );
+*
+* await OpenFeature.setContext({ targetingKey: 'user-123', plan: 'premium' });
+*
+* const client = OpenFeature.getClient();
+* const darkMode = client.getBooleanValue('dark-mode', false);
+* ```
+*/
+var FlagshipClientProvider = class {
+	constructor(options) {
+		this.runsOn = "client";
+		this.events = new OpenFeatureEventEmitter();
+		this.cache = /* @__PURE__ */ new Map();
+		this.currentStatus = ProviderStatus.NOT_READY;
+		this.metadata = { name: "Flagship Client Provider" };
+		this.client = new FlagshipClient(options);
+		this.prefetchFlags = options.prefetchFlags || [];
+		this.logging = options.logging ?? false;
+	}
+	get status() {
+		return this.currentStatus;
+	}
+	/**
+	* Fetches all `prefetchFlags` in parallel and populates the cache.
+	* Individual flag fetch failures are logged when `logging` is enabled but
+	* do not prevent the provider from reaching READY.
+	*/
+	async initialize(context = {}) {
+		await this.fetchAll(context, "initialization");
+		this.currentStatus = ProviderStatus.READY;
+		this.events.emit(ProviderEvents.Ready);
+	}
+	async onClose() {
+		this.cache.clear();
+		this.currentStatus = ProviderStatus.NOT_READY;
+	}
+	/**
+	* Invalidates the entire cache and re-fetches all `prefetchFlags` for the
+	* new context. Returning a Promise causes the SDK to automatically emit
+	* `ProviderEvents.Reconciling` while this method executes.
+	*/
+	async onContextChange(_oldContext, newContext = {}) {
+		this.cache.clear();
+		await this.fetchAll(newContext, "context change");
+	}
+	resolveBooleanEvaluation(flagKey, defaultValue, _context, logger) {
+		return this.resolveFromCache(flagKey, defaultValue, "boolean", logger);
+	}
+	resolveStringEvaluation(flagKey, defaultValue, _context, logger) {
+		return this.resolveFromCache(flagKey, defaultValue, "string", logger);
+	}
+	resolveNumberEvaluation(flagKey, defaultValue, _context, logger) {
+		return this.resolveFromCache(flagKey, defaultValue, "number", logger);
+	}
+	resolveObjectEvaluation(flagKey, defaultValue, _context, logger) {
+		return this.resolveFromCache(flagKey, defaultValue, "object", logger);
+	}
+	/**
+	* Fetches all `prefetchFlags` in parallel using `Promise.allSettled`.
+	* Failures are logged individually when `logging` is enabled.
+	*/
+	async fetchAll(context, phase) {
+		if (this.prefetchFlags.length === 0) return;
+		const results = await Promise.allSettled(this.prefetchFlags.map(async (flagKey) => {
+			const result = await this.client.evaluate(flagKey, context);
+			this.cache.set(flagKey, {
+				value: result.value,
+				reason: result.reason,
+				variant: result.variant
+			});
+		}));
+		if (this.logging) results.forEach((result, i) => {
+			if (result.status === "rejected") {
+				const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+				console.warn(`[Flagship] Failed to fetch flag "${this.prefetchFlags[i]}" during ${phase}: ${reason}`);
+			}
+		});
+	}
+	resolveFromCache(flagKey, defaultValue, expectedType, logger) {
+		const cached = this.cache.get(flagKey);
+		if (!cached) {
+			const msg = `Flag "${flagKey}" not found in cache. Add it to prefetchFlags to ensure it is fetched on initialization.`;
+			if (this.logging) logger.warn(`[Flagship] ${msg}`);
+			return {
+				value: defaultValue,
+				reason: "ERROR",
+				errorCode: ErrorCode.FLAG_NOT_FOUND,
+				errorMessage: msg
+			};
+		}
+		const actualType = this.getValueType(cached.value);
+		if (actualType !== expectedType) {
+			const msg = `Flag "${flagKey}" type mismatch: expected ${expectedType}, got ${actualType}`;
+			if (this.logging) logger.warn(`[Flagship] ${msg}`);
+			return {
+				value: defaultValue,
+				errorCode: ErrorCode.TYPE_MISMATCH,
+				errorMessage: msg,
+				reason: "ERROR"
+			};
+		}
+		return {
+			value: cached.value,
+			reason: "CACHED",
+			variant: cached.variant,
+			flagMetadata: {}
+		};
+	}
+	getValueType(value) {
+		if (typeof value === "boolean") return "boolean";
+		if (typeof value === "string") return "string";
+		if (typeof value === "number") return "number";
+		return "object";
+	}
+};
+//#endregion
+export { ContextTransformer, FLAGSHIP_DEFAULT_BASE_URL, FlagshipClient, FlagshipClientProvider, FlagshipError, FlagshipErrorCode };