gemi 0.193.0 → 0.194.0

package/dist/{chunk-xwz5fmwy.js.map → chunk-geqdq8hp.js.map}

@@ -9,6 +9,6 @@
     "import type { Dialect } from \"../../database/dialect\";\nimport type { Binder, Fragment } from \"../compile/fragment\";\nimport type { RowLockClause } from \"../compile/lock\";\nimport type { FieldSchema, ScalarType } from \"../schema\";\nimport { PostgresDialect } from \"./postgres\";\nimport { SqliteDialect } from \"./sqlite\";\n\n/**\n * The per-database strategy.\n *\n * The rule this interface exists to enforce: no `if (dialect === \"postgres\")`\n * ever appears inside the compiler. When something genuinely cannot be\n * expressed through the interface, the interface widens — which is why\n * `inList`, `like` and `paginate` return `Fragment`s rather than strings. Each\n * of the three is a place where SQLite and Postgres disagree about *structure*,\n * not just spelling:\n *\n * - `inList` — SQLite expands one placeholder per element, so `in: [1,2]` and\n *   `in: [1,2,3]` are different SQL and different plans. Postgres binds the\n *   whole array to one parameter with `= any($1)`, so every length shares a\n *   single plan and a single prepared statement.\n * - `like` — Postgres has `ilike` for `mode: \"insensitive\"`; SQLite has no\n *   equivalent, and Prisma rejects the argument there outright.\n * - `paginate` — SQLite cannot parse `offset` without a preceding `limit`.\n */\nexport interface SqlDialect {\n  readonly name: Dialect;\n\n  /**\n   * Whether `mode: \"insensitive\"` can be expressed at all. False on SQLite,\n   * where Prisma rejects the argument rather than emulating it.\n   */\n  readonly supportsInsensitiveMode: boolean;\n\n  /**\n   * Whether an `in` list binds as a single parameter however long it is.\n   *\n   * True on Postgres (`= any($1)`), false on SQLite (`in (?, ?, ?)`). It is the\n   * plan *cache* that needs to know: where the length does not change the SQL\n   * text, it must not change the cache key either, or every distinct list\n   * length mints another entry holding SQL identical to its neighbours'. That\n   * matters most for relations, where the list length is the parent row count\n   * and so varies with the data rather than with the code.\n   */\n  readonly bindsListAsOneParameter: boolean;\n\n  /**\n   * Whether `insert`/`update`/`delete` can return the rows they touched.\n   *\n   * True on both implemented dialects — Postgres has had `RETURNING` forever,\n   * and SQLite since 3.35 (Bun 1.3.14 bundles 3.51.0, verified by querying\n   * `sqlite_version()` rather than by reading a changelog).\n   *\n   * It is a capability rather than an assumption because MySQL and MariaDB have\n   * no `RETURNING` at all. Their fallback — `lastInsertRowid` plus a re-select,\n   * and no way to identify the rows an `updateMany` touched — is a different\n   * statement shape, not a different spelling. Iteration 4 does not build it,\n   * but it must stay expressible, so the write compiler asks rather than\n   * assumes and raises a clear error when the answer is no.\n   */\n  readonly supportsReturning: boolean;\n\n  /**\n   * How many parameters one statement may bind.\n   *\n   * A hard protocol/driver limit, not a tuning knob: Postgres sends the\n   * parameter count as an int16 in the Bind message, and SQLite compiles\n   * `SQLITE_MAX_VARIABLE_NUMBER` in.\n   *\n   * Three shapes can approach it, all of them scaling with the caller's *data*\n   * rather than with the query's shape:\n   *\n   * - `createMany`, at `rows × columns`.\n   * - An `in` list on SQLite, which binds one placeholder per element — and\n   *   such a list is routinely request-derived (`?ids=…`).\n   * - A to-many `include` on SQLite, which batches an `in` over the parent\n   *   keys, so a large enough `findMany` reaches it with no big list in sight.\n   *\n   * Postgres escapes the last two: `= any($1)` is one parameter however long\n   * the array. The check itself lives in `compile/fragment.ts`'s `render`,\n   * because that is the one place that sees a statement's final count.\n   *\n   * It lives *here* rather than as a constant in the compiler for the usual\n   * reason: the number differs per dialect, and the compiler is not allowed to\n   * know which dialect it is compiling for.\n   */\n  readonly maxBoundParameters: number;\n\n  /**\n   * Whether the **statement** decides a parameter's type, so a cast the caller\n   * wrote onto their own placeholder changes how the driver encodes the value.\n   *\n   * True on Postgres: the server describes the statement, the client is told\n   * the parameter is `jsonb`, and Bun then JSON-*encodes* whatever JS value it\n   * was handed. That is the whole of #376 — the reason `json-param.ts` retypes\n   * such a parameter through `text` and serialises it to match.\n   *\n   * False on SQLite, and not merely because the correction is unnecessary\n   * there: it would be **wrong**, and it would not parse. A parameter's type is\n   * the bound value's, and `cast(x as json)` is not a JSON cast at all — SQLite\n   * takes any type name and applies affinity rules, and a name containing none\n   * of INT/CHAR/CLOB/TEXT/BLOB/REAL/FLOA/DOUB gets NUMERIC affinity, so\n   * `cast('{\"a\":1}' as json)` is `0`. Measured through `bun:sqlite` (Bun\n   * 1.3.14):\n   *\n   *   select cast(? as jsonb)                            -> 0        (runs)\n   *   select json_set('{\"a\":1}','$.b', cast(? as json))   -> {\"a\":1,\"b\":2}\n   *   select cast(? as text)::json                        -> ERROR unrecognized token: \":\"\n   *\n   * So the retyping's rewrite — `cast(? as text)::json` — turns a statement\n   * that runs on SQLite today into a syntax error. `::` genuinely cannot fire\n   * there (it does not parse), but `cast(… as …)` is not Postgres-only syntax,\n   * and \"SQLite has no jsonb type\" is a claim about semantics rather than about\n   * what the parser accepts. Asking here rather than matching on `name` is what\n   * makes that a fact `tsc` and a test can hold.\n   */\n  readonly typesParametersFromStatement: boolean;\n\n  /** Quote a table or column name. Only ever called with names from the schema. */\n  quoteIdent(name: string): string;\n\n  /**\n   * The parameter marker for the `index`-th (0-based) parameter in a statement.\n   * SQLite ignores the index and returns `?`; Postgres returns `$1`, `$2`, ...\n   */\n  placeholder(index: number): string;\n\n  /**\n   * Prisma-shaped value -> the value the driver must be handed for this field.\n   * The mirror of `decode`, and just as load-bearing: Bun's SQLite driver binds\n   * a `Date` to `NULL`, so an unencoded `where: { createdAt: date }` would\n   * return no rows rather than failing.\n   *\n   * Applied at bind time, not compile time — it is a function of the value.\n   * Which encoder runs is still decided from the schema, so compile stays pure.\n   */\n  encode(value: unknown, field: FieldSchema): unknown;\n\n  /**\n   * SQL appended to this field's placeholder, or `\"\"` for none.\n   *\n   * The one string a dialect contributes to the statement that is not a\n   * parameter, so it must be a constant — never derived from a value, and never\n   * from anything an application supplies. `fieldParam` is the only caller, and\n   * a non-empty cast also means it serialises the value; the two travel\n   * together and neither is correct alone (#209).\n   */\n  castParameter(field: FieldSchema): string;\n\n  /**\n   * The same, for a value with **no declared column type** — a parameter\n   * interpolated into a composed raw fragment, where there is no schema to ask.\n   *\n   * It exists because \"raw\" cannot mean \"unportable\". Bun's SQLite driver\n   * rejects a `Date` outright (`Binding expected string, TypedArray, boolean,\n   * number, bigint or null`) while Postgres takes one, so\n   * ``sql`where \"createdAt\" > ${date}` `` would work on one dialect and throw on\n   * the other — and the caller has no dialect-independent value to reach for\n   * instead, because milliseconds are only correct if that is what the ORM\n   * stored. Which it is: this converts to exactly what `encode` writes for a\n   * `DateTime`, so a raw statement compares against ORM-written rows correctly.\n   *\n   * Deliberately narrow. It normalises the JavaScript types whose SQL form the\n   * ORM has already decided — a `Date`, a boolean — and touches nothing else. A\n   * plain object is *not* JSON-encoded here: the compiler only knows to do that\n   * because a field says `Json`, and guessing from the value would turn a\n   * mistyped parameter into a successfully-written string.\n   *\n   * The exception is a parameter the *caller* cast to `json`/`jsonb`, which is\n   * a declared type by another route and does not reach this at all — see\n   * `json-param.ts`. It is still not a guess from the value: the statement says\n   * so.\n   */\n  encodeUntyped(value: unknown): unknown;\n\n  /** Driver value -> the value Prisma would have returned for this field. */\n  decode(value: unknown, field: FieldSchema): unknown;\n\n  /**\n   * False when the driver already returns exactly what Prisma would for this\n   * field, letting the shaper skip the call entirely on the hot path.\n   */\n  needsDecode(field: FieldSchema): boolean;\n\n  /**\n   * `<lhs> in (...)` / `<lhs> not in (...)`.\n   *\n   * `length` is the element count, which is shape information and is already\n   * part of the plan key. `values` returns the whole array at bind time; how it\n   * is spread across parameters is the dialect's business.\n   */\n  inList(\n    lhs: string,\n    negated: boolean,\n    length: number,\n    values: Binder,\n  ): Fragment;\n\n  /** `<lhs> like <pattern>`, case-insensitively when the dialect can. */\n  like(lhs: string, insensitive: boolean, pattern: Binder): Fragment;\n\n  /**\n   * Whether this dialect can match a **tuple** of columns against a list of\n   * tuples in a statement whose text does not grow with the list.\n   *\n   * The single-column case is `inList`, and on Postgres `= any($1)` already\n   * gives one SQL text for every length — which is what lets `collapsedList`\n   * keep a batched relation query to one plan entry however many parents it\n   * has. A relation joining on *more than one* field cannot use it, so the\n   * loader falls back to an `OR` of `AND`s whose text does grow, and the plan\n   * cache churns with the parent count (#97).\n   *\n   * `unnest` closes that on Postgres — one array parameter per *column*, so the\n   * text is fixed — but it needs each column's SQL type for the cast, and the\n   * types are asked about here rather than assumed: a dialect that cannot spell\n   * one of them says so and the caller keeps the portable `OR`.\n   */\n  canBindCompositeIn(types: readonly ScalarType[]): boolean;\n\n  /**\n   * `(a, b) in (select * from unnest($1::t[], $2::u[]))`.\n   *\n   * `values` yields one tuple per parent at bind time; the dialect decides how\n   * they are transposed into per-column arrays. Only called when\n   * {@link canBindCompositeIn} returned true for these types.\n   */\n  compositeIn(\n    columns: readonly string[],\n    types: readonly ScalarType[],\n    values: Binder,\n  ): Fragment;\n\n  /**\n   * The filters this dialect can apply to a **scalar list** — `tags String[]`.\n   *\n   * **Empty is the whole of SQLite's answer**, and it is a capability rather\n   * than a gap in this ORM: SQLite has no array type, and Prisma refuses the\n   * declaration there at validation time — *\"Field `tags` in model `User` can't\n   * be a list. The current connector does not support lists of primitive\n   * types.\"* So a SQLite database cannot hold such a column to begin with.\n   *\n   * The refusal lives here rather than in the generator, which is where it used\n   * to live (#300). The generated artifact is dialect-agnostic on purpose —\n   * `DATABASE_URL` can name a different database than `prisma generate` saw —\n   * so a generator that refused a scalar list refused it for Postgres too, and\n   * one `String[]` anywhere meant no artifact for *any* model. Asking the\n   * dialect at compile time refuses exactly the combination that cannot work,\n   * and names it, which is the shape {@link UnsupportedDialectError} already\n   * has for the dialects with no compiler at all.\n   */\n  readonly listFilters: ReadonlySet<string>;\n\n  /**\n   * `<value> = any(<column>)` — is this element in the list?\n   *\n   * The mirror of {@link inList} rather than a variant of it, and the two are\n   * easy to confuse: there, one column is matched against a caller's list;\n   * here, one caller value is matched against a column that *is* a list.\n   *\n   * **These four take a `Fragment` where every other member here takes a\n   * `Binder`**, which is a deliberate exception. A list operand may need a cast\n   * on its placeholder — a single element of a `Json[]` needs #209's\n   * `::text::jsonb`, and the serialisation that must travel with it — so the\n   * parameter is built by `fieldParam` before it arrives and the dialect\n   * chooses only the operator. Handing over a `Binder` instead would oblige\n   * each dialect to restate `fieldParam`'s rule, and restating it slightly\n   * wrong is silent: `$1::jsonb = any(col)` answers *false* where\n   * `$1::text::jsonb = any(col)` answers true, with no error on either.\n   */\n  listHas(column: string, value: Fragment): Fragment;\n\n  /** `hasEvery` — every element of the operand is present in the column. */\n  listHasEvery(column: string, values: Fragment): Fragment;\n\n  /** `hasSome` — the column and the operand share at least one element. */\n  listHasSome(column: string, values: Fragment): Fragment;\n\n  /**\n   * `isEmpty: true`, or its negation when `empty` is false.\n   *\n   * The odd one out with no operand at all: the value being compared against is\n   * the empty list, which is the compiler's own constant rather than the\n   * caller's. It stays a bound parameter regardless — see `jsonNullComparison`,\n   * which declines the same exception for the same reason.\n   */\n  listIsEmpty(column: string, empty: boolean): Fragment;\n\n  /**\n   * The right-hand side of a `push`: the column's current value with the\n   * operand appended. An expression rather than a statement, because it is\n   * assigned by the write compiler like any other `set` value.\n   */\n  listPush(column: string, values: Fragment): Fragment;\n\n  /**\n   * How this dialect spells a JSON path, and which filters it can apply to one.\n   *\n   * The **path grammar itself differs**, which is unusual enough to be worth\n   * stating rather than hiding: Prisma takes `path: [\"a\", \"b\"]` on Postgres and\n   * `path: \"$.a.b\"` on SQLite, and refuses the other form on each. That is not\n   * a gemi choice — it is the shape the generated client accepts, measured on\n   * both — so reproducing it is what \"Prisma-compatible\" means here.\n   *\n   * `jsonFilters` is the set of scalar filters the dialect can apply to an\n   * extracted value. Prisma refuses `array_contains` and the numeric\n   * comparisons on SQLite with *\"Unknown argument\"*, so refusing them here is\n   * matching it rather than falling short of it.\n   */\n  readonly jsonPathSyntax: \"array\" | \"jsonpath\";\n  readonly jsonFilters: ReadonlySet<string>;\n\n  /**\n   * Whether an extracted value compares as **text**.\n   *\n   * Postgres's `#>>` yields `text`, so `equals: 3` has to bind `\"3\"` — comparing\n   * text to an integer parameter is a type error there. SQLite's `json_extract`\n   * yields a native value, so the same filter has to bind `3`: bind `\"3\"` and\n   * SQLite compares an INTEGER to a TEXT, which is silently *false* rather than\n   * an error. One filter, two encodings, and the wrong one is a returned-no-rows\n   * bug on one dialect and a raised error on the other.\n   */\n  readonly jsonComparesAsText: boolean;\n\n  /**\n   * The extracted value, as a fragment whose path is **bound**.\n   *\n   * A JSON path is the one place a caller's *value* decides part of an\n   * expression's meaning, which makes it the obvious place to interpolate by\n   * accident and break invariant 2. Both dialects can take it as a parameter —\n   * Postgres's `#>` accepts a `text[]`, SQLite's `json_extract` a string — so\n   * nothing has to be bent to keep it out of the SQL text.\n   *\n   * `asText` picks the extraction that yields SQL text rather than JSON. Every\n   * comparison in `jsonComparison` passes `true` — the string filters compare\n   * against text, and `equals` / `not` / the numeric operators compare an\n   * extracted *scalar*, which is what the text form gives them. The JSON form\n   * has exactly one caller, `jsonArrayContains`, because containment is the one\n   * operator whose right-hand side is a document.\n   *\n   * SQLite ignores the flag: `json_extract` already yields a SQL value rather\n   * than a JSON document for a scalar at the path. That is why the null\n   * sentinels need {@link jsonValueAt} instead of this — see there.\n   */\n  jsonExtract(column: string, path: Binder, asText: boolean): Fragment;\n\n  /** `<extracted> @> <value>` — Postgres only; see `jsonFilters`. */\n  jsonArrayContains(column: string, path: Binder, value: Binder): Fragment;\n\n  /**\n   * The value at `path` **as JSON**, in the form two JSON values compare in.\n   *\n   * The difference from {@link jsonExtract} is the whole of #407, and it is the\n   * distinction the null sentinels are made of. Both dialects have an\n   * extraction that collapses \"the key is absent\" into \"the key holds the JSON\n   * value `null`\", and both have one that does not:\n   *\n   * |          | collapses          | keeps the distinction |\n   * | ---      | ---                | ---                   |\n   * | postgres | `#>>` (text)       | `#>` (jsonb)          |\n   * | sqlite   | `json_extract`     | `->` (JSON text)      |\n   *\n   * `jsonExtract` is the left column at `asText: true`, which is what every\n   * scalar comparison wants — a value to compare, not a document. This is the\n   * right column, and it is what lets `equals: DbNull` compile to\n   * `<value at path> is null` while `equals: JsonNull` compiles to\n   * `<value at path> = <the JSON null>`. Refusing them because `#>>` cannot\n   * tell the two apart was true of `#>>` and not of the dialect.\n   *\n   * **Postgres casts and SQLite does not**, and the cast is not decoration:\n   * `#>` on a `json` column (a `@db.Json` field) yields `json`, which has no\n   * equality operator at all — *\"operator does not exist: json = jsonb\"*, a\n   * raised error rather than a wrong answer, but still one Prisma does not\n   * raise. Prisma emits `(…#>…)::jsonb` for exactly this reason and so does\n   * this. SQLite's `->` already yields the JSON text form.\n   *\n   * Bound, never interpolated, for the same reason `jsonExtract` is.\n   */\n  jsonValueAt(column: string, path: Binder): Fragment;\n\n  /**\n   * Whether the JSON value at `path` — the column itself when `path` is\n   * `undefined` — is an **object** holding the key, any of the keys, or all of\n   * them: `has_key`, `has_some_keys`, `has_every_key` (#664).\n   *\n   * `keys` binds a string for `\"one\"` and a string array for the other two;\n   * `count` is that array's length, which SQLite needs because it tests one\n   * key per term. Postgres binds the array whole, so its text does not depend\n   * on `count` and the plan key collapses the list (`LIST_KEYS` in `plan.ts`).\n   *\n   * **Objects only, on both dialects.** Postgres's `?` also matches a string\n   * *element* of a top-level array; SQLite's path lookup does not. Both forms\n   * are guarded with \"the value is an object\" so the two answer the same rows:\n   * `has_every_key: []` is \"is an object\", and `has_some_keys: []` is false.\n   * A key holding the JSON value `null` exists.\n   */\n  jsonHasKeys(\n    column: string,\n    path: Binder | undefined,\n    keys: Binder,\n    mode: \"one\" | \"some\" | \"every\",\n    count: number,\n  ): Fragment;\n\n  /**\n   * `lhs` differs from `rhs`, treating NULL as equal to NULL — the guard\n   * `skipIfUnchanged` adds to an update's `where` (#664).\n   *\n   * `rhs` is the same parameter the `set` binds, so the comparison is against\n   * the stored encoding of the value. A `Json` column compares as JSON rather\n   * than as text: `jsonb` equality on Postgres (key order and whitespace do not\n   * matter), and `json()`-normalised text on SQLite (whitespace does not\n   * matter; key order does).\n   */\n  distinctFrom(lhs: string, rhs: Fragment, field: FieldSchema): Fragment;\n\n  /**\n   * `limit`/`offset`. Both are values and therefore parameters — this is the\n   * single most tempting place in the compiler to inline a number.\n   */\n  paginate(take: Binder | null, skip: Binder | null): Fragment;\n\n  /**\n   * The clause that makes an insert skip rows violating a unique constraint —\n   * `createMany({ skipDuplicates: true })` — or `null` where it is not offered.\n   *\n   * **`null` is a parity decision, not a missing feature**, and that is worth\n   * knowing before someone \"fixes\" SQLite by returning `insert or ignore`.\n   * SQLite has `on conflict do nothing` and has since 3.24; Prisma nonetheless\n   * rejects the *argument* on SQLite — `Unknown argument 'skipDuplicates'`,\n   * whatever its value, verified against a generated 6.19 client. Offering it\n   * here would make gemi a silent superset of Prisma on the one dialect the\n   * differential harness could then no longer compare, which is the trade this\n   * project has declined every other time it came up.\n   *\n   * A method rather than a boolean because the SQL differs where it exists, and\n   * a `Fragment` because everything the compiler emits is one.\n   */\n  ignoreConflicts(): Fragment | null;\n\n  /**\n   * The clause a locking read ends with — `lock: \"update\"` on a `findMany` —\n   * naming `table` as the only table whose rows are locked.\n   *\n   * Scoped to the root table (`for update of \"User\"`) rather than left bare,\n   * because a folded `include` puts a lateral subquery in the `from` clause and\n   * Postgres refuses to lock through one (`FOR UPDATE is not allowed with\n   * aggregate functions`). Scoping it also matches the documented contract on\n   * both strategies: the root rows are locked, related rows never are.\n   *\n   * **Empty on SQLite, and that is a decision.** SQLite has no row locks, and\n   * does not need them for what a locking read is for: its transactions are\n   * serializable, with one writer at a time on the whole database, so the lost\n   * update a row lock prevents cannot happen there. Two transactions that race\n   * wait on (or fail with `SQLITE_BUSY` on) the database lock instead of the\n   * row's, and `skipLocked` / `noWait` have no row lock to react to. Refusing\n   * would stop code that runs on Postgres in production from running against\n   * SQLite in development and tests, for no gain. The one misuse that matters\n   * on both — a lock outside a transaction — is refused in `Model.$execute`\n   * on every dialect.\n   */\n  rowLock(lock: RowLockClause, table: string): Fragment;\n\n  /**\n   * Recognise a driver error as a constraint violation, and say which columns\n   * it names.\n   *\n   * Returns `null` for anything else, including the *other* constraint kinds:\n   * SQLite reports NOT NULL and FOREIGN KEY failures through the same exception\n   * type, and reporting one of those as a duplicate-key error would send a\n   * caller looking for a row that does not exist.\n   *\n   * Columns, not fields — the driver only knows the database's names. The\n   * caller maps them back through the schema, where `@map` is in scope.\n   */\n  constraintViolation(error: unknown): ConstraintViolation | null;\n}\n\n/** A driver error identified as a constraint failure, in dialect-neutral terms. */\nexport interface ConstraintViolation {\n  /** Only `unique` is translated today; the rest surface as the raw error. */\n  kind: \"unique\";\n  /** Database column names, in the order the driver reported them. */\n  columns: string[];\n  /** The constraint's own name, when the driver gives one. Postgres does. */\n  constraint?: string;\n}\n\n/**\n * The ORM was asked to compile against a dialect it does not implement.\n *\n * **The split this message has to convey**, because it is the surprising part:\n * `DatabaseManager` connects to MySQL and MariaDB perfectly well — Bun's client\n * speaks all four — so raw SQL through `DB.query` / `DB.sql` works, and\n * transactions work. What does not exist is a `SqlDialect` for them, so\n * everything that *compiles* a statement stops here.\n *\n * A caller who reads only \"not supported\" reasonably concludes the connection\n * is unusable, which is wrong and is the more expensive misreading: it is the\n * ORM that is unavailable, not the database.\n */\nexport class UnsupportedDialectError extends Error {\n  constructor(dialect: Dialect) {\n    super(\n      `The gemi ORM does not support the '${dialect}' dialect. Only sqlite ` +\n        `and postgres are implemented — see the supported matrix in ` +\n        `docs/orm.md.\\n\\n` +\n        `The *connection* is fine: Bun's client speaks ${dialect}, so raw SQL ` +\n        `through DB.query / DB.sql and transactions all work. It is the query ` +\n        `compiler that has no ${dialect} dialect, so every model operation ` +\n        `raises this.\\n\\n` +\n        `Point DATABASE_URL at Postgres or SQLite to use the ORM, or keep ` +\n        `using Prisma's own client for this database.`,\n    );\n    this.name = \"UnsupportedDialectError\";\n  }\n}\n\n/**\n * Whether the ORM can compile for this dialect at all.\n *\n * Exported so an application can find out at **boot** rather than on its first\n * query. That is the whole gap this closes: `DatabaseManager` constructs\n * happily against MySQL, so a deploy pointed at one starts, passes a health\n * check, serves traffic, and fails on the first model read — which is the\n * latest and most expensive moment to learn it.\n */\nexport function ormSupports(dialect: Dialect): boolean {\n  return COMPILERS[dialect] !== null;\n}\n\n/** Every dialect `Dialect` names, for anything that has to walk them all. */\nexport function everyDialect(): Dialect[] {\n  return Object.keys(COMPILERS) as Dialect[];\n}\n\n/**\n * The compiler for each dialect, or `null` where the ORM has none.\n *\n * **One map rather than two lists, and `satisfies` rather than a lookup.** The\n * supported set used to be written three times — `ormSupports`' `||` chain,\n * `dialectFor`'s `if` chain, and a test enumerating a hand-written copy of the\n * `Dialect` union — so adding a fifth member to that union changed nothing\n * anywhere: `tsc` clean, tests green, the new dialect silently reported as\n * unsupported by one function and unknown to the other.\n *\n * That moment is exactly what the guard exists for. Adding a dialect to the\n * union is the *first step of implementing one*, and it is the step where a\n * half-added dialect would disagree with itself.\n *\n * `satisfies Record<Dialect, …>` makes it a compile error in a file the build\n * actually checks. It has to live here rather than in a test: `tsconfig.json`\n * excludes test files and vitest transpiles without type-checking, so an\n * exhaustiveness check written there is a type error nothing ever evaluates.\n *\n * The sixth thing in this codebase made `tsc`'s job rather than a convention's\n * — see the note on `resolveLink`'s `operation`.\n */\nconst COMPILERS = {\n  sqlite: new SqliteDialect(),\n  postgres: new PostgresDialect(),\n  // Bun's client speaks both; the ORM has no compiler for either. See\n  // `UnsupportedDialectError`, which is careful to say that the *connection*\n  // still works.\n  mysql: null,\n  mariadb: null,\n} satisfies Record<Dialect, SqlDialect | null>;\n\n/**\n * Resolved per call from `DatabaseManager.dialect`, never baked into a\n * generated artifact — `DATABASE_URL` can point at a different database than\n * the one `prisma generate` saw.\n */\nexport function dialectFor(dialect: Dialect): SqlDialect {\n  const compiler = COMPILERS[dialect];\n  if (compiler === null) throw new UnsupportedDialectError(dialect);\n  return compiler;\n}\n\nexport { PostgresDialect, SqliteDialect };\n"
   ],
   "mappings": "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",
