@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/flags/FlagTypes.d.ts

@@ -1,7 +1,7 @@
 /** Defines a JSON scalar — the leaves of an object flag's payload. */
 export type JsonPrimitive = string | number | boolean | null;
 /** Defines any JSON-serialisable value inside an object flag's payload. */
-export type JsonValue = JsonPrimitive | readonly JsonValue[] | JsonObject;
+export type JsonValue = JsonPrimitive | ReadonlyArray<JsonValue> | JsonObject;
 /**
  * Defines the payload of an object flag — a JSON object.
  *
@@ -14,7 +14,7 @@ export interface JsonObject {
 }
 /** Defines every value a flag can evaluate to — the four supported flag types. */
 export type FlagValue = boolean | string | number | JsonObject;
-/** Defines an attribute value carried by an {@link EvaluationContext} — comparable scalars, plus a list for multi-value attributes (roles, groups). */
+/** Defines an attribute value on an {@link EvaluationContext} — a scalar, or a list for roles and groups. */
 export type ContextAttribute = string | number | boolean | null | readonly (string | number | boolean)[];
 /**
  * Defines the targeting input of an evaluation — who/what the flag is being resolved for.
@@ -36,9 +36,9 @@ export declare const FlagReason: {
     readonly Static: "static";
     /** Refers to a value chosen by a targeting rule matching the evaluation context. */
     readonly Targeting: "targeting";
-    /** Refers to the caller's `defaultValue` standing in because the flag is not configured — the normal pre-rollout state, not a fault. */
+    /** Refers to `defaultValue` standing in for an unconfigured flag — the pre-rollout state, not a fault. */
     readonly Default: "default";
-    /** Refers to the caller's `defaultValue` standing in after a fault (wrong type on the wire, throwing provider) — see `errorCode`. */
+    /** Refers to `defaultValue` standing in after a fault, such as a wrong wire type — see `errorCode`. */
     readonly Error: "error";
     /** Refers to the caller's `defaultValue` standing in because the flag exists but is switched off. */
     readonly Disabled: "disabled";
@@ -46,7 +46,7 @@ export declare const FlagReason: {
 export type FlagReason = (typeof FlagReason)[keyof typeof FlagReason];
 /** Defines what went wrong on an evaluation with `reason: 'error'`. */
 export declare const FlagErrorCode: {
-    /** Refers to a resolved value whose runtime type is not the type asked for (a `string` for `getBoolean`, a non-finite `number`, an array for an object flag). */
+    /** Refers to a resolved value whose runtime type is not the one asked for — a `string` for `getBoolean`. */
     readonly TypeMismatch: "type-mismatch";
     /** Refers to a provider that threw, rejected, or reported its own failure. */
     readonly ProviderError: "provider-error";
@@ -72,7 +72,7 @@ export interface FlagEvaluation<TValue extends FlagValue> {
     /** A human-readable description of the fault; set only when `reason` is `error`. */
     readonly errorMessage?: string;
 }
-/** Defines the fault handed to `createFlagClient({ onError })` — evaluation itself has already fallen back, this is the reporting channel. */
+/** Defines the fault handed to `createFlagClient({ onError })`; evaluation has already fallen back. */
 export interface FlagErrorInfo {
     /** The flag key being evaluated when the fault occurred. */
     readonly key: string;

package/dist/flags/StaticFlagProvider.d.ts

@@ -6,7 +6,7 @@ import { ContextAttribute, EvaluationContext, FlagValue, JsonObject } from './Fl
  *
  * `{ plan: 'pro' }` · `{ plan: ['pro', 'team'], region: 'eu' }` · `(ctx) => ctx.seats > 50`
  */
-export type StaticFlagCondition = Readonly<Record<string, ContextAttribute | readonly ContextAttribute[]>> | ((context: EvaluationContext) => boolean);
+export type StaticFlagCondition = Readonly<Record<string, ContextAttribute | ReadonlyArray<ContextAttribute>>> | ((context: EvaluationContext) => boolean);
 /** Defines one targeting rule of a static flag — the value served to contexts matching `when`. */
 export interface StaticFlagRule<TValue extends FlagValue> {
     /** The condition the evaluation context must satisfy. */
@@ -22,10 +22,10 @@ export interface StaticFlagDefinition<TValue extends FlagValue> {
     readonly value: TValue;
     /** The variant name reported alongside `value`. */
     readonly variant?: string;
-    /** Whether the flag is switched off — every evaluation returns the CALLER's default with `reason: 'disabled'`, rules skipped. */
+    /** Whether the flag is off; every evaluation returns the caller's default, `reason: 'disabled'`, rules skipped. */
     readonly disabled?: boolean;
     /** The targeting rules, evaluated top-down; the first match wins. */
-    readonly rules?: readonly StaticFlagRule<TValue>[];
+    readonly rules?: ReadonlyArray<StaticFlagRule<TValue>>;
 }
 /**
  * Defines one entry of a static flag map — a bare value or a {@link StaticFlagDefinition}.
@@ -40,12 +40,6 @@ export type StaticFlags = Readonly<Record<string, StaticFlagEntry>>;
  * Creates an in-memory {@link FlagProvider} over a `key → flag` map — the test double, the
  * local-dev default, and the fallback used when a client is created without a provider.
  *
- * ```ts
- * const provider = staticFlagProvider({
- *   newNav: true,                                        // bare value
- *   theme: { value: 'light', variant: 'control', rules: [{ when: { plan: ['pro', 'team'] }, value: 'dark', variant: 'treatment' }] },
- *   legacyExport: { value: true, disabled: true },        // gated off → callers get their own default
- * });
- * ```
+ * An entry is a bare value or a {@link StaticFlagDefinition}; a disabled one hands back the caller's default.
  */
 export declare function staticFlagProvider(flags?: StaticFlags): FlagProvider;

package/dist/flags/index.d.ts

@@ -2,5 +2,5 @@ export { FlagReason, FlagErrorCode, type JsonPrimitive, type JsonValue, type Jso
 export type { FlagProvider, FlagResolution } from './FlagProvider';
 export { staticFlagProvider, type StaticFlags, type StaticFlagEntry, type StaticFlagDefinition, type StaticFlagRule, type StaticFlagCondition, } from './StaticFlagProvider';
 export { createFlagClient, type FlagClient, type CreateFlagClientOptions, type FlagErrorListener, type FlagContextListener, } from './FlagClient';
-export { default as FlagsProvider, type FlagsProviderProps } from './FlagsProvider.vue';
-export { useFlag, useFlags } from './FlagsContext';
+export { default as FlagsProvider, type FlagsProviderProps } from './providers/FlagsProvider.vue';
+export { useFlag, useFlags } from './providers/FlagsContext';

package/dist/flags/index.js

@@ -4,15 +4,15 @@ const FlagReason = {
   Static: "static",
   /** Refers to a value chosen by a targeting rule matching the evaluation context. */
   Targeting: "targeting",
-  /** Refers to the caller's `defaultValue` standing in because the flag is not configured — the normal pre-rollout state, not a fault. */
+  /** Refers to `defaultValue` standing in for an unconfigured flag — the pre-rollout state, not a fault. */
   Default: "default",
-  /** Refers to the caller's `defaultValue` standing in after a fault (wrong type on the wire, throwing provider) — see `errorCode`. */
+  /** Refers to `defaultValue` standing in after a fault, such as a wrong wire type — see `errorCode`. */
   Error: "error",
   /** Refers to the caller's `defaultValue` standing in because the flag exists but is switched off. */
   Disabled: "disabled"
 };
 const FlagErrorCode = {
-  /** Refers to a resolved value whose runtime type is not the type asked for (a `string` for `getBoolean`, a non-finite `number`, an array for an object flag). */
+  /** Refers to a resolved value whose runtime type is not the one asked for — a `string` for `getBoolean`. */
   TypeMismatch: "type-mismatch",
   /** Refers to a provider that threw, rejected, or reported its own failure. */
   ProviderError: "provider-error",
@@ -76,7 +76,11 @@ function mergeContext(base, patch) {
   for (const key of Object.keys(merged)) {
     if (merged[key] === void 0) delete merged[key];
   }
-  return merged;
+  for (const key of Object.keys(merged)) {
+    const value = merged[key];
+    if (Array.isArray(value)) merged[key] = Object.freeze([...value]);
+  }
+  return Object.freeze(merged);
 }
 function createFlagClient(options = {}) {
   const provider = options.provider ?? staticFlagProvider();
@@ -94,13 +98,26 @@ function createFlagClient(options = {}) {
     } catch (cause) {
       const message = `provider "${provider.name ?? "unnamed"}" threw while resolving "${key}"`;
       report(key, FlagErrorCode.ProviderError, message, cause);
-      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.ProviderError, errorMessage: message };
+      return {
+        key,
+        value: defaultValue,
+        reason: FlagReason.Error,
+        errorCode: FlagErrorCode.ProviderError,
+        errorMessage: message
+      };
     }
     if (resolution === void 0) return { key, value: defaultValue, reason: FlagReason.Default };
     if (resolution.errorCode !== void 0) {
-      const message = resolution.errorMessage ?? `provider reported "${resolution.errorCode}" for "${key}"`;
-      report(key, resolution.errorCode, message);
-      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: resolution.errorCode, errorMessage: message, variant: resolution.variant };
+      const message = `provider reported "${resolution.errorCode}" for "${key}"`;
+      report(key, resolution.errorCode, message, resolution.errorMessage);
+      return {
+        key,
+        value: defaultValue,
+        reason: FlagReason.Error,
+        errorCode: resolution.errorCode,
+        errorMessage: message,
+        variant: resolution.variant
+      };
     }
     if (resolution.reason === FlagReason.Disabled) {
       return { key, value: defaultValue, reason: FlagReason.Disabled, variant: resolution.variant };
@@ -108,9 +125,21 @@ function createFlagClient(options = {}) {
     if (!isValid(resolution.value)) {
       const message = `flag "${key}" resolved to ${typeof resolution.value}, expected ${typeName}`;
       report(key, FlagErrorCode.TypeMismatch, message);
-      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.TypeMismatch, errorMessage: message, variant: resolution.variant };
+      return {
+        key,
+        value: defaultValue,
+        reason: FlagReason.Error,
+        errorCode: FlagErrorCode.TypeMismatch,
+        errorMessage: message,
+        variant: resolution.variant
+      };
     }
-    return { key, value: resolution.value, reason: resolution.reason ?? FlagReason.Static, variant: resolution.variant };
+    return {
+      key,
+      value: resolution.value,
+      reason: resolution.reason ?? FlagReason.Static,
+      variant: resolution.variant
+    };
   };
   const isBoolean = (value) => typeof value === "boolean";
   const isString = (value) => typeof value === "string";
@@ -121,21 +150,41 @@ function createFlagClient(options = {}) {
   const evaluateNumber = (key, defaultValue, context) => core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, "number");
   const evaluateObject = (key, defaultValue, context) => core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, "object");
   const evaluate = (key, defaultValue, context) => {
-    if (typeof defaultValue === "boolean") return core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, "boolean");
-    if (typeof defaultValue === "string") return core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, "string");
-    if (typeof defaultValue === "number") return core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, "number");
-    if (isJsonObject(defaultValue)) return core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, "object");
+    if (typeof defaultValue === "boolean")
+      return core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, "boolean");
+    if (typeof defaultValue === "string")
+      return core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, "string");
+    if (typeof defaultValue === "number")
+      return core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, "number");
+    if (isJsonObject(defaultValue))
+      return core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, "object");
     const message = `flag "${key}" was given a ${typeof defaultValue} default, expected boolean, string, number, or object`;
     report(key, FlagErrorCode.InvalidDefault, message);
