@shipeasy/openapi 1.6.0 → 2.2.0

package/dist/index.js

@@ -1,4379 +1,262 @@
-// src/transport.ts
-var ApiError = class extends Error {
-  constructor(message, status) {
-    super(message);
-    this.status = status;
-    this.name = "ApiError";
-  }
-  status;
+import {
+  approveEvent,
+  client,
+  configure,
+  createAlertRule,
+  createAttribute,
+  createClient,
+  createConfig,
+  createConfig2,
+  createConnector,
+  createEvent,
+  createExperiment,
+  createGate,
+  createGateTemplate,
+  createI18nDraft,
+  createI18nProfile,
+  createKey,
+  createKillswitch,
+  createMetric,
+  createOpsItem,
+  createTriggerConnector,
+  createUniverse,
+  deleteAlertRule,
+  deleteAttribute,
+  deleteConfig,
+  deleteConnector,
+  deleteEvent,
+  deleteExperiment,
+  deleteGate,
+  deleteGateTemplate,
+  deleteKillswitch,
+  deleteMetric,
+  deleteUniverse,
+  disableGate,
+  discardConfigDraft,
+  enableGate,
+  fileErrorTicket,
+  fireConnector,
+  getAttribute,
+  getConfig,
+  getConnector,
+  getCurrentProject,
+  getError,
+  getErrorSeries,
+  getEvent,
+  getExperiment,
+  getExperimentResults,
+  getExperimentTimeseries,
+  getGateTemplate,
+  getKillswitch,
+  getMetric,
+  getOpsItem,
+  linkPrToOpsItem,
+  listAlertRules,
+  listAttributes,
+  listConfigActivity,
+  listConfigs,
+  listConnectors,
+  listErrors,
+  listEvents,
+  listExperiments,
+  listGateTemplates,
+  listGates,
+  listI18nDrafts,
+  listI18nKeys,
+  listI18nProfiles,
+  listKeys,
+  listKillswitches,
+  listMetrics,
+  listOpsItems,
+  listSlackChannels,
+  listUniverses,
+  notifyOps,
+  publishConfigDraft,
+  publishI18nProfile,
+  pushI18nKeys,
+  reanalyzeExperiment,
+  revokeKey,
+  saveConfigDraft,
+  searchResources,
+  setExperimentMetrics,
+  setExperimentStatus,
+  setI18nLabel,
+  setKillswitchSwitch,
+  setKillswitchValue,
+  testConnector,
+  unsetKillswitchSwitch,
+  updateAlertRule,
+  updateAttribute,
+  updateConfig,
+  updateConfigSchema,
+  updateConnector,
+  updateErrorStatus,
+  updateEvent,
+  updateExperiment,
+  updateGate,
+  updateGateTemplate,
+  updateI18nDraft,
+  updateI18nKey,
+  updateKillswitch,
+  updateMetric,
+  updateOpsItem,
+  updateProject,
+  updateTriggerConnector,
+  updateUniverse,
+  upsertProject
+} from "./chunk-643YSMLU.js";
+import {
+  zErrorCode
+} from "./chunk-MRW3DJ57.js";
+
+// src/errors.ts
+var ERROR_CODES = zErrorCode.options;
+function isApiErrorBody(value) {
+  return typeof value === "object" && value !== null && "error" in value && typeof value.error === "string";
+}
+function errorCodeOf(value) {
+  if (!isApiErrorBody(value)) return void 0;
+  const code = value.code;
+  return code && ERROR_CODES.includes(code) ? code : void 0;
+}
+var REAUTH_COMMAND = {
+  cli: "shipeasy login --force",
+  mcp: "shipeasy-mcp install --force"
 };
-function createHttpTransport(opts) {
-  const baseUrl = opts.baseUrl.replace(/\/$/, "");
-  return {
-    async request(method, path, body, query) {
-      if (method !== "GET" && opts.beforeMutation) {
-        await opts.beforeMutation(method, path);
-      }
-      const auth = opts.getAuth();
-      const url = new URL(`${baseUrl}${path}`);
-      if (query) {
-        for (const [k, v] of Object.entries(query)) url.searchParams.set(k, v);
-      }
-      const res = await fetch(url.toString(), {
-        method,
-        headers: {
-          "X-SDK-Key": auth.token,
-          "X-Project-Id": auth.projectId,
-          "Content-Type": "application/json"
-        },
-        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
-      });
-      if (res.status === 204 || res.status === 202) return void 0;
-      const json = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
-      if (!res.ok) {
-        const msg = json.error ?? `HTTP ${res.status}`;
-        throw new ApiError(msg, res.status);
-      }
-      return json;
-    }
-  };
-}
-
-// src/schemas/pagination.ts
-import { z } from "zod";
-var DEFAULT_PAGE_SIZE = 100;
-var MAX_PAGE_SIZE = 500;
-var pageQuerySchema = z.object({
-  limit: z.coerce.number().int().min(1).max(MAX_PAGE_SIZE).default(DEFAULT_PAGE_SIZE),
-  cursor: z.string().min(1).optional()
-});
-var SEP = "|";
-function encodeCursor(parts) {
-  if (parts.ts.includes(SEP)) {
-    throw new Error(`pagination: ts must not contain '${SEP}'`);
-  }
-  return base64UrlEncode(`${parts.ts}${SEP}${parts.id}`);
-}
-function decodeCursor(cursor) {
-  let raw;
-  try {
-    raw = base64UrlDecode(cursor);
-  } catch {
-    throw new Error("pagination: cursor is not valid base64url");
-  }
-  const sep = raw.indexOf(SEP);
-  if (sep < 0) throw new Error("pagination: cursor missing separator");
-  const ts = raw.slice(0, sep);
-  const id = raw.slice(sep + 1);
-  if (!ts || !id) throw new Error("pagination: cursor parts empty");
-  return { ts, id };
+function formatAuthFailure(surface, status, message) {
+  const reauth = REAUTH_COMMAND[surface];
+  if (status === 401) {
+    return [
+      `AUTH_REQUIRED: ${message} (401)`,
+      ``,
+      `Cause: the request's Shipeasy credentials are missing, invalid, or expired.`,
+      `Fix:`,
+      `  1. Run: ${reauth}`,
+      `  2. Retry the command that failed.`
+    ].join("\n");
+  }
+  if (status === 403) {
+    return [
+      `AUTH_FORBIDDEN: ${message} (403)`,
+      ``,
+      `Cause: the credentials are valid but don't have access to this project or resource.`,
+      `Fix:`,
+      `  1. Confirm the bound project is correct (check the .shipeasy file, or run: shipeasy root --json).`,
+      `  2. If it's the wrong project, run: shipeasy bind <project_id>.`,
+      `  3. If it's the right project, ask a workspace admin to grant access \u2014 retrying will not help.`
+    ].join("\n");
+  }
+  return void 0;
 }
-function base64UrlEncode(s) {
-  const b64 = btoa(s);
-  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function base64UrlDecode(s) {
-  const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
-  return atob(s.replace(/-/g, "+").replace(/_/g, "/") + pad);
-}
-
-// src/resources/gates.ts
-import { z as z4 } from "zod";
-
-// src/schemas/gates.ts
-import { z as z3 } from "zod";
-
-// src/schemas/folder.ts
-import { z as z2 } from "zod";
-var folderSchema = z2.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 = z3.object({
-  attr: z3.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: z3.enum([
-    "eq",
-    "neq",
-    "in",
-    "not_in",
-    "gt",
-    "gte",
-    "lt",
-    "lte",
-    "contains",
-    "regex",
-    "semver_gt",
-    "semver_gte",
-    "semver_lt",
-    "semver_lte",
-    "gate_pass",
-    "exp_in"
-  ]).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). Cross-resource references (evaluated only on the worker hot path, where both KV blobs load): `gate_pass` (`value` is another gate\'s name \u2014 true when that gate passes for the same caller); `exp_in` (`attr` is a running experiment\'s name, `value` is a group name, `"$holdout"`, or `"$any"` \u2014 true when the caller is in that variant / the universe holdout / any variant).'
-  ),
-  value: z3.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`; referenced gate name for `gate_pass`; group name / `"$holdout"` / `"$any"` for `exp_in`.'
-  )
-}).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 = z3.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 rampSchema = z3.object({
-  from: z3.number().int().min(0).max(1e4).describe("Start of the ramp in basis points (0\u201310000)."),
-  to: z3.number().int().min(0).max(1e4).describe("End of the ramp in basis points (0\u201310000)."),
-  startAt: z3.number().int().nonnegative().describe("Ramp start, epoch milliseconds (UTC)."),
-  durationMs: z3.number().int().positive().describe("Ramp length in milliseconds.")
-}).describe(
-  "Linear rollout ramp. The effective rollout % interpolates `from`\u2192`to` over `[startAt, startAt+durationMs]`, clamped outside that window, evaluated against the wall-clock at eval time. Overrides the entry's static `rolloutPct` while present."
-);
-var stackedConditionSchema = z3.object({
-  id: z3.string().min(1).describe(
-    "Client-supplied stable id for the stack entry (used for React keys, audit diffs, and as the default per-condition rollout salt)."
-  ),
-  type: z3.literal("condition").describe("Discriminator. `condition` = rule-based predicate sub-gate."),
-  name: z3.string().optional().describe("Human label shown in the dashboard."),
-  fromTemplate: z3.string().nullable().optional().describe(
-    "Id of the project template this entry was seeded from, or `null` if hand-authored."
-  ),
-  pass: z3.enum(["all", "any"]).optional().describe("Combinator across `rules`. `all` = AND (default), `any` = OR."),
-  rules: z3.array(gateRuleSchema).default([]).describe("Predicates evaluated under `pass`. Empty array = match nothing."),
-  rolloutPct: z3.number().int().min(0).max(1e4).optional().describe(
-    "Per-condition rollout in basis points. After the rules match, the caller is bucketed at this %; in-bucket \u2192 gate `true`, otherwise fall through to the next entry. Absent \u21D2 10000 (100%, every matching caller passes)."
-  ),
-  bucketBy: z3.string().optional().describe("Attribute used to hash the caller into the per-condition bucket. Default `userID`."),
-  salt: z3.string().optional().describe("Per-condition hash salt. Defaults to the entry `id`, then the gate salt."),
-  ramp: rampSchema.optional(),
-  locked: z3.boolean().optional().describe("If `true`, dashboard hides edit controls (e.g. the trailing public-floor entry).")
-}).describe(
-  "Rule-based sub-gate. When the rules match and the caller falls in the per-condition rollout bucket, evaluation short-circuits and the gate returns `true`; otherwise it falls through to the next entry."
-);
-var stackedRolloutSchema = z3.object({
-  id: z3.string().min(1).describe("Client-supplied stable id for the stack entry."),
-  type: z3.literal("rollout").describe("Discriminator. `rollout` = percentage-bucket sub-gate."),
-  name: z3.string().optional().describe("Human label shown in the dashboard."),
-  fromTemplate: z3.string().nullable().optional().describe("Source template id, or `null`."),
-  rolloutPct: z3.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: z3.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: z3.string().optional().describe(
-    "Per-entry hash salt. Defaults to the gate's salt. Set explicitly to keep two rollouts independent or correlated across gates."
-  ),
-  ramp: rampSchema.optional(),
-  locked: z3.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 (or the ramp's effective % when `ramp` is set)."
-);
-var stackedGateEntrySchema = z3.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: z3.string().max(140).optional().describe("Human-readable title shown in the dashboard. Free-form, no key format constraint."),
-  description: z3.string().max(2e3).optional().describe("Long-form description / runbook. Markdown is rendered in the dashboard."),
-  folder: folderSchema,
-  group: z3.string().max(64).optional().describe("Group label for dashboard organisation (e.g. team or product area)."),
-  owner_email: z3.string().max(190).optional().describe("Owner contact. Displayed verbatim; not used for auth.")
-};
-var gateMetadataPatchSchema = z3.object(gateMetadataFields);
-var gateCreateSchema = z3.object({
-  name: gateNameSchema,
-  enabled: z3.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: z3.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: z3.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: z3.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: z3.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: z3.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 = z3.object({
-  rollout_pct: z3.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: z3.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: z3.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: z3.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: z3.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 = z3.object({
-  id: z3.string().describe("Stable opaque gate id (`gat_\u2026`)."),
-  name: gateNameSchema,
-  /** D1 stores enabled as 0/1; clients see either form. */
-  enabled: z3.union([z3.boolean(), z3.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: z3.number().int().min(0).max(1e4).describe("Current rollout in basis points (0\u201310000)."),
-  rules: z3.array(gateRuleSchema).optional(),
-  salt: z3.string().optional().describe("Hash salt used for percentage bucketing."),
-  title: z3.string().nullable().optional(),
-  description: z3.string().nullable().optional(),
-  folder: z3.string().nullable().optional(),
-  groupName: z3.string().nullable().optional().describe("Group label (note: `groupName` in response, `group` in request)."),
-  ownerEmail: z3.string().nullable().optional().describe("Owner email (note: `ownerEmail` in response, `owner_email` in request)."),
-  stack: z3.array(stackedGateEntrySchema).nullable().optional(),
-  updatedAt: z3.string().describe("ISO-8601 timestamp of last mutation.")
-});
-var gateCreateResponseSchema = z3.object({
-  id: z3.string().describe("Newly assigned gate id (`gat_\u2026`)."),
-  name: gateNameSchema
-});
-var gateUpdateResponseSchema = z3.object({ id: z3.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 = z3.object({ ok: z3.literal(true) });
-var gateToggleResponseSchema = z3.object({
-  id: z3.string(),
-  enabled: z3.boolean()
-});
-
-// src/resources/gates.ts
-var gateListResponseSchema = z4.object({
-  data: z4.array(gateResponseSchema),
-  next_cursor: z4.string().nullable()
-});
-var BASE = "/api/admin/gates";
-function gatesClient(t) {
-  async function list(opts = {}) {
-    const query = {};
-    if (opts.limit !== void 0) query.limit = String(opts.limit);
-    if (opts.cursor) query.cursor = opts.cursor;
-    return t.request("GET", BASE, void 0, query);
-  }
-  async function listAll() {
-    const out = [];
-    let cursor;
-    do {
-      const page = await list({ limit: 500, cursor });
-      out.push(...page.data);
-      cursor = page.next_cursor ?? void 0;
-    } while (cursor);
-    return out;
-  }
-  async function resolve(idOrName) {
-    const all = await listAll();
-    const found = all.find((g) => g.id === idOrName) ?? all.find((g) => g.name === idOrName);
-    if (!found) throw new ApiError(`Gate '${idOrName}' not found`, 404);
-    return found;
-  }
-  return {
-    list,
-    listAll,
-    resolve,
-    getByName: async (name) => {
-      const found = (await listAll()).find((g) => g.name === name);
-      if (!found) throw new ApiError(`Gate '${name}' not found`, 404);
-      return found;
-    },
-    create: (input) => t.request("POST", BASE, gateCreateSchema.parse(input)),
-    update: (id, input) => t.request("PATCH", `${BASE}/${id}`, gateUpdateSchema.parse(input)),
-    delete: (id) => t.request("DELETE", `${BASE}/${id}`),
-    enable: (id) => t.request("POST", `${BASE}/${id}/enable`),
-    disable: (id) => t.request("POST", `${BASE}/${id}/disable`),
-    setRollout: async (name, pct) => {
-      if (!Number.isFinite(pct) || pct < 0 || pct > 100) {
-        throw new ApiError("rollout must be a number between 0 and 100", 400);
-      }
-      const gate = await resolve(name);
-      return t.request("PATCH", `${BASE}/${gate.id}`, {
-        rollout_pct: Math.round(pct * 100)
-      });
-    }
-  };
-}
-var gatesResource = {
-  name: "gates",
-  basePath: BASE,
-  describeOne: "feature gate",
-  describeMany: "feature gates",
-  tag: {
-    name: "Gates",
-    description: [
-      "Feature gates: boolean flags evaluated at runtime against project rules + a percentage rollout.",
-      "",
-      "**Identity.** Each gate is keyed by a stable `name` (a-z, 0-9, `_`/`-`, max 64 chars) which is what SDKs pass to `Shipeasy.checkGate(user, '<name>')`. The `name` is immutable \u2014 rename means delete + recreate.",
-      "",
-      "**Evaluation model.** A gate returns `true` when (a) `enabled` is true, and (b) the caller satisfies the gate's rules. There are two evaluation shapes:",
-      "- **Flat** \u2014 `rules` (AND-combined predicates) gate the caller, then `rollout_pct` (basis points, 0\u201310000) hashes them into a bucket. Used for simple `is in X% rollout` gates.",
-      "- **Gatekeeper stack** \u2014 an ordered array of `condition` and `rollout` sub-gates, evaluated top-to-bottom; first match wins. Used to express `internal-only \u222A 1% beta \u222A 50% public` in one gate. When `stack` is present it takes precedence over the flat fields.",
-      "",
-      "**Rules.** Each rule is `{ attr, op, value }`. Supported ops: `eq`, `neq`, `in`, `not_in`, `gt`, `gte`, `lt`, `lte`, `contains`, `regex`. Attribute names match the keys on the SDK evaluation context (e.g. `country`, `plan`, `email`).",
-      "",
-      "**Rollout basis points.** `rollout_pct` is in **basis points**, not percent. `0` = 0%, `100` = 1%, `5000` = 50%, `10000` = 100%. This allows sub-1% precision (e.g. `7` = 0.07%).",
-      "",
-      "**Lifecycle.** Create dark (`rollout_pct: 0`) \u2192 attach rules \u2192 ramp via PATCH \u2192 flip kill-switch via `disable`/`enable` \u2192 delete once retired. Deletion is blocked while a running experiment references the gate as a targeting gate."
-    ].join("\n")
-  },
-  schemas: {
-    create: gateCreateSchema,
-    update: gateUpdateSchema
-  },
-  /** Custom action endpoints beyond CRUD (POST <basePath>/:id/<action>). */
-  actions: [
-    { name: "enable", description: "Enable a gate" },
-    { name: "disable", description: "Disable a gate" }
-  ],
-  /**
-   * Full operation list for the OpenAPI doc. Order here is the order shown in
-   * the docs sidebar. The typed client (`gatesClient`) is the runtime contract;
-   * this is the documented surface.
-   */
-  endpoints: [
-    {
-      operationId: "listGates",
-      method: "GET",
-      path: "",
-      summary: "List feature gates",
-      description: "Returns a single page of gates ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.",
-      response: gateListResponseSchema,
-      examples: {
-        response: {
-          data: [
-            {
-              id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc",
-              name: "checkout_v2",
-              enabled: 1,
-              rolloutPct: 5e3,
-              rules: [
-                { attr: "country", op: "in", value: ["US", "CA", "GB"] },
-                { attr: "plan", op: "neq", value: "free" }
-              ],
-              salt: "9c1f4f1f2c0c4a5fa1c2b6d3e7c8e3a1",
-              title: "Checkout v2",
-              description: "New checkout flow. Pro users in US/CA/GB only.",
-              folder: "checkout",
-              groupName: "growth",
-              ownerEmail: "ana@example.com",
-              stack: null,
-              updatedAt: "2026-05-09T16:01:22.000Z"
-            }
-          ],
-          next_cursor: null
-        }
-      },
-      useCase: "Snapshot every gate in the project \u2014 for example to render an admin overview or to drive a CI check that asserts no gate is left at 100% in staging."
-    },
-    {
-      operationId: "createGate",
-      method: "POST",
-      path: "",
-      summary: "Create a feature gate",
-      description: [
-        "Creates a new gate. Default `enabled: true` at the supplied `rollout_pct` (`0` = fully dark).",
-        "",
-        "Only `name` is required. Request fields use snake_case (`owner_email`); the GET response returns camelCase (`ownerEmail`, `groupName`).",
-        "",
-        "Returns `409` if `name` already exists in the project (case-sensitive)."
-      ].join("\n"),
-      successStatus: 201,
-      request: gateCreateSchema,
-      response: gateCreateResponseSchema,
-      examples: {
-        requestExamples: {
-          minimal: {
-            summary: "Minimal \u2014 dark gate, name only",
-            description: "Smallest valid body. The gate is created `enabled: true` at `rollout_pct: 0`, with no rules. Ramp it later via PATCH.",
-            value: { name: "checkout_v2" }
-          },
-          targeted: {
-            summary: "Targeted rollout \u2014 rules + percentage",
-            description: "Gate Pro users in US/CA/GB, then hash 10% of that audience into the on-bucket (`rollout_pct: 1000` = 10.00%). Adds dashboard metadata so the gate is self-documenting.",
-            value: {
-              name: "checkout_v2",
-              rollout_pct: 1e3,
-              rules: [
-                { attr: "country", op: "in", value: ["US", "CA", "GB"] },
-                { attr: "plan", op: "neq", value: "free" }
-              ],
-              title: "Checkout v2",
-              description: "New checkout flow. Pro users in US/CA/GB only.",
-              folder: "checkout",
-              group: "growth",
-              owner_email: "ana@example.com"
-            }
-          },
-          gatekeeperStack: {
-            summary: "Gatekeeper stack \u2014 internal \u222A beta \u222A public",
-            description: "Three-layer fall-through: employees always on, opted-in beta accounts always on, then 25% of everyone else. First match wins; evaluation stops as soon as one entry returns `true`.",
-            value: {
-              name: "checkout_v2",
-              title: "Checkout v2",
-              owner_email: "ana@example.com",
-              stack: [
-                {
-                  id: "01HKJ0EMP",
-                  type: "condition",
-                  name: "Employees",
-                  pass: "any",
-                  rules: [{ attr: "email", op: "regex", value: "@acme\\.com$" }]
-                },
-                {
-                  id: "01HKJ0BETA",
-                  type: "condition",
-                  name: "Beta opt-in",
-                  pass: "all",
-                  rules: [{ attr: "beta_opt_in", op: "eq", value: true }]
-                },
-                {
-                  id: "01HKJ0PUB",
-                  type: "rollout",
-                  name: "Public",
-                  rolloutPct: 2500,
-                  bucketBy: "userID",
-                  locked: true
-                }
-              ]
-            }
-          },
-          disabledOnCreate: {
-            summary: "Disabled on create \u2014 provision then enable later",
-            description: "Create with `enabled: false` so the gate evaluates to `false` for every caller until a follow-up `POST /{id}/enable`. Useful when provisioning ahead of a launch.",
-            value: { name: "checkout_v2", enabled: false, rollout_pct: 0 }
-          }
-        },
-        response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", name: "checkout_v2" }
-      },
-      useCase: [
-        '- **Dark create + ramp later** \u2014 `{ "name": "checkout_v2" }` at 0% rollout. Ramp via PATCH after deploy validation.',
-        "- **Targeted rollout** \u2014 supply `rules` to gate the caller (e.g. only `plan = pro` users) plus a `rollout_pct` to bucket within that audience.",
-        "- **Gatekeeper stack** \u2014 supply `stack` instead of `rules`/`rollout_pct` for `internal \u222A beta \u222A public` fall-through. Stack entries evaluated top-to-bottom; first match wins.",
-        "- **Dashboard metadata** \u2014 populate `title`, `description`, `folder`, `group`, `owner_email` so the admin UI is self-documenting from day one.",
-        "- **Disabled on create** \u2014 pre-provision with `enabled: false` for a future launch; flip on with `POST /{id}/enable` at go-live."
-      ].join("\n")
-    },
-    {
-      operationId: "updateGate",
-      method: "PATCH",
-      path: "/{id}",
-      summary: "Update a feature gate",
-      description: [
-        "Partial update \u2014 only supplied fields change. Array fields (`rules`, `stack`) **replace** wholesale; there is no merge or append.",
-        "",
-        "`name` and the gate id are immutable. The response carries only `{ id }` \u2014 re-fetch via `GET /api/admin/gates` for the new row."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque gate id (`gat_\u2026`)." },
-      request: gateUpdateSchema,
-      response: gateUpdateResponseSchema,
-      examples: {
-        requestExamples: {
-          rampRollout: {
-            summary: "Ramp rollout \u2014 0 \u2192 50%",
-            description: "Single-field patch. `5000` basis points = 50%.",
-            value: { rollout_pct: 5e3 }
-          },
-          killSwitch: {
-            summary: "Kill switch \u2014 disable the gate",
-            description: "Forces evaluation to `false` for every caller, regardless of rules or rollout. Same effect as `POST /{id}/disable` but composable with other patches.",
-            value: { enabled: false }
-          },
-          extendInRule: {
-            summary: "Add a value to an `in` rule",
-            description: "Array fields replace wholesale \u2014 there is no per-rule patch. To add `'AU'` to a country whitelist that previously held `['US','CA','GB']`, send the full new `rules` array. Same pattern applies to `not_in`.",
-            value: {
-              rules: [
-                { attr: "country", op: "in", value: ["US", "CA", "GB", "AU"] },
-                { attr: "plan", op: "neq", value: "free" }
-              ]
-            }
-          },
-          replaceStack: {
-            summary: "Replace gatekeeper stack",
-            description: 'Stack is replace-wholesale. Send the full new ordered list. Pass `"stack": null` to revert the gate to flat `rules` + `rollout_pct` evaluation.',
-            value: {
-              stack: [
-                {
-                  id: "01HKJ0EMP",
-                  type: "condition",
-                  name: "Employees",
-                  pass: "any",
-                  rules: [{ attr: "email", op: "regex", value: "@acme\\.com$" }]
-                },
-                {
-                  id: "01HKJ0PUB",
-                  type: "rollout",
-                  name: "Public",
-                  rolloutPct: 5e3,
-                  locked: true
-                }
-              ]
-            }
-          },
-          updateMetadata: {
-            summary: "Update dashboard metadata",
-            description: "Any subset of `title`, `description`, `folder`, `group`, `owner_email`. Snake-case in the request; the GET response returns camelCase (`groupName`, `ownerEmail`).",
-            value: {
-              title: "Checkout v2 (50%)",
-              description: "Bumped to 50% after passing canary. Added AU.",
-              folder: "checkout",
-              owner_email: "ana@example.com"
-            }
-          }
-        },
-        response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc" }
-      },
-      useCase: [
-        '- **Ramp rollout** \u2014 `{ "rollout_pct": 5000 }` for 50%. Basis points (0\u201310000); `100` = 1%.',
-        '- **Kill switch** \u2014 `{ "enabled": false }`. Forces evaluation to `false` for every caller regardless of rules/rollout. Re-enable with `POST /{id}/enable` or `{ "enabled": true }`.',
-        '- **Modify a rule\'s `in` set** \u2014 send the full new `rules` array. To add `\'GB\'` to `[\'US\',\'CA\']`: `{ "rules": [{ "attr": "country", "op": "in", "value": ["US","CA","GB"] }] }`. No per-rule patch endpoint.',
-        '- **Add targeting from scratch** \u2014 `{ "rules": [{ "attr": "email", "op": "regex", "value": "@acme\\\\.com$" }] }`.',
-        '- **Switch to gatekeeper stack** \u2014 send a non-null `stack`. To revert to flat eval, send `{ "stack": null }`.',
-        "- **Update metadata** \u2014 any subset of `title`, `description`, `folder`, `group`, `owner_email`."
-      ].join("\n")
-    },
-    {
-      operationId: "deleteGate",
-      method: "DELETE",
-      path: "/{id}",
-      summary: "Delete a feature gate",
-      description: "Soft-deletes the gate. Returns 409 if the gate is still referenced by a running experiment as a targeting gate \u2014 stop the experiment first.",
-      pathParams: { id: "Stable opaque gate id (`gat_\u2026`)." },
-      response: gateDeleteResponseSchema,
-      examples: { response: { ok: true } },
-      useCase: "Tear down a gate after a feature has fully shipped and the rollout flag is no longer needed."
-    },
-    {
-      operationId: "enableGate",
-      method: "POST",
-      path: "/{id}/enable",
-      summary: "Enable a gate",
-      description: "Sets `enabled: true`. The current `rollout_pct` is preserved.",
-      pathParams: { id: "Stable opaque gate id." },
-      response: gateToggleResponseSchema,
-      examples: { response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", enabled: true } },
-      useCase: "Re-enable a previously disabled gate without re-issuing a full update."
-    },
-    {
-      operationId: "disableGate",
-      method: "POST",
-      path: "/{id}/disable",
-      summary: "Disable a gate",
-      description: "Sets `enabled: false` so the gate evaluates to `false` for every caller, regardless of `rollout_pct` or `rules`. Use as a quick kill switch.",
-      pathParams: { id: "Stable opaque gate id." },
-      response: gateToggleResponseSchema,
-      examples: { response: { id: "gat_01j7w7m9q4hxbf6npe6s9zr3vc", enabled: false } },
-      useCase: "Flip a gate off in production without redeploying \u2014 the canonical kill-switch flow."
-    }
-  ]
-};
-
-// src/resources/experiments.ts
-import { z as z7 } from "zod";
-
-// src/schemas/experiments.ts
-import { z as z6 } from "zod";
-
-// src/schemas/metric-name.ts
-import { z as z5 } from "zod";
-var metricNameSchema = z5.string().regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?)?$/).max(128);
-
-// src/schemas/experiments.ts
-var experimentInlineMetricSchema = z6.object({
-  name: metricNameSchema.optional(),
-  query: z6.string().min(1).max(4096).describe("Metric DSL string, e.g. `count_users(checkout_completed)`.")
-});
-var experimentNameSchema = z6.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 = z6.object({
-  name: z6.string().min(1).max(64).describe("Group label (e.g. `control`, `treatment_a`). Max 64 chars."),
-  weight: z6.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: z6.record(z6.string(), z6.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 = z6.record(z6.string(), z6.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 bucketBySchema = z6.string().min(1).max(128).regex(
-  /^[a-zA-Z_][a-zA-Z0-9_]*$/,
-  "Must be a user-attribute name (letters, digits, underscore; not starting with a digit)."
-).describe(
-  "User-attribute name used as the bucketing key \u2014 e.g. `user_id` (default), `session_id`, `device_id`, or a custom attribute like `company_id` to keep a whole org on one variant. Defaults to `user_id` when omitted."
-);
-var experimentCreateSchema = z6.object({
-  name: experimentNameSchema,
-  description: z6.string().max(2e3).nullable().default(null).describe("Free-form description. Max 2000 chars, markdown rendered in the dashboard."),
-  hypothesis: z6.string().max(4e3).nullable().default(null).describe("Hypothesis statement shown in the editor. Display-only."),
-  tag: z6.string().max(64).nullable().default(null).describe("Short tag chip rendered next to the name. Display-only."),
-  owner_email: z6.string().max(254).nullable().default(null).describe("Owner email. Display-only."),
-  audience: z6.string().max(256).nullable().default(null).describe("Audience label shown in the editor. Display-only."),
-  bucket_by: bucketBySchema.nullable().default(null),
-  folder: folderSchema,
-  universe: z6.string().min(1).describe(
-    "Name of an existing universe in the project. Returns `422` if the universe doesn't exist."
-  ),
-  targeting_gate: z6.string().nullable().default(null).describe(
-    "Optional gate name. Only callers that pass the gate are enrolled in the experiment."
-  ),
-  allocation_pct: z6.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: z6.string().min(1).max(64).optional().describe("Hash salt for bucketing. Auto-generated if omitted. Immutable while running."),
-  params: paramSchemaSchema.default({}),
-  groups: z6.array(experimentGroupSchema).min(2).describe(
-    "Two or more variants. Weights must sum to exactly 10000 (100%). Immutable while running."
-  ),
-  significance_threshold: z6.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: z6.number().int().min(0).max(365).default(0).describe("Minimum days the experiment must run before results are considered conclusive."),
-  min_sample_size: z6.number().int().min(1).default(100).describe("Minimum exposures per group before results are considered conclusive."),
-  sequential_testing: z6.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: z6.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,
-  "groups weights must sum to exactly 10000"
-).describe(
-  "Body for `POST /api/admin/experiments`. `name`, `universe`, and `groups` (\u22652, weights sum to 10000) required."
-);
-var experimentUpdateSchema = z6.object({
-  name: experimentNameSchema.optional(),
-  description: z6.string().max(2e3).nullable().optional(),
-  hypothesis: z6.string().max(4e3).nullable().optional(),
-  tag: z6.string().max(64).nullable().optional(),
-  owner_email: z6.string().max(254).nullable().optional(),
-  audience: z6.string().max(256).nullable().optional(),
-  bucket_by: bucketBySchema.nullable().optional(),
-  folder: folderSchema,
-  targeting_gate: z6.string().nullable().optional(),
-  allocation_pct: z6.number().int().min(0).max(1e4).optional().describe("Basis-points allocation (0\u201310000). Immutable while the experiment is running."),
-  salt: z6.string().min(1).max(64).optional().describe("Hash salt. Immutable while running."),
-  universe: z6.string().optional().describe(
-    "New universe name. Immutable while running. Returns `422` if the universe doesn't exist."
-  ),
-  params: paramSchemaSchema.optional(),
-  groups: z6.array(experimentGroupSchema).min(2).optional().describe("Replacement groups. Weights must sum to 10000. Immutable while running."),
-  significance_threshold: z6.number().min(1e-4).max(0.5).optional(),
-  min_runtime_days: z6.number().int().min(0).max(365).optional(),
-  min_sample_size: z6.number().int().min(1).optional(),
-  sequential_testing: z6.boolean().optional(),
-  goal_metric: experimentInlineMetricSchema.optional().describe("Replaces the goal metric (event auto-upserted)."),
-  guardrail_metrics: z6.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 = z6.object({
-  status: z6.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 = z6.object({
-  metrics: z6.array(
-    z6.object({
-      metric_id: z6.string().describe("Existing metric id in the project."),
-      role: z6.enum(["goal", "guardrail", "secondary"]).describe(
-        "Metric role. `goal` drives the decision, `guardrail` blocks ship if degraded, `secondary` is informational."
-      )
-    })
-  ).describe("Replacement metrics list \u2014 replaces the current attachments wholesale.")
-}).describe(
-  "Body for `POST /api/admin/experiments/{id}/metrics`. Replaces the experiment's metric attachments wholesale. Returns `422` if any `metric_id` is unknown."
-);
-var experimentResponseSchema = z6.object({
-  id: z6.string().describe("Stable opaque experiment id (`exp_\u2026`)."),
-  name: experimentNameSchema,
-  description: z6.string().nullable(),
-  hypothesis: z6.string().nullable(),
-  tag: z6.string().nullable(),
-  ownerEmail: z6.string().nullable(),
-  audience: z6.string().nullable(),
-  bucketBy: bucketBySchema.nullable(),
-  folder: z6.string().nullable(),
-  status: z6.enum(["draft", "running", "stopped", "archived"]),
-  universe: z6.string().describe("Universe name this experiment draws from."),
-  targetingGate: z6.string().nullable(),
-  allocationPct: z6.number().int().describe("Allocation in basis points (0\u201310000)."),
-  salt: z6.string(),
-  params: z6.record(z6.string(), z6.enum(["string", "bool", "number"])),
-  groups: z6.array(experimentGroupSchema),
-  significanceThreshold: z6.number(),
-  minRuntimeDays: z6.number().int(),
-  minSampleSize: z6.number().int(),
-  sequentialTesting: z6.boolean(),
-  startedAt: z6.string().nullable().describe("ISO-8601 timestamp the experiment last transitioned to `running`, or `null`."),
-  stoppedAt: z6.string().nullable().optional(),
-  updatedAt: z6.string()
-});
-var experimentCreateResponseSchema = z6.object({
-  id: z6.string().describe("Newly assigned experiment id."),
-  name: experimentNameSchema
-});
-var experimentUpdateResponseSchema = z6.object({
-  id: z6.string().describe("Experiment id that was updated.")
-});
-var experimentDeleteResponseSchema = z6.object({ ok: z6.literal(true) });
-var experimentStatusResponseSchema = z6.object({
-  id: z6.string(),
-  status: z6.enum(["draft", "running", "stopped", "archived"])
-});
-var experimentMetricsResponseSchema = z6.object({
-  id: z6.string(),
-  metrics: z6.array(
-    z6.object({
-      metric_id: z6.string(),
-      role: z6.enum(["goal", "guardrail", "secondary"])
-    })
-  )
-});
-var experimentResultRowSchema = z6.object({
-  metric: z6.string(),
-  group_name: z6.string(),
-  ds: z6.string().describe("Date slice (`YYYY-MM-DD`)."),
-  n: z6.number().nullable(),
-  mean: z6.number().nullable(),
-  delta_pct: z6.number().nullable(),
-  p_value: z6.number().nullable(),
-  srm_detected: z6.number().nullable().describe("`1` if sample-ratio mismatch detected, else `0`.")
-});
-var experimentResultsResponseSchema = z6.object({
-  experiment: z6.object({
-    id: z6.string(),
-    name: experimentNameSchema,
-    status: z6.enum(["draft", "running", "stopped", "archived"])
-  }),
-  results: z6.array(experimentResultRowSchema)
-});
-var experimentTimeseriesResponseSchema = z6.object({
-  experiment: z6.object({
-    id: z6.string(),
-    name: experimentNameSchema,
-    status: z6.enum(["draft", "running", "stopped", "archived"])
-  }),
-  series: z6.array(experimentResultRowSchema)
-});
-var experimentReanalyzeResponseSchema = z6.object({
-  id: z6.string(),
-  queued: z6.literal(true)
-});
-
-// src/resources/experiments.ts
-var experimentListResponseSchema = z7.object({
-  data: z7.array(experimentResponseSchema),
-  next_cursor: z7.string().nullable()
-});
-var BASE2 = "/api/admin/experiments";
-function experimentsClient(t) {
-  async function list(opts = {}) {
-    const query = {};
-    if (opts.limit !== void 0) query.limit = String(opts.limit);
-    if (opts.cursor) query.cursor = opts.cursor;
-    return t.request("GET", BASE2, void 0, query);
-  }
-  async function listAllWith(status) {
-    const out = [];
-    let cursor;
-    do {
-      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 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;
-  }
-  async function setStatus(id, status) {
-    return t.request(
-      "POST",
-      `${BASE2}/${id}/status`,
-      experimentStatusUpdateSchema.parse({ status })
-    );
-  }
-  return {
-    list,
-    listAll,
-    resolve,
-    get: (id) => t.request("GET", `${BASE2}/${id}`),
-    create: (input) => t.request("POST", BASE2, experimentCreateSchema.parse(input)),
-    update: (id, input) => t.request("PATCH", `${BASE2}/${id}`, experimentUpdateSchema.parse(input)),
-    delete: (id) => t.request("DELETE", `${BASE2}/${id}`),
-    setStatus,
-    start: (id) => setStatus(id, "running"),
-    stop: (id) => setStatus(id, "stopped"),
-    archive: (id) => setStatus(id, "archived"),
-    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(
-      "GET",
-      `${BASE2}/${id}/timeseries`,
-      void 0,
-      metric ? { metric } : void 0
-    ),
-    reanalyze: (id) => t.request("POST", `${BASE2}/${id}/reanalyze`)
-  };
-}
-var SAMPLE_EXP = {
-  id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1",
-  name: "checkout_button_color",
-  description: "Test green vs. blue CTA on the checkout page.",
-  tag: "checkout",
-  status: "running",
-  universe: "primary_users",
-  targetingGate: null,
-  allocationPct: 5e3,
-  salt: "8d3e9a1f6b7c4a5fa1c2b6d3e7c8e3a1",
-  params: { cta_color: "string" },
-  groups: [
-    { name: "control", weight: 5e3, params: { cta_color: "blue" } },
-    { name: "treatment", weight: 5e3, params: { cta_color: "green" } }
-  ],
-  significanceThreshold: 0.05,
-  minRuntimeDays: 7,
-  minSampleSize: 1e3,
-  sequentialTesting: false,
-  startedAt: "2026-05-01T12:00:00.000Z",
-  stoppedAt: null,
-  updatedAt: "2026-05-09T18:22:11.000Z"
-};
-var experimentsResource = {
-  name: "experiments",
-  basePath: BASE2,
-  describeOne: "experiment",
-  describeMany: "experiments",
-  tag: {
-    name: "Experiments",
-    description: [
-      "A/B/n experiments: randomised group assignment plus the analysis pipeline (t-test, sequential testing, SRM detection) on top of a universe.",
-      "",
-      "**Identity.** Stable `name` (a-z, 0-9, `_`/`-`, max 64 chars). Immutable after create.",
-      "",
-      "**Lifecycle.** `draft \u2192 running \u2192 stopped \u2192 archived`. Transition via `POST /{id}/status`. 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.",
-      "",
-      "**Immutable while running.** `allocation_pct`, `groups`, `salt`, `universe`, `params` cannot be edited on a running experiment \u2014 stop it first.",
-      "",
-      "**Metrics.** Attach via `POST /{id}/metrics`. Each metric has a role: `goal` drives the decision, `guardrail` blocks ship on regression, `secondary` is informational.",
-      "",
-      "**Analysis.** Daily cron writes results to D1. Read via `GET /{id}/results` (latest per metric/group/day) or `GET /{id}/timeseries` (full history). `POST /{id}/reanalyze` requeues the analysis pass."
-    ].join("\n")
-  },
-  schemas: {
-    create: experimentCreateSchema,
-    update: experimentUpdateSchema
-  },
-  actions: [
-    { name: "start", description: "Transition draft experiment to running" },
-    { name: "stop", description: "Stop a running experiment" },
-    { name: "archive", description: "Archive a stopped experiment" },
-    { name: "restore", description: "Restore an archived (never-started) experiment to draft" },
-    { name: "reanalyze", description: "Re-run analysis pass for the experiment" }
-  ],
-  endpoints: [
-    {
-      operationId: "listExperiments",
-      method: "GET",
-      path: "",
-      summary: "List experiments",
-      description: "Returns a single page of non-archived experiments ordered by `updated_at desc, id desc`. Use the `cursor` query parameter to paginate.",
-      response: experimentListResponseSchema,
-      examples: { response: { data: [SAMPLE_EXP], next_cursor: null } },
-      useCase: "Snapshot every active experiment in the project \u2014 e.g. render an overview dashboard or drive a CI check that no experiment has been running past its `min_runtime_days`."
-    },
-    {
-      operationId: "getExperiment",
-      method: "GET",
-      path: "/{id}",
-      summary: "Get one experiment",
-      description: "Returns the full experiment row including groups, params, allocation, and lifecycle timestamps.",
-      pathParams: { id: "Stable opaque experiment id (`exp_\u2026`) or the experiment's `name`." },
-      response: experimentResponseSchema,
-      examples: { response: SAMPLE_EXP },
-      useCase: "Fetch one experiment to render the detail page or to inspect its current allocation and group weights."
-    },
-    {
-      operationId: "createExperiment",
-      method: "POST",
-      path: "",
-      summary: "Create an experiment",
-      description: [
-        "Creates a new experiment in `draft` status. `name`, `universe`, and `groups` are required; everything else has sensible defaults.",
-        "",
-        "Returns `409` if `name` already exists, `422` if the named universe doesn't exist, `403` if a plan-gated option is set (`sequential_testing`, custom `significance_threshold`) on a plan that doesn't include it."
-      ].join("\n"),
-      successStatus: 201,
-      request: experimentCreateSchema,
-      response: experimentCreateResponseSchema,
-      examples: {
-        requestExamples: {
-          minimal: {
-            summary: "Minimal \u2014 two-group 50/50",
-            description: "Smallest valid body. Two groups at 50/50, no allocation, no targeting.",
-            value: {
-              name: "checkout_button_color",
-              universe: "primary_users",
-              groups: [
-                { name: "control", weight: 5e3 },
-                { name: "treatment", weight: 5e3 }
-              ]
-            }
-          },
-          targeted: {
-            summary: "Targeted \u2014 gate + allocation + params",
-            description: "Gate the audience with a `targeting_gate`, allocate 50% of it, and parameterise the variants.",
-            value: {
-              name: "checkout_button_color",
-              description: "Green CTA on checkout for Pro users.",
-              universe: "primary_users",
-              targeting_gate: "pro_plan_only",
-              allocation_pct: 5e3,
-              params: { cta_color: "string" },
-              groups: [
-                { name: "control", weight: 5e3, params: { cta_color: "blue" } },
-                { name: "treatment", weight: 5e3, params: { cta_color: "green" } }
-              ]
-            }
-          },
-          multivariant: {
-            summary: "Multivariant \u2014 three groups",
-            description: "Three variants splitting 40/30/30. Requires the sum to equal 10000.",
-            value: {
-              name: "headline_test",
-              universe: "primary_users",
-              groups: [
-                { name: "control", weight: 4e3 },
-                { name: "alt_a", weight: 3e3 },
-                { name: "alt_b", weight: 3e3 }
-              ]
-            }
-          },
-          sequential: {
-            summary: "Sequential testing \u2014 Premium plan",
-            description: "Enable always-valid sequential tests. Requires Premium plan or higher.",
-            value: {
-              name: "checkout_button_color",
-              universe: "primary_users",
-              groups: [
-                { name: "control", weight: 5e3 },
-                { name: "treatment", weight: 5e3 }
-              ],
-              sequential_testing: true,
-              min_runtime_days: 14
-            }
-          }
-        },
-        response: { id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1", name: "checkout_button_color" }
-      },
-      useCase: [
-        "- **Minimal 50/50** \u2014 `name` + `universe` + two equal-weight groups.",
-        "- **Targeted rollout** \u2014 supply `targeting_gate` to restrict the eligible audience and `allocation_pct` to enrol a slice of it.",
-        "- **Multivariant** \u2014 three or more groups with weights summing to 10000.",
-        "- **Sequential testing** \u2014 `sequential_testing: true` for Premium plans."
-      ].join("\n")
-    },
-    {
-      operationId: "updateExperiment",
-      method: "PATCH",
-      path: "/{id}",
-      summary: "Update an experiment",
-      description: [
-        "Partial update. `allocation_pct`, `groups`, `salt`, `universe`, `params` are **immutable while running** \u2014 returns `409` if you try. Stop the experiment first.",
-        "",
-        "Editing `groups` while in `draft` is fine; weights must still sum to 10000."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque experiment id." },
-      request: experimentUpdateSchema,
-      response: experimentUpdateResponseSchema,
-      examples: {
-        requestExamples: {
-          rampAllocation: {
-            summary: "Ramp allocation \u2014 0 \u2192 50%",
-            description: "Bumps the share of the targeted audience enrolled. Allowed only when the experiment is in `draft`.",
-            value: { allocation_pct: 5e3 }
-          },
-          changeWeights: {
-            summary: "Change group weights",
-            description: "Replace the groups array \u2014 weights must still sum to 10000.",
-            value: {
-              groups: [
-                { name: "control", weight: 2500 },
-                { name: "treatment", weight: 7500 }
-              ]
-            }
-          },
-          tighterSignificance: {
-            summary: "Tighter significance threshold",
-            description: "Drop the p-value cutoff from 0.05 \u2192 0.01. Requires Pro plan or higher.",
-            value: { significance_threshold: 0.01 }
-          },
-          updateMetadata: {
-            summary: "Update metadata",
-            description: "Change description/tag/targeting_gate freely on running experiments.",
-            value: {
-              description: "Bumped to 50% after passing canary on 25%.",
-              tag: "checkout"
-            }
-          }
-        },
-        response: { id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1" }
-      },
-      useCase: [
-        "- **Update metadata** \u2014 `description`, `tag`, `targeting_gate` editable any time.",
-        "- **Ramp before launch** \u2014 set `allocation_pct` while still in `draft`.",
-        "- **Tighten significance** \u2014 `significance_threshold` (Pro+).",
-        "- **Rewire groups** \u2014 replace `groups` wholesale while in `draft`; immutable once running."
-      ].join("\n")
-    },
-    {
-      operationId: "deleteExperiment",
-      method: "DELETE",
-      path: "/{id}",
-      summary: "Delete an experiment",
-      description: "Archives the experiment (soft-delete via status transition). Returns `409` if the experiment is still `running` \u2014 stop it first.",
-      pathParams: { id: "Stable opaque experiment id." },
-      response: experimentDeleteResponseSchema,
-      examples: { response: { ok: true } },
-      useCase: "Tear down an experiment after the analysis is signed off."
-    },
-    {
-      operationId: "setExperimentStatus",
-      method: "POST",
-      path: "/{id}/status",
-      summary: "Transition experiment status",
-      description: [
-        "Drives the experiment lifecycle. Allowed transitions:",
-        "",
-        "- `draft \u2192 running` \u2014 starts allocation. Bumps the `startedAt` timestamp.",
-        "- `running \u2192 stopped` \u2014 halts allocation. Existing exposures stay in the dataset.",
-        "- `stopped \u2192 archived` \u2014 soft-delete.",
-        "- `draft \u2192 archived` \u2014 discard an unstarted experiment.",
-        "- `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 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,
-      response: experimentStatusResponseSchema,
-      examples: {
-        requestExamples: {
-          start: {
-            summary: "Start \u2014 draft \u2192 running",
-            description: "Begins allocation. The experiment counts against the plan's `experiments_running` limit.",
-            value: { status: "running" }
-          },
-          stop: {
-            summary: "Stop \u2014 running \u2192 stopped",
-            description: "Halts allocation. Existing exposures remain analysable.",
-            value: { status: "stopped" }
-          },
-          archive: {
-            summary: "Archive \u2014 stopped \u2192 archived",
-            description: "Soft-deletes the experiment. List endpoints exclude archived rows by default.",
-            value: { status: "archived" }
-          },
-          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" }
-      },
-      useCase: [
-        '- **Start** \u2014 `{ "status": "running" }` after wiring up the SDK and verifying targeting on staging.',
-        '- **Stop** \u2014 `{ "status": "stopped" }` once the experiment hits its `min_runtime_days` and conclusive results land.',
-        '- **Archive** \u2014 `{ "status": "archived" }` to soft-delete after sign-off.'
-      ].join("\n")
-    },
-    {
-      operationId: "setExperimentMetrics",
-      method: "POST",
-      path: "/{id}/metrics",
-      summary: "Attach metrics",
-      description: [
-        "Replaces the experiment's metric attachments wholesale. Each entry pairs an existing `metric_id` with a `role` (`goal` / `guardrail` / `secondary`).",
-        "",
-        "Returns `422` if any `metric_id` doesn't exist in the project. Pass `{ metrics: [] }` to detach everything."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque experiment id." },
-      request: experimentMetricsUpdateSchema,
-      response: experimentMetricsResponseSchema,
-      examples: {
-        requestExamples: {
-          standard: {
-            summary: "Standard \u2014 one goal + one guardrail",
-            description: "Attaches one decision metric and one safety metric.",
-            value: {
-              metrics: [
-                { metric_id: "met_checkout_completed", role: "goal" },
-                { metric_id: "met_page_errors", role: "guardrail" }
-              ]
-            }
-          },
-          detach: {
-            summary: "Detach all",
-            description: "Send an empty array to clear every metric.",
-            value: { metrics: [] }
-          }
-        },
-        response: {
-          id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1",
-          metrics: [
-            { metric_id: "met_checkout_completed", role: "goal" },
-            { metric_id: "met_page_errors", role: "guardrail" }
-          ]
-        }
-      },
-      useCase: [
-        "- **Standard setup** \u2014 one `goal`, one or two `guardrail`, optional `secondary` metrics for diagnostics.",
-        '- **Detach all** \u2014 send `{ "metrics": [] }` before archiving.'
-      ].join("\n")
-    },
-    {
-      operationId: "getExperimentResults",
-      method: "GET",
-      path: "/{id}/results",
-      summary: "Get analysis results",
-      description: "Returns the latest analysis output for the experiment \u2014 one row per metric/group/day, including sample size, mean, % delta vs. control, p-value, and a sample-ratio mismatch flag.",
-      pathParams: { id: "Stable opaque experiment id." },
-      response: experimentResultsResponseSchema,
-      examples: {
-        response: {
-          experiment: {
-            id: "exp_01j7wb12c3d4e5f6g7h8j9k0l1",
-            name: "checkout_button_color",
-            status: "running"
-          },
-          results: [
-            {
-              metric: "checkout_completed",
-              group_name: "control",
-              ds: "2026-05-09",
-              n: 12421,
-              mean: 0.1834,
-              delta_pct: null,
-              p_value: null,
-              srm_detected: 0
-            },
-            {
-              metric: "checkout_completed",
-              group_name: "treatment",
-              ds: "2026-05-09",
-              n: 12519,
-              mean: 0.1922,
-              delta_pct: 4.8,
-              p_value: 0.018,
-              srm_detected: 0
-            }
-          ]
-        }
-      },
-      useCase: "Render the results table on the experiment detail page or drive an automated decision once a `goal` metric reaches significance."
-    },
-    {
-      operationId: "getExperimentTimeseries",
-      method: "GET",
-      path: "/{id}/timeseries",
-      summary: "Get analysis timeseries",
-      description: "Same row shape as `/results`, but returns every daily slice rather than the latest. Filter to a single metric with the `metric` query parameter.",
-      pathParams: { id: "Stable opaque experiment id." },
-      queryParams: {
-        metric: {
-          schema: z7.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 z9 } from "zod";
-
-// src/schemas/configs.ts
-import { z as z8 } from "zod";
-
-// src/schemas/constants.ts
-var CONFIG_ENVS = ["dev", "staging", "prod"];
-var CONFIG_KINDS = ["config", "killswitch"];
-
-// src/schemas/configs.ts
-var SEGMENT = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/;
-var RESERVED_FOLDER = "_default";
-var configNameSchema = z8.string().max(128).refine(
-  (s) => {
-    const parts = s.split(".");
-    if (parts.length !== 2) return false;
-    return parts.every((p, i) => p === RESERVED_FOLDER && i === 0 ? true : SEGMENT.test(p));
-  },
-  {
-    message: "Must be `folder.name` \u2014 exactly two lowercase segments separated by a dot (e.g. `pricing.tiers`)."
-  }
-).describe(
-  "Stable config key in `folder.name` form (two lowercase segments separated by a dot, e.g. `pricing.tiers`). Used by SDKs as `Shipeasy.getConfig('<name>')`. Immutable after create."
-);
-var configKindSchema = z8.enum(CONFIG_KINDS);
-var configEnvSchema = z8.enum(CONFIG_ENVS).describe("Target environment. One of the project's configured envs (`dev`, `stage`, `prod`).");
-var jsonSchemaSchema = z8.record(z8.string(), z8.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 = z8.union([z8.unknown(), z8.record(configEnvSchema, z8.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 = z8.object({
-  name: configNameSchema,
-  description: z8.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 = z8.object({
-  schema: jsonSchemaSchema.optional().describe(
-    "Replacement schema. When supplied, the new schema is validated against every published value before it lands."
-  ),
-  value: z8.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 = z8.object({ schema: jsonSchemaSchema }).describe("Schema-only update. Does not bump value versions or rebuild KV.");
-var configDraftUpsertSchema = z8.object({
-  env: configEnvSchema,
-  value: z8.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 = z8.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 = z8.object({
-  version: z8.number().int().describe("Monotonically increasing version per env."),
-  publishedAt: z8.string().describe("ISO-8601 publish timestamp."),
-  publishedBy: z8.string().describe("Email/id of the actor who published this version.")
-});
-var configDraftSummarySchema = z8.object({
-  updatedAt: z8.string().describe("ISO-8601 last-edit timestamp on the draft."),
-  authorEmail: z8.string().describe("Email/id of the actor who last edited the draft."),
-  baseVersion: z8.number().int().describe("Published version the draft was forked from.")
-});
-var configResponseSchema = z8.object({
-  id: z8.string().describe("Stable opaque config id (`cfg_\u2026`)."),
-  name: configNameSchema,
-  description: z8.string().nullable(),
-  schema: jsonSchemaSchema,
-  updatedAt: z8.string().describe("ISO-8601 timestamp of last mutation."),
-  envs: z8.record(configEnvSchema, configEnvPublishedSchema).describe("Per-env latest published version metadata."),
-  drafts: z8.record(configEnvSchema, configDraftSummarySchema).describe("Per-env active drafts (if any)."),
-  values: z8.record(configEnvSchema, z8.unknown()).optional().describe("Per-env latest published values (only returned by `GET /{id}`, not list)."),
-  draftValues: z8.record(configEnvSchema, z8.unknown()).optional().describe("Per-env draft values (only returned by `GET /{id}`).")
-});
-var configCreateResponseSchema = z8.object({
-  id: z8.string().describe("Newly assigned config id."),
-  name: configNameSchema
-});
-var configUpdateResponseSchema = z8.object({
-  id: z8.string().describe("Config id that was updated.")
-});
-var configDeleteResponseSchema = z8.object({ ok: z8.literal(true) });
-var configDraftSaveResponseSchema = z8.object({
-  id: z8.string(),
-  env: configEnvSchema,
-  baseVersion: z8.number().int().describe("Published version the draft is based on."),
-  updatedAt: z8.string()
-});
-var configDraftDiscardResponseSchema = z8.object({ ok: z8.literal(true) });
-var configPublishResponseSchema = z8.object({
-  id: z8.string(),
-  env: configEnvSchema,
-  version: z8.number().int().describe("Newly published version on `env`.")
-});
-var configActivityEntrySchema = z8.object({
-  id: z8.string(),
-  action: z8.string().describe("Audit action (e.g. `config.create`, `config.publish`)."),
-  actorEmail: z8.string(),
-  actorType: z8.enum(["user", "cli", "system"]),
-  payload: z8.unknown().nullable(),
-  createdAt: z8.string().describe("ISO-8601 timestamp.")
-});
-var configActivityResponseSchema = z8.array(configActivityEntrySchema).describe("Recent audit rows for one config, newest first.");
-
-// src/resources/configs.ts
-var configListResponseSchema = z9.object({
-  data: z9.array(configResponseSchema),
-  next_cursor: z9.string().nullable()
-});
-var BASE3 = "/api/admin/configs";
-function configsClient(t) {
-  async function list(opts = {}) {
-    const query = {};
-    if (opts.limit !== void 0) query.limit = String(opts.limit);
-    if (opts.cursor) query.cursor = opts.cursor;
-    return t.request("GET", BASE3, void 0, query);
-  }
-  async function listAll() {
-    const out = [];
-    let cursor;
-    do {
-      const page = await list({ limit: 500, cursor });
-      out.push(...page.data);
-      cursor = page.next_cursor ?? void 0;
-    } while (cursor);
-    return out;
-  }
-  async function resolve(idOrName) {
-    try {
-      return await t.request("GET", `${BASE3}/${idOrName}`);
-    } catch (err) {
-      if (!(err instanceof ApiError) || err.status !== 404) throw err;
-    }
-    const all = await listAll();
-    const found = all.find((c) => c.name === idOrName);
-    if (!found) throw new ApiError(`Config '${idOrName}' not found`, 404);
-    return found;
-  }
-  return {
-    list,
-    listAll,
-    resolve,
-    get: (id) => t.request("GET", `${BASE3}/${id}`),
-    create: (input) => t.request("POST", BASE3, configCreateSchema.parse(input)),
-    update: (id, input) => t.request("PATCH", `${BASE3}/${id}`, configUpdateSchema.parse(input)),
-    delete: (id) => t.request("DELETE", `${BASE3}/${id}`),
-    saveDraft: (id, input) => t.request("PUT", `${BASE3}/${id}/drafts`, configDraftUpsertSchema.parse(input)),
-    discardDraft: (id, input) => t.request("DELETE", `${BASE3}/${id}/drafts`, configPublishSchema.parse(input)),
-    publish: (id, input) => t.request("POST", `${BASE3}/${id}/publish`, configPublishSchema.parse(input)),
-    activity: (id, limit) => t.request(
-      "GET",
-      `${BASE3}/${id}/activity`,
-      void 0,
-      limit ? { limit: String(limit) } : void 0
-    )
-  };
-}
-var SAMPLE_CFG = {
-  id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4",
-  name: "pricing.tiers",
-  description: "Pricing tier definitions consumed by the checkout flow.",
-  schema: {
-    type: "object",
-    properties: {
-      tiers: { type: "array", items: { type: "object" } }
-    },
-    required: ["tiers"]
-  },
-  updatedAt: "2026-05-09T18:22:11.000Z",
-  envs: {
-    dev: { version: 5, publishedAt: "2026-05-09T18:22:11.000Z", publishedBy: "ana@example.com" },
-    stage: { version: 4, publishedAt: "2026-05-08T11:05:22.000Z", publishedBy: "ana@example.com" },
-    prod: { version: 4, publishedAt: "2026-05-08T11:05:22.000Z", publishedBy: "ana@example.com" }
-  },
-  drafts: {
-    dev: {
-      updatedAt: "2026-05-10T09:31:00.000Z",
-      authorEmail: "bo@example.com",
-      baseVersion: 5
-    }
-  }
-};
-var configsResource = {
-  name: "configs",
-  basePath: BASE3,
-  describeOne: "config",
-  describeMany: "configs",
-  tag: {
-    name: "Configs",
-    description: [
-      "Dynamic configs: JSON-Schema-validated structured values delivered to SDKs and editable per environment with a draft/publish workflow.",
-      "",
-      "**Identity.** Each config is keyed by `name` in `folder.name` form (e.g. `pricing.tiers`). Immutable after create.",
-      "",
-      "**Schema-first.** Every config carries a JSON Schema (draft 2020-12, top-level `type: 'object'`). Every published value is validated against it.",
-      "",
-      "**Drafts \u2192 publish.** Per-env edits go through `PUT /{id}/drafts` (stages a value) then `POST /{id}/publish` (promotes to a new version). The flat `PATCH /{id}` republishes on **every** env in one shot \u2014 bypassing drafts.",
-      "",
-      "**Versioning.** Each publish bumps the per-env `version` monotonically. SDKs deliver the latest published version for each env."
-    ].join("\n")
-  },
-  schemas: {
-    create: configCreateSchema,
-    update: configUpdateSchema,
-    saveDraft: configDraftUpsertSchema,
-    publish: configPublishSchema
-  },
-  actions: [
-    { name: "publish", description: "Publish a config draft for an env" },
-    { name: "saveDraft", description: "Save a draft value for an env" },
-    { name: "discardDraft", description: "Discard a draft for an env" }
-  ],
-  endpoints: [
-    {
-      operationId: "listConfigs",
-      method: "GET",
-      path: "",
-      summary: "List dynamic configs",
-      description: "Returns a single page of configs ordered by `updated_at desc, id desc`. Each row includes the latest published `version` per env and any active drafts.",
-      response: configListResponseSchema,
-      examples: { response: { data: [SAMPLE_CFG], next_cursor: null } },
-      useCase: "Snapshot every config in the project \u2014 e.g. CI check that asserts no env is stuck on a stale default or that every config has a published value on prod."
-    },
-    {
-      operationId: "getConfig",
-      method: "GET",
-      path: "/{id}",
-      summary: "Get one config",
-      description: "Returns config metadata plus the latest published values per env and any active draft values. Use this to fetch the JSON the editor renders.",
-      pathParams: { id: "Stable opaque config id (`cfg_\u2026`) or the config's `name`." },
-      response: configResponseSchema,
-      examples: {
-        response: {
-          ...SAMPLE_CFG,
-          values: {
-            dev: { tiers: [{ name: "free" }, { name: "pro" }] },
-            stage: { tiers: [{ name: "free" }, { name: "pro" }] },
-            prod: { tiers: [{ name: "free" }, { name: "pro" }] }
-          },
-          draftValues: {
-            dev: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] }
-          }
-        }
-      },
-      useCase: "Fetch one config's current published values and any in-flight drafts."
-    },
-    {
-      operationId: "createConfig",
-      method: "POST",
-      path: "",
-      summary: "Create a dynamic config",
-      description: [
-        "Creates a new config with the given `schema`. The initial `value` (or an empty object) is published as version 1 on **every** env.",
-        "",
-        "Returns `409` if `name` already exists in the project, `400` if `value` doesn't validate against `schema`."
-      ].join("\n"),
-      successStatus: 201,
-      request: configCreateSchema,
-      response: configCreateResponseSchema,
-      examples: {
-        requestExamples: {
-          minimal: {
-            summary: "Minimal \u2014 name + schema",
-            description: "Smallest valid body. Initial value defaults to `{}` on every env.",
-            value: {
-              name: "pricing.tiers",
-              schema: {
-                type: "object",
-                properties: { tiers: { type: "array" } },
-                required: ["tiers"]
-              }
-            }
-          },
-          seededValue: {
-            summary: "Seeded \u2014 schema + initial value",
-            description: "Seed the same JSON object on every env at version 1.",
-            value: {
-              name: "pricing.tiers",
-              description: "Pricing tier definitions consumed by checkout.",
-              schema: {
-                type: "object",
-                properties: { tiers: { type: "array" } },
-                required: ["tiers"]
-              },
-              value: { tiers: [{ name: "free" }, { name: "pro" }] }
-            }
-          },
-          perEnvSeed: {
-            summary: "Per-env seed",
-            description: "Pass a `{ env: value }` map to seed different initial values per env.",
-            value: {
-              name: "pricing.tiers",
-              schema: {
-                type: "object",
-                properties: { tiers: { type: "array" } },
-                required: ["tiers"]
-              },
-              value: {
-                dev: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] },
-                stage: { tiers: [{ name: "free" }, { name: "pro" }] },
-                prod: { tiers: [{ name: "free" }, { name: "pro" }] }
-              }
-            }
-          }
-        },
-        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4", name: "pricing.tiers" }
-      },
-      useCase: [
-        "- **Minimal create** \u2014 `name` + `schema`. Initial value defaults to `{}`.",
-        "- **Seeded create** \u2014 supply a flat `value` to publish the same object on every env.",
-        "- **Per-env seed** \u2014 supply a `{ env: value }` map for different per-env starting values."
-      ].join("\n")
-    },
-    {
-      operationId: "updateConfig",
-      method: "PATCH",
-      path: "/{id}",
-      summary: "Update a dynamic config",
-      description: [
-        "Partial update. When `value` is supplied it is **republished on every env** (new version per env). When `schema` is supplied it replaces the current schema; every existing value is re-validated.",
-        "",
-        "For env-scoped edits, use the draft/publish flow (`PUT /{id}/drafts` then `POST /{id}/publish`) instead."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque config id." },
-      request: configUpdateSchema,
-      response: configUpdateResponseSchema,
-      examples: {
-        requestExamples: {
-          flatValue: {
-            summary: "Flat value \u2014 republish on every env",
-            description: "Sets the same JSON object as a new version on dev/stage/prod.",
-            value: { value: { tiers: [{ name: "free" }, { name: "pro" }] } }
-          },
-          schemaOnly: {
-            summary: "Schema-only update",
-            description: "Replaces the schema. Existing values must still validate or the update fails.",
-            value: {
-              schema: {
-                type: "object",
-                properties: {
-                  tiers: { type: "array" },
-                  trial_days: { type: "integer" }
-                },
-                required: ["tiers"]
-              }
-            }
-          }
-        },
-        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4" }
-      },
-      useCase: [
-        '- **Republish flat value** \u2014 `{ "value": {\u2026} }` sets the same value on every env.',
-        '- **Schema migration** \u2014 `{ "schema": {\u2026} }` replaces the schema; existing values are re-validated.',
-        "- **Env-scoped edits** \u2014 use `PUT /{id}/drafts` + `POST /{id}/publish` instead of PATCH."
-      ].join("\n")
-    },
-    {
-      operationId: "deleteConfig",
-      method: "DELETE",
-      path: "/{id}",
-      summary: "Delete a dynamic config",
-      description: "Soft-deletes the config and rebuilds the project's flags KV blob.",
-      pathParams: { id: "Stable opaque config id." },
-      response: configDeleteResponseSchema,
-      examples: { response: { ok: true } },
-      useCase: "Tear down a config after its consumers have stopped reading it."
-    },
-    {
-      operationId: "saveConfigDraft",
-      method: "PUT",
-      path: "/{id}/drafts",
-      summary: "Save a draft value",
-      description: [
-        "Stages a value for one env without publishing. The draft is validated against the config's current schema and stored alongside the `baseVersion` it was forked from.",
-        "",
-        "Saving over an existing draft overwrites it. Use `POST /{id}/publish` to promote it to a new published version."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque config id." },
-      request: configDraftUpsertSchema,
-      response: configDraftSaveResponseSchema,
-      examples: {
-        requestExamples: {
-          stageDev: {
-            summary: "Stage a dev draft",
-            description: "Stages a new value on dev without touching stage/prod.",
-            value: {
-              env: "dev",
-              value: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] }
-            }
-          }
-        },
-        response: {
-          id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4",
-          env: "dev",
-          baseVersion: 5,
-          updatedAt: "2026-05-10T09:31:00.000Z"
-        }
-      },
-      useCase: "Iterate on a config value on dev without affecting prod \u2014 preview in staging, then publish."
-    },
-    {
-      operationId: "discardConfigDraft",
-      method: "DELETE",
-      path: "/{id}/drafts",
-      summary: "Discard a draft",
-      description: "Drops the in-flight draft on one env. Published values are unaffected.",
-      pathParams: { id: "Stable opaque config id." },
-      request: configPublishSchema,
-      response: configDraftDiscardResponseSchema,
-      examples: {
-        requestExamples: {
-          discardDev: {
-            summary: "Discard the dev draft",
-            description: "Drops the staged dev draft without publishing.",
-            value: { env: "dev" }
-          }
-        },
-        response: { ok: true }
-      },
-      useCase: "Abandon an in-progress draft after deciding not to ship it."
-    },
-    {
-      operationId: "publishConfigDraft",
-      method: "POST",
-      path: "/{id}/publish",
-      summary: "Publish a draft",
-      description: [
-        "Promotes the staged draft on one env to a new published version. The draft must still validate against the current schema.",
-        "",
-        "Returns `404` if there is no draft for the given env."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque config id." },
-      request: configPublishSchema,
-      response: configPublishResponseSchema,
-      examples: {
-        requestExamples: {
-          publishDev: {
-            summary: "Publish the dev draft",
-            description: "Promotes the dev draft to a new published version on dev.",
-            value: { env: "dev" }
-          },
-          publishProd: {
-            summary: "Publish to prod",
-            description: "Promotes the prod draft after staging signed off.",
-            value: { env: "prod" }
-          }
-        },
-        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4", env: "dev", version: 6 }
-      },
-      useCase: "Ship a staged change once you've validated it on a lower env."
-    },
-    {
-      operationId: "listConfigActivity",
-      method: "GET",
-      path: "/{id}/activity",
-      summary: "List config activity",
-      description: "Returns recent audit rows for one config (create, update, draft.save, publish, delete) ordered newest first. Use the `limit` query parameter to cap the result (1\u2013100, default 20).",
-      pathParams: { id: "Stable opaque config id." },
-      queryParams: {
-        limit: {
-          schema: z9.coerce.number().int().min(1).max(100).default(20),
-          description: "Max rows to return (1\u2013100). Defaults to 20."
-        }
-      },
-      response: configActivityResponseSchema,
-      examples: {
-        response: [
-          {
-            id: "act_01j7waf01a2b3c4d5e6f7g8h9i",
-            action: "config.publish",
-            actorEmail: "ana@example.com",
-            actorType: "user",
-            payload: { env: "dev", version: 6 },
-            createdAt: "2026-05-10T09:31:42.000Z"
-          }
-        ]
-      },
-      useCase: "Render the activity panel in the config editor or drive a slack notification on publish events."
-    }
-  ]
-};
-
-// src/resources/universes.ts
-import { z as z11 } from "zod";
-
-// src/schemas/universes.ts
-import { z as z10 } from "zod";
-var universeNameSchema = z10.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 = z10.tuple([z10.number().int().min(0).max(9999), z10.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 = z10.object({
-  name: universeNameSchema,
-  folder: folderSchema,
-  unit_type: z10.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 = z10.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 = z10.object({
-  id: z10.string().describe("Stable opaque universe id."),
-  name: universeNameSchema,
-  unitType: z10.string().describe("Unit of randomisation. Snake-case in request (`unit_type`), camelCase in response."),
-  holdoutRange: z10.tuple([z10.number(), z10.number()]).nullable().describe("Reserved holdout bucket range, or `null` if none."),
-  createdAt: z10.string().describe("ISO-8601 timestamp of creation.")
-});
-var universeCreateResponseSchema = z10.object({
-  id: z10.string().describe("Newly assigned universe id."),
-  name: universeNameSchema
-});
-var universeUpdateResponseSchema = z10.object({
-  id: z10.string().describe("Universe id that was updated.")
-});
-var universeDeleteResponseSchema = z10.object({ ok: z10.literal(true) });
-
-// src/resources/universes.ts
-var universeListResponseSchema = z11.object({
-  data: z11.array(universeResponseSchema),
-  next_cursor: z11.string().nullable()
-});
-var BASE4 = "/api/admin/universes";
-function universesClient(t) {
-  async function list(opts = {}) {
-    const query = {};
-    if (opts.limit !== void 0) query.limit = String(opts.limit);
-    if (opts.cursor) query.cursor = opts.cursor;
-    return t.request("GET", BASE4, void 0, query);
-  }
-  async function listAll() {
-    const out = [];
-    let cursor;
-    do {
-      const page = await list({ limit: 500, cursor });
-      out.push(...page.data);
-      cursor = page.next_cursor ?? void 0;
-    } while (cursor);
-    return out;
-  }
-  async function resolve(idOrName) {
-    const all = await listAll();
-    const found = all.find((u) => u.id === idOrName) ?? all.find((u) => u.name === idOrName);
-    if (!found) throw new ApiError(`Universe '${idOrName}' not found`, 404);
-    return found;
-  }
-  return {
-    list,
-    listAll,
-    resolve,
-    create: (input) => t.request("POST", BASE4, universeCreateSchema.parse(input)),
-    update: (id, input) => t.request("PATCH", `${BASE4}/${id}`, universeUpdateSchema.parse(input)),
-    delete: (id) => t.request("DELETE", `${BASE4}/${id}`)
-  };
-}
-var universesResource = {
-  name: "universes",
-  basePath: BASE4,
-  describeOne: "universe",
-  describeMany: "universes",
-  tag: {
-    name: "Universes",
-    description: [
-      "Universes: the shared bucketing space all experiments draw from.",
-      "",
-      "**Identity.** Each universe is keyed by a stable `name` (a-z, 0-9, `_`/`-`, max 64 chars). Experiments reference it via `universe: '<name>'`. The name is immutable.",
-      "",
-      "**Unit of randomisation.** `unit_type` selects the attribute hashed into a 0\u20139999 bucket \u2014 default `user_id` for per-user randomisation, `account_id` to keep a whole account in the same group.",
-      "",
-      "**Holdout.** `holdout_range` is an inclusive `[lo, hi]` bucket range (0\u20139999) reserved for measurement \u2014 callers hashed into the holdout are excluded from every experiment in the universe. Pro plan or higher.",
-      "",
-      "**Deletion.** Blocked while any non-archived experiment references the universe \u2014 archive those first."
-    ].join("\n")
-  },
-  schemas: {
-    create: universeCreateSchema,
-    update: universeUpdateSchema
-  },
-  actions: [],
-  endpoints: [
-    {
-      operationId: "listUniverses",
-      method: "GET",
-      path: "",
-      summary: "List universes",
-      description: "Returns a single page of universes ordered by `created_at desc, id desc`. The universes table has no `updated_at`, so this list is keyed on creation time.",
-      response: universeListResponseSchema,
-      examples: {
-        response: {
-          data: [
-            {
-              id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0",
-              name: "primary_users",
-              unitType: "user_id",
-              holdoutRange: [9500, 9999],
-              createdAt: "2026-04-12T10:14:08.000Z"
-            }
-          ],
-          next_cursor: null
-        }
-      },
-      useCase: "Snapshot every universe in the project \u2014 for example to audit which `unit_type` and `holdout_range` are in use before launching a new experiment."
-    },
-    {
-      operationId: "createUniverse",
-      method: "POST",
-      path: "",
-      summary: "Create a universe",
-      description: [
-        "Creates a new universe. Only `name` is required \u2014 `unit_type` defaults to `user_id` and `holdout_range` defaults to `null` (no holdout).",
-        "",
-        "Returns `409` if `name` already exists in the project. Returns `403` if you supply `holdout_range` on a plan below Pro."
-      ].join("\n"),
-      successStatus: 201,
-      request: universeCreateSchema,
-      response: universeCreateResponseSchema,
-      examples: {
-        requestExamples: {
-          minimal: {
-            summary: "Minimal \u2014 name only",
-            description: "Smallest valid body. Creates a `user_id`-keyed universe with no holdout.",
-            value: { name: "primary_users" }
-          },
-          holdout: {
-            summary: "Holdout \u2014 reserve 5% for measurement",
-            description: "Reserves buckets 9500\u20139999 (5% of callers) as the holdout. Pro plan or higher.",
-            value: { name: "primary_users", holdout_range: [9500, 9999] }
-          },
-          accountLevel: {
-            summary: "Account-level randomisation",
-            description: "Bucket whole accounts together via `unit_type: 'account_id'`.",
-            value: { name: "saas_accounts", unit_type: "account_id" }
-          }
-        },
-        response: { id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0", name: "primary_users" }
-      },
-      useCase: [
-        '- **Default universe** \u2014 `{ "name": "primary_users" }`. Per-user randomisation, no holdout.',
-        "- **Reserved holdout** \u2014 supply `holdout_range` to carve out a measurement slice excluded from all experiments.",
-        "- **Account-level** \u2014 `unit_type: 'account_id'` so multi-seat accounts see one consistent variant."
-      ].join("\n")
-    },
-    {
-      operationId: "updateUniverse",
-      method: "PATCH",
-      path: "/{id}",
-      summary: "Update a universe",
-      description: [
-        "Partial update. Only `holdout_range` is mutable \u2014 `name` and `unit_type` are immutable after create.",
-        "",
-        'Pass `"holdout_range": null` to remove an existing holdout.'
-      ].join("\n"),
-      pathParams: { id: "Stable opaque universe id (`uni_\u2026`)." },
-      request: universeUpdateSchema,
-      response: universeUpdateResponseSchema,
-      examples: {
-        requestExamples: {
-          setHoldout: {
-            summary: "Set holdout \u2014 reserve 5%",
-            description: "Reserve buckets 9500\u20139999 as the holdout. Pro plan or higher.",
-            value: { holdout_range: [9500, 9999] }
-          },
-          removeHoldout: {
-            summary: "Remove holdout",
-            description: "Disable the holdout entirely.",
-            value: { holdout_range: null }
-          }
-        },
-        response: { id: "uni_01j7w8a1b2c3d4e5f6g7h8i9j0" }
-      },
-      useCase: [
-        "- **Adjust holdout** \u2014 change the reserved measurement slice without recreating experiments.",
-        '- **Remove holdout** \u2014 `{ "holdout_range": null }`.'
-      ].join("\n")
-    },
-    {
-      operationId: "deleteUniverse",
-      method: "DELETE",
-      path: "/{id}",
-      summary: "Delete a universe",
-      description: "Soft-deletes the universe. Returns `409` if any non-archived experiment still references it \u2014 archive those experiments first.",
-      pathParams: { id: "Stable opaque universe id." },
-      response: universeDeleteResponseSchema,
-      examples: { response: { ok: true } },
-      useCase: "Tear down a universe after every experiment that used it has been archived."
-    }
-  ]
-};
-
-// src/resources/killswitches.ts
-import { z as z13 } from "zod";
-
-// src/schemas/killswitches.ts
-import { z as z12 } from "zod";
-var SWITCH_KEY_RE = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/;
-var switchKeySchema = z12.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 = z12.object({
-  value: z12.boolean().describe(
-    "Default boolean delivered when no `switches` entry matches the caller's switch key."
-  ),
-  switches: z12.record(switchKeySchema, z12.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 = z12.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: z12.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
-  folder: folderSchema,
-  value: z12.boolean().optional().describe(
-    "Default value applied to every env at creation. Defaults to `false`. Use `true` to ship the killswitch pre-tripped."
-  ),
-  switches: z12.record(switchKeySchema, z12.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 = z12.object({
-  description: z12.string().max(512).nullish().describe("New description, or `null` to clear it. Max 512 chars."),
-  folder: folderSchema,
-  value: z12.boolean().optional().describe(
-    "Flat value applied to every env. Publishes a new version per env when set. Omit to leave values unchanged."
-  ),
-  switches: z12.record(switchKeySchema, z12.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 = z12.object({
-  env: configEnvSchema.describe("Target environment (`dev`/`stage`/`prod`)."),
-  switchKey: switchKeySchema.describe("Switch key to set."),
-  value: z12.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 killswitchValueSetSchema = z12.object({
-  env: configEnvSchema.describe("Target environment whose flat default flips."),
-  value: z12.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 = z12.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 = z12.object({
-  value: z12.boolean().describe("Flat boolean published for this env."),
-  switches: z12.record(switchKeySchema, z12.boolean()).optional(),
-  version: z12.number().int().describe("Monotonically increasing version per env."),
-  publishedAt: z12.string().describe("ISO-8601 publish timestamp for this version.")
-});
-var killswitchResponseSchema = z12.object({
-  id: z12.string().describe("Stable opaque killswitch id."),
-  name: configNameSchema,
-  description: z12.string().nullable().describe("Free-form description or `null`."),
-  updatedAt: z12.string().describe("ISO-8601 timestamp of last mutation."),
-  envs: z12.record(configEnvSchema, killswitchEnvEntrySchema).describe("Per-env latest value, switches, version, and publish timestamp.")
-});
-var killswitchCreateResponseSchema = z12.object({
-  id: z12.string().describe("Newly assigned killswitch id."),
-  name: configNameSchema
-});
-var killswitchUpdateResponseSchema = z12.object({
-  id: z12.string().describe("Killswitch id that was updated.")
-});
-var killswitchDeleteResponseSchema = z12.object({ ok: z12.literal(true) });
-var killswitchSwitchSetResponseSchema = z12.object({
-  id: z12.string(),
-  env: configEnvSchema,
-  switchKey: switchKeySchema,
-  value: z12.boolean()
-});
-var killswitchSwitchUnsetResponseSchema = z12.object({
-  id: z12.string(),
-  env: configEnvSchema,
-  switchKey: switchKeySchema,
-  removed: z12.boolean().describe("`true` if the entry existed and was removed, `false` if no-op.")
-});
-
-// src/resources/killswitches.ts
-var killswitchListResponseSchema = z13.object({
-  data: z13.array(killswitchResponseSchema),
-  next_cursor: z13.string().nullable()
-});
-var BASE5 = "/api/admin/killswitches";
-function killswitchesClient(t) {
-  async function list(opts = {}) {
-    const query = {};
-    if (opts.limit !== void 0) query.limit = String(opts.limit);
-    if (opts.cursor) query.cursor = opts.cursor;
-    return t.request("GET", BASE5, void 0, query);
-  }
-  async function listAll() {
-    const out = [];
-    let cursor;
-    do {
-      const page = await list({ limit: 500, cursor });
-      out.push(...page.data);
-      cursor = page.next_cursor ?? void 0;
-    } while (cursor);
-    return out;
-  }
-  async function resolve(idOrName) {
-    try {
-      return await t.request("GET", `${BASE5}/${idOrName}`);
-    } catch (err) {
-      if (!(err instanceof ApiError) || err.status !== 404) throw err;
-    }
-    const all = await listAll();
-    const found = all.find((k) => k.name === idOrName);
-    if (!found) throw new ApiError(`Killswitch '${idOrName}' not found`, 404);
-    return found;
-  }
-  return {
-    list,
-    listAll,
-    resolve,
-    get: (id) => t.request("GET", `${BASE5}/${id}`),
-    create: (input) => t.request("POST", BASE5, killswitchCreateSchema.parse(input)),
-    update: (id, input) => t.request("PATCH", `${BASE5}/${id}`, killswitchUpdateSchema.parse(input)),
-    delete: (id) => t.request("DELETE", `${BASE5}/${id}`),
-    setSwitch: (id, input) => t.request("PUT", `${BASE5}/${id}/switch`, killswitchSwitchSetSchema.parse(input)),
-    unsetSwitch: (id, input) => t.request("DELETE", `${BASE5}/${id}/switch`, killswitchSwitchUnsetSchema.parse(input))
-  };
-}
-var SAMPLE_KS = {
-  id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8",
-  name: "payments.checkout",
-  description: "Master kill for the checkout flow. Trip to fall back to the legacy provider.",
-  updatedAt: "2026-05-09T18:22:11.000Z",
-  envs: {
-    dev: { value: false, version: 3, publishedAt: "2026-05-09T18:22:11.000Z" },
-    stage: { value: false, version: 3, publishedAt: "2026-05-09T18:22:11.000Z" },
-    prod: {
-      value: false,
-      switches: { eu_region: true },
-      version: 5,
-      publishedAt: "2026-05-09T18:22:11.000Z"
-    }
-  }
-};
-var killswitchesResource = {
-  name: "killswitches",
-  basePath: BASE5,
-  describeOne: "killswitch",
-  describeMany: "killswitches",
-  tag: {
-    name: "Killswitches",
-    description: [
-      "Killswitches: per-env boolean overrides for kill-style operational toggles. Optimised for incident response \u2014 no rules, no rollout, just a flat boolean (plus optional per-key overrides) versioned per environment.",
-      "",
-      "**Identity.** Each killswitch is keyed by `name` in `folder.name` form (e.g. `payments.checkout`). Immutable after create.",
-      "",
-      "**Per-env values.** Every killswitch stores one version stream per env (`dev`, `stage`, `prod`). A `PATCH` with `value`/`switches` applies to **every** env in one shot (publishes a new version per env). To touch a single env, use `PUT /{id}/switch` and friends.",
-      "",
-      "**Switches map.** Optional `switches: { key: bool }` overrides the flat `value` for specific named call sites \u2014 useful for region/feature-scoped kills.",
-      "",
-      "**Versioning.** Each publish (create, update, set-switch, unset-switch) bumps the per-env `version` monotonically. SDKs deliver the latest published version."
-    ].join("\n")
-  },
-  schemas: {
-    create: killswitchCreateSchema,
-    update: killswitchUpdateSchema,
-    setSwitch: killswitchSwitchSetSchema,
-    unsetSwitch: killswitchSwitchUnsetSchema
-  },
-  actions: [
-    { name: "setSwitch", description: "Set or update one switch entry on one env" },
-    { name: "unsetSwitch", description: "Remove one switch entry from one env" }
-  ],
-  endpoints: [
-    {
-      operationId: "listKillswitches",
-      method: "GET",
-      path: "",
-      summary: "List killswitches",
-      description: "Returns a single page of killswitches ordered by `updated_at desc, id desc`. Each row includes the latest published `value`/`switches`/`version` per env.",
-      response: killswitchListResponseSchema,
-      examples: { response: { data: [SAMPLE_KS], next_cursor: null } },
-      useCase: "Snapshot every killswitch in the project \u2014 e.g. to render an incident-response runbook listing every kill and its current trip state."
-    },
-    {
-      operationId: "getKillswitch",
-      method: "GET",
-      path: "/{id}",
-      summary: "Get one killswitch",
-      description: "Returns the killswitch metadata plus the latest published `value`/`switches`/`version` per env.",
-      pathParams: { id: "Stable opaque killswitch id (`ksw_\u2026`)." },
-      response: killswitchResponseSchema,
-      examples: { response: SAMPLE_KS },
-      useCase: "Fetch the current state of one killswitch \u2014 e.g. to verify a trip propagated before declaring an incident mitigated."
-    },
-    {
-      operationId: "createKillswitch",
-      method: "POST",
-      path: "",
-      summary: "Create a killswitch",
-      description: [
-        "Creates a new killswitch with `value` (default `false`) applied to **every** env at version 1.",
-        "",
-        "Returns `409` if `name` already exists in the project."
-      ].join("\n"),
-      successStatus: 201,
-      request: killswitchCreateSchema,
-      response: killswitchCreateResponseSchema,
-      examples: {
-        requestExamples: {
-          minimal: {
-            summary: "Minimal \u2014 name only, untripped",
-            description: "Smallest valid body. Creates a killswitch with `value: false` on every env.",
-            value: { name: "payments.checkout" }
-          },
-          preTripped: {
-            summary: "Pre-tripped on create",
-            description: "Ship the killswitch already tripped (`value: true`) \u2014 useful when provisioning a kill ahead of a deploy you want to ship with the feature off.",
-            value: {
-              name: "payments.checkout",
-              description: "Master kill for the new checkout flow.",
-              value: true
-            }
-          },
-          withSwitches: {
-            summary: "With per-region switches",
-            description: "Seed a `switches` map so specific named call sites can be tripped independently of the flat `value`.",
-            value: {
-              name: "payments.checkout",
-              value: false,
-              switches: { eu_region: true, apac_region: false }
-            }
-          }
-        },
-        response: { id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8", name: "payments.checkout" }
-      },
-      useCase: [
-        '- **Untripped create** \u2014 `{ "name": "payments.checkout" }`. Provision the kill ahead of an incident.',
-        '- **Pre-tripped** \u2014 `{ "value": true }` to ship the killswitch already engaged.',
-        "- **With switches** \u2014 seed `switches` to carve out per-region/per-tenant kills from day one."
-      ].join("\n")
-    },
-    {
-      operationId: "updateKillswitch",
-      method: "PATCH",
-      path: "/{id}",
-      summary: "Update a killswitch",
-      description: [
-        "Partial update applied to **every** env. Setting `value`/`switches` publishes a new version per env. Description-only patches don't bump versions.",
-        "",
-        "To change a single switch on a single env, use `PUT /{id}/switch` instead."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque killswitch id." },
-      request: killswitchUpdateSchema,
-      response: killswitchUpdateResponseSchema,
-      examples: {
-        requestExamples: {
-          trip: {
-            summary: "Trip the killswitch on every env",
-            description: "Sets `value: true` on dev/stage/prod, bumping each env's version by one.",
-            value: { value: true }
-          },
-          untrip: {
-            summary: "Untrip on every env",
-            description: "Sets `value: false` on every env.",
-            value: { value: false }
-          },
-          replaceSwitches: {
-            summary: "Replace switches map",
-            description: "Replaces the per-key overrides wholesale on every env. Pass `{}` to clear.",
-            value: { switches: { eu_region: true, apac_region: true } }
-          },
-          updateDescription: {
-            summary: "Description-only update",
-            description: "Doesn't bump versions or trigger a republish \u2014 only metadata changes.",
-            value: { description: "Master kill \u2014 owner: payments-platform" }
-          }
-        },
-        response: { id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8" }
-      },
-      useCase: [
-        '- **Trip everywhere** \u2014 `{ "value": true }`. Kills the feature across dev/stage/prod in one call.',
-        '- **Untrip everywhere** \u2014 `{ "value": false }`.',
-        "- **Replace switches** \u2014 send the full new map; per-key edits use `PUT /{id}/switch`.",
-        "- **Update description** \u2014 metadata-only patches don't bump versions."
-      ].join("\n")
-    },
-    {
-      operationId: "deleteKillswitch",
-      method: "DELETE",
-      path: "/{id}",
-      summary: "Delete a killswitch",
-      description: "Soft-deletes the killswitch and rebuilds the project's flags KV blob so SDKs stop seeing it.",
-      pathParams: { id: "Stable opaque killswitch id." },
-      response: killswitchDeleteResponseSchema,
-      examples: { response: { ok: true } },
-      useCase: "Tear down a killswitch after the feature it protected has been removed."
-    },
-    {
-      operationId: "setKillswitchSwitch",
-      method: "PUT",
-      path: "/{id}/switch",
-      summary: "Set one switch entry",
-      description: [
-        "Sets or updates a single `switchKey` on a single `env`. Publishes one new version on that env only \u2014 other envs untouched.",
-        "",
-        "Use this for surgical per-env, per-key flips during incident response (e.g. trip `eu_region` on prod without touching the flat `value` or other envs)."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque killswitch id." },
-      request: killswitchSwitchSetSchema,
-      response: killswitchSwitchSetResponseSchema,
-      examples: {
-        requestExamples: {
-          tripRegion: {
-            summary: "Trip eu_region on prod",
-            description: "Sets `switches.eu_region = true` on prod only. Other envs and the flat `value` are unchanged.",
-            value: { env: "prod", switchKey: "eu_region", value: true }
-          },
-          untripRegion: {
-            summary: "Untrip eu_region on prod",
-            description: "Flip the same entry back off without removing it from the map.",
-            value: { env: "prod", switchKey: "eu_region", value: false }
-          }
-        },
-        response: {
-          id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8",
-          env: "prod",
-          switchKey: "eu_region",
-          value: true
-        }
-      },
-      useCase: [
-        '- **Trip a region** \u2014 `{ "env": "prod", "switchKey": "eu_region", "value": true }`.',
-        "- **Untrip without removing** \u2014 same payload with `value: false`. To remove the entry entirely use `DELETE /{id}/switch`."
-      ].join("\n")
-    },
-    {
-      operationId: "unsetKillswitchSwitch",
-      method: "DELETE",
-      path: "/{id}/switch",
-      summary: "Remove one switch entry",
-      description: [
-        "Removes a single `switchKey` from the `switches` map on a single `env`. Publishes a new version on that env.",
-        "",
-        "Returns `{ removed: false }` if the entry didn't exist (idempotent no-op)."
-      ].join("\n"),
-      pathParams: { id: "Stable opaque killswitch id." },
-      request: killswitchSwitchUnsetSchema,
-      response: killswitchSwitchUnsetResponseSchema,
-      examples: {
-        requestExamples: {
-          removeRegion: {
-            summary: "Remove eu_region from prod",
-            description: "Drops the `eu_region` override on prod so the flat `value` applies again.",
-            value: { env: "prod", switchKey: "eu_region" }
-          }
-        },
-        response: {
-          id: "ksw_01j7w9d8h2k4m6n8p0q2r4s6t8",
-          env: "prod",
-          switchKey: "eu_region",
-          removed: true
-        }
-      },
-      useCase: "Clean up a per-region override after the incident is resolved so the flat `value` governs again."
-    }
-  ]
-};
-
-// src/schemas/alert-rules.ts
-import { z as z14 } from "zod";
-var ALERT_COMPARATORS = ["gt", "gte", "lt", "lte"];
-var ALERT_SEVERITIES = ["danger", "warn", "info"];
-var notificationTargetSchema = z14.object({
-  slackChannel: z14.object({
-    id: z14.string().min(1).describe("Slack channel id (e.g. C0123ABCD)."),
-    name: z14.string().min(1).describe("Slack channel name (without the leading #).")
-  }).nullish().describe("Slack channel to post this rule's alert to. Requires a Slack connector."),
-  email: z14.string().email().nullish().describe("Email address to notify for this rule (overrides the default recipient).")
-}).strict();
-var alertRuleCreateSchema = z14.object({
-  name: z14.string().min(1).max(120).describe("Human label for the rule, shown on the alert and the rules list."),
-  metricId: z14.string().min(1).describe("Id of the metric to evaluate."),
-  comparator: z14.enum(ALERT_COMPARATORS).describe("How the metric value is compared to the threshold (gt/gte/lt/lte)."),
-  threshold: z14.number().finite().describe("Threshold the metric value is compared against."),
-  windowHours: z14.number().int().min(1).max(720).default(24).describe("Lookback window (hours) the metric is aggregated over. 1\u2013720."),
-  severity: z14.enum(ALERT_SEVERITIES).default("warn").describe("Severity of the raised alert."),
-  enabled: z14.boolean().default(true).describe("Whether the rule is evaluated by the cron."),
-  notify: notificationTargetSchema.nullish().describe("Where to deliver this rule's alert (Slack channel and/or email target).")
-}).strict();
-var alertRuleUpdateSchema = z14.object({
-  name: z14.string().min(1).max(120),
-  comparator: z14.enum(ALERT_COMPARATORS),
-  threshold: z14.number().finite(),
-  windowHours: z14.number().int().min(1).max(720),
-  severity: z14.enum(ALERT_SEVERITIES),
-  enabled: z14.boolean(),
-  notify: notificationTargetSchema.nullish()
-}).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/metrics.ts
-var BASE7 = "/api/admin/metrics";
-function metricsClient(t) {
-  async function list() {
-    return t.request("GET", BASE7);
-  }
-  async function resolve(idOrName) {
-    const all = await list();
-    const byId = all.find((m) => m.id === idOrName);
-    if (byId) return byId;
-    const byPrefix = all.filter((m) => m.id.startsWith(idOrName));
-    if (byPrefix.length === 1) return byPrefix[0];
-    if (byPrefix.length > 1) throw new ApiError(`Metric id prefix '${idOrName}' is ambiguous`, 400);
-    const byName = all.filter((m) => m.name === idOrName);
-    if (byName.length === 1) return byName[0];
-    if (byName.length > 1)
-      throw new ApiError(`Metric name '${idOrName}' is ambiguous \u2014 pass an id`, 400);
-    throw new ApiError(`Metric '${idOrName}' not found`, 404);
-  }
-  return {
-    list,
-    resolve,
-    get: (id) => t.request("GET", `${BASE7}/${id}`),
-    create: (input) => t.request("POST", BASE7, input),
-    delete: (id) => t.request("DELETE", `${BASE7}/${id}`)
-  };
-}
-
-// src/resources/events.ts
-var BASE8 = "/api/admin/events";
-function eventsClient(t) {
-  async function list() {
-    return t.request("GET", BASE8);
-  }
-  async function resolve(idOrName) {
-    const all = await list();
-    const byId = all.find((e) => e.id === idOrName);
-    if (byId) return byId;
-    const byPrefix = all.filter((e) => e.id.startsWith(idOrName));
-    if (byPrefix.length === 1) return byPrefix[0];
-    if (byPrefix.length > 1) throw new ApiError(`Event id prefix '${idOrName}' is ambiguous`, 400);
-    const byName = all.filter((e) => e.name === idOrName);
-    if (byName.length === 1) return byName[0];
-    if (byName.length > 1)
-      throw new ApiError(`Event name '${idOrName}' is ambiguous \u2014 pass an id`, 400);
-    throw new ApiError(`Event '${idOrName}' not found`, 404);
-  }
-  return {
-    list,
-    resolve,
-    get: (id) => t.request("GET", `${BASE8}/${id}`),
-    create: (input) => t.request("POST", BASE8, input),
-    update: (id, input) => t.request("PATCH", `${BASE8}/${id}`, input),
-    approve: (id, input = {}) => t.request("POST", `${BASE8}/${id}/approve`, input),
-    delete: (id) => t.request("DELETE", `${BASE8}/${id}`)
-  };
-}
-
-// src/resources/ops.ts
-var FEEDBACK = "/api/admin/feedback";
-var NOTIFY = "/api/admin/notifications";
-var CREATE_PATH = {
-  bug: "/api/admin/bugs",
-  feature_request: "/api/admin/feature-requests"
-};
-function itemPath(handle) {
-  return `${FEEDBACK}/${encodeURIComponent(handle)}`;
-}
-function opsClient(t) {
-  return {
-    list: (query = {}) => {
-      const q = {};
-      if (query.type) q.type = query.type;
-      if (query.status) q.status = query.status;
-      if (query.limit !== void 0) q.limit = String(query.limit);
-      return t.request("GET", FEEDBACK, void 0, q);
-    },
-    get: (handle) => t.request("GET", itemPath(handle)),
-    create: ({ type, ...body }) => t.request("POST", CREATE_PATH[type], body),
-    update: (handle, input) => t.request("PATCH", itemPath(handle), input),
-    linkPr: (handle, input) => t.request("POST", `${itemPath(handle)}/link-pr`, input),
-    notify: (input) => t.request("POST", NOTIFY, {
-      title: input.title,
-      summary: input.summary,
-      steps: input.steps ?? [],
-      ...input.href ? { href: input.href } : {},
-      ...input.dedupeKey ? { dedupeKey: input.dedupeKey } : {}
-    }),
-    channels: () => t.request("GET", "/api/admin/slack/channels")
-  };
-}
-
-// src/resources/projects.ts
-var BASE9 = "/api/admin/projects";
-function projectsClient(t) {
-  return {
-    upsert: (input) => t.request("POST", `${BASE9}/upsert`, {
-      domain: input.domain,
-      ...input.name ? { name: input.name } : {}
-    }),
-    current: () => t.request("GET", `${BASE9}/current`)
-  };
-}
-
-// src/resources/i18n.ts
-var PROFILES = "/api/admin/i18n/profiles";
-var KEYS = "/api/admin/i18n/keys";
-var DRAFTS = "/api/admin/i18n/drafts";
-function i18nClient(t) {
-  async function listProfiles() {
-    return t.request("GET", PROFILES);
-  }
-  async function resolveProfile(name) {
-    const all = await listProfiles();
-    const found = all.find((p) => p.name === name);
-    if (!found)
-      throw new ApiError(
-        `Profile '${name}' not found. Existing: ${all.map((p) => p.name).join(", ") || "(none)"}`,
-        404
-      );
-    return found;
-  }
-  async function listKeys(query = {}) {
-    const q = {};
-    if (query.profile_id) q.profile_id = query.profile_id;
-    if (query.prefix) q.prefix = query.prefix;
-    if (query.limit !== void 0) q.limit = String(query.limit);
-    const res = await t.request("GET", KEYS, void 0, q);
-    return Array.isArray(res) ? res : res.keys;
-  }
-  function updateKey(id, input) {
-    return t.request("PUT", `${KEYS}/${id}`, input);
-  }
-  return {
-    listProfiles,
-    resolveProfile,
-    listKeys,
-    updateKey,
-    createProfile: (input) => t.request("POST", PROFILES, input),
-    pushKeys: (input) => t.request("POST", KEYS, input),
-    updateKeyByName: async (profileId, key, input) => {
-      const rows = await listKeys({ profile_id: profileId, prefix: key, limit: 500 });
-      const match = rows.find((k) => k.key === key);
-      if (!match)
-        throw new ApiError(`Key '${key}' not found in profile. Add it first with i18n push.`, 404);
-      return updateKey(match.id, input);
-    },
-    listDrafts: () => t.request("GET", DRAFTS),
-    publish: (profileId, input) => t.request("POST", `${PROFILES}/${profileId}/publish`, { chunk: input.chunk ?? "default" })
-  };
-}
-
-// src/resources/attributes.ts
-var BASE10 = "/api/admin/attributes";
-function attributesClient(t) {
-  return {
-    list: () => t.request("GET", BASE10)
-  };
-}
-
-// src/resources/index.ts
-function createAdminClient(transport) {
-  return {
-    transport,
-    gates: gatesClient(transport),
-    experiments: experimentsClient(transport),
-    configs: configsClient(transport),
-    universes: universesClient(transport),
-    killswitches: killswitchesClient(transport),
-    alertRules: alertRulesClient(transport),
-    metrics: metricsClient(transport),
-    events: eventsClient(transport),
-    ops: opsClient(transport),
-    projects: projectsClient(transport),
-    i18n: i18nClient(transport),
-    attributes: attributesClient(transport)
-  };
-}
-var RESOURCE_REGISTRY = [
-  gatesResource,
-  experimentsResource,
-  configsResource,
-  universesResource,
-  killswitchesResource
-];
-
-// src/operations/types.ts
-var opId = (op) => [...op.group, op.name].join(".");
-var opMcpName = (op) => [...op.group, op.name].join("_");
-var opCli = (op) => [...op.group, op.name].join(" ");
-
-// src/operations/coerce.ts
-function coerceValue(param, raw) {
-  if (raw === void 0 || raw === null) return void 0;
-  switch (param.type) {
-    case "number": {
-      const n = typeof raw === "number" ? raw : Number(raw);
-      if (!Number.isFinite(n)) throw new ApiError(`--${param.name} must be a number`, 400);
-      return n;
-    }
-    case "boolean":
-      return raw === true || raw === "true" || raw === "1";
-    case "json":
-      if (typeof raw !== "string") return raw;
-      try {
-        return JSON.parse(raw);
-      } catch {
-        throw new ApiError(`--${param.name} must be valid JSON`, 400);
-      }
-    case "string":
-    default: {
-      const s = String(raw);
-      if (param.enum && !param.enum.includes(s)) {
-        throw new ApiError(`--${param.name} must be one of: ${param.enum.join(", ")}`, 400);
-      }
-      return s;
-    }
-  }
-}
-function coerceInput(op, raw) {
-  const out = {};
-  for (const param of op.params) {
-    const value = coerceValue(param, raw[param.name]);
-    if (value === void 0) {
-      if (param.required) throw new ApiError(`${param.name} is required`, 400);
-      continue;
-    }
-    out[param.name] = value;
-  }
-  return out;
-}
-
-// src/operations/cli-adapter.ts
-var toKebab = (s) => s.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-function commandSignature(op) {
-  const positionals = op.params.filter((p) => p.positional).map((p) => p.required === false ? `[${p.name}]` : `<${p.name}>`);
-  return [op.name, ...positionals].join(" ");
-}
-function mountOperations(group, ops, ctx) {
-  for (const op of ops) {
-    const positionals = op.params.filter((p) => p.positional);
-    const flags = op.params.filter((p) => !p.positional);
-    const cmd = group.command(commandSignature(op)).description(op.summary);
-    for (const p of flags) {
-      cmd.option(`--${toKebab(p.name)} <value>`, p.description);
-    }
-    cmd.option("--json", "Output as JSON");
-    cmd.option("--project <id>", "Project ID override");
-    cmd.action(async (...argv) => {
-      try {
-        const opts = argv.find((a) => a && typeof a === "object" && !Array.isArray(a)) ?? {};
-        const raw = { ...opts };
-        positionals.forEach((p, i) => {
-          raw[p.name] = argv[i];
-        });
-        const input = coerceInput(op, raw);
-        const client = ctx.getClient({
-          mutates: op.mutates,
-          projectOverride: opts.project
-        });
-        const data = await op.run(client, input);
-        if (opts.json) ctx.printJson(data);
-        else ctx.printResult(op, data, input);
-      } catch (e) {
-        ctx.onError(e);
-      }
-    });
-  }
-}
-
-// src/operations/mcp-adapter.ts
-function jsonType(t) {
-  switch (t) {
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "json":
-    case "string":
-    default:
-      return "string";
-  }
-}
-function operationsToMcpTools(ops) {
-  return ops.map((op) => {
-    const properties = {};
-    const required = [];
-    for (const p of op.params) {
-      properties[p.name] = { type: jsonType(p.type), description: p.description };
-      if (p.enum) properties[p.name].enum = p.enum;
-      if (p.required) required.push(p.name);
-    }
-    return {
-      name: opMcpName(op),
-      description: op.description,
-      inputSchema: { type: "object", ...required.length ? { required } : {}, properties }
-    };
-  });
-}
-function operationsToDispatch(ops) {
-  const map = {};
-  for (const op of ops) {
-    map[opMcpName(op)] = async (client, args) => op.run(client, coerceInput(op, args ?? {}));
-  }
-  return map;
-}
-
-// src/operations/docs.ts
-function renderOperationsMarkdown(ops, opts = {}) {
-  const lines = [];
-  if (opts.title) lines.push(`# ${opts.title}`, "");
-  for (const op of ops) {
-    lines.push(`## \`${opId(op)}\``, "");
-    lines.push(op.summary, "");
-    if (op.description && op.description !== op.summary) lines.push(op.description, "");
-    lines.push(
-      `- **CLI:** \`shipeasy ${opCli(op)}\`  \xB7  **MCP tool:** \`${opMcpName(op)}\`  \xB7  ${op.mutates ? "write (needs project binding)" : "read"}`,
-      ""
-    );
-    if (op.params.length) {
-      lines.push("| Param | Type | Required | Description |", "| --- | --- | --- | --- |");
-      for (const p of op.params) {
-        const kind = p.positional ? `${p.type} (positional)` : p.type;
-        lines.push(`| \`${p.name}\` | ${kind} | ${p.required ? "yes" : "no"} | ${p.description} |`);
-      }
-      lines.push("");
-    }
-    if (op.examples?.length) {
-      lines.push("**Examples**", "");
-      for (const ex of op.examples) {
-        if (ex.note) lines.push(`- ${ex.note}:`);
-        lines.push("```sh", ex.run, "```");
-      }
-      lines.push("");
-    }
-  }
-  return lines.join("\n");
-}
-
-// src/operations/util.ts
-var num = (i, k) => i[k] === void 0 ? void 0 : i[k];
-var str = (i, k) => i[k] === void 0 ? void 0 : i[k];
-var bool = (i, k) => i[k] === void 0 ? void 0 : i[k];
-
-// src/operations/gates.ts
-var ROLLOUT_DESC = "Rollout percentage, 0\u2013100 (converted to basis points internally).";
-var RULES_DESC = `Targeting rules as a JSON array, e.g. '[{"attr":"plan","op":"eq","value":"pro"}]'. AND-combined.`;
-var STACK_DESC = "Gatekeeper stack as a JSON array of ordered first-match-wins tiers (condition/rollout steps, rolloutPct in basis points). Takes precedence over flat rules/rollout. Pass to express internal \u222A beta \u222A public in one gate.";
-var gateOperations = [
-  {
-    group: ["release", "flags"],
-    name: "list",
-    mutates: false,
-    summary: "List all feature gates",
-    description: "Return every feature gate in the project (name, enabled, rollout %), ordered by most recently updated.",
-    params: [],
-    examples: [{ run: "shipeasy release flags list" }],
-    run: (client) => client.gates.listAll()
-  },
-  {
-    group: ["release", "flags"],
-    name: "create",
-    mutates: true,
-    summary: "Create a feature gate",
-    description: "Create a feature gate. A flat gate is `rules` + a single `rollout` %. For tiered rollouts (e.g. 'US @ 50% \u2192 bots @ 30% \u2192 everyone else @ 10%') pass `stack` \u2014 an ordered list of steps evaluated first-match-wins; flat `rules`/`rollout` are then ignored.",
-    params: [
-      { name: "name", type: "string", description: "Gate key (lowercase, digits, _/-).", required: true, positional: true },
-      { name: "rollout", type: "number", description: ROLLOUT_DESC },
-      { name: "rules", type: "json", description: RULES_DESC },
-      { name: "salt", type: "string", description: "Override hash salt (immutable after create)." },
-      { name: "stack", type: "json", description: STACK_DESC }
-    ],
-    examples: [
-      { note: "Off by default; flip it on later", run: "shipeasy release flags create checkout-v2" },
-      {
-        note: "Roll out to 25% of pro-plan users",
-        run: `shipeasy release flags create new-ui --rollout 25 --rules '[{"attr":"plan","op":"eq","value":"pro"}]'`
-      }
-    ],
-    run: (client, i) => client.gates.create({
-      name: i.name,
-      rollout_pct: Math.round((num(i, "rollout") ?? 0) * 100),
-      // Validated at runtime by gateCreateSchema.parse inside gates.create().
-      rules: i.rules ?? [],
-      ...i.salt ? { salt: i.salt } : {},
-      ...i.stack ? { stack: i.stack } : {}
-    })
-  },
-  {
-    group: ["release", "flags"],
-    name: "update",
-    mutates: true,
-    summary: "Update a gate's rollout, rules, stack, or enabled flag",
-    description: "Update a feature gate's rollout, rules, gatekeeper stack, or enabled flag. Pass `stack` to replace the tiered rollout wholesale; array fields replace, they do not merge.",
-    params: [
-      { name: "name", type: "string", description: "Gate name to update.", required: true, positional: true },
-      { name: "rollout", type: "number", description: ROLLOUT_DESC },
-      { name: "rules", type: "json", description: RULES_DESC + " Replaces the existing rules wholesale." },
-      { name: "stack", type: "json", description: STACK_DESC + " Pass null to revert to flat evaluation." },
-      { name: "enabled", type: "boolean", description: "Master switch \u2014 false forces the gate off for every caller." }
-    ],
-    examples: [{ note: "Ramp to 50%", run: "shipeasy release flags update checkout-v2 --rollout 50" }],
-    run: async (client, i) => {
-      const gate = await client.gates.resolve(i.name);
-      const patch = {};
-      const rollout = num(i, "rollout");
-      if (rollout !== void 0) patch.rollout_pct = Math.round(rollout * 100);
-      if (i.rules !== void 0) patch.rules = i.rules;
-      if (i.stack !== void 0) patch.stack = i.stack;
-      if (i.enabled !== void 0) patch.enabled = i.enabled;
-      return client.gates.update(gate.id, patch);
-    }
-  },
-  {
-    group: ["release", "flags"],
-    name: "enable",
-    mutates: true,
-    summary: "Enable a feature gate",
-    description: "Set `enabled: true`, preserving the current rollout %.",
-    params: [{ name: "name", type: "string", description: "Gate name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release flags enable checkout-v2" }],
-    run: async (client, i) => {
-      const gate = await client.gates.resolve(i.name);
-      return client.gates.enable(gate.id);
-    }
-  },
-  {
-    group: ["release", "flags"],
-    name: "disable",
-    mutates: true,
-    summary: "Disable a feature gate (kill switch)",
-    description: "Set `enabled: false` so the gate evaluates to `false` for every caller regardless of rules/rollout.",
-    params: [{ name: "name", type: "string", description: "Gate name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release flags disable checkout-v2" }],
-    run: async (client, i) => {
-      const gate = await client.gates.resolve(i.name);
-      return client.gates.disable(gate.id);
-    }
-  },
-  {
-    group: ["release", "flags"],
-    name: "rollout",
-    mutates: true,
-    summary: "Set rollout percentage (0\u2013100)",
-    description: "Resolve the gate by name and set its rollout percentage (0\u2013100).",
-    params: [
-      { name: "name", type: "string", description: "Gate name.", required: true, positional: true },
-      { name: "pct", type: "number", description: "Rollout percentage, 0\u2013100.", required: true, positional: true }
-    ],
-    examples: [
-      { note: "Ramp to 50%", run: "shipeasy release flags rollout checkout-v2 50" },
-      { note: "Instant kill \u2014 set to 0", run: "shipeasy release flags rollout checkout-v2 0" }
-    ],
-    run: (client, i) => client.gates.setRollout(i.name, num(i, "pct"))
-  },
-  {
-    group: ["release", "flags"],
-    name: "archive",
-    mutates: true,
-    summary: "Archive a feature gate",
-    description: "Archive (soft-delete) a feature gate by name. Refuses if a running experiment references it as a targeting gate.",
-    params: [{ name: "name", type: "string", description: "Gate name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release flags archive checkout-v2" }],
-    run: async (client, i) => {
-      const gate = await client.gates.resolve(i.name);
-      await client.gates.delete(gate.id);
-      return { ok: true, archived: i.name };
-    }
-  }
-];
-
-// src/operations/killswitches.ts
-var GROUP = ["release", "killswitch"];
-var ENVS = ["dev", "staging", "prod"];
-var killswitchOperations = [
-  {
-    group: GROUP,
-    name: "list",
-    mutates: false,
-    summary: "List all kill switches",
-    description: "Return every kill switch with its per-env default value and switch count.",
-    params: [],
-    examples: [{ run: "shipeasy release killswitch list" }],
-    run: (client) => client.killswitches.listAll()
-  },
-  {
-    group: GROUP,
-    name: "create",
-    mutates: true,
-    summary: "Create a kill switch",
-    description: "Create a kill switch (a static `{ value, switches }` config shipped in the flags KV blob). Name must be `folder.name`. Switches take precedence over `value` for that switch_key.",
-    params: [
-      { name: "name", type: "string", description: "`folder.name` \u2014 two lowercase segments.", required: true, positional: true },
-      { name: "description", type: "string", description: "Optional description." },
-      { name: "value", type: "boolean", description: "Default value (true|false). Defaults to false." },
-      { name: "switches", type: "json", description: "JSON object of { switch_key: bool }; takes precedence over value." }
-    ],
-    examples: [
-      { note: "Default OFF", run: "shipeasy release killswitch create payments.stripe-gateway" },
-      { note: "Pre-seed per-key switches", run: `shipeasy release killswitch create payments.stripe-gateway --switches '{"refunds":true,"payouts":false}'` }
-    ],
-    run: (client, i) => client.killswitches.create({
-      name: i.name,
-      description: str(i, "description"),
-      value: bool(i, "value") ?? false,
-      switches: i.switches
-    })
-  },
-  {
-    group: GROUP,
-    name: "update",
-    mutates: true,
-    summary: "Update a kill switch's default value, switches map, or description",
-    description: "Patch a kill switch. `switches` replaces the map wholesale; pass an empty description to clear it.",
-    params: [
-      { name: "name", type: "string", description: "Kill switch name.", required: true, positional: true },
-      { name: "value", type: "boolean", description: "Default value (true|false)." },
-      { name: "switches", type: "json", description: "JSON { switch_key: bool } \u2014 replaces wholesale." },
-      { name: "description", type: "string", description: "Description (empty string clears it)." }
-    ],
-    examples: [{ note: "Flip the default ON", run: "shipeasy release killswitch update payments.stripe-gateway --value true" }],
-    run: async (client, i) => {
-      const k = await client.killswitches.resolve(i.name);
-      const patch = {};
-      if (i.value !== void 0) patch.value = i.value;
-      if (i.switches !== void 0) patch.switches = i.switches;
-      if (i.description !== void 0) patch.description = i.description === "" ? null : i.description;
-      return client.killswitches.update(k.id, patch);
-    }
-  },
-  {
-    group: GROUP,
-    name: "set",
-    mutates: true,
-    summary: "Set one switch entry on one env",
-    description: "Set or update a single named switch on one environment (default `prod`), leaving the rest untouched.",
-    params: [
-      { name: "name", type: "string", description: "Kill switch name.", required: true, positional: true },
-      { name: "switchKey", type: "string", description: "Switch key to set.", required: true, positional: true },
-      { name: "value", type: "boolean", description: "true|false.", required: true, positional: true },
-      { name: "env", type: "string", description: `Env: ${ENVS.join(" | ")} (default prod).`, enum: ENVS }
-    ],
-    examples: [
-      { note: "Kill refunds in prod", run: "shipeasy release killswitch set payments.stripe-gateway refunds true" },
-      { note: "Target staging instead", run: "shipeasy release killswitch set payments.stripe-gateway refunds true --env staging" }
-    ],
-    run: async (client, i) => {
-      const k = await client.killswitches.resolve(i.name);
-      return client.killswitches.setSwitch(k.id, {
-        env: str(i, "env") ?? "prod",
-        switchKey: i.switchKey,
-        value: i.value
-      });
-    }
-  },
-  {
-    group: GROUP,
-    name: "unset",
-    mutates: true,
-    summary: "Remove one switch entry from one env",
-    description: "Remove a single named switch from one environment (default `prod`), reverting it to the default.",
-    params: [
-      { name: "name", type: "string", description: "Kill switch name.", required: true, positional: true },
-      { name: "switchKey", type: "string", description: "Switch key to remove.", required: true, positional: true },
-      { name: "env", type: "string", description: `Env: ${ENVS.join(" | ")} (default prod).`, enum: ENVS }
-    ],
-    examples: [{ run: "shipeasy release killswitch unset payments.stripe-gateway refunds" }],
-    run: async (client, i) => {
-      const k = await client.killswitches.resolve(i.name);
-      return client.killswitches.unsetSwitch(k.id, {
-        env: str(i, "env") ?? "prod",
-        switchKey: i.switchKey
-      });
-    }
-  },
-  {
-    group: GROUP,
-    name: "archive",
-    mutates: true,
-    summary: "Archive a kill switch",
-    description: "Archive (soft-delete) a kill switch by name.",
-    params: [{ name: "name", type: "string", description: "Kill switch name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release killswitch archive payments.stripe-gateway" }],
-    run: async (client, i) => {
-      const k = await client.killswitches.resolve(i.name);
-      await client.killswitches.delete(k.id);
-      return { ok: true, archived: i.name };
-    }
-  }
-];
-
-// src/operations/configs.ts
-var GROUP2 = ["release", "configs"];
-var configOperations = [
-  {
-    group: GROUP2,
-    name: "list",
-    mutates: false,
-    summary: "List all configs",
-    description: "Return every dynamic config (name, schema, last updated).",
-    params: [],
-    examples: [{ run: "shipeasy release configs list" }],
-    run: (client) => client.configs.listAll()
-  },
-  {
-    group: GROUP2,
-    name: "get",
-    mutates: false,
-    summary: "Show a config by name",
-    description: "Resolve a config by name and return its full detail (schema + per-env values + drafts).",
-    params: [{ name: "name", type: "string", description: "Config name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release configs get pricing" }],
-    run: async (client, i) => {
-      const c = await client.configs.resolve(i.name);
-      return client.configs.get(c.id);
-    }
-  },
-  {
-    group: GROUP2,
-    name: "create",
-    mutates: true,
-    summary: "Create a config",
-    description: "Create a dynamic config. Configs are JSON objects validated against a JSON Schema (object-only).",
-    params: [
-      { name: "name", type: "string", description: "Config name.", required: true, positional: true },
-      { name: "schema", type: "json", description: "JSON Schema (top-level type=object). Defaults to a permissive object schema." },
-      { name: "value", type: "json", description: "Initial value as a JSON object. Defaults to {}." },
-      { name: "description", type: "string", description: "Human-readable description." }
-    ],
-    examples: [
-      { note: "Permissive schema, empty value", run: "shipeasy release configs create pricing" },
-      { note: "Seed an initial value", run: `shipeasy release configs create pricing --value '{"free_trial_days":14}'` }
-    ],
-    run: (client, i) => client.configs.create({
-      name: i.name,
-      schema: i.schema ?? { type: "object", properties: {}, additionalProperties: true },
-      value: i.value ?? {},
-      ...i.description ? { description: i.description } : {}
-    })
-  },
-  {
-    group: GROUP2,
-    name: "update",
-    mutates: true,
-    summary: "Update a config's value (flat, all envs)",
-    description: "Legacy flat value update across all envs. Use draft + publish for per-env staging.",
-    params: [
-      { name: "name", type: "string", description: "Config name.", required: true, positional: true },
-      { name: "value", type: "json", description: "New value (JSON object).", required: true }
-    ],
-    examples: [{ note: "Overwrite the value (all envs)", run: `shipeasy release configs update pricing --value '{"free_trial_days":30}'` }],
-    run: async (client, i) => {
-      const c = await client.configs.resolve(i.name);
-      return client.configs.update(c.id, { value: i.value });
-    }
-  },
-  {
-    group: GROUP2,
-    name: "draft",
-    mutates: true,
-    summary: "Save a draft value for one env",
-    description: "Stage a draft value for the given env, to publish later.",
-    params: [
-      { name: "name", type: "string", description: "Config name.", required: true, positional: true },
-      { name: "env", type: "string", description: "Target env (e.g. prod, staging, dev).", required: true },
-      { name: "value", type: "json", description: "Draft value (JSON object).", required: true }
-    ],
-    examples: [{ note: "Stage a prod value", run: `shipeasy release configs draft pricing --env prod --value '{"free_trial_days":30}'` }],
-    run: async (client, i) => {
-      const c = await client.configs.resolve(i.name);
-      return client.configs.saveDraft(c.id, { env: i.env, value: i.value });
-    }
-  },
-  {
-    group: GROUP2,
-    name: "publish",
-    mutates: true,
-    summary: "Publish the saved draft for one env",
-    description: "Promote the staged draft for the given env to live.",
-    params: [
-      { name: "name", type: "string", description: "Config name.", required: true, positional: true },
-      { name: "env", type: "string", description: "Target env to publish.", required: true }
-    ],
-    examples: [{ note: "Promote staged draft to prod", run: "shipeasy release configs publish pricing --env prod" }],
-    run: async (client, i) => {
-      const c = await client.configs.resolve(i.name);
-      return client.configs.publish(c.id, { env: str(i, "env") });
-    }
-  },
-  {
-    group: GROUP2,
-    name: "archive",
-    mutates: true,
-    summary: "Archive a config",
-    description: "Archive (soft-delete) a config by name.",
-    params: [{ name: "name", type: "string", description: "Config name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release configs archive pricing" }],
-    run: async (client, i) => {
-      const c = await client.configs.resolve(i.name);
-      await client.configs.delete(c.id);
-      return { ok: true, archived: i.name };
-    }
-  }
-];
-
-// src/operations/experiments.ts
-var GROUP3 = ["release", "experiments"];
-var DEFAULT_GROUPS = [
-  { name: "control", weight: 5e3, params: {} },
-  { name: "test", weight: 5e3, params: {} }
-];
-var AGGREGATIONS = [
-  "count_users",
-  "count_events",
-  "retention_7d",
-  "retention_30d",
-  "sum",
-  "avg"
-];
-function buildGoalMetric(i) {
-  const event = str(i, "successEvent");
-  if (!event) return void 0;
-  const agg = str(i, "successAggregation") ?? "count_users";
-  const value = str(i, "successValue");
-  switch (agg) {
-    case "count_users":
-      return { query: `count_users(${event})` };
-    case "count_events":
-      return { query: `count(${event})` };
-    case "retention_7d":
-      return { query: `retention_7d(${event})` };
-    case "retention_30d":
-      return { query: `retention_30d(${event})` };
-    case "sum":
-    case "avg":
-      if (!value)
-        throw new Error(
-          `successAggregation '${agg}' requires successValue \u2014 the numeric event property to ${agg} (e.g. "amount")`
-        );
-      return { query: `${agg}(${event}, ${value})` };
-    default:
-      throw new Error(`Unknown successAggregation '${agg}'`);
-  }
-}
-function parseGuardrails(raw) {
-  if (!Array.isArray(raw)) return [];
-  const out = [];
-  for (const entry of raw) {
-    if (typeof entry === "string") {
-      const query = entry.trim();
-      if (query) out.push({ query });
-    } else if (entry && typeof entry === "object") {
-      const o = entry;
-      const query = typeof o.query === "string" ? o.query.trim() : "";
-      if (query)
-        out.push(typeof o.name === "string" && o.name ? { query, name: o.name } : { query });
-    }
-  }
-  return out;
-}
-function computeVerdict(detail, results) {
-  if (results.some((r) => r.srm_detected === 1))
-    return { verdict: "invalid_srm", reason: "sample-ratio mismatch detected" };
-  if (detail.status !== "running") return { verdict: "not_running", reason: `status=${detail.status}` };
-  if (!results.length) return { verdict: "wait", reason: "no data yet" };
-  const withP = results.filter((r) => r.p_value !== null);
-  if (!withP.length) return { verdict: "wait", reason: "no p-values yet" };
-  const best = withP.reduce((a, b) => a.p_value < b.p_value ? a : b);
-  const threshold = detail.significance_threshold ?? 0.05;
-  if (best.p_value < threshold) return { verdict: "ship" };
-  const startedAt = detail.startedAt ?? detail.started_at;
-  const daysRunning = startedAt ? (Date.now() - new Date(startedAt).getTime()) / (1e3 * 60 * 60 * 24) : 0;
-  return daysRunning < (detail.min_runtime_days ?? 0) ? { verdict: "wait", reason: "min runtime not reached" } : { verdict: "hold" };
-}
-var experimentOperations = [
-  {
-    group: GROUP3,
-    name: "list",
-    mutates: false,
-    summary: "List experiments",
-    description: "Return every experiment (status, universe, allocation).",
-    params: [],
-    examples: [{ run: "shipeasy release experiments list" }],
-    run: (client) => client.experiments.listAll()
-  },
-  {
-    group: GROUP3,
-    name: "create",
-    mutates: true,
-    summary: "Create an experiment",
-    description: "Create an experiment draft with groups, params, optional targeting gate, a success (goal) metric, optional guardrail metrics, and full statistical config. Pass `successEvent` (+ `successAggregation`) to attach the goal metric inline \u2014 required before the experiment can be started. Defaults to a 50/50 control-vs-test split at 100% allocation in the `default` universe. Does NOT start \u2014 call `start`.",
-    params: [
-      { name: "name", type: "string", description: "Experiment name.", required: true, positional: true },
-      { name: "universe", type: "string", description: "Universe name. Defaults to 'default'." },
-      { name: "allocation", type: "number", description: "Allocation percentage, 0\u2013100. Defaults to 100." },
-      { name: "groups", type: "json", description: "Groups as JSON [{name,weight,params}]. weight is basis points." },
-      { name: "params", type: "json", description: "Parameter schema {name: type}." },
-      { name: "targetingGate", type: "string", description: "Targeting gate name." },
-      { name: "bucketBy", type: "string", description: "Attribute to bucket by (defaults to the universe unit)." },
-      { name: "salt", type: "string", description: "Override hash salt." },
-      { name: "successEvent", type: "string", description: "Event name for the inline goal metric. Attaching one makes the draft startable." },
-      { name: "successAggregation", type: "string", description: `Goal-metric reducer. Defaults to count_users.`, enum: [...AGGREGATIONS] },
-      { name: "successValue", type: "string", description: "Numeric event property for sum/avg goal metrics." },
-      { name: "guardrailMetrics", type: "json", description: "Up to 10 guardrail metrics: JSON array of DSL query strings or {query,name}." },
-      { name: "significance", type: "number", description: "Significance threshold (0.0001\u20130.5). Defaults to 0.05." },
-      { name: "minRuntimeDays", type: "number", description: "Minimum runtime in days." },
-      { name: "minSampleSize", type: "number", description: "Minimum sample size." },
-      { name: "sequentialTesting", type: "boolean", description: "Enable sequential testing (always-valid p-values; Premium+)." },
-      { name: "description", type: "string", description: "Human-readable description." }
-    ],
-    examples: [
-      { note: "Default 50/50, full traffic", run: "shipeasy release experiments create pricing-page" },
-      {
-        note: "Attach a goal metric so it's startable",
-        run: "shipeasy release experiments create checkout-cta --universe web --success-event checkout_completed"
-      }
-    ],
-    run: (client, i) => {
-      const goal_metric = buildGoalMetric(i);
-      const guardrail_metrics = parseGuardrails(i.guardrailMetrics);
-      return client.experiments.create({
-        name: i.name,
-        universe: str(i, "universe") ?? "default",
-        allocation_pct: Math.round((num(i, "allocation") ?? 100) * 100),
-        groups: i.groups ?? DEFAULT_GROUPS,
-        params: i.params ?? {},
-        targeting_gate: str(i, "targetingGate") ?? null,
-        ...str(i, "bucketBy") ? { bucket_by: str(i, "bucketBy") } : {},
-        ...str(i, "description") !== void 0 ? { description: str(i, "description") } : {},
-        ...i.salt ? { salt: i.salt } : {},
-        ...num(i, "significance") !== void 0 ? { significance_threshold: num(i, "significance") } : {},
-        ...num(i, "minRuntimeDays") !== void 0 ? { min_runtime_days: num(i, "minRuntimeDays") } : {},
-        ...num(i, "minSampleSize") !== void 0 ? { min_sample_size: num(i, "minSampleSize") } : {},
-        ...bool(i, "sequentialTesting") !== void 0 ? { sequential_testing: bool(i, "sequentialTesting") } : {},
-        ...goal_metric ? { goal_metric } : {},
-        ...guardrail_metrics.length ? { guardrail_metrics } : {}
-      });
-    }
-  },
-  {
-    group: GROUP3,
-    name: "update",
-    mutates: true,
-    summary: "Update an experiment",
-    description: "Patch allocation, groups, params, targeting gate, or stats thresholds. Pass `targetingGate` = 'null' to clear it.",
-    params: [
-      { name: "name", type: "string", description: "Experiment name.", required: true, positional: true },
-      { name: "allocation", type: "number", description: "Allocation percentage, 0\u2013100." },
-      { name: "groups", type: "json", description: "Groups as JSON [{name,weight,params}]." },
-      { name: "params", type: "json", description: "Parameter schema {name: type}." },
-      { name: "targetingGate", type: "string", description: "Targeting gate name ('null' to clear)." },
-      { name: "bucketBy", type: "string", description: "Attribute to bucket by (empty string clears)." },
-      { name: "successEvent", type: "string", description: "Attach/replace the goal metric from this event." },
-      { name: "successAggregation", type: "string", description: "Goal-metric reducer (with successEvent).", enum: [...AGGREGATIONS] },
-      { name: "successValue", type: "string", description: "Numeric event property for sum/avg goal metrics." },
-      { name: "guardrailMetrics", type: "json", description: "Replace the guardrail set: JSON array of DSL queries or {query,name}." },
-      { name: "significance", type: "number", description: "Significance threshold (0.0001\u20130.5)." },
-      { name: "minRuntimeDays", type: "number", description: "Minimum runtime in days." },
-      { name: "minSampleSize", type: "number", description: "Minimum sample size." },
-      { name: "sequentialTesting", type: "boolean", description: "Enable sequential testing (always-valid p-values)." }
-    ],
-    examples: [
-      { note: "Dial allocation to 50%", run: "shipeasy release experiments update pricing-page --allocation 50" },
-      { note: "Clear targeting + tighten significance", run: "shipeasy release experiments update checkout-cta --targeting-gate null --significance 0.01" }
-    ],
-    run: async (client, i) => {
-      const e = await client.experiments.resolve(i.name);
-      const patch = {};
-      const allocation = num(i, "allocation");
-      if (allocation !== void 0) patch.allocation_pct = Math.round(allocation * 100);
-      if (i.groups !== void 0) patch.groups = i.groups;
-      if (i.params !== void 0) patch.params = i.params;
-      if (i.targetingGate !== void 0)
-        patch.targeting_gate = i.targetingGate === "null" ? null : i.targetingGate;
-      if (str(i, "bucketBy") !== void 0) patch.bucket_by = str(i, "bucketBy") || null;
-      if (i.significance !== void 0) patch.significance_threshold = i.significance;
-      if (i.minRuntimeDays !== void 0) patch.min_runtime_days = i.minRuntimeDays;
-      if (i.minSampleSize !== void 0) patch.min_sample_size = i.minSampleSize;
-      if (bool(i, "sequentialTesting") !== void 0) patch.sequential_testing = bool(i, "sequentialTesting");
-      if (i.guardrailMetrics !== void 0) patch.guardrail_metrics = parseGuardrails(i.guardrailMetrics);
-      const goal_metric = buildGoalMetric(i);
-      if (goal_metric) patch.goal_metric = goal_metric;
-      return client.experiments.update(e.id, patch);
-    }
-  },
-  {
-    group: GROUP3,
-    name: "start",
-    mutates: true,
-    summary: "Start an experiment",
-    description: "Move an experiment from draft to running.",
-    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release experiments start pricing-page" }],
-    run: async (client, i) => {
-      const e = await client.experiments.resolve(i.name);
-      return client.experiments.start(e.id);
-    }
-  },
-  {
-    group: GROUP3,
-    name: "stop",
-    mutates: true,
-    summary: "Stop a running experiment",
-    description: "Stop a running experiment. Optionally name a `promoteGroup` to record an intent note (actual promotion happens in the dashboard).",
-    params: [
-      { name: "name", type: "string", description: "Experiment name.", required: true, positional: true },
-      { name: "promoteGroup", type: "string", description: "Group to note as the winner to promote." }
-    ],
-    examples: [{ run: "shipeasy release experiments stop pricing-page" }],
-    run: async (client, i) => {
-      const e = await client.experiments.resolve(i.name);
-      const result = await client.experiments.stop(e.id);
-      const promote = str(i, "promoteGroup");
-      return {
-        ...result,
-        ...promote ? {
-          promote_group_note: `Manual promotion needed: promote group '${promote}' in the dashboard or via PATCH /api/admin/experiments/${e.id}.`
-        } : {}
-      };
-    }
-  },
-  {
-    group: GROUP3,
-    name: "archive",
-    mutates: true,
-    summary: "Archive a stopped experiment",
-    description: "Archive (soft-delete) a stopped experiment, hiding it from the default list while preserving results.",
-    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release experiments archive pricing-page" }],
-    run: async (client, i) => {
-      const e = await client.experiments.resolve(i.name);
-      return client.experiments.archive(e.id);
-    }
-  },
-  {
-    group: GROUP3,
-    name: "restore",
-    mutates: true,
-    summary: "Restore an archived experiment to draft",
-    description: "Restore a soft-deleted (archived) experiment back to `draft`. Allowed only if it never started; one that already ran must be cloned instead. Preserves the goal metric.",
-    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release experiments restore pricing-page" }],
-    run: async (client, i) => {
-      const e = await client.experiments.resolve(i.name);
-      return client.experiments.restore(e.id);
-    }
-  },
-  {
-    group: GROUP3,
-    name: "reanalyze",
-    mutates: true,
-    summary: "Re-run the analysis pass",
-    description: "Trigger a fresh analysis pass for an experiment.",
-    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release experiments reanalyze pricing-page" }],
-    run: async (client, i) => {
-      const e = await client.experiments.resolve(i.name);
-      return client.experiments.reanalyze(e.id);
-    }
-  },
-  {
-    group: GROUP3,
-    name: "status",
-    mutates: false,
-    summary: "Show experiment status, verdict, and latest results",
-    description: "Return the experiment, its latest per-metric results (enrolment, deltas, p-values), and a ship/hold/wait/not_running/invalid_srm verdict computed from the goal metric vs the significance threshold and minimum runtime.",
-    params: [{ name: "name", type: "string", description: "Experiment name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release experiments status pricing-page" }],
-    run: async (client, i) => {
-      const e = await client.experiments.resolve(i.name);
-      const detail = await client.experiments.get(e.id).catch(() => e);
-      const results = await client.experiments.results(e.id).catch(() => []);
-      const { verdict, reason } = computeVerdict(detail, results);
-      return { verdict, ...reason ? { reason } : {}, experiment: detail, results };
-    }
-  }
-];
-
-// src/operations/universes.ts
-var GROUP4 = ["release", "experiments", "universes"];
-function parseHoldout(raw) {
-  if (raw === void 0 || raw === "" || raw === "null") return null;
-  const [lo, hi] = raw.split(",").map((s) => Number(s.trim()));
-  if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
-    throw new ApiError("holdout must be 'lo,hi' integers in [0,9999]", 400);
-  }
-  return [lo, hi];
-}
-var universeOperations = [
-  {
-    group: GROUP4,
-    name: "list",
-    mutates: false,
-    summary: "List universes",
-    description: "Return every experiment universe (allocation %, holdout %).",
-    params: [],
-    examples: [{ run: "shipeasy release experiments universes list" }],
-    run: (client) => client.universes.listAll()
-  },
-  {
-    group: GROUP4,
-    name: "create",
-    mutates: true,
-    summary: "Create a universe",
-    description: "Create an experiment universe (container + optional holdout).",
-    params: [
-      { name: "name", type: "string", description: "Universe name.", required: true, positional: true },
-      { name: "unitType", type: "string", description: "Unit type (e.g. user_id, account_id). Defaults to user_id." },
-      { name: "holdout", type: "string", description: "Holdout range as 'lo,hi' (0\u20139999); omit for no holdout." }
-    ],
-    examples: [
-      { note: "Default user_id unit, no holdout", run: "shipeasy release experiments universes create web" },
-      { note: "Holdout 0\u2013999, keyed on account_id", run: "shipeasy release experiments universes create web --unit-type account_id --holdout 0,999" }
-    ],
-    run: (client, i) => client.universes.create({
-      name: i.name,
-      unit_type: str(i, "unitType") ?? "user_id",
-      holdout_range: parseHoldout(str(i, "holdout"))
-    })
-  },
-  {
-    group: GROUP4,
-    name: "update",
-    mutates: true,
-    summary: "Update a universe's holdout range",
-    description: "Update the holdout range. Pass 'null' to clear the holdout.",
-    params: [
-      { name: "name", type: "string", description: "Universe name.", required: true, positional: true },
-      { name: "holdout", type: "string", description: "Holdout range as 'lo,hi' (0\u20139999), or 'null' to clear." }
-    ],
-    examples: [
-      { note: "Set a 5% holdout", run: "shipeasy release experiments universes update web --holdout 0,499" },
-      { note: "Clear the holdout", run: "shipeasy release experiments universes update web --holdout null" }
-    ],
-    run: async (client, i) => {
-      const x = await client.universes.resolve(i.name);
-      const patch = i.holdout === void 0 ? {} : { holdout_range: parseHoldout(str(i, "holdout")) };
-      return client.universes.update(x.id, patch);
-    }
-  },
-  {
-    group: GROUP4,
-    name: "archive",
-    mutates: true,
-    summary: "Archive a universe",
-    description: "Archive (soft-delete) a universe by name.",
-    params: [{ name: "name", type: "string", description: "Universe name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy release experiments universes archive web" }],
-    run: async (client, i) => {
-      const x = await client.universes.resolve(i.name);
-      await client.universes.delete(x.id);
-      return { ok: true, archived: i.name };
-    }
-  }
-];
-
-// src/operations/metrics.ts
-var GROUP5 = ["metrics"];
-var METRIC_GRAMMAR = `Shipeasy metric query DSL
-=========================
-
-Query        := AggFunc "(" Selector ("," Identifier)? ")" GroupBy?
-AggFunc      := count_users | count | sum | avg | min | max | unique |
-                p50 | p75 | p90 | p95 | p99 | p999 |
-                retention_<N>d            (N in 1..90)
-Selector     := Identifier ("{" Filter ("," Filter)* ","? "}")?
-Filter       := Identifier MatchOp StringLiteral
-MatchOp      := "=" | "!=" | "=~" | "!~"
-StringLiteral := double-quoted, supports \\" and \\\\
-GroupBy      := ("by" | "without") "(" Identifier ("," Identifier)* ","? ")"
-
-Examples
---------
-  count_users(checkout_completed)
-  sum(purchase{country="US"}, amount)
-  p99(req_dur{route=~"/api/.*"}, ms) by (route, status)
-  retention_7d(session_start)
-  avg(req_dur{tier!="free"}, ms) without (region)
-
-Notes
------
-- One event selector per query (no formulas).
-- "count" maps to count_events (per-row count); "count_users" is uniq-by-user.
-- For experiments, "by (label)" is ignored \u2014 per-user reducer is applied.
-- Filter values must be quoted strings, even for numeric labels (they are coerced).
-- Filter labels and value labels must be declared on the source event.
-`;
-var metricOperations = [
-  {
-    group: GROUP5,
-    name: "grammar",
-    mutates: false,
-    summary: "Print the metric query DSL grammar",
-    description: "Return the full metric query DSL grammar \u2014 aggregation functions, event selectors, label filters, and group-by. A pure op: it ignores the client and never hits the API.",
-    params: [],
-    examples: [{ run: "shipeasy metrics grammar" }],
-    run: async () => ({ grammar: METRIC_GRAMMAR })
-  },
-  {
-    group: GROUP5,
-    name: "list",
-    mutates: false,
-    summary: "List all metrics",
-    description: "Return every metric in the project (name, folder, source event, aggregation).",
-    params: [],
-    examples: [{ run: "shipeasy metrics list" }],
-    run: (client) => client.metrics.list()
-  },
-  {
-    group: GROUP5,
-    name: "show",
-    mutates: false,
-    summary: "Show one metric",
-    description: "Resolve a metric by id, id-prefix, or name and return its full detail.",
-    params: [{ name: "metric", type: "string", description: "Metric id or name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy metrics show checkouts" }],
-    run: (client, i) => client.metrics.resolve(i.metric)
-  },
-  {
-    group: GROUP5,
-    name: "create",
-    mutates: true,
-    summary: "Create a metric",
-    description: "Create an event-backed metric. Pass the query as the DSL string (`query`) or the typed IR form (`queryIr`). `event` must match the event the query references. Run `metrics grammar` for the DSL syntax.",
-    params: [
-      { name: "name", type: "string", description: "Metric name.", required: true, positional: true },
-      { name: "event", type: "string", description: "Source event name (must equal the query's event).", required: true },
-      { name: "query", type: "string", description: "Query DSL string, e.g. 'sum(purchase, amount)'." },
-      { name: "queryIr", type: "json", description: "Typed IR JSON (alternative to query)." },
-      { name: "folder", type: "string", description: "Folder to file the metric under." },
-      { name: "winsorize", type: "number", description: "Winsorize percentile (1\u201399). Defaults to 99." },
-      { name: "mde", type: "number", description: "Min detectable effect (0\u20131)." }
-    ],
-    examples: [
-      { note: "Unique users who completed checkout", run: "shipeasy metrics create checkouts --event checkout_completed --query 'count_users(checkout_completed)'" },
-      { note: "p99 latency grouped by route", run: `shipeasy metrics create api-latency --event req_dur --query 'p99(req_dur{route=~"/api/.*"}, ms) by (route)'` }
-    ],
-    run: (client, i) => client.metrics.create({
-      name: i.name,
-      event_name: i.event,
-      folder: str(i, "folder") ?? null,
-      winsorize_pct: num(i, "winsorize") ?? 99,
-      min_detectable_effect: num(i, "mde") ?? null,
-      ...i.query ? { query: i.query } : {},
-      ...i.queryIr ? { query_ir: i.queryIr } : {}
-    })
-  },
-  {
-    group: GROUP5,
-    name: "archive",
-    mutates: true,
-    summary: "Archive a metric",
-    description: "Archive (soft-delete) a metric by id or name.",
-    params: [{ name: "metric", type: "string", description: "Metric id or name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy metrics archive checkouts" }],
-    run: async (client, i) => {
-      const m = await client.metrics.resolve(i.metric);
-      await client.metrics.delete(m.id);
-      return { ok: true, archived: m.name };
-    }
-  }
-];
-
-// src/operations/events.ts
-var GROUP6 = ["events"];
-var PROPS_DESC = `Event properties as a JSON array, e.g. '[{"name":"amount","type":"number","required":true}]'. type is one of string|number|boolean. Replaces the full set on update/approve.`;
-function props(i) {
-  return i.props === void 0 ? void 0 : i.props;
-}
-var eventOperations = [
-  {
-    group: GROUP6,
-    name: "list",
-    mutates: false,
-    summary: "List catalogued events",
-    description: "List every catalogued event (including pending auto-discovered names). Pass `pending` to show only the unapproved queue.",
-    params: [{ name: "pending", type: "boolean", description: "Show only pending (unapproved) events." }],
-    examples: [
-      { run: "shipeasy metrics events list" },
-      { note: "Review the auto-discovered queue", run: "shipeasy metrics events list --pending true" }
-    ],
-    run: async (client, i) => {
-      const rows = await client.events.list();
-      return bool(i, "pending") ? rows.filter((e) => e.pending === 1) : rows;
-    }
-  },
-  {
-    group: GROUP6,
-    name: "get",
-    mutates: false,
-    summary: "Show one catalogued event",
-    description: "Resolve an event by id, id-prefix, or name and return its full detail.",
-    params: [{ name: "event", type: "string", description: "Event id or name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy metrics events get checkout_completed" }],
-    run: (client, i) => client.events.resolve(i.event)
-  },
-  {
-    group: GROUP6,
-    name: "create",
-    mutates: true,
-    summary: "Register a new event",
-    description: "Register a new event name and (optionally) its typed properties.",
-    params: [
-      { name: "name", type: "string", description: "Event name.", required: true, positional: true },
-      { name: "folder", type: "string", description: "Folder to file it under." },
-      { name: "description", type: "string", description: "Human-readable description." },
-      { name: "props", type: "json", description: PROPS_DESC }
-    ],
-    examples: [
-      { run: "shipeasy metrics events create checkout_completed" },
-      { note: "With a typed, required property", run: `shipeasy metrics events create purchase --props '[{"name":"amount","type":"number","required":true}]'` }
-    ],
-    run: (client, i) => client.events.create({
-      name: i.name,
-      folder: str(i, "folder") ?? null,
-      ...i.description ? { description: i.description } : {},
-      properties: props(i) ?? []
-    })
-  },
-  {
-    group: GROUP6,
-    name: "update",
-    mutates: true,
-    summary: "Update an event",
-    description: "Update an event's folder, description, or properties (props replace the full set).",
-    params: [
-      { name: "event", type: "string", description: "Event id.", required: true, positional: true },
-      { name: "folder", type: "string", description: "New folder." },
-      { name: "description", type: "string", description: "New description." },
-      { name: "props", type: "json", description: PROPS_DESC }
-    ],
-    examples: [{ run: "shipeasy metrics events update evt_3f9a --folder checkout" }],
-    run: (client, i) => {
-      const patch = {};
-      if (i.folder !== void 0) patch.folder = i.folder;
-      if (i.description !== void 0) patch.description = i.description;
-      const p = props(i);
-      if (p) patch.properties = p;
-      return client.events.update(i.event, patch);
-    }
-  },
-  {
-    group: GROUP6,
-    name: "approve",
-    mutates: true,
-    summary: "Approve a pending event",
-    description: "Promote a pending (auto-discovered) event so metrics can query it. Optionally declare its folder/props on approval.",
-    params: [
-      { name: "event", type: "string", description: "Event id.", required: true, positional: true },
-      { name: "folder", type: "string", description: "Folder to file it under." },
-      { name: "description", type: "string", description: "Description." },
-      { name: "props", type: "json", description: PROPS_DESC }
-    ],
-    examples: [{ note: "Promote an auto-discovered event", run: "shipeasy metrics events approve evt_3f9a" }],
-    run: (client, i) => {
-      const body = {};
-      if (i.folder !== void 0) body.folder = i.folder;
-      if (i.description !== void 0) body.description = i.description;
-      const p = props(i);
-      if (p) body.properties = p;
-      return client.events.approve(i.event, body);
-    }
-  },
-  {
-    group: GROUP6,
-    name: "archive",
-    mutates: true,
-    summary: "Archive an event",
-    description: "Archive (remove) an event from the catalog by id.",
-    params: [{ name: "event", type: "string", description: "Event id.", required: true, positional: true }],
-    examples: [{ run: "shipeasy metrics events archive evt_3f9a" }],
-    run: async (client, i) => {
-      await client.events.delete(i.event);
-      return { ok: true, archived: i.event };
-    }
-  }
-];
-
-// src/operations/ops.ts
-var QUEUE = ["ops"];
-var ALERTS = ["ops", "alerts"];
-var TYPES = ["bug", "feature_request", "error", "alert"];
-var STATUSES = [
-  "open",
-  "triaged",
-  "in_progress",
-  "ready_for_qa",
-  "resolved",
-  "wont_fix"
-];
-var PRIORITIES = ["nice_to_have", "medium", "high", "critical"];
-var COMPARATORS = ["gt", "gte", "lt", "lte"];
-var SEVERITIES = ["danger", "warn", "info"];
-async function resolveSlackChannel(client, idOrName) {
-  const res = await client.ops.channels();
-  if (!res.connected)
-    throw new ApiError("No Slack connector \u2014 connect Slack in Settings \u2192 Notifications first.", 400);
-  const stripped = idOrName.replace(/^#/, "");
-  const byId = res.channels.find((c) => c.id === idOrName);
-  if (byId) return { id: byId.id, name: byId.name };
-  const byName = res.channels.filter((c) => c.name === stripped);
-  if (byName.length === 1) return { id: byName[0].id, name: byName[0].name };
-  if (byName.length > 1)
-    throw new ApiError(`Slack channel name '${stripped}' is ambiguous \u2014 pass a channel id`, 400);
-  throw new ApiError(`Slack channel '${idOrName}' not found (run 'ops alerts channels')`, 404);
-}
-var opsOperations = [
-  // ── unified queue ──────────────────────────────────────────────────────────
-  {
-    group: QUEUE,
-    name: "list",
-    mutates: false,
-    summary: "List the operational queue",
-    description: "List the unified queue \u2014 bugs, feature requests, and auto-filed error/alert tickets. Filter by `type`, `status`, or `priority`.",
-    params: [
-      { name: "type", type: "string", description: "Filter by type.", enum: [...TYPES, "all"] },
-      { name: "status", type: "string", description: "Filter by status.", enum: [...STATUSES, "all"] },
-      { name: "priority", type: "string", description: "Filter by priority.", enum: PRIORITIES },
-      { name: "limit", type: "number", description: "Max rows (default 200)." }
-    ],
-    examples: [
-      { note: "Open critical items only", run: "shipeasy ops list --priority critical" },
-      { note: "Just error tickets", run: "shipeasy ops list --type error" }
-    ],
-    run: async (client, i) => {
-      let items = await client.ops.list({
-        type: str(i, "type") ?? "all",
-        status: str(i, "status") ?? "open",
-        limit: num(i, "limit") ?? 200
-      });
-      const priority = str(i, "priority");
-      if (priority) items = items.filter((x) => x.priority === priority);
-      return items;
-    }
-  },
-  {
-    group: QUEUE,
-    name: "get",
-    mutates: false,
-    summary: "Show one queue item",
-    description: "Show one queue item by number (#7 \u2192 7) or id \u2014 any type.",
-    params: [{ name: "handle", type: "string", description: "Item number or id.", required: true, positional: true }],
-    examples: [{ note: "By queue number", run: "shipeasy ops get 7" }],
-    run: (client, i) => client.ops.get(i.handle)
-  },
-  {
-    group: QUEUE,
-    name: "create",
-    mutates: true,
-    summary: "File a bug or feature request",
-    description: "File an operational item \u2014 a bug report or feature request \u2014 against the bound project. Fires the project's connectors (GitHub issue, Slack). error/alert tickets are auto-filed and cannot be created here.",
-    params: [
-      { name: "type", type: "string", description: "Item type.", required: true, enum: ["bug", "feature_request"] },
-      { name: "title", type: "string", description: "One-line title.", required: true, positional: true },
-      { name: "body", type: "string", description: "Detailed description." },
-      { name: "priority", type: "string", description: "Priority.", enum: PRIORITIES },
-      { name: "stepsToReproduce", type: "string", description: "Repro steps (bugs)." },
-      { name: "pageUrl", type: "string", description: "Page URL the item relates to." }
-    ],
-    examples: [
-      { note: "File a bug", run: 'shipeasy ops create "Checkout 500s on Safari" --type bug' },
-      { note: "File a feature request", run: 'shipeasy ops create "Dark mode" --type feature_request --priority medium' }
-    ],
-    run: (client, i) => client.ops.create({
-      type: i.type,
-      title: i.title,
-      ...i.body ? { body: i.body } : {},
-      ...i.priority ? { priority: i.priority } : {},
-      ...i.stepsToReproduce ? { stepsToReproduce: i.stepsToReproduce } : {},
-      ...i.pageUrl ? { pageUrl: i.pageUrl } : {}
-    })
-  },
-  {
-    group: QUEUE,
-    name: "update",
-    mutates: true,
-    summary: "Update a queue item's status/priority",
-    description: "Flip a queue item's status (any type) and optionally its priority.",
-    params: [
-      { name: "handle", type: "string", description: "Item number or id.", required: true, positional: true },
-      { name: "status", type: "string", description: "New status.", enum: STATUSES },
-      { name: "priority", type: "string", description: "New priority.", enum: PRIORITIES }
-    ],
-    examples: [
-      { note: "Resolve item #7", run: "shipeasy ops update 7 --status resolved" },
-      { note: "Bump priority", run: "shipeasy ops update 7 --priority high" }
-    ],
-    run: (client, i) => {
-      const patch = {};
-      if (i.status !== void 0) patch.status = i.status;
-      if (i.priority !== void 0) patch.priority = i.priority;
-      if (!Object.keys(patch).length)
-        throw new ApiError("Nothing to update \u2014 pass status and/or priority.", 400);
-      return client.ops.update(i.handle, patch);
-    }
-  },
-  {
-    group: QUEUE,
-    name: "link-pr",
-    mutates: true,
-    summary: "Link the PR that fixed an item",
-    description: "Link the PR that fixed a queue item (any type). Records connector_data.github.pr. Pass `remove` to unlink.",
-    params: [
-      { name: "handle", type: "string", description: "Item number or id.", required: true, positional: true },
-      { name: "prNumber", type: "number", description: "PR number.", positional: true },
-      { name: "url", type: "string", description: "Explicit PR URL (required for error/alert tickets)." },
-      { name: "remove", type: "boolean", description: "Unlink the PR instead of setting one." }
-    ],
-    examples: [
-      { note: "Link the fixing PR", run: "shipeasy ops link-pr 7 42 --url https://github.com/acme/app/pull/42" }
-    ],
-    run: (client, i) => {
-      if (i.remove) return client.ops.linkPr(i.handle, { prNumber: null });
-      const prNumber = num(i, "prNumber");
-      if (prNumber === void 0 || !Number.isInteger(prNumber) || prNumber <= 0)
-        throw new ApiError("Pass a positive PR number (or --remove to unlink).", 400);
-      return client.ops.linkPr(i.handle, {
-        prNumber,
-        ...i.url ? { prUrl: i.url } : {}
-      });
-    }
-  },
-  {
-    group: QUEUE,
-    name: "notify",
-    mutates: true,
-    summary: "Raise a 'needs your attention' bell notification",
-    description: "Raise an attention bell notification (agent escalation, create-only). Idempotent on the dedupe key \u2014 pass `item` to derive `feedback:<n>`, or an explicit `key`.",
-    params: [
-      { name: "title", type: "string", description: "One-line headline of what's blocked.", required: true },
-      { name: "summary", type: "string", description: "One sentence: why it can't be fixed in code.", required: true },
-      { name: "steps", type: "json", description: "Steps the human should take, as a JSON array of strings." },
-      { name: "href", type: "string", description: "Dashboard-relative deep link." },
-      { name: "item", type: "string", description: "Queue item number this is about (sets dedupe key feedback:<n>)." },
-      { name: "key", type: "string", description: "Explicit dedupe key (overrides item)." }
-    ],
-    examples: [
-      { note: "Escalate a blocked item", run: `shipeasy ops notify --item 7 --title "Needs a DB migration" --summary "Fix requires a schema change I can't apply in code"` }
-    ],
-    run: (client, i) => {
-      const item = str(i, "item");
-      const dedupeKey = str(i, "key") ?? (item ? `feedback:${item.replace(/^#/, "")}` : void 0);
-      return client.ops.notify({
-        title: i.title,
-        summary: i.summary,
-        steps: i.steps ?? [],
-        ...i.href ? { href: i.href } : {},
-        ...dedupeKey ? { dedupeKey } : {}
-      });
-    }
-  },
-  // ── alert rules (ops alerts …) ───────────────────────────────────────────────
-  {
-    group: ALERTS,
-    name: "list",
-    mutates: false,
-    summary: "List alert rules",
-    description: "List the project's metric-threshold alert rules the analysis cron evaluates.",
-    params: [],
-    examples: [{ run: "shipeasy ops alerts list" }],
-    run: (client) => client.alertRules.list()
-  },
-  {
-    group: ALERTS,
-    name: "channels",
-    mutates: false,
-    summary: "List the project's Slack channels",
-    description: "List the project's Slack channels (for the `slackChannel` alert target).",
-    params: [],
-    examples: [{ run: "shipeasy ops alerts channels" }],
-    run: (client) => client.ops.channels()
-  },
-  {
-    group: ALERTS,
-    name: "create",
-    mutates: true,
-    summary: "Create an alert rule",
-    description: "Create a metric-threshold alert rule. The metric (and its aggregation) is fixed for the rule's life \u2014 delete + recreate to repoint it. Optionally target a Slack channel/email.",
-    params: [
-      { name: "name", type: "string", description: "Rule name.", required: true, positional: true },
-      { name: "metric", type: "string", description: "Metric to evaluate (id or name).", required: true },
-      { name: "comparator", type: "string", description: "Comparison operator.", required: true, enum: COMPARATORS },
-      { name: "threshold", type: "number", description: "Threshold the metric value is compared against.", required: true },
-      { name: "window", type: "number", description: "Lookback window in whole hours (1\u2013720). Defaults to 24." },
-      { name: "severity", type: "string", description: "Severity. Defaults to warn.", enum: SEVERITIES },
-      { name: "disabled", type: "boolean", description: "Create the rule disabled." },
-      { name: "slackChannel", type: "string", description: "Slack channel to post to (id or name)." },
-      { name: "email", type: "string", description: "Email address to notify." }
-    ],
-    examples: [
-      { note: "Alert when error rate exceeds 50 / 24h", run: "shipeasy ops alerts create high-error-rate --metric api-errors --comparator gt --threshold 50" },
-      { note: "Post to a Slack channel + email on-call", run: "shipeasy ops alerts create high-error-rate --metric api-errors --comparator gt --threshold 50 --slack-channel '#incidents' --email oncall@acme.com" }
-    ],
-    run: async (client, i) => {
-      const metric = await client.metrics.resolve(i.metric);
-      const slackChannel = str(i, "slackChannel");
-      const email = str(i, "email");
-      const notify = slackChannel || email ? {
-        slackChannel: slackChannel ? await resolveSlackChannel(client, slackChannel) : null,
-        email: email ?? null
-      } : void 0;
-      return client.alertRules.create({
-        name: i.name,
-        metricId: metric.id,
-        comparator: i.comparator,
-        threshold: num(i, "threshold"),
-        windowHours: num(i, "window") ?? 24,
-        severity: str(i, "severity") ?? "warn",
-        enabled: !i.disabled,
-        ...notify ? { notify } : {}
-      });
-    }
-  },
-  {
-    group: ALERTS,
-    name: "update",
-    mutates: true,
-    summary: "Update an alert rule",
-    description: "Update an alert rule's tunable knobs (by id, id-prefix, or unique name). The metric is immutable. Pass `clearTarget` to revert the rule's target to the project default.",
-    params: [
-      { name: "rule", type: "string", description: "Rule id, id-prefix, or name.", required: true, positional: true },
-      { name: "name", type: "string", description: "New human label." },
-      { name: "comparator", type: "string", description: "Comparison operator.", enum: COMPARATORS },
-      { name: "threshold", type: "number", description: "New threshold." },
-      { name: "window", type: "number", description: "New lookback window in whole hours (1\u2013720)." },
-      { name: "severity", type: "string", description: "New severity.", enum: SEVERITIES },
-      { name: "enabled", type: "boolean", description: "Enable/disable the rule." },
-      { name: "slackChannel", type: "string", description: "Set the Slack channel target (id or name)." },
-      { name: "email", type: "string", description: "Set the email target." },
-      { name: "clearTarget", type: "boolean", description: "Clear the target back to the project default." }
-    ],
-    examples: [
-      { note: "Raise the threshold", run: "shipeasy ops alerts update high-error-rate --threshold 100" },
-      { note: "Disable a rule", run: "shipeasy ops alerts update high-error-rate --enabled false" }
-    ],
-    run: async (client, i) => {
-      const rule = await client.alertRules.resolve(i.rule);
-      const patch = {};
-      if (i.name !== void 0) patch.name = i.name;
-      if (i.comparator !== void 0) patch.comparator = i.comparator;
-      if (i.threshold !== void 0) patch.threshold = num(i, "threshold");
-      if (i.window !== void 0) patch.windowHours = num(i, "window");
-      if (i.severity !== void 0) patch.severity = i.severity;
-      if (i.enabled !== void 0) patch.enabled = i.enabled;
-      const slackChannel = str(i, "slackChannel");
-      const email = str(i, "email");
-      if (i.clearTarget) {
-        patch.notify = { slackChannel: null, email: null };
-      } else if (slackChannel || email) {
-        patch.notify = {
-          slackChannel: slackChannel ? await resolveSlackChannel(client, slackChannel) : rule.notify?.slackChannel ?? null,
-          email: email ?? rule.notify?.email ?? null
-        };
-      }
-      if (!Object.keys(patch).length)
-        throw new ApiError("Nothing to update \u2014 pass at least one field to change.", 400);
-      return client.alertRules.update(rule.id, patch);
-    }
-  },
-  {
-    group: ALERTS,
-    name: "archive",
-    mutates: true,
-    summary: "Archive an alert rule",
-    description: "Archive (delete) an alert rule by id, id-prefix, or unique name.",
-    params: [{ name: "rule", type: "string", description: "Rule id, id-prefix, or name.", required: true, positional: true }],
-    examples: [{ run: "shipeasy ops alerts archive high-error-rate" }],
-    run: async (client, i) => {
-      const rule = await client.alertRules.resolve(i.rule);
-      await client.alertRules.delete(rule.id);
-      return { ok: true, archived: rule.name };
-    }
-  }
-];
-
-// src/operations/projects.ts
-var GROUP7 = ["projects"];
-var projectOperations = [
-  {
-    group: GROUP7,
-    name: "current",
-    mutates: false,
-    summary: "Show the current project",
-    description: "Return the project the session resolves to (plan, status, enabled modules, billing). The server reads the project from the auth header \u2014 no id needed. Powers `whoami`.",
-    params: [],
-    examples: [{ run: "shipeasy projects current" }],
-    run: (client) => client.projects.current()
-  },
-  {
-    group: GROUP7,
-    name: "upsert",
-    mutates: false,
-    summary: "Find-or-create a project by domain",
-    description: "Find-or-create a project by domain (idempotent), under the session's owner. Returns the project. The `.shipeasy` bind that records the result locally is a consumer side-effect layered on top of this op \u2014 it is not performed here.",
-    params: [
-      { name: "domain", type: "string", description: "Hostname-like project identifier (e.g. acme.com).", required: true },
-      { name: "name", type: "string", description: "Human-readable name (defaults to the domain on first create)." }
-    ],
-    examples: [
-      { note: "Find-or-create by domain", run: "shipeasy projects upsert --domain acme.com" },
-      { note: "Name it explicitly", run: 'shipeasy projects upsert --domain shouks.app --name "Shouks"' }
-    ],
-    run: (client, i) => client.projects.upsert({
-      domain: i.domain,
-      ...i.name ? { name: i.name } : {}
-    })
-  }
-];
-
-// src/operations/i18n.ts
-var I18N = ["i18n"];
-var PROFILES2 = ["i18n", "profiles"];
-var DRAFTS2 = ["i18n", "drafts"];
-var i18nOperations = [
-  {
-    group: PROFILES2,
-    name: "list",
-    mutates: false,
-    summary: "List i18n locale profiles",
-    description: "List the project's i18n locale profiles (name, default locale, locales).",
-    params: [],
-    examples: [{ run: "shipeasy i18n profiles list" }],
-    run: (client) => client.i18n.listProfiles()
-  },
-  {
-    group: PROFILES2,
-    name: "create",
-    mutates: true,
-    summary: "Create an i18n locale profile",
-    description: "Create an i18n profile (e.g. 'en:prod', 'fr:prod') with one or more locales.",
-    params: [
-      { name: "name", type: "string", description: "Profile name.", required: true, positional: true },
-      { name: "locales", type: "json", description: `Locales as a JSON array, e.g. '["fr","fr-CA"]'. Defaults to ["en"].` },
-      { name: "defaultLocale", type: "string", description: "Default locale (defaults to the first locale)." }
-    ],
-    examples: [
-      { run: "shipeasy i18n profiles create en:prod" },
-      { note: "Multiple locales with a default", run: `shipeasy i18n profiles create fr:prod --locales '["fr","fr-CA"]' --default-locale fr` }
-    ],
-    run: (client, i) => {
-      const locales = i.locales ?? ["en"];
-      return client.i18n.createProfile({
-        name: i.name,
-        locales,
-        default_locale: str(i, "defaultLocale") ?? locales[0]
-      });
-    }
-  },
-  {
-    group: I18N,
-    name: "push",
-    mutates: true,
-    summary: "Add new i18n keys (insert-only)",
-    description: "Add NEW keys to a profile. Insert-only \u2014 existing keys are never overwritten (use `i18n update` to change a value). Keys are a JSON array of {key,value}.",
-    params: [
-      { name: "profile", type: "string", description: "Profile name (e.g. 'en:prod').", required: true },
-      { name: "keys", type: "json", description: `Keys as a JSON array, e.g. '[{"key":"home.cta","value":"Get started"}]'.`, required: true },
-      { name: "chunk", type: "string", description: "Logical grouping for the keys. Defaults to 'default'." }
-    ],
-    examples: [
-      { note: "Add keys to a profile", run: `shipeasy i18n push --profile en:prod --keys '[{"key":"home.cta","value":"Get started"}]'` }
-    ],
-    run: async (client, i) => {
-      const profile = await client.i18n.resolveProfile(i.profile);
-      return client.i18n.pushKeys({
-        profile_id: profile.id,
-        chunk: str(i, "chunk") ?? "default",
-        keys: i.keys
-      });
-    }
-  },
-  {
-    group: I18N,
-    name: "update",
-    mutates: true,
-    summary: "Update one i18n key's value",
-    description: "Change the value of a single existing key (the only overwrite path; `push` only adds). One key per call.",
-    params: [
-      { name: "key", type: "string", description: "Key name.", required: true, positional: true },
-      { name: "value", type: "string", description: "New value.", required: true, positional: true },
-      { name: "profile", type: "string", description: "Profile name (e.g. 'en:prod').", required: true },
-      { name: "description", type: "string", description: "Optional description to store with the key." }
-    ],
-    examples: [
-      { note: "Change one key's value", run: "shipeasy i18n update home.cta 'Get started' --profile en:prod" }
-    ],
-    run: async (client, i) => {
-      const profile = await client.i18n.resolveProfile(i.profile);
-      return client.i18n.updateKeyByName(profile.id, i.key, {
-        value: i.value,
-        ...i.description !== void 0 ? { description: i.description } : {}
-      });
-    }
-  },
-  {
-    group: I18N,
-    name: "publish",
-    mutates: true,
-    summary: "Publish a profile chunk to the CDN",
-    description: "Publish a profile chunk (rebuilds the KV manifest and purges the CDN).",
-    params: [
-      { name: "profile", type: "string", description: "Profile name (e.g. 'en:prod').", required: true },
-      { name: "chunk", type: "string", description: "Chunk to publish. Defaults to 'default'." }
-    ],
-    examples: [
-      { note: "Publish the default chunk", run: "shipeasy i18n publish --profile en:prod" },
-      { note: "Publish a specific chunk", run: "shipeasy i18n publish --profile fr:prod --chunk marketing" }
-    ],
-    run: async (client, i) => {
-      const profile = await client.i18n.resolveProfile(i.profile);
-      return client.i18n.publish(profile.id, { chunk: str(i, "chunk") ?? "default" });
-    }
-  },
-  {
-    group: DRAFTS2,
-    name: "list",
-    mutates: false,
-    summary: "List staged i18n drafts",
-    description: "List staged translation drafts. Replaces the `drafts` kind of the deleted MCP generic read.",
-    params: [],
-    examples: [{ run: "shipeasy i18n drafts list" }],
-    run: (client) => client.i18n.listDrafts()
-  }
-];
-
-// src/operations/attributes.ts
-var attributeOperations = [
-  {
-    group: ["attributes"],
-    name: "list",
-    mutates: false,
-    summary: "List targeting attributes",
-    description: "List the auto-inferred user-attribute schema available for gate/experiment targeting.",
-    params: [],
-    examples: [{ run: "shipeasy attributes list" }],
-    run: (client) => client.attributes.list()
-  }
-];
-
-// src/operations/sdk-docs.ts
-var SDK_REPOS = {
-  typescript: { owner: "shipeasy-ai", repo: "sdk" },
-  javascript: { owner: "shipeasy-ai", repo: "sdk" },
-  node: { owner: "shipeasy-ai", repo: "sdk" },
-  ts: { owner: "shipeasy-ai", repo: "sdk" },
-  python: { owner: "shipeasy-ai", repo: "sdk-python" },
-  go: { owner: "shipeasy-ai", repo: "sdk-go" },
-  java: { owner: "shipeasy-ai", repo: "sdk-java" },
-  kotlin: { owner: "shipeasy-ai", repo: "sdk-kotlin" },
-  php: { owner: "shipeasy-ai", repo: "sdk-php" },
-  swift: { owner: "shipeasy-ai", repo: "sdk-swift" },
-  ruby: { owner: "shipeasy-ai", repo: "sdk-ruby" }
-};
-var SDK_ENUM = Object.keys(SDK_REPOS);
-var DEFAULT_MANIFEST = {
-  schemaVersion: 2,
-  sdk: "default",
-  placeholders: ["RESOURCE_NAME"],
-  skill: "skill/SKILL.md",
-  pages: { overview: "pages/overview.md", installation: "pages/installation.md" },
-  snippets: { release: { flags: "snippets/release/flags.md" } }
-};
-var DEFAULT_CONTENT = {
-  "pages/overview.md": "# Shipeasy SDK\n\nThis SDK has not published its `/docs/` folder yet. See https://docs.shipeasy.ai for the full reference.",
-  "pages/installation.md": "# Installation\n\nInstall the Shipeasy SDK for your language, then call `shipeasy({ serverKey })` (server) or `shipeasy({ clientKey })` (browser).",
-  "snippets/release/flags.md": "```\nconst on = await client.checkGate(user, '{{RESOURCE_NAME}}');\n```",
-  "skill/SKILL.md": "---\nname: shipeasy-sdk\ndescription: Use the Shipeasy SDK for flags, experiments, configs, and i18n.\n---\n\nThis SDK has not published a skill yet. See https://docs.shipeasy.ai."
-};
-function repoFor(sdk) {
-  const r = SDK_REPOS[sdk.toLowerCase()];
-  if (!r) throw new ApiError(`Unknown SDK '${sdk}'. One of: ${SDK_ENUM.join(", ")}`, 400);
-  return r;
-}
-function pagesBase(sdk) {
-  const { owner, repo } = repoFor(sdk);
-  return `https://${owner}.github.io/${repo}`;
-}
-async function fetchText(url) {
-  const res = await fetch(url);
-  if (!res.ok) return null;
-  return res.text();
-}
-async function loadManifest(sdk) {
-  const text = await fetchText(`${pagesBase(sdk)}/manifest.json`);
-  if (!text) return { manifest: DEFAULT_MANIFEST, fallback: true };
-  try {
-    return { manifest: JSON.parse(text), fallback: false };
-  } catch {
-    return { manifest: DEFAULT_MANIFEST, fallback: true };
-  }
-}
-function resolvePath(manifest, handle) {
-  if (handle.endsWith(".md")) return handle;
-  if (manifest.pages?.[handle]) return manifest.pages[handle];
-  if (handle.includes("/")) {
-    const [group, resource] = handle.split("/", 2);
-    const p = manifest.snippets?.[group]?.[resource];
-    if (p) return p;
-  }
-  throw new ApiError(
-    `Doc '${handle}' not found. Run 'docs list --sdk <lang>' to see available pages and snippets.`,
-    404
-  );
-}
-function substitute(body, manifest, i) {
-  let out = body;
-  for (const ph of manifest.placeholders ?? []) {
-    const value = str(i, ph) ?? (ph === "RESOURCE_NAME" ? str(i, "name") : void 0) ?? (ph === "FRAMEWORK" ? str(i, "framework") : void 0);
-    if (value !== void 0) out = out.replaceAll(`{{${ph}}}`, value);
-  }
-  return out;
-}
-var docsOperations = [
-  {
-    group: ["docs"],
-    name: "list",
-    mutates: false,
-    summary: "List an SDK's documentation tree",
-    description: "Fetch an SDK's `/docs/manifest.json` and return the doc tree \u2014 the feature-reference pages, the nested snippet groups, and whether an installable skill exists. The runtime 'explore' step before fetching a specific page or snippet.",
-    params: [{ name: "sdk", type: "string", description: "SDK language.", required: true, enum: SDK_ENUM }],
-    examples: [{ run: "shipeasy docs list --sdk python" }],
-    run: async (_client, i) => {
-      const { manifest, fallback } = await loadManifest(i.sdk);
-      return {
-        sdk: i.sdk,
-        fallback,
-        pages: Object.keys(manifest.pages ?? {}),
-        snippets: Object.fromEntries(
-          Object.entries(manifest.snippets ?? {}).map(([g, r]) => [g, Object.keys(r)])
-        ),
-        skill: Boolean(manifest.skill)
-      };
-    }
-  },
-  {
-    group: ["docs"],
-    name: "get",
-    mutates: false,
-    summary: "Fetch one SDK doc page or snippet",
-    description: "Fetch one feature-reference page (`flags`, `experiments`, \u2026) or nested snippet (`release/experiments`, `i18n/setup`, \u2026) from the SDK's published docs, substituting declared {{placeholders}} from caller args. Replaces the old `get_sdk_snippet`.",
-    params: [
-      { name: "sdk", type: "string", description: "SDK language.", required: true, enum: SDK_ENUM },
-      { name: "path", type: "string", description: "Page key or snippet 'group/resource'.", required: true, positional: true },
-      { name: "framework", type: "string", description: "Framework hint (substitutes {{FRAMEWORK}})." },
-      { name: "name", type: "string", description: "Resource name (substitutes {{RESOURCE_NAME}})." }
-    ],
-    examples: [
-      { note: "A feature page", run: "shipeasy docs get --sdk python experiments" },
-      { note: "A nested snippet, with a resource name", run: "shipeasy docs get --sdk typescript release/flags --name checkout_v2" }
-    ],
-    run: async (_client, i) => {
-      const sdk = i.sdk;
-      const { manifest, fallback } = await loadManifest(sdk);
-      const path = resolvePath(manifest, i.path);
-      const body = fallback ? DEFAULT_CONTENT[path] : await fetchText(`${pagesBase(sdk)}/${path}`) ?? void 0;
-      if (body === void 0) throw new ApiError(`Doc '${path}' could not be fetched for '${sdk}'.`, 404);
-      return { sdk, path, fallback, content: substitute(body, manifest, i) };
-    }
-  },
-  {
-    group: ["docs"],
-    name: "skill",
-    mutates: false,
-    summary: "Fetch an SDK's installable LLM skill",
-    description: "Fetch the SDK's `skill/SKILL.md` (YAML frontmatter intact) so an agent can install it verbatim into its skills directory. The CLI's `--install` writes it locally (a consumer fs side-effect layered on the fetch); the op itself just returns the bytes.",
-    params: [
-      { name: "sdk", type: "string", description: "SDK language.", required: true, enum: SDK_ENUM },
-      { name: "install", type: "boolean", description: "CLI only: write the skill to the local agent skills dir." }
-    ],
-    examples: [
-      { run: "shipeasy docs skill --sdk python" },
-      { note: "Install into the local skills dir", run: "shipeasy docs skill --sdk python --install true" }
-    ],
-    run: async (_client, i) => {
-      const sdk = i.sdk;
-      const { manifest, fallback } = await loadManifest(sdk);
-      const skillPath = manifest.skill ?? "skill/SKILL.md";
-      const content = fallback ? DEFAULT_CONTENT[skillPath] : await fetchText(`${pagesBase(sdk)}/${skillPath}`) ?? void 0;
-      if (content === void 0) throw new ApiError(`No skill published for '${sdk}'.`, 404);
-      return { sdk, skillPath, fallback, content };
-    }
-  }
-];
-
-// src/operations/index.ts
-var RELEASE_OPERATIONS = [
-  ...gateOperations,
-  ...killswitchOperations,
-  ...configOperations,
-  ...experimentOperations,
-  ...universeOperations
-];
-var ALL_OPERATIONS = [
-  ...RELEASE_OPERATIONS,
-  ...metricOperations,
-  ...eventOperations,
-  ...opsOperations,
-  ...projectOperations,
-  ...i18nOperations,
-  ...attributeOperations,
-  ...docsOperations
-];
 export {
-  ALL_OPERATIONS,
-  ApiError,
-  DEFAULT_PAGE_SIZE,
-  MAX_PAGE_SIZE,
-  METRIC_GRAMMAR,
-  RELEASE_OPERATIONS,
-  RESOURCE_REGISTRY,
-  alertRulesClient,
-  attributeOperations,
-  attributesClient,
-  coerceInput,
-  configOperations,
-  configsClient,
-  configsResource,
-  createAdminClient,
-  createHttpTransport,
-  decodeCursor,
-  docsOperations,
-  encodeCursor,
-  eventOperations,
-  eventsClient,
-  experimentOperations,
-  experimentsClient,
-  experimentsResource,
-  gateOperations,
-  gatesClient,
-  gatesResource,
-  i18nClient,
-  i18nOperations,
-  killswitchOperations,
-  killswitchesClient,
-  killswitchesResource,
-  metricOperations,
-  metricsClient,
-  mountOperations,
-  opCli,
-  opId,
-  opMcpName,
-  operationsToDispatch,
-  operationsToMcpTools,
-  opsClient,
-  opsOperations,
-  pageQuerySchema,
-  projectOperations,
-  projectsClient,
-  renderOperationsMarkdown,
-  universeOperations,
-  universesClient,
-  universesResource
+  ERROR_CODES,
+  approveEvent,
+  client,
+  configure,
+  createAlertRule,
+  createAttribute,
+  createClient,
+  createConfig as createClientConfig,
+  createConfig2 as createConfig,
+  createConnector,
+  createEvent,
+  createExperiment,
+  createGate,
+  createGateTemplate,
+  createI18nDraft,
+  createI18nProfile,
+  createKey,
+  createKillswitch,
+  createMetric,
+  createOpsItem,
+  createTriggerConnector,
+  createUniverse,
+  deleteAlertRule,
+  deleteAttribute,
+  deleteConfig,
+  deleteConnector,
+  deleteEvent,
+  deleteExperiment,
+  deleteGate,
+  deleteGateTemplate,
+  deleteKillswitch,
+  deleteMetric,
+  deleteUniverse,
+  disableGate,
+  discardConfigDraft,
+  enableGate,
+  errorCodeOf,
+  fileErrorTicket,
+  fireConnector,
+  formatAuthFailure,
+  getAttribute,
+  getConfig,
+  getConnector,
+  getCurrentProject,
+  getError,
+  getErrorSeries,
+  getEvent,
+  getExperiment,
+  getExperimentResults,
+  getExperimentTimeseries,
+  getGateTemplate,
+  getKillswitch,
+  getMetric,
+  getOpsItem,
+  isApiErrorBody,
+  linkPrToOpsItem,
+  listAlertRules,
+  listAttributes,
+  listConfigActivity,
+  listConfigs,
+  listConnectors,
+  listErrors,
+  listEvents,
+  listExperiments,
+  listGateTemplates,
+  listGates,
+  listI18nDrafts,
+  listI18nKeys,
+  listI18nProfiles,
+  listKeys,
+  listKillswitches,
+  listMetrics,
+  listOpsItems,
+  listSlackChannels,
+  listUniverses,
+  notifyOps,
+  publishConfigDraft,
+  publishI18nProfile,
+  pushI18nKeys,
+  reanalyzeExperiment,
+  revokeKey,
+  saveConfigDraft,
+  searchResources,
+  setExperimentMetrics,
+  setExperimentStatus,
+  setI18nLabel,
+  setKillswitchSwitch,
+  setKillswitchValue,
+  testConnector,
+  unsetKillswitchSwitch,
+  updateAlertRule,
+  updateAttribute,
+  updateConfig,
+  updateConfigSchema,
+  updateConnector,
+  updateErrorStatus,
+  updateEvent,
+  updateExperiment,
+  updateGate,
+  updateGateTemplate,
+  updateI18nDraft,
+  updateI18nKey,
+  updateKillswitch,
+  updateMetric,
+  updateOpsItem,
+  updateProject,
+  updateTriggerConnector,
+  updateUniverse,
+  upsertProject
 };
+//# sourceMappingURL=index.js.map