@davidlee49/launchgate 0.0.0-stage → 0.5.1

package/dist/index.d.ts

@@ -0,0 +1,232 @@
+import { S as Source, F as FlagValue, a as FlagMeta, E as EvaluationContext, b as FlagRegistry, R as Resolver, c as FlagValueOf } from './resolver-B2cstRTq.js';
+export { C as Context, D as Decision, d as FlagDef, e as ResolvedFlags, f as ResolverOptions, g as Retirement, h as SourceErrorInfo, i as createResolver, j as defineFlags } from './resolver-B2cstRTq.js';
+
+interface EnvOverrideOptions {
+    /** How to read an environment variable. Defaults to `process.env` where it exists. */
+    read?: (name: string) => string | undefined;
+    /** Variable-name prefix. Default `FLAG_`. */
+    prefix?: string;
+}
+/**
+ * Slot 1 — the operator override, whose primary use is the kill switch.
+ *
+ * `FLAG_NEW_HOMEPAGE=off` forces a flag off; any value the flag's type accepts
+ * forces that value. This sits **above** `cookieOverride` deliberately: a flag
+ * forced on by a visitor cookie must not survive the attempt to kill it.
+ *
+ * An unparseable value throws, which aborts to the flag's fallback and reports
+ * through `onError` — an operator typo is loud rather than silently ignored.
+ */
+declare function envOverride(options?: EnvOverrideOptions): Source;
+interface EnvDefaultOptions {
+    /** The current environment name, matched against each flag's `byEnv`. */
+    env: string | (() => string);
+}
+/**
+ * Slot 4 — the registry's per-environment value, e.g. `byEnv: { development: true }`.
+ *
+ * This is also the whole of "preview deployments": a preview host is just a
+ * different `env` with different values, needing no runtime machinery.
+ */
+declare function envDefault(options: EnvDefaultOptions): Source;
+
+declare const DEFAULT_OVERRIDE_COOKIE = "lg_override";
+interface CookieOverrideOptions {
+    /** Secret for the HMAC. Must not be readable by the client. */
+    secret: string;
+    /** Cookie holding the signed token. Default `lg_override`. */
+    cookieName?: string;
+}
+/**
+ * Slot 2 — the signed per-visitor override: how the author sees hidden work on
+ * the real production site, with no account and no database.
+ *
+ * Honours **only** flags declaring `overridable: true`. A visitor must never be
+ * able to force a flag with real consequences — harmless while flags are
+ * cosmetic, load-bearing the day a project puts an entitlement source in slot 3.
+ *
+ * A missing, malformed, or tampered token is *undecided*, not an error: hostile
+ * input should fall through to the normal chain, not push the flag to its
+ * fallback.
+ */
+declare function cookieOverride(options: CookieOverrideOptions): Source;
+
+/**
+ * What storage knows about one subject and one flag.
+ *
+ * `override` is written only by the platform side. `'disabled'` is the per-subject
+ * kill switch, `'enabled'` the grant (beta cohort, comp, early access) — and they
+ * sit in *different* slots of the chain, which is why they are one row but two
+ * sources.
+ */
+interface SubjectState {
+    override?: "enabled" | "disabled";
+    /** Grant a specific value rather than `true`. For value-typed flags. */
+    value?: FlagValue;
+    /** Has the subject switched it on themselves? */
+    optedIn?: boolean;
+    /**
+     * Projects may return their own fields alongside these and read them back via
+     * `store.state()` — impartire's loader returns the org's `is_platform` here so
+     * its stage policy shares this read instead of issuing a second query.
+     */
+    [projectField: string]: unknown;
+}
+type LoadSubjectState = (subject: string, key: string, flag: FlagMeta) => Promise<SubjectState | undefined> | SubjectState | undefined;
+/**
+ * Every flag's state for one subject, in one read. Keys absent from the result
+ * are treated as "no row", exactly as `load` returning `undefined` is.
+ */
+type LoadAllSubjectState = (subject: string) => Promise<Map<string, SubjectState> | Record<string, SubjectState>> | Map<string, SubjectState> | Record<string, SubjectState>;
+interface SubjectStoreOptions {
+    /** Per-flag read. Supply this, `loadAll`, or both. */
+    load?: LoadSubjectState;
+    /**
+     * Batch read for the whole registry. When present it is preferred, and one
+     * subject costs **one** read per request however many flags resolve — which
+     * is what makes `resolver.resolveAll()` affordable. Without it, evaluating
+     * N flags means N reads.
+     */
+    loadAll?: LoadAllSubjectState;
+    /**
+     * Flags the subject must switch on for themselves — entitlement alone isn't
+     * enough. Default: none.
+     */
+    requiresOptIn?: (flag: FlagMeta) => boolean;
+}
+interface SubjectStore {
+    /** Slot 1, beside `envOverride`. A per-subject kill outranks a visitor cookie. */
+    kill: Source;
+    /** Slot 3a. Vetoes a flag the subject hasn't switched on. */
+    requireOptIn: Source;
+    /** Slot 3b. The platform's grant. */
+    grant: Source;
+    /**
+     * The cached read, for a project's own policy source. Sharing it is what keeps
+     * a bespoke rule from costing an extra query.
+     */
+    state(flag: FlagMeta, ctx: EvaluationContext): Promise<SubjectState | undefined>;
+}
+/**
+ * Three sources over one storage read.
+ *
+ * They share a cache keyed on the `EvaluationContext` object, which is per request, so a
+ * request pays **one** load per flag however many of the three are in the chain —
+ * the alternative being the same row fetched three times. Supply `loadAll` and
+ * the whole registry collapses to one read as well, which is what makes
+ * `resolver.resolveAll()` affordable.
+ *
+ * The library owns the semantics; you own the SQL. `load` returns whatever your
+ * schema says; a row shape of `(subject_id, flag_key, override)` is all this needs.
+ */
+declare function subjectStore(options: SubjectStoreOptions): SubjectStore;
+
+/**
+ * Registry hygiene, checked at build time rather than watched on a dashboard.
+ *
+ * LaunchDarkly ships `find-code-refs` — a scanner that crawls a customer's repo
+ * so the SaaS control plane can warn that an archived key still appears in code.
+ * That tool exists to buy back something a code-first registry has for free: the
+ * flags *are* source, so their hygiene is a build step, and a build step can
+ * fail rather than warn. This is that build step.
+ *
+ * It audits only what the library owns — the retirement clock and the shape of
+ * a `Retirement`. A project's own lifecycle vocabulary (impartire's `stage`, a
+ * `since` stamp on unreleased work, an owner field) is audited by the project,
+ * which knows what those mean; merge the two reports and print them together.
+ */
+interface AuditOptions {
+    /** Defaults to now. Injectable so the age checks are testable. */
+    today?: Date;
+    /**
+     * How long retired code may sit undeleted before the report warns.
+     *
+     * 40 days by default, matching Unleash's documented expected lifetime for a
+     * release flag: retirement is the same debt seen from the other end, and a
+     * budget nobody picked is a budget nobody keeps.
+     */
+    retiredAfterDays?: number;
+}
+interface AuditReport {
+    /** Registry defects. A consumer should fail the build on these. */
+    problems: string[];
+    /** Debt worth seeing every run, but not worth blocking a merge. */
+    warnings: string[];
+}
+declare function auditRegistry(flags: FlagRegistry, options?: AuditOptions): AuditReport;
+
+/**
+ * Prefix match: exact, or a path segment below it.
+ *
+ * `"/"` matches only `"/"` — it falls out of the general rule rather than needing
+ * a special case, because no real pathname starts with `"//"`.
+ *
+ * Exported standalone because nav filtering usually runs in a client component,
+ * where the rule must be identical to the server's or the menu and the router
+ * disagree.
+ */
+declare function matchesPrefix(pathname: string, prefixes: readonly string[]): boolean;
+interface RouteGateOptions<T extends FlagRegistry> {
+    resolver: Resolver<T>;
+    /** Flag key → the path prefixes it reveals. A flag may reveal several. */
+    routes: Partial<Record<keyof T & string, readonly string[]>>;
+    /**
+     * Paths served regardless of any flag — the launched surface. Omit for an
+     * app whose routes are all either public or flagged.
+     */
+    allow?: readonly string[];
+    /**
+     * What to do with a path that is neither allowed nor covered by a flag.
+     *
+     * Required, with no default, because it is the whole safety posture and the
+     * two answers fail in very different ways. `"deny"` means a route added
+     * tomorrow is hidden until someone lists it — it 404s loudly and safely.
+     * `"allow"` means it ships publicly the moment it exists, and forgetting to
+     * flag work in progress leaks it silently.
+     */
+    unlisted: "deny" | "allow";
+}
+interface RouteGate {
+    /** May this path be served right now? */
+    isPermitted(pathname: string, ctx?: EvaluationContext): Promise<boolean>;
+    /** Prefixes currently revealed by a flag. For filtering nav server-side. */
+    revealedPrefixes(ctx?: EvaluationContext): Promise<string[]>;
+    /** Everything servable right now — `allow` plus whatever is revealed. */
+    permittedPrefixes(ctx?: EvaluationContext): Promise<string[]>;
+}
+/**
+ * Turns "which flags are on" into "which paths may be served".
+ *
+ * The app supplies two lists — what is launched, and which flag hides what. This
+ * owns the policy: check the allowlist first (so a launched route costs no flag
+ * resolution at all), then ask the flags.
+ *
+ * **Throws at construction** if a prefix is both allowed and flagged. That flag
+ * could never change anything, because the allowlist would already be letting
+ * the path through — a silent no-op that is very hard to spot by reading, and
+ * exactly the kind of thing a launch gate must not have.
+ */
+declare function createRouteGate<T extends FlagRegistry>(options: RouteGateOptions<T>): RouteGate;
+
+/**
+ * Mints the signed token that `cookieOverride` reads. Lives in the core rather
+ * than the framework adapter so an adapter is only cookie plumbing.
+ */
+declare function signOverrides(overrides: Record<string, FlagValue>, secret: string): Promise<string>;
+/** Verifies and parses a token. Returns `undefined` for anything not genuinely signed. */
+declare function readOverrides(token: string, secret: string): Promise<Record<string, FlagValue> | undefined>;
+
+type FlagValues<T extends FlagRegistry> = Partial<{
+    [K in keyof T]: FlagValueOf<T, K>;
+}>;
+/**
+ * A resolver that answers from a fixed map, falling back to each flag's declared
+ * `fallback` for keys left unset.
+ *
+ * Use this in consumers' tests instead of standing up real sources: flags
+ * multiply a test matrix, and the multiplication is only tolerable if pinning a
+ * value is one line.
+ */
+declare function withFlags<T extends FlagRegistry>(flags: T, values?: FlagValues<T>): Resolver<T>;
+
+export { type AuditOptions, type AuditReport, type CookieOverrideOptions, DEFAULT_OVERRIDE_COOKIE, type EnvDefaultOptions, type EnvOverrideOptions, EvaluationContext, FlagMeta, FlagRegistry, FlagValue, type FlagValues, type LoadAllSubjectState, type LoadSubjectState, Resolver, type RouteGate, type RouteGateOptions, Source, type SubjectState, type SubjectStore, type SubjectStoreOptions, auditRegistry, cookieOverride, createRouteGate, envDefault, envOverride, matchesPrefix, readOverrides, signOverrides, subjectStore, withFlags };

