@sequenceholdings/orm 2.11.0 → 2.11.1

package/dist/index.js

@@ -4965,6 +4965,149 @@ function compileStaticPolicySql({ table, predicate, tables, namespace, alias, ro
   });
   return render(table, predicate, alias, rootRelation);
 }
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var TIMESTAMPTZ_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+var INTEGER_RE = /^-?\d+$/;
+var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
+function sourceSchemaAllowed(schema) {
+  return schema !== "information_schema" && !schema.startsWith("pg_");
+}
+function isRelationIdentifier(value) {
+  return value.length <= 63 && IDENTIFIER_PATTERN.test(value);
+}
+function isSourceColumn(value) {
+  return value.length <= 63 && COLUMN_IDENTIFIER_PATTERN.test(value);
+}
+function splitQualifiedRelation(from) {
+  const dot = from.indexOf(".");
+  if (dot <= 0 || dot !== from.lastIndexOf(".")) return null;
+  const schema = from.slice(0, dot);
+  const table = from.slice(dot + 1);
+  if (!isRelationIdentifier(schema) || !isRelationIdentifier(table)) return null;
+  return { schema, table };
+}
+function postgresTypeName(type) {
+  if (type === "double") return "double precision";
+  if (type === "timestamptz") return "timestamp with time zone";
+  return type;
+}
+function columnPostgresType(column, schemaName, enums) {
+  if (typeof column.type === "string") return postgresTypeName(column.type);
+  if (!enums.has(column.type.enum)) return null;
+  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(column.type.enum)}`;
+}
+function quoteQualified(schema, table) {
+  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+}
+var INT4_MIN = -2147483648;
+var INT4_MAX = 2147483647;
+function resumeLiteralSql({
+  column,
+  after,
+  schemaName,
+  enums
+}) {
+  const coerced = coerceResumeValue(column, after);
+  if (!coerced.ok) return coerced;
+  return literalSql({ column, value: coerced.value, schemaName, enums });
+}
+function coerceResumeValue(column, after) {
+  const type = typeof column.type === "string" ? column.type : null;
+  if (type === "integer") {
+    if (!INTEGER_RE.test(after)) return { ok: false, error: `${column.name}: after must be an integer` };
+    const parsed = Number(after);
+    if (!Number.isSafeInteger(parsed) || parsed < INT4_MIN || parsed > INT4_MAX) {
+      return { ok: false, error: `${column.name}: after must be an integer` };
+    }
+    return { ok: true, value: parsed };
+  }
+  if (type === "boolean") {
+    if (after !== "true" && after !== "false") return { ok: false, error: `${column.name}: after must be true or false` };
+    return { ok: true, value: after === "true" };
+  }
+  return { ok: true, value: after };
+}
+function literalSql({
+  column,
+  value,
+  schemaName,
+  enums
+}) {
+  const label = column.name;
+  if (typeof value === "string" && value.includes("\0")) {
+    return { ok: false, error: `${label}: null default contains a NUL character` };
+  }
+  if (typeof column.type !== "string") {
+    const enumDef = enums.get(column.type.enum);
+    if (!enumDef) return { ok: false, error: `${label}: enum '${column.type.enum}' is not declared` };
+    if (typeof value !== "string" || !enumDef.values.includes(value)) {
+      return { ok: false, error: `${label}: null default must be one of ${enumDef.values.join(", ")}` };
+    }
+    const typeName = columnPostgresType(column, schemaName, enums);
+    return { ok: true, sql: `${quoteLiteral(value)}::${typeName}` };
+  }
+  return scalarLiteral({ column, type: column.type, value, label });
+}
+var SCALAR_LITERALS = {
+  text: (value, label) => typeof value === "string" ? { ok: true, sql: quoteLiteral(value) } : { ok: false, error: `${label}: null default must be a string` },
+  uuid: (value, label) => typeof value === "string" && UUID_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::uuid` } : { ok: false, error: `${label}: null default must be a UUID` },
+  boolean: (value, label) => typeof value === "boolean" ? { ok: true, sql: value ? "TRUE" : "FALSE" } : { ok: false, error: `${label}: null default must be true or false` },
+  integer: (value, label) => typeof value === "number" && Number.isSafeInteger(value) ? { ok: true, sql: String(value) } : { ok: false, error: `${label}: null default must be an integer` },
+  bigint: (value, label) => typeof value === "string" && INTEGER_RE.test(value) ? { ok: true, sql: `${value}::bigint` } : { ok: false, error: `${label}: null default must be a base-10 integer string` },
+  numeric: numericLiteral,
+  double: numericLiteral,
+  date: (value, label) => typeof value === "string" && DATE_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::date` } : { ok: false, error: `${label}: null default must be a YYYY-MM-DD date` },
+  timestamptz: (value, label) => typeof value === "string" && TIMESTAMPTZ_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::${postgresTypeName("timestamptz")}` } : { ok: false, error: `${label}: null default must be an ISO-8601 timestamp` },
+  jsonb: jsonbLiteral
+};
+function numericLiteral(value, label) {
+  if (typeof value === "number" && Number.isFinite(value)) return { ok: true, sql: String(value) };
+  if (typeof value === "string" && NUMERIC_RE.test(value)) return { ok: true, sql: value };
+  return { ok: false, error: `${label}: null default must be a finite number` };
+}
+function scalarLiteral({
+  column,
+  type,
+  value,
+  label
+}) {
+  const encode = SCALAR_LITERALS[type];
+  if (!encode) return { ok: false, error: `${column.name}: unsupported type '${type}'` };
+  return encode(value, label);
+}
+function jsonbLiteral(value, label) {
+  if (typeof value !== "string") return { ok: false, error: `${label}: null default must be a JSON string` };
+  try {
+    JSON.parse(value);
+  } catch {
+    return { ok: false, error: `${label}: null default must be valid JSON` };
+  }
+  return { ok: true, sql: `${quoteLiteral(value)}::jsonb` };
+}
+function dollarQuote(body) {
+  const digest = createHash("sha256").update(body).digest("hex");
+  const candidates = ["seq_orm_import", `seq_orm_${digest.slice(0, 16)}`, `seq_orm_${digest}`];
+  const tag = candidates.find((candidate) => !body.includes(`$${candidate}$`)) ?? `seq_orm_${digest}_body`;
+  return `$${tag}$${body}$${tag}$`;
+}
+
+// src/engine/synced-backing-absent.ts
+var SYNCED_BACKING_ABSENT_FUNCTION = "orm_synced_backing_absent";
+var SYNCED_BACKING_ABSENT_SQLSTATE = "55000";
+var REASON = "is disabled in this environment: its synced pipeline is not deployed here";
+var SYNCED_BACKING_ABSENT_RAISE = `RAISE EXCEPTION 'ORM object % ${REASON}', object
+    USING ERRCODE = '${SYNCED_BACKING_ABSENT_SQLSTATE}';`;
+var RAISED = new RegExp(`^ORM object ([a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*) ${REASON}`);
+function disabledSyncedObjectFromError(error) {
+  if (error === null || typeof error !== "object") return null;
+  const { code, message } = error;
+  if (code !== SYNCED_BACKING_ABSENT_SQLSTATE || typeof message !== "string") return null;
+  return RAISED.exec(message)?.[1] ?? null;
+}
+function disabledSyncedObjectMessage(object) {
+  return `${object} ${REASON}`;
+}
 
 // src/engine/security.ts
 var CONSUMER_TABLE_PRIVILEGES = ["SELECT", "INSERT", "UPDATE", "DELETE"];
