gemi 0.64.0 → 0.66.0

package/dist/chunk-f9ccncar.js.map

@@ -1,13 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../database/dialect.ts", "../database/Connection.ts", "../database/DatabaseManager.ts", "../database/config.ts"],
-  "sourcesContent": [
-    "// The SQL dialects Bun's `SQL` client can talk to. Bun infers the *connection*\n// from the URL protocol on its own, but it does not tell us which dialect it\n// picked — and gemi needs to know, because the SQL it generates differs per\n// dialect (`RETURNING` support, upsert syntax, autoincrement, boolean and\n// timestamp types). So we infer it a second time, here, for query generation.\nexport type Dialect = \"sqlite\" | \"postgres\" | \"mysql\" | \"mariadb\";\n\nexport class UnknownDatabaseUrlError extends Error {\n  constructor(url: string) {\n    super(\n      `Could not infer a database dialect from \"${url}\". Expected a URL ` +\n        `starting with postgres://, postgresql://, mysql://, mariadb://, ` +\n        `sqlite://, or file: — or a SQLite path such as ./dev.db or :memory:.`,\n    );\n    this.name = \"UnknownDatabaseUrlError\";\n  }\n}\n\nexport class MissingDatabaseUrlError extends Error {\n  // The connection's name, when it is not the default one. A named connection\n  // has no environment variable behind it and no top-level `url` to fall back\n  // on, so the generic message would send whoever reads it to check\n  // `DATABASE_URL`, which is set and is not what is missing.\n  constructor(connection?: string) {\n    super(\n      connection === undefined || connection === \"default\"\n        ? \"No database URL configured. Set the DATABASE_URL environment \" +\n            \"variable, or set `url` in app/config/database.ts.\"\n        : `The \"${connection}\" database connection has no \\`url\\`. Set one ` +\n            `under \\`connections.${connection}\\` in app/config/database.ts.`,\n    );\n    this.name = \"MissingDatabaseUrlError\";\n  }\n}\n\nconst PROTOCOLS: Record<string, Dialect> = {\n  \"postgres:\": \"postgres\",\n  \"postgresql:\": \"postgres\",\n  \"mysql:\": \"mysql\",\n  \"mariadb:\": \"mariadb\",\n  \"sqlite:\": \"sqlite\",\n  \"file:\": \"sqlite\",\n};\n\nconst SQLITE_FILE_EXTENSIONS = [\".db\", \".sqlite\", \".sqlite3\"];\n\n// Infer the dialect from a connection string. Accepts every form Bun's `SQL`\n// accepts, including the bare SQLite paths (`./dev.db`, `:memory:`) that have no\n// protocol at all.\n//\n// Note this deliberately does NOT default to postgres the way `new SQL(...)`\n// does. Guessing the dialect wrong means generating SQL that fails at runtime\n// against a database that connected fine, which is a far more confusing failure\n// than refusing to guess.\nexport function inferDialect(url: string): Dialect {\n  const trimmed = url.trim();\n\n  if (trimmed === \"\") {\n    throw new UnknownDatabaseUrlError(url);\n  }\n\n  // `:memory:` is SQLite's in-memory database. It looks like a protocol to\n  // `new URL()` but isn't one, so it has to be checked before parsing.\n  if (trimmed === \":memory:\") {\n    return \"sqlite\";\n  }\n\n  const separator = trimmed.indexOf(\":\");\n  if (separator !== -1) {\n    const protocol = trimmed.slice(0, separator + 1).toLowerCase();\n    const dialect = PROTOCOLS[protocol];\n    if (dialect) {\n      return dialect;\n    }\n  }\n\n  // No recognised protocol. Bun treats a bare path as a SQLite file, so we do\n  // too — but only when it actually looks like one, rather than treating every\n  // unrecognised string as SQLite.\n  if (looksLikeSqlitePath(trimmed)) {\n    return \"sqlite\";\n  }\n\n  throw new UnknownDatabaseUrlError(url);\n}\n\nfunction looksLikeSqlitePath(value: string): boolean {\n  if (value.startsWith(\"./\") || value.startsWith(\"../\") || value.startsWith(\"/\")) {\n    return true;\n  }\n  const lower = value.toLowerCase();\n  return SQLITE_FILE_EXTENSIONS.some((extension) => lower.endsWith(extension));\n}\n\n// True when the dialect stores a SQLite database, i.e. a local file rather than\n// a networked server. Callers use this to decide whether `db:setup` should\n// create a file, and which DDL flavour to emit.\nexport function isSqlite(dialect: Dialect): boolean {\n  return dialect === \"sqlite\";\n}\n\n// MariaDB is wire-compatible with MySQL and takes the same SQL in everything\n// gemi generates, so query builders collapse the two.\nexport function isMysqlFamily(dialect: Dialect): boolean {\n  return dialect === \"mysql\" || dialect === \"mariadb\";\n}\n",
-    "import { SQL } from \"bun\";\nimport type { ConnectionConfig } from \"./config\";\nimport { MissingDatabaseUrlError, inferDialect, type Dialect } from \"./dialect\";\n\n/**\n * The name of the connection an application gets without asking for one: the\n * `url` / `options` pair at the top level of `app/config/database.ts`.\n *\n * A constant rather than the string spelled at each site, because it is\n * compared in five places across three layers — the manager resolving a name,\n * the ORM deciding whether a query names a different pool than the open\n * transaction, and the facade — and a typo in any one of them reads as \"that\n * connection is not configured\" rather than as a typo.\n */\nexport const DEFAULT_CONNECTION = \"default\";\n\n/**\n * What every layer above `database/` is allowed to know about a connection.\n *\n * `DatabaseManager` implements this itself and *is* the default connection —\n * see the note on `DatabaseManager.connection`. So this interface is the one\n * shape the ORM and the `DB` facade read, whether they are looking at the\n * default pool or at a named one, and neither has to branch on which it got.\n */\nexport interface DatabaseConnection {\n  /** `\"default\"`, or the key this connection was declared under. */\n  readonly name: string;\n  readonly url: string;\n  readonly dialect: Dialect;\n  readonly sql: SQL;\n  readonly ready: Promise<void>;\n  readonly config: ConnectionConfig;\n}\n\n/** A connection named in the config that the manager has no pool for. */\nexport class UnknownConnectionError extends Error {\n  constructor(name: string, known: readonly string[]) {\n    super(\n      `No database connection named \"${name}\". Configured: ` +\n        `${known.map((one) => `\"${one}\"`).join(\", \")}. Declare it under ` +\n        `\\`connections\\` in app/config/database.ts.`,\n    );\n    this.name = \"UnknownConnectionError\";\n  }\n}\n\n/**\n * A `connections` entry that would shadow the top-level `url`.\n *\n * Refused rather than merged, because the two spellings would be a silent\n * either/or: whichever the manager happened to build last would win, and the\n * losing half of the config would go on describing a pool nothing uses.\n */\nexport class ReservedConnectionNameError extends Error {\n  constructor(name: string) {\n    super(\n      `\"${name}\" is the name of the connection declared by the top-level ` +\n        `\\`url\\` and \\`options\\`, so it cannot also appear under ` +\n        `\\`connections\\`. Rename it, or move its settings up to the top level.`,\n    );\n    this.name = \"ReservedConnectionNameError\";\n  }\n}\n\n/**\n * A statement that named one connection while a transaction was open on\n * another.\n *\n * **The whole reason named connections refuse rather than route.** A\n * transaction lives on one reserved connection of one pool; there is no\n * mechanism by which a second pool's statement could join it, and no rollback\n * that could take it back. So the alternatives to this error are both worse\n * than an error:\n *\n * - Run it on the other pool anyway, *outside* the transaction. The caller\n *   wrote `Model.transaction`, the block rolls back, and that one statement\n *   stays committed. Half the work landed and nothing said so.\n * - Run it on the open handle, ignoring the name. Then the statement went to\n *   the wrong database, which the ORM cannot even detect afterwards — the\n *   tables are usually the same shape.\n *\n * There is no third answer at this layer; two-phase commit is not what a second\n * pool for analytics is asking for. So the failure is made loud and early, at\n * the call that would have straddled the two, and the fix is always the same\n * shape: move that query outside the transaction, or do the whole unit on one\n * connection.\n */\nexport class CrossConnectionTransactionError extends Error {\n  constructor(\n    /** The connection the open transaction belongs to. */\n    public readonly open: string,\n    /** The connection the refused statement named. */\n    public readonly requested: string,\n  ) {\n    super(\n      `A transaction is open on the \"${open}\" connection, and this statement ` +\n        `names \"${requested}\". A transaction cannot span two connections: ` +\n        `the statement would run outside it and stay committed when the ` +\n        `transaction rolls back. Move this query outside the transaction, or ` +\n        `run the whole unit on one connection.`,\n    );\n    this.name = \"CrossConnectionTransactionError\";\n  }\n}\n\n/**\n * One pool: a URL, its dialect, and Bun's client for it.\n *\n * Extracted from `DatabaseManager` when a second connection became\n * configurable (#327). The manager kept the lifecycle — which names exist, how\n * they are resolved, closing them all — and this kept everything that is true\n * of a connection *one at a time*, so the two do not have to be written twice.\n *\n * Safe to build eagerly, like the manager it came from: Bun's client connects\n * on the first query, not at construction. A named connection an application\n * declares and never queries therefore costs an object.\n */\nexport class Connection implements DatabaseConnection {\n  public readonly sql: SQL;\n  public readonly dialect: Dialect;\n  public readonly url: string;\n\n  /**\n   * Resolves once the connection has been configured, or rejects if it could\n   * not be. Only SQLite has anything to do; elsewhere it is already resolved.\n   *\n   * Exposed so a caller that needs the guarantee can wait for it. Nothing has\n   * to: SQLite queues statements on one connection in the order they were\n   * issued, so the pragma below is ahead of anything a caller sends after the\n   * constructor returns. That ordering is asserted in `DatabaseManager.test.ts`\n   * rather than assumed, because it is the load-bearing half.\n   */\n  public readonly ready: Promise<void>;\n\n  constructor(\n    public readonly name: string,\n    public readonly config: ConnectionConfig = {},\n  ) {\n    const url = config.url;\n    if (!url) {\n      throw new MissingDatabaseUrlError(name);\n    }\n\n    this.url = url;\n    // An explicit `dialect` wins, for URLs whose protocol we can't read (a\n    // pooler on a custom scheme). Otherwise infer, which throws rather than\n    // guessing — see the note in dialect.ts.\n    this.dialect = config.dialect ?? inferDialect(url);\n    this.sql = config.options\n      ? new SQL(url, config.options as any)\n      : new SQL(url);\n    this.ready = this.configure();\n  }\n\n  /**\n   * `pragma foreign_keys = ON`, which SQLite leaves **off** by default — and so\n   * does Bun's driver, which reports `0` on a fresh connection.\n   *\n   * Without it SQLite enforces nothing at all. Not \"cascades do not fire\":\n   * nothing. An insert naming a parent that does not exist is accepted, a\n   * dangling reference survives the parent's deletion, and `ON DELETE RESTRICT`\n   * does not restrict — while the migrations declare all three. Postgres\n   * enforces them always, and Prisma turns the pragma on for every SQLite\n   * connection it opens, so leaving it off meant development and production\n   * disagreed about whether the schema's constraints were real.\n   *\n   * It is also why this is more than a dialect gap. The differential harness\n   * compares gemi against Prisma on one database per dialect; with the pragma\n   * off on one side, the two were being asked to agree while running under\n   * different integrity rules, so an entire class of divergence was invisible\n   * to the instrument rather than merely untested.\n   *\n   * **Per connection, not per database**, which is what makes this a live\n   * assumption rather than a one-line fix: Bun serves SQLite from a single\n   * connection today, so setting it once holds for every later statement. If\n   * that ever becomes a pool, one statement's worth of enforcement would move\n   * to whichever connection happened to serve it. `DatabaseManager.test.ts`\n   * pins both halves — the value, and that it is the same across concurrent\n   * queries — so the day it changes is a failing test rather than a silent\n   * regression.\n   *\n   * That per-connection wording is now literal in a second sense: a named\n   * SQLite connection is a *different* Bun client, so it needs the pragma of\n   * its own. Running it from this constructor is what makes that automatic —\n   * the alternative, doing it once for the default connection, was correct\n   * exactly while there was only one.\n   *\n   * Issued outside any transaction. SQLite documents the pragma as a no-op\n   * inside one, so a lazy \"set it on first use\" would be correct exactly until\n   * the first use happened to be a transaction.\n   */\n  private async configure(): Promise<void> {\n    if (this.dialect !== \"sqlite\") return;\n    await this.sql.unsafe(\"pragma foreign_keys = ON\");\n  }\n\n  // Escape hatch matching Bun's own API, so `connection.query` reads like `sql`\n  // does in Bun's docs: connection.query`select * from users where id = ${id}`\n  get query(): SQL {\n    return this.sql;\n  }\n\n  async close(): Promise<void> {\n    // A close that races the constructor's `pragma` leaves that statement to\n    // settle against a client that is going away, and it settles as a rejection\n    // — `ERR_SQLITE_CONNECTION_CLOSED`, from a promise nobody is holding, which\n    // arrives as an unhandled rejection naming neither the close nor the\n    // pragma. The caller asked for this connection to go away, so that\n    // rejection is expected rather than something to surface. Marked handled\n    // here rather than suppressed globally, and only on the way out.\n    this.ready.catch(() => {});\n    await this.sql.close();\n  }\n}\n",
-    "import type { SQL } from \"bun\";\nimport type { ConnectionConfig, DatabaseConfig } from \"./config\";\nimport {\n  Connection,\n  DEFAULT_CONNECTION,\n  ReservedConnectionNameError,\n  UnknownConnectionError,\n  type DatabaseConnection,\n} from \"./Connection\";\nimport type { Dialect } from \"./dialect\";\n\n// Wraps Bun's `SQL` client. Bun ships one client that speaks SQLite, Postgres,\n// MySQL and MariaDB, so gemi does not need a driver per database — it needs to\n// know *which* one is in use, which is what `dialect` carries.\n//\n// Safe to build eagerly: Bun's client connects on the first query, not at\n// construction. (`RedisManager` used to be cited here as the parallel case. As\n// of #403 it builds its client in a memoizing getter instead — not because\n// eager construction was unsafe, but because naming Bun's `RedisClient` at\n// module scope is what made `gemi/services` unloadable off Bun. `Connection`\n// still imports `SQL` as a value for the same reason, which is the remaining\n// half of #396.) It is still bound as a lazy singleton,\n// so an app that never touches the database never resolves it and never has to\n// have DATABASE_URL set.\n//\n// Since #327 it holds *connections*, plural: the top-level `url` and `options`\n// build the one called `\"default\"`, and each key under `connections` builds\n// another. What it does not do is decide which one a query uses — that is the\n// ORM's ambient scope and the `DB` facade, because the choice is per query\n// rather than per application. See `connection` below.\nexport class DatabaseManager implements DatabaseConnection {\n  static token = \"database\";\n\n  /**\n   * This object *is* the default connection, so it answers to the name.\n   *\n   * Not a formality: `connection(\"default\")` returns `this` rather than the\n   * `Connection` in the map, which is what keeps every existing reader —\n   * `DB.sql`, `db.dialect`, and the test harnesses that wrap the manager in a\n   * Proxy to count statements — looking at the same object the ORM executes\n   * through. A second object for the default pool would have quietly bypassed\n   * all of them while every test still passed.\n   */\n  public readonly name = DEFAULT_CONNECTION;\n\n  /**\n   * Every pool this manager owns, keyed by name and including the default one.\n   *\n   * Private because the map is the manager's bookkeeping — `connection()` is\n   * the way in, and it is the only path that knows the default is `this`.\n   */\n  private readonly pools = new Map<string, Connection>();\n\n  /**\n   * Resolves once **every** connection has been configured, or rejects if one\n   * could not be. Only SQLite has anything to do; elsewhere it is already\n   * resolved.\n   *\n   * All of them rather than the default alone, because the thing a caller waits\n   * on this for — SQLite's `pragma foreign_keys` — is per client, so a second\n   * SQLite connection has its own and a caller awaiting one manager-level\n   * promise means all of them.\n   */\n  public readonly ready: Promise<void>;\n\n  constructor(public config: DatabaseConfig = {}) {\n    const { connections = {}, ...primary } = config;\n\n    // The default first, so a `MissingDatabaseUrlError` from a missing\n    // `DATABASE_URL` still comes out of construction the way it always has,\n    // rather than after a named connection has already opened a client.\n    this.pools.set(\n      DEFAULT_CONNECTION,\n      new Connection(DEFAULT_CONNECTION, primary),\n    );\n\n    // A connection that is built before the one whose config is wrong is still\n    // a live client with an open handle, and on the throwing path nothing else\n    // will ever hold it: the manager never becomes a value, so nobody can call\n    // `close`. Left alone, the pragma this constructor issues for a SQLite\n    // connection settles against a client being torn down and surfaces as an\n    // unhandled rejection with no configuration error anywhere near it.\n    try {\n      this.build(connections, primary.slowTransactionThreshold);\n    } catch (error) {\n      for (const pool of this.pools.values()) {\n        // The in-flight configuration first: it is what rejects when the client\n        // under it goes away, and this is the only place that can say the\n        // rejection was expected.\n        pool.ready.catch(() => {});\n        pool.close().catch(() => {});\n      }\n      throw error;\n    }\n\n    // Built once here rather than derived per read, so that a connection whose\n    // configuration rejects produces one unhandled rejection at most instead of\n    // a fresh one per access.\n    this.ready = Promise.all(\n      [...this.pools.values()].map((pool) => pool.ready),\n    ).then(() => undefined);\n  }\n\n  private build(\n    connections: Record<string, ConnectionConfig>,\n    slowTransactionThreshold: number | false | undefined,\n  ): void {\n    for (const [name, connection] of Object.entries(connections)) {\n      if (name === DEFAULT_CONNECTION)\n        throw new ReservedConnectionNameError(name);\n\n      this.pools.set(\n        name,\n        new Connection(name, {\n          // The threshold is the one setting a named connection is likely to\n          // want *unchanged*: it is a development diagnostic about holding a\n          // pooled connection, and that concern does not stop applying because\n          // the pool has a name. `url`, `options` and `dialect` are deliberately\n          // not inherited — a connection that borrowed the default's URL by\n          // omission would be a second pool onto the same database created by a\n          // typo in a key.\n          slowTransactionThreshold,\n          ...connection,\n        }),\n      );\n    }\n  }\n\n  /**\n   * The connection called `name`, or the default one when called with nothing.\n   *\n   * Throws rather than falling back to the default for an unknown name, and\n   * that is the important half. A fallback would make `Model.on(\"analitycs\")`\n   * run on the hot path — the exact pool the caller was trying to stay off —\n   * and the only symptom would be the incident it was meant to prevent,\n   * arriving weeks later with nothing pointing back at the typo.\n   */\n  connection(name: string = DEFAULT_CONNECTION): DatabaseConnection {\n    // `this`, not `pools.get(DEFAULT_CONNECTION)` — see `name` above.\n    if (name === DEFAULT_CONNECTION) return this;\n\n    const found = this.pools.get(name);\n    if (!found) throw new UnknownConnectionError(name, this.connectionNames);\n    return found;\n  }\n\n  /** Every configured name, default first. For error messages and diagnostics. */\n  get connectionNames(): string[] {\n    return [...this.pools.keys()];\n  }\n\n  /**\n   * The default connection's client. Unchanged in meaning: an application that\n   * never names a connection sees exactly what it saw before #327.\n   */\n  get sql(): SQL {\n    return this.default.sql;\n  }\n\n  get dialect(): Dialect {\n    return this.default.dialect;\n  }\n\n  get url(): string {\n    return this.default.url;\n  }\n\n  // Escape hatch matching Bun's own API, so `db.query` reads like `sql` does in\n  // Bun's docs: db.query`select * from users where id = ${id}`\n  get query(): SQL {\n    return this.sql;\n  }\n\n  /** Closes every connection, not only the default one. */\n  async close(): Promise<void> {\n    // The aggregate promise needs the same treatment each connection's own\n    // `ready` gets in `Connection.close` — it is derived from them, so a\n    // rejection there arrives here as a second, separately unhandled one.\n    this.ready.catch(() => {});\n    await Promise.all([...this.pools.values()].map((pool) => pool.close()));\n  }\n\n  private get default(): Connection {\n    return this.pools.get(DEFAULT_CONNECTION)!;\n  }\n}\n",
-    "import type { SQL } from \"bun\";\nimport type { Dialect } from \"./dialect\";\n\n// One connection: a URL, the dialect to compile for, and the pool behind it.\n//\n// Split out of `DatabaseConfig` when a second connection became configurable\n// (#327), so that a named connection is described by exactly the same fields\n// the default one is — rather than by a smaller, second-class shape that would\n// need widening the first time somebody's analytics pool needed a `dialect`\n// override or a threshold of its own.\nexport interface ConnectionConfig {\n  // Connection string. Defaults to the `DATABASE_URL` environment variable.\n  // The dialect is inferred from it — `postgres://`, `mysql://`, `mariadb://`,\n  // `sqlite://`, `file:`, or a SQLite path like `./dev.db` or `:memory:`.\n  url?: string;\n\n  // Override the inferred dialect. Only needed when the URL doesn't carry a\n  // recognisable protocol — a proxy or connection pooler fronting Postgres on a\n  // custom scheme, say. Wrong values here produce SQL that fails at runtime\n  // against a database that connected fine, so leave it unset unless inference\n  // actually gets it wrong.\n  dialect?: Dialect;\n\n  // Options passed straight through to Bun's `SQL` client (pool size, timeouts,\n  // TLS, ...). See https://bun.sh/docs/api/sql.\n  options?: Record<string, unknown>;\n\n  // How long a transaction may run, in milliseconds, before development warns\n  // that it is still holding a pooled connection. `false` turns the warning off.\n  //\n  // A diagnostic, not a limit: nothing here cancels or shortens a transaction.\n  // It only fires in development — the cost of a long transaction is paid by\n  // unrelated queries blocking on connection acquisition, and that is a problem\n  // worth catching while the callback is still in front of you.\n  //\n  // Raise it for a seed script or a data migration whose transactions are\n  // legitimately long; `false` if the noise is not worth it at all. A value\n  // that is not a positive finite number falls back to the 2s default rather\n  // than disabling, so the warning cannot be lost to a typo — say `false` when\n  // you mean off.\n  //\n  // Per connection, and this is the field most likely to differ between two of\n  // them: a connection that exists *because* its queries are slow will warn on\n  // every transaction it opens if it inherits the hot path's threshold, and a\n  // warning that always fires is one nobody reads. A named connection that\n  // does not set it inherits the top-level value.\n  slowTransactionThreshold?: number | false;\n}\n\n// Config key: `database`.\n//\n// The top-level `url` / `options` / `dialect` describe the connection called\n// `\"default\"` — the one every query uses unless it says otherwise. `connections`\n// declares the others.\nexport interface DatabaseConfig extends ConnectionConfig {\n  // Additional connections, keyed by the name `DB.connection(name)` and\n  // `Model.on(name)` take.\n  //\n  // The case this exists for is two pools against **one** database with\n  // opposite workloads — a hot path that must never block, and an analytics\n  // path whose queries legitimately run for seconds:\n  //\n  //     export default defineDatabaseConfig({\n  //       url: process.env.DATABASE_URL,\n  //       options: { max: 12 },\n  //\n  //       connections: {\n  //         analytics: {\n  //           url: process.env.DATABASE_URL,\n  //           options: { max: 3, idleTimeout: 60, connectionTimeout: 45 },\n  //           slowTransactionThreshold: 60_000,\n  //         },\n  //       },\n  //     })\n  //\n  // A value that protects one of those is the wrong value for the other, which\n  // is the entire reason they cannot be one pool with one setting. The same URL\n  // twice is normal here and is not a mistake: what differs is the pool, not\n  // the database.\n  //\n  // Two consequences worth knowing before declaring one, both of them\n  // structural rather than incidental:\n  //\n  // - **A transaction cannot span two connections.** A statement that names one\n  //   while a transaction is open on another raises\n  //   `CrossConnectionTransactionError` rather than quietly running outside the\n  //   transaction.\n  // - **Every connection is a real pool**, counted separately against whatever\n  //   connection cap the server or the pooler enforces. Two pools of 12 is 24\n  //   connections, not 12.\n  connections?: Record<string, ConnectionConfig>;\n}\n\nexport function defineDatabaseConfig(config: DatabaseConfig): DatabaseConfig {\n  return config;\n}\n\nexport function databaseConfigDefaults(): DatabaseConfig {\n  return {\n    url: process.env.DATABASE_URL,\n    dialect: undefined,\n    options: undefined,\n    slowTransactionThreshold: SLOW_TRANSACTION_THRESHOLD,\n    connections: undefined,\n  };\n}\n\n// The default warning threshold, in milliseconds. Exported so the ORM can fall\n// back to the same number when a `DatabaseManager` was built without going\n// through `withDefaults` — a test constructing one directly, say — rather than\n// keeping a second copy of it that can drift.\nexport const SLOW_TRANSACTION_THRESHOLD = 2_000;\n\nexport type { SQL };\n"
-  ],
-  "mappings": "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",
-  "debugId": "FF3653F64371C6CE64756E2164756E21",
-  "names": []
-}

