@prisma-next/family-sql 0.0.1 → 0.1.0-dev.1

package/README.md

@@ -76,6 +76,7 @@ The descriptor is "pure data + factory" - it only provides the hook and factory
 - **`./control`**: Control plane entry point for CLI/config usage (exports `SqlFamilyDescriptor`)
 - **`./control-adapter`**: SQL control adapter interface (`SqlControlAdapter`, `SqlControlAdapterDescriptor`) for target-specific adapters
 - **`./runtime`**: Runtime entry point (placeholder for future functionality)
+- **`./verify`**: Verification utilities (`readMarker`, `readMarkerSql`, `parseContractMarkerRow`) for reading contract markers from databases
 
 ## Dependencies
 

package/dist/exports/chunk-3HYKCN35.js

@@ -0,0 +1,89 @@
+// src/core/verify.ts
+import { type } from "arktype";
+var MetaSchema = type({ "[string]": "unknown" });
+function parseMeta(meta) {
+  if (meta === null || meta === void 0) {
+    return {};
+  }
+  let parsed;
+  if (typeof meta === "string") {
+    try {
+      parsed = JSON.parse(meta);
+    } catch {
+      return {};
+    }
+  } else {
+    parsed = meta;
+  }
+  const result = MetaSchema(parsed);
+  if (result instanceof type.errors) {
+    return {};
+  }
+  return result;
+}
+var ContractMarkerRowSchema = type({
+  core_hash: "string",
+  profile_hash: "string",
+  "contract_json?": "unknown | null",
+  "canonical_version?": "number | null",
+  "updated_at?": "Date | string",
+  "app_tag?": "string | null",
+  "meta?": "unknown | null"
+});
+function parseContractMarkerRow(row) {
+  const result = ContractMarkerRowSchema(row);
+  if (result instanceof type.errors) {
+    const messages = result.map((p) => p.message).join("; ");
+    throw new Error(`Invalid contract marker row: ${messages}`);
+  }
+  const validatedRow = result;
+  const updatedAt = validatedRow.updated_at ? validatedRow.updated_at instanceof Date ? validatedRow.updated_at : new Date(validatedRow.updated_at) : /* @__PURE__ */ new Date();
+  return {
+    coreHash: validatedRow.core_hash,
+    profileHash: validatedRow.profile_hash,
+    contractJson: validatedRow.contract_json ?? null,
+    canonicalVersion: validatedRow.canonical_version ?? null,
+    updatedAt,
+    appTag: validatedRow.app_tag ?? null,
+    meta: parseMeta(validatedRow.meta)
+  };
+}
+function readMarkerSql() {
+  return {
+    sql: `select
+      core_hash,
+      profile_hash,
+      contract_json,
+      canonical_version,
+      updated_at,
+      app_tag,
+      meta
+    from prisma_contract.marker
+    where id = $1`,
+    params: [1]
+  };
+}
+async function readMarker(driver) {
+  const markerStatement = readMarkerSql();
+  const queryResult = await driver.query(markerStatement.sql, markerStatement.params);
+  if (queryResult.rows.length === 0) {
+    return null;
+  }
+  const markerRow = queryResult.rows[0];
+  if (!markerRow) {
+    throw new Error("Database query returned unexpected result structure");
+  }
+  return parseContractMarkerRow(markerRow);
+}
+function collectSupportedCodecTypeIds(descriptors) {
+  void descriptors;
+  return [];
+}
+
+export {
+  parseContractMarkerRow,
+  readMarkerSql,
+  readMarker,
+  collectSupportedCodecTypeIds
+};
+//# sourceMappingURL=chunk-3HYKCN35.js.map

