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

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

@@ -1,4 +1,4 @@
-import { A as ExecuteDbVerifyOptions, C as IntrospectOptions, D as SchemaVerifyOptions, M as executeDbVerify, O as SignOptions, S as EmitSuccess, T as OnControlProgress, _ as EmitContractConfig, a as ControlClientOptions, b as EmitOptions, c as DbInitFailureCode, d as DbInitSuccess, f as DbUpdateFailure, g as DbUpdateSuccess, h as DbUpdateResult, i as ControlClient, j as ExecuteDbVerifyResult, k as VerifyOptions, l as DbInitOptions, m as DbUpdateOptions, n as ContractEmitResult, o as ControlProgressEvent, p as DbUpdateFailureCode, r as ControlActionName, s as DbInitFailure, t as ContractEmitOptions, u as DbInitResult, v as EmitFailure, x as EmitResult, y as EmitFailureCode } from "../types-D4r_HI9-.mjs";
+import { A as ExecuteDbVerifyOptions, C as IntrospectOptions, D as SchemaVerifyOptions, M as executeDbVerify, O as SignOptions, S as EmitSuccess, T as OnControlProgress, _ as EmitContractConfig, a as ControlClientOptions, b as EmitOptions, c as DbInitFailureCode, d as DbInitSuccess, f as DbUpdateFailure, g as DbUpdateSuccess, h as DbUpdateResult, i as ControlClient, j as ExecuteDbVerifyResult, k as VerifyOptions, l as DbInitOptions, m as DbUpdateOptions, n as ContractEmitResult, o as ControlProgressEvent, p as DbUpdateFailureCode, r as ControlActionName, s as DbInitFailure, t as ContractEmitOptions, u as DbInitResult, v as EmitFailure, x as EmitResult, y as EmitFailureCode } from "../types-DgXprE3w.mjs";
 import { ControlAdapterInstance, ControlDriverInstance, ControlExtensionDescriptor, ControlFamilyInstance, ControlStack, SignDatabaseResult, TargetMigrationsCapability, VerifyDatabaseResult, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
 import { Contract } from "@prisma-next/contract/types";
@@ -59,7 +59,7 @@ declare function executeContractEmit(options: ContractEmitOptions): Promise<Cont
  * 3. The runner's `execute` applies the per-space plans
  *    inside one outer transaction.
  *
- * `extensionPacks` mirrors `Config.extensionPacks` (descriptor list).
+ * `extensions` mirrors `Config.extensions` (descriptor list).
  * The loader (sub-spec § Loader) is the sole descriptor-import boundary.
  */
 interface ExecuteDbInitOptions<TFamilyId extends string, TTargetId extends string> {
@@ -85,7 +85,7 @@ interface ExecuteDbInitOptions<TFamilyId extends string, TTargetId extends strin
    * routes through the same loader → planner → runner pipeline with no
    * extension spaces in the aggregate.
    */
-  readonly extensionPacks?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
+  readonly extensions?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
   /** Optional progress callback for observing operation progress */
   readonly onProgress?: OnControlProgress;
 }
@@ -119,7 +119,7 @@ interface ExecuteDbUpdateOptions<TFamilyId extends string, TTargetId extends str
   readonly acceptDataLoss?: boolean;
   readonly migrationsDir: string;
   readonly targetId: TTargetId;
-  readonly extensionPacks?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
+  readonly extensions?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
   readonly onProgress?: OnControlProgress;
 }
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"control-api.d.mts","names":[],"sources":["../../src/control-api/client.ts","../../src/control-api/contract-enrichment.ts","../../src/control-api/operations/contract-emit.ts","../../src/control-api/operations/db-init.ts","../../src/control-api/operations/db-update.ts","../../src/utils/emit-queue.ts"],"mappings":";;;;;;;;;;;;;;;iBAuEgB,oBAAoB,SAAS,uBAAuB;;;;;;iBCVpD,eACd,IAAI,UACJ,YAAY,cAAc,kDACzB;;;;;;;;;;;;;;;;;;;;;;;iBCwFmB,oBACpB,SAAS,sBACR,QAAQ;;;;;;;;;;;;;;;;;;;;UC5HM,qBAAqB,0BAA0B;WACrD,QAAQ,sBAAsB,WAAW;WACzC,SAAS,uBAAuB,WAAW;WAC3C,gBAAgB,sBAAsB;WACtC,UAAU;WACV;WACA,YAAY,2BACnB,WACA,WACA,sBAAsB;WAEf,qBAAqB,cAAc,+BAA+B,WAAW;;;;;WAK7E;;;;;WAKA,UAAU;;;;;;WAMV,iBAAiB,cAAc,2BAA2B,WAAW;;WAErE,aAAa;;;;;;;;;iBAUF,cAAc,0BAA0B,0BAC5D,SAAS,qBAAqB,WAAW,aACxC,QAAQ;;;;;;;;;;;;UC5CM,uBAAuB,0BAA0B;WACvD,QAAQ,sBAAsB,WAAW;WACzC,SAAS,uBAAuB,WAAW;WAC3C,gBAAgB,sBAAsB;WACtC,UAAU;WACV;WACA,YAAY,2BACnB,WACA,WACA,sBAAsB;WAEf,qBAAqB,cAAc,+BAA+B,WAAW;WAC7E;WACA;WACA,UAAU;WACV,iBAAiB,cAAc,2BAA2B,WAAW;WACrE,aAAa;;;;;;;;;;;iBAYF,gBAAgB,0BAA0B,0BAC9D,SAAS,uBAAuB,WAAW,aAC1C,QAAQ;;;iBClCK,iBAAiB"}
+{"version":3,"file":"control-api.d.mts","names":[],"sources":["../../src/control-api/client.ts","../../src/control-api/contract-enrichment.ts","../../src/control-api/operations/contract-emit.ts","../../src/control-api/operations/db-init.ts","../../src/control-api/operations/db-update.ts","../../src/utils/emit-queue.ts"],"mappings":";;;;;;;;;;;;;;;iBAuEgB,oBAAoB,SAAS,uBAAuB;;;;;;iBCVpD,eACd,IAAI,UACJ,YAAY,cAAc,kDACzB;;;;;;;;;;;;;;;;;;;;;;;iBCwFmB,oBACpB,SAAS,sBACR,QAAQ;;;;;;;;;;;;;;;;;;;;UC5HM,qBAAqB,0BAA0B;WACrD,QAAQ,sBAAsB,WAAW;WACzC,SAAS,uBAAuB,WAAW;WAC3C,gBAAgB,sBAAsB;WACtC,UAAU;WACV;WACA,YAAY,2BACnB,WACA,WACA,sBAAsB;WAEf,qBAAqB,cAAc,+BAA+B,WAAW;;;;;WAK7E;;;;;WAKA,UAAU;;;;;;WAMV,aAAa,cAAc,2BAA2B,WAAW;;WAEjE,aAAa;;;;;;;;;iBAUF,cAAc,0BAA0B,0BAC5D,SAAS,qBAAqB,WAAW,aACxC,QAAQ;;;;;;;;;;;;UC5CM,uBAAuB,0BAA0B;WACvD,QAAQ,sBAAsB,WAAW;WACzC,SAAS,uBAAuB,WAAW;WAC3C,gBAAgB,sBAAsB;WACtC,UAAU;WACV;WACA,YAAY,2BACnB,WACA,WACA,sBAAsB;WAEf,qBAAqB,cAAc,+BAA+B,WAAW;WAC7E;WACA;WACA,UAAU;WACV,aAAa,cAAc,2BAA2B,WAAW;WACjE,aAAa;;;;;;;;;;;iBAYF,gBAAgB,0BAA0B,0BAC9D,SAAS,uBAAuB,WAAW,aAC1C,QAAQ;;;iBClCK,iBAAiB"}

