@prisma-next/cli 0.3.0-dev.16 → 0.3.0-dev.163

package/src/utils/terminal-ui.ts

@@ -0,0 +1,276 @@
+import * as clack from '@clack/prompts';
+import { bold, cyan, dim, green, red, yellow } from 'colorette';
+import { shutdownSignal } from './shutdown';
+
+/**
+ * Composable CLI output abstraction.
+ *
+ * Follows the Unix convention of separating data from decoration:
+ * - **stdout** — data output only (`ui.output()`). This is what scripts and pipes capture.
+ * - **stderr** — all decoration (spinners, logs, notes, intro/outro). Visible in terminal, invisible in pipes.
+ *
+ * Rules:
+ * 1. All methods except `output()` and `error()` write to stderr only in interactive mode.
+ * 2. `output(data)` always writes to stdout — if a command calls it, there is data to emit.
+ * 3. `error()` always writes to stderr — errors matter even when piped.
+ * 4. All other decoration is suppressed when piped — `isInteractive` gates every other decoration method.
+ * 5. Never write data to stderr — decoration methods are for human context only.
+ * 6. Never write decoration to stdout — it breaks pipes, `$(...)` captures, and `> file` redirects.
+ */
+export class TerminalUI {
+  /**
+   * True when stdout is a TTY (interactive terminal).
+   * False when piped (e.g., `prisma-next db verify | jq`).
+   */
+  readonly isInteractive: boolean;
+
+  /**
+   * Whether color output is enabled.
+   */
+  readonly useColor: boolean;
+
+  private static readonly stderrOpts = { output: process.stderr } as const;
+
+  constructor(options?: {
+    readonly color?: boolean | undefined;
+    readonly interactive?: boolean | undefined;
+  }) {
+    // --interactive/--no-interactive override TTY detection
+    this.isInteractive = options?.interactive ?? !!process.stdout.isTTY;
+    this.useColor = options?.color ?? this.isInteractive;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Decoration → stderr (only in interactive mode)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Log a message line to stderr. No-op when piped.
+   */
+  log(message: string): void {
+    if (!this.isInteractive) return;
+    clack.log.message(message, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Log a success message to stderr. No-op when piped.
+   */
+  success(message: string): void {
+    if (!this.isInteractive) return;
+    clack.log.success(message, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Log a warning message to stderr. No-op when piped.
+   */
+  warn(message: string): void {
+    if (!this.isInteractive) return;
+    clack.log.warn(message, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Log an error message to stderr. Always writes (errors matter even in pipes).
+   */
+  error(message: string): void {
+    clack.log.error(message, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Log an info message to stderr. No-op when piped.
+   */
+  info(message: string): void {
+    if (!this.isInteractive) return;
+    clack.log.info(message, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Log a step message to stderr. No-op when piped.
+   */
+  step(message: string): void {
+    if (!this.isInteractive) return;
+    clack.log.step(message, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Display a note box on stderr. No-op when piped.
+   */
+  note(message: string, title?: string): void {
+    if (!this.isInteractive) return;
+    clack.note(message, title, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Display intro banner on stderr. No-op when piped.
+   */
+  intro(title?: string): void {
+    if (!this.isInteractive) return;
+    clack.intro(title, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Display outro banner on stderr. No-op when piped.
+   */
+  outro(message?: string): void {
+    if (!this.isInteractive) return;
+    clack.outro(message, TerminalUI.stderrOpts);
+  }
+
+  /**
+   * Create a Clack spinner on stderr with a 100ms delay threshold.
+   * The spinner only appears if the operation takes longer than the threshold,
+   * avoiding flicker for fast operations. Returns a no-op spinner when not interactive.
+   */
+  spinner(delayMs = 100): clack.SpinnerResult {
+    const noop: clack.SpinnerResult = {
+      start: () => {},
+      stop: () => {},
+      cancel: () => {},
+      error: () => {},
+      message: () => {},
+      clear: () => {},
+      get isCancelled() {
+        return false;
+      },
+    };
+
+    if (!this.isInteractive) {
+      return noop;
+    }
+
+    // Wrap the real spinner with a delay: only show it after `delayMs`
+    let inner: clack.SpinnerResult | undefined;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let pendingMsg: string | undefined;
+    let settled = false;
+
+    const ensureCleared = () => {
+      if (timer !== undefined) {
+        clearTimeout(timer);
+        timer = undefined;
+      }
+    };
+
+    // Cancel the spinner if a shutdown signal fires
+    const onAbort = () => {
+      if (!settled) {
+        settled = true;
+        ensureCleared();
+        if (inner) {
+          inner.cancel('Interrupted');
+        }
+      }
+    };
+    if (!shutdownSignal.aborted) {
+      shutdownSignal.addEventListener('abort', onAbort, { once: true });
+    }
+
+    return {
+      start(msg?: string) {
+        pendingMsg = msg;
+        timer = setTimeout(() => {
+          if (!settled) {
+            inner = clack.spinner(TerminalUI.stderrOpts);
+            inner.start(pendingMsg);
+          }
+        }, delayMs);
+      },
+      stop(msg?: string) {
+        settled = true;
+        ensureCleared();
+        if (inner) {
+          inner.stop(msg);
+        }
+      },
+      cancel(msg?: string) {
+        settled = true;
+        ensureCleared();
+        if (inner) {
+          inner.cancel(msg);
+        }
+      },
+      error(msg?: string) {
+        settled = true;
+        ensureCleared();
+        if (inner) {
+          inner.error(msg);
+        }
+      },
+      message(msg?: string) {
+        pendingMsg = msg;
+        if (inner) {
+          inner.message(msg);
+        }
+      },
+      clear() {
+        settled = true;
+        ensureCleared();
+        if (inner) {
+          inner.clear();
+        }
+      },
+      get isCancelled() {
+        return inner?.isCancelled ?? false;
+      },
+    };
+  }
+
+  /**
+   * Prompt for yes/no confirmation on stderr. Returns true if confirmed.
+   * In non-interactive mode or when cancelled (Ctrl-C), returns false.
+   */
+  async confirm(message: string): Promise<boolean> {
+    if (!this.isInteractive) return false;
+    const result = await clack.confirm({
+      message,
+      ...TerminalUI.stderrOpts,
+    });
+    if (clack.isCancel(result)) return false;
+    return result;
+  }
+
+  /**
+   * Write a raw line to stderr. No-op when piped.
+   * Use for decoration that doesn't fit Clack's log format (e.g. styled headers).
+   */
+  stderr(message: string): void {
+    if (!this.isInteractive) return;
+    process.stderr.write(`${message}\n`);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Data → stdout (only when piped)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Write machine-readable data to stdout.
+   * Always writes — if a command calls output(), there is data to emit.
+   *
+   * This is what scripts and pipes capture: `prisma-next db verify --json | jq .ok`
+   */
+  output(data: string): void {
+    process.stdout.write(`${data}\n`);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Color helpers
+  // ---------------------------------------------------------------------------
+
+  green(text: string): string {
+    return this.useColor ? green(text) : text;
+  }
+  red(text: string): string {
+    return this.useColor ? red(text) : text;
+  }
+  cyan(text: string): string {
+    return this.useColor ? cyan(text) : text;
+  }
+  dim(text: string): string {
+    return this.useColor ? dim(text) : text;
+  }
+  bold(text: string): string {
+    return this.useColor ? bold(text) : text;
+  }
+  yellow(text: string): string {
+    return this.useColor ? yellow(text) : text;
+  }
+}

package/dist/chunk-5MPKZYVI.js

@@ -1,47 +0,0 @@
-import {
-  CliStructuredError
-} from "./chunk-VI2YETW7.js";
-
-// src/utils/action.ts
-import { notOk, ok } from "@prisma-next/utils/result";
-async function performAction(fn) {
-  try {
-    const value = await fn();
-    return ok(value);
-  } catch (error) {
-    if (error instanceof CliStructuredError) {
-      return notOk(error);
-    }
-    throw error;
-  }
-}
-
-// src/utils/spinner.ts
-import ora from "ora";
-async function withSpinner(operation, options) {
-  const { message, flags } = options;
-  const shouldShowSpinner = !flags.quiet && flags.json !== "object" && process.stdout.isTTY;
-  if (!shouldShowSpinner) {
-    return operation();
-  }
-  const startTime = Date.now();
-  const spinner = ora({
-    text: message,
-    color: flags.color !== false ? "cyan" : false
-  }).start();
-  try {
-    const result = await operation();
-    const elapsed = Date.now() - startTime;
-    spinner.succeed(`${message} (${elapsed}ms)`);
-    return result;
-  } catch (error) {
-    spinner.fail(`${message} failed: ${error instanceof Error ? error.message : String(error)}`);
-    throw error;
-  }
-}
-
-export {
-  performAction,
-  withSpinner
-};
-//# sourceMappingURL=chunk-5MPKZYVI.js.map

package/dist/chunk-5MPKZYVI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/action.ts","../src/utils/spinner.ts"],"sourcesContent":["import type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { CliStructuredError } from './cli-errors';\n\nexport type CliResult<T> = Result<T, CliStructuredError>;\n\n/**\n * Performs an async action and catches structured errors, returning a Result.\n * Only catches CliStructuredError instances - other errors are allowed to propagate (fail fast).\n * If the function throws a CliStructuredError, it's caught and converted to a NotOk result.\n */\nexport async function performAction<T>(fn: () => Promise<T>): Promise<CliResult<T>> {\n  try {\n    const value = await fn();\n    return ok(value);\n  } catch (error) {\n    // Only catch structured errors - let other errors propagate (fail fast)\n    if (error instanceof CliStructuredError) {\n      return notOk(error);\n    }\n    // Re-throw non-structured errors to fail fast\n    throw error;\n  }\n}\n\n/**\n * Wraps a synchronous function to catch structured errors and return a Result.\n * Only catches CliStructuredError instances - other errors are allowed to propagate (fail fast).\n * If the function throws a CliStructuredError, it's caught and converted to a NotOk result.\n */\nexport function wrapSync<T>(fn: () => T): CliResult<T> {\n  try {\n    const value = fn();\n    return ok(value);\n  } catch (error) {\n    // Only catch structured errors - let other errors propagate (fail fast)\n    if (error instanceof CliStructuredError) {\n      return notOk(error);\n    }\n    // Re-throw non-structured errors to fail fast\n    throw error;\n  }\n}\n","import ora from 'ora';\nimport type { GlobalFlags } from './global-flags';\n\n/**\n * Options for the withSpinner helper function.\n */\ninterface WithSpinnerOptions {\n  /**\n   * The message to display in the spinner.\n   */\n  readonly message: string;\n  /**\n   * Global flags that control spinner behavior (quiet, json, color).\n   */\n  readonly flags: GlobalFlags;\n}\n\n/**\n * Wraps an async operation with a spinner.\n *\n * The spinner respects:\n * - `flags.quiet`: No spinner if quiet mode is enabled\n * - `flags.json === 'object'`: No spinner if JSON output is enabled\n * - Non-TTY environments: No spinner if stdout is not a TTY\n *\n * @param operation - The async operation to execute\n * @param options - Spinner configuration options\n * @returns The result of the operation\n */\nexport async function withSpinner<T>(\n  operation: () => Promise<T>,\n  options: WithSpinnerOptions,\n): Promise<T> {\n  const { message, flags } = options;\n\n  // Skip spinner if quiet, JSON output, or non-TTY\n  const shouldShowSpinner = !flags.quiet && flags.json !== 'object' && process.stdout.isTTY;\n\n  if (!shouldShowSpinner) {\n    // Just execute the operation without spinner\n    return operation();\n  }\n\n  // Start spinner immediately\n  const startTime = Date.now();\n  const spinner = ora({\n    text: message,\n    color: flags.color !== false ? 'cyan' : false,\n  }).start();\n\n  try {\n    // Execute the operation\n    const result = await operation();\n\n    // Mark spinner as succeeded\n    const elapsed = Date.now() - startTime;\n    spinner.succeed(`${message} (${elapsed}ms)`);\n\n    return result;\n  } catch (error) {\n    // Mark spinner as failed\n    spinner.fail(`${message} failed: ${error instanceof Error ? error.message : String(error)}`);\n\n    // Re-throw the error\n    throw error;\n  }\n}\n"],"mappings":";;;;;AACA,SAAS,OAAO,UAAU;AAU1B,eAAsB,cAAiB,IAA6C;AAClF,MAAI;AACF,UAAM,QAAQ,MAAM,GAAG;AACvB,WAAO,GAAG,KAAK;AAAA,EACjB,SAAS,OAAO;AAEd,QAAI,iBAAiB,oBAAoB;AACvC,aAAO,MAAM,KAAK;AAAA,IACpB;AAEA,UAAM;AAAA,EACR;AACF;;;ACvBA,OAAO,SAAS;AA6BhB,eAAsB,YACpB,WACA,SACY;AACZ,QAAM,EAAE,SAAS,MAAM,IAAI;AAG3B,QAAM,oBAAoB,CAAC,MAAM,SAAS,MAAM,SAAS,YAAY,QAAQ,OAAO;AAEpF,MAAI,CAAC,mBAAmB;AAEtB,WAAO,UAAU;AAAA,EACnB;AAGA,QAAM,YAAY,KAAK,IAAI;AAC3B,QAAM,UAAU,IAAI;AAAA,IAClB,MAAM;AAAA,IACN,OAAO,MAAM,UAAU,QAAQ,SAAS;AAAA,EAC1C,CAAC,EAAE,MAAM;AAET,MAAI;AAEF,UAAM,SAAS,MAAM,UAAU;AAG/B,UAAM,UAAU,KAAK,IAAI,IAAI;AAC7B,YAAQ,QAAQ,GAAG,OAAO,KAAK,OAAO,KAAK;AAE3C,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,YAAQ,KAAK,GAAG,OAAO,YAAY,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC,EAAE;AAG3F,UAAM;AAAA,EACR;AACF;","names":[]}

package/dist/chunk-6EPKRATC.js

@@ -1,91 +0,0 @@
-import {
-  errorConfigValidation,
-  errorContractMissingExtensionPacks
-} from "./chunk-VI2YETW7.js";
-
-// src/utils/framework-components.ts
-import {
-  checkContractComponentRequirements
-} from "@prisma-next/contract/framework-components";
-function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId, frameworkComponents) {
-  for (let i = 0; i < frameworkComponents.length; i++) {
-    const component = frameworkComponents[i];
-    if (typeof component !== "object" || component === null) {
-      throw errorConfigValidation("frameworkComponents[]", {
-        why: `Framework component at index ${i} must be an object`
-      });
-    }
-    const record = component;
-    if (!Object.hasOwn(record, "kind")) {
-      throw errorConfigValidation("frameworkComponents[].kind", {
-        why: `Framework component at index ${i} must have 'kind' property`
-      });
-    }
-    const kind = record["kind"];
-    if (kind !== "target" && kind !== "adapter" && kind !== "extension" && kind !== "driver") {
-      throw errorConfigValidation("frameworkComponents[].kind", {
-        why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')`
-      });
-    }
-    if (!Object.hasOwn(record, "familyId")) {
-      throw errorConfigValidation("frameworkComponents[].familyId", {
-        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property`
-      });
-    }
-    const familyId = record["familyId"];
-    if (familyId !== expectedFamilyId) {
-      throw errorConfigValidation("frameworkComponents[].familyId", {
-        why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'`
-      });
-    }
-    if (!Object.hasOwn(record, "targetId")) {
-      throw errorConfigValidation("frameworkComponents[].targetId", {
-        why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property`
-      });
-    }
-    const targetId = record["targetId"];
-    if (targetId !== expectedTargetId) {
-      throw errorConfigValidation("frameworkComponents[].targetId", {
-        why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'`
-      });
-    }
-  }
-  return frameworkComponents;
-}
-function assertContractRequirementsSatisfied({
-  contract,
-  stack
-}) {
-  const providedComponentIds = /* @__PURE__ */ new Set([stack.target.id, stack.adapter.id]);
-  for (const extension of stack.extensionPacks) {
-    providedComponentIds.add(extension.id);
-  }
-  const result = checkContractComponentRequirements({
-    contract,
-    expectedTargetFamily: stack.target.familyId,
-    expectedTargetId: stack.target.targetId,
-    providedComponentIds
-  });
-  if (result.familyMismatch) {
-    throw errorConfigValidation("contract.targetFamily", {
-      why: `Contract was emitted for family '${result.familyMismatch.actual}' but CLI config is wired to '${result.familyMismatch.expected}'.`
-    });
-  }
-  if (result.targetMismatch) {
-    throw errorConfigValidation("contract.target", {
-      why: `Contract target '${result.targetMismatch.actual}' does not match CLI target '${result.targetMismatch.expected}'.`
-    });
-  }
-  if (result.missingExtensionPackIds.length > 0) {
-    throw errorContractMissingExtensionPacks({
-      missingExtensionPacks: result.missingExtensionPackIds,
-      providedComponentIds: [...providedComponentIds]
-    });
-  }
-}
-
-export {
-  assertFrameworkComponentsCompatible,
-  assertContractRequirementsSatisfied
-};
-//# sourceMappingURL=chunk-6EPKRATC.js.map

package/dist/chunk-6EPKRATC.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/framework-components.ts"],"sourcesContent":["import {\n  checkContractComponentRequirements,\n  type TargetBoundComponentDescriptor,\n} from '@prisma-next/contract/framework-components';\nimport type { ContractIR } from '@prisma-next/contract/ir';\nimport type { ControlPlaneStack } from '@prisma-next/core-control-plane/types';\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 IR 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 contractIR = await loadContractJson(config.contract.output);\n * const stack = createControlPlaneStack({ target: config.target, adapter: config.adapter, ... });\n *\n * // Throws if contract is incompatible with config\n * assertContractRequirementsSatisfied({ contract: contractIR, stack });\n * ```\n */\nexport function assertContractRequirementsSatisfied<\n  TFamilyId extends string,\n  TTargetId extends string,\n>({\n  contract,\n  stack,\n}: {\n  readonly contract: Pick<ContractIR, 'targetFamily' | 'target' | 'extensionPacks'>;\n  readonly stack: ControlPlaneStack<TFamilyId, TTargetId>;\n}): void {\n  const providedComponentIds = new Set<string>([stack.target.id, stack.adapter.id]);\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":";;;;;;AAAA;AAAA,EACE;AAAA,OAEK;AAuCA,SAAS,oCAId,kBACA,kBACA,qBACqE;AACrE,WAAS,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;AACnD,UAAM,YAAY,oBAAoB,CAAC;AAGvC,QAAI,OAAO,cAAc,YAAY,cAAc,MAAM;AACvD,YAAM,sBAAsB,yBAAyB;AAAA,QACnD,KAAK,gCAAgC,CAAC;AAAA,MACxC,CAAC;AAAA,IACH;AAEA,UAAM,SAAS;AAGf,QAAI,CAAC,OAAO,OAAO,QAAQ,MAAM,GAAG;AAClC,YAAM,sBAAsB,8BAA8B;AAAA,QACxD,KAAK,gCAAgC,CAAC;AAAA,MACxC,CAAC;AAAA,IACH;AAEA,UAAM,OAAO,OAAO,MAAM;AAC1B,QAAI,SAAS,YAAY,SAAS,aAAa,SAAS,eAAe,SAAS,UAAU;AACxF,YAAM,sBAAsB,8BAA8B;AAAA,QACxD,KAAK,gCAAgC,CAAC,sBAAsB,OAAO,IAAI,CAAC;AAAA,MAC1E,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,GAAG;AACtC,YAAM,sBAAsB,kCAAkC;AAAA,QAC5D,KAAK,gCAAgC,CAAC,WAAW,OAAO,IAAI,CAAC;AAAA,MAC/D,CAAC;AAAA,IACH;AAEA,UAAM,WAAW,OAAO,UAAU;AAClC,QAAI,aAAa,kBAAkB;AACjC,YAAM,sBAAsB,kCAAkC;AAAA,QAC5D,KAAK,gCAAgC,CAAC,WAAW,OAAO,IAAI,CAAC,mBAAmB,OAAO,QAAQ,CAAC,mBAAmB,gBAAgB;AAAA,MACrI,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,GAAG;AACtC,YAAM,sBAAsB,kCAAkC;AAAA,QAC5D,KAAK,gCAAgC,CAAC,WAAW,OAAO,IAAI,CAAC;AAAA,MAC/D,CAAC;AAAA,IACH;AAEA,UAAM,WAAW,OAAO,UAAU;AAClC,QAAI,aAAa,kBAAkB;AACjC,YAAM,sBAAsB,kCAAkC;AAAA,QAC5D,KAAK,gCAAgC,CAAC,WAAW,OAAO,IAAI,CAAC,mBAAmB,OAAO,QAAQ,CAAC,mBAAmB,gBAAgB;AAAA,MACrI,CAAC;AAAA,IACH;AAAA,EACF;AAGA,SAAO;AACT;AA6BO,SAAS,oCAGd;AAAA,EACA;AAAA,EACA;AACF,GAGS;AACP,QAAM,uBAAuB,oBAAI,IAAY,CAAC,MAAM,OAAO,IAAI,MAAM,QAAQ,EAAE,CAAC;AAChF,aAAW,aAAa,MAAM,gBAAgB;AAC5C,yBAAqB,IAAI,UAAU,EAAE;AAAA,EACvC;AAEA,QAAM,SAAS,mCAAmC;AAAA,IAChD;AAAA,IACA,sBAAsB,MAAM,OAAO;AAAA,IACnC,kBAAkB,MAAM,OAAO;AAAA,IAC/B;AAAA,EACF,CAAC;AAED,MAAI,OAAO,gBAAgB;AACzB,UAAM,sBAAsB,yBAAyB;AAAA,MACnD,KAAK,oCAAoC,OAAO,eAAe,MAAM,iCAAiC,OAAO,eAAe,QAAQ;AAAA,IACtI,CAAC;AAAA,EACH;AAEA,MAAI,OAAO,gBAAgB;AACzB,UAAM,sBAAsB,mBAAmB;AAAA,MAC7C,KAAK,oBAAoB,OAAO,eAAe,MAAM,gCAAgC,OAAO,eAAe,QAAQ;AAAA,IACrH,CAAC;AAAA,EACH;AAEA,MAAI,OAAO,wBAAwB,SAAS,GAAG;AAC7C,UAAM,mCAAmC;AAAA,MACvC,uBAAuB,OAAO;AAAA,MAC9B,sBAAsB,CAAC,GAAG,oBAAoB;AAAA,IAChD,CAAC;AAAA,EACH;AACF;","names":[]}