package/dist/index.js

@@ -0,0 +1,274 @@
+import {
+  DEFAULT_OVERRIDE_COOKIE,
+  cookieOverride,
+  readOverrides,
+  signOverrides
+} from "./chunk-YIOEKCH6.js";
+
+// src/resolver.ts
+function defineFlags(flags) {
+  return flags;
+}
+function createResolver(options) {
+  const { flags, sources, onError } = options;
+  async function resolve(key, ctx = {}) {
+    const def = flags[key];
+    if (!def) throw new Error(`launchgate: unknown flag "${key}"`);
+    if (def.retired) return def.retired.value;
+    const meta = { key, def };
+    for (const source of sources) {
+      let decision;
+      try {
+        decision = await source.decide(meta, ctx);
+      } catch (error) {
+        onError?.(error, { flag: key, source: source.name });
+        return def.fallback;
+      }
+      if (decision === void 0) continue;
+      if (typeof decision !== typeof def.fallback) {
+        onError?.(
+          new TypeError(
+            `launchgate: source "${source.name}" answered ${typeof decision} for flag "${key}", which is ${typeof def.fallback}`
+          ),
+          { flag: key, source: source.name }
+        );
+        return def.fallback;
+      }
+      return decision;
+    }
+    return def.fallback;
+  }
+  async function resolveAll(ctx = {}) {
+    const keys = Object.keys(flags);
+    const values = await Promise.all(keys.map((key) => resolve(key, ctx)));
+    return Object.fromEntries(
+      keys.map((key, i) => [key, values[i]])
+    );
+  }
+  return { flags, resolve, resolveAll };
+}
+
+// src/sources/env.ts
+function envName(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
+}
+function parseAs(raw, fallback, variable) {
+  const trimmed = raw.trim();
+  if (typeof fallback === "boolean") {
+    const v = trimmed.toLowerCase();
+    if (v === "on" || v === "true" || v === "1" || v === "yes") return true;
+    if (v === "off" || v === "false" || v === "0" || v === "no") return false;
+    throw new Error(
+      `launchgate: ${variable}="${raw}" is not on/off for a boolean flag`
+    );
+  }
+  if (typeof fallback === "number") {
+    const n = Number(trimmed);
+    if (!Number.isFinite(n)) {
+      throw new Error(`launchgate: ${variable}="${raw}" is not a number`);
+    }
+    return n;
+  }
+  return trimmed;
+}
+function defaultRead(name) {
+  const proc = globalThis.process;
+  return proc?.env?.[name];
+}
+function envOverride(options = {}) {
+  const read = options.read ?? defaultRead;
+  const prefix = options.prefix ?? "FLAG_";
+  return {
+    name: "envOverride",
+    decide({ key, def }) {
+      const variable = prefix + envName(key);
+      const raw = read(variable);
+      if (raw === void 0 || raw === "") return void 0;
+      return parseAs(raw, def.fallback, variable);
+    }
+  };
+}
+function envDefault(options) {
+  const { env } = options;
+  return {
+    name: "envDefault",
+    decide({ def }) {
+      const current = typeof env === "function" ? env() : env;
+      return def.byEnv?.[current];
+    }
+  };
+}
+
+// src/sources/subject.ts
+function offValue(flag) {
+  return typeof flag.def.fallback === "boolean" ? false : flag.def.fallback;
+}
+function subjectStore(options) {
+  const { load, loadAll, requiresOptIn } = options;
+  if (!load && !loadAll) {
+    throw new Error("launchgate: subjectStore needs `load` or `loadAll`");
+  }
+  const caches = /* @__PURE__ */ new WeakMap();
+  function read(flag, ctx, subject) {
+    let cache = caches.get(ctx);
+    if (!cache) {
+      cache = { perFlag: /* @__PURE__ */ new Map(), batch: /* @__PURE__ */ new Map() };
+      caches.set(ctx, cache);
+    }
+    if (loadAll) {
+      let batched = cache.batch.get(subject);
+      if (!batched) {
+        batched = Promise.resolve(loadAll(subject)).then(
+          (result) => result instanceof Map ? result : new Map(Object.entries(result))
+        );
+        cache.batch.set(subject, batched);
+      }
+      return batched.then((states) => states.get(flag.key));
+    }
+    const cacheKey = `${subject}\0${flag.key}`;
+    let pending = cache.perFlag.get(cacheKey);
+    if (!pending) {
+      pending = Promise.resolve(load(subject, flag.key, flag));
+      cache.perFlag.set(cacheKey, pending);
+    }
+    return pending;
+  }
+  function source(name, decide, applies = () => true) {
+    return {
+      name,
+      async decide(flag, ctx) {
+        if (!ctx.targetingKey || !applies(flag)) return void 0;
+        const state = await read(flag, ctx, ctx.targetingKey);
+        return state ? decide(state, flag) : decide({}, flag);
+      }
+    };
+  }
+  return {
+    state: async (flag, ctx) => ctx.targetingKey ? read(flag, ctx, ctx.targetingKey) : void 0,
+    kill: source(
+      "subjectKill",
+      (state, flag) => state.override === "disabled" ? offValue(flag) : void 0
+    ),
+    requireOptIn: source(
+      "subjectOptIn",
+      (state, flag) => state.optedIn ? void 0 : offValue(flag),
+      (flag) => requiresOptIn?.(flag) === true
+    ),
+    grant: source("subjectGrant", (state, flag) => {
+      if (state.override !== "enabled") return void 0;
+      if (state.value !== void 0) return state.value;
+      return typeof flag.def.fallback === "boolean" ? true : void 0;
+    })
+  };
+}
+
+// src/audit.ts
+var DATE = /^\d{4}-\d{2}-\d{2}$/;
+function auditRegistry(flags, options = {}) {
+  const { today = /* @__PURE__ */ new Date(), retiredAfterDays = 40 } = options;
+  const problems = [];
+  const warnings = [];
+  for (const [key, def] of Object.entries(flags)) {
+    const retired = def.retired;
+    if (!retired) continue;
+    if (typeof retired.value !== typeof def.fallback) {
+      problems.push(
+        `flag "${key}" is retired to a ${typeof retired.value} but its fallback is ${typeof def.fallback}. Every evaluation would return the wrong type.`
+      );
+    }
+    if (def.overridable) {
+      warnings.push(
+        `"${key}" is retired but still declares \`overridable\`. Retirement outranks the override cookie, so it can no longer be revealed that way \u2014 drop the field.`
+      );
+    }
+    if (!DATE.test(retired.since)) {
+      problems.push(
+        `flag "${key}" is retired with since: "${retired.since}", which is not YYYY-MM-DD. The date is the cleanup clock, so an unparseable one silently stops it.`
+      );
+      continue;
+    }
+    const days = Math.floor(
+      (today.getTime() - (/* @__PURE__ */ new Date(`${retired.since}T00:00:00Z`)).getTime()) / 864e5
+    );
+    if (days > retiredAfterDays) {
+      warnings.push(
+        `"${key}" has been retired for ${days} days (budget ${retiredAfterDays}).
+      Its doors are dark and its code is dead: delete the components, the
+      routes, then the registry entry. Retiring is a state, not a resting place.`
+      );
+    }
+  }
+  return { problems, warnings };
+}
+
+// src/route-gate.ts
+function matchesPrefix(pathname, prefixes) {
+  return prefixes.some(
+    (prefix) => pathname === prefix || pathname.startsWith(prefix + "/")
+  );
+}
+function createRouteGate(options) {
+  const { resolver, routes, allow = [], unlisted } = options;
+  const entries = Object.entries(routes);
+  for (const [key, prefixes] of entries) {
+    for (const prefix of prefixes) {
+      if (allow.includes(prefix)) {
+        throw new Error(
+          `launchgate: "${prefix}" is both allowed and gated by flag "${key}". The allowlist would serve it whatever the flag says, so the flag is dead.`
+        );
+      }
+    }
+    if (!(key in resolver.flags)) {
+      throw new Error(`launchgate: routes reference unknown flag "${key}"`);
+    }
+  }
+  async function revealedPrefixes(ctx = {}) {
+    const revealed = await Promise.all(
+      entries.map(
+        async ([key, prefixes]) => await resolver.resolve(key, ctx) ? prefixes : []
+      )
+    );
+    return revealed.flat();
+  }
+  return {
+    revealedPrefixes,
+    async permittedPrefixes(ctx) {
+      return [...allow, ...await revealedPrefixes(ctx)];
+    },
+    async isPermitted(pathname, ctx) {
+      if (matchesPrefix(pathname, allow)) return true;
+      if (matchesPrefix(pathname, await revealedPrefixes(ctx))) return true;
+      const flagged = entries.flatMap(([, prefixes]) => prefixes);
+      if (matchesPrefix(pathname, flagged)) return false;
+      return unlisted === "allow";
+    }
+  };
+}
+
+// src/testing.ts
+function withFlags(flags, values = {}) {
+  return createResolver({
+    flags,
+    sources: [
+      {
+        name: "withFlags",
+        decide: ({ key }) => values[key]
+      }
+    ]
+  });
+}
+export {
+  DEFAULT_OVERRIDE_COOKIE,
+  auditRegistry,
+  cookieOverride,
+  createResolver,
+  createRouteGate,
+  defineFlags,
+  envDefault,
+  envOverride,
+  matchesPrefix,
+  readOverrides,
+  signOverrides,
+  subjectStore,
+  withFlags
+};