package/dist/exports/control-api.mjs

@@ -1,4 +1,4 @@
-import { n as executeContractEmit, r as disposeEmitQueue } from "../contract-emit-cJQBlvGb.mjs";
-import { t as enrichContract } from "../contract-enrichment-gn9sWbPw.mjs";
-import { a as executeDbInit, i as executeDbUpdate, r as executeDbVerify, t as createControlClient } from "../client-KuBQftxz.mjs";
+import { n as executeContractEmit, r as disposeEmitQueue } from "../contract-emit-CfIbTnsR.mjs";
+import { t as enrichContract } from "../contract-enrichment-JUhLv-BX.mjs";
+import { a as executeDbInit, i as executeDbUpdate, r as executeDbVerify, t as createControlClient } from "../client-CMusjGV5.mjs";
 export { createControlClient, disposeEmitQueue, enrichContract, executeContractEmit, executeDbInit, executeDbUpdate, executeDbVerify };

package/dist/exports/index.mjs

@@ -1,5 +1,5 @@
-import { t as createContractEmitCommand } from "../contract-emit-CgnXSANN.mjs";
-import { t as createFormatCommand } from "../format-DAUAZqPt.mjs";
+import { t as createContractEmitCommand } from "../contract-emit-PaY3qRdN.mjs";
+import { t as createFormatCommand } from "../format-cCyDfmRE.mjs";
 import { join, resolve } from "pathe";
 import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";

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