@@ -5141,6 +5284,42 @@ function splitPhysicalRelation(physicalRelation) {
     `synced view physical relation must be "table" or "schema.table" (got "${physicalRelation}")`
   );
 }
+function syncedViewUnbackedStatements({
+  definition,
+  tables,
+  columnTypesByTable
+}) {
+  if (tables.length === 0) return [];
+  const schema = quoteIdentifier(ormSchemaName(definition.namespace));
+  const role = quoteIdentifier(consumerRoleName(definition.namespace));
+  const guard = `${schema}.${quoteIdentifier(SYNCED_BACKING_ABSENT_FUNCTION)}`;
+  const wanted = new Set(tables);
+  const statements = [
+    `CREATE OR REPLACE FUNCTION ${guard}(object text, typed anyelement) RETURNS anyelement LANGUAGE plpgsql VOLATILE AS ${quoteLiteral(`BEGIN
+  ${SYNCED_BACKING_ABSENT_RAISE}
+END`)}`
+  ];
+  for (const table of syncedTables(definition)) {
+    if (!wanted.has(table.table)) continue;
+    const columns = Object.entries(table.columns ?? {});
+    if (columns.length === 0) {
+      throw new OrmDefinitionError(`synced table "${table.table}" needs declared columns to be disabled while its backing is absent`);
+    }
+    const object = quoteLiteral(`${definition.namespace}.${table.table}`);
+    const canonicalTypes = columnTypesByTable?.get(table.table);
+    const projection = columns.map(([name2, column]) => {
+      const declared = canonicalTypes?.[name2];
+      const sqlType = typeof declared === "object" ? `${schema}.${quoteIdentifier(declared.enum)}` : postgresTypeName(column.type);
+      return `${guard}(${object}, NULL::${sqlType}) AS ${quoteIdentifier(name2)}`;
+    }).join(", ");
+    const viewName = `${schema}.${quoteIdentifier(table.table)}`;
+    statements.push(
+      `CREATE OR REPLACE VIEW ${viewName} AS SELECT ${projection} WHERE ${guard}(${object}, true)`,
+      `GRANT SELECT ON ${viewName} TO ${role}`
+    );
+  }
+  return statements;
+}
 function syncedViewDropStatements({
   schemaName,
   tables
@@ -6223,11 +6402,13 @@ function applyMigrationHintsV2(previous, definition) {
       if (column.renamedFrom) {
         const previousColumn = snapshotTable.columns[column.renamedFrom];
         if (previousColumn && snapshotTable.columns[name2]) {
-          throw new OrmDefinitionError(
-            `'${table.table}.${name2}' declares renamedFrom '${column.renamedFrom}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
-          );
-        }
-        if (previousColumn) {
+          const reused = table.columns.some((candidate) => candidate.columnName === column.renamedFrom);
+          if (!reused) {
+            throw new OrmDefinitionError(
+              `'${table.table}.${name2}' declares renamedFrom '${column.renamedFrom}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
+            );
+          }
+        } else if (previousColumn) {
           statements.push(
             `ALTER TABLE ${qualified2(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamedFrom)} TO ${quoteIdentifier(name2)}`
           );
@@ -6320,7 +6501,7 @@ async function planWithViewRecreation({
   const schema = ormSchemaName(canonical.namespace);
   const previous = previousSnapshot ? normalizeSnapshot(previousSnapshot) : emptySnapshot(canonical.namespace);
   assertValidViewDependencies(canonical);
-  const hints = applyMigrationHintsV2(previous, canonical);
+  const hints = previousSnapshot === void 0 ? { statements: [], adjusted: previous } : applyMigrationHintsV2(previous, canonical);
   const snapshot = generateSnapshotV2(canonical, previousId(previous));
   const generatedBaseDdl = await diffStatements(withoutViews(hints.adjusted), withoutViews(snapshot));
   const baseDdl = orderForeignKeyAdditions(canonical, generatedBaseDdl);
@@ -7072,52 +7253,6 @@ async function planMigration({
 }
 var compileNamespace = (definition) => planMigration({ definition });
 var previousId2 = (snapshot) => snapshot.id;
-var ORM_MIGRATION_EXPORT_FILE = "orm.migration.json";
-var ORM_MIGRATION_EXPORT_MAX_BYTES = ORM_REGISTRATION_MAX_BYTES;
-var hash = z.string().regex(/^sha256:[0-9a-f]{64}$/);
-var ormMigrationPayloadSchema = z.object({
-  canonical_definition: canonicalDefinitionSchema,
-  documents: z.array(z.object({ path: z.string().min(1).max(2048), contents: z.string().max(1e6) }).strict()).max(5e3),
-  client_manifest: z.object({ ops_hash: hash, operations: z.record(z.string(), hash) }).strict(),
-  sdl: z.string().refine((value) => Buffer.byteLength(value, "utf8") <= MAX_GENERATED_SDL_BYTES, {
-    message: `sdl exceeds ${MAX_GENERATED_SDL_BYTES} bytes`
-  }),
-  schema_snapshot: z.json(),
-  // The existing ORM committed-migration validator and replay engine remain
-  // authoritative. This envelope hashes the provenance, never authorizes SQL.
-  migration: z.json().optional()
-}).strict();
-var ormMigrationExportSchema = z.object({
-  schema_version: z.literal(1),
-  schema_hash: hash,
-  payload: ormMigrationPayloadSchema,
-  checksum: z.string().regex(/^[0-9a-f]{64}$/)
-}).strict();
-function checksum(value) {
-  return createHash("sha256").update(stableJson(value)).digest("hex");
-}
-function createOrmMigrationExport({ schemaHash, payload }) {
-  const contents = { schema_version: 1, schema_hash: hash.parse(schemaHash), payload: ormMigrationPayloadSchema.parse(payload) };
-  return { ...contents, checksum: checksum(contents) };
-}
-function parseOrmMigrationExport(text4) {
-  if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
-  const exported = ormMigrationExportSchema.parse(JSON.parse(text4));
-  const { checksum: expected, ...contents } = exported;
-  if (checksum(contents) !== expected) throw new Error("ORM migration export checksum mismatch; regenerate and commit it");
-  return exported;
-}
-function renderOrmMigrationExport(exported) {
-  const text4 = `${JSON.stringify(exported, null, 2)}
-`;
-  if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
-  return text4;
-}
-
-// src/client/sql.ts
-var BUILTIN_SQL_READ_HASH = "sha256:a50c477c952a5e0fe68ed158a4530e4aab573c09bcbb1a8ac454dc88a39a6258";
-
-// src/ir/index.ts
 var IR_VERSION = 6;
 var LEGACY_IR_VERSION = 1;
 var GUARDED_IR_VERSION = 2;
@@ -7153,9 +7288,9 @@ var EXTERNAL_POLICY_CLAIM_KEYS = ["ext_subject", "ext_email"];
 function isExternalPolicyClaimKey(key) {
   return EXTERNAL_POLICY_CLAIM_KEYS.includes(key);
 }
-var scalarLiteral = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+var scalarLiteral2 = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 var valueIrSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("literal"), value: z.union([scalarLiteral, z.array(scalarLiteral)]) }),
+  z.object({ kind: z.literal("literal"), value: z.union([scalarLiteral2, z.array(scalarLiteral2)]) }),
   z.object({ kind: z.literal("variable"), name: z.string() }),
   z.object({ kind: z.literal("claim"), key: z.enum(["sub", "org", ...EXTERNAL_POLICY_CLAIM_KEYS]) })
 ]);
@@ -7402,7 +7537,7 @@ var INPUT_REF_KINDS = [
   "onConflict"
 ];
 var variableDefaultIrSchema = z.object({
-  value: z.union([scalarLiteral, z.array(scalarLiteral)])
+  value: z.union([scalarLiteral2, z.array(scalarLiteral2)])
 });
 var variableIrSchema = z.object({
   name: z.string(),
@@ -7445,8 +7580,7 @@ var compiledOperationSchema = z.object({
     maxRows: z.number().int().min(1).max(1e4)
   }).strict().optional(),
   irVersion: irVersionSchema,
-  name: z.string(),
-  opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+  name: z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: z.enum(["query", "mutation"]),
   requires: z.object({
     capability: z.string().optional(),
@@ -7462,7 +7596,7 @@ var compiledOperationSchema = z.object({
   }
   if (operation.language === "sql") {
     const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
-    const builtin = operation.name === "BuiltinSqlRead" && operation.opHash === BUILTIN_SQL_READ_HASH && operation.requires === null;
+    const builtin = operation.name === "BuiltinSqlRead" && operation.requires === null;
     if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !builtin && !operation.requires?.capability) {
       ctx.addIssue({ code: "custom", message: "SQL operations require a query-only v4 plan or v5 runtime contract, capability, and no GraphQL roots" });
     }
@@ -7477,7 +7611,7 @@ var compiledOperationSchema = z.object({
   }
 });
 var resolvedSourceIrSchema = z.object({
-  name: z.string(),
+  name: z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: z.enum(["manual", "etl", "prefetch"]),
   /** Logical table key of the backing relation. */
   table: z.string(),
@@ -7591,7 +7725,6 @@ var compiledArtifactSchema = z.object({
   ownSchemaHash: z.string().optional(),
   dependencies: z.record(z.string(), z.string()).optional(),
   readPolicies: z.record(z.string(), predIrSchema).optional(),
-  opsHash: z.string(),
   /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
   unbackedTables: z.array(z.string()).optional(),
   tables: z.record(z.string(), tableMetaIrSchema),
@@ -7621,11 +7754,52 @@ function normalizeIr(raw) {
   if (!irVersionSchema.safeParse(version).success) throw new IrVersionError(version);
   return compiledArtifactSchema.parse(raw);
 }
-function indexByHash(artifact) {
+function indexByName(artifact) {
   const map = /* @__PURE__ */ new Map();
-  for (const op of Object.values(artifact.operations)) map.set(op.opHash, op);
+  for (const op of Object.values(artifact.operations)) map.set(op.name, op);
   return map;
 }
+var ORM_MIGRATION_EXPORT_FILE = "orm.migration.json";
+var ORM_MIGRATION_EXPORT_MAX_BYTES = ORM_REGISTRATION_MAX_BYTES;
+var hash = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+var ormMigrationPayloadSchema = z.object({
+  canonical_definition: canonicalDefinitionSchema,
+  documents: z.array(z.object({ path: z.string().min(1).max(2048), contents: z.string().max(1e6) }).strict()).max(5e3),
+  client_manifest: z.object({ operations: z.record(z.string(), compiledOperationSchema) }).strict(),
+  sdl: z.string().refine((value) => Buffer.byteLength(value, "utf8") <= MAX_GENERATED_SDL_BYTES, {
+    message: `sdl exceeds ${MAX_GENERATED_SDL_BYTES} bytes`
+  }),
+  schema_snapshot: z.json(),
+  // The existing ORM committed-migration validator and replay engine remain
+  // authoritative. This envelope hashes the provenance, never authorizes SQL.
+  migration: z.json().optional()
+}).strict();
+var ormMigrationExportSchema = z.object({
+  schema_version: z.literal(1),
+  schema_hash: hash,
+  payload: ormMigrationPayloadSchema,
+  checksum: z.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+function checksum(value) {
+  return createHash("sha256").update(stableJson(value)).digest("hex");
+}
+function createOrmMigrationExport({ schemaHash, payload }) {
+  const contents = { schema_version: 1, schema_hash: hash.parse(schemaHash), payload: ormMigrationPayloadSchema.parse(payload) };
+  return { ...contents, checksum: checksum(contents) };
+}
+function parseOrmMigrationExport(text4) {
+  if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
+  const exported = ormMigrationExportSchema.parse(JSON.parse(text4));
+  const { checksum: expected, ...contents } = exported;
+  if (checksum(contents) !== expected) throw new Error("ORM migration export checksum mismatch; regenerate and commit it");
+  return exported;
+}
+function renderOrmMigrationExport(exported) {
+  const text4 = `${JSON.stringify(exported, null, 2)}
+`;
+  if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
+  return text4;
+}
 
 // src/schema/namespace.ts
 var EMPTY_CAPABILITIES = { roles: { definitions: {}, capabilities: {} }, uses: [] };
@@ -8356,132 +8530,6 @@ var importSpecSchema = z.object({
   onConflict: z.enum(IMPORT_CONFLICT_MODES).default("skip"),
   batchSize: z.number().int().min(1).max(2e4).default(5e3)
 }).strict();
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-var TIMESTAMPTZ_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
-var INTEGER_RE = /^-?\d+$/;
-var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
-function sourceSchemaAllowed(schema) {
-  return schema !== "information_schema" && !schema.startsWith("pg_");
-}
-function isRelationIdentifier(value) {
-  return value.length <= 63 && IDENTIFIER_PATTERN.test(value);
-}
-function isSourceColumn(value) {
-  return value.length <= 63 && COLUMN_IDENTIFIER_PATTERN.test(value);
-}
-function splitQualifiedRelation(from) {
-  const dot = from.indexOf(".");
-  if (dot <= 0 || dot !== from.lastIndexOf(".")) return null;
-  const schema = from.slice(0, dot);
-  const table = from.slice(dot + 1);
-  if (!isRelationIdentifier(schema) || !isRelationIdentifier(table)) return null;
-  return { schema, table };
-}
-function postgresTypeName(type) {
-  if (type === "double") return "double precision";
-  if (type === "timestamptz") return "timestamp with time zone";
-  return type;
-}
-function columnPostgresType(column, schemaName, enums) {
-  if (typeof column.type === "string") return postgresTypeName(column.type);
-  if (!enums.has(column.type.enum)) return null;
-  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(column.type.enum)}`;
-}
-function quoteQualified(schema, table) {
-  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
-}
-var INT4_MIN = -2147483648;
-var INT4_MAX = 2147483647;
-function resumeLiteralSql({
-  column,
-  after,
-  schemaName,
-  enums
-}) {
-  const coerced = coerceResumeValue(column, after);
-  if (!coerced.ok) return coerced;
-  return literalSql({ column, value: coerced.value, schemaName, enums });
-}
-function coerceResumeValue(column, after) {
-  const type = typeof column.type === "string" ? column.type : null;
-  if (type === "integer") {
-    if (!INTEGER_RE.test(after)) return { ok: false, error: `${column.name}: after must be an integer` };
-    const parsed = Number(after);
-    if (!Number.isSafeInteger(parsed) || parsed < INT4_MIN || parsed > INT4_MAX) {
-      return { ok: false, error: `${column.name}: after must be an integer` };
-    }
-    return { ok: true, value: parsed };
-  }
-  if (type === "boolean") {
-    if (after !== "true" && after !== "false") return { ok: false, error: `${column.name}: after must be true or false` };
-    return { ok: true, value: after === "true" };
-  }
-  return { ok: true, value: after };
-}
-function literalSql({
-  column,
-  value,
-  schemaName,
-  enums
-}) {
-  const label = column.name;
-  if (typeof value === "string" && value.includes("\0")) {
-    return { ok: false, error: `${label}: null default contains a NUL character` };
-  }
-  if (typeof column.type !== "string") {
-    const enumDef = enums.get(column.type.enum);
-    if (!enumDef) return { ok: false, error: `${label}: enum '${column.type.enum}' is not declared` };
-    if (typeof value !== "string" || !enumDef.values.includes(value)) {
-      return { ok: false, error: `${label}: null default must be one of ${enumDef.values.join(", ")}` };
-    }
-    const typeName = columnPostgresType(column, schemaName, enums);
-    return { ok: true, sql: `${quoteLiteral(value)}::${typeName}` };
-  }
-  return scalarLiteral2({ column, type: column.type, value, label });
-}
-var SCALAR_LITERALS = {
-  text: (value, label) => typeof value === "string" ? { ok: true, sql: quoteLiteral(value) } : { ok: false, error: `${label}: null default must be a string` },
-  uuid: (value, label) => typeof value === "string" && UUID_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::uuid` } : { ok: false, error: `${label}: null default must be a UUID` },
-  boolean: (value, label) => typeof value === "boolean" ? { ok: true, sql: value ? "TRUE" : "FALSE" } : { ok: false, error: `${label}: null default must be true or false` },
-  integer: (value, label) => typeof value === "number" && Number.isSafeInteger(value) ? { ok: true, sql: String(value) } : { ok: false, error: `${label}: null default must be an integer` },
-  bigint: (value, label) => typeof value === "string" && INTEGER_RE.test(value) ? { ok: true, sql: `${value}::bigint` } : { ok: false, error: `${label}: null default must be a base-10 integer string` },
-  numeric: numericLiteral,
-  double: numericLiteral,
-  date: (value, label) => typeof value === "string" && DATE_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::date` } : { ok: false, error: `${label}: null default must be a YYYY-MM-DD date` },
-  timestamptz: (value, label) => typeof value === "string" && TIMESTAMPTZ_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::${postgresTypeName("timestamptz")}` } : { ok: false, error: `${label}: null default must be an ISO-8601 timestamp` },
-  jsonb: jsonbLiteral
-};
-function numericLiteral(value, label) {
-  if (typeof value === "number" && Number.isFinite(value)) return { ok: true, sql: String(value) };
-  if (typeof value === "string" && NUMERIC_RE.test(value)) return { ok: true, sql: value };
-  return { ok: false, error: `${label}: null default must be a finite number` };
-}
-function scalarLiteral2({
-  column,
-  type,
-  value,
-  label
-}) {
-  const encode = SCALAR_LITERALS[type];
-  if (!encode) return { ok: false, error: `${column.name}: unsupported type '${type}'` };
-  return encode(value, label);
-}
-function jsonbLiteral(value, label) {
-  if (typeof value !== "string") return { ok: false, error: `${label}: null default must be a JSON string` };
-  try {
-    JSON.parse(value);
-  } catch {
-    return { ok: false, error: `${label}: null default must be valid JSON` };
-  }
-  return { ok: true, sql: `${quoteLiteral(value)}::jsonb` };
-}
-function dollarQuote(body) {
-  const digest = createHash("sha256").update(body).digest("hex");
-  const candidates = ["seq_orm_import", `seq_orm_${digest.slice(0, 16)}`, `seq_orm_${digest}`];
-  const tag = candidates.find((candidate) => !body.includes(`$${candidate}$`)) ?? `seq_orm_${digest}_body`;
-  return `$${tag}$${body}$${tag}$`;
-}
 
 // src/import/script.ts
 function renderImportScript({
@@ -8858,6 +8906,6 @@ function resumeArguments({
   return [literal2.sql];
 }
 
-export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CELLS_FIELD, CELL_PARTS, CELL_PART_SUFFIX, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES, COMPARE_OPS, COMPOSED_IR_VERSION, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, EXTERNAL_POLICY_CLAIM_KEYS, GUARDED_IR_VERSION, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, IMPORT_CONFLICT_MODES, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MATERIALIZE_ACTOR, MATERIALIZE_CLAIMS_JSON, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MAX_PERSISTED_READ_ROWS, MAX_TRACKED_COLUMN_NAME, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, OPERATION_DOCUMENTS_FILE, OPERATION_DOCUMENTS_VERSION, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, RUNTIME_SQL_IR_VERSION, SCHEMA_DIR, SERVICE_PRINCIPAL_IR_VERSION, SQL_IR_VERSION, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, assertSyncedViewDefinitionMatches, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, cellColumnName, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, custom, declaredCapabilityKeys, declaredSyncedIndexes, defineEnum, defineNamespace, defineOperation, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, etlSource, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, highest, identifierSchema, importSpecSchema, indexByHash, isColumnBuilder, isEnumRef, isExternalPolicyClaimKey, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, isSyncedIndexStatement, latest, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, lowest, managedFn, manualSource, materializeLockKey, materializedRefreshFunctionName, migrationName, namespaceConfigSchema, namespaceSchema, nonNullFirst, normalizeCanonical, normalizeIr, normalizeSnapshot, objectRef, ontologyContractSchema, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, pendingSyncedIndexStatements, planCommittedMigrationV2, planMigration, planMigrationV2, planTableImport, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, prefetchPlanIrSchema, prefetchSource, priority, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readOntologyContract, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlObjectIrSchema, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedIndexStatements, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, usesServicePrincipal, validateNamespaceCatalog, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
+export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CELLS_FIELD, CELL_PARTS, CELL_PART_SUFFIX, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES, COMPARE_OPS, COMPOSED_IR_VERSION, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, EXTERNAL_POLICY_CLAIM_KEYS, GUARDED_IR_VERSION, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, IMPORT_CONFLICT_MODES, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MATERIALIZE_ACTOR, MATERIALIZE_CLAIMS_JSON, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MAX_PERSISTED_READ_ROWS, MAX_TRACKED_COLUMN_NAME, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, OPERATION_DOCUMENTS_FILE, OPERATION_DOCUMENTS_VERSION, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, RUNTIME_SQL_IR_VERSION, SCHEMA_DIR, SERVICE_PRINCIPAL_IR_VERSION, SQL_IR_VERSION, STATEMENT_KINDS, SYNCED_BACKING_ABSENT_FUNCTION, SYNCED_BACKING_ABSENT_SQLSTATE, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, assertSyncedViewDefinitionMatches, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, cellColumnName, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, custom, declaredCapabilityKeys, declaredSyncedIndexes, defineEnum, defineNamespace, defineOperation, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, disabledSyncedObjectFromError, disabledSyncedObjectMessage, emptyJournal, emptySnapshot, endAuthoringContext, etlSource, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, highest, identifierSchema, importSpecSchema, indexByName, isColumnBuilder, isEnumRef, isExternalPolicyClaimKey, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, isSyncedIndexStatement, latest, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, lowest, managedFn, manualSource, materializeLockKey, materializedRefreshFunctionName, migrationName, namespaceConfigSchema, namespaceSchema, nonNullFirst, normalizeCanonical, normalizeIr, normalizeSnapshot, objectRef, ontologyContractSchema, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, pendingSyncedIndexStatements, planCommittedMigrationV2, planMigration, planMigrationV2, planTableImport, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, prefetchPlanIrSchema, prefetchSource, priority, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readOntologyContract, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlObjectIrSchema, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedIndexStatements, syncedTables, syncedViewDropStatements, syncedViewStatements, syncedViewUnbackedStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, usesServicePrincipal, validateNamespaceCatalog, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map