package/dist/next/index.d.ts

@@ -0,0 +1,42 @@
+import { NextResponse } from 'next/server';
+import { b as FlagRegistry, R as Resolver, E as EvaluationContext } from '../resolver-B2cstRTq.js';
+
+/**
+ * Builds an `EvaluationContext` that reads cookies from the incoming request.
+ *
+ * **This opts the caller into dynamic rendering** — `cookies()` always does. On
+ * a page that is already dynamic (anything authenticated) that costs nothing; on
+ * a page you need statically rendered, don't call it, and see `staticVariant`
+ * in the README instead.
+ */
+declare function requestContext(extra?: EvaluationContext): Promise<EvaluationContext>;
+/**
+ * Route-handler guard. 404, not 403: a feature you don't have shouldn't
+ * advertise its own existence.
+ *
+ *   const gate = await requireFlag(resolver, "network", { targetingKey: orgId });
+ *   if (gate) return gate;
+ */
+declare function requireFlag<T extends FlagRegistry, K extends keyof T & string>(resolver: Resolver<T>, key: K, ctx?: EvaluationContext): Promise<NextResponse | null>;
+interface OverrideRouteOptions<T extends FlagRegistry> {
+    resolver: Resolver<T>;
+    /** HMAC secret. Same value `cookieOverride` was given. Never appears in a URL. */
+    secret: string;
+    /** Shared secret presented as `?token=` to use this route. Must differ from `secret`. */
+    accessToken: string;
+    cookieName?: string;
+    /** Cookie lifetime in seconds. Default 30 days. */
+    maxAge?: number;
+}
+/**
+ * `GET /__flags?token=…&flag=newHomepage&value=on` — sets the signed override
+ * cookie, so you see hidden work on the real production site with no account and
+ * no database. `&clear=1` drops everything; omitting `value` clears one flag.
+ *
+ * Mount it at a path you don't advertise, and give it a real `accessToken`.
+ */
+declare function createOverrideRoute<T extends FlagRegistry>(options: OverrideRouteOptions<T>): {
+    GET: (request: Request) => Promise<NextResponse>;
+};
+
+export { type OverrideRouteOptions, createOverrideRoute, requestContext, requireFlag };