-  "debugId": "5F266DABAEED1FC064756E2164756E21",
+  "debugId": "4FDEB899DC6867D464756E2164756E21",
   "names": []
 }

package/dist/{chunk-9dfrsj4m.js → chunk-gmcttf0f.js}

@@ -1,5 +1,5 @@
 // @bun
 class K extends Error{lock;token;constructor(x,z,C="its lease ran out or another holder took it"){super(`Lost the lock "${x}" (token ${z}): ${C}.`);this.lock=x;this.token=z;this.name="LockLostError"}}var X=60000,Y=100,Z=(x)=>new Promise((z)=>setTimeout(z,x));class V{store;name;owner;token;ttl;lost;controller=new AbortController;deadline;expiryTimer;renewTimer;done=!1;constructor(x,z,C,B,G,J){this.store=x;this.name=z;this.owner=C;this.token=B;this.ttl=G;this.lost=this.controller.signal,this.deadline=J+G,this.armExpiry()}get expired(){return this.lost.aborted||performance.now()>=this.deadline}async extend(x=this.ttl){if(this.lost.aborted)return!1;let z=performance.now();if(!await this.store.extend(this.name,this.owner,this.token,x))return this.markLost(),!1;if(this.done)return!0;return this.deadline=Math.max(this.deadline,z+x),this.armExpiry(),!0}async isHeld(){if(this.lost.aborted)return!1;let x=await this.store.held(this.name,this.owner,this.token);if(!x)this.markLost();return x}async fence(x){if(this.lost.aborted)throw new K(this.name,this.token);try{return await this.store.fence(this.name,this.owner,this.token,x)}catch(z){if(z instanceof K)this.markLost();throw z}}async release(){if(this.stop(),this.lost.aborted)return!1;return this.store.release(this.name,this.owner,this.token)}startRenewing(){if(this.renewTimer||this.done)return;this.renewTimer=setInterval(()=>{this.extend().catch((x)=>{console.error(`[gemi] Could not renew the lock "${this.name}".`,x)})},Math.max(1,Math.floor(this.ttl/3))),this.renewTimer.unref?.()}markLost(x){if(this.stop(),!this.lost.aborted)this.controller.abort(new K(this.name,this.token,x))}stop(){this.done=!0,clearInterval(this.renewTimer),clearTimeout(this.expiryTimer),this.renewTimer=void 0,this.expiryTimer=void 0}armExpiry(){clearTimeout(this.expiryTimer),this.expiryTimer=setTimeout(()=>this.markLost("its lease ran out before it was renewed"),Math.max(0,this.deadline-performance.now())),this.expiryTimer.unref?.()}}class ${store;static token="locks";constructor(x){this.store=x}async acquire(x,z={}){let C=z.ttl??X;if(!(C>0))throw Error(`A lock's ttl must be a positive number of milliseconds; got ${C}.`);let B=Bun.randomUUIDv7(),G=performance.now()+Math.max(0,z.wait??0);for(;;){let J=performance.now(),M=await this.store.acquire(x,B,C);if(M!==null){let Q=new V(this.store,x,B,M,C,J);if(z.renew)Q.startRenewing();return Q}let O=G-performance.now();if(O<=0)return null;await Z(Math.min(Y,O))}}async run(x,z,C){let B=await this.acquire(x,{...z,renew:z.renew??!0});if(!B)return{acquired:!1};let G;try{G=await C(B)}catch(J){throw await B.release().catch(()=>{}),J}if(B.expired)throw B.markLost(),B.lost.reason;return await B.release(),{acquired:!0,value:G}}}var j={ms:1,s:1000,m:60000,h:3600000,d:86400000,w:604800000};function P(x){if(typeof x==="number"){if(!Number.isFinite(x)||x<0)throw TypeError(`A duration is 0 or more milliseconds; got ${x}.`);return Math.round(x)}let z=/^\s*(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)\s*$/.exec(String(x));if(!z)throw TypeError(`"${String(x)}" is not a duration. Use milliseconds, or a number and one of ms, s, m, h, d, w ("30s", "7d").`);return Math.round(Number(z[1])*j[z[2]])}
