@lunora/flags 1.0.0-alpha.5 → 1.0.0-alpha.50

package/LICENSE.md

@@ -103,3 +103,9 @@ Unless required by applicable law or agreed to in writing, software distributed
 under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 CONDITIONS OF ANY KIND, either express or implied. See the License for the
 specific language governing permissions and limitations under the License.
+
+<!-- DEPENDENCIES -->
+<!-- /DEPENDENCIES -->
+
+<!-- TYPE_DEPENDENCIES -->
+<!-- /TYPE_DEPENDENCIES -->

package/README.md

@@ -79,7 +79,11 @@ export const listPosts = query(async (ctx) => {
 ```
 
 `ctx.flags` never throws: a missing flag, type mismatch, or provider error resolves
-with the `defaultValue`. The default `targetingKey` (from `identify`) is merged under
+with the `defaultValue`. It does not do so silently — a provider that fails to BIND
+(a missing binding, an unset token, a throwing `initialize`) is logged through
+`defineFlags({ logger })`, or on `console.error` when none is configured, since
+otherwise a misconfigured deployment serves every flag at its checked-in default
+with nothing to notice. The default `targetingKey` (from `identify`) is merged under
 any per-call context, and identical evaluations within one request are memoized.
 
 ## Exports

package/dist/index.d.mts

@@ -1,56 +1,97 @@
-import { a as FlagsConfig, b as FlagsDefinition, L as LunoraFlags } from "./packem_shared/types.d-BWygZiSc.mjs";
-export type { c as FlagsAuth, F as FlagsProviderFactory } from "./packem_shared/types.d-BWygZiSc.mjs";
-import { Hook, Logger, Provider } from '@openfeature/server-sdk';
+import { a as FlagsConfig, b as FlagsDefinition, L as LunoraFlags } from "./packem_shared/types.d-Bek9WZpB.mjs";
+export type { c as FlagsAuth, F as FlagsProviderFactory } from "./packem_shared/types.d-Bek9WZpB.mjs";
+import { Provider } from '@openfeature/server-sdk';
 export type { EvaluationContext, EvaluationDetails, Hook, JsonValue, Logger, Provider } from '@openfeature/server-sdk';
 /**
-* Declare the feature-flag provider for a Lunora app. Pure validation +
-* branding — codegen discovers the default export of `lunora/flags.ts`, imports
-* it into the generated worker, and wires `ctx.flags` from `provider` /
-* `identify` (mirrors how `defineQueue` / `defineWorkflow` feed codegen).
-*
-* ```ts
-* // lunora/flags.ts
-* import { defineFlags } from "@lunora/flags";
-* import { flagshipProvider } from "@lunora/flags/providers/flagship";
-*
-* export default defineFlags({
-*     provider: flagshipProvider({ binding: "FLAGS" }), // Cloudflare Flagship (binding mode)
-*     identify: (auth) => auth.userId ?? undefined,      // default targetingKey
-* });
-* ```
-*
-* Any OpenFeature provider works — Flagship is just the first-class default:
-*
-* ```ts
-* export default defineFlags({ provider: (env) => new SomeOpenFeatureProvider(env.SOME_KEY) });
-* ```
-*/
+ * Declare the feature-flag provider for a Lunora app. Pure validation +
+ * branding — codegen discovers the default export of `lunora/flags.ts`, imports
+ * it into the generated worker, and wires `ctx.flags` from `provider` /
+ * `identify` (mirrors how `defineQueue` / `defineWorkflow` feed codegen).
+ *
+ * ```ts
+ * // lunora/flags.ts
+ * import { defineFlags } from "@lunora/flags";
+ * import { flagshipProvider } from "@lunora/flags/providers/flagship";
+ *
+ * export default defineFlags({
+ *     provider: flagshipProvider({ binding: "FLAGS" }), // Cloudflare Flagship (binding mode)
+ *     identify: (auth) => auth.userId ?? undefined,      // default targetingKey
+ * });
+ * ```
+ *
+ * Any OpenFeature provider works — Flagship is just the first-class default:
+ *
+ * ```ts
+ * export default defineFlags({ provider: (env) => new SomeOpenFeatureProvider(env.SOME_KEY) });
+ * ```
+ */
 declare const defineFlags: (config: FlagsConfig) => FlagsDefinition;
 /** True when a value is a {@link defineFlags} result (the runtime brand check). */
 declare const isFlagsDefinition: (value: unknown) => value is FlagsDefinition;
-/** Options for `createFlags`. Built by codegen from `defineFlags(...)`. */
+/**
+ * Per-request extras for `createFlags`. Everything static — the provider
+ * factory, `hooks`, `logger` — is read from the {@link FlagsDefinition} itself,
+ * so this carries only what the definition cannot know: the test/config
+ * provider override and the request's targeting key.
+ */
 interface CreateFlagsOptions {
-  /** OpenFeature hooks applied when the provider is bound. */
-  hooks?: Hook[];
-  /** Logger for the OpenFeature client. */
-  logger?: Logger;
-  /** Lazily constructs the OpenFeature provider from `env` (invoked once per isolate). */
-  provider: () => Provider;
   /**
-  * Default `targetingKey` for every evaluation (from `defineFlags({ identify })`).
-  * May be a thunk — codegen passes one wrapping the user's `identify` — so a
-  * throwing `identify` fails open to no `targetingKey` rather than escaping
-  * ctx construction and taking down the whole request.
-  */
+   * Overrides the definition's provider (codegen's `config.flags` test seam).
+   * Returning `undefined` falls back to `definition.provider(env)`.
+   */
+  provider?: () => Provider | undefined;
+  /**
+   * Default `targetingKey` for every evaluation (from `defineFlags({ identify })`).
+   * May be a thunk — codegen passes one wrapping the user's `identify` — so a
+   * throwing `identify` fails open to no `targetingKey` rather than escaping
+   * ctx construction and taking down the whole request.
+   */
   targetingKey?: (() => string | undefined) | string;
 }
 /**
-* Builds the `ctx.flags` facade for a single request. Evaluations resolve
-* through the OpenFeature client (the SDK applies hooks and never throws —
-* provider errors surface as the default value with an `errorCode`). The default
-* `targetingKey` is merged under any per-call context, and identical evaluations
-* within the request are memoized so repeated reads of the same flag are
-* internally consistent and hit the provider once.
-*/
-declare const createFlags: (options: CreateFlagsOptions) => LunoraFlags;
-export { type CreateFlagsOptions, type FlagsConfig, type FlagsDefinition, type LunoraFlags, createFlags, defineFlags, isFlagsDefinition };
+ * Builds the `ctx.flags` facade for a single request. The provider, `hooks`,
+ * and `logger` come from `definition`; the client bind is memoized per
+ * (`definition`, `env`) pair — both stable object identities for the isolate's
+ * lifetime — and each pair owns its own OpenFeature domain, so a pair always
+ * evaluates against the provider it was configured with instead of whichever
+ * bind happened first. The bind is additionally attempted at most ONCE per
+ * request, so a broken deployment costs one `initialize` and one log line
+ * rather than one per flag read. Evaluations resolve through the
+ * OpenFeature client (the SDK applies hooks and never throws — provider errors
+ * surface as the default value with an `errorCode`). The default `targetingKey`
+ * is merged under any per-call context, and identical evaluations within the
+ * request are memoized so repeated reads of the same flag are internally
+ * consistent and hit the provider once.
+ */
+declare const createFlags: (definition: FlagsDefinition, env: Record<string, unknown>, options?: CreateFlagsOptions) => LunoraFlags;
+export { type CreateFlagsOptions, type FlagsConfig, type FlagsDefinition, type LunoraFlags, createFlags,
+/**
+ * `@lunora/flags`
+ *
+ * OpenFeature-based feature flags for Lunora. `defineFlags` in `lunora/flags.ts`
+ * configures an OpenFeature provider (Cloudflare Flagship by default, any
+ * provider pluggable); codegen wires `ctx.flags` onto every handler ctx from it.
+ *
+ * - `@lunora/flags` — `defineFlags`, the `createFlags` ctx facade, and types.
+ * - `@lunora/flags/providers/flagship` — the first-class Cloudflare Flagship provider.
+ * - `@lunora/flags/providers/memory` — a static, in-memory provider (tests/local/simple apps, zero extra deps).
+ * - `@lunora/flags/providers/env` — reads flags from the Worker `env` vars/secrets (zero deps).
+ * - `@lunora/flags/web` — optional browser OpenFeature provider (escape hatch).
+ * @packageDocumentation
+ */
+defineFlags,
+/**
+ * `@lunora/flags`
+ *
+ * OpenFeature-based feature flags for Lunora. `defineFlags` in `lunora/flags.ts`
+ * configures an OpenFeature provider (Cloudflare Flagship by default, any
+ * provider pluggable); codegen wires `ctx.flags` onto every handler ctx from it.
+ *
+ * - `@lunora/flags` — `defineFlags`, the `createFlags` ctx facade, and types.
+ * - `@lunora/flags/providers/flagship` — the first-class Cloudflare Flagship provider.
+ * - `@lunora/flags/providers/memory` — a static, in-memory provider (tests/local/simple apps, zero extra deps).
+ * - `@lunora/flags/providers/env` — reads flags from the Worker `env` vars/secrets (zero deps).
+ * - `@lunora/flags/web` — optional browser OpenFeature provider (escape hatch).
+ * @packageDocumentation
+ */
+isFlagsDefinition };

package/dist/index.d.ts

@@ -1,56 +1,97 @@
-import { a as FlagsConfig, b as FlagsDefinition, L as LunoraFlags } from "./packem_shared/types.d-BWygZiSc.js";
-export type { c as FlagsAuth, F as FlagsProviderFactory } from "./packem_shared/types.d-BWygZiSc.js";
-import { Hook, Logger, Provider } from '@openfeature/server-sdk';
+import { a as FlagsConfig, b as FlagsDefinition, L as LunoraFlags } from "./packem_shared/types.d-Bek9WZpB.js";
+export type { c as FlagsAuth, F as FlagsProviderFactory } from "./packem_shared/types.d-Bek9WZpB.js";
+import { Provider } from '@openfeature/server-sdk';
 export type { EvaluationContext, EvaluationDetails, Hook, JsonValue, Logger, Provider } from '@openfeature/server-sdk';
 /**
-* Declare the feature-flag provider for a Lunora app. Pure validation +
-* branding — codegen discovers the default export of `lunora/flags.ts`, imports
-* it into the generated worker, and wires `ctx.flags` from `provider` /
-* `identify` (mirrors how `defineQueue` / `defineWorkflow` feed codegen).
-*
-* ```ts
-* // lunora/flags.ts
-* import { defineFlags } from "@lunora/flags";
-* import { flagshipProvider } from "@lunora/flags/providers/flagship";
-*
-* export default defineFlags({
-*     provider: flagshipProvider({ binding: "FLAGS" }), // Cloudflare Flagship (binding mode)
-*     identify: (auth) => auth.userId ?? undefined,      // default targetingKey
-* });
-* ```
-*
-* Any OpenFeature provider works — Flagship is just the first-class default:
-*
-* ```ts
-* export default defineFlags({ provider: (env) => new SomeOpenFeatureProvider(env.SOME_KEY) });
-* ```
-*/
+ * Declare the feature-flag provider for a Lunora app. Pure validation +
+ * branding — codegen discovers the default export of `lunora/flags.ts`, imports
+ * it into the generated worker, and wires `ctx.flags` from `provider` /
+ * `identify` (mirrors how `defineQueue` / `defineWorkflow` feed codegen).
+ *
+ * ```ts
+ * // lunora/flags.ts
+ * import { defineFlags } from "@lunora/flags";
+ * import { flagshipProvider } from "@lunora/flags/providers/flagship";
+ *
+ * export default defineFlags({
+ *     provider: flagshipProvider({ binding: "FLAGS" }), // Cloudflare Flagship (binding mode)
+ *     identify: (auth) => auth.userId ?? undefined,      // default targetingKey
+ * });
+ * ```
+ *
+ * Any OpenFeature provider works — Flagship is just the first-class default:
+ *
+ * ```ts
+ * export default defineFlags({ provider: (env) => new SomeOpenFeatureProvider(env.SOME_KEY) });
+ * ```
+ */
 declare const defineFlags: (config: FlagsConfig) => FlagsDefinition;
 /** True when a value is a {@link defineFlags} result (the runtime brand check). */
 declare const isFlagsDefinition: (value: unknown) => value is FlagsDefinition;
-/** Options for `createFlags`. Built by codegen from `defineFlags(...)`. */
+/**
+ * Per-request extras for `createFlags`. Everything static — the provider
+ * factory, `hooks`, `logger` — is read from the {@link FlagsDefinition} itself,
+ * so this carries only what the definition cannot know: the test/config
+ * provider override and the request's targeting key.
+ */
 interface CreateFlagsOptions {
-  /** OpenFeature hooks applied when the provider is bound. */
-  hooks?: Hook[];
-  /** Logger for the OpenFeature client. */
-  logger?: Logger;
-  /** Lazily constructs the OpenFeature provider from `env` (invoked once per isolate). */
-  provider: () => Provider;
   /**
-  * Default `targetingKey` for every evaluation (from `defineFlags({ identify })`).
-  * May be a thunk — codegen passes one wrapping the user's `identify` — so a
-  * throwing `identify` fails open to no `targetingKey` rather than escaping
-  * ctx construction and taking down the whole request.
-  */
+   * Overrides the definition's provider (codegen's `config.flags` test seam).
+   * Returning `undefined` falls back to `definition.provider(env)`.
+   */
+  provider?: () => Provider | undefined;
+  /**
+   * Default `targetingKey` for every evaluation (from `defineFlags({ identify })`).
+   * May be a thunk — codegen passes one wrapping the user's `identify` — so a
+   * throwing `identify` fails open to no `targetingKey` rather than escaping
+   * ctx construction and taking down the whole request.
+   */
   targetingKey?: (() => string | undefined) | string;
 }
 /**
-* Builds the `ctx.flags` facade for a single request. Evaluations resolve
-* through the OpenFeature client (the SDK applies hooks and never throws —
-* provider errors surface as the default value with an `errorCode`). The default
-* `targetingKey` is merged under any per-call context, and identical evaluations
-* within the request are memoized so repeated reads of the same flag are
-* internally consistent and hit the provider once.
-*/
-declare const createFlags: (options: CreateFlagsOptions) => LunoraFlags;
-export { type CreateFlagsOptions, type FlagsConfig, type FlagsDefinition, type LunoraFlags, createFlags, defineFlags, isFlagsDefinition };
+ * Builds the `ctx.flags` facade for a single request. The provider, `hooks`,
+ * and `logger` come from `definition`; the client bind is memoized per
+ * (`definition`, `env`) pair — both stable object identities for the isolate's
+ * lifetime — and each pair owns its own OpenFeature domain, so a pair always
+ * evaluates against the provider it was configured with instead of whichever
+ * bind happened first. The bind is additionally attempted at most ONCE per
+ * request, so a broken deployment costs one `initialize` and one log line
+ * rather than one per flag read. Evaluations resolve through the
+ * OpenFeature client (the SDK applies hooks and never throws — provider errors
+ * surface as the default value with an `errorCode`). The default `targetingKey`
+ * is merged under any per-call context, and identical evaluations within the
+ * request are memoized so repeated reads of the same flag are internally
+ * consistent and hit the provider once.
+ */
+declare const createFlags: (definition: FlagsDefinition, env: Record<string, unknown>, options?: CreateFlagsOptions) => LunoraFlags;
+export { type CreateFlagsOptions, type FlagsConfig, type FlagsDefinition, type LunoraFlags, createFlags,
+/**
+ * `@lunora/flags`
+ *
+ * OpenFeature-based feature flags for Lunora. `defineFlags` in `lunora/flags.ts`
+ * configures an OpenFeature provider (Cloudflare Flagship by default, any
+ * provider pluggable); codegen wires `ctx.flags` onto every handler ctx from it.
+ *
+ * - `@lunora/flags` — `defineFlags`, the `createFlags` ctx facade, and types.
+ * - `@lunora/flags/providers/flagship` — the first-class Cloudflare Flagship provider.
+ * - `@lunora/flags/providers/memory` — a static, in-memory provider (tests/local/simple apps, zero extra deps).
+ * - `@lunora/flags/providers/env` — reads flags from the Worker `env` vars/secrets (zero deps).
+ * - `@lunora/flags/web` — optional browser OpenFeature provider (escape hatch).
+ * @packageDocumentation
+ */
+defineFlags,
+/**
+ * `@lunora/flags`
+ *
+ * OpenFeature-based feature flags for Lunora. `defineFlags` in `lunora/flags.ts`
+ * configures an OpenFeature provider (Cloudflare Flagship by default, any
+ * provider pluggable); codegen wires `ctx.flags` onto every handler ctx from it.
+ *
+ * - `@lunora/flags` — `defineFlags`, the `createFlags` ctx facade, and types.
+ * - `@lunora/flags/providers/flagship` — the first-class Cloudflare Flagship provider.
+ * - `@lunora/flags/providers/memory` — a static, in-memory provider (tests/local/simple apps, zero extra deps).
+ * - `@lunora/flags/providers/env` — reads flags from the Worker `env` vars/secrets (zero deps).
+ * - `@lunora/flags/web` — optional browser OpenFeature provider (escape hatch).
+ * @packageDocumentation
+ */
+isFlagsDefinition };

package/dist/index.mjs

@@ -1,2 +1 @@
-export { defineFlags, isFlagsDefinition } from './packem_shared/defineFlags-DAIO8cWQ.mjs';
-export { createFlags } from './packem_shared/createFlags-CEbcdnqZ.mjs';
+import{defineFlags as o,isFlagsDefinition as r}from"./packem_shared/defineFlags-BZhoR_h7.mjs";import{createFlags as f}from"./packem_shared/createFlags-D8e_hTbh.mjs";export{f as createFlags,o as defineFlags,r as isFlagsDefinition};

package/dist/packem_shared/createFlags-D8e_hTbh.mjs

@@ -0,0 +1 @@
+import{LunoraError as D}from"@lunora/errors";import{OpenFeature as E,ErrorCode as $}from"@openfeature/server-sdk";const A=/["\\\u0000-\u001F\uD800-\uDFFF]/,j=e=>A.test(e)?JSON.stringify(e):`"${e}"`,h=e=>{if(e===void 0)return"null";if(typeof e=="bigint")throw new TypeError("stableStringify: cannot use a bigint in a stable JSON cache key — pass it as a string, or use stableWireKey");if(typeof e=="number"){if(Number.isNaN(e))return"nan";if(e===1/0)return"inf";if(e===-1/0)return"-inf";if(Object.is(e,-0))return"-0"}if(typeof e=="string")return j(e);if(e===null||typeof e!="object")return JSON.stringify(e);if(Array.isArray(e)){let i="[";for(let l=0;l<e.length;l++)l>0&&(i+=","),i+=h(e[l]);return i+"]"}const c=Object.getPrototypeOf(e);if(c!==null&&c!==Object.prototype){const i=e.constructor?.name??"value";throw new TypeError(`stableStringify: cannot use a ${i} in a stable JSON cache key — only plain objects, arrays, and JSON primitives are supported (wire-typed values key via stableWireKey)`)}const a=e,s=Object.keys(a).sort();let n="{",u=!0;for(const i of s){const l=a[i];l!==void 0&&(u?u=!1:n+=",",n+=j(i),n+=":",n+=h(l))}return n+"}"},S="lunora";let O=new WeakMap,p=0;const C={},M=e=>Object.keys(e).length===0?C:e,T=e=>typeof e?.then=="function",W=(e,c)=>{const a=`@lunora/flags: could not bind the OpenFeature provider — every flag read falls back to its caller-supplied default until this is fixed: ${c instanceof Error?c.message:String(c)}`;if(e)try{const s=e.error(a);T(s)&&s.catch(()=>{});return}catch{}console.error(a)},J=(e,c,a)=>{const s=M(c);let n=O.get(e);n===void 0&&(n=new WeakMap,O.set(e,n));let u=n.get(s);if(u===void 0&&(p+=1,u={domain:p===1?S:`${S}-${String(p)}`},n.set(s,u)),u.client!==void 0)return u.client;const i=u,{domain:l}=i,{hooks:b,logger:d}=e,g=(async()=>{await E.setProviderAndWait(l,a());const t=E.getClient(l);return d&&t.setLogger(d),b&&b.length>0&&t.addHooks(...b),t})();return i.client=g,g.catch(t=>{i.client===g&&(i.client=void 0),W(d,t)}).catch(()=>{}),g},B=async()=>{O=new WeakMap,p=0,await E.clearProviders()},L=(e,c,a,s)=>{const n=h([e,c,a]);return Object.keys(s).length===0?`${n}:{}`:`${n}:${h(s)}`},P=(e,c,a,s,n)=>{switch(c){case"boolean":return e.getBooleanDetails(a,s,n);case"number":return e.getNumberDetails(a,s,n);case"object":return e.getObjectDetails(a,s,n);case"string":return e.getStringDetails(a,s,n);default:throw new D("INTERNAL",`createFlags: unknown flag type "${c}"`)}},_=(e,c,a={})=>{const{provider:s,targetingKey:n}=a,u=()=>s?.()??e.provider(c);let i;try{i=typeof n=="function"?n():n}catch{i=void 0}const l=new Map;let b;const d=()=>(b??=J(e,c,u),b),g=(t,r,o,f)=>{const k=i===void 0?{...f}:{targetingKey:i,...f},F=y=>({errorCode:$.GENERAL,errorMessage:y instanceof Error?y.message:String(y),flagKey:r,flagMetadata:{},reason:"ERROR",value:o}),w=()=>d().then(y=>P(y,t,r,o,k)).catch(F);let m;try{m=L(t,r,o,k)}catch{return w()}const v=l.get(m);if(v)return v;const N=w();return l.set(m,N),N};return{boolean:(t,r,o)=>g("boolean",t,r,o).then(f=>f.value),details:{boolean:(t,r,o)=>g("boolean",t,r,o),number:(t,r,o)=>g("number",t,r,o),object:(t,r,o)=>g("object",t,r,o),string:(t,r,o)=>g("string",t,r,o)},number:(t,r,o)=>g("number",t,r,o).then(f=>f.value),object:(t,r,o)=>g("object",t,r,o).then(f=>f.value),string:(t,r,o)=>g("string",t,r,o).then(f=>f.value)}};export{_ as createFlags,B as resetFlags};

package/dist/packem_shared/defineFlags-BZhoR_h7.mjs

@@ -0,0 +1 @@
+const r=e=>{if(typeof e.provider!="function")throw new TypeError('defineFlags: `provider` must be a function `(env) => Provider` (e.g. flagshipProvider({ binding: "FLAGS" }))');if(e.identify!==void 0&&typeof e.identify!="function")throw new TypeError("defineFlags: `identify` must be a function `(auth) => string | undefined` when provided");if(e.hooks!==void 0&&!Array.isArray(e.hooks))throw new TypeError("defineFlags: `hooks` must be an array of OpenFeature hooks when provided");return{...e,isLunoraFlags:!0}},i=e=>typeof e=="object"&&e!==null&&e.isLunoraFlags===!0;export{r as defineFlags,i as isFlagsDefinition};

package/dist/packem_shared/{types.d-BWygZiSc.d.mts → types.d-Bek9WZpB.d.mts}

@@ -1,18 +1,18 @@
 import { Hook, Logger, Provider, EvaluationContext, EvaluationDetails, JsonValue } from '@openfeature/server-sdk';
 /**
-* The flag-evaluation surface spliced onto every Lunora `ctx` as `ctx.flags`
-* (query / mutation / action) by codegen when an app wires `@lunora/flags`.
-*
-* Every method resolves through the configured OpenFeature provider and **never
-* throws** — on a missing flag, type mismatch, provider error, or
-* misconfiguration it resolves with the supplied `defaultValue`. Use the
-* `details.*` variants when you need the full {@link EvaluationDetails} (reason,
-* variant, `errorCode`, `errorMessage`) alongside the value.
-*
-* The optional per-call `context` is merged on top of the default targeting
-* context (the `targetingKey` derived from `defineFlags({ identify })`), so a
-* call can add or override targeting attributes for that single evaluation.
-*/
+ * The flag-evaluation surface spliced onto every Lunora `ctx` as `ctx.flags`
+ * (query / mutation / action) by codegen when an app wires `@lunora/flags`.
+ *
+ * Every method resolves through the configured OpenFeature provider and **never
+ * throws** — on a missing flag, type mismatch, provider error, or
+ * misconfiguration it resolves with the supplied `defaultValue`. Use the
+ * `details.*` variants when you need the full {@link EvaluationDetails} (reason,
+ * variant, `errorCode`, `errorMessage`) alongside the value.
+ *
+ * The optional per-call `context` is merged on top of the default targeting
+ * context (the `targetingKey` derived from `defineFlags({ identify })`), so a
+ * call can add or override targeting attributes for that single evaluation.
+ */
 interface LunoraFlags {
   /** Resolve a boolean flag (feature on/off). */
   boolean: (flagKey: string, defaultValue: boolean, context?: EvaluationContext) => Promise<boolean>;
@@ -31,11 +31,11 @@ interface LunoraFlags {
   string: (flagKey: string, defaultValue: string, context?: EvaluationContext) => Promise<string>;
 }
 /**
-* The resolved request auth handed to {@link FlagsConfig.identify} so an app can
-* derive the default OpenFeature `targetingKey` (usually the authenticated user
-* id). This mirrors the `auth` shape the runtime already threads into other ctx
-* helpers, so `identify` never needs the full ctx.
-*/
+ * The resolved request auth handed to {@link FlagsConfig.identify} so an app can
+ * derive the default OpenFeature `targetingKey` (usually the authenticated user
+ * id). This mirrors the `auth` shape the runtime already threads into other ctx
+ * helpers, so `identify` never needs the full ctx.
+ */
 interface FlagsAuth {
   /** The verified identity claims for the request, or `null` when anonymous. */
   identity: Record<string, unknown> | null;
@@ -43,41 +43,41 @@ interface FlagsAuth {
   userId: string | null;
 }
 /**
-* Builds the OpenFeature {@link Provider} for the request from the Worker `env`.
-*
-* Receiving `env` (rather than a constructed provider) is what lets the Flagship
-* binding provider read `env.FLAGS` at request time — matching the existing
-* `config.ai?.(env)` thunk pattern. Construction is memoized per DO isolate, so
-* this factory is invoked once per isolate, not once per request.
-*/
+ * Builds the OpenFeature {@link Provider} for the request from the Worker `env`.
+ *
+ * Receiving `env` (rather than a constructed provider) is what lets the Flagship
+ * binding provider read `env.FLAGS` at request time — matching the existing
+ * `config.ai?.(env)` thunk pattern. Construction is memoized per DO isolate, so
+ * this factory is invoked once per isolate, not once per request.
+ */
 type FlagsProviderFactory = (env: Record<string, unknown>) => Provider;
 /** Options accepted by `defineFlags`. */
 interface FlagsConfig {
   /**
-  * OpenFeature hooks run on every evaluation (logging, telemetry, …). Applied
-  * to the Lunora flags client when the provider is bound.
-  */
+   * OpenFeature hooks run on every evaluation (logging, telemetry, …). Applied
+   * to the Lunora flags client when the provider is bound.
+   */
   hooks?: Hook[];
   /**
-  * Derives the default OpenFeature `targetingKey` from the request auth. Most
-  * apps return the user id: `identify: (auth) => auth.userId ?? undefined`.
-  * A per-call `context.targetingKey` still overrides this.
-  */
+   * Derives the default OpenFeature `targetingKey` from the request auth. Most
+   * apps return the user id: `identify: (auth) => auth.userId ?? undefined`.
+   * A per-call `context.targetingKey` still overrides this.
+   */
   identify?: (auth: FlagsAuth) => string | undefined;
   /** Logger for the OpenFeature client (provider + SDK diagnostics). */
   logger?: Logger;
   /**
-  * The OpenFeature provider factory. Use `flagshipProvider(...)` from
-  * `@lunora/flags/providers/flagship`, or return any OpenFeature provider:
-  * `provider: (env) => new LaunchDarklyProvider(env.LD_KEY)`.
-  */
+   * The OpenFeature provider factory. Use `flagshipProvider(...)` from
+   * `@lunora/flags/providers/flagship`, or return any OpenFeature provider:
+   * `provider: (env) => new LaunchDarklyProvider(env.LD_KEY)`.
+   */
   provider: FlagsProviderFactory;
 }
 /**
-* A branded {@link FlagsConfig} produced by `defineFlags`. This is the
-* default export of `lunora/flags.ts`; codegen imports it into the generated
-* worker and wires `ctx.flags` from its `provider` / `identify`.
-*/
+ * A branded {@link FlagsConfig} produced by `defineFlags`. This is the
+ * default export of `lunora/flags.ts`; codegen imports it into the generated
+ * worker and wires `ctx.flags` from its `provider` / `identify`.
+ */
 interface FlagsDefinition extends FlagsConfig {
   /** Runtime brand used by `isFlagsDefinition` and codegen discovery. */
   readonly isLunoraFlags: true;

package/dist/packem_shared/{types.d-BWygZiSc.d.ts → types.d-Bek9WZpB.d.ts}

@@ -1,18 +1,18 @@
 import { Hook, Logger, Provider, EvaluationContext, EvaluationDetails, JsonValue } from '@openfeature/server-sdk';
 /**
-* The flag-evaluation surface spliced onto every Lunora `ctx` as `ctx.flags`
-* (query / mutation / action) by codegen when an app wires `@lunora/flags`.
-*
-* Every method resolves through the configured OpenFeature provider and **never
-* throws** — on a missing flag, type mismatch, provider error, or
-* misconfiguration it resolves with the supplied `defaultValue`. Use the
-* `details.*` variants when you need the full {@link EvaluationDetails} (reason,
-* variant, `errorCode`, `errorMessage`) alongside the value.
-*
-* The optional per-call `context` is merged on top of the default targeting
-* context (the `targetingKey` derived from `defineFlags({ identify })`), so a
-* call can add or override targeting attributes for that single evaluation.
-*/
+ * The flag-evaluation surface spliced onto every Lunora `ctx` as `ctx.flags`
+ * (query / mutation / action) by codegen when an app wires `@lunora/flags`.
+ *
+ * Every method resolves through the configured OpenFeature provider and **never
+ * throws** — on a missing flag, type mismatch, provider error, or
+ * misconfiguration it resolves with the supplied `defaultValue`. Use the
+ * `details.*` variants when you need the full {@link EvaluationDetails} (reason,
+ * variant, `errorCode`, `errorMessage`) alongside the value.
+ *
+ * The optional per-call `context` is merged on top of the default targeting
+ * context (the `targetingKey` derived from `defineFlags({ identify })`), so a
+ * call can add or override targeting attributes for that single evaluation.
+ */
 interface LunoraFlags {
   /** Resolve a boolean flag (feature on/off). */
   boolean: (flagKey: string, defaultValue: boolean, context?: EvaluationContext) => Promise<boolean>;
@@ -31,11 +31,11 @@ interface LunoraFlags {
   string: (flagKey: string, defaultValue: string, context?: EvaluationContext) => Promise<string>;
 }
 /**
-* The resolved request auth handed to {@link FlagsConfig.identify} so an app can
-* derive the default OpenFeature `targetingKey` (usually the authenticated user
-* id). This mirrors the `auth` shape the runtime already threads into other ctx
-* helpers, so `identify` never needs the full ctx.
-*/
+ * The resolved request auth handed to {@link FlagsConfig.identify} so an app can
+ * derive the default OpenFeature `targetingKey` (usually the authenticated user
+ * id). This mirrors the `auth` shape the runtime already threads into other ctx
+ * helpers, so `identify` never needs the full ctx.
+ */
 interface FlagsAuth {
   /** The verified identity claims for the request, or `null` when anonymous. */
   identity: Record<string, unknown> | null;
@@ -43,41 +43,41 @@ interface FlagsAuth {
   userId: string | null;
 }
 /**
-* Builds the OpenFeature {@link Provider} for the request from the Worker `env`.
-*
-* Receiving `env` (rather than a constructed provider) is what lets the Flagship
-* binding provider read `env.FLAGS` at request time — matching the existing
-* `config.ai?.(env)` thunk pattern. Construction is memoized per DO isolate, so
-* this factory is invoked once per isolate, not once per request.
-*/
+ * Builds the OpenFeature {@link Provider} for the request from the Worker `env`.
+ *
+ * Receiving `env` (rather than a constructed provider) is what lets the Flagship
+ * binding provider read `env.FLAGS` at request time — matching the existing
+ * `config.ai?.(env)` thunk pattern. Construction is memoized per DO isolate, so
+ * this factory is invoked once per isolate, not once per request.
+ */
 type FlagsProviderFactory = (env: Record<string, unknown>) => Provider;
 /** Options accepted by `defineFlags`. */
 interface FlagsConfig {
   /**
-  * OpenFeature hooks run on every evaluation (logging, telemetry, …). Applied
-  * to the Lunora flags client when the provider is bound.
-  */
+   * OpenFeature hooks run on every evaluation (logging, telemetry, …). Applied
+   * to the Lunora flags client when the provider is bound.
+   */
   hooks?: Hook[];
   /**
-  * Derives the default OpenFeature `targetingKey` from the request auth. Most
-  * apps return the user id: `identify: (auth) => auth.userId ?? undefined`.
-  * A per-call `context.targetingKey` still overrides this.
-  */
+   * Derives the default OpenFeature `targetingKey` from the request auth. Most
+   * apps return the user id: `identify: (auth) => auth.userId ?? undefined`.
+   * A per-call `context.targetingKey` still overrides this.
+   */
   identify?: (auth: FlagsAuth) => string | undefined;
   /** Logger for the OpenFeature client (provider + SDK diagnostics). */
   logger?: Logger;
   /**
-  * The OpenFeature provider factory. Use `flagshipProvider(...)` from
-  * `@lunora/flags/providers/flagship`, or return any OpenFeature provider:
-  * `provider: (env) => new LaunchDarklyProvider(env.LD_KEY)`.
-  */
+   * The OpenFeature provider factory. Use `flagshipProvider(...)` from
+   * `@lunora/flags/providers/flagship`, or return any OpenFeature provider:
+   * `provider: (env) => new LaunchDarklyProvider(env.LD_KEY)`.
+   */
   provider: FlagsProviderFactory;
 }
 /**
-* A branded {@link FlagsConfig} produced by `defineFlags`. This is the
-* default export of `lunora/flags.ts`; codegen imports it into the generated
-* worker and wires `ctx.flags` from its `provider` / `identify`.
-*/
+ * A branded {@link FlagsConfig} produced by `defineFlags`. This is the
+ * default export of `lunora/flags.ts`; codegen imports it into the generated
+ * worker and wires `ctx.flags` from its `provider` / `identify`.
+ */
 interface FlagsDefinition extends FlagsConfig {
   /** Runtime brand used by `isFlagsDefinition` and codegen discovery. */
   readonly isLunoraFlags: true;