@shipeasy/openapi 1.0.0

package/dist/resources/index.js

@@ -0,0 +1,4528 @@
+// src/resources/gates.ts
+import { z as z2 } from "zod";
+
+// ../core/src/schemas/gates.ts
+import { z } from "zod";
+var gateRuleSchema = z.object({
+  attr: z.string().min(1).describe(
+    "Attribute key on the evaluation context (e.g. `country`, `plan`, `email`). Matched case-sensitively against `Shipeasy.checkGate(user, name)` input."
+  ),
+  op: z.enum(["eq", "neq", "in", "not_in", "gt", "gte", "lt", "lte", "contains", "regex"]).describe(
+    "Comparison operator. Equality: `eq`/`neq`. Set membership: `in`/`not_in` (value is an array). Numeric order: `gt`/`gte`/`lt`/`lte`. String: `contains` (substring), `regex` (JS-flavour pattern, value is the pattern string)."
+  ),
+  value: z.unknown().describe(
+    "Operand. Shape depends on `op`: scalar for `eq/neq/gt/gte/lt/lte/contains`; array of scalars for `in/not_in`; string pattern for `regex`."
+  )
+}).describe(
+  "Single targeting predicate. A gate's `rules` array is evaluated with AND semantics; use the gatekeeper `stack` for OR / fall-through logic."
+);
+var gateNameSchema = z.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "lowercase, digits, _/-; max 64 chars").describe(
+  "Stable gate key used by SDKs (`Shipeasy.checkGate(user, '<name>')`). Lowercase letters, digits, `_` or `-`, must start with a letter/digit, max 64 chars. Immutable after create \u2014 rename = delete + recreate."
+);
+var stackedConditionSchema = z.object({
+  id: z.string().min(1).describe(
+    "Client-supplied stable id for the stack entry (used for React keys, audit diffs)."
+  ),
+  type: z.literal("condition").describe("Discriminator. `condition` = rule-based predicate sub-gate."),
+  name: z.string().optional().describe("Human label shown in the dashboard."),
+  fromTemplate: z.string().nullable().optional().describe(
+    "Id of the project template this entry was seeded from, or `null` if hand-authored."
+  ),
+  pass: z.enum(["all", "any"]).optional().describe("Combinator across `rules`. `all` = AND (default), `any` = OR."),
+  rules: z.array(gateRuleSchema).default([]).describe("Predicates evaluated under `pass`. Empty array = match nothing."),
+  locked: z.boolean().optional().describe("If `true`, dashboard hides edit controls (e.g. the trailing public-floor entry).")
+}).describe(
+  "Rule-based sub-gate. When matched, evaluation short-circuits and the gate returns `true` for the current caller."
+);
+var stackedRolloutSchema = z.object({
+  id: z.string().min(1).describe("Client-supplied stable id for the stack entry."),
+  type: z.literal("rollout").describe("Discriminator. `rollout` = percentage-bucket sub-gate."),
+  name: z.string().optional().describe("Human label shown in the dashboard."),
+  fromTemplate: z.string().nullable().optional().describe("Source template id, or `null`."),
+  rolloutPct: z.number().int().min(0).max(1e4).describe(
+    "Bucket size in basis points (0\u201310000 = 0%\u2013100%). `5000` = 50%, `100` = 1%, allows sub-1% precision."
+  ),
+  bucketBy: z.string().optional().describe(
+    "Attribute used to hash the caller into a bucket. Defaults to `user.userID`. Use e.g. `accountID` to bucket whole accounts together."
+  ),
+  salt: z.string().optional().describe(
+    "Per-entry hash salt. Defaults to the gate's salt. Set explicitly to keep two rollouts independent or correlated across gates."
+  ),
+  locked: z.boolean().optional().describe("If `true`, dashboard hides edit controls.")
+}).describe(
+  "Percentage-rollout sub-gate. Hashes `bucketBy` (default `userID`) with `salt` and returns `true` for `rolloutPct/10000` fraction of callers."
+);
+var stackedGateEntrySchema = z.discriminatedUnion("type", [stackedConditionSchema, stackedRolloutSchema]).describe(
+  "One entry in the ordered gatekeeper stack. Evaluated top-to-bottom; first matching entry decides. Mix `condition` and `rollout` entries to express `internal-only` + `1% beta` + `50% public` in a single gate."
+);
+var gateMetadataFields = {
+  title: z.string().max(140).optional().describe("Human-readable title shown in the dashboard. Free-form, no key format constraint."),
+  description: z.string().max(2e3).optional().describe("Long-form description / runbook. Markdown is rendered in the dashboard."),
+  folder: z.string().max(64).optional().describe(
+    "Folder label for dashboard organisation. Free-form; folders are inferred from the set of values."
+  ),
+  group: z.string().max(64).optional().describe("Group label for dashboard organisation (e.g. team or product area)."),
+  owner_email: z.string().max(190).optional().describe("Owner contact. Displayed verbatim; not used for auth.")
+};
+var gateMetadataPatchSchema = z.object(gateMetadataFields);
+var gateCreateSchema = z.object({
+  name: gateNameSchema,
+  enabled: z.boolean().default(true).describe(
+    "Master switch. Defaults to `true`. Set `false` to create the gate disabled (evaluates to `false` regardless of rules/rollout); flip on via `POST /{id}/enable` or PATCH."
+  ),
+  rollout_pct: z.number().int().min(0).max(1e4).default(0).describe(
+    "Initial rollout in basis points (0\u201310000 = 0%\u2013100%). Use `0` to create the gate dark and ramp via PATCH after deploy validation."
+  ),
+  rules: z.array(gateRuleSchema).default([]).describe(
+    "Targeting predicates. AND-combined. If non-empty, the gate returns `true` only for callers that satisfy every rule **and** fall under `rollout_pct`."
+  ),
+  salt: z.string().min(1).max(64).optional().describe(
+    "Hash salt for percentage bucketing. Auto-generated if omitted. Provide explicitly to keep a gate's buckets stable across delete/recreate. **Immutable after create** \u2014 there is no PATCH for `salt` because changing it would re-bucket every caller."
+  ),
+  stack: z.array(stackedGateEntrySchema).nullable().optional().describe(
+    "Optional gatekeeper stack. When provided, takes precedence over `rules` + `rollout_pct` at evaluation time. Omit (or pass `null`) for a flat gate."
+  ),
+  ...gateMetadataFields
+}).describe(
+  "Body for `POST /api/admin/gates`. At minimum supply `name`; everything else has sensible defaults."
+);
+var gateUpdateSchema = z.object({
+  rollout_pct: z.number().int().min(0).max(1e4).optional().describe("New rollout in basis points (0\u201310000 = 0%\u2013100%). Omit to leave unchanged."),
+  rules: z.array(gateRuleSchema).optional().describe(
+    "Replaces the rule list wholesale. To add a value to an `in` rule, send the full new `rules` array with the augmented `value` (e.g. previous `['US','CA']` \u2192 `['US','CA','GB']`)."
+  ),
+  enabled: z.boolean().optional().describe(
+    "Master switch. `false` makes the gate evaluate to `false` for every caller regardless of `rollout_pct`, `rules`, or `stack` \u2014 use as kill switch."
+  ),
+  stack: z.array(stackedGateEntrySchema).nullable().optional().describe(
+    "Replaces the gatekeeper stack wholesale. Send `null` to revert to flat `rules` + `rollout_pct` evaluation."
+  ),
+  ...gateMetadataFields
+}).describe(
+  "Body for `PATCH /api/admin/gates/{id}`. Partial \u2014 only supplied fields change. Array fields (`rules`, `stack`) replace, not merge."
+);
+var gateResponseSchema = z.object({
+  id: z.string().describe("Stable opaque gate id (`gat_\u2026`)."),
+  name: gateNameSchema,
+  /** D1 stores enabled as 0/1; clients see either form. */
+  enabled: z.union([z.boolean(), z.number().int().min(0).max(1)]).describe("Master switch. Returned as `1`/`0` from D1; treat truthy as enabled."),
+  /** Rollout percentage in basis points (0–10000 = 0%–100%). */
+  rolloutPct: z.number().int().min(0).max(1e4).describe("Current rollout in basis points (0\u201310000)."),
+  rules: z.array(gateRuleSchema).optional(),
+  salt: z.string().optional().describe("Hash salt used for percentage bucketing."),
+  title: z.string().nullable().optional(),
+  description: z.string().nullable().optional(),
+  folder: z.string().nullable().optional(),
+  groupName: z.string().nullable().optional().describe("Group label (note: `groupName` in response, `group` in request)."),
+  ownerEmail: z.string().nullable().optional().describe("Owner email (note: `ownerEmail` in response, `owner_email` in request)."),
+  stack: z.array(stackedGateEntrySchema).nullable().optional(),
+  updatedAt: z.string().describe("ISO-8601 timestamp of last mutation.")
+});
+var gateCreateResponseSchema = z.object({
+  id: z.string().describe("Newly assigned gate id (`gat_\u2026`)."),
+  name: gateNameSchema
+});
+var gateUpdateResponseSchema = z.object({ id: z.string().describe("Gate id that was updated.") }).describe("Update returns only the id \u2014 re-fetch via `GET /api/admin/gates` for the full row.");
+var gateDeleteResponseSchema = z.object({ ok: z.literal(true) });
+var gateToggleResponseSchema = z.object({
+  id: z.string(),
+  enabled: z.boolean()
+});
+
+// src/transport.ts
+var ApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+
+// src/resources/gates.ts
+var gateListResponseSchema = z2.object({
+  data: z2.array(gateResponseSchema),
+  next_cursor: z2.string().nullable()
+});
+var BASE = "/api/admin/gates";
+function gatesClient(t) {
+  async function list(opts = {}) {
+    const query = {};
+    if (opts.limit !== void 0) query.limit = String(opts.limit);
+    if (opts.cursor) query.cursor = opts.cursor;
+    return t.request("GET", BASE, void 0, query);
+  }
+  async function listAll() {
+    const out = [];
+    let cursor;
+    do {
+      const page = await list({ limit: 500, cursor });
+      out.push(...page.data);
+      cursor = page.next_cursor ?? void 0;
+    } while (cursor);
+    return out;
+  }
+  async function resolve(idOrName) {
+    const all = await listAll();
+    const found = all.find((g) => g.id === idOrName) ?? all.find((g) => g.name === idOrName);
+    if (!found) throw new ApiError(`Gate '${idOrName}' not found`, 404);
+    return found;
+  }
+  return {
+    list,
+    listAll,
+    resolve,
+    getByName: async (name) => {
+      const found = (await listAll()).find((g) => g.name === name);
+      if (!found) throw new ApiError(`Gate '${name}' not found`, 404);
+      return found;
+    },
+    create: (input) => t.request("POST", BASE, gateCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE}/${id}`, gateUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE}/${id}`),
+    enable: (id) => t.request("POST", `${BASE}/${id}/enable`),
+    disable: (id) => t.request("POST", `${BASE}/${id}/disable`),
+    setRollout: async (name, pct) => {
+      if (!Number.isFinite(pct) || pct < 0 || pct > 100) {
+        throw new ApiError("rollout must be a number between 0 and 100", 400);
+      }
+      const gate = await resolve(name);
+      return t.request("PATCH", `${BASE}/${gate.id}`, {
+        rollout_pct: Math.round(pct * 100)
+      });
+    }
+  };
+}
+var gatesResource = {
+  name: "gates",
+  basePath: BASE,
+  describeOne: "feature gate",
+  describeMany: "feature gates",
+  tag: {
+    name: "Gates",
+    description: [
+      "Feature gates: boolean flags evaluated at runtime against project rules + a percentage rollout.",
+      "",
+      "**Identity.** Each gate is keyed by a stable `name` (a-z, 0-9, `_`/`-`, max 64 chars) which is what SDKs pass to `Shipeasy.checkGate(user, '<name>')`. The `name` is immutable \u2014 rename means delete + recreate.",
+      "",
+      "**Evaluation model.** A gate returns `true` when (a) `enabled` is true, and (b) the caller satisfies the gate's rules. There are two evaluation shapes:",
+      "- **Flat** \u2014 `rules` (AND-combined predicates) gate the caller, then `rollout_pct` (basis points, 0\u201310000) hashes them into a bucket. Used for simple `is in X% rollout` gates.",
+      "- **Gatekeeper stack** \u2014 an ordered array of `condition` and `rollout` sub-gates, evaluated top-to-bottom; first match wins. Used to express `internal-only \u222A 1% beta \u222A 50% public` in one gate. When `stack` is present it takes precedence over the flat fields.",
+      "",
+      "**Rules.** Each rule is `{ attr, op, value }`. Supported ops: `eq`, `neq`, `in`, `not_in`, `gt`, `gte`, `lt`, `lte`, `contains`, `regex`. Attribute names match the keys on the SDK evaluation context (e.g. `country`, `plan`, `email`).",
+      "",
+      "**Rollout basis points.** `rollout_pct` is in **basis points**, not percent. `0` = 0%, `100` = 1%, `5000` = 50%, `10000` = 100%. This allows sub-1% precision (e.g. `7` = 0.07%).",
+      "",
+      "**Lifecycle.** Create dark (`rollout_pct: 0`) \u2192 attach rules \u2192 ramp via PATCH \u2192 flip kill-switch via `disable`/`enable` \u2192 delete once retired. Deletion is blocked while a running experiment references the gate as a targeting gate."
+    ].join("\n")
+  },
+  schemas: {
+    create: gateCreateSchema,
+    update: gateUpdateSchema
+  },
+  /** Custom action endpoints beyond CRUD (POST <basePath>/:id/<action>). */
+  actions: [
+    { name: "enable", description: "Enable a gate" },
+    { name: "disable", description: "Disable a gate" }
+  ],
+  /**
+   * Full operation list for the OpenAPI doc. Order here is the order shown in
+   * the docs sidebar. The typed client (`gatesClient`) is the runtime contract;
+   * this is the documented surface.
+   */
+  endpoints: [
+    {
+      operationId: "listGates",
+      method: "GET",
+      path: "",
+      summary: "List feature gates",
+      description: "Returns a single page of gates ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.",
+      response: gateListResponseSchema,
+      examples: {
+        response: {
+          data: [
+            {
+              id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc",
+              name: "checkout_v2",
+              enabled: 1,
+              rolloutPct: 5e3,
+              rules: [
+                { attr: "country", op: "in", value: ["US", "CA", "GB"] },
+                { attr: "plan", op: "neq", value: "free" }
+              ],
+              salt: "9c1f4f1f2c0c4a5fa1c2b6d3e7c8e3a1",
+              title: "Checkout v2",
+              description: "New checkout flow. Pro users in US/CA/GB only.",
+              folder: "checkout",
+              groupName: "growth",
+              ownerEmail: "ana@example.com",
+              stack: null,
+              updatedAt: "2026-05-09T16:01:22.000Z"
+            }
+          ],
+          next_cursor: null
+        }
+      },
+      useCase: "Snapshot every gate in the project \u2014 for example to render an admin overview or to drive a CI check that asserts no gate is left at 100% in staging."
+    },
+    {
+      operationId: "createGate",
+      method: "POST",
+      path: "",
+      summary: "Create a feature gate",
+      description: [
+        "Creates a new gate. Default `enabled: true` at the supplied `rollout_pct` (`0` = fully dark).",
+        "",
+        "Only `name` is required. Request fields use snake_case (`owner_email`); the GET response returns camelCase (`ownerEmail`, `groupName`).",
+        "",
+        "Returns `409` if `name` already exists in the project (case-sensitive)."
+      ].join("\n"),
+      successStatus: 201,
+      request: gateCreateSchema,
+      response: gateCreateResponseSchema,
+      examples: {
+        requestExamples: {
+          minimal: {
+            summary: "Minimal \u2014 dark gate, name only",
+            description: "Smallest valid body. The gate is created `enabled: true` at `rollout_pct: 0`, with no rules. Ramp it later via PATCH.",
+            value: { name: "checkout_v2" }
+          },
+          targeted: {
+            summary: "Targeted rollout \u2014 rules + percentage",
+            description: "Gate Pro users in US/CA/GB, then hash 10% of that audience into the on-bucket (`rollout_pct: 1000` = 10.00%). Adds dashboard metadata so the gate is self-documenting.",
+            value: {
+              name: "checkout_v2",
+              rollout_pct: 1e3,
+              rules: [
+                { attr: "country", op: "in", value: ["US", "CA", "GB"] },
+                { attr: "plan", op: "neq", value: "free" }
+              ],
+              title: "Checkout v2",
+              description: "New checkout flow. Pro users in US/CA/GB only.",
+              folder: "checkout",
+              group: "growth",
+              owner_email: "ana@example.com"
+            }
+          },
+          gatekeeperStack: {
+            summary: "Gatekeeper stack \u2014 internal \u222A beta \u222A public",
+            description: "Three-layer fall-through: employees always on, opted-in beta accounts always on, then 25% of everyone else. First match wins; evaluation stops as soon as one entry returns `true`.",
+            value: {
+              name: "checkout_v2",
+              title: "Checkout v2",
+              owner_email: "ana@example.com",
+              stack: [
+                {
+                  id: "01HKJ0EMP",
+                  type: "condition",
+                  name: "Employees",
+                  pass: "any",
+                  rules: [{ attr: "email", op: "regex", value: "@acme\\.com$" }]
+                },
+                {
+                  id: "01HKJ0BETA",
+                  type: "condition",
+                  name: "Beta opt-in",
+                  pass: "all",
+                  rules: [{ attr: "beta_opt_in", op: "eq", value: true }]
+                },
+                {
+                  id: "01HKJ0PUB",
+                  type: "rollout",
+                  name: "Public",
+                  rolloutPct: 2500,
+                  bucketBy: "userID",
+                  locked: true
+                }
+              ]
+            }
+          },
+          disabledOnCreate: {
+            summary: "Disabled on create \u2014 provision then enable later",
+            description: "Create with `enabled: false` so the gate evaluates to `false` for every caller until a follow-up `POST /{id}/enable`. Useful when provisioning ahead of a launch.",
+            value: { name: "checkout_v2", enabled: false, rollout_pct: 0 }
+          }
+        },
+        response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", name: "checkout_v2" }
+      },
+      useCase: [
+        '- **Dark create + ramp later** \u2014 `{ "name": "checkout_v2" }` at 0% rollout. Ramp via PATCH after deploy validation.',
+        "- **Targeted rollout** \u2014 supply `rules` to gate the caller (e.g. only `plan = pro` users) plus a `rollout_pct` to bucket within that audience.",
+        "- **Gatekeeper stack** \u2014 supply `stack` instead of `rules`/`rollout_pct` for `internal \u222A beta \u222A public` fall-through. Stack entries evaluated top-to-bottom; first match wins.",
+        "- **Dashboard metadata** \u2014 populate `title`, `description`, `folder`, `group`, `owner_email` so the admin UI is self-documenting from day one.",
+        "- **Disabled on create** \u2014 pre-provision with `enabled: false` for a future launch; flip on with `POST /{id}/enable` at go-live."
+      ].join("\n")
+    },
+    {
+      operationId: "updateGate",
+      method: "PATCH",
+      path: "/{id}",
+      summary: "Update a feature gate",
+      description: [
+        "Partial update \u2014 only supplied fields change. Array fields (`rules`, `stack`) **replace** wholesale; there is no merge or append.",
+        "",
+        "`name` and the gate id are immutable. The response carries only `{ id }` \u2014 re-fetch via `GET /api/admin/gates` for the new row."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque gate id (`gat_\u2026`)." },
+      request: gateUpdateSchema,
+      response: gateUpdateResponseSchema,
+      examples: {
+        requestExamples: {
+          rampRollout: {
+            summary: "Ramp rollout \u2014 0 \u2192 50%",
+            description: "Single-field patch. `5000` basis points = 50%.",
+            value: { rollout_pct: 5e3 }
+          },
+          killSwitch: {
+            summary: "Kill switch \u2014 disable the gate",
+            description: "Forces evaluation to `false` for every caller, regardless of rules or rollout. Same effect as `POST /{id}/disable` but composable with other patches.",
+            value: { enabled: false }
+          },
+          extendInRule: {
+            summary: "Add a value to an `in` rule",
+            description: "Array fields replace wholesale \u2014 there is no per-rule patch. To add `'AU'` to a country whitelist that previously held `['US','CA','GB']`, send the full new `rules` array. Same pattern applies to `not_in`.",
+            value: {
+              rules: [
+                { attr: "country", op: "in", value: ["US", "CA", "GB", "AU"] },
+                { attr: "plan", op: "neq", value: "free" }
+              ]
+            }
+          },
+          replaceStack: {
+            summary: "Replace gatekeeper stack",
+            description: 'Stack is replace-wholesale. Send the full new ordered list. Pass `"stack": null` to revert the gate to flat `rules` + `rollout_pct` evaluation.',
+            value: {
+              stack: [
+                {
+                  id: "01HKJ0EMP",
+                  type: "condition",
+                  name: "Employees",
+                  pass: "any",
+                  rules: [{ attr: "email", op: "regex", value: "@acme\\.com$" }]
+                },
+                {
+                  id: "01HKJ0PUB",
+                  type: "rollout",
+                  name: "Public",
+                  rolloutPct: 5e3,
+                  locked: true
+                }
+              ]
+            }
+          },
+          updateMetadata: {
+            summary: "Update dashboard metadata",
+            description: "Any subset of `title`, `description`, `folder`, `group`, `owner_email`. Snake-case in the request; the GET response returns camelCase (`groupName`, `ownerEmail`).",
+            value: {
+              title: "Checkout v2 (50%)",
+              description: "Bumped to 50% after passing canary. Added AU.",
+              folder: "checkout",
+              owner_email: "ana@example.com"
+            }
+          }
+        },
+        response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc" }
+      },
+      useCase: [
+        '- **Ramp rollout** \u2014 `{ "rollout_pct": 5000 }` for 50%. Basis points (0\u201310000); `100` = 1%.',
+        '- **Kill switch** \u2014 `{ "enabled": false }`. Forces evaluation to `false` for every caller regardless of rules/rollout. Re-enable with `POST /{id}/enable` or `{ "enabled": true }`.',
+        '- **Modify a rule\'s `in` set** \u2014 send the full new `rules` array. To add `\'GB\'` to `[\'US\',\'CA\']`: `{ "rules": [{ "attr": "country", "op": "in", "value": ["US","CA","GB"] }] }`. No per-rule patch endpoint.',
+        '- **Add targeting from scratch** \u2014 `{ "rules": [{ "attr": "email", "op": "regex", "value": "@acme\\\\.com$" }] }`.',
+        '- **Switch to gatekeeper stack** \u2014 send a non-null `stack`. To revert to flat eval, send `{ "stack": null }`.',
+        "- **Update metadata** \u2014 any subset of `title`, `description`, `folder`, `group`, `owner_email`."
+      ].join("\n")
+    },
+    {
+      operationId: "deleteGate",
+      method: "DELETE",
+      path: "/{id}",
+      summary: "Delete a feature gate",
+      description: "Soft-deletes the gate. Returns 409 if the gate is still referenced by a running experiment as a targeting gate \u2014 stop the experiment first.",
+      pathParams: { id: "Stable opaque gate id (`gat_\u2026`)." },
+      response: gateDeleteResponseSchema,
+      examples: { response: { ok: true } },
+      useCase: "Tear down a gate after a feature has fully shipped and the rollout flag is no longer needed."
+    },
+    {
+      operationId: "enableGate",
+      method: "POST",
+      path: "/{id}/enable",
+      summary: "Enable a gate",
+      description: "Sets `enabled: true`. The current `rollout_pct` is preserved.",
+      pathParams: { id: "Stable opaque gate id." },
+      response: gateToggleResponseSchema,
+      examples: { response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", enabled: true } },
+      useCase: "Re-enable a previously disabled gate without re-issuing a full update."
+    },
+    {
+      operationId: "disableGate",
+      method: "POST",
+      path: "/{id}/disable",
+      summary: "Disable a gate",
+      description: "Sets `enabled: false` so the gate evaluates to `false` for every caller, regardless of `rollout_pct` or `rules`. Use as a quick kill switch.",
+      pathParams: { id: "Stable opaque gate id." },
+      response: gateToggleResponseSchema,
+      examples: { response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", enabled: false } },
+      useCase: "Flip a gate off in production without redeploying \u2014 the canonical kill-switch flow."
+    }
+  ]
+};
+
+// src/resources/experiments.ts
+import { z as z4 } from "zod";
+
+// ../core/src/schemas/experiments.ts
+import { z as z3 } from "zod";
+var experimentNameSchema = z3.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/).describe(
+  "Stable experiment key (a-z, 0-9, `_`/`-`, must start with letter/digit, max 64 chars). Used by SDKs as `Shipeasy.getExperiment(user, '<name>')`. Immutable after create."
+);
+var experimentGroupSchema = z3.object({
+  name: z3.string().min(1).max(64).describe("Group label (e.g. `control`, `treatment_a`). Max 64 chars."),
+  weight: z3.number().int().min(0).max(1e4).describe(
+    "Allocation weight in basis points (0\u201310000). The sum across all groups must equal exactly **10000** (100%)."
+  ),
+  params: z3.record(z3.string(), z3.unknown()).default({}).describe(
+    "Per-group parameter values delivered to the SDK when a caller is hashed into this group. Keys must match the experiment's `params` schema."
+  )
+}).describe("One variant in the experiment. Weights across all groups must sum to 10000.");
+var paramSchemaSchema = z3.record(z3.string(), z3.enum(["string", "bool", "number"])).describe(
+  "Map of param-name \u2192 scalar type. Defines the shape of `groups[].params`. Example: `{ headline: 'string', show_cta: 'bool' }`."
+);
+var experimentCreateSchema = z3.object({
+  name: experimentNameSchema,
+  description: z3.string().max(2e3).nullable().default(null).describe("Free-form description. Max 2000 chars, markdown rendered in the dashboard."),
+  tag: z3.string().max(64).nullable().default(null).describe("Optional tag used to group experiments in the dashboard."),
+  universe: z3.string().min(1).describe(
+    "Name of an existing universe in the project. Returns `422` if the universe doesn't exist."
+  ),
+  targeting_gate: z3.string().nullable().default(null).describe(
+    "Optional gate name. Only callers that pass the gate are enrolled in the experiment."
+  ),
+  allocation_pct: z3.number().int().min(0).max(1e4).default(0).describe(
+    "Share of the (gated) audience allocated to the experiment, in basis points (0\u201310000 = 0%\u2013100%). `0` = unallocated. Immutable while the experiment is running."
+  ),
+  salt: z3.string().min(1).max(64).optional().describe("Hash salt for bucketing. Auto-generated if omitted. Immutable while running."),
+  params: paramSchemaSchema.default({}),
+  groups: z3.array(experimentGroupSchema).min(2).describe(
+    "Two or more variants. Weights must sum to exactly 10000 (100%). Immutable while running."
+  ),
+  significance_threshold: z3.number().min(1e-4).max(0.5).default(0.05).describe(
+    "p-value cutoff used by the analysis pass. Defaults to `0.05`. Values other than 0.05 require Pro plan or higher."
+  ),
+  min_runtime_days: z3.number().int().min(0).max(365).default(0).describe("Minimum days the experiment must run before results are considered conclusive."),
+  min_sample_size: z3.number().int().min(1).default(100).describe("Minimum exposures per group before results are considered conclusive."),
+  sequential_testing: z3.boolean().default(false).describe(
+    "Enable sequential testing (always-valid p-values). Requires Premium plan or higher."
+  )
+}).refine(
+  (e) => e.groups.reduce((s, g) => s + g.weight, 0) === 1e4,
+  "groups weights must sum to exactly 10000"
+).describe(
+  "Body for `POST /api/admin/experiments`. `name`, `universe`, and `groups` (\u22652, weights sum to 10000) required."
+);
+var experimentUpdateSchema = z3.object({
+  name: experimentNameSchema.optional(),
+  description: z3.string().max(2e3).nullable().optional(),
+  tag: z3.string().max(64).nullable().optional(),
+  targeting_gate: z3.string().nullable().optional(),
+  allocation_pct: z3.number().int().min(0).max(1e4).optional().describe("Basis-points allocation (0\u201310000). Immutable while the experiment is running."),
+  salt: z3.string().min(1).max(64).optional().describe("Hash salt. Immutable while running."),
+  universe: z3.string().optional().describe(
+    "New universe name. Immutable while running. Returns `422` if the universe doesn't exist."
+  ),
+  params: paramSchemaSchema.optional(),
+  groups: z3.array(experimentGroupSchema).min(2).optional().describe("Replacement groups. Weights must sum to 10000. Immutable while running."),
+  significance_threshold: z3.number().min(1e-4).max(0.5).optional(),
+  min_runtime_days: z3.number().int().min(0).max(365).optional(),
+  min_sample_size: z3.number().int().min(1).optional(),
+  sequential_testing: z3.boolean().optional()
+}).describe(
+  "Body for `PATCH /api/admin/experiments/{id}`. Partial \u2014 only supplied fields change. `allocation_pct`, `groups`, `salt`, `universe`, `params` are immutable while the experiment is running (stop first)."
+);
+var experimentStatusUpdateSchema = z3.object({
+  status: z3.enum(["draft", "running", "stopped", "archived"]).describe(
+    "Target status. Allowed transitions: `draft \u2192 running`, `running \u2192 stopped`, `stopped \u2192 archived`, `draft \u2192 archived`. Restarting an archived experiment is not allowed."
+  )
+}).describe("Body for `POST /api/admin/experiments/{id}/status`.");
+var experimentMetricsUpdateSchema = z3.object({
+  metrics: z3.array(
+    z3.object({
+      metric_id: z3.string().describe("Existing metric id in the project."),
+      role: z3.enum(["goal", "guardrail", "secondary"]).describe(
+        "Metric role. `goal` drives the decision, `guardrail` blocks ship if degraded, `secondary` is informational."
+      )
+    })
+  ).describe("Replacement metrics list \u2014 replaces the current attachments wholesale.")
+}).describe(
+  "Body for `POST /api/admin/experiments/{id}/metrics`. Replaces the experiment's metric attachments wholesale. Returns `422` if any `metric_id` is unknown."
+);
+var experimentResponseSchema = z3.object({
+  id: z3.string().describe("Stable opaque experiment id (`exp_\u2026`)."),
+  name: experimentNameSchema,
+  description: z3.string().nullable(),
+  tag: z3.string().nullable(),
+  status: z3.enum(["draft", "running", "stopped", "archived"]),
+  universe: z3.string().describe("Universe name this experiment draws from."),
+  targetingGate: z3.string().nullable(),
+  allocationPct: z3.number().int().describe("Allocation in basis points (0\u201310000)."),
+  salt: z3.string(),
+  params: z3.record(z3.string(), z3.enum(["string", "bool", "number"])),
+  groups: z3.array(experimentGroupSchema),
+  significanceThreshold: z3.number(),
+  minRuntimeDays: z3.number().int(),
+  minSampleSize: z3.number().int(),
+  sequentialTesting: z3.boolean(),
+  startedAt: z3.string().nullable().describe("ISO-8601 timestamp the experiment last transitioned to `running`, or `null`."),
+  stoppedAt: z3.string().nullable().optional(),
+  updatedAt: z3.string()
+});
+var experimentCreateResponseSchema = z3.object({
+  id: z3.string().describe("Newly assigned experiment id."),
+  name: experimentNameSchema
+});
+var experimentUpdateResponseSchema = z3.object({
+  id: z3.string().describe("Experiment id that was updated.")
+});
+var experimentDeleteResponseSchema = z3.object({ ok: z3.literal(true) });
+var experimentStatusResponseSchema = z3.object({
+  id: z3.string(),
+  status: z3.enum(["draft", "running", "stopped", "archived"])
+});
+var experimentMetricsResponseSchema = z3.object({
+  id: z3.string(),
+  metrics: z3.array(
+    z3.object({
+      metric_id: z3.string(),
+      role: z3.enum(["goal", "guardrail", "secondary"])
+    })
+  )
+});
+var experimentResultRowSchema = z3.object({
+  metric: z3.string(),
+  group_name: z3.string(),
+  ds: z3.string().describe("Date slice (`YYYY-MM-DD`)."),
+  n: z3.number().nullable(),
+  mean: z3.number().nullable(),
+  delta_pct: z3.number().nullable(),
+  p_value: z3.number().nullable(),
+  srm_detected: z3.number().nullable().describe("`1` if sample-ratio mismatch detected, else `0`.")
+});
+var experimentResultsResponseSchema = z3.object({
+  experiment: z3.object({
+    id: z3.string(),
+    name: experimentNameSchema,
+    status: z3.enum(["draft", "running", "stopped", "archived"])
+  }),
+  results: z3.array(experimentResultRowSchema)
+});
+var experimentTimeseriesResponseSchema = z3.object({
+  experiment: z3.object({
+    id: z3.string(),
+    name: experimentNameSchema,
+    status: z3.enum(["draft", "running", "stopped", "archived"])
+  }),
+  series: z3.array(experimentResultRowSchema)
+});
+var experimentReanalyzeResponseSchema = z3.object({
+  id: z3.string(),
+  queued: z3.literal(true)
+});
+
+// src/resources/experiments.ts
+var experimentListResponseSchema = z4.object({
+  data: z4.array(experimentResponseSchema),
+  next_cursor: z4.string().nullable()
+});
+var BASE2 = "/api/admin/experiments";
+function experimentsClient(t) {
+  async function list(opts = {}) {
+    const query = {};
+    if (opts.limit !== void 0) query.limit = String(opts.limit);
+    if (opts.cursor) query.cursor = opts.cursor;
+    return t.request("GET", BASE2, void 0, query);
+  }
+  async function listAll() {
+    const out = [];
+    let cursor;
+    do {
+      const page = await list({ limit: 500, cursor });
+      out.push(...page.data);
+      cursor = page.next_cursor ?? void 0;
+    } while (cursor);
+    return out;
+  }
+  async function resolve(idOrName) {
+    try {
+      return await t.request("GET", `${BASE2}/${idOrName}`);
+    } catch (err) {
+      if (!(err instanceof ApiError) || err.status !== 404) throw err;
+    }
+    const all = await listAll();
+    const found = all.find((e) => e.name === idOrName);
+    if (!found) throw new ApiError(`Experiment '${idOrName}' not found`, 404);
+    return found;
+  }
+  async function setStatus(id, status) {
+    return t.request(
+      "POST",
+      `${BASE2}/${id}/status`,
+      experimentStatusUpdateSchema.parse({ status })
+    );
+  }
+  return {
+    list,
+    listAll,
+    resolve,
+    get: (id) => t.request("GET", `${BASE2}/${id}`),
+    create: (input) => t.request("POST", BASE2, experimentCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE2}/${id}`, experimentUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE2}/${id}`),
+    setStatus,
+    start: (id) => setStatus(id, "running"),
+    stop: (id) => setStatus(id, "stopped"),
+    archive: (id) => setStatus(id, "archived"),
+    setMetrics: (id, input) => t.request("POST", `${BASE2}/${id}/metrics`, experimentMetricsUpdateSchema.parse(input)),
+    results: (id) => t.request("GET", `${BASE2}/${id}/results`),
+    timeseries: (id, metric) => t.request(
+      "GET",
+      `${BASE2}/${id}/timeseries`,
+      void 0,
+      metric ? { metric } : void 0
+    ),
+    reanalyze: (id) => t.request("POST", `${BASE2}/${id}/reanalyze`)
+  };
+}
+var SAMPLE_EXP = {
+  id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1",
+  name: "checkout_button_color",
+  description: "Test green vs. blue CTA on the checkout page.",
+  tag: "checkout",
+  status: "running",
+  universe: "primary_users",
+  targetingGate: null,
+  allocationPct: 5e3,
+  salt: "8d3e9a1f6b7c4a5fa1c2b6d3e7c8e3a1",
+  params: { cta_color: "string" },
+  groups: [
+    { name: "control", weight: 5e3, params: { cta_color: "blue" } },
+    { name: "treatment", weight: 5e3, params: { cta_color: "green" } }
+  ],
+  significanceThreshold: 0.05,
+  minRuntimeDays: 7,
+  minSampleSize: 1e3,
+  sequentialTesting: false,
+  startedAt: "2026-05-01T12:00:00.000Z",
+  stoppedAt: null,
+  updatedAt: "2026-05-09T18:22:11.000Z"
+};
+var experimentsResource = {
+  name: "experiments",
+  basePath: BASE2,
+  describeOne: "experiment",
+  describeMany: "experiments",
+  tag: {
+    name: "Experiments",
+    description: [
+      "A/B/n experiments: randomised group assignment plus the analysis pipeline (t-test, sequential testing, SRM detection) on top of a universe.",
+      "",
+      "**Identity.** Stable `name` (a-z, 0-9, `_`/`-`, max 64 chars). Immutable after create.",
+      "",
+      "**Lifecycle.** `draft \u2192 running \u2192 stopped \u2192 archived`. Transition via `POST /{id}/status`. Restarting an archived experiment is not allowed.",
+      "",
+      "**Allocation.** `allocation_pct` (basis points, 0\u201310000) is the share of the targeted audience enrolled; `groups[].weight` (must sum to 10000) splits the enrolled audience. `targeting_gate` narrows the eligible audience before allocation.",
+      "",
+      "**Immutable while running.** `allocation_pct`, `groups`, `salt`, `universe`, `params` cannot be edited on a running experiment \u2014 stop it first.",
+      "",
+      "**Metrics.** Attach via `POST /{id}/metrics`. Each metric has a role: `goal` drives the decision, `guardrail` blocks ship on regression, `secondary` is informational.",
+      "",
+      "**Analysis.** Daily cron writes results to D1. Read via `GET /{id}/results` (latest per metric/group/day) or `GET /{id}/timeseries` (full history). `POST /{id}/reanalyze` requeues the analysis pass."
+    ].join("\n")
+  },
+  schemas: {
+    create: experimentCreateSchema,
+    update: experimentUpdateSchema
+  },
+  actions: [
+    { name: "start", description: "Transition draft experiment to running" },
+    { name: "stop", description: "Stop a running experiment" },
+    { name: "archive", description: "Archive a stopped experiment" },
+    { name: "reanalyze", description: "Re-run analysis pass for the experiment" }
+  ],
+  endpoints: [
+    {
+      operationId: "listExperiments",
+      method: "GET",
+      path: "",
+      summary: "List experiments",
+      description: "Returns a single page of non-archived experiments ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.",
+      response: experimentListResponseSchema,
+      examples: { response: { data: [SAMPLE_EXP], next_cursor: null } },
+      useCase: "Snapshot every active experiment in the project \u2014 e.g. render an overview dashboard or drive a CI check that no experiment has been running past its `min_runtime_days`."
+    },
+    {
+      operationId: "getExperiment",
+      method: "GET",
+      path: "/{id}",
+      summary: "Get one experiment",
+      description: "Returns the full experiment row including groups, params, allocation, and lifecycle timestamps.",
+      pathParams: { id: "Stable opaque experiment id (`exp_\u2026`) or the experiment's `name`." },
+      response: experimentResponseSchema,
+      examples: { response: SAMPLE_EXP },
+      useCase: "Fetch one experiment to render the detail page or to inspect its current allocation and group weights."
+    },
+    {
+      operationId: "createExperiment",
+      method: "POST",
+      path: "",
+      summary: "Create an experiment",
+      description: [
+        "Creates a new experiment in `draft` status. `name`, `universe`, and `groups` are required; everything else has sensible defaults.",
+        "",
+        "Returns `409` if `name` already exists, `422` if the named universe doesn't exist, `403` if a plan-gated option is set (`sequential_testing`, custom `significance_threshold`) on a plan that doesn't include it."
+      ].join("\n"),
+      successStatus: 201,
+      request: experimentCreateSchema,
+      response: experimentCreateResponseSchema,
+      examples: {
+        requestExamples: {
+          minimal: {
+            summary: "Minimal \u2014 two-group 50/50",
+            description: "Smallest valid body. Two groups at 50/50, no allocation, no targeting.",
+            value: {
+              name: "checkout_button_color",
+              universe: "primary_users",
+              groups: [
+                { name: "control", weight: 5e3 },
+                { name: "treatment", weight: 5e3 }
+              ]
+            }
+          },
+          targeted: {
+            summary: "Targeted \u2014 gate + allocation + params",
+            description: "Gate the audience with a `targeting_gate`, allocate 50% of it, and parameterise the variants.",
+            value: {
+              name: "checkout_button_color",
+              description: "Green CTA on checkout for Pro users.",
+              universe: "primary_users",
+              targeting_gate: "pro_plan_only",
+              allocation_pct: 5e3,
+              params: { cta_color: "string" },
+              groups: [
+                { name: "control", weight: 5e3, params: { cta_color: "blue" } },
+                { name: "treatment", weight: 5e3, params: { cta_color: "green" } }
+              ]
+            }
+          },
+          multivariant: {
+            summary: "Multivariant \u2014 three groups",
+            description: "Three variants splitting 40/30/30. Requires the sum to equal 10000.",
+            value: {
+              name: "headline_test",
+              universe: "primary_users",
+              groups: [
+                { name: "control", weight: 4e3 },
+                { name: "alt_a", weight: 3e3 },
+                { name: "alt_b", weight: 3e3 }
+              ]
+            }
+          },
+          sequential: {
+            summary: "Sequential testing \u2014 Premium plan",
+            description: "Enable always-valid sequential tests. Requires Premium plan or higher.",
+            value: {
+              name: "checkout_button_color",
+              universe: "primary_users",
+              groups: [
+                { name: "control", weight: 5e3 },
+                { name: "treatment", weight: 5e3 }
+              ],
+              sequential_testing: true,
+              min_runtime_days: 14
+            }
+          }
+        },
+        response: { id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1", name: "checkout_button_color" }
+      },
+      useCase: [
+        "- **Minimal 50/50** \u2014 `name` + `universe` + two equal-weight groups.",
+        "- **Targeted rollout** \u2014 supply `targeting_gate` to restrict the eligible audience and `allocation_pct` to enrol a slice of it.",
+        "- **Multivariant** \u2014 three or more groups with weights summing to 10000.",
+        "- **Sequential testing** \u2014 `sequential_testing: true` for Premium plans."
+      ].join("\n")
+    },
+    {
+      operationId: "updateExperiment",
+      method: "PATCH",
+      path: "/{id}",
+      summary: "Update an experiment",
+      description: [
+        "Partial update. `allocation_pct`, `groups`, `salt`, `universe`, `params` are **immutable while running** \u2014 returns `409` if you try. Stop the experiment first.",
+        "",
+        "Editing `groups` while in `draft` is fine; weights must still sum to 10000."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque experiment id." },
+      request: experimentUpdateSchema,
+      response: experimentUpdateResponseSchema,
+      examples: {
+        requestExamples: {
+          rampAllocation: {
+            summary: "Ramp allocation \u2014 0 \u2192 50%",
+            description: "Bumps the share of the targeted audience enrolled. Allowed only when the experiment is in `draft`.",
+            value: { allocation_pct: 5e3 }
+          },
+          changeWeights: {
+            summary: "Change group weights",
+            description: "Replace the groups array \u2014 weights must still sum to 10000.",
+            value: {
+              groups: [
+                { name: "control", weight: 2500 },
+                { name: "treatment", weight: 7500 }
+              ]
+            }
+          },
+          tighterSignificance: {
+            summary: "Tighter significance threshold",
+            description: "Drop the p-value cutoff from 0.05 \u2192 0.01. Requires Pro plan or higher.",
+            value: { significance_threshold: 0.01 }
+          },
+          updateMetadata: {
+            summary: "Update metadata",
+            description: "Change description/tag/targeting_gate freely on running experiments.",
+            value: {
+              description: "Bumped to 50% after passing canary on 25%.",
+              tag: "checkout"
+            }
+          }
+        },
+        response: { id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1" }
+      },
+      useCase: [
+        "- **Update metadata** \u2014 `description`, `tag`, `targeting_gate` editable any time.",
+        "- **Ramp before launch** \u2014 set `allocation_pct` while still in `draft`.",
+        "- **Tighten significance** \u2014 `significance_threshold` (Pro+).",
+        "- **Rewire groups** \u2014 replace `groups` wholesale while in `draft`; immutable once running."
+      ].join("\n")
+    },
+    {
+      operationId: "deleteExperiment",
+      method: "DELETE",
+      path: "/{id}",
+      summary: "Delete an experiment",
+      description: "Archives the experiment (soft-delete via status transition). Returns `409` if the experiment is still `running` \u2014 stop it first.",
+      pathParams: { id: "Stable opaque experiment id." },
+      response: experimentDeleteResponseSchema,
+      examples: { response: { ok: true } },
+      useCase: "Tear down an experiment after the analysis is signed off."
+    },
+    {
+      operationId: "setExperimentStatus",
+      method: "POST",
+      path: "/{id}/status",
+      summary: "Transition experiment status",
+      description: [
+        "Drives the experiment lifecycle. Allowed transitions:",
+        "",
+        "- `draft \u2192 running` \u2014 starts allocation. Bumps the `startedAt` timestamp.",
+        "- `running \u2192 stopped` \u2014 halts allocation. Existing exposures stay in the dataset.",
+        "- `stopped \u2192 archived` \u2014 soft-delete.",
+        "- `draft \u2192 archived` \u2014 discard an unstarted experiment.",
+        "",
+        "Restarting an `archived` experiment is not allowed; clone instead. Returns `409` on illegal transitions and `429` if the plan's `experiments_running` limit is exceeded on `\u2192 running`."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque experiment id." },
+      request: experimentStatusUpdateSchema,
+      response: experimentStatusResponseSchema,
+      examples: {
+        requestExamples: {
+          start: {
+            summary: "Start \u2014 draft \u2192 running",
+            description: "Begins allocation. The experiment counts against the plan's `experiments_running` limit.",
+            value: { status: "running" }
+          },
+          stop: {
+            summary: "Stop \u2014 running \u2192 stopped",
+            description: "Halts allocation. Existing exposures remain analysable.",
+            value: { status: "stopped" }
+          },
+          archive: {
+            summary: "Archive \u2014 stopped \u2192 archived",
+            description: "Soft-deletes the experiment. List endpoints exclude archived rows by default.",
+            value: { status: "archived" }
+          }
+        },
+        response: { id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1", status: "running" }
+      },
+      useCase: [
+        '- **Start** \u2014 `{ "status": "running" }` after wiring up the SDK and verifying targeting on staging.',
+        '- **Stop** \u2014 `{ "status": "stopped" }` once the experiment hits its `min_runtime_days` and conclusive results land.',
+        '- **Archive** \u2014 `{ "status": "archived" }` to soft-delete after sign-off.'
+      ].join("\n")
+    },
+    {
+      operationId: "setExperimentMetrics",
+      method: "POST",
+      path: "/{id}/metrics",
+      summary: "Attach metrics",
+      description: [
+        "Replaces the experiment's metric attachments wholesale. Each entry pairs an existing `metric_id` with a `role` (`goal` / `guardrail` / `secondary`).",
+        "",
+        "Returns `422` if any `metric_id` doesn't exist in the project. Pass `{ metrics: [] }` to detach everything."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque experiment id." },
+      request: experimentMetricsUpdateSchema,
+      response: experimentMetricsResponseSchema,
+      examples: {
+        requestExamples: {
+          standard: {
+            summary: "Standard \u2014 one goal + one guardrail",
+            description: "Attaches one decision metric and one safety metric.",
+            value: {
+              metrics: [
+                { metric_id: "met_checkout_completed", role: "goal" },
+                { metric_id: "met_page_errors", role: "guardrail" }
+              ]
+            }
+          },
+          detach: {
+            summary: "Detach all",
+            description: "Send an empty array to clear every metric.",
+            value: { metrics: [] }
+          }
+        },
+        response: {
+          id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1",
+          metrics: [
+            { metric_id: "met_checkout_completed", role: "goal" },
+            { metric_id: "met_page_errors", role: "guardrail" }
+          ]
+        }
+      },
+      useCase: [
+        "- **Standard setup** \u2014 one `goal`, one or two `guardrail`, optional `secondary` metrics for diagnostics.",
+        '- **Detach all** \u2014 send `{ "metrics": [] }` before archiving.'
+      ].join("\n")
+    },
+    {
+      operationId: "getExperimentResults",
+      method: "GET",
+      path: "/{id}/results",
+      summary: "Get analysis results",
+      description: "Returns the latest analysis output for the experiment \u2014 one row per metric/group/day, including sample size, mean, % delta vs. control, p-value, and a sample-ratio mismatch flag.",
+      pathParams: { id: "Stable opaque experiment id." },
+      response: experimentResultsResponseSchema,
+      examples: {
+        response: {
+          experiment: {
+            id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1",
+            name: "checkout_button_color",
+            status: "running"
+          },
+          results: [
+            {
+              metric: "checkout_completed",
+              group_name: "control",
+              ds: "2026-05-09",
+              n: 12421,
+              mean: 0.1834,
+              delta_pct: null,
+              p_value: null,
+              srm_detected: 0
+            },
+            {
+              metric: "checkout_completed",
+              group_name: "treatment",
+              ds: "2026-05-09",
+              n: 12519,
+              mean: 0.1922,
+              delta_pct: 4.8,
+              p_value: 0.018,
+              srm_detected: 0
+            }
+          ]
+        }
+      },
+      useCase: "Render the results table on the experiment detail page or drive an automated decision once a `goal` metric reaches significance."
+    },
+    {
+      operationId: "getExperimentTimeseries",
+      method: "GET",
+      path: "/{id}/timeseries",
+      summary: "Get analysis timeseries",
+      description: "Same row shape as `/results`, but returns every daily slice rather than the latest. Filter to a single metric with the `metric` query parameter.",
+      pathParams: { id: "Stable opaque experiment id." },
+      queryParams: {
+        metric: {
+          schema: z4.string().optional(),
+          description: "Optional metric name to filter the series."
+        }
+      },
+      response: experimentTimeseriesResponseSchema,
+      examples: {
+        response: {
+          experiment: {
+            id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1",
+            name: "checkout_button_color",
+            status: "running"
+          },
+          series: [
+            {
+              metric: "checkout_completed",
+              group_name: "treatment",
+              ds: "2026-05-08",
+              n: 11200,
+              mean: 0.1903,
+              delta_pct: 3.9,
+              p_value: 0.034,
+              srm_detected: 0
+            },
+            {
+              metric: "checkout_completed",
+              group_name: "treatment",
+              ds: "2026-05-09",
+              n: 12519,
+              mean: 0.1922,
+              delta_pct: 4.8,
+              p_value: 0.018,
+              srm_detected: 0
+            }
+          ]
+        }
+      },
+      useCase: "Drive a chart of metric movement over the experiment runtime, or sanity-check the lift is monotonic before deciding."
+    },
+    {
+      operationId: "reanalyzeExperiment",
+      method: "POST",
+      path: "/{id}/reanalyze",
+      summary: "Re-queue analysis",
+      description: "Requeues the daily analysis pass for this experiment outside the normal cron cadence. Useful after attaching a new metric or correcting an event taxonomy. The job runs asynchronously.",
+      pathParams: { id: "Stable opaque experiment id." },
+      response: experimentReanalyzeResponseSchema,
+      examples: { response: { id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1", queued: true } },
+      useCase: "Force-refresh results after wiring up a new metric without waiting for the next nightly cron tick."
+    }
+  ]
+};
+
+// src/resources/configs.ts
+import { z as z6 } from "zod";
+
+// ../core/src/schemas/configs.ts
+import { z as z5 } from "zod";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/entity.js
+var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(
+      `Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
+    );
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/column.js
+var Column = class {
+  constructor(table, config) {
+    this.table = table;
+    this.config = config;
+    this.name = config.name;
+    this.keyAsName = config.keyAsName;
+    this.notNull = config.notNull;
+    this.default = config.default;
+    this.defaultFn = config.defaultFn;
+    this.onUpdateFn = config.onUpdateFn;
+    this.hasDefault = config.hasDefault;
+    this.primary = config.primaryKey;
+    this.isUnique = config.isUnique;
+    this.uniqueName = config.uniqueName;
+    this.uniqueType = config.uniqueType;
+    this.dataType = config.dataType;
+    this.columnType = config.columnType;
+    this.generated = config.generated;
+    this.generatedIdentity = config.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = void 0;
+  generated = void 0;
+  generatedIdentity = void 0;
+  config;
+  mapFromDriverValue(value) {
+    return value;
+  }
+  mapToDriverValue(value) {
+    return value;
+  }
+  // ** @internal */
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+  static [entityKind] = "ColumnBuilder";
+  config;
+  constructor(name, dataType, columnType) {
+    this.config = {
+      name,
+      keyAsName: name === "",
+      notNull: false,
+      default: void 0,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: void 0,
+      uniqueType: void 0,
+      dataType,
+      columnType,
+      generated: void 0
+    };
+  }
+  /**
+   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+   *
+   * @example
+   * ```ts
+   * const users = pgTable('users', {
+   * 	id: integer('id').$type<UserId>().primaryKey(),
+   * 	details: json('details').$type<UserDetails>().notNull(),
+   * });
+   * ```
+   */
+  $type() {
+    return this;
+  }
+  /**
+   * Adds a `not null` clause to the column definition.
+   *
+   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+   */
+  notNull() {
+    this.config.notNull = true;
+    return this;
+  }
+  /**
+   * Adds a `default <value>` clause to the column definition.
+   *
+   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+   *
+   * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+   */
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Adds a dynamic default value to the column.
+   * The function will be called when the row is inserted, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Alias for {@link $defaultFn}.
+   */
+  $default = this.$defaultFn;
+  /**
+   * Adds a dynamic update value to the column.
+   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Alias for {@link $onUpdateFn}.
+   */
+  $onUpdate = this.$onUpdateFn;
+  /**
+   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+   *
+   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+   */
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
+  }
+  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+  setName(name) {
+    if (this.config.name !== "")
+      return;
+    this.config.name = name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/table.utils.js
+var TableName = /* @__PURE__ */ Symbol.for("drizzle:Name");
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/foreign-keys.js
+var ForeignKeyBuilder = class {
+  static [entityKind] = "PgForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate = "no action";
+  /** @internal */
+  _onDelete = "no action";
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action === void 0 ? "no action" : action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action === void 0 ? "no action" : action;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new ForeignKey(table, this);
+  }
+};
+var ForeignKey = class {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "PgForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var UniqueConstraintBuilder = class {
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "PgUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  nullsNotDistinctConfig = false;
+  nullsNotDistinct() {
+    this.nullsNotDistinctConfig = true;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
+  }
+};
+var UniqueOnConstraintBuilder = class {
+  static [entityKind] = "PgUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
+  }
+};
+var UniqueConstraint = class {
+  constructor(table, columns, nullsNotDistinct, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+    this.nullsNotDistinct = nullsNotDistinct;
+  }
+  static [entityKind] = "PgUniqueConstraint";
+  columns;
+  name;
+  nullsNotDistinct = false;
+  getName() {
+    return this.name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+  for (let i = startFrom; i < arrayString.length; i++) {
+    const char = arrayString[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (char === "," || char === "}") {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
+    }
+  }
+  return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
+}
+function parsePgNestedArray(arrayString, startFrom = 0) {
+  const result = [];
+  let i = startFrom;
+  let lastCharIsComma = false;
+  while (i < arrayString.length) {
+    const char = arrayString[i];
+    if (char === ",") {
+      if (lastCharIsComma || i === startFrom) {
+        result.push("");
+      }
+      lastCharIsComma = true;
+      i++;
+      continue;
+    }
+    lastCharIsComma = false;
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === '"') {
+      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    if (char === "}") {
+      return [result, i + 1];
+    }
+    if (char === "{") {
+      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+    result.push(value);
+    i = newStartFrom;
+  }
+  return [result, i];
+}
+function parsePgArray(arrayString) {
+  const [result] = parsePgNestedArray(arrayString, 1);
+  return result;
+}
+function makePgArray(array) {
+  return `{${array.map((item) => {
+    if (Array.isArray(item)) {
+      return makePgArray(item);
+    }
+    if (typeof item === "string") {
+      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return `${item}`;
+  }).join(",")}}`;
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumnBuilder = class extends ColumnBuilder {
+  foreignKeyConfigs = [];
+  static [entityKind] = "PgColumnBuilder";
+  array(size) {
+    return new PgArrayBuilder(this.config.name, this, size);
+  }
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name, config) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config?.nulls;
+    return this;
+  }
+  generatedAlwaysAs(as) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: "stored"
+    };
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return iife(
+        (ref2, actions2) => {
+          const builder = new ForeignKeyBuilder(() => {
+            const foreignColumn = ref2();
+            return { columns: [column], foreignColumns: [foreignColumn] };
+          });
+          if (actions2.onUpdate) {
+            builder.onUpdate(actions2.onUpdate);
+          }
+          if (actions2.onDelete) {
+            builder.onDelete(actions2.onDelete);
+          }
+          return builder.build(table);
+        },
+        ref,
+        actions
+      );
+    });
+  }
+  /** @internal */
+  buildExtraConfigColumn(table) {
+    return new ExtraConfigColumn(table, this.config);
+  }
+};
+var PgColumn = class extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "PgColumn";
+};
+var ExtraConfigColumn = class extends PgColumn {
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: void 0
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+  /**
+   * ### PostgreSQL documentation quote
+   *
+   * > An operator class with optional parameters can be specified for each column of an index.
+   * The operator class identifies the operators to be used by the index for that column.
+   * For example, a B-tree index on four-byte integers would use the int4_ops class;
+   * this operator class includes comparison functions for four-byte integers.
+   * In practice the default operator class for the column's data type is usually sufficient.
+   * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
+   * For example, we might want to sort a complex-number data type either by absolute value or by real part.
+   * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
+   * More information about operator classes check:
+   *
+   * ### Useful links
+   * https://www.postgresql.org/docs/current/sql-createindex.html
+   *
+   * https://www.postgresql.org/docs/current/indexes-opclass.html
+   *
+   * https://www.postgresql.org/docs/current/xindex.html
+   *
+   * ### Additional types
+   * If you have the `pg_vector` extension installed in your database, you can use the
+   * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
+   *
+   * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
+   *
+   * @param opClass
+   * @returns
+   */
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
+  }
+};
+var IndexedColumn = class {
+  static [entityKind] = "IndexedColumn";
+  constructor(name, keyAsName, type, indexConfig) {
+    this.name = name;
+    this.keyAsName = keyAsName;
+    this.type = type;
+    this.indexConfig = indexConfig;
+  }
+  name;
+  keyAsName;
+  type;
+  indexConfig;
+};
+var PgArrayBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgArrayBuilder";
+  constructor(name, baseBuilder, size) {
+    super(name, "array", "PgArray");
+    this.config.baseBuilder = baseBuilder;
+    this.config.size = size;
+  }
+  /** @internal */
+  build(table) {
+    const baseColumn = this.config.baseBuilder.build(table);
+    return new PgArray(
+      table,
+      this.config,
+      baseColumn
+    );
+  }
+};
+var PgArray = class _PgArray extends PgColumn {
+  constructor(table, config, baseColumn, range) {
+    super(table, config);
+    this.baseColumn = baseColumn;
+    this.range = range;
+    this.size = config.size;
+  }
+  size;
+  static [entityKind] = "PgArray";
+  getSQLType() {
+    return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      value = parsePgArray(value);
+    }
+    return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+  }
+  mapToDriverValue(value, isNestedArray = false) {
+    const a = value.map(
+      (v) => v === null ? null : is(this.baseColumn, _PgArray) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v)
+    );
+    if (isNestedArray)
+      return a;
+    return makePgArray(a);
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/columns/enum.js
+var isPgEnumSym = /* @__PURE__ */ Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+var PgEnumColumnBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgEnumColumnBuilder";
+  constructor(name, enumInstance) {
+    super(name, "string", "PgEnumColumn");
+    this.config.enum = enumInstance;
+  }
+  /** @internal */
+  build(table) {
+    return new PgEnumColumn(
+      table,
+      this.config
+    );
+  }
+};
+var PgEnumColumn = class extends PgColumn {
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+  static [entityKind] = "Subquery";
+  constructor(sql2, selection, alias, isWith = false) {
+    this._ = {
+      brand: "Subquery",
+      sql: sql2,
+      selectedFields: selection,
+      alias,
+      isWith
+    };
+  }
+  // getSQL(): SQL<unknown> {
+  // 	return new SQL([this]);
+  // }
+};
+var WithSubquery = class extends Subquery {
+  static [entityKind] = "WithSubquery";
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/version.js
+var version = "0.36.4";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/tracing.js
+var otel;
+var rawTracer;
+var tracer = {
+  startActiveSpan(name, fn) {
+    if (!otel) {
+      return fn();
+    }
+    if (!rawTracer) {
+      rawTracer = otel.trace.getTracer("drizzle-orm", version);
+    }
+    return iife(
+      (otel2, rawTracer2) => rawTracer2.startActiveSpan(
+        name,
+        (span) => {
+          try {
+            return fn(span);
+          } catch (e) {
+            span.setStatus({
+              code: otel2.SpanStatusCode.ERROR,
+              message: e instanceof Error ? e.message : "Unknown error"
+              // eslint-disable-line no-instanceof/no-instanceof
+            });
+            throw e;
+          } finally {
+            span.end();
+          }
+        }
+      ),
+      otel,
+      rawTracer
+    );
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = /* @__PURE__ */ Symbol.for("drizzle:ViewBaseConfig");
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/table.js
+var Schema = /* @__PURE__ */ Symbol.for("drizzle:Schema");
+var Columns = /* @__PURE__ */ Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = /* @__PURE__ */ Symbol.for("drizzle:OriginalName");
+var BaseName = /* @__PURE__ */ Symbol.for("drizzle:BaseName");
+var IsAlias = /* @__PURE__ */ Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable");
+var Table = class {
+  static [entityKind] = "Table";
+  /** @internal */
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  /**
+   * @internal
+   * Can be changed if the table is aliased.
+   */
+  [TableName];
+  /**
+   * @internal
+   * Used to store the original name of the table, before any aliasing.
+   */
+  [OriginalName];
+  /** @internal */
+  [Schema];
+  /** @internal */
+  [Columns];
+  /** @internal */
+  [ExtraConfigColumns];
+  /**
+   *  @internal
+   * Used to store the table name before the transformation via the `tableCreator` functions.
+   */
+  [BaseName];
+  /** @internal */
+  [IsAlias] = false;
+  /** @internal */
+  [IsDrizzleTable] = true;
+  /** @internal */
+  [ExtraConfigBuilder] = void 0;
+  constructor(name, schema, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema;
+    this[BaseName] = baseName;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sql/sql.js
+var FakePrimitiveParam = class {
+  static [entityKind] = "FakePrimitiveParam";
+};
+function isSQLWrapper(value) {
+  return value !== null && value !== void 0 && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+var StringChunk = class {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var SQL = class _SQL {
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+  }
+  static [entityKind] = "SQL";
+  /** @internal */
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || { value: 0 }
+    });
+    const {
+      casing,
+      escapeName,
+      escapeParam,
+      prepareTyping,
+      inlineParams,
+      paramStartIndex
+    } = config;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return { sql: chunk.value.join(""), params: [] };
+      }
+      if (is(chunk, Name)) {
+        return { sql: escapeName(chunk.value), params: [] };
+      }
+      if (chunk === void 0) {
+        return { sql: "", params: [] };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [new StringChunk("(")];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config);
+      }
+      if (is(chunk, _SQL)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === void 0 ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = casing.getColumnCasing(chunk);
+        if (_config.invokeSource === "indexes") {
+          return { sql: escapeName(columnName), params: [] };
+        }
+        const schemaName = chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === void 0 ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, _SQL)) {
+          return this.buildQueryFromSourceParams([mappedValue], config);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+        }
+        let typings = ["none"];
+        if (prepareTyping) {
+          typings = [prepareTyping(chunk.encoder)];
+        }
+        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+      }
+      if (is(chunk, Placeholder)) {
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }
+      if (is(chunk, _SQL.Aliased) && chunk.fieldAlias !== void 0) {
+        return { sql: escapeName(chunk.fieldAlias), params: [] };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return { sql: escapeName(chunk._.alias), params: [] };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+        }
+        return { sql: escapeName(chunk.enumName), params: [] };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config);
+      }
+      if (inlineParams) {
+        return { sql: this.mapInlineParam(chunk, config), params: [] };
+      }
+      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === void 0) {
+      return this;
+    }
+    return new _SQL.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  /**
+   * This method is used to conditionally include a part of the query.
+   *
+   * @param condition - Condition to check
+   * @returns itself if the condition is `true`, otherwise `undefined`
+   */
+  if(condition) {
+    return condition ? this : void 0;
+  }
+};
+var Name = class {
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var noopDecoder = {
+  mapFromDriverValue: (value) => value
+};
+var noopEncoder = {
+  mapToDriverValue: (value) => value
+};
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+var Param = class {
+  /**
+   * @param value - Parameter value
+   * @param encoder - Encoder to convert the value to a driver parameter
+   */
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  sql2.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  sql2.raw = raw;
+  function join(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== void 0) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  sql2.join = join;
+  function identifier(value) {
+    return new Name(value);
+  }
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+  class Aliased {
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    /** @internal */
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class {
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var View = class {
+  static [entityKind] = "View";
+  /** @internal */
+  [ViewBaseConfig];
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/utils.js
+function getColumnNameAndConfig(a, b) {
+  return {
+    name: typeof a === "string" && a.length > 0 ? a : "",
+    config: typeof a === "object" ? a : b
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+var ForeignKeyBuilder2 = class {
+  static [entityKind] = "SQLiteForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate;
+  /** @internal */
+  _onDelete;
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new ForeignKey2(table, this);
+  }
+};
+var ForeignKey2 = class {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "SQLiteForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+function uniqueKeyName2(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var UniqueConstraintBuilder2 = class {
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "SQLiteUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint2(table, this.columns, this.name);
+  }
+};
+var UniqueOnConstraintBuilder2 = class {
+  static [entityKind] = "SQLiteUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder2(columns, this.name);
+  }
+};
+var UniqueConstraint2 = class {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName2(this.table, this.columns.map((column) => column.name));
+  }
+  static [entityKind] = "SQLiteUniqueConstraint";
+  columns;
+  name;
+  getName() {
+    return this.name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/common.js
+var SQLiteColumnBuilder = class extends ColumnBuilder {
+  static [entityKind] = "SQLiteColumnBuilder";
+  foreignKeyConfigs = [];
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    return this;
+  }
+  generatedAlwaysAs(as, config) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: config?.mode ?? "virtual"
+    };
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return ((ref2, actions2) => {
+        const builder = new ForeignKeyBuilder2(() => {
+          const foreignColumn = ref2();
+          return { columns: [column], foreignColumns: [foreignColumn] };
+        });
+        if (actions2.onUpdate) {
+          builder.onUpdate(actions2.onUpdate);
+        }
+        if (actions2.onDelete) {
+          builder.onDelete(actions2.onDelete);
+        }
+        return builder.build(table);
+      })(ref, actions);
+    });
+  }
+};
+var SQLiteColumn = class extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName2(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "SQLiteColumn";
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+var SQLiteBigIntBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBigInt(table, this.config);
+  }
+};
+var SQLiteBigInt = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    return BigInt(Buffer.isBuffer(value) ? value.toString() : String.fromCodePoint(...value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(value.toString());
+  }
+};
+var SQLiteBlobJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteBlobJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobJson(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteBlobJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    return JSON.parse(Buffer.isBuffer(value) ? value.toString() : String.fromCodePoint(...value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(JSON.stringify(value));
+  }
+};
+var SQLiteBlobBufferBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobBufferBuilder";
+  constructor(name) {
+    super(name, "buffer", "SQLiteBlobBuffer");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobBuffer(table, this.config);
+  }
+};
+var SQLiteBlobBuffer = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobBuffer";
+  getSQLType() {
+    return "blob";
+  }
+};
+function blob(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "json") {
+    return new SQLiteBlobJsonBuilder(name);
+  }
+  if (config?.mode === "bigint") {
+    return new SQLiteBigIntBuilder(name);
+  }
+  return new SQLiteBlobBufferBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+var SQLiteCustomColumnBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteCustomColumnBuilder";
+  constructor(name, fieldConfig, customTypeParams) {
+    super(name, "custom", "SQLiteCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteCustomColumn(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteCustomColumn = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  constructor(table, config) {
+    super(table, config);
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapTo = config.customTypeParams.toDriver;
+    this.mapFrom = config.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(value) {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  }
+  mapToDriverValue(value) {
+    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+  }
+};
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name, config } = getColumnNameAndConfig(a, b);
+    return new SQLiteCustomColumnBuilder(
+      name,
+      config,
+      customTypeParams
+    );
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+var SQLiteBaseIntegerBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBaseIntegerBuilder";
+  constructor(name, dataType, columnType) {
+    super(name, dataType, columnType);
+    this.config.autoIncrement = false;
+  }
+  primaryKey(config) {
+    if (config?.autoIncrement) {
+      this.config.autoIncrement = true;
+    }
+    this.config.hasDefault = true;
+    return super.primaryKey();
+  }
+};
+var SQLiteBaseInteger = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBaseInteger";
+  autoIncrement = this.config.autoIncrement;
+  getSQLType() {
+    return "integer";
+  }
+};
+var SQLiteIntegerBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteIntegerBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteInteger");
+  }
+  build(table) {
+    return new SQLiteInteger(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteInteger = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteInteger";
+};
+var SQLiteTimestampBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteTimestampBuilder";
+  constructor(name, mode) {
+    super(name, "date", "SQLiteTimestamp");
+    this.config.mode = mode;
+  }
+  /**
+   * @deprecated Use `default()` with your own expression instead.
+   *
+   * Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.
+   */
+  defaultNow() {
+    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
+  }
+  build(table) {
+    return new SQLiteTimestamp(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteTimestamp = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteTimestamp";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    if (this.config.mode === "timestamp") {
+      return new Date(value * 1e3);
+    }
+    return new Date(value);
+  }
+  mapToDriverValue(value) {
+    const unix = value.getTime();
+    if (this.config.mode === "timestamp") {
+      return Math.floor(unix / 1e3);
+    }
+    return unix;
+  }
+};
+var SQLiteBooleanBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteBooleanBuilder";
+  constructor(name, mode) {
+    super(name, "boolean", "SQLiteBoolean");
+    this.config.mode = mode;
+  }
+  build(table) {
+    return new SQLiteBoolean(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteBoolean = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteBoolean";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    return Number(value) === 1;
+  }
+  mapToDriverValue(value) {
+    return value ? 1 : 0;
+  }
+};
+function integer(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") {
+    return new SQLiteTimestampBuilder(name, config.mode);
+  }
+  if (config?.mode === "boolean") {
+    return new SQLiteBooleanBuilder(name, config.mode);
+  }
+  return new SQLiteIntegerBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+var SQLiteNumericBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBuilder";
+  constructor(name) {
+    super(name, "string", "SQLiteNumeric");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumeric(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteNumeric = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumeric";
+  getSQLType() {
+    return "numeric";
+  }
+};
+function numeric(name) {
+  return new SQLiteNumericBuilder(name ?? "");
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/real.js
+var SQLiteRealBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteRealBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteReal");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteReal(table, this.config);
+  }
+};
+var SQLiteReal = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteReal";
+  getSQLType() {
+    return "real";
+  }
+};
+function real(name) {
+  return new SQLiteRealBuilder(name ?? "");
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/text.js
+var SQLiteTextBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextBuilder";
+  constructor(name, config) {
+    super(name, "string", "SQLiteText");
+    this.config.enumValues = config.enum;
+    this.config.length = config.length;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteText(table, this.config);
+  }
+};
+var SQLiteText = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteText";
+  enumValues = this.config.enumValues;
+  length = this.config.length;
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return `text${this.config.length ? `(${this.config.length})` : ""}`;
+  }
+};
+var SQLiteTextJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteTextJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteTextJson(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteTextJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteTextJson";
+  getSQLType() {
+    return "text";
+  }
+  mapFromDriverValue(value) {
+    return JSON.parse(value);
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+};
+function text(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config.mode === "json") {
+    return new SQLiteTextJsonBuilder(name);
+  }
+  return new SQLiteTextBuilder(name, config);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/all.js
+function getSQLiteColumnBuilders() {
+  return {
+    blob,
+    customType,
+    integer,
+    numeric,
+    real,
+    text
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/table.js
+var InlineForeignKeys = /* @__PURE__ */ Symbol.for("drizzle:SQLiteInlineForeignKeys");
+var SQLiteTable = class extends Table {
+  static [entityKind] = "SQLiteTable";
+  /** @internal */
+  static Symbol = Object.assign({}, Table.Symbol, {
+    InlineForeignKeys
+  });
+  /** @internal */
+  [Table.Symbol.Columns];
+  /** @internal */
+  [InlineForeignKeys] = [];
+  /** @internal */
+  [Table.Symbol.ExtraConfigBuilder] = void 0;
+};
+function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
+  const rawTable = new SQLiteTable(name, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(
+    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+      const colBuilder = colBuilderBase;
+      colBuilder.setName(name2);
+      const column = colBuilder.build(rawTable);
+      rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+      return [name2, column];
+    })
+  );
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+  if (extraConfig) {
+    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  }
+  return table;
+}
+var sqliteTable = (name, columns, extraConfig) => {
+  return sqliteTableBase(name, columns, extraConfig);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+  constructor(name, unique) {
+    this.name = name;
+    this.unique = unique;
+  }
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+};
+var IndexBuilder = class {
+  static [entityKind] = "SQLiteIndexBuilder";
+  /** @internal */
+  config;
+  constructor(name, columns, unique) {
+    this.config = {
+      name,
+      columns,
+      unique,
+      where: void 0
+    };
+  }
+  /**
+   * Condition for partial index.
+   */
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
+  }
+};
+var Index = class {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  constructor(config, table) {
+    this.config = { ...config, table };
+  }
+};
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
+function uniqueIndex(name) {
+  return new IndexBuilderOn(name, true);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+function primaryKey(...config) {
+  if (config[0].columns) {
+    return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+  }
+  return new PrimaryKeyBuilder(config);
+}
+var PrimaryKeyBuilder = class {
+  static [entityKind] = "SQLitePrimaryKeyBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  name;
+  constructor(columns, name) {
+    this.columns = columns;
+    this.name = name;
+  }
+  /** @internal */
+  build(table) {
+    return new PrimaryKey(table, this.columns, this.name);
+  }
+};
+var PrimaryKey = class {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name;
+  }
+  static [entityKind] = "SQLitePrimaryKey";
+  columns;
+  name;
+  getName() {
+    return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+  }
+};
+
+// ../core/src/db/schema.ts
+var projects = sqliteTable(
+  "projects",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    domain: text("domain"),
+    ownerEmail: text("owner_email").notNull(),
+    plan: text("plan", { enum: ["free", "paid"] }).notNull().default("free"),
+    status: text("status", { enum: ["active", "inactive"] }).notNull().default("active"),
+    // Stripe billing
+    stripeCustomerId: text("stripe_customer_id").unique(),
+    stripeSubscriptionId: text("stripe_subscription_id").unique(),
+    stripeItemIdBase: text("stripe_item_id_base"),
+    stripeItemIdExperiments: text("stripe_item_id_experiments"),
+    stripeItemIdGates: text("stripe_item_id_gates"),
+    stripeItemIdConfigs: text("stripe_item_id_configs"),
+    subscriptionStatus: text("subscription_status", {
+      enum: ["none", "trialing", "active", "past_due", "canceled", "incomplete"]
+    }).notNull().default("none"),
+    currentPeriodEnd: text("current_period_end"),
+    trialEndsAt: text("trial_ends_at"),
+    cancelAtPeriodEnd: integer("cancel_at_period_end").notNull().default(0),
+    billingInterval: text("billing_interval", { enum: ["monthly", "annual"] }).notNull().default("monthly"),
+    // Per-project module toggles. Control which surfaces (admin tabs, devtools
+    // panels) are exposed for this project. All default to enabled so existing
+    // projects keep their full feature set after the migration.
+    moduleTranslations: integer("module_translations", { mode: "boolean" }).notNull().default(true),
+    moduleConfigs: integer("module_configs", { mode: "boolean" }).notNull().default(true),
+    moduleGates: integer("module_gates", { mode: "boolean" }).notNull().default(true),
+    moduleExperiments: integer("module_experiments", { mode: "boolean" }).notNull().default(true),
+    moduleFeedback: integer("module_feedback", { mode: "boolean" }).notNull().default(true),
+    moduleUser: integer("module_user", { mode: "boolean" }).notNull().default(true),
+    moduleEvents: integer("module_events", { mode: "boolean" }).notNull().default(true),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    // One project per (owner, domain): a single account can't accidentally
+    // create two projects pointing at the same site. Multiple projects per
+    // owner are still allowed across different domains, and `domain` may be
+    // NULL for projects without a configured site (SQLite treats each NULL
+    // as distinct under UNIQUE, so multiple no-domain projects per owner are
+    // permitted).
+    ownerDomainUniq: uniqueIndex("projects_owner_domain_uniq").on(t.ownerEmail, t.domain)
+  })
+);
+var users = sqliteTable("users", {
+  email: text("email").primaryKey(),
+  termsAcceptedAt: text("terms_accepted_at"),
+  termsVersion: text("terms_version"),
+  onboardingCompletedAt: text("onboarding_completed_at"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var projectMembers = sqliteTable(
+  "project_members",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    email: text("email").notNull(),
+    role: text("role", { enum: ["admin", "editor", "viewer"] }).notNull().default("editor"),
+    status: text("status", { enum: ["active", "pending", "removed"] }).notNull().default("pending"),
+    invitedByEmail: text("invited_by_email").notNull(),
+    invitedAt: text("invited_at").notNull(),
+    acceptedAt: text("accepted_at"),
+    removedAt: text("removed_at")
+  },
+  (t) => ({
+    projectIdx: index("project_members_project").on(t.projectId, t.status),
+    projectEmailUniq: uniqueIndex("project_members_project_email").on(t.projectId, t.email)
+  })
+);
+var sdkKeys = sqliteTable(
+  "sdk_keys",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    keyHash: text("key_hash").unique().notNull(),
+    type: text("type", { enum: ["server", "client", "admin"] }).notNull(),
+    scope: text("scope", { enum: ["experiments", "i18n"] }).notNull().default("experiments"),
+    createdAt: text("created_at").notNull(),
+    revokedAt: text("revoked_at"),
+    expiresAt: text("expires_at"),
+    // Email of the human who minted this key (admin keys via dashboard or
+    // CLI device-flow). Used to authorize cross-project --project overrides
+    // by joining against project_members. Null for older keys + for
+    // service-to-service keys without a human owner.
+    createdByEmail: text("created_by_email")
+  },
+  (t) => ({ hashIdx: index("sdk_keys_hash").on(t.keyHash) })
+);
+var cliAuthSessions = sqliteTable(
+  "cli_auth_sessions",
+  {
+    state: text("state").primaryKey(),
+    codeChallenge: text("code_challenge").notNull(),
+    projectId: text("project_id").references(() => projects.id),
+    tokenHash: text("token_hash"),
+    status: text("status", { enum: ["pending", "complete", "expired"] }).notNull().default("pending"),
+    createdAt: text("created_at").notNull(),
+    expiresAt: text("expires_at").notNull(),
+    completedAt: text("completed_at")
+  },
+  (t) => ({ expiresIdx: index("cli_auth_sessions_expires").on(t.expiresAt) })
+);
+var cliTokens = sqliteTable(
+  "cli_tokens",
+  {
+    tokenId: text("token_id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    userEmail: text("user_email").notNull(),
+    issuedAt: text("issued_at").notNull(),
+    expiresAt: text("expires_at").notNull(),
+    revokedAt: text("revoked_at"),
+    lastUsedAt: text("last_used_at")
+  },
+  (t) => ({
+    projectIdx: index("cli_tokens_project").on(t.projectId),
+    expiresIdx: index("cli_tokens_expires").on(t.expiresAt)
+  })
+);
+var analysisFailures = sqliteTable("analysis_failures", {
+  projectId: text("project_id").primaryKey().references(() => projects.id),
+  failedAt: text("failed_at").notNull(),
+  retryCount: integer("retry_count").notNull().default(3),
+  messageBody: text("message_body"),
+  resolvedAt: text("resolved_at")
+});
+var systemHealth = sqliteTable("system_health", {
+  key: text("key").primaryKey(),
+  lastFiredAt: text("last_fired_at").notNull(),
+  projectsEnqueued: integer("projects_enqueued")
+});
+var auditLog = sqliteTable(
+  "audit_log",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id),
+    actorEmail: text("actor_email").notNull(),
+    actorType: text("actor_type", { enum: ["user", "cli", "system"] }).notNull(),
+    action: text("action").notNull(),
+    resourceType: text("resource_type").notNull(),
+    resourceId: text("resource_id"),
+    payload: text("payload"),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("audit_log_project").on(t.projectId, t.createdAt),
+    actorIdx: index("audit_log_actor").on(t.actorEmail),
+    resourceIdx: index("audit_log_resource").on(t.resourceType, t.resourceId)
+  })
+);
+var gates = sqliteTable(
+  "gates",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    rules: text("rules", { mode: "json" }).$type().notNull(),
+    rolloutPct: integer("rollout_pct").notNull().default(0),
+    salt: text("salt").notNull(),
+    enabled: integer("enabled").notNull().default(1),
+    // Gatekeeper metadata + ordered sub-gate stack. Stack is null on rows that
+    // predate the gatekeeper migration; eval falls back to rules+rolloutPct.
+    title: text("title"),
+    description: text("description"),
+    folder: text("folder"),
+    groupName: text("group_name"),
+    ownerEmail: text("owner_email"),
+    stack: text("stack", { mode: "json" }).$type(),
+    updatedAt: text("updated_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("gates_project").on(t.projectId),
+    projectNameUniq: uniqueIndex("gates_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var CONFIG_ENVS = ["dev", "staging", "prod"];
+var CONFIG_KINDS = ["config", "killswitch"];
+var DEFAULT_CONFIG_SCHEMA = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
+var configs = sqliteTable(
+  "configs",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    description: text("description"),
+    kind: text("kind", { enum: CONFIG_KINDS }).notNull().default("config"),
+    schemaJson: text("schema_json", { mode: "json" }).$type().notNull().default(DEFAULT_CONFIG_SCHEMA),
+    updatedAt: text("updated_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    uniq: uniqueIndex("configs_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var configValues = sqliteTable(
+  "config_values",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    configId: text("config_id").notNull().references(() => configs.id, { onDelete: "cascade" }),
+    env: text("env", { enum: CONFIG_ENVS }).notNull(),
+    valueJson: text("value_json", { mode: "json" }).$type().notNull(),
+    version: integer("version").notNull(),
+    publishedAt: text("published_at").notNull(),
+    publishedBy: text("published_by").notNull()
+  },
+  (t) => ({
+    projectIdx: index("config_values_project").on(t.projectId),
+    configEnvIdx: index("config_values_config_env").on(t.configId, t.env, t.version),
+    uniq: uniqueIndex("config_values_config_env_version").on(t.configId, t.env, t.version)
+  })
+);
+var configDrafts = sqliteTable(
+  "config_drafts",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    configId: text("config_id").notNull().references(() => configs.id, { onDelete: "cascade" }),
+    env: text("env", { enum: CONFIG_ENVS }).notNull(),
+    valueJson: text("value_json", { mode: "json" }).$type().notNull(),
+    baseVersion: integer("base_version").notNull(),
+    authorEmail: text("author_email").notNull(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("config_drafts_project").on(t.projectId),
+    uniq: uniqueIndex("config_drafts_config_env").on(t.configId, t.env)
+  })
+);
+var universes = sqliteTable(
+  "universes",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    unitType: text("unit_type").notNull().default("user_id"),
+    holdoutRange: text("holdout_range", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("universes_project").on(t.projectId),
+    projectUniq: uniqueIndex("universes_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var experiments = sqliteTable(
+  "experiments",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    description: text("description"),
+    tag: text("tag"),
+    universe: text("universe").notNull(),
+    targetingGate: text("targeting_gate"),
+    allocationPct: integer("allocation_pct").notNull().default(0),
+    salt: text("salt").notNull(),
+    params: text("params", { mode: "json" }).$type().notNull(),
+    groups: text("groups", { mode: "json" }).$type().notNull(),
+    status: text("status", { enum: ["draft", "running", "stopped", "archived"] }).notNull().default("draft"),
+    startedAt: text("started_at"),
+    stoppedAt: text("stopped_at"),
+    significanceThreshold: real("significance_threshold").notNull().default(0.05),
+    minRuntimeDays: integer("min_runtime_days").notNull().default(0),
+    minSampleSize: integer("min_sample_size").notNull().default(100),
+    cupedFrozenAt: text("cuped_frozen_at"),
+    sequentialTesting: integer("sequential_testing", { mode: "boolean" }).notNull().default(false),
+    hashVersion: integer("hash_version").notNull().default(1),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("experiments_project").on(t.projectId),
+    projectUniq: uniqueIndex("experiments_project_name").on(t.projectId, t.name)
+  })
+);
+var events = sqliteTable(
+  "events",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    description: text("description"),
+    properties: text("properties", { mode: "json" }).$type().notNull().default([]),
+    pending: integer("pending").notNull().default(0),
+    createdAt: text("created_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("events_project").on(t.projectId),
+    projectUniq: uniqueIndex("events_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var metrics = sqliteTable(
+  "metrics",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    eventName: text("event_name").notNull(),
+    valuePath: text("value_path"),
+    aggregation: text("aggregation", {
+      enum: ["count_users", "count_events", "sum", "avg", "retention_Nd"]
+    }).notNull().default("count_users"),
+    winsorizePct: integer("winsorize_pct").notNull().default(99),
+    minDetectableEffect: real("min_detectable_effect"),
+    updatedAt: text("updated_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    uniq: uniqueIndex("metrics_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var experimentMetrics = sqliteTable(
+  "experiment_metrics",
+  {
+    id: text("id").primaryKey(),
+    experimentId: text("experiment_id").notNull().references(() => experiments.id, { onDelete: "cascade" }),
+    metricId: text("metric_id").notNull().references(() => metrics.id, { onDelete: "cascade" }),
+    role: text("role", { enum: ["goal", "guardrail", "secondary"] }).notNull(),
+    createdAt: integer("created_at").notNull()
+  },
+  (t) => ({ uniq: uniqueIndex("exp_metrics_uniq").on(t.experimentId, t.metricId) })
+);
+var experimentResults = sqliteTable(
+  "experiment_results",
+  {
+    projectId: text("project_id").notNull(),
+    experiment: text("experiment").notNull(),
+    metric: text("metric").notNull(),
+    groupName: text("group_name").notNull(),
+    ds: text("ds").notNull(),
+    n: integer("n"),
+    mean: real("mean"),
+    variance: real("variance"),
+    delta: real("delta"),
+    deltaPct: real("delta_pct"),
+    ci95Low: real("ci_95_low"),
+    ci95High: real("ci_95_high"),
+    ci99Low: real("ci_99_low"),
+    ci99High: real("ci_99_high"),
+    pValue: real("p_value"),
+    expectedN: integer("expected_n"),
+    srmPValue: real("srm_p_value"),
+    srmDetected: integer("srm_detected").notNull().default(0),
+    msprtLambda: real("msprt_lambda"),
+    msprtSignificant: integer("msprt_significant"),
+    isFinal: integer("is_final").notNull().default(0),
+    peekWarning: integer("peek_warning").notNull().default(0)
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.experiment, t.metric, t.groupName, t.ds] }),
+    dsIdx: index("experiment_results_ds").on(t.projectId, t.ds)
+  })
+);
+var userMetricBaseline = sqliteTable(
+  "user_metric_baseline",
+  {
+    projectId: text("project_id").notNull(),
+    userId: text("user_id").notNull(),
+    metricName: text("metric_name").notNull(),
+    avgValue: real("avg_value").notNull(),
+    updatedDs: text("updated_ds").notNull()
+  },
+  (t) => ({ pk: primaryKey({ columns: [t.projectId, t.userId, t.metricName] }) })
+);
+var userAliases = sqliteTable(
+  "user_aliases",
+  {
+    projectId: text("project_id").notNull(),
+    anonymousId: text("anonymous_id").notNull(),
+    userId: text("user_id").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.anonymousId] }),
+    userIdx: index("user_aliases_user").on(t.projectId, t.userId)
+  })
+);
+var userAttributes = sqliteTable(
+  "user_attributes",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    type: text("type", { enum: ["string", "number", "boolean", "enum", "date"] }).notNull(),
+    enumValues: text("enum_values", { mode: "json" }).$type(),
+    required: integer("required").notNull().default(0),
+    description: text("description"),
+    sdkPath: text("sdk_path"),
+    createdAt: text("created_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("user_attributes_project").on(t.projectId),
+    projectUniq: uniqueIndex("user_attributes_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var labelProfiles = sqliteTable(
+  "label_profiles",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    defaultChunkId: text("default_chunk_id"),
+    createdAt: text("created_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("label_profiles_project").on(t.projectId),
+    projectNameUniq: uniqueIndex("label_profiles_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var labelChunks = sqliteTable(
+  "label_chunks",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    profileId: text("profile_id").notNull().references(() => labelProfiles.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    isIndex: integer("is_index").notNull().default(0),
+    publishedUrl: text("published_url"),
+    publishedHash: text("published_hash"),
+    publishedAt: text("published_at"),
+    etag: text("etag")
+  },
+  (t) => ({
+    projectIdx: index("label_chunks_project").on(t.projectId),
+    profileNameUniq: uniqueIndex("label_chunks_profile_name").on(t.profileId, t.name)
+  })
+);
+var labelKeys = sqliteTable(
+  "label_keys",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    profileId: text("profile_id").notNull().references(() => labelProfiles.id, { onDelete: "cascade" }),
+    chunkId: text("chunk_id").notNull().references(() => labelChunks.id, { onDelete: "cascade" }),
+    key: text("key").notNull(),
+    value: text("value").notNull(),
+    description: text("description"),
+    // JSON array of variable names extracted from the value's {{var}} placeholders.
+    // `null` = no variables detected; `[]` = explicitly none (normalized).
+    variables: text("variables", { mode: "json" }).$type(),
+    updatedAt: text("updated_at").notNull(),
+    updatedBy: text("updated_by").notNull()
+  },
+  (t) => ({
+    projectIdx: index("label_keys_project").on(t.projectId),
+    chunkIdx: index("label_keys_chunk").on(t.chunkId),
+    profileKeyUniq: uniqueIndex("label_keys_profile_key").on(t.profileId, t.key)
+  })
+);
+var labelDrafts = sqliteTable(
+  "label_drafts",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    profileId: text("profile_id").notNull().references(() => labelProfiles.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    sourceProfileId: text("source_profile_id").references(() => labelProfiles.id, {
+      onDelete: "set null"
+    }),
+    createdBy: text("created_by").notNull(),
+    status: text("status", { enum: ["open", "merged", "abandoned"] }).notNull().default("open"),
+    createdAt: text("created_at").notNull(),
+    publishedAt: text("published_at")
+  },
+  (t) => ({
+    projectIdx: index("label_drafts_project").on(t.projectId),
+    projectNameUniq: uniqueIndex("label_drafts_project_name").on(t.projectId, t.name)
+  })
+);
+var labelDraftKeys = sqliteTable(
+  "label_draft_keys",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    draftId: text("draft_id").notNull().references(() => labelDrafts.id, { onDelete: "cascade" }),
+    key: text("key").notNull(),
+    value: text("value").notNull(),
+    description: text("description"),
+    variables: text("variables", { mode: "json" }).$type(),
+    updatedBy: text("updated_by").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    draftKeyUniq: uniqueIndex("label_draft_keys_draft_key").on(t.draftId, t.key),
+    projectIdx: index("label_draft_keys_project").on(t.projectId)
+  })
+);
+var BUG_STATUSES = ["open", "triaged", "in_progress", "resolved", "wont_fix"];
+var BUG_PRIORITIES = ["low", "medium", "high", "critical"];
+var bugReports = sqliteTable(
+  "bug_reports",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    stepsToReproduce: text("steps_to_reproduce").notNull().default(""),
+    actualResult: text("actual_result").notNull().default(""),
+    expectedResult: text("expected_result").notNull().default(""),
+    status: text("status", { enum: BUG_STATUSES }).notNull().default("open"),
+    priority: text("priority", { enum: BUG_PRIORITIES }),
+    reporterEmail: text("reporter_email"),
+    pageUrl: text("page_url"),
+    userAgent: text("user_agent"),
+    viewport: text("viewport"),
+    context: text("context", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("bug_reports_project").on(t.projectId, t.status),
+    createdIdx: index("bug_reports_created").on(t.projectId, t.createdAt)
+  })
+);
+var FEATURE_REQUEST_STATUSES = [
+  "open",
+  "considering",
+  "planned",
+  "shipped",
+  "declined"
+];
+var FEATURE_REQUEST_IMPORTANCES = ["nice_to_have", "important", "critical"];
+var featureRequests = sqliteTable(
+  "feature_requests",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    description: text("description").notNull().default(""),
+    useCase: text("use_case").notNull().default(""),
+    importance: text("importance", { enum: FEATURE_REQUEST_IMPORTANCES }).notNull().default("nice_to_have"),
+    status: text("status", { enum: FEATURE_REQUEST_STATUSES }).notNull().default("open"),
+    reporterEmail: text("reporter_email"),
+    pageUrl: text("page_url"),
+    userAgent: text("user_agent"),
+    context: text("context", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("feature_requests_project").on(t.projectId, t.status),
+    createdIdx: index("feature_requests_created").on(t.projectId, t.createdAt)
+  })
+);
+var REPORT_KINDS = ["bug", "feature_request"];
+var ATTACHMENT_KINDS = ["screenshot", "recording", "file"];
+var reportAttachments = sqliteTable(
+  "report_attachments",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    reportKind: text("report_kind", { enum: REPORT_KINDS }).notNull(),
+    reportId: text("report_id").notNull(),
+    kind: text("kind", { enum: ATTACHMENT_KINDS }).notNull(),
+    filename: text("filename").notNull(),
+    mimeType: text("mime_type").notNull(),
+    sizeBytes: integer("size_bytes").notNull(),
+    r2Key: text("r2_key").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    reportIdx: index("report_attachments_report").on(t.projectId, t.reportKind, t.reportId)
+  })
+);
+var CONNECTOR_PROVIDERS = ["google_sheets"];
+var connectors = sqliteTable(
+  "connectors",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    provider: text("provider", { enum: CONNECTOR_PROVIDERS }).notNull(),
+    name: text("name").notNull(),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+    events: text("events", { mode: "json" }).$type().notNull(),
+    config: text("config", { mode: "json" }).$type().notNull(),
+    // AES-GCM encrypted JSON: { refresh_token, access_token, expires_at, scope }
+    credentialsCipher: text("credentials_cipher"),
+    // Display label (e.g., the OAuth account email)
+    accountLabel: text("account_label"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("connectors_project").on(t.projectId, t.provider)
+  })
+);
+var i18nUsageDaily = sqliteTable(
+  "i18n_usage_daily",
+  {
+    projectId: text("project_id").notNull(),
+    sdkKeyId: text("sdk_key_id").notNull(),
+    date: text("date").notNull(),
+    requestCount: integer("request_count").notNull().default(0)
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.sdkKeyId, t.date] }),
+    projectDateIdx: index("i18n_usage_daily_project_date").on(t.projectId, t.date)
+  })
+);
+var billingEvents = sqliteTable(
+  "billing_events",
+  {
+    // Stripe event ID — INSERT OR IGNORE makes webhook handling idempotent
+    id: text("id").primaryKey(),
+    projectId: text("project_id").references(() => projects.id, { onDelete: "set null" }),
+    type: text("type").notNull(),
+    payload: text("payload", { mode: "json" }).$type().notNull(),
+    receivedAt: text("received_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("billing_events_project").on(t.projectId)
+  })
+);
+
+// ../core/src/schemas/configs.ts
+var SEGMENT = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/;
+var RESERVED_FOLDER = "_default";
+var configNameSchema = z5.string().max(128).refine(
+  (s) => {
+    const parts = s.split(".");
+    if (parts.length !== 2) return false;
+    return parts.every((p, i) => p === RESERVED_FOLDER && i === 0 ? true : SEGMENT.test(p));
+  },
+  {
+    message: "Must be `folder.name` \u2014 exactly two lowercase segments separated by a dot (e.g. `pricing.tiers`)."
+  }
+).describe(
+  "Stable config key in `folder.name` form (two lowercase segments separated by a dot, e.g. `pricing.tiers`). Used by SDKs as `Shipeasy.getConfig('<name>')`. Immutable after create."
+);
+var configKindSchema = z5.enum(CONFIG_KINDS);
+var configEnvSchema = z5.enum(CONFIG_ENVS).describe("Target environment. One of the project's configured envs (`dev`, `stage`, `prod`).");
+var jsonSchemaSchema = z5.record(z5.string(), z5.unknown()).refine((s) => s.type === "object", { message: "Top-level schema type must be 'object'" }).describe(
+  "JSON Schema (draft 2020-12) describing the shape of the config value. Top-level `type` must be `'object'`; every published value is validated against this schema."
+);
+var initialValuesSchema = z5.union([z5.unknown(), z5.record(configEnvSchema, z5.unknown())]).describe(
+  "Initial config value. Either a single JSON object applied to every env, or a `{ env: value }` map seeding per-env values. Must match `schema`. Defaults to `{}` on every env when omitted."
+);
+var configCreateSchema = z5.object({
+  name: configNameSchema,
+  description: z5.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  schema: jsonSchemaSchema,
+  value: initialValuesSchema.optional()
+}).describe("Body for `POST /api/admin/configs`. `name` + `schema` required.");
+var configUpdateSchema = z5.object({
+  schema: jsonSchemaSchema.optional().describe(
+    "Replacement schema. When supplied, the new schema is validated against every published value before it lands."
+  ),
+  value: z5.unknown().optional().describe(
+    "Flat value applied to **every** env. Publishes a new version per env. To target one env, use `PUT /{id}/drafts` then `POST /{id}/publish`."
+  )
+}).describe(
+  "Body for `PATCH /api/admin/configs/{id}`. Partial \u2014 only supplied fields change. `value` republishes on every env."
+);
+var configSchemaUpdateSchema = z5.object({ schema: jsonSchemaSchema }).describe("Schema-only update. Does not bump value versions or rebuild KV.");
+var configDraftUpsertSchema = z5.object({
+  env: configEnvSchema,
+  value: z5.unknown().describe("Draft value to stage on `env`. Validated against the config's current schema.")
+}).describe(
+  "Body for `PUT /api/admin/configs/{id}/drafts`. Stages a value for a single env without publishing."
+);
+var configPublishSchema = z5.object({ env: configEnvSchema }).describe(
+  "Body for `POST /api/admin/configs/{id}/publish` and `DELETE /api/admin/configs/{id}/drafts`. Names the target env."
+);
+var configEnvPublishedSchema = z5.object({
+  version: z5.number().int().describe("Monotonically increasing version per env."),
+  publishedAt: z5.string().describe("ISO-8601 publish timestamp."),
+  publishedBy: z5.string().describe("Email/id of the actor who published this version.")
+});
+var configDraftSummarySchema = z5.object({
+  updatedAt: z5.string().describe("ISO-8601 last-edit timestamp on the draft."),
+  authorEmail: z5.string().describe("Email/id of the actor who last edited the draft."),
+  baseVersion: z5.number().int().describe("Published version the draft was forked from.")
+});
+var configResponseSchema = z5.object({
+  id: z5.string().describe("Stable opaque config id (`cfg_\u2026`)."),
+  name: configNameSchema,
+  description: z5.string().nullable(),
+  schema: jsonSchemaSchema,
+  updatedAt: z5.string().describe("ISO-8601 timestamp of last mutation."),
+  envs: z5.record(configEnvSchema, configEnvPublishedSchema).describe("Per-env latest published version metadata."),
+  drafts: z5.record(configEnvSchema, configDraftSummarySchema).describe("Per-env active drafts (if any)."),
+  values: z5.record(configEnvSchema, z5.unknown()).optional().describe("Per-env latest published values (only returned by `GET /{id}`, not list)."),
+  draftValues: z5.record(configEnvSchema, z5.unknown()).optional().describe("Per-env draft values (only returned by `GET /{id}`).")
+});
+var configCreateResponseSchema = z5.object({
+  id: z5.string().describe("Newly assigned config id."),
+  name: configNameSchema
+});
+var configUpdateResponseSchema = z5.object({
+  id: z5.string().describe("Config id that was updated.")
+});
+var configDeleteResponseSchema = z5.object({ ok: z5.literal(true) });
+var configDraftSaveResponseSchema = z5.object({
+  id: z5.string(),
+  env: configEnvSchema,
+  baseVersion: z5.number().int().describe("Published version the draft is based on."),
+  updatedAt: z5.string()
+});
+var configDraftDiscardResponseSchema = z5.object({ ok: z5.literal(true) });
+var configPublishResponseSchema = z5.object({
+  id: z5.string(),
+  env: configEnvSchema,
+  version: z5.number().int().describe("Newly published version on `env`.")
+});
+var configActivityEntrySchema = z5.object({
+  id: z5.string(),
+  action: z5.string().describe("Audit action (e.g. `config.create`, `config.publish`)."),
+  actorEmail: z5.string(),
+  actorType: z5.enum(["user", "cli", "system"]),
+  payload: z5.unknown().nullable(),
+  createdAt: z5.string().describe("ISO-8601 timestamp.")
+});
+var configActivityResponseSchema = z5.array(configActivityEntrySchema).describe("Recent audit rows for one config, newest first.");
+
+// src/resources/configs.ts
+var configListResponseSchema = z6.object({
+  data: z6.array(configResponseSchema),
+  next_cursor: z6.string().nullable()
+});
+var BASE3 = "/api/admin/configs";
+function configsClient(t) {
+  async function list(opts = {}) {
+    const query = {};
+    if (opts.limit !== void 0) query.limit = String(opts.limit);
+    if (opts.cursor) query.cursor = opts.cursor;
+    return t.request("GET", BASE3, void 0, query);
+  }
+  async function listAll() {
+    const out = [];
+    let cursor;
+    do {
+      const page = await list({ limit: 500, cursor });
+      out.push(...page.data);
+      cursor = page.next_cursor ?? void 0;
+    } while (cursor);
+    return out;
+  }
+  async function resolve(idOrName) {
+    try {
+      return await t.request("GET", `${BASE3}/${idOrName}`);
+    } catch (err) {
+      if (!(err instanceof ApiError) || err.status !== 404) throw err;
+    }
+    const all = await listAll();
+    const found = all.find((c) => c.name === idOrName);
+    if (!found) throw new ApiError(`Config '${idOrName}' not found`, 404);
+    return found;
+  }
+  return {
+    list,
+    listAll,
+    resolve,
+    get: (id) => t.request("GET", `${BASE3}/${id}`),
+    create: (input) => t.request("POST", BASE3, configCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE3}/${id}`, configUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE3}/${id}`),
+    saveDraft: (id, input) => t.request("PUT", `${BASE3}/${id}/drafts`, configDraftUpsertSchema.parse(input)),
+    discardDraft: (id, input) => t.request("DELETE", `${BASE3}/${id}/drafts`, configPublishSchema.parse(input)),
+    publish: (id, input) => t.request("POST", `${BASE3}/${id}/publish`, configPublishSchema.parse(input)),
+    activity: (id, limit) => t.request(
+      "GET",
+      `${BASE3}/${id}/activity`,
+      void 0,
+      limit ? { limit: String(limit) } : void 0
+    )
+  };
+}
+var SAMPLE_CFG = {
+  id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4",
+  name: "pricing.tiers",
+  description: "Pricing tier definitions consumed by the checkout flow.",
+  schema: {
+    type: "object",
+    properties: {
+      tiers: { type: "array", items: { type: "object" } }
+    },
+    required: ["tiers"]
+  },
+  updatedAt: "2026-05-09T18:22:11.000Z",
+  envs: {
+    dev: { version: 5, publishedAt: "2026-05-09T18:22:11.000Z", publishedBy: "ana@example.com" },
+    stage: { version: 4, publishedAt: "2026-05-08T11:05:22.000Z", publishedBy: "ana@example.com" },
+    prod: { version: 4, publishedAt: "2026-05-08T11:05:22.000Z", publishedBy: "ana@example.com" }
+  },
+  drafts: {
+    dev: {
+      updatedAt: "2026-05-10T09:31:00.000Z",
+      authorEmail: "bo@example.com",
+      baseVersion: 5
+    }
+  }
+};
+var configsResource = {
+  name: "configs",
+  basePath: BASE3,
+  describeOne: "config",
+  describeMany: "configs",
+  tag: {
+    name: "Configs",
+    description: [
+      "Dynamic configs: JSON-Schema-validated structured values delivered to SDKs and editable per environment with a draft/publish workflow.",
+      "",
+      "**Identity.** Each config is keyed by `name` in `folder.name` form (e.g. `pricing.tiers`). Immutable after create.",
+      "",
+      "**Schema-first.** Every config carries a JSON Schema (draft 2020-12, top-level `type: 'object'`). Every published value is validated against it.",
+      "",
+      "**Drafts \u2192 publish.** Per-env edits go through `PUT /{id}/drafts` (stages a value) then `POST /{id}/publish` (promotes to a new version). The flat `PATCH /{id}` republishes on **every** env in one shot \u2014 bypassing drafts.",
+      "",
+      "**Versioning.** Each publish bumps the per-env `version` monotonically. SDKs deliver the latest published version for each env."
+    ].join("\n")
+  },
+  schemas: {
+    create: configCreateSchema,
+    update: configUpdateSchema,
+    saveDraft: configDraftUpsertSchema,
+    publish: configPublishSchema
+  },
+  actions: [
+    { name: "publish", description: "Publish a config draft for an env" },
+    { name: "saveDraft", description: "Save a draft value for an env" },
+    { name: "discardDraft", description: "Discard a draft for an env" }
+  ],
+  endpoints: [
+    {
+      operationId: "listConfigs",
+      method: "GET",
+      path: "",
+      summary: "List dynamic configs",
+      description: "Returns a single page of configs ordered by `updated_at desc, id desc`. Each row includes the latest published `version` per env and any active drafts.",
+      response: configListResponseSchema,
+      examples: { response: { data: [SAMPLE_CFG], next_cursor: null } },
+      useCase: "Snapshot every config in the project \u2014 e.g. CI check that asserts no env is stuck on a stale default or that every config has a published value on prod."
+    },
+    {
+      operationId: "getConfig",
+      method: "GET",
+      path: "/{id}",
+      summary: "Get one config",
+      description: "Returns config metadata plus the latest published values per env and any active draft values. Use this to fetch the JSON the editor renders.",
+      pathParams: { id: "Stable opaque config id (`cfg_\u2026`) or the config's `name`." },
+      response: configResponseSchema,
+      examples: {
+        response: {
+          ...SAMPLE_CFG,
+          values: {
+            dev: { tiers: [{ name: "free" }, { name: "pro" }] },
+            stage: { tiers: [{ name: "free" }, { name: "pro" }] },
+            prod: { tiers: [{ name: "free" }, { name: "pro" }] }
+          },
+          draftValues: {
+            dev: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] }
+          }
+        }
+      },
+      useCase: "Fetch one config's current published values and any in-flight drafts."
+    },
+    {
+      operationId: "createConfig",
+      method: "POST",
+      path: "",
+      summary: "Create a dynamic config",
+      description: [
+        "Creates a new config with the given `schema`. The initial `value` (or an empty object) is published as version 1 on **every** env.",
+        "",
+        "Returns `409` if `name` already exists in the project, `400` if `value` doesn't validate against `schema`."
+      ].join("\n"),
+      successStatus: 201,
+      request: configCreateSchema,
+      response: configCreateResponseSchema,
+      examples: {
+        requestExamples: {
+          minimal: {
+            summary: "Minimal \u2014 name + schema",
+            description: "Smallest valid body. Initial value defaults to `{}` on every env.",
+            value: {
+              name: "pricing.tiers",
+              schema: {
+                type: "object",
+                properties: { tiers: { type: "array" } },
+                required: ["tiers"]
+              }
+            }
+          },
+          seededValue: {
+            summary: "Seeded \u2014 schema + initial value",
+            description: "Seed the same JSON object on every env at version 1.",
+            value: {
+              name: "pricing.tiers",
+              description: "Pricing tier definitions consumed by checkout.",
+              schema: {
+                type: "object",
+                properties: { tiers: { type: "array" } },
+                required: ["tiers"]
+              },
+              value: { tiers: [{ name: "free" }, { name: "pro" }] }
+            }
+          },
+          perEnvSeed: {
+            summary: "Per-env seed",
+            description: "Pass a `{ env: value }` map to seed different initial values per env.",
+            value: {
+              name: "pricing.tiers",
+              schema: {
+                type: "object",
+                properties: { tiers: { type: "array" } },
+                required: ["tiers"]
+              },
+              value: {
+                dev: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] },
+                stage: { tiers: [{ name: "free" }, { name: "pro" }] },
+                prod: { tiers: [{ name: "free" }, { name: "pro" }] }
+              }
+            }
+          }
+        },
+        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4", name: "pricing.tiers" }
+      },
+      useCase: [
+        "- **Minimal create** \u2014 `name` + `schema`. Initial value defaults to `{}`.",
+        "- **Seeded create** \u2014 supply a flat `value` to publish the same object on every env.",
+        "- **Per-env seed** \u2014 supply a `{ env: value }` map for different per-env starting values."
+      ].join("\n")
+    },
+    {
+      operationId: "updateConfig",
+      method: "PATCH",
+      path: "/{id}",
+      summary: "Update a dynamic config",
+      description: [
+        "Partial update. When `value` is supplied it is **republished on every env** (new version per env). When `schema` is supplied it replaces the current schema; every existing value is re-validated.",
+        "",
+        "For env-scoped edits, use the draft/publish flow (`PUT /{id}/drafts` then `POST /{id}/publish`) instead."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque config id." },
+      request: configUpdateSchema,
+      response: configUpdateResponseSchema,
+      examples: {
+        requestExamples: {
+          flatValue: {
+            summary: "Flat value \u2014 republish on every env",
+            description: "Sets the same JSON object as a new version on dev/stage/prod.",
+            value: { value: { tiers: [{ name: "free" }, { name: "pro" }] } }
+          },
+          schemaOnly: {
+            summary: "Schema-only update",
+            description: "Replaces the schema. Existing values must still validate or the update fails.",
+            value: {
+              schema: {
+                type: "object",
+                properties: {
+                  tiers: { type: "array" },
+                  trial_days: { type: "integer" }
+                },
+                required: ["tiers"]
+              }
+            }
+          }
+        },
+        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4" }
+      },
+      useCase: [
+        '- **Republish flat value** \u2014 `{ "value": {\u2026} }` sets the same value on every env.',
+        '- **Schema migration** \u2014 `{ "schema": {\u2026} }` replaces the schema; existing values are re-validated.',
+        "- **Env-scoped edits** \u2014 use `PUT /{id}/drafts` + `POST /{id}/publish` instead of PATCH."
+      ].join("\n")
+    },
+    {
+      operationId: "deleteConfig",
+      method: "DELETE",
+      path: "/{id}",
+      summary: "Delete a dynamic config",
+      description: "Soft-deletes the config and rebuilds the project's flags KV blob.",
+      pathParams: { id: "Stable opaque config id." },
+      response: configDeleteResponseSchema,
+      examples: { response: { ok: true } },
+      useCase: "Tear down a config after its consumers have stopped reading it."
+    },
+    {
+      operationId: "saveConfigDraft",
+      method: "PUT",
+      path: "/{id}/drafts",
+      summary: "Save a draft value",
+      description: [
+        "Stages a value for one env without publishing. The draft is validated against the config's current schema and stored alongside the `baseVersion` it was forked from.",
+        "",
+        "Saving over an existing draft overwrites it. Use `POST /{id}/publish` to promote it to a new published version."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque config id." },
+      request: configDraftUpsertSchema,
+      response: configDraftSaveResponseSchema,
+      examples: {
+        requestExamples: {
+          stageDev: {
+            summary: "Stage a dev draft",
+            description: "Stages a new value on dev without touching stage/prod.",
+            value: {
+              env: "dev",
+              value: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] }
+            }
+          }
+        },
+        response: {
+          id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4",
+          env: "dev",
+          baseVersion: 5,
+          updatedAt: "2026-05-10T09:31:00.000Z"
+        }
+      },
+      useCase: "Iterate on a config value on dev without affecting prod \u2014 preview in staging, then publish."
+    },
+    {
+      operationId: "discardConfigDraft",
+      method: "DELETE",
+      path: "/{id}/drafts",
+      summary: "Discard a draft",
+      description: "Drops the in-flight draft on one env. Published values are unaffected.",
+      pathParams: { id: "Stable opaque config id." },
+      request: configPublishSchema,
+      response: configDraftDiscardResponseSchema,
+      examples: {
+        requestExamples: {
+          discardDev: {
+            summary: "Discard the dev draft",
+            description: "Drops the staged dev draft without publishing.",
+            value: { env: "dev" }
+          }
+        },
+        response: { ok: true }
+      },
+      useCase: "Abandon an in-progress draft after deciding not to ship it."
+    },
+    {
+      operationId: "publishConfigDraft",
+      method: "POST",
+      path: "/{id}/publish",
+      summary: "Publish a draft",
+      description: [
+        "Promotes the staged draft on one env to a new published version. The draft must still validate against the current schema.",
+        "",
+        "Returns `404` if there is no draft for the given env."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque config id." },
+      request: configPublishSchema,
+      response: configPublishResponseSchema,
+      examples: {
+        requestExamples: {
+          publishDev: {
+            summary: "Publish the dev draft",
+            description: "Promotes the dev draft to a new published version on dev.",
+            value: { env: "dev" }
+          },
+          publishProd: {
+            summary: "Publish to prod",
+            description: "Promotes the prod draft after staging signed off.",
+            value: { env: "prod" }
+          }
+        },
+        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4", env: "dev", version: 6 }
+      },
+      useCase: "Ship a staged change once you've validated it on a lower env."
+    },
+    {
+      operationId: "listConfigActivity",
+      method: "GET",
+      path: "/{id}/activity",
+      summary: "List config activity",
+      description: "Returns recent audit rows for one config (create, update, draft.save, publish, delete) ordered newest first. Use the `limit` query parameter to cap the result (1\u2013100, default 20).",
+      pathParams: { id: "Stable opaque config id." },
+      queryParams: {
+        limit: {
+          schema: z6.coerce.number().int().min(1).max(100).default(20),
+          description: "Max rows to return (1\u2013100). Defaults to 20."
+        }
+      },
+      response: configActivityResponseSchema,
+      examples: {
+        response: [
+          {
+            id: "act_01j7waf01a2b3c4d5e6f7g8h9i",
+            action: "config.publish",
+            actorEmail: "ana@example.com",
+            actorType: "user",
+            payload: { env: "dev", version: 6 },
+            createdAt: "2026-05-10T09:31:42.000Z"
+          }
+        ]
+      },
+      useCase: "Render the activity panel in the config editor or drive a slack notification on publish events."
+    }
+  ]
+};
+
+// src/resources/universes.ts
+import { z as z8 } from "zod";
+
+// ../core/src/schemas/universes.ts
+import { z as z7 } from "zod";
+var universeNameSchema = z7.string().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/).describe(
+  "Stable universe key referenced by experiments via `universe: '<name>'`. Lowercase letters, digits, `_` or `-`, max 64 chars. Immutable after create."
+);
+var holdoutRangeSchema = z7.tuple([z7.number().int().min(0).max(9999), z7.number().int().min(0).max(9999)]).refine(([lo, hi]) => lo <= hi, "lo must be <= hi").nullable().describe(
+  "Inclusive `[lo, hi]` bucket range (0\u20139999) reserved as the **holdout** \u2014 callers hashed into this slice are excluded from every experiment in the universe. `null` disables the holdout. Pro plan or higher required."
+);
+var universeCreateSchema = z7.object({
+  name: universeNameSchema,
+  unit_type: z7.string().default("user_id").describe(
+    "Unit of randomisation. Typically `user_id`. Use `account_id` to keep whole accounts in the same group across an experiment."
+  ),
+  holdout_range: holdoutRangeSchema.default(null)
+}).describe("Body for `POST /api/admin/universes`. Only `name` is required.");
+var universeUpdateSchema = z7.object({
+  holdout_range: holdoutRangeSchema.optional()
+}).describe(
+  "Body for `PATCH /api/admin/universes/{id}`. Only `holdout_range` is mutable \u2014 name and unit_type are immutable after create."
+);
+var universeResponseSchema = z7.object({
+  id: z7.string().describe("Stable opaque universe id."),
+  name: universeNameSchema,
+  unitType: z7.string().describe("Unit of randomisation. Snake-case in request (`unit_type`), camelCase in response."),
+  holdoutRange: z7.tuple([z7.number(), z7.number()]).nullable().describe("Reserved holdout bucket range, or `null` if none."),
+  createdAt: z7.string().describe("ISO-8601 timestamp of creation.")
+});
+var universeCreateResponseSchema = z7.object({
+  id: z7.string().describe("Newly assigned universe id."),
+  name: universeNameSchema
+});
+var universeUpdateResponseSchema = z7.object({
+  id: z7.string().describe("Universe id that was updated.")
+});
+var universeDeleteResponseSchema = z7.object({ ok: z7.literal(true) });
+
+// src/resources/universes.ts
+var universeListResponseSchema = z8.object({
+  data: z8.array(universeResponseSchema),
+  next_cursor: z8.string().nullable()
+});
+var BASE4 = "/api/admin/universes";
+function universesClient(t) {
+  async function list(opts = {}) {
+    const query = {};
+    if (opts.limit !== void 0) query.limit = String(opts.limit);
+    if (opts.cursor) query.cursor = opts.cursor;
+    return t.request("GET", BASE4, void 0, query);
+  }
+  async function listAll() {
+    const out = [];
+    let cursor;
+    do {
+      const page = await list({ limit: 500, cursor });
+      out.push(...page.data);
+      cursor = page.next_cursor ?? void 0;
+    } while (cursor);
+    return out;
+  }
+  async function resolve(idOrName) {
+    const all = await listAll();
+    const found = all.find((u) => u.id === idOrName) ?? all.find((u) => u.name === idOrName);
+    if (!found) throw new ApiError(`Universe '${idOrName}' not found`, 404);
+    return found;
+  }
+  return {
+    list,
+    listAll,
+    resolve,
+    create: (input) => t.request("POST", BASE4, universeCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE4}/${id}`, universeUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE4}/${id}`)
+  };
+}
+var universesResource = {
+  name: "universes",
+  basePath: BASE4,
+  describeOne: "universe",
+  describeMany: "universes",
+  tag: {
+    name: "Universes",
+    description: [
+      "Universes: the shared bucketing space all experiments draw from.",
+      "",
+      "**Identity.** Each universe is keyed by a stable `name` (a-z, 0-9, `_`/`-`, max 64 chars). Experiments reference it via `universe: '<name>'`. The name is immutable.",
+      "",
+      "**Unit of randomisation.** `unit_type` selects the attribute hashed into a 0\u20139999 bucket \u2014 default `user_id` for per-user randomisation, `account_id` to keep a whole account in the same group.",
+      "",
+      "**Holdout.** `holdout_range` is an inclusive `[lo, hi]` bucket range (0\u20139999) reserved for measurement \u2014 callers hashed into the holdout are excluded from every experiment in the universe. Pro plan or higher.",
+      "",
+      "**Deletion.** Blocked while any non-archived experiment references the universe \u2014 archive those first."
+    ].join("\n")
+  },
+  schemas: {
+    create: universeCreateSchema,
+    update: universeUpdateSchema
+  },
+  actions: [],
+  endpoints: [
+    {
+      operationId: "listUniverses",
+      method: "GET",
+      path: "",
+      summary: "List universes",
+      description: "Returns a single page of universes ordered by `created_at desc, id desc`. The universes table has no `updated_at`, so this list is keyed on creation time.",
+      response: universeListResponseSchema,
+      examples: {
+        response: {
+          data: [
+            {
+              id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0",
+              name: "primary_users",
+              unitType: "user_id",
+              holdoutRange: [9500, 9999],
+              createdAt: "2026-04-12T10:14:08.000Z"
+            }
+          ],
+          next_cursor: null
+        }
+      },
+      useCase: "Snapshot every universe in the project \u2014 for example to audit which `unit_type` and `holdout_range` are in use before launching a new experiment."
+    },
+    {
+      operationId: "createUniverse",
+      method: "POST",
+      path: "",
+      summary: "Create a universe",
+      description: [
+        "Creates a new universe. Only `name` is required \u2014 `unit_type` defaults to `user_id` and `holdout_range` defaults to `null` (no holdout).",
+        "",
+        "Returns `409` if `name` already exists in the project. Returns `403` if you supply `holdout_range` on a plan below Pro."
+      ].join("\n"),
+      successStatus: 201,
+      request: universeCreateSchema,
+      response: universeCreateResponseSchema,
+      examples: {
+        requestExamples: {
+          minimal: {
+            summary: "Minimal \u2014 name only",
+            description: "Smallest valid body. Creates a `user_id`-keyed universe with no holdout.",
+            value: { name: "primary_users" }
+          },
+          holdout: {
+            summary: "Holdout \u2014 reserve 5% for measurement",
+            description: "Reserves buckets 9500\u20139999 (5% of callers) as the holdout. Pro plan or higher.",
+            value: { name: "primary_users", holdout_range: [9500, 9999] }
+          },
+          accountLevel: {
+            summary: "Account-level randomisation",
+            description: "Bucket whole accounts together via `unit_type: 'account_id'`.",
+            value: { name: "saas_accounts", unit_type: "account_id" }
+          }
+        },
+        response: { id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0", name: "primary_users" }
+      },
+      useCase: [
+        '- **Default universe** \u2014 `{ "name": "primary_users" }`. Per-user randomisation, no holdout.',
+        "- **Reserved holdout** \u2014 supply `holdout_range` to carve out a measurement slice excluded from all experiments.",
+        "- **Account-level** \u2014 `unit_type: 'account_id'` so multi-seat accounts see one consistent variant."
+      ].join("\n")
+    },
+    {
+      operationId: "updateUniverse",
+      method: "PATCH",
+      path: "/{id}",
+      summary: "Update a universe",
+      description: [
+        "Partial update. Only `holdout_range` is mutable \u2014 `name` and `unit_type` are immutable after create.",
+        "",
+        'Pass `"holdout_range": null` to remove an existing holdout.'
+      ].join("\n"),
+      pathParams: { id: "Stable opaque universe id (`uni_\u2026`)." },
+      request: universeUpdateSchema,
+      response: universeUpdateResponseSchema,
+      examples: {
+        requestExamples: {
+          setHoldout: {
+            summary: "Set holdout \u2014 reserve 5%",
+            description: "Reserve buckets 9500\u20139999 as the holdout. Pro plan or higher.",
+            value: { holdout_range: [9500, 9999] }
+          },
+          removeHoldout: {
+            summary: "Remove holdout",
+            description: "Disable the holdout entirely.",
+            value: { holdout_range: null }
+          }
+        },
+        response: { id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0" }
+      },
+      useCase: [
+        "- **Adjust holdout** \u2014 change the reserved measurement slice without recreating experiments.",
+        '- **Remove holdout** \u2014 `{ "holdout_range": null }`.'
+      ].join("\n")
+    },
+    {
+      operationId: "deleteUniverse",
+      method: "DELETE",
+      path: "/{id}",
+      summary: "Delete a universe",
+      description: "Soft-deletes the universe. Returns `409` if any non-archived experiment still references it \u2014 archive those experiments first.",
+      pathParams: { id: "Stable opaque universe id." },
+      response: universeDeleteResponseSchema,
+      examples: { response: { ok: true } },
+      useCase: "Tear down a universe after every experiment that used it has been archived."
+    }
+  ]
+};
+
+// src/resources/killswitches.ts
+import { z as z10 } from "zod";
+
+// ../core/src/schemas/killswitches.ts
+import { z as z9 } from "zod";
+var switchKeySchema = z9.string().max(64).regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/, {
+  message: "Switch keys must be lowercase, no dots."
+}).describe(
+  "Single-segment switch key (lowercase letters, digits, `_`/`-`; no dots). Used as the nested switch entry inside a killswitch's `switches` map."
+);
+var killswitchValueSchema = z9.object({
+  value: z9.boolean().describe(
+    "Default boolean delivered when no `switches` entry matches the caller's switch key."
+  ),
+  switches: z9.record(switchKeySchema, z9.boolean()).optional().describe(
+    "Per-switch overrides. When present, a matching key takes precedence over `value` on the client."
+  )
+}).describe("Runtime killswitch payload returned to SDKs.");
+var killswitchCreateSchema = z9.object({
+  name: configNameSchema.describe(
+    "Stable killswitch key in `folder.name` form (two lowercase segments separated by a dot \u2014 e.g. `payments.checkout`). Immutable after create."
+  ),
+  description: z9.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  value: z9.boolean().optional().describe(
+    "Default value applied to every env at creation. Defaults to `false`. Use `true` to ship the killswitch pre-tripped."
+  ),
+  switches: z9.record(switchKeySchema, z9.boolean()).optional().describe(
+    "Initial per-switch overrides applied to every env. Empty/omitted leaves the killswitch with only the flat `value`."
+  )
+}).describe("Body for `POST /api/admin/killswitches`. Only `name` is required.");
+var killswitchUpdateSchema = z9.object({
+  description: z9.string().max(512).nullish().describe("New description, or `null` to clear it. Max 512 chars."),
+  value: z9.boolean().optional().describe(
+    "Flat value applied to every env. Publishes a new version per env when set. Omit to leave values unchanged."
+  ),
+  switches: z9.record(switchKeySchema, z9.boolean()).optional().describe(
+    "Replace the switches map wholesale on every env. To edit a single entry on a single env use `PUT /{id}/switch` instead."
+  )
+}).describe(
+  "Body for `PATCH /api/admin/killswitches/{id}`. Partial \u2014 only supplied fields change. `switches` replaces wholesale (no merge)."
+);
+var killswitchSwitchSetSchema = z9.object({
+  env: configEnvSchema.describe("Target environment (`dev`/`stage`/`prod`)."),
+  switchKey: switchKeySchema.describe("Switch key to set."),
+  value: z9.boolean().describe("New boolean value for this `switchKey` on this `env`.")
+}).describe(
+  "Body for `PUT /api/admin/killswitches/{id}/switch`. Sets or updates one switch entry on one env."
+);
+var killswitchSwitchUnsetSchema = z9.object({
+  env: configEnvSchema.describe("Target environment."),
+  switchKey: switchKeySchema.describe("Switch key to remove.")
+}).describe(
+  "Body for `DELETE /api/admin/killswitches/{id}/switch`. Removes one switch entry from one env."
+);
+var killswitchEnvEntrySchema = z9.object({
+  value: z9.boolean().describe("Flat boolean published for this env."),
+  switches: z9.record(switchKeySchema, z9.boolean()).optional(),
+  version: z9.number().int().describe("Monotonically increasing version per env."),
+  publishedAt: z9.string().describe("ISO-8601 publish timestamp for this version.")
+});
+var killswitchResponseSchema = z9.object({
+  id: z9.string().describe("Stable opaque killswitch id."),
+  name: configNameSchema,
+  description: z9.string().nullable().describe("Free-form description or `null`."),
+  updatedAt: z9.string().describe("ISO-8601 timestamp of last mutation."),
+  envs: z9.record(configEnvSchema, killswitchEnvEntrySchema).describe("Per-env latest value, switches, version, and publish timestamp.")
+});
+var killswitchCreateResponseSchema = z9.object({
+  id: z9.string().describe("Newly assigned killswitch id."),
+  name: configNameSchema
+});
+var killswitchUpdateResponseSchema = z9.object({
+  id: z9.string().describe("Killswitch id that was updated.")
+});
+var killswitchDeleteResponseSchema = z9.object({ ok: z9.literal(true) });
+var killswitchSwitchSetResponseSchema = z9.object({
+  id: z9.string(),
+  env: configEnvSchema,
+  switchKey: switchKeySchema,
+  value: z9.boolean()
+});
+var killswitchSwitchUnsetResponseSchema = z9.object({
+  id: z9.string(),
+  env: configEnvSchema,
+  switchKey: switchKeySchema,
+  removed: z9.boolean().describe("`true` if the entry existed and was removed, `false` if no-op.")
+});
+
+// src/resources/killswitches.ts
+var killswitchListResponseSchema = z10.object({
+  data: z10.array(killswitchResponseSchema),
+  next_cursor: z10.string().nullable()
+});
+var BASE5 = "/api/admin/killswitches";
+function killswitchesClient(t) {
+  async function list(opts = {}) {
+    const query = {};
+    if (opts.limit !== void 0) query.limit = String(opts.limit);
+    if (opts.cursor) query.cursor = opts.cursor;
+    return t.request("GET", BASE5, void 0, query);
+  }
+  async function listAll() {
+    const out = [];
+    let cursor;
+    do {
+      const page = await list({ limit: 500, cursor });
+      out.push(...page.data);
+      cursor = page.next_cursor ?? void 0;
+    } while (cursor);
+    return out;
+  }
+  async function resolve(idOrName) {
+    try {
+      return await t.request("GET", `${BASE5}/${idOrName}`);
+    } catch (err) {
+      if (!(err instanceof ApiError) || err.status !== 404) throw err;
+    }
+    const all = await listAll();
+    const found = all.find((k) => k.name === idOrName);
+    if (!found) throw new ApiError(`Killswitch '${idOrName}' not found`, 404);
+    return found;
+  }
+  return {
+    list,
+    listAll,
+    resolve,
+    get: (id) => t.request("GET", `${BASE5}/${id}`),
+    create: (input) => t.request("POST", BASE5, killswitchCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE5}/${id}`, killswitchUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE5}/${id}`),
+    setSwitch: (id, input) => t.request("PUT", `${BASE5}/${id}/switch`, killswitchSwitchSetSchema.parse(input)),
+    unsetSwitch: (id, input) => t.request("DELETE", `${BASE5}/${id}/switch`, killswitchSwitchUnsetSchema.parse(input))
+  };
+}
+var SAMPLE_KS = {
+  id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8",
+  name: "payments.checkout",
+  description: "Master kill for the checkout flow. Trip to fall back to the legacy provider.",
+  updatedAt: "2026-05-09T18:22:11.000Z",
+  envs: {
+    dev: { value: false, version: 3, publishedAt: "2026-05-09T18:22:11.000Z" },
+    stage: { value: false, version: 3, publishedAt: "2026-05-09T18:22:11.000Z" },
+    prod: {
+      value: false,
+      switches: { eu_region: true },
+      version: 5,
+      publishedAt: "2026-05-09T18:22:11.000Z"
+    }
+  }
+};
+var killswitchesResource = {
+  name: "killswitches",
+  basePath: BASE5,
+  describeOne: "killswitch",
+  describeMany: "killswitches",
+  tag: {
+    name: "Killswitches",
+    description: [
+      "Killswitches: per-env boolean overrides for kill-style operational toggles. Optimised for incident response \u2014 no rules, no rollout, just a flat boolean (plus optional per-key overrides) versioned per environment.",
+      "",
+      "**Identity.** Each killswitch is keyed by `name` in `folder.name` form (e.g. `payments.checkout`). Immutable after create.",
+      "",
+      "**Per-env values.** Every killswitch stores one version stream per env (`dev`, `stage`, `prod`). A `PATCH` with `value`/`switches` applies to **every** env in one shot (publishes a new version per env). To touch a single env, use `PUT /{id}/switch` and friends.",
+      "",
+      "**Switches map.** Optional `switches: { key: bool }` overrides the flat `value` for specific named call sites \u2014 useful for region/feature-scoped kills.",
+      "",
+      "**Versioning.** Each publish (create, update, set-switch, unset-switch) bumps the per-env `version` monotonically. SDKs deliver the latest published version."
+    ].join("\n")
+  },
+  schemas: {
+    create: killswitchCreateSchema,
+    update: killswitchUpdateSchema,
+    setSwitch: killswitchSwitchSetSchema,
+    unsetSwitch: killswitchSwitchUnsetSchema
+  },
+  actions: [
+    { name: "setSwitch", description: "Set or update one switch entry on one env" },
+    { name: "unsetSwitch", description: "Remove one switch entry from one env" }
+  ],
+  endpoints: [
+    {
+      operationId: "listKillswitches",
+      method: "GET",
+      path: "",
+      summary: "List killswitches",
+      description: "Returns a single page of killswitches ordered by `updated_at desc, id desc`. Each row includes the latest published `value`/`switches`/`version` per env.",
+      response: killswitchListResponseSchema,
+      examples: { response: { data: [SAMPLE_KS], next_cursor: null } },
+      useCase: "Snapshot every killswitch in the project \u2014 e.g. to render an incident-response runbook listing every kill and its current trip state."
+    },
+    {
+      operationId: "getKillswitch",
+      method: "GET",
+      path: "/{id}",
+      summary: "Get one killswitch",
+      description: "Returns the killswitch metadata plus the latest published `value`/`switches`/`version` per env.",
+      pathParams: { id: "Stable opaque killswitch id (`ksw_\u2026`)." },
+      response: killswitchResponseSchema,
+      examples: { response: SAMPLE_KS },
+      useCase: "Fetch the current state of one killswitch \u2014 e.g. to verify a trip propagated before declaring an incident mitigated."
+    },
+    {
+      operationId: "createKillswitch",
+      method: "POST",
+      path: "",
+      summary: "Create a killswitch",
+      description: [
+        "Creates a new killswitch with `value` (default `false`) applied to **every** env at version 1.",
+        "",
+        "Returns `409` if `name` already exists in the project."
+      ].join("\n"),
+      successStatus: 201,
+      request: killswitchCreateSchema,
+      response: killswitchCreateResponseSchema,
+      examples: {
+        requestExamples: {
+          minimal: {
+            summary: "Minimal \u2014 name only, untripped",
+            description: "Smallest valid body. Creates a killswitch with `value: false` on every env.",
+            value: { name: "payments.checkout" }
+          },
+          preTripped: {
+            summary: "Pre-tripped on create",
+            description: "Ship the killswitch already tripped (`value: true`) \u2014 useful when provisioning a kill ahead of a deploy you want to ship with the feature off.",
+            value: {
+              name: "payments.checkout",
+              description: "Master kill for the new checkout flow.",
+              value: true
+            }
+          },
+          withSwitches: {
+            summary: "With per-region switches",
+            description: "Seed a `switches` map so specific named call sites can be tripped independently of the flat `value`.",
+            value: {
+              name: "payments.checkout",
+              value: false,
+              switches: { eu_region: true, apac_region: false }
+            }
+          }
+        },
+        response: { id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8", name: "payments.checkout" }
+      },
+      useCase: [
+        '- **Untripped create** \u2014 `{ "name": "payments.checkout" }`. Provision the kill ahead of an incident.',
+        '- **Pre-tripped** \u2014 `{ "value": true }` to ship the killswitch already engaged.',
+        "- **With switches** \u2014 seed `switches` to carve out per-region/per-tenant kills from day one."
+      ].join("\n")
+    },
+    {
+      operationId: "updateKillswitch",
+      method: "PATCH",
+      path: "/{id}",
+      summary: "Update a killswitch",
+      description: [
+        "Partial update applied to **every** env. Setting `value`/`switches` publishes a new version per env. Description-only patches don't bump versions.",
+        "",
+        "To change a single switch on a single env, use `PUT /{id}/switch` instead."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque killswitch id." },
+      request: killswitchUpdateSchema,
+      response: killswitchUpdateResponseSchema,
+      examples: {
+        requestExamples: {
+          trip: {
+            summary: "Trip the killswitch on every env",
+            description: "Sets `value: true` on dev/stage/prod, bumping each env's version by one.",
+            value: { value: true }
+          },
+          untrip: {
+            summary: "Untrip on every env",
+            description: "Sets `value: false` on every env.",
+            value: { value: false }
+          },
+          replaceSwitches: {
+            summary: "Replace switches map",
+            description: "Replaces the per-key overrides wholesale on every env. Pass `{}` to clear.",
+            value: { switches: { eu_region: true, apac_region: true } }
+          },
+          updateDescription: {
+            summary: "Description-only update",
+            description: "Doesn't bump versions or trigger a republish \u2014 only metadata changes.",
+            value: { description: "Master kill \u2014 owner: payments-platform" }
+          }
+        },
+        response: { id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8" }
+      },
+      useCase: [
+        '- **Trip everywhere** \u2014 `{ "value": true }`. Kills the feature across dev/stage/prod in one call.',
+        '- **Untrip everywhere** \u2014 `{ "value": false }`.',
+        "- **Replace switches** \u2014 send the full new map; per-key edits use `PUT /{id}/switch`.",
+        "- **Update description** \u2014 metadata-only patches don't bump versions."
+      ].join("\n")
+    },
+    {
+      operationId: "deleteKillswitch",
+      method: "DELETE",
+      path: "/{id}",
+      summary: "Delete a killswitch",
+      description: "Soft-deletes the killswitch and rebuilds the project's flags KV blob so SDKs stop seeing it.",
+      pathParams: { id: "Stable opaque killswitch id." },
+      response: killswitchDeleteResponseSchema,
+      examples: { response: { ok: true } },
+      useCase: "Tear down a killswitch after the feature it protected has been removed."
+    },
+    {
+      operationId: "setKillswitchSwitch",
+      method: "PUT",
+      path: "/{id}/switch",
+      summary: "Set one switch entry",
+      description: [
+        "Sets or updates a single `switchKey` on a single `env`. Publishes one new version on that env only \u2014 other envs untouched.",
+        "",
+        "Use this for surgical per-env, per-key flips during incident response (e.g. trip `eu_region` on prod without touching the flat `value` or other envs)."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque killswitch id." },
+      request: killswitchSwitchSetSchema,
+      response: killswitchSwitchSetResponseSchema,
+      examples: {
+        requestExamples: {
+          tripRegion: {
+            summary: "Trip eu_region on prod",
+            description: "Sets `switches.eu_region = true` on prod only. Other envs and the flat `value` are unchanged.",
+            value: { env: "prod", switchKey: "eu_region", value: true }
+          },
+          untripRegion: {
+            summary: "Untrip eu_region on prod",
+            description: "Flip the same entry back off without removing it from the map.",
+            value: { env: "prod", switchKey: "eu_region", value: false }
+          }
+        },
+        response: {
+          id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8",
+          env: "prod",
+          switchKey: "eu_region",
+          value: true
+        }
+      },
+      useCase: [
+        '- **Trip a region** \u2014 `{ "env": "prod", "switchKey": "eu_region", "value": true }`.',
+        "- **Untrip without removing** \u2014 same payload with `value: false`. To remove the entry entirely use `DELETE /{id}/switch`."
+      ].join("\n")
+    },
+    {
+      operationId: "unsetKillswitchSwitch",
+      method: "DELETE",
+      path: "/{id}/switch",
+      summary: "Remove one switch entry",
+      description: [
+        "Removes a single `switchKey` from the `switches` map on a single `env`. Publishes a new version on that env.",
+        "",
+        "Returns `{ removed: false }` if the entry didn't exist (idempotent no-op)."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque killswitch id." },
+      request: killswitchSwitchUnsetSchema,
+      response: killswitchSwitchUnsetResponseSchema,
+      examples: {
+        requestExamples: {
+          removeRegion: {
+            summary: "Remove eu_region from prod",
+            description: "Drops the `eu_region` override on prod so the flat `value` applies again.",
+            value: { env: "prod", switchKey: "eu_region" }
+          }
+        },
+        response: {
+          id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8",
+          env: "prod",
+          switchKey: "eu_region",
+          removed: true
+        }
+      },
+      useCase: "Clean up a per-region override after the incident is resolved so the flat `value` governs again."
+    }
+  ]
+};
+
+// src/resources/index.ts
+function createAdminClient(transport) {
+  return {
+    transport,
+    gates: gatesClient(transport),
+    experiments: experimentsClient(transport),
+    configs: configsClient(transport),
+    universes: universesClient(transport),
+    killswitches: killswitchesClient(transport)
+  };
+}
+var RESOURCE_REGISTRY = [
+  gatesResource,
+  experimentsResource,
+  configsResource,
+  universesResource,
+  killswitchesResource
+];
+export {
+  RESOURCE_REGISTRY,
+  configsClient,
+  configsResource,
+  createAdminClient,
+  experimentsClient,
+  experimentsResource,
+  gatesClient,
+  gatesResource,
+  killswitchesClient,
+  killswitchesResource,
+  universesClient,
+  universesResource
+};