@stratal/feature-flags 0.0.0-canary-e5681b8

package/CHANGELOG.md

@@ -0,0 +1,131 @@
+# @stratal/feature-flags
+
+## 0.0.0-canary-e5681b8
+
+### Patch Changes
+
+- e5681b8: Release alongside the rest of the packages; nothing changed in this one.
+
+  Every Stratal package is versioned as one fixed group, so `@stratal/feature-flags` is republished at the same version as the packages it builds on rather than being left behind. Its peer ranges are open-ended, so an existing install keeps resolving — upgrade only to keep one aligned set of versions across the framework.
+
+- Updated dependencies [e5681b8]
+- Updated dependencies [e5681b8]
+  - stratal@0.0.0-canary-e5681b8
+  - @stratal/inertia@0.0.0-canary-e5681b8
+
+## 0.1.0
+
+### Patch Changes
+
+- a753e55: Release alongside the rest of the packages; nothing changed in this one.
+
+  Every Stratal package is versioned as one fixed group, so `@stratal/feature-flags` is republished at the same version as the packages it builds on rather than being left behind. Its peer ranges are open-ended, so an existing install keeps resolving — upgrade only to keep one aligned set of versions across the framework.
+
+- Updated dependencies [a753e55]
+- Updated dependencies [a753e55]
+  - stratal@0.1.0
+  - @stratal/inertia@0.1.0
+
+## 0.0.27
+
+### Patch Changes
+
+- 41a9140: Make feature flag evaluation resilient to runtime failures
+
+  Flag evaluation now returns the fallback value and logs a warning if a lookup throws — for example when a remote-binding dev tunnel drops — rather than failing the request. Detail methods return an `ERROR` reason with the fallback in these cases.
+
+- Updated dependencies [41a9140]
+  - stratal@0.0.27
+  - @stratal/inertia@0.0.27
+
+## 0.0.26
+
+### Patch Changes
+
+- Updated dependencies [ab95f52]
+- Updated dependencies [ab95f52]
+- Updated dependencies [bb6d3b9]
+  - stratal@0.0.26
+  - @stratal/inertia@0.0.26
+
+## 0.0.25
+
+### Patch Changes
+
+- Updated dependencies [e93db60]
+- Updated dependencies [e93db60]
+  - stratal@0.0.25
+  - @stratal/inertia@0.0.25
+
+## 0.0.24
+
+### Patch Changes
+
+- Updated dependencies [10cf223]
+  - @stratal/inertia@0.0.24
+  - stratal@0.0.24
+
+## 0.0.23
+
+### Patch Changes
+
+- 13b0e8d: Add `@stratal/feature-flags` — Cloudflare Flagship feature flags via the native Worker binding API.
+  - `FeatureFlagModule.forRoot({ apps: [{ binding, flags }], default, context })` with a declare-once flag manifest, manifest defaults, a per-request evaluation-context resolver, and multi-app support via `FeatureFlagService.use(binding)`.
+  - `FeatureFlagShareMiddleware` shares evaluated flags to Inertia pages as the `featureFlags` prop; register it yourself (scoped to page controllers via `router.middleware(...)` or app-wide via `router.use(...)`) so a stalled Flagship binding can't block unrelated routes. Typed `useFlag` / `useFeatureFlags` hooks on `@stratal/feature-flags/react`. No runtime dependency on `@stratal/inertia`.
+  - `@stratal/inertia`: expose a generic `ctx.share(key, value)` macro on `RouterContext` so middleware and packages can contribute per-request shared props.
+  - `@stratal/framework`: add a `ctx.user()` macro on `RouterContext` (shorthand for `AuthContext.requireUser()`).
+
+- 13b0e8d: Fix correctness and security issues found in review.
+
+  Queue:
+  - Retry the correct binding: dispatch stamps the producer binding into message metadata and failed jobs record it, so `queue:retry` re-enqueues through the Cloudflare binding instead of the queue name (which is not a valid binding key and broke retry whenever the two differed). A message with no binding metadata is logged and acked rather than stored as an unretryable job.
+  - Honor the documented retry budget: `maxRetries` now counts retries correctly against Cloudflare's 1-based `message.attempts` (previously gave one fewer retry than configured).
+  - Derive idempotency keys from an order-stable serialization of `type` + `payload`, so payloads that differ only in key order dedupe correctly.
+  - `queue:retry --all` / `queue:purge --all --queue` collect matching keys before deleting, so cursor pagination no longer skips jobs; `queue:failed --queue --limit` now counts matching jobs rather than scanned keys.
+  - Documented that delivery is at-least-once with best-effort de-duplication (not exactly-once), since the processed marker is written only after a handler succeeds and KV is eventually consistent — handlers must be idempotent.
+
+  Email (SMTP):
+  - Upgrade STARTTLS onto the socket `startTls()` returns: the original socket is closed by the runtime, so the post-upgrade reader/writer are re-derived from the new secure socket and any pre-handshake bytes are discarded (fixes a broken `smtp://` STARTTLS path on real Workers and closes the STARTTLS plaintext-injection vector).
+  - Refuse to send credentials over an unencrypted connection: an `smtp://` server that doesn't offer STARTTLS now fails loudly instead of leaking the password (blocks STARTTLS-stripping downgrades). Credential-free connections (e.g. local Mailpit) are unaffected.
+  - AUTH is gated on the server's advertised mechanisms and supports both `PLAIN` and `LOGIN`; usernames are percent-decoded like passwords.
+  - Add a response timeout so a hung SMTP server can't wedge the worker; QUIT/socket close are now best-effort and never mask a successful send.
+  - MIME builder strips CR/LF from headers, escapes/RFC 2231-encodes attachment filenames (prevents header injection), base64-encodes message bodies (fixes long-line corruption), and rejects envelope addresses containing whitespace or angle brackets (prevents `MAIL FROM`/`RCPT TO` desync).
+
+  Inertia SEO:
+  - `titleTemplate` substitutes every `%s` and treats `$`-sequences in the title literally.
+  - Inject head/body content via function replacements, so SEO/page content containing `$`-sequences (`$$`, `$&`, `` $` ``, `$'`) is no longer corrupted or able to splice a template placeholder back into the output.
+  - Drop unsafe attribute names — including inline event handlers (`on*`) — from custom `meta`/`link` entries (prevents tag breakout server-side, `setAttribute` errors during client head-sync, and developer-supplied event-handler attributes).
+
+  Feature flags:
+  - `FeatureFlagService.use()` binds the target app exactly once.
+
+  Database (framework):
+  - The reentrant `$transaction` proxy forwards the receiver for non-transaction property access.
+
+  Testing:
+  - `TestingModule.close()` drops the isolated per-file database even if shutdown throws; the stale-database sweep escapes LIKE metacharacters so a prefix containing `_` can't over-match.
+
+  DI:
+  - Construct singletons against the root container so they can never capture a request-scoped dependency (which would leak one request's state across every later request); an illegal singleton→request dependency now throws loudly.
+  - Detect circular dependencies and throw a clear error naming the cycle instead of overflowing the stack.
+  - `tryResolve` only swallows "no provider"; a registered provider that throws while constructing now surfaces the real error instead of injecting `undefined`.
+  - Request-cache invalidation tracks transitive constructor dependencies, so re-registering a value rebuilds cached services that depend on it through a transient intermediary.
+
+  Quarry dev runtime:
+  - Persist every durable plugin (KV, D1, R2, Durable Objects, cache) under `.wrangler/state/v3`, matching `wrangler dev` (previously only R2 was persisted); load `.env.local` / `.env.<env>.local` into `process.env` for full parity.
+  - The `cloudflare:sockets` STARTTLS shim re-attaches the stream error handler to the upgraded socket, so post-upgrade connection errors still surface.
+
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [13b0e8d]
+- Updated dependencies [be813bc]
+  - stratal@0.0.23
+  - @stratal/inertia@0.0.23

package/README.md

@@ -0,0 +1,90 @@
+# @stratal/feature-flags
+
+[Cloudflare Flagship](https://developers.cloudflare.com/flagship/) feature flags for the [Stratal](https://stratal.dev) framework, using the native Worker **binding API** — with opt-in [Inertia.js](https://inertiajs.com) sharing and typed React hooks.
+
+[![npm version](https://img.shields.io/npm/v/@stratal/feature-flags)](https://www.npmjs.com/package/@stratal/feature-flags)
+[![CI](https://github.com/strataljs/stratal/actions/workflows/ci.yml/badge.svg)](https://github.com/strataljs/stratal/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![npm downloads](https://img.shields.io/npm/dm/@stratal/feature-flags)](https://www.npmjs.com/package/@stratal/feature-flags)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5-blue?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/strataljs/stratal/pulls)
+[![GitHub stars](https://img.shields.io/github/stars/strataljs/stratal?style=social)](https://github.com/strataljs/stratal)
+
+## Install
+
+```bash
+npm i @stratal/feature-flags
+```
+
+Add the Flagship binding to your Wrangler config and run `npx wrangler types`:
+
+```jsonc
+// wrangler.jsonc
+{ "flagship": [{ "binding": "FLAGS", "app_id": "<APP_ID>" }] }
+```
+
+## Usage
+
+```ts
+import { FeatureFlagModule } from '@stratal/feature-flags'
+
+@Module({
+  imports: [
+    FeatureFlagModule.forRoot({
+      apps: [{ binding: 'FLAGS', flags: { 'new-checkout': false } }],
+      context: (ctx) => ({ userId: ctx.user().id }), // ctx.user() from @stratal/framework
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+A Worker can bind to several Flagship apps — list each one under `apps`, and set `default` to pick the binding the injected `FeatureFlagService` uses. Flagship has no enumeration API, so the `flags` manifest declares what you intend to evaluate and share, and its values double as defaults.
+
+To expose flags to an Inertia frontend, register `FeatureFlagShareMiddleware` where you want them — scoped to your page-rendering controllers (`router.middleware(...)`) or app-wide (`router.use(...)`).
+
+Evaluate on the server:
+
+```ts
+const enabled = await this.flags.getBooleanValue('new-checkout') // uses manifest default
+```
+
+`getStringValue()`, `getNumberValue()` and `getObjectValue()` cover the other flag types, each with a `*Details()` variant that returns the full evaluation details. `use(binding)` switches to another bound app, and `all()` evaluates the whole manifest at once.
+
+Read on the client:
+
+```tsx
+import { useFeatureFlags, useFlag } from '@stratal/feature-flags/react'
+
+const showNewCheckout = useFlag('new-checkout')
+const flags = useFeatureFlags()
+```
+
+## Typed flag keys
+
+Augment `FeatureFlagRegistry` once and both the service and the hooks get typed keys:
+
+```ts
+declare module '@stratal/feature-flags' {
+  interface FeatureFlagRegistry {
+    'new-checkout': boolean
+    'checkout-flow': string
+  }
+}
+```
+
+## Documentation
+
+See the framework docs at **[stratal.dev](https://stratal.dev)** for the full API.
+
+## Support the project
+
+If Stratal is useful to you, **[star the repository](https://github.com/strataljs/stratal)** — it is the simplest way to help others find it.
+
+## Maintainer
+
+Built and maintained by **Temitayo Fadojutimi** — [@adesege_](https://x.com/adesege_).
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,185 @@
+import { a as FlagValue, i as FlagManifest, n as FeatureFlagModuleOptions, o as FlagshipBindingName, r as FeatureFlagRegistry, t as FeatureFlagApp } from "./types-D-uV0zlC.mjs";
+import { AsyncModuleOptions, DynamicModule } from "stratal/module";
+import { LoggerService } from "stratal/logger";
+import { Middleware, Next, RouterContext } from "stratal/router";
+import { ApplicationError } from "stratal/errors";
+import { StratalEnv } from "stratal";
+//#region src/feature-flags.module.d.ts
+/**
+ * Feature Flag Module
+ *
+ * Evaluates Cloudflare Flagship feature flags through the native Worker binding.
+ * Declare your apps (and the flags you use) once; inject {@link FeatureFlagService}
+ * to evaluate them.
+ *
+ * To expose flags to an Inertia frontend, register {@link FeatureFlagShareMiddleware}
+ * yourself — scope it to the controllers that render pages (`router.middleware(...)`)
+ * or app-wide (`router.use(...)`) from a module's `configureRoutes`. It is not
+ * registered for you, so a stalled Flagship binding never blocks unrelated routes.
+ *
+ * @example
+ * ```typescript
+ * FeatureFlagModule.forRoot({
+ *   apps: [{ binding: 'FLAGS', flags: { 'new-checkout': false } }],
+ *   context: (ctx) => ({ userId: ctx.user().id }), // ctx.user() from @stratal/framework
+ * })
+ *
+ * // Or async, from config namespaces:
+ * FeatureFlagModule.forRootAsync({
+ *   inject: [flagsConfig.KEY],
+ *   useFactory: (cfg) => ({ apps: cfg.apps, default: cfg.default }),
+ * })
+ * ```
+ */
+export declare class FeatureFlagModule {
+  /** Configure with static options. */
+  static forRoot(options: FeatureFlagModuleOptions): DynamicModule;
+  /** Configure with an async factory (when options depend on other services). */
+  static forRootAsync(options: AsyncModuleOptions<FeatureFlagModuleOptions>): DynamicModule;
+}
+//#endregion
+//#region src/services/feature-flag.service.d.ts
+/**
+ * Feature Flag Service
+ *
+ * Type-safe wrapper around a Cloudflare Flagship binding (`env.FLAGS`). Mirrors
+ * the binding's evaluation methods 1:1, with two ergonomic additions:
+ *
+ * - **Manifest defaults** — when you omit a default, the value declared in the
+ *   app's `flags` manifest is used (an explicit argument always wins).
+ * - **Default context** — the module's `context` resolver is merged into every
+ *   evaluation (per-call context overrides it). Resolved from the current
+ *   request; skipped automatically outside request scope.
+ *
+ * Switch to another Flagship app with {@link use}. Evaluation never throws —
+ * the binding returns the default value on evaluation errors, and the service
+ * catches everything else (e.g. a dropped remote-binding tunnel in local dev)
+ * and returns the same fallback, logging a warning.
+ *
+ * @example
+ * ```typescript
+ * @inject(FEATURE_FLAG_TOKENS.FeatureFlagService)
+ * private readonly flags: FeatureFlagService
+ *
+ * const enabled = await this.flags.getBooleanValue('new-checkout')        // manifest default
+ * const layout  = await this.flags.use('EXPERIMENT_FLAGS').getStringValue('layout', 'v1')
+ * ```
+ *
+ * @see https://developers.cloudflare.com/flagship/binding/
+ */
+export declare class FeatureFlagService {
+  private readonly options;
+  private readonly env;
+  private readonly routerContext;
+  private readonly logger;
+  private readonly apps;
+  private bindingName;
+  private binding;
+  private manifest;
+  constructor(options: FeatureFlagModuleOptions, env: StratalEnv, routerContext: RouterContext | undefined, logger: LoggerService | undefined, initialBinding?: string);
+  /**
+   * Switch to a different configured Flagship app.
+   *
+   * Returns a new immutable instance bound to `binding`; the original is
+   * unchanged. The binding must be declared in the module's `apps`.
+   */
+  use(binding: FlagshipBindingName): FeatureFlagService;
+  /** The binding name this instance currently targets. */
+  get app(): string;
+  /** Returns the raw flag value without type checking. */
+  get(flagKey: string, defaultValue?: unknown, context?: FlagshipEvaluationContext): Promise<unknown>;
+  /** Returns the flag value as a `boolean`. */
+  getBooleanValue(flagKey: string, defaultValue?: boolean, context?: FlagshipEvaluationContext): Promise<boolean>;
+  /** Returns the flag value as a `string`. */
+  getStringValue(flagKey: string, defaultValue?: string, context?: FlagshipEvaluationContext): Promise<string>;
+  /** Returns the flag value as a `number`. */
+  getNumberValue(flagKey: string, defaultValue?: number, context?: FlagshipEvaluationContext): Promise<number>;
+  /** Returns the flag value as a typed object. */
+  getObjectValue<T extends object>(flagKey: string, defaultValue?: T, context?: FlagshipEvaluationContext): Promise<T>;
+  /** Returns the `boolean` flag value with evaluation metadata. */
+  getBooleanDetails(flagKey: string, defaultValue?: boolean, context?: FlagshipEvaluationContext): Promise<FlagshipEvaluationDetails<boolean>>;
+  /** Returns the `string` flag value with evaluation metadata. */
+  getStringDetails(flagKey: string, defaultValue?: string, context?: FlagshipEvaluationContext): Promise<FlagshipEvaluationDetails<string>>;
+  /** Returns the `number` flag value with evaluation metadata. */
+  getNumberDetails(flagKey: string, defaultValue?: number, context?: FlagshipEvaluationContext): Promise<FlagshipEvaluationDetails<number>>;
+  /** Returns the typed object flag value with evaluation metadata. */
+  getObjectDetails<T extends object>(flagKey: string, defaultValue?: T, context?: FlagshipEvaluationContext): Promise<FlagshipEvaluationDetails<T>>;
+  /**
+   * Evaluates every flag declared in the current app's manifest and returns a
+   * `{ key: value }` map. The evaluation method is chosen from each declared
+   * default's type. Powers `FeatureFlagShareMiddleware`.
+   */
+  all(context?: FlagshipEvaluationContext): Promise<Record<string, FlagValue>>;
+  private bindTo;
+  /** Resolves the merged evaluation context (default context + per-call override). */
+  private context;
+  /** Picks the default: explicit arg, then manifest, then the type's zero value. */
+  private fallback;
+  /** Evaluates a single flag, choosing the method from the declared default's type. */
+  private evaluate;
+  /**
+   * Runs an evaluation and absorbs any failure into the fallback. The binding
+   * already returns the default on evaluation errors, but the call itself can
+   * still reject — e.g. when a `remote: true` binding's dev-proxy WebSocket
+   * tunnel drops. A flag lookup must never take the request down with it.
+   */
+  private safe;
+  /** Synthesizes the details shape the binding would return for a failed evaluation. */
+  private errorDetails;
+  /** Extracts a human-readable message from an unknown thrown value. */
+  private message;
+}
+//#endregion
+//#region src/feature-flag-share.middleware.d.ts
+/**
+ * Evaluates the declared flag manifest for the default app and shares it as the
+ * `featureFlags` prop on every Inertia page rendered during the request.
+ *
+ * Only runs on `GET` requests — page renders (full visits and partial reloads)
+ * are always `GET`, so mutating API calls don't trigger evaluation. No-ops when
+ * Inertia is not installed (`ctx.share` absent).
+ *
+ * Register it yourself, scoped to where flags are actually needed — a Flagship
+ * stall then only affects those routes, not the whole app:
+ *
+ * ```typescript
+ * configureRoutes(router: Router): void {
+ *   // only the controllers that render flag-aware pages
+ *   router.group([DashboardController], (r) => r.middleware(FeatureFlagShareMiddleware))
+ *   // ...or app-wide: router.use(FeatureFlagShareMiddleware)
+ * }
+ * ```
+ */
+export declare class FeatureFlagShareMiddleware implements Middleware {
+  private readonly flags;
+  constructor(flags: FeatureFlagService);
+  handle(ctx: RouterContext, next: Next): Promise<void>;
+}
+//#endregion
+//#region src/feature-flags.tokens.d.ts
+/**
+ * DI tokens for the feature-flags module.
+ *
+ * Use `Symbol.for(...)` so the tokens resolve to the same symbol across module
+ * boundaries (the global symbol registry).
+ */
+export declare const FEATURE_FLAG_TOKENS: {
+  /** The resolved {@link FeatureFlagModuleOptions}. */
+  readonly Options: symbol;
+  /** The request-scoped {@link FeatureFlagService} bound to the default app. */
+  readonly FeatureFlagService: symbol;
+};
+type FeatureFlagToken = (typeof FEATURE_FLAG_TOKENS)[keyof typeof FEATURE_FLAG_TOKENS];
+//#endregion
+//#region src/feature-flags.error.d.ts
+/**
+ * Thrown for feature-flag misconfiguration — an unknown app or a Flagship
+ * binding that is not present on the Worker environment.
+ *
+ * Note: flag *evaluation* never throws; the binding returns the supplied
+ * default value on error.
+ */
+export declare class FeatureFlagError extends ApplicationError {}
+//#endregion
+export type { FeatureFlagApp, FeatureFlagModuleOptions, FeatureFlagRegistry, FeatureFlagToken, FlagManifest, FlagValue, FlagshipBindingName };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/feature-flags.module.ts","../src/services/feature-flag.service.ts","../src/feature-flag-share.middleware.ts","../src/feature-flags.tokens.ts","../src/feature-flags.error.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCa;;SAEJ,QAAQ,SAAS,2BAA2B;;SAU5C,aAAa,SAAS,mBAAmB,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBCNjE;mBAO6C;mBACJ;mBAC0B;mBACA;mBAT7D;UACT;UACA;UACA;EAER,YACwD,SAAS,0BACb,KAAK,YACqB,eAAe,2BACf,QAAQ,2BAGpF;;;;;;;EAcF,IAAI,SAAS,sBAAsB;;MAM/B;;EAOE,IAAI,iBAAiB,wBAAwB,UAAU,4BAA4B;;EAMnF,gBAAgB,iBAAiB,wBAAwB,UAAU,4BAA4B;;EAM/F,eAAe,iBAAiB,uBAAuB,UAAU,4BAA4B;;EAM7F,eAAe,iBAAiB,uBAAuB,UAAU,4BAA4B;;EAM7F,eAAe,kBAAkB,iBAAiB,eAAe,GAAG,UAAU,4BAA4B,QAAQ;;EAMlH,kBAAkB,iBAAiB,wBAAwB,UAAU,4BAA4B,QAAQ;;EAMzG,iBAAiB,iBAAiB,uBAAuB,UAAU,4BAA4B,QAAQ;;EAMvG,iBAAiB,iBAAiB,uBAAuB,UAAU,4BAA4B,QAAQ;;EAMvG,iBAAiB,kBAAkB,iBAAiB,eAAe,GAAG,UAAU,4BAA4B,QAAQ,0BAA0B;;;;;;EAU9I,IAAI,UAAU,4BAA4B,QAAQ,eAAe;UAsB/D;;UAkBM;;UAON;;UAOA;;;;;;;UAmBM;;UAYN;;UAKA;;;;;;;;;;;;;;;;;;;;;;;qBC5MG,sCAAsC;mBAEkB;EADnE,YACmE,OAAO;EAGpE,OAAO,KAAK,eAAe,MAAM,OAAO;;;;;;;;;;qBC1BnC;;WAEX;;WAEA;;KAGU,2BAA2B,kCAAkC;;;;;;;;;;qBCJ5D,yBAAyB"}

package/dist/index.mjs

@@ -0,0 +1,275 @@
+import { Module } from "stratal/module";
+import { DI_TOKENS, Transient, inject } from "stratal/di";
+import { LOGGER_TOKENS } from "stratal/logger";
+import { ROUTER_TOKENS } from "stratal/router";
+import { ApplicationError } from "stratal/errors";
+//#region src/feature-flags.tokens.ts
+/**
+* DI tokens for the feature-flags module.
+*
+* Use `Symbol.for(...)` so the tokens resolve to the same symbol across module
+* boundaries (the global symbol registry).
+*/
+const FEATURE_FLAG_TOKENS = {
+	/** The resolved {@link FeatureFlagModuleOptions}. */
+	Options: Symbol.for("stratal:feature-flags:options"),
+	/** The request-scoped {@link FeatureFlagService} bound to the default app. */
+	FeatureFlagService: Symbol.for("stratal:feature-flags:service")
+};
+//#endregion
+//#region src/feature-flags.error.ts
+/**
+* Thrown for feature-flag misconfiguration — an unknown app or a Flagship
+* binding that is not present on the Worker environment.
+*
+* Note: flag *evaluation* never throws; the binding returns the supplied
+* default value on error.
+*/
+var FeatureFlagError = class extends ApplicationError {};
+//#endregion
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/services/feature-flag.service.ts
+var _FeatureFlagService;
+let FeatureFlagService = _FeatureFlagService = class FeatureFlagService {
+	options;
+	env;
+	routerContext;
+	logger;
+	apps = /* @__PURE__ */ new Map();
+	bindingName;
+	binding;
+	manifest;
+	constructor(options, env, routerContext, logger, initialBinding) {
+		this.options = options;
+		this.env = env;
+		this.routerContext = routerContext;
+		this.logger = logger;
+		for (const app of options.apps) this.apps.set(app.binding, app);
+		this.bindTo(initialBinding ?? options.default ?? options.apps[0]?.binding);
+	}
+	/**
+	* Switch to a different configured Flagship app.
+	*
+	* Returns a new immutable instance bound to `binding`; the original is
+	* unchanged. The binding must be declared in the module's `apps`.
+	*/
+	use(binding) {
+		if (binding === this.bindingName) return this;
+		return new _FeatureFlagService(this.options, this.env, this.routerContext, this.logger, binding);
+	}
+	/** The binding name this instance currently targets. */
+	get app() {
+		return this.bindingName;
+	}
+	/** Returns the raw flag value without type checking. */
+	async get(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue);
+		return this.safe(flagKey, async () => this.binding.get(flagKey, fallback, await this.context(context)), () => fallback);
+	}
+	/** Returns the flag value as a `boolean`. */
+	async getBooleanValue(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue, false);
+		return this.safe(flagKey, async () => this.binding.getBooleanValue(flagKey, fallback, await this.context(context)), () => fallback);
+	}
+	/** Returns the flag value as a `string`. */
+	async getStringValue(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue, "");
+		return this.safe(flagKey, async () => this.binding.getStringValue(flagKey, fallback, await this.context(context)), () => fallback);
+	}
+	/** Returns the flag value as a `number`. */
+	async getNumberValue(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue, 0);
+		return this.safe(flagKey, async () => this.binding.getNumberValue(flagKey, fallback, await this.context(context)), () => fallback);
+	}
+	/** Returns the flag value as a typed object. */
+	async getObjectValue(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue, {});
+		return this.safe(flagKey, async () => this.binding.getObjectValue(flagKey, fallback, await this.context(context)), () => fallback);
+	}
+	/** Returns the `boolean` flag value with evaluation metadata. */
+	async getBooleanDetails(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue, false);
+		return this.safe(flagKey, async () => this.binding.getBooleanDetails(flagKey, fallback, await this.context(context)), (error) => this.errorDetails(flagKey, fallback, error));
+	}
+	/** Returns the `string` flag value with evaluation metadata. */
+	async getStringDetails(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue, "");
+		return this.safe(flagKey, async () => this.binding.getStringDetails(flagKey, fallback, await this.context(context)), (error) => this.errorDetails(flagKey, fallback, error));
+	}
+	/** Returns the `number` flag value with evaluation metadata. */
+	async getNumberDetails(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue, 0);
+		return this.safe(flagKey, async () => this.binding.getNumberDetails(flagKey, fallback, await this.context(context)), (error) => this.errorDetails(flagKey, fallback, error));
+	}
+	/** Returns the typed object flag value with evaluation metadata. */
+	async getObjectDetails(flagKey, defaultValue, context) {
+		const fallback = this.fallback(flagKey, defaultValue, {});
+		return this.safe(flagKey, async () => this.binding.getObjectDetails(flagKey, fallback, await this.context(context)), (error) => this.errorDetails(flagKey, fallback, error));
+	}
+	/**
+	* Evaluates every flag declared in the current app's manifest and returns a
+	* `{ key: value }` map. The evaluation method is chosen from each declared
+	* default's type. Powers `FeatureFlagShareMiddleware`.
+	*/
+	async all(context) {
+		const keys = Object.keys(this.manifest);
+		let merged;
+		try {
+			merged = await this.context(context);
+		} catch (error) {
+			this.logger?.warn(`Feature flag context resolution failed on app "${this.bindingName}"; returning manifest defaults.`, { error: this.message(error) });
+			return { ...this.manifest };
+		}
+		const values = await Promise.all(keys.map((key) => this.evaluate(key, this.manifest[key], merged)));
+		const result = {};
+		keys.forEach((key, i) => {
+			result[key] = values[i];
+		});
+		return result;
+	}
+	bindTo(name) {
+		if (!name) throw new FeatureFlagError("No feature flag apps configured. Provide at least one app in FeatureFlagModule.forRoot({ apps: [...] }).");
+		const app = this.apps.get(name);
+		if (!app) throw new FeatureFlagError(`Feature flag app "${name}" is not configured.`);
+		const binding = this.env[name];
+		if (!binding) throw new FeatureFlagError(`Flagship binding "${name}" was not found in the environment.`);
+		this.bindingName = name;
+		this.binding = binding;
+		this.manifest = app.flags ?? {};
+	}
+	/** Resolves the merged evaluation context (default context + per-call override). */
+	async context(callContext) {
+		if (!this.options.context || !this.routerContext) return callContext;
+		const base = await this.options.context(this.routerContext);
+		return callContext ? {
+			...base,
+			...callContext
+		} : base;
+	}
+	/** Picks the default: explicit arg, then manifest, then the type's zero value. */
+	fallback(flagKey, provided, zero) {
+		if (provided !== void 0) return provided;
+		if (flagKey in this.manifest) return this.manifest[flagKey];
+		return zero;
+	}
+	/** Evaluates a single flag, choosing the method from the declared default's type. */
+	evaluate(flagKey, declared, context) {
+		switch (typeof declared) {
+			case "boolean": return this.safe(flagKey, () => this.binding.getBooleanValue(flagKey, declared, context), () => declared);
+			case "number": return this.safe(flagKey, () => this.binding.getNumberValue(flagKey, declared, context), () => declared);
+			case "string": return this.safe(flagKey, () => this.binding.getStringValue(flagKey, declared, context), () => declared);
+			default: return this.safe(flagKey, () => this.binding.getObjectValue(flagKey, declared, context), () => declared);
+		}
+	}
+	/**
+	* Runs an evaluation and absorbs any failure into the fallback. The binding
+	* already returns the default on evaluation errors, but the call itself can
+	* still reject — e.g. when a `remote: true` binding's dev-proxy WebSocket
+	* tunnel drops. A flag lookup must never take the request down with it.
+	*/
+	async safe(flagKey, evaluate, onError) {
+		try {
+			return await evaluate();
+		} catch (error) {
+			this.logger?.warn(`Feature flag evaluation failed for "${flagKey}" on app "${this.bindingName}"; returning the fallback value.`, { error: this.message(error) });
+			return onError(error);
+		}
+	}
+	/** Synthesizes the details shape the binding would return for a failed evaluation. */
+	errorDetails(flagKey, value, error) {
+		return {
+			flagKey,
+			value,
+			reason: "ERROR",
+			errorMessage: this.message(error)
+		};
+	}
+	/** Extracts a human-readable message from an unknown thrown value. */
+	message(error) {
+		return error instanceof Error ? error.message : String(error);
+	}
+};
+FeatureFlagService = _FeatureFlagService = __decorate([
+	Transient(FEATURE_FLAG_TOKENS.FeatureFlagService),
+	__decorateParam(0, inject(FEATURE_FLAG_TOKENS.Options)),
+	__decorateParam(1, inject(DI_TOKENS.CloudflareEnv)),
+	__decorateParam(2, inject(ROUTER_TOKENS.RouterContext, { isOptional: true })),
+	__decorateParam(3, inject(LOGGER_TOKENS.LoggerService, { isOptional: true })),
+	__decorateMetadata("design:paramtypes", [
+		Object,
+		Object,
+		Object,
+		Object,
+		String
+	])
+], FeatureFlagService);
+//#endregion
+//#region src/feature-flags.module.ts
+var _FeatureFlagModule;
+let FeatureFlagModule = _FeatureFlagModule = class FeatureFlagModule {
+	/** Configure with static options. */
+	static forRoot(options) {
+		return {
+			module: _FeatureFlagModule,
+			providers: [{
+				provide: FEATURE_FLAG_TOKENS.Options,
+				useValue: options
+			}]
+		};
+	}
+	/** Configure with an async factory (when options depend on other services). */
+	static forRootAsync(options) {
+		return {
+			module: _FeatureFlagModule,
+			providers: [{
+				provide: FEATURE_FLAG_TOKENS.Options,
+				useFactory: options.useFactory,
+				inject: options.inject
+			}]
+		};
+	}
+};
+FeatureFlagModule = _FeatureFlagModule = __decorate([Module({ providers: [{
+	provide: FEATURE_FLAG_TOKENS.FeatureFlagService,
+	useClass: FeatureFlagService
+}] })], FeatureFlagModule);
+//#endregion
+//#region src/feature-flag-share.middleware.ts
+let FeatureFlagShareMiddleware = class FeatureFlagShareMiddleware {
+	flags;
+	constructor(flags) {
+		this.flags = flags;
+	}
+	async handle(ctx, next) {
+		if (ctx.c.req.method === "GET" && typeof ctx.share === "function") ctx.share("featureFlags", await this.flags.all());
+		await next();
+	}
+};
+FeatureFlagShareMiddleware = __decorate([
+	Transient(),
+	__decorateParam(0, inject(FEATURE_FLAG_TOKENS.FeatureFlagService)),
+	__decorateMetadata("design:paramtypes", [Object])
+], FeatureFlagShareMiddleware);
+//#endregion
+export { FEATURE_FLAG_TOKENS, FeatureFlagError, FeatureFlagModule, FeatureFlagService, FeatureFlagShareMiddleware };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/feature-flags.tokens.ts","../src/feature-flags.error.ts","../src/services/feature-flag.service.ts","../src/feature-flags.module.ts","../src/feature-flag-share.middleware.ts"],"sourcesContent":["/**\n * DI tokens for the feature-flags module.\n *\n * Use `Symbol.for(...)` so the tokens resolve to the same symbol across module\n * boundaries (the global symbol registry).\n */\nexport const FEATURE_FLAG_TOKENS = {\n  /** The resolved {@link FeatureFlagModuleOptions}. */\n  Options: Symbol.for('stratal:feature-flags:options'),\n  /** The request-scoped {@link FeatureFlagService} bound to the default app. */\n  FeatureFlagService: Symbol.for('stratal:feature-flags:service'),\n} as const\n\nexport type FeatureFlagToken = (typeof FEATURE_FLAG_TOKENS)[keyof typeof FEATURE_FLAG_TOKENS]\n","import { ApplicationError } from 'stratal/errors'\n\n/**\n * Thrown for feature-flag misconfiguration — an unknown app or a Flagship\n * binding that is not present on the Worker environment.\n *\n * Note: flag *evaluation* never throws; the binding returns the supplied\n * default value on error.\n */\nexport class FeatureFlagError extends ApplicationError {}\n","import type { StratalEnv } from 'stratal'\nimport { DI_TOKENS, Transient, inject } from 'stratal/di'\nimport { LOGGER_TOKENS, type LoggerService } from 'stratal/logger'\nimport { ROUTER_TOKENS, type RouterContext } from 'stratal/router'\nimport { FeatureFlagError } from '../feature-flags.error'\nimport { FEATURE_FLAG_TOKENS } from '../feature-flags.tokens'\nimport type {\n  FeatureFlagApp,\n  FeatureFlagModuleOptions,\n  FlagManifest,\n  FlagValue,\n  FlagshipBindingName,\n} from '../types'\n\n/**\n * Feature Flag Service\n *\n * Type-safe wrapper around a Cloudflare Flagship binding (`env.FLAGS`). Mirrors\n * the binding's evaluation methods 1:1, with two ergonomic additions:\n *\n * - **Manifest defaults** — when you omit a default, the value declared in the\n *   app's `flags` manifest is used (an explicit argument always wins).\n * - **Default context** — the module's `context` resolver is merged into every\n *   evaluation (per-call context overrides it). Resolved from the current\n *   request; skipped automatically outside request scope.\n *\n * Switch to another Flagship app with {@link use}. Evaluation never throws —\n * the binding returns the default value on evaluation errors, and the service\n * catches everything else (e.g. a dropped remote-binding tunnel in local dev)\n * and returns the same fallback, logging a warning.\n *\n * @example\n * ```typescript\n * @inject(FEATURE_FLAG_TOKENS.FeatureFlagService)\n * private readonly flags: FeatureFlagService\n *\n * const enabled = await this.flags.getBooleanValue('new-checkout')        // manifest default\n * const layout  = await this.flags.use('EXPERIMENT_FLAGS').getStringValue('layout', 'v1')\n * ```\n *\n * @see https://developers.cloudflare.com/flagship/binding/\n */\n@Transient(FEATURE_FLAG_TOKENS.FeatureFlagService)\nexport class FeatureFlagService {\n  private readonly apps = new Map<string, FeatureFlagApp>()\n  private bindingName!: string\n  private binding!: Flagship\n  private manifest!: FlagManifest\n\n  constructor(\n    @inject(FEATURE_FLAG_TOKENS.Options) private readonly options: FeatureFlagModuleOptions,\n    @inject(DI_TOKENS.CloudflareEnv) private readonly env: StratalEnv,\n    @inject(ROUTER_TOKENS.RouterContext, { isOptional: true }) private readonly routerContext: RouterContext | undefined,\n    @inject(LOGGER_TOKENS.LoggerService, { isOptional: true }) private readonly logger: LoggerService | undefined,\n    // Only passed by `use()`; DI never injects it. Lets `use()` bind exactly once\n    // instead of binding to the default in the constructor and re-binding after.\n    initialBinding?: string,\n  ) {\n    for (const app of options.apps) {\n      this.apps.set(app.binding, app)\n    }\n    this.bindTo(initialBinding ?? options.default ?? options.apps[0]?.binding)\n  }\n\n  /**\n   * Switch to a different configured Flagship app.\n   *\n   * Returns a new immutable instance bound to `binding`; the original is\n   * unchanged. The binding must be declared in the module's `apps`.\n   */\n  use(binding: FlagshipBindingName): FeatureFlagService {\n    if (binding === this.bindingName) return this\n    return new FeatureFlagService(this.options, this.env, this.routerContext, this.logger, binding)\n  }\n\n  /** The binding name this instance currently targets. */\n  get app(): string {\n    return this.bindingName\n  }\n\n  // ==================== EVALUATION ====================\n\n  /** Returns the raw flag value without type checking. */\n  async get(flagKey: string, defaultValue?: unknown, context?: FlagshipEvaluationContext): Promise<unknown> {\n    const fallback = this.fallback(flagKey, defaultValue)\n    return this.safe(flagKey, async () => this.binding.get(flagKey, fallback, await this.context(context)), () => fallback)\n  }\n\n  /** Returns the flag value as a `boolean`. */\n  async getBooleanValue(flagKey: string, defaultValue?: boolean, context?: FlagshipEvaluationContext): Promise<boolean> {\n    const fallback = this.fallback(flagKey, defaultValue, false)\n    return this.safe(flagKey, async () => this.binding.getBooleanValue(flagKey, fallback, await this.context(context)), () => fallback)\n  }\n\n  /** Returns the flag value as a `string`. */\n  async getStringValue(flagKey: string, defaultValue?: string, context?: FlagshipEvaluationContext): Promise<string> {\n    const fallback = this.fallback(flagKey, defaultValue, '')\n    return this.safe(flagKey, async () => this.binding.getStringValue(flagKey, fallback, await this.context(context)), () => fallback)\n  }\n\n  /** Returns the flag value as a `number`. */\n  async getNumberValue(flagKey: string, defaultValue?: number, context?: FlagshipEvaluationContext): Promise<number> {\n    const fallback = this.fallback(flagKey, defaultValue, 0)\n    return this.safe(flagKey, async () => this.binding.getNumberValue(flagKey, fallback, await this.context(context)), () => fallback)\n  }\n\n  /** Returns the flag value as a typed object. */\n  async getObjectValue<T extends object>(flagKey: string, defaultValue?: T, context?: FlagshipEvaluationContext): Promise<T> {\n    const fallback = this.fallback(flagKey, defaultValue, {} as T)\n    return this.safe(flagKey, async () => this.binding.getObjectValue<T>(flagKey, fallback, await this.context(context)), () => fallback)\n  }\n\n  /** Returns the `boolean` flag value with evaluation metadata. */\n  async getBooleanDetails(flagKey: string, defaultValue?: boolean, context?: FlagshipEvaluationContext): Promise<FlagshipEvaluationDetails<boolean>> {\n    const fallback = this.fallback(flagKey, defaultValue, false)\n    return this.safe(flagKey, async () => this.binding.getBooleanDetails(flagKey, fallback, await this.context(context)), (error) => this.errorDetails(flagKey, fallback, error))\n  }\n\n  /** Returns the `string` flag value with evaluation metadata. */\n  async getStringDetails(flagKey: string, defaultValue?: string, context?: FlagshipEvaluationContext): Promise<FlagshipEvaluationDetails<string>> {\n    const fallback = this.fallback(flagKey, defaultValue, '')\n    return this.safe(flagKey, async () => this.binding.getStringDetails(flagKey, fallback, await this.context(context)), (error) => this.errorDetails(flagKey, fallback, error))\n  }\n\n  /** Returns the `number` flag value with evaluation metadata. */\n  async getNumberDetails(flagKey: string, defaultValue?: number, context?: FlagshipEvaluationContext): Promise<FlagshipEvaluationDetails<number>> {\n    const fallback = this.fallback(flagKey, defaultValue, 0)\n    return this.safe(flagKey, async () => this.binding.getNumberDetails(flagKey, fallback, await this.context(context)), (error) => this.errorDetails(flagKey, fallback, error))\n  }\n\n  /** Returns the typed object flag value with evaluation metadata. */\n  async getObjectDetails<T extends object>(flagKey: string, defaultValue?: T, context?: FlagshipEvaluationContext): Promise<FlagshipEvaluationDetails<T>> {\n    const fallback = this.fallback(flagKey, defaultValue, {} as T)\n    return this.safe(flagKey, async () => this.binding.getObjectDetails<T>(flagKey, fallback, await this.context(context)), (error) => this.errorDetails(flagKey, fallback, error))\n  }\n\n  /**\n   * Evaluates every flag declared in the current app's manifest and returns a\n   * `{ key: value }` map. The evaluation method is chosen from each declared\n   * default's type. Powers `FeatureFlagShareMiddleware`.\n   */\n  async all(context?: FlagshipEvaluationContext): Promise<Record<string, FlagValue>> {\n    const keys = Object.keys(this.manifest)\n    // Resolve the shared context once. A throwing resolver must not take the\n    // batch down — fall back to the manifest defaults, the same values each\n    // per-flag method returns when evaluation can't proceed.\n    let merged: FlagshipEvaluationContext | undefined\n    try {\n      merged = await this.context(context)\n    } catch (error) {\n      this.logger?.warn(`Feature flag context resolution failed on app \"${this.bindingName}\"; returning manifest defaults.`, { error: this.message(error) })\n      return { ...this.manifest }\n    }\n    const values = await Promise.all(keys.map((key) => this.evaluate(key, this.manifest[key], merged)))\n    const result: Record<string, FlagValue> = {}\n    keys.forEach((key, i) => {\n      result[key] = values[i]\n    })\n    return result\n  }\n\n  // ==================== INTERNAL ====================\n\n  private bindTo(name: string | undefined): void {\n    if (!name) {\n      throw new FeatureFlagError('No feature flag apps configured. Provide at least one app in FeatureFlagModule.forRoot({ apps: [...] }).')\n    }\n    const app = this.apps.get(name)\n    if (!app) {\n      throw new FeatureFlagError(`Feature flag app \"${name}\" is not configured.`)\n    }\n    const binding = (this.env as unknown as Record<string, unknown>)[name] as Flagship | undefined\n    if (!binding) {\n      throw new FeatureFlagError(`Flagship binding \"${name}\" was not found in the environment.`)\n    }\n    this.bindingName = name\n    this.binding = binding\n    this.manifest = app.flags ?? {}\n  }\n\n  /** Resolves the merged evaluation context (default context + per-call override). */\n  private async context(callContext?: FlagshipEvaluationContext): Promise<FlagshipEvaluationContext | undefined> {\n    if (!this.options.context || !this.routerContext) return callContext\n    const base = await this.options.context(this.routerContext)\n    return callContext ? { ...base, ...callContext } : base\n  }\n\n  /** Picks the default: explicit arg, then manifest, then the type's zero value. */\n  private fallback<T>(flagKey: string, provided: T | undefined, zero?: T): T {\n    if (provided !== undefined) return provided\n    if (flagKey in this.manifest) return this.manifest[flagKey] as T\n    return zero as T\n  }\n\n  /** Evaluates a single flag, choosing the method from the declared default's type. */\n  private evaluate(flagKey: string, declared: FlagValue, context?: FlagshipEvaluationContext): Promise<FlagValue> {\n    switch (typeof declared) {\n      case 'boolean':\n        return this.safe(flagKey, () => this.binding.getBooleanValue(flagKey, declared, context), () => declared)\n      case 'number':\n        return this.safe(flagKey, () => this.binding.getNumberValue(flagKey, declared, context), () => declared)\n      case 'string':\n        return this.safe(flagKey, () => this.binding.getStringValue(flagKey, declared, context), () => declared)\n      default:\n        return this.safe(flagKey, () => this.binding.getObjectValue(flagKey, declared, context), () => declared)\n    }\n  }\n\n  /**\n   * Runs an evaluation and absorbs any failure into the fallback. The binding\n   * already returns the default on evaluation errors, but the call itself can\n   * still reject — e.g. when a `remote: true` binding's dev-proxy WebSocket\n   * tunnel drops. A flag lookup must never take the request down with it.\n   */\n  private async safe<T>(flagKey: string, evaluate: () => Promise<T>, onError: (error: unknown) => T): Promise<T> {\n    try {\n      return await evaluate()\n    } catch (error) {\n      this.logger?.warn(`Feature flag evaluation failed for \"${flagKey}\" on app \"${this.bindingName}\"; returning the fallback value.`, {\n        error: this.message(error),\n      })\n      return onError(error)\n    }\n  }\n\n  /** Synthesizes the details shape the binding would return for a failed evaluation. */\n  private errorDetails<T>(flagKey: string, value: T, error: unknown): FlagshipEvaluationDetails<T> {\n    return { flagKey, value, reason: 'ERROR', errorMessage: this.message(error) }\n  }\n\n  /** Extracts a human-readable message from an unknown thrown value. */\n  private message(error: unknown): string {\n    return error instanceof Error ? error.message : String(error)\n  }\n}\n","import { Module } from 'stratal/module'\nimport type { AsyncModuleOptions, DynamicModule } from 'stratal/module'\nimport { FEATURE_FLAG_TOKENS } from './feature-flags.tokens'\nimport { FeatureFlagService } from './services/feature-flag.service'\nimport type { FeatureFlagModuleOptions } from './types'\n\n/**\n * Feature Flag Module\n *\n * Evaluates Cloudflare Flagship feature flags through the native Worker binding.\n * Declare your apps (and the flags you use) once; inject {@link FeatureFlagService}\n * to evaluate them.\n *\n * To expose flags to an Inertia frontend, register {@link FeatureFlagShareMiddleware}\n * yourself — scope it to the controllers that render pages (`router.middleware(...)`)\n * or app-wide (`router.use(...)`) from a module's `configureRoutes`. It is not\n * registered for you, so a stalled Flagship binding never blocks unrelated routes.\n *\n * @example\n * ```typescript\n * FeatureFlagModule.forRoot({\n *   apps: [{ binding: 'FLAGS', flags: { 'new-checkout': false } }],\n *   context: (ctx) => ({ userId: ctx.user().id }), // ctx.user() from @stratal/framework\n * })\n *\n * // Or async, from config namespaces:\n * FeatureFlagModule.forRootAsync({\n *   inject: [flagsConfig.KEY],\n *   useFactory: (cfg) => ({ apps: cfg.apps, default: cfg.default }),\n * })\n * ```\n */\n@Module({\n  providers: [\n    { provide: FEATURE_FLAG_TOKENS.FeatureFlagService, useClass: FeatureFlagService },\n  ],\n})\nexport class FeatureFlagModule {\n  /** Configure with static options. */\n  static forRoot(options: FeatureFlagModuleOptions): DynamicModule {\n    return {\n      module: FeatureFlagModule,\n      providers: [\n        { provide: FEATURE_FLAG_TOKENS.Options, useValue: options },\n      ],\n    }\n  }\n\n  /** Configure with an async factory (when options depend on other services). */\n  static forRootAsync(options: AsyncModuleOptions<FeatureFlagModuleOptions>): DynamicModule {\n    return {\n      module: FeatureFlagModule,\n      providers: [\n        {\n          provide: FEATURE_FLAG_TOKENS.Options,\n          useFactory: options.useFactory,\n          inject: options.inject,\n        },\n      ],\n    }\n  }\n}\n","/// <reference types=\"@stratal/inertia\" />\n\nimport { Transient, inject } from 'stratal/di';\nimport type { Middleware, Next, RouterContext } from 'stratal/router';\nimport { FEATURE_FLAG_TOKENS } from './feature-flags.tokens';\nimport type { FeatureFlagService } from './services/feature-flag.service';\n\n/**\n * Evaluates the declared flag manifest for the default app and shares it as the\n * `featureFlags` prop on every Inertia page rendered during the request.\n *\n * Only runs on `GET` requests — page renders (full visits and partial reloads)\n * are always `GET`, so mutating API calls don't trigger evaluation. No-ops when\n * Inertia is not installed (`ctx.share` absent).\n *\n * Register it yourself, scoped to where flags are actually needed — a Flagship\n * stall then only affects those routes, not the whole app:\n *\n * ```typescript\n * configureRoutes(router: Router): void {\n *   // only the controllers that render flag-aware pages\n *   router.group([DashboardController], (r) => r.middleware(FeatureFlagShareMiddleware))\n *   // ...or app-wide: router.use(FeatureFlagShareMiddleware)\n * }\n * ```\n */\n@Transient()\nexport class FeatureFlagShareMiddleware implements Middleware {\n  constructor(\n    @inject(FEATURE_FLAG_TOKENS.FeatureFlagService) private readonly flags: FeatureFlagService,\n  ) {}\n\n  async handle(ctx: RouterContext, next: Next): Promise<void> {\n    if (ctx.c.req.method === 'GET' && typeof ctx.share === 'function') {\n      ctx.share('featureFlags', await this.flags.all())\n    }\n    await next()\n  }\n}\n"],"mappings":"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"}

package/dist/react.d.mts

@@ -0,0 +1,22 @@
+import { r as FeatureFlagRegistry } from "./types-D-uV0zlC.mjs";
+//#region src/react/use-feature-flags.d.ts
+/**
+ * Returns the full map of feature flags shared by `FeatureFlagShareMiddleware`.
+ */
+export declare function useFeatureFlags(): Record<string, unknown>;
+/**
+ * Returns a single shared feature flag value.
+ *
+ * When you augment {@link FeatureFlagRegistry}, the key and return type are
+ * checked against your declared flags. Otherwise pass an explicit default.
+ *
+ * @example
+ * ```tsx
+ * const showNewCheckout = useFlag('new-checkout')        // typed via FeatureFlagRegistry
+ * const layout = useFlag('layout', 'v1')                 // loose fallback
+ * ```
+ */
+export declare function useFlag<K extends keyof FeatureFlagRegistry>(key: K): FeatureFlagRegistry[K];
+export declare function useFlag<T>(key: string, defaultValue: T): T;
+//#endregion
+//# sourceMappingURL=react.d.mts.map

package/dist/react.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.mts","names":[],"sources":["../src/react/use-feature-flags.ts"],"mappings":";;;;;wBAWgB,mBAAmB;;;;;;;;;;;;;wBAgBnB,QAAQ,gBAAgB,qBAAqB,KAAK,IAAI,oBAAoB;wBAC1E,QAAQ,GAAG,aAAa,cAAc,IAAI"}

package/dist/react.mjs

@@ -0,0 +1,16 @@
+import { usePage } from "@inertiajs/react";
+//#region src/react/use-feature-flags.ts
+/**
+* Returns the full map of feature flags shared by `FeatureFlagShareMiddleware`.
+*/
+function useFeatureFlags() {
+	return usePage().props.featureFlags ?? {};
+}
+function useFlag(key, defaultValue) {
+	const flags = useFeatureFlags();
+	return key in flags ? flags[key] : defaultValue;
+}
+//#endregion
+export { useFeatureFlags, useFlag };
+
+//# sourceMappingURL=react.mjs.map

package/dist/react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.mjs","names":[],"sources":["../src/react/use-feature-flags.ts"],"sourcesContent":["import type { PageProps } from '@inertiajs/core'\nimport { usePage } from '@inertiajs/react'\nimport type { FeatureFlagRegistry } from '../types'\n\ninterface FeatureFlagsPageProps extends PageProps {\n  featureFlags?: Record<string, unknown>\n}\n\n/**\n * Returns the full map of feature flags shared by `FeatureFlagShareMiddleware`.\n */\nexport function useFeatureFlags(): Record<string, unknown> {\n  return usePage<FeatureFlagsPageProps>().props.featureFlags ?? {}\n}\n\n/**\n * Returns a single shared feature flag value.\n *\n * When you augment {@link FeatureFlagRegistry}, the key and return type are\n * checked against your declared flags. Otherwise pass an explicit default.\n *\n * @example\n * ```tsx\n * const showNewCheckout = useFlag('new-checkout')        // typed via FeatureFlagRegistry\n * const layout = useFlag('layout', 'v1')                 // loose fallback\n * ```\n */\nexport function useFlag<K extends keyof FeatureFlagRegistry>(key: K): FeatureFlagRegistry[K]\nexport function useFlag<T>(key: string, defaultValue: T): T\nexport function useFlag(key: string, defaultValue?: unknown): unknown {\n  const flags = useFeatureFlags()\n  return key in flags ? flags[key] : defaultValue\n}\n"],"mappings":";;;;;AAWA,SAAgB,kBAA2C;CACzD,OAAO,QAA+B,CAAC,CAAC,MAAM,gBAAgB,CAAC;AACjE;AAgBA,SAAgB,QAAQ,KAAa,cAAiC;CACpE,MAAM,QAAQ,gBAAgB;CAC9B,OAAO,OAAO,QAAQ,MAAM,OAAO;AACrC"}

package/dist/types-D-uV0zlC.d.mts

@@ -0,0 +1,70 @@
+import { RouterContext } from "stratal/router";
+import { StratalEnv } from "stratal";
+//#region src/types.d.ts
+/**
+ * A value a feature flag can resolve to.
+ *
+ * @see https://developers.cloudflare.com/flagship/binding/methods/
+ */
+type FlagValue = boolean | string | number | object;
+/**
+ * String keys of the augmented `StratalEnv` whose value is a Flagship binding.
+ */
+type FlagshipBindingFromEnv = Extract<{ [K in keyof StratalEnv]: StratalEnv[K] extends Flagship ? K : never; }[keyof StratalEnv], string>;
+/**
+ * Type-safe Flagship binding name.
+ *
+ * Resolves to the union of `Flagship`-typed binding keys on the augmented
+ * `StratalEnv`. Falls back to `string` when no Flagship bindings are visible
+ * (for example library code compiled outside an app's env context).
+ */
+type FlagshipBindingName = [FlagshipBindingFromEnv] extends [never] ? string : FlagshipBindingFromEnv;
+/**
+ * Augment this interface to get typed flag keys for `useFlag()` and the service.
+ *
+ * @example
+ * ```typescript
+ * declare module '@stratal/feature-flags' {
+ *   interface FeatureFlagRegistry {
+ *     'new-checkout': boolean
+ *     'checkout-flow': string
+ *   }
+ * }
+ * ```
+ */
+interface FeatureFlagRegistry {}
+/**
+ * A declared set of flags and their default values.
+ *
+ * Flagship has no enumeration API, so the flags you intend to evaluate (and
+ * share to the frontend) must be declared once here. The default also
+ * doubles as the type hint used to pick the evaluation method in `all()`.
+ */
+type FlagManifest = Record<string, FlagValue>;
+/**
+ * A single Flagship app bound to the Worker.
+ */
+interface FeatureFlagApp {
+  /** Flagship binding name from your Wrangler config (type-checked against `StratalEnv`). */
+  binding: FlagshipBindingName;
+  /** Declared flags + defaults for this app. Used for manifest defaults and Inertia sharing. */
+  flags?: FlagManifest;
+}
+/**
+ * Feature-flags module configuration.
+ */
+interface FeatureFlagModuleOptions {
+  /** One or more Flagship apps. A Worker may bind to multiple apps. */
+  apps: FeatureFlagApp[];
+  /** Default app binding used by the injected `FeatureFlagService`. Defaults to `apps[0].binding`. */
+  default?: FlagshipBindingName;
+  /**
+   * Resolves a per-request evaluation context (for example `{ userId }`) merged
+   * into every evaluation. Per-call context passed to a method overrides these.
+   * Receives the current request context; skipped outside request scope.
+   */
+  context?: (ctx: RouterContext) => FlagshipEvaluationContext | Promise<FlagshipEvaluationContext>;
+}
+//#endregion
+export { FlagValue as a, FlagManifest as i, FeatureFlagModuleOptions as n, FlagshipBindingName as o, FeatureFlagRegistry as r, FeatureFlagApp as t };
+//# sourceMappingURL=types-D-uV0zlC.d.mts.map

package/dist/types-D-uV0zlC.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D-uV0zlC.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;KAQY;;;;KAKP,yBAAyB,WACzB,WAAW,aAAa,WAAW,WAAW,WAAW,mBAAkB;;;;;;;;KAWpE,uBAAuB,mDAE/B;;;;;;;;;;;;;;UAea;;;;;;;;KASL,eAAe,eAAe;;;;UAKzB;;EAEf,SAAS;;EAET,QAAQ;;;;;UAMO;;EAEf,MAAM;;EAEN,UAAU;;;;;;EAMV,WAAW,KAAK,kBAAkB,4BAA4B,QAAQ"}

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@stratal/feature-flags",
+  "version": "0.0.0-canary-e5681b8",
+  "description": "Cloudflare Flagship feature flags for the Stratal framework — binding API wrapper with Inertia.js sharing",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "Temitayo Fadojutimi",
+    "url": "https://x.com/adesege_"
+  },
+  "homepage": "https://stratal.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/strataljs/stratal.git",
+    "directory": "packages/feature-flags"
+  },
+  "bugs": {
+    "url": "https://github.com/strataljs/stratal/issues"
+  },
+  "keywords": [
+    "stratal",
+    "feature-flags",
+    "flagship",
+    "cloudflare-workers",
+    "inertia",
+    "react"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./react": {
+      "types": "./dist/react.d.mts",
+      "import": "./dist/react.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "npx oxlint .",
+    "lint:fix": "npx oxlint --fix ."
+  },
+  "peerDependencies": {
+    "@inertiajs/core": ">=3",
+    "@inertiajs/react": ">=3",
+    "@stratal/inertia": "0.0.0-canary-e5681b8",
+    "hono": ">=4",
+    "react": ">=19",
+    "react-dom": ">=19",
+    "stratal": "0.0.0-canary-e5681b8"
+  },
+  "peerDependenciesMeta": {
+    "@inertiajs/core": {
+      "optional": true
+    },
+    "@inertiajs/react": {
+      "optional": true
+    },
+    "@stratal/inertia": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "5.20260919.1",
+    "@inertiajs/core": "^3.7.1",
+    "@inertiajs/react": "^3.7.1",
+    "@stratal/inertia": "0.0.0-canary-e5681b8",
+    "@types/node": "^26.6.2",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "hono": "^4.13.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "stratal": "0.0.0-canary-e5681b8",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "~4.1.11"
+  }
+}