@prisma-next/family-sql 0.15.0 → 0.16.0-dev.1

package/package.json

@@ -1,35 +1,37 @@
 {
   "name": "@prisma-next/family-sql",
-  "version": "0.15.0",
+  "version": "0.16.0-dev.1",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL family descriptor for Prisma Next",
   "dependencies": {
-    "@prisma-next/contract": "0.15.0",
-    "@prisma-next/emitter": "0.15.0",
-    "@prisma-next/framework-components": "0.15.0",
-    "@prisma-next/migration-tools": "0.15.0",
-    "@prisma-next/operations": "0.15.0",
-    "@prisma-next/sql-contract": "0.15.0",
-    "@prisma-next/sql-contract-emitter": "0.15.0",
-    "@prisma-next/sql-contract-ts": "0.15.0",
-    "@prisma-next/sql-operations": "0.15.0",
-    "@prisma-next/sql-relational-core": "0.15.0",
-    "@prisma-next/sql-runtime": "0.15.0",
-    "@prisma-next/sql-schema-ir": "0.15.0",
-    "@prisma-next/utils": "0.15.0",
-    "arktype": "^2.2.2"
+    "@prisma-next/contract": "0.16.0-dev.1",
+    "@prisma-next/emitter": "0.16.0-dev.1",
+    "@prisma-next/framework-components": "0.16.0-dev.1",
+    "@prisma-next/migration-tools": "0.16.0-dev.1",
+    "@prisma-next/operations": "0.16.0-dev.1",
+    "@prisma-next/sql-contract": "0.16.0-dev.1",
+    "@prisma-next/sql-contract-emitter": "0.16.0-dev.1",
+    "@prisma-next/sql-contract-ts": "0.16.0-dev.1",
+    "@prisma-next/sql-operations": "0.16.0-dev.1",
+    "@prisma-next/sql-relational-core": "0.16.0-dev.1",
+    "@prisma-next/sql-runtime": "0.16.0-dev.1",
+    "@prisma-next/sql-schema-ir": "0.16.0-dev.1",
+    "@prisma-next/utils": "0.16.0-dev.1",
+    "arktype": "^2.2.2",
+    "pluralize": "^8.0.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-postgres": "0.15.0",
-    "@prisma-next/psl-parser": "0.15.0",
-    "@prisma-next/psl-printer": "0.15.0",
-    "@prisma-next/sql-contract-psl": "0.15.0",
-    "@prisma-next/test-utils": "0.15.0",
-    "@prisma-next/tsconfig": "0.15.0",
-    "@prisma-next/tsdown": "0.15.0",
-    "tsdown": "0.22.3",
+    "@prisma-next/driver-postgres": "0.16.0-dev.1",
+    "@prisma-next/psl-parser": "0.16.0-dev.1",
+    "@prisma-next/psl-printer": "0.16.0-dev.1",
+    "@prisma-next/sql-contract-psl": "0.16.0-dev.1",
+    "@prisma-next/test-utils": "0.16.0-dev.1",
+    "@prisma-next/tsconfig": "0.16.0-dev.1",
+    "@prisma-next/tsdown": "0.16.0-dev.1",
+    "@types/pluralize": "^0.0.33",
+    "tsdown": "0.22.8",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
   },

package/src/core/diff/schema-verify.ts

@@ -23,7 +23,7 @@ import type {
   VerifierOutcome,
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
-import { dispositionForCategory } from '@prisma-next/framework-components/control';
+import { dispositionForCategory, issueOutcome } from '@prisma-next/framework-components/control';
 import { isStorageTypeInstance, type SqlStorage } from '@prisma-next/sql-contract/types';
 import { RelationalSchemaNodeKind, type SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
@@ -101,10 +101,10 @@ export function classifySqlDiffIssue(
   issue: SchemaDiffIssue,
   granularityOf: (nodeKind: string) => DiffSubjectGranularity,
 ): VerifierIssueCategory {
-  if (issue.reason === 'not-found') {
+  if (issueOutcome(issue) === 'not-found') {
     return 'declaredMissing';
   }
-  if (issue.reason === 'not-expected') {
+  if (issueOutcome(issue) === 'not-expected') {
     const granularity = classifyDiffSubjectGranularity(issue, granularityOf);
     if (granularity === 'entity' || granularity === 'namespace') {
       return 'extraTopLevelObject';
@@ -173,7 +173,7 @@ export function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdic
   for (const issue of input.issues) {
     if (
       !input.strict &&
-      issue.reason === 'not-expected' &&
+      issueOutcome(issue) === 'not-expected' &&
       isStrictOnlyExtra(issue, input.granularityOf)
     ) {
       continue;
@@ -300,7 +300,7 @@ export function verifySqlSchemaByDiff(
       : undefined;
   return {
     ok,
-    ...(ok ? {} : { code: 'PN-SCHEMA-0001' }),
+    ...(ok ? {} : { code: 'CONTRACT.SCHEMA_VERIFICATION_FAILED' }),
     summary: ok
       ? 'Database schema satisfies contract'
       : `Database schema does not satisfy contract (${failCount} failure${failCount === 1 ? '' : 's'})`,

package/src/core/diff/verifier-disposition.ts

@@ -4,7 +4,7 @@ import type {
   VerifierIssueCategory,
   VerifierOutcome,
 } from '@prisma-next/framework-components/control';
-import { dispositionForCategory } from '@prisma-next/framework-components/control';
+import { dispositionForCategory, issueOutcome } from '@prisma-next/framework-components/control';
 
 /**
  * Classifies a codec `verifyType` hook finding into the target-neutral
@@ -13,10 +13,10 @@ import { dispositionForCategory } from '@prisma-next/framework-components/contro
  * to its value set, so a paired mismatch always classifies as `valueDrift`.
  */
 export function classifyStorageTypeDiffIssue(issue: SchemaDiffIssue): VerifierIssueCategory {
-  if (issue.reason === 'not-found') {
+  if (issueOutcome(issue) === 'not-found') {
     return 'declaredMissing';
   }
-  if (issue.reason === 'not-expected') {
+  if (issueOutcome(issue) === 'not-expected') {
     return 'extraAuxiliary';
   }
   return 'valueDrift';

package/src/core/migrations/contract-to-schema-ir.ts

@@ -1,6 +1,9 @@
 import type { ColumnDefault, Contract, JsonValue } from '@prisma-next/contract/types';
 import type { CodecRef } from '@prisma-next/framework-components/codec';
-import type { MigrationPlannerConflict } from '@prisma-next/framework-components/control';
+import type {
+  MigrationPlannerConflict,
+  SchemaNodeRef,
+} from '@prisma-next/framework-components/control';
 import {
   type CheckConstraint,
   type ForeignKey,
@@ -12,8 +15,8 @@ import {
   type StorageTypeInstance,
   type UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
-import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
 import {
+  RelationalSchemaNodeKind,
   type SqlAnnotations,
   type SqlCheckConstraintIRInput,
   type SqlColumnIRInput,
@@ -25,7 +28,6 @@ import {
 } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { backingIndexColumnKeys } from '../foreign-key-index-backing';
 
 /**
  * Target-specific callback that expands a column's base `nativeType` and optional
@@ -54,6 +56,17 @@ export type NativeTypeExpander = (input: {
  */
 export type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;
 
+/**
+ * Target-supplied hook (same IoC seam as `NativeTypeExpander`/`DefaultRenderer`)
+ * that normalizes a contract-declared `ColumnDefault` into the resolved shape
+ * the target's introspection parses from the live database — e.g. a
+ * `dbgenerated("'{}'::jsonb")` function call and the literal Postgres reports
+ * are the same value in different shapes, and `resolvedDefaultsEqual`
+ * compares `kind` before content. When omitted, the contract's raw default
+ * is the resolved default unchanged.
+ */
+export type DefaultResolver = (def: ColumnDefault, resolvedNativeType: string) => ColumnDefault;
+
 /**
  * Target-supplied callback that resolves a contract namespace to the live
  * database schema its enums are stored under.
@@ -75,6 +88,7 @@ function convertColumn(
   storageTypes: ResolvedStorageTypes,
   expandNativeType: NativeTypeExpander | undefined,
   renderDefault: DefaultRenderer | undefined,
+  resolveDefault: DefaultResolver | undefined,
 ): SqlColumnIRInput {
   // Resolve `typeRef` so columns that delegate their `nativeType`/`codecId`/
   // `typeParams` to a named `storage.types` entry expand the same way as
@@ -105,6 +119,11 @@ function convertColumn(
   // agree on as the comparable "expanded" type.
   const nativeType = baseNativeType;
   const resolvedNativeType = column.many ? `${baseNativeType}[]` : baseNativeType;
+  const rawColumnDefault = column.default ?? undefined;
+  const resolvedColumnDefault =
+    rawColumnDefault !== undefined && resolveDefault
+      ? resolveDefault(rawColumnDefault, resolvedNativeType)
+      : rawColumnDefault;
   return {
     name,
     nativeType,
@@ -115,11 +134,14 @@ function convertColumn(
       column.default != null && renderDefault ? renderDefault(column.default, column) : undefined,
     ),
     // Contract-derived columns are resolved by construction: the computed
-    // full native type doubles as the resolved value, and the contract's
-    // structured default is the resolved default (the introspected side
-    // stamps its normalizer's parse of the raw expression).
+    // full native type doubles as the resolved value. The contract's raw
+    // structured default becomes the resolved default after passing through
+    // the target's `resolveDefault` hook (when supplied), so a default the
+    // target's introspection side would normalize differently (e.g. a
+    // `dbgenerated(...)` function call that is actually a literal) compares
+    // equal instead of drifting on `kind` alone.
     resolvedNativeType,
-    ...ifDefined('resolvedDefault', column.default ?? undefined),
+    ...ifDefined('resolvedDefault', resolvedColumnDefault),
     // The column's codec identity, carried the same way the query AST
     // carries `CodecRef` (TML-2456) — the migration planner's op-builders
     // resolve DDL rendering from this at plan time (Decision 5), instead of
@@ -246,14 +268,15 @@ function convertCheck(check: CheckConstraint, storage: SqlStorage): SqlCheckCons
   };
 }
 
-function convertUnique(unique: UniqueConstraint): SqlUniqueIRInput {
+function convertUnique(unique: UniqueConstraint, tableName: string): SqlUniqueIRInput {
   return {
     columns: unique.columns,
     ...ifDefined('name', unique.name),
+    dependsOn: flatColumnDependsOn(tableName, unique.columns),
   };
 }
 
-function convertIndex(index: Index): SqlIndexIRInput {
+function convertIndex(index: Index, tableName: string): SqlIndexIRInput {
   return {
     columns: index.columns,
     unique: false,
@@ -262,9 +285,42 @@ function convertIndex(index: Index): SqlIndexIRInput {
     // introspected side (the legacy walk read them from the contract).
     ...ifDefined('type', index.type),
     ...ifDefined('options', index.options),
+    dependsOn: flatColumnDependsOn(tableName, index.columns),
   };
 }
 
+/**
+ * The referenced table's chain in the flat (single-schema) tree
+ * `contractToSchemaIR`/`contractNamespaceToSchemaIR` build: the root
+ * (`SqlSchemaIR`, fixed `'database'` id) followed by the table's own id.
+ * Postgres discards this when it re-derives the FK against its own
+ * multi-schema tree shape (`contractToPostgresDatabaseSchemaNode`); SQLite's
+ * flat tree uses it as-is.
+ */
+function flatSchemaDependsOn(tableName: string): SchemaNodeRef {
+  return [
+    { nodeKind: RelationalSchemaNodeKind.schema, id: 'database' },
+    { nodeKind: RelationalSchemaNodeKind.table, id: tableName },
+  ];
+}
+
+/**
+ * The chains from a table-child object (foreign key, index, unique, primary
+ * key) to each of the own columns it is built on, in the flat tree. Dropping
+ * a covered column auto-drops the object, so the object's drop must precede
+ * the column's; the graph derives that direction from these edges.
+ */
+function flatColumnDependsOn(
+  tableName: string,
+  columns: readonly string[],
+): readonly SchemaNodeRef[] {
+  return columns.map((column) => [
+    { nodeKind: RelationalSchemaNodeKind.schema, id: 'database' },
+    { nodeKind: RelationalSchemaNodeKind.table, id: tableName },
+    { nodeKind: RelationalSchemaNodeKind.column, id: `column:${column}` },
+  ]);
+}
+
 /**
  * The FK's referenced-namespace identity comes from the target's namespace
  * node, not the raw namespace-id string. An unbound target namespace stamps
@@ -274,6 +330,10 @@ function convertIndex(index: Index): SqlIndexIRInput {
  * cross-space target whose namespace lives in another contract's storage)
  * stamps its coordinate verbatim; namespaced targets (Postgres) resolve the
  * real DDL schema downstream.
+ *
+ * `dependsOn` carries the referenced table (created before the FK, dropped
+ * after it) plus the FK's own columns (dropped after the FK, since dropping a
+ * column auto-drops the FK built on it).
  */
 function convertForeignKey(fk: ForeignKey, storage: SqlStorage): SqlForeignKeyIRInput {
   const targetNamespace = storage.namespaces[fk.target.namespaceId];
@@ -286,6 +346,10 @@ function convertForeignKey(fk: ForeignKey, storage: SqlStorage): SqlForeignKeyIR
     ...ifDefined('name', fk.name),
     ...ifDefined('onDelete', fk.onDelete),
     ...ifDefined('onUpdate', fk.onUpdate),
+    dependsOn: [
+      flatSchemaDependsOn(fk.target.tableName),
+      ...flatColumnDependsOn(fk.source.tableName, fk.source.columns),
+    ],
   };
 }
 
@@ -295,6 +359,7 @@ function convertTable(
   storageTypes: ResolvedStorageTypes,
   expandNativeType: NativeTypeExpander | undefined,
   renderDefault: DefaultRenderer | undefined,
+  resolveDefault: DefaultResolver | undefined,
   storage: SqlStorage,
 ): SqlTableIR {
   const columns: Record<string, SqlColumnIRInput> = {};
@@ -305,37 +370,36 @@ function convertTable(
       storageTypes,
       expandNativeType,
       renderDefault,
+      resolveDefault,
     );
   }
 
-  const satisfiedIndexColumns = new Set(backingIndexColumnKeys(table));
-  const fkBackingIndexes: SqlIndexIRInput[] = [];
-  for (const fk of table.foreignKeys) {
-    if (fk.index === false) continue;
-    const key = fk.source.columns.join(',');
-    if (satisfiedIndexColumns.has(key)) continue;
-    fkBackingIndexes.push({
-      columns: fk.source.columns,
-      unique: false,
-      name: defaultIndexName(name, fk.source.columns),
-    });
-    satisfiedIndexColumns.add(key);
-  }
-
   const checks: SqlCheckConstraintIRInput[] | undefined =
     table.checks && table.checks.length > 0
       ? table.checks.map((c) => convertCheck(c, storage))
       : undefined;
 
+  const primaryKey =
+    table.primaryKey !== undefined
+      ? {
+          columns: table.primaryKey.columns,
+          ...ifDefined('name', table.primaryKey.name),
+          dependsOn: flatColumnDependsOn(name, table.primaryKey.columns),
+        }
+      : undefined;
+
   return new SqlTableIR({
     name,
     columns,
-    ...ifDefined('primaryKey', table.primaryKey),
-    foreignKeys: table.foreignKeys
-      .filter((fk) => fk.constraint !== false)
-      .map((fk) => convertForeignKey(fk, storage)),
-    uniques: table.uniques.map(convertUnique),
-    indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],
+    ...ifDefined('primaryKey', primaryKey),
+    // #989 persists a `constraint: false` FK's absence and its backing index as
+    // discrete entities at contract construction, so every `foreignKeys[]` entry
+    // is now constraint-bearing (no filter) and each FK-backing index is already
+    // a `table.indexes[]` entry — it flows through `convertIndex` below, carrying
+    // the object→own-column `dependsOn` edge like any other index.
+    foreignKeys: table.foreignKeys.map((fk) => convertForeignKey(fk, storage)),
+    uniques: table.uniques.map((u) => convertUnique(u, name)),
+    indexes: table.indexes.map((i) => convertIndex(i, name)),
     ...ifDefined('checks', checks),
   });
 }
@@ -402,6 +466,7 @@ export interface ContractToSchemaIROptions {
   readonly annotationNamespace: string;
   readonly expandNativeType?: NativeTypeExpander;
   readonly renderDefault?: DefaultRenderer;
+  readonly resolveDefault?: DefaultResolver;
   /**
    * Target-supplied resolver mapping a namespace to the live database schema
    * its enums are stored under. When provided (Postgres), namespace-scoped
@@ -462,6 +527,7 @@ export function contractNamespaceToSchemaIR(
       storageTypes,
       options.expandNativeType,
       options.renderDefault,
+      options.resolveDefault,
       storage,
     );
   }
@@ -498,6 +564,7 @@ export function contractToSchemaIR(
         storageTypes,
         options.expandNativeType,
         options.renderDefault,
+        options.resolveDefault,
         storage,
       );
     }

package/src/core/migrations/types.ts

@@ -419,16 +419,16 @@ export interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
 }
 
 export type SqlMigrationRunnerErrorCode =
-  | 'DESTINATION_CONTRACT_MISMATCH'
-  | 'LEGACY_MARKER_SHAPE'
-  | 'MARKER_ORIGIN_MISMATCH'
-  | 'MARKER_CAS_FAILURE'
-  | 'POLICY_VIOLATION'
-  | 'PRECHECK_FAILED'
-  | 'POSTCHECK_FAILED'
-  | 'SCHEMA_VERIFY_FAILED'
-  | 'FOREIGN_KEY_VIOLATION'
-  | 'EXECUTION_FAILED';
+  | 'MIGRATION.DESTINATION_CONTRACT_MISMATCH'
+  | 'MIGRATION.LEGACY_MARKER_SHAPE'
+  | 'MIGRATION.MARKER_ORIGIN_MISMATCH'
+  | 'MIGRATION.MARKER_CAS_FAILURE'
+  | 'MIGRATION.POLICY_VIOLATION'
+  | 'MIGRATION.PRECHECK_FAILED'
+  | 'MIGRATION.POSTCHECK_FAILED'
+  | 'MIGRATION.SCHEMA_VERIFY_FAILED'
+  | 'MIGRATION.FOREIGN_KEY_VIOLATION'
+  | 'MIGRATION.EXECUTION_FAILED';
 
 export interface SqlMigrationRunnerFailure extends MigrationRunnerFailure {
   readonly code: SqlMigrationRunnerErrorCode;

package/src/core/psl-contract-infer/name-transforms.ts

@@ -1,3 +1,5 @@
+import pluralizeLib from 'pluralize';
+
 const PSL_RESERVED_WORDS = new Set(['model', 'enum', 'types', 'type', 'generator', 'datasource']);
 
 const IDENTIFIER_PART_PATTERN = /[A-Za-z0-9]+/g;
@@ -143,19 +145,7 @@ export function toEnumMemberName(value: string): string {
 }
 
 export function pluralize(word: string): string {
-  if (
-    word.endsWith('s') ||
-    word.endsWith('x') ||
-    word.endsWith('z') ||
-    word.endsWith('ch') ||
-    word.endsWith('sh')
-  ) {
-    return `${word}es`;
-  }
-  if (word.endsWith('y') && !/[aeiou]y$/i.test(word)) {
-    return `${word.slice(0, -1)}ies`;
-  }
-  return `${word}s`;
+  return pluralizeLib.plural(word);
 }
 
 export function deriveRelationFieldName(

package/src/core/psl-contract-infer/relation-inference.ts

@@ -1,5 +1,8 @@
+import {
+  backingIndexColumnKeys,
+  isBackedByColumnKeys,
+} from '@prisma-next/sql-contract/foreign-key-materialization';
 import type { SqlForeignKeyIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
-import { backingIndexColumnKeys, isBackedByColumnKeys } from '../foreign-key-index-backing';
 import { deriveBackRelationFieldName, deriveRelationFieldName, pluralize } from './name-transforms';
 import type { RelationField } from './printer-config';
 

package/src/core/timestamp-now-generator.ts

@@ -73,3 +73,91 @@ export function temporalAuthoringPresets<
     },
   } as const satisfies Record<string, AuthoringFieldPresetDescriptor>;
 }
+
+const TEMPORAL_PRECISION_ARG = {
+  name: 'precision',
+  kind: 'number',
+  optional: true,
+  integer: true,
+  minimum: 0,
+} as const;
+
+const TEMPORAL_ON_CREATE_ARG = {
+  name: 'onCreate',
+  kind: 'option',
+  values: ['now'],
+  optional: true,
+} as const;
+
+const TEMPORAL_ON_UPDATE_ARG = {
+  name: 'onUpdate',
+  kind: 'option',
+  values: ['now'],
+  optional: true,
+} as const;
+
+/**
+ * Selects the `timestampNow` generator descriptor for the preset's `now`
+ * token. The token is preset vocabulary; the generator id never appears in a
+ * user's spelling (ADR 169 — `timestampNow` is preset-only).
+ */
+function temporalPhaseTemplate<const Index extends number>(index: Index) {
+  return {
+    kind: 'select',
+    index,
+    cases: { now: { kind: 'generator', id: TIMESTAMP_NOW_GENERATOR_ID } },
+  } as const;
+}
+
+/**
+ * Builds a `temporal.<codec>` field preset for a codec that takes a precision
+ * parameter (`pg/timestamp@1`, `pg/timestamptz@1`). Arguments change field
+ * properties only — never the codec, which the caller fixes here.
+ *
+ * All three arguments are optional: omitting `precision` omits `typeParams`
+ * entirely, and omitting a phase omits that phase (both omitted omits
+ * `executionDefaults`).
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export function temporalCodecPresetWithPrecision<
+  const CodecId extends string,
+  const NativeType extends string,
+>(input: { readonly codecId: CodecId; readonly nativeType: NativeType }) {
+  return {
+    kind: 'fieldPreset',
+    args: [TEMPORAL_PRECISION_ARG, TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG],
+    output: {
+      codecId: input.codecId,
+      nativeType: input.nativeType,
+      typeParams: { precision: { kind: 'arg', index: 0 } },
+      executionDefaults: {
+        onCreate: temporalPhaseTemplate(1),
+        onUpdate: temporalPhaseTemplate(2),
+      },
+    },
+  } as const satisfies AuthoringFieldPresetDescriptor;
+}
+
+/**
+ * Builds a `temporal.<codec>` field preset for a codec with no type
+ * parameters (`sqlite/datetime@1`). As with the precision-bearing variant,
+ * both phase arguments are optional and omitting one omits that phase.
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export function temporalCodecPreset<
+  const CodecId extends string,
+  const NativeType extends string,
+>(input: { readonly codecId: CodecId; readonly nativeType: NativeType }) {
+  return {
+    kind: 'fieldPreset',
+    args: [TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG],
+    output: {
+      codecId: input.codecId,
+      nativeType: input.nativeType,
+      executionDefaults: {
+        onCreate: temporalPhaseTemplate(0),
+        onUpdate: temporalPhaseTemplate(1),
+      },
+    },
+  } as const satisfies AuthoringFieldPresetDescriptor;
+}

package/src/exports/control.ts

@@ -21,6 +21,7 @@ export type {
 export type {
   ContractToSchemaIROptions,
   DefaultRenderer,
+  DefaultResolver,
   EnumNamespaceSchemaResolver,
   NativeTypeExpander,
 } from '../core/migrations/contract-to-schema-ir';
@@ -87,6 +88,8 @@ export type {
 } from '../core/migrations/types';
 export {
   temporalAuthoringPresets,
+  temporalCodecPreset,
+  temporalCodecPresetWithPrecision,
   timestampNowControlDescriptor,
 } from '../core/timestamp-now-generator';
 

package/dist/control-adapter-BQgad8Zc.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control-adapter-BQgad8Zc.d.mts","names":[],"sources":["../src/core/diff/sql-schema-diff.ts","../src/core/control-adapter.ts"],"mappings":";;;;;;;;;;;KAeY,iBAAA,IACV,UAAA,UACA,UAAA,aACG,aAAa;;AAAA;AAOlB;;;KAAY,oBAAA,IAAwB,UAAkB;AAAA;AAKtD;;AALsD,iBAKtC,WAAA,CAAY,CAAA,qBAAsB,CAAoB;;;;AAftE;;;;;;UCQiB,OAAA;EACf,KAAA,CAAM,GAAA,EAAK,WAAA,GAAc,OAAA,EAAS,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;ADCvE;;;;AAAsD;AAKtD;AALA,UCQiB,qBAAA,SAA8B,OAAA;EAC7C,qBAAA,CACE,GAAA,EAAK,WAAA,GAAc,OAAA,EACnB,OAAA,GAAU,cAAA,YACT,OAAA,CAAQ,iBAAA;AAAA;ADPyD;;;;ACPtE;;ADOsE,UCgBrD,iBAAA,0CACP,sBAAA,QAA8B,OAAA,GACpC,qBAAA;EAxBS;;;;;;;;;;;;;;AAA0E;EAwCrF,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,WACC,OAAA,CAAQ,oBAAA;EAlC0B;;;;;;;EA2CrC,cAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,IAChC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EA7CqB;;;;EAmDpD,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,YACC,OAAA,UAAiB,iBAAA;EApDC;;;;;;EA4DrB,YAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EAxDmC;;;;;;EAgEtC,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EAlCO;;;;;;;EA2CV,YAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,YAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EASgC;;;;;;EADnC,gBAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,KAAA;IAAA,SACW,MAAA;IAAA,SACA,IAAA;IAAA,SACA,EAAA;IAAA,SACA,aAAA;IAAA,SACA,aAAA;IAAA,SACA,UAAA;IAAA,SACA,uBAAA;EAAA,IAEV,OAAA;EA/G8B;;;;;;;;;;;;;;;;;EAkIjC,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,eAAA;EAhGX;;;;;EAAA,SAuGS,gBAAA,GAAmB,iBAAA;EApGR;;;;;EAAA,SA2GX,mBAAA,GAAsB,oBAAA;EA/FlB;;;;EAqGb,4BAAA,aAAyC,OAAA;EAzFzC;;;;EA+FA,0BAAA,aAAuC,OAAA;AAAA;;;;;;;UASxB,2BAAA;EAtFb;;;;;;EA6FF,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}

package/dist/foreign-key-index-backing-BP71iI-Q.mjs

@@ -1,32 +0,0 @@
-//#region src/core/foreign-key-index-backing.ts
-/**
-* The column-list keys (`"colA,colB"`, order preserved) a table's own
-* indexes, unique constraints, and primary key already back. A foreign key
-* whose source columns join to one of these keys needs no separately
-* derived backing index.
-*
-* Shared by {@link isBackedByColumnKeys}'s two callers, which must agree on
-* what counts as "backed": `contract-to-schema-ir.ts`'s `convertTable`
-* (deriving the FK-backing-index expectation `db verify` checks against a
-* live database) and the postgres PSL inferrer (deciding whether an
-* introspected relation needs an explicit `index: false`).
-*/
-function backingIndexColumnKeys(table) {
-	return [
-		...table.indexes.map((index) => index.columns.join(",")),
-		...table.uniques.map((unique) => unique.columns.join(",")),
-		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
-	];
-}
-/**
-* Whether `columns`, in order, matches one of `backingKeys` (see
-* {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not
-* satisfy a backing index declared as `(b, a)`.
-*/
-function isBackedByColumnKeys(columns, backingKeys) {
-	return backingKeys.includes(columns.join(","));
-}
-//#endregion
-export { isBackedByColumnKeys as n, backingIndexColumnKeys as t };
-
-//# sourceMappingURL=foreign-key-index-backing-BP71iI-Q.mjs.map

package/dist/foreign-key-index-backing-BP71iI-Q.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"foreign-key-index-backing-BP71iI-Q.mjs","names":[],"sources":["../src/core/foreign-key-index-backing.ts"],"sourcesContent":["export type BackingIndexCandidates = {\n  readonly indexes: readonly { readonly columns: readonly string[] }[];\n  readonly uniques: readonly { readonly columns: readonly string[] }[];\n  readonly primaryKey?: { readonly columns: readonly string[] } | undefined;\n};\n\n/**\n * The column-list keys (`\"colA,colB\"`, order preserved) a table's own\n * indexes, unique constraints, and primary key already back. A foreign key\n * whose source columns join to one of these keys needs no separately\n * derived backing index.\n *\n * Shared by {@link isBackedByColumnKeys}'s two callers, which must agree on\n * what counts as \"backed\": `contract-to-schema-ir.ts`'s `convertTable`\n * (deriving the FK-backing-index expectation `db verify` checks against a\n * live database) and the postgres PSL inferrer (deciding whether an\n * introspected relation needs an explicit `index: false`).\n */\nexport function backingIndexColumnKeys(table: BackingIndexCandidates): readonly string[] {\n  return [\n    ...table.indexes.map((index) => index.columns.join(',')),\n    ...table.uniques.map((unique) => unique.columns.join(',')),\n    ...(table.primaryKey ? [table.primaryKey.columns.join(',')] : []),\n  ];\n}\n\n/**\n * Whether `columns`, in order, matches one of `backingKeys` (see\n * {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not\n * satisfy a backing index declared as `(b, a)`.\n */\nexport function isBackedByColumnKeys(\n  columns: readonly string[],\n  backingKeys: readonly string[],\n): boolean {\n  return backingKeys.includes(columns.join(','));\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,SAAgB,uBAAuB,OAAkD;CACvF,OAAO;EACL,GAAG,MAAM,QAAQ,KAAK,UAAU,MAAM,QAAQ,KAAK,GAAG,CAAC;EACvD,GAAG,MAAM,QAAQ,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG,CAAC;EACzD,GAAI,MAAM,aAAa,CAAC,MAAM,WAAW,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC;CACjE;AACF;;;;;;AAOA,SAAgB,qBACd,SACA,aACS;CACT,OAAO,YAAY,SAAS,QAAQ,KAAK,GAAG,CAAC;AAC/C"}

package/dist/schema-differ-DnoopSXm.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-differ-DnoopSXm.d.mts","names":[],"sources":["../src/core/migrations/schema-differ.ts"],"mappings":";;;;;;;;;AAcA;;;;;;UAAiB,mBAAA;EAiBU;EAAA,SAfhB,MAAA,WAAiB,eAAA;EAeY;;;;;;;;EAAA,SAN7B,oBAAA,GAAuB,KAAA,EAAO,eAAA,KAAoB,aAAA;EAMT;;;AAAuB;AAG3E;EAHoD,SAAzC,cAAA,EAAgB,aAAA;IAAA,SAAyB,MAAA,EAAQ,eAAA;EAAA;AAAA;AAAA,UAG3C,kBAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,MAAA,EAAQ,eAAA;EAAA,SACR,mBAAA,EAAqB,aAAA,CAAc,8BAAA;AAAA;AAAA,KAGlC,eAAA,IAAmB,KAAA,EAAO,kBAAA,KAAuB,mBAAmB"}

package/dist/schema-verify-W3r631Jh.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-verify-W3r631Jh.mjs","names":["d"],"sources":["../src/core/assembly.ts","../src/core/diff/verifier-disposition.ts","../src/core/diff/schema-verify.ts"],"sourcesContent":["import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport { assertUniqueCodecOwner } from '@prisma-next/framework-components/control';\nimport type { CodecControlHooks } from './migrations/types';\n\ntype CodecControlHooksMap = Record<string, CodecControlHooks>;\n\nfunction hasCodecControlHooks(descriptor: unknown): descriptor is {\n  readonly id: string;\n  readonly types: {\n    readonly codecTypes: {\n      readonly controlPlaneHooks: CodecControlHooksMap;\n    };\n  };\n} {\n  if (typeof descriptor !== 'object' || descriptor === null) {\n    return false;\n  }\n  const d = descriptor as { types?: { codecTypes?: { controlPlaneHooks?: unknown } } };\n  const hooks = d.types?.codecTypes?.controlPlaneHooks;\n  return hooks !== null && hooks !== undefined && typeof hooks === 'object';\n}\n\nexport function extractCodecControlHooks(\n  descriptors: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>,\n): Map<string, CodecControlHooks> {\n  const hooks = new Map<string, CodecControlHooks>();\n  const owners = new Map<string, string>();\n\n  for (const descriptor of descriptors) {\n    if (typeof descriptor !== 'object' || descriptor === null) {\n      continue;\n    }\n    if (!hasCodecControlHooks(descriptor)) {\n      continue;\n    }\n    const controlPlaneHooks = descriptor.types.codecTypes.controlPlaneHooks;\n    for (const [codecId, hook] of Object.entries(controlPlaneHooks)) {\n      assertUniqueCodecOwner({\n        codecId,\n        owners,\n        descriptorId: descriptor.id,\n        entityLabel: 'control hooks',\n        entityOwnershipLabel: 'owner',\n      });\n      hooks.set(codecId, hook);\n      owners.set(codecId, descriptor.id);\n    }\n  }\n\n  return hooks;\n}\n","import type { ControlPolicy } from '@prisma-next/contract/types';\nimport type {\n  SchemaDiffIssue,\n  VerifierIssueCategory,\n  VerifierOutcome,\n} from '@prisma-next/framework-components/control';\nimport { dispositionForCategory } from '@prisma-next/framework-components/control';\n\n/**\n * Classifies a codec `verifyType` hook finding into the target-neutral\n * categories the framework grades. A storage type is a named type instance\n * (e.g. a native enum); the only shape divergence it can carry is a change\n * to its value set, so a paired mismatch always classifies as `valueDrift`.\n */\nexport function classifyStorageTypeDiffIssue(issue: SchemaDiffIssue): VerifierIssueCategory {\n  if (issue.reason === 'not-found') {\n    return 'declaredMissing';\n  }\n  if (issue.reason === 'not-expected') {\n    return 'extraAuxiliary';\n  }\n  return 'valueDrift';\n}\n\nexport function verifierDisposition(\n  controlPolicy: ControlPolicy,\n  issue: SchemaDiffIssue,\n): VerifierOutcome {\n  return dispositionForCategory(controlPolicy, classifyStorageTypeDiffIssue(issue));\n}\n","/**\n * The differ-based SQL schema verify: post-diff filters and verdict.\n *\n * The generic node differ (`diffSchemas`) reports every node-level\n * difference between the derived expected tree and the introspected actual\n * tree. This module is the consumer side the spec assigns to the SQL\n * family: strict-mode extras gating and control-policy disposition are\n * reason/kind-keyed filters applied AFTER the diff — never inside it — and\n * the verify verdict derives from the filtered issue list.\n *\n * `verifySqlSchemaByDiff` wraps the verdict in the issue-based result\n * envelope — this is THE SQL schema verify (the legacy relational walk and\n * its verification tree are retired).\n */\n\nimport type { Contract, ControlPolicy } from '@prisma-next/contract/types';\nimport { effectiveControlPolicy } from '@prisma-next/contract/types';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  DiffSubjectGranularity,\n  SchemaDiffIssue,\n  VerifierIssueCategory,\n  VerifierOutcome,\n  VerifyDatabaseSchemaResult,\n} from '@prisma-next/framework-components/control';\nimport { dispositionForCategory } from '@prisma-next/framework-components/control';\nimport { isStorageTypeInstance, type SqlStorage } from '@prisma-next/sql-contract/types';\nimport { RelationalSchemaNodeKind, type SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { extractCodecControlHooks } from '../assembly';\nimport type { SqlSchemaDiffFn } from '../migrations/schema-differ';\nimport type { CodecControlHooks } from '../migrations/types';\nimport { verifierDisposition } from './verifier-disposition';\n\n// ============================================================================\n// Subject-granularity classification — nodeKind → framework-neutral granularity\n// ============================================================================\n\nfunction issueNode(issue: SchemaDiffIssue): SqlSchemaIRNode | undefined {\n  const node = issue.expected ?? issue.actual;\n  if (node === undefined) return undefined;\n  return blindCast<\n    SqlSchemaIRNode,\n    'every node in a SQL schema diff tree is a SqlSchemaIRNode; nodeKind is its identity'\n  >(node);\n}\n\n/**\n * Resolves an issue's framework-neutral {@link DiffSubjectGranularity} on\n * demand, from the issue's node's `nodeKind` via the target-provided\n * `granularityOf` map. The node carries only its `nodeKind` identity, never a\n * classification, and nothing is stamped onto the issue — every consumer\n * (the family verdict below, the framework aggregate's unclaimed-elements\n * sweep via {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable})\n * calls this the same way, resolved by the family/target that owns the node\n * vocabulary. `undefined` for an issue with no node.\n */\nexport function classifyDiffSubjectGranularity(\n  issue: SchemaDiffIssue,\n  granularityOf: (nodeKind: string) => DiffSubjectGranularity,\n): DiffSubjectGranularity | undefined {\n  const node = issueNode(issue);\n  return node === undefined ? undefined : granularityOf(node.nodeKind);\n}\n\n/**\n * Resolves an issue's storage `entityKind` on demand, from the issue's\n * node's `nodeKind` via the target-provided `entityKindOf` map — the sibling\n * of {@link classifyDiffSubjectGranularity}, called the same way by the same\n * consumers (via\n * {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}).\n * `undefined` for an issue with no node, or for a node kind with no storage\n * entity of its own.\n */\nexport function classifyDiffEntityKind(\n  issue: SchemaDiffIssue,\n  entityKindOf: (nodeKind: string) => string | undefined,\n): string | undefined {\n  const node = issueNode(issue);\n  return node === undefined ? undefined : entityKindOf(node.nodeKind);\n}\n\n// ============================================================================\n// Issue classification — subject granularity + reason → target-neutral category\n// ============================================================================\n\n/**\n * Re-keys the legacy `classifySqlVerifierIssueKind` category mapping on the\n * issue's {@link DiffSubjectGranularity} (resolved via `granularityOf`) + the\n * issue reason. The vocabulary maps one-to-one: an undeclared live entity or\n * namespace is `extraTopLevelObject`, an undeclared live field\n * `extraNestedElement`, undeclared auxiliaries (constraints, indexes,\n * defaults) and structural leaves (policies) `extraAuxiliary`; a value-set\n * drift on a check node is `valueDrift`; every other paired divergence is\n * `declaredIncompatible`; anything the database lacks is `declaredMissing`.\n * `granularityOf` is the target's classifier, so target and extension node\n * kinds classify without the family importing them.\n */\nexport function classifySqlDiffIssue(\n  issue: SchemaDiffIssue,\n  granularityOf: (nodeKind: string) => DiffSubjectGranularity,\n): VerifierIssueCategory {\n  if (issue.reason === 'not-found') {\n    return 'declaredMissing';\n  }\n  if (issue.reason === 'not-expected') {\n    const granularity = classifyDiffSubjectGranularity(issue, granularityOf);\n    if (granularity === 'entity' || granularity === 'namespace') {\n      return 'extraTopLevelObject';\n    }\n    if (granularity === 'field') {\n      return 'extraNestedElement';\n    }\n    return 'extraAuxiliary';\n  }\n  if (issueNode(issue)?.nodeKind === RelationalSchemaNodeKind.check) {\n    return 'valueDrift';\n  }\n  return 'declaredIncompatible';\n}\n\n/**\n * Whether a `not-expected` issue is a strict-mode-only finding. The legacy\n * walk detected every relational extra (namespaces, entities, fields, and\n * their auxiliaries) only under `--strict`; the structural diff (roots, RLS\n * policies, roles) was never strict-gated — its extras fail in both modes.\n * Keyed on the issue's granularity, resolved via `granularityOf`.\n */\nfunction isStrictOnlyExtra(\n  issue: SchemaDiffIssue,\n  granularityOf: (nodeKind: string) => DiffSubjectGranularity,\n): boolean {\n  const granularity = classifyDiffSubjectGranularity(issue, granularityOf);\n  return (\n    granularity === 'namespace' ||\n    granularity === 'entity' ||\n    granularity === 'field' ||\n    granularity === 'auxiliary'\n  );\n}\n\n// ============================================================================\n// The post-diff filter + verdict\n// ============================================================================\n\nexport interface SqlDiffVerdictInput {\n  /** The full, ownership-scoped diff issue list from the target's differ. */\n  readonly issues: readonly SchemaDiffIssue[];\n  /** Resolves a diff issue's subject table's declared control policy directly from the contract. */\n  readonly resolveControlPolicy: (issue: SchemaDiffIssue) => ControlPolicy | undefined;\n  readonly strict: boolean;\n  readonly defaultControlPolicy: ControlPolicy | undefined;\n  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */\n  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;\n}\n\nexport interface SqlDiffVerdict {\n  readonly failures: readonly SchemaDiffIssue[];\n  readonly warnings: readonly SchemaDiffIssue[];\n}\n\n/**\n * Applies the two consumer filters to a diff issue list: strict gating\n * (relational `not-expected` findings drop in lenient mode) and\n * control-policy disposition (each surviving issue grades against its\n * subject table's effective policy; suppressed issues drop, `observed`\n * subjects warn). The verify verdict is `failures.length === 0`.\n */\nexport function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdict {\n  const failures: SchemaDiffIssue[] = [];\n  const warnings: SchemaDiffIssue[] = [];\n  for (const issue of input.issues) {\n    if (\n      !input.strict &&\n      issue.reason === 'not-expected' &&\n      isStrictOnlyExtra(issue, input.granularityOf)\n    ) {\n      continue;\n    }\n    const tablePolicy = input.resolveControlPolicy(issue);\n    const policy = effectiveControlPolicy(tablePolicy, input.defaultControlPolicy);\n    const disposition: VerifierOutcome = dispositionForCategory(\n      policy,\n      classifySqlDiffIssue(issue, input.granularityOf),\n    );\n    if (disposition === 'suppress') continue;\n    if (disposition === 'warn') {\n      warnings.push(issue);\n      continue;\n    }\n    failures.push(issue);\n  }\n  return { failures, warnings };\n}\n\n// ============================================================================\n// Storage-types check — the codec verifyType hook path\n// ============================================================================\n\nexport interface StorageTypeVerdictInput {\n  readonly contract: Contract<SqlStorage>;\n  /**\n   * Expected/actual namespace-node pairs the target's differ input produced:\n   * for a namespaced tree, one entry per expected namespace with a\n   * non-empty table set, paired by DDL schema name (absent actual side for\n   * a schema the database lacks); a flat tree is the sole pair.\n   */\n  readonly namespacePairs: ReadonlyArray<{\n    readonly actual: SqlSchemaIRNode | undefined;\n  }>;\n  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;\n}\n\n/**\n * Runs the codec `verifyType` hooks the way the legacy walk did: once per\n * contract namespace with tables, against that namespace's paired actual\n * node (the hook reads namespace-scoped state such as `enums` off it).\n * Issue dispositions grade against the contract default policy, matching\n * the legacy `pushTypeNode` semantics.\n */\nexport interface StorageTypeVerdict {\n  readonly failures: readonly SchemaDiffIssue[];\n  readonly warnings: readonly SchemaDiffIssue[];\n}\n\nexport function computeStorageTypeVerdict(input: StorageTypeVerdictInput): StorageTypeVerdict {\n  const failures: SchemaDiffIssue[] = [];\n  const warnings: SchemaDiffIssue[] = [];\n  const policy = effectiveControlPolicy(undefined, input.contract.defaultControlPolicy);\n  for (const pair of input.namespacePairs) {\n    if (pair.actual === undefined) continue;\n    for (const [typeName, typeInstance] of Object.entries(input.contract.storage.types ?? {})) {\n      if (!isStorageTypeInstance(typeInstance)) continue;\n      const hook = input.codecHooks.get(typeInstance.codecId);\n      if (!hook?.verifyType) continue;\n      const typeIssues = hook.verifyType({ typeName, typeInstance, schema: pair.actual });\n      for (const issue of typeIssues) {\n        const disposition = verifierDisposition(policy, issue);\n        if (disposition === 'suppress') continue;\n        if (disposition === 'warn') {\n          warnings.push(issue);\n          continue;\n        }\n        failures.push(issue);\n      }\n    }\n  }\n  return { failures, warnings };\n}\n\n// ============================================================================\n// The issue-based verify envelope\n// ============================================================================\n\nexport interface VerifySqlSchemaByDiffInput {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIRNode;\n  readonly strict: boolean;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n  /** The target's full-tree node diff (`diffSchema` descriptor hook). */\n  readonly diffSchema: SqlSchemaDiffFn;\n  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */\n  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;\n}\n\n/**\n * THE SQL schema verify: runs the target's full-tree node diff, grades it\n * through the family's post-diff filters (strict gating + control-policy\n * disposition) plus the codec `verifyType` hook findings, and wraps the\n * verdict in the issue-based result envelope. `ok` holds exactly when both\n * issue lists are empty — the lists carry the verdict's failures.\n */\nexport function verifySqlSchemaByDiff(\n  input: VerifySqlSchemaByDiffInput,\n): VerifyDatabaseSchemaResult {\n  const startTime = Date.now();\n  const verdictDiff = input.diffSchema({\n    contract: input.contract,\n    schema: input.schema,\n    frameworkComponents: input.frameworkComponents,\n  });\n  const diffVerdict = computeSqlDiffVerdict({\n    issues: verdictDiff.issues,\n    resolveControlPolicy: verdictDiff.resolveControlPolicy,\n    strict: input.strict,\n    defaultControlPolicy: input.contract.defaultControlPolicy,\n    granularityOf: input.granularityOf,\n  });\n  const storageTypeVerdict = computeStorageTypeVerdict({\n    contract: input.contract,\n    namespacePairs: verdictDiff.namespacePairs,\n    codecHooks: extractCodecControlHooks(input.frameworkComponents),\n  });\n  const failCount = diffVerdict.failures.length + storageTypeVerdict.failures.length;\n  const ok = failCount === 0;\n  const profileHash =\n    'profileHash' in input.contract && typeof input.contract.profileHash === 'string'\n      ? input.contract.profileHash\n      : undefined;\n  return {\n    ok,\n    ...(ok ? {} : { code: 'PN-SCHEMA-0001' }),\n    summary: ok\n      ? 'Database schema satisfies contract'\n      : `Database schema does not satisfy contract (${failCount} failure${failCount === 1 ? '' : 's'})`,\n    contract: {\n      storageHash: input.contract.storage.storageHash,\n      ...ifDefined('profileHash', profileHash),\n    },\n    target: {\n      expected: input.contract.target,\n      actual: input.contract.target,\n    },\n    schema: {\n      issues: [...diffVerdict.failures, ...storageTypeVerdict.failures],\n      warnings: {\n        issues: [...diffVerdict.warnings, ...storageTypeVerdict.warnings],\n      },\n    },\n    meta: { strict: input.strict },\n    timings: { total: Date.now() - startTime },\n  };\n}\n"],"mappings":"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"}