package/dist/next/index.js

@@ -0,0 +1,102 @@
+import {
+  DEFAULT_OVERRIDE_COOKIE,
+  readOverrides,
+  signOverrides
+} from "../chunk-YIOEKCH6.js";
+
+// src/next/index.ts
+import { cookies } from "next/headers";
+import { NextResponse } from "next/server";
+async function requestContext(extra = {}) {
+  const jar = await cookies();
+  return { ...extra, cookie: (name) => jar.get(name)?.value };
+}
+async function requireFlag(resolver, key, ctx) {
+  const value = await resolver.resolve(key, ctx);
+  return value === false || value === void 0 ? NextResponse.json({ error: "Not found" }, { status: 404 }) : null;
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function parseAs(raw, fallback) {
+  if (typeof fallback === "boolean") {
+    const v = raw.trim().toLowerCase();
+    if (v === "on" || v === "true" || v === "1") return true;
+    if (v === "off" || v === "false" || v === "0") return false;
+    return void 0;
+  }
+  if (typeof fallback === "number") {
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return raw;
+}
+function createOverrideRoute(options) {
+  const { resolver, secret, accessToken } = options;
+  const cookieName = options.cookieName ?? DEFAULT_OVERRIDE_COOKIE;
+  const maxAge = options.maxAge ?? 60 * 60 * 24 * 30;
+  async function GET(request) {
+    const url = new URL(request.url);
+    const token = url.searchParams.get("token") ?? "";
+    if (!timingSafeEqual(token, accessToken)) {
+      return NextResponse.json({ error: "Not found" }, { status: 404 });
+    }
+    const jar = await cookies();
+    const current = jar.get(cookieName)?.value;
+    let overrides = (current ? await readOverrides(current, secret) : void 0) ?? {};
+    if (url.searchParams.get("clear") !== null) {
+      overrides = {};
+    } else {
+      const key = url.searchParams.get("flag");
+      if (!key) {
+        return NextResponse.json({ error: "flag is required" }, { status: 400 });
+      }
+      const def = resolver.flags[key];
+      if (!def) {
+        return NextResponse.json({ error: `unknown flag "${key}"` }, { status: 400 });
+      }
+      if (!def.overridable) {
+        return NextResponse.json(
+          { error: `flag "${key}" is not overridable` },
+          { status: 400 }
+        );
+      }
+      const raw = url.searchParams.get("value");
+      if (raw === null) {
+        delete overrides[key];
+      } else {
+        const value = parseAs(raw, def.fallback);
+        if (value === void 0) {
+          return NextResponse.json(
+            { error: `"${raw}" is not a valid value for "${key}"` },
+            { status: 400 }
+          );
+        }
+        overrides[key] = value;
+      }
+    }
+    const body = { overrides };
+    const response = NextResponse.json(body);
+    if (Object.keys(overrides).length === 0) {
+      response.cookies.delete(cookieName);
+    } else {
+      response.cookies.set(cookieName, await signOverrides(overrides, secret), {
+        httpOnly: true,
+        sameSite: "lax",
+        secure: url.protocol === "https:",
+        path: "/",
+        maxAge
+      });
+    }
+    return response;
+  }
+  return { GET };
+}
+export {
+  createOverrideRoute,
+  requestContext,
+  requireFlag
+};