@prisma-next/family-sql 0.1.0-dev.2 → 0.1.0-dev.21

package/dist/exports/control.js

@@ -1,1354 +1,11 @@
 import {
-  collectSupportedCodecTypeIds,
-  readMarker
-} from "./chunk-3HYKCN35.js";
+  createSqlFamilyInstance
+} from "./chunk-LECWNGKN.js";
+import "./chunk-C3GKWCKA.js";
+import "./chunk-54XYY6SU.js";
 
 // src/core/descriptor.ts
-import { sqlTargetFamilyHook as sqlTargetFamilyHook2 } from "@prisma-next/sql-contract-emitter";
-
-// 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";
-
-// src/core/assembly.ts
-import { createOperationRegistry } from "@prisma-next/operations";
-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;
-}
-
-// src/core/instance.ts
-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/descriptor.ts
 var sqlFamilyManifest = {
   id: "sql",
   version: "0.0.1"
@@ -1358,7 +15,7 @@ var SqlFamilyDescriptor = class {
   id = "sql";
   familyId = "sql";
   manifest = sqlFamilyManifest;
-  hook = sqlTargetFamilyHook2;
+  hook = sqlTargetFamilyHook;
   create(options) {
     return createSqlFamilyInstance({
       target: options.target,
@@ -1368,9 +25,129 @@ var SqlFamilyDescriptor = class {
   }
 };
 
+// src/core/migrations/plan-helpers.ts
+import { notOk, ok } from "@prisma-next/utils/result";
+var readOnlyEmptyObject = Object.freeze({});
+function cloneRecord(value) {
+  if (value === readOnlyEmptyObject) {
+    return value;
+  }
+  return Object.freeze({ ...value });
+}
+function freezeSteps(steps) {
+  if (steps.length === 0) {
+    return Object.freeze([]);
+  }
+  return Object.freeze(
+    steps.map(
+      (step) => Object.freeze({
+        description: step.description,
+        sql: step.sql,
+        ...step.meta ? { meta: cloneRecord(step.meta) } : {}
+      })
+    )
+  );
+}
+function freezeDetailsValue(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return Object.freeze([...value]);
+  }
+  return Object.freeze({ ...value });
+}
+function freezeTargetDetails(target) {
+  return Object.freeze({
+    id: target.id,
+    ...target.details !== void 0 ? { details: freezeDetailsValue(target.details) } : {}
+  });
+}
+function freezeOperation(operation) {
+  return Object.freeze({
+    id: operation.id,
+    label: operation.label,
+    ...operation.summary ? { summary: operation.summary } : {},
+    operationClass: operation.operationClass,
+    target: freezeTargetDetails(operation.target),
+    precheck: freezeSteps(operation.precheck),
+    execute: freezeSteps(operation.execute),
+    postcheck: freezeSteps(operation.postcheck),
+    ...operation.meta ? { meta: cloneRecord(operation.meta) } : {}
+  });
+}
+function freezeOperations(operations) {
+  if (operations.length === 0) {
+    return Object.freeze([]);
+  }
+  return Object.freeze(operations.map((operation) => freezeOperation(operation)));
+}
+function createMigrationPlan(options) {
+  return Object.freeze({
+    targetId: options.targetId,
+    ...options.origin !== void 0 ? { origin: options.origin ? Object.freeze({ ...options.origin }) : null } : {},
+    destination: Object.freeze({ ...options.destination }),
+    operations: freezeOperations(options.operations),
+    ...options.meta ? { meta: cloneRecord(options.meta) } : {}
+  });
+}
+function plannerSuccess(plan) {
+  return Object.freeze({
+    kind: "success",
+    plan
+  });
+}
+function plannerFailure(conflicts) {
+  return Object.freeze({
+    kind: "failure",
+    conflicts: Object.freeze(
+      conflicts.map(
+        (conflict) => Object.freeze({
+          kind: conflict.kind,
+          summary: conflict.summary,
+          ...conflict.why ? { why: conflict.why } : {},
+          ...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+          ...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
+        })
+      )
+    )
+  });
+}
+function runnerSuccess(value) {
+  return ok(
+    Object.freeze({
+      operationsPlanned: value.operationsPlanned,
+      operationsExecuted: value.operationsExecuted
+    })
+  );
+}
+function runnerFailure(code, summary, options) {
+  const failure = Object.freeze({
+    code,
+    summary,
+    ...options?.why ? { why: options.why } : {},
+    ...options?.meta ? { meta: cloneRecord(options.meta) } : {}
+  });
+  return notOk(failure);
+}
+
+// src/core/migrations/policies.ts
+var INIT_ADDITIVE_POLICY = Object.freeze({
+  allowedOperationClasses: Object.freeze(["additive"])
+});
+
 // src/exports/control.ts
 var control_default = new SqlFamilyDescriptor();
 export {
-  control_default as default
+  INIT_ADDITIVE_POLICY,
+  createMigrationPlan,
+  control_default as default,
+  plannerFailure,
+  plannerSuccess,
+  runnerFailure,
+  runnerSuccess
 };
 //# sourceMappingURL=control.js.map