-export{P as ik,K as jk,V as kk,$ as lk};
+export{P as lk,K as mk,V as nk,$ as ok};
 
-//# debugId=5A6E7DCFA0033AAF64756E2164756E21
+//# debugId=D562626EF50B2BD664756E2164756E21

package/dist/{chunk-9dfrsj4m.js.map → chunk-gmcttf0f.js.map}

@@ -7,6 +7,6 @@
     "/**\n * A length of time: milliseconds as a number, or a number and a unit, such as\n * `\"500ms\"`, `\"30s\"`, `\"5m\"`, `\"2h\"`, `\"7d\"` or `\"1w\"`.\n */\nexport type Duration = number | `${number}${\"ms\" | \"s\" | \"m\" | \"h\" | \"d\" | \"w\"}`;\n\nconst UNITS: Record<string, number> = {\n  ms: 1,\n  s: 1000,\n  m: 60_000,\n  h: 60 * 60_000,\n  d: 24 * 60 * 60_000,\n  w: 7 * 24 * 60 * 60_000,\n};\n\n/** A `Duration` in milliseconds. Throws for anything else, on the caller's stack. */\nexport function toMilliseconds(duration: Duration): number {\n  if (typeof duration === \"number\") {\n    if (!Number.isFinite(duration) || duration < 0) {\n      throw new TypeError(`A duration is 0 or more milliseconds; got ${duration}.`);\n    }\n    return Math.round(duration);\n  }\n  const match = /^\\s*(\\d+(?:\\.\\d+)?)\\s*(ms|s|m|h|d|w)\\s*$/.exec(String(duration));\n  if (!match) {\n    throw new TypeError(\n      `\"${String(duration)}\" is not a duration. Use milliseconds, or a number and ` +\n        `one of ms, s, m, h, d, w (\"30s\", \"7d\").`,\n    );\n  }\n  return Math.round(Number(match[1]) * UNITS[match[2]!]!);\n}\n"
   ],
   "mappings": "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",
