@spotify-confidence/openfeature-server-provider-local 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.10.0](https://github.com/spotify/confidence-resolver/compare/openfeature-provider-js-v0.9.1...openfeature-provider-js-v0.10.0) (2026-03-06)
+
+
+### Features
+
+* metrics in telemetry data ([#266](https://github.com/spotify/confidence-resolver/issues/266)) ([965eff6](https://github.com/spotify/confidence-resolver/commit/965eff60b6c0377336e6e86624a78f6f3a859f73))
+
+
+### Bug Fixes
+
+* **js:** increase state fetch stall timeout to 1s ([#293](https://github.com/spotify/confidence-resolver/issues/293)) ([f95da45](https://github.com/spotify/confidence-resolver/commit/f95da455ef338b3e43604f4a2d76d008c9e63496))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * rust-guest bumped from 0.1.17 to 0.1.18
+
+## [0.9.1](https://github.com/spotify/confidence-resolver/compare/openfeature-provider-js-v0.9.0...openfeature-provider-js-v0.9.1) (2026-02-20)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * rust-guest bumped from 0.1.16 to 0.1.17
+
 ## [0.9.0](https://github.com/spotify/confidence-resolver/compare/openfeature-provider-js-v0.8.1...openfeature-provider-js-v0.9.0) (2026-02-19)
 
 

package/dist/index.fetch.d.ts

@@ -80,6 +80,8 @@ declare enum ResolveReason {
   RESOLVE_REASON_ERROR = 6,
   /** RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE - The flag could not be resolved because a targeting rule was not recognized */
   RESOLVE_REASON_UNRECOGNIZED_TARGETING_RULE = 7,
+  /** RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED - The flag could not be resolved because a rule is using materialization */
+  RESOLVE_REASON_MATERIALIZATION_NOT_SUPPORTED = 8,
   UNRECOGNIZED = -1,
 }
 declare enum SdkId {
@@ -233,45 +235,51 @@ interface MessageFns$3<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;
+//#region src/proto/confidence/wasm/wasm_api.d.ts
+interface ResolveProcessRequest {
+  /** Materialization reads will "suspend" the resolve */
+  deferredMaterializations?: ResolveFlagsRequest | undefined;
+  /** Materializations will be read from a statically provided set */
+  staticMaterializations?: ResolveProcessRequest_StaticMaterializations | undefined;
+  /** No materialization support, reads will error the flag. */
+  withoutMaterializations?: ResolveFlagsRequest | undefined;
+  /** Resume a previously suspended resolve with requested materializations */
+  resume?: ResolveProcessRequest_Resume | undefined;
+}
+interface ResolveProcessRequest_StaticMaterializations {
+  resolveRequest?: ResolveFlagsRequest | undefined;
+  materializations: MaterializationRecord[];
 }
-interface InclusionReadOp {
-  unit: string;
-  materialization: string;
+interface ResolveProcessRequest_Resume {
+  materializations: MaterializationRecord[];
+  state: Uint8Array;
 }
-interface ReadOp$1 {
-  variantReadOp?: VariantReadOp | undefined;
-  inclusionReadOp?: InclusionReadOp | undefined;
+interface ResolveProcessResponse {
+  resolved?: ResolveProcessResponse_Resolved | undefined;
+  suspended?: ResolveProcessResponse_Suspended | undefined;
 }
-interface ReadOperationsRequest {
-  ops: ReadOp$1[];
+interface ResolveProcessResponse_Resolved {
+  response?: ResolveFlagsResponse | undefined;
+  materializationsToWrite: MaterializationRecord[];
 }
-interface VariantData {
+interface ResolveProcessResponse_Suspended {
+  materializationsToRead: MaterializationRecord[];
+  state: Uint8Array;
+}
+/** This message is used both as a query and a result when reading materializations. */
+interface MaterializationRecord {
   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>;
+declare const ResolveProcessRequest: MessageFns$2<ResolveProcessRequest>;
+declare const ResolveProcessRequest_StaticMaterializations: MessageFns$2<ResolveProcessRequest_StaticMaterializations>;
+declare const ResolveProcessRequest_Resume: MessageFns$2<ResolveProcessRequest_Resume>;
+declare const ResolveProcessResponse: MessageFns$2<ResolveProcessResponse>;
+declare const ResolveProcessResponse_Resolved: MessageFns$2<ResolveProcessResponse_Resolved>;
+declare const ResolveProcessResponse_Suspended: MessageFns$2<ResolveProcessResponse_Suspended>;
+declare const MaterializationRecord: MessageFns$2<MaterializationRecord>;
 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;
@@ -285,32 +293,12 @@ interface MessageFns$2<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[];
+//#region src/proto/confidence/wasm/messages.d.ts
+interface SetResolverStateRequest {
+  state: Uint8Array;
+  accountId: string;
 }
-declare const ResolveWithStickyRequest: MessageFns$1<ResolveWithStickyRequest>;
-declare const ResolveWithStickyResponse: MessageFns$1<ResolveWithStickyResponse>;
-declare const ResolveWithStickyResponse_Success: MessageFns$1<ResolveWithStickyResponse_Success>;
+declare const SetResolverStateRequest: MessageFns$1<SetResolverStateRequest>;
 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;
@@ -324,12 +312,34 @@ interface MessageFns$1<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;
+//#region src/LocalResolver.d.ts
+interface LocalResolver {
+  resolveProcess(request: ResolveProcessRequest): ResolveProcessResponse;
+  setResolverState(request: SetResolverStateRequest): void;
+  flushLogs(): Uint8Array;
+  flushAssigned(): Uint8Array;
+  applyFlags(request: ApplyFlagsRequest): void;
+}
+//#endregion
+//#region src/proto/confidence/flags/resolver/v1/internal_api.d.ts
+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 SetResolverStateRequest: MessageFns<SetResolverStateRequest>;
+declare const VariantData: MessageFns<VariantData>;
+declare const InclusionData: MessageFns<InclusionData>;
+declare const ReadResult: MessageFns<ReadResult>;
 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;
@@ -343,15 +353,6 @@ interface MessageFns<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;
-  applyFlags(request: ApplyFlagsRequest): void;
-}
-//#endregion
 //#region src/materialization.d.ts
 declare namespace MaterializationStore {
   namespace ReadOp {
@@ -465,7 +466,7 @@ interface ProviderOptions {
   initializeTimeout?: number;
   /** Interval in milliseconds between state polling updates. Defaults to 30000ms. */
   stateUpdateInterval?: number;
-  /** Interval in milliseconds between log flushes. Defaults to 10000ms. */
+  /** Interval in milliseconds between log flushes. Defaults to 15000ms. */
   flushInterval?: number;
   fetch?: typeof fetch;
   materializationStore?: MaterializationStore | "CONFIDENCE_REMOTE_STORE";
@@ -493,7 +494,8 @@ declare class ConfidenceServerProviderLocal implements Provider {
   onClose(): Promise<void>;
   resolve(context: EvaluationContext, flagNames: string[], apply?: boolean): Promise<FlagBundle$1>;
   evaluate<T extends JsonValue>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
-  private resolveWithSticky;
+  private resolveProcess;
+  private handleMaterializationWrites;
   updateState(signal?: AbortSignal): Promise<void>;
   flush(signal?: AbortSignal): Promise<void>;
   private flushAssigned;