anycodex 0.0.7 → 0.0.9

package/dist/chunk-52L2IFLQ.js

@@ -0,0 +1,2765 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+import {
+  Glob
+} from "./chunk-5WPHGERF.js";
+import {
+  Schema_exports,
+  withStatics,
+  zod_default
+} from "./chunk-HGHQOBPB.js";
+import {
+  __callDispose,
+  __using
+} from "./chunk-CPXZVSHE.js";
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/column-common.js
+var OriginalColumn = /* @__PURE__ */ Symbol.for("drizzle:OriginalColumn");
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/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@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/column.js
+var Column = class {
+  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;
+  length;
+  isLengthExact;
+  isAlias;
+  /** @internal */
+  config;
+  /** @internal */
+  table;
+  /** @internal */
+  onInit() {
+  }
+  constructor(table, config) {
+    this.config = config;
+    this.onInit();
+    this.table = table;
+    this.name = config.name;
+    this.isAlias = false;
+    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;
+    this.length = config["length"];
+    this.isLengthExact = config["isLengthExact"];
+  }
+  mapFromDriverValue(value) {
+    return value;
+  }
+  mapToDriverValue(value) {
+    return value;
+  }
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+  /** @internal */
+  [OriginalColumn]() {
+    return this;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/table.utils.js
+var TableName = /* @__PURE__ */ Symbol.for("drizzle:Name");
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/table.js
+var TableSchema = /* @__PURE__ */ Symbol.for("drizzle:Schema");
+var TableColumns = /* @__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: TableSchema,
+    OriginalName,
+    Columns: TableColumns,
+    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 */
+  [TableSchema];
+  /** @internal */
+  [TableColumns];
+  /** @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[TableSchema] = schema;
+    this[BaseName] = baseName;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+  static [entityKind] = "Subquery";
+  constructor(sql2, fields, alias, isWith = false, usedTables = []) {
+    this._ = {
+      brand: "Subquery",
+      sql: sql2,
+      selectedFields: fields,
+      alias,
+      isWith,
+      usedTables
+    };
+  }
+};
+var WithSubquery = class extends Subquery {
+  static [entityKind] = "WithSubquery";
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/tracing.js
+var tracer = { startActiveSpan(name, fn) {
+  return fn();
+} };
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/view-common.js
+var ViewBaseConfig = /* @__PURE__ */ Symbol.for("drizzle:ViewBaseConfig");
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/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 SQL2 {
+  static [entityKind] = "SQL";
+  /** @internal */
+  decoder = noopDecoder;
+  /** @internal */
+  shouldInlineParams = false;
+  /** @internal */
+  usedTables = [];
+  constructor(queryChunks) {
+    this.queryChunks = queryChunks;
+    for (const chunk of queryChunks) if (is(chunk, Table)) {
+      const schemaName = chunk[Table.Symbol.Schema];
+      this.usedTables.push(schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+    }
+  }
+  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, invokeSource } = 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, SQL2)) 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];
+        if (invokeSource === "mssql-view-with-schemabinding") return {
+          sql: (schemaName === void 0 ? escapeName("dbo") : escapeName(schemaName)) + "." + escapeName(tableName),
+          params: []
+        };
+        return {
+          sql: schemaName === void 0 || chunk[IsAlias] ? 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 = invokeSource === "mssql-check" ? void 0 : chunk.table[Table.Symbol.Schema];
+        return {
+          sql: chunk.isAlias ? escapeName(chunk.name) : 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 || chunk[ViewBaseConfig].isAlias ? 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, SQL2)) 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, SQL2.Aliased) && chunk.fieldAlias !== void 0) return {
+        sql: (chunk.origin !== void 0 ? escapeName(chunk.origin) + "." : "") + 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 (typeof chunk === "function" && "enumName" in chunk) {
+        if ("schema" in chunk && 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" || typeof chunk === "bigint") 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 SQL2.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 {
+  static [entityKind] = "Name";
+  brand;
+  constructor(value) {
+    this.value = value;
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var noopDecoder = { mapFromDriverValue: (value) => value };
+var noopEncoder = { mapToDriverValue: (value) => value };
+var noopMapper = {
+  ...noopDecoder,
+  ...noopEncoder
+};
+var Param = class {
+  static [entityKind] = "Param";
+  brand;
+  /**
+  * @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;
+  }
+  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, param$1] of params.entries()) queryChunks.push(param$1, new StringChunk(strings[paramIndex + 1]));
+  return new SQL(queryChunks);
+}
+(function(_sql) {
+  function empty() {
+    return new SQL([]);
+  }
+  _sql.empty = empty;
+  function fromList(list) {
+    return new SQL(list);
+  }
+  _sql.fromList = fromList;
+  function raw(str) {
+    return new SQL([new StringChunk(str)]);
+  }
+  _sql.raw = raw;
+  function join2(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);
+  }
+  _sql.join = join2;
+  function identifier(value) {
+    return new Name(value);
+  }
+  _sql.identifier = identifier;
+  function placeholder$1(name$1) {
+    return new Placeholder(name$1);
+  }
+  _sql.placeholder = placeholder$1;
+  function param$1(value, encoder) {
+    return new Param(value, encoder);
+  }
+  _sql.param = param$1;
+})(sql || (sql = {}));
+(function(_SQL) {
+  class Aliased {
+    static [entityKind] = "SQL.Aliased";
+    /** @internal */
+    isSelectionField = false;
+    /** @internal */
+    origin;
+    constructor(sql$1, fieldAlias) {
+      this.sql = sql$1;
+      this.fieldAlias = fieldAlias;
+    }
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new Aliased(this.sql, this.fieldAlias);
+    }
+  }
+  _SQL.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class {
+  static [entityKind] = "Placeholder";
+  constructor(name$1) {
+    this.name = name$1;
+  }
+  getSQL() {
+    return new SQL([this]);
+  }
+};
+var IsDrizzleView = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleView");
+var View = class {
+  static [entityKind] = "View";
+  /** @internal */
+  [ViewBaseConfig];
+  /** @internal */
+  [IsDrizzleView] = true;
+  /** @internal */
+  get [TableName]() {
+    return this[ViewBaseConfig].name;
+  }
+  /** @internal */
+  get [TableSchema]() {
+    return this[ViewBaseConfig].schema;
+  }
+  /** @internal */
+  get [IsAlias]() {
+    return this[ViewBaseConfig].isAlias;
+  }
+  /** @internal */
+  get [OriginalName]() {
+    return this[ViewBaseConfig].originalName;
+  }
+  /** @internal */
+  get [TableColumns]() {
+    return this[ViewBaseConfig].selectedFields;
+  }
+  constructor({ name: name$1, schema, selectedFields, query }) {
+    this[ViewBaseConfig] = {
+      name: name$1,
+      originalName: name$1,
+      schema,
+      selectedFields,
+      query,
+      isExisting: !query,
+      isAlias: false
+    };
+  }
+};
+Column.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+  return new SQL([this]);
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+  static [entityKind] = "ColumnBuilder";
+  /** @internal */
+  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@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+var ForeignKeyBuilder = 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 ForeignKey(table, this);
+  }
+};
+var ForeignKey = class {
+  static [entityKind] = "SQLiteForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  constructor(table, builder) {
+    this.table = table;
+    this.reference = builder.reference;
+    this.onUpdate = builder._onUpdate;
+    this.onDelete = builder._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`;
+  }
+  isNameExplicit() {
+    return !!this.reference().name;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/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 ((ref$1, actions$1) => {
+        const builder = new ForeignKeyBuilder(() => {
+          const foreignColumn = ref$1();
+          return {
+            columns: [column],
+            foreignColumns: [foreignColumn]
+          };
+        });
+        if (actions$1.onUpdate) builder.onUpdate(actions$1.onUpdate);
+        if (actions$1.onDelete) builder.onDelete(actions$1.onDelete);
+        return builder.build(table);
+      })(ref, actions);
+    });
+  }
+};
+var SQLiteColumn = class extends Column {
+  static [entityKind] = "SQLiteColumn";
+  /** @internal */
+  table;
+  constructor(table, config) {
+    super(table, config);
+    this.table = table;
+  }
+};
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/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
+  };
+}
+var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+function hexToText(hexString) {
+  let result = "";
+  for (let i = 0; i < hexString.length; i += 2) {
+    const hexPair = hexString.slice(i, i + 2);
+    const decimalValue = Number.parseInt(hexPair, 16);
+    result += String.fromCodePoint(decimalValue);
+  }
+  return result;
+}
+var SQLiteBigIntBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint int64", "SQLiteBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBigInt(table, this.config);
+  }
+};
+var SQLiteBigInt = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") return BigInt(hexToText(value));
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return BigInt(buf.toString("utf8"));
+    }
+    return BigInt(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(value.toString());
+  }
+};
+var SQLiteBlobJsonBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobJsonBuilder";
+  constructor(name) {
+    super(name, "object json", "SQLiteBlobJson");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobJson(table, this.config);
+  }
+};
+var SQLiteBlobJson = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") return JSON.parse(hexToText(value));
+    if (typeof Buffer !== "undefined" && Buffer.from) {
+      const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+      return JSON.parse(buf.toString("utf8"));
+    }
+    return JSON.parse(textDecoder.decode(value));
+  }
+  mapToDriverValue(value) {
+    return Buffer.from(JSON.stringify(value));
+  }
+};
+var SQLiteBlobBufferBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteBlobBufferBuilder";
+  constructor(name) {
+    super(name, "object buffer", "SQLiteBlobBuffer");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteBlobBuffer(table, this.config);
+  }
+};
+var SQLiteBlobBuffer = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteBlobBuffer";
+  mapFromDriverValue(value) {
+    if (Buffer.isBuffer(value)) return value;
+    if (typeof value === "string") return Buffer.from(value, "hex");
+    return Buffer.from(value);
+  }
+  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@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/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;
+  mapJson;
+  forJsonSelect;
+  constructor(table, config) {
+    super(table, config);
+    this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+    this.mapTo = config.customTypeParams.toDriver;
+    this.mapFrom = config.customTypeParams.fromDriver;
+    this.mapJson = config.customTypeParams.fromJson;
+    this.forJsonSelect = config.customTypeParams.forJsonSelect;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(value) {
+    return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+  }
+  mapFromJsonValue(value) {
+    return typeof this.mapJson === "function" ? this.mapJson(value) : this.mapFromDriverValue(value);
+  }
+  jsonSelectIdentifier(identifier, sql2) {
+    if (typeof this.forJsonSelect === "function") return this.forJsonSelect(identifier, sql2);
+    const rawType = this.getSQLType().toLowerCase();
+    const parenPos = rawType.indexOf("(");
+    switch (parenPos + 1 ? rawType.slice(0, parenPos) : rawType) {
+      case "numeric":
+      case "decimal":
+      case "bigint":
+        return sql2`cast(${identifier} as text)`;
+      case "blob":
+        return sql2`hex(${identifier})`;
+      default:
+        return identifier;
+    }
+  }
+  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@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/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 int53", "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, "object 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 (typeof value === "string") return new Date(value.replaceAll('"', ""));
+    if (this.config.mode === "timestamp") return /* @__PURE__ */ new Date(value * 1e3);
+    return new Date(value);
+  }
+  mapToDriverValue(value) {
+    if (typeof value === "number") return 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@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+var SQLiteNumericBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBuilder";
+  constructor(name) {
+    super(name, "string numeric", "SQLiteNumeric");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumeric(table, this.config);
+  }
+};
+var SQLiteNumeric = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumeric";
+  mapFromDriverValue(value) {
+    if (typeof value === "string") return value;
+    return String(value);
+  }
+  getSQLType() {
+    return "numeric";
+  }
+};
+var SQLiteNumericNumberBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericNumberBuilder";
+  constructor(name) {
+    super(name, "number", "SQLiteNumericNumber");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumericNumber(table, this.config);
+  }
+};
+var SQLiteNumericNumber = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericNumber";
+  mapFromDriverValue(value) {
+    if (typeof value === "number") return value;
+    return Number(value);
+  }
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+};
+var SQLiteNumericBigIntBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteNumericBigIntBuilder";
+  constructor(name) {
+    super(name, "bigint int64", "SQLiteNumericBigInt");
+  }
+  /** @internal */
+  build(table) {
+    return new SQLiteNumericBigInt(table, this.config);
+  }
+};
+var SQLiteNumericBigInt = class extends SQLiteColumn {
+  static [entityKind] = "SQLiteNumericBigInt";
+  mapFromDriverValue = BigInt;
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+};
+function numeric(a, b) {
+  const { name, config } = getColumnNameAndConfig(a, b);
+  const mode = config?.mode;
+  return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/sqlite-core/columns/real.js
+var SQLiteRealBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteRealBuilder";
+  constructor(name) {
+    super(name, "number double", "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@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/sqlite-core/columns/text.js
+var SQLiteTextBuilder = class extends SQLiteColumnBuilder {
+  static [entityKind] = "SQLiteTextBuilder";
+  constructor(name, config) {
+    super(name, config.enum?.length ? "string enum" : "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;
+  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, "object 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@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+  static [entityKind] = "SQLiteIndexBuilderOn";
+  constructor(name, unique) {
+    this.name = name;
+    this.unique = unique;
+  }
+  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;
+  isNameExplicit;
+  constructor(config, table) {
+    this.config = {
+      ...config,
+      table
+    };
+    this.isNameExplicit = !!config.name;
+  }
+};
+function index(name) {
+  return new IndexBuilderOn(name, false);
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/node_modules/drizzle-orm/sqlite-core/columns/all.js
+function getSQLiteColumnBuilders() {
+  return {
+    blob,
+    customType,
+    integer,
+    numeric,
+    real,
+    text
+  };
+}
+
+// ../../node_modules/.pnpm/drizzle-orm@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/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(([name$1, colBuilderBase]) => {
+    const colBuilder = colBuilderBase;
+    colBuilder.setName(name$1);
+    const column = colBuilder.build(rawTable);
+    rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+    return [name$1, 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@1.0.0-beta.16-ea816b6_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_0f21266a0de314c39cfb891f27e2ae25/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 {
+  static [entityKind] = "SQLitePrimaryKey";
+  columns;
+  name;
+  isNameExplicit;
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name;
+    this.isNameExplicit = !!name;
+  }
+  getName() {
+    return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+  }
+};
+
+// ../agent/dist/chunk-KXKREECS.js
+import fs from "fs/promises";
+var sep = "/";
+function join(...parts) {
+  const joined = parts.filter(Boolean).join("/");
+  return normalize(joined);
+}
+function dirname(p) {
+  if (!p) return ".";
+  const i = p.lastIndexOf("/");
+  if (i < 0) return ".";
+  if (i === 0) return "/";
+  return p.slice(0, i);
+}
+function basename(p, ext) {
+  if (p.endsWith("/")) p = p.slice(0, -1);
+  const i = p.lastIndexOf("/");
+  const base = i < 0 ? p : p.slice(i + 1);
+  if (ext && base.endsWith(ext)) return base.slice(0, -ext.length);
+  return base;
+}
+function extname(p) {
+  const base = basename(p);
+  const i = base.lastIndexOf(".");
+  if (i <= 0) return "";
+  return base.slice(i);
+}
+function isAbsolute(p) {
+  return p.startsWith("/");
+}
+function normalize(p) {
+  if (!p) return ".";
+  const isAbs = p.startsWith("/");
+  const segments = p.split("/");
+  const out = [];
+  for (const s of segments) {
+    if (s === "" || s === ".") continue;
+    if (s === "..") {
+      if (out.length > 0 && out[out.length - 1] !== "..") {
+        out.pop();
+      } else if (!isAbs) {
+        out.push("..");
+      }
+    } else {
+      out.push(s);
+    }
+  }
+  const result = out.join("/");
+  if (isAbs) return "/" + result;
+  return result || ".";
+}
+function relative(from, to) {
+  from = normalize(from);
+  to = normalize(to);
+  if (from === to) return "";
+  const fromParts = from.split("/").filter(Boolean);
+  const toParts = to.split("/").filter(Boolean);
+  let common = 0;
+  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
+    common++;
+  }
+  const ups = fromParts.length - common;
+  const downs = toParts.slice(common);
+  const parts = [...Array(ups).fill(".."), ...downs];
+  return parts.join("/") || ".";
+}
+function resolve(...parts) {
+  let resolved = "";
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const part = parts[i];
+    if (!part) continue;
+    resolved = resolved ? part + "/" + resolved : part;
+    if (isAbsolute(part)) break;
+  }
+  return normalize(resolved);
+}
+var Filesystem;
+((Filesystem2) => {
+  async function exists(context, p) {
+    return context.fs.exists(p);
+  }
+  Filesystem2.exists = exists;
+  async function isDir(context, p) {
+    const s = await context.fs.stat(p);
+    return s?.isDirectory ?? false;
+  }
+  Filesystem2.isDir = isDir;
+  async function stat(context, p) {
+    return context.fs.stat(p);
+  }
+  Filesystem2.stat = stat;
+  async function size(context, p) {
+    const s = await context.fs.stat(p);
+    return s?.size ?? 0;
+  }
+  Filesystem2.size = size;
+  async function readText(context, p) {
+    return context.fs.readText(p);
+  }
+  Filesystem2.readText = readText;
+  async function readJson(context, p) {
+    return JSON.parse(await readText(context, p));
+  }
+  Filesystem2.readJson = readJson;
+  async function readBytes(context, p) {
+    return context.fs.readBytes(p);
+  }
+  Filesystem2.readBytes = readBytes;
+  async function readArrayBuffer(context, p) {
+    const bytes = await readBytes(context, p);
+    return bytes.buffer;
+  }
+  Filesystem2.readArrayBuffer = readArrayBuffer;
+  async function write(context, p, content) {
+    return context.fs.write(p, content);
+  }
+  Filesystem2.write = write;
+  async function writeJson(context, p, data) {
+    return write(context, p, JSON.stringify(data, null, 2));
+  }
+  Filesystem2.writeJson = writeJson;
+  async function mkdir(context, p) {
+    return context.fs.mkdir(p);
+  }
+  Filesystem2.mkdir = mkdir;
+  async function remove(context, p) {
+    return context.fs.remove(p);
+  }
+  Filesystem2.remove = remove;
+  const MIME_MAP = {
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".mjs": "application/javascript",
+    ".json": "application/json",
+    ".ts": "text/typescript",
+    ".tsx": "text/typescript",
+    ".jsx": "text/javascript",
+    ".md": "text/markdown",
+    ".txt": "text/plain",
+    ".csv": "text/csv",
+    ".xml": "application/xml",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".toml": "text/plain",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".pdf": "application/pdf",
+    ".zip": "application/zip",
+    ".gz": "application/gzip",
+    ".wasm": "application/wasm",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+    ".sh": "text/x-shellscript",
+    ".py": "text/x-python",
+    ".rb": "text/x-ruby",
+    ".go": "text/x-go",
+    ".rs": "text/x-rust",
+    ".java": "text/x-java",
+    ".c": "text/x-c",
+    ".cpp": "text/x-c++",
+    ".h": "text/x-c",
+    ".hpp": "text/x-c++"
+  };
+  function mimeType(p) {
+    return MIME_MAP[extname(p).toLowerCase()] || "application/octet-stream";
+  }
+  Filesystem2.mimeType = mimeType;
+  function resolve2(p) {
+    return resolve(p);
+  }
+  Filesystem2.resolve = resolve2;
+  function overlaps(a, b) {
+    const relA = relative(a, b);
+    const relB = relative(b, a);
+    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..");
+  }
+  Filesystem2.overlaps = overlaps;
+  function contains(parent, child) {
+    return !relative(parent, child).startsWith("..");
+  }
+  Filesystem2.contains = contains;
+  async function findUp(context, target, start, stop) {
+    let current = start;
+    const result = [];
+    while (true) {
+      const search = join(current, target);
+      if (await exists(context, search)) result.push(search);
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    return result;
+  }
+  Filesystem2.findUp = findUp;
+  async function* up(context, options) {
+    const { targets, start, stop } = options;
+    let current = start;
+    while (true) {
+      for (const target of targets) {
+        const search = join(current, target);
+        if (await exists(context, search)) yield search;
+      }
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  Filesystem2.up = up;
+  async function globUp(context, pattern, start, stop) {
+    let current = start;
+    const result = [];
+    while (true) {
+      try {
+        const { Glob: Glob2 } = await import("./glob-RMMK6FVW-AWD4KFLI.js");
+        const matches = await Glob2.scan(context, pattern, {
+          cwd: current,
+          absolute: true,
+          include: "file",
+          dot: true
+        });
+        result.push(...matches);
+      } catch {
+      }
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    return result;
+  }
+  Filesystem2.globUp = globUp;
+})(Filesystem || (Filesystem = {}));
+var Log;
+((Log2) => {
+  Log2.Level = zod_default.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" });
+  const levelPriority = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3
+  };
+  let level = "INFO";
+  function shouldLog(input) {
+    return levelPriority[input] >= levelPriority[level];
+  }
+  const loggers = /* @__PURE__ */ new Map();
+  Log2.Default = create({ service: "default" });
+  let write = (msg) => {
+    console.error(msg);
+    return msg.length;
+  };
+  async function init(options) {
+    if (options.level) level = options.level;
+    if (options.writer) {
+      write = (msg) => {
+        options.writer(msg);
+        return msg.length;
+      };
+    }
+  }
+  Log2.init = init;
+  function formatError(error, depth = 0) {
+    const result = error.message;
+    return error.cause instanceof Error && depth < 10 ? result + " Caused by: " + formatError(error.cause, depth + 1) : result;
+  }
+  let last = Date.now();
+  function create(tags) {
+    tags = tags || {};
+    const service = tags["service"];
+    if (service && typeof service === "string") {
+      const cached = loggers.get(service);
+      if (cached) {
+        return cached;
+      }
+    }
+    function build(message, extra) {
+      const prefix = Object.entries({
+        ...tags,
+        ...extra
+      }).filter(([_, value]) => value !== void 0 && value !== null).map(([key, value]) => {
+        const prefix2 = `${key}=`;
+        if (value instanceof Error) return prefix2 + formatError(value);
+        if (typeof value === "object") return prefix2 + JSON.stringify(value);
+        return prefix2 + value;
+      }).join(" ");
+      const next = /* @__PURE__ */ new Date();
+      const diff = next.getTime() - last;
+      last = next.getTime();
+      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n";
+    }
+    const result = {
+      debug(message, extra) {
+        if (shouldLog("DEBUG")) {
+          write("DEBUG " + build(message, extra));
+        }
+      },
+      info(message, extra) {
+        if (shouldLog("INFO")) {
+          write("INFO  " + build(message, extra));
+        }
+      },
+      error(message, extra) {
+        if (shouldLog("ERROR")) {
+          write("ERROR " + build(message, extra));
+        }
+      },
+      warn(message, extra) {
+        if (shouldLog("WARN")) {
+          write("WARN  " + build(message, extra));
+        }
+      },
+      tag(key, value) {
+        if (tags) tags[key] = value;
+        return result;
+      },
+      clone() {
+        return Log2.create({ ...tags });
+      },
+      time(message, extra) {
+        const now = Date.now();
+        result.info(message, { status: "started", ...extra });
+        function stop() {
+          result.info(message, {
+            status: "completed",
+            duration: Date.now() - now,
+            ...extra
+          });
+        }
+        return {
+          stop,
+          [Symbol.dispose]() {
+            stop();
+          }
+        };
+      }
+    };
+    if (service && typeof service === "string") {
+      loggers.set(service, result);
+    }
+    return result;
+  }
+  Log2.create = create;
+})(Log || (Log = {}));
+var _env = {};
+function truthy(key) {
+  const value = _env[key]?.toLowerCase();
+  return value === "true" || value === "1";
+}
+function falsy(key) {
+  const value = _env[key]?.toLowerCase();
+  return value === "false" || value === "0";
+}
+function number(key) {
+  const value = _env[key];
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+var Flag;
+((Flag2) => {
+  function init(env) {
+    _env = env;
+    Flag2.OPENCODE_AUTO_SHARE = truthy("OPENCODE_AUTO_SHARE");
+    Flag2.OPENCODE_GIT_BASH_PATH = _env["OPENCODE_GIT_BASH_PATH"];
+    Flag2.OPENCODE_CONFIG = _env["OPENCODE_CONFIG"];
+    Flag2.OPENCODE_CONFIG_CONTENT = _env["OPENCODE_CONFIG_CONTENT"];
+    Flag2.OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE");
+    Flag2.OPENCODE_DISABLE_PRUNE = truthy("OPENCODE_DISABLE_PRUNE");
+    Flag2.OPENCODE_DISABLE_TERMINAL_TITLE = truthy("OPENCODE_DISABLE_TERMINAL_TITLE");
+    Flag2.OPENCODE_PERMISSION = _env["OPENCODE_PERMISSION"];
+    Flag2.OPENCODE_DISABLE_DEFAULT_PLUGINS = truthy("OPENCODE_DISABLE_DEFAULT_PLUGINS");
+    Flag2.OPENCODE_DISABLE_LSP_DOWNLOAD = truthy("OPENCODE_DISABLE_LSP_DOWNLOAD");
+    Flag2.OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthy("OPENCODE_ENABLE_EXPERIMENTAL_MODELS");
+    Flag2.OPENCODE_DISABLE_AUTOCOMPACT = truthy("OPENCODE_DISABLE_AUTOCOMPACT");
+    Flag2.OPENCODE_DISABLE_MODELS_FETCH = truthy("OPENCODE_DISABLE_MODELS_FETCH");
+    Flag2.OPENCODE_DISABLE_CLAUDE_CODE = truthy("OPENCODE_DISABLE_CLAUDE_CODE");
+    Flag2.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_PROMPT");
+    Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS");
+    Flag2.OPENCODE_DISABLE_EXTERNAL_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS || truthy("OPENCODE_DISABLE_EXTERNAL_SKILLS");
+    Flag2.OPENCODE_FAKE_VCS = _env["OPENCODE_FAKE_VCS"];
+    Flag2.OPENCODE_SERVER_PASSWORD = _env["OPENCODE_SERVER_PASSWORD"];
+    Flag2.OPENCODE_SERVER_USERNAME = _env["OPENCODE_SERVER_USERNAME"];
+    Flag2.OPENCODE_ENABLE_QUESTION_TOOL = truthy("OPENCODE_ENABLE_QUESTION_TOOL");
+    Flag2.OPENCODE_EXPERIMENTAL = truthy("OPENCODE_EXPERIMENTAL");
+    Flag2.OPENCODE_EXPERIMENTAL_FILEWATCHER = truthy("OPENCODE_EXPERIMENTAL_FILEWATCHER");
+    Flag2.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = truthy("OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER");
+    Flag2.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY");
+    Flag2.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = (() => {
+      const copy = _env["OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"];
+      return copy === void 0 ? false : truthy("OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT");
+    })();
+    Flag2.OPENCODE_ENABLE_EXA = truthy("OPENCODE_ENABLE_EXA") || Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_EXA");
+    Flag2.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS");
+    Flag2.OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX");
+    Flag2.OPENCODE_EXPERIMENTAL_OXFMT = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_OXFMT");
+    Flag2.OPENCODE_EXPERIMENTAL_LSP_TY = truthy("OPENCODE_EXPERIMENTAL_LSP_TY");
+    Flag2.OPENCODE_EXPERIMENTAL_LSP_TOOL = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_LSP_TOOL");
+    Flag2.OPENCODE_DISABLE_FILETIME_CHECK = truthy("OPENCODE_DISABLE_FILETIME_CHECK");
+    Flag2.OPENCODE_EXPERIMENTAL_PLAN_MODE = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE");
+    Flag2.OPENCODE_EXPERIMENTAL_WORKSPACES = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_WORKSPACES");
+    Flag2.OPENCODE_EXPERIMENTAL_MARKDOWN = !falsy("OPENCODE_EXPERIMENTAL_MARKDOWN");
+    Flag2.OPENCODE_MODELS_URL = _env["OPENCODE_MODELS_URL"];
+    Flag2.OPENCODE_MODELS_PATH = _env["OPENCODE_MODELS_PATH"];
+    Flag2.OPENCODE_DISABLE_CHANNEL_DB = truthy("OPENCODE_DISABLE_CHANNEL_DB");
+    Flag2.OPENCODE_SKIP_MIGRATIONS = truthy("OPENCODE_SKIP_MIGRATIONS");
+    Flag2.OPENCODE_STRICT_CONFIG_DEPS = truthy("OPENCODE_STRICT_CONFIG_DEPS");
+  }
+  Flag2.init = init;
+  Flag2.OPENCODE_AUTO_SHARE = false;
+  Flag2.OPENCODE_DISABLE_AUTOUPDATE = false;
+  Flag2.OPENCODE_DISABLE_PRUNE = false;
+  Flag2.OPENCODE_DISABLE_TERMINAL_TITLE = false;
+  Flag2.OPENCODE_DISABLE_DEFAULT_PLUGINS = false;
+  Flag2.OPENCODE_DISABLE_LSP_DOWNLOAD = false;
+  Flag2.OPENCODE_ENABLE_EXPERIMENTAL_MODELS = false;
+  Flag2.OPENCODE_DISABLE_AUTOCOMPACT = false;
+  Flag2.OPENCODE_DISABLE_MODELS_FETCH = false;
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE = false;
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = false;
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = false;
+  Flag2.OPENCODE_DISABLE_EXTERNAL_SKILLS = false;
+  Flag2.OPENCODE_ENABLE_QUESTION_TOOL = false;
+  Flag2.OPENCODE_EXPERIMENTAL = false;
+  Flag2.OPENCODE_EXPERIMENTAL_FILEWATCHER = false;
+  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = false;
+  Flag2.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = false;
+  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = false;
+  Flag2.OPENCODE_ENABLE_EXA = false;
+  Flag2.OPENCODE_EXPERIMENTAL_OXFMT = false;
+  Flag2.OPENCODE_EXPERIMENTAL_LSP_TY = false;
+  Flag2.OPENCODE_EXPERIMENTAL_LSP_TOOL = false;
+  Flag2.OPENCODE_DISABLE_FILETIME_CHECK = false;
+  Flag2.OPENCODE_EXPERIMENTAL_PLAN_MODE = false;
+  Flag2.OPENCODE_EXPERIMENTAL_WORKSPACES = false;
+  Flag2.OPENCODE_EXPERIMENTAL_MARKDOWN = true;
+  Flag2.OPENCODE_DISABLE_CHANNEL_DB = false;
+  Flag2.OPENCODE_SKIP_MIGRATIONS = false;
+  Flag2.OPENCODE_STRICT_CONFIG_DEPS = false;
+})(Flag || (Flag = {}));
+Object.defineProperty(Flag, "OPENCODE_DISABLE_PROJECT_CONFIG", {
+  get() {
+    return truthy("OPENCODE_DISABLE_PROJECT_CONFIG");
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_TUI_CONFIG", {
+  get() {
+    return _env["OPENCODE_TUI_CONFIG"];
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_CONFIG_DIR", {
+  get() {
+    return _env["OPENCODE_CONFIG_DIR"];
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_CLIENT", {
+  get() {
+    return _env["OPENCODE_CLIENT"] ?? "cli";
+  },
+  enumerable: true,
+  configurable: false
+});
+var projectIdSchema = Schema_exports.String.pipe(Schema_exports.brand("ProjectID"));
+var ProjectID = projectIdSchema.pipe(
+  withStatics((schema) => ({
+    global: schema.makeUnsafe("global"),
+    make: (id) => schema.makeUnsafe(id),
+    zod: zod_default.string().pipe(zod_default.custom())
+  }))
+);
+var ProjectTable = sqliteTable("project", {
+  id: text().$type().primaryKey(),
+  worktree: text().notNull(),
+  vcs: text(),
+  name: text(),
+  icon_url: text(),
+  icon_color: text(),
+  ...Timestamps,
+  time_initialized: integer(),
+  sandboxes: text({ mode: "json" }).notNull().$type(),
+  commands: text({ mode: "json" }).$type()
+});
+var DARWIN_HOME = [
+  "Music",
+  "Pictures",
+  "Movies",
+  "Downloads",
+  "Desktop",
+  "Documents",
+  "Public",
+  "Applications",
+  "Library"
+];
+var DARWIN_LIBRARY = [
+  "Application Support/AddressBook",
+  "Calendars",
+  "Mail",
+  "Messages",
+  "Safari",
+  "Cookies",
+  "Application Support/com.apple.TCC",
+  "PersonalizationPortrait",
+  "Metadata/CoreSpotlight",
+  "Suggestions"
+];
+var DARWIN_ROOT = ["/.DocumentRevisions-V100", "/.Spotlight-V100", "/.Trashes", "/.fseventsd"];
+var WIN32_HOME = ["AppData", "Downloads", "Desktop", "Documents", "Pictures", "Music", "Videos", "OneDrive"];
+var Protected;
+((Protected2) => {
+  function names(platform) {
+    if (platform === "darwin") return new Set(DARWIN_HOME);
+    if (platform === "win32") return new Set(WIN32_HOME);
+    return /* @__PURE__ */ new Set();
+  }
+  Protected2.names = names;
+  function paths(home, platform) {
+    if (platform === "darwin")
+      return [
+        ...DARWIN_HOME.map((n) => join(home, n)),
+        ...DARWIN_LIBRARY.map((n) => join(home, "Library", n)),
+        ...DARWIN_ROOT
+      ];
+    if (platform === "win32") return WIN32_HOME.map((n) => join(home, n));
+    return [];
+  }
+  Protected2.paths = paths;
+})(Protected || (Protected = {}));
+var FileIgnore;
+((FileIgnore2) => {
+  const FOLDERS = /* @__PURE__ */ new Set([
+    "node_modules",
+    "bower_components",
+    ".pnpm-store",
+    "vendor",
+    ".npm",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    "target",
+    "bin",
+    "obj",
+    ".git",
+    ".svn",
+    ".hg",
+    ".vscode",
+    ".idea",
+    ".turbo",
+    ".output",
+    "desktop",
+    ".sst",
+    ".cache",
+    ".webkit-cache",
+    "__pycache__",
+    ".pytest_cache",
+    "mypy_cache",
+    ".history",
+    ".gradle"
+  ]);
+  const FILES = [
+    "**/*.swp",
+    "**/*.swo",
+    "**/*.pyc",
+    "**/.DS_Store",
+    "**/Thumbs.db",
+    "**/logs/**",
+    "**/tmp/**",
+    "**/temp/**",
+    "**/*.log",
+    "**/coverage/**",
+    "**/.nyc_output/**"
+  ];
+  FileIgnore2.PATTERNS = [...FILES, ...FOLDERS];
+  function match(filepath, opts) {
+    for (const pattern of opts?.whitelist || []) {
+      if (Glob.match(pattern, filepath)) return false;
+    }
+    const parts = filepath.split(/[/\\]/);
+    for (let i = 0; i < parts.length; i++) {
+      if (FOLDERS.has(parts[i])) return true;
+    }
+    const extra = opts?.extra || [];
+    for (const pattern of [...FILES, ...extra]) {
+      if (Glob.match(pattern, filepath)) return true;
+    }
+    return false;
+  }
+  FileIgnore2.match = match;
+})(FileIgnore || (FileIgnore = {}));
+var FileTimeService = class {
+  log = Log.create({ service: "file.time" });
+  readTimes = {};
+  locks = /* @__PURE__ */ new Map();
+  read(sessionID, file) {
+    this.log.info("read", { sessionID, file });
+    this.readTimes[sessionID] = this.readTimes[sessionID] || {};
+    this.readTimes[sessionID][file] = /* @__PURE__ */ new Date();
+  }
+  get(sessionID, file) {
+    return this.readTimes[sessionID]?.[file];
+  }
+  async assert(context, sessionID, filepath) {
+    if (Flag.OPENCODE_DISABLE_FILETIME_CHECK === true) return;
+    const time = this.get(sessionID, filepath);
+    if (!time) throw new Error(`You must read file ${filepath} before overwriting it. Use the Read tool first`);
+    const s = await Filesystem.stat(context, filepath);
+    const mtimeMs = s?.mtimeMs;
+    if (mtimeMs && mtimeMs > time.getTime() + 50) {
+      const mtime = new Date(mtimeMs);
+      throw new Error(
+        `File ${filepath} has been modified since it was last read.
+Last modification: ${mtime.toISOString()}
+Last read: ${time.toISOString()}
+
+Please read the file again before modifying it.`
+      );
+    }
+  }
+  async withLock(filepath, fn) {
+    const currentLock = this.locks.get(filepath) ?? Promise.resolve();
+    let release = () => {
+    };
+    const nextLock = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    const chained = currentLock.then(() => nextLock);
+    this.locks.set(filepath, chained);
+    await currentLock;
+    try {
+      return await fn();
+    } finally {
+      release();
+      if (this.locks.get(filepath) === chained) this.locks.delete(filepath);
+    }
+  }
+};
+var FileTime;
+((FileTime2) => {
+  function svc(context) {
+    if (context.fileTime) return context.fileTime;
+    return context.fileTime;
+  }
+  function state(context) {
+    const s = svc(context);
+    return { read: s.readTimes, locks: s.locks };
+  }
+  FileTime2.state = state;
+  function read(context, sessionID, file) {
+    svc(context).read(sessionID, file);
+  }
+  FileTime2.read = read;
+  function get(context, sessionID, file) {
+    return svc(context).get(sessionID, file);
+  }
+  FileTime2.get = get;
+  async function withLock(context, filepath, fn) {
+    return svc(context).withLock(filepath, fn);
+  }
+  FileTime2.withLock = withLock;
+  async function assert(context, sessionID, filepath) {
+    return svc(context).assert(context, sessionID, filepath);
+  }
+  FileTime2.assert = assert;
+})(FileTime || (FileTime = {}));
+var Project;
+((Project2) => {
+  const log = Log.create({ service: "project" });
+  Project2.Info = zod_default.object({
+    id: ProjectID.zod,
+    worktree: zod_default.string(),
+    vcs: zod_default.literal("git").optional(),
+    name: zod_default.string().optional(),
+    icon: zod_default.object({
+      url: zod_default.string().optional(),
+      override: zod_default.string().optional(),
+      color: zod_default.string().optional()
+    }).optional(),
+    commands: zod_default.object({
+      start: zod_default.string().optional().describe("Startup script to run when creating a new workspace (worktree)")
+    }).optional(),
+    time: zod_default.object({
+      created: zod_default.number(),
+      updated: zod_default.number(),
+      initialized: zod_default.number().optional()
+    }),
+    sandboxes: zod_default.array(zod_default.string())
+  }).meta({ ref: "Project" });
+  function fromRow(row) {
+    const icon = row.icon_url || row.icon_color ? { url: row.icon_url ?? void 0, color: row.icon_color ?? void 0 } : void 0;
+    return {
+      id: ProjectID.make(row.id),
+      worktree: row.worktree,
+      vcs: row.vcs ? Project2.Info.shape.vcs.parse(row.vcs) : void 0,
+      name: row.name ?? void 0,
+      icon,
+      time: {
+        created: row.time_created,
+        updated: row.time_updated,
+        initialized: row.time_initialized ?? void 0
+      },
+      sandboxes: row.sandboxes,
+      commands: row.commands ?? void 0
+    };
+  }
+  Project2.fromRow = fromRow;
+  function setInitialized(context, id) {
+    context.db.update("project", { op: "eq", field: "id", value: id }, { time_initialized: Date.now() });
+  }
+  Project2.setInitialized = setInitialized;
+  function list(context) {
+    return context.db.findMany("project").map((row) => fromRow(row));
+  }
+  Project2.list = list;
+  function get(context, id) {
+    const row = context.db.findOne("project", { op: "eq", field: "id", value: id });
+    if (!row) return void 0;
+    return fromRow(row);
+  }
+  Project2.get = get;
+  async function sandboxes(context, id) {
+    const row = context.db.findOne("project", { op: "eq", field: "id", value: id });
+    if (!row) return [];
+    const data = fromRow(row);
+    const valid = [];
+    for (const dir of data.sandboxes) {
+      const s = await Filesystem.stat(context, dir);
+      if (s?.isDirectory) valid.push(dir);
+    }
+    return valid;
+  }
+  Project2.sandboxes = sandboxes;
+})(Project || (Project = {}));
+var SessionTable = sqliteTable(
+  "session",
+  {
+    id: text().$type().primaryKey(),
+    project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    workspace_id: text().$type(),
+    parent_id: text().$type(),
+    slug: text().notNull(),
+    directory: text().notNull(),
+    title: text().notNull(),
+    version: text().notNull(),
+    share_url: text(),
+    summary_additions: integer(),
+    summary_deletions: integer(),
+    summary_files: integer(),
+    summary_diffs: text({ mode: "json" }).$type(),
+    revert: text({ mode: "json" }).$type(),
+    ...Timestamps,
+    time_compacting: integer(),
+    time_archived: integer()
+  },
+  (table) => [
+    index("session_project_idx").on(table.project_id),
+    index("session_workspace_idx").on(table.workspace_id),
+    index("session_parent_idx").on(table.parent_id)
+  ]
+);
+var MessageTable = sqliteTable(
+  "message",
+  {
+    id: text().$type().primaryKey(),
+    session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+    ...Timestamps,
+    data: text({ mode: "json" }).notNull().$type()
+  },
+  (table) => [index("message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id)]
+);
+var PartTable = sqliteTable(
+  "part",
+  {
+    id: text().$type().primaryKey(),
+    message_id: text().$type().notNull().references(() => MessageTable.id, { onDelete: "cascade" }),
+    session_id: text().$type().notNull(),
+    ...Timestamps,
+    data: text({ mode: "json" }).notNull().$type()
+  },
+  (table) => [
+    index("part_message_id_id_idx").on(table.message_id, table.id),
+    index("part_session_idx").on(table.session_id)
+  ]
+);
+var TodoTable = sqliteTable(
+  "todo",
+  {
+    session_id: text().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+    content: text().notNull(),
+    status: text().notNull(),
+    priority: text().notNull(),
+    position: integer().notNull(),
+    ...Timestamps
+  },
+  (table) => [
+    primaryKey({ columns: [table.session_id, table.position] }),
+    index("todo_session_idx").on(table.session_id)
+  ]
+);
+var NamedError = class _NamedError extends Error {
+  static create(name, data) {
+    const schema = zod_default.object({
+      name: zod_default.literal(name),
+      data
+    }).meta({
+      ref: name
+    });
+    const result = class extends _NamedError {
+      constructor(data2, options) {
+        super(name, options);
+        this.data = data2;
+        this.name = name;
+      }
+      static Schema = schema;
+      name = name;
+      static isInstance(input) {
+        return typeof input === "object" && "name" in input && input.name === name;
+      }
+      schema() {
+        return schema;
+      }
+      toObject() {
+        return {
+          name,
+          data: this.data
+        };
+      }
+    };
+    Object.defineProperty(result, "name", { value: name });
+    return result;
+  }
+  static Unknown = _NamedError.create(
+    "UnknownError",
+    zod_default.object({
+      message: zod_default.string()
+    })
+  );
+};
+var Lock;
+((Lock2) => {
+  const locks = /* @__PURE__ */ new Map();
+  function get(key) {
+    if (!locks.has(key)) {
+      locks.set(key, {
+        readers: 0,
+        writer: false,
+        waitingReaders: [],
+        waitingWriters: []
+      });
+    }
+    return locks.get(key);
+  }
+  function process(key) {
+    const lock = locks.get(key);
+    if (!lock || lock.writer || lock.readers > 0) return;
+    if (lock.waitingWriters.length > 0) {
+      const nextWriter = lock.waitingWriters.shift();
+      nextWriter();
+      return;
+    }
+    while (lock.waitingReaders.length > 0) {
+      const nextReader = lock.waitingReaders.shift();
+      nextReader();
+    }
+    if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
+      locks.delete(key);
+    }
+  }
+  async function read(key) {
+    const lock = get(key);
+    return new Promise((resolve2) => {
+      if (!lock.writer && lock.waitingWriters.length === 0) {
+        lock.readers++;
+        resolve2({
+          [Symbol.dispose]: () => {
+            lock.readers--;
+            process(key);
+          }
+        });
+      } else {
+        lock.waitingReaders.push(() => {
+          lock.readers++;
+          resolve2({
+            [Symbol.dispose]: () => {
+              lock.readers--;
+              process(key);
+            }
+          });
+        });
+      }
+    });
+  }
+  Lock2.read = read;
+  async function write(key) {
+    const lock = get(key);
+    return new Promise((resolve2) => {
+      if (!lock.writer && lock.readers === 0) {
+        lock.writer = true;
+        resolve2({
+          [Symbol.dispose]: () => {
+            lock.writer = false;
+            process(key);
+          }
+        });
+      } else {
+        lock.waitingWriters.push(() => {
+          lock.writer = true;
+          resolve2({
+            [Symbol.dispose]: () => {
+              lock.writer = false;
+              process(key);
+            }
+          });
+        });
+      }
+    });
+  }
+  Lock2.write = write;
+})(Lock || (Lock = {}));
+var Timestamps = {
+  time_created: integer().notNull().$default(() => Date.now()),
+  time_updated: integer().notNull().$onUpdate(() => Date.now())
+};
+var NotFoundError = NamedError.create(
+  "NotFoundError",
+  zod_default.object({
+    message: zod_default.string()
+  })
+);
+var Database;
+((Database2) => {
+  const INITIAL_MIGRATION = `-- project table
+CREATE TABLE IF NOT EXISTS "project" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "worktree" TEXT NOT NULL,
+  "vcs" TEXT,
+  "name" TEXT,
+  "icon_url" TEXT,
+  "icon_color" TEXT,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_initialized" INTEGER,
+  "sandboxes" TEXT NOT NULL DEFAULT '[]',
+  "commands" TEXT
+);
+
+-- session table
+CREATE TABLE IF NOT EXISTS "session" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "project_id" TEXT NOT NULL REFERENCES "project"("id") ON DELETE CASCADE,
+  "workspace_id" TEXT,
+  "parent_id" TEXT,
+  "slug" TEXT NOT NULL,
+  "directory" TEXT NOT NULL,
+  "title" TEXT NOT NULL,
+  "version" TEXT NOT NULL,
+  "share_url" TEXT,
+  "summary_additions" INTEGER,
+  "summary_deletions" INTEGER,
+  "summary_files" INTEGER,
+  "summary_diffs" TEXT,
+  "revert" TEXT,
+  "permission" TEXT,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_compacting" INTEGER,
+  "time_archived" INTEGER
+);
+CREATE INDEX IF NOT EXISTS "session_project_idx" ON "session"("project_id");
+CREATE INDEX IF NOT EXISTS "session_workspace_idx" ON "session"("workspace_id");
+CREATE INDEX IF NOT EXISTS "session_parent_idx" ON "session"("parent_id");
+
+-- message table
+CREATE TABLE IF NOT EXISTS "message" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "session_id" TEXT NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "data" TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS "message_session_time_created_id_idx" ON "message"("session_id", "time_created", "id");
+
+-- part table
+CREATE TABLE IF NOT EXISTS "part" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "message_id" TEXT NOT NULL REFERENCES "message"("id") ON DELETE CASCADE,
+  "session_id" TEXT NOT NULL,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "data" TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS "part_message_id_id_idx" ON "part"("message_id", "id");
+CREATE INDEX IF NOT EXISTS "part_session_idx" ON "part"("session_id");
+
+-- todo table
+CREATE TABLE IF NOT EXISTS "todo" (
+  "session_id" TEXT NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
+  "content" TEXT NOT NULL,
+  "status" TEXT NOT NULL,
+  "priority" TEXT NOT NULL,
+  "position" INTEGER NOT NULL,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  PRIMARY KEY ("session_id", "position")
+);
+CREATE INDEX IF NOT EXISTS "todo_session_idx" ON "todo"("session_id");
+
+-- permission table
+CREATE TABLE IF NOT EXISTS "permission" (
+  "project_id" TEXT PRIMARY KEY NOT NULL REFERENCES "project"("id") ON DELETE CASCADE,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "data" TEXT NOT NULL
+);
+
+-- session_share table
+CREATE TABLE IF NOT EXISTS "session_share" (
+  "session_id" TEXT PRIMARY KEY NOT NULL REFERENCES "session"("id") ON DELETE CASCADE,
+  "id" TEXT NOT NULL,
+  "secret" TEXT NOT NULL,
+  "url" TEXT NOT NULL,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+-- workspace table
+CREATE TABLE IF NOT EXISTS "workspace" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "type" TEXT NOT NULL,
+  "branch" TEXT,
+  "name" TEXT,
+  "directory" TEXT,
+  "extra" TEXT,
+  "project_id" TEXT NOT NULL REFERENCES "project"("id") ON DELETE CASCADE
+);
+
+-- account table
+CREATE TABLE IF NOT EXISTS "account" (
+  "id" TEXT PRIMARY KEY NOT NULL,
+  "email" TEXT NOT NULL,
+  "url" TEXT NOT NULL,
+  "access_token" TEXT NOT NULL,
+  "refresh_token" TEXT NOT NULL,
+  "token_expiry" INTEGER,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+);
+
+-- account_state table
+CREATE TABLE IF NOT EXISTS "account_state" (
+  "id" INTEGER PRIMARY KEY,
+  "active_account_id" TEXT REFERENCES "account"("id") ON DELETE SET NULL,
+  "active_org_id" TEXT
+);
+
+-- control_account table (legacy)
+CREATE TABLE IF NOT EXISTS "control_account" (
+  "email" TEXT NOT NULL,
+  "url" TEXT NOT NULL,
+  "access_token" TEXT NOT NULL,
+  "refresh_token" TEXT NOT NULL,
+  "token_expiry" INTEGER,
+  "active" INTEGER NOT NULL DEFAULT 0,
+  "time_created" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  "time_updated" INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+  PRIMARY KEY ("email", "url")
+);`;
+  function getMigrations() {
+    const entries = [
+      { sql: INITIAL_MIGRATION, timestamp: Date.UTC(2024, 0, 1), name: "20240101000000_initial" }
+    ];
+    if (Flag.OPENCODE_SKIP_MIGRATIONS) {
+      for (const item of entries) {
+        item.sql = "select 1;";
+      }
+    }
+    return entries;
+  }
+  Database2.getMigrations = getMigrations;
+})(Database || (Database = {}));
+var SqliteNoSqlDb = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  insert(table, row) {
+    const cols = Object.keys(row);
+    const placeholders = cols.map(() => "?").join(", ");
+    const sql2 = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+    this.raw.run(sql2, cols.map((c) => serialize(row[c])));
+  }
+  upsert(table, row, conflictKeys, updateFields) {
+    const cols = Object.keys(row);
+    const placeholders = cols.map(() => "?").join(", ");
+    const conflict = conflictKeys.map((k) => `"${k}"`).join(", ");
+    const updates = Object.keys(updateFields).map((k) => `"${k}" = ?`).join(", ");
+    const sql2 = `INSERT INTO "${table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders}) ON CONFLICT (${conflict}) DO UPDATE SET ${updates}`;
+    const params = [
+      ...cols.map((c) => serialize(row[c])),
+      ...Object.keys(updateFields).map((k) => serialize(updateFields[k]))
+    ];
+    this.raw.run(sql2, params);
+  }
+  findOne(table, filter, options) {
+    const fields = options?.select?.map((f) => `"${f}"`).join(", ") ?? "*";
+    const { clause, params } = filter ? buildWhere(filter) : { clause: "", params: [] };
+    const where = clause ? ` WHERE ${clause}` : "";
+    const sql2 = `SELECT ${fields} FROM "${table}"${where} LIMIT 1`;
+    const row = this.raw.get(sql2, params);
+    return row ? deserializeRow(row) : void 0;
+  }
+  findMany(table, options) {
+    const fields = options?.select?.map((f) => `"${f}"`).join(", ") ?? "*";
+    const { clause, params } = options?.filter ? buildWhere(options.filter) : { clause: "", params: [] };
+    const where = clause ? ` WHERE ${clause}` : "";
+    let orderClause = "";
+    if (options?.orderBy?.length) {
+      const parts = options.orderBy.map(
+        (o) => `"${o.field}" ${o.direction === "desc" ? "DESC" : "ASC"}`
+      );
+      orderClause = ` ORDER BY ${parts.join(", ")}`;
+    }
+    const limitClause = options?.limit != null ? ` LIMIT ${options.limit}` : "";
+    const sql2 = `SELECT ${fields} FROM "${table}"${where}${orderClause}${limitClause}`;
+    return this.raw.all(sql2, params).map(deserializeRow);
+  }
+  update(table, filter, set) {
+    const setCols = Object.keys(set);
+    const setClause = setCols.map((k) => `"${k}" = ?`).join(", ");
+    const { clause, params } = buildWhere(filter);
+    const sql2 = `UPDATE "${table}" SET ${setClause} WHERE ${clause} RETURNING *`;
+    const setParams = setCols.map((k) => serialize(set[k]));
+    const row = this.raw.get(sql2, [...setParams, ...params]);
+    return row ? deserializeRow(row) : void 0;
+  }
+  remove(table, filter) {
+    const { clause, params } = buildWhere(filter);
+    this.raw.run(`DELETE FROM "${table}" WHERE ${clause}`, params);
+  }
+  transaction(fn) {
+    this.raw.transaction(() => {
+      fn(this);
+    });
+  }
+};
+function buildWhere(filter) {
+  switch (filter.op) {
+    case "eq":
+      return { clause: `"${filter.field}" = ?`, params: [serialize(filter.value)] };
+    case "ne":
+      return { clause: `"${filter.field}" != ?`, params: [serialize(filter.value)] };
+    case "gt":
+      return { clause: `"${filter.field}" > ?`, params: [serialize(filter.value)] };
+    case "gte":
+      return { clause: `"${filter.field}" >= ?`, params: [serialize(filter.value)] };
+    case "lt":
+      return { clause: `"${filter.field}" < ?`, params: [serialize(filter.value)] };
+    case "like":
+      return { clause: `"${filter.field}" LIKE ?`, params: [filter.value] };
+    case "isNull":
+      return { clause: `"${filter.field}" IS NULL`, params: [] };
+    case "in": {
+      const placeholders = filter.values.map(() => "?").join(", ");
+      return { clause: `"${filter.field}" IN (${placeholders})`, params: filter.values.map(serialize) };
+    }
+    case "and": {
+      const parts = filter.conditions.map(buildWhere);
+      return {
+        clause: parts.map((p) => `(${p.clause})`).join(" AND "),
+        params: parts.flatMap((p) => p.params)
+      };
+    }
+    case "or": {
+      const parts = filter.conditions.map(buildWhere);
+      return {
+        clause: parts.map((p) => `(${p.clause})`).join(" OR "),
+        params: parts.flatMap((p) => p.params)
+      };
+    }
+  }
+}
+function serialize(value) {
+  if (value === void 0) return null;
+  if (value === null) return null;
+  if (typeof value === "object" && !(value instanceof Buffer) && !(value instanceof Uint8Array)) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function deserializeRow(row) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var Storage;
+((Storage2) => {
+  const log = Log.create({ service: "storage" });
+  Storage2.NotFoundError = NamedError.create(
+    "NotFoundError",
+    zod_default.object({
+      message: zod_default.string()
+    })
+  );
+  const MIGRATIONS = [
+    async (context, dir) => {
+      const project = resolve(dir, "../project");
+      if (!await Filesystem.isDir(context, project)) return;
+      const projectDirs = await Glob.scan(context, "*", {
+        cwd: project,
+        include: "all"
+      });
+      for (const projectDir of projectDirs) {
+        const fullPath = join(project, projectDir);
+        if (!await Filesystem.isDir(context, fullPath)) continue;
+        log.info(`migrating project ${projectDir}`);
+        let projectID = projectDir;
+        const fullProjectDir = join(project, projectDir);
+        let worktree = "/";
+        if (projectID !== "global") {
+          for (const msgFile of await Glob.scan(context, "storage/session/message/*/*.json", {
+            cwd: join(project, projectDir),
+            absolute: true
+          })) {
+            const json = await Filesystem.readJson(context, msgFile);
+            worktree = json.path?.root;
+            if (worktree) break;
+          }
+          if (!worktree) continue;
+          if (!await Filesystem.isDir(context, worktree)) continue;
+          const result = await context.git.run(["rev-list", "--max-parents=0", "--all"], {
+            cwd: worktree
+          });
+          const [id] = result.text().split("\n").filter(Boolean).map((x) => x.trim()).toSorted();
+          if (!id) continue;
+          projectID = id;
+          await Filesystem.writeJson(context, join(dir, "project", projectID + ".json"), {
+            id,
+            vcs: "git",
+            worktree,
+            time: {
+              created: Date.now(),
+              initialized: Date.now()
+            }
+          });
+          log.info(`migrating sessions for project ${projectID}`);
+          for (const sessionFile of await Glob.scan(context, "storage/session/info/*.json", {
+            cwd: fullProjectDir,
+            absolute: true
+          })) {
+            const dest = join(dir, "session", projectID, basename(sessionFile));
+            log.info("copying", {
+              sessionFile,
+              dest
+            });
+            const session = await Filesystem.readJson(context, sessionFile);
+            await Filesystem.writeJson(context, dest, session);
+            log.info(`migrating messages for session ${session.id}`);
+            for (const msgFile of await Glob.scan(context, `storage/session/message/${session.id}/*.json`, {
+              cwd: fullProjectDir,
+              absolute: true
+            })) {
+              const dest2 = join(dir, "message", session.id, basename(msgFile));
+              log.info("copying", {
+                msgFile,
+                dest: dest2
+              });
+              const message = await Filesystem.readJson(context, msgFile);
+              await Filesystem.writeJson(context, dest2, message);
+              log.info(`migrating parts for message ${message.id}`);
+              for (const partFile of await Glob.scan(context, `storage/session/part/${session.id}/${message.id}/*.json`, {
+                cwd: fullProjectDir,
+                absolute: true
+              })) {
+                const dest3 = join(dir, "part", message.id, basename(partFile));
+                const part = await Filesystem.readJson(context, partFile);
+                log.info("copying", {
+                  partFile,
+                  dest: dest3
+                });
+                await Filesystem.writeJson(context, dest3, part);
+              }
+            }
+          }
+        }
+      }
+    },
+    async (context, dir) => {
+      for (const item of await Glob.scan(context, "session/*/*.json", {
+        cwd: dir,
+        absolute: true
+      })) {
+        const session = await Filesystem.readJson(context, item);
+        if (!session.projectID) continue;
+        if (!session.summary?.diffs) continue;
+        const { diffs } = session.summary;
+        await Filesystem.write(context, join(dir, "session_diff", session.id + ".json"), JSON.stringify(diffs));
+        await Filesystem.writeJson(context, join(dir, "session", session.projectID, session.id + ".json"), {
+          ...session,
+          summary: {
+            additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+            deletions: diffs.reduce((sum, x) => sum + x.deletions, 0)
+          }
+        });
+      }
+    }
+  ];
+  async function getDir(context) {
+    const dir = join(context.dataPath, "storage");
+    const migration = await Filesystem.readJson(context, join(dir, "migration")).then((x) => parseInt(x)).catch(() => 0);
+    for (let index2 = migration; index2 < MIGRATIONS.length; index2++) {
+      log.info("running migration", { index: index2 });
+      const migrationFn = MIGRATIONS[index2];
+      await migrationFn(context, dir).catch(() => log.error("failed to run migration", { index: index2 }));
+      await Filesystem.write(context, join(dir, "migration"), (index2 + 1).toString());
+    }
+    return dir;
+  }
+  async function remove(context, key) {
+    const dir = await getDir(context);
+    const target = join(dir, ...key) + ".json";
+    return withErrorHandling(async () => {
+      await fs.unlink(target).catch(() => {
+      });
+    });
+  }
+  Storage2.remove = remove;
+  async function read(context, key) {
+    const dir = await getDir(context);
+    const target = join(dir, ...key) + ".json";
+    return withErrorHandling(async () => {
+      var _stack = [];
+      try {
+        const _ = __using(_stack, await Lock.read(target));
+        const result = await Filesystem.readJson(context, target);
+        return result;
+      } catch (_2) {
+        var _error = _2, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
+    });
+  }
+  Storage2.read = read;
+  async function update(context, key, fn) {
+    const dir = await getDir(context);
+    const target = join(dir, ...key) + ".json";
+    return withErrorHandling(async () => {
+      var _stack = [];
+      try {
+        const _ = __using(_stack, await Lock.write(target));
+        const content = await Filesystem.readJson(context, target);
+        fn(content);
+        await Filesystem.writeJson(context, target, content);
+        return content;
+      } catch (_2) {
+        var _error = _2, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
+    });
+  }
+  Storage2.update = update;
+  async function write(context, key, content) {
+    const dir = await getDir(context);
+    const target = join(dir, ...key) + ".json";
+    return withErrorHandling(async () => {
+      var _stack = [];
+      try {
+        const _ = __using(_stack, await Lock.write(target));
+        await Filesystem.writeJson(context, target, content);
+      } catch (_2) {
+        var _error = _2, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
+    });
+  }
+  Storage2.write = write;
+  async function withErrorHandling(body) {
+    return body().catch((e) => {
+      if (!(e instanceof Error)) throw e;
+      const errnoException = e;
+      if (errnoException.code === "ENOENT") {
+        throw new Storage2.NotFoundError({ message: `Resource not found: ${errnoException.path}` });
+      }
+      throw e;
+    });
+  }
+  async function list(context, prefix) {
+    const dir = await getDir(context);
+    try {
+      const result = await Glob.scan(context, "**/*", {
+        cwd: join(dir, ...prefix),
+        include: "file"
+      }).then((results) => results.map((x) => [...prefix, ...x.slice(0, -5).split(sep)]));
+      result.sort();
+      return result;
+    } catch {
+      return [];
+    }
+  }
+  Storage2.list = list;
+})(Storage || (Storage = {}));
+
+export {
+  join,
+  dirname,
+  basename,
+  extname,
+  isAbsolute,
+  relative,
+  resolve,
+  Filesystem,
+  Log,
+  Flag,
+  ProjectID,
+  ProjectTable,
+  Protected,
+  FileIgnore,
+  FileTimeService,
+  Project,
+  SessionTable,
+  MessageTable,
+  PartTable,
+  TodoTable,
+  NamedError,
+  Timestamps,
+  NotFoundError,
+  Database,
+  SqliteNoSqlDb,
+  Storage
+};