@prisma-next/family-sql 0.1.0-pr.64.2 → 0.1.0-pr.65.1

package/dist/exports/chunk-PVUVID3J.js

@@ -0,0 +1,62 @@
+// src/core/assembly.ts
+import { createOperationRegistry } from "@prisma-next/operations";
+function assembleOperationRegistry(descriptors, convertOperationManifest) {
+  const registry = createOperationRegistry();
+  for (const descriptor of descriptors) {
+    const operations = descriptor.operations ?? [];
+    for (const operationManifest of operations) {
+      const signature = convertOperationManifest(operationManifest);
+      registry.register(signature);
+    }
+  }
+  return registry;
+}
+function extractCodecTypeImports(descriptors) {
+  const imports = [];
+  for (const descriptor of descriptors) {
+    const types = descriptor.types;
+    const codecTypes = types?.codecTypes;
+    if (codecTypes?.import) {
+      imports.push(codecTypes.import);
+    }
+  }
+  return imports;
+}
+function extractOperationTypeImports(descriptors) {
+  const imports = [];
+  for (const descriptor of descriptors) {
+    const types = descriptor.types;
+    const operationTypes = 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;
+}
+
+export {
+  assembleOperationRegistry,
+  extractCodecTypeImports,
+  extractOperationTypeImports,
+  extractExtensionIds
+};
+//# sourceMappingURL=chunk-PVUVID3J.js.map

package/dist/exports/chunk-PVUVID3J.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/assembly.ts"],"sourcesContent":["import type { OperationManifest } from '@prisma-next/contract/pack-manifest-types';\nimport type { TypesImportSpec } from '@prisma-next/contract/types';\nimport type {\n  ControlAdapterDescriptor,\n  ControlExtensionDescriptor,\n  ControlTargetDescriptor,\n} from '@prisma-next/core-control-plane/types';\nimport type { OperationRegistry, OperationSignature } from '@prisma-next/operations';\nimport { createOperationRegistry } from '@prisma-next/operations';\n\n/**\n * Assembles an operation registry from descriptors (adapter, target, extensions).\n * Loops over descriptors, extracts operations, converts them using the provided\n * conversion function, and registers them in a new registry.\n */\nexport function assembleOperationRegistry(\n  descriptors: ReadonlyArray<\n    | ControlTargetDescriptor<'sql', string>\n    | ControlAdapterDescriptor<'sql', string>\n    | ControlExtensionDescriptor<'sql', string>\n  >,\n  convertOperationManifest: (manifest: OperationManifest) => OperationSignature,\n): OperationRegistry {\n  const registry = createOperationRegistry();\n\n  for (const descriptor of descriptors) {\n    const operations = descriptor.operations ?? [];\n    for (const operationManifest of operations as ReadonlyArray<OperationManifest>) {\n      const signature = convertOperationManifest(operationManifest);\n      registry.register(signature);\n    }\n  }\n\n  return registry;\n}\n\n/**\n * Extracts codec type imports from descriptors for contract.d.ts generation.\n */\nexport function extractCodecTypeImports(\n  descriptors: ReadonlyArray<\n    | ControlTargetDescriptor<'sql', string>\n    | ControlAdapterDescriptor<'sql', string>\n    | ControlExtensionDescriptor<'sql', string>\n  >,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const types = descriptor.types;\n    const codecTypes = types?.codecTypes;\n    if (codecTypes?.import) {\n      imports.push(codecTypes.import);\n    }\n  }\n\n  return imports;\n}\n\n/**\n * Extracts operation type imports from descriptors for contract.d.ts generation.\n */\nexport function extractOperationTypeImports(\n  descriptors: ReadonlyArray<\n    | ControlTargetDescriptor<'sql', string>\n    | ControlAdapterDescriptor<'sql', string>\n    | ControlExtensionDescriptor<'sql', string>\n  >,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const types = descriptor.types;\n    const operationTypes = types?.operationTypes;\n    if (operationTypes?.import) {\n      imports.push(operationTypes.import);\n    }\n  }\n\n  return imports;\n}\n\n/**\n * Extracts extension IDs from descriptors in deterministic order:\n * [adapter.id, target.id, ...extensions.map(e => e.id)]\n * Deduplicates while preserving stable order.\n */\nexport function extractExtensionIds(\n  adapter: ControlAdapterDescriptor<'sql', string>,\n  target: ControlTargetDescriptor<'sql', string>,\n  extensions: ReadonlyArray<ControlExtensionDescriptor<'sql', string>>,\n): ReadonlyArray<string> {\n  const ids: string[] = [];\n  const seen = new Set<string>();\n\n  // Add adapter first\n  if (!seen.has(adapter.id)) {\n    ids.push(adapter.id);\n    seen.add(adapter.id);\n  }\n\n  // Add target second\n  if (!seen.has(target.id)) {\n    ids.push(target.id);\n    seen.add(target.id);\n  }\n\n  // Add extensions in order\n  for (const ext of extensions) {\n    if (!seen.has(ext.id)) {\n      ids.push(ext.id);\n      seen.add(ext.id);\n    }\n  }\n\n  return ids;\n}\n"],"mappings":";AAQA,SAAS,+BAA+B;AAOjC,SAAS,0BACd,aAKA,0BACmB;AACnB,QAAM,WAAW,wBAAwB;AAEzC,aAAW,cAAc,aAAa;AACpC,UAAM,aAAa,WAAW,cAAc,CAAC;AAC7C,eAAW,qBAAqB,YAAgD;AAC9E,YAAM,YAAY,yBAAyB,iBAAiB;AAC5D,eAAS,SAAS,SAAS;AAAA,IAC7B;AAAA,EACF;AAEA,SAAO;AACT;AAKO,SAAS,wBACd,aAKgC;AAChC,QAAM,UAA6B,CAAC;AAEpC,aAAW,cAAc,aAAa;AACpC,UAAM,QAAQ,WAAW;AACzB,UAAM,aAAa,OAAO;AAC1B,QAAI,YAAY,QAAQ;AACtB,cAAQ,KAAK,WAAW,MAAM;AAAA,IAChC;AAAA,EACF;AAEA,SAAO;AACT;AAKO,SAAS,4BACd,aAKgC;AAChC,QAAM,UAA6B,CAAC;AAEpC,aAAW,cAAc,aAAa;AACpC,UAAM,QAAQ,WAAW;AACzB,UAAM,iBAAiB,OAAO;AAC9B,QAAI,gBAAgB,QAAQ;AAC1B,cAAQ,KAAK,eAAe,MAAM;AAAA,IACpC;AAAA,EACF;AAEA,SAAO;AACT;AAOO,SAAS,oBACd,SACA,QACA,YACuB;AACvB,QAAM,MAAgB,CAAC;AACvB,QAAM,OAAO,oBAAI,IAAY;AAG7B,MAAI,CAAC,KAAK,IAAI,QAAQ,EAAE,GAAG;AACzB,QAAI,KAAK,QAAQ,EAAE;AACnB,SAAK,IAAI,QAAQ,EAAE;AAAA,EACrB;AAGA,MAAI,CAAC,KAAK,IAAI,OAAO,EAAE,GAAG;AACxB,QAAI,KAAK,OAAO,EAAE;AAClB,SAAK,IAAI,OAAO,EAAE;AAAA,EACpB;AAGA,aAAW,OAAO,YAAY;AAC5B,QAAI,CAAC,KAAK,IAAI,IAAI,EAAE,GAAG;AACrB,UAAI,KAAK,IAAI,EAAE;AACf,WAAK,IAAI,IAAI,EAAE;AAAA,IACjB;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/exports/control.d.ts

@@ -1,5 +1,4 @@
 import { OperationRegistry } from '@prisma-next/operations';
-import { ExtensionPackManifest } from '@prisma-next/contract/pack-manifest-types';
 import { ControlFamilyDescriptor, ControlAdapterDescriptor, ControlDriverDescriptor, ControlExtensionDescriptor, MigrationOperationPolicy } from '@prisma-next/core-control-plane/types';
 export { MigrationOperationClass, MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerResult, TargetMigrationsCapability } from '@prisma-next/core-control-plane/types';
 import { SqlControlAdapter } from './control-adapter.js';
@@ -111,7 +110,7 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
     readonly kind: "family";
     readonly id = "sql";
     readonly familyId: "sql";
-    readonly manifest: ExtensionPackManifest;
+    readonly version = "0.0.1";
     readonly hook: {
         readonly id: "sql";
         readonly validateTypes: (ir: ContractIR, _ctx: ValidationContext) => void;

package/dist/exports/control.js

@@ -1,21 +1,531 @@
 import {
-  createSqlFamilyInstance
-} from "./chunk-RVUPZUZP.js";
-import "./chunk-C3GKWCKA.js";
-import "./chunk-UKUAX2QM.js";
+  collectSupportedCodecTypeIds,
+  readMarker
+} from "./chunk-C3GKWCKA.js";
+import {
+  assembleOperationRegistry,
+  extractCodecTypeImports,
+  extractExtensionIds,
+  extractOperationTypeImports
+} from "./chunk-PVUVID3J.js";
+import {
+  verifySqlSchema
+} from "./chunk-UKUAX2QM.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";
-var sqlFamilyManifest = {
-  id: "sql",
-  version: "0.0.1"
-};
+import { validateContract } from "@prisma-next/sql-contract-ts/contract";
+import {
+  ensureSchemaStatement,
+  ensureTableStatement,
+  writeContractMarker
+} from "@prisma-next/sql-runtime";
+import { ifDefined } from "@prisma-next/utils/defined";
+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 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 types = descriptor.types;
+    const storageTypes = 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, context, frameworkComponents } = options2;
+      const contract = validateContract(contractIR);
+      const controlAdapter = adapter.create();
+      const schemaIR = await controlAdapter.introspect(driver, contractIR);
+      return verifySqlSchema({
+        contract,
+        schema: schemaIR,
+        strict,
+        ...ifDefined("context", context),
+        typeMetadataRegistry,
+        frameworkComponents
+      });
+    },
+    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 readMarker(options2) {
+      return readMarker(options2.driver);
+    },
+    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 SqlFamilyDescriptor = class {
   kind = "family";
   id = "sql";
   familyId = "sql";
-  manifest = sqlFamilyManifest;
-  hook = sqlTargetFamilyHook;
+  version = "0.0.1";
+  hook = sqlTargetFamilyHook2;
   create(options) {
     return createSqlFamilyInstance({
       target: options.target,