-  "debugId": "5A6E7DCFA0033AAF64756E2164756E21",
+  "debugId": "D562626EF50B2BD664756E2164756E21",
   "names": []
 }

package/dist/chunk-gn90agsv.js

@@ -0,0 +1,5 @@
+// @bun
+import{me as o}from"./chunk-3svm89z4.js";import{ne as i}from"./chunk-xpkpz4g6.js";import{pk as t}from"./chunk-beckfwe9.js";import{pl as r}from"./chunk-8e17k7ht.js";class n extends i{register(){this.app.singleton(r,()=>new r(t(o(),this.app.config.get("translation",{}))))}}
+export{n as bb};
+
+//# debugId=24D2145F126B46BD64756E2164756E21

package/dist/{chunk-waq4kj7n.js.map → chunk-gn90agsv.js.map}

@@ -5,6 +5,6 @@
     "import { ServiceProvider } from \"../support/ServiceProvider\";\nimport { withDefaults } from \"../support/withDefaults\";\nimport { Translator } from \"./Translator\";\nimport { translationConfigDefaults, type TranslationConfig } from \"./config\";\n\nexport class TranslationServiceProvider extends ServiceProvider {\n  register() {\n    this.app.singleton(\n      Translator,\n      () =>\n        new Translator(\n          withDefaults(\n            translationConfigDefaults(),\n            this.app.config.get<TranslationConfig>(\"translation\", {}),\n          ),\n        ),\n    );\n  }\n}\n"
   ],
   "mappings": ";sLAKO,AAAM,IAAmC,LAAgB,CAC9D,QAAQ,EAAG,CACT,KAAK,IAAI,UACP,EACA,IACE,IAAI,EACF,EACE,EAA0B,EAC1B,KAAK,IAAI,OAAO,IAAuB,cAAe,CAAC,CAAC,CAC1D,CACF,CACJ,EAEJ",
