@bakery-framework/orm 2.0.0-alpha.9 → 2.0.0-rc.1

package/src/schema-util.ts

@@ -24,12 +24,12 @@ export type DataTypes = keyof TypeMap
  * Three parameters, where there were five (`type, default, nullable,
  * autoIncrement, primary`). The two that went were positional booleans nothing
  * outside `Field.Primary()` ever set, and `default` was carried only so
- * nullability and optionality could be *derived* from it — which is why
+ * nullability and optionality could be *derived* from it, which is why
  * "defaulted but not nullable" and "nullable" were indistinguishable to
  * anything downstream.
  *
  * **`T` is the row type, not a dialect name.** `number`, `string | null`, or an
- * enum's own union — so `ExtractTableTypes` is a lookup rather than a mapping
+ * enum's own union, so `ExtractTableTypes` is a lookup rather than a mapping
  * through `TypeMap`, and a type `TypeMap` cannot express (an enum, a branded
  * id) needs no special case.
  *
@@ -61,9 +61,8 @@ export const dateNow = '%dateNow%'
  * The row type of a column descriptor.
  *
  * Two forms reach here. A `Field.*` builder returns `TableDef<T, …>`, whose
- * `type` **is** the row type, so this is a lookup. A hand-written literal —
- * `{ type: 'integer', default: 0, nullable: true }`, the one shape `Field`
- * does not spell — carries a dialect name there instead, which still goes
+ * `type` **is** the row type, so this is a lookup. A hand-written literal ( * `{ type: 'integer', default: 0, nullable: true }`, the one shape `Field`
+ * does not spell) carries a dialect name there instead, which still goes
  * through `TypeMap`.
  *
  * Distinguished by whether `type` is one of `TypeMap`'s keys. That is
