@avsbhq/vue 1.0.2 → 1.1.1

package/dist/index.cjs

@@ -18,227 +18,243 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   AvsbInjectionKey: () => AvsbInjectionKey,
   AvsbPlugin: () => AvsbPlugin,
   AvsbProvider: () => AvsbProvider,
+  DecideOption: () => import_core2.DecideOption,
   useAlias: () => useAlias,
   useAllFlags: () => useAllFlags,
   useAvsbClient: () => useAvsbClient,
-  useAvsbStore: () => useAvsbStore,
+  useAvsbStatus: () => useAvsbStatus,
   useBoolFlag: () => useBoolFlag,
+  useExposure: () => useExposure,
   useFlag: () => useFlag,
   useFlagReady: () => useFlagReady,
+  useFlagSubscription: () => useFlagSubscription,
   useFlagValue: () => useFlagValue,
   useIdentify: () => useIdentify,
   useJsonFlag: () => useJsonFlag,
   useNumberFlag: () => useNumberFlag,
+  useReset: () => useReset,
   useStringFlag: () => useStringFlag,
   useTrack: () => useTrack
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/AvsbProvider.ts
-var import_vue2 = require("vue");
-var import_browser = require("@avsbhq/browser");
+var import_vue3 = require("vue");
+var import_browser2 = require("@avsbhq/browser");
+var import_core = require("@avsbhq/core");
 
 // src/context.ts
 var import_vue = require("vue");
 var AvsbInjectionKey = /* @__PURE__ */ Symbol("avsb-injection-key");
 function useAvsbContext() {
-  const v = (0, import_vue.inject)(AvsbInjectionKey);
-  if (v === void 0) {
+  const value = (0, import_vue.inject)(AvsbInjectionKey);
+  if (value === void 0) {
     throw new Error(
-      '[avsb] composables must be used inside <AvsbProvider> or app.use(AvsbPlugin). Wrap your component tree with <AvsbProvider sdkKey="..." context={...}> or install the plugin.'
+      `[avsb] composables must be used inside <AvsbProvider> or app.use(AvsbPlugin). Wrap your component tree with <AvsbProvider sdk-key="sdk_production_..." :context="{ kind: 'user', key: userId }">, or install the plugin with app.use(AvsbPlugin, { sdkKey: 'sdk_production_...' }).`
     );
   }
-  return v;
+  return value;
+}
+function hasAvsbContext() {
+  return (0, import_vue.inject)(AvsbInjectionKey, null) !== null;
+}
+
+// src/internal/providerState.ts
+var import_vue2 = require("vue");
+var UNEXPLAINED_FAILURE = "[avsb] the SDK could not load a datafile and nothing was cached or bootstrapped, so every flag is returning the default you passed. Check the SDK key on app.avsb.cloud under Environments in the project sidebar.";
+function createProviderState(client) {
+  const status = (0, import_vue2.ref)(client.isReady() ? "ready" : "loading");
+  const error = (0, import_vue2.shallowRef)(void 0);
+  const degraded = (0, import_vue2.ref)(false);
+  let stopped = false;
+  const applyInitResult = (result) => {
+    if (stopped) return;
+    if (result.success) {
+      status.value = "ready";
+      degraded.value = result.degraded === true;
+      error.value = result.error;
+      return;
+    }
+    status.value = "error";
+    error.value = result.error ?? new Error(UNEXPLAINED_FAILURE);
+  };
+  const settled = client.getInitResult();
+  if (settled) {
+    applyInitResult(settled);
+  } else {
+    void client.onReady().then(applyInitResult);
+  }
+  const offError = client.on("error", (e) => {
+    if (stopped) return;
+    error.value = e;
+    if (client.isReady()) {
+      degraded.value = true;
+      return;
+    }
+    status.value = "error";
+  });
+  const offReady = client.on("ready", applyInitResult);
+  return {
+    status,
+    error,
+    degraded,
+    stop: () => {
+      stopped = true;
+      offError();
+      offReady();
+    }
+  };
+}
+
+// src/internal/resolveClient.ts
+var import_browser = require("@avsbhq/browser");
+var MISUSE_MESSAGE = `[avsb] <AvsbProvider> needs either an sdk-key (Mode A) or a client (Mode B). Mode A: <AvsbProvider sdk-key="sdk_production_..." :context="{ kind: 'user', key: userId }">. Mode B: <AvsbProvider :client="myClient">. The key for each environment is on app.avsb.cloud under Environments in the project sidebar.`;
+function resolveClient(props) {
+  const injected = props.client;
+  if (injected !== void 0 && injected !== null) {
+    return { client: injected, owned: false };
+  }
+  const { sdkKey, context, bootstrap, options } = props;
+  if (typeof sdkKey !== "string" || sdkKey.length === 0) {
+    throw new Error(MISUSE_MESSAGE);
+  }
+  const clientOptions = {
+    ...options ?? {},
+    sdkKey,
+    ...context !== void 0 ? { context } : {},
+    ...bootstrap !== void 0 ? { bootstrap } : {}
+  };
+  return { client: new import_browser.AvsbClient(clientOptions), owned: true };
 }
 
 // src/AvsbProvider.ts
-var AvsbProvider = (0, import_vue2.defineComponent)({
+var NESTED_PROVIDER_WARNING = "[avsb] <AvsbProvider> is nested inside another <AvsbProvider>. The inner one shadows the outer for everything below it, so two clients are now running, each with its own visitor id and its own event queue. Mount one provider at the root of the app unless you meant to isolate a subtree.";
+var AvsbProvider = (0, import_vue3.defineComponent)({
   name: "AvsbProvider",
   props: {
-    // Mode B — caller passes a pre-built client
+    /** Mode B: a client you built and own. */
     client: {
       type: Object,
       default: void 0
     },
-    // Mode A — sdkKey is the minimum required field from AvsbClientOptions
+    /** Mode A: the environment's SDK key. */
     sdkKey: {
       type: String,
       default: void 0
+    },
+    /** Mode A: evaluation context. Omit for an anonymous visitor. */
+    context: {
+      type: Object,
+      default: void 0
+    },
+    /** Mode A: a datafile fetched on the server, for a real first paint. */
+    bootstrap: {
+      type: Object,
+      default: void 0
+    },
+    /** Mode A: everything else AvsbClient accepts. */
+    options: {
+      type: Object,
+      default: void 0
     }
   },
-  // Accept any additional option props (pollingInterval, bootstrap, etc.)
-  // via inheritAttrs + $attrs so callers can pass the full AvsbClientOptions
-  // surface without enumerating every field as a prop.
-  inheritAttrs: false,
-  setup(props, { slots, attrs }) {
-    const injectedClient = props.client ?? null;
-    const isInjectionMode = injectedClient !== null;
-    let ownedClient = null;
-    if (!isInjectionMode) {
-      if (!props.sdkKey) {
-        throw new Error(
-          "[avsb] <AvsbProvider> requires either a `client` prop (Mode B) or a `sdkKey` prop (Mode A)."
-        );
-      }
-      const opts = {
-        sdkKey: props.sdkKey,
-        ...attrs
-      };
-      ownedClient = new import_browser.AvsbClient(opts);
+  setup(props, { slots }) {
+    if (hasAvsbContext() && (0, import_browser2.isDevEnvironment)()) {
+      (0, import_core.consoleLogger)("warn").warn(NESTED_PROVIDER_WARNING);
     }
-    const activeClient = isInjectionMode ? injectedClient : ownedClient;
-    const status = (0, import_vue2.ref)("loading");
-    const error = (0, import_vue2.ref)(void 0);
-    (0, import_vue2.provide)(AvsbInjectionKey, {
-      get client() {
-        return activeClient;
-      },
+    const { client, owned } = resolveClient(props);
+    const state = createProviderState(client);
+    (0, import_vue3.provide)(AvsbInjectionKey, {
+      client,
       get status() {
-        return status.value;
+        return state.status.value;
       },
       get error() {
-        return error.value;
-      }
-    });
-    let cancelled = false;
-    let unsubscribeError;
-    (0, import_vue2.onMounted)(() => {
-      if (!activeClient) return;
-      activeClient.onReady().then(() => {
-        if (!cancelled) status.value = "ready";
-      }).catch((err) => {
-        if (!cancelled) {
-          status.value = "error";
-          error.value = err instanceof Error ? err : new Error(String(err));
-        }
-      });
-      if (typeof activeClient.on === "function") {
-        unsubscribeError = activeClient.on("error", (e) => {
-          if (!cancelled) {
-            status.value = "error";
-            error.value = e;
-          }
-        });
+        return state.error.value;
+      },
+      get degraded() {
+        return state.degraded.value;
       }
     });
-    (0, import_vue2.onUnmounted)(() => {
-      cancelled = true;
-      unsubscribeError?.();
-      if (!isInjectionMode && ownedClient) {
-        ownedClient.close().catch(() => {
-        });
-        ownedClient = null;
-      }
+    (0, import_vue3.onUnmounted)(() => {
+      state.stop();
+      if (owned) void client.close();
     });
     return () => slots.default?.();
-  },
-  render() {
-    return (0, import_vue2.h)("div");
   }
 });
 
 // src/plugin.ts
-var import_vue3 = require("vue");
-var import_browser2 = require("@avsbhq/browser");
 var AvsbPlugin = {
   install(app, options) {
-    const injectedClient = "client" in options && options.client ? options.client : null;
-    const isInjectionMode = injectedClient !== null;
-    let activeClient;
-    if (isInjectionMode) {
-      activeClient = injectedClient;
-    } else {
-      const opts = options;
-      activeClient = new import_browser2.AvsbClient(opts);
-    }
-    const status = (0, import_vue3.ref)("loading");
-    const error = (0, import_vue3.ref)(void 0);
+    const { sdkKey, context, bootstrap, client: injected, ...rest } = options;
+    const { client, owned } = resolveClient({
+      ...injected ? { client: injected } : { sdkKey },
+      ...context !== void 0 ? { context } : {},
+      ...bootstrap !== void 0 ? { bootstrap } : {},
+      options: rest
+    });
+    const state = createProviderState(client);
     app.provide(AvsbInjectionKey, {
-      get client() {
-        return activeClient;
-      },
+      client,
       get status() {
-        return status.value;
+        return state.status.value;
       },
       get error() {
-        return error.value;
+        return state.error.value;
+      },
+      get degraded() {
+        return state.degraded.value;
       }
     });
-    activeClient.onReady().then(() => {
-      status.value = "ready";
-    }).catch((err) => {
-      status.value = "error";
-      error.value = err instanceof Error ? err : new Error(String(err));
-    });
-    if (typeof activeClient.on === "function") {
-      activeClient.on("error", (e) => {
-        status.value = "error";
-        error.value = e;
-      });
-    }
-    if (!isInjectionMode) {
-      app.unmount = new Proxy(app.unmount, {
-        apply(target, thisArg, args) {
-          activeClient.close().catch(() => {
-          });
-          return Reflect.apply(target, thisArg, args);
-        }
-      });
-    }
+    const unmount = app.unmount.bind(app);
+    app.unmount = () => {
+      state.stop();
+      if (owned) void client.close();
+      unmount();
+    };
   }
 };
 
-// src/composables/useFlag.ts
+// src/internal/bindFlagRef.ts
 var import_vue4 = require("vue");
-var import_core = require("@avsbhq/core");
-function useFlag(flagKey, defaultValue) {
-  const { client } = useAvsbContext();
-  const noClientSentinel = (0, import_core.notFoundFlag)(defaultValue, "no client");
-  const flagRef = (0, import_vue4.ref)(
-    client !== null && typeof client.getSnapshot === "function" ? client.getSnapshot(
-      (0, import_vue4.isRef)(flagKey) ? flagKey.value : flagKey,
-      defaultValue
-    ) : noClientSentinel
-  );
-  let unsub;
-  function resubscribe() {
-    unsub?.();
-    unsub = void 0;
-    if (!client || typeof client.subscribe !== "function") return;
-    const key = (0, import_vue4.isRef)(flagKey) ? flagKey.value : flagKey;
-    if (typeof client.getSnapshot === "function") {
-      flagRef.value = client.getSnapshot(key, defaultValue);
-    }
-    unsub = client.subscribe(key, () => {
-      if (typeof client.getSnapshot === "function") {
-        flagRef.value = client.getSnapshot(
-          (0, import_vue4.isRef)(flagKey) ? flagKey.value : flagKey,
-          defaultValue
-        );
-      }
+var RENDER_SAFE = { readOnly: true };
+function resolveFlagKey(flagKey) {
+  return (0, import_vue4.isRef)(flagKey) ? flagKey.value : flagKey;
+}
+function bindFlagRef(client, flagKey, read) {
+  const current = (0, import_vue4.shallowRef)(read(client, resolveFlagKey(flagKey)));
+  let unsubscribe;
+  const subscribe = (key) => {
+    unsubscribe?.();
+    current.value = read(client, key);
+    unsubscribe = client.subscribe(key, () => {
+      current.value = read(client, key);
     });
-  }
-  let stopWatcher;
-  (0, import_vue4.onMounted)(() => {
-    if ((0, import_vue4.isRef)(flagKey)) {
-      stopWatcher = (0, import_vue4.watchEffect)(() => {
-        void flagKey.value;
-        resubscribe();
-      });
-    } else {
-      resubscribe();
-    }
-  });
-  (0, import_vue4.onUnmounted)(() => {
+  };
+  subscribe(resolveFlagKey(flagKey));
+  const stopWatcher = (0, import_vue4.isRef)(flagKey) ? (0, import_vue4.watch)(flagKey, (next) => subscribe(next), { flush: "sync" }) : void 0;
+  (0, import_vue4.onScopeDispose)(() => {
     stopWatcher?.();
-    unsub?.();
+    unsubscribe?.();
+    unsubscribe = void 0;
   });
-  return (0, import_vue4.computed)(() => flagRef.value);
+  return (0, import_vue4.computed)(() => current.value);
+}
+
+// src/composables/useFlag.ts
+function useFlag(flagKey, defaultValue) {
+  const { client } = useAvsbContext();
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getSnapshot(key, defaultValue)
+  );
 }
 
 // src/composables/useFlagValue.ts
@@ -249,274 +265,191 @@ function useFlagValue(flagKey, defaultValue) {
 }
 
 // src/composables/useBoolFlag.ts
-var import_vue6 = require("vue");
-var import_core2 = require("@avsbhq/core");
 function useBoolFlag(flagKey, defaultValue) {
   const { client } = useAvsbContext();
-  const noClientSentinel = (0, import_core2.notFoundFlag)(defaultValue, "no client");
-  const flagRef = (0, import_vue6.ref)(
-    client !== null && typeof client.getBoolFlag === "function" ? client.getBoolFlag(flagKey, defaultValue) : noClientSentinel
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getBoolFlag(key, defaultValue, RENDER_SAFE)
   );
-  let unsub;
-  (0, import_vue6.onMounted)(() => {
-    if (!client || typeof client.subscribe !== "function") return;
-    if (typeof client.getBoolFlag === "function") {
-      flagRef.value = client.getBoolFlag(flagKey, defaultValue);
-    }
-    unsub = client.subscribe(flagKey, () => {
-      if (typeof client.getBoolFlag === "function") {
-        flagRef.value = client.getBoolFlag(flagKey, defaultValue);
-      }
-    });
-  });
-  (0, import_vue6.onUnmounted)(() => {
-    unsub?.();
-  });
-  return (0, import_vue6.computed)(() => flagRef.value);
 }
 
 // src/composables/useStringFlag.ts
-var import_vue7 = require("vue");
-var import_core3 = require("@avsbhq/core");
 function useStringFlag(flagKey, defaultValue) {
   const { client } = useAvsbContext();
-  const noClientSentinel = (0, import_core3.notFoundFlag)(defaultValue, "no client");
-  const flagRef = (0, import_vue7.ref)(
-    client !== null && typeof client.getStringFlag === "function" ? client.getStringFlag(flagKey, defaultValue) : noClientSentinel
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getStringFlag(key, defaultValue, RENDER_SAFE)
   );
-  let unsub;
-  (0, import_vue7.onMounted)(() => {
-    if (!client || typeof client.subscribe !== "function") return;
-    if (typeof client.getStringFlag === "function") {
-      flagRef.value = client.getStringFlag(flagKey, defaultValue);
-    }
-    unsub = client.subscribe(flagKey, () => {
-      if (typeof client.getStringFlag === "function") {
-        flagRef.value = client.getStringFlag(flagKey, defaultValue);
-      }
-    });
-  });
-  (0, import_vue7.onUnmounted)(() => {
-    unsub?.();
-  });
-  return (0, import_vue7.computed)(() => flagRef.value);
 }
 
 // src/composables/useNumberFlag.ts
-var import_vue8 = require("vue");
-var import_core4 = require("@avsbhq/core");
 function useNumberFlag(flagKey, defaultValue) {
   const { client } = useAvsbContext();
-  const noClientSentinel = (0, import_core4.notFoundFlag)(defaultValue, "no client");
-  const flagRef = (0, import_vue8.ref)(
-    client !== null && typeof client.getNumberFlag === "function" ? client.getNumberFlag(flagKey, defaultValue) : noClientSentinel
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getNumberFlag(key, defaultValue, RENDER_SAFE)
   );
-  let unsub;
-  (0, import_vue8.onMounted)(() => {
-    if (!client || typeof client.subscribe !== "function") return;
-    if (typeof client.getNumberFlag === "function") {
-      flagRef.value = client.getNumberFlag(flagKey, defaultValue);
-    }
-    unsub = client.subscribe(flagKey, () => {
-      if (typeof client.getNumberFlag === "function") {
-        flagRef.value = client.getNumberFlag(flagKey, defaultValue);
-      }
-    });
-  });
-  (0, import_vue8.onUnmounted)(() => {
-    unsub?.();
-  });
-  return (0, import_vue8.computed)(() => flagRef.value);
 }
 
 // src/composables/useJsonFlag.ts
-var import_vue9 = require("vue");
-var import_core5 = require("@avsbhq/core");
 function useJsonFlag(flagKey, defaultValue) {
   const { client } = useAvsbContext();
-  const noClientSentinel = (0, import_core5.notFoundFlag)(defaultValue, "no client");
-  const flagRef = (0, import_vue9.ref)(
-    client !== null && typeof client.getJsonFlag === "function" ? client.getJsonFlag(flagKey, defaultValue) : noClientSentinel
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getJsonFlag(key, defaultValue, RENDER_SAFE)
   );
-  let unsub;
-  (0, import_vue9.onMounted)(() => {
-    if (!client || typeof client.subscribe !== "function") return;
-    if (typeof client.getJsonFlag === "function") {
-      flagRef.value = client.getJsonFlag(flagKey, defaultValue);
-    }
-    unsub = client.subscribe(flagKey, () => {
-      if (typeof client.getJsonFlag === "function") {
-        flagRef.value = client.getJsonFlag(flagKey, defaultValue);
-      }
-    });
-  });
-  (0, import_vue9.onUnmounted)(() => {
-    unsub?.();
-  });
-  return (0, import_vue9.computed)(() => flagRef.value);
 }
 
 // src/composables/useAllFlags.ts
-var import_vue10 = require("vue");
+var import_vue6 = require("vue");
 function useAllFlags() {
   const { client } = useAvsbContext();
-  const snapshotRef = (0, import_vue10.ref)(
-    client !== null && typeof client.getAllFlags === "function" ? client.getAllFlags() : {}
-  );
-  let unsub;
-  (0, import_vue10.onMounted)(() => {
-    if (!client || typeof client.on !== "function") return;
-    if (typeof client.getAllFlags === "function") {
-      snapshotRef.value = client.getAllFlags();
-    }
-    unsub = client.on("flagChange", () => {
-      if (typeof client.getAllFlags === "function") {
-        snapshotRef.value = client.getAllFlags();
-      }
-    });
-  });
-  (0, import_vue10.onUnmounted)(() => {
-    unsub?.();
+  const current = (0, import_vue6.shallowRef)(client.getAllFlags());
+  const unsubscribe = client.on("flagChange", () => {
+    current.value = client.getAllFlags();
   });
-  return (0, import_vue10.computed)(() => snapshotRef.value);
+  (0, import_vue6.onScopeDispose)(unsubscribe);
+  return (0, import_vue6.computed)(() => current.value);
 }
 
 // src/composables/useFlagReady.ts
-var import_vue11 = require("vue");
+var import_vue7 = require("vue");
 function useFlagReady() {
   const context = useAvsbContext();
-  return (0, import_vue11.computed)(() => context.status === "ready");
+  return (0, import_vue7.computed)(() => context.status === "ready");
+}
+
+// src/composables/useAvsbStatus.ts
+var import_vue8 = require("vue");
+function useAvsbStatus() {
+  const context = useAvsbContext();
+  return {
+    status: (0, import_vue8.computed)(() => context.status),
+    error: (0, import_vue8.computed)(() => context.error),
+    degraded: (0, import_vue8.computed)(() => context.degraded)
+  };
 }
 
 // src/composables/useAvsbClient.ts
 function useAvsbClient() {
-  const { client } = useAvsbContext();
-  return client;
+  return useAvsbContext().client;
 }
 
 // src/composables/useIdentify.ts
-var import_vue12 = require("vue");
 function useIdentify() {
   const { client } = useAvsbContext();
-  const clientRef = (0, import_vue12.ref)(client);
-  clientRef.value = client;
-  function identify(ctx) {
-    const c = clientRef.value;
-    if (!c || typeof c.identify !== "function") return;
-    c.identify(ctx);
-  }
-  return identify;
+  return (context) => {
+    client.identify(context);
+  };
 }
 
 // src/composables/useAlias.ts
-var import_vue13 = require("vue");
 function useAlias() {
   const { client } = useAvsbContext();
-  const clientRef = (0, import_vue13.ref)(client);
-  clientRef.value = client;
-  async function alias(prev, next) {
-    const c = clientRef.value;
-    if (!c || typeof c.alias !== "function") return;
-    await c.alias(prev, next);
-  }
-  return alias;
+  return (previousContext, newContext) => {
+    client.alias(previousContext, newContext);
+  };
+}
+
+// src/composables/useReset.ts
+function useReset() {
+  const { client } = useAvsbContext();
+  return () => {
+    client.reset();
+  };
 }
 
 // src/composables/useTrack.ts
-var import_vue14 = require("vue");
 function useTrack() {
   const { client } = useAvsbContext();
-  const clientRef = (0, import_vue14.ref)(client);
-  clientRef.value = client;
-  function track(eventKey, payload) {
-    const c = clientRef.value;
-    if (!c || typeof c.track !== "function") return;
-    c.track(eventKey, payload);
+  return (eventKey, payload) => {
+    client.track(eventKey, payload);
+  };
+}
+
+// src/composables/useExposure.ts
+var import_vue9 = require("vue");
+
+// src/internal/fireExposure.ts
+function fireExposureWhenReady(client, flagKey) {
+  if (client.isReady()) {
+    client.getFlag(flagKey, null);
+    return () => {
+    };
   }
-  return track;
+  const off = client.on("ready", () => {
+    client.getFlag(flagKey, null);
+    off();
+  });
+  return off;
 }
 
-// src/pinia.ts
-var import_pinia = require("pinia");
-var import_vue15 = require("vue");
-var import_vue16 = require("vue");
-var useAvsbStore = (0, import_pinia.defineStore)("avsb", () => {
-  const injectedContext = (0, import_vue16.inject)(AvsbInjectionKey);
-  const _client = (0, import_vue15.ref)(injectedContext?.client ?? null);
-  const _status = (0, import_vue15.ref)(
-    injectedContext?.status ?? "loading"
-  );
-  const _error = (0, import_vue15.ref)(injectedContext?.error);
-  if (injectedContext) {
+// src/composables/useExposure.ts
+function useExposure(flagKey) {
+  const { client } = useAvsbContext();
+  let cancel;
+  const fire = (key) => {
+    cancel?.();
+    cancel = fireExposureWhenReady(client, key);
+  };
+  (0, import_vue9.onMounted)(() => {
+    fire(resolveFlagKey(flagKey));
+  });
+  if (typeof flagKey !== "string") {
+    (0, import_vue9.watch)(flagKey, (next) => fire(next));
   }
-  const client = (0, import_vue15.computed)(
-    () => injectedContext ? injectedContext.client : _client.value
-  );
-  const status = (0, import_vue15.computed)(
-    () => injectedContext ? injectedContext.status : _status.value
-  );
-  const error = (0, import_vue15.computed)(
-    () => injectedContext ? injectedContext.error : _error.value
-  );
-  function setClient(c) {
-    _client.value = c;
-    _status.value = "loading";
-    _error.value = void 0;
-    if (!c) return;
-    c.onReady().then(() => {
-      _status.value = "ready";
-    }).catch((err) => {
-      _status.value = "error";
-      _error.value = err instanceof Error ? err : new Error(String(err));
+  (0, import_vue9.onUnmounted)(() => {
+    cancel?.();
+    cancel = void 0;
+  });
+}
+
+// src/composables/useFlagSubscription.ts
+var import_vue10 = require("vue");
+function useFlagSubscription(flagKey, callback) {
+  const { client } = useAvsbContext();
+  let unsubscribe;
+  const subscribe = (key) => {
+    unsubscribe?.();
+    unsubscribe = client.subscribe(key, () => {
+      callback(client.getSnapshot(key, void 0));
     });
-  }
-  function identify(ctx) {
-    const c = client.value;
-    if (!c || typeof c.identify !== "function") return;
-    c.identify(ctx);
-  }
-  function track(eventKey, payload) {
-    const c = client.value;
-    if (!c || typeof c.track !== "function") return;
-    c.track(eventKey, payload);
-  }
-  async function alias(prev, next) {
-    const c = client.value;
-    if (!c || typeof c.alias !== "function") return;
-    await c.alias(prev, next);
-  }
-  function reset() {
-    const c = client.value;
-    if (!c || typeof c.reset !== "function") return;
-    c.reset();
-  }
-  return {
-    client,
-    status,
-    error,
-    setClient,
-    identify,
-    track,
-    alias,
-    reset
   };
-});
+  subscribe(resolveFlagKey(flagKey));
+  const stopWatcher = typeof flagKey === "string" ? void 0 : (0, import_vue10.watch)(flagKey, (next) => subscribe(next), { flush: "sync" });
+  (0, import_vue10.onScopeDispose)(() => {
+    stopWatcher?.();
+    unsubscribe?.();
+    unsubscribe = void 0;
+  });
+}
+
+// src/index.ts
+var import_core2 = require("@avsbhq/core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AvsbInjectionKey,
   AvsbPlugin,
   AvsbProvider,
+  DecideOption,
   useAlias,
   useAllFlags,
   useAvsbClient,
-  useAvsbStore,
+  useAvsbStatus,
   useBoolFlag,
+  useExposure,
   useFlag,
   useFlagReady,
+  useFlagSubscription,
   useFlagValue,
   useIdentify,
   useJsonFlag,
   useNumberFlag,
+  useReset,
   useStringFlag,
   useTrack
 });