@sequenceholdings/orm 2.11.0 → 2.11.1

package/dist/cli.js

@@ -6,7 +6,7 @@ import { fileURLToPath, pathToFileURL } from 'url';
 import { createJiti } from 'jiti';
 import { createHash } from 'crypto';
 import { z } from 'zod';
-import { buildSchema, parse, validate, Kind, valueFromASTUntyped, visit, print } from 'graphql';
+import { buildSchema, parse, validate, Kind, valueFromASTUntyped, visit } from 'graphql';
 import { PgParser } from '@supabase/pg-parser';
 import { sql } from 'drizzle-orm';
 import { pgSchema, PgDialect, QueryBuilder, getViewConfig, extractUsedTable, check, foreignKey, uniqueIndex, index, primaryKey, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text as text$1, uuid } from 'drizzle-orm/pg-core';
@@ -2290,9 +2290,6 @@ function normalizeCanonical(definition) {
   return normalized;
 }
 
-// src/client/sql.ts
-var BUILTIN_SQL_READ_HASH = "sha256:a50c477c952a5e0fe68ed158a4530e4aab573c09bcbb1a8ac454dc88a39a6258";
-
 // src/ir/index.ts
 var IR_VERSION = 6;
 var LEGACY_IR_VERSION = 1;
@@ -2621,8 +2618,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(),
@@ -2638,7 +2634,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" });
     }
@@ -2653,7 +2649,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(),
@@ -2767,7 +2763,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),
@@ -4434,24 +4429,6 @@ function flattenOperation({
 }) {
   return { ...operation, selectionSet: flattenSelectionSet(operation.selectionSet, fragments, []) };
 }
