@kequtech/tenon-orm 0.4.2 → 0.4.3

package/docs/human-guide.md

@@ -22,17 +22,41 @@ Supply `DATABASE_URL` through your environment setup. For a local example databa
 export DATABASE_URL=postgresql://postgres:postgres@localhost:5432/your_database
 ```
 
-Tenon does not create the database or load `.env` files. Create one shared database module:
+Tenon does not create the database or load `.env` files. Create shared configuration:
+
+```sh
+npx tenon init
+```
+
+The command writes `tenon.config.ts` without opening a database or overwriting existing config:
+
+```ts
+// tenon.config.ts
+import type { TenonConfig } from '@kequtech/tenon-orm';
+
+const connectionString = process.env.DATABASE_URL;
+if (!connectionString) throw new Error('DATABASE_URL is required');
+export default {
+  connection: { connectionString },
+  migrations: { directory: 'migrations', namespace: 'public' },
+  generate: { out: 'src/generated-schema.d.ts' },
+  check: { project: 'tsconfig.json' },
+} satisfies TenonConfig;
+```
+
+Use it in the application too:
 
 ```ts
 // src/db.ts
 import { createTenon } from '@kequtech/tenon-orm';
+import config from '../tenon.config.ts';
 
-const connection = process.env.DATABASE_URL;
-if (!connection) throw new Error('DATABASE_URL is required');
-export const db = createTenon({ connection });
+export const db = createTenon({ connection: config.connection });
 ```
 
+These `.ts` imports use Node.js 24+ TypeScript support. See
+[shared configuration](configuration.md) for import conventions, custom codecs, discovery, and overrides.
+
 Reuse `db` across requests. Call `await db.close()` when a standalone script finishes or a server
 shuts down. See [connections](connections.md) for pool options and application-owned pools.
 
@@ -166,35 +190,26 @@ savepoints, and retry limits. For object-based inserts and patches, see [writing
 ## Generate types
 
 Generation is optional. It reads the migrated database and writes table read/insert/update types.
-Run it through the configured instance so the types use the same value conversions as your queries:
-
-```ts
-// scripts/generate-types.ts
-import { parseArgs } from 'node:util';
-import { db } from '../src/db.ts';
+The CLI uses the shared connection and codecs from `tenon.config.ts`:
 
-const { values } = parseArgs({ options: { check: { type: 'boolean', default: false } } });
-try {
-  await db.generateTypes({ out: 'src/generated-schema.d.ts', check: values.check });
-} finally {
-  await db.close();
-}
+```sh
+npx tenon generate
+npx tenon generate --check
 ```
 
-This script runs directly on Node.js 24+ using its TypeScript support. For this execution path,
-`src/db.ts` must be runnable without build-time transformations or extension rewriting. If your
-project compiles scripts, use its normal runner and import conventions instead. To typecheck `.ts`
-imports with `noEmit`, enable `allowImportingTsExtensions`; emitting projects can use
-`rewriteRelativeImportExtensions`.
+The second command checks committed output without rewriting it. The namespace comes from
+`generate.namespace`, then `migrations.namespace`, then `public`, independently of runtime
+`search_path`. Generate after migrations have committed.
 
-Add these scripts to your existing `package.json`:
+Add these commands to your existing `package.json`:
 
 ```json
 {
   "scripts": {
-    "db:generate": "node scripts/generate-types.ts",
-    "db:check-types": "npm run db:generate -- --check",
-    "db:migrate": "tenon migrate && npm run db:generate"
+    "db:generate": "tenon generate",
+    "db:check-types": "tenon generate --check",
+    "db:check": "tenon check",
+    "db:migrate": "tenon migrate && tenon generate"
   }
 }
 ```

package/docs/migrations.md

