@shipeasy/openapi 1.0.0 → 1.2.0

package/dist/resources/index.js

@@ -1,132 +1,164 @@
 // src/resources/gates.ts
+import { z as z3 } from "zod";
+
+// src/schemas/gates.ts
 import { z as z2 } from "zod";
 
-// ../core/src/schemas/gates.ts
+// src/schemas/folder.ts
 import { z } from "zod";
-var gateRuleSchema = z.object({
-  attr: z.string().min(1).describe(
+var folderSchema = z.string().max(256).regex(/^[a-zA-Z0-9_-]+$/, "Folder must be alphanumeric, `_` or `-` (no `/`).").nullable().optional().describe(
+  "Optional folder name used to group items in the dashboard. Part of the SDK lookup key: an item in folder `checkout` named `new-cart` is referenced as `checkout/new-cart` from the SDK."
+);
+
+// src/schemas/gates.ts
+var gateRuleSchema = z2.object({
+  attr: z2.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)."
+  op: z2.enum([
+    "eq",
+    "neq",
+    "in",
+    "not_in",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "contains",
+    "regex",
+    "semver_gt",
+    "semver_gte",
+    "semver_lt",
+    "semver_lte"
+  ]).describe(
+    "Comparison operator. Equality: `eq`/`neq`. Set membership: `in`/`not_in` (value is an array). Numeric order: `gt`/`gte`/`lt`/`lte`. Semver order: `semver_gt`/`semver_gte`/`semver_lt`/`semver_lte` (value is a dotted version like `4.2.0`). 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`."
+  value: z2.unknown().describe(
+    "Operand. Shape depends on `op`: scalar for `eq/neq/gt/gte/lt/lte/contains/semver_*`; 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 gateNameSchema = z2.string().regex(
+  /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/,
+  "lowercase, digits, _/-; optional folder.name shape"
+).max(128).describe(
+  "Stable gate key used by SDKs (`Shipeasy.checkGate(user, '<name>')`). Single segment or `folder.name`. Lowercase letters, digits, `_` or `-`; max 128 chars. Immutable after create \u2014 rename = delete + recreate."
 );
-var stackedConditionSchema = z.object({
-  id: z.string().min(1).describe(
+var stackedConditionSchema = z2.object({
+  id: z2.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(
+  type: z2.literal("condition").describe("Discriminator. `condition` = rule-based predicate sub-gate."),
+  name: z2.string().optional().describe("Human label shown in the dashboard."),
+  fromTemplate: z2.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).")
+  pass: z2.enum(["all", "any"]).optional().describe("Combinator across `rules`. `all` = AND (default), `any` = OR."),
+  rules: z2.array(gateRuleSchema).default([]).describe("Predicates evaluated under `pass`. Empty array = match nothing."),
+  locked: z2.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(
+var stackedRolloutSchema = z2.object({
+  id: z2.string().min(1).describe("Client-supplied stable id for the stack entry."),
+  type: z2.literal("rollout").describe("Discriminator. `rollout` = percentage-bucket sub-gate."),
+  name: z2.string().optional().describe("Human label shown in the dashboard."),
+  fromTemplate: z2.string().nullable().optional().describe("Source template id, or `null`."),
+  rolloutPct: z2.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(
+  bucketBy: z2.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(
+  salt: z2.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.")
+  locked: z2.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(
+var stackedGateEntrySchema = z2.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({
+  title: z2.string().max(140).optional().describe("Human-readable title shown in the dashboard. Free-form, no key format constraint."),
+  description: z2.string().max(2e3).optional().describe("Long-form description / runbook. Markdown is rendered in the dashboard."),
+  folder: folderSchema,
+  group: z2.string().max(64).optional().describe("Group label for dashboard organisation (e.g. team or product area)."),
+  owner_email: z2.string().max(190).optional().describe("Owner contact. Displayed verbatim; not used for auth.")
+};
+var gateMetadataPatchSchema = z2.object(gateMetadataFields);
+var gateCreateSchema = z2.object({
   name: gateNameSchema,
-  enabled: z.boolean().default(true).describe(
+  enabled: z2.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."
+  rollout_pct: z2.number().int().min(0).max(1e4).default(0).describe(
+    "Initial rollout in **basis points** (0\u201310000 = 0%\u2013100%) \u2014 `100` here means **1%**, not 100%. Use `rollout_percent` (0\u2013100) below if you'd rather think in percent. Use `0` to create the gate dark and ramp via PATCH after deploy validation."
+  ),
+  rollout_percent: z2.number().min(0).max(100).optional().describe(
+    "Initial rollout as a **percentage** (0\u2013100, fractional ok). Friendlier alias for `rollout_pct`; converted internally to basis points (e.g. `100` here = 10000 bp = 100%). If both `rollout_pct` and `rollout_percent` are set, `rollout_percent` wins."
   ),
-  rules: z.array(gateRuleSchema).default([]).describe(
+  rules: z2.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(
+  salt: z2.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(
+  stack: z2.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(
+var gateUpdateSchema = z2.object({
+  rollout_pct: z2.number().int().min(0).max(1e4).optional().describe(
+    "New rollout in **basis points** (0\u201310000 = 0%\u2013100%) \u2014 `100` here means **1%**. Use `rollout_percent` (0\u2013100) below for percent. Omit both to leave unchanged."
+  ),
+  rollout_percent: z2.number().min(0).max(100).optional().describe(
+    "New rollout as a **percentage** (0\u2013100). Friendlier alias for `rollout_pct`; converted internally. Wins over `rollout_pct` if both are supplied. Omit both to leave unchanged."
+  ),
+  rules: z2.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(
+  enabled: z2.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(
+  stack: z2.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`)."),
+var gateResponseSchema = z2.object({
+  id: z2.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."),
+  enabled: z2.union([z2.boolean(), z2.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.")
+  rolloutPct: z2.number().int().min(0).max(1e4).describe("Current rollout in basis points (0\u201310000)."),
+  rules: z2.array(gateRuleSchema).optional(),
+  salt: z2.string().optional().describe("Hash salt used for percentage bucketing."),
+  title: z2.string().nullable().optional(),
+  description: z2.string().nullable().optional(),
+  folder: z2.string().nullable().optional(),
+  groupName: z2.string().nullable().optional().describe("Group label (note: `groupName` in response, `group` in request)."),
+  ownerEmail: z2.string().nullable().optional().describe("Owner email (note: `ownerEmail` in response, `owner_email` in request)."),
+  stack: z2.array(stackedGateEntrySchema).nullable().optional(),
+  updatedAt: z2.string().describe("ISO-8601 timestamp of last mutation.")
 });
-var gateCreateResponseSchema = z.object({
-  id: z.string().describe("Newly assigned gate id (`gat_\u2026`)."),
+var gateCreateResponseSchema = z2.object({
+  id: z2.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()
+var gateUpdateResponseSchema = z2.object({ id: z2.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 = z2.object({ ok: z2.literal(true) });
+var gateToggleResponseSchema = z2.object({
+  id: z2.string(),
+  enabled: z2.boolean()
 });
 
 // src/transport.ts
@@ -140,9 +172,9 @@ var ApiError = class extends Error {
 };
 
 // src/resources/gates.ts
-var gateListResponseSchema = z2.object({
-  data: z2.array(gateResponseSchema),
-  next_cursor: z2.string().nullable()
+var gateListResponseSchema = z3.object({
+  data: z3.array(gateResponseSchema),
+  next_cursor: z3.string().nullable()
 });
 var BASE = "/api/admin/gates";
 function gatesClient(t) {
@@ -469,50 +501,72 @@ var gatesResource = {
 };
 
 // src/resources/experiments.ts
+import { z as z6 } from "zod";
+
+// src/schemas/experiments.ts
+import { z as z5 } from "zod";
+
+// src/schemas/metric-name.ts
 import { z as z4 } from "zod";
+var metricNameSchema = z4.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/).max(128);
 
-// ../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."
+// src/schemas/experiments.ts
+var experimentInlineMetricSchema = z5.object({
+  name: metricNameSchema.optional(),
+  query: z5.string().min(1).max(4096).describe("Metric DSL string, e.g. `count_users(checkout_completed)`.")
+});
+var experimentNameSchema = z5.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/).max(128).describe(
+  "Stable experiment key. Single segment or `folder.name` (a-z, 0-9, `_`/`-`; max 128 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(
+var experimentGroupSchema = z5.object({
+  name: z5.string().min(1).max(64).describe("Group label (e.g. `control`, `treatment_a`). Max 64 chars."),
+  weight: z5.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(
+  params: z5.record(z5.string(), z5.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(
+var paramSchemaSchema = z5.record(z5.string(), z5.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({
+var bucketBySchema = z5.enum(["user_id", "session_id", "device_id"]).describe("Identifier used as the bucketing key. `user_id` is sticky across sessions.");
+var experimentCreateSchema = z5.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(
+  description: z5.string().max(2e3).nullable().default(null).describe("Free-form description. Max 2000 chars, markdown rendered in the dashboard."),
+  hypothesis: z5.string().max(4e3).nullable().default(null).describe("Hypothesis statement shown in the editor. Display-only."),
+  tag: z5.string().max(64).nullable().default(null).describe("Short tag chip rendered next to the name. Display-only."),
+  owner_email: z5.string().max(254).nullable().default(null).describe("Owner email. Display-only."),
+  audience: z5.string().max(256).nullable().default(null).describe("Audience label shown in the editor. Display-only."),
+  bucket_by: bucketBySchema.nullable().default(null),
+  folder: folderSchema,
+  universe: z5.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(
+  targeting_gate: z5.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(
+  allocation_pct: z5.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."),
+  salt: z5.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(
+  groups: z5.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(
+  significance_threshold: z5.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(
+  min_runtime_days: z5.number().int().min(0).max(365).default(0).describe("Minimum days the experiment must run before results are considered conclusive."),
+  min_sample_size: z5.number().int().min(1).default(100).describe("Minimum exposures per group before results are considered conclusive."),
+  sequential_testing: z5.boolean().default(false).describe(
     "Enable sequential testing (always-valid p-values). Requires Premium plan or higher."
+  ),
+  goal_metric: experimentInlineMetricSchema.optional().describe(
+    "Single goal metric defined inline as a DSL query. The underlying event is auto-created if missing."
+  ),
+  guardrail_metrics: z5.array(experimentInlineMetricSchema).max(10).default([]).describe(
+    "Up to 10 guardrail metrics defined inline. Each is upserted (event + metric) and attached with role=guardrail."
   )
 }).refine(
   (e) => e.groups.reduce((s, g) => s + g.weight, 0) === 1e4,
@@ -520,35 +574,42 @@ var experimentCreateSchema = z3.object({
 ).describe(
   "Body for `POST /api/admin/experiments`. `name`, `universe`, and `groups` (\u22652, weights sum to 10000) required."
 );
-var experimentUpdateSchema = z3.object({
+var experimentUpdateSchema = z5.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(
+  description: z5.string().max(2e3).nullable().optional(),
+  hypothesis: z5.string().max(4e3).nullable().optional(),
+  tag: z5.string().max(64).nullable().optional(),
+  owner_email: z5.string().max(254).nullable().optional(),
+  audience: z5.string().max(256).nullable().optional(),
+  bucket_by: bucketBySchema.nullable().optional(),
+  folder: folderSchema,
+  targeting_gate: z5.string().nullable().optional(),
+  allocation_pct: z5.number().int().min(0).max(1e4).optional().describe("Basis-points allocation (0\u201310000). Immutable while the experiment is running."),
+  salt: z5.string().min(1).max(64).optional().describe("Hash salt. Immutable while running."),
+  universe: z5.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()
+  groups: z5.array(experimentGroupSchema).min(2).optional().describe("Replacement groups. Weights must sum to 10000. Immutable while running."),
+  significance_threshold: z5.number().min(1e-4).max(0.5).optional(),
+  min_runtime_days: z5.number().int().min(0).max(365).optional(),
+  min_sample_size: z5.number().int().min(1).optional(),
+  sequential_testing: z5.boolean().optional(),
+  goal_metric: experimentInlineMetricSchema.optional().describe("Replaces the goal metric (event auto-upserted)."),
+  guardrail_metrics: z5.array(experimentInlineMetricSchema).max(10).optional().describe("Replaces the guardrail set wholesale (event auto-upserted per entry).")
 }).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."
+var experimentStatusUpdateSchema = z5.object({
+  status: z5.enum(["draft", "running", "stopped", "archived"]).describe(
+    "Target status. Allowed transitions: `draft \u2192 running`, `running \u2192 stopped`, `stopped \u2192 archived`, `draft \u2192 archived`, and `archived \u2192 draft` (restore \u2014 only if the experiment never started). Restarting an archived experiment directly is not allowed; restore it to draft first, then start."
   )
 }).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(
+var experimentMetricsUpdateSchema = z5.object({
+  metrics: z5.array(
+    z5.object({
+      metric_id: z5.string().describe("Existing metric id in the project."),
+      role: z5.enum(["goal", "guardrail", "secondary"]).describe(
         "Metric role. `goal` drives the decision, `guardrail` blocks ship if degraded, `secondary` is informational."
       )
     })
@@ -556,82 +617,87 @@ var experimentMetricsUpdateSchema = z3.object({
 }).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`)."),
+var experimentResponseSchema = z5.object({
+  id: z5.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()
+  description: z5.string().nullable(),
+  hypothesis: z5.string().nullable(),
+  tag: z5.string().nullable(),
+  ownerEmail: z5.string().nullable(),
+  audience: z5.string().nullable(),
+  bucketBy: bucketBySchema.nullable(),
+  folder: z5.string().nullable(),
+  status: z5.enum(["draft", "running", "stopped", "archived"]),
+  universe: z5.string().describe("Universe name this experiment draws from."),
+  targetingGate: z5.string().nullable(),
+  allocationPct: z5.number().int().describe("Allocation in basis points (0\u201310000)."),
+  salt: z5.string(),
+  params: z5.record(z5.string(), z5.enum(["string", "bool", "number"])),
+  groups: z5.array(experimentGroupSchema),
+  significanceThreshold: z5.number(),
+  minRuntimeDays: z5.number().int(),
+  minSampleSize: z5.number().int(),
+  sequentialTesting: z5.boolean(),
+  startedAt: z5.string().nullable().describe("ISO-8601 timestamp the experiment last transitioned to `running`, or `null`."),
+  stoppedAt: z5.string().nullable().optional(),
+  updatedAt: z5.string()
 });
-var experimentCreateResponseSchema = z3.object({
-  id: z3.string().describe("Newly assigned experiment id."),
+var experimentCreateResponseSchema = z5.object({
+  id: z5.string().describe("Newly assigned experiment id."),
   name: experimentNameSchema
 });
-var experimentUpdateResponseSchema = z3.object({
-  id: z3.string().describe("Experiment id that was updated.")
+var experimentUpdateResponseSchema = z5.object({
+  id: z5.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 experimentDeleteResponseSchema = z5.object({ ok: z5.literal(true) });
+var experimentStatusResponseSchema = z5.object({
+  id: z5.string(),
+  status: z5.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 experimentMetricsResponseSchema = z5.object({
+  id: z5.string(),
+  metrics: z5.array(
+    z5.object({
+      metric_id: z5.string(),
+      role: z5.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 experimentResultRowSchema = z5.object({
+  metric: z5.string(),
+  group_name: z5.string(),
+  ds: z5.string().describe("Date slice (`YYYY-MM-DD`)."),
+  n: z5.number().nullable(),
+  mean: z5.number().nullable(),
+  delta_pct: z5.number().nullable(),
+  p_value: z5.number().nullable(),
+  srm_detected: z5.number().nullable().describe("`1` if sample-ratio mismatch detected, else `0`.")
 });
-var experimentResultsResponseSchema = z3.object({
-  experiment: z3.object({
-    id: z3.string(),
+var experimentResultsResponseSchema = z5.object({
+  experiment: z5.object({
+    id: z5.string(),
     name: experimentNameSchema,
-    status: z3.enum(["draft", "running", "stopped", "archived"])
+    status: z5.enum(["draft", "running", "stopped", "archived"])
   }),
-  results: z3.array(experimentResultRowSchema)
+  results: z5.array(experimentResultRowSchema)
 });
-var experimentTimeseriesResponseSchema = z3.object({
-  experiment: z3.object({
-    id: z3.string(),
+var experimentTimeseriesResponseSchema = z5.object({
+  experiment: z5.object({
+    id: z5.string(),
     name: experimentNameSchema,
-    status: z3.enum(["draft", "running", "stopped", "archived"])
+    status: z5.enum(["draft", "running", "stopped", "archived"])
   }),
-  series: z3.array(experimentResultRowSchema)
+  series: z5.array(experimentResultRowSchema)
 });
-var experimentReanalyzeResponseSchema = z3.object({
-  id: z3.string(),
-  queued: z3.literal(true)
+var experimentReanalyzeResponseSchema = z5.object({
+  id: z5.string(),
+  queued: z5.literal(true)
 });
 
 // src/resources/experiments.ts
-var experimentListResponseSchema = z4.object({
-  data: z4.array(experimentResponseSchema),
-  next_cursor: z4.string().nullable()
+var experimentListResponseSchema = z6.object({
+  data: z6.array(experimentResponseSchema),
+  next_cursor: z6.string().nullable()
 });
 var BASE2 = "/api/admin/experiments";
 function experimentsClient(t) {
@@ -641,24 +707,29 @@ function experimentsClient(t) {
     if (opts.cursor) query.cursor = opts.cursor;
     return t.request("GET", BASE2, void 0, query);
   }
-  async function listAll() {
+  async function listAllWith(status) {
     const out = [];
     let cursor;
     do {
-      const page = await list({ limit: 500, cursor });
+      const query = { limit: "500" };
+      if (cursor) query.cursor = cursor;
+      if (status) query.status = status;
+      const page = await t.request("GET", BASE2, void 0, query);
       out.push(...page.data);
       cursor = page.next_cursor ?? void 0;
     } while (cursor);
     return out;
   }
+  async function listAll() {
+    return listAllWith();
+  }
   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);
+    const found = (await listAllWith()).find((e) => e.name === idOrName) ?? (await listAllWith("archived")).find((e) => e.name === idOrName);
     if (!found) throw new ApiError(`Experiment '${idOrName}' not found`, 404);
     return found;
   }
@@ -681,6 +752,7 @@ function experimentsClient(t) {
     start: (id) => setStatus(id, "running"),
     stop: (id) => setStatus(id, "stopped"),
     archive: (id) => setStatus(id, "archived"),
+    restore: (id) => setStatus(id, "draft"),
     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(
@@ -727,7 +799,7 @@ var experimentsResource = {
       "",
       "**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.",
+      "**Lifecycle.** `draft \u2192 running \u2192 stopped \u2192 archived`. Transition via `POST /{id}/status`. An archived experiment that never started can be restored with `archived \u2192 draft`; restarting an archived experiment directly 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.",
       "",
@@ -746,6 +818,7 @@ var experimentsResource = {
     { name: "start", description: "Transition draft experiment to running" },
     { name: "stop", description: "Stop a running experiment" },
     { name: "archive", description: "Archive a stopped experiment" },
+    { name: "restore", description: "Restore an archived (never-started) experiment to draft" },
     { name: "reanalyze", description: "Re-run analysis pass for the experiment" }
   ],
   endpoints: [
@@ -926,8 +999,9 @@ var experimentsResource = {
         "- `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.",
+        "- `archived \u2192 draft` \u2014 restore a soft-deleted experiment so it can be re-completed and started. Allowed only if it never started; one that already ran must be cloned instead.",
         "",
-        "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`."
+        "Restarting an `archived` experiment directly is not allowed \u2014 restore it to `draft` first. 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,
@@ -948,6 +1022,11 @@ var experimentsResource = {
             summary: "Archive \u2014 stopped \u2192 archived",
             description: "Soft-deletes the experiment. List endpoints exclude archived rows by default.",
             value: { status: "archived" }
+          },
+          restore: {
+            summary: "Restore \u2014 archived \u2192 draft",
+            description: "Un-deletes a soft-deleted experiment so it can be re-completed and started. Allowed only if it never ran.",
+            value: { status: "draft" }
           }
         },
         response: { id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1", status: "running" }
@@ -1047,2393 +1126,77 @@ var experimentsResource = {
       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);
+      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: z6.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."
     }
-    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);
-}
+// src/resources/configs.ts
+import { z as z8 } 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/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`;
-  }
-};
+// src/schemas/configs.ts
+import { z as z7 } from "zod";
 
-// ../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`)
-  })
-);
+// src/schemas/constants.ts
 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
+// 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(
+var configNameSchema = z7.string().max(128).refine(
   (s) => {
     const parts = s.split(".");
     if (parts.length !== 2) return false;
@@ -3445,95 +1208,97 @@ var configNameSchema = z5.string().max(128).refine(
 ).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(
+var configKindSchema = z7.enum(CONFIG_KINDS);
+var configEnvSchema = z7.enum(CONFIG_ENVS).describe("Target environment. One of the project's configured envs (`dev`, `stage`, `prod`).");
+var jsonSchemaSchema = z7.record(z7.string(), z7.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(
+var initialValuesSchema = z7.union([z7.unknown(), z7.record(configEnvSchema, z7.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({
+var configCreateSchema = z7.object({
   name: configNameSchema,
-  description: z5.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  description: z7.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  folder: folderSchema,
   schema: jsonSchemaSchema,
   value: initialValuesSchema.optional()
 }).describe("Body for `POST /api/admin/configs`. `name` + `schema` required.");
-var configUpdateSchema = z5.object({
+var configUpdateSchema = z7.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(
+  value: z7.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`."
-  )
+  ),
+  folder: folderSchema
 }).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({
+var configSchemaUpdateSchema = z7.object({ schema: jsonSchemaSchema }).describe("Schema-only update. Does not bump value versions or rebuild KV.");
+var configDraftUpsertSchema = z7.object({
   env: configEnvSchema,
-  value: z5.unknown().describe("Draft value to stage on `env`. Validated against the config's current schema.")
+  value: z7.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(
+var configPublishSchema = z7.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 configEnvPublishedSchema = z7.object({
+  version: z7.number().int().describe("Monotonically increasing version per env."),
+  publishedAt: z7.string().describe("ISO-8601 publish timestamp."),
+  publishedBy: z7.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 configDraftSummarySchema = z7.object({
+  updatedAt: z7.string().describe("ISO-8601 last-edit timestamp on the draft."),
+  authorEmail: z7.string().describe("Email/id of the actor who last edited the draft."),
+  baseVersion: z7.number().int().describe("Published version the draft was forked from.")
 });
-var configResponseSchema = z5.object({
-  id: z5.string().describe("Stable opaque config id (`cfg_\u2026`)."),
+var configResponseSchema = z7.object({
+  id: z7.string().describe("Stable opaque config id (`cfg_\u2026`)."),
   name: configNameSchema,
-  description: z5.string().nullable(),
+  description: z7.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}`).")
+  updatedAt: z7.string().describe("ISO-8601 timestamp of last mutation."),
+  envs: z7.record(configEnvSchema, configEnvPublishedSchema).describe("Per-env latest published version metadata."),
+  drafts: z7.record(configEnvSchema, configDraftSummarySchema).describe("Per-env active drafts (if any)."),
+  values: z7.record(configEnvSchema, z7.unknown()).optional().describe("Per-env latest published values (only returned by `GET /{id}`, not list)."),
+  draftValues: z7.record(configEnvSchema, z7.unknown()).optional().describe("Per-env draft values (only returned by `GET /{id}`).")
 });
-var configCreateResponseSchema = z5.object({
-  id: z5.string().describe("Newly assigned config id."),
+var configCreateResponseSchema = z7.object({
+  id: z7.string().describe("Newly assigned config id."),
   name: configNameSchema
 });
-var configUpdateResponseSchema = z5.object({
-  id: z5.string().describe("Config id that was updated.")
+var configUpdateResponseSchema = z7.object({
+  id: z7.string().describe("Config id that was updated.")
 });
-var configDeleteResponseSchema = z5.object({ ok: z5.literal(true) });
-var configDraftSaveResponseSchema = z5.object({
-  id: z5.string(),
+var configDeleteResponseSchema = z7.object({ ok: z7.literal(true) });
+var configDraftSaveResponseSchema = z7.object({
+  id: z7.string(),
   env: configEnvSchema,
-  baseVersion: z5.number().int().describe("Published version the draft is based on."),
-  updatedAt: z5.string()
+  baseVersion: z7.number().int().describe("Published version the draft is based on."),
+  updatedAt: z7.string()
 });
-var configDraftDiscardResponseSchema = z5.object({ ok: z5.literal(true) });
-var configPublishResponseSchema = z5.object({
-  id: z5.string(),
+var configDraftDiscardResponseSchema = z7.object({ ok: z7.literal(true) });
+var configPublishResponseSchema = z7.object({
+  id: z7.string(),
   env: configEnvSchema,
-  version: z5.number().int().describe("Newly published version on `env`.")
+  version: z7.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 configActivityEntrySchema = z7.object({
+  id: z7.string(),
+  action: z7.string().describe("Audit action (e.g. `config.create`, `config.publish`)."),
+  actorEmail: z7.string(),
+  actorType: z7.enum(["user", "cli", "system"]),
+  payload: z7.unknown().nullable(),
+  createdAt: z7.string().describe("ISO-8601 timestamp.")
 });
-var configActivityResponseSchema = z5.array(configActivityEntrySchema).describe("Recent audit rows for one config, newest first.");
+var configActivityResponseSchema = z7.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 configListResponseSchema = z8.object({
+  data: z8.array(configResponseSchema),
+  next_cursor: z8.string().nullable()
 });
 var BASE3 = "/api/admin/configs";
 function configsClient(t) {
@@ -3886,7 +1651,7 @@ var configsResource = {
       pathParams: { id: "Stable opaque config id." },
       queryParams: {
         limit: {
-          schema: z6.coerce.number().int().min(1).max(100).default(20),
+          schema: z8.coerce.number().int().min(1).max(100).default(20),
           description: "Max rows to return (1\u2013100). Defaults to 20."
         }
       },
@@ -3909,48 +1674,50 @@ var configsResource = {
 };
 
 // src/resources/universes.ts
-import { z as z8 } from "zod";
+import { z as z10 } 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."
+// src/schemas/universes.ts
+import { z as z9 } from "zod";
+var universeNameSchema = z9.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/).max(128).describe(
+  "Stable universe key. Single segment or `folder.name`. Lowercase letters, digits, `_` or `-`; max 128 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(
+var holdoutRangeSchema = z9.tuple([z9.number().int().min(0).max(9999), z9.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({
+var universeCreateSchema = z9.object({
   name: universeNameSchema,
-  unit_type: z7.string().default("user_id").describe(
+  folder: folderSchema,
+  unit_type: z9.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({
+var universeUpdateSchema = z9.object({
+  folder: folderSchema,
   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."),
+var universeResponseSchema = z9.object({
+  id: z9.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.")
+  unitType: z9.string().describe("Unit of randomisation. Snake-case in request (`unit_type`), camelCase in response."),
+  holdoutRange: z9.tuple([z9.number(), z9.number()]).nullable().describe("Reserved holdout bucket range, or `null` if none."),
+  createdAt: z9.string().describe("ISO-8601 timestamp of creation.")
 });
-var universeCreateResponseSchema = z7.object({
-  id: z7.string().describe("Newly assigned universe id."),
+var universeCreateResponseSchema = z9.object({
+  id: z9.string().describe("Newly assigned universe id."),
   name: universeNameSchema
 });
-var universeUpdateResponseSchema = z7.object({
-  id: z7.string().describe("Universe id that was updated.")
+var universeUpdateResponseSchema = z9.object({
+  id: z9.string().describe("Universe id that was updated.")
 });
-var universeDeleteResponseSchema = z7.object({ ok: z7.literal(true) });
+var universeDeleteResponseSchema = z9.object({ ok: z9.literal(true) });
 
 // src/resources/universes.ts
-var universeListResponseSchema = z8.object({
-  data: z8.array(universeResponseSchema),
-  next_cursor: z8.string().nullable()
+var universeListResponseSchema = z10.object({
+  data: z10.array(universeResponseSchema),
+  next_cursor: z10.string().nullable()
 });
 var BASE4 = "/api/admin/universes";
 function universesClient(t) {
@@ -4120,97 +1887,106 @@ var universesResource = {
 };
 
 // src/resources/killswitches.ts
-import { z as z10 } from "zod";
+import { z as z12 } 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])?$/, {
+// src/schemas/killswitches.ts
+import { z as z11 } from "zod";
+var SWITCH_KEY_RE = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/;
+var switchKeySchema = z11.string().max(64).regex(SWITCH_KEY_RE, {
   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(
+var killswitchValueSchema = z11.object({
+  value: z11.boolean().describe(
     "Default boolean delivered when no `switches` entry matches the caller's switch key."
   ),
-  switches: z9.record(switchKeySchema, z9.boolean()).optional().describe(
+  switches: z11.record(switchKeySchema, z11.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({
+var killswitchCreateSchema = z11.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(
+  description: z11.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  folder: folderSchema,
+  value: z11.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(
+  switches: z11.record(switchKeySchema, z11.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(
+var killswitchUpdateSchema = z11.object({
+  description: z11.string().max(512).nullish().describe("New description, or `null` to clear it. Max 512 chars."),
+  folder: folderSchema,
+  value: z11.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(
+  switches: z11.record(switchKeySchema, z11.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({
+var killswitchSwitchSetSchema = z11.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`.")
+  value: z11.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({
+var killswitchValueSetSchema = z11.object({
+  env: configEnvSchema.describe("Target environment whose flat default flips."),
+  value: z11.boolean().describe("New flat default for this env. Existing switches carry forward unchanged.")
+}).describe(
+  "Body for the killswitch quick-toggle. Sets the flat `value` on one env without touching its switches."
+);
+var killswitchSwitchUnsetSchema = z11.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 killswitchEnvEntrySchema = z11.object({
+  value: z11.boolean().describe("Flat boolean published for this env."),
+  switches: z11.record(switchKeySchema, z11.boolean()).optional(),
+  version: z11.number().int().describe("Monotonically increasing version per env."),
+  publishedAt: z11.string().describe("ISO-8601 publish timestamp for this version.")
 });
-var killswitchResponseSchema = z9.object({
-  id: z9.string().describe("Stable opaque killswitch id."),
+var killswitchResponseSchema = z11.object({
+  id: z11.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.")
+  description: z11.string().nullable().describe("Free-form description or `null`."),
+  updatedAt: z11.string().describe("ISO-8601 timestamp of last mutation."),
+  envs: z11.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."),
+var killswitchCreateResponseSchema = z11.object({
+  id: z11.string().describe("Newly assigned killswitch id."),
   name: configNameSchema
 });
-var killswitchUpdateResponseSchema = z9.object({
-  id: z9.string().describe("Killswitch id that was updated.")
+var killswitchUpdateResponseSchema = z11.object({
+  id: z11.string().describe("Killswitch id that was updated.")
 });
-var killswitchDeleteResponseSchema = z9.object({ ok: z9.literal(true) });
-var killswitchSwitchSetResponseSchema = z9.object({
-  id: z9.string(),
+var killswitchDeleteResponseSchema = z11.object({ ok: z11.literal(true) });
+var killswitchSwitchSetResponseSchema = z11.object({
+  id: z11.string(),
   env: configEnvSchema,
   switchKey: switchKeySchema,
-  value: z9.boolean()
+  value: z11.boolean()
 });
-var killswitchSwitchUnsetResponseSchema = z9.object({
-  id: z9.string(),
+var killswitchSwitchUnsetResponseSchema = z11.object({
+  id: z11.string(),
   env: configEnvSchema,
   switchKey: switchKeySchema,
-  removed: z9.boolean().describe("`true` if the entry existed and was removed, `false` if no-op.")
+  removed: z11.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 killswitchListResponseSchema = z12.object({
+  data: z12.array(killswitchResponseSchema),
+  next_cursor: z12.string().nullable()
 });
 var BASE5 = "/api/admin/killswitches";
 function killswitchesClient(t) {
@@ -4494,6 +2270,60 @@ var killswitchesResource = {
   ]
 };
 
+// src/schemas/alert-rules.ts
+import { z as z13 } from "zod";
+var ALERT_COMPARATORS = ["gt", "gte", "lt", "lte"];
+var ALERT_SEVERITIES = ["danger", "warn", "info"];
+var alertRuleCreateSchema = z13.object({
+  name: z13.string().min(1).max(120).describe("Human label for the rule, shown on the alert and the rules list."),
+  metricId: z13.string().min(1).describe("Id of the metric to evaluate."),
+  comparator: z13.enum(ALERT_COMPARATORS).describe("How the metric value is compared to the threshold (gt/gte/lt/lte)."),
+  threshold: z13.number().finite().describe("Threshold the metric value is compared against."),
+  windowHours: z13.number().int().min(1).max(720).default(24).describe("Lookback window (hours) the metric is aggregated over. 1\u2013720."),
+  severity: z13.enum(ALERT_SEVERITIES).default("warn").describe("Severity of the raised alert."),
+  enabled: z13.boolean().default(true).describe("Whether the rule is evaluated by the cron.")
+}).strict();
+var alertRuleUpdateSchema = z13.object({
+  name: z13.string().min(1).max(120),
+  comparator: z13.enum(ALERT_COMPARATORS),
+  threshold: z13.number().finite(),
+  windowHours: z13.number().int().min(1).max(720),
+  severity: z13.enum(ALERT_SEVERITIES),
+  enabled: z13.boolean()
+}).partial().strict();
+
+// src/resources/alert-rules.ts
+var BASE6 = "/api/admin/alert-rules";
+function alertRulesClient(t) {
+  async function list() {
+    return t.request("GET", BASE6);
+  }
+  async function resolve(idOrName) {
+    const all = await list();
+    const byId = all.find((r) => r.id === idOrName);
+    if (byId) return byId;
+    const byPrefix = all.filter((r) => r.id.startsWith(idOrName));
+    if (byPrefix.length === 1) return byPrefix[0];
+    if (byPrefix.length > 1)
+      throw new ApiError(`Alert rule id prefix '${idOrName}' is ambiguous`, 400);
+    const byName = all.filter((r) => r.name === idOrName);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1)
+      throw new ApiError(
+        `Alert rule name '${idOrName}' is ambiguous \u2014 pass an id instead`,
+        400
+      );
+    throw new ApiError(`Alert rule '${idOrName}' not found`, 404);
+  }
+  return {
+    list,
+    resolve,
+    create: (input) => t.request("POST", BASE6, alertRuleCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE6}/${id}`, alertRuleUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE6}/${id}`)
+  };
+}
+
 // src/resources/index.ts
 function createAdminClient(transport) {
   return {
@@ -4502,7 +2332,8 @@ function createAdminClient(transport) {
     experiments: experimentsClient(transport),
     configs: configsClient(transport),
     universes: universesClient(transport),
-    killswitches: killswitchesClient(transport)
+    killswitches: killswitchesClient(transport),
+    alertRules: alertRulesClient(transport)
   };
 }
 var RESOURCE_REGISTRY = [
@@ -4514,6 +2345,7 @@ var RESOURCE_REGISTRY = [
 ];
 export {
   RESOURCE_REGISTRY,
+  alertRulesClient,
   configsClient,
   configsResource,
   createAdminClient,