@prisma-next/core-control-plane 0.3.0-dev.5 → 0.3.0-dev.50

package/src/emission/hashing.ts

@@ -1,46 +1,32 @@
 import { createHash } from 'node:crypto';
-import type { ContractIR } from '@prisma-next/contract/ir';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { CanonicalContractInput } from './canonicalization';
 import { canonicalizeContract } from './canonicalization';
 
-type ContractInput = {
-  schemaVersion: string;
-  targetFamily: string;
-  target: string;
-  models: Record<string, unknown>;
-  relations: Record<string, unknown>;
-  storage: Record<string, unknown>;
-  extensionPacks: Record<string, unknown>;
-  sources: Record<string, unknown>;
-  capabilities: Record<string, Record<string, boolean>>;
-  meta: Record<string, unknown>;
-  [key: string]: unknown;
-};
-
 function computeHash(content: string): string {
   const hash = createHash('sha256');
   hash.update(content);
   return `sha256:${hash.digest('hex')}`;
 }
 
-export function computeCoreHash(contract: ContractInput): string {
-  const coreContract: ContractIR = {
+export function computeStorageHash(contract: CanonicalContractInput): string {
+  const storageContract = {
     schemaVersion: contract.schemaVersion,
     targetFamily: contract.targetFamily,
     target: contract.target,
-    models: contract.models,
-    relations: contract.relations,
     storage: contract.storage,
-    extensionPacks: contract.extensionPacks,
-    sources: contract.sources,
-    capabilities: contract.capabilities,
-    meta: contract.meta,
+    models: {},
+    relations: {},
+    extensionPacks: {},
+    capabilities: {},
+    meta: {},
   };
-  const canonical = canonicalizeContract(coreContract);
+  const canonical = canonicalizeContract(storageContract);
   return computeHash(canonical);
 }
 
-export function computeProfileHash(contract: ContractInput): string {
-  const profileContract: ContractIR = {
+export function computeProfileHash(contract: CanonicalContractInput): string {
+  const profileContract = {
     schemaVersion: contract.schemaVersion,
     targetFamily: contract.targetFamily,
     target: contract.target,
@@ -50,8 +36,24 @@ export function computeProfileHash(contract: ContractInput): string {
     extensionPacks: {},
     capabilities: contract.capabilities,
     meta: {},
-    sources: {},
   };
   const canonical = canonicalizeContract(profileContract);
   return computeHash(canonical);
 }
+
+export function computeExecutionHash(contract: CanonicalContractInput): string {
+  const executionContract = {
+    schemaVersion: contract.schemaVersion,
+    targetFamily: contract.targetFamily,
+    target: contract.target,
+    models: {},
+    relations: {},
+    storage: {},
+    extensionPacks: {},
+    capabilities: {},
+    meta: {},
+    ...ifDefined('execution', contract.execution),
+  };
+  const canonical = canonicalizeContract(executionContract);
+  return computeHash(canonical);
+}

package/src/emission/types.ts

@@ -1,4 +1,4 @@
-import type { TypesImportSpec } from '@prisma-next/contract/types';
+import type { TypeRenderEntry, TypesImportSpec } from '@prisma-next/contract/types';
 import type { OperationRegistry } from '@prisma-next/operations';
 
 export interface EmitOptions {
@@ -7,11 +7,22 @@ export interface EmitOptions {
   readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
   readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;
   readonly extensionIds?: ReadonlyArray<string>;
+  /**
+   * Normalized parameterized type renderers, keyed by codecId.
+   * These are extracted from descriptors and normalized during assembly.
+   */
+  readonly parameterizedRenderers?: Map<string, TypeRenderEntry>;
+  /**
+   * Type imports for parameterized codecs.
+   * These are added to contract.d.ts alongside codec and operation type imports.
+   */
+  readonly parameterizedTypeImports?: ReadonlyArray<TypesImportSpec>;
 }
 
 export interface EmitResult {
   readonly contractJson: string;
   readonly contractDts: string;
-  readonly coreHash: string;
+  readonly storageHash: string;
+  readonly executionHash?: string;
   readonly profileHash: string;
 }

package/src/errors.ts

@@ -94,6 +94,23 @@ export class CliStructuredError extends Error {
       docsUrl: this.docsUrl,
     };
   }
+
+  /**
+   * Type guard to check if an error is a CliStructuredError.
+   * Uses duck-typing to work across module boundaries where instanceof may fail.
+   */
+  static is(error: unknown): error is CliStructuredError {
+    if (!(error instanceof Error)) {
+      return false;
+    }
+    const candidate = error as CliStructuredError;
+    return (
+      candidate.name === 'CliStructuredError' &&
+      typeof candidate.code === 'string' &&
+      (candidate.domain === 'CLI' || candidate.domain === 'RTM') &&
+      typeof candidate.toEnvelope === 'function'
+    );
+  }
 }
 
 // ============================================================================
@@ -171,13 +188,15 @@ export function errorFileNotFound(
 }
 
 /**
- * Database URL is required but not provided.
+ * Database connection is required but not provided.
  */
-export function errorDatabaseUrlRequired(options?: { readonly why?: string }): CliStructuredError {
-  return new CliStructuredError('4005', 'Database URL is required', {
+export function errorDatabaseConnectionRequired(options?: {
+  readonly why?: string;
+}): CliStructuredError {
+  return new CliStructuredError('4005', 'Database connection is required', {
     domain: 'CLI',
-    why: options?.why ?? 'Database URL is required for this command',
-    fix: 'Provide `--db <url>` or set `db: { url: "postgres://…" }` in prisma-next.config.ts',
+    why: options?.why ?? 'Database connection is required for this command',
+    fix: 'Provide `--db <url>` or set `db: { connection: "postgres://…" }` in prisma-next.config.ts',
   });
 }
 

package/src/exports/config-types.ts

@@ -3,3 +3,10 @@ export type {
   PrismaNextConfig,
 } from '../config-types';
 export { defineConfig } from '../config-types';
+export type {
+  ContractSourceDiagnostic,
+  ContractSourceDiagnosticPosition,
+  ContractSourceDiagnosticSpan,
+  ContractSourceDiagnostics,
+  ContractSourceProvider,
+} from '../contract-source-types';

package/src/exports/emission.ts

@@ -2,5 +2,5 @@
 
 export { canonicalizeContract } from '../emission/canonicalization';
 export { emit } from '../emission/emit';
-export { computeCoreHash, computeProfileHash } from '../emission/hashing';
+export { computeExecutionHash, computeProfileHash, computeStorageHash } from '../emission/hashing';
 export type { EmitOptions, EmitResult } from '../emission/types';

package/src/exports/errors.ts

@@ -6,7 +6,7 @@ export {
   errorContractConfigMissing,
   errorContractMissingExtensionPacks,
   errorContractValidationFailed,
-  errorDatabaseUrlRequired,
+  errorDatabaseConnectionRequired,
   errorDriverRequired,
   errorFamilyReadMarkerSqlRequired,
   errorFileNotFound,

package/src/exports/stack.ts

@@ -0,0 +1 @@
+export { createControlPlaneStack } from '../stack';

package/src/exports/types.ts

@@ -8,6 +8,7 @@ export type {
   ControlExtensionInstance,
   ControlFamilyDescriptor,
   ControlFamilyInstance,
+  ControlPlaneStack,
   ControlTargetDescriptor,
   ControlTargetInstance,
   EmitContractResult,

package/src/migrations.ts

@@ -58,7 +58,7 @@ export interface MigrationPlan {
   readonly targetId: string;
   /** Destination contract identity that the plan intends to reach. */
   readonly destination: {
-    readonly coreHash: string;
+    readonly storageHash: string;
     readonly profileHash?: string;
   };
   /** Ordered list of operations to execute. */

package/src/stack.ts

@@ -0,0 +1,38 @@
+import type {
+  ControlAdapterDescriptor,
+  ControlDriverDescriptor,
+  ControlExtensionDescriptor,
+  ControlPlaneStack,
+  ControlTargetDescriptor,
+} from './types';
+
+/**
+ * Creates a ControlPlaneStack from component descriptors.
+ *
+ * Provides sensible defaults:
+ * - `driver` defaults to `undefined` (optional for commands that don't need DB connection)
+ * - `extensionPacks` defaults to `[]` (empty array)
+ *
+ * @example
+ * ```ts
+ * const stack = createControlPlaneStack({
+ *   target: postgresTarget,
+ *   adapter: postgresAdapter,
+ *   driver: postgresDriver, // optional
+ *   extensionPacks: [pgvector], // optional
+ * });
+ * ```
+ */
+export function createControlPlaneStack<TFamilyId extends string, TTargetId extends string>(input: {
+  readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;
+  readonly adapter: ControlAdapterDescriptor<TFamilyId, TTargetId>;
+  readonly driver?: ControlDriverDescriptor<TFamilyId, TTargetId> | undefined;
+  readonly extensionPacks?: readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[] | undefined;
+}): ControlPlaneStack<TFamilyId, TTargetId> {
+  return {
+    target: input.target,
+    adapter: input.adapter,
+    driver: input.driver,
+    extensionPacks: input.extensionPacks ?? [],
+  };
+}

package/src/types.ts

@@ -53,17 +53,17 @@ export interface ControlFamilyInstance<TFamilyId extends string, TSchemaIR = unk
    * Mappings are runtime-only and should not be part of ContractIR.
    *
    * Note: The returned ContractIR may include additional fields from the emitted contract
-   * (like coreHash, profileHash) that are not part of the ContractIR type but are preserved
+   * (like storageHash/executionHash, profileHash) that are not part of the ContractIR type but are preserved
    * for use by verify/sign operations.
    */
   validateContractIR(contractJson: unknown): ContractIR;
 
   /**
    * Verifies the database marker against the contract.
-   * Compares target, coreHash, and profileHash.
+   * Compares target, storageHash, and profileHash.
    *
    * @param options.contractIR - The validated contract (from validateContractIR). Must have
-   *   coreHash and target fields for verification. These fields are present in emitted
+   *   storageHash and target fields for verification. These fields are present in emitted
    *   contracts but not in the ContractIR type definition.
    */
   verify(options: {
@@ -236,6 +236,23 @@ export interface OperationContext {
 // Control*Descriptor Interfaces (ADR 151)
 // ============================================================================
 
+/**
+ * A bundle of control-plane component descriptors for a specific family and target.
+ *
+ * This struct groups the target, adapter, driver (optional), and extension packs
+ * needed to create a family instance and run CLI commands. Use `createControlPlaneStack()`
+ * to construct with sensible defaults.
+ *
+ * @template TFamilyId - The family ID (e.g., 'sql', 'document')
+ * @template TTargetId - The target ID (e.g., 'postgres', 'mysql')
+ */
+export interface ControlPlaneStack<TFamilyId extends string, TTargetId extends string> {
+  readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;
+  readonly adapter: ControlAdapterDescriptor<TFamilyId, TTargetId>;
+  readonly driver: ControlDriverDescriptor<TFamilyId, TTargetId> | undefined;
+  readonly extensionPacks: readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[];
+}
+
 /**
  * Descriptor for a control-plane family (e.g., SQL).
  * Provides the family hook and factory method.
@@ -248,12 +265,7 @@ export interface ControlFamilyDescriptor<
   TFamilyInstance extends ControlFamilyInstance<TFamilyId> = ControlFamilyInstance<TFamilyId>,
 > extends FamilyDescriptor<TFamilyId> {
   readonly hook: TargetFamilyHook;
-  create<TTargetId extends string>(options: {
-    readonly target: ControlTargetDescriptor<TFamilyId, TTargetId>;
-    readonly adapter: ControlAdapterDescriptor<TFamilyId, TTargetId>;
-    readonly driver: ControlDriverDescriptor<TFamilyId, TTargetId>;
-    readonly extensionPacks: readonly ControlExtensionDescriptor<TFamilyId, TTargetId>[];
-  }): TFamilyInstance;
+  create<TTargetId extends string>(stack: ControlPlaneStack<TFamilyId, TTargetId>): TFamilyInstance;
 }
 
 /**
@@ -304,9 +316,14 @@ export interface ControlAdapterDescriptor<
 /**
  * Descriptor for a control-plane driver component (e.g., Postgres driver).
  *
+ * The connection input type is driver-specific. For example:
+ * - Postgres uses a connection string (URL)
+ * - Other drivers may accept structured objects (e.g., file paths, credentials)
+ *
  * @template TFamilyId - The family ID (e.g., 'sql', 'document')
  * @template TTargetId - The target ID (e.g., 'postgres', 'mysql')
  * @template TDriverInstance - The driver instance type
+ * @template TConnection - The connection input type (defaults to `string` for URL-based drivers)
  */
 export interface ControlDriverDescriptor<
   TFamilyId extends string,
@@ -315,8 +332,9 @@ export interface ControlDriverDescriptor<
     TFamilyId,
     TTargetId
   >,
+  TConnection = string,
 > extends DriverDescriptor<TFamilyId, TTargetId> {
-  create(url: string): Promise<TDriverInstance>;
+  create(connection: TConnection): Promise<TDriverInstance>;
 }
 
 /**
@@ -345,11 +363,11 @@ export interface VerifyDatabaseResult {
   readonly code?: string;
   readonly summary: string;
   readonly contract: {
-    readonly coreHash: string;
+    readonly storageHash: string;
     readonly profileHash?: string;
   };
   readonly marker?: {
-    readonly coreHash?: string;
+    readonly storageHash?: string;
     readonly profileHash?: string;
   };
   readonly target: {
@@ -381,15 +399,20 @@ export interface SchemaIssue {
     | 'extra_unique_constraint'
     | 'extra_index'
     | 'type_mismatch'
+    | 'type_missing'
+    | 'type_values_mismatch'
     | 'nullability_mismatch'
     | 'primary_key_mismatch'
     | 'foreign_key_mismatch'
     | 'unique_constraint_mismatch'
     | 'index_mismatch'
-    | 'extension_missing';
+    | 'extension_missing'
+    | 'default_missing'
+    | 'default_mismatch';
   readonly table: string;
   readonly column?: string;
   readonly indexOrConstraint?: string;
+  readonly typeName?: string;
   readonly expected?: string;
   readonly actual?: string;
   readonly message: string;
@@ -419,7 +442,7 @@ export interface VerifyDatabaseSchemaResult {
   readonly code?: string;
   readonly summary: string;
   readonly contract: {
-    readonly coreHash: string;
+    readonly storageHash: string;
     readonly profileHash?: string;
   };
   readonly target: {
@@ -452,7 +475,8 @@ export interface VerifyDatabaseSchemaResult {
 export interface EmitContractResult {
   readonly contractJson: string;
   readonly contractDts: string;
-  readonly coreHash: string;
+  readonly storageHash: string;
+  readonly executionHash?: string;
   readonly profileHash: string;
 }
 
@@ -487,7 +511,7 @@ export interface SignDatabaseResult {
   readonly ok: boolean;
   readonly summary: string;
   readonly contract: {
-    readonly coreHash: string;
+    readonly storageHash: string;
     readonly profileHash?: string;
   };
   readonly target: {
@@ -498,7 +522,7 @@ export interface SignDatabaseResult {
     readonly created: boolean;
     readonly updated: boolean;
     readonly previous?: {
-      readonly coreHash?: string;
+      readonly storageHash?: string;
       readonly profileHash?: string;
     };
   };

package/dist/chunk-U5RYT6PT.js

@@ -1,229 +0,0 @@
-// src/errors.ts
-var CliStructuredError = class extends Error {
-  code;
-  domain;
-  severity;
-  why;
-  fix;
-  where;
-  meta;
-  docsUrl;
-  constructor(code, summary, options) {
-    super(summary);
-    this.name = "CliStructuredError";
-    this.code = code;
-    this.domain = options?.domain ?? "CLI";
-    this.severity = options?.severity ?? "error";
-    this.why = options?.why;
-    this.fix = options?.fix;
-    this.where = options?.where ? {
-      path: options.where.path,
-      line: options.where.line
-    } : void 0;
-    this.meta = options?.meta;
-    this.docsUrl = options?.docsUrl;
-  }
-  /**
-   * Converts this error to a CLI error envelope for output formatting.
-   */
-  toEnvelope() {
-    const codePrefix = this.domain === "CLI" ? "PN-CLI-" : "PN-RTM-";
-    return {
-      code: `${codePrefix}${this.code}`,
-      domain: this.domain,
-      severity: this.severity,
-      summary: this.message,
-      why: this.why,
-      fix: this.fix,
-      where: this.where,
-      meta: this.meta,
-      docsUrl: this.docsUrl
-    };
-  }
-};
-function errorConfigFileNotFound(configPath, options) {
-  return new CliStructuredError("4001", "Config file not found", {
-    domain: "CLI",
-    ...options?.why ? { why: options.why } : { why: "Config file not found" },
-    fix: "Run 'prisma-next init' to create a config file",
-    docsUrl: "https://prisma-next.dev/docs/cli/config",
-    ...configPath ? { where: { path: configPath } } : {}
-  });
-}
-function errorContractConfigMissing(options) {
-  return new CliStructuredError("4002", "Contract configuration missing", {
-    domain: "CLI",
-    why: options?.why ?? "The contract configuration is required for emit",
-    fix: "Add contract configuration to your prisma-next.config.ts",
-    docsUrl: "https://prisma-next.dev/docs/cli/contract-emit"
-  });
-}
-function errorContractValidationFailed(reason, options) {
-  return new CliStructuredError("4003", "Contract validation failed", {
-    domain: "CLI",
-    why: reason,
-    fix: "Re-run `prisma-next contract emit`, or fix the contract file and try again",
-    docsUrl: "https://prisma-next.dev/docs/contracts",
-    ...options?.where ? { where: options.where } : {}
-  });
-}
-function errorFileNotFound(filePath, options) {
-  return new CliStructuredError("4004", "File not found", {
-    domain: "CLI",
-    why: options?.why ?? `File not found: ${filePath}`,
-    fix: options?.fix ?? "Check that the file path is correct",
-    where: { path: filePath },
-    ...options?.docsUrl ? { docsUrl: options.docsUrl } : {}
-  });
-}
-function errorDatabaseUrlRequired(options) {
-  return new CliStructuredError("4005", "Database URL is required", {
-    domain: "CLI",
-    why: options?.why ?? "Database URL is required for this command",
-    fix: 'Provide `--db <url>` or set `db: { url: "postgres://\u2026" }` in prisma-next.config.ts'
-  });
-}
-function errorQueryRunnerFactoryRequired(options) {
-  return new CliStructuredError("4006", "Query runner factory is required", {
-    domain: "CLI",
-    why: options?.why ?? "Config.db.queryRunnerFactory is required for db verify",
-    fix: "Add db.queryRunnerFactory to prisma-next.config.ts",
-    docsUrl: "https://prisma-next.dev/docs/cli/db-verify"
-  });
-}
-function errorFamilyReadMarkerSqlRequired(options) {
-  return new CliStructuredError("4007", "Family readMarker() is required", {
-    domain: "CLI",
-    why: options?.why ?? "Family verify.readMarker is required for db verify",
-    fix: "Ensure family.verify.readMarker() is exported by your family package",
-    docsUrl: "https://prisma-next.dev/docs/cli/db-verify"
-  });
-}
-function errorJsonFormatNotSupported(options) {
-  return new CliStructuredError("4008", "Unsupported JSON format", {
-    domain: "CLI",
-    why: `The ${options.command} command does not support --json ${options.format}`,
-    fix: `Use --json ${options.supportedFormats.join(" or ")}, or omit --json for human output`,
-    meta: {
-      command: options.command,
-      format: options.format,
-      supportedFormats: options.supportedFormats
-    }
-  });
-}
-function errorDriverRequired(options) {
-  return new CliStructuredError("4010", "Driver is required for DB-connected commands", {
-    domain: "CLI",
-    why: options?.why ?? "Config.driver is required for DB-connected commands",
-    fix: "Add a control-plane driver to prisma-next.config.ts (e.g. import a driver descriptor and set `driver: postgresDriver`)",
-    docsUrl: "https://prisma-next.dev/docs/cli/config"
-  });
-}
-function errorContractMissingExtensionPacks(options) {
-  const missing = [...options.missingExtensionPacks].sort();
-  return new CliStructuredError("4011", "Missing extension packs in config", {
-    domain: "CLI",
-    why: missing.length === 1 ? `Contract requires extension pack '${missing[0]}', but CLI config does not provide a matching descriptor.` : `Contract requires extension packs ${missing.map((p) => `'${p}'`).join(", ")}, but CLI config does not provide matching descriptors.`,
-    fix: "Add the missing extension descriptors to `extensions` in prisma-next.config.ts",
-    docsUrl: "https://prisma-next.dev/docs/cli/config",
-    meta: {
-      missingExtensionPacks: missing,
-      providedComponentIds: [...options.providedComponentIds].sort()
-    }
-  });
-}
-function errorMigrationPlanningFailed(options) {
-  const conflictSummaries = options.conflicts.map((c) => c.summary);
-  const computedWhy = options.why ?? conflictSummaries.join("\n");
-  const conflictFixes = options.conflicts.map((c) => c.why).filter((why) => typeof why === "string");
-  const computedFix = conflictFixes.length > 0 ? conflictFixes.join("\n") : "Use `db schema-verify` to inspect conflicts, or ensure the database is empty";
-  return new CliStructuredError("4020", "Migration planning failed", {
-    domain: "CLI",
-    why: computedWhy,
-    fix: computedFix,
-    meta: { conflicts: options.conflicts },
-    docsUrl: "https://prisma-next.dev/docs/cli/db-init"
-  });
-}
-function errorTargetMigrationNotSupported(options) {
-  return new CliStructuredError("4021", "Target does not support migrations", {
-    domain: "CLI",
-    why: options?.why ?? "The configured target does not provide migration planner/runner",
-    fix: "Select a target that provides migrations (it must export `target.migrations` for db init)",
-    docsUrl: "https://prisma-next.dev/docs/cli/db-init"
-  });
-}
-function errorConfigValidation(field, options) {
-  return new CliStructuredError("4001", "Config file not found", {
-    domain: "CLI",
-    why: options?.why ?? `Config must have a "${field}" field`,
-    fix: "Run 'prisma-next init' to create a config file",
-    docsUrl: "https://prisma-next.dev/docs/cli/config"
-  });
-}
-function errorMarkerMissing(options) {
-  return new CliStructuredError("3001", "Marker missing", {
-    domain: "RTM",
-    why: options?.why ?? "Contract marker not found in database",
-    fix: "Run `prisma-next db sign --db <url>` to create marker"
-  });
-}
-function errorHashMismatch(options) {
-  return new CliStructuredError("3002", "Hash mismatch", {
-    domain: "RTM",
-    why: options?.why ?? "Contract hash does not match database marker",
-    fix: "Migrate database or re-sign if intentional",
-    ...options?.expected || options?.actual ? {
-      meta: {
-        ...options.expected ? { expected: options.expected } : {},
-        ...options.actual ? { actual: options.actual } : {}
-      }
-    } : {}
-  });
-}
-function errorTargetMismatch(expected, actual, options) {
-  return new CliStructuredError("3003", "Target mismatch", {
-    domain: "RTM",
-    why: options?.why ?? `Contract target does not match config target (expected: ${expected}, actual: ${actual})`,
-    fix: "Align contract target and config target",
-    meta: { expected, actual }
-  });
-}
-function errorRuntime(summary, options) {
-  return new CliStructuredError("3000", summary, {
-    domain: "RTM",
-    ...options?.why ? { why: options.why } : { why: "Verification failed" },
-    ...options?.fix ? { fix: options.fix } : { fix: "Check contract and database state" },
-    ...options?.meta ? { meta: options.meta } : {}
-  });
-}
-function errorUnexpected(message, options) {
-  return new CliStructuredError("4999", "Unexpected error", {
-    domain: "CLI",
-    why: options?.why ?? message,
-    fix: options?.fix ?? "Check the error message and try again"
-  });
-}
-
-export {
-  CliStructuredError,
-  errorConfigFileNotFound,
-  errorContractConfigMissing,
-  errorContractValidationFailed,
-  errorFileNotFound,
-  errorDatabaseUrlRequired,
-  errorQueryRunnerFactoryRequired,
-  errorFamilyReadMarkerSqlRequired,
-  errorJsonFormatNotSupported,
-  errorDriverRequired,
-  errorContractMissingExtensionPacks,
-  errorMigrationPlanningFailed,
-  errorTargetMigrationNotSupported,
-  errorConfigValidation,
-  errorMarkerMissing,
-  errorHashMismatch,
-  errorTargetMismatch,
-  errorRuntime,
-  errorUnexpected
-};
-//# sourceMappingURL=chunk-U5RYT6PT.js.map