okmodel 0.5.0 → 0.6.0

package/dist/tooling/migrate/apply.d.ts

@@ -49,6 +49,14 @@ export type ApplyRequest = {
      * `SET ROLE` before any statement. That statement is not a plan step.
      */
     readonly migrationRole?: string;
+    /**
+     * Application role.
+     *
+     * After the plan, this role receives `SELECT` on `okm_meta` and nothing
+     * else. `connect()` can then read the stored hash. Check scratch paths
+     * leave this unset.
+     */
+    readonly appRole?: string;
     /**
      * Schema the migration role may create in.
      *
@@ -95,6 +103,12 @@ export type ApplyReport = {
     /** Set when the runner issued `SET ROLE` at session start. */
     readonly setRole?: string;
 };
+/**
+ * Creates `okm_meta`, `okm_history`, and `okm_backfill` when they are absent.
+ *
+ * @param execute - Runs one statement on the apply or check connection
+ */
+export declare function ensureMigrationTables(execute: (sql: string) => Promise<unknown>): Promise<void>;
 /**
  * Groups pending steps into the transactions apply will run.
  *

package/dist/tooling/migrate/check.d.ts

@@ -1,10 +1,9 @@
 /**
  * `okm migrate check` proves a migration history is sound (D196).
  *
- * The command replays every file into a scratch schema through
- * {@link applyTarget}, then plans the introspected schema back to that
- * file's catalog. It also checks the previous catalog, the head, and the
- * linter. Nothing here changes apply.
+ * The command replays every file into a scratch schema inside one transaction
+ * and rolls that transaction back. It also checks the previous catalog, the
+ * head, and the linter. Nothing here changes apply.
  */
 import type { Catalog } from "../../contracts/catalog/types.js";
 import { type MigrationClass } from "./classify.js";

package/dist/tooling/migrate/classify.d.ts

@@ -76,6 +76,10 @@ export declare const STEP_CLASS: {
     readonly "rename-sequence": "contract";
     readonly "backfill-expand": "expand";
     readonly "backfill-contract": "contract";
+    readonly "enable-rls": "expand";
+    readonly "create-policy": "expand";
+    readonly "drop-policy": "contract";
+    readonly "disable-rls": "contract";
     readonly "raw-sql": "unclassified";
 };
 /** A planner operation. */

package/dist/tooling/migrate/commands.d.ts

@@ -4,7 +4,6 @@
  * The bin wrapper imports {@link run}. Importing this module does not parse
  * `process.argv`.
  */
