@prisma-next/family-sql 0.1.0-dev.10 → 0.1.0-dev.12

package/dist/exports/chunk-LXRIZAYE.js

@@ -0,0 +1,1389 @@
+import {
+  collectSupportedCodecTypeIds,
+  readMarker
+} from "./chunk-3HYKCN35.js";
+
+// src/core/assembly.ts
+import { createOperationRegistry } from "@prisma-next/operations";
+
+// src/core/instance.ts
+import { emit } from "@prisma-next/core-control-plane/emission";
+import { sqlTargetFamilyHook } from "@prisma-next/sql-contract-emitter";
+import { validateContract } from "@prisma-next/sql-contract-ts/contract";
+import {
+  ensureSchemaStatement,
+  ensureTableStatement,
+  writeContractMarker
+} from "@prisma-next/sql-runtime";
+function convertOperationManifest(manifest) {
+  return {
+    forTypeId: manifest.for,
+    method: manifest.method,
+    args: manifest.args.map((arg) => {
+      if (arg.kind === "typeId") {
+        if (!arg.type) {
+          throw new Error("typeId arg must have type property");
+        }
+        return { kind: "typeId", type: arg.type };
+      }
+      if (arg.kind === "param") {
+        return { kind: "param" };
+      }
+      if (arg.kind === "literal") {
+        return { kind: "literal" };
+      }
+      throw new Error(`Invalid arg kind: ${arg.kind}`);
+    }),
+    returns: (() => {
+      if (manifest.returns.kind === "typeId") {
+        return { kind: "typeId", type: manifest.returns.type };
+      }
+      if (manifest.returns.kind === "builtin") {
+        return {
+          kind: "builtin",
+          type: manifest.returns.type
+        };
+      }
+      throw new Error(`Invalid return kind: ${manifest.returns.kind}`);
+    })(),
+    lowering: {
+      targetFamily: "sql",
+      strategy: manifest.lowering.strategy,
+      template: manifest.lowering.template
+    },
+    ...manifest.capabilities ? { capabilities: manifest.capabilities } : {}
+  };
+}
+function extractCodecTypeIdsFromContract(contract) {
+  const typeIds = /* @__PURE__ */ new Set();
+  if (typeof contract === "object" && contract !== null && "storage" in contract && typeof contract.storage === "object" && contract.storage !== null && "tables" in contract.storage) {
+    const storage = contract.storage;
+    if (storage.tables && typeof storage.tables === "object") {
+      for (const table of Object.values(storage.tables)) {
+        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" && "codecId" in column && typeof column.codecId === "string") {
+              typeIds.add(column.codecId);
+            }
+          }
+        }
+      }
+    }
+  }
+  return Array.from(typeIds).sort();
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function comparePrimaryKey(contractPK, schemaPK, tableName, issues) {
+  if (!schemaPK) {
+    issues.push({
+      kind: "primary_key_mismatch",
+      table: tableName,
+      expected: contractPK.columns.join(", "),
+      message: `Table "${tableName}" is missing primary key`
+    });
+    return "fail";
+  }
+  if (!arraysEqual(contractPK.columns, schemaPK.columns)) {
+    issues.push({
+      kind: "primary_key_mismatch",
+      table: tableName,
+      expected: contractPK.columns.join(", "),
+      actual: schemaPK.columns.join(", "),
+      message: `Table "${tableName}" has primary key mismatch: expected columns [${contractPK.columns.join(", ")}], got [${schemaPK.columns.join(", ")}]`
+    });
+    return "fail";
+  }
+  if (contractPK.name && schemaPK.name && contractPK.name !== schemaPK.name) {
+    issues.push({
+      kind: "primary_key_mismatch",
+      table: tableName,
+      indexOrConstraint: contractPK.name,
+      expected: contractPK.name,
+      actual: schemaPK.name,
+      message: `Table "${tableName}" has primary key name mismatch: expected "${contractPK.name}", got "${schemaPK.name}"`
+    });
+    return "fail";
+  }
+  return "pass";
+}
+function compareForeignKeys(contractFKs, schemaFKs, tableName, tablePath, issues, strict) {
+  const nodes = [];
+  for (const contractFK of contractFKs) {
+    const fkPath = `${tablePath}.foreignKeys[${contractFK.columns.join(",")}]`;
+    const matchingFK = schemaFKs.find((fk) => {
+      return arraysEqual(fk.columns, contractFK.columns) && fk.referencedTable === contractFK.references.table && arraysEqual(fk.referencedColumns, contractFK.references.columns);
+    });
+    if (!matchingFK) {
+      issues.push({
+        kind: "foreign_key_mismatch",
+        table: tableName,
+        expected: `${contractFK.columns.join(", ")} -> ${contractFK.references.table}(${contractFK.references.columns.join(", ")})`,
+        message: `Table "${tableName}" is missing foreign key: ${contractFK.columns.join(", ")} -> ${contractFK.references.table}(${contractFK.references.columns.join(", ")})`
+      });
+      nodes.push({
+        status: "fail",
+        kind: "foreignKey",
+        name: `foreignKey(${contractFK.columns.join(", ")})`,
+        contractPath: fkPath,
+        code: "foreign_key_mismatch",
+        message: "Foreign key missing",
+        expected: contractFK,
+        actual: void 0,
+        children: []
+      });
+    } else {
+      if (contractFK.name && matchingFK.name && contractFK.name !== matchingFK.name) {
+        issues.push({
+          kind: "foreign_key_mismatch",
+          table: tableName,
+          indexOrConstraint: contractFK.name,
+          expected: contractFK.name,
+          actual: matchingFK.name,
+          message: `Table "${tableName}" has foreign key name mismatch: expected "${contractFK.name}", got "${matchingFK.name}"`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "foreignKey",
+          name: `foreignKey(${contractFK.columns.join(", ")})`,
+          contractPath: fkPath,
+          code: "foreign_key_mismatch",
+          message: "Foreign key name mismatch",
+          expected: contractFK.name,
+          actual: matchingFK.name,
+          children: []
+        });
+      } else {
+        nodes.push({
+          status: "pass",
+          kind: "foreignKey",
+          name: `foreignKey(${contractFK.columns.join(", ")})`,
+          contractPath: fkPath,
+          code: "",
+          message: "",
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+      }
+    }
+  }
+  if (strict) {
+    for (const schemaFK of schemaFKs) {
+      const matchingFK = contractFKs.find((fk) => {
+        return arraysEqual(fk.columns, schemaFK.columns) && fk.references.table === schemaFK.referencedTable && arraysEqual(fk.references.columns, schemaFK.referencedColumns);
+      });
+      if (!matchingFK) {
+        issues.push({
+          kind: "foreign_key_mismatch",
+          table: tableName,
+          message: `Extra foreign key found in database (not in contract): ${schemaFK.columns.join(", ")} -> ${schemaFK.referencedTable}(${schemaFK.referencedColumns.join(", ")})`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "foreignKey",
+          name: `foreignKey(${schemaFK.columns.join(", ")})`,
+          contractPath: `${tablePath}.foreignKeys[${schemaFK.columns.join(",")}]`,
+          code: "extra_foreign_key",
+          message: "Extra foreign key found",
+          expected: void 0,
+          actual: schemaFK,
+          children: []
+        });
+      }
+    }
+  }
+  return nodes;
+}
+function compareUniqueConstraints(contractUniques, schemaUniques, tableName, tablePath, issues, strict) {
+  const nodes = [];
+  for (const contractUnique of contractUniques) {
+    const uniquePath = `${tablePath}.uniques[${contractUnique.columns.join(",")}]`;
+    const matchingUnique = schemaUniques.find(
+      (u) => arraysEqual(u.columns, contractUnique.columns)
+    );
+    if (!matchingUnique) {
+      issues.push({
+        kind: "unique_constraint_mismatch",
+        table: tableName,
+        expected: contractUnique.columns.join(", "),
+        message: `Table "${tableName}" is missing unique constraint: ${contractUnique.columns.join(", ")}`
+      });
+      nodes.push({
+        status: "fail",
+        kind: "unique",
+        name: `unique(${contractUnique.columns.join(", ")})`,
+        contractPath: uniquePath,
+        code: "unique_constraint_mismatch",
+        message: "Unique constraint missing",
+        expected: contractUnique,
+        actual: void 0,
+        children: []
+      });
+    } else {
+      if (contractUnique.name && matchingUnique.name && contractUnique.name !== matchingUnique.name) {
+        issues.push({
+          kind: "unique_constraint_mismatch",
+          table: tableName,
+          indexOrConstraint: contractUnique.name,
+          expected: contractUnique.name,
+          actual: matchingUnique.name,
+          message: `Table "${tableName}" has unique constraint name mismatch: expected "${contractUnique.name}", got "${matchingUnique.name}"`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "unique",
+          name: `unique(${contractUnique.columns.join(", ")})`,
+          contractPath: uniquePath,
+          code: "unique_constraint_mismatch",
+          message: "Unique constraint name mismatch",
+          expected: contractUnique.name,
+          actual: matchingUnique.name,
+          children: []
+        });
+      } else {
+        nodes.push({
+          status: "pass",
+          kind: "unique",
+          name: `unique(${contractUnique.columns.join(", ")})`,
+          contractPath: uniquePath,
+          code: "",
+          message: "",
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+      }
+    }
+  }
+  if (strict) {
+    for (const schemaUnique of schemaUniques) {
+      const matchingUnique = contractUniques.find(
+        (u) => arraysEqual(u.columns, schemaUnique.columns)
+      );
+      if (!matchingUnique) {
+        issues.push({
+          kind: "unique_constraint_mismatch",
+          table: tableName,
+          message: `Extra unique constraint found in database (not in contract): ${schemaUnique.columns.join(", ")}`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "unique",
+          name: `unique(${schemaUnique.columns.join(", ")})`,
+          contractPath: `${tablePath}.uniques[${schemaUnique.columns.join(",")}]`,
+          code: "extra_unique_constraint",
+          message: "Extra unique constraint found",
+          expected: void 0,
+          actual: schemaUnique,
+          children: []
+        });
+      }
+    }
+  }
+  return nodes;
+}
+function compareIndexes(contractIndexes, schemaIndexes, tableName, tablePath, issues, strict) {
+  const nodes = [];
+  for (const contractIndex of contractIndexes) {
+    const indexPath = `${tablePath}.indexes[${contractIndex.columns.join(",")}]`;
+    const matchingIndex = schemaIndexes.find(
+      (idx) => arraysEqual(idx.columns, contractIndex.columns) && idx.unique === false
+    );
+    if (!matchingIndex) {
+      issues.push({
+        kind: "index_mismatch",
+        table: tableName,
+        expected: contractIndex.columns.join(", "),
+        message: `Table "${tableName}" is missing index: ${contractIndex.columns.join(", ")}`
+      });
+      nodes.push({
+        status: "fail",
+        kind: "index",
+        name: `index(${contractIndex.columns.join(", ")})`,
+        contractPath: indexPath,
+        code: "index_mismatch",
+        message: "Index missing",
+        expected: contractIndex,
+        actual: void 0,
+        children: []
+      });
+    } else {
+      if (contractIndex.name && matchingIndex.name && contractIndex.name !== matchingIndex.name) {
+        issues.push({
+          kind: "index_mismatch",
+          table: tableName,
+          indexOrConstraint: contractIndex.name,
+          expected: contractIndex.name,
+          actual: matchingIndex.name,
+          message: `Table "${tableName}" has index name mismatch: expected "${contractIndex.name}", got "${matchingIndex.name}"`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "index",
+          name: `index(${contractIndex.columns.join(", ")})`,
+          contractPath: indexPath,
+          code: "index_mismatch",
+          message: "Index name mismatch",
+          expected: contractIndex.name,
+          actual: matchingIndex.name,
+          children: []
+        });
+      } else {
+        nodes.push({
+          status: "pass",
+          kind: "index",
+          name: `index(${contractIndex.columns.join(", ")})`,
+          contractPath: indexPath,
+          code: "",
+          message: "",
+          expected: void 0,
+          actual: void 0,
+          children: []
+        });
+      }
+    }
+  }
+  if (strict) {
+    for (const schemaIndex of schemaIndexes) {
+      if (schemaIndex.unique) {
+        continue;
+      }
+      const matchingIndex = contractIndexes.find(
+        (idx) => arraysEqual(idx.columns, schemaIndex.columns)
+      );
+      if (!matchingIndex) {
+        issues.push({
+          kind: "index_mismatch",
+          table: tableName,
+          message: `Extra index found in database (not in contract): ${schemaIndex.columns.join(", ")}`
+        });
+        nodes.push({
+          status: "fail",
+          kind: "index",
+          name: `index(${schemaIndex.columns.join(", ")})`,
+          contractPath: `${tablePath}.indexes[${schemaIndex.columns.join(",")}]`,
+          code: "extra_index",
+          message: "Extra index found",
+          expected: void 0,
+          actual: schemaIndex,
+          children: []
+        });
+      }
+    }
+  }
+  return nodes;
+}
+function compareExtensions(contractExtensions, schemaExtensions, contractTarget, issues, _strict) {
+  const nodes = [];
+  if (!contractExtensions) {
+    return nodes;
+  }
+  const contractExtensionNames = Object.keys(contractExtensions).filter(
+    (name) => name !== contractTarget
+  );
+  for (const extName of contractExtensionNames) {
+    const extPath = `extensions.${extName}`;
+    const normalizedExtName = extName.toLowerCase().replace(/^pg/, "");
+    const matchingExt = schemaExtensions.find((e) => {
+      const normalizedE = e.toLowerCase();
+      if (normalizedE === normalizedExtName || normalizedE === extName.toLowerCase()) {
+        return true;
+      }
+      if (normalizedE.includes(normalizedExtName) || normalizedExtName.includes(normalizedE)) {
+        return true;
+      }
+      return false;
+    });
+    const extensionLabels = {
+      pg: "database is postgres",
+      pgvector: "vector extension is enabled",
+      vector: "vector extension is enabled"
+    };
+    const extensionLabel = extensionLabels[extName] ?? `extension "${extName}" is enabled`;
+    if (!matchingExt) {
+      issues.push({
+        kind: "extension_missing",
+        table: "",
+        message: `Extension "${extName}" is missing from database`
+      });
+      nodes.push({
+        status: "fail",
+        kind: "extension",
+        name: extensionLabel,
+        contractPath: extPath,
+        code: "extension_missing",
+        message: `Extension "${extName}" is missing`,
+        expected: void 0,
+        actual: void 0,
+        children: []
+      });
+    } else {
+      nodes.push({
+        status: "pass",
+        kind: "extension",
+        name: extensionLabel,
+        contractPath: extPath,
+        code: "",
+        message: "",
+        expected: void 0,
+        actual: void 0,
+        children: []
+      });
+    }
+  }
+  return nodes;
+}
+function computeCounts(node) {
+  let pass = 0;
+  let warn = 0;
+  let fail = 0;
+  function traverse(n) {
+    if (n.status === "pass") {
+      pass++;
+    } else if (n.status === "warn") {
+      warn++;
+    } else if (n.status === "fail") {
+      fail++;
+    }
+    if (n.children) {
+      for (const child of n.children) {
+        traverse(child);
+      }
+    }
+  }
+  traverse(node);
+  return {
+    pass,
+    warn,
+    fail,
+    totalNodes: pass + warn + fail
+  };
+}
+function createVerifyResult(options) {
+  const contract = {
+    coreHash: options.contractCoreHash
+  };
+  if (options.contractProfileHash) {
+    contract.profileHash = options.contractProfileHash;
+  }
+  const target = {
+    expected: options.expectedTargetId
+  };
+  if (options.actualTargetId) {
+    target.actual = options.actualTargetId;
+  }
+  const meta = {
+    contractPath: options.contractPath
+  };
+  if (options.configPath) {
+    meta.configPath = options.configPath;
+  }
+  const result = {
+    ok: options.ok,
+    summary: options.summary,
+    contract,
+    target,
+    meta,
+    timings: {
+      total: options.totalTime
+    }
+  };
+  if (options.code) {
+    result.code = options.code;
+  }
+  if (options.marker) {
+    result.marker = {
+      coreHash: options.marker.coreHash,
+      profileHash: options.marker.profileHash
+    };
+  }
+  if (options.missingCodecs) {
+    result.missingCodecs = options.missingCodecs;
+  }
+  if (options.codecCoverageSkipped) {
+    result.codecCoverageSkipped = options.codecCoverageSkipped;
+  }
+  return result;
+}
+function buildSqlTypeMetadataRegistry(options) {
+  const { target, adapter, extensions } = options;
+  const registry = /* @__PURE__ */ new Map();
+  const targetId = adapter.targetId;
+  const descriptors = [target, adapter, ...extensions];
+  for (const descriptor of descriptors) {
+    const manifest = descriptor.manifest;
+    const storageTypes = manifest.types?.storage;
+    if (!storageTypes) {
+      continue;
+    }
+    for (const storageType of storageTypes) {
+      if (storageType.familyId === "sql" && storageType.targetId === targetId) {
+        registry.set(storageType.typeId, {
+          typeId: storageType.typeId,
+          familyId: "sql",
+          targetId: storageType.targetId,
+          ...storageType.nativeType !== void 0 ? { nativeType: storageType.nativeType } : {}
+        });
+      }
+    }
+  }
+  return registry;
+}
+function createSqlFamilyInstance(options) {
+  const { target, adapter, extensions } = options;
+  const descriptors = [target, adapter, ...extensions];
+  const operationRegistry = assembleOperationRegistry(descriptors, convertOperationManifest);
+  const codecTypeImports = extractCodecTypeImports(descriptors);
+  const operationTypeImports = extractOperationTypeImports(descriptors);
+  const extensionIds = extractExtensionIds(adapter, target, extensions);
+  const typeMetadataRegistry = buildSqlTypeMetadataRegistry({ target, adapter, extensions });
+  function stripMappings(contract) {
+    if (typeof contract === "object" && contract !== null && "mappings" in contract) {
+      const { mappings: _mappings, ...contractIR } = contract;
+      return contractIR;
+    }
+    return contract;
+  }
+  return {
+    familyId: "sql",
+    operationRegistry,
+    codecTypeImports,
+    operationTypeImports,
+    extensionIds,
+    typeMetadataRegistry,
+    validateContractIR(contractJson) {
+      const validated = validateContract(contractJson);
+      const { mappings: _mappings, ...contractIR } = validated;
+      return contractIR;
+    },
+    async verify(verifyOptions) {
+      const { driver, contractIR, expectedTargetId, contractPath, configPath } = verifyOptions;
+      const startTime = Date.now();
+      if (typeof contractIR !== "object" || contractIR === null || !("coreHash" in contractIR) || !("target" in contractIR) || typeof contractIR.coreHash !== "string" || typeof contractIR.target !== "string") {
+        throw new Error("Contract is missing required fields: coreHash or target");
+      }
+      const contractCoreHash = contractIR.coreHash;
+      const contractProfileHash = "profileHash" in contractIR && typeof contractIR.profileHash === "string" ? contractIR.profileHash : void 0;
+      const contractTarget = contractIR.target;
+      const marker = await readMarker(driver);
+      let missingCodecs;
+      let codecCoverageSkipped = false;
+      const supportedTypeIds = collectSupportedCodecTypeIds([
+        adapter,
+        target,
+        ...extensions
+      ]);
+      if (supportedTypeIds.length === 0) {
+        codecCoverageSkipped = true;
+      } else {
+        const supportedSet = new Set(supportedTypeIds);
+        const usedTypeIds = extractCodecTypeIdsFromContract(contractIR);
+        const missing = usedTypeIds.filter((id) => !supportedSet.has(id));
+        if (missing.length > 0) {
+          missingCodecs = missing;
+        }
+      }
+      if (!marker) {
+        const totalTime2 = Date.now() - startTime;
+        return createVerifyResult({
+          ok: false,
+          code: "PN-RTM-3001",
+          summary: "Marker missing",
+          contractCoreHash,
+          expectedTargetId,
+          contractPath,
+          totalTime: totalTime2,
+          ...contractProfileHash ? { contractProfileHash } : {},
+          ...missingCodecs ? { missingCodecs } : {},
+          ...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+          ...configPath ? { configPath } : {}
+        });
+      }
+      if (contractTarget !== expectedTargetId) {
+        const totalTime2 = Date.now() - startTime;
+        return createVerifyResult({
+          ok: false,
+          code: "PN-RTM-3003",
+          summary: "Target mismatch",
+          contractCoreHash,
+          marker,
+          expectedTargetId,
+          actualTargetId: contractTarget,
+          contractPath,
+          totalTime: totalTime2,
+          ...contractProfileHash ? { contractProfileHash } : {},
+          ...missingCodecs ? { missingCodecs } : {},
+          ...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+          ...configPath ? { configPath } : {}
+        });
+      }
+      if (marker.coreHash !== contractCoreHash) {
+        const totalTime2 = Date.now() - startTime;
+        return createVerifyResult({
+          ok: false,
+          code: "PN-RTM-3002",
+          summary: "Hash mismatch",
+          contractCoreHash,
+          marker,
+          expectedTargetId,
+          contractPath,
+          totalTime: totalTime2,
+          ...contractProfileHash ? { contractProfileHash } : {},
+          ...missingCodecs ? { missingCodecs } : {},
+          ...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+          ...configPath ? { configPath } : {}
+        });
+      }
+      if (contractProfileHash && marker.profileHash !== contractProfileHash) {
+        const totalTime2 = Date.now() - startTime;
+        return createVerifyResult({
+          ok: false,
+          code: "PN-RTM-3002",
+          summary: "Hash mismatch",
+          contractCoreHash,
+          contractProfileHash,
+          marker,
+          expectedTargetId,
+          contractPath,
+          totalTime: totalTime2,
+          ...missingCodecs ? { missingCodecs } : {},
+          ...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+          ...configPath ? { configPath } : {}
+        });
+      }
+      const totalTime = Date.now() - startTime;
+      return createVerifyResult({
+        ok: true,
+        summary: "Database matches contract",
+        contractCoreHash,
+        marker,
+        expectedTargetId,
+        contractPath,
+        totalTime,
+        ...contractProfileHash ? { contractProfileHash } : {},
+        ...missingCodecs ? { missingCodecs } : {},
+        ...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+        ...configPath ? { configPath } : {}
+      });
+    },
+    async schemaVerify(options2) {
+      const { driver, contractIR, strict, contractPath, configPath } = options2;
+      const startTime = Date.now();
+      const contract = validateContract(contractIR);
+      const contractCoreHash = contract.coreHash;
+      const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : void 0;
+      const contractTarget = contract.target;
+      const controlAdapter = adapter.create();
+      const schemaIR = await controlAdapter.introspect(
+        driver,
+        contractIR
+      );
+      const issues = [];
+      const rootChildren = [];
+      const contractTables = contract.storage.tables;
+      const schemaTables = schemaIR.tables;
+      for (const [tableName, contractTable] of Object.entries(contractTables)) {
+        const schemaTable = schemaTables[tableName];
+        const tablePath = `storage.tables.${tableName}`;
+        if (!schemaTable) {
+          issues.push({
+            kind: "missing_table",
+            table: tableName,
+            message: `Table "${tableName}" is missing from database`
+          });
+          rootChildren.push({
+            status: "fail",
+            kind: "table",
+            name: `table ${tableName}`,
+            contractPath: tablePath,
+            code: "missing_table",
+            message: `Table "${tableName}" is missing`,
+            expected: void 0,
+            actual: void 0,
+            children: []
+          });
+          continue;
+        }
+        const tableChildren = [];
+        const columnNodes = [];
+        for (const [columnName, contractColumn] of Object.entries(contractTable.columns)) {
+          const schemaColumn = schemaTable.columns[columnName];
+          const columnPath = `${tablePath}.columns.${columnName}`;
+          if (!schemaColumn) {
+            issues.push({
+              kind: "missing_column",
+              table: tableName,
+              column: columnName,
+              message: `Column "${tableName}"."${columnName}" is missing from database`
+            });
+            columnNodes.push({
+              status: "fail",
+              kind: "column",
+              name: `${columnName}: missing`,
+              contractPath: columnPath,
+              code: "missing_column",
+              message: `Column "${columnName}" is missing`,
+              expected: void 0,
+              actual: void 0,
+              children: []
+            });
+            continue;
+          }
+          const columnChildren = [];
+          let columnStatus = "pass";
+          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: "fail",
+              kind: "type",
+              name: "type",
+              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: "unknown",
+              message: `Column "${tableName}"."${columnName}" has type mismatch: schema column has no nativeType`
+            });
+            columnChildren.push({
+              status: "fail",
+              kind: "type",
+              name: "type",
+              contractPath: `${columnPath}.nativeType`,
+              code: "type_mismatch",
+              message: "Schema column has no nativeType",
+              expected: contractNativeType,
+              actual: "unknown",
+              children: []
+            });
+            columnStatus = "fail";
+          } else if (contractNativeType !== schemaNativeType) {
+            issues.push({
+              kind: "type_mismatch",
+              table: tableName,
+              column: columnName,
+              expected: contractNativeType,
+              actual: schemaNativeType,
+              message: `Column "${tableName}"."${columnName}" has type mismatch: expected "${contractNativeType}", got "${schemaNativeType}"`
+            });
+            columnChildren.push({
+              status: "fail",
+              kind: "type",
+              name: "type",
+              contractPath: `${columnPath}.nativeType`,
+              code: "type_mismatch",
+              message: `Type mismatch: expected ${contractNativeType}, got ${schemaNativeType}`,
+              expected: contractNativeType,
+              actual: schemaNativeType,
+              children: []
+            });
+            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",
+              table: tableName,
+              column: columnName,
+              expected: String(contractColumn.nullable),
+              actual: String(schemaColumn.nullable),
+              message: `Column "${tableName}"."${columnName}" has nullability mismatch: expected ${contractColumn.nullable ? "nullable" : "not null"}, got ${schemaColumn.nullable ? "nullable" : "not null"}`
+            });
+            columnChildren.push({
+              status: "fail",
+              kind: "nullability",
+              name: "nullability",
+              contractPath: `${columnPath}.nullable`,
+              code: "nullability_mismatch",
+              message: `Nullability mismatch: expected ${contractColumn.nullable ? "nullable" : "not null"}, got ${schemaColumn.nullable ? "nullable" : "not null"}`,
+              expected: contractColumn.nullable,
+              actual: schemaColumn.nullable,
+              children: []
+            });
+            columnStatus = "fail";
+          }
+          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 = 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 : "";
+          columnNodes.push({
+            status: finalColumnStatus,
+            kind: "column",
+            name: `${columnName}: ${columnTypeDisplay} (${nullableText})`,
+            contractPath: columnPath,
+            code: columnCode,
+            message: columnMessage,
+            expected: void 0,
+            actual: void 0,
+            children: columnChildren
+          });
+        }
+        if (columnNodes.length > 0) {
+          const columnsStatus = columnNodes.some((c) => c.status === "fail") ? "fail" : columnNodes.some((c) => c.status === "warn") ? "warn" : "pass";
+          tableChildren.push({
+            status: columnsStatus,
+            kind: "columns",
+            name: "columns",
+            contractPath: `${tablePath}.columns`,
+            code: "",
+            message: "",
+            expected: void 0,
+            actual: void 0,
+            children: columnNodes
+          });
+        }
+        if (strict) {
+          for (const [columnName, schemaColumn] of Object.entries(schemaTable.columns)) {
+            if (!contractTable.columns[columnName]) {
+              issues.push({
+                kind: "missing_column",
+                table: tableName,
+                column: columnName,
+                message: `Extra column "${tableName}"."${columnName}" found in database (not in contract)`
+              });
+              columnNodes.push({
+                status: "fail",
+                kind: "column",
+                name: `${columnName}: extra`,
+                contractPath: `${tablePath}.columns.${columnName}`,
+                code: "extra_column",
+                message: `Extra column "${columnName}" found`,
+                expected: void 0,
+                actual: schemaColumn.nativeType,
+                children: []
+              });
+            }
+          }
+        }
+        if (contractTable.primaryKey) {
+          const pkStatus = comparePrimaryKey(
+            contractTable.primaryKey,
+            schemaTable.primaryKey,
+            tableName,
+            issues
+          );
+          if (pkStatus === "fail") {
+            tableChildren.push({
+              status: "fail",
+              kind: "primaryKey",
+              name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
+              contractPath: `${tablePath}.primaryKey`,
+              code: "primary_key_mismatch",
+              message: "Primary key mismatch",
+              expected: contractTable.primaryKey,
+              actual: schemaTable.primaryKey,
+              children: []
+            });
+          } else {
+            tableChildren.push({
+              status: "pass",
+              kind: "primaryKey",
+              name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
+              contractPath: `${tablePath}.primaryKey`,
+              code: "",
+              message: "",
+              expected: void 0,
+              actual: void 0,
+              children: []
+            });
+          }
+        } else if (schemaTable.primaryKey && strict) {
+          issues.push({
+            kind: "primary_key_mismatch",
+            table: tableName,
+            message: "Extra primary key found in database (not in contract)"
+          });
+          tableChildren.push({
+            status: "fail",
+            kind: "primaryKey",
+            name: `primary key: ${schemaTable.primaryKey.columns.join(", ")}`,
+            contractPath: `${tablePath}.primaryKey`,
+            code: "extra_primary_key",
+            message: "Extra primary key found",
+            expected: void 0,
+            actual: schemaTable.primaryKey,
+            children: []
+          });
+        }
+        const fkStatuses = compareForeignKeys(
+          contractTable.foreignKeys,
+          schemaTable.foreignKeys,
+          tableName,
+          tablePath,
+          issues,
+          strict
+        );
+        tableChildren.push(...fkStatuses);
+        const uniqueStatuses = compareUniqueConstraints(
+          contractTable.uniques,
+          schemaTable.uniques,
+          tableName,
+          tablePath,
+          issues,
+          strict
+        );
+        tableChildren.push(...uniqueStatuses);
+        const indexStatuses = compareIndexes(
+          contractTable.indexes,
+          schemaTable.indexes,
+          tableName,
+          tablePath,
+          issues,
+          strict
+        );
+        tableChildren.push(...indexStatuses);
+        const tableStatus = tableChildren.some((c) => c.status === "fail") ? "fail" : tableChildren.some((c) => c.status === "warn") ? "warn" : "pass";
+        const tableFailureMessages = tableChildren.filter((child) => child.status === "fail" && child.message).map((child) => child.message).filter((msg) => typeof msg === "string" && msg.length > 0);
+        const tableMessage = tableStatus === "fail" && tableFailureMessages.length > 0 ? `${tableFailureMessages.length} issue${tableFailureMessages.length === 1 ? "" : "s"}` : "";
+        const tableCode = tableStatus === "fail" && tableChildren.length > 0 && tableChildren[0] ? tableChildren[0].code : "";
+        rootChildren.push({
+          status: tableStatus,
+          kind: "table",
+          name: `table ${tableName}`,
+          contractPath: tablePath,
+          code: tableCode,
+          message: tableMessage,
+          expected: void 0,
+          actual: void 0,
+          children: tableChildren
+        });
+      }
+      if (strict) {
+        for (const tableName of Object.keys(schemaTables)) {
+          if (!contractTables[tableName]) {
+            issues.push({
+              kind: "missing_table",
+              table: tableName,
+              message: `Extra table "${tableName}" found in database (not in contract)`
+            });
+            rootChildren.push({
+              status: "fail",
+              kind: "table",
+              name: `table ${tableName}`,
+              contractPath: `storage.tables.${tableName}`,
+              code: "extra_table",
+              message: `Extra table "${tableName}" found`,
+              expected: void 0,
+              actual: void 0,
+              children: []
+            });
+          }
+        }
+      }
+      const extensionStatuses = compareExtensions(
+        contract.extensions,
+        schemaIR.extensions,
+        contractTarget,
+        issues,
+        strict
+      );
+      rootChildren.push(...extensionStatuses);
+      const rootStatus = rootChildren.some((c) => c.status === "fail") ? "fail" : rootChildren.some((c) => c.status === "warn") ? "warn" : "pass";
+      const root = {
+        status: rootStatus,
+        kind: "contract",
+        name: "contract",
+        contractPath: "",
+        code: "",
+        message: "",
+        expected: void 0,
+        actual: void 0,
+        children: rootChildren
+      };
+      const counts = computeCounts(root);
+      const ok = counts.fail === 0;
+      const code = ok ? void 0 : "PN-SCHEMA-0001";
+      const summary = ok ? "Database schema satisfies contract" : `Database schema does not satisfy contract (${counts.fail} failure${counts.fail === 1 ? "" : "s"})`;
+      const totalTime = Date.now() - startTime;
+      return {
+        ok,
+        ...code ? { code } : {},
+        summary,
+        contract: {
+          coreHash: contractCoreHash,
+          ...contractProfileHash ? { profileHash: contractProfileHash } : {}
+        },
+        target: {
+          expected: contractTarget,
+          actual: contractTarget
+        },
+        schema: {
+          issues,
+          root,
+          counts
+        },
+        meta: {
+          contractPath,
+          strict,
+          ...configPath ? { configPath } : {}
+        },
+        timings: {
+          total: totalTime
+        }
+      };
+    },
+    async sign(options2) {
+      const { driver, contractIR, contractPath, configPath } = options2;
+      const startTime = Date.now();
+      const contract = validateContract(contractIR);
+      const contractCoreHash = contract.coreHash;
+      const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : contractCoreHash;
+      const contractTarget = contract.target;
+      await driver.query(ensureSchemaStatement.sql, ensureSchemaStatement.params);
+      await driver.query(ensureTableStatement.sql, ensureTableStatement.params);
+      const existingMarker = await readMarker(driver);
+      let markerCreated = false;
+      let markerUpdated = false;
+      let previousHashes;
+      if (!existingMarker) {
+        const write = writeContractMarker({
+          coreHash: contractCoreHash,
+          profileHash: contractProfileHash,
+          contractJson: contractIR,
+          canonicalVersion: 1
+        });
+        await driver.query(write.insert.sql, write.insert.params);
+        markerCreated = true;
+      } else {
+        const existingCoreHash = existingMarker.coreHash;
+        const existingProfileHash = existingMarker.profileHash;
+        const coreHashMatches = existingCoreHash === contractCoreHash;
+        const profileHashMatches = existingProfileHash === contractProfileHash;
+        if (!coreHashMatches || !profileHashMatches) {
+          previousHashes = {
+            coreHash: existingCoreHash,
+            profileHash: existingProfileHash
+          };
+          const write = writeContractMarker({
+            coreHash: contractCoreHash,
+            profileHash: contractProfileHash,
+            contractJson: contractIR,
+            canonicalVersion: existingMarker.canonicalVersion ?? 1
+          });
+          await driver.query(write.update.sql, write.update.params);
+          markerUpdated = true;
+        }
+      }
+      let summary;
+      if (markerCreated) {
+        summary = "Database signed (marker created)";
+      } else if (markerUpdated) {
+        summary = `Database signed (marker updated from ${previousHashes?.coreHash ?? "unknown"})`;
+      } else {
+        summary = "Database already signed with this contract";
+      }
+      const totalTime = Date.now() - startTime;
+      return {
+        ok: true,
+        summary,
+        contract: {
+          coreHash: contractCoreHash,
+          profileHash: contractProfileHash
+        },
+        target: {
+          expected: contractTarget,
+          actual: contractTarget
+        },
+        marker: {
+          created: markerCreated,
+          updated: markerUpdated,
+          ...previousHashes ? { previous: previousHashes } : {}
+        },
+        meta: {
+          contractPath,
+          ...configPath ? { configPath } : {}
+        },
+        timings: {
+          total: totalTime
+        }
+      };
+    },
+    async introspect(options2) {
+      const { driver, contractIR } = options2;
+      const controlAdapter = adapter.create();
+      return controlAdapter.introspect(driver, contractIR);
+    },
+    toSchemaView(schema) {
+      const rootLabel = "contract";
+      const tableNodes = Object.entries(schema.tables).map(
+        ([tableName, table]) => {
+          const children = [];
+          const columnNodes = [];
+          for (const [columnName, column] of Object.entries(table.columns)) {
+            const nullableText = column.nullable ? "(nullable)" : "(not nullable)";
+            const typeDisplay = column.nativeType;
+            const label = `${columnName}: ${typeDisplay} ${nullableText}`;
+            columnNodes.push({
+              kind: "field",
+              id: `column-${tableName}-${columnName}`,
+              label,
+              meta: {
+                nativeType: column.nativeType,
+                nullable: column.nullable
+              }
+            });
+          }
+          if (columnNodes.length > 0) {
+            children.push({
+              kind: "collection",
+              id: `columns-${tableName}`,
+              label: "columns",
+              children: columnNodes
+            });
+          }
+          if (table.primaryKey) {
+            const pkColumns = table.primaryKey.columns.join(", ");
+            children.push({
+              kind: "index",
+              id: `primary-key-${tableName}`,
+              label: `primary key: ${pkColumns}`,
+              meta: {
+                columns: table.primaryKey.columns,
+                ...table.primaryKey.name ? { name: table.primaryKey.name } : {}
+              }
+            });
+          }
+          for (const unique of table.uniques) {
+            const name = unique.name ?? `${tableName}_${unique.columns.join("_")}_unique`;
+            const label = `unique ${name}`;
+            children.push({
+              kind: "index",
+              id: `unique-${tableName}-${name}`,
+              label,
+              meta: {
+                columns: unique.columns,
+                unique: true
+              }
+            });
+          }
+          for (const index of table.indexes) {
+            const name = index.name ?? `${tableName}_${index.columns.join("_")}_idx`;
+            const label = index.unique ? `unique index ${name}` : `index ${name}`;
+            children.push({
+              kind: "index",
+              id: `index-${tableName}-${name}`,
+              label,
+              meta: {
+                columns: index.columns,
+                unique: index.unique
+              }
+            });
+          }
+          const tableMeta = {};
+          if (table.primaryKey) {
+            tableMeta["primaryKey"] = table.primaryKey.columns;
+            if (table.primaryKey.name) {
+              tableMeta["primaryKeyName"] = table.primaryKey.name;
+            }
+          }
+          if (table.foreignKeys.length > 0) {
+            tableMeta["foreignKeys"] = table.foreignKeys.map((fk) => ({
+              columns: fk.columns,
+              referencedTable: fk.referencedTable,
+              referencedColumns: fk.referencedColumns,
+              ...fk.name ? { name: fk.name } : {}
+            }));
+          }
+          const node = {
+            kind: "entity",
+            id: `table-${tableName}`,
+            label: `table ${tableName}`,
+            ...Object.keys(tableMeta).length > 0 ? { meta: tableMeta } : {},
+            ...children.length > 0 ? { children } : {}
+          };
+          return node;
+        }
+      );
+      const extensionNodes = schema.extensions.map((extName) => ({
+        kind: "extension",
+        id: `extension-${extName}`,
+        label: `${extName} extension is enabled`
+      }));
+      const rootChildren = [...tableNodes, ...extensionNodes];
+      const rootNode = {
+        kind: "root",
+        id: "sql-schema",
+        label: rootLabel,
+        ...rootChildren.length > 0 ? { children: rootChildren } : {}
+      };
+      return {
+        root: rootNode
+      };
+    },
+    async emitContract({ contractIR }) {
+      const contractWithoutMappings = stripMappings(contractIR);
+      const validatedIR = this.validateContractIR(contractWithoutMappings);
+      const result = await emit(
+        validatedIR,
+        {
+          outputDir: "",
+          operationRegistry,
+          codecTypeImports,
+          operationTypeImports,
+          extensionIds
+        },
+        sqlTargetFamilyHook
+      );
+      return {
+        contractJson: result.contractJson,
+        contractDts: result.contractDts,
+        coreHash: result.coreHash,
+        profileHash: result.profileHash
+      };
+    }
+  };
+}
+
+// src/core/assembly.ts
+function assembleOperationRegistry(descriptors, convertOperationManifest2) {
+  const registry = createOperationRegistry();
+  for (const descriptor of descriptors) {
+    const operations = descriptor.manifest.operations ?? [];
+    for (const operationManifest of operations) {
+      const signature = convertOperationManifest2(operationManifest);
+      registry.register(signature);
+    }
+  }
+  return registry;
+}
+function extractCodecTypeImports(descriptors) {
+  const imports = [];
+  for (const descriptor of descriptors) {
+    const codecTypes = descriptor.manifest.types?.codecTypes;
+    if (codecTypes?.import) {
+      imports.push(codecTypes.import);
+    }
+  }
+  return imports;
+}
+function extractOperationTypeImports(descriptors) {
+  const imports = [];
+  for (const descriptor of descriptors) {
+    const operationTypes = descriptor.manifest.types?.operationTypes;
+    if (operationTypes?.import) {
+      imports.push(operationTypes.import);
+    }
+  }
+  return imports;
+}
+function extractExtensionIds(adapter, target, extensions) {
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (!seen.has(adapter.id)) {
+    ids.push(adapter.id);
+    seen.add(adapter.id);
+  }
+  if (!seen.has(target.id)) {
+    ids.push(target.id);
+    seen.add(target.id);
+  }
+  for (const ext of extensions) {
+    if (!seen.has(ext.id)) {
+      ids.push(ext.id);
+      seen.add(ext.id);
+    }
+  }
+  return ids;
+}
+function extractCodecTypeImportsFromPacks(packs) {
+  const imports = [];
+  for (const pack of packs) {
+    const codecTypes = pack.manifest.types?.codecTypes;
+    if (codecTypes?.import) {
+      imports.push(codecTypes.import);
+    }
+  }
+  return imports;
+}
+function extractOperationTypeImportsFromPacks(packs) {
+  const imports = [];
+  for (const pack of packs) {
+    const operationTypes = pack.manifest.types?.operationTypes;
+    if (operationTypes?.import) {
+      imports.push(operationTypes.import);
+    }
+  }
+  return imports;
+}
+function assembleOperationRegistryFromPacks(packs) {
+  const registry = createOperationRegistry();
+  for (const pack of packs) {
+    const operations = pack.manifest.operations ?? [];
+    for (const operationManifest of operations) {
+      const signature = convertOperationManifest(operationManifest);
+      registry.register(signature);
+    }
+  }
+  return registry;
+}
+function extractExtensionIdsFromPacks(packs) {
+  return packs.map((pack) => pack.manifest.id);
+}
+
+export {
+  extractCodecTypeImportsFromPacks,
+  extractOperationTypeImportsFromPacks,
+  assembleOperationRegistryFromPacks,
+  extractExtensionIdsFromPacks,
+  createSqlFamilyInstance
+};
+//# sourceMappingURL=chunk-LXRIZAYE.js.map