-  "debugId": "15BF569238FEB78464756E2164756E21",
+  "debugId": "24D2145F126B46BD64756E2164756E21",
   "names": []
 }

package/dist/{chunk-67zz58cw.js → chunk-h9taahxv.js}

@@ -1,5 +1,5 @@
 // @bun
-import{Rd as R}from"./chunk-495k9h6p.js";import{Yd as Q,fe as S,ke as E}from"./chunk-6rmz0mkm.js";import{ql as K}from"./chunk-8pfy75y6.js";import{Hl as A,Il as $,Jl as D}from"./chunk-fryj3asn.js";class j extends Error{code;constructor(q,z=1){super(q);this.code=z;this.name="CommandFailed"}}class J{static commandName="unset";static description="";static args=[];static options=[];run(q){}}function p(q){return q}function C(){return{commands:[],commandsDir:"app/commands"}}var I=Symbol.for("gemi.console.builder");function k(q){if(q.trim()==="")throw Error("A command name cannot be empty.");if(/[{}]/.test(q)||/\s/.test(q))throw Error(`Invalid command name ${JSON.stringify(q)}. gemi does not parse a signature string; the name is the whole of it. Declare arguments with .arg() and flags with .option():
+import{Rd as R}from"./chunk-495k9h6p.js";import{Yd as Q,fe as S,ke as E}from"./chunk-mc8fdh65.js";import{tl as K}from"./chunk-ermvtpy9.js";import{Kl as A,Ll as $,Ml as D}from"./chunk-aycfrzh1.js";class j extends Error{code;constructor(q,z=1){super(q);this.code=z;this.name="CommandFailed"}}class J{static commandName="unset";static description="";static args=[];static options=[];run(q){}}function p(q){return q}function C(){return{commands:[],commandsDir:"app/commands"}}var I=Symbol.for("gemi.console.builder");function k(q){if(q.trim()==="")throw Error("A command name cannot be empty.");if(/[{}]/.test(q)||/\s/.test(q))throw Error(`Invalid command name ${JSON.stringify(q)}. gemi does not parse a signature string; the name is the whole of it. Declare arguments with .arg() and flags with .option():
 
     defineCommand("mail:send")
       .arg("user", { required: true })
@@ -16,4 +16,4 @@ import{Rd as R}from"./chunk-495k9h6p.js";import{Yd as Q,fe as S,ke as E}from"./c
 If this is an abstract base its subclasses extend, move it out of the `+"listeners directory \u2014 the walk excludes gemi's `Listener` and "+"nothing else, so a base sitting beside its subclasses is registered and run like one of them.")}function v(q){for(let z of q){if(Object.getOwnPropertyDescriptor(z,"name")?.writable)continue;console.warn(`Event listener ${z.name} does not declare \`static name\`, so it is registered under its class name, which a production build renames. Nothing reads that name across a build boundary while the `+"listener is sync, which is why this is a warning \u2014 but adding "+`\`queued = true\` to it is refused at boot for the same reason, because the queue's key is that string. Add: static name = "${z.name}";`)}}function u(q){let z=new Set;for(let{event:F}of q){if(z.has(F))continue;if(Object.getOwnPropertyDescriptor(F,"name")?.writable)continue;z.add(F),console.warn(`Event ${F.name} does not declare \`static name\`, so it is dispatched under its class name. A production build minifies the code that dispatches it and renames the class, while discovery reads `+"the listener's copy from source and does not \u2014 so the dispatch would "+`reach no listener in production and nowhere else. Add: static name = "${F.name}";`)}}
 export{j as Bd,J as Cd,p as Dd,C as Ed,c as Fd,o as Gd,T as Hd,i as Id,B as Jd,U as Kd,W as Ld,Sq as Md,Zq as Nd,_q as Od,Iq as Pd,Uq as Qd};
 
-//# debugId=EA66FE1C27E7B2B264756E2164756E21
+//# debugId=3D42FA18091A255864756E2164756E21

package/dist/{chunk-67zz58cw.js.map → chunk-h9taahxv.js.map}