@@ -10,8 +10,10 @@ you intend to [transfer migration ownership](adoption-guide.md#transfer-migratio
 npx tenon new add_user_display_name
 ```
 
-`new` works offline. It creates the next numeric pair in `migrations/`, starting at `0001` in an empty
-directory. For a directory whose latest migration is `0001`:
+`new` opens no database connection. It creates the next numeric pair in the configured migration
+directory, defaulting to `migrations/`, and starts at `0001` in an empty directory. As with other
+commands, importing your config may require its environment values. For a directory whose latest
+migration is `0001`:
 
 ```sql
 -- migrations/0002_add_user_display_name.up.sql
@@ -23,7 +25,8 @@ ALTER TABLE public.users ADD COLUMN display_name text;
 ALTER TABLE public.users DROP COLUMN display_name;
 ```
 
-Set `DATABASE_URL` through your environment, then run:
+Configure `connection` and migration directory/namespace in [shared configuration](configuration.md).
+Without config, migration commands retain the `DATABASE_URL` workflow. Then run:
 
 ```sh
 npx tenon status
@@ -82,8 +85,12 @@ may not be recoverable. Use the application's backup and recovery procedure when
 
 ## Directory, schema, and locking
 
-Defaults are `--directory migrations` and `--namespace public`. For a custom schema, use the same
-options consistently:
+Set `migrations: { directory: 'db/migrations', namespace: 'app' }` in shared configuration to use
+the same defaults for creation, status, migration, and rollback. Generation inherits that namespace
+unless `generate.namespace` is set. Without configured values, defaults are directory `migrations`
+and namespace `public`.
+
+CLI flags override the config for an individual command:
 
 ```sh
 npx tenon new add_setting --directory db/migrations
@@ -95,7 +102,7 @@ npx tenon rollback --directory db/migrations --namespace app --steps 1
 The namespace selects history location, migration search path, and lock scope. During a file,
 `search_path` is `<namespace>, pg_catalog`; qualify cross-schema names explicitly. The runner creates
 the namespace when applying pending migrations. It does not configure runtime application queries.
-Pass the matching namespace to type generation when generating that schema.
+Keep generation on the same namespace, through the shared default or an explicit override.
 
 Migration and adoption operations use an exclusive session advisory lock for this database and
 namespace. Status and generation use a shared lock. Different namespaces have independent lock

package/docs/query-checking.md

@@ -4,13 +4,13 @@
 metadata. It can catch a missing result property, an int8 result declared as number, or an unsupported
 bound input. It is optional; normal execution still trusts `sql<Row>` annotations.
 
-The checker reads source without importing the application, evaluating input expressions, binding
-values, or executing application SQL. PostgreSQL still parses/analyzes each recovered statement,
+The CLI imports the selected configuration module; the checker then reads query source without
+importing those modules, evaluating input expressions, binding values, or executing application SQL. PostgreSQL still parses/analyzes each recovered statement,
 which can take locks. Use a representative migrated development/test database.
 
 ## Run a check
 
-Set `DATABASE_URL`, then select a project, file, or one query:
+Create [shared configuration](configuration.md), then select a project, file, or one query:
 
 ```sh
 npx tenon check
@@ -23,15 +23,16 @@ A one-based line selects the complete query containing it, including multiline t
 variable declaration line. A line with no query or multiple queries fails. A fragment alone is not
 a complete query target.
 
-The checker discovers `tsconfig.json` from the target's directory or current working directory.
-Use `--project` for another config or project directory; targets must belong to that project.
+The CLI uses `check.project`, defaulting to `tsconfig.json` beside the shared config. Use `--project`
+for another TypeScript config or project directory; targets must belong to that project. Configured
+paths resolve from the shared config; CLI targets and path flags resolve from the working directory.
 It uses the bundled TypeScript 6 compiler and the project's imports, aliases, indexed access,
 `Pick`, unions, and path mappings. `strictNullChecks` is required. Invalid configuration and compiler
 errors in selected files fail the report.
 
 Match runtime role, search path, timezone, and codecs. Session/timeout flags are the same as
-[Describe](query-inspection.md#cli). CLI checks use default codecs; use the programmatic API for
-a custom registry.
+[Describe](query-inspection.md#cli). CLI checks inherit the shared connection
+and codec registry. Inspection-only session settings and flags override runtime startup settings.
 
 ## What gets checked
 
@@ -166,7 +167,9 @@ if (!report.ok) process.exitCode = 1;
 ```
 
 The report has `ok`, `project`, `queries`, `diagnostics`, and available inspection `context`. Options
-also accept `session`, `timeouts`, `codecs`, and `readTypes`. `connection` is a URI.
+also accept `session`, `timeouts`, `codecs`, and `readTypes`. `connection` is a URI or pool-option
+values; its `codecs` are inherited unless the explicit inspection `codecs` argument is supplied.
+The programmatic API does not discover shared configuration.
 
 For a custom codec, pass the same registry as runtime queries. A text codec may declare its output:
 
@@ -193,7 +196,7 @@ registry representation. It cannot replace known metadata or claim JSON members
 decoding. Expressions resolve from the tsconfig directory. A codec declaration is trusted output
 metadata, not data validation.
 
-Custom configuration belongs in an application-owned checking script; the checker does not load
-application configuration automatically. Generated-file freshness remains a separate
-`db.generateTypes({ out, check: true })` operation. For behavior tests, see
+The CLI loads the shared configuration for custom codecs; no checking script is required. An
+application-owned script may still call the programmatic API with explicit options. Generated-file
+freshness remains a separate `tenon generate --check` operation. For behavior tests, see
 [query inspection and testing](query-inspection.md).

package/docs/query-inspection.md

@@ -7,10 +7,11 @@ compare TypeScript source annotations instead, use [query checking](query-checki
 ## Inspect completed SQL
 
 ```ts
+// scripts/inspect-query.ts
 import { describeQuery, sql } from '@kequtech/tenon-orm';
+import config from '../tenon.config.ts';
 
-const connection = process.env.DATABASE_URL;
-if (!connection) throw new Error('DATABASE_URL is required');
+const connection = config.connection;
 
 const query = sql<{ id: number; total: string }>`
   SELECT ${42}::integer AS id, count(*) AS total FROM pg_catalog.pg_class
@@ -28,8 +29,8 @@ and analyzes the statement, which can take locks.
 
 ## Session and timeouts
 
-Inspection opens and closes its own short-lived session. `connection` must be a PostgreSQL URI;
-it does not inherit a runtime pool or transaction:
+Inspection opens and closes its own short-lived session. `connection` accepts a PostgreSQL URI or pgclear pool-option values;
+it does not reuse a runtime pool or transaction:
 
 ```ts
 const description = await describeQuery({
@@ -83,7 +84,8 @@ members remain unknown.
 
 ## Custom codecs
 
-Pass the runtime registry as `codecs` to report its read representations; omission uses defaults:
+Programmatic inspection inherits `connection.codecs` when connection-option values are supplied.
+With a URI, pass the runtime registry as `codecs`; omission uses defaults:
 
 ```ts
 import { builtin, defaultCodecs } from '@kequtech/tenon-orm';
@@ -157,11 +159,12 @@ npx tenon describe query.sql
 npx tenon describe query.sql --search-path app,public --time-zone UTC
 ```
 
-The CLI reads `DATABASE_URL` and prints JSON using default codecs. Session flags are `--role`,
+The CLI requires [shared configuration](configuration.md) and prints JSON using its connection
+and codec registry. Pass `--config path` to select a specific module. Session flags are `--role`,
 `--search-path`, and `--time-zone`; timeout flags are `--connect-timeout-ms`,
 `--statement-timeout-ms`, and `--lock-timeout-ms`. Unsupported flags, including `--namespace` and
 `--check`, reject.
 
 Exit 0 means inspection succeeded, even with unresolved findings. Input, connection, timeout, or
 PostgreSQL analysis failures exit 1. The inspected statement is never executed. Generated-file
-freshness uses `db.generateTypes({ out, check: true })`, a separate operation.
+freshness uses `tenon generate --check`, a separate operation.

package/docs/reference.md

@@ -23,7 +23,6 @@ The returned `Database` provides:
 | ------------------------ | ---------------------------------------------------------------------------------------- |
 | `query(query, options?)` | Execute a Tenon `SqlQuery` and apply result/count options                                |
 | `transaction(callback)`  | Commit on callback success, roll back on an escaping error; return the callback's result |
-| `generateTypes(options)` | Write or check schema declarations using this instance's pool/codecs                     |
 | `native`                 | The underlying pgclear pool                                                              |
 | `close({ timeoutMs? }?)` | Disable the wrapper and close an owned pool; default grace 5,000 ms                      |
 
@@ -206,16 +205,17 @@ Use codes and structured fields rather than matching message text. Retain unexpe
 
 ## Generated types and checking
 
-```text
-db.generateTypes({ out, namespace?, check?, onWarning? }): Promise<void>
-generateDefinitions({ connection, namespace?, onWarning? }): Promise<string>
+```sh
+tenon generate
+tenon generate --check
 ```
 
-`out` is required for file generation. Namespace defaults to `public`; `check` defaults to false.
-Generation inherits the database registry. Missing/stale output rejects under `check: true` without
-writing. See [schema types and values](schema-types.md) for file guarantees, generated shapes,
-value mappings, codecs, and domain validation. The standalone `tenon generate` command was removed;
-use an application script.
+Generation uses [shared configuration](configuration.md) for its connection/codecs, output path,
+and namespace. Missing/stale output rejects under `--check` without writing. See
+[schema types and values](schema-types.md) for file guarantees, generated shapes, and value mappings.
+`generateDefinitions({ connection, namespace?, onWarning? }): Promise<string>` returns source text
+without file handling for custom tooling. Database instances expose query execution and lifecycle
+methods; generation is a CLI tool.
 
 ### Application aliases
 
@@ -234,15 +234,16 @@ Generated types account for defaults, identity/computed columns, domains, and nu
 
 ## Choosing a validation tool
 
-Use the intended development/test schema and role. TypeScript itself needs no connection.
+Use the intended development/test schema and role through shared configuration. TypeScript itself
+needs no connection.
 
-| Tool                                     | Question answered                                                              | Main limit                                                      |
-| ---------------------------------------- | ------------------------------------------------------------------------------ | --------------------------------------------------------------- |
-| `tsc --noEmit`                           | Does application code satisfy TypeScript contracts?                            | Does not inspect SQL/schema                                     |
-| `tenon check [file.ts[:line]]`           | Does recoverable SQL contradict declared input/result types?                   | Unsupported sites fail; inconclusive properties remain unproven |
-| `tenon describe query.sql`               | What metadata does PostgreSQL report for finished SQL?                         | Does not compare annotations or bind values                     |
-| `db.generateTypes({ out, check: true })` | Does committed output match generation now?                                    | Does not check queries or replace migration status              |
-| Database tests                           | Do exercised queries produce correct rows, effects, permissions, and rollback? | Cover only tested inputs and paths                              |
+| Tool                           | Question answered                                                              | Main limit                                                      |
+| ------------------------------ | ------------------------------------------------------------------------------ | --------------------------------------------------------------- |
+| `tsc --noEmit`                 | Does application code satisfy TypeScript contracts?                            | Does not inspect SQL/schema                                     |
+| `tenon check [file.ts[:line]]` | Does recoverable SQL contradict declared input/result types?                   | Unsupported sites fail; inconclusive properties remain unproven |
+| `tenon describe query.sql`     | What metadata does PostgreSQL report for finished SQL?                         | Does not compare annotations or bind values                     |
+| `tenon generate --check`       | Does committed output match generation now?                                    | Does not check queries or replace migration status              |
+| Database tests                 | Do exercised queries produce correct rows, effects, permissions, and rollback? | Cover only tested inputs and paths                              |
 
 After schema changes, migrate the test database, regenerate/review declarations, and run typechecks,
 applicable source checks, and database tests. In CI, check generated output without replacing it.
@@ -255,7 +256,7 @@ take locks. Neither proves actual bound values or write effects.
 The bundled TypeScript compiler loads only through that path or the check command.
 
 Options are `{ connection, target?, project?, session?, timeouts?, codecs?, readTypes? }`.
-Connection is a URI. The report contains `ok`, `project`, `queries`, `diagnostics`, and available
+Connection is a URI or pool-option values; connection codecs are inherited unless `codecs` is explicit. The report contains `ok`, `project`, `queries`, `diagnostics`, and available
 inspection `context`. Mismatches, unchecked sites, and no sites fail; unproven findings alone do not.
 See [query checking](query-checking.md) for selection, supported composition, and custom decoders.
 
@@ -265,7 +266,7 @@ See [query checking](query-checking.md) for selection, supported composition, an
 describeQuery({ connection, query, session?, timeouts?, codecs? }): Promise<QueryDescription>
 ```
 
-Connection is a URI; query is finished SQL text or `{ text, parameterTypes? }`. A `SqlQuery` fits
+Connection is a URI or pool-option values; query is finished SQL text or `{ text, parameterTypes? }`. A `SqlQuery` fits
 because it has `text`; values and its row annotation are not checked. The report includes
 `parameters`, `columns`, `rowType`, `issues`, and `context`. It uses a separate session with bounded
 timeouts. See [query inspection](query-inspection.md) for fields and finding codes.
@@ -281,7 +282,8 @@ prepared statements, and dedicated notification listeners.
 
 | Symptom                                      | Response                                                                                                                                                     |
 | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `DATABASE_URL is required`                   | Supply the variable to CLI commands. No `.env` files are loaded automatically. Application configuration is explicit.                                        |
+| Missing shared configuration                 | Run `tenon init` or select an existing config with `--config`. Generation, checking, and inspection require it.                                              |
+| `DATABASE_URL is required`                   | Supply the variable for migration commands without config, or from your shared config module. No `.env` files are loaded automatically.                      |
 | `PGCLEAR_ENCODE`                             | Check inputs: objects/arrays need `json`/`param`; direct undefined, unsafe integers, nonfinite numbers, and invalid Dates reject. JSON still rejects bigint. |
 | `CardinalityError`                           | Check the expected row count and predicate. To choose one of several rows, author deterministic `ORDER BY ... LIMIT 1`.                                      |
 | `TENON_AFFECTED_ROWS_MISMATCH`               | The guarded operation rolled back. Inspect `actual` and the predicate; retain the intended bound.                                                            |
@@ -300,15 +302,23 @@ happened; review the transaction contract before adding retries.
 
 ## Command reference
 
-All database commands read `DATABASE_URL`. `new` and `--help` work offline. No environment files
-are loaded. Paths resolve from the working directory; unsupported command flags reject.
+All commands accept `--config path`. `generate`, `check`, and `describe` require
+[shared configuration](configuration.md) and use its connection/codecs. Migration and baseline
+commands use config when present and fall back to `DATABASE_URL` only when no config is found.
+`init` creates config without importing application code; `new` uses the configured migration
+directory without opening a database; `--help` loads no config.
+Config modules may read environment variables, but Tenon loads no `.env` files automatically.
+Configured paths resolve from the config file; CLI path flags resolve from the working directory.
+Unsupported command flags reject.
 
 ```text
+tenon init [--config path]
 tenon new <name> [--directory migrations]
+tenon generate [--out path] [--namespace schema] [--check]
 tenon migrate [--directory migrations] [--namespace public]
 tenon status [--directory migrations] [--namespace public]
 tenon rollback [--directory migrations] [--namespace public] [--steps 1]
-tenon baseline capture [--directory migrations] [--namespace public] [--schema name ...]
+tenon baseline capture [--directory migrations] [--namespace public] [--schema name ...] [--connection native-uri]
 tenon baseline adopt [--directory migrations] [--namespace public]
 tenon check [file.ts[:line]] [--project tsconfig.json] [--json]
   [--role name] [--search-path value] [--time-zone value]
@@ -317,15 +327,17 @@ tenon describe <query.sql> [--role name] [--search-path value] [--time-zone valu
   [--connect-timeout-ms 3000] [--statement-timeout-ms 5000] [--lock-timeout-ms 1000]
 ```
 
-| Command                | Output and behavior                                               |
-| ---------------------- | ----------------------------------------------------------------- |
-| `new`                  | Paths of the new empty up/down pair; fill before applying         |
-| `migrate` / `rollback` | Completed IDs or “nothing to do”; each file commits independently |
-| `status`               | JSON `{ applied, pending }`; validates history                    |
-| `baseline capture`     | Writes a reviewed schema-only baseline using native `pg_dump`     |
-| `baseline adopt`       | Records baseline history without executing its SQL                |
-| `check`                | Diagnostics/counts, or a structured report with `--json`          |
-| `describe`             | JSON metadata, including unresolved findings                      |
+| Command                | Output and behavior                                                                     |
+| ---------------------- | --------------------------------------------------------------------------------------- |
+| `init`                 | Creates a minimal TypeScript or JavaScript config, refusing to overwrite existing files |
+| `new`                  | Paths of the new empty up/down pair; fill before applying                               |
+| `migrate` / `rollback` | Completed IDs or “nothing to do”; each file commits independently                       |
+| `status`               | JSON `{ applied, pending }`; validates history                                          |
+| `baseline capture`     | Writes a reviewed schema-only baseline using native `pg_dump`                           |
+| `baseline adopt`       | Records baseline history without executing its SQL                                      |
+| `generate`             | Writes output atomically; `--check` rejects missing/stale output without writing        |
+| `check`                | Diagnostics/counts, or a structured report with `--json`                                |
+| `describe`             | JSON metadata, including unresolved findings                                            |
 
 Successful commands exit 0. Invalid input or a failed operation exits 1. `check` also exits 1 for
 mismatches, unchecked sites, or no sites; unproven findings alone do not fail. `describe` can exit 0

package/docs/schema-types.md

@@ -6,33 +6,35 @@ the selected columns, joins, and expressions.
 
 ## Generate and check a file
 
-Use the application's configured database instance, after migrations have committed:
+Configure `generate.out` in [shared configuration](configuration.md), then run after migrations
+have committed:
 
-```ts
-await db.generateTypes({ out: 'src/generated-schema.d.ts' });
-await db.generateTypes({ out: 'src/generated-schema.d.ts', check: true });
+```sh
+npx tenon generate
+npx tenon generate --check
 ```
 
-The first call writes declarations. The second rejects if they are missing or stale, without
-rewriting them. Use it in CI to verify committed output. The
-[getting-started script](human-guide.md#generate-types) provides a complete command-line wrapper.
+The first command writes declarations. The second rejects missing or stale output without rewriting
+it. Both use the configured connection and codecs. Relative configured paths resolve from the config
+file; `--out` paths resolve from the working directory. The generation namespace comes from
+`generate.namespace`, then `migrations.namespace`, then `public`; `--namespace` overrides it. It is
+independent of runtime `search_path`.
 
-`namespace` defaults to `public`, independently of runtime `search_path`. Pass it explicitly for a
-different schema. Paths resolve from the working directory. Keep exact output unchanged and exclude
-it from automatic formatting.
+Keep exact output unchanged and exclude it from automatic formatting. See
+[getting started](human-guide.md#generate-types) for npm commands.
 
-Generation uses the instance's pool and codecs. It is available on `db`, outside callback
-transactions. It uses a repeatable-read catalog snapshot and shares the migration advisory lock;
-use a direct or session-pooled connection. It needs no migration files or Tenon history.
+Generation runs outside callback transactions. It uses a repeatable-read catalog snapshot and
+shares the migration advisory lock; use a direct or session-pooled connection. It needs no migration
+files or Tenon history.
 
-Tenon creates parent directories and replaces the entire output file atomically. With `check: true`,
-it creates no directories, writes no files, and includes a bounded diff for stale output. An optional
-`onWarning(message)` can be synchronous or asynchronous; the default is `console.warn`. Warning
-handler failures reject generation before output changes. Other filesystem errors propagate.
+Tenon creates parent directories and replaces the entire output file atomically. With `--check`,
+it creates no directories, writes no files, and includes a bounded diff for stale output. The CLI
+prints warnings to stderr. Generation failures preserve the existing file; filesystem errors propagate.
 
 For source text without file handling, use
 `generateDefinitions({ connection, namespace?, onWarning? }): Promise<string>`. Pass the configured
-pool or connection options to retain runtime read mappings.
+pool or connection options to retain runtime read mappings. Its optional `onWarning` callback may
+be synchronous or asynchronous and defaults to `console.warn`; callback failures reject generation.
 
 ## Read the generated types
 
@@ -196,10 +198,11 @@ checking consume the registry's metadata. An unidentified decoder warns and beco
 a declared representation is trusted, not runtime validation. Under a custom registry, enum output
 may remain string because a decoder can transform labels; enum write inputs retain catalog choices.
 
-Use the same registry for execution, generation, inspection, and source checking. Relative type-import
+Place the registry in shared `connection.codecs` so runtime, CLI generation, inspection, and source
+checking use it consistently. Programmatic inspection/checking inherit `connection.codecs` too. Relative type-import
 expressions resolve from the generated file for saved declarations and from the tsconfig directory
-for checking. Prefer a package or configured alias that resolves in both places. Tenon does not
-execute referenced modules. See [custom-codec checking](query-checking.md#programmatic-use-and-custom-codecs).
+for checking. Prefer a package or configured alias that resolves in both places. Resolving these
+type expressions does not execute their referenced modules. See [custom-codec checking](query-checking.md#programmatic-use-and-custom-codecs).
 
 Catalog queries use default result decoding on the same borrowed session, so application codecs do
 not alter Tenon's metadata inputs. Output codec choices do not select input encoders.
@@ -256,7 +259,7 @@ application's authentication and authorization checks.
 
 ## What freshness checks establish
 
-`check: true` compares the exact generated file with output from this database and codec registry.
+`tenon generate --check` compares the exact generated file with output from this database and codec registry.
 It does not check query annotations, pending migrations, functions, privileges, or every database
 object. A driver or generator update can change output without schema drift. Review generated diffs
 after upgrades. Generated text and schema-summary formatting are not version-stable schema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kequtech/tenon-orm",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "license": "ISC",
   "type": "module",
   "description": "A PostgreSQL ORM designed for coding agents, with explicit SQL, typed queries, and migrations",