-var COMPILER_MAJOR = 1;
-var OP_HASH_DOMAIN = "sequence-orm-op\0";
-var OPS_HASH_DOMAIN = "sequence-orm-opset\0";
-function canonicalOperationText(definition) {
-  const document = { kind: Kind.DOCUMENT, definitions: [definition] };
-  return print(document);
-}
-function computeOpHash({
-  definition,
-  schemaHash
-}) {
-  const digest = createHash("sha256").update(OP_HASH_DOMAIN).update(`${COMPILER_MAJOR}\0${schemaHash}\0`).update(canonicalOperationText(definition)).digest("hex");
-  return `sha256:${digest}`;
-}
-function computeOpsHash(opHashes) {
-  const digest = createHash("sha256").update(OPS_HASH_DOMAIN).update([...opHashes].sort().join("\n")).digest("hex");
-  return `sha256:${digest}`;
-}
 var SOURCE_DIRECTIVES = /* @__PURE__ */ new Set(["prefetch", "writeback", "localOnly"]);
 var fail = (message, code) => {
   throw new DocumentCompileError(message, code);
@@ -5947,7 +5924,6 @@ function compileNamespace({ canonical, sdl, documents }) {
         operations[restricted.name] = {
           irVersion: usesServicePrincipal(roots) ? SERVICE_PRINCIPAL_IR_VERSION : canonical.imports?.length ? COMPOSED_IR_VERSION : roots.some((root) => root.kind === "mutation" && root.assertAffectedRows !== void 0) ? GUARDED_IR_VERSION : LEGACY_IR_VERSION,
           name: restricted.name,
-          opHash: computeOpHash({ definition: flattened, schemaHash }),
           kind: restricted.kind,
           requires: restricted.requires,
           variables: restricted.variables,
@@ -5980,7 +5956,6 @@ function compileNamespace({ canonical, sdl, documents }) {
       dependencies: Object.fromEntries(canonical.imports.map((owner) => [owner.namespace, computeSchemaHash(localContract(owner))]))
     } : {},
     readPolicies: Object.fromEntries(ctx.readPolicies),
-    opsHash: computeOpsHash(Object.values(operations).map((op) => op.opHash)),
     tables: ctx.tables,
     operations
   };
@@ -5988,11 +5963,10 @@ function compileNamespace({ canonical, sdl, documents }) {
   const manifest = {
     namespace: ctx.namespace,
     schemaHash,
-    opsHash: normalized.opsHash,
     operations: Object.fromEntries(
       Object.values(normalized.operations).map((op) => [
         op.name,
-        { opHash: op.opHash, kind: op.kind, requires: op.requires }
+        op
       ])
     )
   };
@@ -6174,7 +6148,6 @@ function createSqlCatalog({ canonical, publishedObjects, executionTarget }) {
 }
 function createSqlCatalogFromContext({ canonical, publishedObjects, executionTarget, ctx, identity: suppliedIdentity }) {
   if (!publishedObjects.length || new Set(publishedObjects).size !== publishedObjects.length) throw new Error("SQL objects must be explicitly declared and unique");
-  const identity = suppliedIdentity ?? sqlHash(`ontology-sql-v1\0${computeSchemaHash(canonical)}\0${executionTarget}`);
   const logicalNames = new Map(Object.entries(ctx.tables).map(([key, meta]) => [meta, key]));
   const refOf = (meta) => `${meta.namespace ?? canonical.namespace}/${logicalNames.get(meta)}`;
   const definitions = [canonical, ...canonical.imports ?? []];
@@ -6199,7 +6172,7 @@ function createSqlCatalogFromContext({ canonical, publishedObjects, executionTar
     const scan = `SELECT ${projection} FROM ${quoteIdentifier(meta.schema)}.${quoteIdentifier(meta.table)} AS ${quoteIdentifier("p0")} WHERE ${compileStaticPolicySql({ table: meta, predicate: policy, tables: ctx.tables, namespace: canonical.namespace, alias: "p0", onRead: (target) => reads.add(refOf(target)) })}`;
     return { ref, table: meta.table, columns, scan, read: [...reads].sort() };
   });
-  return { identity, objects };
+  return { identity: suppliedIdentity ?? sqlHash(JSON.stringify(["ontology-sql-catalog-v2", executionTarget, objects])), objects };
 }
 
 // src/sql/ast.ts
@@ -6727,20 +6700,10 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
       const catalog = createSqlCatalog({ canonical: input.canonical, publishedObjects: read, executionTarget: "registered-operation" });
       if ("mode" in definition) {
         if (catalog.objects.some((object) => object.read.some((ref) => !read.includes(ref)))) throw new Error("SQL policy accesses an undeclared ontology object");
-        const opHash2 = sqlHash(JSON.stringify([
-          "sequence-runtime-sql-operation-v1",
-          definition.name,
-          definition.namespace,
-          definition.requires.capability,
-          read,
-          catalog.identity,
-          definition.maxRows
-        ]));
         result.artifact.operations[definition.name] = compiledOperationSchema.parse({
           irVersion: RUNTIME_SQL_IR_VERSION,
           language: "sql",
           name: definition.name,
-          opHash: opHash2,
           kind: "query",
           requires: definition.requires,
           variables: [
@@ -6751,7 +6714,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
           tableSet: read.map((ref) => ref.split("/")[1]).sort(),
           sqlQuery: { catalog, read, maxRows: definition.maxRows }
         });
-        result.manifest.operations[definition.name] = { opHash: opHash2, kind: "query", requires: definition.requires };
+        result.manifest.operations[definition.name] = result.artifact.operations[definition.name];
         continue;
       }
       const names = Object.keys(definition.parameters).sort();
@@ -6769,20 +6732,10 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
         nullable: !definition.parameters[name2].required,
         list: false
       }));
-      const opHash = sqlHash(JSON.stringify([
-        "sequence-sql-operation-v1",
-        definition.name,
-        definition.namespace,
-        definition.requires.capability,
-        read,
-        variables,
-        plan.queryHash
-      ]));
       const operation = compiledOperationSchema.parse({
         irVersion: SQL_IR_VERSION,
         language: "sql",
         name: definition.name,
-        opHash,
         kind: "query",
         requires: definition.requires,
         variables,
@@ -6791,7 +6744,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
         sql: { text: plan.text, columns: plan.columns, parameters: names, read, maxRows: plan.maxRows }
       });
       result.artifact.operations[definition.name] = operation;
-      result.manifest.operations[definition.name] = { opHash, kind: "query", requires: definition.requires };
+      result.manifest.operations[definition.name] = result.artifact.operations[definition.name];
     } catch (error) {
       return { ok: false, diagnostics: [...result.diagnostics, {
         severity: "error",
@@ -6803,8 +6756,6 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
   }
   const required = requiredArtifactIrVersion(Object.values(result.artifact.operations));
   if (required > result.artifact.irVersion) result.artifact.irVersion = required;
-  result.artifact.opsHash = computeOpsHash(Object.values(result.artifact.operations).map((op) => op.opHash));
-  result.manifest.opsHash = result.artifact.opsHash;
   return { ...result, artifact: normalizeIr(result.artifact) };
 }
 async function managedViewDiagnostics(canonical) {
@@ -7665,7 +7616,7 @@ var manifestOperationSchema = z.object({
   requires: manifestRequiresSchema
 });
 var operationsManifestSchema = z.object({
-  manifestVersion: z.union([z.literal(1), z.literal(MANIFEST_VERSION)]),
+  manifestVersion: z.literal(MANIFEST_VERSION),
   operations: z.record(z.string().regex(GRAPHQL_NAME_RE), manifestOperationSchema)
 });
 function buildOperationsManifest({
@@ -8632,6 +8583,132 @@ function compilePredicate(predicate, columnTypes, options = {}) {
       return `(${options.statementClaimChecks ? "SELECT " : ""}${capabilityExpression(predicate.key)})`;
   }
 }
+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 typeName2 = columnPostgresType(column, schemaName, enums);
+    return { ok: true, sql: `${quoteLiteral(value)}::${typeName2}` };
+  }
+  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/engine/security.ts
 var CONSUMER_TABLE_PRIVILEGES = ["SELECT", "INSERT", "UPDATE", "DELETE"];
@@ -9448,11 +9525,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 ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamedFrom)} TO ${quoteIdentifier(name2)}`
           );
@@ -9545,7 +9624,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);
@@ -10775,7 +10854,7 @@ 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(),
+  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`
   }),
