@sequenceholdings/orm 2.11.0 → 2.11.1

package/dist/index.cjs

@@ -4967,6 +4967,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 = crypto.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"];
@@ -5143,6 +5286,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
@@ -6225,11 +6404,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)}`
           );
@@ -6322,7 +6503,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);
@@ -7074,52 +7255,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 = zod.z.string().regex(/^sha256:[0-9a-f]{64}$/);
-var ormMigrationPayloadSchema = zod.z.object({
-  canonical_definition: canonicalDefinitionSchema,
-  documents: zod.z.array(zod.z.object({ path: zod.z.string().min(1).max(2048), contents: zod.z.string().max(1e6) }).strict()).max(5e3),
-  client_manifest: zod.z.object({ ops_hash: hash, operations: zod.z.record(zod.z.string(), hash) }).strict(),
-  sdl: zod.z.string().refine((value) => Buffer.byteLength(value, "utf8") <= MAX_GENERATED_SDL_BYTES, {
-    message: `sdl exceeds ${MAX_GENERATED_SDL_BYTES} bytes`
-  }),
-  schema_snapshot: zod.z.json(),
-  // The existing ORM committed-migration validator and replay engine remain
-  // authoritative. This envelope hashes the provenance, never authorizes SQL.
-  migration: zod.z.json().optional()
-}).strict();
-var ormMigrationExportSchema = zod.z.object({
-  schema_version: zod.z.literal(1),
-  schema_hash: hash,
-  payload: ormMigrationPayloadSchema,
-  checksum: zod.z.string().regex(/^[0-9a-f]{64}$/)
-}).strict();
-function checksum(value) {
-  return crypto.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;
@@ -7155,9 +7290,9 @@ var EXTERNAL_POLICY_CLAIM_KEYS = ["ext_subject", "ext_email"];
 function isExternalPolicyClaimKey(key) {
   return EXTERNAL_POLICY_CLAIM_KEYS.includes(key);
 }
-var scalarLiteral = zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]);
+var scalarLiteral2 = zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]);
 var valueIrSchema = zod.z.discriminatedUnion("kind", [
-  zod.z.object({ kind: zod.z.literal("literal"), value: zod.z.union([scalarLiteral, zod.z.array(scalarLiteral)]) }),
+  zod.z.object({ kind: zod.z.literal("literal"), value: zod.z.union([scalarLiteral2, zod.z.array(scalarLiteral2)]) }),
   zod.z.object({ kind: zod.z.literal("variable"), name: zod.z.string() }),
   zod.z.object({ kind: zod.z.literal("claim"), key: zod.z.enum(["sub", "org", ...EXTERNAL_POLICY_CLAIM_KEYS]) })
 ]);
@@ -7404,7 +7539,7 @@ var INPUT_REF_KINDS = [
   "onConflict"
 ];
 var variableDefaultIrSchema = zod.z.object({
-  value: zod.z.union([scalarLiteral, zod.z.array(scalarLiteral)])
+  value: zod.z.union([scalarLiteral2, zod.z.array(scalarLiteral2)])
 });
 var variableIrSchema = zod.z.object({
   name: zod.z.string(),
@@ -7447,8 +7582,7 @@ var compiledOperationSchema = zod.z.object({
     maxRows: zod.z.number().int().min(1).max(1e4)
   }).strict().optional(),
   irVersion: irVersionSchema,
-  name: zod.z.string(),
-  opHash: zod.z.string().regex(/^sha256:[0-9a-f]{64}$/),
+  name: zod.z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: zod.z.enum(["query", "mutation"]),
   requires: zod.z.object({
     capability: zod.z.string().optional(),
@@ -7464,7 +7598,7 @@ var compiledOperationSchema = zod.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" });
     }
@@ -7479,7 +7613,7 @@ var compiledOperationSchema = zod.z.object({
   }
 });
 var resolvedSourceIrSchema = zod.z.object({
-  name: zod.z.string(),
+  name: zod.z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: zod.z.enum(["manual", "etl", "prefetch"]),
   /** Logical table key of the backing relation. */
   table: zod.z.string(),
@@ -7593,7 +7727,6 @@ var compiledArtifactSchema = zod.z.object({
   ownSchemaHash: zod.z.string().optional(),
   dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
   readPolicies: zod.z.record(zod.z.string(), predIrSchema).optional(),
-  opsHash: zod.z.string(),
   /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
   unbackedTables: zod.z.array(zod.z.string()).optional(),
   tables: zod.z.record(zod.z.string(), tableMetaIrSchema),
@@ -7623,11 +7756,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 = zod.z.string().regex(/^sha256:[0-9a-f]{64}$/);
+var ormMigrationPayloadSchema = zod.z.object({
+  canonical_definition: canonicalDefinitionSchema,
+  documents: zod.z.array(zod.z.object({ path: zod.z.string().min(1).max(2048), contents: zod.z.string().max(1e6) }).strict()).max(5e3),
+  client_manifest: zod.z.object({ operations: zod.z.record(zod.z.string(), compiledOperationSchema) }).strict(),
+  sdl: zod.z.string().refine((value) => Buffer.byteLength(value, "utf8") <= MAX_GENERATED_SDL_BYTES, {
+    message: `sdl exceeds ${MAX_GENERATED_SDL_BYTES} bytes`
+  }),
+  schema_snapshot: zod.z.json(),
+  // The existing ORM committed-migration validator and replay engine remain
+  // authoritative. This envelope hashes the provenance, never authorizes SQL.
+  migration: zod.z.json().optional()
+}).strict();
+var ormMigrationExportSchema = zod.z.object({
+  schema_version: zod.z.literal(1),
+  schema_hash: hash,
+  payload: ormMigrationPayloadSchema,
+  checksum: zod.z.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+function checksum(value) {
+  return crypto.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: [] };
@@ -8358,132 +8532,6 @@ var importSpecSchema = zod.z.object({
   onConflict: zod.z.enum(IMPORT_CONFLICT_MODES).default("skip"),
   batchSize: zod.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 = crypto.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({
@@ -8947,6 +8995,8 @@ exports.SCHEMA_DIR = SCHEMA_DIR;
 exports.SERVICE_PRINCIPAL_IR_VERSION = SERVICE_PRINCIPAL_IR_VERSION;
 exports.SQL_IR_VERSION = SQL_IR_VERSION;
 exports.STATEMENT_KINDS = STATEMENT_KINDS;
+exports.SYNCED_BACKING_ABSENT_FUNCTION = SYNCED_BACKING_ABSENT_FUNCTION;
+exports.SYNCED_BACKING_ABSENT_SQLSTATE = SYNCED_BACKING_ABSENT_SQLSTATE;
 exports.SYNCED_CONTRACT_HASH_DOMAIN = SYNCED_CONTRACT_HASH_DOMAIN;
 exports.SYNCED_SOURCE_PATTERN = SYNCED_SOURCE_PATTERN;
 exports.SYNCED_VIEW_EXECUTION_OWNER_ROLE = SYNCED_VIEW_EXECUTION_OWNER_ROLE;
@@ -9016,6 +9066,8 @@ exports.defineView = defineView;
 exports.deriveColumnName = deriveColumnName;
 exports.diffCommand = diffCommand;
 exports.diffStatements = diffStatements;
+exports.disabledSyncedObjectFromError = disabledSyncedObjectFromError;
+exports.disabledSyncedObjectMessage = disabledSyncedObjectMessage;
 exports.emptyJournal = emptyJournal;
 exports.emptySnapshot = emptySnapshot;
 exports.endAuthoringContext = endAuthoringContext;
@@ -9028,7 +9080,7 @@ exports.generateSnapshotV2 = generateSnapshotV2;
 exports.highest = highest;
 exports.identifierSchema = identifierSchema;
 exports.importSpecSchema = importSpecSchema;
-exports.indexByHash = indexByHash;
+exports.indexByName = indexByName;
 exports.isColumnBuilder = isColumnBuilder;
 exports.isEnumRef = isEnumRef;
 exports.isExternalPolicyClaimKey = isExternalPolicyClaimKey;
@@ -9116,6 +9168,7 @@ exports.syncedIndexStatements = syncedIndexStatements;
 exports.syncedTables = syncedTables;
 exports.syncedViewDropStatements = syncedViewDropStatements;
 exports.syncedViewStatements = syncedViewStatements;
+exports.syncedViewUnbackedStatements = syncedViewUnbackedStatements;
 exports.t = t;
 exports.tableFileSchema = tableFileSchema;
 exports.tableMetaIrSchema = tableMetaIrSchema;