@@ -12,6 +12,6 @@
     "import { existsSync } from \"node:fs\";\nimport { dirname, isAbsolute, join } from \"node:path\";\n\nimport {\n  discoverClasses,\n  DiscoveryError,\n  projectRoot,\n} from \"../support/discover\";\nimport { Command, type CommandClass } from \"../console/Command\";\nimport { commandConfigDefaults } from \"../console/config\";\nimport { isUnfinishedBuilder } from \"../console/builder\";\nimport { CronJob } from \"./cron/CronJob\";\nimport { scheduleConfigDefaults } from \"./cron/config\";\nimport { eventConfigDefaults } from \"./events/config\";\nimport type { EventClass } from \"./events/Event\";\nimport { Listener, type ListenerClass } from \"./events/Listener\";\nimport { Job } from \"./queue/Job\";\nimport { queueConfigDefaults } from \"./queue/config\";\nimport { Workflow, type WorkflowClass } from \"./queue/workflow/Workflow\";\n\n/**\n * Reading an application's jobs off the filesystem, for the two subsystems that\n * were asking every app to write its job list twice.\n *\n * Both functions here are the same call to `discoverClasses` with a different\n * base class, which is deliberate: one walk, one set of skip rules, one answer\n * to \"what does this app have\". They are exported from `gemi/services` rather\n * than kept private to the providers because the list stopped being something\n * an app could import — a test that used to walk the exported `jobs` array\n * needs somewhere to ask the same question, and so does a script.\n *\n * What the providers add on top of these is the decision of *whether* to ask,\n * which is the config's to make and not this file's.\n */\n\n/**\n * A directory the app named, resolved the way the app meant it.\n *\n * Relative paths hang off the project root rather than `process.cwd()` at the\n * moment of the call, because a config slice saying `app/jobs` means the app's\n * `app/jobs` and not whatever directory somebody happened to launch a script\n * from. Absolute paths are taken as given, which is what makes these callable\n * from a test that has no project around it.\n */\nfunction resolveDir(dir: string): string {\n  return isAbsolute(dir) ? dir : join(projectRoot(), dir);\n}\n\n/**\n * Says something when the directory is missing *and so is the tree it lives in*.\n *\n * A missing directory has two readings and they want opposite responses. An app\n * that has never written a cron job has no `app/cron`, and warning about that on\n * every boot for the rest of its life is noise — the answer \"you have no cron\n * jobs\" is correct and uninteresting. But a deploy that ships `dist/` and\n * `node_modules/` without the source has no `app/cron` *and no `app/`*, and\n * there discovery quietly returns nothing while the app very much does have\n * jobs: the exact silence #322 and #323 exist to remove, reintroduced one layer\n * down and in production only.\n *\n * The parent directory is what tells them apart. If neither the directory nor\n * the one above it is there, the tree this was pointed into is not there\n * either, and that is worth a sentence.\n */\nfunction warnIfSourceIsMissing(\n  resolved: string,\n  subject: string,\n  slice: string,\n) {\n  if (existsSync(resolved) || existsSync(dirname(resolved))) return;\n\n  console.warn(\n    `No ${subject} were discovered: neither ${resolved} nor the directory ` +\n      `above it exists, so this process cannot see the application's source. ` +\n      `If this is a deploy that ships only the build output, list the classes ` +\n      `explicitly in app/config/${slice}.ts so they travel with it.`,\n  );\n}\n\n/**\n * The `Job` subclasses under `dir`, defaulting to the config slice's `app/jobs`.\n *\n * This is what a `queue` config slice with no `jobs` key resolves to. Call it\n * directly to ask the question a test used to answer by importing the array:\n * every job this application would register, in the order it would register\n * them.\n *\n * Every file underneath is imported, so calling this runs the app's job modules\n * — the cost `discoverClasses` documents at length, paid once per call.\n */\nexport async function discoverJobs(\n  dir: string = queueConfigDefaults().jobsDir,\n): Promise<Array<new () => Job>> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"queue jobs\", \"queue\");\n  const jobs = await discoverClasses(resolved, Job);\n  warnIfNameWillNotSurviveTheBuild(jobs);\n  return jobs;\n}\n\n/**\n * The `Workflow` subclasses under `dir`, defaulting to the queue slice's\n * `app/workflows`: what a `queue` slice with no `workflows` key resolves to.\n * A missing directory is no workflows, said nothing about unless the tree\n * above it is missing too.\n */\nexport async function discoverWorkflows(\n  dir: string = queueConfigDefaults().workflowsDir,\n): Promise<WorkflowClass[]> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"workflows\", \"queue\");\n  const workflows = (await discoverClasses(resolved, Workflow)) as WorkflowClass[];\n  for (const workflow of workflows) {\n    if (Object.getOwnPropertyDescriptor(workflow, \"name\")?.writable) continue;\n    console.warn(\n      `Workflow ${workflow.name} does not declare \\`static name\\`. A workflow ` +\n        `is stored under its name, and a production build renames the class. ` +\n        `Add: static name = \"${workflow.name}\";`,\n    );\n  }\n  return workflows;\n}\n\n/**\n * Says something about a discovered job that never declared `static name`.\n *\n * This is the one hazard discovery introduces rather than removes, and it is\n * production-only. `gemi build` minifies the server entry, and app code\n * reachable from it — a controller, and every job class that controller\n * imports to dispatch — is bundled and minified with it. Minification renames\n * the class binding, and a class's implicit `.name` is that binding: a\n * `TestJob` in the bundle reports `\"D\"`. Discovery, meanwhile, imports\n * `app/jobs/TestJob.ts` from source at runtime, where it is still `\"TestJob\"`.\n * The queue is keyed by that name, so the two halves stop agreeing and the\n * dispatch is dropped — in production, and only there.\n *\n * A declared `static name = \"TestJob\"` is a string literal, which survives\n * minification intact, and the two halves agree again. `docs/jobs-and-queues.md`\n * has always called it required; before discovery an app could get away without\n * it, because the explicit `jobs` array was bundled too and both sides were\n * wrong in the same way.\n *\n * The check is exact rather than a guess: a `static name = \"...\"` class field\n * defines a *writable* own property, while the implicit class name is\n * non-writable. Cron is unaffected — `CronJob.name` is an instance field\n * holding a string literal, not the class binding.\n */\nfunction warnIfNameWillNotSurviveTheBuild(jobs: Array<new () => Job>) {\n  for (const job of jobs) {\n    if (Object.getOwnPropertyDescriptor(job, \"name\")?.writable) continue;\n\n    console.warn(\n      `Queued job ${job.name} does not declare \\`static name\\`, so it is ` +\n        `registered under its class name. A production build minifies the ` +\n        `class that dispatches it and renames it, while discovery reads this ` +\n        `file from source and does not — so the dispatch would be dropped in ` +\n        `production and nowhere else. Add: static name = \"${job.name}\";`,\n    );\n  }\n}\n\n/**\n * The `CronJob` subclasses under `dir`, defaulting to the config slice's\n * `app/cron`.\n *\n * This is what a `schedule` config slice with no `jobs` key resolves to. Call it\n * directly to ask the question a test used to answer by importing the array —\n * though after boot `app(Scheduler).jobs` is the better one, because it is what\n * the scheduler actually took rather than what this would find if asked again.\n *\n * Every file underneath is imported, so calling this runs the app's cron\n * modules — the cost `discoverClasses` documents at length, paid once per call.\n */\nexport async function discoverCronJobs(\n  dir: string = scheduleConfigDefaults().jobsDir,\n): Promise<Array<new () => CronJob>> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"cron jobs\", \"schedule\");\n  return await discoverClasses(resolved, CronJob);\n}\n\n/**\n * The `Command` subclasses under `dir`, defaulting to the config slice's\n * `app/commands`.\n *\n * This is what a `commands`-less `command` slice resolves to, and what\n * `gemi run` lists. Unlike the two above it is not called during boot — a\n * command registry has one consumer, and importing every file under\n * `app/commands` into every server process would be a cost paid on every start\n * for code no request reaches.\n *\n * Every file underneath is imported, so calling this runs the app's command\n * modules — the cost `discoverClasses` documents at length, paid once per call.\n */\nexport async function discoverCommands(\n  dir: string = commandConfigDefaults().commandsDir,\n): Promise<CommandClass[]> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"commands\", \"command\");\n\n  const unfinished: string[] = [];\n\n  const commands = await discoverClasses(\n    resolved,\n    Command,\n    [],\n    (value, file) => {\n      if (isUnfinishedBuilder(value)) unfinished.push(file);\n    },\n  );\n\n  refuseUnfinishedBuilders(unfinished);\n\n  return commands as CommandClass[];\n}\n\n/**\n * Stops the walk for a builder chain that was never finished.\n *\n * This is the one silence the builder introduces, and it is the exact shape\n * #322 and #323 exist to remove. `defineCommand(...).arg(...)` without a\n * trailing `.handle(...)` is a plain object rather than a class, so\n * `discoverClasses` discards it along with every constant and helper a command\n * file happens to export — and the command disappears from `gemi run` with\n * nothing raised. The author sees a listing containing every command except the\n * one they just wrote.\n *\n * A throw rather than a warning, because there is no reading of an unfinished\n * builder under which the author meant it: the chain builds a description of a\n * command and then discards it.\n *\n * \"Unfinished\" is decided by `.handle()` clearing the brand, not by the export\n * still being a builder object. Those differ for the natural way to share\n * declarations —\n *\n *     export const base = defineCommand(\"reindex\").option(\"verbose\", …);\n *     export default base.handle(async () => {});\n *\n * — where `base` is a builder that *did* produce a command. Keying off the shape\n * alone made that file abort the whole of `gemi run`, taking every other command\n * in the project down with it, under a message that was untrue for it.\n */\nfunction refuseUnfinishedBuilders(files: string[]): void {\n  if (files.length === 0) return;\n\n  const subject =\n    files.length === 1\n      ? `${files[0]} exports a command builder that never called \\`.handle()\\``\n      : `${files.length} files export a command builder that never called ` +\n        `\\`.handle()\\`:\\n    ${files.join(\"\\n    \")}`;\n\n  throw new DiscoveryError(\n    `${subject}, so there is no command to run. \\`.handle()\\` is what turns ` +\n      `the chain into a command — finish it:\\n\\n` +\n      `    export default defineCommand(\"my-command\")\\n` +\n      `      .handle(async ({ line }) => { line(\"hello\") })`,\n  );\n}\n\n/**\n * The `Listener` subclasses under `dir`, defaulting to the config slice's\n * `app/listeners`.\n *\n * This is what an `events` config slice with no `listeners` key resolves to.\n * Call it directly to ask what an application would register: every listener,\n * in the order it would register them.\n *\n * Only listeners are walked. Event classes are never discovered — each is\n * imported by the listener that binds to it and by the code that dispatches it,\n * so there is nothing a walk over them would find that is not already in the\n * module graph.\n *\n * **Known residual, matching jobs and cron.** `discoverClasses` excludes the\n * `base` it is handed and not intermediates, so an abstract listener base\n * written in `listenersDir` and extended by its siblings is discovered and\n * registered alongside them — constructed, with its `handle` called, on every\n * dispatch of whatever event it declares. Keep shared bases outside the\n * directory.\n *\n * Every file underneath is imported, so calling this runs the app's listener\n * modules — the cost `discoverClasses` documents at length, paid once per call.\n *\n * @throws DiscoveryError if a discovered listener declares no `static event`.\n */\nexport async function discoverListeners(\n  dir: string = eventConfigDefaults().listenersDir,\n): Promise<ListenerClass[]> {\n  const resolved = resolveDir(dir);\n  warnIfSourceIsMissing(resolved, \"event listeners\", \"events\");\n\n  const listeners = (await discoverClasses(\n    resolved,\n    Listener,\n  )) as ListenerClass[];\n\n  refuseListenersWithNoEvent(listeners);\n  warnIfListenerNameWillNotSurviveTheBuild(listeners);\n  warnIfEventNameWillNotSurviveTheBuild(listeners);\n\n  return listeners;\n}\n\n/**\n * Stops the walk for a listener that binds to nothing.\n *\n * `static event` is declared as required on the base and the compiler still\n * cannot see it missing: every subclass inherits the declaration whether or not\n * it assigns to one, so `typeof SomeListener` type-checks either way. What the\n * author gets instead is a file that is imported, registered under no name, and\n * never called — the silence this whole module is arranged against.\n *\n * A throw rather than a warning, because there is no reading of a listener with\n * no event under which the author meant it. The usual cause is the residual\n * above: an abstract base sharing a gate between two listeners, sitting in\n * `listenersDir` where the walk finds it. Moving it out is the fix, and the\n * message says so — the alternative, excluding it by some guess about\n * abstractness, is how a discovery pass ends up quietly covering less than the\n * directory holds.\n */\nfunction refuseListenersWithNoEvent(listeners: ListenerClass[]): void {\n  const orphans = listeners.filter((listener) => !listener.event);\n  if (orphans.length === 0) return;\n\n  throw new DiscoveryError(\n    `${orphans\n      .map((listener) => listener.name)\n      .join(\", \")} declare no \\`static event\\`, so there is no event name to ` +\n      `register them under and their \\`handle\\` would never run. Every ` +\n      `listener binds to exactly one event:\\n\\n` +\n      `    static event = UserRegistered;\\n\\n` +\n      `If this is an abstract base its subclasses extend, move it out of the ` +\n      `listeners directory — the walk excludes gemi's \\`Listener\\` and ` +\n      `nothing else, so a base sitting beside its subclasses is registered ` +\n      `and run like one of them.`,\n  );\n}\n\n/**\n * Says something about a discovered listener that never declared `static name`.\n *\n * The hazard is `warnIfNameWillNotSurviveTheBuild`'s, one subsystem over: a\n * `static name = \"...\"` class field defines a *writable* own property while the\n * implicit class binding does not, and a minifier renames the binding while\n * leaving the string literal alone. The two spellings are indistinguishable by\n * value — both read `\"SendWelcomeEmail\"` in development — so the descriptor is\n * the only thing that tells them apart, and the difference only becomes visible\n * in a production build.\n *\n * A warning rather than a refusal, because a *sync* listener's name has no\n * second half to disagree with: every reader of it comes from this same\n * source-side walk, so a minified build and this walk cannot produce two\n * different strings for it. A **queued** listener does have one — the name is\n * the queue's key and it crosses a JSON boundary — and that case is refused\n * outright, by `jobForListener`, at the point the listener is registered with\n * the queue rather than here. This walk cannot tell the two apart without\n * constructing every listener it found; the registry constructs them anyway.\n */\nfunction warnIfListenerNameWillNotSurviveTheBuild(listeners: ListenerClass[]) {\n  for (const listener of listeners) {\n    if (Object.getOwnPropertyDescriptor(listener, \"name\")?.writable) continue;\n\n    console.warn(\n      `Event listener ${listener.name} does not declare \\`static name\\`, so ` +\n        `it is registered under its class name, which a production build ` +\n        `renames. Nothing reads that name across a build boundary while the ` +\n        `listener is sync, which is why this is a warning — but adding ` +\n        `\\`queued = true\\` to it is refused at boot for the same reason, ` +\n        `because the queue's key is that string. Add: static name = ` +\n        `\"${listener.name}\";`,\n    );\n  }\n}\n\n/**\n * Says something about the *event* a discovered listener binds to, when that\n * event's name is the implicit class binding.\n *\n * This is the check that matters from the first dispatch, and it is the reason\n * `discoverListeners` reads `static event` at all. The registry is keyed by the\n * event's name; the dispatcher supplies that name from the class it constructs.\n * A production build minifies the server entry and the app code reachable from\n * it — the controller, and the event class it imports in order to dispatch —\n * while discovery imports `app/listeners/*.ts` from source, and those files\n * import `app/events/*.ts` from source too. Two module graphs, two class\n * objects, and an implicit `.name` that reads `\"UserRegistered\"` on one side\n * and `\"D\"` on the other. The dispatch then finds no listeners, which is legal,\n * normal, and completely silent.\n *\n * A declared `static name` is a string literal, which survives minification\n * intact, and the two halves agree again.\n *\n * Checked through the descriptor rather than the string, and not by comparing\n * `event.name` to anything: in development the two spellings produce the same\n * value, so a check on the string would be a tautology that passes forever.\n */\nfunction warnIfEventNameWillNotSurviveTheBuild(listeners: ListenerClass[]) {\n  const warned = new Set<EventClass>();\n\n  for (const { event } of listeners) {\n    if (warned.has(event)) continue;\n    if (Object.getOwnPropertyDescriptor(event, \"name\")?.writable) continue;\n    warned.add(event);\n\n    console.warn(\n      `Event ${event.name} does not declare \\`static name\\`, so it is ` +\n        `dispatched under its class name. A production build minifies the ` +\n        `code that dispatches it and renames the class, while discovery reads ` +\n        `the listener's copy from source and does not — so the dispatch would ` +\n        `reach no listener in production and nowhere else. Add: ` +\n        `static name = \"${event.name}\";`,\n    );\n  }\n}\n"
   ],
   "mappings": "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",