@@ -10874,132 +10953,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 typeName2 = columnPostgresType(column, schemaName, enums);
-    return { ok: true, sql: `${quoteLiteral(value)}::${typeName2}` };
-  }
-  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({
@@ -11513,7 +11466,7 @@ var USAGE = `usage:
   seq-studio orm generate [dir] --migration-export [--check]
                                         export reviewed ORM inputs for a coordinated pipeline migration; --check verifies without writing
   seq-studio orm validate [dir]          parse + validate definitions and verify committed migrations are in sync
-  seq-studio orm plan [dir] -e <env>     offline dry run: compile definitions and diff against the registry (no database, no writes)
+  seq-studio orm plan [dir] -e <env>     preview fresh-schema DDL and compare registry versions (no live migration diff, no writes)
   seq-studio orm apply [dir] -e <env>    author the migration, register, apply, and refresh the generated outputs (the everyday command)
   seq-studio orm apply --dry-run -e <env>  rehearse the migration on a copy of the environment's real data, then discard it (no real apply)
   seq-studio orm apply --no-create -e <env>  apply only if the namespace is already registered (CI guard; never provisions a new namespace)
@@ -11799,7 +11752,7 @@ async function generateCommand(rest) {
       canonical_definition: loaded2.canonical,
       documents,
       sdl,
-      client_manifest: { ops_hash: manifest2.opsHash, operations: Object.fromEntries(Object.entries(manifest2.operations).map(([name2, operation]) => [name2, operation.opHash])) },
+      client_manifest: { operations: manifest2.operations },
       schema_snapshot: workspace.tipSnapshot,
       ...migration ? { migration } : {}
     } });
@@ -12246,8 +12199,7 @@ async function applyV2Command(rest, dir) {
     canonical_definition: loaded.canonical,
     documents,
     client_manifest: {
-      ops_hash: manifest.opsHash,
-      operations: Object.fromEntries(Object.entries(manifest.operations).map(([name2, op]) => [name2, op.opHash]))
+      operations: manifest.operations
     },
     sdl,
     ...workspace.tipSnapshot !== void 0 ? { schema_snapshot: workspace.tipSnapshot } : {},
@@ -12257,7 +12209,7 @@ async function applyV2Command(rest, dir) {
     ...noCreate ? { no_create: true } : {}
   });
   console.log(
-    (registered.created ? `registered ${namespace}@${registered.content_hash.slice(0, 12)}` : `already registered ${namespace}@${registered.content_hash.slice(0, 12)}`) + (registered.ops_hash ? ` (ops ${registered.ops_hash.slice(0, 19)})` : "") + (migration ? ` with committed migration ${migration.name}` : "")
+    (registered.created ? `registered ${namespace}@${registered.content_hash.slice(0, 12)}` : `already registered ${namespace}@${registered.content_hash.slice(0, 12)}`) + (migration ? ` with committed migration ${migration.name}` : "")
   );
   if (dryRun) return dryRunRehearsal({ namespace, versionId: registered.version_id, contentHash: registered.content_hash });
   const registry = await fetchRegistryState(namespace, registered.content_hash);