-import { OkmError } from "../../contracts/error.js";
 /** Where a command reads the project and writes its text. */
 export type CommandIo = {
     readonly cwd?: string;
@@ -18,7 +17,7 @@ export type CommandIo = {
  * @param error - Failure from a command
  * @returns The stderr text, including the trailing newline
  */
-export declare function formatFailure(error: OkmError): string;
+export declare function formatFailure(error: unknown, verbose?: boolean): string;
 /**
  * Runs one `okm` invocation.
  *

package/dist/tooling/migrate/config.d.ts

@@ -59,10 +59,11 @@ export type MigrateConfig = {
         readonly statementTimeoutMs?: number;
     };
     /**
-     * Migration role and application role.
+     * Migration role, application role, and the optional reporting role.
      *
      * A name is external unless it is also listed in `managed`. The plan creates
-     * a managed role and never drops one.
+     * a managed role and never drops one. `reporting` receives select only.
+     * `columns` grants select or update on named columns.
      */
     readonly roles?: RolesInput;
 };

package/dist/tooling/migrate/drift.d.ts

@@ -18,7 +18,7 @@ import type { RolesInput } from "../../dialects/pg/role/index.js";
  * @param author - Schema catalog, including roles when the config names them
  * @param roles - `defineConfig({ roles })`, when set
  */
-export declare function assertAuthorDrift(url: string, author: Catalog, roles?: RolesInput): Promise<void>;
+export declare function assertAuthorDrift(url: string, author: Catalog, roles?: RolesInput, allowPooler?: boolean): Promise<void>;
 /**
  * Turns a postgres.js handle into the query shape introspection uses.
  *

package/dist/tooling/migrate/estimate.d.ts

@@ -40,7 +40,20 @@ export declare function readRowEstimates(url: string, schema: string, tables: re
  * @param estimates - `reltuples` for tables that exist on the target
  * @returns The text after `-- lock: `
  */
-export declare function annotateLock(step: PlanStep, estimates: ReadonlyMap<string, RowEstimate>): string;
+export declare function annotateLock(step: PlanStep, estimates: ReadonlyMap<string, RowEstimate>, aliases?: ReadonlyMap<string, string>): string;
+/**
+ * Maps a rename destination to the table that still has `reltuples`.
+ *
+ * The rename statement names the old table. Later steps name the new one,
+ * which is not in `pg_class` yet.
+ *
+ * @param steps - Plan steps
+ * @returns New name to old name
+ */
+export declare function renameAliases(steps: readonly {
+    readonly kind?: string;
+    readonly sql: string;
+}[]): ReadonlyMap<string, string>;
 /**
  * Compact phrase for one estimate.
  *

package/dist/tooling/migrate/files.d.ts

@@ -2,7 +2,7 @@
  * Migration files on disk: SQL from {@link formatPlan} plus the catalog hash.
  */
 import { parseCatalog } from "../../contracts/catalog/document.js";
-import { type PlanStep } from "./plan.js";
+import { type MigrationPlan, type PlanStep } from "./plan.js";
 /** One migration the applier can run and resume. */
 export type StoredMigration = {
     readonly id: string;
@@ -25,6 +25,16 @@ export type StoredMigration = {
  * @returns Migrations in apply order
  */
 export declare function loadMigrations(directory: string): readonly StoredMigration[];
+/**
+ * Reads one migration SQL file.
+ *
+ * Line endings and a UTF-8 BOM are normalized. A non-empty file with no steps
+ * and no `-- no steps` line is refused.
+ *
+ * @param path - `*.sql` path
+ * @returns The plan
+ */
+export declare function readMigrationPlan(path: string): MigrationPlan;
 /**
  * Loads the last migration's catalog, which is the head snapshot.
  *

package/dist/tooling/migrate/index.js

@@ -1,25 +1,27 @@
-import"../../shared/wqem4jed.js";
-import"../../shared/8bwbwy8h.js";
+import"../../shared/wkme6tep.js";
+import"../../shared/qq3899ht.js";
 import"../../shared/n442h54c.js";
 import {
   applyTarget2,
   backfillTiming2
-} from "../../shared/xhh1srw3.js";
+} from "../../shared/nx9hh281.js";
 import {
-  loadMigrations,
-  loadHeadSnapshot,
   readReference
-} from "../../shared/kdkxh3kb.js";
-import"../../shared/szm0cksa.js";
-import"../../shared/fancm5pt.js";
+} from "../../shared/p248q79y.js";
+import"../../shared/knmes2kh.js";
+import"../../shared/vjpnzwjz.js";
 import {
-  assertTargetPolicy,
-  selectTarget,
+  projectPath,
+  loadMigrations,
+  loadHeadSnapshot,
   loadBuiltSchema,
   loadConfig
-} from "../../shared/xdpj5kkm.js";
-import"../../shared/ayz64vzj.js";
-import"../../shared/8xsbagad.js";
+} from "../../shared/t3g0k88x.js";
+import {
+  assertTargetPolicy,
+  selectTarget
+} from "../../shared/ttmg09vd.js";
+import"../../shared/9s0ypp87.js";
 import {
   OkmError2
 } from "../../shared/52szzakm.js";
@@ -29,12 +31,11 @@ function defineConfig(config) {
   return config;
 }
 // src/tooling/migrate/provision.ts
-import { join } from "node:path";
 async function provision(target, cwd = process.cwd()) {
   const config = await loadConfig(cwd);
   const selected = selectTarget(config, target);
   assertTargetPolicy(selected, "provision");
-  const directory = join(cwd, config.migrations ?? "migrations");
+  const directory = projectPath(cwd, config.migrations ?? "migrations");
   const migrations = loadMigrations(directory);
   const head = loadHeadSnapshot(directory);
   if (head === undefined) {
@@ -57,7 +58,7 @@ async function provision(target, cwd = process.cwd()) {
       reference: readReference(built.tables, built.casing, head.catalog),
       only: true
     },
-    ...config.roles !== undefined ? { migrationRole: config.roles.migration } : {},
+    ...config.roles !== undefined ? { migrationRole: config.roles.migration, appRole: config.roles.app } : {},
     lintDirectory: directory
   });
   if (report.applied.length === 0)

package/dist/tooling/migrate/lint.d.ts

@@ -2,14 +2,14 @@
  * Runs the migration linter.
  *
  * The linter reads a plan and the two catalogs. It does not connect.
- * An override is a `-- okm-allow` line on the statement. It silences only
- * the code it names, and only with a reason.
+ * An override is a `-- okm-allow` line on the step. It silences that code
+ * on every statement of the step, and only with a reason.
  */
 import type { Catalog } from "../../contracts/catalog/types.js";
 import { OkmError } from "../../contracts/error.js";
 import { type LintSeverity } from "./lint-rules.js";
-import { type MigrationPlan } from "./plan.js";
-/** One finding. `place` is `step N` or `table.column`, optionally prefixed with the file. */
+import type { MigrationPlan } from "./plan.js";
+/** One finding. `place` is `step N`, `step N statement M`, or `table.column`. */
 export type Finding = {
     readonly severity: LintSeverity;
     readonly code: string;

package/dist/tooling/migrate/lost.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A session that dies in the middle of a command.
+ *
+ * A commit that was sent and never answered stays OKM1401. Every other
+ * dropped connection is unavailable. Cleanup that throws is ignored so the
+ * original failure is the one the command reports.
+ */
+import { OkmError } from "../../contracts/error.js";
+/**
+ * Maps a lost session to unavailable or OKM1401.
+ *
+ * An {@link OkmError} that already has one of those kinds is returned. An
+ * `invalid` error whose cause is a lost session keeps its message and takes
+ * that kind. Anything else returns `undefined`.
+ *
+ * @param error - Caught value
+ * @returns The session failure, or `undefined` when this is some other error
+ */
+export declare function sessionFailure(error: unknown): OkmError | undefined;
+/**
+ * Runs cleanup and ignores its failure.
+ *
+ * A dead session must not replace the error the command is already reporting,
+ * and it must not leave the process waiting on that session.
+ *
+ * @param run - Close, release, or unlock
+ */
+export declare function finishQuiet(run: () => Promise<unknown>): Promise<void>;

package/dist/tooling/migrate/paths.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Config paths resolved against the project directory.
+ */
+/**
+ * Resolves a config path against `cwd`.
+ *
+ * An absolute segment stays absolute. A relative segment, including `..`,
+ * is resolved from `cwd`.
+ *
+ * @param cwd - Project directory
+ * @param parts - `schema`, `tables`, `migrations`, `out`, a seed file, or a child
+ * @returns An absolute path
+ */
+export declare function projectPath(cwd: string, ...parts: readonly string[]): string;

package/dist/tooling/migrate/plan.d.ts

@@ -70,10 +70,10 @@ export type PlanStep = {
      */
     readonly behavior?: "change";
     /**
-     * `-- okm-allow` lines directly above the statement.
+     * `-- okm-allow` lines on the step.
      *
-     * A reason silences that code only. An empty reason, or a code the
-     * statement did not trigger, is OKM1510 and silences nothing.
+     * A reason silences that code on every statement of the step. An empty
+     * reason, or a code no statement triggered, is OKM1510 and silences nothing.
      */
     readonly allows?: readonly StepAllow[];
 };
@@ -128,6 +128,13 @@ export declare function formatPlan(plan: MigrationPlan, lockText?: (step: PlanSt
 /**
  * Reads a plan written by {@link formatPlan}.
  *
+ * A blank line ends a step. A blank line inside a quote, a dollar quote, a
+ * block comment, or a `BEGIN ATOMIC` routine body stays in that step, and so
+ * does a `--` line while that quote or body is still open.
+ *
+ * `\r\n` and a lone `\r` are read as `\n`. A leading UTF-8 BOM is stripped.
+ * UTF-16 is refused.
+ *
  * @param text - SQL file text
  * @returns The plan. The header class is kept when the file has no steps
  */

package/dist/tooling/migrate/policy.d.ts

@@ -56,6 +56,17 @@ export declare function assertTargetAlias(targets: readonly TargetRecord[]): voi
  * @param allowPooler - The invocation opted in
  */
 export declare function assertDirectConnection(url: string, allowPooler: boolean): void;
+/**
+ * Refuses a session whose backend pid changes between two statements.
+ *
+ * The two reads are separate round trips and are not wrapped in a
+ * transaction. A transaction-mode pooler can hand back a different backend
+ * for the second one. `--allow-pooler` skips the probe.
+ *
+ * @param readPid - Reads `pg_backend_pid()` on the session under test
+ * @param allowPooler - The invocation opted in
+ */
+export declare function assertStableBackend(readPid: () => Promise<string>, allowPooler: boolean): Promise<void>;
 /**
  * Lists configured targets.
  *

package/dist/tooling/migrate/runner.d.ts

@@ -95,7 +95,32 @@ export declare function assumeRole(connection: DriverConnection, role: string, s
  * @param schema - Schema the migration writes
  * @param role - Role that was just created
  */
+/**
+ * Grants the application role `SELECT` on `okm_meta`.
+ *
+ * No other privilege. When the session has `SET ROLE`, the grant runs as
+ * the session user and the role is restored. A second apply grants the
+ * same privilege again.
+ *
+ * @param connection - Reserved connection
+ * @param role - Application role. Omitted when the config names none
+ * @param session - Role the runner already assumed
+ */
+export declare function grantAppMeta(connection: DriverConnection, role: string | undefined, session: {
+    setRole?: string;
+}): Promise<void>;
 export declare function grantSchema(connection: DriverConnection, schema: string, role: string): Promise<void>;
+/**
+ * Fails when `GRANT USAGE ON SCHEMA` did not add the role.
+ *
+ * Postgres warns and changes nothing when the acting role does not own the
+ * schema. A later check then reports the grant forever. The migration role
+ * has to own the schema first.
+ *
+ * @param connection - Reserved connection, in the grant's transaction
+ * @param sql - The statement that just ran
+ */
+export declare function assertSchemaUsageLanded(connection: DriverConnection, sql: string): Promise<void>;
 /**
  * Reports whether Postgres refuses to run `sql` inside a transaction.
  *

package/dist/tooling/migrate/sandbox.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Replays `okm migrate check` inside one transaction and rolls it back.
+ *
+ * The scratch schema is created in that transaction. Nothing here updates a
+ * system catalog or a real ACL. A step that cannot run in a transaction is
+ * rewritten to the transactional form, or skipped and named.
+ */
+import type { Catalog } from "../../contracts/catalog/types.js";
+import type { MigrateConfig } from "./config.js";
+import { type MigrationPlan, type PlanStep } from "./plan.js";
+/** One migration the check replays. */
+export type CheckMigration = {
+    readonly id: string;
+    readonly catalog: Catalog;
+    readonly steps: readonly PlanStep[];
+};
+/** The first migration whose replay does not match its catalog. */
+export type ReplayStop = {
+    readonly index: number;
+    readonly back: MigrationPlan;
+};
+/** Replay result. `skips` are statements check did not execute. */
+export type ReplayOutcome = {
+    readonly skips: readonly string[];
+    readonly stop?: ReplayStop;
+};
+/**
+ * Replays `history` in one transaction and rolls it back.
+ *
+ * @param url - Target URL
+ * @param scratch - Schema created inside the transaction
+ * @param config - Roles and timeouts
+ * @param allowPooler - Passed through to the pooler guard
+ * @param history - Migrations in apply order
+ * @returns Skipped statements, and the first catalog mismatch
+ */
+export declare function replayCheckHistory(url: string, scratch: string, config: MigrateConfig, allowPooler: boolean, history: readonly CheckMigration[]): Promise<ReplayOutcome>;
+/**
+ * Compares a head snapshot with a full replay. Both run in rolled-back transactions.
+ *
+ * @param url - Target URL
+ * @param provided - Scratch schema for the snapshot
+ * @param replayed - Scratch schema for the history
+ * @param config - Roles and timeouts
+ * @param allowPooler - Passed through to the pooler guard
+ * @param history - Migrations in apply order
+ * @returns The difference, or `undefined` when the catalogs match
+ */
+export declare function proveCheckSnapshot(url: string, provided: string, replayed: string, config: MigrateConfig, allowPooler: boolean, history: readonly CheckMigration[]): Promise<string | undefined>;
+/**
+ * Rewrites `"public".` to the scratch schema.
+ *
+ * @param steps - Plan steps
+ * @param schema - Scratch schema
+ * @returns The same steps, aimed at `schema`
+ */
+export declare function retargetSteps(steps: readonly PlanStep[], schema: string): readonly PlanStep[];

package/dist/tooling/migrate/sql-lex.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Splits one migration step into statements.
+ *
+ * Comments are removed. A semicolon splits only at the top level.
+ * `standard_conforming_strings` is on: a plain `'...'` ends on a single
+ * quote, and `''` is one quote inside it. `E'...'` still treats a backslash
+ * as an escape. A dollar quote runs until the same tag; a different tag
+ * inside it is text, so `$outer$ ... $inner$ ... $inner$ ... $outer$` stays
+ * one span. A `BEGIN ATOMIC` body of `CREATE FUNCTION` or `CREATE PROCEDURE`
+ * stays in that statement: a semicolon inside it does not split, and
+ * `CASE ... END` does not close the body. `BEGIN ATOMIC` elsewhere still
+ * splits. An unterminated string, quoted identifier, block comment, dollar
+ * quote, or atomic body is one opaque tail. This function does not throw.
+ */
+/** Statements of `sql`, comments removed, with no trailing semicolon. */
+export declare function sqlStatements(sql: string): readonly string[];
+/**
+ * Whether `sql` still has an open quote or block comment.
+ *
+ * A line comment does not count: it ends at the newline or at the end.
+ * An unclosed `BEGIN ATOMIC` routine body counts too.
+ *
+ * @param sql - Step text accumulated so far
+ * @returns `true` when a later blank line is still inside that quote or body
+ */
+export declare function sqlQuoteOpen(sql: string): boolean;
+/**
+ * Transaction control in a migration step.
+ *
+ * Dollar-quoted bodies are scanned only for a `DO` block. `CREATE FUNCTION`
+ * and `CREATE PROCEDURE` may commit inside their own body. A `BEGIN ATOMIC`
+ * body stays one statement, so its `END` is not transaction control. A bare
+ * `BEGIN` or `END` inside a `DO` body is plpgsql and is ignored. `ROLLBACK TO`
+ * does not end the outer transaction.
+ *
+ * @param sql - Step text
+ * @returns The command, or `undefined` when the step stays in one transaction
+ */
+export declare function transactionControl(sql: string): string | undefined;

package/dist/tooling/migrate/text.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Migration file text before it is parsed.
+ *
+ * Line endings and a UTF-8 BOM are normalized here, once, so every reader
+ * sees the same plan. UTF-16 is refused. The kind stays `invalid`.
+ */
+import { OkmError } from "../../contracts/error.js";
+/** Why a migration file was refused before it was applied. */
+export type MigrationTextReason = "no-steps" | "utf16";
+/**
+ * A migration file this version will not apply.
+ *
+ * `reason` is `no-steps` or `utf16`. The kind stays `invalid`.
+ */
+export declare class MigrationTextError extends OkmError {
+    /** Which check refused the file. */
+    readonly reason: MigrationTextReason;
+    /**
+     * @param reason - Which check failed
+     * @param message - What the author should change
+     */
+    constructor(reason: MigrationTextReason, message: string);
+}
+/**
+ * Strips a UTF-8 BOM and turns `\r\n` and a lone `\r` into `\n`.
+ *
+ * @param text - File text
+ * @param label - File name used when the text is UTF-16
+ * @returns Text `parsePlan` can split on `\n`
+ */
+export declare function prepareMigrationText(text: string, label?: string): string;
+/**
+ * Refuses a non-empty file that produced no steps and has no `-- no steps` line.
+ *
+ * An intentional empty plan from `formatPlan` carries that line.
+ * Anything else would apply as "nothing to apply" and skip the linter.
+ *
+ * @param text - Text already passed through {@link prepareMigrationText}
+ * @param stepCount - Steps the parser returned
+ * @param label - File name in the error
+ */
+export declare function assertMigrationSteps(text: string, stepCount: number, label: string): void;

package/dist/tooling/node-version.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Node version `okm` needs in order to load `okmodel.config.ts`.
+ *
+ * Node 22.18 unflags type stripping. Bun loads TypeScript itself, so the
+ * check does not apply when `bun --bun` is the runtime.
+ */
+/**
+ * Whether `version` can strip types in a `.ts` config.
+ *
+ * @param version - `process.version`, such as `v22.18.0`
+ * @returns `true` for Node 22.18 and every newer major
+ */
+export declare function nodeSupportsConfigTypes(version: string): boolean;
+/**
+ * Startup text when this process cannot load a TypeScript config.
+ *
+ * @param version - `process.version`
+ * @param bunRuntime - `true` when Bun is running the process
+ * @returns The stderr line, or `undefined` when the process can continue
+ */
+export declare function nodeStartupMessage(version: string, bunRuntime: boolean): string | undefined;

package/dist/tooling/testing/factories.d.ts

@@ -114,4 +114,14 @@ export declare function bindFactories(host: FactoryHost, definitions: Readonly<R
  * @returns The inserted row
  */
 export declare function insertRow(host: FactoryHost, table: string, overrides: Readonly<Record<string, unknown>> | undefined, children: Readonly<Record<string, number>> | undefined, inherited: string | undefined): Promise<Record<string, unknown>>;
+/**
+ * Drops a cached factory row.
+ *
+ * `isolation()` deletes the row it inserted. A later table must not reuse that id.
+ *
+ * @param host - The open harness
+ * @param table - Table name
+ * @param tenant - Tenant scope, when the table is tenanted
+ */
+export declare function forgetCached(host: FactoryHost, table: string, tenant: string | undefined): void;
 export {};

package/dist/tooling/testing/facts.d.ts

@@ -2,9 +2,9 @@
  * What a factory needs from a compiled schema: required columns, foreign keys,
  * and which tables are tenant or global.
  *
- * Column tenancy is the only strategy in this version. A table is tenant when
- * its predicate binds a scope, and global when `global("reason")` opted it out.
- * `schemaPerTenant` and `databasePerTenant` are not in 0.4.
+ * A table is tenant when its predicate binds a scope, and global when
+ * `global("reason")` opted it out. Composite and path use that probe.
+ * `schemaPerTenant` and `databasePerTenant` are not in this version.
  */
 import type { Catalog } from "../../contracts/catalog/types.js";
 import type { QuerySchema, RelationModel } from "../../dialects/pg/model.js";
@@ -46,6 +46,25 @@ export type TableFacts = {
     /** `global("reason")`. Absent on a tenant table and on a schema with no tenancy. */
     readonly globalReason: string | undefined;
 };
+/** One view or materialized view. Isolation reads it; it does not insert into it. */
+export type ViewFacts = {
+    /** Client name, camelCase. */
+    readonly name: string;
+    /** SQL name. */
+    readonly sql: string;
+    readonly kind: "view" | "materializedView";
+    /** Author SQL. */
+    readonly query: string;
+    readonly columns: readonly {
+        readonly field: string;
+        readonly dataType: string;
+        readonly guarded: boolean;
+    }[];
+    /** The predicate binds a scope. A global view is not tenant. */
+    readonly tenant: boolean;
+    /** `global("reason")` on the view. Absent when the view is not global. */
+    readonly globalReason: string | undefined;
+};
 /**
  * Scope value used to ask a tenancy object whether a table is tenant.
  *
@@ -56,13 +75,22 @@ export declare const tenantProbe = "00000000-0000-4000-8000-000000000001";
 /**
  * Reads every table in declaration order.
  *
- * Views and materialized views are in the query model too. They have no rows
- * of their own to insert, so they are left out.
+ * Views are read by {@link readViews}. They are not tables, so they are left out here.
  *
  * @param schema - Compiled schema
  * @returns One facts object per table
  */
 export declare function readFacts(schema: TestingSchema): readonly TableFacts[];
+/**
+ * Reads every view and materialized view in model order.
+ *
+ * A global view is not tenant. The reason comes from the view declaration,
+ * which is not stored on the catalog.
+ *
+ * @param schema - Compiled schema
+ * @returns One facts object per view
+ */
+export declare function readViews(schema: TestingSchema): readonly ViewFacts[];
 /**
  * A column the factory must set when the definition and the overrides omit it.
  *

package/dist/tooling/testing/index.d.ts

@@ -72,7 +72,7 @@ export type Testing<S extends TestingSchema = TestingSchema> = {
     /**
      * Runs the cross-tenant check.
      *
-     * @returns Checked tenant tables and skipped global tables
+     * @returns Checked tenant tables and views, and skipped global objects
      */
     isolation(): Promise<IsolationReport>;
     /** Closes the client and the pool. */

package/dist/tooling/testing/index.js

@@ -1,8 +1,8 @@
 import {
   testing2
-} from "../../shared/g516zdsb.js";
-import"../../shared/8xsbagad.js";
-import"../../shared/8bwbwy8h.js";
+} from "../../shared/8x72s86k.js";
+import"../../shared/9s0ypp87.js";
+import"../../shared/qq3899ht.js";
 export {
   testing2 as testing
 };