@@ -1 +1 @@
-{"version":3,"file":"init-output.d.mts","names":[],"sources":["../../src/commands/init/output.ts"],"mappings":";;;;;;;;;;;;;;;;cAkBa,gEAAgB;;;;;;;;;;;;;;;;KAwBjB,oBAAoB,iBAAiB"}
+{"version":3,"file":"init-output.d.mts","names":[],"sources":["../../src/commands/init/output.ts"],"mappings":";;;;;;;;;;;;;;;;cAkBa,gEAAgB;;;;;;;;;;;;;;;;KAuBjB,oBAAoB,iBAAiB"}

package/dist/exports/init-output.mjs

@@ -1,2 +1,2 @@
-import { t as InitOutputSchema } from "../output-mEQ74_nd.mjs";
+import { t as InitOutputSchema } from "../output-DWNYqZGc.mjs";
 export { InitOutputSchema };

package/dist/{format-DAUAZqPt.mjs → format-cCyDfmRE.mjs}

@@ -1,4 +1,4 @@
-import { A as formatStyledHeader, F as CliStructuredError, _ as createTerminalUI, ct as errorUnexpected, g as parseGlobalFlagsOrExit, l as setCommandDescriptions, rt as errorRuntime, t as addGlobalOptions, u as setCommandExamples, y as handleResult } from "./command-helpers-Cpq44aVa.mjs";
+import { A as formatStyledHeader, F as CliStructuredError, _ as createTerminalUI, ct as errorUnexpected, g as parseGlobalFlagsOrExit, l as setCommandDescriptions, rt as errorRuntime, t as addGlobalOptions, u as setCommandExamples, y as handleResult } from "./command-helpers-CVn3U9Uz.mjs";
 import { Command } from "commander";
 import { loadConfig } from "@prisma-next/config-loader";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -6,7 +6,8 @@ import { notOk, ok } from "@prisma-next/utils/result";
 import { relative, resolve } from "pathe";
 import { readFile, writeFile } from "node:fs/promises";
 import { EOL } from "node:os";
-import { PslFormatError, format } from "@prisma-next/psl-parser/format";
+import { format } from "@prisma-next/psl-parser/format";
+import { isStructuredError } from "@prisma-next/utils/structured-error";
 //#region src/control-api/operations/format.ts
 function resolveNewline(formatterNewline, eol) {
 	if (formatterNewline !== void 0) return formatterNewline;
@@ -22,7 +23,7 @@ async function executeFormat(options) {
 		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error)));
 	}
 	const source = config.contract?.source;
-	if (source?.sourceFormat !== "psl") return ok({ formatted: false });
+	if (source?.format !== "psl") return ok({ formatted: false });
 	const inputPath = source.inputs?.[0];
 	if (inputPath === void 0) return ok({ formatted: false });
 	let contents;