@@ -85,12 +84,12 @@ export type ExtractTableTypes<C, K extends keyof C> = {
  * Which columns may be omitted from an `INSERT`.
  *
  * `optional: true` when a `Field.*` builder said so, which is the whole check
- * for anything `Field` produces — it states optionality rather than leaving it
+ * for anything `Field` produces, it states optionality rather than leaving it
  * to be reconstructed. The three derived conditions below it are the fallback
  * for a hand-written literal, which has no `optional` key.
  *
  * Stating it also makes a shape expressible that derivation could not:
- * **optional but neither nullable nor defaulted** — a column the database fills
+ * **optional but neither nullable nor defaulted**: a column the database fills
  * in, such as a generated key.
  */
 export type ExtractOptionals<C, T extends keyof C> = {
@@ -149,7 +148,7 @@ export const SQL_FUNCTIONS = new Set([
  * `ROW_NUMBER()` outside an `OVER` clause is a syntax error on all three
  * dialects, so putting it in the general list would let the builder emit SQL
  * that cannot run. The aggregates in `SQL_FUNCTIONS` work in *both* positions
- * and stay where they are — `evalOperands` accepts either list inside a window.
+ * and stay where they are: `evalOperands` accepts either list inside a window.
  *
  * Verified present on all three servers: SQLite has had window functions since
  * 3.25, MySQL since 8.0, Postgres throughout.
@@ -171,15 +170,15 @@ export const WINDOW_FUNCTIONS = new Set([
 /**
  * A function call with an `OVER (…)` clause.
  *
- * `spec` is the inside of the parentheses — `PARTITION BY "a" ORDER BY "b" ASC`
- * — and arrives **already validated and quoted**, exactly like `_joins[].on`.
+ * `spec` is the inside of the parentheses (`PARTITION BY "a" ORDER BY "b" ASC`
+ *), and arrives **already validated and quoted**, exactly like `_joins[].on`.
  * That is deliberate: `safeColumn` lives in the query builder, and duplicating
  * the identifier rules here would make two writers of the same SQL, which is
  * the thing convention 8 exists to prevent. This class stores; the builder
  * validates.
  *
  * No frame clause (`ROWS BETWEEN …`). It is legal everywhere and would fit, but
- * it has its own grammar and nobody has asked — an empty frame is the SQL
+ * it has its own grammar and nobody has asked: an empty frame is the SQL
  * default and is what every call here gets.
  */
 export class WindowRef {
@@ -205,13 +204,13 @@ function activeQuoteChar(): string {
 
 /**
  * Memo for `Case.snake`, which is the single most expensive step in quoting an
- * identifier — measurably more than the quoting itself — and is re-run for the
+ * identifier (measurably more than the quoting itself), and is re-run for the
  * same handful of table and column names on every clause of every query.
  *
  * A capped `Map` rather than `LRUCache`: an LRU `get` deletes and re-inserts on
  * every hit to maintain recency, which measured ~38x slower than `Map.get` and
  * would cost more than the `Case.snake` call it is meant to replace. Convention
- * 6 asks for bounded, and this is bounded by construction — identifiers are
+ * 6 asks for bounded, and this is bounded by construction: identifiers are
  * schema-derived in practice, but `DB.col()` takes a caller-supplied string, so
  * the bound cannot rest on that. Dropping the whole map on overflow is correct
  * because every entry is recomputable: it is a memo, not state.
@@ -281,7 +280,7 @@ export class OperatorRef<R = any> {
 
 // Convention 8 makes this the single writer of SQL identifiers, so the arms
 // belong together: splitting by operand kind spreads that responsibility.
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: recursive operand evaluator — one arm per operand shape
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: recursive operand evaluator, one arm per operand shape
 export function evalOperands(
   where: unknown,
   params: unknown[],
@@ -324,7 +323,7 @@ export function evalOperands(
   if (typeof where === 'object' && where !== null) {
     if (where instanceof WindowRef) {
       // The function half only. `spec` was built by the query builder out of
-      // `safeColumn` output and is inserted as-is — see the class comment.
+      // `safeColumn` output and is inserted as-is. See the class comment.
       let call: string
       if (where.fn instanceof SQLFunctionRef) {
         call = evalOperands(where.fn, params, true)
@@ -348,7 +347,7 @@ export function evalOperands(
       const colArg = where.col
       const extraArgs = where.extraArgs || []
 
-      // fnName is interpolated, not bound — only known functions may pass.
+      // fnName is interpolated, not bound. Only known functions may pass.
       if (!SQL_FUNCTIONS.has(fnName)) {
         throws(`Unsupported SQL function: ${where.fnName}`)
       }
@@ -436,7 +435,7 @@ export function old<TSchema extends SyncTypes.DBConstraints>(
  * position, so it is where the two vocabularies meet: `ColumnConstraint.type`
  * is the dialect name the sync engine reads, while a `Field.*` builder declares
  * `type` as the **row type**. Requiring the sync-side shape here rejected every
- * `Field` value — `old('title', Field.Varchar(255))` stopped compiling.
+ * `Field` value: `old('title', Field.Varchar(255))` stopped compiling.
  *
  * `old()` only copies the object and adds two keys, so it needs no more than
  * "something with a `type`", and returning `T` unchanged means the row type and
@@ -465,3 +464,35 @@ export function old(
     _transform: transform,
   })
 }
+
+/**
+ * The SQL spelling of a comparison against an explicit `null`, or `null` when
+ * the comparison is an ordinary one.
+ *
+ * A bound NULL can never satisfy `=` or `<>`: three-valued logic makes both
+ * UNKNOWN for every row, so `where(col, null)` matched nothing while reporting
+ * success. On a `SELECT` that is an empty result; on a `DELETE` or an
+ * `UPDATE` it is a write that silently does nothing and answers zero changes,
+ * which a caller cannot tell from a genuine conflict.
+ *
+ * **This lives here, not in a `WHERE` builder, because there are three of
+ * them.** `formatClause` in `orm/query.ts` and the two `evalWhere` copies in
+ * `orm/mutation.ts` each compile a clause, and the copies have now diverged
+ * twice: once over the one-argument `where(DB.raw\`…\`)` form, which the
+ * comment in `DeleteExecutable.evalWhere` records, and once over this rule,
+ * which reached the builder and neither mutation path. Both were silent. One
+ * function three callers share cannot drift a third time.
+ *
+ * A column reference on the right is a different comparison and is left alone.
+ */
+export function nullComparison(
+  operator: string,
+  right: unknown,
+  isRightColumn?: boolean,
+): string | null {
+  if (right !== null || isRightColumn) return null
+  const op = operator.toUpperCase()
+  if (op === '=') return 'IS NULL'
+  if (op === '!=' || op === '<>') return 'IS NOT NULL'
+  return null
+}

package/src/sync/builder.ts

@@ -9,8 +9,8 @@ import { formatViewBody } from './view-sql'
 /**
  * Names that cannot bind a `const` in a module (modules are always strict), so
  * they cannot be used as the export name for a generated `table()`. The export
- * name is cosmetic — `InferConstraints` and `collectConstraints` both key off
- * the string passed to `table()`, not the binding — so renaming one is safe.
+ * name is cosmetic (`InferConstraints` and `collectConstraints` both key off
+ * the string passed to `table()`, not the binding), so renaming one is safe.
  */
 const RESERVED_WORDS = new Set([
   'await',
@@ -84,7 +84,7 @@ export class SchemaBuilder {
         // Fall back to what introspection reported, not to `false`.
         //
         // The old `: false` flattened every view column to NOT NULL whenever
-        // there was no previous schema to copy from — which is exactly the
+        // there was no previous schema to copy from, which is exactly the
         // seeding path, the one a project with an existing database takes. On
         // a real view that made `category` and `images` non-nullable in the
         // generated interface while the database reports both nullable, so the
@@ -120,7 +120,7 @@ export class SchemaBuilder {
 
     // **A null default is only spellable on a nullable column**, and conflating
     // the two turned every NOT NULL column without a default into a nullable
-    // one. `Field`'s convention — stated in `asFieldCall` below — is that a null
+    // one. `Field`'s convention (stated in `asFieldCall` below) is that a null
     // default *means* nullable, so `Field.Int(null)` does not describe
     // `author_id integer NOT NULL`; it redefines it.
     //
@@ -158,7 +158,7 @@ export class SchemaBuilder {
     const named = SchemaBuilder.asFieldCall(cons, d, n)
     if (named) return `${indent}${colName}: ${named},\n`
 
-    // Nothing in the `Field` vocabulary spells this column — nullable *and*
+    // Nothing in the `Field` vocabulary spells this column, nullable *and*
     // defaulted to something other than null, or an explicit `primary` that is
     // not auto-increment.
     //
@@ -168,7 +168,7 @@ export class SchemaBuilder {
     // column, rather than dropping one it cannot spell.
     const parts = [`type: '${cons.type}'`]
     if (typeof cons.length === 'number') parts.push(`length: ${cons.length}`)
-    // `d` is already source text from `getDefaultValue` — a quoted literal, a
+    // `d` is already source text from `getDefaultValue`, a quoted literal, a
     // bare number, `null`, or the identifier `dateNow`. The marker is spelled
     // out here instead so the emitted file needs no import for it.
     if (d !== undefined) {
@@ -187,10 +187,10 @@ export class SchemaBuilder {
     // `as const`, and without it the folder layout loses these columns' types.
     //
     // `table()` takes `C extends ColumnMap`, which is `Record<string, unknown>`
-    // — a constraint that does not preserve literals, so `{ type: 'integer' }`
+    //: a constraint that does not preserve literals, so `{ type: 'integer' }`
     // widens to `{ type: string }` and `InferSchema` has no `'integer'` left to
-    // match. Every column the `Field` vocabulary cannot name — which since
-    // foreign keys round-trip includes *every referencing column* — then infers
+    // match. Every column the `Field` vocabulary cannot name (which since
+    // foreign keys round-trip includes *every referencing column*), then infers
     // as a string.
     //
     // Invisible in the single-file layout, where `DBInfo.constraints` is already
@@ -204,14 +204,14 @@ export class SchemaBuilder {
    * Copy introspected foreign keys onto the columns that carry them.
    *
    * `getConstraints()` describes columns and `getForeignKeys()` describes
-   * references, and the generator only ever read the first — so a database whose
+   * references, and the generator only ever read the first, so a database whose
    * `posts.author_id` references `users.id ON DELETE CASCADE` regenerated as a
    * plain integer. The constraint stayed in the database, the schema stopped
    * mentioning it, and the next sync therefore planned to rebuild the table to
    * *remove* a key nobody asked to remove.
    *
    * Single-column keys only. A composite key cannot be a property of one column
-   * — it is declared with `foreign()` alongside the indexes — and inventing a
+   * (it is declared with `foreign()` alongside the indexes), and inventing a
    * per-column half of one would be worse than omitting it, so it is counted and
    * reported rather than silently dropped.
    */
@@ -265,7 +265,7 @@ export class SchemaBuilder {
    * anything else falls through to `value()` above rather than being
    * approximated into a column that means something slightly different.
    *
-   * `_enum` is deliberately absent — the members are not part of the column diff
+   * `_enum` is deliberately absent: the members are not part of the column diff
    * and are not introspected, so the database cannot tell us an enum from a
    * `VARCHAR`, and guessing would silently invent a constraint.
    */
@@ -277,7 +277,7 @@ export class SchemaBuilder {
   ): string | null {
     if (cons.primary || cons.autoIncrement) return null
     // A referencing column has no `Field.*` spelling that also carries the
-    // reference — `Field.Foreign` needs the parent table's column *value* in
+    // reference, `Field.Foreign` needs the parent table's column *value* in
     // scope, which the generated file cannot guarantee (introspection order is
     // not declaration order, and the single-file layout has no table values at
     // all). Fall through to the object literal, which spells `_references`
@@ -335,7 +335,7 @@ export class SchemaBuilder {
    * The TypeScript type of a column, for a generated view interface.
    *
    * A view has no column DDL, so this is the only place its columns appear.
-   * Straight through `TypeMap`'s mapping, with `| null` for a nullable column —
+   * Straight through `TypeMap`'s mapping, with `| null` for a nullable column:
    * introspection reports that faithfully for a view's projected columns.
    */
   private static tsTypeFor(cons: any): string {
@@ -365,13 +365,13 @@ export class SchemaBuilder {
    *       `SELECT ...`,
    *     )
    *
-   * The interface is what a view *is* — `CREATE VIEW` declares no column types,
+   * The interface is what a view *is*, `CREATE VIEW` declares no column types,
    * so emitting `Field.Varchar(64)` here would state a width the database
    * neither stores nor enforces. It is also the thing worth exporting: the row
    * type gets a name you can use in a signature.
    *
    * Both type arguments are written out because TypeScript stops inferring the
-   * rest once one is supplied, and the *name* has to stay a literal — it is
+   * rest once one is supplied, and the *name* has to stay a literal: it is
    * what the schema map is keyed on. Generated code, so the repetition is free.
    */
   private static buildViewModule(
@@ -406,14 +406,14 @@ export class SchemaBuilder {
  *
  * A view is a stored SELECT; it has no column DDL, so each one is described by
  * an interface rather than by column builders. Edit the SELECT here and the
- * next sync recreates the view — views hold no data, so there is nothing to
+ * next sync recreates the view: views hold no data, so there is nothing to
  * migrate.
  *
  * **This file is yours from now on. The generator writes it once and never
  * overwrites it**, because the interfaces are the part worth editing by hand:
  * introspection can only report a JSON column as \`unknown\`, and the shape it
- * actually holds — \`{ id: number; name: string }[]\` for a
- * \`json_arrayagg(json_object(...))\` — is knowledge only you have. Regenerating
+ * actually holds: \`{ id: number; name: string }[]\` for a
+ * \`json_arrayagg(json_object(...))\`. Is knowledge only you have. Regenerating
  * over that would throw away the reason for writing it down.
  *
  * A view added to the database later will not appear here on its own; add it,
@@ -472,7 +472,7 @@ ${body}`
     return `/**
  * Generated from the database by \`db:sync\`.
  *
- * Seeded once and never overwritten — unlike \`tables.ts\`. An index this file
+ * Seeded once and never overwritten, unlike \`tables.ts\`. An index this file
  * does not declare is dropped by the next TS-wins sync, so add new ones here
  * rather than only in the database.
  *
@@ -495,7 +495,7 @@ ${body}`
       // `Field.Index` / `Field.Unique`, capitalised from the stored `index` /
       // `unique` type. This emitted the bare `index(…)` / `unique(…)` names
       // until they were removed, at which point the generated file referenced
-      // two identifiers it did not import — invisible here because the *tables*
+      // two identifiers it did not import: invisible here because the *tables*
       // are what the round-trip test imports, not the index block.
       const fn = idx.type === 'unique' ? 'Field.Unique' : 'Field.Index'
       result += `    ${idxName}: ${fn}('${idx.table}', ${colsStr}),\n`
@@ -523,7 +523,7 @@ ${body}`
    *
    * A depth-first walk with a visiting set, which is also the cycle break: a
    * table already on the stack is left where it is, and the column pointing back
-   * at it falls through to the object literal — correct, just not pretty.
+   * at it falls through to the object literal, correct, just not pretty.
    * Circular references between tables are legal SQL and this must not fail on
    * them or, worse, emit a forward reference that is `undefined` at module
    * evaluation.
@@ -561,7 +561,7 @@ ${body}`
   /**
    * `Field.Foreign(parent.column, …)` when the parent is already in scope.
    *
-   * Returns null when it is not — the cycle case above — so the caller falls
+   * Returns null when it is not (the cycle case above), so the caller falls
    * back to the literal rather than emitting a reference to a `const` declared
    * further down the file, which is a TDZ error at import time.
    */
@@ -630,7 +630,7 @@ ${body}`
               colName,
               cons,
               adapter,
-              // Never a view here — those were skipped above.
+              // Never a view here. Those were skipped above.
               false,
               '  ',
             )
@@ -653,7 +653,7 @@ ${body}`
  *
  * Tables only. In the orm/ folder layout \`index.ts\` owns the re-exports and
  * the schema registration, \`indexes.ts\` owns the index and unique
- * declarations, and \`views.ts\` owns the views — none of which is written here.
+ * declarations, and \`views.ts\` owns the views: none of which is written here.
  *
  * The cost of that separation, worth knowing: an index or a view the database
  * has and its file does not declare is dropped by the next TS-wins sync. It
@@ -672,7 +672,7 @@ ${body}`
    *
    * `Field` is imported from the package root and the types from
    * `schema-util`, in two statements rather than one, because `schema-util`
-   * cannot re-export `Field` without closing a cycle — `field.ts` calls
+   * cannot re-export `Field` without closing a cycle: `field.ts` calls
    * `value`/`primary`/`index`/`unique`, and this repo has already paid once for
    * a cycle that typechecked and then failed at runtime.
    */
@@ -733,7 +733,7 @@ declare module '@bakery-framework/orm/schema-registry' {
     messages.GEN_TYPES()
 
     // Stripped, or `--choose=db` writes `__bakery_schema` into the app's own
-    // schema as an ordinary table — after which sync manages the ledger, the
+    // schema as an ordinary table, after which sync manages the ledger, the
     // ledger records itself, and the shape check never matches again. The diff
     // path strips it in `resolveCurrentState`; this path reads the adapter
     // directly and was missing it.
@@ -768,7 +768,7 @@ declare module '@bakery-framework/orm/schema-registry' {
 
     await Bun.write(schemaPath, source)
 
-    // `views.ts` beside `tables.ts`, and only in the folder layout — the
+    // `views.ts` beside `tables.ts`, and only in the folder layout: the
     // single-file layout already carries views inside its `DBInfo` namespace.
     //
     // Written only when the database *has* views: creating an empty file, and
@@ -781,7 +781,7 @@ declare module '@bakery-framework/orm/schema-registry' {
       )
       if (viewsSource) {
         const viewsPath = `${schemaPath.replace(/[^/\\]+$/, '')}views.ts`
-        // Seeded once, then never overwritten — unlike `tables.ts`, which the
+        // Seeded once, then never overwritten, unlike `tables.ts`, which the
         // generator owns outright.
         //
         // The interfaces are the part worth editing by hand. Introspection can
@@ -804,7 +804,7 @@ declare module '@bakery-framework/orm/schema-registry' {
       // way the single-file layout is not: `DBInfo` carries an `indexes` block,
       // so `--choose=db` there round-trips them, while the folder layout left
       // every index undeclared. A TS-wins sync then drops what the schema does
-      // not mention — so regenerating a folder-layout schema from a database
+      // not mention, so regenerating a folder-layout schema from a database
       // armed the *next* sync to delete every index in it.
       const indexes = await adapter.getIndexes()
       if (Object.keys(indexes).length) {
@@ -828,13 +828,13 @@ declare module '@bakery-framework/orm/schema-registry' {
    * Copy the current schema aside before it is overwritten.
    *
    * `--choose=db` regenerates the schema wholesale, and anything hand-written
-   * in it — a comment, a `_view`, an `old()` rename wrapper — is gone. The
+   * in it (a comment, a `_view`, an `old()` rename wrapper) is gone. The
    * database is backed up before a destructive sync; the schema, which is
    * source, was not. It is also gitignored, so `git checkout` cannot recover
    * it either: this is the one file with no other safety net.
    *
    * Stored under `bakery/backups` (`Bakery.dataDir`) rather than the cache,
-   * because a cache is defined as safe to delete and this is not — the
+   * because a cache is defined as safe to delete and this is not: the
    * framework itself deletes the cache directory on every version bump.
    */
   private static async preserveExisting(

package/src/sync/diff.ts

@@ -34,7 +34,7 @@ function diffColumnMismatch(
   // TEXT trap that made this dangerous to add blind.
   //
   // Driven by the *schema* side only. When the schema declares a width, any
-  // other answer from the database differs — including no width at all, which
+  // other answer from the database differs, including no width at all, which
   // is a real `TEXT` column that should become `VARCHAR(n)`. Requiring both
   // sides to be sized meant sizing an existing TEXT column silently did
   // nothing, and `db:sync` then reported a perfectly synced database whose
@@ -44,16 +44,16 @@ function diffColumnMismatch(
   // (measured, see `SQLAdapter.sizedTextLength`): after one rebuild the two
   // agree. A column that reports *no* width really is unsized.
   //
-  // When the schema declares no width, nothing differs — `Field.Text()` against
+  // When the schema declares no width, nothing differs: `Field.Text()` against
   // an existing `VARCHAR` is not a request to shrink it.
   const lengthDiffers =
     typeof tsCol.length === 'number' && tsCol.length !== dbCol.length
 
   // Enum members join the diff, so changing them migrates instead of silently
-  // doing nothing — but **only when the current state came from the ledger**.
+  // doing nothing, but **only when the current state came from the ledger**.
   //
   // `_enum` is emitted as an inline `CHECK (col IN (...))` by all three
-  // dialects, and all three *will* report that constraint back — in three
+  // dialects, and all three *will* report that constraint back: in three
   // incompatible shapes. Measured:
   //
   //   sqlite  CHECK (status IN ('draft','live'))            in the table DDL
@@ -61,14 +61,14 @@ function diffColumnMismatch(
   //   pgsql   CHECK (((status)::text = ANY ((ARRAY[...])))    re-rendered
   //
   // Postgres does not store the text it was given, it re-renders a parsed
-  // expression — the same trap that turned `EXTRACT` into `date_part` and
+  // expression: the same trap that turned `EXTRACT` into `date_part` and
   // rebuilt a table on every sync forever. Three parsers, each an opportunity
   // for that bug, is the wrong trade when the ledger already holds the members
   // exactly as declared.
   //
   // So under introspection this stays out of the diff. A schema-side-only
   // comparison would find `_enum` on one side and nothing on the other, differ
-  // every time, and rebuild the table on every sync — which is precisely what
+  // every time, and rebuild the table on every sync, which is precisely what
   // the `length` note above says it waited to rule out before shipping.
   const enumDiffers =
     plan.ledgerSource === 'ledger' &&
@@ -238,12 +238,12 @@ function diffViewStrings(
   constraints: any,
   database?: string,
 ): boolean {
-  // Both sides through the same canonicaliser, which is the only thing that
+  // Both sides through the same canonicalizer, which is the only thing that
   // makes a text comparison viable: you write `SELECT id FROM users` and MySQL
   // returns it fully qualified, fully quoted and aliased column by column.
   //
-  // Symmetry is the whole requirement. Normalising the *generated file* while
-  // comparing raw — or stripping the schema on one side only — recreates the
+  // Symmetry is the whole requirement. Normalizing the *generated file* while
+  // comparing raw (or stripping the schema on one side only) recreates the
   // view on every sync, which is the same churn the column diff has hit twice.
   const tsViewStr = normalizeViewBody(
     String(constraints[camelTable]._view || ''),
@@ -265,7 +265,7 @@ function diffViewStrings(
  * The view lifecycle: create, recreate, drop.
  *
  * Views were invisible to the planner. `initDbTablesMap` skips `_view` entries,
- * and every existing comparison iterates that map — so a declared view never
+ * and every existing comparison iterates that map, so a declared view never
  * reached `diffViewStrings`, and nothing about a view ever reached
  * `hasChanges`. The consequences, all three measured:
  *
@@ -279,11 +279,11 @@ function diffViewStrings(
  * reported a perfectly synced database and left the view alone.
  *
  * Bodies are compared through `normalizeViewBody` on both sides. That converges
- * on SQLite, which stores the text verbatim, and via the ledger everywhere —
+ * on SQLite, which stores the text verbatim, and via the ledger everywhere:
  * the ledger records what was *applied*, so it holds the authored SELECT.
  * Diffing against live introspection on MySQL or Postgres will still see a
  * difference, because both re-render the body (MySQL re-qualifies every column,
- * Postgres adds parentheses), and no amount of text normalisation short of a
+ * Postgres adds parentheses), and no amount of text normalization short of a
  * parser fixes that. It costs a recreate, and a view holds no data.
  */
 export function diffViews(

package/src/sync/engine.ts

@@ -17,17 +17,17 @@ import type * as SyncTypes from './types'
 export const syncMsgs = {
   GEN_TYPES: 'I Generating types...',
   // Counted rather than silently dropped: a composite key is not a property of
-  // one column, so the generator cannot spell it — but a reader who is not told
+  // one column, so the generator cannot spell it, but a reader who is not told
   // will believe the generated schema is complete.
   GEN_COMPOSITE_FK:
-    'W %y{count}%* composite foreign key(s) could not be generated as column references — declare them with %yforeign()%* beside the indexes.',
+    'W %y{count}%* composite foreign key(s) could not be generated as column references. Declare them with %yforeign()%* beside the indexes.',
   INDEXES_SEEDED: 'I Seeded %y{file}%* from the database.',
   INDEXES_KEPT:
     'I Left %y{file}%* alone: index declarations are hand-owned once seeded. Delete it and re-run to reseed.',
   MIGRATE_DONE:
     'I %gAdopted the existing database%*. No tables were changed; run %ydb:sync%* to confirm nothing is pending.',
   MIGRATE_NO_LEDGER:
-    'W Schema written, but the ledger could not be recorded — the next sync will diff against live introspection instead.',
+    'W Schema written, but the ledger could not be recorded: the next sync will diff against live introspection instead.',
   SYNC_SUCCESS: 'I %gschema.ts successfully synced%* to Database!',
   INVALID_SCHEMA: 'W %yschema.ts is invalid or corrupt. Treating as new.%*',
   NO_DBINFO: 'W %yDBInfo namespace not found in schema.ts!%*',
@@ -70,7 +70,7 @@ export const syncMsgs = {
   EXEC_ADD_INDEX: 'I Creating %y{type}%* index: %g{name}%*...',
   // Declared late. `executeSyncPlan` has always called these two, and
   // `messageLogger`'s proxy answers an undeclared key with a live emitter that
-  // prints `E Error message not found: EXEC_ADD_FK` — so every foreign key
+  // prints `E Error message not found: EXEC_ADD_FK`, so every foreign key
   // added or dropped on a dialect that can ALTER one logged an *error* where
   // its ten sibling operations logged progress. Only reachable with
   // `supportsAlterForeignKey`, which is why SQLite-only local runs never
@@ -89,11 +89,11 @@ export const syncMsgs = {
   FATAL_ERROR:
     'E %rFATAL ERROR: Sync failed! All changes have been safely rolled back. Detail: {error}%*',
   VIEWS_SEEDED:
-    'I Seeded %y{file}%* from the database. It is yours from now on — the generator will not overwrite it.',
+    'I Seeded %y{file}%* from the database. It is yours from now on: the generator will not overwrite it.',
   VIEWS_KEPT:
     'I Left %y{file}%* alone: view interfaces are hand-owned. Delete it and re-run to reseed.',
   LEDGER_DRIFT:
-    'W %yDatabase has drifted from the last schema Bakery applied%*: {reason}. Diffing against live introspection instead of the ledger. Something changed this database outside Bakery — if that was not deliberate, check it before syncing.',
+    'W %yDatabase has drifted from the last schema Bakery applied%*: {reason}. Diffing against live introspection instead of the ledger. Something changed this database outside Bakery: if that was not deliberate, check it before syncing.',
 } as const
 
 const logger = new Logger('db-sync')
@@ -102,7 +102,7 @@ export const MESSAGES = messageLogger(logger, syncMsgs)
 /**
  * Whether a destructive sync in this process needs an explicit `--force-sync`.
  *
- * **`NODE_ENV` is the only term, deliberately — do not add a `PROD` check back.**
+ * **`NODE_ENV` is the only term, deliberately. Do not add a `PROD` check back.**
  * There used to be a `process.env.PROD === 'true'` half that could never be
  * true, since `core/init.ts` installs `PROD` as a getter returning a *boolean*.
  * Repairing it rather than deleting it would have been worse: `PROD` means only
@@ -136,7 +136,7 @@ export class SyncEngine {
   /**
    * Record the adopted database as the schema Bakery last applied.
    *
-   * Without this, the first sync after an adoption falls back to introspection —
+   * Without this, the first sync after an adoption falls back to introspection:
    * safe, but it withdraws the thing the ledger is for, and enum member changes
    * only migrate when the diff runs against the ledger.
    *
@@ -201,7 +201,7 @@ export class SyncEngine {
     // Creating or recreating a view cannot lose anything: a view holds no data,
     // and `createView` drops and recreates in one step. Counting it as
     // destructive made a schema with a view demand `--force-sync` in production
-    // for no reason — and it matters more now that views are diffed at all,
+    // for no reason, and it matters more now that views are diffed at all,
     // because MySQL and Postgres re-render a stored body, so a run that falls
     // back to introspection sees one as changed every time.
     //
@@ -298,11 +298,11 @@ export class SyncEngine {
     // After the transaction commits, never inside it: MySQL commits DDL
     // implicitly, so there is no unit of work these two could share anyway, and
     // writing the ledger first would claim a migration that had not happened.
-    // Best-effort by design — a sync that succeeded still succeeded, and a
+    // Best-effort by design: a sync that succeeded still succeeded, and a
     // missing ledger only costs the next run its fast path.
     // `tsIndexes`, not `adapter.getIndexes()`: the ledger records what was
     // *applied*, and re-reading the database here would record whatever the
-    // dialect reports back — the exact normalisation problem the ledger exists
+    // dialect reports back, the exact normalization problem the ledger exists
     // to route around.
     await writeLedger(adapter, constraints, tsIndexes)
 
@@ -328,7 +328,7 @@ export class SyncEngine {
     //
     // It is not `--choose=db` with a nicer name. `--choose=db` sits *after* the
     // "no changes" early return, so on a database that already matches it does
-    // nothing — which is the common case when adopting one, since the schema
+    // nothing, which is the common case when adopting one, since the schema
     // being written is derived from that same database. And it never writes the
     // ledger, so the first real sync afterwards diffs against introspection
     // instead: the one place enum changes are invisible.
@@ -337,7 +337,7 @@ export class SyncEngine {
       //
       // Passing the loaded schema in makes `syncNullableConstraints` reconcile
       // view column nullability against it, which is right for a regeneration of
-      // a schema you are keeping and wrong for this — the point of `--migrate`
+      // a schema you are keeping and wrong for this: the point of `--migrate`
       // is that the database is the source of truth, and quietly carrying a
       // detail over from the file being replaced would make the result depend on
       // what happened to be there.
@@ -359,13 +359,13 @@ export class SyncEngine {
     // column rename existed, which dated from SQLite before 3.25 (2018) having
     // no ALTER TABLE … RENAME COLUMN. Bun ships 3.53. Measured against a real
     // database, the special case lost a rename in a non-renamed table silently
-    // — reporting a perfect sync — and threw outright in the two cases where it
+    // (reporting a perfect sync), and threw outright in the two cases where it
     // did fire. See sync/engine.test.ts, which pins all four.
     const plan = await buildSyncPlan(adapter, constraints, logger, MESSAGES)
 
     // `buildSyncPlan` has always recorded which state it diffed against and
-    // nothing ever read it. Falling back to introspection is *correct* — see
-    // sync/ledger.ts — but doing it silently means a column somebody added by
+    // nothing ever read it. Falling back to introspection is *correct*. See
+    // sync/ledger.ts, but doing it silently means a column somebody added by
     // hand in production looks exactly like an ordinary run. "No ledger yet" is
     // the normal state of a fresh database and is not drift.
     if (
@@ -394,8 +394,8 @@ export class SyncEngine {
       plan.tablesToRebuild,
       beingCreated,
     )
-    // SQLite cannot ALTER a foreign key in or out — the constraint is part of
-    // the table definition — so those become table rebuilds, which recreate the
+    // SQLite cannot ALTER a foreign key in or out (the constraint is part of
+    // the table definition), so those become table rebuilds, which recreate the
     // table with the keys inline. Decided here rather than in the adapter so
     // the printed plan states the work that will actually happen.
     if (!adapter.supportsAlterForeignKey) {
@@ -424,7 +424,7 @@ export class SyncEngine {
     logPlannedChanges(plan, indexesToDrop, indexesToAdd, isDangerous, MESSAGES)
     if (argv.includes('--dry-run')) {
       // `logger.log` takes the level as its second argument. A leading 'D ' is
-      // `messageLogger` table syntax, and this is not a table — so the letter
+      // `messageLogger` table syntax, and this is not a table, so the letter
       // was printed verbatim and the level defaulted.
       //
       // `info`, not the `debug` the stray 'D' was reaching for: this line is