@shipeasy/openapi 1.0.0

package/dist/resources/configs.js

@@ -0,0 +1,2817 @@
+// src/resources/configs.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.");
+
+// src/transport.ts
+var ApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+
+// src/resources/configs.ts
+var configListResponseSchema = z2.object({
+  data: z2.array(configResponseSchema),
+  next_cursor: z2.string().nullable()
+});
+var BASE = "/api/admin/configs";
+function configsClient(t) {
+  async function list(opts = {}) {
+    const query = {};
+    if (opts.limit !== void 0) query.limit = String(opts.limit);
+    if (opts.cursor) query.cursor = opts.cursor;
+    return t.request("GET", 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((c) => c.name === idOrName);
+    if (!found) throw new ApiError(`Config '${idOrName}' not found`, 404);
+    return found;
+  }
+  return {
+    list,
+    listAll,
+    resolve,
+    get: (id) => t.request("GET", `${BASE}/${id}`),
+    create: (input) => t.request("POST", BASE, configCreateSchema.parse(input)),
+    update: (id, input) => t.request("PATCH", `${BASE}/${id}`, configUpdateSchema.parse(input)),
+    delete: (id) => t.request("DELETE", `${BASE}/${id}`),
+    saveDraft: (id, input) => t.request("PUT", `${BASE}/${id}/drafts`, configDraftUpsertSchema.parse(input)),
+    discardDraft: (id, input) => t.request("DELETE", `${BASE}/${id}/drafts`, configPublishSchema.parse(input)),
+    publish: (id, input) => t.request("POST", `${BASE}/${id}/publish`, configPublishSchema.parse(input)),
+    activity: (id, limit) => t.request(
+      "GET",
+      `${BASE}/${id}/activity`,
+      void 0,
+      limit ? { limit: String(limit) } : void 0
+    )
+  };
+}
+var SAMPLE_CFG = {
+  id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4",
+  name: "pricing.tiers",
+  description: "Pricing tier definitions consumed by the checkout flow.",
+  schema: {
+    type: "object",
+    properties: {
+      tiers: { type: "array", items: { type: "object" } }
+    },
+    required: ["tiers"]
+  },
+  updatedAt: "2026-05-09T18:22:11.000Z",
+  envs: {
+    dev: { version: 5, publishedAt: "2026-05-09T18:22:11.000Z", publishedBy: "ana@example.com" },
+    stage: { version: 4, publishedAt: "2026-05-08T11:05:22.000Z", publishedBy: "ana@example.com" },
+    prod: { version: 4, publishedAt: "2026-05-08T11:05:22.000Z", publishedBy: "ana@example.com" }
+  },
+  drafts: {
+    dev: {
+      updatedAt: "2026-05-10T09:31:00.000Z",
+      authorEmail: "bo@example.com",
+      baseVersion: 5
+    }
+  }
+};
+var configsResource = {
+  name: "configs",
+  basePath: BASE,
+  describeOne: "config",
+  describeMany: "configs",
+  tag: {
+    name: "Configs",
+    description: [
+      "Dynamic configs: JSON-Schema-validated structured values delivered to SDKs and editable per environment with a draft/publish workflow.",
+      "",
+      "**Identity.** Each config is keyed by `name` in `folder.name` form (e.g. `pricing.tiers`). Immutable after create.",
+      "",
+      "**Schema-first.** Every config carries a JSON Schema (draft 2020-12, top-level `type: 'object'`). Every published value is validated against it.",
+      "",
+      "**Drafts \u2192 publish.** Per-env edits go through `PUT /{id}/drafts` (stages a value) then `POST /{id}/publish` (promotes to a new version). The flat `PATCH /{id}` republishes on **every** env in one shot \u2014 bypassing drafts.",
+      "",
+      "**Versioning.** Each publish bumps the per-env `version` monotonically. SDKs deliver the latest published version for each env."
+    ].join("\n")
+  },
+  schemas: {
+    create: configCreateSchema,
+    update: configUpdateSchema,
+    saveDraft: configDraftUpsertSchema,
+    publish: configPublishSchema
+  },
+  actions: [
+    { name: "publish", description: "Publish a config draft for an env" },
+    { name: "saveDraft", description: "Save a draft value for an env" },
+    { name: "discardDraft", description: "Discard a draft for an env" }
+  ],
+  endpoints: [
+    {
+      operationId: "listConfigs",
+      method: "GET",
+      path: "",
+      summary: "List dynamic configs",
+      description: "Returns a single page of configs ordered by `updated_at desc, id desc`. Each row includes the latest published `version` per env and any active drafts.",
+      response: configListResponseSchema,
+      examples: { response: { data: [SAMPLE_CFG], next_cursor: null } },
+      useCase: "Snapshot every config in the project \u2014 e.g. CI check that asserts no env is stuck on a stale default or that every config has a published value on prod."
+    },
+    {
+      operationId: "getConfig",
+      method: "GET",
+      path: "/{id}",
+      summary: "Get one config",
+      description: "Returns config metadata plus the latest published values per env and any active draft values. Use this to fetch the JSON the editor renders.",
+      pathParams: { id: "Stable opaque config id (`cfg_\u2026`) or the config's `name`." },
+      response: configResponseSchema,
+      examples: {
+        response: {
+          ...SAMPLE_CFG,
+          values: {
+            dev: { tiers: [{ name: "free" }, { name: "pro" }] },
+            stage: { tiers: [{ name: "free" }, { name: "pro" }] },
+            prod: { tiers: [{ name: "free" }, { name: "pro" }] }
+          },
+          draftValues: {
+            dev: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] }
+          }
+        }
+      },
+      useCase: "Fetch one config's current published values and any in-flight drafts."
+    },
+    {
+      operationId: "createConfig",
+      method: "POST",
+      path: "",
+      summary: "Create a dynamic config",
+      description: [
+        "Creates a new config with the given `schema`. The initial `value` (or an empty object) is published as version 1 on **every** env.",
+        "",
+        "Returns `409` if `name` already exists in the project, `400` if `value` doesn't validate against `schema`."
+      ].join("\n"),
+      successStatus: 201,
+      request: configCreateSchema,
+      response: configCreateResponseSchema,
+      examples: {
+        requestExamples: {
+          minimal: {
+            summary: "Minimal \u2014 name + schema",
+            description: "Smallest valid body. Initial value defaults to `{}` on every env.",
+            value: {
+              name: "pricing.tiers",
+              schema: {
+                type: "object",
+                properties: { tiers: { type: "array" } },
+                required: ["tiers"]
+              }
+            }
+          },
+          seededValue: {
+            summary: "Seeded \u2014 schema + initial value",
+            description: "Seed the same JSON object on every env at version 1.",
+            value: {
+              name: "pricing.tiers",
+              description: "Pricing tier definitions consumed by checkout.",
+              schema: {
+                type: "object",
+                properties: { tiers: { type: "array" } },
+                required: ["tiers"]
+              },
+              value: { tiers: [{ name: "free" }, { name: "pro" }] }
+            }
+          },
+          perEnvSeed: {
+            summary: "Per-env seed",
+            description: "Pass a `{ env: value }` map to seed different initial values per env.",
+            value: {
+              name: "pricing.tiers",
+              schema: {
+                type: "object",
+                properties: { tiers: { type: "array" } },
+                required: ["tiers"]
+              },
+              value: {
+                dev: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] },
+                stage: { tiers: [{ name: "free" }, { name: "pro" }] },
+                prod: { tiers: [{ name: "free" }, { name: "pro" }] }
+              }
+            }
+          }
+        },
+        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4", name: "pricing.tiers" }
+      },
+      useCase: [
+        "- **Minimal create** \u2014 `name` + `schema`. Initial value defaults to `{}`.",
+        "- **Seeded create** \u2014 supply a flat `value` to publish the same object on every env.",
+        "- **Per-env seed** \u2014 supply a `{ env: value }` map for different per-env starting values."
+      ].join("\n")
+    },
+    {
+      operationId: "updateConfig",
+      method: "PATCH",
+      path: "/{id}",
+      summary: "Update a dynamic config",
+      description: [
+        "Partial update. When `value` is supplied it is **republished on every env** (new version per env). When `schema` is supplied it replaces the current schema; every existing value is re-validated.",
+        "",
+        "For env-scoped edits, use the draft/publish flow (`PUT /{id}/drafts` then `POST /{id}/publish`) instead."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque config id." },
+      request: configUpdateSchema,
+      response: configUpdateResponseSchema,
+      examples: {
+        requestExamples: {
+          flatValue: {
+            summary: "Flat value \u2014 republish on every env",
+            description: "Sets the same JSON object as a new version on dev/stage/prod.",
+            value: { value: { tiers: [{ name: "free" }, { name: "pro" }] } }
+          },
+          schemaOnly: {
+            summary: "Schema-only update",
+            description: "Replaces the schema. Existing values must still validate or the update fails.",
+            value: {
+              schema: {
+                type: "object",
+                properties: {
+                  tiers: { type: "array" },
+                  trial_days: { type: "integer" }
+                },
+                required: ["tiers"]
+              }
+            }
+          }
+        },
+        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4" }
+      },
+      useCase: [
+        '- **Republish flat value** \u2014 `{ "value": {\u2026} }` sets the same value on every env.',
+        '- **Schema migration** \u2014 `{ "schema": {\u2026} }` replaces the schema; existing values are re-validated.',
+        "- **Env-scoped edits** \u2014 use `PUT /{id}/drafts` + `POST /{id}/publish` instead of PATCH."
+      ].join("\n")
+    },
+    {
+      operationId: "deleteConfig",
+      method: "DELETE",
+      path: "/{id}",
+      summary: "Delete a dynamic config",
+      description: "Soft-deletes the config and rebuilds the project's flags KV blob.",
+      pathParams: { id: "Stable opaque config id." },
+      response: configDeleteResponseSchema,
+      examples: { response: { ok: true } },
+      useCase: "Tear down a config after its consumers have stopped reading it."
+    },
+    {
+      operationId: "saveConfigDraft",
+      method: "PUT",
+      path: "/{id}/drafts",
+      summary: "Save a draft value",
+      description: [
+        "Stages a value for one env without publishing. The draft is validated against the config's current schema and stored alongside the `baseVersion` it was forked from.",
+        "",
+        "Saving over an existing draft overwrites it. Use `POST /{id}/publish` to promote it to a new published version."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque config id." },
+      request: configDraftUpsertSchema,
+      response: configDraftSaveResponseSchema,
+      examples: {
+        requestExamples: {
+          stageDev: {
+            summary: "Stage a dev draft",
+            description: "Stages a new value on dev without touching stage/prod.",
+            value: {
+              env: "dev",
+              value: { tiers: [{ name: "free" }, { name: "pro" }, { name: "enterprise" }] }
+            }
+          }
+        },
+        response: {
+          id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4",
+          env: "dev",
+          baseVersion: 5,
+          updatedAt: "2026-05-10T09:31:00.000Z"
+        }
+      },
+      useCase: "Iterate on a config value on dev without affecting prod \u2014 preview in staging, then publish."
+    },
+    {
+      operationId: "discardConfigDraft",
+      method: "DELETE",
+      path: "/{id}/drafts",
+      summary: "Discard a draft",
+      description: "Drops the in-flight draft on one env. Published values are unaffected.",
+      pathParams: { id: "Stable opaque config id." },
+      request: configPublishSchema,
+      response: configDraftDiscardResponseSchema,
+      examples: {
+        requestExamples: {
+          discardDev: {
+            summary: "Discard the dev draft",
+            description: "Drops the staged dev draft without publishing.",
+            value: { env: "dev" }
+          }
+        },
+        response: { ok: true }
+      },
+      useCase: "Abandon an in-progress draft after deciding not to ship it."
+    },
+    {
+      operationId: "publishConfigDraft",
+      method: "POST",
+      path: "/{id}/publish",
+      summary: "Publish a draft",
+      description: [
+        "Promotes the staged draft on one env to a new published version. The draft must still validate against the current schema.",
+        "",
+        "Returns `404` if there is no draft for the given env."
+      ].join("\n"),
+      pathParams: { id: "Stable opaque config id." },
+      request: configPublishSchema,
+      response: configPublishResponseSchema,
+      examples: {
+        requestExamples: {
+          publishDev: {
+            summary: "Publish the dev draft",
+            description: "Promotes the dev draft to a new published version on dev.",
+            value: { env: "dev" }
+          },
+          publishProd: {
+            summary: "Publish to prod",
+            description: "Promotes the prod draft after staging signed off.",
+            value: { env: "prod" }
+          }
+        },
+        response: { id: "cfg_01j7wae5h6j7k8l9m0n1p2q3r4", env: "dev", version: 6 }
+      },
+      useCase: "Ship a staged change once you've validated it on a lower env."
+    },
+    {
+      operationId: "listConfigActivity",
+      method: "GET",
+      path: "/{id}/activity",
+      summary: "List config activity",
+      description: "Returns recent audit rows for one config (create, update, draft.save, publish, delete) ordered newest first. Use the `limit` query parameter to cap the result (1\u2013100, default 20).",
+      pathParams: { id: "Stable opaque config id." },
+      queryParams: {
+        limit: {
+          schema: z2.coerce.number().int().min(1).max(100).default(20),
+          description: "Max rows to return (1\u2013100). Defaults to 20."
+        }
+      },
+      response: configActivityResponseSchema,
+      examples: {
+        response: [
+          {
+            id: "act_01j7waf01a2b3c4d5e6f7g8h9i",
+            action: "config.publish",
+            actorEmail: "ana@example.com",
+            actorType: "user",
+            payload: { env: "dev", version: 6 },
+            createdAt: "2026-05-10T09:31:42.000Z"
+          }
+        ]
+      },
+      useCase: "Render the activity panel in the config editor or drive a slack notification on publish events."
+    }
+  ]
+};
+export {
+  configsClient,
+  configsResource
+};