-  "debugId": "EA66FE1C27E7B2B264756E2164756E21",
+  "debugId": "3D42FA18091A255864756E2164756E21",
   "names": []
 }

package/dist/{chunk-wa1xmvgr.js → chunk-hmn6pa78.js}

@@ -1,5 +1,5 @@
 // @bun
-import{va as B,wa as C,ya as E}from"./chunk-mvd4mc8p.js";import{Tk as x,Vk as z,Wk as A}from"./chunk-h688s2ba.js";function M(b,f={}){let j=B(b,f.sourceLocale);return G(E(b),j,(q)=>C(b,q,j))}function N(b,f){let j=Object.keys(f);return G(b,j,(q)=>{let v=f[q]??f[j[0]];if(!v)return{};return v().then((k)=>k.default)})}function G(b,f,j){let q={id:b,locales:f,load:j};x(q);let v=()=>x(q);return{id:b,locales:f,load:(k)=>{return v(),z(b,k)},loadForRender:(k)=>{return v(),A(b,k)},get:(k)=>{v();let w=z(b,k);if(w instanceof Promise){w.catch(()=>{});return}return w}}}
+import{va as B,wa as C,ya as E}from"./chunk-mvd4mc8p.js";import{Wk as x,Yk as z,Zk as A}from"./chunk-m08p5mre.js";function M(b,f={}){let j=B(b,f.sourceLocale);return G(E(b),j,(q)=>C(b,q,j))}function N(b,f){let j=Object.keys(f);return G(b,j,(q)=>{let v=f[q]??f[j[0]];if(!v)return{};return v().then((k)=>k.default)})}function G(b,f,j){let q={id:b,locales:f,load:j};x(q);let v=()=>x(q);return{id:b,locales:f,load:(k)=>{return v(),z(b,k)},loadForRender:(k)=>{return v(),A(b,k)},get:(k)=>{v();let w=z(b,k);if(w instanceof Promise){w.catch(()=>{});return}return w}}}
 export{M as da,N as ea};
 
