okmodel 0.3.0 → 0.5.0

package/dist/shared/xdpj5kkm.js

@@ -0,0 +1,2203 @@
+import {
+  VALIDATION_NOT_IMPORTED2,
+  VALIDATION_NOT_IMPORTED_FIX2
+} from "./n442h54c.js";
+import {
+  roleObject,
+  grantObject,
+  defaultPrivilegeObject,
+  serializeCatalog2,
+  catalogHash2,
+  startupCatalog2,
+  parseCatalog2
+} from "./8bwbwy8h.js";
+import {
+  open2
+} from "./wqem4jed.js";
+import {
+  canonicalTypeName,
+  batchSizeField,
+  aboutBatchCount,
+  parseReplace,
+  planMigration,
+  formatPlan,
+  parsePlan,
+  staleRenames
+} from "./ayz64vzj.js";
+import {
+  contributedFields
+} from "./n0dgs0pb.js";
+import {
+  assertValidation,
+  writeWouldValidate
+} from "./9m80mkac.js";
+import {
+  catalog,
+  isDomain
+} from "./g7ez901n.js";
+import {
+  snakeCase,
+  emittedTypeName
+} from "./jsd07prz.js";
+import {
+  ColumnBuilder2
+} from "./c9z5g0fm.js";
+import {
+  staticNamespace2
+} from "./t4tbsy9h.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/errors/registry.ts
+var ERROR_DOCS = [
+  {
+    code: "OKM1012",
+    title: "Trait field conflict",
+    summary: "A trait added a field that the table already declares.",
+    fix: "Rename the table field or drop the trait that introduces it. The error names both."
+  },
+  {
+    code: "OKM1020",
+    title: "Unknown table",
+    summary: "A table, dependency, or catalog object is missing or does not match its identity.",
+    fix: "Use a name that is in the schema. The error lists the accepted names and a nearest-name hint when one is close."
+  },
+  {
+    code: "OKM1021",
+    title: "Foreign key target",
+    summary: "A foreign key is missing its target table or column, or the target is ambiguous.",
+    fix: "Name the referenced table and columns. The error lists the columns that exist on the target."
+  },
+  {
+    code: "OKM1022",
+    title: "Foreign key type",
+    summary: "A foreign key column and the column it references have different types.",
+    fix: "Give both columns the same type. The error names the type that is accepted."
+  },
+  {
+    code: "OKM1023",
+    title: "Duplicate name",
+    summary: "Two catalog objects share an identity, or two tables emit the same type name.",
+    fix: "Rename one of them. Table names and emitted type names must be unique in the schema."
+  },
+  {
+    code: "OKM1024",
+    title: "Table file not in schema",
+    summary: "A table file is not passed to schema().",
+    fix: "Add the file's table to the schema() call that okm check reads."
+  },
+  {
+    code: "OKM1025",
+    title: "Multiple Register",
+    summary: "More than one Register augmentation is in the project.",
+    fix: 'Keep a single declare module "okmodel" that sets schema. Pass an explicit schema type everywhere else.'
+  },
+  {
+    code: "OKM1026",
+    title: "Dependency cycle",
+    summary: "The catalog dependency graph contains a cycle, so objects cannot be ordered.",
+    fix: "Break the cycle. The error is raised while ordering the catalog."
+  },
+  {
+    code: "OKM1027",
+    title: "Unreadable catalog",
+    summary: "The catalog document is malformed or uses a version this build cannot read.",
+    fix: "Regenerate the catalog with this version of okmodel. Do not hand-edit the document."
+  },
+  {
+    code: "OKM1030",
+    title: "Validation in two places",
+    summary: "A field is validated both on the column and somewhere else.",
+    fix: "Keep one validation for the field. The error names the field."
+  },
+  {
+    code: "OKM1040",
+    title: "Preset name collision",
+    summary: "A preset uses the name of a client method or a reserved name, or a table and its traits (or two traits) define the same preset.",
+    fix: "Rename the preset. The error names both sources when two define it. okm upgrade renames a preset when a later release claims its name."
+  },
+  {
+    code: "OKM1051",
+    title: "Archive foreign key",
+    summary: "A foreign key into a table-strategy archivable table uses CASCADE, SET NULL, or SET DEFAULT and is not listed in cascade.",
+    fix: "List the child table, the foreign key, and its action in cascade, or use RESTRICT or NO ACTION."
+  },
+  {
+    code: "OKM1052",
+    title: "Not archivable",
+    summary: "archive or restore was called on a table that is not archivable.",
+    fix: "Call it only on an archivable table. The methods are absent from the types of other tables."
+  },
+  {
+    code: "OKM1060",
+    title: "Invalid column",
+    summary: "A column definition has a bad length, precision, scale, array rank, interval qualifier, or an empty or repeated picklist or enum.",
+    fix: "Use a value the error lists as accepted."
+  },
+  {
+    code: "OKM1061",
+    title: "Reserved option",
+    summary: "The option exists in the types but this version does not implement it.",
+    fix: "Remove the option until the prompt or milestone named in the error adds it."
+  },
+  {
+    code: "OKM1101",
+    title: "Find without limit",
+    summary: "find was called without a limit.",
+    fix: "Pass limit, or call .all(reason) when the full set is intentional."
+  },
+  {
+    code: "OKM1102",
+    title: "Unfiltered write",
+    summary: "update or delete would run with an empty where.",
+    fix: "Pass a filter. undefined in a write filter does not mean every row."
+  },
+  {
+    code: "OKM1104",
+    title: "Upsert target",
+    summary: "onConflict names columns that are not a unique constraint.",
+    fix: "Set on to the columns of a unique constraint or the primary key."
+  },
+  {
+    code: "OKM1105",
+    title: "Include without limit",
+    summary: "A to-many include has no limit.",
+    fix: "Pass limit on the include, or call .all(reason)."
+  },
+  {
+    code: "OKM1110",
+    title: "Engine version",
+    summary: "The feature needs a newer engine than schema({ requires }) allows.",
+    fix: "Raise requires, or stop using the feature. The error names both versions."
+  },
+  {
+    code: "OKM1111",
+    title: "Missing capability",
+    summary: "The call needs a driver capability this driver does not have.",
+    fix: "Use a driver that declares the capability, or drop the call. The error names the flag."
+  },
+  {
+    code: "OKM1120",
+    title: "Unknown field",
+    summary: "A field name in where, select, orderBy, or include is not on the table.",
+    fix: "Use a field from the catalog. The error includes a nearest-name hint when one is close."
+  },
+  {
+    code: "OKM1121",
+    title: "Object as value",
+    summary: "A plain object was passed where a value is required. JSON cannot create an operator.",
+    fix: "Wrap the value with eq. eq is the equality form for json and jsonb."
+  },
+  {
+    code: "OKM1122",
+    title: "Bad identifier",
+    summary: "An identifier is empty, too long, contains NUL or another control character, or is an unquoted reserved word.",
+    fix: "Use a shorter name without control characters. Quote is not accepted here. The error names the rule that failed."
+  },
+  {
+    code: "OKM1123",
+    title: "Hidden field allowlist",
+    summary: "A hidden field was added to a filter or sort allowlist.",
+    fix: "Remove the hidden field from the allowlist. Hidden fields stay out of caller filters and sorts."
+  },
+  {
+    code: "OKM1124",
+    title: "Operator mismatch",
+    summary: "An operator does not apply to the column type.",
+    fix: "Use an operator the error lists for that column type. Text search needs a tsvector column."
+  },
+  {
+    code: "OKM1130",
+    title: "Cursor order",
+    summary: "A cursor was reused with a different orderBy than the one that created it, or is not a cursor page() returned.",
+    fix: "Request the next page with the same orderBy and the exact next value the previous page returned. The cursor encodes that order."
+  },
+  {
+    code: "OKM1190",
+    title: "Safety violation",
+    summary: "A query composition broke a core invariant. violations lists every broken rule in stable order.",
+    fix: "Change the contribution named on the first violation, or pass an explicit escape hatch (unscoped, all, trusted, allow) and record the reason."
+  },
+  {
+    code: "OKM1191",
+    title: "No snapshot plan",
+    summary: "A multi-statement read was requested inside READ COMMITTED and no single-statement plan exists.",
+    fix: "Run the read in REPEATABLE READ or SERIALIZABLE, or shape it so it is one statement."
+  },
+  {
+    code: "OKM1200",
+    title: "Validation failed",
+    summary: "A write or a standalone check failed a validation rule. issues lists each path and message key.",
+    fix: "Fix the fields named in issues. Each issue message is a key, not display text."
+  },
+  {
+    code: "OKM1201",
+    title: "Validation not imported",
+    summary: VALIDATION_NOT_IMPORTED2,
+    fix: VALIDATION_NOT_IMPORTED_FIX2
+  },
+  {
+    code: "OKM1210",
+    title: "Codec rejected a value",
+    summary: "A codec refused a value: not numeric text, not a valid temporal value, or the wrong shape.",
+    fix: "Pass a value the error lists as accepted. A missing Temporal global tells you to assign one to globalThis.Temporal."
+  },
+  {
+    code: "OKM1401",
+    title: "Outcome unknown",
+    summary: "A commit or batch was sent and its result never arrived, so the write may or may not have happened.",
+    fix: "Check whether the write landed, using an idempotency key, before retrying. This error is never retried automatically."
+  },
+  {
+    code: "OKM1510",
+    title: "Unsafe migration",
+    summary: "A migration has an unresolved lint error, or an override with an empty reason or a code the statement did not trigger.",
+    fix: "Put `-- okm-allow OKM15xx: reason` on the line above the statement. The code must be one that statement triggered, and the reason must not be empty."
+  },
+  {
+    code: "OKM1511",
+    title: "Drop table",
+    summary: "A statement drops a table. The rows and anything that reads them are gone.",
+    fix: "Stop reading the table in an expand migration, then drop it in a later contract. Or allow OKM1511 with a reason."
+  },
+  {
+    code: "OKM1512",
+    title: "Drop column",
+    summary: "A statement drops a column. Stored values and the code that reads them are gone.",
+    fix: "Stop reading the column in an expand migration, then drop it in a later contract. Or allow OKM1512 with a reason."
+  },
+  {
+    code: "OKM1513",
+    title: "Drop enum",
+    summary: "A statement drops an enum that columns or code may still depend on.",
+    fix: "Move every column off the enum first. Or allow OKM1513 with a reason."
+  },
+  {
+    code: "OKM1514",
+    title: "Drop domain",
+    summary: "A statement drops a domain that columns or code may still depend on.",
+    fix: "Move every column off the domain first. Or allow OKM1514 with a reason."
+  },
+  {
+    code: "OKM1515",
+    title: "Drop function",
+    summary: "A statement drops a function that queries or triggers may still call.",
+    fix: "Remove the callers in an expand migration, then drop the function. Or allow OKM1515 with a reason."
+  },
+  {
+    code: "OKM1516",
+    title: "Drop view",
+    summary: "A statement drops a view that queries may still read.",
+    fix: "Stop reading the view in an expand migration, then drop it. Or allow OKM1516 with a reason."
+  },
+  {
+    code: "OKM1517",
+    title: "Drop extension",
+    summary: "A statement drops an extension. A dependent still in the catalog is refused before this finding.",
+    fix: "Confirm nothing outside the catalog uses the extension. Or allow OKM1517 with a reason."
+  },
+  {
+    code: "OKM1518",
+    title: "Drop materialized view",
+    summary: "A statement drops a materialized view and the rows it stores.",
+    fix: "Stop reading the view in an expand migration, then drop it. Or allow OKM1518 with a reason."
+  },
+  {
+    code: "OKM1519",
+    title: "Rename column",
+    summary: "A statement renames a column. Existing queries still use the old name.",
+    fix: "Add the new column, backfill, and switch readers before dropping the old name. Or allow OKM1519 with a reason."
+  },
+  {
+    code: "OKM1520",
+    title: "Schema drift",
+    summary: "The database has drifted past what an expand migration can repair.",
+    fix: "Inspect the diff and repair the database, or generate a migration that matches the drift."
+  },
+  {
+    code: "OKM1521",
+    title: "Snapshot mismatch",
+    summary: "Provisioning from the snapshot does not match the replayed migration history.",
+    fix: "Regenerate the snapshot from the history. okm migrate check --provision is the command that reports this."
+  },
+  {
+    code: "OKM1522",
+    title: "Apply lock held",
+    summary: "Another apply already holds the target's migration lock.",
+    fix: "Wait for that apply to finish. Do not start a second apply against the same target."
+  },
+  {
+    code: "OKM1523",
+    title: "Rename table",
+    summary: "A statement renames a table. Existing queries still use the old name.",
+    fix: "Create the new table, backfill, and switch readers before dropping the old name. Or allow OKM1523 with a reason."
+  },
+  {
+    code: "OKM1524",
+    title: "Column type change",
+    summary: "A statement changes a column type. Existing readers and writers may not accept the new type.",
+    fix: "Add a new column, backfill, and switch readers before dropping the old one. Or allow OKM1524 with a reason."
+  },
+  {
+    code: "OKM1525",
+    title: "Required column",
+    summary: "A statement adds a NOT NULL column with no default to a table that already has rows.",
+    fix: "Add the column nullable, backfill, then set it NOT NULL. Or allow OKM1525 with a reason."
+  },
+  {
+    code: "OKM1526",
+    title: "Drop default",
+    summary: "A statement removes a column default. Writers that omitted the column will fail.",
+    fix: "Update writers to send the column, then drop the default. Or allow OKM1526 with a reason."
+  },
+  {
+    code: "OKM1527",
+    title: "Shrink length",
+    summary: "A statement shortens a character length. Values longer than the new limit no longer fit.",
+    fix: "Shorten the stored values first, or keep the old length. Or allow OKM1527 with a reason."
+  },
+  {
+    code: "OKM1528",
+    title: "Unique constraint",
+    summary: "A statement adds a unique or primary-key constraint on a table that already has rows.",
+    fix: "Deduplicate the rows first. Or allow OKM1528 with a reason."
+  },
+  {
+    code: "OKM1529",
+    title: "Unique index",
+    summary: "A statement creates a unique index on a table that already has rows.",
+    fix: "Deduplicate the rows first. Or allow OKM1529 with a reason."
+  },
+  {
+    code: "OKM1530",
+    title: "Ambiguous rename",
+    summary: "A rename could match more than one object.",
+    fix: "Declare the rename explicitly so the plan has one pairing."
+  },
+  {
+    code: "OKM1531",
+    title: "Validating check",
+    summary: "A statement adds or validates a check against rows already stored.",
+    fix: "Add the check NOT VALID, repair the rows, then validate it. Or allow OKM1531 with a reason."
+  },
+  {
+    code: "OKM1532",
+    title: "Validating foreign key",
+    summary: "A statement adds or validates a foreign key against rows already stored.",
+    fix: "Add the foreign key NOT VALID, repair the rows, then validate it. Or allow OKM1532 with a reason."
+  },
+  {
+    code: "OKM1533",
+    title: "Narrowing type",
+    summary: "A statement narrows a numeric or integer type. Values outside the new range no longer fit.",
+    fix: "Rewrite the values into the new range first. Or allow OKM1533 with a reason."
+  },
+  {
+    code: "OKM1534",
+    title: "Index locks",
+    summary: "A statement creates an index on an existing table without CONCURRENTLY.",
+    fix: "Create the index with CREATE INDEX CONCURRENTLY, outside a transaction. The planner does this on an existing table."
+  },
+  {
+    code: "OKM1535",
+    title: "Check without NOT VALID",
+    summary: "A statement adds a check on an existing table without NOT VALID.",
+    fix: "Add the check NOT VALID, then validate it in its own step. The planner does this on an existing table."
+  },
+  {
+    code: "OKM1536",
+    title: "Foreign key without NOT VALID",
+    summary: "A statement adds a foreign key on an existing table without NOT VALID.",
+    fix: "Add the foreign key NOT VALID, then validate it in its own step. The planner does this on an existing table."
+  },
+  {
+    code: "OKM1537",
+    title: "Set not null",
+    summary: "A statement sets NOT NULL on a column that already exists.",
+    fix: "Add CHECK (column IS NOT NULL) NOT VALID, validate it, then SET NOT NULL and drop the check. The planner does this on an existing column."
+  },
+  {
+    code: "OKM1538",
+    title: "Type rewrite",
+    summary: "A statement changes a column type in a way that rewrites the table.",
+    fix: "There is no safe form for a rewriting type change in this version. A column swap is expand and contract work for a later step. OKM1524 already requires a reason for the type change."
+  },
+  {
+    code: "OKM1539",
+    title: "Timestamp without time zone",
+    summary: "A column is timestamp without time zone. The instant depends on the session time zone.",
+    fix: "Use timestamptz."
+  },
+  {
+    code: "OKM1540",
+    title: "varchar length",
+    summary: "A column is varchar(n). text stores the same values without a length limit in the type.",
+    fix: "Use text, and check the length in the application when one is required."
+  },
+  {
+    code: "OKM1541",
+    title: "Picklist removal",
+    summary: "A picklist or enum value was removed and the replacement was not given.",
+    fix: "Pass --replace <table>.<column>.<old>=<new>, or =null on a nullable column. The replacement must be in the new list."
+  },
+  {
+    code: "OKM1542",
+    title: "Data statement",
+    summary: "A migration contains a data statement outside backfill().",
+    fix: "Move the statement into backfill(). Data changes are batched and resumable there."
+  },
+  {
+    code: "OKM1543",
+    title: "serial column",
+    summary: "A column uses serial or a nextval default. Identity is the form this repo generates.",
+    fix: "Use an identity column generated always."
+  },
+  {
+    code: "OKM1544",
+    title: "json column",
+    summary: "A column is json. jsonb is available and stores the same documents in binary.",
+    fix: "Use jsonb."
+  },
+  {
+    code: "OKM1545",
+    title: "Identity not always",
+    summary: "An identity column is generated by default. The repo default is generated always.",
+    fix: "Declare the identity as generated always."
+  },
+  {
+    code: "OKM1546",
+    title: "Backfill key",
+    summary: "A backfill step targets a table that has no primary key.",
+    fix: "Add a primary key. A backfill walks that key and does not scan the table."
+  },
+  {
+    code: "OKM1547",
+    title: "History differs",
+    summary: "Replaying a migration does not match its stored catalog, or the file was generated from a different parent than the previous migration.",
+    fix: "Regenerate the migration from the previous catalog so the SQL and the stored catalog describe the same schema."
+  },
+  {
+    code: "OKM1548",
+    title: "Previous catalog",
+    summary: "An expand migration drops or changes a table, column, constraint, or type the previous catalog relies on.",
+    fix: "Keep every table, column, constraint, and type the previous catalog relies on, or classify the migration as contract."
+  },
+  {
+    code: "OKM1549",
+    title: "Stale head",
+    summary: "The last migration's catalog does not match the schema.",
+    fix: "Run okm generate."
+  },
+  {
+    code: "OKM1601",
+    title: "Stale typed SQL",
+    summary: "A typed SQL signature no longer matches the database.",
+    fix: "Regenerate the typed SQL and commit the new signature."
+  },
+  {
+    code: "OKM1701",
+    title: "Tenant context missing",
+    summary: "A tenant table was used on a client that has no tenant context.",
+    fix: "Open the client with the tenant context before reading or writing that table."
+  },
+  {
+    code: "OKM1702",
+    title: "Unverifiable tenant SQL",
+    summary: "Raw SQL touches a tenant table and the tenant predicate cannot be proved.",
+    fix: "Use the query builder, or mark the fragment trusted with a reason if it is reviewed."
+  },
+  {
+    code: "OKM1704",
+    title: "Tenant key change",
+    summary: "An update tried to change the tenant key.",
+    fix: "Remove the tenant key from the update. Moving a row between tenants is not an update."
+  },
+  {
+    code: "OKM1705",
+    title: "Global references tenant",
+    summary: "A global table references a tenant table.",
+    fix: "Drop the reference, or make the referencing table a tenant table."
+  },
+  {
+    code: "OKM1706",
+    title: "Tenant index",
+    summary: "An index on a tenant table does not lead with the tenant key.",
+    fix: "Put the tenant key first in the index columns."
+  },
+  {
+    code: "OKM1707",
+    title: "RLS role",
+    summary: "connect() was given a role that owns the tables or is a superuser, under the rls strategy.",
+    fix: "Connect as a role that is neither the owner nor a superuser."
+  },
+  {
+    code: "OKM1801",
+    title: "Dialect mismatch",
+    summary: "The schema dialect and the driver dialect are not the same.",
+    fix: "Open the schema with the driver package that matches it."
+  },
+  {
+    code: "OKM1802",
+    title: "Server version",
+    summary: "The connected server does not satisfy schema({ requires }).",
+    fix: "Upgrade the server, or lower requires to a version the server meets."
+  },
+  {
+    code: "OKM1803",
+    title: "Postgres floor",
+    summary: "The connected server is older than PostgreSQL 15, and the schema does not set requires to that older major.",
+    fix: "Upgrade the server to PostgreSQL 15 or newer, or set schema({ requires }) to the older major on purpose."
+  },
+  {
+    code: "OKM1810",
+    title: "Extension not declared",
+    summary: "An extension builder was used but the extension is not declared on the schema.",
+    fix: "Declare the extension next to the schema that uses it."
+  },
+  {
+    code: "OKM1811",
+    title: "Extension unavailable",
+    summary: "A declared extension is not installed on the server.",
+    fix: "Install the extension, or remove the declaration. okm doctor reports this against the connected server."
+  },
+  {
+    code: "OKM1812",
+    title: "Feature version",
+    summary: "A feature needs a newer Postgres or extension version than the one declared or connected.",
+    fix: 'Raise the declared version, or avoid the feature. uuidv7() below 18 can use t.id({ default: "uuidv4" }), defaults.id set to "uuidv4", or a client generator. Core features are never gated on an extension.'
+  },
+  {
+    code: "OKM1813",
+    title: "Extension defined twice",
+    summary: "The same extension definition was registered twice.",
+    fix: "Keep one definition. A second copy fails at build."
+  },
+  {
+    code: "OKM1814",
+    title: "Extension change refused",
+    summary: "The plan would downgrade an extension, move a non-relocatable one, or drop one that still has dependents.",
+    fix: "Drop or move the dependents first. Postgres cannot lower an extension version."
+  },
+  {
+    code: "OKM1820",
+    title: "View tenancy",
+    summary: "A view over tenant tables does not expose the tenant key and is not marked global.",
+    fix: "Expose the tenant key so the predicate can be applied, or declare global(reason)."
+  },
+  {
+    code: "OKM1821",
+    title: "Replace needs recreate",
+    summary: "An incompatible replace would have to recreate dependents. CASCADE is never used.",
+    fix: "Review the dependents the plan lists and recreate them explicitly."
+  },
+  {
+    code: "OKM1822",
+    title: "Concurrent refresh",
+    summary: "REFRESH CONCURRENTLY was declared without a unique index on the materialized view.",
+    fix: "Add a unique index, or refresh without CONCURRENTLY."
+  },
+  {
+    code: "OKM1823",
+    title: "Security definer path",
+    summary: "A SECURITY DEFINER function has no search_path.",
+    fix: "Set search_path on the function to the schemas it is allowed to see."
+  },
+  {
+    code: "OKM1824",
+    title: "Function dependencies",
+    summary: "A plpgsql function has no dependsOn. Postgres does not record dependencies inside the body.",
+    fix: "List dependsOn. LANGUAGE sql with BEGIN ATOMIC is inferred and does not need the list."
+  },
+  {
+    code: "OKM1825",
+    title: "Missing privilege",
+    summary: "The application role lacks a privilege on a managed object.",
+    fix: "Grant the privilege, or change the role. okm doctor reports the object and the privilege."
+  },
+  {
+    code: "OKM1830",
+    title: "Lock outside transaction",
+    summary: "find was called with a row lock outside tx().",
+    fix: "Take the lock inside tx(). Advisory locks are transaction-scoped too."
+  },
+  {
+    code: "OKM1840",
+    title: "Replica not allowed",
+    summary: "A replica route was used on an operation that requires the primary, or inside tx().",
+    fix: "Run the operation on the primary. Writes, batch, locks, and tx() never go to a replica."
+  },
+  {
+    code: "OKM1841",
+    title: "External object differs",
+    summary: "An external object does not match the owner's exported catalog.",
+    fix: "Update the dependency's export, or stop treating the object as external."
+  },
+  {
+    code: "OKM1842",
+    title: "Cross-database foreign key",
+    summary: "A foreign key points at a table in another database.",
+    fix: "Keep the foreign key inside one database. Cross-catalog keys are allowed only there."
+  },
+  {
+    code: "OKM1843",
+    title: "No eligible replica",
+    summary: "A replica was required and none is eligible: unhealthy, behind the session, or none configured.",
+    fix: "Configure a replica or drop the route. This call does not read the primary."
+  },
+  {
+    code: "OKM1844",
+    title: "Fallback refused",
+    summary: "An automatic read found no eligible replica and fallback is error.",
+    fix: "Restore a replica, or set fallback to primary if the primary should absorb the read."
+  },
+  {
+    code: "OKM1845",
+    title: "Target unresolved",
+    summary: "The target could not be resolved. The tenant is unknown or the resolver failed.",
+    fix: "Check the tenant id and the resolver. Connection details are not guessed."
+  },
+  {
+    code: "OKM1846",
+    title: "Acquire timeout",
+    summary: "The pool did not hand out a connection within timeouts.acquire.",
+    fix: "Raise timeouts.acquire, or stop holding connections. The wait does not spill into another pool."
+  },
+  {
+    code: "OKM1850",
+    title: "Protected target",
+    summary: "The operation is blocked on a protected target and --allow-protected was not passed.",
+    fix: "Run a read-only command or an expand migration, or pass --allow-protected for this invocation."
+  },
+  {
+    code: "OKM1851",
+    title: "Target not empty",
+    summary: "Provisioning was asked to fill a target that already has objects.",
+    fix: "Provision an empty schema or an empty database. A non-empty target is refused."
+  },
+  {
+    code: "OKM1852",
+    title: "Protection mismatch",
+    summary: "Targets that resolve to the same database disagree about protection, or tenants of one schema-per-tenant database do.",
+    fix: "Give those targets the same protection flag. okm check and okm doctor both report this."
+  },
+  {
+    code: "OKM1853",
+    title: "Target not named",
+    summary: "Several targets are configured and the command was not given --target.",
+    fix: "Pass --target <name>. The command does not guess."
+  }
+];
+var byCode;
+function errorDoc(code) {
+  const index = byCode ?? indexDocs();
+  return index.get(code);
+}
+function indexDocs() {
+  const index = new Map;
+  for (const doc of ERROR_DOCS)
+    index.set(doc.code, doc);
+  byCode = index;
+  return index;
+}
+
+// src/tooling/migrate/lint.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/tooling/migrate/lint-rules.ts
+var INTEGER_WIDTH = {
+  smallint: 2,
+  integer: 4,
+  bigint: 8
+};
+var FLOAT_WIDTH = {
+  real: 4,
+  "double precision": 8
+};
+var STEP_RULES = [
+  rule("OKM1511", "destructive", "error", "Dropping a table destroys its rows.", (input) => hit(matches(input.step, "drop-table", /^drop table\b/), "drops a table")),
+  rule("OKM1512", "destructive", "error", "Dropping a column destroys its values.", (input) => hit(matches(input.step, "drop-column", /^alter table\s+\S+\s+drop column\b/), "drops a column")),
+  rule("OKM1513", "destructive", "error", "Dropping an enum can break columns that use it.", (input) => hit(droppedType(input) === "enum", "drops an enum")),
+  rule("OKM1514", "destructive", "error", "Dropping a domain can break columns that use it.", (input) => hit(droppedType(input) === "domain", "drops a domain")),
+  rule("OKM1515", "destructive", "error", "Dropping a function can break its callers.", (input) => hit(matches(input.step, "drop-function", /^drop function\b/), "drops a function")),
+  rule("OKM1516", "destructive", "error", "Dropping a view can break queries that read it.", (input) => hit(matches(input.step, "drop-view", /^drop view\b/), "drops a view")),
+  rule("OKM1517", "destructive", "error", "Dropping an extension removes it even when the catalog has no dependent.", (input) => hit(matches(input.step, "drop-extension", /^drop extension\b/), "drops an extension")),
+  rule("OKM1518", "destructive", "error", "Dropping a materialized view destroys the rows it stores.", (input) => hit(matches(input.step, "drop-matview", /^drop materialized view\b/), "drops a materialized view")),
+  rule("OKM1519", "backward-incompatible", "error", "Renaming a column breaks queries that still use the old name.", (input) => hit(matches(input.step, "rename-column", /^alter table\s+\S+\s+rename column\b/), "renames a column")),
+  rule("OKM1523", "backward-incompatible", "error", "Renaming a table breaks queries that still use the old name.", (input) => hit(renamesTable(input.step), "renames a table")),
+  rule("OKM1524", "backward-incompatible", "error", "Changing a column type can break readers and writers.", (input) => typeChange(input, "incompatible")),
+  rule("OKM1525", "backward-incompatible", "error", "Adding NOT NULL without a default fails when the table already has rows.", (input) => hit(requiredColumn(input), "adds NOT NULL without a default")),
+  rule("OKM1526", "backward-incompatible", "error", "Removing a default breaks writers that omit the column.", (input) => hit(matches(input.step, "drop-default", /^alter table\s+\S+\s+alter column\s+\S+\s+drop default\b/), "removes a default")),
+  rule("OKM1527", "backward-incompatible", "error", "Shortening a character length rejects values that used to fit.", (input) => typeChange(input, "shrink")),
+  rule("OKM1528", "data-dependent", "error", "A new unique or primary key on an existing table fails when rows collide.", (input) => hit(uniqueConstraint(input), "builds a unique or primary key")),
+  rule("OKM1529", "data-dependent", "error", "A new unique index on an existing table fails when rows collide.", (input) => hit(uniqueIndex(input), "creates a unique index")),
+  rule("OKM1531", "data-dependent", "error", "A check that validates existing rows fails when a row does not pass.", (input) => hit(validatingCheck(input), "validates a check")),
+  rule("OKM1532", "data-dependent", "error", "A foreign key that validates existing rows fails when a row has no target.", (input) => hit(validatingForeignKey(input), "validates a foreign key")),
+  rule("OKM1533", "data-dependent", "error", "Narrowing an integer, float, or numeric type rejects values outside the new range.", (input) => typeChange(input, "narrow")),
+  rule("OKM1534", "locking", "error", "Creating an index on an existing table without CONCURRENTLY locks writes.", (input) => hit(blockingIndex(input), "creates an index without CONCURRENTLY")),
+  rule("OKM1535", "locking", "error", "Adding a check without NOT VALID locks the table while it scans.", (input) => hit(checkWithoutNotValid(input), "adds a check without NOT VALID")),
+  rule("OKM1536", "locking", "error", "Adding a foreign key without NOT VALID locks the table while it scans.", (input) => hit(foreignKeyWithoutNotValid(input), "adds a foreign key without NOT VALID")),
+  rule("OKM1537", "locking", "error", "SET NOT NULL locks the table while it scans for nulls.", (input) => hit(unsafeSetNotNull(input), "sets NOT NULL")),
+  rule("OKM1538", "locking", "warning", "A type change that rewrites the table locks it for the rewrite.", (input) => typeChange(input, "rewrite")),
+  rule("OKM1542", "data-dependent", "error", "A data statement outside backfill() is not a migration step.", (input) => hit(dataStatement(input.step), "changes rows outside backfill()"))
+];
+var COLUMN_RULES = [
+  {
+    code: "OKM1539",
+    category: "type-preference",
+    severity: "warning",
+    doc: "timestamp without time zone depends on the session time zone; use timestamptz.",
+    check: (column) => /^timestamp(?:\(\d+\))? without time zone$/.test(canonical(column.definition.dataType)) ? "is timestamp without time zone" : undefined
+  },
+  {
+    code: "OKM1540",
+    category: "type-preference",
+    severity: "warning",
+    doc: "varchar(n) can be text; a length check belongs in the application.",
+    check: (column) => /^character varying\(\d+\)$/.test(canonical(column.definition.dataType)) ? "is varchar(n)" : undefined
+  },
+  {
+    code: "OKM1543",
+    category: "type-preference",
+    severity: "warning",
+    doc: "serial and nextval defaults should be identity generated always.",
+    check: (column) => isSerial(column) ? "uses serial or nextval" : undefined
+  },
+  {
+    code: "OKM1544",
+    category: "type-preference",
+    severity: "warning",
+    doc: "json should be jsonb, which is available on every supported Postgres.",
+    check: (column) => canonical(column.definition.dataType) === "json" ? "is json" : undefined
+  },
+  {
+    code: "OKM1545",
+    category: "type-preference",
+    severity: "warning",
+    doc: "An identity that is not generated always differs from the repo default.",
+    check: (column) => column.definition.identity?.always === false ? "is generated by default" : undefined
+  }
+];
+function rule(code, category, severity, doc, check) {
+  return { code, category, severity, doc, check };
+}
+function hit(matched, reason) {
+  return matched ? [reason] : [];
+}
+function normalized(sql) {
+  const collapsed = sql.trim().replace(/\s+/g, " ");
+  let out = "";
+  let quoted = false;
+  for (const char of collapsed) {
+    if (char === '"') {
+      quoted = !quoted;
+      out += char;
+      continue;
+    }
+    out += quoted ? char : char.toLowerCase();
+  }
+  return out;
+}
+function dataStatement(step) {
+  if (step.backfill !== undefined)
+    return false;
+  const text = normalized(step.sql);
+  if (/^(?:insert|update|delete|merge|truncate)\b/.test(text))
+    return true;
+  return /^with\b/.test(text) && /\b(?:insert|update|delete|merge)\b/.test(text);
+}
+function matches(step, kind, pattern) {
+  return pattern.test(normalized(step.sql)) || step.kind === kind;
+}
+function renamesTable(step) {
+  const text = normalized(step.sql);
+  if (/^alter table\s+\S+\s+rename to\b/.test(text))
+    return true;
+  return step.kind === "rename-table" && !/^alter table\s+\S+\s+rename (column|constraint)\b/.test(text);
+}
+function droppedType(input) {
+  const text = normalized(input.step.sql);
+  const dropping = /^drop type\b/.test(text);
+  if (!dropping && input.step.kind !== "drop-enum" && input.step.kind !== "drop-domain") {
+    return;
+  }
+  if (input.step.kind === "drop-domain")
+    return "domain";
+  if (input.step.kind === "drop-enum")
+    return "enum";
+  const name = lastName(/^drop type\s+(\S+)/.exec(text)?.[1]);
+  const found = input.before.objects.find((object) => object.kind === "type" && object.identity.name === name);
+  if (found !== undefined && isDomain(found.definition))
+    return "domain";
+  return "enum";
+}
+function requiredColumn(input) {
+  const text = normalized(input.step.sql);
+  const adding = /^alter table\s+\S+\s+add column\b/.test(text) || input.step.kind === "add-column-required";
+  if (!adding)
+    return false;
+  if (input.step.kind === "add-column")
+    return false;
+  if (!tableExists(input))
+    return false;
+  if (input.step.kind === "add-column-required")
+    return true;
+  const body = text.replace(/^alter table\s+\S+\s+add column\s+/, "");
+  return /\bnot null\b/.test(body) && !/\bdefault\b/.test(body) && !/\bgenerated\b/.test(body);
+}
+function uniqueConstraint(input) {
+  if (!tableExists(input))
+    return false;
+  const text = normalized(input.step.sql);
+  if (/\busing index\b/.test(text))
+    return false;
+  if (/^alter table\s+\S+\s+add constraint\b/.test(text) && /\b(unique|primary key)\b/.test(text)) {
+    return true;
+  }
+  if (!/^create unique index\b/.test(text))
+    return false;
+  const name = createdIndexName(text);
+  if (name === undefined)
+    return false;
+  return input.later.some((step) => usesIndex(normalized(step.sql), name));
+}
+function uniqueIndex(input) {
+  const text = normalized(input.step.sql);
+  if (!/^create unique index\b/.test(text))
+    return false;
+  if (!tableExists(input))
+    return false;
+  const name = createdIndexName(text);
+  if (name !== undefined && input.later.some((step) => usesIndex(normalized(step.sql), name))) {
+    return false;
+  }
+  return true;
+}
+function createdIndexName(text) {
+  const match = /^create unique index (?:concurrently )?(?:"([^"]+)"|([a-z_][\w$]*))/.exec(text);
+  return match?.[1] ?? match?.[2];
+}
+function usesIndex(text, name) {
+  return text.includes(`using index "${name}"`) || text.includes(`using index ${name}`);
+}
+function unsafeSetNotNull(input) {
+  const text = normalized(input.step.sql);
+  const match = /^alter table\s+(\S+)\s+alter column\s+(\S+)\s+set not null\b/.exec(text);
+  if (match === null && input.step.kind !== "set-not-null")
+    return false;
+  if (!tableExists(input))
+    return false;
+  const table = match?.[1];
+  const column = match?.[2];
+  if (table !== undefined && column !== undefined && validatedNotNullCheck(input.earlier, table, column)) {
+    return false;
+  }
+  return true;
+}
+function validatedNotNullCheck(earlier, table, column) {
+  const needle = `check (${column} is not null) not valid`;
+  for (const step of earlier) {
+    const text = normalized(step.sql);
+    if (!text.startsWith(`alter table ${table} `) || !text.includes(needle))
+      continue;
+    const added = /^alter table\s+\S+\s+add constraint\s+(\S+)\s+check\b/.exec(text);
+    const name = added?.[1];
+    if (name === undefined)
+      continue;
+    const validated = earlier.some((item) => normalized(item.sql).startsWith(`alter table ${table} validate constraint ${name}`));
+    if (validated)
+      return true;
+  }
+  return false;
+}
+function blockingIndex(input) {
+  const text = normalized(input.step.sql);
+  if (!/^create(?: unique)? index\b/.test(text) && input.step.kind !== "create-index")
+    return false;
+  if (/\bconcurrently\b/.test(text))
+    return false;
+  return tableExists(input);
+}
+function checkWithoutNotValid(input) {
+  return addedConstraint(input, "check") && !/\bnot valid\b/.test(normalized(input.step.sql));
+}
+function foreignKeyWithoutNotValid(input) {
+  return addedConstraint(input, "foreign key") && !/\bnot valid\b/.test(normalized(input.step.sql));
+}
+function validatingCheck(input) {
+  if (widenValidate(input))
+    return false;
+  if (validates(input, "check"))
+    return true;
+  return checkWithoutNotValid(input);
+}
+function widenValidate(input) {
+  const text = normalized(input.step.sql);
+  if (!/^alter table\s+\S+\s+validate constraint\b/.test(text))
+    return false;
+  if (input.step.kind === "widen-check")
+    return true;
+  const name = /^alter table\s+\S+\s+validate constraint\s+(\S+)/.exec(text)?.[1];
+  if (name === undefined)
+    return false;
+  return input.earlier.some((step) => {
+    if (step.kind !== "widen-check")
+      return false;
+    const prior = normalized(step.sql);
+    return prior.includes(`add constraint ${name} `);
+  });
+}
+function validatingForeignKey(input) {
+  if (validates(input, "foreignKey"))
+    return true;
+  return foreignKeyWithoutNotValid(input);
+}
+function addedConstraint(input, kind) {
+  if (!tableExists(input))
+    return false;
+  const text = normalized(input.step.sql);
+  if (!/^alter table\s+\S+\s+add constraint\b/.test(text))
+    return false;
+  return new RegExp(`\\b${kind}\\b`).test(text);
+}
+function validates(input, kind) {
+  const text = normalized(input.step.sql);
+  const table = /^alter table\s+\S+\s+validate constraint\s+(\S+)/.exec(text);
+  if (table !== null) {
+    const token = table[1];
+    if (token === undefined)
+      return kind === "check";
+    const name = lastName(token);
+    if (name === undefined)
+      return kind === "check";
+    const constraint = findConstraint(input.after, name);
+    if (constraint === undefined)
+      return kind === "check";
+    return constraint.definition.constraintKind === kind;
+  }
+  if (kind === "check" && /^alter domain\s+\S+\s+validate constraint\b/.test(text))
+    return true;
+  return false;
+}
+function typeChange(input, mode) {
+  const text = normalized(input.step.sql);
+  const changing = /^alter table\s+\S+\s+alter column\s+\S+\s+set data type\b/.test(text) || input.step.kind === "set-column-type";
+  if (!changing)
+    return [];
+  const compared = columnTypes(input);
+  if (compared === undefined) {
+    if (mode === "incompatible" || mode === "rewrite")
+      return ["changes a column type"];
+    return [];
+  }
+  const { before, after } = compared;
+  if (before === after)
+    return [];
+  const shrink = lengthShrink(before, after);
+  if (mode === "shrink")
+    return shrink ? ["shortens a character length"] : [];
+  if (shrink)
+    return [];
+  if (mode === "narrow")
+    return narrows(before, after) ? ["narrows a type"] : [];
+  if (lengthGrow(before, after))
+    return [];
+  if (mode === "incompatible")
+    return ["changes a column type"];
+  return rewrites(before, after) ? ["rewrites the table"] : [];
+}
+function columnTypes(input) {
+  const text = normalized(input.step.sql);
+  const match = /^alter table\s+(\S+)\s+alter column\s+(\S+)\s+set data type\b/.exec(text);
+  const table = lastName(match?.[1]);
+  const column = lastName(match?.[2]);
+  if (table === undefined || column === undefined)
+    return;
+  const previous = findColumn(input.before, table, column);
+  const next = findColumn(input.after, table, column);
+  if (previous === undefined || next === undefined)
+    return;
+  return {
+    before: canonical(previous.definition.dataType),
+    after: canonical(next.definition.dataType)
+  };
+}
+function lengthShrink(before, after) {
+  const left = charLength(before);
+  const right = charLength(after);
+  return left !== undefined && right !== undefined && left.family === right.family && right.length < left.length;
+}
+function lengthGrow(before, after) {
+  const left = charLength(before);
+  const right = charLength(after);
+  return left !== undefined && right !== undefined && left.family === right.family && right.length > left.length;
+}
+function rewrites(before, after) {
+  if (lengthShrink(before, after) || lengthGrow(before, after))
+    return false;
+  if (isCharacter(before) && after === "text")
+    return false;
+  return true;
+}
+function narrows(before, after) {
+  const leftInt = INTEGER_WIDTH[before];
+  const rightInt = INTEGER_WIDTH[after];
+  if (leftInt !== undefined && rightInt !== undefined)
+    return rightInt < leftInt;
+  const leftFloat = FLOAT_WIDTH[before];
+  const rightFloat = FLOAT_WIDTH[after];
+  if (leftFloat !== undefined && rightFloat !== undefined)
+    return rightFloat < leftFloat;
+  const left = numericSpec(before);
+  const right = numericSpec(after);
+  if (left === undefined || right === undefined)
+    return false;
+  return right.precision < left.precision || right.scale < left.scale;
+}
+function charLength(type) {
+  const varying = /^character varying\((\d+)\)$/.exec(type);
+  if (varying?.[1] !== undefined)
+    return { family: "varying", length: Number(varying[1]) };
+  const fixed = /^character\((\d+)\)$/.exec(type);
+  if (fixed?.[1] !== undefined)
+    return { family: "fixed", length: Number(fixed[1]) };
+  return;
+}
+function isCharacter(type) {
+  return type === "text" || charLength(type) !== undefined;
+}
+function numericSpec(type) {
+  const match = /^numeric(?:\((\d+)(?:,(\d+))?\))?$/.exec(type);
+  if (match === null)
+    return;
+  if (match[1] === undefined)
+    return { precision: 1000, scale: 0 };
+  return {
+    precision: Number(match[1]),
+    scale: match[2] === undefined ? 0 : Number(match[2])
+  };
+}
+function tableExists(input) {
+  const name = statementTable(input.step);
+  return name !== undefined && input.existingTables.has(name);
+}
+function statementTable(step) {
+  const text = normalized(step.sql);
+  const altered = /^(?:alter|drop) table\s+(\S+)/.exec(text);
+  if (altered?.[1] !== undefined)
+    return lastName(altered[1]);
+  const index = /^create(?: unique)? index(?: concurrently)?\s+\S+\s+on\s+(\S+)/.exec(text);
+  return lastName(index?.[1]);
+}
+function lastName(token) {
+  if (token === undefined)
+    return;
+  const parts = [...token.matchAll(/"(?:[^"]|"")*"|[A-Za-z_][\w$]*/g)];
+  const last = parts.at(-1)?.[0];
+  if (last === undefined)
+    return;
+  if (last.startsWith('"'))
+    return last.slice(1, -1).replaceAll('""', '"');
+  return last;
+}
+function findColumn(source, table, name) {
+  return source.objects.find((object) => object.kind === "column" && object.identity.parent.name === table && object.identity.name === name);
+}
+function findConstraint(source, name) {
+  return source.objects.find((object) => object.kind === "constraint" && object.identity.name === name);
+}
+function canonical(typeName) {
+  return canonicalTypeName(typeName);
+}
+function isSerial(column) {
+  const typeName = column.definition.dataType.toLowerCase();
+  if (typeName === "serial" || typeName === "smallserial" || typeName === "bigserial")
+    return true;
+  if (column.definition.identity !== undefined)
+    return false;
+  return /nextval\s*\(/i.test(column.definition.defaultExpression ?? "");
+}
+
+// src/tooling/migrate/lint.ts
+function lintPlan(plan, before, after) {
+  const existingTables = tableNames(before);
+  const findings = [];
+  plan.steps.forEach((step, index) => {
+    findings.push(...lintStep(step, index + 1, before, after, existingTables, plan.steps.slice(0, index), plan.steps.slice(index + 1)));
+  });
+  return findings;
+}
+function lintCatalog(source) {
+  const findings = [];
+  for (const object of source.objects) {
+    if (object.kind !== "column")
+      continue;
+    for (const rule of COLUMN_RULES) {
+      const reason = rule.check(object);
+      if (reason === undefined)
+        continue;
+      findings.push(finding(rule.severity, rule.code, columnPlace(object), reason));
+    }
+  }
+  return findings;
+}
+function lintMigrationDirectory(directory, pending) {
+  if (!existsSync(directory))
+    return [];
+  const names = readdirSync(directory).filter((file) => file.endsWith(".sql")).sort();
+  let before = catalog([]);
+  const findings = [];
+  for (const file of names) {
+    const id = file.slice(0, -".sql".length);
+    const plan = parsePlan(readFileSync(join(directory, file), "utf8"));
+    const after = parseCatalog2(readFileSync(join(directory, `${id}.catalog.json`), "utf8"));
+    if (pending === undefined || pending.has(id)) {
+      for (const item of lintPlan(plan, before, after)) {
+        findings.push({ ...item, place: `${id} ${item.place}` });
+      }
+    }
+    before = after;
+  }
+  return findings;
+}
+function formatFindings(findings) {
+  if (findings.length === 0)
+    return "";
+  return `${findings.map(formatFinding).join(`
+`)}
+`;
+}
+function hasError(findings) {
+  return findings.some((item) => item.severity === "error");
+}
+function lintRefusal(findings) {
+  const doc = errorDoc("OKM1510");
+  return new OkmError2("OKM1510", formatFindings(findings).trim(), {
+    fix: { summary: doc?.fix ?? "Allow the finding with a reason, or change the statement." }
+  });
+}
+function lintStep(step, number, before, after, existingTables, earlier, later) {
+  const hits = [];
+  for (const rule of STEP_RULES) {
+    for (const reason of rule.check({ step, before, after, existingTables, earlier, later })) {
+      hits.push({ code: rule.code, severity: rule.severity, reason });
+    }
+  }
+  const triggered = new Set(hits.map((item) => item.code));
+  const silenced = new Set;
+  const findings = [];
+  const place = `step ${String(number)}`;
+  for (const allow of step.allows ?? []) {
+    if (allow.reason.trim().length === 0 || allow.code.length === 0) {
+      findings.push(finding("error", "OKM1510", place, "override needs a reason"));
+      continue;
+    }
+    if (!triggered.has(allow.code)) {
+      findings.push(finding("error", "OKM1510", place, `override ${allow.code} does not match this statement`));
+      continue;
+    }
+    silenced.add(allow.code);
+  }
+  for (const hit of hits) {
+    if (silenced.has(hit.code))
+      continue;
+    findings.push(finding(hit.severity, hit.code, place, hit.reason));
+  }
+  return findings;
+}
+function finding(severity, code, place, reason) {
+  const doc = errorDoc(code);
+  if (doc === undefined)
+    throw new Error(`${code} missing from the error registry.`);
+  return { severity, code, place, reason, fix: doc.fix };
+}
+function formatFinding(item) {
+  return `${item.severity} ${item.code} ${item.place}: ${item.reason} -- fix: ${item.fix}`;
+}
+function tableNames(source) {
+  const names = new Set;
+  for (const object of source.objects) {
+    if (object.kind === "table")
+      names.add(object.identity.name);
+  }
+  return names;
+}
+function columnPlace(column) {
+  return `${column.identity.parent.name}.${column.identity.name}`;
+}
+
+// src/tooling/migrate/policy.ts
+var READ = new Set([
+  "plan",
+  "status",
+  "check",
+  "drift",
+  "verify",
+  "pull",
+  "catalog-export",
+  "inspect"
+]);
+var ALLOWED = new Set(["expand", "reference", "provision"]);
+var FORWARD_ONLY = new Set(["drop", "rollback"]);
+function assertTargetPolicy(target, operation, allowProtected = false) {
+  if (FORWARD_ONLY.has(operation)) {
+    throw new OkmError2("invalid", "There is no down migration.", {
+      fix: { summary: "Recovery is a new forward migration." }
+    });
+  }
+  if (!target.protected || allowProtected)
+    return;
+  if (READ.has(operation) || ALLOWED.has(operation))
+    return;
+  throw new OkmError2("OKM1850", `${operation} is blocked on protected target ${target.name}.`, {
+    kind: "forbidden",
+    fix: {
+      summary: "Run a read-only command or an expand migration, or pass --allow-protected for this invocation."
+    }
+  });
+}
+function assertTargetAlias(targets) {
+  const groups = new Map;
+  for (const target of targets) {
+    const key = `${target.host}
+${target.port}
+${target.database}`;
+    const group = groups.get(key);
+    if (group === undefined)
+      groups.set(key, [target]);
+    else
+      group.push(target);
+  }
+  for (const group of groups.values()) {
+    const protectedTarget = group.find((target) => target.protected);
+    const open = group.find((target) => !target.protected);
+    if (protectedTarget !== undefined && open !== undefined) {
+      throw new OkmError2("OKM1852", `${open.name} and ${protectedTarget.name} resolve to the same database and disagree about protection.`, {
+        fix: {
+          summary: "Give those targets the same protection flag. okm check and okm doctor both report this."
+        }
+      });
+    }
+  }
+}
+function assertDirectConnection(url, allowPooler) {
+  if (allowPooler)
+    return;
+  const endpoint = endpointOf(url);
+  const parsed = new URL(url);
+  const host = endpoint.host;
+  if (host.includes("pooler") || host.includes("pgbouncer") || host.includes("-pooler") || endpoint.port === "6543" || parsed.searchParams.get("pgbouncer") === "true") {
+    throw new OkmError2("invalid", `Refusing pooler host ${host}. Apply needs a direct connection.`, { fix: { summary: "Use a direct connection, or pass --allow-pooler." } });
+  }
+}
+function listTargets(config) {
+  if (config.database !== undefined && config.targets !== undefined) {
+    throw new OkmError2("invalid", "Set database or targets, not both.", {
+      fix: { summary: "database is the one target named default. Use targets for more than one." }
+    });
+  }
+  const entries = [];
+  if (config.database !== undefined)
+    entries.push(["default", config.database]);
+  if (config.targets !== undefined) {
+    for (const name of Object.keys(config.targets).sort()) {
+      const input = config.targets[name];
+      if (input !== undefined)
+        entries.push([name, input]);
+    }
+  }
+  return entries.map(([name, input]) => resolveTarget(name, input));
+}
+function selectTarget(config, name) {
+  const targets = listTargets(config);
+  if (targets.length === 0) {
+    throw new OkmError2("OKM1845", "No target is configured.", {
+      fix: { summary: "Set database or targets in okmodel.config.ts." }
+    });
+  }
+  if (name === undefined) {
+    if (targets.length === 1) {
+      const only = targets[0];
+      if (only !== undefined)
+        return only;
+    }
+    throw new OkmError2("OKM1853", "Several targets are configured and --target was not passed.", {
+      fix: { summary: "Pass --target <name>. The command does not guess." }
+    });
+  }
+  const found = targets.find((target) => target.name === name);
+  if (found === undefined) {
+    throw new OkmError2("OKM1845", `Target ${name} is not configured.`, {
+      fix: { summary: "Pass a name from targets, or database for the target named default." }
+    });
+  }
+  return found;
+}
+function resolveTarget(name, input) {
+  if (typeof input !== "string" && isReplicaTarget(input)) {
+    throw new OkmError2("OKM1845", `Target ${name} is a replica. Migrations run on the primary only.`, {
+      fix: {
+        summary: "Set database or targets to the primary URL. A replica is not a migration target."
+      }
+    });
+  }
+  const url = typeof input === "string" ? input : input.url;
+  const protectedTarget = typeof input === "string" ? false : input.protected === true;
+  if (url === undefined || url.length === 0) {
+    throw new OkmError2("OKM1845", `Target ${name} has no url.`, {
+      fix: { summary: "Set the target url. A target is not inferred from the environment." }
+    });
+  }
+  const endpoint = endpointOf(url);
+  return {
+    name,
+    url,
+    protected: protectedTarget,
+    host: endpoint.host,
+    port: endpoint.port,
+    database: endpoint.database
+  };
+}
+function isReplicaTarget(input) {
+  return "primary" in input || "replicas" in input || "weight" in input || "pool" in input;
+}
+function endpointOf(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new OkmError2("OKM1845", "The target URL is not a Postgres URL.", {
+      fix: { summary: "Pass a postgres:// URL for the target." }
+    });
+  }
+  const database = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
+  return {
+    host: parsed.hostname.toLowerCase(),
+    port: parsed.port.length > 0 ? parsed.port : "5432",
+    database
+  };
+}
+
+// src/tooling/migrate/project.ts
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { basename, join as join2 } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/dialects/pg/declarations.ts
+function schemaDeclarations(source) {
+  const renames = [];
+  for (const item of source.tables) {
+    const tableName = sqlTableName(item, source.casing);
+    const renamed = tableRenamedFrom(item);
+    if (renamed !== undefined) {
+      renames.push({ kind: "table", from: renamed, to: tableName });
+    }
+    for (const [field, value] of Object.entries(item.columns)) {
+      if (!(value instanceof ColumnBuilder2))
+        continue;
+      const state = value.state;
+      const columnName = state.sqlName ?? sqlIdentifier(field, source.casing);
+      if (state.renamedFrom !== undefined) {
+        renames.push({
+          kind: "column",
+          table: tableName,
+          from: state.renamedFrom,
+          to: columnName
+        });
+      }
+    }
+  }
+  return { renames };
+}
+function sqlTableName(item, casing) {
+  const options = item.options;
+  return options?.sqlName ?? sqlIdentifier(item.name, casing);
+}
+function tableRenamedFrom(item) {
+  const options = item.options;
+  return options?.renamedFrom;
+}
+function sqlIdentifier(name, casing) {
+  return casing === "snake" ? snakeCase(name) : name;
+}
+
+// src/dialects/pg/emit.ts
+function emitRowTypes(source) {
+  const lines = [
+    "/**",
+    " * Row types emitted from the schema.",
+    ` * Mode: ${source.types}.`,
+    " */",
+    ""
+  ];
+  const rows = [];
+  const inserts = [];
+  const updates = [];
+  for (const item of source.tables) {
+    const name = emittedTypeName(item.name);
+    const key = propertyName(item.name);
+    rows.push(`  readonly ${key}: ${name};`);
+    inserts.push(`  readonly ${key}: ${name}Insert;`);
+    updates.push(`  readonly ${key}: ${name}Update;`);
+    lines.push(`export interface ${name} {`);
+    lines.push(fields(item, "row", source));
+    lines.push("}", "");
+    lines.push(`export interface ${name}Insert {`);
+    lines.push(fields(item, "insert", source));
+    lines.push("}", "");
+    lines.push(`export interface ${name}Update {`);
+    lines.push(fields(item, "update", source));
+    lines.push("}", "");
+  }
+  lines.push("export interface Rows {");
+  lines.push(rows.join(`
+`));
+  lines.push("}", "");
+  lines.push("export interface Inserts {");
+  lines.push(inserts.join(`
+`));
+  lines.push("}", "");
+  lines.push("export interface Updates {");
+  lines.push(updates.join(`
+`));
+  lines.push("}");
+  return `${lines.join(`
+`)}
+`;
+}
+function propertyName(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : JSON.stringify(name);
+}
+function fields(item, kind, source) {
+  const printed = [];
+  const options = item.options;
+  const entries = Object.entries(item.columns);
+  for (const pair of contributedFields(source.traits, options)) {
+    if (!Object.hasOwn(item.columns, pair[0]))
+      entries.push([pair[0], pair[1]]);
+  }
+  if (source.tenancy !== undefined && options?.tenancy?.kind !== "global" && !Object.hasOwn(item.columns, source.tenancy.key)) {
+    entries.push([source.tenancy.key, source.tenancy.column()]);
+  }
+  for (const [field, builder] of entries) {
+    if (!(builder instanceof ColumnBuilder2)) {
+      continue;
+    }
+    const state = builder.state;
+    if (kind === "row") {
+      if (!state.hidden) {
+        printed.push(`  readonly ${field}: ${valueType(state, "required")};`);
+      }
+      continue;
+    }
+    const written = kind === "update" ? updateMode(state) : insertMode(state);
+    if (written === "omit") {
+      continue;
+    }
+    const mode = kind === "update" ? "optional" : written;
+    printed.push(`  readonly ${field}: ${valueType(state, mode)};`);
+  }
+  return printed.join(`
+`);
+}
+function insertMode(state) {
+  if (state.omitWrite || state.generated !== undefined || state.guarded) {
+    return "omit";
+  }
+  if (state.hasDefault || state.nullable) {
+    return "optional";
+  }
+  return "required";
+}
+function updateMode(state) {
+  if (state.omitUpdate || insertMode(state) === "omit")
+    return "omit";
+  return "optional";
+}
+function valueType(state, mode) {
+  let label = scalarLabel(state);
+  if (state.dims > 0) {
+    for (let rank = 0;rank < state.dims; rank += 1) {
+      label = `readonly (${label})[]`;
+    }
+  }
+  if (state.nullable) {
+    label += " | null";
+  }
+  if (mode === "optional") {
+    label += " | undefined";
+  }
+  return label;
+}
+function scalarLabel(state) {
+  if (state.picklist !== undefined) {
+    return state.picklist.values.map((value) => JSON.stringify(value)).join(" | ");
+  }
+  if (state.typeLabel !== undefined) {
+    return state.typeLabel;
+  }
+  const base = baseName(state.baseType);
+  switch (base) {
+    case "smallint":
+    case "integer":
+    case "real":
+    case "double precision":
+      return "number";
+    case "bigint":
+    case "numeric":
+    case "text":
+    case "varchar":
+    case "char":
+    case "citext":
+    case "uuid":
+    case "inet":
+    case "cidr":
+    case "macaddr":
+    case "macaddr8":
+    case "tsvector":
+    case "ltree":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "bytea":
+      return "Uint8Array";
+    case "json":
+    case "jsonb":
+      return "unknown";
+    case "timestamptz":
+      return "Temporal.Instant";
+    case "timestamp":
+      return "Temporal.PlainDateTime";
+    case "date":
+      return "Temporal.PlainDate";
+    case "time":
+      return "Temporal.PlainTime";
+    case "timetz":
+      return "{ readonly time: Temporal.PlainTime; readonly offset: string }";
+    case "interval":
+      return "Temporal.Duration";
+    case "tstzrange":
+      return rangeLabel("Temporal.Instant");
+    case "daterange":
+      return rangeLabel("Temporal.PlainDate");
+    case "int4range":
+      return rangeLabel("number");
+    case "int8range":
+    case "numrange":
+      return rangeLabel("string");
+    case "point":
+      return "{ readonly x: number; readonly y: number }";
+    case "line":
+      return "{ readonly a: number; readonly b: number; readonly c: number }";
+    default:
+      return "unknown";
+  }
+}
+function rangeLabel(bound) {
+  return `{ readonly empty: true } | { readonly empty: false; readonly lower: ${bound} | null; readonly upper: ${bound} | null; readonly lowerInclusive: boolean; readonly upperInclusive: boolean }`;
+}
+function baseName(dataType) {
+  if (dataType.startsWith("double precision")) {
+    return "double precision";
+  }
+  const space = dataType.indexOf(" ");
+  const head = space === -1 ? dataType : dataType.slice(0, space);
+  const paren = head.indexOf("(");
+  return paren === -1 ? head : head.slice(0, paren);
+}
+
+// src/dialects/pg/role/index.ts
+var PROVENANCE = { origin: "file", name: "roles" };
+var RELATION = ["SELECT", "INSERT", "UPDATE", "DELETE"];
+var READ2 = ["SELECT"];
+var ROUTINE = ["EXECUTE"];
+var SEQUENCE = ["USAGE", "SELECT"];
+function attachRoles(source, input) {
+  return catalog([...source.objects, ...contributeRoles(input, source.objects)]);
+}
+function contributeRoles(input, built) {
+  const migration = requireName(input.migration, "migration");
+  const app = requireName(input.app, "app");
+  const managed = new Map;
+  for (const role of input.managed ?? []) {
+    const name = requireName(role.name, "managed role");
+    managed.set(name, role);
+  }
+  const objects = [];
+  const names = new Set([migration, app, ...managed.keys()]);
+  for (const name of [...names].sort()) {
+    const declaration = managed.get(name);
+    objects.push(roleObject({
+      name,
+      owner: declaration === undefined ? "external" : "managed",
+      provenance: PROVENANCE,
+      ...declaration === undefined ? { login: false, inherit: true } : {
+        ...declaration.login !== undefined ? { login: declaration.login } : {},
+        ...declaration.inherit !== undefined ? { inherit: declaration.inherit } : {}
+      }
+    }));
+  }
+  const roleIdentity = (name) => ({ kind: "role", name });
+  const namespaces = new Set;
+  for (const object of built) {
+    if (object.owner === "ignored")
+      continue;
+    const ref = grantRef(object);
+    if (ref === undefined)
+      continue;
+    if (ref.namespace.form === "static")
+      namespaces.add(ref.namespace.name);
+    const privileges = privilegesFor(ref.kind);
+    for (const privilege of privileges) {
+      objects.push(grantObject({
+        role: app,
+        object: ref,
+        privilege,
+        provenance: PROVENANCE,
+        dependencies: [roleIdentity(app), objectIdentity(object)]
+      }));
+    }
+  }
+  const schemas = namespaces.size === 0 ? ["public"] : [...namespaces].sort();
+  for (const name of schemas) {
+    const namespace = staticNamespace2(name);
+    for (const [objectKind, privileges] of [
+      ["table", RELATION],
+      ["function", ROUTINE],
+      ["sequence", SEQUENCE]
+    ]) {
+      for (const privilege of privileges) {
+        objects.push(defaultPrivilegeObject({
+          forRole: migration,
+          namespace,
+          objectKind,
+          grantee: app,
+          privilege,
+          provenance: PROVENANCE,
+          dependencies: [roleIdentity(migration), roleIdentity(app)]
+        }));
+      }
+    }
+  }
+  return objects;
+}
+function requireName(name, role) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new OkmError2("invalid", `roles.${role} needs a name.`, {
+      fix: { summary: "Set roles.migration and roles.app to role names." }
+    });
+  }
+  return name;
+}
+function grantRef(object) {
+  if (object.kind === "table" || object.kind === "view" || object.kind === "materializedView") {
+    return { kind: object.kind, namespace: object.identity.namespace, name: object.identity.name };
+  }
+  if (object.kind === "sequence") {
+    return { kind: "sequence", namespace: object.identity.namespace, name: object.identity.name };
+  }
+  if (object.kind === "function") {
+    return {
+      kind: "function",
+      namespace: object.identity.namespace,
+      name: `${object.identity.name}(${object.identity.argTypes.join(",")})`
+    };
+  }
+  return;
+}
+function privilegesFor(kind) {
+  if (kind === "function")
+    return ROUTINE;
+  if (kind === "sequence")
+    return SEQUENCE;
+  if (kind === "materializedView")
+    return READ2;
+  if (kind === "namespace")
+    return [];
+  return RELATION;
+}
+function objectIdentity(object) {
+  return object.identity;
+}
+
+// src/tooling/migrate/estimate.ts
+var LARGE_TABLE_ROWS = 1e6;
+var ESTIMATE_SQL = `
+  select c.relname, c.reltuples::float8::text
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  where n.nspname = $1
+    and c.relname = any(string_to_array($2, E'\\x1f'))
+    and c.relkind in ('r', 'p', 'f', 'm')
+`;
+async function readRowEstimates(url, schema, tables) {
+  const pool = open2({ url, max: 1 });
+  try {
+    const connection = await pool.reserve?.();
+    if (connection === undefined) {
+      throw new Error("The target connection cannot start a transaction.");
+    }
+    let began = false;
+    try {
+      await connection.execute("begin read only");
+      began = true;
+      await connection.execute("set local statement_timeout = '5s'");
+      const map = new Map;
+      const unique = [...new Set(tables)];
+      if (unique.length > 0) {
+        const result = await connection.execute(ESTIMATE_SQL, [schema, unique.join("\x1F")]);
+        for (const row of result.rows) {
+          const name = row[0];
+          if (name === null || name === undefined)
+            continue;
+          map.set(name, classify(row[1] ?? null));
+        }
+      }
+      await connection.execute("commit");
+      began = false;
+      return map;
+    } catch (error) {
+      if (began)
+        await connection.execute("rollback").catch(() => {
+          return;
+        });
+      throw error;
+    } finally {
+      await connection.release();
+    }
+  } finally {
+    await pool.close();
+  }
+}
+function annotateLock(step, estimates) {
+  const pieces = lockPieces(step);
+  const text = withBatches(step, pieces.map((piece) => {
+    if (piece.table === undefined)
+      return piece.mode;
+    return `${piece.mode} on ${piece.table}, ${estimatePhrase(estimates.get(piece.table))}`;
+  }).join("; "), estimates);
+  if (step.safeRewrite === true)
+    return `${text}; safe rewrite applied`;
+  if (exclusiveOverLarge(pieces, estimates)) {
+    return `${text}; note: more than ${String(LARGE_TABLE_ROWS)} estimated rows`;
+  }
+  return text;
+}
+function aboutRows(count) {
+  const rounded = Math.max(0, Math.round(count));
+  if (rounded < 1000)
+    return `about ${String(rounded)} rows`;
+  const units = [
+    [1e9, "B"],
+    [1e6, "M"],
+    [1000, "K"]
+  ];
+  for (const [unit, suffix] of units) {
+    if (rounded < unit)
+      continue;
+    const scaled = rounded / unit;
+    const digits = scaled >= 10 || Number.isInteger(scaled) ? 0 : 1;
+    const text = trimZero(scaled.toFixed(digits));
+    return `about ${text}${suffix} rows`;
+  }
+  return `about ${String(rounded)} rows`;
+}
+function withBatches(step, text, estimates) {
+  const batch = step.backfill?.batch;
+  if (batch === undefined)
+    return text;
+  const name = step.tables?.[0];
+  const estimate = name === undefined ? undefined : estimates.get(name);
+  if (estimate === undefined || estimate.kind !== "rows")
+    return text;
+  return `${text}, about ${String(aboutBatchCount(estimate.reltuples, batch))} batches`;
+}
+function classify(raw) {
+  if (raw === null)
+    return { kind: "unknown" };
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0)
+    return { kind: "unknown" };
+  return { kind: "rows", reltuples: value };
+}
+function estimatePhrase(estimate) {
+  if (estimate === undefined)
+    return "new table";
+  if (estimate.kind === "unknown")
+    return "rows unknown (table not analyzed)";
+  return aboutRows(estimate.reltuples);
+}
+function lockPieces(step) {
+  const segments = step.lock.split("; ").map((part) => part.trim()).filter((part) => part.length > 0);
+  const named = new Map;
+  for (const segment of segments) {
+    const table = lockTable(segment);
+    if (table !== undefined)
+      named.set(table, stripLockTable(segment));
+  }
+  const primary = segments[0] ?? step.lock;
+  const primaryTable = lockTable(primary);
+  const primaryMode = primaryTable === undefined ? primary : stripLockTable(primary);
+  const pieces = [];
+  const seen = new Set;
+  if (primaryTable === undefined) {
+    const lead = (step.tables ?? []).filter((name) => !named.has(name));
+    if (lead.length === 0 && named.size === 0)
+      pieces.push({ mode: step.lock, table: undefined });
+    for (const table of lead) {
+      seen.add(table);
+      pieces.push({ mode: primaryMode, table });
+    }
+  }
+  for (const segment of segments) {
+    const table = lockTable(segment);
+    if (table === undefined) {
+      if (primaryTable !== undefined || pieces.length === 0) {
+        pieces.push({ mode: segment, table: undefined });
+      }
+      continue;
+    }
+    if (seen.has(table))
+      continue;
+    seen.add(table);
+    pieces.push({ mode: stripLockTable(segment), table });
+  }
+  for (const table of step.tables ?? []) {
+    if (seen.has(table))
+      continue;
+    pieces.push({ mode: primaryMode, table });
+  }
+  return pieces;
+}
+function exclusiveOverLarge(pieces, estimates) {
+  for (const piece of pieces) {
+    if (piece.mode !== "ACCESS EXCLUSIVE" || piece.table === undefined)
+      continue;
+    const estimate = estimates.get(piece.table);
+    if (estimate === undefined || estimate.kind !== "rows")
+      continue;
+    if (estimate.reltuples > LARGE_TABLE_ROWS)
+      return true;
+  }
+  return false;
+}
+function lockTable(segment) {
+  const match = /\bon\s+"((?:[^"]|"")*)"\."((?:[^"]|"")*)"/.exec(segment);
+  const name = match?.[2];
+  if (name === undefined)
+    return;
+  return name.replaceAll('""', '"');
+}
+function stripLockTable(segment) {
+  return segment.replace(/\s+on\s+"((?:[^"]|"")*)"\."((?:[^"]|"")*)"/, "").trim();
+}
+function trimZero(text) {
+  return text.endsWith(".0") ? text.slice(0, -2) : text;
+}
+
+// src/tooling/migrate/project.ts
+async function buildProject(cwd) {
+  const config = await loadConfig(cwd);
+  const built = await loadSchema(cwd, config.schema);
+  return writeArtifact(cwd, config, withRoles(built, config));
+}
+async function generateProject(cwd, name, flags) {
+  const prepared = await prepare(cwd, name, flags);
+  writeArtifact(cwd, prepared.config, prepared.built);
+  if (prepared.plan.steps.length === 0)
+    return;
+  const directory = join2(cwd, prepared.config.migrations ?? "migrations");
+  mkdirSync(directory, { recursive: true });
+  const base = `${nextNumber(directory)}_${safeName(name)}`;
+  const sqlPath = join2(directory, `${base}.sql`);
+  writeFileSync(sqlPath, formatPlan(prepared.plan));
+  writeFileSync(join2(directory, `${base}.catalog.json`), serializeCatalog2(prepared.built.catalog));
+  return { path: sqlPath, findings: lintPrepared(prepared) };
+}
+async function planProject(cwd, name, flags, invoke) {
+  const prepared = await prepare(cwd, name, flags);
+  return {
+    plan: prepared.plan,
+    findings: lintPrepared(prepared),
+    text: await displayPlan(prepared.config, prepared.plan, invoke)
+  };
+}
+async function checkProject(cwd, flags) {
+  const opened = await openProject(cwd);
+  assertValidation(opened.built);
+  if (schemaRequestsValidation(opened.built) && !projectImportsValidate(cwd)) {
+    const doc = errorDoc("OKM1201");
+    if (doc === undefined)
+      throw new Error("OKM1201 missing from the error registry.");
+    throw new OkmError2(doc.code, doc.summary, { fix: { summary: doc.fix } });
+  }
+  const targets = listTargets(opened.config);
+  assertTargetAlias(targets);
+  if (opened.config.tables !== undefined) {
+    const directory = join2(cwd, opened.config.tables);
+    const files = existsSync2(directory) ? readdirSync2(directory) : [];
+    const source = readFileSync2(join2(cwd, opened.config.schema), "utf8");
+    const missing = unlistedTableFiles(source, files);
+    if (missing.length > 0) {
+      throw new OkmError2("OKM1024", `Table file not in schema: ${missing.join(", ")}.`, {
+        fix: { summary: "Add the file's table to the schema() call that okm check reads." }
+      });
+    }
+  }
+  const findings = lintOpened(opened);
+  if (hasError(findings))
+    throw lintRefusal(findings);
+  const named = flags?.target;
+  if (targets.length === 0)
+    return findings;
+  if (targets.length > 1 && named === undefined)
+    return findings;
+  const target = selectTarget(opened.config, named);
+  assertTargetPolicy(target, "check", flags?.allowProtected ?? false);
+  assertTargetPolicy(target, "drift", flags?.allowProtected ?? false);
+  const { assertAuthorDrift } = await import("./ykv7wh5b.js");
+  await assertAuthorDrift(target.url, opened.built.catalog, opened.config.roles);
+  return findings;
+}
+function unlistedTableFiles(schemaSource, fileNames) {
+  const missing = [];
+  for (const file of fileNames) {
+    if (!file.endsWith(".ts"))
+      continue;
+    const stem = basename(file, ".ts");
+    if (stem.length === 0 || stem.startsWith("."))
+      continue;
+    if (!schemaSource.includes(stem))
+      missing.push(file);
+  }
+  return missing;
+}
+async function projectHead(cwd) {
+  const opened = await openProject(cwd);
+  return { previous: opened.previous, catalog: opened.built.catalog, renames: opened.renames };
+}
+async function prepare(cwd, name, flags) {
+  const opened = await openProject(cwd);
+  const plan = planMigration({
+    before: opened.previous,
+    after: opened.built.catalog,
+    renames: opened.renames,
+    replacements: flags.map((flag) => parseReplace(flag)),
+    name,
+    ...batchSizeField(opened.config.backfill?.batchSize)
+  });
+  return {
+    config: opened.config,
+    built: opened.built,
+    plan,
+    before: opened.previous,
+    after: opened.built.catalog
+  };
+}
+function lintPrepared(prepared) {
+  return lintPlan(prepared.plan, prepared.before, prepared.after);
+}
+async function displayPlan(config, plan, invoke) {
+  const offline = formatPlan(plan);
+  const targets = listTargets(config);
+  if (targets.length === 0)
+    return offline;
+  assertTargetAlias(targets);
+  const named = invoke?.target;
+  if (named === undefined && targets.length !== 1)
+    return offline;
+  const target = selectTarget(config, named);
+  assertTargetPolicy(target, "plan", invoke?.allowProtected ?? false);
+  let estimates;
+  try {
+    const names = plan.steps.flatMap((step) => step.tables ?? []);
+    estimates = await readRowEstimates(target.url, "public", names);
+  } catch {
+    return offline;
+  }
+  return formatPlan(plan, (step) => annotateLock(step, estimates));
+}
+function lintOpened(opened) {
+  const plan = planMigration({
+    before: opened.previous,
+    after: opened.built.catalog,
+    renames: opened.renames,
+    name: "check",
+    ...batchSizeField(opened.config.backfill?.batchSize)
+  });
+  return [
+    ...lintPlan(plan, opened.previous, opened.built.catalog),
+    ...lintCatalog(opened.built.catalog)
+  ];
+}
+async function openProject(cwd) {
+  const config = await loadConfig(cwd);
+  const built = withRoles(await loadSchema(cwd, config.schema), config);
+  const declarations = schemaDeclarations(built);
+  const previous = readPrevious(join2(cwd, config.migrations ?? "migrations"));
+  const stale = staleRenames(previous?.catalog, declarations.renames);
+  if (stale.length > 0) {
+    throw new OkmError2("OKM1020", stale.join(" "), {
+      fix: { summary: "Remove renamedFrom once the migration that used it has been applied." }
+    });
+  }
+  return {
+    config,
+    built,
+    previous: previous?.catalog ?? catalog([]),
+    renames: declarations.renames
+  };
+}
+function withRoles(built, config) {
+  if (config.roles === undefined)
+    return built;
+  return { ...built, catalog: attachRoles(built.catalog, config.roles) };
+}
+function writeArtifact(cwd, config, built) {
+  const directory = join2(cwd, config.out ?? ".okm");
+  mkdirSync(directory, { recursive: true });
+  const startup = startupCatalog2(built.catalog);
+  writeFileSync(join2(directory, "catalog.json"), serializeCatalog2(startup));
+  writeFileSync(join2(directory, "catalog.hash"), `${catalogHash2(startup)}
+`);
+  writeFileSync(join2(directory, "types.d.ts"), `${emitRowTypes(built)}${referenceAugmentation(built)}`);
+  return directory;
+}
+async function loadBuiltSchema(cwd, config) {
+  return withRoles(await loadSchema(cwd, config.schema), config);
+}
+async function loadConfig(cwd) {
+  const path = join2(cwd, "okmodel.config.ts");
+  const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
+  const record = isRecord(imported) ? imported : {};
+  const config = record.default ?? record.config;
+  if (!isConfig(config)) {
+    throw new OkmError2("invalid", "okmodel.config.ts must default-export defineConfig(...).");
+  }
+  return config;
+}
+async function loadSchema(cwd, spec) {
+  const path = join2(cwd, spec);
+  const imported = await import(`${pathToFileURL(path).href}?okm=${Date.now()}`);
+  const record = isRecord(imported) ? imported : {};
+  for (const value of Object.values(record)) {
+    if (!isBuilt(value))
+      continue;
+    value.catalog;
+    return value;
+  }
+  throw new OkmError2("invalid", `${spec} must export a schema().`);
+}
+function readPrevious(directory) {
+  if (!existsSync2(directory))
+    return;
+  const catalogs = readdirSync2(directory).filter((file) => file.endsWith(".catalog.json")).sort();
+  const latest = catalogs.at(-1);
+  if (latest === undefined)
+    return;
+  const text = readFileSync2(join2(directory, latest), "utf8");
+  return { catalog: parseCatalog2(text) };
+}
+function referenceAugmentation(source) {
+  const names = source.tables.map((item) => JSON.stringify(item.name));
+  const union = names.length === 0 ? "never" : names.join(" | ");
+  return [
+    'import type { ColumnFlags, ReferenceOptions } from "okmodel/pg";',
+    "",
+    'declare module "okmodel/pg" {',
+    "  interface ColumnBuilder<TValue, TFlags extends ColumnFlags> {",
+    "    references(",
+    `      table: ${union},`,
+    "      options?: ReferenceOptions,",
+    "    ): ColumnBuilder<TValue, TFlags>;",
+    "  }",
+    "}",
+    "",
+    `export type TableName = ${union};`,
+    ""
+  ].join(`
+`);
+}
+function nextNumber(directory) {
+  let max = 0;
+  if (existsSync2(directory)) {
+    for (const file of readdirSync2(directory)) {
+      const match = /^(\d+)_/.exec(file);
+      const value = match?.[1];
+      if (value !== undefined)
+        max = Math.max(max, Number(value));
+    }
+  }
+  return String(max + 1).padStart(4, "0");
+}
+function safeName(name) {
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+    throw new OkmError2("invalid", `Migration name ${name} must be letters, digits, _ or -.`);
+  }
+  return name;
+}
+function isBuilt(value) {
+  if (!isRecord(value) || !Array.isArray(value.tables))
+    return false;
+  return "catalog" in value;
+}
+function isConfig(value) {
+  return isRecord(value) && typeof value.schema === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+var SKIP_SCAN = new Set(["node_modules", "dist", "coverage"]);
+function schemaRequestsValidation(built) {
+  const flag = built.validation;
+  for (const item of built.tables) {
+    if (writeWouldValidate(flag, item, {}))
+      return true;
+  }
+  return false;
+}
+function projectImportsValidate(cwd) {
+  return directoryImportsValidate(cwd);
+}
+function directoryImportsValidate(dir) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || SKIP_SCAN.has(entry.name))
+      continue;
+    const path = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (directoryImportsValidate(path))
+        return true;
+      continue;
+    }
+    if (!/\.(?:ts|tsx|mts|cts)$/.test(entry.name))
+      continue;
+    if (runtimeImportsValidate(readFileSync2(path, "utf8")))
+      return true;
+  }
+  return false;
+}
+function runtimeImportsValidate(source) {
+  const text = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+  const pattern = /["']okmodel\/validate(?:\.js)?["']/g;
+  for (const match of text.matchAll(pattern)) {
+    const index = match.index ?? 0;
+    const lead = text.slice(Math.max(0, index - 240), index);
+    const start = Math.max(lead.lastIndexOf(`
+`), lead.lastIndexOf(";"));
+    const head = lead.slice(start + 1);
+    if (/\bimport\s+type\b/.test(head) || /\bexport\s+type\b/.test(head))
+      continue;
+    if (/\bimport\b/.test(head) || /\bexport\b/.test(head))
+      return true;
+  }
+  return false;
+}
+
+export { errorDoc, lintMigrationDirectory, formatFindings, hasError, lintRefusal, assertTargetPolicy, assertDirectConnection, listTargets, selectTarget, buildProject, generateProject, planProject, checkProject, projectHead, openProject, loadBuiltSchema, loadConfig, loadSchema };