@shipeasy/openapi 1.0.0

package/dist/resources/killswitches.js

@@ -0,0 +1,2813 @@
+// src/resources/killswitches.ts
+import { z as z3 } from "zod";
+
+// ../core/src/schemas/killswitches.ts
+import { z as z2 } from "zod";
+
+// ../core/src/schemas/configs.ts
+import { z } from "zod";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/entity.js
+var entityKind = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(
+      `Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
+    );
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/column.js
+var Column = class {
+  constructor(table, config) {
+    this.table = table;
+    this.config = config;
+    this.name = config.name;
+    this.keyAsName = config.keyAsName;
+    this.notNull = config.notNull;
+    this.default = config.default;
+    this.defaultFn = config.defaultFn;
+    this.onUpdateFn = config.onUpdateFn;
+    this.hasDefault = config.hasDefault;
+    this.primary = config.primaryKey;
+    this.isUnique = config.isUnique;
+    this.uniqueName = config.uniqueName;
+    this.uniqueType = config.uniqueType;
+    this.dataType = config.dataType;
+    this.columnType = config.columnType;
+    this.generated = config.generated;
+    this.generatedIdentity = config.generatedIdentity;
+  }
+  static [entityKind] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = void 0;
+  generated = void 0;
+  generatedIdentity = void 0;
+  config;
+  mapFromDriverValue(value) {
+    return value;
+  }
+  mapToDriverValue(value) {
+    return value;
+  }
+  // ** @internal */
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+  static [entityKind] = "ColumnBuilder";
+  config;
+  constructor(name, dataType, columnType) {
+    this.config = {
+      name,
+      keyAsName: name === "",
+      notNull: false,
+      default: void 0,
+      hasDefault: false,
+      primaryKey: false,
+      isUnique: false,
+      uniqueName: void 0,
+      uniqueType: void 0,
+      dataType,
+      columnType,
+      generated: void 0
+    };
+  }
+  /**
+   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+   *
+   * @example
+   * ```ts
+   * const users = pgTable('users', {
+   * 	id: integer('id').$type<UserId>().primaryKey(),
+   * 	details: json('details').$type<UserDetails>().notNull(),
+   * });
+   * ```
+   */
+  $type() {
+    return this;
+  }
+  /**
+   * Adds a `not null` clause to the column definition.
+   *
+   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+   */
+  notNull() {
+    this.config.notNull = true;
+    return this;
+  }
+  /**
+   * Adds a `default <value>` clause to the column definition.
+   *
+   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+   *
+   * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+   */
+  default(value) {
+    this.config.default = value;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Adds a dynamic default value to the column.
+   * The function will be called when the row is inserted, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $defaultFn(fn) {
+    this.config.defaultFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Alias for {@link $defaultFn}.
+   */
+  $default = this.$defaultFn;
+  /**
+   * Adds a dynamic update value to the column.
+   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $onUpdateFn(fn) {
+    this.config.onUpdateFn = fn;
+    this.config.hasDefault = true;
+    return this;
+  }
+  /**
+   * Alias for {@link $onUpdateFn}.
+   */
+  $onUpdate = this.$onUpdateFn;
+  /**
+   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+   *
+   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+   */
+  primaryKey() {
+    this.config.primaryKey = true;
+    this.config.notNull = true;
+    return this;
+  }
+  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+  setName(name) {
+    if (this.config.name !== "")
+      return;
+    this.config.name = name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/table.utils.js
+var TableName = /* @__PURE__ */ Symbol.for("drizzle:Name");
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/foreign-keys.js
+var ForeignKeyBuilder = class {
+  static [entityKind] = "PgForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate = "no action";
+  /** @internal */
+  _onDelete = "no action";
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action === void 0 ? "no action" : action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action === void 0 ? "no action" : action;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new ForeignKey(table, this);
+  }
+};
+var ForeignKey = class {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "PgForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+  return fn(...args);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var UniqueConstraintBuilder = class {
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "PgUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  nullsNotDistinctConfig = false;
+  nullsNotDistinct() {
+    this.nullsNotDistinctConfig = true;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
+  }
+};
+var UniqueOnConstraintBuilder = class {
+  static [entityKind] = "PgUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder(columns, this.name);
+  }
+};
+var UniqueConstraint = class {
+  constructor(table, columns, nullsNotDistinct, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+    this.nullsNotDistinct = nullsNotDistinct;
+  }
+  static [entityKind] = "PgUniqueConstraint";
+  columns;
+  name;
+  nullsNotDistinct = false;
+  getName() {
+    return this.name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+  for (let i = startFrom; i < arrayString.length; i++) {
+    const char = arrayString[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+    }
+    if (inQuotes) {
+      continue;
+    }
+    if (char === "," || char === "}") {
+      return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
+    }
+  }
+  return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
+}
+function parsePgNestedArray(arrayString, startFrom = 0) {
+  const result = [];
+  let i = startFrom;
+  let lastCharIsComma = false;
+  while (i < arrayString.length) {
+    const char = arrayString[i];
+    if (char === ",") {
+      if (lastCharIsComma || i === startFrom) {
+        result.push("");
+      }
+      lastCharIsComma = true;
+      i++;
+      continue;
+    }
+    lastCharIsComma = false;
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === '"') {
+      const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    if (char === "}") {
+      return [result, i + 1];
+    }
+    if (char === "{") {
+      const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+      result.push(value2);
+      i = startFrom2;
+      continue;
+    }
+    const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+    result.push(value);
+    i = newStartFrom;
+  }
+  return [result, i];
+}
+function parsePgArray(arrayString) {
+  const [result] = parsePgNestedArray(arrayString, 1);
+  return result;
+}
+function makePgArray(array) {
+  return `{${array.map((item) => {
+    if (Array.isArray(item)) {
+      return makePgArray(item);
+    }
+    if (typeof item === "string") {
+      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return `${item}`;
+  }).join(",")}}`;
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumnBuilder = class extends ColumnBuilder {
+  foreignKeyConfigs = [];
+  static [entityKind] = "PgColumnBuilder";
+  array(size) {
+    return new PgArrayBuilder(this.config.name, this, size);
+  }
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name, config) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config?.nulls;
+    return this;
+  }
+  generatedAlwaysAs(as) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: "stored"
+    };
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return iife(
+        (ref2, actions2) => {
+          const builder = new ForeignKeyBuilder(() => {
+            const foreignColumn = ref2();
+            return { columns: [column], foreignColumns: [foreignColumn] };
+          });
+          if (actions2.onUpdate) {
+            builder.onUpdate(actions2.onUpdate);
+          }
+          if (actions2.onDelete) {
+            builder.onDelete(actions2.onDelete);
+          }
+          return builder.build(table);
+        },
+        ref,
+        actions
+      );
+    });
+  }
+  /** @internal */
+  buildExtraConfigColumn(table) {
+    return new ExtraConfigColumn(table, this.config);
+  }
+};
+var PgColumn = class extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "PgColumn";
+};
+var ExtraConfigColumn = class extends PgColumn {
+  static [entityKind] = "ExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: void 0
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+  /**
+   * ### PostgreSQL documentation quote
+   *
+   * > An operator class with optional parameters can be specified for each column of an index.
+   * The operator class identifies the operators to be used by the index for that column.
+   * For example, a B-tree index on four-byte integers would use the int4_ops class;
+   * this operator class includes comparison functions for four-byte integers.
+   * In practice the default operator class for the column's data type is usually sufficient.
+   * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
+   * For example, we might want to sort a complex-number data type either by absolute value or by real part.
+   * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
+   * More information about operator classes check:
+   *
+   * ### Useful links
+   * https://www.postgresql.org/docs/current/sql-createindex.html
+   *
+   * https://www.postgresql.org/docs/current/indexes-opclass.html
+   *
+   * https://www.postgresql.org/docs/current/xindex.html
+   *
+   * ### Additional types
+   * If you have the `pg_vector` extension installed in your database, you can use the
+   * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
+   *
+   * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
+   *
+   * @param opClass
+   * @returns
+   */
+  op(opClass) {
+    this.indexConfig.opClass = opClass;
+    return this;
+  }
+};
+var IndexedColumn = class {
+  static [entityKind] = "IndexedColumn";
+  constructor(name, keyAsName, type, indexConfig) {
+    this.name = name;
+    this.keyAsName = keyAsName;
+    this.type = type;
+    this.indexConfig = indexConfig;
+  }
+  name;
+  keyAsName;
+  type;
+  indexConfig;
+};
+var PgArrayBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgArrayBuilder";
+  constructor(name, baseBuilder, size) {
+    super(name, "array", "PgArray");
+    this.config.baseBuilder = baseBuilder;
+    this.config.size = size;
+  }
+  /** @internal */
+  build(table) {
+    const baseColumn = this.config.baseBuilder.build(table);
+    return new PgArray(
+      table,
+      this.config,
+      baseColumn
+    );
+  }
+};
+var PgArray = class _PgArray extends PgColumn {
+  constructor(table, config, baseColumn, range) {
+    super(table, config);
+    this.baseColumn = baseColumn;
+    this.range = range;
+    this.size = config.size;
+  }
+  size;
+  static [entityKind] = "PgArray";
+  getSQLType() {
+    return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      value = parsePgArray(value);
+    }
+    return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+  }
+  mapToDriverValue(value, isNestedArray = false) {
+    const a = value.map(
+      (v) => v === null ? null : is(this.baseColumn, _PgArray) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v)
+    );
+    if (isNestedArray)
+      return a;
+    return makePgArray(a);
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/pg-core/columns/enum.js
+var isPgEnumSym = /* @__PURE__ */ Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+var PgEnumColumnBuilder = class extends PgColumnBuilder {
+  static [entityKind] = "PgEnumColumnBuilder";
+  constructor(name, enumInstance) {
+    super(name, "string", "PgEnumColumn");
+    this.config.enum = enumInstance;
+  }
+  /** @internal */
+  build(table) {
+    return new PgEnumColumn(
+      table,
+      this.config
+    );
+  }
+};
+var PgEnumColumn = class extends PgColumn {
+  static [entityKind] = "PgEnumColumn";
+  enum = this.config.enum;
+  enumValues = this.config.enum.enumValues;
+  constructor(table, config) {
+    super(table, config);
+    this.enum = config.enum;
+  }
+  getSQLType() {
+    return this.enum.enumName;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+  static [entityKind] = "Subquery";
+  constructor(sql2, selection, alias, isWith = false) {
+    this._ = {
+      brand: "Subquery",
+      sql: sql2,
+      selectedFields: selection,
+      alias,
+      isWith
+    };
+  }
+  // getSQL(): SQL<unknown> {
+  // 	return new SQL([this]);
+  // }
+};
+var WithSubquery = class extends Subquery {
+  static [entityKind] = "WithSubquery";
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/version.js
+var version = "0.36.4";
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/tracing.js
+var otel;
+var rawTracer;
+var tracer = {
+  startActiveSpan(name, fn) {
+    if (!otel) {
+      return fn();
+    }
+    if (!rawTracer) {
+      rawTracer = otel.trace.getTracer("drizzle-orm", version);
+    }
+    return iife(
+      (otel2, rawTracer2) => rawTracer2.startActiveSpan(
+        name,
+        (span) => {
+          try {
+            return fn(span);
+          } catch (e) {
+            span.setStatus({
+              code: otel2.SpanStatusCode.ERROR,
+              message: e instanceof Error ? e.message : "Unknown error"
+              // eslint-disable-line no-instanceof/no-instanceof
+            });
+            throw e;
+          } finally {
+            span.end();
+          }
+        }
+      ),
+      otel,
+      rawTracer
+    );
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = /* @__PURE__ */ Symbol.for("drizzle:ViewBaseConfig");
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/table.js
+var Schema = /* @__PURE__ */ Symbol.for("drizzle:Schema");
+var Columns = /* @__PURE__ */ Symbol.for("drizzle:Columns");
+var ExtraConfigColumns = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigColumns");
+var OriginalName = /* @__PURE__ */ Symbol.for("drizzle:OriginalName");
+var BaseName = /* @__PURE__ */ Symbol.for("drizzle:BaseName");
+var IsAlias = /* @__PURE__ */ Symbol.for("drizzle:IsAlias");
+var ExtraConfigBuilder = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigBuilder");
+var IsDrizzleTable = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable");
+var Table = class {
+  static [entityKind] = "Table";
+  /** @internal */
+  static Symbol = {
+    Name: TableName,
+    Schema,
+    OriginalName,
+    Columns,
+    ExtraConfigColumns,
+    BaseName,
+    IsAlias,
+    ExtraConfigBuilder
+  };
+  /**
+   * @internal
+   * Can be changed if the table is aliased.
+   */
+  [TableName];
+  /**
+   * @internal
+   * Used to store the original name of the table, before any aliasing.
+   */
+  [OriginalName];
+  /** @internal */
+  [Schema];
+  /** @internal */
+  [Columns];
+  /** @internal */
+  [ExtraConfigColumns];
+  /**
+   *  @internal
+   * Used to store the table name before the transformation via the `tableCreator` functions.
+   */
+  [BaseName];
+  /** @internal */
+  [IsAlias] = false;
+  /** @internal */
+  [IsDrizzleTable] = true;
+  /** @internal */
+  [ExtraConfigBuilder] = void 0;
+  constructor(name, schema, baseName) {
+    this[TableName] = this[OriginalName] = name;
+    this[Schema] = schema;
+    this[BaseName] = baseName;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sql/sql.js
+var FakePrimitiveParam = class {
+  static [entityKind] = "FakePrimitiveParam";
+};
+function isSQLWrapper(value) {
+  return value !== null && value !== void 0 && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+var StringChunk = class {
+  static [entityKind] = "StringChunk";
+  value;
+  constructor(value) {
+    this.value = Array.isArray(value) ? value : [value];
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var SQL = class _SQL {
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+  }
+  static [entityKind] = "SQL";
+  /** @internal */
+  decoder = noopDecoder;
+  shouldInlineParams = false;
+  append(query) {
+    this.queryChunks.push(...query.queryChunks);
+    return this;
+  }
+  toQuery(config) {
+    return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+      const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+      span?.setAttributes({
+        "drizzle.query.text": query.sql,
+        "drizzle.query.params": JSON.stringify(query.params)
+      });
+      return query;
+    });
+  }
+  buildQueryFromSourceParams(chunks, _config) {
+    const config = Object.assign({}, _config, {
+      inlineParams: _config.inlineParams || this.shouldInlineParams,
+      paramStartIndex: _config.paramStartIndex || { value: 0 }
+    });
+    const {
+      casing,
+      escapeName,
+      escapeParam,
+      prepareTyping,
+      inlineParams,
+      paramStartIndex
+    } = config;
+    return mergeQueries(chunks.map((chunk) => {
+      if (is(chunk, StringChunk)) {
+        return { sql: chunk.value.join(""), params: [] };
+      }
+      if (is(chunk, Name)) {
+        return { sql: escapeName(chunk.value), params: [] };
+      }
+      if (chunk === void 0) {
+        return { sql: "", params: [] };
+      }
+      if (Array.isArray(chunk)) {
+        const result = [new StringChunk("(")];
+        for (const [i, p] of chunk.entries()) {
+          result.push(p);
+          if (i < chunk.length - 1) {
+            result.push(new StringChunk(", "));
+          }
+        }
+        result.push(new StringChunk(")"));
+        return this.buildQueryFromSourceParams(result, config);
+      }
+      if (is(chunk, _SQL)) {
+        return this.buildQueryFromSourceParams(chunk.queryChunks, {
+          ...config,
+          inlineParams: inlineParams || chunk.shouldInlineParams
+        });
+      }
+      if (is(chunk, Table)) {
+        const schemaName = chunk[Table.Symbol.Schema];
+        const tableName = chunk[Table.Symbol.Name];
+        return {
+          sql: schemaName === void 0 ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+          params: []
+        };
+      }
+      if (is(chunk, Column)) {
+        const columnName = casing.getColumnCasing(chunk);
+        if (_config.invokeSource === "indexes") {
+          return { sql: escapeName(columnName), params: [] };
+        }
+        const schemaName = chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+          params: []
+        };
+      }
+      if (is(chunk, View)) {
+        const schemaName = chunk[ViewBaseConfig].schema;
+        const viewName = chunk[ViewBaseConfig].name;
+        return {
+          sql: schemaName === void 0 ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+          params: []
+        };
+      }
+      if (is(chunk, Param)) {
+        if (is(chunk.value, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+        if (is(mappedValue, _SQL)) {
+          return this.buildQueryFromSourceParams([mappedValue], config);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+        }
+        let typings = ["none"];
+        if (prepareTyping) {
+          typings = [prepareTyping(chunk.encoder)];
+        }
+        return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+      }
+      if (is(chunk, Placeholder)) {
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }
+      if (is(chunk, _SQL.Aliased) && chunk.fieldAlias !== void 0) {
+        return { sql: escapeName(chunk.fieldAlias), params: [] };
+      }
+      if (is(chunk, Subquery)) {
+        if (chunk._.isWith) {
+          return { sql: escapeName(chunk._.alias), params: [] };
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk._.sql,
+          new StringChunk(") "),
+          new Name(chunk._.alias)
+        ], config);
+      }
+      if (isPgEnum(chunk)) {
+        if (chunk.schema) {
+          return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+        }
+        return { sql: escapeName(chunk.enumName), params: [] };
+      }
+      if (isSQLWrapper(chunk)) {
+        if (chunk.shouldOmitSQLParens?.()) {
+          return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+        }
+        return this.buildQueryFromSourceParams([
+          new StringChunk("("),
+          chunk.getSQL(),
+          new StringChunk(")")
+        ], config);
+      }
+      if (inlineParams) {
+        return { sql: this.mapInlineParam(chunk, config), params: [] };
+      }
+      return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(chunk, { escapeString }) {
+    if (chunk === null) {
+      return "null";
+    }
+    if (typeof chunk === "number" || typeof chunk === "boolean") {
+      return chunk.toString();
+    }
+    if (typeof chunk === "string") {
+      return escapeString(chunk);
+    }
+    if (typeof chunk === "object") {
+      const mappedValueAsString = chunk.toString();
+      if (mappedValueAsString === "[object Object]") {
+        return escapeString(JSON.stringify(chunk));
+      }
+      return escapeString(mappedValueAsString);
+    }
+    throw new Error("Unexpected param value: " + chunk);
+  }
+  getSQL() {
+    return this;
+  }
+  as(alias) {
+    if (alias === void 0) {
+      return this;
+    }
+    return new _SQL.Aliased(this, alias);
+  }
+  mapWith(decoder) {
+    this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+    return this;
+  }
+  inlineParams() {
+    this.shouldInlineParams = true;
+    return this;
+  }
+  /**
+   * This method is used to conditionally include a part of the query.
+   *
+   * @param condition - Condition to check
+   * @returns itself if the condition is `true`, otherwise `undefined`
+   */
+  if(condition) {
+    return condition ? this : void 0;
+  }
+};
+var Name = class {
+  constructor(value) {
+    this.value = value;
+  }
+  static [entityKind] = "Name";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var noopDecoder = {
+  mapFromDriverValue: (value) => value
+};
+var noopEncoder = {
+  mapToDriverValue: (value) => value
+};
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+var Param = class {
+  /**
+   * @param value - Parameter value
+   * @param encoder - Encoder to convert the value to a driver parameter
+   */
+  constructor(value, encoder = noopEncoder) {
+    this.value = value;
+    this.encoder = encoder;
+  }
+  static [entityKind] = "Param";
+  brand;
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+((sql2) => {
+  function empty() {
+    return new SQL([]);
+  }
+  sql2.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  sql2.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  sql2.raw = raw;
+  function join(chunks, separator) {
+    const result = [];
+    for (const [i, chunk] of chunks.entries()) {
+      if (i > 0 && separator !== void 0) {
+        result.push(separator);
+      }
+      result.push(chunk);
+    }
+    return new SQL(result);
+  }
+  sql2.join = join;
+  function identifier(value) {
+    return new Name(value);
+  }
+  sql2.identifier = identifier;
+  function placeholder2(name2) {
+    return new Placeholder(name2);
+  }
+  sql2.placeholder = placeholder2;
+  function param2(value, encoder) {
+    return new Param(value, encoder);
+  }
+  sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+  class Aliased {
+    constructor(sql2, fieldAlias) {
+      this.sql = sql2;
+      this.fieldAlias = fieldAlias;
+    }
+    static [entityKind] = "SQL.Aliased";
+    /** @internal */
+    isSelectionField = false;
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class {
+  constructor(name2) {
+    this.name = name2;
+  }
+  static [entityKind] = "Placeholder";
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var View = class {
+  static [entityKind] = "View";
+  /** @internal */
+  [ViewBaseConfig];
+  constructor({ name: name2, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name2,
+      originalName: name2,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/utils.js
+function getColumnNameAndConfig(a, b) {
+  return {
+    name: typeof a === "string" && a.length > 0 ? a : "",
+    config: typeof a === "object" ? a : b
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+var ForeignKeyBuilder2 = class {
+  static [entityKind] = "SQLiteForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate;
+  /** @internal */
+  _onDelete;
+  constructor(config, actions) {
+    this.reference = () => {
+      const { name, columns, foreignColumns } = config();
+      return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
+    };
+    if (actions) {
+      this._onUpdate = actions.onUpdate;
+      this._onDelete = actions.onDelete;
+    }
+  }
+  onUpdate(action) {
+    this._onUpdate = action;
+    return this;
+  }
+  onDelete(action) {
+    this._onDelete = action;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new ForeignKey2(table, this);
+  }
+};
+var ForeignKey2 = class {
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._onDelete;
+  }
+  static [entityKind] = "SQLiteForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name, columns, foreignColumns } = this.reference();
+    const columnNames = columns.map((column) => column.name);
+    const foreignColumnNames = foreignColumns.map((column) => column.name);
+    const chunks = [
+      this.table[TableName],
+      ...columnNames,
+      foreignColumns[0].table[TableName],
+      ...foreignColumnNames
+    ];
+    return name ?? `${chunks.join("_")}_fk`;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+function uniqueKeyName2(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var UniqueConstraintBuilder2 = class {
+  constructor(columns, name) {
+    this.name = name;
+    this.columns = columns;
+  }
+  static [entityKind] = "SQLiteUniqueConstraintBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  build(table) {
+    return new UniqueConstraint2(table, this.columns, this.name);
+  }
+};
+var UniqueOnConstraintBuilder2 = class {
+  static [entityKind] = "SQLiteUniqueOnConstraintBuilder";
+  /** @internal */
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  on(...columns) {
+    return new UniqueConstraintBuilder2(columns, this.name);
+  }
+};
+var UniqueConstraint2 = class {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name ?? uniqueKeyName2(this.table, this.columns.map((column) => column.name));
+  }
+  static [entityKind] = "SQLiteUniqueConstraint";
+  columns;
+  name;
+  getName() {
+    return this.name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/common.js
+var SQLiteColumnBuilder = class extends ColumnBuilder {
+  static [entityKind] = "SQLiteColumnBuilder";
+  foreignKeyConfigs = [];
+  references(ref, actions = {}) {
+    this.foreignKeyConfigs.push({ ref, actions });
+    return this;
+  }
+  unique(name) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    return this;
+  }
+  generatedAlwaysAs(as, config) {
+    this.config.generated = {
+      as,
+      type: "always",
+      mode: config?.mode ?? "virtual"
+    };
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(column, table) {
+    return this.foreignKeyConfigs.map(({ ref, actions }) => {
+      return ((ref2, actions2) => {
+        const builder = new ForeignKeyBuilder2(() => {
+          const foreignColumn = ref2();
+          return { columns: [column], foreignColumns: [foreignColumn] };
+        });
+        if (actions2.onUpdate) {
+          builder.onUpdate(actions2.onUpdate);
+        }
+        if (actions2.onDelete) {
+          builder.onDelete(actions2.onDelete);
+        }
+        return builder.build(table);
+      })(ref, actions);
+    });
+  }
+};
+var SQLiteColumn = class extends Column {
+  constructor(table, config) {
+    if (!config.uniqueName) {
+      config.uniqueName = uniqueKeyName2(table, [config.name]);
+    }
+    super(table, config);
+    this.table = table;
+  }
+  static [entityKind] = "SQLiteColumn";
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+var SQLiteBigIntBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint", "SQLiteBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBigInt(table, this.config);
+  }
+};
+var SQLiteBigInt = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    return BigInt(Buffer.isBuffer(value) ? value.toString() : String.fromCodePoint(...value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(value.toString());
+  }
+};
+var SQLiteBlobJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteBlobJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobJson(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteBlobJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    return JSON.parse(Buffer.isBuffer(value) ? value.toString() : String.fromCodePoint(...value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(JSON.stringify(value));
+  }
+};
+var SQLiteBlobBufferBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobBufferBuilder";
+  constructor(name) {
+    super(name, "buffer", "SQLiteBlobBuffer");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobBuffer(table, this.config);
+  }
+};
+var SQLiteBlobBuffer = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobBuffer";
+  getSQLType() {
+    return "blob";
+  }
+};
+function blob(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "json") {
+    return new SQLiteBlobJsonBuilder(name);
+  }
+  if (config?.mode === "bigint") {
+    return new SQLiteBigIntBuilder(name);
+  }
+  return new SQLiteBlobBufferBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+var SQLiteCustomColumnBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteCustomColumnBuilder";
+  constructor(name, fieldConfig, customTypeParams) {
+    super(name, "custom", "SQLiteCustomColumn");
+    this.config.fieldConfig = fieldConfig;
+    this.config.customTypeParams = customTypeParams;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteCustomColumn(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteCustomColumn = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  constructor(table, config) {
+    super(table, config);
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapTo = config.customTypeParams.toDriver;
+    this.mapFrom = config.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(value) {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  }
+  mapToDriverValue(value) {
+    return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+  }
+};
+function customType(customTypeParams) {
+  return (a, b) => {
+    const { name, config } = getColumnNameAndConfig(a, b);
+    return new SQLiteCustomColumnBuilder(
+      name,
+      config,
+      customTypeParams
+    );
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+var SQLiteBaseIntegerBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBaseIntegerBuilder";
+  constructor(name, dataType, columnType) {
+    super(name, dataType, columnType);
+    this.config.autoIncrement = false;
+  }
+  primaryKey(config) {
+    if (config?.autoIncrement) {
+      this.config.autoIncrement = true;
+    }
+    this.config.hasDefault = true;
+    return super.primaryKey();
+  }
+};
+var SQLiteBaseInteger = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBaseInteger";
+  autoIncrement = this.config.autoIncrement;
+  getSQLType() {
+    return "integer";
+  }
+};
+var SQLiteIntegerBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteIntegerBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteInteger");
+  }
+  build(table) {
+    return new SQLiteInteger(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteInteger = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteInteger";
+};
+var SQLiteTimestampBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteTimestampBuilder";
+  constructor(name, mode) {
+    super(name, "date", "SQLiteTimestamp");
+    this.config.mode = mode;
+  }
+  /**
+   * @deprecated Use `default()` with your own expression instead.
+   *
+   * Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.
+   */
+  defaultNow() {
+    return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
+  }
+  build(table) {
+    return new SQLiteTimestamp(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteTimestamp = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteTimestamp";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    if (this.config.mode === "timestamp") {
+      return new Date(value * 1e3);
+    }
+    return new Date(value);
+  }
+  mapToDriverValue(value) {
+    const unix = value.getTime();
+    if (this.config.mode === "timestamp") {
+      return Math.floor(unix / 1e3);
+    }
+    return unix;
+  }
+};
+var SQLiteBooleanBuilder = class extends SQLiteBaseIntegerBuilder {
+  static [entityKind] = "SQLiteBooleanBuilder";
+  constructor(name, mode) {
+    super(name, "boolean", "SQLiteBoolean");
+    this.config.mode = mode;
+  }
+  build(table) {
+    return new SQLiteBoolean(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteBoolean = class extends SQLiteBaseInteger {
+  static [entityKind] = "SQLiteBoolean";
+  mode = this.config.mode;
+  mapFromDriverValue(value) {
+    return Number(value) === 1;
+  }
+  mapToDriverValue(value) {
+    return value ? 1 : 0;
+  }
+};
+function integer(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") {
+    return new SQLiteTimestampBuilder(name, config.mode);
+  }
+  if (config?.mode === "boolean") {
+    return new SQLiteBooleanBuilder(name, config.mode);
+  }
+  return new SQLiteIntegerBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+var SQLiteNumericBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBuilder";
+  constructor(name) {
+    super(name, "string", "SQLiteNumeric");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumeric(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteNumeric = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumeric";
+  getSQLType() {
+    return "numeric";
+  }
+};
+function numeric(name) {
+  return new SQLiteNumericBuilder(name ?? "");
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/real.js
+var SQLiteRealBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteRealBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteReal");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteReal(table, this.config);
+  }
+};
+var SQLiteReal = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteReal";
+  getSQLType() {
+    return "real";
+  }
+};
+function real(name) {
+  return new SQLiteRealBuilder(name ?? "");
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/text.js
+var SQLiteTextBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextBuilder";
+  constructor(name, config) {
+    super(name, "string", "SQLiteText");
+    this.config.enumValues = config.enum;
+    this.config.length = config.length;
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteText(table, this.config);
+  }
+};
+var SQLiteText = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteText";
+  enumValues = this.config.enumValues;
+  length = this.config.length;
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return `text${this.config.length ? `(${this.config.length})` : ""}`;
+  }
+};
+var SQLiteTextJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextJsonBuilder";
+  constructor(name) {
+    super(name, "json", "SQLiteTextJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteTextJson(
+      table,
+      this.config
+    );
+  }
+};
+var SQLiteTextJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteTextJson";
+  getSQLType() {
+    return "text";
+  }
+  mapFromDriverValue(value) {
+    return JSON.parse(value);
+  }
+  mapToDriverValue(value) {
+    return JSON.stringify(value);
+  }
+};
+function text(a, b = {}) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  if (config.mode === "json") {
+    return new SQLiteTextJsonBuilder(name);
+  }
+  return new SQLiteTextBuilder(name, config);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/columns/all.js
+function getSQLiteColumnBuilders() {
+  return {
+    blob,
+    customType,
+    integer,
+    numeric,
+    real,
+    text
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/table.js
+var InlineForeignKeys = /* @__PURE__ */ Symbol.for("drizzle:SQLiteInlineForeignKeys");
+var SQLiteTable = class extends Table {
+  static [entityKind] = "SQLiteTable";
+  /** @internal */
+  static Symbol = Object.assign({}, Table.Symbol, {
+    InlineForeignKeys
+  });
+  /** @internal */
+  [Table.Symbol.Columns];
+  /** @internal */
+  [InlineForeignKeys] = [];
+  /** @internal */
+  [Table.Symbol.ExtraConfigBuilder] = void 0;
+};
+function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
+  const rawTable = new SQLiteTable(name, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(
+    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+      const colBuilder = colBuilderBase;
+      colBuilder.setName(name2);
+      const column = colBuilder.build(rawTable);
+      rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+      return [name2, column];
+    })
+  );
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+  if (extraConfig) {
+    table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  }
+  return table;
+}
+var sqliteTable = (name, columns, extraConfig) => {
+  return sqliteTableBase(name, columns, extraConfig);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+  constructor(name, unique) {
+    this.name = name;
+    this.unique = unique;
+  }
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(this.name, columns, this.unique);
+  }
+};
+var IndexBuilder = class {
+  static [entityKind] = "SQLiteIndexBuilder";
+  /** @internal */
+  config;
+  constructor(name, columns, unique) {
+    this.config = {
+      name,
+      columns,
+      unique,
+      where: void 0
+    };
+  }
+  /**
+   * Condition for partial index.
+   */
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
+  }
+};
+var Index = class {
+  static [entityKind] = "SQLiteIndex";
+  config;
+  constructor(config, table) {
+    this.config = { ...config, table };
+  }
+};
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
+function uniqueIndex(name) {
+  return new IndexBuilderOn(name, true);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@0.36.4_@cloudflare+workers-types@4.20260416.2_@types+better-sqlite3@7.6.13__6bda8a68f3e10d0b03cd2031bac7989c/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+function primaryKey(...config) {
+  if (config[0].columns) {
+    return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+  }
+  return new PrimaryKeyBuilder(config);
+}
+var PrimaryKeyBuilder = class {
+  static [entityKind] = "SQLitePrimaryKeyBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  name;
+  constructor(columns, name) {
+    this.columns = columns;
+    this.name = name;
+  }
+  /** @internal */
+  build(table) {
+    return new PrimaryKey(table, this.columns, this.name);
+  }
+};
+var PrimaryKey = class {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name;
+  }
+  static [entityKind] = "SQLitePrimaryKey";
+  columns;
+  name;
+  getName() {
+    return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+  }
+};
+
+// ../core/src/db/schema.ts
+var projects = sqliteTable(
+  "projects",
+  {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    domain: text("domain"),
+    ownerEmail: text("owner_email").notNull(),
+    plan: text("plan", { enum: ["free", "paid"] }).notNull().default("free"),
+    status: text("status", { enum: ["active", "inactive"] }).notNull().default("active"),
+    // Stripe billing
+    stripeCustomerId: text("stripe_customer_id").unique(),
+    stripeSubscriptionId: text("stripe_subscription_id").unique(),
+    stripeItemIdBase: text("stripe_item_id_base"),
+    stripeItemIdExperiments: text("stripe_item_id_experiments"),
+    stripeItemIdGates: text("stripe_item_id_gates"),
+    stripeItemIdConfigs: text("stripe_item_id_configs"),
+    subscriptionStatus: text("subscription_status", {
+      enum: ["none", "trialing", "active", "past_due", "canceled", "incomplete"]
+    }).notNull().default("none"),
+    currentPeriodEnd: text("current_period_end"),
+    trialEndsAt: text("trial_ends_at"),
+    cancelAtPeriodEnd: integer("cancel_at_period_end").notNull().default(0),
+    billingInterval: text("billing_interval", { enum: ["monthly", "annual"] }).notNull().default("monthly"),
+    // Per-project module toggles. Control which surfaces (admin tabs, devtools
+    // panels) are exposed for this project. All default to enabled so existing
+    // projects keep their full feature set after the migration.
+    moduleTranslations: integer("module_translations", { mode: "boolean" }).notNull().default(true),
+    moduleConfigs: integer("module_configs", { mode: "boolean" }).notNull().default(true),
+    moduleGates: integer("module_gates", { mode: "boolean" }).notNull().default(true),
+    moduleExperiments: integer("module_experiments", { mode: "boolean" }).notNull().default(true),
+    moduleFeedback: integer("module_feedback", { mode: "boolean" }).notNull().default(true),
+    moduleUser: integer("module_user", { mode: "boolean" }).notNull().default(true),
+    moduleEvents: integer("module_events", { mode: "boolean" }).notNull().default(true),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    // One project per (owner, domain): a single account can't accidentally
+    // create two projects pointing at the same site. Multiple projects per
+    // owner are still allowed across different domains, and `domain` may be
+    // NULL for projects without a configured site (SQLite treats each NULL
+    // as distinct under UNIQUE, so multiple no-domain projects per owner are
+    // permitted).
+    ownerDomainUniq: uniqueIndex("projects_owner_domain_uniq").on(t.ownerEmail, t.domain)
+  })
+);
+var users = sqliteTable("users", {
+  email: text("email").primaryKey(),
+  termsAcceptedAt: text("terms_accepted_at"),
+  termsVersion: text("terms_version"),
+  onboardingCompletedAt: text("onboarding_completed_at"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull()
+});
+var projectMembers = sqliteTable(
+  "project_members",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    email: text("email").notNull(),
+    role: text("role", { enum: ["admin", "editor", "viewer"] }).notNull().default("editor"),
+    status: text("status", { enum: ["active", "pending", "removed"] }).notNull().default("pending"),
+    invitedByEmail: text("invited_by_email").notNull(),
+    invitedAt: text("invited_at").notNull(),
+    acceptedAt: text("accepted_at"),
+    removedAt: text("removed_at")
+  },
+  (t) => ({
+    projectIdx: index("project_members_project").on(t.projectId, t.status),
+    projectEmailUniq: uniqueIndex("project_members_project_email").on(t.projectId, t.email)
+  })
+);
+var sdkKeys = sqliteTable(
+  "sdk_keys",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    keyHash: text("key_hash").unique().notNull(),
+    type: text("type", { enum: ["server", "client", "admin"] }).notNull(),
+    scope: text("scope", { enum: ["experiments", "i18n"] }).notNull().default("experiments"),
+    createdAt: text("created_at").notNull(),
+    revokedAt: text("revoked_at"),
+    expiresAt: text("expires_at"),
+    // Email of the human who minted this key (admin keys via dashboard or
+    // CLI device-flow). Used to authorize cross-project --project overrides
+    // by joining against project_members. Null for older keys + for
+    // service-to-service keys without a human owner.
+    createdByEmail: text("created_by_email")
+  },
+  (t) => ({ hashIdx: index("sdk_keys_hash").on(t.keyHash) })
+);
+var cliAuthSessions = sqliteTable(
+  "cli_auth_sessions",
+  {
+    state: text("state").primaryKey(),
+    codeChallenge: text("code_challenge").notNull(),
+    projectId: text("project_id").references(() => projects.id),
+    tokenHash: text("token_hash"),
+    status: text("status", { enum: ["pending", "complete", "expired"] }).notNull().default("pending"),
+    createdAt: text("created_at").notNull(),
+    expiresAt: text("expires_at").notNull(),
+    completedAt: text("completed_at")
+  },
+  (t) => ({ expiresIdx: index("cli_auth_sessions_expires").on(t.expiresAt) })
+);
+var cliTokens = sqliteTable(
+  "cli_tokens",
+  {
+    tokenId: text("token_id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    userEmail: text("user_email").notNull(),
+    issuedAt: text("issued_at").notNull(),
+    expiresAt: text("expires_at").notNull(),
+    revokedAt: text("revoked_at"),
+    lastUsedAt: text("last_used_at")
+  },
+  (t) => ({
+    projectIdx: index("cli_tokens_project").on(t.projectId),
+    expiresIdx: index("cli_tokens_expires").on(t.expiresAt)
+  })
+);
+var analysisFailures = sqliteTable("analysis_failures", {
+  projectId: text("project_id").primaryKey().references(() => projects.id),
+  failedAt: text("failed_at").notNull(),
+  retryCount: integer("retry_count").notNull().default(3),
+  messageBody: text("message_body"),
+  resolvedAt: text("resolved_at")
+});
+var systemHealth = sqliteTable("system_health", {
+  key: text("key").primaryKey(),
+  lastFiredAt: text("last_fired_at").notNull(),
+  projectsEnqueued: integer("projects_enqueued")
+});
+var auditLog = sqliteTable(
+  "audit_log",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id),
+    actorEmail: text("actor_email").notNull(),
+    actorType: text("actor_type", { enum: ["user", "cli", "system"] }).notNull(),
+    action: text("action").notNull(),
+    resourceType: text("resource_type").notNull(),
+    resourceId: text("resource_id"),
+    payload: text("payload"),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("audit_log_project").on(t.projectId, t.createdAt),
+    actorIdx: index("audit_log_actor").on(t.actorEmail),
+    resourceIdx: index("audit_log_resource").on(t.resourceType, t.resourceId)
+  })
+);
+var gates = sqliteTable(
+  "gates",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    rules: text("rules", { mode: "json" }).$type().notNull(),
+    rolloutPct: integer("rollout_pct").notNull().default(0),
+    salt: text("salt").notNull(),
+    enabled: integer("enabled").notNull().default(1),
+    // Gatekeeper metadata + ordered sub-gate stack. Stack is null on rows that
+    // predate the gatekeeper migration; eval falls back to rules+rolloutPct.
+    title: text("title"),
+    description: text("description"),
+    folder: text("folder"),
+    groupName: text("group_name"),
+    ownerEmail: text("owner_email"),
+    stack: text("stack", { mode: "json" }).$type(),
+    updatedAt: text("updated_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("gates_project").on(t.projectId),
+    projectNameUniq: uniqueIndex("gates_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var CONFIG_ENVS = ["dev", "staging", "prod"];
+var CONFIG_KINDS = ["config", "killswitch"];
+var DEFAULT_CONFIG_SCHEMA = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
+var configs = sqliteTable(
+  "configs",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    description: text("description"),
+    kind: text("kind", { enum: CONFIG_KINDS }).notNull().default("config"),
+    schemaJson: text("schema_json", { mode: "json" }).$type().notNull().default(DEFAULT_CONFIG_SCHEMA),
+    updatedAt: text("updated_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    uniq: uniqueIndex("configs_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var configValues = sqliteTable(
+  "config_values",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    configId: text("config_id").notNull().references(() => configs.id, { onDelete: "cascade" }),
+    env: text("env", { enum: CONFIG_ENVS }).notNull(),
+    valueJson: text("value_json", { mode: "json" }).$type().notNull(),
+    version: integer("version").notNull(),
+    publishedAt: text("published_at").notNull(),
+    publishedBy: text("published_by").notNull()
+  },
+  (t) => ({
+    projectIdx: index("config_values_project").on(t.projectId),
+    configEnvIdx: index("config_values_config_env").on(t.configId, t.env, t.version),
+    uniq: uniqueIndex("config_values_config_env_version").on(t.configId, t.env, t.version)
+  })
+);
+var configDrafts = sqliteTable(
+  "config_drafts",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    configId: text("config_id").notNull().references(() => configs.id, { onDelete: "cascade" }),
+    env: text("env", { enum: CONFIG_ENVS }).notNull(),
+    valueJson: text("value_json", { mode: "json" }).$type().notNull(),
+    baseVersion: integer("base_version").notNull(),
+    authorEmail: text("author_email").notNull(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("config_drafts_project").on(t.projectId),
+    uniq: uniqueIndex("config_drafts_config_env").on(t.configId, t.env)
+  })
+);
+var universes = sqliteTable(
+  "universes",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    unitType: text("unit_type").notNull().default("user_id"),
+    holdoutRange: text("holdout_range", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("universes_project").on(t.projectId),
+    projectUniq: uniqueIndex("universes_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var experiments = sqliteTable(
+  "experiments",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    description: text("description"),
+    tag: text("tag"),
+    universe: text("universe").notNull(),
+    targetingGate: text("targeting_gate"),
+    allocationPct: integer("allocation_pct").notNull().default(0),
+    salt: text("salt").notNull(),
+    params: text("params", { mode: "json" }).$type().notNull(),
+    groups: text("groups", { mode: "json" }).$type().notNull(),
+    status: text("status", { enum: ["draft", "running", "stopped", "archived"] }).notNull().default("draft"),
+    startedAt: text("started_at"),
+    stoppedAt: text("stopped_at"),
+    significanceThreshold: real("significance_threshold").notNull().default(0.05),
+    minRuntimeDays: integer("min_runtime_days").notNull().default(0),
+    minSampleSize: integer("min_sample_size").notNull().default(100),
+    cupedFrozenAt: text("cuped_frozen_at"),
+    sequentialTesting: integer("sequential_testing", { mode: "boolean" }).notNull().default(false),
+    hashVersion: integer("hash_version").notNull().default(1),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("experiments_project").on(t.projectId),
+    projectUniq: uniqueIndex("experiments_project_name").on(t.projectId, t.name)
+  })
+);
+var events = sqliteTable(
+  "events",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    description: text("description"),
+    properties: text("properties", { mode: "json" }).$type().notNull().default([]),
+    pending: integer("pending").notNull().default(0),
+    createdAt: text("created_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("events_project").on(t.projectId),
+    projectUniq: uniqueIndex("events_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var metrics = sqliteTable(
+  "metrics",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    eventName: text("event_name").notNull(),
+    valuePath: text("value_path"),
+    aggregation: text("aggregation", {
+      enum: ["count_users", "count_events", "sum", "avg", "retention_Nd"]
+    }).notNull().default("count_users"),
+    winsorizePct: integer("winsorize_pct").notNull().default(99),
+    minDetectableEffect: real("min_detectable_effect"),
+    updatedAt: text("updated_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    uniq: uniqueIndex("metrics_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var experimentMetrics = sqliteTable(
+  "experiment_metrics",
+  {
+    id: text("id").primaryKey(),
+    experimentId: text("experiment_id").notNull().references(() => experiments.id, { onDelete: "cascade" }),
+    metricId: text("metric_id").notNull().references(() => metrics.id, { onDelete: "cascade" }),
+    role: text("role", { enum: ["goal", "guardrail", "secondary"] }).notNull(),
+    createdAt: integer("created_at").notNull()
+  },
+  (t) => ({ uniq: uniqueIndex("exp_metrics_uniq").on(t.experimentId, t.metricId) })
+);
+var experimentResults = sqliteTable(
+  "experiment_results",
+  {
+    projectId: text("project_id").notNull(),
+    experiment: text("experiment").notNull(),
+    metric: text("metric").notNull(),
+    groupName: text("group_name").notNull(),
+    ds: text("ds").notNull(),
+    n: integer("n"),
+    mean: real("mean"),
+    variance: real("variance"),
+    delta: real("delta"),
+    deltaPct: real("delta_pct"),
+    ci95Low: real("ci_95_low"),
+    ci95High: real("ci_95_high"),
+    ci99Low: real("ci_99_low"),
+    ci99High: real("ci_99_high"),
+    pValue: real("p_value"),
+    expectedN: integer("expected_n"),
+    srmPValue: real("srm_p_value"),
+    srmDetected: integer("srm_detected").notNull().default(0),
+    msprtLambda: real("msprt_lambda"),
+    msprtSignificant: integer("msprt_significant"),
+    isFinal: integer("is_final").notNull().default(0),
+    peekWarning: integer("peek_warning").notNull().default(0)
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.experiment, t.metric, t.groupName, t.ds] }),
+    dsIdx: index("experiment_results_ds").on(t.projectId, t.ds)
+  })
+);
+var userMetricBaseline = sqliteTable(
+  "user_metric_baseline",
+  {
+    projectId: text("project_id").notNull(),
+    userId: text("user_id").notNull(),
+    metricName: text("metric_name").notNull(),
+    avgValue: real("avg_value").notNull(),
+    updatedDs: text("updated_ds").notNull()
+  },
+  (t) => ({ pk: primaryKey({ columns: [t.projectId, t.userId, t.metricName] }) })
+);
+var userAliases = sqliteTable(
+  "user_aliases",
+  {
+    projectId: text("project_id").notNull(),
+    anonymousId: text("anonymous_id").notNull(),
+    userId: text("user_id").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.anonymousId] }),
+    userIdx: index("user_aliases_user").on(t.projectId, t.userId)
+  })
+);
+var userAttributes = sqliteTable(
+  "user_attributes",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    type: text("type", { enum: ["string", "number", "boolean", "enum", "date"] }).notNull(),
+    enumValues: text("enum_values", { mode: "json" }).$type(),
+    required: integer("required").notNull().default(0),
+    description: text("description"),
+    sdkPath: text("sdk_path"),
+    createdAt: text("created_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("user_attributes_project").on(t.projectId),
+    projectUniq: uniqueIndex("user_attributes_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var labelProfiles = sqliteTable(
+  "label_profiles",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    defaultChunkId: text("default_chunk_id"),
+    createdAt: text("created_at").notNull(),
+    deletedAt: text("deleted_at")
+  },
+  (t) => ({
+    projectIdx: index("label_profiles_project").on(t.projectId),
+    projectNameUniq: uniqueIndex("label_profiles_project_name").on(t.projectId, t.name).where(sql`deleted_at is null`)
+  })
+);
+var labelChunks = sqliteTable(
+  "label_chunks",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    profileId: text("profile_id").notNull().references(() => labelProfiles.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    isIndex: integer("is_index").notNull().default(0),
+    publishedUrl: text("published_url"),
+    publishedHash: text("published_hash"),
+    publishedAt: text("published_at"),
+    etag: text("etag")
+  },
+  (t) => ({
+    projectIdx: index("label_chunks_project").on(t.projectId),
+    profileNameUniq: uniqueIndex("label_chunks_profile_name").on(t.profileId, t.name)
+  })
+);
+var labelKeys = sqliteTable(
+  "label_keys",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    profileId: text("profile_id").notNull().references(() => labelProfiles.id, { onDelete: "cascade" }),
+    chunkId: text("chunk_id").notNull().references(() => labelChunks.id, { onDelete: "cascade" }),
+    key: text("key").notNull(),
+    value: text("value").notNull(),
+    description: text("description"),
+    // JSON array of variable names extracted from the value's {{var}} placeholders.
+    // `null` = no variables detected; `[]` = explicitly none (normalized).
+    variables: text("variables", { mode: "json" }).$type(),
+    updatedAt: text("updated_at").notNull(),
+    updatedBy: text("updated_by").notNull()
+  },
+  (t) => ({
+    projectIdx: index("label_keys_project").on(t.projectId),
+    chunkIdx: index("label_keys_chunk").on(t.chunkId),
+    profileKeyUniq: uniqueIndex("label_keys_profile_key").on(t.profileId, t.key)
+  })
+);
+var labelDrafts = sqliteTable(
+  "label_drafts",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    profileId: text("profile_id").notNull().references(() => labelProfiles.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    sourceProfileId: text("source_profile_id").references(() => labelProfiles.id, {
+      onDelete: "set null"
+    }),
+    createdBy: text("created_by").notNull(),
+    status: text("status", { enum: ["open", "merged", "abandoned"] }).notNull().default("open"),
+    createdAt: text("created_at").notNull(),
+    publishedAt: text("published_at")
+  },
+  (t) => ({
+    projectIdx: index("label_drafts_project").on(t.projectId),
+    projectNameUniq: uniqueIndex("label_drafts_project_name").on(t.projectId, t.name)
+  })
+);
+var labelDraftKeys = sqliteTable(
+  "label_draft_keys",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull(),
+    draftId: text("draft_id").notNull().references(() => labelDrafts.id, { onDelete: "cascade" }),
+    key: text("key").notNull(),
+    value: text("value").notNull(),
+    description: text("description"),
+    variables: text("variables", { mode: "json" }).$type(),
+    updatedBy: text("updated_by").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    draftKeyUniq: uniqueIndex("label_draft_keys_draft_key").on(t.draftId, t.key),
+    projectIdx: index("label_draft_keys_project").on(t.projectId)
+  })
+);
+var BUG_STATUSES = ["open", "triaged", "in_progress", "resolved", "wont_fix"];
+var BUG_PRIORITIES = ["low", "medium", "high", "critical"];
+var bugReports = sqliteTable(
+  "bug_reports",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    stepsToReproduce: text("steps_to_reproduce").notNull().default(""),
+    actualResult: text("actual_result").notNull().default(""),
+    expectedResult: text("expected_result").notNull().default(""),
+    status: text("status", { enum: BUG_STATUSES }).notNull().default("open"),
+    priority: text("priority", { enum: BUG_PRIORITIES }),
+    reporterEmail: text("reporter_email"),
+    pageUrl: text("page_url"),
+    userAgent: text("user_agent"),
+    viewport: text("viewport"),
+    context: text("context", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("bug_reports_project").on(t.projectId, t.status),
+    createdIdx: index("bug_reports_created").on(t.projectId, t.createdAt)
+  })
+);
+var FEATURE_REQUEST_STATUSES = [
+  "open",
+  "considering",
+  "planned",
+  "shipped",
+  "declined"
+];
+var FEATURE_REQUEST_IMPORTANCES = ["nice_to_have", "important", "critical"];
+var featureRequests = sqliteTable(
+  "feature_requests",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    description: text("description").notNull().default(""),
+    useCase: text("use_case").notNull().default(""),
+    importance: text("importance", { enum: FEATURE_REQUEST_IMPORTANCES }).notNull().default("nice_to_have"),
+    status: text("status", { enum: FEATURE_REQUEST_STATUSES }).notNull().default("open"),
+    reporterEmail: text("reporter_email"),
+    pageUrl: text("page_url"),
+    userAgent: text("user_agent"),
+    context: text("context", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("feature_requests_project").on(t.projectId, t.status),
+    createdIdx: index("feature_requests_created").on(t.projectId, t.createdAt)
+  })
+);
+var REPORT_KINDS = ["bug", "feature_request"];
+var ATTACHMENT_KINDS = ["screenshot", "recording", "file"];
+var reportAttachments = sqliteTable(
+  "report_attachments",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    reportKind: text("report_kind", { enum: REPORT_KINDS }).notNull(),
+    reportId: text("report_id").notNull(),
+    kind: text("kind", { enum: ATTACHMENT_KINDS }).notNull(),
+    filename: text("filename").notNull(),
+    mimeType: text("mime_type").notNull(),
+    sizeBytes: integer("size_bytes").notNull(),
+    r2Key: text("r2_key").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    reportIdx: index("report_attachments_report").on(t.projectId, t.reportKind, t.reportId)
+  })
+);
+var CONNECTOR_PROVIDERS = ["google_sheets"];
+var connectors = sqliteTable(
+  "connectors",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    provider: text("provider", { enum: CONNECTOR_PROVIDERS }).notNull(),
+    name: text("name").notNull(),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+    events: text("events", { mode: "json" }).$type().notNull(),
+    config: text("config", { mode: "json" }).$type().notNull(),
+    // AES-GCM encrypted JSON: { refresh_token, access_token, expires_at, scope }
+    credentialsCipher: text("credentials_cipher"),
+    // Display label (e.g., the OAuth account email)
+    accountLabel: text("account_label"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("connectors_project").on(t.projectId, t.provider)
+  })
+);
+var i18nUsageDaily = sqliteTable(
+  "i18n_usage_daily",
+  {
+    projectId: text("project_id").notNull(),
+    sdkKeyId: text("sdk_key_id").notNull(),
+    date: text("date").notNull(),
+    requestCount: integer("request_count").notNull().default(0)
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.projectId, t.sdkKeyId, t.date] }),
+    projectDateIdx: index("i18n_usage_daily_project_date").on(t.projectId, t.date)
+  })
+);
+var billingEvents = sqliteTable(
+  "billing_events",
+  {
+    // Stripe event ID — INSERT OR IGNORE makes webhook handling idempotent
+    id: text("id").primaryKey(),
+    projectId: text("project_id").references(() => projects.id, { onDelete: "set null" }),
+    type: text("type").notNull(),
+    payload: text("payload", { mode: "json" }).$type().notNull(),
+    receivedAt: text("received_at").notNull()
+  },
+  (t) => ({
+    projectIdx: index("billing_events_project").on(t.projectId)
+  })
+);
+
+// ../core/src/schemas/configs.ts
+var SEGMENT = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/;
+var RESERVED_FOLDER = "_default";
+var configNameSchema = z.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 = z.enum(CONFIG_KINDS);
+var configEnvSchema = z.enum(CONFIG_ENVS).describe("Target environment. One of the project's configured envs (`dev`, `stage`, `prod`).");
+var jsonSchemaSchema = z.record(z.string(), z.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 = z.union([z.unknown(), z.record(configEnvSchema, z.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 = z.object({
+  name: configNameSchema,
+  description: z.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  schema: jsonSchemaSchema,
+  value: initialValuesSchema.optional()
+}).describe("Body for `POST /api/admin/configs`. `name` + `schema` required.");
+var configUpdateSchema = z.object({
+  schema: jsonSchemaSchema.optional().describe(
+    "Replacement schema. When supplied, the new schema is validated against every published value before it lands."
+  ),
+  value: z.unknown().optional().describe(
+    "Flat value applied to **every** env. Publishes a new version per env. To target one env, use `PUT /{id}/drafts` then `POST /{id}/publish`."
+  )
+}).describe(
+  "Body for `PATCH /api/admin/configs/{id}`. Partial \u2014 only supplied fields change. `value` republishes on every env."
+);
+var configSchemaUpdateSchema = z.object({ schema: jsonSchemaSchema }).describe("Schema-only update. Does not bump value versions or rebuild KV.");
+var configDraftUpsertSchema = z.object({
+  env: configEnvSchema,
+  value: z.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 = z.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 = z.object({
+  version: z.number().int().describe("Monotonically increasing version per env."),
+  publishedAt: z.string().describe("ISO-8601 publish timestamp."),
+  publishedBy: z.string().describe("Email/id of the actor who published this version.")
+});
+var configDraftSummarySchema = z.object({
+  updatedAt: z.string().describe("ISO-8601 last-edit timestamp on the draft."),
+  authorEmail: z.string().describe("Email/id of the actor who last edited the draft."),
+  baseVersion: z.number().int().describe("Published version the draft was forked from.")
+});
+var configResponseSchema = z.object({
+  id: z.string().describe("Stable opaque config id (`cfg_\u2026`)."),
+  name: configNameSchema,
+  description: z.string().nullable(),
+  schema: jsonSchemaSchema,
+  updatedAt: z.string().describe("ISO-8601 timestamp of last mutation."),
+  envs: z.record(configEnvSchema, configEnvPublishedSchema).describe("Per-env latest published version metadata."),
+  drafts: z.record(configEnvSchema, configDraftSummarySchema).describe("Per-env active drafts (if any)."),
+  values: z.record(configEnvSchema, z.unknown()).optional().describe("Per-env latest published values (only returned by `GET /{id}`, not list)."),
+  draftValues: z.record(configEnvSchema, z.unknown()).optional().describe("Per-env draft values (only returned by `GET /{id}`).")
+});
+var configCreateResponseSchema = z.object({
+  id: z.string().describe("Newly assigned config id."),
+  name: configNameSchema
+});
+var configUpdateResponseSchema = z.object({
+  id: z.string().describe("Config id that was updated.")
+});
+var configDeleteResponseSchema = z.object({ ok: z.literal(true) });
+var configDraftSaveResponseSchema = z.object({
+  id: z.string(),
+  env: configEnvSchema,
+  baseVersion: z.number().int().describe("Published version the draft is based on."),
+  updatedAt: z.string()
+});
+var configDraftDiscardResponseSchema = z.object({ ok: z.literal(true) });
+var configPublishResponseSchema = z.object({
+  id: z.string(),
+  env: configEnvSchema,
+  version: z.number().int().describe("Newly published version on `env`.")
+});
+var configActivityEntrySchema = z.object({
+  id: z.string(),
+  action: z.string().describe("Audit action (e.g. `config.create`, `config.publish`)."),
+  actorEmail: z.string(),
+  actorType: z.enum(["user", "cli", "system"]),
+  payload: z.unknown().nullable(),
+  createdAt: z.string().describe("ISO-8601 timestamp.")
+});
+var configActivityResponseSchema = z.array(configActivityEntrySchema).describe("Recent audit rows for one config, newest first.");
+
+// ../core/src/schemas/killswitches.ts
+var switchKeySchema = z2.string().max(64).regex(/^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/, {
+  message: "Switch keys must be lowercase, no dots."
+}).describe(
+  "Single-segment switch key (lowercase letters, digits, `_`/`-`; no dots). Used as the nested switch entry inside a killswitch's `switches` map."
+);
+var killswitchValueSchema = z2.object({
+  value: z2.boolean().describe(
+    "Default boolean delivered when no `switches` entry matches the caller's switch key."
+  ),
+  switches: z2.record(switchKeySchema, z2.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 = z2.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: z2.string().max(512).optional().describe("Optional free-form description shown in the dashboard. Max 512 chars."),
+  value: z2.boolean().optional().describe(
+    "Default value applied to every env at creation. Defaults to `false`. Use `true` to ship the killswitch pre-tripped."
+  ),
+  switches: z2.record(switchKeySchema, z2.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 = z2.object({
+  description: z2.string().max(512).nullish().describe("New description, or `null` to clear it. Max 512 chars."),
+  value: z2.boolean().optional().describe(
+    "Flat value applied to every env. Publishes a new version per env when set. Omit to leave values unchanged."
+  ),
+  switches: z2.record(switchKeySchema, z2.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 = z2.object({
+  env: configEnvSchema.describe("Target environment (`dev`/`stage`/`prod`)."),
+  switchKey: switchKeySchema.describe("Switch key to set."),
+  value: z2.boolean().describe("New boolean value for this `switchKey` on this `env`.")
+}).describe(
+  "Body for `PUT /api/admin/killswitches/{id}/switch`. Sets or updates one switch entry on one env."
+);
+var killswitchSwitchUnsetSchema = z2.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 = z2.object({
+  value: z2.boolean().describe("Flat boolean published for this env."),
+  switches: z2.record(switchKeySchema, z2.boolean()).optional(),
+  version: z2.number().int().describe("Monotonically increasing version per env."),
+  publishedAt: z2.string().describe("ISO-8601 publish timestamp for this version.")
+});
+var killswitchResponseSchema = z2.object({
+  id: z2.string().describe("Stable opaque killswitch id."),
+  name: configNameSchema,
+  description: z2.string().nullable().describe("Free-form description or `null`."),
+  updatedAt: z2.string().describe("ISO-8601 timestamp of last mutation."),
+  envs: z2.record(configEnvSchema, killswitchEnvEntrySchema).describe("Per-env latest value, switches, version, and publish timestamp.")
+});
+var killswitchCreateResponseSchema = z2.object({
+  id: z2.string().describe("Newly assigned killswitch id."),
+  name: configNameSchema
+});
+var killswitchUpdateResponseSchema = z2.object({
+  id: z2.string().describe("Killswitch id that was updated.")
+});
+var killswitchDeleteResponseSchema = z2.object({ ok: z2.literal(true) });
+var killswitchSwitchSetResponseSchema = z2.object({
+  id: z2.string(),
+  env: configEnvSchema,
+  switchKey: switchKeySchema,
+  value: z2.boolean()
+});
+var killswitchSwitchUnsetResponseSchema = z2.object({
+  id: z2.string(),
+  env: configEnvSchema,
+  switchKey: switchKeySchema,
+  removed: z2.boolean().describe("`true` if the entry existed and was removed, `false` if no-op.")
+});
+
+// src/transport.ts
+var ApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+
+// src/resources/killswitches.ts
+var killswitchListResponseSchema = z3.object({
+  data: z3.array(killswitchResponseSchema),
+  next_cursor: z3.string().nullable()
+});
+var BASE = "/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", 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) {
+    try {
+      return await t.request("GET", `${BASE}/${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", `${BASE}/${id}`),
+    create: (input) => t.request("POST", BASE, killswitchCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE}/${id}`, killswitchUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE}/${id}`),
+    setSwitch: (id, input) => t.request("PUT", `${BASE}/${id}/switch`, killswitchSwitchSetSchema.parse(input)),
+    unsetSwitch: (id, input) => t.request("DELETE", `${BASE}/${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: BASE,
+  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."
+    }
+  ]
+};
+export {
+  killswitchesClient,
+  killswitchesResource
+};