@sheepit-ai/sdk-js 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GoaTech AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# @goatech/sdk-js
+
+Browser-side SDK for the [GoaTech](https://goatech.ai) release-intelligence platform. Ship flags, run experiments, and track events with a tiny (~8KB gzipped) client.
+
+> React apps: use **[@goatech/react](https://www.npmjs.com/package/@goatech/react)** — it wraps this SDK with hooks and a provider.
+
+## Install
+
+```bash
+npm install @goatech/sdk-js
+# or
+pnpm add @goatech/sdk-js
+# or
+yarn add @goatech/sdk-js
+```
+
+## Quickstart
+
+```ts
+import { GoaTech } from "@sheepit-ai/sdk-js";
+
+const gt = GoaTech.create({
+  apiKey: "lp_pub_xxx_abc123...", // publishable key — safe in browsers
+  apiUrl: "https://api.goatech.ai", // optional, defaults to prod
+});
+
+// Track an event
+gt.track("course_viewed", { course_id: "abc-123" });
+
+// Evaluate a flag
+const showBeta = gt.flag("show_beta_ui", false);
+
+// Get an experiment variant (server-bucketed, sticky per device)
+const { variant, payload } = gt.experiment("checkout_redesign");
+
+// Identify a user after login
+gt.identify("user_abc123", { email: "jane@example.com" });
+
+// On logout
+gt.reset();
+```
+
+## Keys
+
+Use the **publishable** key (`lp_pub_*`) in browsers. It can only post events and fetch config — no admin access. Secret keys (`lp_sec_*`) are rejected at initialization if used in a browser context.
+
+## API
+
+### `GoaTech.create(config)`
+
+Create an SDK instance. Required: `apiKey`. Other options:
+
+- `apiUrl` — defaults to `https://api.goatech.ai`
+- `debug` — enables verbose logging + local flag overrides
+- `flushInterval` — ms between event flushes (default 5000)
+- `flushSize` — batch size (default 20)
+- `autoCaptureErrors` — capture `window.onerror` + `unhandledrejection` as `$error` events (default `true`; pass `false` to disable or an object to configure)
+- `autoCaptureHttpErrors` — wrap `fetch` to emit `$http_error` on non-2xx responses (default `false`)
+- `appVersion` — attached to every event for Release attribution
+
+### `gt.track(eventName, properties?)`
+
+Queue an event for batch upload. Returns immediately; events flush on a timer, on `visibilitychange`, and on `pagehide`.
+
+### `gt.identify(userId, traits?)`
+
+Associate the current device with a user. Subsequent events carry `user_id` + `traits`. Do **not** put PII in `traits` unless you've disclosed it.
+
+### `gt.reset()`
+
+Clear user identity and cached experiment assignments. Call on logout.
+
+### `gt.flag<T>(flagKey, defaultValue?)`
+
+Return the server-evaluated flag value, or `defaultValue` if not set. Fires a `$flag_exposure` event once per session per flag.
+
+### `gt.experiment(experimentKey)`
+
+Return the assigned variant for an experiment. Result is `{ variant: string; payload?: Record<string, unknown> }`. Assignments are computed server-side and remain sticky per device.
+
+### `gt.flush()`
+
+Force-flush queued events. Returns a promise that resolves when the batch is sent.
+
+### `gt.destroy()`
+
+Tear down the instance (stops timers, clears state). Useful in tests.
+
+## Offline
+
+Events queue locally (IndexedDB or localStorage) when the network is down and retry with exponential backoff. Cap is ~1000 events to prevent unbounded memory growth — oldest dropped first.
+
+## Type-safe flags via `@goatech/cli`
+
+Install the CLI and run `goatech codegen` to generate type-safe flag constants from your project's Flag definitions. See the [CLI README](https://www.npmjs.com/package/@goatech/cli).
+
+## License
+
+MIT © GoaTech

package/dist/boot-error.d.mts

@@ -0,0 +1,39 @@
+interface BootErrorScriptOptions {
+    /**
+     * URL the ultra-early error script posts to. Must be same-origin relative
+     * (e.g. "/api/log-boot-error") so `navigator.sendBeacon` works on page unload.
+     * Customers wire a corresponding server route that forwards to GoaTech or
+     * logs to their infra. (See README for a Next.js example.)
+     */
+    endpoint: string;
+    /** Stack-trace length cap in chars. Default: 4096. */
+    stackLimit?: number;
+}
+/**
+ * Returns an IIFE string to inline in `<head>` BEFORE any bundle loads.
+ * Captures errors that happen before React / the SDK hydrates — a render
+ * crash in that window never reaches the normal event pipeline.
+ *
+ * Usage (Next.js App Router):
+ *
+ *   import { getBootErrorScript } from "@sheepit-ai/sdk-js/boot-error";
+ *   ...
+ *   <head>
+ *     <script dangerouslySetInnerHTML={{ __html: getBootErrorScript({ endpoint: "/api/log-boot-error" }) }} />
+ *   </head>
+ */
+declare function getBootErrorScript(options: BootErrorScriptOptions): string;
+interface BootErrorPayload {
+    reason: "uncaught_error" | "unhandled_rejection";
+    message: string;
+    source?: string | null;
+    line?: number | null;
+    col?: number | null;
+    stack?: string | null;
+    ua: string;
+    url: string;
+    pathname: string;
+    ts: number;
+}
+
+export { type BootErrorPayload, type BootErrorScriptOptions, getBootErrorScript };

package/dist/boot-error.d.ts

@@ -0,0 +1,39 @@
+interface BootErrorScriptOptions {
+    /**
+     * URL the ultra-early error script posts to. Must be same-origin relative
+     * (e.g. "/api/log-boot-error") so `navigator.sendBeacon` works on page unload.
+     * Customers wire a corresponding server route that forwards to GoaTech or
+     * logs to their infra. (See README for a Next.js example.)
+     */
+    endpoint: string;
+    /** Stack-trace length cap in chars. Default: 4096. */
+    stackLimit?: number;
+}
+/**
+ * Returns an IIFE string to inline in `<head>` BEFORE any bundle loads.
+ * Captures errors that happen before React / the SDK hydrates — a render
+ * crash in that window never reaches the normal event pipeline.
+ *
+ * Usage (Next.js App Router):
+ *
+ *   import { getBootErrorScript } from "@sheepit-ai/sdk-js/boot-error";
+ *   ...
+ *   <head>
+ *     <script dangerouslySetInnerHTML={{ __html: getBootErrorScript({ endpoint: "/api/log-boot-error" }) }} />
+ *   </head>
+ */
+declare function getBootErrorScript(options: BootErrorScriptOptions): string;
+interface BootErrorPayload {
+    reason: "uncaught_error" | "unhandled_rejection";
+    message: string;
+    source?: string | null;
+    line?: number | null;
+    col?: number | null;
+    stack?: string | null;
+    ua: string;
+    url: string;
+    pathname: string;
+    ts: number;
+}
+
+export { type BootErrorPayload, type BootErrorScriptOptions, getBootErrorScript };

package/dist/boot-error.js

@@ -0,0 +1,32 @@
+'use strict';function t(e){let n=JSON.stringify(e.endpoint),r=e.stackLimit??4096;return `(function(){
+  function post(p){
+    try {
+      var d = JSON.stringify(p);
+      if (navigator.sendBeacon) {
+        navigator.sendBeacon(${n}, new Blob([d],{type:"application/json"}));
+      } else {
+        fetch(${n},{method:"POST",body:d,keepalive:true,headers:{"Content-Type":"application/json"}}).catch(function(){});
+      }
+    } catch(e){}
+  }
+  function base(r){
+    return {reason:r,ua:navigator.userAgent,url:location.href,ts:Date.now(),pathname:location.pathname};
+  }
+  window.addEventListener("error",function(e){
+    var p=base("uncaught_error");
+    p.message=e&&e.message?String(e.message):"(no message)";
+    p.source=e&&e.filename?String(e.filename):null;
+    p.line=e&&typeof e.lineno==="number"?e.lineno:null;
+    p.col=e&&typeof e.colno==="number"?e.colno:null;
+    p.stack=e&&e.error&&e.error.stack?String(e.error.stack).slice(0,${r}):null;
+    post(p);
+  });
+  window.addEventListener("unhandledrejection",function(e){
+    var p=base("unhandled_rejection");
+    var r=e&&e.reason;
+    p.message=r&&r.message?String(r.message):String(r);
+    p.stack=r&&r.stack?String(r.stack).slice(0,${r}):null;
+    post(p);
+  });
+})();`}exports.getBootErrorScript=t;//# sourceMappingURL=boot-error.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/boot-error.mjs

@@ -0,0 +1,2 @@
+export{a as getBootErrorScript}from'./chunk-35ZDSFHA.mjs';//# sourceMappingURL=boot-error.mjs.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJib290LWVycm9yLm1qcyJ9

package/dist/chunk-35ZDSFHA.mjs

@@ -0,0 +1,32 @@
+function t(e){let n=JSON.stringify(e.endpoint),r=e.stackLimit??4096;return `(function(){
+  function post(p){
+    try {
+      var d = JSON.stringify(p);
+      if (navigator.sendBeacon) {
+        navigator.sendBeacon(${n}, new Blob([d],{type:"application/json"}));
+      } else {
+        fetch(${n},{method:"POST",body:d,keepalive:true,headers:{"Content-Type":"application/json"}}).catch(function(){});
+      }
+    } catch(e){}
+  }
+  function base(r){
+    return {reason:r,ua:navigator.userAgent,url:location.href,ts:Date.now(),pathname:location.pathname};
+  }
+  window.addEventListener("error",function(e){
+    var p=base("uncaught_error");
+    p.message=e&&e.message?String(e.message):"(no message)";
+    p.source=e&&e.filename?String(e.filename):null;
+    p.line=e&&typeof e.lineno==="number"?e.lineno:null;
+    p.col=e&&typeof e.colno==="number"?e.colno:null;
+    p.stack=e&&e.error&&e.error.stack?String(e.error.stack).slice(0,${r}):null;
+    post(p);
+  });
+  window.addEventListener("unhandledrejection",function(e){
+    var p=base("unhandled_rejection");
+    var r=e&&e.reason;
+    p.message=r&&r.message?String(r.message):String(r);
+    p.stack=r&&r.stack?String(r.stack).slice(0,${r}):null;
+    post(p);
+  });
+})();`}export{t as a};//# sourceMappingURL=chunk-35ZDSFHA.mjs.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chunk-6BNLBHZS.mjs

@@ -0,0 +1,2 @@
+var s="lp_debug_overrides",i=class{constructor(){this.flagValues={};this.debugOverrides={};this.exposed=new Set;this.debugMode=false;}setEvaluatedFlags(e){this.flagValues=e,this.exposed.clear();}setDebugMode(e){this.debugMode=e,e&&this.loadDebugOverrides();}overrideFlag(e,r){this.debugOverrides[e]=r,this.saveDebugOverrides();}clearOverrides(){this.debugOverrides={};try{localStorage.removeItem(s);}catch{}}getOverrides(){return {...this.debugOverrides}}count(){return Object.keys(this.flagValues).length}evaluate(e,r,o,u,d){if(this.debugMode&&e in this.debugOverrides)return this.debugOverrides[e];if(e in this.flagValues){let t=this.flagValues[e];return this.exposed.has(e)||(this.exposed.add(e),d(e,t)),t}return r}clearExposed(){this.exposed.clear();}loadDebugOverrides(){try{let e=localStorage.getItem(s);e&&(this.debugOverrides=JSON.parse(e));}catch{}}saveDebugOverrides(){try{localStorage.setItem(s,JSON.stringify(this.debugOverrides));}catch{}}};export{i as a};//# sourceMappingURL=chunk-6BNLBHZS.mjs.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chunk-X5MDWZGR.mjs

@@ -0,0 +1,3 @@
+var a="0.1.0",g={apiUrl:"https://api.goatech.ai",environment:"production",flushInterval:5e3,flushSize:20,debug:false,configRefreshInterval:3e5,maxQueueSize:1e3,retryAttempts:3,retryBackoff:[1e3,5e3,15e3],diagnosticBufferSize:100},e={deviceId:"gt_device_id",anonymousId:"gt_anonymous_id",identity:"gt_identity",sdkConfig:"gt_config",offlineQueue:"gt_offline_queue",sessionId:"gt_session_id",sessionLastSeen:"gt_session_last_seen",experimentAssignments:"gt_exp_assignments",sessionAttribution:"gt_session_attribution",firstTouchAttribution:"gt_first_touch"},c=1800*1e3,m=1440*60*1e3,_=500;var A=200;var i=class{constructor(){this.assignments={};this.stickyAssignments={};this.exposed=new Set;this.loadStickyAssignments();}setAssignments(s){this.assignments=s;}count(){return Object.keys(this.assignments).length}resolve(s,o){let n=this.assignments[s];if(!n)return {variant:"control"};let t=n.variant_key;return this.stickyAssignments[s]!==t&&(this.stickyAssignments[s]=t,this.saveStickyAssignments()),this.exposed.has(s)||(this.exposed.add(s),o(s,t)),{variant:t,payload:n.payload}}clearAssignments(){this.stickyAssignments={},this.exposed.clear();try{localStorage.removeItem(e.experimentAssignments);}catch{}}loadStickyAssignments(){try{let s=localStorage.getItem(e.experimentAssignments);s&&(this.stickyAssignments=JSON.parse(s));}catch{this.stickyAssignments={};}}saveStickyAssignments(){try{localStorage.setItem(e.experimentAssignments,JSON.stringify(this.stickyAssignments));}catch{}}};
+export{a,g as b,e as c,c as d,m as e,_ as f,A as g,i as h};//# sourceMappingURL=chunk-X5MDWZGR.mjs.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/defaults.ts","../src/experiments.ts"],"names":["SDK_VERSION","DEFAULTS","STORAGE_KEYS","SESSION_TIMEOUT_MS","CONFIG_MAX_AGE_MS","OFFLINE_QUEUE_MAX","EVENT_NAME_MAX_LENGTH","ExperimentManager","assignments","experimentKey","onExposure","assignment","variantKey","raw"],"mappings":"AAAO,IAAMA,CAAAA,CAAc,OAAA,CAEdC,CAAAA,CAAW,CACtB,MAAA,CAAQ,yBACR,WAAA,CAAa,YAAA,CACb,aAAA,CAAe,GAAA,CACf,SAAA,CAAW,EAAA,CACX,MAAO,KAAA,CACP,qBAAA,CAAuB,GAAA,CACvB,YAAA,CAAc,GAAA,CACd,aAAA,CAAe,EACf,YAAA,CAAc,CAAC,GAAA,CAAM,GAAA,CAAM,IAAM,CAAA,CACjC,qBAAsB,GACxB,CAAA,CAeaC,CAAAA,CAAe,CAC1B,QAAA,CAAU,cAAA,CACV,YAAa,iBAAA,CACb,QAAA,CAAU,aAAA,CACV,SAAA,CAAW,WAAA,CACX,YAAA,CAAc,mBACd,SAAA,CAAW,eAAA,CACX,eAAA,CAAiB,sBAAA,CACjB,qBAAA,CAAuB,oBAAA,CAIvB,kBAAA,CAAoB,wBAAA,CAIpB,qBAAA,CAAuB,gBACzB,CAAA,CAEaC,CAAAA,CAAqB,IAAA,CAAU,GAAA,CAC/BC,EAAoB,IAAA,CAAU,EAAA,CAAK,GAAA,CACnCC,CAAAA,CAAoB,IAE1B,IAAMC,EAAwB,ICnC9B,IAAMC,CAAAA,CAAN,KAAwB,CAM7B,WAAA,EAAc,CALd,IAAA,CAAQ,WAAA,CAAoD,EAAC,CAE7D,IAAA,CAAQ,iBAAA,CAAqC,EAAC,CAC9C,IAAA,CAAQ,OAAA,CAAU,IAAI,GAAA,CAGpB,IAAA,CAAK,wBACP,CAEA,cAAA,CAAeC,CAAAA,CAAyD,CACtE,IAAA,CAAK,YAAcA,EACrB,CAEA,KAAA,EAAgB,CACd,OAAO,MAAA,CAAO,KAAK,IAAA,CAAK,WAAW,CAAA,CAAE,MACvC,CAEA,OAAA,CACEC,CAAAA,CACAC,CAAAA,CACkB,CAClB,IAAMC,CAAAA,CAAa,IAAA,CAAK,WAAA,CAAYF,CAAa,EACjD,GAAI,CAACE,CAAAA,CACH,OAAO,CAAE,OAAA,CAAS,SAAU,CAAA,CAG9B,IAAMC,CAAAA,CAAaD,CAAAA,CAAW,WAAA,CAI9B,OAAI,KAAK,iBAAA,CAAkBF,CAAa,CAAA,GAAMG,CAAAA,GAC5C,IAAA,CAAK,iBAAA,CAAkBH,CAAa,CAAA,CAAIG,CAAAA,CACxC,IAAA,CAAK,qBAAA,EAAsB,CAAA,CAGxB,IAAA,CAAK,QAAQ,GAAA,CAAIH,CAAa,CAAA,GACjC,IAAA,CAAK,OAAA,CAAQ,GAAA,CAAIA,CAAa,CAAA,CAC9BC,CAAAA,CAAWD,CAAAA,CAAeG,CAAU,CAAA,CAAA,CAG/B,CAAE,QAASA,CAAAA,CAAY,OAAA,CAASD,CAAAA,CAAW,OAAQ,CAC5D,CAEA,gBAAA,EAAyB,CACvB,IAAA,CAAK,iBAAA,CAAoB,EAAC,CAC1B,IAAA,CAAK,OAAA,CAAQ,OAAM,CACnB,GAAI,CACF,YAAA,CAAa,UAAA,CAAWT,CAAAA,CAAa,qBAAqB,EAC5D,CAAA,KAAQ,CAER,CACF,CAEQ,qBAAA,EAA8B,CACpC,GAAI,CACF,IAAMW,CAAAA,CAAM,YAAA,CAAa,OAAA,CAAQX,CAAAA,CAAa,qBAAqB,CAAA,CAC/DW,CAAAA,GACF,IAAA,CAAK,iBAAA,CAAoB,IAAA,CAAK,KAAA,CAAMA,CAAG,CAAA,EAE3C,CAAA,KAAQ,CACN,IAAA,CAAK,iBAAA,CAAoB,GAC3B,CACF,CAEQ,qBAAA,EAA8B,CACpC,GAAI,CACF,aAAa,OAAA,CACXX,CAAAA,CAAa,qBAAA,CACb,IAAA,CAAK,SAAA,CAAU,IAAA,CAAK,iBAAiB,CACvC,EACF,CAAA,KAAQ,CAER,CACF,CACF","file":"chunk-X5MDWZGR.mjs","sourcesContent":["export const SDK_VERSION = \"0.1.0\";\n\nexport const DEFAULTS = {\n  apiUrl: \"https://api.goatech.ai\",\n  environment: \"production\",\n  flushInterval: 5000,\n  flushSize: 20,\n  debug: false,\n  configRefreshInterval: 300_000,\n  maxQueueSize: 1000,\n  retryAttempts: 3,\n  retryBackoff: [1000, 5000, 15_000] as [number, number, number],\n  diagnosticBufferSize: 100,\n} as const;\n\n/**\n * Browser storage keys.\n *\n * Audit E-010 — renamed from `lp_*` to `gt_*` to match the rest of the\n * GoaTech rename. `migrateLegacyStorageKeys()` (see `./storage-migration.ts`)\n * runs once on SDK init and copies any pre-existing `lp_*` value into\n * the new `gt_*` slot, so existing testers don't lose their device id,\n * identity, offline queue, attribution, or experiment assignments.\n *\n * Sources of truth: never hardcode the `gt_*` strings in consumers —\n * always import `STORAGE_KEYS.<name>`. The legacy strings live only in\n * `storage-migration.ts`.\n */\nexport const STORAGE_KEYS = {\n  deviceId: \"gt_device_id\",\n  anonymousId: \"gt_anonymous_id\",\n  identity: \"gt_identity\",\n  sdkConfig: \"gt_config\",\n  offlineQueue: \"gt_offline_queue\",\n  sessionId: \"gt_session_id\",\n  sessionLastSeen: \"gt_session_last_seen\",\n  experimentAssignments: \"gt_exp_assignments\",\n  /** Per-session attribution snapshot (UTM + referrer + landing page).\n   *  Captured on session creation; persists for the session's lifetime so\n   *  every event in that session carries the same first-touch context. */\n  sessionAttribution: \"gt_session_attribution\",\n  /** First-ever-touch attribution across the whole browser lifetime.\n   *  Written once on the first session where UTM or referrer is present;\n   *  never overwritten. Useful for \"how did this user FIRST find us\". */\n  firstTouchAttribution: \"gt_first_touch\",\n} as const;\n\nexport const SESSION_TIMEOUT_MS = 30 * 60 * 1000;\nexport const CONFIG_MAX_AGE_MS = 24 * 60 * 60 * 1000;\nexport const OFFLINE_QUEUE_MAX = 500;\nexport const ATTRIBUTE_MAX_KEYS = 50;\nexport const EVENT_NAME_MAX_LENGTH = 200;\n","import { STORAGE_KEYS } from \"./defaults.js\";\nimport type { ExperimentAssignment, ExperimentResult } from \"./types.js\";\n\ntype AssignmentStore = Record<string, string>;\n\n/**\n * Experiments are bucketed server-side. The `/v1/config` endpoint returns\n * `experiments: { [experimentKey]: { variant_key, payload } }` — one entry\n * per experiment the caller's device is enrolled in. The SDK's job is to\n * cache the assignment, emit a single exposure event per session, and\n * surface the variant to calling code.\n *\n * No client-side bucketing. No traffic gates. No cumulative weights. All\n * of that happens on the server so every platform (web, iOS, server SDK)\n * agrees on the assignment for a given device.\n */\nexport class ExperimentManager {\n  private assignments: Record<string, ExperimentAssignment> = {};\n  /** Persisted per-session: remembers which variant we last surfaced. */\n  private stickyAssignments: AssignmentStore = {};\n  private exposed = new Set<string>();\n\n  constructor() {\n    this.loadStickyAssignments();\n  }\n\n  setAssignments(assignments: Record<string, ExperimentAssignment>): void {\n    this.assignments = assignments;\n  }\n\n  count(): number {\n    return Object.keys(this.assignments).length;\n  }\n\n  resolve(\n    experimentKey: string,\n    onExposure: (key: string, variant: string) => void,\n  ): ExperimentResult {\n    const assignment = this.assignments[experimentKey];\n    if (!assignment) {\n      return { variant: \"control\" };\n    }\n\n    const variantKey = assignment.variant_key;\n\n    // Persist so the variant is stable even if the server response is\n    // briefly unavailable after a cache miss.\n    if (this.stickyAssignments[experimentKey] !== variantKey) {\n      this.stickyAssignments[experimentKey] = variantKey;\n      this.saveStickyAssignments();\n    }\n\n    if (!this.exposed.has(experimentKey)) {\n      this.exposed.add(experimentKey);\n      onExposure(experimentKey, variantKey);\n    }\n\n    return { variant: variantKey, payload: assignment.payload };\n  }\n\n  clearAssignments(): void {\n    this.stickyAssignments = {};\n    this.exposed.clear();\n    try {\n      localStorage.removeItem(STORAGE_KEYS.experimentAssignments);\n    } catch {\n      // no localStorage\n    }\n  }\n\n  private loadStickyAssignments(): void {\n    try {\n      const raw = localStorage.getItem(STORAGE_KEYS.experimentAssignments);\n      if (raw) {\n        this.stickyAssignments = JSON.parse(raw) as AssignmentStore;\n      }\n    } catch {\n      this.stickyAssignments = {};\n    }\n  }\n\n  private saveStickyAssignments(): void {\n    try {\n      localStorage.setItem(\n        STORAGE_KEYS.experimentAssignments,\n        JSON.stringify(this.stickyAssignments),\n      );\n    } catch {\n      // no localStorage\n    }\n  }\n}\n"]}

package/dist/experiments.d.mts

@@ -0,0 +1,29 @@
+import { s as ExperimentAssignment, E as ExperimentResult } from './types-CxAq_Cds.mjs';
+export { j as ExperimentConfig, l as ExperimentVariant } from './types-CxAq_Cds.mjs';
+
+/**
+ * Experiments are bucketed server-side. The `/v1/config` endpoint returns
+ * `experiments: { [experimentKey]: { variant_key, payload } }` — one entry
+ * per experiment the caller's device is enrolled in. The SDK's job is to
+ * cache the assignment, emit a single exposure event per session, and
+ * surface the variant to calling code.
+ *
+ * No client-side bucketing. No traffic gates. No cumulative weights. All
+ * of that happens on the server so every platform (web, iOS, server SDK)
+ * agrees on the assignment for a given device.
+ */
+declare class ExperimentManager {
+    private assignments;
+    /** Persisted per-session: remembers which variant we last surfaced. */
+    private stickyAssignments;
+    private exposed;
+    constructor();
+    setAssignments(assignments: Record<string, ExperimentAssignment>): void;
+    count(): number;
+    resolve(experimentKey: string, onExposure: (key: string, variant: string) => void): ExperimentResult;
+    clearAssignments(): void;
+    private loadStickyAssignments;
+    private saveStickyAssignments;
+}
+
+export { ExperimentManager, ExperimentResult };

package/dist/experiments.d.ts

@@ -0,0 +1,29 @@
+import { s as ExperimentAssignment, E as ExperimentResult } from './types-CxAq_Cds.js';
+export { j as ExperimentConfig, l as ExperimentVariant } from './types-CxAq_Cds.js';
+
+/**
+ * Experiments are bucketed server-side. The `/v1/config` endpoint returns
+ * `experiments: { [experimentKey]: { variant_key, payload } }` — one entry
+ * per experiment the caller's device is enrolled in. The SDK's job is to
+ * cache the assignment, emit a single exposure event per session, and
+ * surface the variant to calling code.
+ *
+ * No client-side bucketing. No traffic gates. No cumulative weights. All
+ * of that happens on the server so every platform (web, iOS, server SDK)
+ * agrees on the assignment for a given device.
+ */
+declare class ExperimentManager {
+    private assignments;
+    /** Persisted per-session: remembers which variant we last surfaced. */
+    private stickyAssignments;
+    private exposed;
+    constructor();
+    setAssignments(assignments: Record<string, ExperimentAssignment>): void;
+    count(): number;
+    resolve(experimentKey: string, onExposure: (key: string, variant: string) => void): ExperimentResult;
+    clearAssignments(): void;
+    private loadStickyAssignments;
+    private saveStickyAssignments;
+}
+
+export { ExperimentManager, ExperimentResult };

package/dist/experiments.js

@@ -0,0 +1,2 @@
+'use strict';var e={deviceId:"gt_device_id",anonymousId:"gt_anonymous_id",identity:"gt_identity",sdkConfig:"gt_config",offlineQueue:"gt_offline_queue",sessionId:"gt_session_id",sessionLastSeen:"gt_session_last_seen",experimentAssignments:"gt_exp_assignments",sessionAttribution:"gt_session_attribution",firstTouchAttribution:"gt_first_touch"};var i=class{constructor(){this.assignments={};this.stickyAssignments={};this.exposed=new Set;this.loadStickyAssignments();}setAssignments(t){this.assignments=t;}count(){return Object.keys(this.assignments).length}resolve(t,r){let n=this.assignments[t];if(!n)return {variant:"control"};let s=n.variant_key;return this.stickyAssignments[t]!==s&&(this.stickyAssignments[t]=s,this.saveStickyAssignments()),this.exposed.has(t)||(this.exposed.add(t),r(t,s)),{variant:s,payload:n.payload}}clearAssignments(){this.stickyAssignments={},this.exposed.clear();try{localStorage.removeItem(e.experimentAssignments);}catch{}}loadStickyAssignments(){try{let t=localStorage.getItem(e.experimentAssignments);t&&(this.stickyAssignments=JSON.parse(t));}catch{this.stickyAssignments={};}}saveStickyAssignments(){try{localStorage.setItem(e.experimentAssignments,JSON.stringify(this.stickyAssignments));}catch{}}};exports.ExperimentManager=i;//# sourceMappingURL=experiments.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/defaults.ts","../src/experiments.ts"],"names":["STORAGE_KEYS","ExperimentManager","assignments","experimentKey","onExposure","assignment","variantKey","raw"],"mappings":"aA4BO,IAAMA,CAAAA,CAAe,CAC1B,QAAA,CAAU,cAAA,CACV,YAAa,iBAAA,CACb,QAAA,CAAU,cACV,SAAA,CAAW,WAAA,CACX,aAAc,kBAAA,CACd,SAAA,CAAW,gBACX,eAAA,CAAiB,sBAAA,CACjB,sBAAuB,oBAAA,CAIvB,kBAAA,CAAoB,yBAIpB,qBAAA,CAAuB,gBACzB,EC7BO,IAAMC,EAAN,KAAwB,CAM7B,aAAc,CALd,IAAA,CAAQ,YAAoD,EAAC,CAE7D,KAAQ,iBAAA,CAAqC,GAC7C,IAAA,CAAQ,OAAA,CAAU,IAAI,GAAA,CAGpB,IAAA,CAAK,wBACP,CAEA,eAAeC,CAAAA,CAAyD,CACtE,KAAK,WAAA,CAAcA,EACrB,CAEA,KAAA,EAAgB,CACd,OAAO,MAAA,CAAO,IAAA,CAAK,KAAK,WAAW,CAAA,CAAE,MACvC,CAEA,OAAA,CACEC,EACAC,CAAAA,CACkB,CAClB,IAAMC,CAAAA,CAAa,IAAA,CAAK,YAAYF,CAAa,CAAA,CACjD,GAAI,CAACE,CAAAA,CACH,OAAO,CAAE,OAAA,CAAS,SAAU,CAAA,CAG9B,IAAMC,EAAaD,CAAAA,CAAW,WAAA,CAI9B,OAAI,IAAA,CAAK,iBAAA,CAAkBF,CAAa,IAAMG,CAAAA,GAC5C,IAAA,CAAK,kBAAkBH,CAAa,CAAA,CAAIG,EACxC,IAAA,CAAK,qBAAA,IAGF,IAAA,CAAK,OAAA,CAAQ,IAAIH,CAAa,CAAA,GACjC,KAAK,OAAA,CAAQ,GAAA,CAAIA,CAAa,CAAA,CAC9BC,CAAAA,CAAWD,EAAeG,CAAU,CAAA,CAAA,CAG/B,CAAE,OAAA,CAASA,CAAAA,CAAY,QAASD,CAAAA,CAAW,OAAQ,CAC5D,CAEA,gBAAA,EAAyB,CACvB,IAAA,CAAK,iBAAA,CAAoB,EAAC,CAC1B,IAAA,CAAK,QAAQ,KAAA,EAAM,CACnB,GAAI,CACF,YAAA,CAAa,UAAA,CAAWL,CAAAA,CAAa,qBAAqB,EAC5D,MAAQ,CAER,CACF,CAEQ,qBAAA,EAA8B,CACpC,GAAI,CACF,IAAMO,EAAM,YAAA,CAAa,OAAA,CAAQP,EAAa,qBAAqB,CAAA,CAC/DO,IACF,IAAA,CAAK,iBAAA,CAAoB,KAAK,KAAA,CAAMA,CAAG,GAE3C,CAAA,KAAQ,CACN,KAAK,iBAAA,CAAoB,GAC3B,CACF,CAEQ,uBAA8B,CACpC,GAAI,CACF,YAAA,CAAa,OAAA,CACXP,EAAa,qBAAA,CACb,IAAA,CAAK,UAAU,IAAA,CAAK,iBAAiB,CACvC,EACF,CAAA,KAAQ,CAER,CACF,CACF","file":"experiments.js","sourcesContent":["export const SDK_VERSION = \"0.1.0\";\n\nexport const DEFAULTS = {\n  apiUrl: \"https://api.goatech.ai\",\n  environment: \"production\",\n  flushInterval: 5000,\n  flushSize: 20,\n  debug: false,\n  configRefreshInterval: 300_000,\n  maxQueueSize: 1000,\n  retryAttempts: 3,\n  retryBackoff: [1000, 5000, 15_000] as [number, number, number],\n  diagnosticBufferSize: 100,\n} as const;\n\n/**\n * Browser storage keys.\n *\n * Audit E-010 — renamed from `lp_*` to `gt_*` to match the rest of the\n * GoaTech rename. `migrateLegacyStorageKeys()` (see `./storage-migration.ts`)\n * runs once on SDK init and copies any pre-existing `lp_*` value into\n * the new `gt_*` slot, so existing testers don't lose their device id,\n * identity, offline queue, attribution, or experiment assignments.\n *\n * Sources of truth: never hardcode the `gt_*` strings in consumers —\n * always import `STORAGE_KEYS.<name>`. The legacy strings live only in\n * `storage-migration.ts`.\n */\nexport const STORAGE_KEYS = {\n  deviceId: \"gt_device_id\",\n  anonymousId: \"gt_anonymous_id\",\n  identity: \"gt_identity\",\n  sdkConfig: \"gt_config\",\n  offlineQueue: \"gt_offline_queue\",\n  sessionId: \"gt_session_id\",\n  sessionLastSeen: \"gt_session_last_seen\",\n  experimentAssignments: \"gt_exp_assignments\",\n  /** Per-session attribution snapshot (UTM + referrer + landing page).\n   *  Captured on session creation; persists for the session's lifetime so\n   *  every event in that session carries the same first-touch context. */\n  sessionAttribution: \"gt_session_attribution\",\n  /** First-ever-touch attribution across the whole browser lifetime.\n   *  Written once on the first session where UTM or referrer is present;\n   *  never overwritten. Useful for \"how did this user FIRST find us\". */\n  firstTouchAttribution: \"gt_first_touch\",\n} as const;\n\nexport const SESSION_TIMEOUT_MS = 30 * 60 * 1000;\nexport const CONFIG_MAX_AGE_MS = 24 * 60 * 60 * 1000;\nexport const OFFLINE_QUEUE_MAX = 500;\nexport const ATTRIBUTE_MAX_KEYS = 50;\nexport const EVENT_NAME_MAX_LENGTH = 200;\n","import { STORAGE_KEYS } from \"./defaults.js\";\nimport type { ExperimentAssignment, ExperimentResult } from \"./types.js\";\n\ntype AssignmentStore = Record<string, string>;\n\n/**\n * Experiments are bucketed server-side. The `/v1/config` endpoint returns\n * `experiments: { [experimentKey]: { variant_key, payload } }` — one entry\n * per experiment the caller's device is enrolled in. The SDK's job is to\n * cache the assignment, emit a single exposure event per session, and\n * surface the variant to calling code.\n *\n * No client-side bucketing. No traffic gates. No cumulative weights. All\n * of that happens on the server so every platform (web, iOS, server SDK)\n * agrees on the assignment for a given device.\n */\nexport class ExperimentManager {\n  private assignments: Record<string, ExperimentAssignment> = {};\n  /** Persisted per-session: remembers which variant we last surfaced. */\n  private stickyAssignments: AssignmentStore = {};\n  private exposed = new Set<string>();\n\n  constructor() {\n    this.loadStickyAssignments();\n  }\n\n  setAssignments(assignments: Record<string, ExperimentAssignment>): void {\n    this.assignments = assignments;\n  }\n\n  count(): number {\n    return Object.keys(this.assignments).length;\n  }\n\n  resolve(\n    experimentKey: string,\n    onExposure: (key: string, variant: string) => void,\n  ): ExperimentResult {\n    const assignment = this.assignments[experimentKey];\n    if (!assignment) {\n      return { variant: \"control\" };\n    }\n\n    const variantKey = assignment.variant_key;\n\n    // Persist so the variant is stable even if the server response is\n    // briefly unavailable after a cache miss.\n    if (this.stickyAssignments[experimentKey] !== variantKey) {\n      this.stickyAssignments[experimentKey] = variantKey;\n      this.saveStickyAssignments();\n    }\n\n    if (!this.exposed.has(experimentKey)) {\n      this.exposed.add(experimentKey);\n      onExposure(experimentKey, variantKey);\n    }\n\n    return { variant: variantKey, payload: assignment.payload };\n  }\n\n  clearAssignments(): void {\n    this.stickyAssignments = {};\n    this.exposed.clear();\n    try {\n      localStorage.removeItem(STORAGE_KEYS.experimentAssignments);\n    } catch {\n      // no localStorage\n    }\n  }\n\n  private loadStickyAssignments(): void {\n    try {\n      const raw = localStorage.getItem(STORAGE_KEYS.experimentAssignments);\n      if (raw) {\n        this.stickyAssignments = JSON.parse(raw) as AssignmentStore;\n      }\n    } catch {\n      this.stickyAssignments = {};\n    }\n  }\n\n  private saveStickyAssignments(): void {\n    try {\n      localStorage.setItem(\n        STORAGE_KEYS.experimentAssignments,\n        JSON.stringify(this.stickyAssignments),\n      );\n    } catch {\n      // no localStorage\n    }\n  }\n}\n"]}

package/dist/experiments.mjs

@@ -0,0 +1,2 @@
+export{h as ExperimentManager}from'./chunk-X5MDWZGR.mjs';//# sourceMappingURL=experiments.mjs.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJleHBlcmltZW50cy5tanMifQ==

package/dist/flags.d.mts

@@ -0,0 +1,34 @@
+import { F as FlagValue } from './types-CxAq_Cds.mjs';
+export { C as Condition, m as FlagConfig, n as FlagRule } from './types-CxAq_Cds.mjs';
+
+/**
+ * FlagManager stores server-evaluated Flag values and exposes them to SDK
+ * consumers. Evaluation happens on the API (see `/v1/config`); the SDK only
+ * caches the result and tracks exposure once per flag per session.
+ *
+ * Debug overrides take precedence over server values when debug mode is
+ * active, so developers can test different branches without touching the
+ * server. Overrides are persisted in localStorage under DEBUG_OVERRIDES_KEY.
+ */
+declare class FlagManager {
+    private flagValues;
+    private debugOverrides;
+    private exposed;
+    private debugMode;
+    /** Apply the latest evaluated flag values from `/v1/config`. */
+    setEvaluatedFlags(flags: Record<string, unknown>): void;
+    setDebugMode(enabled: boolean): void;
+    /** Override a flag value for local testing. Only active when debug=true. */
+    overrideFlag(key: string, value: FlagValue): void;
+    /** Clear all debug overrides. */
+    clearOverrides(): void;
+    /** Get all current debug overrides (for debug menu UI). */
+    getOverrides(): Record<string, unknown>;
+    count(): number;
+    evaluate(flagKey: string, defaultValue: FlagValue, _userId: string | null, _attributes: Record<string, unknown>, onExposure: (flagKey: string, value: FlagValue) => void): FlagValue;
+    clearExposed(): void;
+    private loadDebugOverrides;
+    private saveDebugOverrides;
+}
+
+export { FlagManager, FlagValue };

package/dist/flags.d.ts

@@ -0,0 +1,34 @@
+import { F as FlagValue } from './types-CxAq_Cds.js';
+export { C as Condition, m as FlagConfig, n as FlagRule } from './types-CxAq_Cds.js';
+
+/**
+ * FlagManager stores server-evaluated Flag values and exposes them to SDK
+ * consumers. Evaluation happens on the API (see `/v1/config`); the SDK only
+ * caches the result and tracks exposure once per flag per session.
+ *
+ * Debug overrides take precedence over server values when debug mode is
+ * active, so developers can test different branches without touching the
+ * server. Overrides are persisted in localStorage under DEBUG_OVERRIDES_KEY.
+ */
+declare class FlagManager {
+    private flagValues;
+    private debugOverrides;
+    private exposed;
+    private debugMode;
+    /** Apply the latest evaluated flag values from `/v1/config`. */
+    setEvaluatedFlags(flags: Record<string, unknown>): void;
+    setDebugMode(enabled: boolean): void;
+    /** Override a flag value for local testing. Only active when debug=true. */
+    overrideFlag(key: string, value: FlagValue): void;
+    /** Clear all debug overrides. */
+    clearOverrides(): void;
+    /** Get all current debug overrides (for debug menu UI). */
+    getOverrides(): Record<string, unknown>;
+    count(): number;
+    evaluate(flagKey: string, defaultValue: FlagValue, _userId: string | null, _attributes: Record<string, unknown>, onExposure: (flagKey: string, value: FlagValue) => void): FlagValue;
+    clearExposed(): void;
+    private loadDebugOverrides;
+    private saveDebugOverrides;
+}
+
+export { FlagManager, FlagValue };

package/dist/flags.js

@@ -0,0 +1,2 @@
+'use strict';var s="lp_debug_overrides",t=class{constructor(){this.flagValues={};this.debugOverrides={};this.exposed=new Set;this.debugMode=false;}setEvaluatedFlags(e){this.flagValues=e,this.exposed.clear();}setDebugMode(e){this.debugMode=e,e&&this.loadDebugOverrides();}overrideFlag(e,r){this.debugOverrides[e]=r,this.saveDebugOverrides();}clearOverrides(){this.debugOverrides={};try{localStorage.removeItem(s);}catch{}}getOverrides(){return {...this.debugOverrides}}count(){return Object.keys(this.flagValues).length}evaluate(e,r,o,u,a){if(this.debugMode&&e in this.debugOverrides)return this.debugOverrides[e];if(e in this.flagValues){let i=this.flagValues[e];return this.exposed.has(e)||(this.exposed.add(e),a(e,i)),i}return r}clearExposed(){this.exposed.clear();}loadDebugOverrides(){try{let e=localStorage.getItem(s);e&&(this.debugOverrides=JSON.parse(e));}catch{}}saveDebugOverrides(){try{localStorage.setItem(s,JSON.stringify(this.debugOverrides));}catch{}}};exports.FlagManager=t;//# sourceMappingURL=flags.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9mbGFncy50cyJdLCJuYW1lcyI6WyJERUJVR19PVkVSUklERVNfS0VZIiwiRmxhZ01hbmFnZXIiLCJmbGFncyIsImVuYWJsZWQiLCJrZXkiLCJ2YWx1ZSIsImZsYWdLZXkiLCJkZWZhdWx0VmFsdWUiLCJfdXNlcklkIiwiX2F0dHJpYnV0ZXMiLCJvbkV4cG9zdXJlIiwic3RvcmVkIl0sIm1hcHBpbmdzIjoiYUFFQSxJQUFNQSxFQUFzQixvQkFBQSxDQVdmQyxDQUFBQSxDQUFOLEtBQWtCLENBQWxCLFdBQUEsRUFBQSxDQUNMLEtBQVEsVUFBQSxDQUFzQyxHQUM5QyxJQUFBLENBQVEsY0FBQSxDQUEwQyxFQUFDLENBQ25ELElBQUEsQ0FBUSxRQUFVLElBQUksR0FBQSxDQUN0QixLQUFRLFNBQUEsQ0FBWSxNQUFBLENBR3BCLGtCQUFrQkMsQ0FBQUEsQ0FBc0MsQ0FDdEQsS0FBSyxVQUFBLENBQWFBLENBQUFBLENBQ2xCLEtBQUssT0FBQSxDQUFRLEtBQUEsR0FDZixDQUVBLFlBQUEsQ0FBYUMsRUFBd0IsQ0FDbkMsSUFBQSxDQUFLLFVBQVlBLENBQUFBLENBQ2JBLENBQUFBLEVBQVMsS0FBSyxrQkFBQSxHQUNwQixDQUdBLFlBQUEsQ0FBYUMsQ0FBQUEsQ0FBYUMsQ0FBQUEsQ0FBd0IsQ0FDaEQsS0FBSyxjQUFBLENBQWVELENBQUcsRUFBSUMsQ0FBQUEsQ0FDM0IsSUFBQSxDQUFLLHFCQUNQLENBR0EsZ0JBQXVCLENBQ3JCLElBQUEsQ0FBSyxlQUFpQixFQUFDLENBQ3ZCLEdBQUksQ0FDRixZQUFBLENBQWEsV0FBV0wsQ0FBbUIsRUFDN0MsTUFBUSxDQUVSLENBQ0YsQ0FHQSxZQUFBLEVBQXdDLENBQ3RDLE9BQU8sQ0FBRSxHQUFHLEtBQUssY0FBZSxDQUNsQyxDQUVBLEtBQUEsRUFBZ0IsQ0FDZCxPQUFPLE1BQUEsQ0FBTyxJQUFBLENBQUssS0FBSyxVQUFVLENBQUEsQ0FBRSxNQUN0QyxDQUVBLFFBQUEsQ0FDRU0sQ0FBQUEsQ0FDQUMsQ0FBQUEsQ0FDQUMsRUFDQUMsQ0FBQUEsQ0FDQUMsQ0FBQUEsQ0FDVyxDQUNYLEdBQUksSUFBQSxDQUFLLFdBQWFKLENBQUFBLElBQVcsSUFBQSxDQUFLLGVBQ3BDLE9BQU8sSUFBQSxDQUFLLGVBQWVBLENBQU8sQ0FBQSxDQUdwQyxHQUFJQSxDQUFBQSxJQUFXLElBQUEsQ0FBSyxXQUFZLENBQzlCLElBQU1ELEVBQVEsSUFBQSxDQUFLLFVBQUEsQ0FBV0MsQ0FBTyxDQUFBLENBQ3JDLE9BQUssS0FBSyxPQUFBLENBQVEsR0FBQSxDQUFJQSxDQUFPLENBQUEsR0FDM0IsSUFBQSxDQUFLLFFBQVEsR0FBQSxDQUFJQSxDQUFPLEVBQ3hCSSxDQUFBQSxDQUFXSixDQUFBQSxDQUFTRCxDQUFLLENBQUEsQ0FBQSxDQUVwQkEsQ0FDVCxDQUVBLE9BQU9FLENBQ1QsQ0FFQSxZQUFBLEVBQXFCLENBQ25CLElBQUEsQ0FBSyxPQUFBLENBQVEsUUFDZixDQUVRLG9CQUEyQixDQUNqQyxHQUFJLENBQ0YsSUFBTUksQ0FBQUEsQ0FBUyxhQUFhLE9BQUEsQ0FBUVgsQ0FBbUIsRUFDbkRXLENBQUFBLEdBQVEsSUFBQSxDQUFLLGVBQWlCLElBQUEsQ0FBSyxLQUFBLENBQU1BLENBQU0sQ0FBQSxFQUNyRCxDQUFBLEtBQVEsQ0FFUixDQUNGLENBRVEsb0JBQTJCLENBQ2pDLEdBQUksQ0FDRixZQUFBLENBQWEsT0FBQSxDQUFRWCxFQUFxQixJQUFBLENBQUssU0FBQSxDQUFVLEtBQUssY0FBYyxDQUFDLEVBQy9FLENBQUEsS0FBUSxDQUVSLENBQ0YsQ0FDRiIsImZpbGUiOiJmbGFncy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRmxhZ1ZhbHVlIH0gZnJvbSBcIi4vdHlwZXMuanNcIjtcblxuY29uc3QgREVCVUdfT1ZFUlJJREVTX0tFWSA9IFwibHBfZGVidWdfb3ZlcnJpZGVzXCI7XG5cbi8qKlxuICogRmxhZ01hbmFnZXIgc3RvcmVzIHNlcnZlci1ldmFsdWF0ZWQgRmxhZyB2YWx1ZXMgYW5kIGV4cG9zZXMgdGhlbSB0byBTREtcbiAqIGNvbnN1bWVycy4gRXZhbHVhdGlvbiBoYXBwZW5zIG9uIHRoZSBBUEkgKHNlZSBgL3YxL2NvbmZpZ2ApOyB0aGUgU0RLIG9ubHlcbiAqIGNhY2hlcyB0aGUgcmVzdWx0IGFuZCB0cmFja3MgZXhwb3N1cmUgb25jZSBwZXIgZmxhZyBwZXIgc2Vzc2lvbi5cbiAqXG4gKiBEZWJ1ZyBvdmVycmlkZXMgdGFrZSBwcmVjZWRlbmNlIG92ZXIgc2VydmVyIHZhbHVlcyB3aGVuIGRlYnVnIG1vZGUgaXNcbiAqIGFjdGl2ZSwgc28gZGV2ZWxvcGVycyBjYW4gdGVzdCBkaWZmZXJlbnQgYnJhbmNoZXMgd2l0aG91dCB0b3VjaGluZyB0aGVcbiAqIHNlcnZlci4gT3ZlcnJpZGVzIGFyZSBwZXJzaXN0ZWQgaW4gbG9jYWxTdG9yYWdlIHVuZGVyIERFQlVHX09WRVJSSURFU19LRVkuXG4gKi9cbmV4cG9ydCBjbGFzcyBGbGFnTWFuYWdlciB7XG4gIHByaXZhdGUgZmxhZ1ZhbHVlczogUmVjb3JkPHN0cmluZywgdW5rbm93bj4gPSB7fTtcbiAgcHJpdmF0ZSBkZWJ1Z092ZXJyaWRlczogUmVjb3JkPHN0cmluZywgdW5rbm93bj4gPSB7fTtcbiAgcHJpdmF0ZSBleHBvc2VkID0gbmV3IFNldDxzdHJpbmc+KCk7XG4gIHByaXZhdGUgZGVidWdNb2RlID0gZmFsc2U7XG5cbiAgLyoqIEFwcGx5IHRoZSBsYXRlc3QgZXZhbHVhdGVkIGZsYWcgdmFsdWVzIGZyb20gYC92MS9jb25maWdgLiAqL1xuICBzZXRFdmFsdWF0ZWRGbGFncyhmbGFnczogUmVjb3JkPHN0cmluZywgdW5rbm93bj4pOiB2b2lkIHtcbiAgICB0aGlzLmZsYWdWYWx1ZXMgPSBmbGFncztcbiAgICB0aGlzLmV4cG9zZWQuY2xlYXIoKTtcbiAgfVxuXG4gIHNldERlYnVnTW9kZShlbmFibGVkOiBib29sZWFuKTogdm9pZCB7XG4gICAgdGhpcy5kZWJ1Z01vZGUgPSBlbmFibGVkO1xuICAgIGlmIChlbmFibGVkKSB0aGlzLmxvYWREZWJ1Z092ZXJyaWRlcygpO1xuICB9XG5cbiAgLyoqIE92ZXJyaWRlIGEgZmxhZyB2YWx1ZSBmb3IgbG9jYWwgdGVzdGluZy4gT25seSBhY3RpdmUgd2hlbiBkZWJ1Zz10cnVlLiAqL1xuICBvdmVycmlkZUZsYWcoa2V5OiBzdHJpbmcsIHZhbHVlOiBGbGFnVmFsdWUpOiB2b2lkIHtcbiAgICB0aGlzLmRlYnVnT3ZlcnJpZGVzW2tleV0gPSB2YWx1ZTtcbiAgICB0aGlzLnNhdmVEZWJ1Z092ZXJyaWRlcygpO1xuICB9XG5cbiAgLyoqIENsZWFyIGFsbCBkZWJ1ZyBvdmVycmlkZXMuICovXG4gIGNsZWFyT3ZlcnJpZGVzKCk6IHZvaWQge1xuICAgIHRoaXMuZGVidWdPdmVycmlkZXMgPSB7fTtcbiAgICB0cnkge1xuICAgICAgbG9jYWxTdG9yYWdlLnJlbW92ZUl0ZW0oREVCVUdfT1ZFUlJJREVTX0tFWSk7XG4gICAgfSBjYXRjaCB7XG4gICAgICAvLyBubyBsb2NhbFN0b3JhZ2VcbiAgICB9XG4gIH1cblxuICAvKiogR2V0IGFsbCBjdXJyZW50IGRlYnVnIG92ZXJyaWRlcyAoZm9yIGRlYnVnIG1lbnUgVUkpLiAqL1xuICBnZXRPdmVycmlkZXMoKTogUmVjb3JkPHN0cmluZywgdW5rbm93bj4ge1xuICAgIHJldHVybiB7IC4uLnRoaXMuZGVidWdPdmVycmlkZXMgfTtcbiAgfVxuXG4gIGNvdW50KCk6IG51bWJlciB7XG4gICAgcmV0dXJuIE9iamVjdC5rZXlzKHRoaXMuZmxhZ1ZhbHVlcykubGVuZ3RoO1xuICB9XG5cbiAgZXZhbHVhdGUoXG4gICAgZmxhZ0tleTogc3RyaW5nLFxuICAgIGRlZmF1bHRWYWx1ZTogRmxhZ1ZhbHVlLFxuICAgIF91c2VySWQ6IHN0cmluZyB8IG51bGwsXG4gICAgX2F0dHJpYnV0ZXM6IFJlY29yZDxzdHJpbmcsIHVua25vd24+LFxuICAgIG9uRXhwb3N1cmU6IChmbGFnS2V5OiBzdHJpbmcsIHZhbHVlOiBGbGFnVmFsdWUpID0+IHZvaWQsXG4gICk6IEZsYWdWYWx1ZSB7XG4gICAgaWYgKHRoaXMuZGVidWdNb2RlICYmIGZsYWdLZXkgaW4gdGhpcy5kZWJ1Z092ZXJyaWRlcykge1xuICAgICAgcmV0dXJuIHRoaXMuZGVidWdPdmVycmlkZXNbZmxhZ0tleV0gYXMgRmxhZ1ZhbHVlO1xuICAgIH1cblxuICAgIGlmIChmbGFnS2V5IGluIHRoaXMuZmxhZ1ZhbHVlcykge1xuICAgICAgY29uc3QgdmFsdWUgPSB0aGlzLmZsYWdWYWx1ZXNbZmxhZ0tleV0gYXMgRmxhZ1ZhbHVlO1xuICAgICAgaWYgKCF0aGlzLmV4cG9zZWQuaGFzKGZsYWdLZXkpKSB7XG4gICAgICAgIHRoaXMuZXhwb3NlZC5hZGQoZmxhZ0tleSk7XG4gICAgICAgIG9uRXhwb3N1cmUoZmxhZ0tleSwgdmFsdWUpO1xuICAgICAgfVxuICAgICAgcmV0dXJuIHZhbHVlO1xuICAgIH1cblxuICAgIHJldHVybiBkZWZhdWx0VmFsdWU7XG4gIH1cblxuICBjbGVhckV4cG9zZWQoKTogdm9pZCB7XG4gICAgdGhpcy5leHBvc2VkLmNsZWFyKCk7XG4gIH1cblxuICBwcml2YXRlIGxvYWREZWJ1Z092ZXJyaWRlcygpOiB2b2lkIHtcbiAgICB0cnkge1xuICAgICAgY29uc3Qgc3RvcmVkID0gbG9jYWxTdG9yYWdlLmdldEl0ZW0oREVCVUdfT1ZFUlJJREVTX0tFWSk7XG4gICAgICBpZiAoc3RvcmVkKSB0aGlzLmRlYnVnT3ZlcnJpZGVzID0gSlNPTi5wYXJzZShzdG9yZWQpO1xuICAgIH0gY2F0Y2gge1xuICAgICAgLy8gbm8gbG9jYWxTdG9yYWdlIG9yIGludmFsaWQgSlNPTlxuICAgIH1cbiAgfVxuXG4gIHByaXZhdGUgc2F2ZURlYnVnT3ZlcnJpZGVzKCk6IHZvaWQge1xuICAgIHRyeSB7XG4gICAgICBsb2NhbFN0b3JhZ2Uuc2V0SXRlbShERUJVR19PVkVSUklERVNfS0VZLCBKU09OLnN0cmluZ2lmeSh0aGlzLmRlYnVnT3ZlcnJpZGVzKSk7XG4gICAgfSBjYXRjaCB7XG4gICAgICAvLyBubyBsb2NhbFN0b3JhZ2VcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/dist/flags.mjs

@@ -0,0 +1,2 @@
+export{a as FlagManager}from'./chunk-6BNLBHZS.mjs';//# sourceMappingURL=flags.mjs.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJmbGFncy5tanMifQ==