-//# debugId=08EC7AE31A4251C164756E2164756E21
+//# debugId=F9F5774870A7711264756E2164756E21

package/dist/{chunk-wa1xmvgr.js.map → chunk-hmn6pa78.js.map}

@@ -5,6 +5,6 @@
     "import {\n  dictionaryId,\n  dictionaryLocales,\n  localeStrings,\n  type DictionaryTranslations,\n  type LocaleStrings,\n} from \"./dictionaryShape\";\nimport {\n  loadDictionary,\n  loadDictionaryForRender,\n  registerDictionary,\n  type RenderThenable,\n} from \"./dictionaryRegistry\";\n\ndeclare const brand: unique symbol;\n\nexport interface DictionaryHandle<\n  T extends DictionaryTranslations = DictionaryTranslations,\n> {\n  readonly id: string;\n  /** Locales this dictionary declares, source language first. */\n  readonly locales: readonly string[];\n  /**\n   * Strings for `locale`. Synchronous when they are already in memory —\n   * always, for an unbundled dictionary; after a preload or the SSR seed, for a\n   * bundled one.\n   */\n  load(locale: string): LocaleStrings | Promise<LocaleStrings>;\n  /**\n   * `load`, but as the exact thing React's `use()` wants: never rejecting, so\n   * a failed locale chunk degrades the component to rendering keys instead of\n   * unmounting it into an error boundary; and always a thenable, even when the\n   * strings are already in memory. The caller skips `use()` only for a\n   * thenable built from strings already in hand, which carries them as\n   * `inHand`; every thenable a render could have suspended on still goes\n   * through it. `loadDictionaryForRender` has the whole reasoning.\n   */\n  loadForRender(locale: string): RenderThenable;\n  get(locale: string): LocaleStrings | undefined;\n  /** Type-only: carries the literal's shape through to `useDictionary`. */\n  readonly [brand]?: T;\n}\n\n/**\n * Declare the strings a component needs, next to the component.\n *\n * ```ts\n * export const homeDict = defineDictionary({\n *   title: { \"en-US\": \"Welcome {{name}}\", \"tr-TR\": \"Hoş geldin {{name}}\" },\n * });\n * ```\n *\n * As written this holds every locale. Under gemi's Vite plugin the call is\n * rewritten so each locale becomes its own chunk and a page downloads only the\n * one it renders in — but the plugin is strictly an optimization, and the\n * behaviour is identical without it (in `bun test`, and in server code that\n * does not go through the bundler).\n *\n * The first locale in the literal is the source language: a key missing from\n * another locale falls back to it rather than rendering as its own key.\n */\nexport interface DefineDictionaryOptions {\n  /**\n   * The locale this dictionary is authored in. Keys missing from another locale\n   * fall back to it, and it is what renders when the app has no locale\n   * configured.\n   *\n   * Optional, but worth setting on any dictionary that is not uniformly\n   * translated: without it the source language is whichever locale appears\n   * first in the literal, so adding a key at the top can re-point every\n   * fallback in the dictionary.\n   */\n  sourceLocale?: string;\n}\n\nexport function defineDictionary<const T extends DictionaryTranslations>(\n  translations: T,\n  options: DefineDictionaryOptions = {},\n): DictionaryHandle<T> {\n  const locales = dictionaryLocales(translations, options.sourceLocale);\n  return createHandle(dictionaryId(translations), locales, (locale) =>\n    localeStrings(translations, locale, locales),\n  );\n}\n\n/**\n * The rewritten form of a `defineDictionary` call — emitted by\n * `packages/gemi/vite/dictionaryPlugin.ts`, never written by hand. `loaders`\n * holds one dynamic import per locale so the bundler emits one chunk per\n * locale and the untaken ones never reach the browser.\n */\nexport function __gemi_dict__<\n  const T extends DictionaryTranslations = DictionaryTranslations,\n>(\n  id: string,\n  loaders: Record<string, () => Promise<{ default: LocaleStrings }>>,\n): DictionaryHandle<T> {\n  const locales = Object.keys(loaders);\n  return createHandle(id, locales, (locale) => {\n    // An unknown locale falls back to the source language, matching what\n    // `localeStrings` does per key on the unbundled path.\n    const load = loaders[locale] ?? loaders[locales[0]];\n    if (!load) {\n      return {};\n    }\n    return load().then((mod) => mod.default);\n  });\n}\n\nfunction createHandle<T extends DictionaryTranslations>(\n  id: string,\n  locales: string[],\n  load: (locale: string) => LocaleStrings | Promise<LocaleStrings>,\n): DictionaryHandle<T> {\n  const entry = { id, locales, load };\n  registerDictionary(entry);\n\n  // Re-asserted on every read rather than only at construction. A handle is\n  // created once, at module scope, but the registry it delegates to can be\n  // emptied under it — a test's `afterEach` reset, an HMR boundary — and the\n  // handle would then be permanently orphaned, throwing \"Unknown dictionary\"\n  // for a dictionary the caller is holding. `registerDictionary` is a no-op\n  // when the id is already there, so this costs one Map lookup.\n  const ensure = () => registerDictionary(entry);\n\n  return {\n    id,\n    locales,\n    // Routed through the registry rather than calling `load` directly so\n    // concurrent readers share one in-flight import and results are cached.\n    load: (locale: string) => {\n      ensure();\n      return loadDictionary(id, locale);\n    },\n    loadForRender: (locale: string) => {\n      ensure();\n      return loadDictionaryForRender(id, locale);\n    },\n    get: (locale: string) => {\n      ensure();\n      const strings = loadDictionary(id, locale);\n      if (strings instanceof Promise) {\n        // Nothing downstream awaits this one — `get` is the synchronous peek,\n        // and the caller is about to discard it. An unattached rejection (a\n        // locale chunk that 404s mid-deploy) would surface as an\n        // `unhandledRejection`, which under Node's default handler takes the\n        // process down over one missing translation file. The load itself is\n        // still cached and still retried through `loadDictionary`.\n        strings.catch(() => {});\n        return undefined;\n      }\n      return strings;\n    },\n  };\n}\n\n"
   ],
   "mappings": ";wHA2EO,GAAS,CAAwD,CACtE,EACA,EAAmC,CAAC,EACf,CACrB,IAAM,EAAU,EAAkB,EAAc,EAAQ,YAAY,EACpE,OAAO,EAAa,EAAa,CAAY,EAAG,EAAS,CAAC,IACxD,EAAc,EAAc,EAAQ,CAAO,CAC7C,EASK,SAAS,CAEf,CACC,EACA,EACqB,CACrB,IAAM,EAAU,OAAO,KAAK,CAAO,EACnC,OAAO,EAAa,EAAI,EAAS,CAAC,IAAW,CAG3C,IAAM,EAAO,EAAQ,IAAW,EAAQ,EAAQ,IAChD,GAAI,CAAC,EACH,MAAO,CAAC,EAEV,OAAO,EAAK,EAAE,KAAK,CAAC,IAAQ,EAAI,OAAO,EACxC,EAGH,SAAS,CAA8C,CACrD,EACA,EACA,EACqB,CACrB,IAAM,EAAQ,CAAE,KAAI,UAAS,MAAK,EAClC,EAAmB,CAAK,EAQxB,IAAM,EAAS,IAAM,EAAmB,CAAK,EAE7C,MAAO,CACL,KACA,UAGA,KAAM,CAAC,IAAmB,CAExB,OADA,EAAO,EACA,EAAe,EAAI,CAAM,GAElC,cAAe,CAAC,IAAmB,CAEjC,OADA,EAAO,EACA,EAAwB,EAAI,CAAM,GAE3C,IAAK,CAAC,IAAmB,CACvB,EAAO,EACP,IAAM,EAAU,EAAe,EAAI,CAAM,EACzC,GAAI,aAAmB,QAAS,CAO9B,EAAQ,MAAM,IAAM,EAAE,EACtB,OAEF,OAAO,EAEX",
-  "debugId": "08EC7AE31A4251C164756E2164756E21",
+  "debugId": "F9F5774870A7711264756E2164756E21",
   "names": []
 }