-    return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.InvalidDefault, errorMessage: message };
+    return {
+      key,
+      value: defaultValue,
+      reason: FlagReason.Error,
+      errorCode: FlagErrorCode.InvalidDefault,
+      errorMessage: message
+    };
   };
   const notifyProvider = (context) => {
     const hook = provider.onContextChange;
     if (hook === void 0) return;
-    const fail = (cause) => report("", FlagErrorCode.ProviderError, `provider "${provider.name ?? "unnamed"}" failed handling the context change`, cause);
+    const fail = (cause) => report(
+      "",
+      FlagErrorCode.ProviderError,
+      `provider "${provider.name ?? "unnamed"}" failed handling the context change`,
+      cause
+    );
     try {
       const pending = hook.call(provider, context);
-      if (pending instanceof Promise) void pending.catch(fail);
+      if (pending !== void 0)
+        void Promise.resolve(pending).then(() => {
+          if (currentContext === context) {
+            for (const listener of [...listeners]) listener(context);
+          }
+        }, fail).catch(fail);
     } catch (cause) {
       fail(cause);
     }
@@ -163,8 +212,11 @@ function createFlagClient(options = {}) {
       const next = mergeContext(currentContext, context);
       if (contextsEqual(currentContext, next)) return;
       currentContext = next;
-      notifyProvider(next);
-      for (const listener of [...listeners]) listener(next);
+      try {
+        notifyProvider(next);
+      } finally {
+        for (const listener of [...listeners]) listener(next);
+      }
     },
     subscribe(listener) {
       listeners.add(listener);
@@ -173,13 +225,9 @@ function createFlagClient(options = {}) {
   };
 }
 const FlagsKey = Symbol("wow-two.flags");
-let standalone;
 function standaloneContext() {
-  if (!standalone) {
-    const client = createFlagClient();
-    standalone = { client: computed(() => client), revision: ref(0) };
-  }
-  return standalone;
+  const client = createFlagClient();
+  return { client: computed(() => client), revision: ref(0) };
 }
 function provideFlags(client) {
   const active = computed(() => toValue(client));
@@ -197,7 +245,39 @@ function resolveFlags() {
   return inject(FlagsKey, standaloneContext, true);
 }
 function useFlags() {
-  return resolveFlags().client.value;
+  const { client } = resolveFlags();
+  return {
+    get provider() {
+      return client.value.provider;
+    },
+    getBoolean: (...args) => client.value.getBoolean(...args),
+    getString: (...args) => client.value.getString(...args),
+    getNumber: (...args) => client.value.getNumber(...args),
+    getObject(key, fallback, context) {
+      return client.value.getObject(key, fallback, context);
+    },
+    evaluateBoolean: (...args) => client.value.evaluateBoolean(...args),
+    evaluateString: (...args) => client.value.evaluateString(...args),
+    evaluateNumber: (...args) => client.value.evaluateNumber(...args),
+    evaluateObject(key, fallback, context) {
+      return client.value.evaluateObject(key, fallback, context);
+    },
+    getValue(key, fallback, context) {
+      return client.value.getValue(key, fallback, context);
+    },
+    evaluate(key, fallback, context) {
+      return client.value.evaluate(key, fallback, context);
+    },
+    getContext: () => client.value.getContext(),
+    setContext: (context) => client.value.setContext(context),
+    subscribe: (listener) => watch(
+      client,
+      (current, _previous, cleanup) => {
+        cleanup(current.subscribe(listener));
+      },
+      { immediate: true, flush: "sync" }
+    )
+  };
 }
 function useFlag(key, defaultValue) {
   const { client, revision } = resolveFlags();

package/dist/flags/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/flags/FlagTypes.ts","../../src/flags/StaticFlagProvider.ts","../../src/flags/FlagClient.ts","../../src/flags/FlagsContext.ts","../../src/flags/FlagsProvider.vue"],"sourcesContent":["/*\n * OpenFeature-SHAPED vocabulary, mirrored structurally — NO `@openfeature/*` dependency, exactly\n * like `forms-engine/StandardSchema.ts` vendors the Standard Schema spec types. An app that later\n * adopts the real OpenFeature JS SDK re-points its adapter and keeps every call site: evaluation\n * context, resolution details, reason, error code and variant all carry the spec's meaning.\n *\n * Three deliberate divergences, each in service of \"every evaluation is total\" (see FlagClient.ts):\n *   - reasons are lowercase house strings (`'targeting'`, not the spec's `TARGETING_MATCH`), matching\n *     the `AuthStatus` / `NoticeTone` const-object shape used everywhere else in this SDK;\n *   - a MISSING flag is `reason: 'default'`, NOT an error — an unconfigured flag is the normal state\n *     during a rollout, so it carries no `errorCode` and never reaches `onError`. Only a genuine\n *     fault (wrong wire type, throwing provider) is an error;\n *   - object flags are constrained to a JSON *object* (`JsonObject`), not the spec's whole\n *     `JsonValue` — a top-level array or scalar flag is expressed as its own typed flag instead.\n */\n\n/** Defines a JSON scalar — the leaves of an object flag's payload. */\nexport type JsonPrimitive = string | number | boolean | null;\n\n/** Defines any JSON-serialisable value inside an object flag's payload. */\nexport type JsonValue = JsonPrimitive | readonly JsonValue[] | JsonObject;\n\n/**\n * Defines the payload of an object flag — a JSON object.\n *\n * TS only grants *type aliases* an implicit index signature, so a payload typed by an `interface`\n * is not assignable here; declare the payload with `type Payload = { … }` (or extend `JsonObject`).\n */\nexport interface JsonObject {\n  /** The payload entries — any JSON-serialisable value. */\n  readonly [key: string]: JsonValue;\n}\n\n/** Defines every value a flag can evaluate to — the four supported flag types. */\nexport type FlagValue = boolean | string | number | JsonObject;\n\n/** Defines an attribute value carried by an {@link EvaluationContext} — comparable scalars, plus a list for multi-value attributes (roles, groups). */\nexport type ContextAttribute = string | number | boolean | null | readonly (string | number | boolean)[];\n\n/**\n * Defines the targeting input of an evaluation — who/what the flag is being resolved for.\n * `targetingKey` is the spec's stable subject identity (user id, tenant, device); every other\n * attribute is free-form and matched by a provider's rules.\n *\n * Set app-wide with `client.setContext(…)` (merged, see {@link FlagClient}) and override per call\n * by passing a context to any `get*` / `evaluate*`.\n */\nexport interface EvaluationContext {\n  /** The stable identity the flag is resolved for — user id, tenant id, device id. */\n  readonly targetingKey?: string;\n\n  /** Any further targeting attribute — `plan`, `region`, `roles`, `isInternal`. */\n  readonly [attribute: string]: ContextAttribute | undefined;\n}\n\n/** Defines why an evaluation produced the value it did. */\nexport const FlagReason = {\n  /** Refers to the flag's configured value, with no rule involved. */\n  Static: 'static',\n  /** Refers to a value chosen by a targeting rule matching the evaluation context. */\n  Targeting: 'targeting',\n  /** Refers to the caller's `defaultValue` standing in because the flag is not configured — the normal pre-rollout state, not a fault. */\n  Default: 'default',\n  /** Refers to the caller's `defaultValue` standing in after a fault (wrong type on the wire, throwing provider) — see `errorCode`. */\n  Error: 'error',\n  /** Refers to the caller's `defaultValue` standing in because the flag exists but is switched off. */\n  Disabled: 'disabled',\n} as const;\n\nexport type FlagReason = (typeof FlagReason)[keyof typeof FlagReason];\n\n/** Defines what went wrong on an evaluation with `reason: 'error'`. */\nexport const FlagErrorCode = {\n  /** Refers to a resolved value whose runtime type is not the type asked for (a `string` for `getBoolean`, a non-finite `number`, an array for an object flag). */\n  TypeMismatch: 'type-mismatch',\n  /** Refers to a provider that threw, rejected, or reported its own failure. */\n  ProviderError: 'provider-error',\n  /** Refers to a `defaultValue` that is not one of the four supported flag types — reachable only from untyped JS. */\n  InvalidDefault: 'invalid-default',\n} as const;\n\nexport type FlagErrorCode = (typeof FlagErrorCode)[keyof typeof FlagErrorCode];\n\n/**\n * Defines the full outcome of one evaluation. Always carries a usable `value`: on any miss,\n * mismatch, or provider fault it is the caller's `defaultValue`, and `reason` says which.\n */\nexport interface FlagEvaluation<TValue extends FlagValue> {\n  /** The flag key evaluated. */\n  readonly key: string;\n\n  /** The resolved value, or the caller's `defaultValue` when `reason` is `default` / `error` / `disabled`. */\n  readonly value: TValue;\n\n  /** Why this value was produced. */\n  readonly reason: FlagReason;\n\n  /** The name of the matched variant, when the provider reports one — for analytics/exposure logging. */\n  readonly variant?: string;\n\n  /** What went wrong; set only when `reason` is `error`. */\n  readonly errorCode?: FlagErrorCode;\n\n  /** A human-readable description of the fault; set only when `reason` is `error`. */\n  readonly errorMessage?: string;\n}\n\n/** Defines the fault handed to `createFlagClient({ onError })` — evaluation itself has already fallen back, this is the reporting channel. */\nexport interface FlagErrorInfo {\n  /** The flag key being evaluated when the fault occurred. */\n  readonly key: string;\n\n  /** What went wrong. */\n  readonly errorCode: FlagErrorCode;\n\n  /** A human-readable description of the fault. */\n  readonly message: string;\n\n  /** The original thrown value, when the fault came from a throwing/rejecting provider. */\n  readonly cause?: unknown;\n}\n","import type { FlagProvider, FlagResolution } from './FlagProvider';\nimport { FlagReason, type ContextAttribute, type EvaluationContext, type FlagValue, type JsonObject } from './FlagTypes';\n\n/*\n * The in-memory provider: the test double AND the local-dev default (`createFlagClient()` with no\n * provider runs an empty one, so every flag cleanly returns the caller's default).\n *\n * A flag is either a bare value (`{ newNav: true }`) or a definition carrying variants, targeting\n * rules and the disabled gate. Rules are evaluated top-down, first match wins — deliberately no\n * rule algebra: this is a local stand-in for a real flag service's targeting, not a rules engine.\n *\n * NOT VALIDATED ON PURPOSE: the typed `resolve*` methods cast their entry rather than checking it,\n * so a map declaring `{ newNav: 'yes' }` really does hand a string to `getBoolean` — which is what\n * makes this provider a faithful double for the type-mismatch path the client guards.\n */\n\n/**\n * Defines a targeting condition. Either an attribute map — every entry must match, an array value\n * meaning \"is one of\" — or a predicate for anything more involved.\n *\n * `{ plan: 'pro' }` · `{ plan: ['pro', 'team'], region: 'eu' }` · `(ctx) => ctx.seats > 50`\n */\nexport type StaticFlagCondition =\n  | Readonly<Record<string, ContextAttribute | readonly ContextAttribute[]>>\n  | ((context: EvaluationContext) => boolean);\n\n/** Defines one targeting rule of a static flag — the value served to contexts matching `when`. */\nexport interface StaticFlagRule<TValue extends FlagValue> {\n  /** The condition the evaluation context must satisfy. */\n  readonly when: StaticFlagCondition;\n\n  /** The value served on a match — reported with `reason: 'targeting'`. */\n  readonly value: TValue;\n\n  /** The variant name reported on a match; falls back to the definition's `variant`. */\n  readonly variant?: string;\n}\n\n/** Defines a static flag with variants, targeting, or an off switch — the long form of a map entry. */\nexport interface StaticFlagDefinition<TValue extends FlagValue> {\n  /** The value served when no rule matches — reported with `reason: 'static'`. */\n  readonly value: TValue;\n\n  /** The variant name reported alongside `value`. */\n  readonly variant?: string;\n\n  /** Whether the flag is switched off — every evaluation returns the CALLER's default with `reason: 'disabled'`, rules skipped. */\n  readonly disabled?: boolean;\n\n  /** The targeting rules, evaluated top-down; the first match wins. */\n  readonly rules?: readonly StaticFlagRule<TValue>[];\n}\n\n/**\n * Defines one entry of a static flag map — a bare value or a {@link StaticFlagDefinition}.\n *\n * The two are told apart by the presence of a `value` property, so an object flag whose payload\n * itself has a `value` key must use the long form (`{ value: { value: 1 } }`).\n */\nexport type StaticFlagEntry = boolean | string | number | JsonObject | StaticFlagDefinition<FlagValue>;\n\n/** Defines the `key → flag` map backing a {@link staticFlagProvider}. */\nexport type StaticFlags = Readonly<Record<string, StaticFlagEntry>>;\n\n/** Reports whether one context attribute satisfies one expected value — an expected array means \"is one of\", an actual array means \"contains\". */\nfunction attributeMatches(actual: ContextAttribute | undefined, expected: ContextAttribute | readonly ContextAttribute[]): boolean {\n  if (Array.isArray(expected)) {\n    return (expected as readonly ContextAttribute[]).some((candidate) => attributeMatches(actual, candidate));\n  }\n  if (Array.isArray(actual)) {\n    return (actual as readonly (string | number | boolean)[]).some((entry) => entry === expected);\n  }\n  return actual === expected;\n}\n\n/** Reports whether an evaluation context satisfies a condition — every attribute must match, or the predicate must return `true`. */\nfunction conditionMatches(condition: StaticFlagCondition, context: EvaluationContext): boolean {\n  if (typeof condition === 'function') return condition(context);\n  return Object.entries(condition).every(([attribute, expected]) => attributeMatches(context[attribute], expected));\n}\n\n/** Reports whether a map entry is the long form — an object carrying a `value` property. */\nfunction isDefinition(entry: StaticFlagEntry): entry is StaticFlagDefinition<FlagValue> {\n  return typeof entry === 'object' && entry !== null && !Array.isArray(entry) && 'value' in entry;\n}\n\n/**\n * Creates an in-memory {@link FlagProvider} over a `key → flag` map — the test double, the\n * local-dev default, and the fallback used when a client is created without a provider.\n *\n * ```ts\n * const provider = staticFlagProvider({\n *   newNav: true,                                        // bare value\n *   theme: { value: 'light', variant: 'control', rules: [{ when: { plan: ['pro', 'team'] }, value: 'dark', variant: 'treatment' }] },\n *   legacyExport: { value: true, disabled: true },        // gated off → callers get their own default\n * });\n * ```\n */\nexport function staticFlagProvider(flags: StaticFlags = {}): FlagProvider {\n  const resolve = (key: string, context: EvaluationContext): FlagResolution<FlagValue> | undefined => {\n    const entry = flags[key];\n    if (entry === undefined) return undefined; // not configured — the client uses the caller's default\n\n    const definition: StaticFlagDefinition<FlagValue> = isDefinition(entry) ? entry : { value: entry };\n    if (definition.disabled === true) {\n      return { value: definition.value, reason: FlagReason.Disabled, variant: definition.variant };\n    }\n\n    for (const rule of definition.rules ?? []) {\n      if (conditionMatches(rule.when, context)) {\n        return { value: rule.value, reason: FlagReason.Targeting, variant: rule.variant ?? definition.variant };\n      }\n    }\n\n    return { value: definition.value, reason: FlagReason.Static, variant: definition.variant };\n  };\n\n  // Each typed method casts rather than validates — a mistyped map must reach the client's\n  // runtime type check, which is the behaviour under test.\n  return {\n    name: 'static',\n    resolveBoolean: (key, context) => resolve(key, context) as FlagResolution<boolean> | undefined,\n    resolveString: (key, context) => resolve(key, context) as FlagResolution<string> | undefined,\n    resolveNumber: (key, context) => resolve(key, context) as FlagResolution<number> | undefined,\n    resolveObject: (key, context) => resolve(key, context) as FlagResolution<JsonObject> | undefined,\n  };\n}\n","import type { FlagProvider, FlagResolution } from './FlagProvider';\nimport { staticFlagProvider } from './StaticFlagProvider';\nimport {\n  FlagErrorCode,\n  FlagReason,\n  type ContextAttribute,\n  type EvaluationContext,\n  type FlagErrorInfo,\n  type FlagEvaluation,\n  type FlagValue,\n  type JsonObject,\n} from './FlagTypes';\n\n/*\n * The evaluator. One rule governs the whole file: EVERY EVALUATION IS TOTAL — it returns a value of\n * the type asked for and never throws, whatever the provider does. A flag read sits inside render\n * paths and hot code; a throwing flag read would take a screen down over a config typo, which is the\n * opposite of what a kill-switch is for. So every failure mode lands on the caller's `defaultValue`:\n *\n *   not configured        → reason 'default'   (no errorCode, NOT reported — normal during rollout)\n *   flag switched off     → reason 'disabled'  (no errorCode, not reported)\n *   wrong runtime type    → reason 'error'     errorCode 'type-mismatch'   → onError\n *   provider threw/failed → reason 'error'     errorCode 'provider-error'  → onError\n *\n * `onError` is therefore the ONLY channel that surfaces a fault — wire it to the feedback bus or a\n * logger. It is called outside a try/catch on purpose (as the feedback bus calls its listeners): a\n * throwing app callback is an app bug and must not be swallowed here.\n *\n * The runtime type check is not belt-and-braces over TypeScript — the provider's typed `resolve*`\n * signatures describe an untyped wire payload, so the check is the only thing that actually holds.\n * `number` additionally rejects `NaN` / `Infinity`: neither survives a JSON round-trip intact, so\n * either one means the payload is broken, not that the flag is set to a strange number.\n */\n\n/** Defines the listener handed each evaluation fault — the reporting channel, evaluation has already fallen back. */\nexport type FlagErrorListener = (error: FlagErrorInfo) => void;\n\n/** Defines the listener notified after the evaluation context changes — how the Vue seam knows to re-evaluate. */\nexport type FlagContextListener = (context: EvaluationContext) => void;\n\n/** Defines the options for {@link createFlagClient}. */\nexport interface CreateFlagClientOptions {\n  /** The flag source. Defaults to an empty {@link staticFlagProvider} — every flag returns the caller's default. */\n  readonly provider?: FlagProvider;\n\n  /** The initial evaluation context (targeting subject + attributes). */\n  readonly context?: EvaluationContext;\n\n  /** Receives every evaluation fault (type mismatch, provider error). Misses and disabled flags are not faults and never arrive here. */\n  readonly onError?: FlagErrorListener;\n}\n\n/**\n * Defines the app-facing evaluation API. `get*` returns just the value — the everyday call; `evaluate*`\n * returns the full {@link FlagEvaluation} when the reason or variant matters (exposure logging,\n * debugging a rollout). Both are total: on any miss or fault the caller's `defaultValue` comes back.\n *\n * Each call takes an optional context that is merged over the client-wide one for that call only.\n */\nexport interface FlagClient {\n  /** The flag source behind this client. */\n  readonly provider: FlagProvider;\n\n  /** Evaluates a boolean flag, returning its value. */\n  getBoolean(key: string, defaultValue: boolean, context?: EvaluationContext): boolean;\n\n  /** Evaluates a string flag, returning its value. */\n  getString(key: string, defaultValue: string, context?: EvaluationContext): string;\n\n  /** Evaluates a number flag, returning its value. */\n  getNumber(key: string, defaultValue: number, context?: EvaluationContext): number;\n\n  /** Evaluates a JSON object flag, returning its payload. Object-ness is verified at runtime; the payload's inner shape is the caller's assertion. */\n  getObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue;\n\n  /** Evaluates a boolean flag, returning the full outcome. */\n  evaluateBoolean(key: string, defaultValue: boolean, context?: EvaluationContext): FlagEvaluation<boolean>;\n\n  /** Evaluates a string flag, returning the full outcome. */\n  evaluateString(key: string, defaultValue: string, context?: EvaluationContext): FlagEvaluation<string>;\n\n  /** Evaluates a number flag, returning the full outcome. */\n  evaluateNumber(key: string, defaultValue: number, context?: EvaluationContext): FlagEvaluation<number>;\n\n  /** Evaluates a JSON object flag, returning the full outcome. */\n  evaluateObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue>;\n\n  /** Evaluates any flag, picking the typed path from the runtime type of `defaultValue` — what `useFlag` is built on. */\n  getValue<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue;\n\n  /** Evaluates any flag, picking the typed path from the runtime type of `defaultValue`, returning the full outcome. */\n  evaluate<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue>;\n\n  /** Reads the current client-wide evaluation context. */\n  getContext(): EvaluationContext;\n\n  /**\n   * Merges attributes into the client-wide evaluation context — an attribute set to `undefined` is\n   * removed. A merge that changes nothing is a no-op: no listener runs and the provider is not\n   * re-notified, so a context literal rebuilt on every parent render costs nothing (a remote adapter\n   * would otherwise refetch, and every flag consumer re-evaluate, once per parent render).\n   */\n  setContext(context: EvaluationContext): void;\n\n  /** Subscribes to context changes; returns an unsubscribe. */\n  subscribe(listener: FlagContextListener): () => void;\n}\n\n/** Reports whether two attribute values are equal — element-wise for lists, so a re-created array is not a change. */\nfunction attributesEqual(left: ContextAttribute | undefined, right: ContextAttribute | undefined): boolean {\n  if (Array.isArray(left) && Array.isArray(right)) {\n    const rightEntries = right as readonly unknown[];\n    const leftEntries = left as readonly unknown[];\n    return leftEntries.length === rightEntries.length && leftEntries.every((entry, index) => entry === rightEntries[index]);\n  }\n  return left === right;\n}\n\n/** Reports whether two evaluation contexts hold the same attributes. */\nfunction contextsEqual(left: EvaluationContext, right: EvaluationContext): boolean {\n  const leftKeys = Object.keys(left);\n  const rightKeys = Object.keys(right);\n  return leftKeys.length === rightKeys.length && leftKeys.every((key) => attributesEqual(left[key], right[key]));\n}\n\n/** Merges a patch over a context, dropping every attribute explicitly set to `undefined`. */\nfunction mergeContext(base: EvaluationContext, patch: EvaluationContext): EvaluationContext {\n  const merged: Record<string, ContextAttribute | undefined> = { ...base, ...patch };\n  for (const key of Object.keys(merged)) {\n    if (merged[key] === undefined) delete merged[key];\n  }\n  return merged;\n}\n\n/**\n * Creates a flag client over a {@link FlagProvider} — one per app, module scope, shared by the Vue\n * seam ({@link FlagsProvider}) and any non-Vue caller (route guards, api-client wiring, sagas).\n *\n * ```ts\n * export const flags = createFlagClient({\n *   provider: staticFlagProvider({ newNav: { value: false, rules: [{ when: { plan: 'pro' }, value: true }] } }),\n *   onError: (error) => notify({ tone: NoticeTone.Warning, title: `flag ${error.key}: ${error.message}` }),\n * });\n *\n * flags.setContext({ targetingKey: user.id, plan: user.plan });\n * flags.getBoolean('newNav', false);\n * ```\n */\nexport function createFlagClient(options: CreateFlagClientOptions = {}): FlagClient {\n  const provider = options.provider ?? staticFlagProvider();\n  const onError = options.onError;\n  const listeners = new Set<FlagContextListener>();\n  let currentContext: EvaluationContext = options.context ? mergeContext({}, options.context) : {};\n\n  const report = (key: string, errorCode: FlagErrorCode, message: string, cause?: unknown): void => {\n    onError?.({ key, errorCode, message, cause });\n  };\n\n  /** Runs one typed evaluation end to end — the single place every failure mode is turned into a value. */\n  const core = <TValue extends FlagValue>(\n    key: string,\n    defaultValue: TValue,\n    callerContext: EvaluationContext | undefined,\n    resolve: (key: string, context: EvaluationContext) => FlagResolution<FlagValue> | undefined,\n    isValid: (value: FlagValue) => boolean,\n    typeName: string,\n  ): FlagEvaluation<TValue> => {\n    const context = callerContext ? mergeContext(currentContext, callerContext) : currentContext;\n\n    let resolution: FlagResolution<FlagValue> | undefined;\n    try {\n      resolution = resolve(key, context);\n    } catch (cause) {\n      const message = `provider \"${provider.name ?? 'unnamed'}\" threw while resolving \"${key}\"`;\n      report(key, FlagErrorCode.ProviderError, message, cause);\n      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.ProviderError, errorMessage: message };\n    }\n\n    if (resolution === undefined) return { key, value: defaultValue, reason: FlagReason.Default };\n\n    if (resolution.errorCode !== undefined) {\n      const message = resolution.errorMessage ?? `provider reported \"${resolution.errorCode}\" for \"${key}\"`;\n      report(key, resolution.errorCode, message);\n      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: resolution.errorCode, errorMessage: message, variant: resolution.variant };\n    }\n\n    // Gated off: the flag exists but must not apply — the caller's default stands, not the stored value.\n    if (resolution.reason === FlagReason.Disabled) {\n      return { key, value: defaultValue, reason: FlagReason.Disabled, variant: resolution.variant };\n    }\n\n    if (!isValid(resolution.value)) {\n      const message = `flag \"${key}\" resolved to ${typeof resolution.value}, expected ${typeName}`;\n      report(key, FlagErrorCode.TypeMismatch, message);\n      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.TypeMismatch, errorMessage: message, variant: resolution.variant };\n    }\n\n    // The only cast in the evaluation path, and `isValid` is what earns it: the runtime type of the\n    // resolved value has just been checked against the type `TValue` was inferred from.\n    return { key, value: resolution.value as TValue, reason: resolution.reason ?? FlagReason.Static, variant: resolution.variant };\n  };\n\n  const isBoolean = (value: FlagValue): boolean => typeof value === 'boolean';\n  const isString = (value: FlagValue): boolean => typeof value === 'string';\n  const isNumber = (value: FlagValue): boolean => typeof value === 'number' && Number.isFinite(value);\n  const isJsonObject = (value: FlagValue): boolean => typeof value === 'object' && value !== null && !Array.isArray(value);\n\n  const evaluateBoolean = (key: string, defaultValue: boolean, context?: EvaluationContext): FlagEvaluation<boolean> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, 'boolean');\n\n  const evaluateString = (key: string, defaultValue: string, context?: EvaluationContext): FlagEvaluation<string> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, 'string');\n\n  const evaluateNumber = (key: string, defaultValue: number, context?: EvaluationContext): FlagEvaluation<number> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, 'number');\n\n  const evaluateObject = <TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, 'object');\n\n  const evaluate = <TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue> => {\n    if (typeof defaultValue === 'boolean') return core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, 'boolean');\n    if (typeof defaultValue === 'string') return core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, 'string');\n    if (typeof defaultValue === 'number') return core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, 'number');\n    if (isJsonObject(defaultValue)) return core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, 'object');\n\n    // Unreachable from TypeScript (`FlagValue` covers the four cases above) — reachable from untyped\n    // JS passing `null` / an array / a function as the default. Still total: hand it straight back.\n    const message = `flag \"${key}\" was given a ${typeof defaultValue} default, expected boolean, string, number, or object`;\n    report(key, FlagErrorCode.InvalidDefault, message);\n    return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.InvalidDefault, errorMessage: message };\n  };\n\n  const notifyProvider = (context: EvaluationContext): void => {\n    const hook = provider.onContextChange;\n    if (hook === undefined) return;\n    const fail = (cause: unknown): void =>\n      report('', FlagErrorCode.ProviderError, `provider \"${provider.name ?? 'unnamed'}\" failed handling the context change`, cause);\n    try {\n      const pending = hook.call(provider, context);\n      if (pending instanceof Promise) void pending.catch(fail); // a rejected refetch must not become an unhandled rejection\n    } catch (cause) {\n      fail(cause);\n    }\n  };\n\n  return {\n    provider,\n\n    getBoolean: (key, defaultValue, context) => evaluateBoolean(key, defaultValue, context).value,\n    getString: (key, defaultValue, context) => evaluateString(key, defaultValue, context).value,\n    getNumber: (key, defaultValue, context) => evaluateNumber(key, defaultValue, context).value,\n\n    // Generic method shorthand, not an arrow: a non-generic arrow contextually typed by a generic\n    // signature widens `TValue` to its constraint and the return no longer narrows back.\n    getObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue {\n      return evaluateObject(key, defaultValue, context).value;\n    },\n\n    evaluateBoolean,\n    evaluateString,\n    evaluateNumber,\n    evaluateObject,\n\n    getValue<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue {\n      return evaluate(key, defaultValue, context).value;\n    },\n    evaluate,\n\n    getContext: () => currentContext,\n\n    setContext(context: EvaluationContext): void {\n      const next = mergeContext(currentContext, context);\n      if (contextsEqual(currentContext, next)) return; // no-op merge — a per-render context literal costs nothing\n      currentContext = next;\n      notifyProvider(next);\n      for (const listener of [...listeners]) listener(next);\n    },\n\n    subscribe(listener: FlagContextListener): () => void {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n}\n","import {\n  computed,\n  inject,\n  provide,\n  ref,\n  toValue,\n  watch,\n  type ComputedRef,\n  type InjectionKey,\n  type MaybeRefOrGetter,\n  type Ref,\n} from 'vue';\n\nimport { createFlagClient, type FlagClient } from './FlagClient';\nimport type { FlagValue } from './FlagTypes';\n\n/*\n * The Vue seam over `FlagClient` — the provide/inject + composable pattern used by\n * `foundation/primitives`' `DirectionProvider`, including its standalone fallback: `useFlag` works\n * with no provider mounted (every flag returns the caller's default), so an SDK component may read\n * a flag without forcing every consuming app to wire one.\n *\n * NOTE ON NAMING: `FlagsProvider` (plural) is the Vue component in `FlagsProvider.vue`;\n * `FlagProvider` (singular, `FlagProvider.ts`) is the backend adapter it evaluates against. Same\n * split as OpenFeature.\n *\n * RE-EVALUATION ON CONTEXT CHANGE. The client is created once and never re-created — swapping it\n * mid-life would drop its subscribers — so a context change cannot propagate by client identity.\n * Instead the provider subscribes to the client and bumps a `revision` ref; every `useFlag` computed\n * reads that ref, so a context change invalidates all of them at once. Evaluation is a synchronous\n * map lookup, so the computed re-evaluates on read with no extra bookkeeping, and never goes stale.\n *\n * WHERE THIS BEATS THE REACT ORIGINAL. React re-rendered every consumer of the context on every\n * revision bump, because the context VALUE carried the revision. Here the revision is a ref read\n * inside each `useFlag` computed, so only the flags actually read are re-evaluated, and only the\n * components that depend on a CHANGED flag re-render — Vue's dependency graph does the narrowing\n * that React's context could not.\n */\n\n/** The active client plus the counter that re-evaluates consumers when the evaluation context moves. */\ninterface FlagsContextValue {\n  /** The client in force. A computed, so a swapped `client` prop still reaches every consumer. */\n  readonly client: ComputedRef<FlagClient>;\n\n  /** Bumped on every context change — what invalidates each `useFlag` computed. */\n  readonly revision: Ref<number>;\n}\n\n/**\n * React's `createContext<FlagsContextValue | undefined>(undefined)` becomes an `InjectionKey` plus\n * the standalone fallback resolved at the injection site. Deliberately NOT re-exported from\n * `index.ts`: the React original kept its context module-private, and the barrel shape is preserved.\n */\nconst FlagsKey: InjectionKey<FlagsContextValue> = Symbol('wow-two.flags');\n\n/**\n * Backs the composables when no `FlagsProvider` is mounted — an empty static provider, so every flag\n * returns the caller's default. Built lazily and memoised rather than at module scope, so merely\n * importing this module allocates nothing; `revision` never bumps, because nothing can move it.\n */\nlet standalone: FlagsContextValue | undefined;\n\nfunction standaloneContext(): FlagsContextValue {\n  if (!standalone) {\n    const client = createFlagClient();\n    standalone = { client: computed(() => client), revision: ref(0) };\n  }\n  return standalone;\n}\n\n/**\n * The provider half — used by `FlagsProvider`, and by any component that owns a flag client.\n * Subscribes to the client and re-subscribes if the active client is swapped, disposing the previous\n * subscription through the watcher's `onCleanup`.\n *\n * Pass `client` as a getter (`() => props.client ?? ownClient`) so the active client stays tracked.\n */\nexport function provideFlags(client: MaybeRefOrGetter<FlagClient>): void {\n  const active = computed(() => toValue(client));\n  const revision = ref(0);\n\n  // React bumped a `revision` into component state from an effect; the Vue equivalent is a watcher\n  // that owns the subscription. `immediate` is safe under SSR — `subscribe` only adds to a Set and\n  // touches no browser global.\n  watch(\n    active,\n    (current, _previous, onCleanup) => {\n      onCleanup(current.subscribe(() => (revision.value += 1)));\n    },\n    { immediate: true },\n  );\n\n  provide(FlagsKey, { client: active, revision });\n}\n\n/** Resolves the surrounding flags context, or the standalone fallback when no provider is mounted. */\nfunction resolveFlags(): FlagsContextValue {\n  return inject(FlagsKey, standaloneContext, true);\n}\n\n/**\n * Reads the flag client. Works without a {@link FlagsProvider} — falls back to an empty one, where\n * every flag returns the caller's default.\n *\n * Returns the plain `FlagClient` rather than a ref, matching the React original: the client is\n * created once and never re-created, so there is nothing to track. Use it for imperative reads and\n * for `setContext`; for a value that must re-evaluate when the evaluation context moves, use\n * {@link useFlag}, whose computed is the reactive path.\n */\nexport function useFlags(): FlagClient {\n  return resolveFlags().client.value;\n}\n\n/**\n * Reads one flag's value, re-evaluating whenever the evaluation context changes. The typed path is\n * picked from `defaultValue`, which also types the result — `useFlag('newNav', false)` is\n * `ComputedRef<boolean>`, `useFlag('limits', { max: 10 })` is a computed of that object type.\n *\n * Diverges from the React original, which returned a bare `TValue` re-read on every render: this\n * returns a `ComputedRef<TValue>`, because a bare value could never re-evaluate. `key` and\n * `defaultValue` may each be a ref or getter — changing either re-evaluates the flag, which the\n * React signature could not express at all.\n */\nexport function useFlag<TValue extends FlagValue>(\n  key: MaybeRefOrGetter<string>,\n  defaultValue: MaybeRefOrGetter<TValue>,\n): ComputedRef<TValue> {\n  const { client, revision } = resolveFlags();\n  return computed<TValue>(() => {\n    // `revision` is the dependency that re-evaluates this flag when the evaluation context moves.\n    // Read through `void` rather than discarded into a binding — the read IS the subscription.\n    void revision.value;\n    return client.value.getValue(toValue(key), toValue(defaultValue));\n  });\n}\n","<script lang=\"ts\">\nimport type { FlagClient, FlagErrorListener } from './FlagClient';\nimport type { FlagProvider } from './FlagProvider';\nimport type { EvaluationContext } from './FlagTypes';\n\n/** Defines the props for {@link FlagsProvider}. */\nexport interface FlagsProviderProps {\n  /** An existing client to serve — the app-wide instance shared with non-Vue callers. Takes precedence over `provider` / `onError`. */\n  client?: FlagClient;\n\n  /** The flag source to build a client around, when no `client` is passed. Read once, at setup. */\n  provider?: FlagProvider;\n\n  /** The evaluation context. Kept in sync on every change — a fresh object literal per render is safe. */\n  context?: EvaluationContext;\n\n  /** Receives evaluation faults, when no `client` is passed. Read once, at setup. */\n  onError?: FlagErrorListener;\n}\n</script>\n\n<script setup lang=\"ts\">\nimport { watch } from 'vue';\n\nimport { createFlagClient } from './FlagClient';\nimport { provideFlags } from './FlagsContext';\n\n/**\n * Provides flag evaluation to every descendant and re-evaluates them whenever the evaluation context\n * changes — including changes made imperatively through `client.setContext(…)` outside Vue.\n *\n * ```vue\n * <FlagsProvider :client=\"flags\" :context=\"{ targetingKey: user.id, plan: user.plan }\">\n *   <App />\n * </FlagsProvider>\n * ```\n *\n * Renders no element of its own — the slot passes straight through, matching `DirectionProvider`.\n */\ndefineOptions({ name: 'FlagsProvider' });\n\nconst props = defineProps<FlagsProviderProps>();\n\n// `setup` runs exactly once per instance, which is precisely what React's lazy `useState`\n// initializer was working around — the client must be created once for the component's life, and a\n// `computed` would be allowed to drop and re-run it.\nconst ownClient = props.client ?? createFlagClient({ provider: props.provider, context: props.context, onError: props.onError });\n\n// A getter, not a snapshot: a swapped `client` prop re-subscribes and reaches every consumer.\nprovideFlags(() => props.client ?? ownClient);\n\n// The `context` prop syncs in through a watcher rather than at construction, so a fresh object\n// literal per render is safe: `setContext` no-ops when the merge changes nothing, so a parent that\n// rebuilds its context literal every render neither refetches nor re-evaluates flag consumers.\n//\n// `immediate` lands the context during setup, BEFORE descendants first evaluate — where React's\n// effect ran after mount, so a passed-in `client` briefly evaluated against a stale targeting\n// context and every gated element could flash. SSR-safe: `setContext` touches no browser global.\nwatch(\n  [() => props.client ?? ownClient, () => props.context],\n  ([client, context]) => {\n    if (context !== undefined) client.setContext(context);\n  },\n  { immediate: true },\n);\n</script>\n\n<template>\n  <slot />\n</template>\n"],"names":["_renderSlot"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../src/flags/FlagTypes.ts","../../src/flags/StaticFlagProvider.ts","../../src/flags/FlagClient.ts","../../src/flags/providers/FlagsContext.ts","../../src/flags/providers/FlagsProvider.vue"],"sourcesContent":["/*\n * OpenFeature-SHAPED vocabulary, mirrored structurally — NO `@openfeature/*` dependency, exactly\n * like `forms-engine/StandardSchema.ts` vendors the Standard Schema spec types. An app that later\n * adopts the real OpenFeature JS SDK re-points its adapter and keeps every call site: evaluation\n * context, resolution details, reason, error code and variant all carry the spec's meaning.\n *\n * Three deliberate divergences, each in service of \"every evaluation is total\" (see FlagClient.ts):\n *   - reasons are lowercase house strings (`'targeting'`, not the spec's `TARGETING_MATCH`), matching\n *     the `AuthStatus` / `NoticeTone` const-object shape used everywhere else in this SDK;\n *   - a MISSING flag is `reason: 'default'`, NOT an error — an unconfigured flag is the normal state\n *     during a rollout, so it carries no `errorCode` and never reaches `onError`. Only a genuine\n *     fault (wrong wire type, throwing provider) is an error;\n *   - object flags are constrained to a JSON *object* (`JsonObject`), not the spec's whole\n *     `JsonValue` — a top-level array or scalar flag is expressed as its own typed flag instead.\n */\n\n/** Defines a JSON scalar — the leaves of an object flag's payload. */\nexport type JsonPrimitive = string | number | boolean | null;\n\n/** Defines any JSON-serialisable value inside an object flag's payload. */\nexport type JsonValue = JsonPrimitive | ReadonlyArray<JsonValue> | JsonObject;\n\n/**\n * Defines the payload of an object flag — a JSON object.\n *\n * TS only grants *type aliases* an implicit index signature, so a payload typed by an `interface`\n * is not assignable here; declare the payload with `type Payload = { … }` (or extend `JsonObject`).\n */\nexport interface JsonObject {\n  /** The payload entries — any JSON-serialisable value. */\n  readonly [key: string]: JsonValue;\n}\n\n/** Defines every value a flag can evaluate to — the four supported flag types. */\nexport type FlagValue = boolean | string | number | JsonObject;\n\n/** Defines an attribute value on an {@link EvaluationContext} — a scalar, or a list for roles and groups. */\nexport type ContextAttribute = string | number | boolean | null | readonly (string | number | boolean)[];\n\n/**\n * Defines the targeting input of an evaluation — who/what the flag is being resolved for.\n * `targetingKey` is the spec's stable subject identity (user id, tenant, device); every other\n * attribute is free-form and matched by a provider's rules.\n *\n * Set app-wide with `client.setContext(…)` (merged, see {@link FlagClient}) and override per call\n * by passing a context to any `get*` / `evaluate*`.\n */\nexport interface EvaluationContext {\n  /** The stable identity the flag is resolved for — user id, tenant id, device id. */\n  readonly targetingKey?: string;\n\n  /** Any further targeting attribute — `plan`, `region`, `roles`, `isInternal`. */\n  readonly [attribute: string]: ContextAttribute | undefined;\n}\n\n/** Defines why an evaluation produced the value it did. */\nexport const FlagReason = {\n  /** Refers to the flag's configured value, with no rule involved. */\n  Static: 'static',\n  /** Refers to a value chosen by a targeting rule matching the evaluation context. */\n  Targeting: 'targeting',\n  /** Refers to `defaultValue` standing in for an unconfigured flag — the pre-rollout state, not a fault. */\n  Default: 'default',\n  /** Refers to `defaultValue` standing in after a fault, such as a wrong wire type — see `errorCode`. */\n  Error: 'error',\n  /** Refers to the caller's `defaultValue` standing in because the flag exists but is switched off. */\n  Disabled: 'disabled',\n} as const;\n\nexport type FlagReason = (typeof FlagReason)[keyof typeof FlagReason];\n\n/** Defines what went wrong on an evaluation with `reason: 'error'`. */\nexport const FlagErrorCode = {\n  /** Refers to a resolved value whose runtime type is not the one asked for — a `string` for `getBoolean`. */\n  TypeMismatch: 'type-mismatch',\n  /** Refers to a provider that threw, rejected, or reported its own failure. */\n  ProviderError: 'provider-error',\n  /** Refers to a `defaultValue` that is not one of the four supported flag types — reachable only from untyped JS. */\n  InvalidDefault: 'invalid-default',\n} as const;\n\nexport type FlagErrorCode = (typeof FlagErrorCode)[keyof typeof FlagErrorCode];\n\n/**\n * Defines the full outcome of one evaluation. Always carries a usable `value`: on any miss,\n * mismatch, or provider fault it is the caller's `defaultValue`, and `reason` says which.\n */\nexport interface FlagEvaluation<TValue extends FlagValue> {\n  /** The flag key evaluated. */\n  readonly key: string;\n\n  /** The resolved value, or the caller's `defaultValue` when `reason` is `default` / `error` / `disabled`. */\n  readonly value: TValue;\n\n  /** Why this value was produced. */\n  readonly reason: FlagReason;\n\n  /** The name of the matched variant, when the provider reports one — for analytics/exposure logging. */\n  readonly variant?: string;\n\n  /** What went wrong; set only when `reason` is `error`. */\n  readonly errorCode?: FlagErrorCode;\n\n  /** A human-readable description of the fault; set only when `reason` is `error`. */\n  readonly errorMessage?: string;\n}\n\n/** Defines the fault handed to `createFlagClient({ onError })`; evaluation has already fallen back. */\nexport interface FlagErrorInfo {\n  /** The flag key being evaluated when the fault occurred. */\n  readonly key: string;\n\n  /** What went wrong. */\n  readonly errorCode: FlagErrorCode;\n\n  /** A human-readable description of the fault. */\n  readonly message: string;\n\n  /** The original thrown value, when the fault came from a throwing/rejecting provider. */\n  readonly cause?: unknown;\n}\n","import type { FlagProvider, FlagResolution } from './FlagProvider';\nimport {\n  FlagReason,\n  type ContextAttribute,\n  type EvaluationContext,\n  type FlagValue,\n  type JsonObject,\n} from './FlagTypes';\n\n/*\n * The in-memory provider: the test double AND the local-dev default (`createFlagClient()` with no\n * provider runs an empty one, so every flag cleanly returns the caller's default).\n *\n * A flag is either a bare value (`{ newNav: true }`) or a definition carrying variants, targeting\n * rules and the disabled gate. Rules are evaluated top-down, first match wins — deliberately no\n * rule algebra: this is a local stand-in for a real flag service's targeting, not a rules engine.\n *\n * NOT VALIDATED ON PURPOSE: the typed `resolve*` methods cast their entry rather than checking it,\n * so a map declaring `{ newNav: 'yes' }` really does hand a string to `getBoolean` — which is what\n * makes this provider a faithful double for the type-mismatch path the client guards.\n */\n\n/**\n * Defines a targeting condition. Either an attribute map — every entry must match, an array value\n * meaning \"is one of\" — or a predicate for anything more involved.\n *\n * `{ plan: 'pro' }` · `{ plan: ['pro', 'team'], region: 'eu' }` · `(ctx) => ctx.seats > 50`\n */\nexport type StaticFlagCondition =\n  | Readonly<Record<string, ContextAttribute | ReadonlyArray<ContextAttribute>>>\n  | ((context: EvaluationContext) => boolean);\n\n/** Defines one targeting rule of a static flag — the value served to contexts matching `when`. */\nexport interface StaticFlagRule<TValue extends FlagValue> {\n  /** The condition the evaluation context must satisfy. */\n  readonly when: StaticFlagCondition;\n\n  /** The value served on a match — reported with `reason: 'targeting'`. */\n  readonly value: TValue;\n\n  /** The variant name reported on a match; falls back to the definition's `variant`. */\n  readonly variant?: string;\n}\n\n/** Defines a static flag with variants, targeting, or an off switch — the long form of a map entry. */\nexport interface StaticFlagDefinition<TValue extends FlagValue> {\n  /** The value served when no rule matches — reported with `reason: 'static'`. */\n  readonly value: TValue;\n\n  /** The variant name reported alongside `value`. */\n  readonly variant?: string;\n\n  /** Whether the flag is off; every evaluation returns the caller's default, `reason: 'disabled'`, rules skipped. */\n  readonly disabled?: boolean;\n\n  /** The targeting rules, evaluated top-down; the first match wins. */\n  readonly rules?: ReadonlyArray<StaticFlagRule<TValue>>;\n}\n\n/**\n * Defines one entry of a static flag map — a bare value or a {@link StaticFlagDefinition}.\n *\n * The two are told apart by the presence of a `value` property, so an object flag whose payload\n * itself has a `value` key must use the long form (`{ value: { value: 1 } }`).\n */\nexport type StaticFlagEntry = boolean | string | number | JsonObject | StaticFlagDefinition<FlagValue>;\n\n/** Defines the `key → flag` map backing a {@link staticFlagProvider}. */\nexport type StaticFlags = Readonly<Record<string, StaticFlagEntry>>;\n\n/** Reports whether one attribute satisfies one expected value — expected array is \"one of\", actual is \"contains\". */\nfunction attributeMatches(\n  actual: ContextAttribute | undefined,\n  expected: ContextAttribute | ReadonlyArray<ContextAttribute>,\n): boolean {\n  if (Array.isArray(expected)) {\n    return (expected as ReadonlyArray<ContextAttribute>).some((candidate) => attributeMatches(actual, candidate));\n  }\n  if (Array.isArray(actual)) {\n    return (actual as ReadonlyArray<string | number | boolean>).some((entry) => entry === expected);\n  }\n  return actual === expected;\n}\n\n/** Reports whether a context satisfies a condition — every attribute matches, or the predicate returns `true`. */\nfunction conditionMatches(condition: StaticFlagCondition, context: EvaluationContext): boolean {\n  if (typeof condition === 'function') return condition(context);\n  return Object.entries(condition).every(([attribute, expected]) => attributeMatches(context[attribute], expected));\n}\n\n/** Reports whether a map entry is the long form — an object carrying a `value` property. */\nfunction isDefinition(entry: StaticFlagEntry): entry is StaticFlagDefinition<FlagValue> {\n  return typeof entry === 'object' && entry !== null && !Array.isArray(entry) && 'value' in entry;\n}\n\n/**\n * Creates an in-memory {@link FlagProvider} over a `key → flag` map — the test double, the\n * local-dev default, and the fallback used when a client is created without a provider.\n *\n * An entry is a bare value or a {@link StaticFlagDefinition}; a disabled one hands back the caller's default.\n */\nexport function staticFlagProvider(flags: StaticFlags = {}): FlagProvider {\n  const resolve = (key: string, context: EvaluationContext): FlagResolution<FlagValue> | undefined => {\n    const entry = flags[key];\n    if (entry === undefined) return undefined; // not configured — the client uses the caller's default\n\n    const definition: StaticFlagDefinition<FlagValue> = isDefinition(entry) ? entry : { value: entry };\n    if (definition.disabled === true) {\n      return { value: definition.value, reason: FlagReason.Disabled, variant: definition.variant };\n    }\n\n    for (const rule of definition.rules ?? []) {\n      if (conditionMatches(rule.when, context)) {\n        return { value: rule.value, reason: FlagReason.Targeting, variant: rule.variant ?? definition.variant };\n      }\n    }\n\n    return { value: definition.value, reason: FlagReason.Static, variant: definition.variant };\n  };\n\n  // Each typed method casts rather than validates — a mistyped map must reach the client's\n  // runtime type check, which is the behaviour under test.\n  return {\n    name: 'static',\n    resolveBoolean: (key, context) => resolve(key, context) as FlagResolution<boolean> | undefined,\n    resolveString: (key, context) => resolve(key, context) as FlagResolution<string> | undefined,\n    resolveNumber: (key, context) => resolve(key, context) as FlagResolution<number> | undefined,\n    resolveObject: (key, context) => resolve(key, context) as FlagResolution<JsonObject> | undefined,\n  };\n}\n","import type { FlagProvider, FlagResolution } from './FlagProvider';\nimport { staticFlagProvider } from './StaticFlagProvider';\nimport {\n  FlagErrorCode,\n  FlagReason,\n  type ContextAttribute,\n  type EvaluationContext,\n  type FlagErrorInfo,\n  type FlagEvaluation,\n  type FlagValue,\n  type JsonObject,\n} from './FlagTypes';\n\n/*\n * The evaluator. One rule governs the whole file: EVERY EVALUATION IS TOTAL — it returns a value of\n * the type asked for and never throws, whatever the provider does. A flag read sits inside render\n * paths and hot code; a throwing flag read would take a screen down over a config typo, which is the\n * opposite of what a kill-switch is for. So every failure mode lands on the caller's `defaultValue`:\n *\n *   not configured        → reason 'default'   (no errorCode, NOT reported — normal during rollout)\n *   flag switched off     → reason 'disabled'  (no errorCode, not reported)\n *   wrong runtime type    → reason 'error'     errorCode 'type-mismatch'   → onError\n *   provider threw/failed → reason 'error'     errorCode 'provider-error'  → onError\n *\n * `onError` is therefore the ONLY channel that surfaces a fault — wire it to the feedback bus or a\n * logger. It is called outside a try/catch on purpose (as the feedback bus calls its listeners): a\n * throwing app callback is an app bug and must not be swallowed here.\n *\n * The runtime type check is not belt-and-braces over TypeScript — the provider's typed `resolve*`\n * signatures describe an untyped wire payload, so the check is the only thing that actually holds.\n * `number` additionally rejects `NaN` / `Infinity`: neither survives a JSON round-trip intact, so\n * either one means the payload is broken, not that the flag is set to a strange number.\n */\n\n/** Defines the listener handed each evaluation fault — the reporting channel, evaluation has already fallen back. */\nexport type FlagErrorListener = (error: FlagErrorInfo) => void;\n\n/** Defines the listener notified after the evaluation context changes — how the Vue seam knows to re-evaluate. */\nexport type FlagContextListener = (context: EvaluationContext) => void;\n\n/** Defines the options for {@link createFlagClient}. */\nexport interface CreateFlagClientOptions {\n  /** The flag source. Defaults to an empty {@link staticFlagProvider} — every flag returns the caller's default. */\n  readonly provider?: FlagProvider;\n\n  /** The initial evaluation context (targeting subject + attributes). */\n  readonly context?: EvaluationContext;\n\n  /** Receives every evaluation fault. A miss or a disabled flag is not a fault and never arrives here. */\n  readonly onError?: FlagErrorListener;\n}\n\n/**\n * Defines the app-facing evaluation API. `get*` returns just the value — the everyday call; `evaluate*`\n * returns the full {@link FlagEvaluation} when the reason or variant matters (exposure logging,\n * debugging a rollout). Both are total: on any miss or fault the caller's `defaultValue` comes back.\n *\n * Each call takes an optional context that is merged over the client-wide one for that call only.\n */\nexport interface FlagClient {\n  /** The flag source behind this client. */\n  readonly provider: FlagProvider;\n\n  /** Evaluates a boolean flag, returning its value. */\n  getBoolean(key: string, defaultValue: boolean, context?: EvaluationContext): boolean;\n\n  /** Evaluates a string flag, returning its value. */\n  getString(key: string, defaultValue: string, context?: EvaluationContext): string;\n\n  /** Evaluates a number flag, returning its value. */\n  getNumber(key: string, defaultValue: number, context?: EvaluationContext): number;\n\n  /** Evaluates a JSON object flag. Object-ness is checked at runtime; the inner shape is the caller's assertion. */\n  getObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue;\n\n  /** Evaluates a boolean flag, returning the full outcome. */\n  evaluateBoolean(key: string, defaultValue: boolean, context?: EvaluationContext): FlagEvaluation<boolean>;\n\n  /** Evaluates a string flag, returning the full outcome. */\n  evaluateString(key: string, defaultValue: string, context?: EvaluationContext): FlagEvaluation<string>;\n\n  /** Evaluates a number flag, returning the full outcome. */\n  evaluateNumber(key: string, defaultValue: number, context?: EvaluationContext): FlagEvaluation<number>;\n\n  /** Evaluates a JSON object flag, returning the full outcome. */\n  evaluateObject<TValue extends JsonObject>(\n    key: string,\n    defaultValue: TValue,\n    context?: EvaluationContext,\n  ): FlagEvaluation<TValue>;\n\n  /** Evaluates any flag, picking the typed path from `defaultValue`'s runtime type. `useFlag` builds on it. */\n  getValue<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue;\n\n  /** Evaluates any flag, picking the typed path from the runtime type of `defaultValue`, returning the full outcome. */\n  evaluate<TValue extends FlagValue>(\n    key: string,\n    defaultValue: TValue,\n    context?: EvaluationContext,\n  ): FlagEvaluation<TValue>;\n\n  /** Reads the current client-wide evaluation context. */\n  getContext(): EvaluationContext;\n\n  /**\n   * Merges attributes into the client-wide evaluation context — an attribute set to `undefined` is\n   * removed. A merge that changes nothing is a no-op: no listener runs and the provider is not\n   * re-notified, so a context literal rebuilt on every parent render costs nothing (a remote adapter\n   * would otherwise refetch, and every flag consumer re-evaluate, once per parent render).\n   */\n  setContext(context: EvaluationContext): void;\n\n  /** Subscribes to context changes; returns an unsubscribe. */\n  subscribe(listener: FlagContextListener): () => void;\n}\n\n/** Reports whether two attribute values are equal — element-wise for lists, so a re-created array is not a change. */\nfunction attributesEqual(left: ContextAttribute | undefined, right: ContextAttribute | undefined): boolean {\n  if (Array.isArray(left) && Array.isArray(right)) {\n    const rightEntries = right as ReadonlyArray<unknown>;\n    const leftEntries = left as ReadonlyArray<unknown>;\n    return (\n      leftEntries.length === rightEntries.length && leftEntries.every((entry, index) => entry === rightEntries[index])\n    );\n  }\n  return left === right;\n}\n\n/** Reports whether two evaluation contexts hold the same attributes. */\nfunction contextsEqual(left: EvaluationContext, right: EvaluationContext): boolean {\n  const leftKeys = Object.keys(left);\n  const rightKeys = Object.keys(right);\n  return leftKeys.length === rightKeys.length && leftKeys.every((key) => attributesEqual(left[key], right[key]));\n}\n\n/** Merges a patch over a context, dropping every attribute explicitly set to `undefined`. */\nfunction mergeContext(base: EvaluationContext, patch: EvaluationContext): EvaluationContext {\n  const merged: Record<string, ContextAttribute | undefined> = { ...base, ...patch };\n  for (const key of Object.keys(merged)) {\n    if (merged[key] === undefined) delete merged[key];\n  }\n  for (const key of Object.keys(merged)) {\n    const value = merged[key];\n    if (Array.isArray(value)) merged[key] = Object.freeze([...value]);\n  }\n  return Object.freeze(merged);\n}\n\n/**\n * Creates a flag client over a {@link FlagProvider} — one per app, module scope, shared by the Vue\n * seam ({@link FlagsProvider}) and any non-Vue caller (route guards, api-client wiring, sagas).\n *\n * ```ts\n * export const flags = createFlagClient({\n *   provider: staticFlagProvider({ newNav: { value: false, rules: [{ when: { plan: 'pro' }, value: true }] } }),\n *   onError: (error) => notify({ tone: NoticeTone.Warning, title: `flag ${error.key}: ${error.message}` }),\n * });\n *\n * flags.setContext({ targetingKey: user.id, plan: user.plan });\n * flags.getBoolean('newNav', false);\n * ```\n */\nexport function createFlagClient(options: CreateFlagClientOptions = {}): FlagClient {\n  const provider = options.provider ?? staticFlagProvider();\n  const onError = options.onError;\n  const listeners = new Set<FlagContextListener>();\n  let currentContext: EvaluationContext = options.context ? mergeContext({}, options.context) : {};\n\n  const report = (key: string, errorCode: FlagErrorCode, message: string, cause?: unknown): void => {\n    onError?.({ key, errorCode, message, cause });\n  };\n\n  /** Runs one typed evaluation end to end — the single place every failure mode is turned into a value. */\n  const core = <TValue extends FlagValue>(\n    key: string,\n    defaultValue: TValue,\n    callerContext: EvaluationContext | undefined,\n    resolve: (key: string, context: EvaluationContext) => FlagResolution<FlagValue> | undefined,\n    isValid: (value: FlagValue) => boolean,\n    typeName: string,\n  ): FlagEvaluation<TValue> => {\n    const context = callerContext ? mergeContext(currentContext, callerContext) : currentContext;\n\n    let resolution: FlagResolution<FlagValue> | undefined;\n    try {\n      resolution = resolve(key, context);\n    } catch (cause) {\n      const message = `provider \"${provider.name ?? 'unnamed'}\" threw while resolving \"${key}\"`;\n      report(key, FlagErrorCode.ProviderError, message, cause);\n      return {\n        key,\n        value: defaultValue,\n        reason: FlagReason.Error,\n        errorCode: FlagErrorCode.ProviderError,\n        errorMessage: message,\n      };\n    }\n\n    if (resolution === undefined) return { key, value: defaultValue, reason: FlagReason.Default };\n\n    if (resolution.errorCode !== undefined) {\n      const message = `provider reported \"${resolution.errorCode}\" for \"${key}\"`;\n      report(key, resolution.errorCode, message, resolution.errorMessage);\n      return {\n        key,\n        value: defaultValue,\n        reason: FlagReason.Error,\n        errorCode: resolution.errorCode,\n        errorMessage: message,\n        variant: resolution.variant,\n      };\n    }\n\n    // Gated off: the flag exists but must not apply — the caller's default stands, not the stored value.\n    if (resolution.reason === FlagReason.Disabled) {\n      return { key, value: defaultValue, reason: FlagReason.Disabled, variant: resolution.variant };\n    }\n\n    if (!isValid(resolution.value)) {\n      const message = `flag \"${key}\" resolved to ${typeof resolution.value}, expected ${typeName}`;\n      report(key, FlagErrorCode.TypeMismatch, message);\n      return {\n        key,\n        value: defaultValue,\n        reason: FlagReason.Error,\n        errorCode: FlagErrorCode.TypeMismatch,\n        errorMessage: message,\n        variant: resolution.variant,\n      };\n    }\n\n    // The only cast in the evaluation path, and `isValid` is what earns it: the runtime type of the\n    // resolved value has just been checked against the type `TValue` was inferred from.\n    return {\n      key,\n      value: resolution.value as TValue,\n      reason: resolution.reason ?? FlagReason.Static,\n      variant: resolution.variant,\n    };\n  };\n\n  const isBoolean = (value: FlagValue): boolean => typeof value === 'boolean';\n  const isString = (value: FlagValue): boolean => typeof value === 'string';\n  const isNumber = (value: FlagValue): boolean => typeof value === 'number' && Number.isFinite(value);\n  const isJsonObject = (value: FlagValue): boolean =>\n    typeof value === 'object' && value !== null && !Array.isArray(value);\n\n  const evaluateBoolean = (key: string, defaultValue: boolean, context?: EvaluationContext): FlagEvaluation<boolean> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, 'boolean');\n\n  const evaluateString = (key: string, defaultValue: string, context?: EvaluationContext): FlagEvaluation<string> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, 'string');\n\n  const evaluateNumber = (key: string, defaultValue: number, context?: EvaluationContext): FlagEvaluation<number> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, 'number');\n\n  const evaluateObject = <TValue extends JsonObject>(\n    key: string,\n    defaultValue: TValue,\n    context?: EvaluationContext,\n  ): FlagEvaluation<TValue> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, 'object');\n\n  const evaluate = <TValue extends FlagValue>(\n    key: string,\n    defaultValue: TValue,\n    context?: EvaluationContext,\n  ): FlagEvaluation<TValue> => {\n    if (typeof defaultValue === 'boolean')\n      return core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, 'boolean');\n    if (typeof defaultValue === 'string')\n      return core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, 'string');\n    if (typeof defaultValue === 'number')\n      return core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, 'number');\n    if (isJsonObject(defaultValue))\n      return core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, 'object');\n\n    // Unreachable from TypeScript (`FlagValue` covers the four cases above) — reachable from untyped\n    // JS passing `null` / an array / a function as the default. Still total: hand it straight back.\n    const message = `flag \"${key}\" was given a ${typeof defaultValue} default, expected boolean, string, number, or object`;\n    report(key, FlagErrorCode.InvalidDefault, message);\n    return {\n      key,\n      value: defaultValue,\n      reason: FlagReason.Error,\n      errorCode: FlagErrorCode.InvalidDefault,\n      errorMessage: message,\n    };\n  };\n\n  const notifyProvider = (context: EvaluationContext): void => {\n    const hook = provider.onContextChange;\n    if (hook === undefined) return;\n    const fail = (cause: unknown): void =>\n      report(\n        '',\n        FlagErrorCode.ProviderError,\n        `provider \"${provider.name ?? 'unnamed'}\" failed handling the context change`,\n        cause,\n      );\n    try {\n      const pending = hook.call(provider, context);\n      // a rejected refetch must not become an unhandled rejection\n      if (pending !== undefined)\n        void Promise.resolve(pending)\n          .then(() => {\n            if (currentContext === context) {\n              for (const listener of [...listeners]) listener(context);\n            }\n          }, fail)\n          .catch(fail);\n    } catch (cause) {\n      fail(cause);\n    }\n  };\n\n  return {\n    provider,\n\n    getBoolean: (key, defaultValue, context) => evaluateBoolean(key, defaultValue, context).value,\n    getString: (key, defaultValue, context) => evaluateString(key, defaultValue, context).value,\n    getNumber: (key, defaultValue, context) => evaluateNumber(key, defaultValue, context).value,\n\n    // Generic method shorthand, not an arrow: a non-generic arrow contextually typed by a generic\n    // signature widens `TValue` to its constraint and the return no longer narrows back.\n    getObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue {\n      return evaluateObject(key, defaultValue, context).value;\n    },\n\n    evaluateBoolean,\n    evaluateString,\n    evaluateNumber,\n    evaluateObject,\n\n    getValue<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue {\n      return evaluate(key, defaultValue, context).value;\n    },\n    evaluate,\n\n    getContext: () => currentContext,\n\n    setContext(context: EvaluationContext): void {\n      const next = mergeContext(currentContext, context);\n      if (contextsEqual(currentContext, next)) return; // no-op merge — a per-render context literal costs nothing\n      currentContext = next;\n      try {\n        notifyProvider(next);\n      } finally {\n        for (const listener of [...listeners]) listener(next);\n      }\n    },\n\n    subscribe(listener: FlagContextListener): () => void {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n}\n","import {\n  computed,\n  inject,\n  provide,\n  ref,\n  toValue,\n  watch,\n  type ComputedRef,\n  type InjectionKey,\n  type MaybeRefOrGetter,\n  type Ref,\n} from 'vue';\n\nimport { createFlagClient, type FlagClient } from '../FlagClient';\nimport type { FlagValue, JsonObject, EvaluationContext } from '../FlagTypes';\n\n/*\n * The Vue seam over `FlagClient` — the provide/inject + composable pattern used by\n * `foundation/primitives`' `DirectionProvider`, including its standalone fallback: `useFlag` works\n * with no provider mounted (every flag returns the caller's default), so an SDK component may read\n * a flag without forcing every consuming app to wire one.\n *\n * NOTE ON NAMING: `FlagsProvider` (plural) is the Vue component in `FlagsProvider.vue`;\n * `FlagProvider` (singular, `FlagProvider.ts`) is the backend adapter it evaluates against. Same\n * split as OpenFeature.\n *\n * RE-EVALUATION ON CONTEXT CHANGE. The client is created once and never re-created — swapping it\n * mid-life would drop its subscribers — so a context change cannot propagate by client identity.\n * Instead the provider subscribes to the client and bumps a `revision` ref; every `useFlag` computed\n * reads that ref, so a context change invalidates all of them at once. Evaluation is a synchronous\n * map lookup, so the computed re-evaluates on read with no extra bookkeeping, and never goes stale.\n *\n * NARROWING. The revision is a ref read inside each `useFlag` computed rather than a value carried\n * by the context, so only the flags actually read are re-evaluated, and only the components that\n * depend on a CHANGED flag re-render — Vue's dependency graph does the narrowing.\n */\n\n/** The active client plus the counter that re-evaluates consumers when the evaluation context moves. */\ninterface FlagsContextValue {\n  /** The client in force. A computed, so a swapped `client` prop still reaches every consumer. */\n  readonly client: ComputedRef<FlagClient>;\n\n  /** Bumped on every context change — what invalidates each `useFlag` computed. */\n  readonly revision: Ref<number>;\n}\n\n/**\n * The injection key for the flags context; the standalone fallback is resolved at the injection\n * site. Deliberately NOT re-exported from `index.ts` — the context stays module-private.\n */\nconst FlagsKey: InjectionKey<FlagsContextValue> = Symbol('wow-two.flags');\n\n/**\n * Backs the composables when no `FlagsProvider` is mounted — an empty static provider, so every flag\n * returns the caller's default. Each injection fallback gets its own client, isolating app-root context.\n */\nfunction standaloneContext(): FlagsContextValue {\n  const client = createFlagClient();\n  return { client: computed(() => client), revision: ref(0) };\n}\n\n/**\n * The provider half — used by `FlagsProvider`, and by any component that owns a flag client.\n * Subscribes to the client and re-subscribes if the active client is swapped, disposing the previous\n * subscription through the watcher's `onCleanup`.\n *\n * Pass `client` as a getter (`() => props.client ?? ownClient`) so the active client stays tracked.\n */\nexport function provideFlags(client: MaybeRefOrGetter<FlagClient>): void {\n  const active = computed(() => toValue(client));\n  const revision = ref(0);\n\n  // A watcher owns the subscription and bumps `revision`. `immediate` is safe under SSR —\n  // `subscribe` only adds to a Set and touches no browser global.\n  watch(\n    active,\n    (current, _previous, onCleanup) => {\n      onCleanup(current.subscribe(() => (revision.value += 1)));\n    },\n    { immediate: true },\n  );\n\n  provide(FlagsKey, { client: active, revision });\n}\n\n/** Resolves the surrounding flags context, or the standalone fallback when no provider is mounted. */\nfunction resolveFlags(): FlagsContextValue {\n  return inject(FlagsKey, standaloneContext, true);\n}\n\n/**\n * Reads the flag client. Works without a {@link FlagsProvider} — falls back to an empty one, where\n * every flag returns the caller's default.\n *\n * Returns a stable facade whose commands reach the current provider client. Use it for imperative reads\n * and `setContext`; for a value that\n * must re-evaluate when the evaluation context moves, use {@link useFlag}, whose computed is the\n * reactive path.\n */\nexport function useFlags(): FlagClient {\n  const { client } = resolveFlags();\n  return {\n    get provider() {\n      return client.value.provider;\n    },\n    getBoolean: (...args) => client.value.getBoolean(...args),\n    getString: (...args) => client.value.getString(...args),\n    getNumber: (...args) => client.value.getNumber(...args),\n    getObject<TValue extends JsonObject>(key: string, fallback: TValue, context?: EvaluationContext): TValue {\n      return client.value.getObject(key, fallback, context);\n    },\n    evaluateBoolean: (...args) => client.value.evaluateBoolean(...args),\n    evaluateString: (...args) => client.value.evaluateString(...args),\n    evaluateNumber: (...args) => client.value.evaluateNumber(...args),\n    evaluateObject<TValue extends JsonObject>(key: string, fallback: TValue, context?: EvaluationContext) {\n      return client.value.evaluateObject(key, fallback, context);\n    },\n    getValue<TValue extends FlagValue>(key: string, fallback: TValue, context?: EvaluationContext): TValue {\n      return client.value.getValue(key, fallback, context);\n    },\n    evaluate<TValue extends FlagValue>(key: string, fallback: TValue, context?: EvaluationContext) {\n      return client.value.evaluate(key, fallback, context);\n    },\n    getContext: () => client.value.getContext(),\n    setContext: (context) => client.value.setContext(context),\n    subscribe: (listener) =>\n      watch(\n        client,\n        (current, _previous, cleanup) => {\n          cleanup(current.subscribe(listener));\n        },\n        { immediate: true, flush: 'sync' },\n      ),\n  };\n}\n\n/**\n * Reads one flag's value, re-evaluating whenever the evaluation context changes. The typed path is\n * picked from `defaultValue`, which also types the result — `useFlag('newNav', false)` is\n * `ComputedRef<boolean>`, `useFlag('limits', { max: 10 })` is a computed of that object type.\n *\n * Returns a `ComputedRef<TValue>` rather than a bare value, because a bare value could never\n * re-evaluate. `key` and `defaultValue` may each be a ref or getter — changing either re-evaluates\n * the flag.\n */\nexport function useFlag<TValue extends FlagValue>(\n  key: MaybeRefOrGetter<string>,\n  defaultValue: MaybeRefOrGetter<TValue>,\n): ComputedRef<TValue> {\n  const { client, revision } = resolveFlags();\n  return computed<TValue>(() => {\n    // `revision` is the dependency that re-evaluates this flag when the evaluation context moves.\n    // Read through `void` rather than discarded into a binding — the read IS the subscription.\n    void revision.value;\n    return client.value.getValue(toValue(key), toValue(defaultValue));\n  });\n}\n","<script lang=\"ts\">\nimport type { FlagClient, FlagErrorListener } from '../FlagClient';\nimport type { FlagProvider } from '../FlagProvider';\nimport type { EvaluationContext } from '../FlagTypes';\n\n/** Defines the props for {@link FlagsProvider}. */\nexport interface FlagsProviderProps {\n  /** An existing client to serve, shared with non-Vue callers. Takes precedence over `provider` / `onError`. */\n  readonly client?: FlagClient;\n\n  /** The flag source to build a client around, when no `client` is passed. Read once, at setup. */\n  readonly provider?: FlagProvider;\n\n  /** The evaluation context. Kept in sync on every change — a fresh object literal per render is safe. */\n  readonly context?: EvaluationContext;\n\n  /** Receives evaluation faults, when no `client` is passed. Read once, at setup. */\n  readonly onError?: FlagErrorListener;\n}\n</script>\n\n<script setup lang=\"ts\">\nimport { watch } from 'vue';\n\nimport { createFlagClient } from '../FlagClient';\nimport { provideFlags } from './FlagsContext';\n\n/**\n * Renders no element of its own — the slot passes straight through, matching `DirectionProvider` — while\n * providing flag evaluation to every descendant and re-evaluating them whenever the evaluation context\n * changes, including changes made imperatively through `client.setContext(…)` outside Vue.\n */\ndefineOptions({ name: 'FlagsProvider' });\n\ndefineSlots<{\n  /** The subtree whose flag evaluations read this client. */\n  default(): unknown;\n}>();\n\nconst props = defineProps<FlagsProviderProps>();\n\n// `setup` runs exactly once per instance, which is precisely what React's lazy `useState`\n// initializer was working around — the client must be created once for the component's life, and a\n// `computed` would be allowed to drop and re-run it.\nconst ownClient =\n  props.client ?? createFlagClient({ provider: props.provider, context: props.context, onError: props.onError });\n\n// A getter, not a snapshot: a swapped `client` prop re-subscribes and reaches every consumer.\nprovideFlags(() => props.client ?? ownClient);\n\n// The `context` prop syncs in through a watcher rather than at construction, so a fresh object\n// literal per render is safe: `setContext` no-ops when the merge changes nothing, so a parent that\n// rebuilds its context literal every render neither refetches nor re-evaluates flag consumers.\n//\n// `immediate` lands the context during setup, BEFORE descendants first evaluate — where React's\n// effect ran after mount, so a passed-in `client` briefly evaluated against a stale targeting\n// context and every gated element could flash. SSR-safe: `setContext` touches no browser global.\nwatch(\n  [() => props.client ?? ownClient, () => props.context],\n  ([client, context]) => {\n    if (context !== undefined) client.setContext(context);\n  },\n  { immediate: true },\n);\n</script>\n\n<template>\n  <slot />\n</template>\n"],"names":["_renderSlot"],"mappings":"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"}

package/dist/flags/providers/FlagsContext.d.ts

@@ -0,0 +1,31 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+import { FlagClient } from '../FlagClient';
+import { FlagValue } from '../FlagTypes';
+/**
+ * The provider half — used by `FlagsProvider`, and by any component that owns a flag client.
+ * Subscribes to the client and re-subscribes if the active client is swapped, disposing the previous
+ * subscription through the watcher's `onCleanup`.
+ *
+ * Pass `client` as a getter (`() => props.client ?? ownClient`) so the active client stays tracked.
+ */
+export declare function provideFlags(client: MaybeRefOrGetter<FlagClient>): void;
+/**
+ * Reads the flag client. Works without a {@link FlagsProvider} — falls back to an empty one, where
+ * every flag returns the caller's default.
+ *
+ * Returns a stable facade whose commands reach the current provider client. Use it for imperative reads
+ * and `setContext`; for a value that
+ * must re-evaluate when the evaluation context moves, use {@link useFlag}, whose computed is the
+ * reactive path.
+ */
+export declare function useFlags(): FlagClient;
+/**
+ * Reads one flag's value, re-evaluating whenever the evaluation context changes. The typed path is
+ * picked from `defaultValue`, which also types the result — `useFlag('newNav', false)` is
+ * `ComputedRef<boolean>`, `useFlag('limits', { max: 10 })` is a computed of that object type.
+ *
+ * Returns a `ComputedRef<TValue>` rather than a bare value, because a bare value could never
+ * re-evaluate. `key` and `defaultValue` may each be a ref or getter — changing either re-evaluates
+ * the flag.
+ */
+export declare function useFlag<TValue extends FlagValue>(key: MaybeRefOrGetter<string>, defaultValue: MaybeRefOrGetter<TValue>): ComputedRef<TValue>;

package/dist/flags/providers/FlagsProvider.vue.d.ts

@@ -0,0 +1,24 @@
+import { FlagClient, FlagErrorListener } from '../FlagClient';
+import { FlagProvider } from '../FlagProvider';
+import { EvaluationContext } from '../FlagTypes';
+/** Defines the props for {@link FlagsProvider}. */
+export interface FlagsProviderProps {
+    /** An existing client to serve, shared with non-Vue callers. Takes precedence over `provider` / `onError`. */
+    readonly client?: FlagClient;
+    /** The flag source to build a client around, when no `client` is passed. Read once, at setup. */
+    readonly provider?: FlagProvider;
+    /** The evaluation context. Kept in sync on every change — a fresh object literal per render is safe. */
+    readonly context?: EvaluationContext;
+    /** Receives evaluation faults, when no `client` is passed. Read once, at setup. */
+    readonly onError?: FlagErrorListener;
+}
+declare const _default: __VLS_WithSlots<import('vue').DefineComponent<FlagsProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FlagsProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    /** The subtree whose flag evaluations read this client. */
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};