package/dist/client/useDictionary.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=useDictionary.test-d.d.ts.map

package/dist/client/useDictionary.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDictionary.test-d.d.ts","sourceRoot":"","sources":["../../client/useDictionary.test-d.ts"],"names":[],"mappings":""}

package/dist/console/builder.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=builder.test-d.d.ts.map

package/dist/console/builder.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builder.test-d.d.ts","sourceRoot":"","sources":["../../console/builder.test-d.ts"],"names":[],"mappings":""}

package/dist/http/ApiRouter.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ApiRouter.test-d.d.ts.map

package/dist/http/ApiRouter.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ApiRouter.test-d.d.ts","sourceRoot":"","sources":["../../http/ApiRouter.test-d.ts"],"names":[],"mappings":""}

package/dist/http/McpRouter.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=McpRouter.test-d.d.ts.map

package/dist/http/McpRouter.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"McpRouter.test-d.d.ts","sourceRoot":"","sources":["../../http/McpRouter.test-d.ts"],"names":[],"mappings":""}

package/dist/services/events/FakeEventManager.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=FakeEventManager.test-d.d.ts.map

package/dist/services/events/FakeEventManager.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FakeEventManager.test-d.d.ts","sourceRoot":"","sources":["../../../services/events/FakeEventManager.test-d.ts"],"names":[],"mappings":""}

package/dist/services/events/Listener.test-d.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Listener.test-d.d.ts.map

package/dist/services/events/Listener.test-d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Listener.test-d.d.ts","sourceRoot":"","sources":["../../../services/events/Listener.test-d.ts"],"names":[],"mappings":""}