package/dist/exports/chunk-3HYKCN35.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/verify.ts"],"sourcesContent":["import type { ContractMarkerRecord } from '@prisma-next/contract/types';\nimport type {\n  ControlAdapterDescriptor,\n  ControlDriverInstance,\n  ControlExtensionDescriptor,\n  ControlTargetDescriptor,\n} from '@prisma-next/core-control-plane/types';\nimport { type } from 'arktype';\n\nconst MetaSchema = type({ '[string]': 'unknown' });\n\nfunction parseMeta(meta: unknown): Record<string, unknown> {\n  if (meta === null || meta === undefined) {\n    return {};\n  }\n\n  let parsed: unknown;\n  if (typeof meta === 'string') {\n    try {\n      parsed = JSON.parse(meta);\n    } catch {\n      return {};\n    }\n  } else {\n    parsed = meta;\n  }\n\n  const result = MetaSchema(parsed);\n  if (result instanceof type.errors) {\n    return {};\n  }\n\n  return result as Record<string, unknown>;\n}\n\nconst ContractMarkerRowSchema = type({\n  core_hash: 'string',\n  profile_hash: 'string',\n  'contract_json?': 'unknown | null',\n  'canonical_version?': 'number | null',\n  'updated_at?': 'Date | string',\n  'app_tag?': 'string | null',\n  'meta?': 'unknown | null',\n});\n\n/**\n * Parses a contract marker row from database query result.\n * This is SQL-specific parsing logic (handles SQL row structure with snake_case columns).\n */\nexport function parseContractMarkerRow(row: unknown): ContractMarkerRecord {\n  const result = ContractMarkerRowSchema(row);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Invalid contract marker row: ${messages}`);\n  }\n\n  const validatedRow = result as {\n    core_hash: string;\n    profile_hash: string;\n    contract_json?: unknown | null;\n    canonical_version?: number | null;\n    updated_at?: Date | string;\n    app_tag?: string | null;\n    meta?: unknown | null;\n  };\n\n  const updatedAt = validatedRow.updated_at\n    ? validatedRow.updated_at instanceof Date\n      ? validatedRow.updated_at\n      : new Date(validatedRow.updated_at)\n    : new Date();\n\n  return {\n    coreHash: validatedRow.core_hash,\n    profileHash: validatedRow.profile_hash,\n    contractJson: validatedRow.contract_json ?? null,\n    canonicalVersion: validatedRow.canonical_version ?? null,\n    updatedAt,\n    appTag: validatedRow.app_tag ?? null,\n    meta: parseMeta(validatedRow.meta),\n  };\n}\n\n/**\n * Returns the SQL statement to read the contract marker.\n * This is a migration-plane helper (no runtime imports).\n * @internal - Used internally by readMarker(). Prefer readMarker() for Control Plane usage.\n */\nexport function readMarkerSql(): { readonly sql: string; readonly params: readonly unknown[] } {\n  return {\n    sql: `select\n      core_hash,\n      profile_hash,\n      contract_json,\n      canonical_version,\n      updated_at,\n      app_tag,\n      meta\n    from prisma_contract.marker\n    where id = $1`,\n    params: [1],\n  };\n}\n\n/**\n * Reads the contract marker from the database using the provided driver.\n * Returns the parsed marker record or null if no marker is found.\n * This abstracts SQL-specific details from the Control Plane.\n *\n * @param driver - ControlDriverInstance instance for executing queries\n * @returns Promise resolving to ContractMarkerRecord or null if marker not found\n */\nexport async function readMarker(\n  driver: ControlDriverInstance,\n): Promise<ContractMarkerRecord | null> {\n  const markerStatement = readMarkerSql();\n  const queryResult = await driver.query<{\n    core_hash: string;\n    profile_hash: string;\n    contract_json: unknown | null;\n    canonical_version: number | null;\n    updated_at: Date | string;\n    app_tag: string | null;\n    meta: unknown | null;\n  }>(markerStatement.sql, markerStatement.params);\n\n  if (queryResult.rows.length === 0) {\n    return null;\n  }\n\n  const markerRow = queryResult.rows[0];\n  if (!markerRow) {\n    // If rows array has length > 0 but first element is undefined, this is an unexpected result structure\n    throw new Error('Database query returned unexpected result structure');\n  }\n\n  return parseContractMarkerRow(markerRow);\n}\n\n/**\n * Collects supported codec type IDs from adapter and extension manifests.\n * Returns a sorted, unique array of type IDs that are declared in the manifests.\n * This enables coverage checks by comparing contract column types against supported types.\n *\n * Note: This extracts type IDs from manifest type imports, not from runtime codec registries.\n * The manifests declare which codec types are available, but the actual type IDs\n * are defined in the codec-types TypeScript modules that are imported.\n *\n * For MVP, we return an empty array since extracting type IDs from TypeScript modules\n * would require runtime evaluation or static analysis. This can be enhanced later.\n */\nexport function collectSupportedCodecTypeIds<TFamilyId extends string, TTargetId extends string>(\n  descriptors: ReadonlyArray<\n    | ControlTargetDescriptor<TFamilyId, TTargetId>\n    | ControlAdapterDescriptor<TFamilyId, TTargetId>\n    | ControlExtensionDescriptor<TFamilyId, TTargetId>\n  >,\n): readonly string[] {\n  // For MVP, return empty array\n  // Future enhancement: Extract type IDs from codec-types modules via static analysis\n  // or require manifests to explicitly list supported type IDs\n  void descriptors;\n  return [];\n}\n"],"mappings":";AAOA,SAAS,YAAY;AAErB,IAAM,aAAa,KAAK,EAAE,YAAY,UAAU,CAAC;AAEjD,SAAS,UAAU,MAAwC;AACzD,MAAI,SAAS,QAAQ,SAAS,QAAW;AACvC,WAAO,CAAC;AAAA,EACV;AAEA,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,QAAI;AACF,eAAS,KAAK,MAAM,IAAI;AAAA,IAC1B,QAAQ;AACN,aAAO,CAAC;AAAA,IACV;AAAA,EACF,OAAO;AACL,aAAS;AAAA,EACX;AAEA,QAAM,SAAS,WAAW,MAAM;AAChC,MAAI,kBAAkB,KAAK,QAAQ;AACjC,WAAO,CAAC;AAAA,EACV;AAEA,SAAO;AACT;AAEA,IAAM,0BAA0B,KAAK;AAAA,EACnC,WAAW;AAAA,EACX,cAAc;AAAA,EACd,kBAAkB;AAAA,EAClB,sBAAsB;AAAA,EACtB,eAAe;AAAA,EACf,YAAY;AAAA,EACZ,SAAS;AACX,CAAC;AAMM,SAAS,uBAAuB,KAAoC;AACzE,QAAM,SAAS,wBAAwB,GAAG;AAC1C,MAAI,kBAAkB,KAAK,QAAQ;AACjC,UAAM,WAAW,OAAO,IAAI,CAAC,MAA2B,EAAE,OAAO,EAAE,KAAK,IAAI;AAC5E,UAAM,IAAI,MAAM,gCAAgC,QAAQ,EAAE;AAAA,EAC5D;AAEA,QAAM,eAAe;AAUrB,QAAM,YAAY,aAAa,aAC3B,aAAa,sBAAsB,OACjC,aAAa,aACb,IAAI,KAAK,aAAa,UAAU,IAClC,oBAAI,KAAK;AAEb,SAAO;AAAA,IACL,UAAU,aAAa;AAAA,IACvB,aAAa,aAAa;AAAA,IAC1B,cAAc,aAAa,iBAAiB;AAAA,IAC5C,kBAAkB,aAAa,qBAAqB;AAAA,IACpD;AAAA,IACA,QAAQ,aAAa,WAAW;AAAA,IAChC,MAAM,UAAU,aAAa,IAAI;AAAA,EACnC;AACF;AAOO,SAAS,gBAA+E;AAC7F,SAAO;AAAA,IACL,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAUL,QAAQ,CAAC,CAAC;AAAA,EACZ;AACF;AAUA,eAAsB,WACpB,QACsC;AACtC,QAAM,kBAAkB,cAAc;AACtC,QAAM,cAAc,MAAM,OAAO,MAQ9B,gBAAgB,KAAK,gBAAgB,MAAM;AAE9C,MAAI,YAAY,KAAK,WAAW,GAAG;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,YAAY,YAAY,KAAK,CAAC;AACpC,MAAI,CAAC,WAAW;AAEd,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AAEA,SAAO,uBAAuB,SAAS;AACzC;AAcO,SAAS,6BACd,aAKmB;AAInB,OAAK;AACL,SAAO,CAAC;AACV;","names":[]}

package/dist/exports/control.d.ts

@@ -1,14 +1,101 @@
-import * as _prisma_next_sql_contract_types from '@prisma-next/sql-contract/types';
-import * as _prisma_next_contract from '@prisma-next/contract';
-import * as _prisma_next_contract_ir from '@prisma-next/contract/ir';
-import { ContractIR } from '@prisma-next/contract/ir';
+import { OperationRegistry } from '@prisma-next/operations';
 import { ExtensionPackManifest } from '@prisma-next/contract/pack-manifest-types';
 import { ControlFamilyInstance, ControlDriverInstance, VerifyDatabaseResult, VerifyDatabaseSchemaResult, SignDatabaseResult, EmitContractResult, ControlFamilyDescriptor, ControlTargetDescriptor, ControlAdapterDescriptor, ControlDriverDescriptor, ControlExtensionDescriptor } from '@prisma-next/core-control-plane/types';
-import { TypesImportSpec } from '@prisma-next/contract/types';
+import { ContractIR as ContractIR$1 } from '@prisma-next/contract/ir';
+import { TypesImportSpec as TypesImportSpec$1 } from '@prisma-next/contract/types';
 import { CoreSchemaView } from '@prisma-next/core-control-plane/schema-view';
-import { O as OperationRegistry } from './index-Bi3Sr19r.js';
 import { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 
+type StorageColumn = {
+    readonly nativeType: string;
+    readonly codecId: string;
+    readonly nullable: boolean;
+};
+type PrimaryKey = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+type UniqueConstraint = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+type Index = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+type ForeignKeyReferences = {
+    readonly table: string;
+    readonly columns: readonly string[];
+};
+type ForeignKey = {
+    readonly columns: readonly string[];
+    readonly references: ForeignKeyReferences;
+    readonly name?: string;
+};
+type StorageTable = {
+    readonly columns: Record<string, StorageColumn>;
+    readonly primaryKey?: PrimaryKey;
+    readonly uniques: ReadonlyArray<UniqueConstraint>;
+    readonly indexes: ReadonlyArray<Index>;
+    readonly foreignKeys: ReadonlyArray<ForeignKey>;
+};
+type SqlStorage = {
+    readonly tables: Record<string, StorageTable>;
+};
+type ModelField = {
+    readonly column: string;
+};
+type ModelStorage = {
+    readonly table: string;
+};
+type ModelDefinition = {
+    readonly storage: ModelStorage;
+    readonly fields: Record<string, ModelField>;
+    readonly relations: Record<string, unknown>;
+};
+
+/**
+ * ContractIR types and factories for building contract intermediate representation.
+ * ContractIR is family-agnostic and used by authoring, emitter, and no-emit runtime.
+ */
+/**
+ * ContractIR represents the intermediate representation of a contract.
+ * It is family-agnostic and contains generic storage, models, and relations.
+ * Note: coreHash and profileHash are computed by the emitter, not part of the IR.
+ */
+interface ContractIR<TStorage extends Record<string, unknown> = Record<string, unknown>, TModels extends Record<string, unknown> = Record<string, unknown>, TRelations extends Record<string, unknown> = Record<string, unknown>> {
+    readonly schemaVersion: string;
+    readonly targetFamily: string;
+    readonly target: string;
+    readonly models: TModels;
+    readonly relations: TRelations;
+    readonly storage: TStorage;
+    readonly extensions: Record<string, unknown>;
+    readonly capabilities: Record<string, Record<string, boolean>>;
+    readonly meta: Record<string, unknown>;
+    readonly sources: Record<string, unknown>;
+}
+
+/**
+ * Specifies how to import TypeScript types from a package.
+ * Used in extension pack manifests to declare codec and operation type imports.
+ */
+interface TypesImportSpec {
+    readonly package: string;
+    readonly named: string;
+    readonly alias: string;
+}
+/**
+ * Validation context passed to TargetFamilyHook.validateTypes().
+ * Contains pre-assembled operation registry, type imports, and extension IDs.
+ */
+interface ValidationContext {
+    readonly operationRegistry?: OperationRegistry;
+    readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
+    readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;
+    readonly extensionIds?: ReadonlyArray<string>;
+}
+
 /**
  * Type metadata for SQL storage types.
  * Maps contract storage type IDs to native database types.
@@ -29,8 +116,8 @@ type SqlTypeMetadataRegistry = Map<string, SqlTypeMetadata>;
  */
 interface SqlFamilyInstanceState {
     readonly operationRegistry: OperationRegistry;
-    readonly codecTypeImports: ReadonlyArray<TypesImportSpec>;
-    readonly operationTypeImports: ReadonlyArray<TypesImportSpec>;
+    readonly codecTypeImports: ReadonlyArray<TypesImportSpec$1>;
+    readonly operationTypeImports: ReadonlyArray<TypesImportSpec$1>;
     readonly extensionIds: ReadonlyArray<string>;
     readonly typeMetadataRegistry: SqlTypeMetadataRegistry;
 }
@@ -108,7 +195,7 @@ interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql'>, SqlFami
      * Handles stripping mappings and validation internally.
      */
     emitContract(options: {
-        readonly contractIR: ContractIR | unknown;
+        readonly contractIR: ContractIR$1 | unknown;
     }): Promise<EmitContractResult>;
 }
 
@@ -123,13 +210,13 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
     readonly manifest: ExtensionPackManifest;
     readonly hook: {
         readonly id: "sql";
-        readonly validateTypes: (ir: _prisma_next_contract_ir.ContractIR, ctx: _prisma_next_contract.ValidationContext) => void;
-        readonly validateStructure: (ir: _prisma_next_contract_ir.ContractIR) => void;
-        readonly generateContractTypes: (ir: _prisma_next_contract_ir.ContractIR, codecTypeImports: ReadonlyArray<_prisma_next_contract.TypesImportSpec>, operationTypeImports: ReadonlyArray<_prisma_next_contract.TypesImportSpec>) => string;
-        readonly generateStorageType: (storage: _prisma_next_sql_contract_types.SqlStorage) => string;
-        readonly generateModelsType: (models: Record<string, _prisma_next_sql_contract_types.ModelDefinition> | undefined, storage: _prisma_next_sql_contract_types.SqlStorage) => string;
+        readonly validateTypes: (ir: ContractIR, ctx: ValidationContext) => void;
+        readonly validateStructure: (ir: ContractIR) => void;
+        readonly generateContractTypes: (ir: ContractIR, codecTypeImports: ReadonlyArray<TypesImportSpec>, operationTypeImports: ReadonlyArray<TypesImportSpec>) => string;
+        readonly generateStorageType: (storage: SqlStorage) => string;
+        readonly generateModelsType: (models: Record<string, ModelDefinition> | undefined, storage: SqlStorage) => string;
         readonly generateRelationsType: (relations: Record<string, unknown> | undefined) => string;
-        readonly generateMappingsType: (models: Record<string, _prisma_next_sql_contract_types.ModelDefinition> | undefined, storage: _prisma_next_sql_contract_types.SqlStorage, codecTypes: string, operationTypes: string) => string;
+        readonly generateMappingsType: (models: Record<string, ModelDefinition> | undefined, storage: SqlStorage, codecTypes: string, operationTypes: string) => string;
     };
     create<TTargetId extends string>(options: {
         readonly target: ControlTargetDescriptor<'sql', TTargetId>;

package/dist/exports/control.js

@@ -1,3 +1,8 @@
+import {
+  collectSupportedCodecTypeIds,
+  readMarker
+} from "./chunk-3HYKCN35.js";
+
 // src/core/descriptor.ts
 import { sqlTargetFamilyHook as sqlTargetFamilyHook2 } from "@prisma-next/sql-contract-emitter";
 
@@ -11,29 +16,8 @@ import {
   writeContractMarker
 } from "@prisma-next/sql-runtime";
 
-// ../../framework/core-operations/src/index.ts
-var OperationRegistryImpl = class {
-  operations = /* @__PURE__ */ new Map();
-  register(op) {
-    const existing = this.operations.get(op.forTypeId) ?? [];
-    const duplicate = existing.find((existingOp) => existingOp.method === op.method);
-    if (duplicate) {
-      throw new Error(
-        `Operation method "${op.method}" already registered for typeId "${op.forTypeId}"`
-      );
-    }
-    existing.push(op);
-    this.operations.set(op.forTypeId, existing);
-  }
-  byType(typeId) {
-    return this.operations.get(typeId) ?? [];
-  }
-};
-function createOperationRegistry() {
-  return new OperationRegistryImpl();
-}
-
 // src/core/assembly.ts
+import { createOperationRegistry } from "@prisma-next/operations";
 function assembleOperationRegistry(descriptors, convertOperationManifest2) {
   const registry = createOperationRegistry();
   for (const descriptor of descriptors) {
@@ -85,88 +69,6 @@ function extractExtensionIds(adapter, target, extensions) {
   return ids;
 }
 
-// src/core/verify.ts
-import { type } from "arktype";
-var MetaSchema = type({ "[string]": "unknown" });
-function parseMeta(meta) {
-  if (meta === null || meta === void 0) {
-    return {};
-  }
-  let parsed;
-  if (typeof meta === "string") {
-    try {
-      parsed = JSON.parse(meta);
-    } catch {
-      return {};
-    }
-  } else {
-    parsed = meta;
-  }
-  const result = MetaSchema(parsed);
-  if (result instanceof type.errors) {
-    return {};
-  }
-  return result;
-}
-var ContractMarkerRowSchema = type({
-  core_hash: "string",
-  profile_hash: "string",
-  "contract_json?": "unknown | null",
-  "canonical_version?": "number | null",
-  "updated_at?": "Date | string",
-  "app_tag?": "string | null",
-  "meta?": "unknown | null"
-});
-function parseContractMarkerRow(row) {
-  const result = ContractMarkerRowSchema(row);
-  if (result instanceof type.errors) {
-    const messages = result.map((p) => p.message).join("; ");
-    throw new Error(`Invalid contract marker row: ${messages}`);
-  }
-  const validatedRow = result;
-  const updatedAt = validatedRow.updated_at ? validatedRow.updated_at instanceof Date ? validatedRow.updated_at : new Date(validatedRow.updated_at) : /* @__PURE__ */ new Date();
-  return {
-    coreHash: validatedRow.core_hash,
-    profileHash: validatedRow.profile_hash,
-    contractJson: validatedRow.contract_json ?? null,
-    canonicalVersion: validatedRow.canonical_version ?? null,
-    updatedAt,
-    appTag: validatedRow.app_tag ?? null,
-    meta: parseMeta(validatedRow.meta)
-  };
-}
-function readMarkerSql() {
-  return {
-    sql: `select
-      core_hash,
-      profile_hash,
-      contract_json,
-      canonical_version,
-      updated_at,
-      app_tag,
-      meta
-    from prisma_contract.marker
-    where id = $1`,
-    params: [1]
-  };
-}
-async function readMarker(driver) {
-  const markerStatement = readMarkerSql();
-  const queryResult = await driver.query(markerStatement.sql, markerStatement.params);
-  if (queryResult.rows.length === 0) {
-    return null;
-  }
-  const markerRow = queryResult.rows[0];
-  if (!markerRow) {
-    throw new Error("Database query returned unexpected result structure");
-  }
-  return parseContractMarkerRow(markerRow);
-}
-function collectSupportedCodecTypeIds(descriptors) {
-  void descriptors;
-  return [];
-}
-
 // src/core/instance.ts
 function convertOperationManifest(manifest) {
   return {
@@ -216,8 +118,8 @@ function extractCodecTypeIdsFromContract(contract) {
         if (typeof table === "object" && table !== null && "columns" in table && typeof table.columns === "object" && table.columns !== null) {
           const columns = table.columns;
           for (const column of Object.values(columns)) {
-            if (column && typeof column === "object" && "type" in column && typeof column.type === "string") {
-              typeIds.add(column.type);
+            if (column && typeof column === "object" && "codecId" in column && typeof column.codecId === "string") {
+              typeIds.add(column.codecId);
             }
           }
         }
@@ -895,39 +797,47 @@ function createSqlFamilyInstance(options) {
           }
           const columnChildren = [];
           let columnStatus = "pass";
-          const typeMetadata = typeMetadataRegistry.get(contractColumn.type);
-          const contractNativeType = typeMetadata?.nativeType;
+          const contractNativeType = contractColumn.nativeType;
           const schemaNativeType = schemaColumn.nativeType;
           if (!contractNativeType) {
+            issues.push({
+              kind: "type_mismatch",
+              table: tableName,
+              column: columnName,
+              expected: "nativeType required",
+              actual: schemaNativeType || "unknown",
+              message: `Column "${tableName}"."${columnName}" is missing nativeType in contract`
+            });
             columnChildren.push({
-              status: "warn",
+              status: "fail",
               kind: "type",
               name: "type",
-              contractPath: `${columnPath}.type`,
-              code: "type_metadata_missing",
-              message: `Contract type "${contractColumn.type}" has no nativeType metadata - native type comparison skipped`,
-              expected: { typeId: contractColumn.type },
-              actual: schemaColumn.typeId || schemaNativeType || "unknown",
+              contractPath: `${columnPath}.nativeType`,
+              code: "type_mismatch",
+              message: "Contract column is missing nativeType",
+              expected: "nativeType required",
+              actual: schemaNativeType || "unknown",
               children: []
             });
+            columnStatus = "fail";
           } else if (!schemaNativeType) {
             issues.push({
               kind: "type_mismatch",
               table: tableName,
               column: columnName,
               expected: contractNativeType,
-              actual: schemaColumn.typeId || "unknown",
+              actual: "unknown",
               message: `Column "${tableName}"."${columnName}" has type mismatch: schema column has no nativeType`
             });
             columnChildren.push({
               status: "fail",
               kind: "type",
               name: "type",
-              contractPath: `${columnPath}.type`,
+              contractPath: `${columnPath}.nativeType`,
               code: "type_mismatch",
               message: "Schema column has no nativeType",
               expected: contractNativeType,
-              actual: schemaColumn.typeId || "unknown",
+              actual: "unknown",
               children: []
             });
             columnStatus = "fail";
@@ -944,7 +854,7 @@ function createSqlFamilyInstance(options) {
               status: "fail",
               kind: "type",
               name: "type",
-              contractPath: `${columnPath}.type`,
+              contractPath: `${columnPath}.nativeType`,
               code: "type_mismatch",
               message: `Type mismatch: expected ${contractNativeType}, got ${schemaNativeType}`,
               expected: contractNativeType,
@@ -953,6 +863,34 @@ function createSqlFamilyInstance(options) {
             });
             columnStatus = "fail";
           }
+          if (contractColumn.codecId) {
+            const typeMetadata = typeMetadataRegistry.get(contractColumn.codecId);
+            if (!typeMetadata) {
+              columnChildren.push({
+                status: "warn",
+                kind: "type",
+                name: "type_metadata_missing",
+                contractPath: `${columnPath}.codecId`,
+                code: "type_metadata_missing",
+                message: `codecId "${contractColumn.codecId}" not found in type metadata registry`,
+                expected: contractColumn.codecId,
+                actual: void 0,
+                children: []
+              });
+            } else if (typeMetadata.nativeType && typeMetadata.nativeType !== contractNativeType) {
+              columnChildren.push({
+                status: "warn",
+                kind: "type",
+                name: "type_consistency",
+                contractPath: `${columnPath}.codecId`,
+                code: "type_consistency_warning",
+                message: `codecId "${contractColumn.codecId}" maps to nativeType "${typeMetadata.nativeType}" in registry, but contract has "${contractNativeType}"`,
+                expected: typeMetadata.nativeType,
+                actual: contractNativeType,
+                children: []
+              });
+            }
+          }
           if (contractColumn.nullable !== schemaColumn.nullable) {
             issues.push({
               kind: "nullability_mismatch",
@@ -978,7 +916,7 @@ function createSqlFamilyInstance(options) {
           const computedColumnStatus = columnChildren.some((c) => c.status === "fail") ? "fail" : columnChildren.some((c) => c.status === "warn") ? "warn" : "pass";
           const finalColumnStatus = columnChildren.length > 0 ? computedColumnStatus : columnStatus;
           const nullableText = contractColumn.nullable ? "nullable" : "not nullable";
-          const columnTypeDisplay = contractNativeType ? `${contractColumn.type} \u2192 ${contractNativeType}` : contractColumn.type;
+          const columnTypeDisplay = contractColumn.codecId ? `${contractNativeType} (${contractColumn.codecId})` : contractNativeType;
           const failureMessages = columnChildren.filter((child) => child.status === "fail" && child.message).map((child) => child.message).filter((msg) => typeof msg === "string" && msg.length > 0);
           const columnMessage = finalColumnStatus === "fail" && failureMessages.length > 0 ? failureMessages.join("; ") : "";
           const columnCode = finalColumnStatus === "fail" && columnChildren.length > 0 && columnChildren[0] ? columnChildren[0].code : finalColumnStatus === "warn" && columnChildren.length > 0 && columnChildren[0] ? columnChildren[0].code : "";
@@ -1025,7 +963,7 @@ function createSqlFamilyInstance(options) {
                 code: "extra_column",
                 message: `Extra column "${columnName}" found`,
                 expected: void 0,
-                actual: schemaColumn.typeId,
+                actual: schemaColumn.nativeType,
                 children: []
               });
             }
@@ -1287,16 +1225,15 @@ function createSqlFamilyInstance(options) {
           const columnNodes = [];
           for (const [columnName, column] of Object.entries(table.columns)) {
             const nullableText = column.nullable ? "(nullable)" : "(not nullable)";
-            const typeDisplay = column.nativeType ?? column.typeId;
+            const typeDisplay = column.nativeType;
             const label = `${columnName}: ${typeDisplay} ${nullableText}`;
             columnNodes.push({
               kind: "field",
               id: `column-${tableName}-${columnName}`,
               label,
               meta: {
-                typeId: column.typeId,
-                nullable: column.nullable,
-                ...column.nativeType ? { nativeType: column.nativeType } : {}
+                nativeType: column.nativeType,
+                nullable: column.nullable
               }
             });
           }