@spotify-confidence/openfeature-server-provider-local 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.7.0](https://github.com/spotify/confidence-resolver/compare/openfeature-provider-js-v0.6.0...openfeature-provider-js-v0.7.0) (2026-01-22)
+
+
+### Features
+
+* inlined WASM for improved portability ([#243](https://github.com/spotify/confidence-resolver/issues/243)) ([8d86283](https://github.com/spotify/confidence-resolver/commit/8d862837244ffd9099bfeb56b42e203212e73a96))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * rust-guest bumped from 0.1.12 to 0.1.13
+
 ## [0.6.0](https://github.com/spotify/confidence-resolver/compare/openfeature-provider-js-v0.5.1...openfeature-provider-js-v0.6.0) (2026-01-15)
 
 

package/README.md

@@ -3,12 +3,14 @@
 OpenFeature provider for the Spotify Confidence resolver (local mode, powered by WebAssembly). It periodically fetches resolver state, evaluates flags locally, and flushes evaluation logs to the Confidence backend.
 
 ## Features
+
 - Local flag evaluation via WASM (no per-eval network calls)
 - Automatic state refresh and batched flag log flushing
 - Pluggable `fetch` with retries, timeouts and routing
 - Optional logging using `debug`
 
 ## Requirements
+
 - Node.js 18+ (built-in `fetch`) or provide a compatible `fetch`
 - WebAssembly support (Node 18+/modern browsers)
 
@@ -24,6 +26,7 @@ yarn add debug
 ```
 
 Notes:
+
 - `debug` is an optional peer. Install it if you want logs. Without it, logging is a no-op.
 - Types and bundling are ESM-first; Node is supported, and a browser build is provided for modern bundlers.
 
@@ -34,6 +37,7 @@ Notes:
 You'll need a **client secret** from Confidence to use this provider.
 
 **📖 See the [Integration Guide: Getting Your Credentials](../INTEGRATION_GUIDE.md#getting-your-credentials)** for step-by-step instructions on:
+
 - How to navigate the Confidence dashboard
 - Creating a Backend integration
 - Creating a test flag for verification
@@ -104,6 +108,7 @@ const context = {
 The provider uses a **default value fallback** pattern - when evaluation fails, it returns your specified default value instead of throwing an error.
 
 **📖 See the [Integration Guide: Error Handling](../INTEGRATION_GUIDE.md#error-handling)** for:
+
 - Common failure scenarios
 - Error codes and meanings
 - Production best practices
@@ -119,8 +124,8 @@ const enabled = await client.getBooleanValue('my-flag.enabled', false, context);
 // For detailed error information, use getBooleanDetails()
 const details = await client.getBooleanDetails('my-flag.enabled', false, context);
 if (details.errorCode) {
-    console.error('Flag evaluation error:', details.errorMessage);
-    console.log('Reason:', details.reason);
+  console.error('Flag evaluation error:', details.errorMessage);
+  console.log('Reason:', details.reason);
 }
 ```
 
@@ -135,11 +140,71 @@ if (details.errorCode) {
 - `fetch` (optional): Custom `fetch` implementation. Required for Node < 18; for Node 18+ you can omit.
 
 The provider periodically:
+
 - Refreshes resolver state (configurable via `stateUpdateInterval`, default every 30s)
 - Flushes flag evaluation logs to the backend (configurable via `flushInterval`, default every 10s)
 
 ---
 
+## Exports and WASM Loading
+
+The package provides multiple exports for different environments:
+
+### Default export (recommended)
+
+```ts
+import { createConfidenceServerProvider } from '@spotify-confidence/openfeature-server-provider-local';
+```
+
+The WASM is **inlined as a data URL** — this is the most portable option and should work across virtually all environments. The tradeoff is a larger bundle (~700kB), but this isn't a problem for the intended server-side usage.
+
+No configuration needed.
+
+### `./node` — Traditional Node.js
+
+```ts
+import { createConfidenceServerProvider } from '@spotify-confidence/openfeature-server-provider-local/node';
+```
+
+Uses `fs.readFile()` to load WASM from the installed package. Works well in a regular Node.js environment with node_modules.
+
+You can customize the WASM path if needed:
+
+```ts
+const provider = createConfidenceServerProvider({
+  flagClientSecret: '...',
+  wasmPath: '/custom/path/to/confidence_resolver.wasm',
+});
+```
+
+### `./fetch` — Modern and standards compliant environments
+
+```ts
+import { createConfidenceServerProvider } from '@spotify-confidence/openfeature-server-provider-local/fetch';
+```
+
+Uses `fetch()` with `import.meta.url` to load WASM. Works in Deno, Bun, and browsers with bundlers that properly handle asset URLs (Vite, Rollup, etc.).
+
+You can customize the WASM URL if needed:
+
+```ts
+const provider = createConfidenceServerProvider({
+  flagClientSecret: '...',
+  wasmUrl: '/assets/confidence_resolver.wasm',
+});
+```
+
+### A note on browser usage
+
+While browsers are mentioned in this doc, this package is intended for server-side use only. Two concerns for browser usage:
+
+- Size: The WASM+JS is currently ~270kb gzipped, too large for typical client bundles.
+- Security: In a browser, all flag rules and variants are exposed to users.
+
+That said, the package does work in browsers, and there may be specialized use cases where these tradeoffs are acceptable.
+
+---
+
 ## Materialization Stores
 
 Materialization stores provide persistent storage for sticky variant assignments and custom targeting segments. This enables two key use cases:
@@ -164,11 +229,13 @@ const provider = createConfidenceServerProvider({
 ```
 
 **When to use**:
+
 - You need sticky assignments or materialized segments but don't want to manage storage infrastructure
 - Quick prototyping or getting started
 - Lower-volume applications where network latency is acceptable
 
 **Trade-offs**:
+
 - Additional network calls during flag resolution (adds latency)
 - Lower performance compared to local storage implementations (Redis, DynamoDB, etc.)
 
@@ -200,6 +267,7 @@ For read-only stores (e.g., pre-populated materialized segments without sticky a
 ### When to Use Materialization Stores
 
 Consider implementing a materialization store if:
+
 - You need to support sticky variant assignments for experiments
 - You use materialized segments for custom targeting
 - You want to minimize network latency during flag resolution
@@ -214,10 +282,12 @@ If you don't use sticky assignments or materialized segments, the default behavi
 Logging uses the `debug` library if present; otherwise, all log calls are no-ops.
 
 Namespaces:
+
 - Core: `cnfd:*`
 - Fetch/middleware: `cnfd:fetch:*` (e.g. retries, auth renewals, request summaries)
 
 Log levels are hierarchical:
+
 - `cnfd:debug` enables debug, info, warn, and error
 - `cnfd:info` enables info, warn, and error
 - `cnfd:warn` enables warn and error
@@ -226,6 +296,7 @@ Log levels are hierarchical:
 Enable logs:
 
 - Node:
+
 ```bash
 DEBUG=cnfd:* node app.js
 # or narrower
@@ -233,6 +304,7 @@ DEBUG=cnfd:info,cnfd:fetch:* node app.js
 ```
 
 - Browser (in DevTools console):
+
 ```js
 localStorage.debug = 'cnfd:*';
 ```
@@ -245,19 +317,6 @@ yarn add debug
 
 ---
 
-## WebAssembly asset notes
-
-- Node: the WASM (`confidence_resolver.wasm`) is resolved from the installed package automatically; no extra config needed.
-- Browser: the ESM build resolves the WASM via `new URL('confidence_resolver.wasm', import.meta.url)` so modern bundlers (Vite/Rollup/Webpack 5 asset modules) will include it. If your bundler does not, configure it to treat the `.wasm` file as a static asset.
-
----
-
-## Using in browsers
-
-The package exports a browser ESM build that compiles the WASM via streaming and uses the global `fetch`. Integrate it with your OpenFeature SDK variant for the web similarly to Node, then register the provider before evaluation. Credentials must be available to the runtime (e.g. through your app’s configuration layer).
-
----
-
 ## Testing
 
 - You can inject a custom `fetch` via the `fetch` option to stub network behavior in tests.

package/dist/index.fetch.d.ts

@@ -0,0 +1,466 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { EvaluationContext, JsonValue, Provider, ProviderMetadata, ProviderStatus, ResolutionDetails } from "@openfeature/server-sdk";
+
+//#region src/proto/confidence/flags/types/v1/types.d.ts
+/** Schema for the value of a flag. */
+interface FlagSchema {
+  /** Schema if this is a struct */
+  structSchema?: FlagSchema_StructFlagSchema | undefined;
+  /** Schema if this is a list */
+  listSchema?: FlagSchema_ListFlagSchema | undefined;
+  /** Schema if this is an int */
+  intSchema?: FlagSchema_IntFlagSchema | undefined;
+  /** Schema if this is a double */
+  doubleSchema?: FlagSchema_DoubleFlagSchema | undefined;
+  /** Schema if this is a string */
+  stringSchema?: FlagSchema_StringFlagSchema | undefined;
+  /** Schema if this is a bool */
+  boolSchema?: FlagSchema_BoolFlagSchema | undefined;
+}
+/** A schema of nested fields. */
+interface FlagSchema_StructFlagSchema {
+  /** Map of field name to the schema for the field */
+  schema: {
+    [key: string]: FlagSchema;
+  };
+}
+/** A number that has a decimal place. */
+interface FlagSchema_DoubleFlagSchema {}
+/** A whole number without a decimal point. */
+interface FlagSchema_IntFlagSchema {}
+/** A string. */
+interface FlagSchema_StringFlagSchema {}
+/** A boolean: true or false. */
+interface FlagSchema_BoolFlagSchema {}
+/** A list of values. */
+interface FlagSchema_ListFlagSchema {
+  /** The schema for the elements in the list */
+  elementSchema?: FlagSchema | undefined;
+}
+declare const FlagSchema: MessageFns$5<FlagSchema>;
+declare const FlagSchema_StructFlagSchema: MessageFns$5<FlagSchema_StructFlagSchema>;
+declare const FlagSchema_DoubleFlagSchema: MessageFns$5<FlagSchema_DoubleFlagSchema>;
+declare const FlagSchema_IntFlagSchema: MessageFns$5<FlagSchema_IntFlagSchema>;
+declare const FlagSchema_StringFlagSchema: MessageFns$5<FlagSchema_StringFlagSchema>;
+declare const FlagSchema_BoolFlagSchema: MessageFns$5<FlagSchema_BoolFlagSchema>;
+declare const FlagSchema_ListFlagSchema: MessageFns$5<FlagSchema_ListFlagSchema>;
+type Builtin$5 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$5<T> = T extends Builtin$5 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$5<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$5<U>> : T extends {} ? { [K in keyof T]?: DeepPartial$5<T[K]> } : Partial<T>;
+type KeysOfUnion$5<T> = T extends T ? keyof T : never;
+type Exact$5<P, I extends P> = P extends Builtin$5 ? P : P & { [K in keyof P]: Exact$5<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$5<P>>]: never };
+interface MessageFns$5<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact$5<DeepPartial$5<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact$5<DeepPartial$5<T>, I>>(object: I): T;
+}
+//#endregion
+//#region src/proto/confidence/flags/resolver/v1/types.d.ts
+declare enum ResolveReason {
+  /** RESOLVE_REASON_UNSPECIFIED - Unspecified enum. */
+  RESOLVE_REASON_UNSPECIFIED = 0,
+  /** RESOLVE_REASON_MATCH - The flag was successfully resolved because one rule matched. */
+  RESOLVE_REASON_MATCH = 1,
+  /** RESOLVE_REASON_NO_SEGMENT_MATCH - The flag could not be resolved because no rule matched. */
+  RESOLVE_REASON_NO_SEGMENT_MATCH = 2,
+  /**
+  * RESOLVE_REASON_NO_TREATMENT_MATCH - The flag could not be resolved because the matching rule had no variant
+  * that could be assigned.
+  *
+  * @deprecated
+  */
+  RESOLVE_REASON_NO_TREATMENT_MATCH = 3,
+  /** RESOLVE_REASON_FLAG_ARCHIVED - The flag could not be resolved because it was archived. */
+  RESOLVE_REASON_FLAG_ARCHIVED = 4,
+  /** RESOLVE_REASON_TARGETING_KEY_ERROR - The flag could not be resolved because the targeting key field was invalid */
+  RESOLVE_REASON_TARGETING_KEY_ERROR = 5,
+  /** RESOLVE_REASON_ERROR - Unknown error occurred during the resolve */
+  RESOLVE_REASON_ERROR = 6,
+  UNRECOGNIZED = -1,
+}
+declare enum SdkId {
+  SDK_ID_UNSPECIFIED = 0,
+  SDK_ID_JAVA_PROVIDER = 1,
+  SDK_ID_KOTLIN_PROVIDER = 2,
+  SDK_ID_SWIFT_PROVIDER = 3,
+  SDK_ID_JS_WEB_PROVIDER = 4,
+  SDK_ID_JS_SERVER_PROVIDER = 5,
+  SDK_ID_PYTHON_PROVIDER = 6,
+  SDK_ID_GO_PROVIDER = 7,
+  SDK_ID_RUBY_PROVIDER = 8,
+  SDK_ID_RUST_PROVIDER = 9,
+  SDK_ID_JAVA_CONFIDENCE = 10,
+  SDK_ID_KOTLIN_CONFIDENCE = 11,
+  SDK_ID_SWIFT_CONFIDENCE = 12,
+  SDK_ID_JS_CONFIDENCE = 13,
+  SDK_ID_PYTHON_CONFIDENCE = 14,
+  SDK_ID_GO_CONFIDENCE = 15,
+  SDK_ID_RUST_CONFIDENCE = 16,
+  SDK_ID_FLUTTER_IOS_CONFIDENCE = 17,
+  SDK_ID_FLUTTER_ANDROID_CONFIDENCE = 18,
+  SDK_ID_DOTNET_CONFIDENCE = 19,
+  SDK_ID_GO_LOCAL_PROVIDER = 20,
+  SDK_ID_JAVA_LOCAL_PROVIDER = 21,
+  SDK_ID_JS_LOCAL_SERVER_PROVIDER = 22,
+  UNRECOGNIZED = -1,
+}
+interface Sdk {
+  /** Name of a Confidence SDKs. */
+  id?: SdkId | undefined;
+  /** Custom name for non-Confidence SDKs. */
+  customId?: string | undefined;
+  /** Version of the SDK. */
+  version: string;
+}
+declare const Sdk: MessageFns$4<Sdk>;
+type Builtin$4 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$4<T> = T extends Builtin$4 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$4<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$4<U>> : T extends {} ? { [K in keyof T]?: DeepPartial$4<T[K]> } : Partial<T>;
+type KeysOfUnion$4<T> = T extends T ? keyof T : never;
+type Exact$4<P, I extends P> = P extends Builtin$4 ? P : P & { [K in keyof P]: Exact$4<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$4<P>>]: never };
+interface MessageFns$4<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact$4<DeepPartial$4<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact$4<DeepPartial$4<T>, I>>(object: I): T;
+}
+//#endregion
+//#region src/proto/confidence/flags/resolver/v1/api.d.ts
+interface ResolveFlagsRequest {
+  /**
+  * If non-empty, the specific flags are resolved, otherwise all flags
+  * available to the client will be resolved.
+  */
+  flags: string[];
+  /**
+  * An object that contains data used in the flag resolve. For example,
+  * the targeting key e.g. the id of the randomization unit, other attributes
+  * like country or version that are used for targeting.
+  */
+  evaluationContext?: {
+    [key: string]: any;
+  } | undefined;
+  /**
+  * Credentials for the client. It is used to identify the client and find
+  * the flags that are available to it.
+  */
+  clientSecret: string;
+  /**
+  * Determines whether the flags should be applied directly as part of the
+  * resolve, or delayed until `ApplyFlag` is called. A flag is typically
+  * applied when it is used, if this occurs much later than the resolve, then
+  * `apply` should likely be set to false.
+  * In a local resolve case it is encouraged to set this to `true`
+  */
+  apply: boolean;
+  /** Information about the SDK used to initiate the request. */
+  sdk?: Sdk | undefined;
+}
+interface ResolveFlagsResponse {
+  /**
+  * The list of all flags that could be resolved. Note: if any flag was
+  * archived it will not be included in this list.
+  */
+  resolvedFlags: ResolvedFlag[];
+  /**
+  * An opaque token that is used when `apply` is set to false in `ResolveFlags`.
+  * When `apply` is set to false, the token must be passed to `ApplyFlags`.
+  */
+  resolveToken: Uint8Array;
+  /** Unique identifier for this particular resolve request. */
+  resolveId: string;
+}
+interface ResolvedFlag {
+  /** The id of the flag that as resolved. */
+  flag: string;
+  /** The id of the resolved variant has the format `flags/abc/variants/xyz`. */
+  variant: string;
+  /**
+  * The value corresponding to the variant. It will always be a json object,
+  * for example `{ "color": "red", "size": 12 }`.
+  */
+  value?: {
+    [key: string]: any;
+  } | undefined;
+  /** The schema of the value that was returned. */
+  flagSchema?: FlagSchema_StructFlagSchema | undefined;
+  /** The reason to why the flag could be resolved or not. */
+  reason: ResolveReason;
+}
+declare const ResolveFlagsRequest: MessageFns$3<ResolveFlagsRequest>;
+declare const ResolveFlagsResponse: MessageFns$3<ResolveFlagsResponse>;
+declare const ResolvedFlag: MessageFns$3<ResolvedFlag>;
+type Builtin$3 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$3<T> = T extends Builtin$3 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$3<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$3<U>> : T extends {} ? { [K in keyof T]?: DeepPartial$3<T[K]> } : Partial<T>;
+type KeysOfUnion$3<T> = T extends T ? keyof T : never;
+type Exact$3<P, I extends P> = P extends Builtin$3 ? P : P & { [K in keyof P]: Exact$3<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$3<P>>]: never };
+interface MessageFns$3<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact$3<DeepPartial$3<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact$3<DeepPartial$3<T>, I>>(object: I): T;
+}
+//#endregion
+//#region src/proto/confidence/flags/resolver/v1/internal_api.d.ts
+interface VariantReadOp {
+  unit: string;
+  materialization: string;
+  rule: string;
+}
+interface InclusionReadOp {
+  unit: string;
+  materialization: string;
+}
+interface ReadOp$1 {
+  variantReadOp?: VariantReadOp | undefined;
+  inclusionReadOp?: InclusionReadOp | undefined;
+}
+interface ReadOperationsRequest {
+  ops: ReadOp$1[];
+}
+interface VariantData {
+  unit: string;
+  materialization: string;
+  rule: string;
+  variant: string;
+}
+interface InclusionData {
+  unit: string;
+  materialization: string;
+  isIncluded: boolean;
+}
+interface ReadResult {
+  variantResult?: VariantData | undefined;
+  inclusionResult?: InclusionData | undefined;
+}
+declare const VariantReadOp: MessageFns$2<VariantReadOp>;
+declare const InclusionReadOp: MessageFns$2<InclusionReadOp>;
+declare const ReadOp$1: MessageFns$2<ReadOp$1>;
+declare const ReadOperationsRequest: MessageFns$2<ReadOperationsRequest>;
+declare const VariantData: MessageFns$2<VariantData>;
+declare const InclusionData: MessageFns$2<InclusionData>;
+declare const ReadResult: MessageFns$2<ReadResult>;
+type Builtin$2 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$2<T> = T extends Builtin$2 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$2<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$2<U>> : T extends {} ? { [K in keyof T]?: DeepPartial$2<T[K]> } : Partial<T>;
+type KeysOfUnion$2<T> = T extends T ? keyof T : never;
+type Exact$2<P, I extends P> = P extends Builtin$2 ? P : P & { [K in keyof P]: Exact$2<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$2<P>>]: never };
+interface MessageFns$2<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact$2<DeepPartial$2<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact$2<DeepPartial$2<T>, I>>(object: I): T;
+}
+//#endregion
+//#region src/proto/confidence/wasm/wasm_api.d.ts
+/** Request for resolving flags with sticky (materialized) assignments */
+interface ResolveWithStickyRequest {
+  /** The standard resolve request */
+  resolveRequest?: ResolveFlagsRequest | undefined;
+  /** if a materialization info is missing, we want tor return to the caller immediately */
+  failFastOnSticky: boolean;
+  /** if we should support sticky or completely skip the flag if they had sticky rules */
+  notProcessSticky: boolean;
+  /** Context about the materialization required for the resolve */
+  materializations: ReadResult[];
+}
+/** Response from resolving with sticky assignments */
+interface ResolveWithStickyResponse {
+  success?: ResolveWithStickyResponse_Success | undefined;
+  readOpsRequest?: ReadOperationsRequest | undefined;
+}
+/** Successful resolution with materialization updates */
+interface ResolveWithStickyResponse_Success {
+  response?: ResolveFlagsResponse | undefined;
+  /** New assignments that should be stored */
+  materializationUpdates: VariantData[];
+}
+declare const ResolveWithStickyRequest: MessageFns$1<ResolveWithStickyRequest>;
+declare const ResolveWithStickyResponse: MessageFns$1<ResolveWithStickyResponse>;
+declare const ResolveWithStickyResponse_Success: MessageFns$1<ResolveWithStickyResponse_Success>;
+type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {} ? { [K in keyof T]?: DeepPartial$1<T[K]> } : Partial<T>;
+type KeysOfUnion$1<T> = T extends T ? keyof T : never;
+type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & { [K in keyof P]: Exact$1<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$1<P>>]: never };
+interface MessageFns$1<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact$1<DeepPartial$1<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
+}
+//#endregion
+//#region src/proto/confidence/wasm/messages.d.ts
+interface SetResolverStateRequest {
+  state: Uint8Array;
+  accountId: string;
+}
+declare const SetResolverStateRequest: MessageFns<SetResolverStateRequest>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> } : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+//#endregion
+//#region src/LocalResolver.d.ts
+interface LocalResolver {
+  resolveWithSticky(request: ResolveWithStickyRequest): ResolveWithStickyResponse;
+  setResolverState(request: SetResolverStateRequest): void;
+  flushLogs(): Uint8Array;
+  flushAssigned(): Uint8Array;
+}
+//#endregion
+//#region src/materialization.d.ts
+declare namespace MaterializationStore {
+  namespace ReadOp {
+    interface Variant {
+      readonly op: "variant";
+      readonly unit: string;
+      readonly materialization: string;
+      readonly rule: string;
+    }
+    interface Inclusion {
+      readonly op: "inclusion";
+      readonly unit: string;
+      readonly materialization: string;
+    }
+  }
+  type ReadOp = ReadOp.Variant | ReadOp.Inclusion;
+  namespace ReadResult {
+    interface Variant {
+      readonly op: "variant";
+      readonly unit: string;
+      readonly materialization: string;
+      readonly rule: string;
+      readonly variant?: string;
+    }
+    interface Inclusion {
+      readonly op: "inclusion";
+      readonly unit: string;
+      readonly materialization: string;
+      readonly included: boolean;
+    }
+  }
+  type ReadResult = ReadResult.Inclusion | ReadResult.Variant;
+  namespace WriteOp {
+    interface Variant {
+      readonly op: "variant";
+      readonly unit: string;
+      readonly materialization: string;
+      readonly rule: string;
+      readonly variant: string;
+    }
+  }
+  type WriteOp = WriteOp.Variant;
+}
+/**
+* Interface for storing and retrieving materialization data.
+*
+* Implementations can use any storage backend (e.g., Redis, BigTable, Cassandra, DynamoDB,
+* or simple key-value stores) as long as they fulfill this contract.
+*
+* @see The README for conceptual documentation on sticky assignments and materialized segments.
+*/
+interface MaterializationStore {
+  /**
+  * Reads materialization data for the given operations.
+  *
+  * For `variant` operations, returns the stored variant assignment (if any) for a unit/materialization/rule combination.
+  * For `inclusion` operations, returns whether a unit is included in a materialized segment.
+  *
+  * @param readOps - The read operations to perform.
+  * @returns Results for each operation. The order of results does not need to match the order of operations;
+  *          callers match results to operations using the `unit`, `materialization`, and `op` fields.
+  */
+  readMaterializations(readOps: MaterializationStore.ReadOp[]): Promise<MaterializationStore.ReadResult[]>;
+  /**
+  * Persists variant assignments for sticky bucketing.
+  *
+  * This method is optional. Omit it for read-only stores that only serve pre-populated
+  * materialized segments without supporting runtime sticky assignment writes.
+  *
+  * @param writeOps - The variant assignments to persist.
+  */
+  writeMaterializations?(writeOps: MaterializationStore.WriteOp[]): Promise<void>;
+}
+//#endregion
+//#region src/ConfidenceServerProviderLocal.d.ts
+interface ProviderOptions {
+  flagClientSecret: string;
+  initializeTimeout?: number;
+  /** Interval in milliseconds between state polling updates. Defaults to 30000ms. */
+  stateUpdateInterval?: number;
+  /** Interval in milliseconds between log flushes. Defaults to 10000ms. */
+  flushInterval?: number;
+  fetch?: typeof fetch;
+  materializationStore?: MaterializationStore | "CONFIDENCE_REMOTE_STORE";
+}
+/**
+* OpenFeature Provider for Confidence Server SDK (Local Mode)
+* @public
+*/
+declare class ConfidenceServerProviderLocal implements Provider {
+  private resolverOrPromise;
+  private options;
+  /** Static data about the provider */
+  readonly metadata: ProviderMetadata;
+  /** Current status of the provider. Can be READY, NOT_READY, ERROR, STALE and FATAL. */
+  status: ProviderStatus;
+  private readonly main;
+  private readonly fetch;
+  private readonly stateUpdateInterval;
+  private readonly flushInterval;
+  private readonly materializationStore;
+  private stateEtag;
+  private get resolver();
+  constructor(resolverOrPromise: LocalResolver | Promise<LocalResolver>, options: ProviderOptions);
+  initialize(context?: EvaluationContext): Promise<void>;
+  onClose(): Promise<void>;
+  evaluate<T>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
+  private resolveWithSticky;
+  /**
+  * Extract and validate the value from a resolved flag.
+  */
+  private extractValue;
+  updateState(signal?: AbortSignal): Promise<void>;
+  flush(signal?: AbortSignal): Promise<void>;
+  private flushAssigned;
+  private sendFlagLogs;
+  private readMaterializations;
+  private writeMaterializations;
+  private static convertReason;
+  private static convertEvaluationContext;
+  /** Resolves with an evaluation of a Boolean flag */
+  resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: EvaluationContext): Promise<ResolutionDetails<boolean>>;
+  /** Resolves with an evaluation of a Numbers flag */
+  resolveNumberEvaluation(flagKey: string, defaultValue: number, context: EvaluationContext): Promise<ResolutionDetails<number>>;
+  /** Resolves with an evaluation of an Object flag */
+  resolveObjectEvaluation<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
+  /** Resolves with an evaluation of a String flag */
+  resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext): Promise<ResolutionDetails<string>>;
+}
+//#endregion
+//#region src/index.fetch.d.ts
+interface ProviderOptionsExt extends ProviderOptions {
+  wasmUrl?: URL | string;
+}
+declare function createConfidenceServerProvider({
+  wasmUrl,
+  ...options
+}: ProviderOptionsExt): ConfidenceServerProviderLocal;
+//#endregion
+export { type MaterializationStore, ProviderOptionsExt, createConfidenceServerProvider };