@@ -42,10 +43,10 @@ async function executeFormat(options) {
 	try {
 		formatted = format(contents, formatOptions);
 	} catch (error) {
-		if (error instanceof PslFormatError) return notOk(errorRuntime("Cannot format PSL with parse errors", {
+		if (isStructuredError(error) && error.code === "PSL.PARSE_FAILED") return notOk(errorRuntime("Cannot format PSL with parse errors", {
 			why: error.message,
 			fix: "Fix the parse errors in your schema and try again.",
-			meta: { diagnostics: error.diagnostics }
+			meta: { diagnostics: error.meta?.["diagnostics"] }
 		}));
 		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error)));
 	}
@@ -66,7 +67,7 @@ async function executeFormat(options) {
 //#region src/commands/format.ts
 function createFormatCommand() {
 	const command = new Command("format");
-	setCommandDescriptions(command, "Format your PSL contract source", "Formats the Prisma schema (PSL) contract source declared in your config\n(contract.source.inputs[0]) in place. Only runs when contract.source.sourceFormat\nis 'psl'; a TypeScript or unset source is left untouched. Indent and newline are\nread from the optional formatter config section, defaulting to two spaces and the\nsystem newline.");
+	setCommandDescriptions(command, "Format your PSL contract source", "Formats the Prisma schema (PSL) contract source declared in your config\n(contract.source.inputs[0]) in place. Only runs when contract.source.format\nis 'psl'; a TypeScript or unset source is left untouched. Indent and newline are\nread from the optional formatter config section, defaulting to two spaces and the\nsystem newline.");
 	setCommandExamples(command, ["prisma-next format", "prisma-next format --config ./custom-config.ts"]);
 	addGlobalOptions(command).option("--config <path>", "Path to prisma-next.config.ts").action(async (options) => {
 		const flags = parseGlobalFlagsOrExit(options);
@@ -99,4 +100,4 @@ function createFormatCommand() {
 //#endregion
 export { createFormatCommand as t };
 
-//# sourceMappingURL=format-DAUAZqPt.mjs.map
+//# sourceMappingURL=format-cCyDfmRE.mjs.map

package/dist/format-cCyDfmRE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-cCyDfmRE.mjs","names":[],"sources":["../src/control-api/operations/format.ts","../src/commands/format.ts"],"sourcesContent":["import { readFile, writeFile } from 'node:fs/promises';\nimport { EOL } from 'node:os';\nimport { loadConfig } from '@prisma-next/config-loader';\nimport { type FormatOptions, format } from '@prisma-next/psl-parser/format';\nimport { notOk, ok, type Result } from '@prisma-next/utils/result';\nimport { isStructuredError } from '@prisma-next/utils/structured-error';\nimport { CliStructuredError, errorRuntime, errorUnexpected } from '../../utils/cli-errors';\n\nexport interface FormatOperationOptions {\n  readonly configPath?: string;\n  readonly eol?: string;\n}\n\nexport interface FormatOperationResult {\n  readonly formatted: boolean;\n  readonly path?: string;\n}\n\nexport function resolveNewline(\n  formatterNewline: 'LF' | 'CRLF' | undefined,\n  eol: string,\n): 'LF' | 'CRLF' {\n  if (formatterNewline !== undefined) {\n    return formatterNewline;\n  }\n  return eol === '\\r\\n' ? 'CRLF' : 'LF';\n}\n\nexport async function executeFormat(\n  options: FormatOperationOptions,\n): Promise<Result<FormatOperationResult, CliStructuredError>> {\n  const eol = options.eol ?? EOL;\n\n  let config: Awaited<ReturnType<typeof loadConfig>>;\n  try {\n    config = await loadConfig(options.configPath);\n  } catch (error) {\n    if (CliStructuredError.is(error)) {\n      return notOk(error);\n    }\n    return notOk(errorUnexpected(error instanceof Error ? error.message : String(error)));\n  }\n\n  const source = config.contract?.source;\n  if (source?.format !== 'psl') {\n    return ok({ formatted: false });\n  }\n\n  const inputPath = source.inputs?.[0];\n  if (inputPath === undefined) {\n    return ok({ formatted: false });\n  }\n\n  let contents: string;\n  try {\n    contents = await readFile(inputPath, 'utf-8');\n  } catch (error) {\n    return notOk(\n      errorRuntime('Failed to read contract source file', {\n        why: error instanceof Error ? error.message : String(error),\n        fix: `Check that ${inputPath} exists and is readable.`,\n      }),\n    );\n  }\n\n  const formatOptions: FormatOptions = {\n    indent: config.formatter?.indent ?? 2,\n    newline: resolveNewline(config.formatter?.newline, eol),\n  };\n\n  let formatted: string;\n  try {\n    formatted = format(contents, formatOptions);\n  } catch (error) {\n    if (isStructuredError(error) && error.code === 'PSL.PARSE_FAILED') {\n      return notOk(\n        errorRuntime('Cannot format PSL with parse errors', {\n          why: error.message,\n          fix: 'Fix the parse errors in your schema and try again.',\n          meta: { diagnostics: error.meta?.['diagnostics'] },\n        }),\n      );\n    }\n    return notOk(errorUnexpected(error instanceof Error ? error.message : String(error)));\n  }\n\n  try {\n    await writeFile(inputPath, formatted, 'utf-8');\n  } catch (error) {\n    return notOk(\n      errorRuntime('Failed to write formatted contract source file', {\n        why: error instanceof Error ? error.message : String(error),\n        fix: `Check that ${inputPath} is writable.`,\n      }),\n    );\n  }\n\n  return ok({ formatted: true, path: inputPath });\n}\n","import { ifDefined } from '@prisma-next/utils/defined';\nimport { Command } from 'commander';\nimport { relative, resolve } from 'pathe';\nimport { executeFormat } from '../control-api/operations/format';\nimport {\n  addGlobalOptions,\n  setCommandDescriptions,\n  setCommandExamples,\n} from '../utils/command-helpers';\nimport { formatStyledHeader } from '../utils/formatters/styled';\nimport type { CommonCommandOptions } from '../utils/global-flags';\nimport { parseGlobalFlagsOrExit } from '../utils/global-flags';\nimport { handleResult } from '../utils/result-handler';\nimport { createTerminalUI } from '../utils/terminal-ui';\n\ninterface FormatCommandOptions extends CommonCommandOptions {\n  readonly config?: string;\n}\n\nexport function createFormatCommand(): Command {\n  const command = new Command('format');\n  setCommandDescriptions(\n    command,\n    'Format your PSL contract source',\n    'Formats the Prisma schema (PSL) contract source declared in your config\\n' +\n      '(contract.source.inputs[0]) in place. Only runs when contract.source.format\\n' +\n      \"is 'psl'; a TypeScript or unset source is left untouched. Indent and newline are\\n\" +\n      'read from the optional formatter config section, defaulting to two spaces and the\\n' +\n      'system newline.',\n  );\n  setCommandExamples(command, [\n    'prisma-next format',\n    'prisma-next format --config ./custom-config.ts',\n  ]);\n  addGlobalOptions(command)\n    .option('--config <path>', 'Path to prisma-next.config.ts')\n    .action(async (options: FormatCommandOptions) => {\n      const flags = parseGlobalFlagsOrExit(options);\n      const ui = createTerminalUI(flags);\n\n      if (!flags.json && !flags.quiet) {\n        const displayConfigPath = options.config\n          ? relative(process.cwd(), resolve(options.config))\n          : 'prisma-next.config.ts';\n        ui.stderr(\n          formatStyledHeader({\n            command: 'format',\n            description: 'Format your PSL contract source',\n            details: [{ label: 'config', value: displayConfigPath }],\n            flags,\n          }),\n        );\n      }\n\n      const result = await executeFormat({ ...ifDefined('configPath', options.config) });\n\n      const exitCode = handleResult(result, flags, ui, (value) => {\n        if (flags.json) {\n          ui.output(JSON.stringify(value));\n          return;\n        }\n        if (flags.quiet) {\n          return;\n        }\n        if (value.formatted) {\n          ui.success(`Formatted ${relative(process.cwd(), value.path ?? '')}`);\n        } else {\n          ui.info('Nothing to format (contract source is not PSL).');\n        }\n      });\n      process.exit(exitCode);\n    });\n\n  return command;\n}\n"],"mappings":"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"}

package/dist/{framework-components-CnbUbiJw.mjs → framework-components-DUN-TYDg.mjs}

@@ -1,4 +1,4 @@
-import { R as errorConfigValidation } from "./command-helpers-Cpq44aVa.mjs";
+import { R as errorConfigValidation } from "./command-helpers-CVn3U9Uz.mjs";
 import "@prisma-next/framework-components/components";
 //#region src/utils/framework-components.ts
 /**
@@ -22,7 +22,7 @@ import "@prisma-next/framework-components/components";
 * @example
 * ```ts
 * const config = await loadConfig();
-* const frameworkComponents = [config.target, config.adapter, ...(config.extensionPacks ?? [])];
+* const frameworkComponents = [config.target, config.adapter, ...(config.extensions ?? [])];
 *
 * // Validate and type-narrow components before passing to planner
 * const typedComponents = assertFrameworkComponentsCompatible(
@@ -55,4 +55,4 @@ function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId,
 //#endregion
 export { assertFrameworkComponentsCompatible as t };
 
-//# sourceMappingURL=framework-components-CnbUbiJw.mjs.map
+//# sourceMappingURL=framework-components-DUN-TYDg.mjs.map

package/dist/framework-components-DUN-TYDg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-components-DUN-TYDg.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, errorContractMissingExtensions } 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.extensions ?? [])];\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, extensions).\n * @param stack - The control plane stack (target, adapter, driver, extensions).\n *\n * @throws {CliStructuredError} errorConfigValidation when contract.targetFamily or contract.target\n *   doesn't match the configured family/target.\n * @throws {CliStructuredError} errorContractMissingExtensions 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' | 'extensions'>;\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.extensions) {\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 errorContractMissingExtensions({\n      missingExtensions: result.missingExtensionPackIds,\n      providedComponentIds: [...providedComponentIds],\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,oCAId,kBACA,kBACA,qBACqE;CACrE,KAAK,IAAI,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;EACnD,MAAM,YAAY,oBAAoB;EAGtC,IAAI,OAAO,cAAc,YAAY,cAAc,MACjD,MAAM,sBAAsB,yBAAyB,EACnD,KAAK,gCAAgC,EAAE,oBACzC,CAAC;EAGH,MAAM,SAAS;EAGf,IAAI,CAAC,OAAO,OAAO,QAAQ,MAAM,GAC/B,MAAM,sBAAsB,8BAA8B,EACxD,KAAK,gCAAgC,EAAE,4BACzC,CAAC;EAGH,MAAM,OAAO,OAAO;EACpB,IAAI,SAAS,YAAY,SAAS,aAAa,SAAS,eAAe,SAAS,UAC9E,MAAM,sBAAsB,8BAA8B,EACxD,KAAK,gCAAgC,EAAE,qBAAqB,OAAO,IAAI,EAAE,2DAC3E,CAAC;EAIH,IAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,GACnC,MAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,IAAI,EAAE,iCAChE,CAAC;EAGH,MAAM,WAAW,OAAO;EACxB,IAAI,aAAa,kBACf,MAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,IAAI,EAAE,kBAAkB,OAAO,QAAQ,EAAE,kBAAkB,iBAAiB,GACtI,CAAC;EAIH,IAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,GACnC,MAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,IAAI,EAAE,iCAChE,CAAC;EAGH,MAAM,WAAW,OAAO;EACxB,IAAI,aAAa,kBACf,MAAM,sBAAsB,kCAAkC,EAC5D,KAAK,gCAAgC,EAAE,UAAU,OAAO,IAAI,EAAE,kBAAkB,OAAO,QAAQ,EAAE,kBAAkB,iBAAiB,GACtI,CAAC;CAEL;CAGA,OAAO;AACT"}

package/dist/{init-C3JhkHg-.mjs → init-C9U3ffHH.mjs}

@@ -1,6 +1,6 @@
-import { F as CliStructuredError, _ as createTerminalUI, b as formatErrorJson, x as formatErrorOutput } from "./command-helpers-Cpq44aVa.mjs";
+import { F as CliStructuredError, _ as createTerminalUI, b as formatErrorJson, x as formatErrorOutput } from "./command-helpers-CVn3U9Uz.mjs";
 import { a as starterSchema, c as version, i as schemaSample, n as dbFile, o as targetLabel, r as defaultSchemaPath, s as targetPackageName, t as configFile } from "./cli.mjs";
-import { i as renderInitOutro, n as buildNextSteps, r as formatInitJson, t as InitOutputSchema } from "./output-mEQ74_nd.mjs";
+import { i as renderInitOutro, n as buildNextSteps, r as formatInitJson, t as InitOutputSchema } from "./output-DWNYqZGc.mjs";
 import { createRequire } from "node:module";
 import { basename, dirname, extname, isAbsolute, join, normalize } from "pathe";
 import { blindCast } from "@prisma-next/utils/casts";
@@ -413,50 +413,59 @@ function errorInitSkillInstallFailed(options) {
 //#endregion
 //#region src/commands/init/hygiene-gitattributes.ts
 /**
-* The schema-relative `.gitattributes` entries written for a freshly
-* initialised project (FR3.4). Mirrors the relevant subset of the
-* repo-root [`.gitattributes`](../../../../../../../../.gitattributes):
+* The `.gitattributes` entries written for a freshly initialised project
+* (FR3.4). Mirrors the relevant subset of the repo-root
+* [`.gitattributes`](../../../../../../../../.gitattributes):
 *
 * - **Today**: `contract.json`, `contract.d.ts` are emitted on every
 *   `prisma-next contract emit`. Marking them `linguist-generated`
 *   keeps GitHub's diff stats honest and collapses the file in code
 *   review by default.
-* - **Forward-looking**: `end-contract.*`, `start-contract.*`, `ops.json`,
-*   `migration.json` are not yet emitted by `init` flows but will be
-*   produced by adjacent commands (lower / migration tooling). Adding
-*   them now matches Decision 5 (forward-looking subset) so the file
-*   does not need to be amended every time a new artefact lands.
-*
-* Patterns are written relative to the schema directory so a user
-* who runs `init --schema-path db/contract.prisma` gets
-* `db/contract.json linguist-generated` — not the workspace-glob form
-* `<glob>/contract.json` (which would over-match any unrelated
+* - **Forward-looking**: `ops.json`, `migration.json` are not yet emitted
+*   by `init` flows but will be produced by adjacent commands (lower /
+*   migration tooling). Adding them now matches Decision 5
+*   (forward-looking subset) so the file does not need to be amended
+*   every time a new artifact lands.
+*
+* `ARTIFACT_FILENAMES` entries are written relative to the schema
+* directory so a user who runs `init --schema-path db/contract.prisma`
+* gets `db/contract.json linguist-generated` — not the workspace-glob
+* form `<glob>/contract.json` (which would over-match any unrelated
 * `contract.json` the user has elsewhere) and not the absolute
-* `DEFAULT_CONTRACT_SOURCE_DIR/contract.json` (which would silently break for a non-default
-* schema path).
+* `DEFAULT_CONTRACT_SOURCE_DIR/contract.json` (which would silently
+* break for a non-default schema path).
+*
+* The migration contract snapshot store (`migrations/snapshots/<hex>/`)
+* is anchored to the migrations root instead, not the schema directory:
+* migration package depth under `migrations/` varies (`app/<pkg>`,
+* `<space>/<pkg>`, or a bare `<pkg>` in extension source repos), so no
+* single schema-dir-relative pattern can reach every snapshot. See
+* `STORE_GITATTRIBUTES_LINES` below.
 */
-const ARTEFACT_FILENAMES$1 = [
+const ARTIFACT_FILENAMES$1 = [
 	"contract.json",
 	"contract.d.ts",
-	"end-contract.json",
-	"end-contract.d.ts",
-	"start-contract.json",
-	"start-contract.d.ts",
 	"ops.json",
 	"migration.json"
 ];
 const ATTRIBUTE = "linguist-generated";
 /**
+* Full `.gitattributes` lines for the migration contract snapshot store,
+* already anchored to the migrations root — unlike `ARTIFACT_FILENAMES`,
+* these are not combined with the schema-relative prefix.
+*/
+const STORE_GITATTRIBUTES_LINES = [`migrations/snapshots/**/contract.json ${ATTRIBUTE}`, `migrations/snapshots/**/contract.d.ts ${ATTRIBUTE}`];
+/**
 * Computes the `.gitattributes` lines this scaffold expects to own. Each
 * line has the shape `<path> linguist-generated`. The `target` parameter
 * is currently unused but accepted for symmetry with the other hygiene
 * helpers and to leave room for target-specific entries (e.g. a future
-* Mongo-only artefact) without a signature break.
+* family-specific artifact) without a signature break.
 */
 function requiredGitattributesLines(schemaDir, _target) {
 	const dir = schemaDir === "." ? "" : schemaDir.replace(/\/+$/, "");
 	const prefix = dir === "" ? "" : `${dir}/`;
-	return ARTEFACT_FILENAMES$1.map((file) => `${prefix}${file} ${ATTRIBUTE}`);
+	return [...ARTIFACT_FILENAMES$1.map((file) => `${prefix}${file} ${ATTRIBUTE}`), ...STORE_GITATTRIBUTES_LINES];
 }
 /**
 * Idempotent `.gitattributes` merge (FR3.4 / FR9.3). Returns the new file
@@ -1037,40 +1046,39 @@ function requirePeer(moduleId, baseDir, overrides) {
 /**
 * Filenames the contract pipeline emits next to the user's schema source
 * (`<schemaDir>/contract.json`, `<schemaDir>/contract.d.ts`, …). Mirrors
-* `ARTEFACT_FILENAMES` in `hygiene-gitattributes.ts`; kept as a separate
-* constant here because the cleanup contract is target-agnostic and we
-* deliberately do not want a stale `start-contract.json` from a previous
-* target lingering after a re-init.
-*
-* If a future emit pipeline produces an additional artefact, add it here
-* **and** to the gitattributes list — the two stay in lockstep so the
-* file `init` advertises as `linguist-generated` is exactly the file
-* `init` is willing to delete on re-init.
-*/
-const ARTEFACT_FILENAMES = [
+* the schema-dir-relative `ARTIFACT_FILENAMES` in `hygiene-gitattributes.ts`
+* (not that file's migrations-root-anchored store lines, which are outside
+* this command's scope — reinit only ever touches `schemaDir`); kept as a
+* separate constant here because the cleanup contract is target-agnostic
+* and we deliberately do not want a stale artifact from a previous target
+* lingering after a re-init.
+*
+* If a future emit pipeline produces an additional schema-dir artifact,
+* add it here **and** to `ARTIFACT_FILENAMES` in `hygiene-gitattributes.ts`
+* — the two stay in lockstep so the file `init` advertises as
+* `linguist-generated` is exactly the file `init` is willing to delete on
+* re-init.
+*/
+const ARTIFACT_FILENAMES = [
 	"contract.json",
 	"contract.d.ts",
-	"end-contract.json",
-	"end-contract.d.ts",
-	"start-contract.json",
-	"start-contract.d.ts",
 	"ops.json",
 	"migration.json"
 ];
 /**
-* Returns the schema-relative paths of stale contract artefacts the
+* Returns the schema-relative paths of stale contract artifacts the
 * previous `init` run (or a `contract emit`) left behind in `schemaDir`.
 * Paths are returned relative to `baseDir` so the caller can plumb them
 * into `filesWritten`-style logging without re-deriving the path.
 *
 * Pure function: no filesystem mutation. Used by `runInit`'s precondition
 * phase (FR6.2 / NFR3 atomicity) so a downstream parse failure leaves
-* the artefacts on disk and the project byte-identical to its pre-init
+* the artifacts on disk and the project byte-identical to its pre-init
 * state.
 */
-function findStaleArtefacts(baseDir, schemaDir) {
+function findStaleArtifacts(baseDir, schemaDir) {
 	const result = [];
-	for (const filename of ARTEFACT_FILENAMES) {
+	for (const filename of ARTIFACT_FILENAMES) {
 		const rel = join(schemaDir, filename);
 		if (existsSync(join(baseDir, rel))) result.push(rel);
 	}
@@ -1669,7 +1677,7 @@ async function runInit(baseDir, runOptions) {
 			content: envExampleContent(inputs.target)
 		}
 	];
-	const filesToDelete = inputs.reinit ? [...findStaleArtefacts(baseDir, schemaDir)] : [];
+	const filesToDelete = inputs.reinit ? [...findStaleArtifacts(baseDir, schemaDir)] : [];
 	if (existsSync(join(baseDir, ".agents/skills/prisma-next/SKILL.md"))) filesToDelete.push(LEGACY_SKILL_FILE);
 	if (inputs.writeEnv) if (!existsSync(join(baseDir, ".env"))) filesToWrite.push({
 		path: ".env",
@@ -2081,7 +2089,7 @@ function formatCatalogWarning(workspaceFile, entries) {
 /**
 * Recognised pnpm error signatures that justify a fallback to npm.
 *
-* These patterns indicate the published artefact itself is at fault
+* These patterns indicate the published artifact itself is at fault
 * (a leaked `workspace:*` or `catalog:` specifier), not the user's
 * environment — pnpm is faithfully reporting "I cannot resolve this
 * registry version", and npm is willing to install it because npm
@@ -2140,7 +2148,7 @@ async function runEmit(ctx) {
 	const spinner = ctx.ui.spinner();
 	spinner.start("Emitting contract...");
 	try {
-		const { executeContractEmit } = await import("./contract-emit-cJQBlvGb.mjs").then((n) => n.t);
+		const { executeContractEmit } = await import("./contract-emit-CfIbTnsR.mjs").then((n) => n.t);
 		await executeContractEmit({ configPath: join(ctx.baseDir, "prisma-next.config.ts") });
 		spinner.stop("Contract emitted");
 	} catch (err) {
@@ -2193,4 +2201,4 @@ function sanitisePackageName(raw) {
 //#endregion
 export { runInit };
 
-//# sourceMappingURL=init-C3JhkHg-.mjs.map
+//# sourceMappingURL=init-C9U3ffHH.mjs.map