@prisma-next/cli 0.5.0-dev.3 → 0.5.0-dev.30

package/dist/{contract-infer-BP3DrGgz.mjs → contract-infer-GztVCOCJ.mjs}

@@ -1,13 +1,12 @@
-import { d as setCommandExamples, m as parseGlobalFlags, n as addGlobalOptions, t as handleResult, u as setCommandDescriptions } from "./result-handler-CIyu0Pdt.mjs";
-import { t as TerminalUI } from "./terminal-ui-C5k88MmW.mjs";
-import { t as inspectLiveSchema } from "./inspect-live-schema-DWzf4Q_m.mjs";
+import { t as TerminalUI } from "./terminal-ui-u2YgKghu.mjs";
+import { d as setCommandExamples, m as parseGlobalFlags, n as addGlobalOptions, t as handleResult, u as setCommandDescriptions } from "./result-handler-BmVh8AeV.mjs";
+import { t as inspectLiveSchema } from "./inspect-live-schema-BaR9ISwa.mjs";
 import { Command } from "commander";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { notOk, ok } from "@prisma-next/utils/result";
 import { dirname, relative, resolve } from "pathe";
 import { errorRuntime } from "@prisma-next/errors/execution";
-import { printPsl, validatePrintableSqlSchemaIR } from "@prisma-next/psl-printer";
-import { createPostgresDefaultMapping, createPostgresTypeMap, extractEnumInfo, parseRawDefault } from "@prisma-next/psl-printer/postgres";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { printPsl } from "@prisma-next/psl-printer";
 
 //#region src/commands/contract-infer-paths.ts
 /**
@@ -35,20 +34,13 @@ async function executeContractInferCommand(options, ui, startTime) {
 		url: "https://pris.ly/contract-infer"
 	});
 	if (!inspectResult.ok) return inspectResult;
-	const { config, target, meta } = inspectResult.value;
-	if (target.familyId !== "sql") return notOk(errorRuntime(`contract infer is not supported for family "${target.familyId}"`, {
-		why: "contract infer currently supports SQL targets only",
-		fix: "Use an SQL target (e.g. Postgres) with this command"
+	const { config, target, meta, pslContractAst } = inspectResult.value;
+	if (!pslContractAst) return notOk(errorRuntime("contract infer is not supported for this family", {
+		why: "The configured family does not implement the PslContractInferCapable capability, so an inferred PSL contract cannot be produced from the live database schema.",
+		fix: "Use a family that supports contract inference (e.g. SQL/Postgres)."
 	}));
-	const schema = validatePrintableSqlSchemaIR(inspectResult.value.schema);
 	const outputPath = resolveContractInferOutputPath(options, config.contract?.output);
-	const enumInfo = extractEnumInfo(schema.annotations);
-	const pslContent = printPsl(schema, {
-		defaultMapping: createPostgresDefaultMapping(),
-		typeMap: createPostgresTypeMap(enumInfo.typeNames),
-		enumInfo,
-		parseRawDefault
-	});
+	const pslContent = printPsl(pslContractAst);
 	if (existsSync(outputPath) && !flags.json && !flags.quiet) ui.stderr(`\u26A0 Overwriting existing file: ${relative(process.cwd(), outputPath)}`);
 	mkdirSync(dirname(outputPath), { recursive: true });
 	writeFileSync(outputPath, pslContent, "utf-8");
@@ -87,4 +79,4 @@ function createContractInferCommand() {
 
 //#endregion
 export { createContractInferCommand as t };
-//# sourceMappingURL=contract-infer-BP3DrGgz.mjs.map
+//# sourceMappingURL=contract-infer-GztVCOCJ.mjs.map

package/dist/contract-infer-GztVCOCJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-infer-GztVCOCJ.mjs","names":[],"sources":["../src/commands/contract-infer-paths.ts","../src/commands/contract-infer.ts"],"sourcesContent":["import { dirname, resolve } from 'pathe';\n\ninterface ContractInferPathOptions {\n  readonly output?: string;\n  readonly config?: string;\n}\n\n/**\n * Resolves the output path for the inferred PSL contract.\n *\n * Priority:\n * 1. --output <path> flag (resolved relative to cwd)\n * 2. contract.prisma next to config.contract.output\n * 3. Canonical default: contract.prisma in the config directory\n */\nexport function resolveContractInferOutputPath(\n  options: ContractInferPathOptions,\n  contractOutput: string | undefined,\n): string {\n  const configDir = options.config\n    ? dirname(resolve(process.cwd(), options.config))\n    : process.cwd();\n\n  if (options.output) {\n    return resolve(process.cwd(), options.output);\n  }\n  if (contractOutput) {\n    const contractPath = resolve(configDir, contractOutput);\n    return resolve(dirname(contractPath), 'contract.prisma');\n  }\n  return resolve(configDir, 'contract.prisma');\n}\n","import { existsSync, mkdirSync, writeFileSync } from 'node:fs';\nimport { errorRuntime } from '@prisma-next/errors/execution';\nimport { printPsl } from '@prisma-next/psl-printer';\nimport { notOk, ok, type Result } from '@prisma-next/utils/result';\nimport { Command } from 'commander';\nimport { dirname, relative } from 'pathe';\nimport type { CliStructuredError } from '../utils/cli-errors';\nimport {\n  addGlobalOptions,\n  setCommandDescriptions,\n  setCommandExamples,\n} from '../utils/command-helpers';\nimport { parseGlobalFlags } from '../utils/global-flags';\nimport { handleResult } from '../utils/result-handler';\nimport { TerminalUI } from '../utils/terminal-ui';\nimport { resolveContractInferOutputPath } from './contract-infer-paths';\nimport {\n  type InspectLiveSchemaOptions,\n  type InspectLiveSchemaResult,\n  inspectLiveSchema,\n} from './inspect-live-schema';\n\ninterface ContractInferOptions extends InspectLiveSchemaOptions {\n  readonly output?: string;\n}\n\ninterface ContractInferSuccessResult {\n  readonly ok: true;\n  readonly summary: string;\n  readonly target: InspectLiveSchemaResult['target'];\n  readonly psl: {\n    readonly path: string;\n  };\n  readonly meta: InspectLiveSchemaResult['meta'];\n  readonly timings: {\n    readonly total: number;\n  };\n}\n\nasync function executeContractInferCommand(\n  options: ContractInferOptions,\n  ui: TerminalUI,\n  startTime: number,\n): Promise<Result<ContractInferSuccessResult, CliStructuredError>> {\n  const flags = parseGlobalFlags(options);\n  const inspectResult = await inspectLiveSchema(options, flags, ui, startTime, {\n    commandName: 'contract infer',\n    description: 'Infer a PSL contract from the live database schema',\n    url: 'https://pris.ly/contract-infer',\n  });\n\n  if (!inspectResult.ok) {\n    return inspectResult;\n  }\n\n  const { config, target, meta, pslContractAst } = inspectResult.value;\n\n  if (!pslContractAst) {\n    return notOk(\n      errorRuntime('contract infer is not supported for this family', {\n        why: 'The configured family does not implement the PslContractInferCapable capability, so an inferred PSL contract cannot be produced from the live database schema.',\n        fix: 'Use a family that supports contract inference (e.g. SQL/Postgres).',\n      }),\n    );\n  }\n\n  const outputPath = resolveContractInferOutputPath(options, config.contract?.output);\n  const pslContent = printPsl(pslContractAst);\n\n  if (existsSync(outputPath) && !flags.json && !flags.quiet) {\n    ui.stderr(`\\u26A0 Overwriting existing file: ${relative(process.cwd(), outputPath)}`);\n  }\n\n  mkdirSync(dirname(outputPath), { recursive: true });\n  writeFileSync(outputPath, pslContent, 'utf-8');\n\n  const pslPath = relative(process.cwd(), outputPath);\n  if (!flags.json && !flags.quiet) {\n    ui.stderr(`\\u2714 Contract written to ${pslPath}`);\n  }\n\n  return ok({\n    ok: true,\n    summary: 'Contract inferred successfully',\n    target,\n    psl: {\n      path: pslPath,\n    },\n    meta,\n    timings: {\n      total: Date.now() - startTime,\n    },\n  });\n}\n\nexport function createContractInferCommand(): Command {\n  const command = new Command('infer');\n  setCommandDescriptions(\n    command,\n    'Infer a PSL contract from the live database schema',\n    'Reads the live database schema and writes an inferred PSL contract to disk.\\n' +\n      'This command stops at `contract.prisma`; follow it with `contract emit` and\\n' +\n      '`db sign` as separate steps.',\n  );\n  setCommandExamples(command, [\n    'prisma-next contract infer --db $DATABASE_URL',\n    'prisma-next contract infer --db $DATABASE_URL --output ./prisma/contract.prisma',\n    'prisma-next contract infer --db $DATABASE_URL --json',\n  ]);\n  addGlobalOptions(command)\n    .option('--db <url>', 'Database connection string')\n    .option('--config <path>', 'Path to prisma-next.config.ts')\n    .option('--output <path>', 'Write the inferred PSL contract to the specified path')\n    .action(async (options: ContractInferOptions) => {\n      const flags = parseGlobalFlags(options);\n      const ui = new TerminalUI({ color: flags.color, interactive: flags.interactive });\n      const startTime = Date.now();\n\n      const result = await executeContractInferCommand(options, ui, startTime);\n      const exitCode = handleResult(result, flags, ui, (value) => {\n        if (flags.json) {\n          ui.output(JSON.stringify(value, null, 2));\n        }\n      });\n\n      process.exit(exitCode);\n    });\n\n  return command;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAeA,SAAgB,+BACd,SACA,gBACQ;CACR,MAAM,YAAY,QAAQ,SACtB,QAAQ,QAAQ,QAAQ,KAAK,EAAE,QAAQ,OAAO,CAAC,GAC/C,QAAQ,KAAK;AAEjB,KAAI,QAAQ,OACV,QAAO,QAAQ,QAAQ,KAAK,EAAE,QAAQ,OAAO;AAE/C,KAAI,eAEF,QAAO,QAAQ,QADM,QAAQ,WAAW,eAAe,CACnB,EAAE,kBAAkB;AAE1D,QAAO,QAAQ,WAAW,kBAAkB;;;;;ACS9C,eAAe,4BACb,SACA,IACA,WACiE;CACjE,MAAM,QAAQ,iBAAiB,QAAQ;CACvC,MAAM,gBAAgB,MAAM,kBAAkB,SAAS,OAAO,IAAI,WAAW;EAC3E,aAAa;EACb,aAAa;EACb,KAAK;EACN,CAAC;AAEF,KAAI,CAAC,cAAc,GACjB,QAAO;CAGT,MAAM,EAAE,QAAQ,QAAQ,MAAM,mBAAmB,cAAc;AAE/D,KAAI,CAAC,eACH,QAAO,MACL,aAAa,mDAAmD;EAC9D,KAAK;EACL,KAAK;EACN,CAAC,CACH;CAGH,MAAM,aAAa,+BAA+B,SAAS,OAAO,UAAU,OAAO;CACnF,MAAM,aAAa,SAAS,eAAe;AAE3C,KAAI,WAAW,WAAW,IAAI,CAAC,MAAM,QAAQ,CAAC,MAAM,MAClD,IAAG,OAAO,qCAAqC,SAAS,QAAQ,KAAK,EAAE,WAAW,GAAG;AAGvF,WAAU,QAAQ,WAAW,EAAE,EAAE,WAAW,MAAM,CAAC;AACnD,eAAc,YAAY,YAAY,QAAQ;CAE9C,MAAM,UAAU,SAAS,QAAQ,KAAK,EAAE,WAAW;AACnD,KAAI,CAAC,MAAM,QAAQ,CAAC,MAAM,MACxB,IAAG,OAAO,8BAA8B,UAAU;AAGpD,QAAO,GAAG;EACR,IAAI;EACJ,SAAS;EACT;EACA,KAAK,EACH,MAAM,SACP;EACD;EACA,SAAS,EACP,OAAO,KAAK,KAAK,GAAG,WACrB;EACF,CAAC;;AAGJ,SAAgB,6BAAsC;CACpD,MAAM,UAAU,IAAI,QAAQ,QAAQ;AACpC,wBACE,SACA,sDACA,yLAGD;AACD,oBAAmB,SAAS;EAC1B;EACA;EACA;EACD,CAAC;AACF,kBAAiB,QAAQ,CACtB,OAAO,cAAc,6BAA6B,CAClD,OAAO,mBAAmB,gCAAgC,CAC1D,OAAO,mBAAmB,wDAAwD,CAClF,OAAO,OAAO,YAAkC;EAC/C,MAAM,QAAQ,iBAAiB,QAAQ;EACvC,MAAM,KAAK,IAAI,WAAW;GAAE,OAAO,MAAM;GAAO,aAAa,MAAM;GAAa,CAAC;EAIjF,MAAM,WAAW,aADF,MAAM,4BAA4B,SAAS,IAFxC,KAAK,KAAK,CAE4C,EAClC,OAAO,KAAK,UAAU;AAC1D,OAAI,MAAM,KACR,IAAG,OAAO,KAAK,UAAU,OAAO,MAAM,EAAE,CAAC;IAE3C;AAEF,UAAQ,KAAK,SAAS;GACtB;AAEJ,QAAO"}

package/dist/exports/control-api.d.mts

@@ -1,8 +1,9 @@
 import { Result } from "@prisma-next/utils/result";
 import { ContractSourceDiagnostics, ContractSourceProvider } from "@prisma-next/config/config-types";
-import { ControlAdapterDescriptor, ControlDriverDescriptor, ControlExtensionDescriptor, ControlFamilyDescriptor, ControlStack, ControlTargetDescriptor, CoreSchemaView, MigrationPlanOperation, MigrationPlannerConflict, SignDatabaseResult, SignDatabaseResult as SignDatabaseResult$1, VerifyDatabaseResult, VerifyDatabaseResult as VerifyDatabaseResult$1, VerifyDatabaseSchemaResult, VerifyDatabaseSchemaResult as VerifyDatabaseSchemaResult$1 } from "@prisma-next/framework-components/control";
+import { ControlAdapterDescriptor, ControlDriverDescriptor, ControlExtensionDescriptor, ControlFamilyDescriptor, ControlStack, ControlTargetDescriptor, CoreSchemaView, MigrationPlanOperation, MigrationPlannerConflict, OperationPreview, SignDatabaseResult, SignDatabaseResult as SignDatabaseResult$1, VerifyDatabaseResult, VerifyDatabaseResult as VerifyDatabaseResult$1, VerifyDatabaseSchemaResult, VerifyDatabaseSchemaResult as VerifyDatabaseSchemaResult$1 } from "@prisma-next/framework-components/control";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
 import { Contract, ContractMarkerRecord } from "@prisma-next/contract/types";
+import { PslDocumentAst } from "@prisma-next/framework-components/psl-ast";
 
 //#region src/control-api/types.d.ts
 
@@ -228,7 +229,14 @@ interface DbInitSuccess {
       readonly label: string;
       readonly operationClass: string;
     }>;
-    readonly sql?: ReadonlyArray<string>;
+    /**
+     * Family-agnostic textual preview of the planned operations, e.g.
+     * `language: 'sql'` for SQL families and `language: 'mongodb-shell'`
+     * for the Mongo family. Replaces the previous `sql?: readonly string[]`
+     * field; consumers that previously read `plan.sql` should read
+     * `plan.preview?.statements.map((s) => s.text)`.
+     */
+    readonly preview?: OperationPreview;
   };
   readonly destination: {
     readonly storageHash: string;
@@ -282,7 +290,14 @@ interface DbUpdateSuccess {
       readonly label: string;
       readonly operationClass: string;
     }>;
-    readonly sql?: ReadonlyArray<string>;
+    /**
+     * Family-agnostic textual preview of the planned operations, e.g.
+     * `language: 'sql'` for SQL families and `language: 'mongodb-shell'`
+     * for the Mongo family. Replaces the previous `sql?: readonly string[]`
+     * field; consumers that previously read `plan.sql` should read
+     * `plan.preview?.statements.map((s) => s.text)`.
+     */
+    readonly preview?: OperationPreview;
   };
   readonly destination: {
     readonly storageHash: string;
@@ -358,7 +373,7 @@ type EmitResult = Result<EmitSuccess, EmitFailure>;
  */
 interface MigrationApplyStep {
   readonly dirName: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly toContract: Contract;
   readonly operations: readonly MigrationPlanOperation[];
@@ -395,7 +410,7 @@ interface MigrationApplyOptions {
  */
 interface MigrationApplyAppliedEntry {
   readonly dirName: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly operationsExecuted: number;
 }
@@ -427,17 +442,30 @@ interface MigrationApplyFailure {
 type MigrationApplyResult = Result<MigrationApplySuccess, MigrationApplyFailure>;
 /**
  * Options for the standalone executeContractEmit function.
- * Used by tooling (e.g., Vite plugin) that needs to emit contracts
- * without the full ControlClient infrastructure.
+ *
+ * `executeContractEmit` is the canonical publication path for both the
+ * `prisma-next contract emit` CLI command and the `@prisma-next/vite-plugin-contract-emit`
+ * Vite plugin. Do not duplicate the load → emit → publish dance elsewhere; if a
+ * caller needs additional behavior, extend this options shape and update the
+ * single implementation rather than building a parallel publication path.
+ *
+ * Concurrent calls for the same output JSON path are serialized per-output via
+ * a FIFO queue; concurrent calls for distinct outputs run in parallel.
  */
 interface ContractEmitOptions {
   /** Path to the prisma-next.config.ts file */
   readonly configPath: string;
-  /** Optional AbortSignal for cancellation support */
+  /** Optional AbortSignal for cancelling the in-flight emit */
   readonly signal?: AbortSignal;
+  /** Optional progress callback for observing source-resolution and emit spans */
+  readonly onProgress?: OnControlProgress;
 }
 /**
  * Result from the standalone executeContractEmit function.
+ *
+ * Always describes the bytes that were just published to disk. Failures throw
+ * (config / source-resolution / emit / publish) — callers do not need to
+ * branch on a result discriminator.
  */
 interface ContractEmitResult {
   /** Hash of the storage contract (schema-level) */
@@ -453,6 +481,12 @@ interface ContractEmitResult {
     /** Path to the emitted contract.d.ts file */
     readonly dts: string;
   };
+  /**
+   * Warning surfaced by `validateContractDeps` after a successful publication.
+   * Callers (CLI, Vite plugin) decide how to render this; the operation does
+   * not write to stderr itself. Undefined when no warning was raised.
+   */
+  readonly validationWarning?: string;
 }
 /**
  * Programmatic control client for Prisma Next operations.
@@ -569,6 +603,23 @@ interface ControlClient {
    * @returns CoreSchemaView if the family supports it, undefined otherwise
    */
   toSchemaView(schemaIR: unknown): CoreSchemaView | undefined;
+  /**
+   * Infers a PSL contract AST from an introspected schema IR.
+   * Delegates to the family instance's inferPslContract method.
+   *
+   * @param schemaIR - The schema IR from introspect()
+   * @returns PslDocumentAst if the family supports the capability, undefined otherwise
+   */
+  inferPslContract(schemaIR: unknown): PslDocumentAst | undefined;
+  /**
+   * Renders a textual preview of a migration plan's operations for the CLI's
+   * "DDL preview" output. Delegates to the family instance's
+   * `toOperationPreview` method.
+   *
+   * @param operations - The migration plan operations to render
+   * @returns OperationPreview if the family supports the capability, undefined otherwise
+   */
+  toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview | undefined;
   /**
    * Emits the contract to JSON and TypeScript declarations.
    * This is an offline operation that does NOT require a database connection.
@@ -602,23 +653,29 @@ declare function enrichContract(ir: Contract, components: ReadonlyArray<TargetBo
 //#endregion
 //#region src/control-api/operations/contract-emit.d.ts
 /**
- * Executes the contract emit operation.
+ * Canonical contract emit operation.
  *
- * This is an offline operation that:
- * 1. Loads the Prisma Next config from the specified path
- * 2. Resolves the contract source from config
- * 3. Creates a control plane stack and family instance
- * 4. Emits contract artifacts (JSON and DTS)
- * 5. Writes files to the paths specified in config
+ * This is the SINGLE publication path used by both the CLI command
+ * (`prisma-next contract emit`) and the Vite plugin
+ * (`@prisma-next/vite-plugin-contract-emit`). New callers must go through this
+ * function rather than re-implementing load → emit → publish.
  *
- * Supports AbortSignal for cancellation, enabling "last change wins" behavior.
+ * The whole flow (load config → resolve source → emit bytes → atomic publish)
+ * is serialized per output JSON path via `queueEmitByOutput`. Concurrent calls
+ * for the same output line up FIFO; the user-visible outcome is "last
+ * submission wins on disk" without any supersession bookkeeping. Within a
+ * single emit, `publishContractArtifactPair` stages temp files, renames
+ * `contract.d.ts` before `contract.json`, and attempts to restore the previous
+ * pair if either rename fails — so type-only consumers never observe a
+ * mismatched pair.
  *
- * @param options - Options including configPath and optional signal
- * @returns File paths and hashes of emitted artifacts
- * @throws If config loading fails, contract is invalid, or file I/O fails
- * @throws signal.reason if cancelled via AbortSignal (typically DOMException with name 'AbortError')
+ * @throws {CliStructuredError} on config/source/validation problems
+ * @throws {DOMException} `AbortError` if cancelled via `signal`
  */
 declare function executeContractEmit(options: ContractEmitOptions): Promise<ContractEmitResult>;
 //#endregion
-export { type ContractEmitOptions, type ContractEmitResult, type ControlActionName, type ControlClient, type ControlClientOptions, type ControlProgressEvent, type ControlStack, type DbInitFailure, type DbInitFailureCode, type DbInitOptions, type DbInitResult, type DbInitSuccess, type DbUpdateFailure, type DbUpdateFailureCode, type DbUpdateOptions, type DbUpdateResult, type DbUpdateSuccess, type EmitContractConfig, type EmitFailure, type EmitFailureCode, type EmitOptions, type EmitResult, type EmitSuccess, type IntrospectOptions, type OnControlProgress, type SchemaVerifyOptions, type SignDatabaseResult, type SignOptions, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, type VerifyOptions, createControlClient, enrichContract, executeContractEmit };
+//#region src/utils/emit-queue.d.ts
+declare function disposeEmitQueue(outputJsonPath: string): void;
+//#endregion
+export { type ContractEmitOptions, type ContractEmitResult, type ControlActionName, type ControlClient, type ControlClientOptions, type ControlProgressEvent, type ControlStack, type DbInitFailure, type DbInitFailureCode, type DbInitOptions, type DbInitResult, type DbInitSuccess, type DbUpdateFailure, type DbUpdateFailureCode, type DbUpdateOptions, type DbUpdateResult, type DbUpdateSuccess, type EmitContractConfig, type EmitFailure, type EmitFailureCode, type EmitOptions, type EmitResult, type EmitSuccess, type IntrospectOptions, type OnControlProgress, type SchemaVerifyOptions, type SignDatabaseResult, type SignOptions, type VerifyDatabaseResult, type VerifyDatabaseSchemaResult, type VerifyOptions, createControlClient, disposeEmitQueue, enrichContract, executeContractEmit };
 //# sourceMappingURL=control-api.d.mts.map

package/dist/exports/control-api.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control-api.d.mts","names":[],"sources":["../../src/control-api/types.ts","../../src/control-api/client.ts","../../src/control-api/contract-enrichment.ts","../../src/control-api/operations/contract-emit.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"control-api.d.mts","names":[],"sources":["../../src/control-api/types.ts","../../src/control-api/client.ts","../../src/control-api/contract-enrichment.ts","../../src/control-api/operations/contract-emit.ts","../../src/utils/emit-queue.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/exports/control-api.mjs

@@ -1,6 +1,8 @@
-import "../config-loader-_W4T21X1.mjs";
-import { t as enrichContract } from "../contract-enrichment-CGW6mm-E.mjs";
-import { t as createControlClient } from "../client-TG7rbCWT.mjs";
-import { t as executeContractEmit } from "../contract-emit-CQfj7xJn.mjs";
+import "../config-loader-ih8ViDb_.mjs";
+import "../cli-errors-By1iVE3z.mjs";
+import { n as disposeEmitQueue, t as executeContractEmit } from "../contract-emit-RZBWzkop.mjs";
+import "../framework-components-Bgcre3Z6.mjs";
+import { t as enrichContract } from "../contract-enrichment-4Ptgw3Pe.mjs";
+import { t as createControlClient } from "../client-keSCAgjW.mjs";
 
-export { createControlClient, enrichContract, executeContractEmit };
+export { createControlClient, disposeEmitQueue, enrichContract, executeContractEmit };

package/dist/exports/index.mjs

@@ -1,7 +1,12 @@
-import "../config-loader-_W4T21X1.mjs";
-import { t as createContractEmitCommand } from "../contract-emit-CNYyzJwF.mjs";
-import { existsSync, unlinkSync, writeFileSync } from "node:fs";
+import "../config-loader-ih8ViDb_.mjs";
+import "../cli-errors-By1iVE3z.mjs";
+import "../contract-emit-RZBWzkop.mjs";
+import "../framework-components-Bgcre3Z6.mjs";
+import "../terminal-ui-u2YgKghu.mjs";
+import "../result-handler-BmVh8AeV.mjs";
+import { t as createContractEmitCommand } from "../contract-emit-DWtGQYCD.mjs";
 import { join } from "pathe";
+import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { pathToFileURL } from "node:url";
 import { build } from "esbuild";

package/dist/exports/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["value","disallowedImports: string[]","contract: unknown"],"sources":["../../src/load-ts-contract.ts"],"sourcesContent":["import { existsSync, unlinkSync, writeFileSync } from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { pathToFileURL } from 'node:url';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { Plugin } from 'esbuild';\nimport { build } from 'esbuild';\nimport { join } from 'pathe';\n\nexport interface LoadTsContractOptions {\n  readonly allowlist?: ReadonlyArray<string>;\n}\n\nconst DEFAULT_ALLOWLIST = ['@prisma-next/*', 'node:crypto'];\n\nfunction isAllowedImport(importPath: string, allowlist: ReadonlyArray<string>): boolean {\n  for (const pattern of allowlist) {\n    if (pattern.endsWith('/*')) {\n      const prefix = pattern.slice(0, -2);\n      if (importPath === prefix || importPath.startsWith(`${prefix}/`)) {\n        return true;\n      }\n    } else if (pattern.endsWith('*')) {\n      const prefix = pattern.slice(0, -1);\n      if (importPath.startsWith(prefix)) {\n        return true;\n      }\n    } else if (importPath === pattern) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction validatePurity(value: unknown): void {\n  if (typeof value !== 'object' || value === null) {\n    return;\n  }\n\n  const path = new WeakSet();\n\n  function check(value: unknown): void {\n    if (value === null || typeof value !== 'object') {\n      return;\n    }\n\n    if (path.has(value)) {\n      throw new Error('Contract export contains circular references');\n    }\n    path.add(value);\n\n    try {\n      for (const key in value) {\n        const descriptor = Object.getOwnPropertyDescriptor(value, key);\n        if (descriptor && (descriptor.get || descriptor.set)) {\n          throw new Error(`Contract export contains getter/setter at key \"${key}\"`);\n        }\n        if (descriptor && typeof descriptor.value === 'function') {\n          throw new Error(`Contract export contains function at key \"${key}\"`);\n        }\n        check((value as Record<string, unknown>)[key]);\n      }\n    } finally {\n      path.delete(value);\n    }\n  }\n\n  try {\n    check(value);\n    JSON.stringify(value);\n  } catch (error) {\n    if (error instanceof Error) {\n      if (error.message.includes('getter') || error.message.includes('circular')) {\n        throw error;\n      }\n      throw new Error(`Contract export is not JSON-serializable: ${error.message}`);\n    }\n    throw new Error('Contract export is not JSON-serializable');\n  }\n}\n\nfunction createImportAllowlistPlugin(allowlist: ReadonlyArray<string>, entryPath: string): Plugin {\n  return {\n    name: 'import-allowlist',\n    setup(build) {\n      build.onResolve({ filter: /.*/ }, (args) => {\n        if (args.kind === 'entry-point') {\n          return undefined;\n        }\n        if (args.path.startsWith('.') || args.path.startsWith('/')) {\n          return undefined;\n        }\n        const isFromEntryPoint = args.importer === entryPath || args.importer === '<stdin>';\n        if (isFromEntryPoint && !isAllowedImport(args.path, allowlist)) {\n          return {\n            path: args.path,\n            external: true,\n          };\n        }\n        return undefined;\n      });\n    },\n  };\n}\n\n/**\n * Loads a contract from a TypeScript file and returns it as Contract.\n *\n * **Responsibility: Parsing Only**\n * This function loads and parses a TypeScript contract file. It does NOT normalize the contract.\n * The contract should already be normalized if it was built using the contract builder.\n *\n * Normalization must happen in the contract builder when the contract is created.\n * This function only validates that the contract is JSON-serializable and returns it as-is.\n *\n * @param entryPath - Path to the TypeScript contract file\n * @param options - Optional configuration (import allowlist)\n * @returns The contract as Contract (should already be normalized)\n * @throws Error if the contract cannot be loaded or is not JSON-serializable\n */\nexport async function loadContractFromTs(\n  entryPath: string,\n  options?: LoadTsContractOptions,\n): Promise<Contract> {\n  const allowlist = options?.allowlist ?? DEFAULT_ALLOWLIST;\n\n  if (!existsSync(entryPath)) {\n    throw new Error(`Contract file not found: ${entryPath}`);\n  }\n\n  const tempFile = join(\n    tmpdir(),\n    `prisma-next-contract-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`,\n  );\n\n  try {\n    const result = await build({\n      entryPoints: [entryPath],\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      target: 'es2022',\n      outfile: tempFile,\n      write: false,\n      metafile: true,\n      plugins: [createImportAllowlistPlugin(allowlist, entryPath)],\n      logLevel: 'error',\n    });\n\n    if (result.errors.length > 0) {\n      const errorMessages = result.errors.map((e: { text: string }) => e.text).join('\\n');\n      throw new Error(`Failed to bundle contract file: ${errorMessages}`);\n    }\n\n    if (!result.outputFiles || result.outputFiles.length === 0) {\n      throw new Error('No output files generated from bundling');\n    }\n\n    const disallowedImports: string[] = [];\n    if (result.metafile) {\n      const inputs = result.metafile.inputs;\n      for (const [, inputData] of Object.entries(inputs)) {\n        const imports =\n          (inputData as { imports?: Array<{ path: string; external?: boolean }> }).imports || [];\n        for (const imp of imports) {\n          if (\n            imp.external &&\n            !imp.path.startsWith('.') &&\n            !imp.path.startsWith('/') &&\n            !isAllowedImport(imp.path, allowlist)\n          ) {\n            disallowedImports.push(imp.path);\n          }\n        }\n      }\n    }\n\n    if (disallowedImports.length > 0) {\n      throw new Error(\n        `Disallowed imports detected. Only imports matching the allowlist are permitted:\\n  Allowlist: ${allowlist.join(', ')}\\n  Disallowed imports: ${disallowedImports.join(', ')}\\n\\nOnly @prisma-next/* packages are allowed in contract files.`,\n      );\n    }\n\n    const bundleContent = result.outputFiles[0]?.text;\n    if (bundleContent === undefined) {\n      throw new Error('Bundle content is undefined');\n    }\n    writeFileSync(tempFile, bundleContent, 'utf-8');\n\n    const module = (await import(/* @vite-ignore */ pathToFileURL(tempFile).href)) as {\n      default?: unknown;\n      contract?: unknown;\n    };\n    unlinkSync(tempFile);\n\n    let contract: unknown;\n\n    if (module.default !== undefined) {\n      contract = module.default;\n    } else if (module.contract !== undefined) {\n      contract = module.contract;\n    } else {\n      throw new Error(\n        `Contract file must export a contract as default export or named export 'contract'. Found exports: ${Object.keys(module as Record<string, unknown>).join(', ') || 'none'}`,\n      );\n    }\n\n    if (typeof contract !== 'object' || contract === null) {\n      throw new Error(`Contract export must be an object, got ${typeof contract}`);\n    }\n\n    validatePurity(contract);\n\n    return contract as Contract;\n  } catch (error) {\n    try {\n      if (tempFile) {\n        unlinkSync(tempFile);\n      }\n    } catch {\n      // Ignore cleanup errors\n    }\n\n    if (error instanceof Error) {\n      throw error;\n    }\n    throw new Error(`Failed to load contract from ${entryPath}: ${String(error)}`);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["value","disallowedImports: string[]","contract: unknown"],"sources":["../../src/load-ts-contract.ts"],"sourcesContent":["import { existsSync, unlinkSync, writeFileSync } from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { pathToFileURL } from 'node:url';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { Plugin } from 'esbuild';\nimport { build } from 'esbuild';\nimport { join } from 'pathe';\n\nexport interface LoadTsContractOptions {\n  readonly allowlist?: ReadonlyArray<string>;\n}\n\nconst DEFAULT_ALLOWLIST = ['@prisma-next/*', 'node:crypto'];\n\nfunction isAllowedImport(importPath: string, allowlist: ReadonlyArray<string>): boolean {\n  for (const pattern of allowlist) {\n    if (pattern.endsWith('/*')) {\n      const prefix = pattern.slice(0, -2);\n      if (importPath === prefix || importPath.startsWith(`${prefix}/`)) {\n        return true;\n      }\n    } else if (pattern.endsWith('*')) {\n      const prefix = pattern.slice(0, -1);\n      if (importPath.startsWith(prefix)) {\n        return true;\n      }\n    } else if (importPath === pattern) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction validatePurity(value: unknown): void {\n  if (typeof value !== 'object' || value === null) {\n    return;\n  }\n\n  const path = new WeakSet();\n\n  function check(value: unknown): void {\n    if (value === null || typeof value !== 'object') {\n      return;\n    }\n\n    if (path.has(value)) {\n      throw new Error('Contract export contains circular references');\n    }\n    path.add(value);\n\n    try {\n      for (const key in value) {\n        const descriptor = Object.getOwnPropertyDescriptor(value, key);\n        if (descriptor && (descriptor.get || descriptor.set)) {\n          throw new Error(`Contract export contains getter/setter at key \"${key}\"`);\n        }\n        if (descriptor && typeof descriptor.value === 'function') {\n          throw new Error(`Contract export contains function at key \"${key}\"`);\n        }\n        check((value as Record<string, unknown>)[key]);\n      }\n    } finally {\n      path.delete(value);\n    }\n  }\n\n  try {\n    check(value);\n    JSON.stringify(value);\n  } catch (error) {\n    if (error instanceof Error) {\n      if (error.message.includes('getter') || error.message.includes('circular')) {\n        throw error;\n      }\n      throw new Error(`Contract export is not JSON-serializable: ${error.message}`);\n    }\n    throw new Error('Contract export is not JSON-serializable');\n  }\n}\n\nfunction createImportAllowlistPlugin(allowlist: ReadonlyArray<string>, entryPath: string): Plugin {\n  return {\n    name: 'import-allowlist',\n    setup(build) {\n      build.onResolve({ filter: /.*/ }, (args) => {\n        if (args.kind === 'entry-point') {\n          return undefined;\n        }\n        if (args.path.startsWith('.') || args.path.startsWith('/')) {\n          return undefined;\n        }\n        const isFromEntryPoint = args.importer === entryPath || args.importer === '<stdin>';\n        if (isFromEntryPoint && !isAllowedImport(args.path, allowlist)) {\n          return {\n            path: args.path,\n            external: true,\n          };\n        }\n        return undefined;\n      });\n    },\n  };\n}\n\n/**\n * Loads a contract from a TypeScript file and returns it as Contract.\n *\n * **Responsibility: Parsing Only**\n * This function loads and parses a TypeScript contract file. It does NOT normalize the contract.\n * The contract should already be normalized if it was built using the contract builder.\n *\n * Normalization must happen in the contract builder when the contract is created.\n * This function only validates that the contract is JSON-serializable and returns it as-is.\n *\n * @param entryPath - Path to the TypeScript contract file\n * @param options - Optional configuration (import allowlist)\n * @returns The contract as Contract (should already be normalized)\n * @throws Error if the contract cannot be loaded or is not JSON-serializable\n */\nexport async function loadContractFromTs(\n  entryPath: string,\n  options?: LoadTsContractOptions,\n): Promise<Contract> {\n  const allowlist = options?.allowlist ?? DEFAULT_ALLOWLIST;\n\n  if (!existsSync(entryPath)) {\n    throw new Error(`Contract file not found: ${entryPath}`);\n  }\n\n  const tempFile = join(\n    tmpdir(),\n    `prisma-next-contract-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`,\n  );\n\n  try {\n    const result = await build({\n      entryPoints: [entryPath],\n      bundle: true,\n      format: 'esm',\n      platform: 'node',\n      target: 'es2022',\n      outfile: tempFile,\n      write: false,\n      metafile: true,\n      plugins: [createImportAllowlistPlugin(allowlist, entryPath)],\n      logLevel: 'error',\n    });\n\n    if (result.errors.length > 0) {\n      const errorMessages = result.errors.map((e: { text: string }) => e.text).join('\\n');\n      throw new Error(`Failed to bundle contract file: ${errorMessages}`);\n    }\n\n    if (!result.outputFiles || result.outputFiles.length === 0) {\n      throw new Error('No output files generated from bundling');\n    }\n\n    const disallowedImports: string[] = [];\n    if (result.metafile) {\n      const inputs = result.metafile.inputs;\n      for (const [, inputData] of Object.entries(inputs)) {\n        const imports =\n          (inputData as { imports?: Array<{ path: string; external?: boolean }> }).imports || [];\n        for (const imp of imports) {\n          if (\n            imp.external &&\n            !imp.path.startsWith('.') &&\n            !imp.path.startsWith('/') &&\n            !isAllowedImport(imp.path, allowlist)\n          ) {\n            disallowedImports.push(imp.path);\n          }\n        }\n      }\n    }\n\n    if (disallowedImports.length > 0) {\n      throw new Error(\n        `Disallowed imports detected. Only imports matching the allowlist are permitted:\\n  Allowlist: ${allowlist.join(', ')}\\n  Disallowed imports: ${disallowedImports.join(', ')}\\n\\nOnly @prisma-next/* packages are allowed in contract files.`,\n      );\n    }\n\n    const bundleContent = result.outputFiles[0]?.text;\n    if (bundleContent === undefined) {\n      throw new Error('Bundle content is undefined');\n    }\n    writeFileSync(tempFile, bundleContent, 'utf-8');\n\n    const module = (await import(/* @vite-ignore */ pathToFileURL(tempFile).href)) as {\n      default?: unknown;\n      contract?: unknown;\n    };\n    unlinkSync(tempFile);\n\n    let contract: unknown;\n\n    if (module.default !== undefined) {\n      contract = module.default;\n    } else if (module.contract !== undefined) {\n      contract = module.contract;\n    } else {\n      throw new Error(\n        `Contract file must export a contract as default export or named export 'contract'. Found exports: ${Object.keys(module as Record<string, unknown>).join(', ') || 'none'}`,\n      );\n    }\n\n    if (typeof contract !== 'object' || contract === null) {\n      throw new Error(`Contract export must be an object, got ${typeof contract}`);\n    }\n\n    validatePurity(contract);\n\n    return contract as Contract;\n  } catch (error) {\n    try {\n      if (tempFile) {\n        unlinkSync(tempFile);\n      }\n    } catch {\n      // Ignore cleanup errors\n    }\n\n    if (error instanceof Error) {\n      throw error;\n    }\n    throw new Error(`Failed to load contract from ${entryPath}: ${String(error)}`);\n  }\n}\n"],"mappings":"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"}

package/dist/exports/init-output.d.mts

@@ -0,0 +1,39 @@
+import "@clack/prompts";
+import * as arktype_internal_variants_object_ts0 from "arktype/internal/variants/object.ts";
+
+//#region src/commands/init/output.d.ts
+
+/**
+ * arktype schema for the structured success document `init --json` writes
+ * to stdout (FR1.5). The same shape backs the human-readable outro
+ * renderer (FR10), so the two output modes carry identical information.
+ *
+ * `target` is normalised to the user-facing flag value (`mongodb` rather
+ * than the internal `mongo`) so consumers can round-trip the document
+ * straight into a follow-up `--target` invocation.
+ *
+ * The `ok: true` literal is the documented success/error discriminator —
+ * see [Style Guide § JSON Semantics](../../../../../../../docs/CLI%20Style%20Guide.md#json-semantics).
+ * Error envelopes (`CliErrorEnvelope`) carry `ok: false` so consumers can
+ * branch with `if (doc.ok)` without inspecting the rest of the structure.
+ */
+declare const InitOutputSchema: arktype_internal_variants_object_ts0.ObjectType<{
+  ok: true;
+  target: "postgres" | "mongodb";
+  authoring: "psl" | "typescript";
+  schemaPath: string;
+  filesWritten: string[];
+  filesDeleted: string[];
+  packagesInstalled: {
+    skipped: boolean;
+    deps: string[];
+    devDeps: string[];
+  };
+  contractEmitted: boolean;
+  nextSteps: string[];
+  warnings: string[];
+}, {}>;
+type InitOutput = typeof InitOutputSchema.infer;
+//#endregion
+export { type InitOutput, InitOutputSchema };
+//# sourceMappingURL=init-output.d.mts.map

package/dist/exports/init-output.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-output.d.mts","names":[],"sources":["../../src/commands/init/output.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkBA;AAwBA;;;;;;;;;;;cAxBa,kBAsBX,oCAAA,CAtB2B;;;;;;;;;;;;;;;;KAwBjB,UAAA,UAAoB,gBAAA,CAAiB"}

package/dist/exports/init-output.mjs

@@ -0,0 +1,3 @@
+import { t as InitOutputSchema } from "../output-BpcQrnnq.mjs";
+
+export { InitOutputSchema };

package/dist/{framework-components-DfZKQBQ2.mjs → framework-components-Bgcre3Z6.mjs}

@@ -1,4 +1,4 @@
-import { r as errorConfigValidation } from "./cli-errors-DHq6GQGu.mjs";
+import { r as errorConfigValidation } from "./cli-errors-By1iVE3z.mjs";
 import "@prisma-next/framework-components/components";
 
 //#region src/utils/framework-components.ts
@@ -56,4 +56,4 @@ function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId,
 
 //#endregion
 export { assertFrameworkComponentsCompatible as t };
-//# sourceMappingURL=framework-components-DfZKQBQ2.mjs.map
+//# sourceMappingURL=framework-components-Bgcre3Z6.mjs.map

package/dist/{framework-components-DfZKQBQ2.mjs.map → framework-components-Bgcre3Z6.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"framework-components-DfZKQBQ2.mjs","names":[],"sources":["../src/utils/framework-components.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport {\n  checkContractComponentRequirements,\n  type TargetBoundComponentDescriptor,\n} from '@prisma-next/framework-components/components';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { errorConfigValidation, errorContractMissingExtensionPacks } from './cli-errors';\n\n/**\n * Asserts that all framework components are compatible with the expected family and target.\n *\n * This function validates that each component in the framework components array:\n * - Has kind 'target', 'adapter', 'extension', or 'driver'\n * - Has familyId matching expectedFamilyId\n * - Has targetId matching expectedTargetId\n *\n * This validation happens at the CLI composition boundary, before passing components\n * to typed planner/runner instances. It fills the gap between runtime validation\n * (via `validateConfig()`) and compile-time type enforcement.\n *\n * @param expectedFamilyId - The expected family ID (e.g., 'sql')\n * @param expectedTargetId - The expected target ID (e.g., 'postgres')\n * @param frameworkComponents - Array of framework components to validate\n * @returns The same array typed as TargetBoundComponentDescriptor\n * @throws CliStructuredError if any component is incompatible\n *\n * @example\n * ```ts\n * const config = await loadConfig();\n * const frameworkComponents = [config.target, config.adapter, ...(config.extensionPacks ?? [])];\n *\n * // Validate and type-narrow components before passing to planner\n * const typedComponents = assertFrameworkComponentsCompatible(\n *   config.family.familyId,\n *   config.target.targetId,\n *   frameworkComponents\n * );\n *\n * const planner = target.migrations.createPlanner(familyInstance);\n * planner.plan({ contract, schema, policy, frameworkComponents: typedComponents });\n * ```\n */\nexport function assertFrameworkComponentsCompatible<\n  TFamilyId extends string,\n  TTargetId extends string,\n>(\n  expectedFamilyId: TFamilyId,\n  expectedTargetId: TTargetId,\n  frameworkComponents: ReadonlyArray<unknown>,\n): ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>> {\n  for (let i = 0; i < frameworkComponents.length; i++) {\n    const component = frameworkComponents[i];\n\n    // Check that component is an object\n    if (typeof component !== 'object' || component === null) {\n      throw errorConfigValidation('frameworkComponents[]', {\n        why: `Framework component at index ${i} must be an object`,\n      });\n    }\n\n    const record = component as Record<string, unknown>;\n\n    // Check kind\n    if (!Object.hasOwn(record, 'kind')) {\n      throw errorConfigValidation('frameworkComponents[].kind', {\n        why: `Framework component at index ${i} must have 'kind' property`,\n      });\n    }\n\n    const kind = record['kind'];\n    if (kind !== 'target' && kind !== 'adapter' && kind !== 'extension' && kind !== 'driver') {\n      throw errorConfigValidation('frameworkComponents[].kind', {\n        why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')`,\n      });\n    }\n\n    // Check familyId\n    if (!Object.hasOwn(record, 'familyId')) {\n      throw errorConfigValidation('frameworkComponents[].familyId', {\n        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property`,\n      });\n    }\n\n    const familyId = record['familyId'];\n    if (familyId !== expectedFamilyId) {\n      throw errorConfigValidation('frameworkComponents[].familyId', {\n        why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'`,\n      });\n    }\n\n    // Check targetId\n    if (!Object.hasOwn(record, 'targetId')) {\n      throw errorConfigValidation('frameworkComponents[].targetId', {\n        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property`,\n      });\n    }\n\n    const targetId = record['targetId'];\n    if (targetId !== expectedTargetId) {\n      throw errorConfigValidation('frameworkComponents[].targetId', {\n        why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'`,\n      });\n    }\n  }\n\n  // Type assertion is safe because we've validated all components above\n  return frameworkComponents as ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;\n}\n\n/**\n * Validates that a contract is compatible with the configured target, adapter,\n * and extension packs. Throws on family/target mismatches or missing extension packs.\n *\n * This check ensures the emitted contract matches the CLI config before running\n * commands that depend on the contract (e.g., db verify, db sign).\n *\n * @param contract - The contract to validate (must include targetFamily, target, extensionPacks).\n * @param stack - The control plane stack (target, adapter, driver, extensionPacks).\n *\n * @throws {CliStructuredError} errorConfigValidation when contract.targetFamily or contract.target\n *   doesn't match the configured family/target.\n * @throws {CliStructuredError} errorContractMissingExtensionPacks when the contract requires\n *   extension packs that are not provided in the config (includes all missing packs in error.meta).\n *\n * @example\n * ```ts\n * import { assertContractRequirementsSatisfied } from './framework-components';\n *\n * const config = await loadConfig();\n * const contract = await loadContractJson(config.contract.output);\n * const stack = createControlStack({ family: config.family, target: config.target, adapter: config.adapter, ... });\n *\n * // Throws if contract is incompatible with config\n * assertContractRequirementsSatisfied({ contract, stack });\n * ```\n */\nexport function assertContractRequirementsSatisfied<\n  TFamilyId extends string,\n  TTargetId extends string,\n>({\n  contract,\n  stack,\n}: {\n  readonly contract: Pick<Contract, 'targetFamily' | 'target' | 'extensionPacks'>;\n  readonly stack: ControlStack<TFamilyId, TTargetId>;\n}): void {\n  const providedComponentIds = new Set<string>([\n    stack.target.id,\n    ...(stack.adapter ? [stack.adapter.id] : []),\n  ]);\n  for (const extension of stack.extensionPacks) {\n    providedComponentIds.add(extension.id);\n  }\n\n  const result = checkContractComponentRequirements({\n    contract,\n    expectedTargetFamily: stack.target.familyId,\n    expectedTargetId: stack.target.targetId,\n    providedComponentIds,\n  });\n\n  if (result.familyMismatch) {\n    throw errorConfigValidation('contract.targetFamily', {\n      why: `Contract was emitted for family '${result.familyMismatch.actual}' but CLI config is wired to '${result.familyMismatch.expected}'.`,\n    });\n  }\n\n  if (result.targetMismatch) {\n    throw errorConfigValidation('contract.target', {\n      why: `Contract target '${result.targetMismatch.actual}' does not match CLI target '${result.targetMismatch.expected}'.`,\n    });\n  }\n\n  if (result.missingExtensionPackIds.length > 0) {\n    throw errorContractMissingExtensionPacks({\n      missingExtensionPacks: result.missingExtensionPackIds,\n      providedComponentIds: [...providedComponentIds],\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,oCAId,kBACA,kBACA,qBACqE;AACrE,MAAK,IAAI,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;EACnD,MAAM,YAAY,oBAAoB;AAGtC,MAAI,OAAO,cAAc,YAAY,cAAc,KACjD,OAAM,sBAAsB,yBAAyB,EACnD,KAAK,gCAAgC,EAAE,qBACxC,CAAC;EAGJ,MAAM,SAAS;AAGf,MAAI,CAAC,OAAO,OAAO,QAAQ,OAAO,CAChC,OAAM,sBAAsB,8BAA8B,EACxD,KAAK,gCAAgC,EAAE,6BACxC,CAAC;EAGJ,MAAM,OAAO,OAAO;AACpB,MAAI,SAAS,YAAY,SAAS,aAAa,SAAS,eAAe,SAAS,SAC9E,OAAM,sBAAsB,8BAA8B,EACxD,KAAK,gCAAgC,EAAE,qBAAqB,OAAO,KAAK,CAAC,4DAC1E,CAAC;AAIJ,MAAI,CAAC,OAAO,OAAO,QAAQ,WAAW,CACpC,OAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,KAAK,CAAC,kCAC/D,CAAC;EAGJ,MAAM,WAAW,OAAO;AACxB,MAAI,aAAa,iBACf,OAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,KAAK,CAAC,kBAAkB,OAAO,SAAS,CAAC,kBAAkB,iBAAiB,IACrI,CAAC;AAIJ,MAAI,CAAC,OAAO,OAAO,QAAQ,WAAW,CACpC,OAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,KAAK,CAAC,kCAC/D,CAAC;EAGJ,MAAM,WAAW,OAAO;AACxB,MAAI,aAAa,iBACf,OAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,KAAK,CAAC,kBAAkB,OAAO,SAAS,CAAC,kBAAkB,iBAAiB,IACrI,CAAC;;AAKN,QAAO"}
+{"version":3,"file":"framework-components-Bgcre3Z6.mjs","names":[],"sources":["../src/utils/framework-components.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport {\n  checkContractComponentRequirements,\n  type TargetBoundComponentDescriptor,\n} from '@prisma-next/framework-components/components';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { errorConfigValidation, errorContractMissingExtensionPacks } from './cli-errors';\n\n/**\n * Asserts that all framework components are compatible with the expected family and target.\n *\n * This function validates that each component in the framework components array:\n * - Has kind 'target', 'adapter', 'extension', or 'driver'\n * - Has familyId matching expectedFamilyId\n * - Has targetId matching expectedTargetId\n *\n * This validation happens at the CLI composition boundary, before passing components\n * to typed planner/runner instances. It fills the gap between runtime validation\n * (via `validateConfig()`) and compile-time type enforcement.\n *\n * @param expectedFamilyId - The expected family ID (e.g., 'sql')\n * @param expectedTargetId - The expected target ID (e.g., 'postgres')\n * @param frameworkComponents - Array of framework components to validate\n * @returns The same array typed as TargetBoundComponentDescriptor\n * @throws CliStructuredError if any component is incompatible\n *\n * @example\n * ```ts\n * const config = await loadConfig();\n * const frameworkComponents = [config.target, config.adapter, ...(config.extensionPacks ?? [])];\n *\n * // Validate and type-narrow components before passing to planner\n * const typedComponents = assertFrameworkComponentsCompatible(\n *   config.family.familyId,\n *   config.target.targetId,\n *   frameworkComponents\n * );\n *\n * const planner = target.migrations.createPlanner(familyInstance);\n * planner.plan({ contract, schema, policy, frameworkComponents: typedComponents });\n * ```\n */\nexport function assertFrameworkComponentsCompatible<\n  TFamilyId extends string,\n  TTargetId extends string,\n>(\n  expectedFamilyId: TFamilyId,\n  expectedTargetId: TTargetId,\n  frameworkComponents: ReadonlyArray<unknown>,\n): ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>> {\n  for (let i = 0; i < frameworkComponents.length; i++) {\n    const component = frameworkComponents[i];\n\n    // Check that component is an object\n    if (typeof component !== 'object' || component === null) {\n      throw errorConfigValidation('frameworkComponents[]', {\n        why: `Framework component at index ${i} must be an object`,\n      });\n    }\n\n    const record = component as Record<string, unknown>;\n\n    // Check kind\n    if (!Object.hasOwn(record, 'kind')) {\n      throw errorConfigValidation('frameworkComponents[].kind', {\n        why: `Framework component at index ${i} must have 'kind' property`,\n      });\n    }\n\n    const kind = record['kind'];\n    if (kind !== 'target' && kind !== 'adapter' && kind !== 'extension' && kind !== 'driver') {\n      throw errorConfigValidation('frameworkComponents[].kind', {\n        why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')`,\n      });\n    }\n\n    // Check familyId\n    if (!Object.hasOwn(record, 'familyId')) {\n      throw errorConfigValidation('frameworkComponents[].familyId', {\n        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property`,\n      });\n    }\n\n    const familyId = record['familyId'];\n    if (familyId !== expectedFamilyId) {\n      throw errorConfigValidation('frameworkComponents[].familyId', {\n        why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'`,\n      });\n    }\n\n    // Check targetId\n    if (!Object.hasOwn(record, 'targetId')) {\n      throw errorConfigValidation('frameworkComponents[].targetId', {\n        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property`,\n      });\n    }\n\n    const targetId = record['targetId'];\n    if (targetId !== expectedTargetId) {\n      throw errorConfigValidation('frameworkComponents[].targetId', {\n        why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'`,\n      });\n    }\n  }\n\n  // Type assertion is safe because we've validated all components above\n  return frameworkComponents as ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;\n}\n\n/**\n * Validates that a contract is compatible with the configured target, adapter,\n * and extension packs. Throws on family/target mismatches or missing extension packs.\n *\n * This check ensures the emitted contract matches the CLI config before running\n * commands that depend on the contract (e.g., db verify, db sign).\n *\n * @param contract - The contract to validate (must include targetFamily, target, extensionPacks).\n * @param stack - The control plane stack (target, adapter, driver, extensionPacks).\n *\n * @throws {CliStructuredError} errorConfigValidation when contract.targetFamily or contract.target\n *   doesn't match the configured family/target.\n * @throws {CliStructuredError} errorContractMissingExtensionPacks when the contract requires\n *   extension packs that are not provided in the config (includes all missing packs in error.meta).\n *\n * @example\n * ```ts\n * import { assertContractRequirementsSatisfied } from './framework-components';\n *\n * const config = await loadConfig();\n * const contract = await loadContractJson(config.contract.output);\n * const stack = createControlStack({ family: config.family, target: config.target, adapter: config.adapter, ... });\n *\n * // Throws if contract is incompatible with config\n * assertContractRequirementsSatisfied({ contract, stack });\n * ```\n */\nexport function assertContractRequirementsSatisfied<\n  TFamilyId extends string,\n  TTargetId extends string,\n>({\n  contract,\n  stack,\n}: {\n  readonly contract: Pick<Contract, 'targetFamily' | 'target' | 'extensionPacks'>;\n  readonly stack: ControlStack<TFamilyId, TTargetId>;\n}): void {\n  const providedComponentIds = new Set<string>([\n    stack.target.id,\n    ...(stack.adapter ? [stack.adapter.id] : []),\n  ]);\n  for (const extension of stack.extensionPacks) {\n    providedComponentIds.add(extension.id);\n  }\n\n  const result = checkContractComponentRequirements({\n    contract,\n    expectedTargetFamily: stack.target.familyId,\n    expectedTargetId: stack.target.targetId,\n    providedComponentIds,\n  });\n\n  if (result.familyMismatch) {\n    throw errorConfigValidation('contract.targetFamily', {\n      why: `Contract was emitted for family '${result.familyMismatch.actual}' but CLI config is wired to '${result.familyMismatch.expected}'.`,\n    });\n  }\n\n  if (result.targetMismatch) {\n    throw errorConfigValidation('contract.target', {\n      why: `Contract target '${result.targetMismatch.actual}' does not match CLI target '${result.targetMismatch.expected}'.`,\n    });\n  }\n\n  if (result.missingExtensionPackIds.length > 0) {\n    throw errorContractMissingExtensionPacks({\n      missingExtensionPacks: result.missingExtensionPackIds,\n      providedComponentIds: [...providedComponentIds],\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,oCAId,kBACA,kBACA,qBACqE;AACrE,MAAK,IAAI,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;EACnD,MAAM,YAAY,oBAAoB;AAGtC,MAAI,OAAO,cAAc,YAAY,cAAc,KACjD,OAAM,sBAAsB,yBAAyB,EACnD,KAAK,gCAAgC,EAAE,qBACxC,CAAC;EAGJ,MAAM,SAAS;AAGf,MAAI,CAAC,OAAO,OAAO,QAAQ,OAAO,CAChC,OAAM,sBAAsB,8BAA8B,EACxD,KAAK,gCAAgC,EAAE,6BACxC,CAAC;EAGJ,MAAM,OAAO,OAAO;AACpB,MAAI,SAAS,YAAY,SAAS,aAAa,SAAS,eAAe,SAAS,SAC9E,OAAM,sBAAsB,8BAA8B,EACxD,KAAK,gCAAgC,EAAE,qBAAqB,OAAO,KAAK,CAAC,4DAC1E,CAAC;AAIJ,MAAI,CAAC,OAAO,OAAO,QAAQ,WAAW,CACpC,OAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,KAAK,CAAC,kCAC/D,CAAC;EAGJ,MAAM,WAAW,OAAO;AACxB,MAAI,aAAa,iBACf,OAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,KAAK,CAAC,kBAAkB,OAAO,SAAS,CAAC,kBAAkB,iBAAiB,IACrI,CAAC;AAIJ,MAAI,CAAC,OAAO,OAAO,QAAQ,WAAW,CACpC,OAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,KAAK,CAAC,kCAC/D,CAAC;EAGJ,MAAM,WAAW,OAAO;AACxB,MAAI,aAAa,iBACf,OAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,KAAK,CAAC,kBAAkB,OAAO,SAAS,CAAC,kBAAkB,iBAAiB,IACrI,CAAC;;AAKN,QAAO"}