@prisma/orm-toolchain 8.0.0-rc.1-dev.46 → 8.0.0-rc.10-dev.1

package/dist/cli__control-api.d.mts

@@ -1,11 +1,11 @@
 import { i as Refs, n as RefEntry } from "./refs-BNCUu58Y-BIso5Jfg.mjs";
 import { n as MigrationGraph } from "./graph-bDjJ4GL9-BhFevsJS.mjs";
-import { r as MigrationRef, t as ContractRef } from "./ref-resolution-COGOSL57.mjs";
-import { A as SchemaVerifyOptions, C as EmitResult, D as IntrospectOptions, E as ExecuteDbVerifyResult, M as VerifyOptions, N as executeDbVerify, S as EmitOptions, T as ExecuteDbVerifyOptions, _ as DbUpdateResult, a as ControlClient, b as EmitFailure, c as CreateControlClient, d as DbInitOptions, f as DbInitResult, g as DbUpdateOptions, h as DbUpdateFailureCode, i as ControlActionName, j as SignOptions, k as OnControlProgress, l as DbInitFailure, m as DbUpdateFailure, n as ContractEmitOptions, o as ControlClientOptions, p as DbInitSuccess, r as ContractEmitResult, s as ControlProgressEvent, t as CliStructuredError$2, u as DbInitFailureCode, v as DbUpdateSuccess, w as EmitSuccess, x as EmitFailureCode, y as EmitContractConfig } from "./db-verify-BwgNK50T-DGvKgFCK.mjs";
-import { a as emit } from "./index-Dgwl8Tzs.mjs";
+import { r as MigrationRef, t as ContractRef } from "./ref-resolution-CaHQJXE0.mjs";
+import { A as SchemaVerifyOptions, C as EmitResult, D as IntrospectOptions, E as ExecuteDbVerifyResult, M as VerifyOptions, N as executeDbVerify, S as EmitOptions, T as ExecuteDbVerifyOptions, _ as DbUpdateResult, a as ControlClient, b as EmitFailure, c as CreateControlClient, d as DbInitOptions, f as DbInitResult, g as DbUpdateOptions, h as DbUpdateFailureCode, i as ControlActionName, j as SignOptions, k as OnControlProgress, l as DbInitFailure, m as DbUpdateFailure, n as ContractEmitOptions, o as ControlClientOptions, p as DbInitSuccess, r as ContractEmitResult, s as ControlProgressEvent, t as CliStructuredError$2, u as DbInitFailureCode, v as DbUpdateSuccess, w as EmitSuccess, x as EmitFailureCode, y as EmitContractConfig } from "./db-verify-Yih5kWtB-B1kv76ec.mjs";
+import { a as emit } from "./index-D217lbiW.mjs";
 import { n as OnDiskMigrationPackage, t as MigrationOps } from "./package-CfWiDNrr-ZR4HM_Iz.mjs";
-import { c as ContractSpaceAggregate, d as IntegrityQueryOptions, p as IntegrityViolation, t as AggregateContractSpace } from "./aggregate-DLUJLq5Y.mjs";
-import { r as PrismaNextConfig$1 } from "./index-DRs7L6N0.mjs";
+import { c as ContractSpaceAggregate, d as IntegrityQueryOptions, p as IntegrityViolation, t as AggregateContractSpace } from "./aggregate-D_eX4zoo.mjs";
+import { r as PrismaNextConfig$1 } from "./index-u5RdrumF.mjs";
 import { t as MigrationMetadata$1 } from "./metadata-2nbOAGsV-uYNeq2Cp.mjs";
 import "./metadata-BtscDay2.mjs";
 import "./package-N9PPdFV_.mjs";
@@ -17,7 +17,7 @@ import { PrismaNextConfig } from "@prisma/orm-framework/config/config-types";
 //#region ../../../1-framework/3-tooling/cli/dist/exports/control-api.d.mts
 //#region src/control-api/client.d.ts
 /**
- * Creates a programmatic control client for Prisma Next operations.
+ * Creates a programmatic control client for Prisma ORM operations.
  *
  * The client accepts framework component descriptors at creation time,
  * manages driver lifecycle via connect()/close(), and exposes domain
@@ -51,7 +51,7 @@ type ContractEmitDependencies = {
  * Canonical contract emit operation.
  *
  * This is the SINGLE publication path used by both the CLI command
- * (`prisma-next contract emit`) and the Vite plugin
+ * (`prisma contract emit`) and the Vite plugin
  * (`@internal/vite-plugin-contract-emit`). New callers must go through this
  * function rather than re-implementing load → emit → publish.
  *
@@ -116,7 +116,7 @@ declare function resolveContractRefToSnapshot(options: ResolveContractRefToSnaps
  * target mismatch, then disjointness, then a contract-validation
  * failure, then any remaining structural integrity violation.
  */
-declare function mapIntegrityViolations(violations: readonly IntegrityViolation[]): CliStructuredError$2 | null;
+declare function mapIntegrityViolations(violations: readonly IntegrityViolation[], migrationsDir: string): CliStructuredError$2 | null;
 /**
  * Inputs needed to compose the aggregate loader at the CLI surface.
  *
@@ -148,13 +148,13 @@ declare function loadContractSpaceAggregateForCli<TFamilyId extends string, TTar
  * the contract-space refusal envelope, or return `null` when the model
  * is acceptable for the requested check scope.
  */
-declare function refuseContractSpaceIntegrity(aggregate: ContractSpaceAggregate, options: IntegrityQueryOptions): CliStructuredError$2 | null;
+declare function refuseContractSpaceIntegrity(aggregate: ContractSpaceAggregate, options: IntegrityQueryOptions, migrationsDir: string): CliStructuredError$2 | null;
 /**
  * Reader-subset integrity refusal for `migration status`: package
  * corruptions only (`hashMismatch`, `providedInvariantsMismatch`,
  * `packageUnloadable`).
  */
-declare function refusePackageCorruptionOnAggregate(aggregate: ContractSpaceAggregate): CliStructuredError$2 | null;
+declare function refusePackageCorruptionOnAggregate(aggregate: ContractSpaceAggregate, migrationsDir: string): CliStructuredError$2 | null;
 /**
  * Construct the tolerant {@link ContractSpaceAggregate} at the CLI
  * surface and apply the explicit integrity refusal.
@@ -742,6 +742,11 @@ interface MigrationPlanResult {
    * `node migration.ts` to self-emit `ops.json` / `migration.json`.
    */
   readonly pendingPlaceholders?: boolean;
+  /**
+   * True when no `--from` was given and no `db` ref existed, so the origin
+   * defaulted to the empty contract. Absent when the user named the origin.
+   */
+  readonly fromDefaulted?: boolean;
   readonly timings: {
     readonly total: number;
   };
@@ -789,6 +794,7 @@ type FromResolution = {
   kind: 'greenfield';
   fromHash: null;
   fromContract: null;
+  defaulted: boolean;
 } | {
   kind: 'graph-node';
   fromHash: string;
@@ -899,7 +905,10 @@ interface ResolveRefAdvancementFieldsOptions {
  * MigrationToolsError mapped, other errors rethrown.
  */
 declare function resolveRefAdvancementFields(options: ResolveRefAdvancementFieldsOptions): Promise<Result<RefAdvancementFields, CliStructuredError$2>>;
-/** migrate's --advance-ref tail: executeRefAdvancement with MigrationToolsError passed through, others rethrown. */
+/**
+ * The --advance-ref tail of migrate and db sign: executeRefAdvancement with
+ * MigrationToolsError failures passed through as notOk, others rethrown.
+ */
 declare function advanceRefSafely(args: {
   readonly refsDir: string;
   readonly migrationsDir: string;

package/dist/cli__control-api.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cli__control-api.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/exports/control-api.d.mts"],"mappings":"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"}
+{"version":3,"file":"cli__control-api.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/exports/control-api.d.mts"],"mappings":"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"}

package/dist/cli__control-api.mjs

@@ -1,2 +1,2 @@
-import { $ as loadContractRawSafely, At as statusForMigrationHash, B as executeDbUpdate, Ct as resolveRefAdvancementFields, Dt as runMigrationCheck, Et as runContractSpaceSeedPhase, G as executeRefAdvancement, H as executeMigrateShowPlan, J as executeRefSetCommand, K as executeRefDeleteCommand, Ot as runMigrationList, Q as loadAggregateIntegrityViolations, R as executeContractEmit, St as resolveMigrationRef, U as executeMigrationNewCommand, V as executeDbVerify, W as executeMigrationPlanCommand, X as hasMigrationPath, Z as listRefsByContractHash, _ as enumerateCheckSpaces, a as buildContractSpaceAggregate, bt as resolveContractRefToSnapshot, c as buildRefAdvancementFields, dt as refuseContractSpaceIntegrity, et as loadContractSpaceAggregateForCli, f as computeRefAdvancementName, ft as refuseDeclaredExtensionTargetMismatch, g as enrichContract, gt as refuseUnknownInvariants, h as disposeEmitQueue, ht as refusePackageCorruptionOnAggregate, i as appliedHashesFromLedger, it as mapIntegrityViolations, l as checkSingleTarget, lt as readContractIR, m as deriveStatusEdgeAnnotations, mt as refuseMissingInvariantPath, n as advanceRefSafely, nt as mapCaughtMigrationError, o as buildMigrationSpaceGraphEntries, ot as migrationSpaceListEntriesFromAggregate, p as createControlClient, pt as refuseMarkerOutsideGraph, q as executeRefListCommand, r as appContractStandInFromIdentity, rt as mapContractAtError, s as buildReadAggregate, st as originHashForStatus, ut as readMigrationRefs, wt as resolveToForPlan, xt as resolveFromForPlan, yt as resolveContractRef$1, z as executeDbInit } from "./ref-h6InR6dO-rGfl18Jv.mjs";
+import { $ as loadAggregateIntegrityViolations, At as runMigrationList, B as executeDbInit, Ct as resolveFromForPlan, Et as resolveToForPlan, G as executeMigrationPlanCommand, H as executeDbVerify, J as executeRefListCommand, K as executeRefAdvancement, Mt as statusForMigrationHash, Ot as runContractSpaceSeedPhase, Q as listRefsByContractHash, St as resolveContractRefToSnapshot, Tt as resolveRefAdvancementFields, U as executeMigrateShowPlan, V as executeDbUpdate, W as executeMigrationNewCommand, Y as executeRefSetCommand, Z as hasMigrationPath, _ as enumerateCheckSpaces, _t as refusePackageCorruptionOnAggregate, a as buildContractSpaceAggregate, at as mapIntegrityViolations, c as buildRefAdvancementFields, ct as originHashForStatus, dt as readContractIR, et as loadContractRawSafely, f as computeRefAdvancementName, ft as readMigrationRefs, g as enrichContract, gt as refuseMissingInvariantPath, h as disposeEmitQueue, ht as refuseMarkerOutsideGraph, i as appliedHashesFromLedger, it as mapContractAtError, kt as runMigrationCheck, l as checkSingleTarget, m as deriveStatusEdgeAnnotations, mt as refuseDeclaredExtensionTargetMismatch, n as advanceRefSafely, o as buildMigrationSpaceGraphEntries, p as createControlClient, pt as refuseContractSpaceIntegrity, q as executeRefDeleteCommand, r as appContractStandInFromIdentity, rt as mapCaughtMigrationError, s as buildReadAggregate, st as migrationSpaceListEntriesFromAggregate, tt as loadContractSpaceAggregateForCli, vt as refuseUnknownInvariants, wt as resolveMigrationRef, xt as resolveContractRef$1, z as executeContractEmit } from "./ref-DcqFmceq-QaUjgZeM.mjs";
 export { advanceRefSafely, appContractStandInFromIdentity, appliedHashesFromLedger, buildContractSpaceAggregate, buildMigrationSpaceGraphEntries, buildReadAggregate, buildRefAdvancementFields, checkSingleTarget, computeRefAdvancementName, createControlClient, deriveStatusEdgeAnnotations, disposeEmitQueue, enrichContract, enumerateCheckSpaces, executeContractEmit, executeDbInit, executeDbUpdate, executeDbVerify, executeMigrateShowPlan, executeMigrationNewCommand, executeMigrationPlanCommand, executeRefAdvancement, executeRefDeleteCommand, executeRefListCommand, executeRefSetCommand, hasMigrationPath, listRefsByContractHash, loadAggregateIntegrityViolations, loadContractRawSafely, loadContractSpaceAggregateForCli, mapCaughtMigrationError, mapContractAtError, mapIntegrityViolations, migrationSpaceListEntriesFromAggregate, originHashForStatus, readContractIR, readMigrationRefs, refuseContractSpaceIntegrity, refuseDeclaredExtensionTargetMismatch, refuseMarkerOutsideGraph, refuseMissingInvariantPath, refusePackageCorruptionOnAggregate, refuseUnknownInvariants, resolveContractRef$1 as resolveContractRef, resolveContractRefToSnapshot, resolveFromForPlan, resolveMigrationRef, resolveRefAdvancementFields, resolveToForPlan, runContractSpaceSeedPhase, runMigrationCheck, runMigrationList, statusForMigrationHash };

package/dist/cli__control-api__testing.d.mts

@@ -1,4 +1,4 @@
-import { C as EmitResult, E as ExecuteDbVerifyResult, O as MigrateResult, _ as DbUpdateResult, a as ControlClient, f as DbInitResult } from "./db-verify-BwgNK50T-DGvKgFCK.mjs";
+import { C as EmitResult, E as ExecuteDbVerifyResult, O as MigrateResult, _ as DbUpdateResult, a as ControlClient, f as DbInitResult } from "./db-verify-Yih5kWtB-B1kv76ec.mjs";
 import { CoreSchemaView, OperationPreview, SignDatabaseResult, VerifyDatabaseResult, VerifyDatabaseSchemaResult } from "@prisma/orm-framework/components/control";
 import { ContractMarkerRecord, LedgerEntryRecord } from "@prisma/orm-framework/contract/types";
 import { AuthoringPslBlockDescriptorNamespace } from "@prisma/orm-framework/components/authoring";

package/dist/cli__init-output.mjs

@@ -1,2 +1,2 @@
-import { t as InitOutputSchema } from "./output-CovTDY14-CUoAqLML.mjs";
+import { t as InitOutputSchema } from "./output-D83nTTpC-XlvN30yS.mjs";
 export { InitOutputSchema };

package/dist/cli__migration-cli.mjs

@@ -1,11 +1,11 @@
-import { g as errorInvalidJson } from "./errors-CXbGUWGu-CstQHPh6.mjs";
-import { a as loadConfigForSections } from "./exports-BZaG8_w_.mjs";
-import { r as buildMigrationArtifacts } from "./migration-hspPIEeV.mjs";
+import { g as errorInvalidJson } from "./errors-SoLLYLtw-DMxVbVs9.mjs";
+import { a as loadConfigForSections } from "./exports-BXXeNWlj.mjs";
+import { r as buildMigrationArtifacts } from "./migration-B9w-7dKe.mjs";
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { CliStructuredError, errorMigrationCliInvalidConfigArg, errorMigrationCliUnknownFlag } from "@prisma/orm-framework/errors/control";
 import { createControlStack } from "@prisma/orm-framework/components/control";
 import { errorMigrationTargetMismatch } from "@prisma/orm-framework/errors/migration";
 import { dirname, join } from "pathe";
-import { readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Cli, Command, Option, UsageError } from "clipanion";
 //#region ../../../1-framework/3-tooling/cli/dist/migration-cli.mjs
@@ -14,7 +14,7 @@ import { Cli, Command, Option, UsageError } from "clipanion";
 * `node migration.ts` directly.
 *
 * Naming: this is *not* a "migration runner" in the apply-time sense. The
-* apply-time runner is the thing `prisma-next migrate` uses to
+* apply-time runner is the thing `prisma db migrate` uses to
 * execute migration JSON ops against a database. `MigrationCLI` is the
 * tiny CLI surface owned by an authored `migration.ts` file: parse the
 * file's argv, load the project's `prisma.config.ts`, assemble a
@@ -396,7 +396,7 @@ async function runMigration(importMetaUrl, MigrationClass, parsed, ctx) {
 		"adapter",
 		"driver",
 		"extensions"
-	], { onDeprecation: (deprecation) => void ctx.stderr.write(`⚠ ${deprecation.message}\n`) });
+	]);
 	if (!configResult.ok) throw configResult.failure;
 	const config = configResult.value;
 	const probe = new MigrationClass();

package/dist/cli__migration-cli.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cli__migration-cli.mjs","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/migration-cli.mjs"],"sourcesContent":["import { CliStructuredError, errorMigrationCliInvalidConfigArg, errorMigrationCliUnknownFlag } from \"@internal/errors/control\";\nimport { createControlStack } from \"@internal/framework-components/control\";\nimport { errorMigrationTargetMismatch } from \"@internal/errors/migration\";\nimport { errorInvalidJson } from \"@internal/migration-tools/errors\";\nimport { dirname, join } from \"pathe\";\nimport { readFileSync, realpathSync, writeFileSync } from \"node:fs\";\nimport { loadConfigForSections } from \"@internal/config-loader\";\nimport { fileURLToPath } from \"node:url\";\nimport { buildMigrationArtifacts } from \"@internal/migration-tools/migration\";\nimport { Cli, Command, Option, UsageError } from \"clipanion\";\n//#region src/migration-cli.ts\n/**\n* The migration-file CLI interface: the actor invoked when the author runs\n* `node migration.ts` directly.\n*\n* Naming: this is *not* a \"migration runner\" in the apply-time sense. The\n* apply-time runner is the thing `prisma-next migrate` uses to\n* execute migration JSON ops against a database. `MigrationCLI` is the\n* tiny CLI surface owned by an authored `migration.ts` file: parse the\n* file's argv, load the project's `prisma.config.ts`, assemble a\n* `ControlStack`, instantiate the migration class, and serialize.\n*\n* The user authors a migration class, then calls\n* `MigrationCLI.run(import.meta.url, MigrationClass)` at module scope\n* after the class definition. When the file is invoked as a node\n* entrypoint (`node migration.ts`), the CLI:\n*\n* 1. Detects whether the file is the direct entrypoint (no-op when imported).\n* 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`) via\n*    [clipanion](https://github.com/arcanis/clipanion).\n* 3. Loads the project's `prisma.config.ts` via the same\n*    `loadConfigForSections` the CLI commands use, walking up from the\n*    migration file's directory.\n* 4. Probe-instantiates the migration class without a stack so it can read\n*    `targetId` and verify it matches `config.target.targetId`\n*    (`MIGRATION.TARGET_MISMATCH` on mismatch) before any stack-driven adapter\n*    construction runs.\n* 5. Assembles a `ControlStack` from the loaded config descriptors and\n*    constructs the migration with that stack.\n* 6. Reads any previously-scaffolded `migration.json`, then calls\n*    `buildMigrationArtifacts` from `@internal/migration-tools` to\n*    produce in-memory `ops.json` + `migration.json` content. Persists\n*    the result to disk (or prints in dry-run mode).\n*\n* File I/O lives here, in `@internal/cli`: this is the only place\n* that legitimately combines config loading, stack assembly, and\n* on-disk persistence. `@internal/migration-tools` owns the pure\n* conversion from a `Migration` instance to artifact strings; `Migration`\n* stays a pure abstract class.\n*\n* Parser library: clipanion (chosen over Commander/citty/`node:util.parseArgs`\n* for its in-process testability and runtime-agnostic execution surface; see\n* `docs/architecture docs/research/commander-friction-points.md` for the\n* evaluation rubric and the durable rationale that drove the choice).\n*/\n/**\n* Flags exposed by the migration-file CLI.\n*\n* Must stay in sync with the `Option` declarations on\n* `MigrationFileCommand` below. This list is rendered in the\n* `errorMigrationCliUnknownFlag` envelope's `fix` text and `meta`,\n* so order matters for user-visible output (declaration order is the\n* order users see when they run `--help`).\n*/\nconst KNOWN_FLAGS = [\n\t\"--help\",\n\t\"--dry-run\",\n\t\"--config\"\n];\n/**\n* The clipanion command that owns the migration-file CLI's option\n* declarations. The class is internal — `MigrationCLI.run` is the\n* stable public surface. Adding a flag here automatically updates\n* `--help` rendering and the `KNOWN_FLAGS` list (the latter must be\n* updated in tandem).\n*/\nvar MigrationFileCommand = class extends Command {\n\tstatic paths = [Command.Default];\n\tstatic usage = Command.Usage({\n\t\tdescription: \"Self-emit ops.json and migration.json from a class-flow migration\",\n\t\tdetails: `\n      Loads the project's prisma.config.ts, assembles a ControlStack\n      from the configured target/adapter/extensions, and serializes the\n      migration's operations + metadata next to this file.\n    `,\n\t\texamples: [\n\t\t\t[\"Self-emit ops.json + migration.json next to migration.ts\", \"$0\"],\n\t\t\t[\"Preview without writing files\", \"$0 --dry-run\"],\n\t\t\t[\"Use a non-default config path\", \"$0 --config ./custom.config.ts\"]\n\t\t]\n\t});\n\tdryRun = Option.Boolean(\"--dry-run\", false, { description: \"Print operations to stdout without writing files\" });\n\tconfig = Option.String(\"--config\", { description: \"Path to prisma.config.ts\" });\n\t/**\n\t* Unused: orchestration runs inside `MigrationCLI.run` so error\n\t* routing stays under our control (clipanion's `cli.run` writes\n\t* error output to `context.stdout`, but our contract requires\n\t* structured errors on stderr). `cli.process` is used to parse\n\t* argv into a populated `MigrationFileCommand` instance whose\n\t* fields drive the orchestration directly.\n\t*/\n\tasync execute() {\n\t\treturn 0;\n\t}\n};\n/**\n* The CLI surface invoked by an authored `migration.ts` file. Exposed as\n* a class with a static `run` method (rather than a free function) to\n* give the concept a stable identity in the ubiquitous language: this is\n* the \"migration-file CLI\", distinct from the apply-time runner that\n* executes migration JSON ops.\n*\n* Currently a single static method. Future surface (e.g. a programmatic\n* `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can\n* land here without changing the import shape used by every authored\n* migration.\n*/\nvar MigrationCLI = class {\n\t/**\n\t* Orchestrates a class-flow `migration.ts` script run.\n\t*\n\t* The third argument is the in-process testability surface: callers\n\t* (and tests) may inject `argv`, `stdout`, and `stderr` instead of\n\t* relying on `process.argv` / `process.stdout` / `process.stderr`.\n\t* Each option defaults to its `process` global when omitted, so\n\t* existing two-argument call sites\n\t* (`MigrationCLI.run(import.meta.url, MyMigration)`) continue to\n\t* compile and behave identically.\n\t*\n\t* Returns the exit code so the caller can branch on it. Also writes\n\t* the same code to `process.exitCode` so script-style callers that\n\t* don't await the return value still surface a non-zero exit when\n\t* something fails.\n\t*\n\t* Exit codes:\n\t* - 0 — success, or `--help`, or imported-not-entrypoint no-op.\n\t* - 1 — runtime/orchestration error (config not found, target\n\t*   mismatch, etc.).\n\t* - 2 — usage error (unknown flag, malformed `--config`). Aligns\n\t*   with `docs/CLI Style Guide.md` § Exit Codes.\n\t*/\n\tstatic async run(importMetaUrl, MigrationClass, options = {}) {\n\t\tif (!importMetaUrl) return 0;\n\t\tconst argv = options.argv ?? process.argv;\n\t\tconst stdout = options.stdout ?? process.stdout;\n\t\tconst stderr = options.stderr ?? process.stderr;\n\t\tif (!isDirectEntrypoint(importMetaUrl, argv)) return 0;\n\t\tconst exitCode = await orchestrate(importMetaUrl, MigrationClass, {\n\t\t\targv,\n\t\t\tstdout,\n\t\t\tstderr\n\t\t});\n\t\tif (exitCode !== 0 || !process.exitCode) process.exitCode = exitCode;\n\t\treturn exitCode;\n\t}\n};\n/**\n* Argv-aware variant of the entrypoint guard. The shared\n* `@internal/migration-tools` helper of the same name reads\n* `process.argv[1]` directly, which doesn't compose with the new\n* in-process testability surface (tests inject `argv` without mutating\n* the process global). Inlined here so the migration-file CLI's check\n* follows the injected `argv[1]` consistently.\n*/\nfunction isDirectEntrypoint(importMetaUrl, argv) {\n\tconst argv1 = argv[1];\n\tif (!argv1) return false;\n\ttry {\n\t\treturn realpathSync(fileURLToPath(importMetaUrl)) === realpathSync(argv1);\n\t} catch {\n\t\treturn false;\n\t}\n}\n/**\n* Argv-and-stream-driven orchestration body. Pulled out of the static\n* method so the entrypoint guard / process-default plumbing stays\n* separate from the parse + load + serialize steps.\n*/\nasync function orchestrate(importMetaUrl, MigrationClass, ctx) {\n\tconst cli = Cli.from([MigrationFileCommand], {\n\t\tbinaryName: \"migration.ts\",\n\t\tbinaryLabel: \"Migration file CLI\"\n\t});\n\tconst input = ctx.argv.slice(2);\n\tconst configError = detectInvalidConfig(input);\n\tif (configError) {\n\t\twriteStructuredError(ctx.stderr, configError);\n\t\treturn 2;\n\t}\n\tlet parsed;\n\ttry {\n\t\tconst command = cli.process({\n\t\t\tinput: [...input],\n\t\t\tcontext: {\n\t\t\t\tstdout: ctx.stdout,\n\t\t\t\tstderr: ctx.stderr\n\t\t\t}\n\t\t});\n\t\tif (!(command instanceof MigrationFileCommand)) {\n\t\t\tctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));\n\t\t\treturn 0;\n\t\t}\n\t\tparsed = command;\n\t} catch (err) {\n\t\treturn renderParseError(err, input, ctx.stderr);\n\t}\n\tif (parsed.help) {\n\t\tctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));\n\t\treturn 0;\n\t}\n\ttry {\n\t\tawait runMigration(importMetaUrl, MigrationClass, parsed, ctx);\n\t\treturn 0;\n\t} catch (err) {\n\t\tif (CliStructuredError.is(err)) writeStructuredError(ctx.stderr, err);\n\t\telse ctx.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`);\n\t\treturn 1;\n\t}\n}\n/**\n* Returns an `errorMigrationCliInvalidConfigArg` envelope when `input`\n* contains a malformed `--config`:\n*\n* - `--config` as the last token (no value follows).\n* - `--config <flag>` where `<flag>` starts with `-` (silently\n*   consuming the next flag would either drop the flag or serialize\n*   against the wrong project).\n* - `--config <empty>` where the value is the empty string. Shells\n*   expand `--config \"\"` (or `--config \"$UNSET_VAR\"`) into a real\n*   empty argv token; treating that as a usage error here surfaces\n*   `CLI.CONFIG_ARG_MISSING_PATH` instead of a less actionable loader error on an\n*   empty path.\n* - `--config=` (the equals form with an empty value). Same shape as\n*   the empty-string case above; the user expressed intent to override\n*   the config path but the override is empty.\n*\n* `--config=<value>` and `--config <value>` with a non-empty value are\n* both valid (and the equals form's value is allowed to start with\n* `-` — the `=` makes the binding explicit).\n*/\nfunction detectInvalidConfig(input) {\n\tfor (let i = 0; i < input.length; i++) {\n\t\tconst token = input[i];\n\t\tif (token === \"--config\") {\n\t\t\tconst next = input[i + 1];\n\t\t\tif (next === void 0 || next === \"\") return errorMigrationCliInvalidConfigArg();\n\t\t\tif (next.startsWith(\"-\")) return errorMigrationCliInvalidConfigArg({ nextToken: next });\n\t\t\tcontinue;\n\t\t}\n\t\tif (token === \"--config=\") return errorMigrationCliInvalidConfigArg();\n\t}\n\treturn null;\n}\n/**\n* Translate clipanion's parse-time errors into the project's structured\n* error envelopes.\n*\n* - `UnknownSyntaxError` covers both unknown flags (`--frobnicate`) and\n*   the bare-trailing `--config` case (where arity-1 needs a value but\n*   none was supplied). Distinguished by inspecting the input array.\n* - `UsageError` covers schema/validator failures from typanion. None\n*   of the migration-file CLI's options have validators today, but we\n*   still translate it as a usage error (exit 2) for forward-compat.\n* - Anything else re-throws — caller's outer catch will surface it as\n*   exit 1 (runtime error).\n*/\nfunction renderParseError(err, input, stderr) {\n\tif (isUnknownSyntaxError(err)) {\n\t\twriteStructuredError(stderr, errorMigrationCliUnknownFlag({\n\t\t\tflag: findOffendingFlag(input),\n\t\t\tknownFlags: KNOWN_FLAGS\n\t\t}));\n\t\treturn 2;\n\t}\n\tif (err instanceof UsageError) {\n\t\twriteStructuredError(stderr, errorMigrationCliInvalidConfigArg({ nextToken: err.message }));\n\t\treturn 2;\n\t}\n\tthrow err;\n}\n/**\n* Duck-type check for clipanion's `UnknownSyntaxError`: the class is\n* thrown by the parser but is not re-exported from the package's main\n* entry (only `UsageError` is — see clipanion's `advanced/index.d.ts`).\n* Identified by `name === 'UnknownSyntaxError'` and the\n* `clipanion.type === 'none'` discriminator that clipanion's\n* `ErrorWithMeta` interface guarantees.\n*/\nfunction isUnknownSyntaxError(err) {\n\tif (!(err instanceof Error) || err.name !== \"UnknownSyntaxError\") return false;\n\tconst meta = err.clipanion;\n\treturn typeof meta === \"object\" && meta !== null && meta.type === \"none\";\n}\n/**\n* Best-effort: pull the first input token that doesn't match a known\n* flag. Falls back to the first token when we can't pinpoint it. The\n* returned name is rendered into the user-visible CLI.UNKNOWN_FLAG envelope\n* (`Unknown flag \\`<name>\\``) and round-tripped via `meta.flag` so\n* agent consumers can render their own \"did you mean\" suggestions.\n*/\nfunction findOffendingFlag(input) {\n\tfor (const token of input) {\n\t\tif (!token.startsWith(\"-\")) continue;\n\t\tconst head = token.split(\"=\", 1)[0] ?? token;\n\t\tif (!KNOWN_FLAGS.includes(head) && head !== \"-h\") return head;\n\t}\n\treturn input[0] ?? \"\";\n}\n/**\n* Write a `CliStructuredError` envelope to the given stream. Format\n* matches the legacy hand-rolled writer (`message: why`) so the rest of\n* the project's error rendering stays consistent across surfaces. The\n* full PN code (`PN-<domain>-<code>`) is included so consumers can\n* grep for stable identifiers.\n*/\nfunction writeStructuredError(stream, err) {\n\tconst envelope = err.toEnvelope();\n\tconst why = envelope.why ?? envelope.summary;\n\tconst fix = envelope.fix ? `\\n${envelope.fix}` : \"\";\n\tstream.write(`${envelope.code}: ${envelope.summary}\\n${why}${fix}\\n`);\n}\n/**\n* Read a previously-scaffolded `migration.json` from disk, returning\n* `null` when the file is missing and throwing `MIGRATION.INVALID_JSON`\n* when the file is present but cannot be parsed as JSON. The CLI feeds\n* this into `buildMigrationArtifacts` so the pure builder can preserve\n* fields owned by `migration plan` (contract bookends, `createdAt`) across\n* re-emits.\n*\n* Author-time path: this loader still does not verify the manifest hash\n* or schema — that is the apply-time loader's job. Hash mismatch is the\n* *expected* outcome of a re-author (the developer's source changes\n* invalidate the prior hash by construction), and verification here\n* would block legitimate regenerations. Syntactic JSON-parse failure,\n* however, is now surfaced rather than swallowed: a malformed\n* `migration.json` indicates either a hand-edit gone wrong or partial\n* write, and silently rebuilding from `describe()` would discard the\n* user's on-disk content (preserved bookends, `createdAt`) without any\n* indication something was wrong on disk.\n* Apply-time consumers always route through the verifying\n* `readMigrationPackage` in `@internal/migration-tools/io` instead.\n*/\nfunction readExistingMetadata(metadataPath) {\n\tlet raw;\n\ttry {\n\t\traw = readFileSync(metadataPath, \"utf-8\");\n\t} catch {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn JSON.parse(raw);\n\t} catch (e) {\n\t\tthrow errorInvalidJson(metadataPath, e instanceof Error ? e.message : String(e));\n\t}\n}\n/**\n* Persist a migration instance's artifacts to `migrationDir`. In\n* `dryRun` mode the artifacts are printed to stdout (with the same\n* `--- migration.json --- / --- ops.json ---` framing the legacy\n* `serializeMigration` helper used) and no files are written. Otherwise\n* `ops.json` and `migration.json` are written next to `migration.ts` and\n* a confirmation line is printed.\n*\n* File I/O lives in the CLI rather than `@internal/migration-tools`\n* so the migration-tools package stays focused on the pure\n* `Migration` → in-memory artifact conversion. The CLI is the only\n* legitimate site for combining config loading, stack assembly, and\n* filesystem persistence.\n*/\nasync function serializeMigrationToDisk(instance, migrationDir, dryRun, stdout) {\n\tconst metadataPath = join(migrationDir, \"migration.json\");\n\tconst { opsJson, metadataJson } = await buildMigrationArtifacts(instance, readExistingMetadata(metadataPath));\n\tif (dryRun) {\n\t\tstdout.write(`--- migration.json ---\\n${metadataJson}\\n`);\n\t\tstdout.write(\"--- ops.json ---\\n\");\n\t\tstdout.write(`${opsJson}\\n`);\n\t\treturn;\n\t}\n\twriteFileSync(join(migrationDir, \"ops.json\"), opsJson);\n\twriteFileSync(metadataPath, metadataJson);\n\tstdout.write(`Wrote ops.json + migration.json to ${migrationDir}\\n`);\n}\n/**\n* Inner orchestration: load config, probe-construct the migration,\n* verify target, assemble the stack, construct with the stack, persist.\n*\n* Throws `CliStructuredError` for known failure modes (config not\n* found, target mismatch); the outer `orchestrate` translates those to\n* exit 1.\n*/\nasync function runMigration(importMetaUrl, MigrationClass, parsed, ctx) {\n\tconst migrationDir = dirname(fileURLToPath(importMetaUrl));\n\tconst configResult = await loadConfigForSections(parsed.config, [\n\t\t\"family\",\n\t\t\"target\",\n\t\t\"adapter\",\n\t\t\"driver\",\n\t\t\"extensions\"\n\t], { onDeprecation: (deprecation) => void ctx.stderr.write(`⚠ ${deprecation.message}\\n`) });\n\tif (!configResult.ok) throw configResult.failure;\n\tconst config = configResult.value;\n\tconst probe = new MigrationClass();\n\tif (probe.targetId !== config.target.targetId) throw errorMigrationTargetMismatch({\n\t\tmigrationTargetId: probe.targetId,\n\t\tconfigTargetId: config.target.targetId\n\t});\n\tawait serializeMigrationToDisk(new MigrationClass(createControlStack(config)), migrationDir, parsed.dryRun, ctx.stdout);\n\tctx.stderr;\n}\n//#endregion\nexport { MigrationCLI };\n\n//# sourceMappingURL=migration-cli.mjs.map"],"mappings":"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"}
+{"version":3,"file":"cli__migration-cli.mjs","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/migration-cli.mjs"],"sourcesContent":["import { readFileSync, realpathSync, writeFileSync } from \"node:fs\";\nimport { CliStructuredError, errorMigrationCliInvalidConfigArg, errorMigrationCliUnknownFlag } from \"@internal/errors/control\";\nimport { createControlStack } from \"@internal/framework-components/control\";\nimport { errorMigrationTargetMismatch } from \"@internal/errors/migration\";\nimport { errorInvalidJson } from \"@internal/migration-tools/errors\";\nimport { dirname, join } from \"pathe\";\nimport { loadConfigForSections } from \"@internal/config-loader\";\nimport { fileURLToPath } from \"node:url\";\nimport { buildMigrationArtifacts } from \"@internal/migration-tools/migration\";\nimport { Cli, Command, Option, UsageError } from \"clipanion\";\n//#region src/migration-cli.ts\n/**\n* The migration-file CLI interface: the actor invoked when the author runs\n* `node migration.ts` directly.\n*\n* Naming: this is *not* a \"migration runner\" in the apply-time sense. The\n* apply-time runner is the thing `prisma db migrate` uses to\n* execute migration JSON ops against a database. `MigrationCLI` is the\n* tiny CLI surface owned by an authored `migration.ts` file: parse the\n* file's argv, load the project's `prisma.config.ts`, assemble a\n* `ControlStack`, instantiate the migration class, and serialize.\n*\n* The user authors a migration class, then calls\n* `MigrationCLI.run(import.meta.url, MigrationClass)` at module scope\n* after the class definition. When the file is invoked as a node\n* entrypoint (`node migration.ts`), the CLI:\n*\n* 1. Detects whether the file is the direct entrypoint (no-op when imported).\n* 2. Parses CLI args (`--help`, `--dry-run`, `--config <path>`) via\n*    [clipanion](https://github.com/arcanis/clipanion).\n* 3. Loads the project's `prisma.config.ts` via the same\n*    `loadConfigForSections` the CLI commands use, walking up from the\n*    migration file's directory.\n* 4. Probe-instantiates the migration class without a stack so it can read\n*    `targetId` and verify it matches `config.target.targetId`\n*    (`MIGRATION.TARGET_MISMATCH` on mismatch) before any stack-driven adapter\n*    construction runs.\n* 5. Assembles a `ControlStack` from the loaded config descriptors and\n*    constructs the migration with that stack.\n* 6. Reads any previously-scaffolded `migration.json`, then calls\n*    `buildMigrationArtifacts` from `@internal/migration-tools` to\n*    produce in-memory `ops.json` + `migration.json` content. Persists\n*    the result to disk (or prints in dry-run mode).\n*\n* File I/O lives here, in `@internal/cli`: this is the only place\n* that legitimately combines config loading, stack assembly, and\n* on-disk persistence. `@internal/migration-tools` owns the pure\n* conversion from a `Migration` instance to artifact strings; `Migration`\n* stays a pure abstract class.\n*\n* Parser library: clipanion (chosen over Commander/citty/`node:util.parseArgs`\n* for its in-process testability and runtime-agnostic execution surface; see\n* `docs/architecture docs/research/commander-friction-points.md` for the\n* evaluation rubric and the durable rationale that drove the choice).\n*/\n/**\n* Flags exposed by the migration-file CLI.\n*\n* Must stay in sync with the `Option` declarations on\n* `MigrationFileCommand` below. This list is rendered in the\n* `errorMigrationCliUnknownFlag` envelope's `fix` text and `meta`,\n* so order matters for user-visible output (declaration order is the\n* order users see when they run `--help`).\n*/\nconst KNOWN_FLAGS = [\n\t\"--help\",\n\t\"--dry-run\",\n\t\"--config\"\n];\n/**\n* The clipanion command that owns the migration-file CLI's option\n* declarations. The class is internal — `MigrationCLI.run` is the\n* stable public surface. Adding a flag here automatically updates\n* `--help` rendering and the `KNOWN_FLAGS` list (the latter must be\n* updated in tandem).\n*/\nvar MigrationFileCommand = class extends Command {\n\tstatic paths = [Command.Default];\n\tstatic usage = Command.Usage({\n\t\tdescription: \"Self-emit ops.json and migration.json from a class-flow migration\",\n\t\tdetails: `\n      Loads the project's prisma.config.ts, assembles a ControlStack\n      from the configured target/adapter/extensions, and serializes the\n      migration's operations + metadata next to this file.\n    `,\n\t\texamples: [\n\t\t\t[\"Self-emit ops.json + migration.json next to migration.ts\", \"$0\"],\n\t\t\t[\"Preview without writing files\", \"$0 --dry-run\"],\n\t\t\t[\"Use a non-default config path\", \"$0 --config ./custom.config.ts\"]\n\t\t]\n\t});\n\tdryRun = Option.Boolean(\"--dry-run\", false, { description: \"Print operations to stdout without writing files\" });\n\tconfig = Option.String(\"--config\", { description: \"Path to prisma.config.ts\" });\n\t/**\n\t* Unused: orchestration runs inside `MigrationCLI.run` so error\n\t* routing stays under our control (clipanion's `cli.run` writes\n\t* error output to `context.stdout`, but our contract requires\n\t* structured errors on stderr). `cli.process` is used to parse\n\t* argv into a populated `MigrationFileCommand` instance whose\n\t* fields drive the orchestration directly.\n\t*/\n\tasync execute() {\n\t\treturn 0;\n\t}\n};\n/**\n* The CLI surface invoked by an authored `migration.ts` file. Exposed as\n* a class with a static `run` method (rather than a free function) to\n* give the concept a stable identity in the ubiquitous language: this is\n* the \"migration-file CLI\", distinct from the apply-time runner that\n* executes migration JSON ops.\n*\n* Currently a single static method. Future surface (e.g. a programmatic\n* `MigrationCLI.serializeOnly(...)` for tests, or extra subcommands) can\n* land here without changing the import shape used by every authored\n* migration.\n*/\nvar MigrationCLI = class {\n\t/**\n\t* Orchestrates a class-flow `migration.ts` script run.\n\t*\n\t* The third argument is the in-process testability surface: callers\n\t* (and tests) may inject `argv`, `stdout`, and `stderr` instead of\n\t* relying on `process.argv` / `process.stdout` / `process.stderr`.\n\t* Each option defaults to its `process` global when omitted, so\n\t* existing two-argument call sites\n\t* (`MigrationCLI.run(import.meta.url, MyMigration)`) continue to\n\t* compile and behave identically.\n\t*\n\t* Returns the exit code so the caller can branch on it. Also writes\n\t* the same code to `process.exitCode` so script-style callers that\n\t* don't await the return value still surface a non-zero exit when\n\t* something fails.\n\t*\n\t* Exit codes:\n\t* - 0 — success, or `--help`, or imported-not-entrypoint no-op.\n\t* - 1 — runtime/orchestration error (config not found, target\n\t*   mismatch, etc.).\n\t* - 2 — usage error (unknown flag, malformed `--config`). Aligns\n\t*   with `docs/CLI Style Guide.md` § Exit Codes.\n\t*/\n\tstatic async run(importMetaUrl, MigrationClass, options = {}) {\n\t\tif (!importMetaUrl) return 0;\n\t\tconst argv = options.argv ?? process.argv;\n\t\tconst stdout = options.stdout ?? process.stdout;\n\t\tconst stderr = options.stderr ?? process.stderr;\n\t\tif (!isDirectEntrypoint(importMetaUrl, argv)) return 0;\n\t\tconst exitCode = await orchestrate(importMetaUrl, MigrationClass, {\n\t\t\targv,\n\t\t\tstdout,\n\t\t\tstderr\n\t\t});\n\t\tif (exitCode !== 0 || !process.exitCode) process.exitCode = exitCode;\n\t\treturn exitCode;\n\t}\n};\n/**\n* Argv-aware variant of the entrypoint guard. The shared\n* `@internal/migration-tools` helper of the same name reads\n* `process.argv[1]` directly, which doesn't compose with the new\n* in-process testability surface (tests inject `argv` without mutating\n* the process global). Inlined here so the migration-file CLI's check\n* follows the injected `argv[1]` consistently.\n*/\nfunction isDirectEntrypoint(importMetaUrl, argv) {\n\tconst argv1 = argv[1];\n\tif (!argv1) return false;\n\ttry {\n\t\treturn realpathSync(fileURLToPath(importMetaUrl)) === realpathSync(argv1);\n\t} catch {\n\t\treturn false;\n\t}\n}\n/**\n* Argv-and-stream-driven orchestration body. Pulled out of the static\n* method so the entrypoint guard / process-default plumbing stays\n* separate from the parse + load + serialize steps.\n*/\nasync function orchestrate(importMetaUrl, MigrationClass, ctx) {\n\tconst cli = Cli.from([MigrationFileCommand], {\n\t\tbinaryName: \"migration.ts\",\n\t\tbinaryLabel: \"Migration file CLI\"\n\t});\n\tconst input = ctx.argv.slice(2);\n\tconst configError = detectInvalidConfig(input);\n\tif (configError) {\n\t\twriteStructuredError(ctx.stderr, configError);\n\t\treturn 2;\n\t}\n\tlet parsed;\n\ttry {\n\t\tconst command = cli.process({\n\t\t\tinput: [...input],\n\t\t\tcontext: {\n\t\t\t\tstdout: ctx.stdout,\n\t\t\t\tstderr: ctx.stderr\n\t\t\t}\n\t\t});\n\t\tif (!(command instanceof MigrationFileCommand)) {\n\t\t\tctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));\n\t\t\treturn 0;\n\t\t}\n\t\tparsed = command;\n\t} catch (err) {\n\t\treturn renderParseError(err, input, ctx.stderr);\n\t}\n\tif (parsed.help) {\n\t\tctx.stdout.write(cli.usage(MigrationFileCommand, { detailed: true }));\n\t\treturn 0;\n\t}\n\ttry {\n\t\tawait runMigration(importMetaUrl, MigrationClass, parsed, ctx);\n\t\treturn 0;\n\t} catch (err) {\n\t\tif (CliStructuredError.is(err)) writeStructuredError(ctx.stderr, err);\n\t\telse ctx.stderr.write(`${err instanceof Error ? err.message : String(err)}\\n`);\n\t\treturn 1;\n\t}\n}\n/**\n* Returns an `errorMigrationCliInvalidConfigArg` envelope when `input`\n* contains a malformed `--config`:\n*\n* - `--config` as the last token (no value follows).\n* - `--config <flag>` where `<flag>` starts with `-` (silently\n*   consuming the next flag would either drop the flag or serialize\n*   against the wrong project).\n* - `--config <empty>` where the value is the empty string. Shells\n*   expand `--config \"\"` (or `--config \"$UNSET_VAR\"`) into a real\n*   empty argv token; treating that as a usage error here surfaces\n*   `CLI.CONFIG_ARG_MISSING_PATH` instead of a less actionable loader error on an\n*   empty path.\n* - `--config=` (the equals form with an empty value). Same shape as\n*   the empty-string case above; the user expressed intent to override\n*   the config path but the override is empty.\n*\n* `--config=<value>` and `--config <value>` with a non-empty value are\n* both valid (and the equals form's value is allowed to start with\n* `-` — the `=` makes the binding explicit).\n*/\nfunction detectInvalidConfig(input) {\n\tfor (let i = 0; i < input.length; i++) {\n\t\tconst token = input[i];\n\t\tif (token === \"--config\") {\n\t\t\tconst next = input[i + 1];\n\t\t\tif (next === void 0 || next === \"\") return errorMigrationCliInvalidConfigArg();\n\t\t\tif (next.startsWith(\"-\")) return errorMigrationCliInvalidConfigArg({ nextToken: next });\n\t\t\tcontinue;\n\t\t}\n\t\tif (token === \"--config=\") return errorMigrationCliInvalidConfigArg();\n\t}\n\treturn null;\n}\n/**\n* Translate clipanion's parse-time errors into the project's structured\n* error envelopes.\n*\n* - `UnknownSyntaxError` covers both unknown flags (`--frobnicate`) and\n*   the bare-trailing `--config` case (where arity-1 needs a value but\n*   none was supplied). Distinguished by inspecting the input array.\n* - `UsageError` covers schema/validator failures from typanion. None\n*   of the migration-file CLI's options have validators today, but we\n*   still translate it as a usage error (exit 2) for forward-compat.\n* - Anything else re-throws — caller's outer catch will surface it as\n*   exit 1 (runtime error).\n*/\nfunction renderParseError(err, input, stderr) {\n\tif (isUnknownSyntaxError(err)) {\n\t\twriteStructuredError(stderr, errorMigrationCliUnknownFlag({\n\t\t\tflag: findOffendingFlag(input),\n\t\t\tknownFlags: KNOWN_FLAGS\n\t\t}));\n\t\treturn 2;\n\t}\n\tif (err instanceof UsageError) {\n\t\twriteStructuredError(stderr, errorMigrationCliInvalidConfigArg({ nextToken: err.message }));\n\t\treturn 2;\n\t}\n\tthrow err;\n}\n/**\n* Duck-type check for clipanion's `UnknownSyntaxError`: the class is\n* thrown by the parser but is not re-exported from the package's main\n* entry (only `UsageError` is — see clipanion's `advanced/index.d.ts`).\n* Identified by `name === 'UnknownSyntaxError'` and the\n* `clipanion.type === 'none'` discriminator that clipanion's\n* `ErrorWithMeta` interface guarantees.\n*/\nfunction isUnknownSyntaxError(err) {\n\tif (!(err instanceof Error) || err.name !== \"UnknownSyntaxError\") return false;\n\tconst meta = err.clipanion;\n\treturn typeof meta === \"object\" && meta !== null && meta.type === \"none\";\n}\n/**\n* Best-effort: pull the first input token that doesn't match a known\n* flag. Falls back to the first token when we can't pinpoint it. The\n* returned name is rendered into the user-visible CLI.UNKNOWN_FLAG envelope\n* (`Unknown flag \\`<name>\\``) and round-tripped via `meta.flag` so\n* agent consumers can render their own \"did you mean\" suggestions.\n*/\nfunction findOffendingFlag(input) {\n\tfor (const token of input) {\n\t\tif (!token.startsWith(\"-\")) continue;\n\t\tconst head = token.split(\"=\", 1)[0] ?? token;\n\t\tif (!KNOWN_FLAGS.includes(head) && head !== \"-h\") return head;\n\t}\n\treturn input[0] ?? \"\";\n}\n/**\n* Write a `CliStructuredError` envelope to the given stream. Format\n* matches the legacy hand-rolled writer (`message: why`) so the rest of\n* the project's error rendering stays consistent across surfaces. The\n* full PN code (`PN-<domain>-<code>`) is included so consumers can\n* grep for stable identifiers.\n*/\nfunction writeStructuredError(stream, err) {\n\tconst envelope = err.toEnvelope();\n\tconst why = envelope.why ?? envelope.summary;\n\tconst fix = envelope.fix ? `\\n${envelope.fix}` : \"\";\n\tstream.write(`${envelope.code}: ${envelope.summary}\\n${why}${fix}\\n`);\n}\n/**\n* Read a previously-scaffolded `migration.json` from disk, returning\n* `null` when the file is missing and throwing `MIGRATION.INVALID_JSON`\n* when the file is present but cannot be parsed as JSON. The CLI feeds\n* this into `buildMigrationArtifacts` so the pure builder can preserve\n* fields owned by `migration plan` (contract bookends, `createdAt`) across\n* re-emits.\n*\n* Author-time path: this loader still does not verify the manifest hash\n* or schema — that is the apply-time loader's job. Hash mismatch is the\n* *expected* outcome of a re-author (the developer's source changes\n* invalidate the prior hash by construction), and verification here\n* would block legitimate regenerations. Syntactic JSON-parse failure,\n* however, is now surfaced rather than swallowed: a malformed\n* `migration.json` indicates either a hand-edit gone wrong or partial\n* write, and silently rebuilding from `describe()` would discard the\n* user's on-disk content (preserved bookends, `createdAt`) without any\n* indication something was wrong on disk.\n* Apply-time consumers always route through the verifying\n* `readMigrationPackage` in `@internal/migration-tools/io` instead.\n*/\nfunction readExistingMetadata(metadataPath) {\n\tlet raw;\n\ttry {\n\t\traw = readFileSync(metadataPath, \"utf-8\");\n\t} catch {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn JSON.parse(raw);\n\t} catch (e) {\n\t\tthrow errorInvalidJson(metadataPath, e instanceof Error ? e.message : String(e));\n\t}\n}\n/**\n* Persist a migration instance's artifacts to `migrationDir`. In\n* `dryRun` mode the artifacts are printed to stdout (with the same\n* `--- migration.json --- / --- ops.json ---` framing the legacy\n* `serializeMigration` helper used) and no files are written. Otherwise\n* `ops.json` and `migration.json` are written next to `migration.ts` and\n* a confirmation line is printed.\n*\n* File I/O lives in the CLI rather than `@internal/migration-tools`\n* so the migration-tools package stays focused on the pure\n* `Migration` → in-memory artifact conversion. The CLI is the only\n* legitimate site for combining config loading, stack assembly, and\n* filesystem persistence.\n*/\nasync function serializeMigrationToDisk(instance, migrationDir, dryRun, stdout) {\n\tconst metadataPath = join(migrationDir, \"migration.json\");\n\tconst { opsJson, metadataJson } = await buildMigrationArtifacts(instance, readExistingMetadata(metadataPath));\n\tif (dryRun) {\n\t\tstdout.write(`--- migration.json ---\\n${metadataJson}\\n`);\n\t\tstdout.write(\"--- ops.json ---\\n\");\n\t\tstdout.write(`${opsJson}\\n`);\n\t\treturn;\n\t}\n\twriteFileSync(join(migrationDir, \"ops.json\"), opsJson);\n\twriteFileSync(metadataPath, metadataJson);\n\tstdout.write(`Wrote ops.json + migration.json to ${migrationDir}\\n`);\n}\n/**\n* Inner orchestration: load config, probe-construct the migration,\n* verify target, assemble the stack, construct with the stack, persist.\n*\n* Throws `CliStructuredError` for known failure modes (config not\n* found, target mismatch); the outer `orchestrate` translates those to\n* exit 1.\n*/\nasync function runMigration(importMetaUrl, MigrationClass, parsed, ctx) {\n\tconst migrationDir = dirname(fileURLToPath(importMetaUrl));\n\tconst configResult = await loadConfigForSections(parsed.config, [\n\t\t\"family\",\n\t\t\"target\",\n\t\t\"adapter\",\n\t\t\"driver\",\n\t\t\"extensions\"\n\t]);\n\tif (!configResult.ok) throw configResult.failure;\n\tconst config = configResult.value;\n\tconst probe = new MigrationClass();\n\tif (probe.targetId !== config.target.targetId) throw errorMigrationTargetMismatch({\n\t\tmigrationTargetId: probe.targetId,\n\t\tconfigTargetId: config.target.targetId\n\t});\n\tawait serializeMigrationToDisk(new MigrationClass(createControlStack(config)), migrationDir, parsed.dryRun, ctx.stdout);\n\tctx.stderr;\n}\n//#endregion\nexport { MigrationCLI };\n\n//# sourceMappingURL=migration-cli.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,MAAM,cAAc;CACnB;CACA;CACA;AACD;;;;;;;;AAQA,IAAI,uBAAuB,cAAc,QAAQ;CAChD,OAAO,QAAQ,CAAC,QAAQ,OAAO;CAC/B,OAAO,QAAQ,QAAQ,MAAM;EAC5B,aAAa;EACb,SAAS;;;;;EAKT,UAAU;GACT,CAAC,4DAA4D,IAAI;GACjE,CAAC,iCAAiC,cAAc;GAChD,CAAC,iCAAiC,gCAAgC;EACnE;CACD,CAAC;CACD,SAAS,OAAO,QAAQ,aAAa,OAAO,EAAE,aAAa,mDAAmD,CAAC;CAC/G,SAAS,OAAO,OAAO,YAAY,EAAE,aAAa,2BAA2B,CAAC;;;;;;;;;CAS9E,MAAM,UAAU;EACf,OAAO;CACR;AACD;;;;;;;;;;;;;AAaA,IAAI,eAAe,MAAM;;;;;;;;;;;;;;;;;;;;;;;;CAwBxB,aAAa,IAAI,eAAe,gBAAgB,UAAU,CAAC,GAAG;EAC7D,IAAI,CAAC,eAAe,OAAO;EAC3B,MAAM,OAAO,QAAQ,QAAQ,QAAQ;EACrC,MAAM,SAAS,QAAQ,UAAU,QAAQ;EACzC,MAAM,SAAS,QAAQ,UAAU,QAAQ;EACzC,IAAI,CAAC,mBAAmB,eAAe,IAAI,GAAG,OAAO;EACrD,MAAM,WAAW,MAAM,YAAY,eAAe,gBAAgB;GACjE;GACA;GACA;EACD,CAAC;EACD,IAAI,aAAa,KAAK,CAAC,QAAQ,UAAU,QAAQ,WAAW;EAC5D,OAAO;CACR;AACD;;;;;;;;;AASA,SAAS,mBAAmB,eAAe,MAAM;CAChD,MAAM,QAAQ,KAAK;CACnB,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI;EACH,OAAO,aAAa,cAAc,aAAa,CAAC,MAAM,aAAa,KAAK;CACzE,QAAQ;EACP,OAAO;CACR;AACD;;;;;;AAMA,eAAe,YAAY,eAAe,gBAAgB,KAAK;CAC9D,MAAM,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG;EAC5C,YAAY;EACZ,aAAa;CACd,CAAC;CACD,MAAM,QAAQ,IAAI,KAAK,MAAM,CAAC;CAC9B,MAAM,cAAc,oBAAoB,KAAK;CAC7C,IAAI,aAAa;EAChB,qBAAqB,IAAI,QAAQ,WAAW;EAC5C,OAAO;CACR;CACA,IAAI;CACJ,IAAI;EACH,MAAM,UAAU,IAAI,QAAQ;GAC3B,OAAO,CAAC,GAAG,KAAK;GAChB,SAAS;IACR,QAAQ,IAAI;IACZ,QAAQ,IAAI;GACb;EACD,CAAC;EACD,IAAI,EAAE,mBAAmB,uBAAuB;GAC/C,IAAI,OAAO,MAAM,IAAI,MAAM,sBAAsB,EAAE,UAAU,KAAK,CAAC,CAAC;GACpE,OAAO;EACR;EACA,SAAS;CACV,SAAS,KAAK;EACb,OAAO,iBAAiB,KAAK,OAAO,IAAI,MAAM;CAC/C;CACA,IAAI,OAAO,MAAM;EAChB,IAAI,OAAO,MAAM,IAAI,MAAM,sBAAsB,EAAE,UAAU,KAAK,CAAC,CAAC;EACpE,OAAO;CACR;CACA,IAAI;EACH,MAAM,aAAa,eAAe,gBAAgB,QAAQ,GAAG;EAC7D,OAAO;CACR,SAAS,KAAK;EACb,IAAI,mBAAmB,GAAG,GAAG,GAAG,qBAAqB,IAAI,QAAQ,GAAG;OAC/D,IAAI,OAAO,MAAM,GAAG,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,EAAE,GAAG;EAC7E,OAAO;CACR;AACD;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAS,oBAAoB,OAAO;CACnC,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACtC,MAAM,QAAQ,MAAM;EACpB,IAAI,UAAU,YAAY;GACzB,MAAM,OAAO,MAAM,IAAI;GACvB,IAAI,SAAS,KAAK,KAAK,SAAS,IAAI,OAAO,kCAAkC;GAC7E,IAAI,KAAK,WAAW,GAAG,GAAG,OAAO,kCAAkC,EAAE,WAAW,KAAK,CAAC;GACtF;EACD;EACA,IAAI,UAAU,aAAa,OAAO,kCAAkC;CACrE;CACA,OAAO;AACR;;;;;;;;;;;;;;AAcA,SAAS,iBAAiB,KAAK,OAAO,QAAQ;CAC7C,IAAI,qBAAqB,GAAG,GAAG;EAC9B,qBAAqB,QAAQ,6BAA6B;GACzD,MAAM,kBAAkB,KAAK;GAC7B,YAAY;EACb,CAAC,CAAC;EACF,OAAO;CACR;CACA,IAAI,eAAe,YAAY;EAC9B,qBAAqB,QAAQ,kCAAkC,EAAE,WAAW,IAAI,QAAQ,CAAC,CAAC;EAC1F,OAAO;CACR;CACA,MAAM;AACP;;;;;;;;;AASA,SAAS,qBAAqB,KAAK;CAClC,IAAI,EAAE,eAAe,UAAU,IAAI,SAAS,sBAAsB,OAAO;CACzE,MAAM,OAAO,IAAI;CACjB,OAAO,OAAO,SAAS,YAAY,SAAS,QAAQ,KAAK,SAAS;AACnE;;;;;;;;AAQA,SAAS,kBAAkB,OAAO;CACjC,KAAK,MAAM,SAAS,OAAO;EAC1B,IAAI,CAAC,MAAM,WAAW,GAAG,GAAG;EAC5B,MAAM,OAAO,MAAM,MAAM,KAAK,CAAC,CAAC,CAAC,MAAM;EACvC,IAAI,CAAC,YAAY,SAAS,IAAI,KAAK,SAAS,MAAM,OAAO;CAC1D;CACA,OAAO,MAAM,MAAM;AACpB;;;;;;;;AAQA,SAAS,qBAAqB,QAAQ,KAAK;CAC1C,MAAM,WAAW,IAAI,WAAW;CAChC,MAAM,MAAM,SAAS,OAAO,SAAS;CACrC,MAAM,MAAM,SAAS,MAAM,KAAK,SAAS,QAAQ;CACjD,OAAO,MAAM,GAAG,SAAS,KAAK,IAAI,SAAS,QAAQ,IAAI,MAAM,IAAI,GAAG;AACrE;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAS,qBAAqB,cAAc;CAC3C,IAAI;CACJ,IAAI;EACH,MAAM,aAAa,cAAc,OAAO;CACzC,QAAQ;EACP,OAAO;CACR;CACA,IAAI;EACH,OAAO,KAAK,MAAM,GAAG;CACtB,SAAS,GAAG;EACX,MAAM,iBAAiB,cAAc,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,CAAC;CAChF;AACD;;;;;;;;;;;;;;;AAeA,eAAe,yBAAyB,UAAU,cAAc,QAAQ,QAAQ;CAC/E,MAAM,eAAe,KAAK,cAAc,gBAAgB;CACxD,MAAM,EAAE,SAAS,iBAAiB,MAAM,wBAAwB,UAAU,qBAAqB,YAAY,CAAC;CAC5G,IAAI,QAAQ;EACX,OAAO,MAAM,2BAA2B,aAAa,GAAG;EACxD,OAAO,MAAM,oBAAoB;EACjC,OAAO,MAAM,GAAG,QAAQ,GAAG;EAC3B;CACD;CACA,cAAc,KAAK,cAAc,UAAU,GAAG,OAAO;CACrD,cAAc,cAAc,YAAY;CACxC,OAAO,MAAM,sCAAsC,aAAa,GAAG;AACpE;;;;;;;;;AASA,eAAe,aAAa,eAAe,gBAAgB,QAAQ,KAAK;CACvE,MAAM,eAAe,QAAQ,cAAc,aAAa,CAAC;CACzD,MAAM,eAAe,MAAM,sBAAsB,OAAO,QAAQ;EAC/D;EACA;EACA;EACA;EACA;CACD,CAAC;CACD,IAAI,CAAC,aAAa,IAAI,MAAM,aAAa;CACzC,MAAM,SAAS,aAAa;CAC5B,MAAM,QAAQ,IAAI,eAAe;CACjC,IAAI,MAAM,aAAa,OAAO,OAAO,UAAU,MAAM,6BAA6B;EACjF,mBAAmB,MAAM;EACzB,gBAAgB,OAAO,OAAO;CAC/B,CAAC;CACD,MAAM,yBAAyB,IAAI,eAAe,mBAAmB,MAAM,CAAC,GAAG,cAAc,OAAO,QAAQ,IAAI,MAAM;CACtH,IAAI;AACL"}

package/dist/config-loader.d.mts

@@ -1,2 +1,2 @@
-import { a as findNearestConfigPathForFile, c as loadConfigForSections, i as finalizeConfig, l as requireConfigSections, n as LoadedConfig, o as loadConfig, r as PrismaNextConfig, s as loadConfigForFile, t as ConfigSection } from "./index-DRs7L6N0.mjs";
+import { a as findNearestConfigPathForFile, c as loadConfigForSections, i as finalizeConfig, l as requireConfigSections, n as LoadedConfig, o as loadConfig, r as PrismaNextConfig, s as loadConfigForFile, t as ConfigSection } from "./index-u5RdrumF.mjs";
 export { type ConfigSection, type LoadedConfig, type PrismaNextConfig, finalizeConfig, findNearestConfigPathForFile, loadConfig, loadConfigForFile, loadConfigForSections, requireConfigSections };

package/dist/config-loader.mjs

@@ -1,2 +1,2 @@
-import { a as loadConfigForSections, i as loadConfigForFile, n as findNearestConfigPathForFile, o as requireConfigSections, r as loadConfig, t as finalizeConfig } from "./exports-BZaG8_w_.mjs";
+import { a as loadConfigForSections, i as loadConfigForFile, n as findNearestConfigPathForFile, o as requireConfigSections, r as loadConfig, t as finalizeConfig } from "./exports-BXXeNWlj.mjs";
 export { finalizeConfig, findNearestConfigPathForFile, loadConfig, loadConfigForFile, loadConfigForSections, requireConfigSections };

package/dist/{contract-snapshot-store-B0G1Fw_F-CHc4QfKb.mjs → contract-snapshot-store-qGrwlGmt-Cf2NFzRL.mjs}

@@ -1,11 +1,11 @@
-import { a as errorContractSnapshotHashMismatch, g as errorInvalidJson, o as errorContractSnapshotMissing } from "./errors-CXbGUWGu-CstQHPh6.mjs";
+import { a as errorContractSnapshotHashMismatch, g as errorInvalidJson, o as errorContractSnapshotMissing } from "./errors-SoLLYLtw-DMxVbVs9.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { CONTRACT_SNAPSHOTS_DIRNAME, storageHashHex } from "@prisma/orm-framework/components/control";
 import { join, relative } from "pathe";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
-//#region ../../../1-framework/3-tooling/migration/dist/contract-snapshot-store-B0G1Fw_F.mjs
+//#region ../../../1-framework/3-tooling/migration/dist/contract-snapshot-store-qGrwlGmt.mjs
 const CONTRACT_JSON_FILE = "contract.json";
 const CONTRACT_DTS_FILE = "contract.d.ts";
 function hasErrnoCode(error, code) {
@@ -115,4 +115,4 @@ function snapshotsImportPathFrom(packageDir, migrationsDir) {
 //#endregion
 export { snapshotsImportPathFrom as a, readContractSnapshotJsonTolerant as i, readContractSnapshotDts as n, writeContractSnapshot as o, readContractSnapshotJson as r, contractSnapshotDir as t };
 
-//# sourceMappingURL=contract-snapshot-store-B0G1Fw_F-CHc4QfKb.mjs.map
+//# sourceMappingURL=contract-snapshot-store-qGrwlGmt-Cf2NFzRL.mjs.map

package/dist/{contract-snapshot-store-B0G1Fw_F-CHc4QfKb.mjs.map → contract-snapshot-store-qGrwlGmt-Cf2NFzRL.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"contract-snapshot-store-B0G1Fw_F-CHc4QfKb.mjs","names":[],"sources":["../../../../1-framework/3-tooling/migration/dist/contract-snapshot-store-B0G1Fw_F.mjs"],"sourcesContent":["import { a as errorContractSnapshotHashMismatch, g as errorInvalidJson, o as errorContractSnapshotMissing } from \"./errors-CXbGUWGu.mjs\";\nimport { join, relative } from \"pathe\";\nimport { mkdir, readFile, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport { randomBytes } from \"node:crypto\";\nimport { CONTRACT_SNAPSHOTS_DIRNAME, storageHashHex } from \"@internal/framework-components/control\";\nimport { canonicalizeJson } from \"@internal/framework-components/utils\";\nimport { blindCast } from \"@internal/utils/casts\";\n//#region src/contract-snapshot-store.ts\nconst CONTRACT_JSON_FILE = \"contract.json\";\nconst CONTRACT_DTS_FILE = \"contract.d.ts\";\nfunction hasErrnoCode(error, code) {\n\treturn error instanceof Error && blindCast(error).code === code;\n}\nasync function directoryExists(p) {\n\ttry {\n\t\treturn (await stat(p)).isDirectory();\n\t} catch (error) {\n\t\tif (hasErrnoCode(error, \"ENOENT\")) return false;\n\t\tthrow error;\n\t}\n}\nfunction contractSnapshotDir(migrationsDir, storageHash) {\n\treturn join(migrationsDir, CONTRACT_SNAPSHOTS_DIRNAME, storageHashHex(storageHash));\n}\nasync function writeContractSnapshot(migrationsDir, storageHash, input) {\n\tconst dir = contractSnapshotDir(migrationsDir, storageHash);\n\tconst actualStorageHash = blindCast(input.contractJson).storage?.storageHash;\n\tif (actualStorageHash !== storageHash) throw errorContractSnapshotHashMismatch(storageHash, typeof actualStorageHash === \"string\" ? actualStorageHash : String(actualStorageHash), dir);\n\tif (await directoryExists(dir)) return {\n\t\twritten: false,\n\t\tdir\n\t};\n\tconst tmpDir = join(join(migrationsDir, CONTRACT_SNAPSHOTS_DIRNAME), `.tmp-${storageHashHex(storageHash)}-${Date.now()}-${randomBytes(4).toString(\"hex\")}`);\n\tawait mkdir(tmpDir, { recursive: true });\n\tconst jsonContent = `${canonicalizeJson(input.contractJson)}\\n`;\n\tconst dtsContent = input.contractDts.endsWith(\"\\n\") ? input.contractDts : `${input.contractDts}\\n`;\n\ttry {\n\t\tawait writeFile(join(tmpDir, CONTRACT_JSON_FILE), jsonContent);\n\t\tawait writeFile(join(tmpDir, CONTRACT_DTS_FILE), dtsContent);\n\t\tawait rename(tmpDir, dir);\n\t} catch (error) {\n\t\tawait rm(tmpDir, {\n\t\t\trecursive: true,\n\t\t\tforce: true\n\t\t});\n\t\tif (hasErrnoCode(error, \"EEXIST\") || hasErrnoCode(error, \"ENOTEMPTY\")) return {\n\t\t\twritten: false,\n\t\t\tdir\n\t\t};\n\t\tthrow error;\n\t}\n\treturn {\n\t\twritten: true,\n\t\tdir\n\t};\n}\nasync function readContractSnapshotJson(migrationsDir, storageHash) {\n\tconst jsonPath = join(contractSnapshotDir(migrationsDir, storageHash), CONTRACT_JSON_FILE);\n\tlet raw;\n\ttry {\n\t\traw = await readFile(jsonPath, \"utf-8\");\n\t} catch (error) {\n\t\tif (hasErrnoCode(error, \"ENOENT\")) throw errorContractSnapshotMissing(storageHash, jsonPath);\n\t\tthrow error;\n\t}\n\ttry {\n\t\treturn JSON.parse(raw);\n\t} catch (e) {\n\t\tthrow errorInvalidJson(jsonPath, e instanceof Error ? e.message : String(e));\n\t}\n}\n/**\n* Tolerant read: a missing store entry (ENOENT), an unparseable\n* `contract.json`, the JSON literal `null`, or a `storageHash` that isn't a\n* well-formed 64-hex value all resolve to `undefined` rather than\n* throwing — parity with the catch-all tolerance of the pre-store\n* `readEndContractJson` (`io.ts`), which never validated the hash it was\n* keyed by either. Any other fs error (e.g. `EACCES` on a present-but-\n* unreadable file) propagates rather than silently loading a contract-less\n* package.\n*/\nasync function readContractSnapshotJsonTolerant(migrationsDir, storageHash) {\n\tlet jsonPath;\n\ttry {\n\t\tjsonPath = join(contractSnapshotDir(migrationsDir, storageHash), CONTRACT_JSON_FILE);\n\t} catch {\n\t\treturn;\n\t}\n\tlet raw;\n\ttry {\n\t\traw = await readFile(jsonPath, \"utf-8\");\n\t} catch (error) {\n\t\tif (hasErrnoCode(error, \"ENOENT\")) return;\n\t\tthrow error;\n\t}\n\ttry {\n\t\tconst parsed = JSON.parse(raw);\n\t\treturn parsed === null ? void 0 : parsed;\n\t} catch {\n\t\treturn;\n\t}\n}\nasync function readContractSnapshotDts(migrationsDir, storageHash) {\n\tconst dtsPath = join(contractSnapshotDir(migrationsDir, storageHash), CONTRACT_DTS_FILE);\n\ttry {\n\t\treturn await readFile(dtsPath, \"utf-8\");\n\t} catch (error) {\n\t\tif (hasErrnoCode(error, \"ENOENT\")) throw errorContractSnapshotMissing(storageHash, dtsPath);\n\t\tthrow error;\n\t}\n}\nfunction snapshotsImportPathFrom(packageDir, migrationsDir) {\n\treturn relative(packageDir, join(migrationsDir, CONTRACT_SNAPSHOTS_DIRNAME)).split(\"\\\\\").join(\"/\");\n}\n//#endregion\nexport { snapshotsImportPathFrom as a, readContractSnapshotJsonTolerant as i, readContractSnapshotDts as n, writeContractSnapshot as o, readContractSnapshotJson as r, contractSnapshotDir as t };\n\n//# sourceMappingURL=contract-snapshot-store-B0G1Fw_F.mjs.map"],"mappings":"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"}
+{"version":3,"file":"contract-snapshot-store-qGrwlGmt-Cf2NFzRL.mjs","names":[],"sources":["../../../../1-framework/3-tooling/migration/dist/contract-snapshot-store-qGrwlGmt.mjs"],"sourcesContent":["import { a as errorContractSnapshotHashMismatch, g as errorInvalidJson, o as errorContractSnapshotMissing } from \"./errors-SoLLYLtw.mjs\";\nimport { join, relative } from \"pathe\";\nimport { mkdir, readFile, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport { randomBytes } from \"node:crypto\";\nimport { CONTRACT_SNAPSHOTS_DIRNAME, storageHashHex } from \"@internal/framework-components/control\";\nimport { canonicalizeJson } from \"@internal/framework-components/utils\";\nimport { blindCast } from \"@internal/utils/casts\";\n//#region src/contract-snapshot-store.ts\nconst CONTRACT_JSON_FILE = \"contract.json\";\nconst CONTRACT_DTS_FILE = \"contract.d.ts\";\nfunction hasErrnoCode(error, code) {\n\treturn error instanceof Error && blindCast(error).code === code;\n}\nasync function directoryExists(p) {\n\ttry {\n\t\treturn (await stat(p)).isDirectory();\n\t} catch (error) {\n\t\tif (hasErrnoCode(error, \"ENOENT\")) return false;\n\t\tthrow error;\n\t}\n}\nfunction contractSnapshotDir(migrationsDir, storageHash) {\n\treturn join(migrationsDir, CONTRACT_SNAPSHOTS_DIRNAME, storageHashHex(storageHash));\n}\nasync function writeContractSnapshot(migrationsDir, storageHash, input) {\n\tconst dir = contractSnapshotDir(migrationsDir, storageHash);\n\tconst actualStorageHash = blindCast(input.contractJson).storage?.storageHash;\n\tif (actualStorageHash !== storageHash) throw errorContractSnapshotHashMismatch(storageHash, typeof actualStorageHash === \"string\" ? actualStorageHash : String(actualStorageHash), dir);\n\tif (await directoryExists(dir)) return {\n\t\twritten: false,\n\t\tdir\n\t};\n\tconst tmpDir = join(join(migrationsDir, CONTRACT_SNAPSHOTS_DIRNAME), `.tmp-${storageHashHex(storageHash)}-${Date.now()}-${randomBytes(4).toString(\"hex\")}`);\n\tawait mkdir(tmpDir, { recursive: true });\n\tconst jsonContent = `${canonicalizeJson(input.contractJson)}\\n`;\n\tconst dtsContent = input.contractDts.endsWith(\"\\n\") ? input.contractDts : `${input.contractDts}\\n`;\n\ttry {\n\t\tawait writeFile(join(tmpDir, CONTRACT_JSON_FILE), jsonContent);\n\t\tawait writeFile(join(tmpDir, CONTRACT_DTS_FILE), dtsContent);\n\t\tawait rename(tmpDir, dir);\n\t} catch (error) {\n\t\tawait rm(tmpDir, {\n\t\t\trecursive: true,\n\t\t\tforce: true\n\t\t});\n\t\tif (hasErrnoCode(error, \"EEXIST\") || hasErrnoCode(error, \"ENOTEMPTY\")) return {\n\t\t\twritten: false,\n\t\t\tdir\n\t\t};\n\t\tthrow error;\n\t}\n\treturn {\n\t\twritten: true,\n\t\tdir\n\t};\n}\nasync function readContractSnapshotJson(migrationsDir, storageHash) {\n\tconst jsonPath = join(contractSnapshotDir(migrationsDir, storageHash), CONTRACT_JSON_FILE);\n\tlet raw;\n\ttry {\n\t\traw = await readFile(jsonPath, \"utf-8\");\n\t} catch (error) {\n\t\tif (hasErrnoCode(error, \"ENOENT\")) throw errorContractSnapshotMissing(storageHash, jsonPath);\n\t\tthrow error;\n\t}\n\ttry {\n\t\treturn JSON.parse(raw);\n\t} catch (e) {\n\t\tthrow errorInvalidJson(jsonPath, e instanceof Error ? e.message : String(e));\n\t}\n}\n/**\n* Tolerant read: a missing store entry (ENOENT), an unparseable\n* `contract.json`, the JSON literal `null`, or a `storageHash` that isn't a\n* well-formed 64-hex value all resolve to `undefined` rather than\n* throwing — parity with the catch-all tolerance of the pre-store\n* `readEndContractJson` (`io.ts`), which never validated the hash it was\n* keyed by either. Any other fs error (e.g. `EACCES` on a present-but-\n* unreadable file) propagates rather than silently loading a contract-less\n* package.\n*/\nasync function readContractSnapshotJsonTolerant(migrationsDir, storageHash) {\n\tlet jsonPath;\n\ttry {\n\t\tjsonPath = join(contractSnapshotDir(migrationsDir, storageHash), CONTRACT_JSON_FILE);\n\t} catch {\n\t\treturn;\n\t}\n\tlet raw;\n\ttry {\n\t\traw = await readFile(jsonPath, \"utf-8\");\n\t} catch (error) {\n\t\tif (hasErrnoCode(error, \"ENOENT\")) return;\n\t\tthrow error;\n\t}\n\ttry {\n\t\tconst parsed = JSON.parse(raw);\n\t\treturn parsed === null ? void 0 : parsed;\n\t} catch {\n\t\treturn;\n\t}\n}\nasync function readContractSnapshotDts(migrationsDir, storageHash) {\n\tconst dtsPath = join(contractSnapshotDir(migrationsDir, storageHash), CONTRACT_DTS_FILE);\n\ttry {\n\t\treturn await readFile(dtsPath, \"utf-8\");\n\t} catch (error) {\n\t\tif (hasErrnoCode(error, \"ENOENT\")) throw errorContractSnapshotMissing(storageHash, dtsPath);\n\t\tthrow error;\n\t}\n}\nfunction snapshotsImportPathFrom(packageDir, migrationsDir) {\n\treturn relative(packageDir, join(migrationsDir, CONTRACT_SNAPSHOTS_DIRNAME)).split(\"\\\\\").join(\"/\");\n}\n//#endregion\nexport { snapshotsImportPathFrom as a, readContractSnapshotJsonTolerant as i, readContractSnapshotDts as n, writeContractSnapshot as o, readContractSnapshotJson as r, contractSnapshotDir as t };\n\n//# sourceMappingURL=contract-snapshot-store-qGrwlGmt.mjs.map"],"mappings":"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"}

package/dist/{db-verify-BwgNK50T-DGvKgFCK.d.mts → db-verify-Yih5kWtB-B1kv76ec.d.mts}

@@ -1,4 +1,4 @@
-import "./ref-resolution-COGOSL57.mjs";
+import "./ref-resolution-CaHQJXE0.mjs";
 import { CliStructuredError as CliStructuredError$2 } from "@prisma/orm-framework/errors/control";
 import { ControlAdapterDescriptor, ControlDriverDescriptor, ControlDriverInstance, ControlExtensionDescriptor, ControlFamilyDescriptor, ControlFamilyInstance, ControlTargetDescriptor, CoreSchemaView, MigrationPlanOperation, MigrationPlannerConflict, OperationPreview, SignDatabaseResult, VerifyDatabaseResult, VerifyDatabaseSchemaResult } from "@prisma/orm-framework/components/control";
 import { Result } from "@prisma/orm-framework/utils/result";
@@ -10,7 +10,7 @@ import "@prisma/cli-engine/protocol";
 import { ContractSourceDiagnostics, ContractSourceProvider, PrismaNextConfig } from "@prisma/orm-framework/config/config-types";
 import { AuthoringPslBlockDescriptorNamespace } from "@prisma/orm-framework/components/authoring";
 import { PslDocumentAst } from "@prisma/orm-framework/components/psl-ast";
-//#region ../../../1-framework/3-tooling/cli/dist/db-verify-BwgNK50T.d.mts
+//#region ../../../1-framework/3-tooling/cli/dist/db-verify-Yih5kWtB.d.mts
 //#region src/control-api/types.d.ts
 /**
  * Options for creating a control client.
@@ -647,7 +647,7 @@ type MigrateResult = Result<MigrateSuccess, MigrateFailure>;
  * Options for the standalone executeContractEmit function.
  *
  * `executeContractEmit` is the canonical publication path for both the
- * `prisma-next contract emit` CLI command and the `@internal/vite-plugin-contract-emit`
+ * `prisma contract emit` CLI command and the `@internal/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.
@@ -709,7 +709,7 @@ interface ContractEmitResult {
   readonly validationWarning?: string;
 }
 /**
- * Programmatic control client for Prisma Next operations.
+ * Programmatic control client for Prisma ORM operations.
  *
  * Lifecycle: `connect(connection)` before operations, `close()` when done.
  * Both `init()` and `connect()` are auto-called by operations if needed,
@@ -960,4 +960,4 @@ type ExecuteDbVerifyResult = Result<ExecuteDbVerifySuccess, CliStructuredError$2
 declare function executeDbVerify<TFamilyId extends string, TTargetId extends string>(options: ExecuteDbVerifyOptions<TFamilyId, TTargetId>): Promise<ExecuteDbVerifyResult>;
 //#endregion
 export { SchemaVerifyOptions as A, EmitResult as C, IntrospectOptions as D, ExecuteDbVerifyResult as E, VerifyOptions as M, executeDbVerify as N, MigrateResult as O, EmitOptions as S, ExecuteDbVerifyOptions as T, DbUpdateResult as _, ControlClient as a, EmitFailure as b, CreateControlClient as c, DbInitOptions as d, DbInitResult as f, DbUpdateOptions as g, DbUpdateFailureCode as h, ControlActionName as i, SignOptions as j, OnControlProgress as k, DbInitFailure as l, DbUpdateFailure as m, ContractEmitOptions as n, ControlClientOptions as o, DbInitSuccess as p, ContractEmitResult as r, ControlProgressEvent as s, CliStructuredError$2 as t, DbInitFailureCode as u, DbUpdateSuccess as v, EmitSuccess as w, EmitFailureCode as x, EmitContractConfig as y };
-//# sourceMappingURL=db-verify-BwgNK50T-DGvKgFCK.d.mts.map
+//# sourceMappingURL=db-verify-Yih5kWtB-B1kv76ec.d.mts.map

package/dist/{db-verify-BwgNK50T-DGvKgFCK.d.mts.map → db-verify-Yih5kWtB-B1kv76ec.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"db-verify-BwgNK50T-DGvKgFCK.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/db-verify-BwgNK50T.d.mts"],"mappings":"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"}
+{"version":3,"file":"db-verify-Yih5kWtB-B1kv76ec.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/db-verify-Yih5kWtB.d.mts"],"mappings":"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"}

package/dist/{domain-type-generation-bpSO3Y0L-jo2C7LlH.mjs → domain-type-generation-CR9ECUau-DOlKbcaE.mjs}

@@ -3,7 +3,7 @@ import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { keepInternalSpecifiers } from "@prisma/orm-framework/components/emission";
 import { renderImports, tsStringLiteral } from "@prisma/orm-framework/ts-render";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-//#region ../../../1-framework/3-tooling/emitter/dist/domain-type-generation-bpSO3Y0L.mjs
+//#region ../../../1-framework/3-tooling/emitter/dist/domain-type-generation-CR9ECUau.mjs
 function emitterError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -66,6 +66,7 @@ function generateModelRelationsType(relations) {
 		const parts = [];
 		if (toRef) parts.push(`readonly to: ${serializeCrossReference(blindCast(toRef))}`);
 		if (relObj["cardinality"]) parts.push(`readonly cardinality: ${serializeValue(relObj["cardinality"])}`);
+		if (typeof relObj["nullable"] === "boolean") parts.push(`readonly nullable: ${relObj["nullable"]}`);
 		const on = relObj["on"];
 		if (on && (!on.localFields || !on.targetFields)) throw emitterError("CONTRACT.RELATION_INVALID", `Relation "${relName}" has an "on" block but is missing localFields or targetFields`, { meta: { relation: relName } });
 		if (on?.localFields && on.targetFields) {
@@ -222,11 +223,26 @@ function resolveFieldType(field, codecLookup, resolvedTypeParams, resolvedValueS
 function generateFieldResolvedType(field, codecLookup, side = "output") {
 	return resolveFieldType(field, codecLookup)[side];
 }
+/**
+* Resolves one model field's input and output types the way `FieldOutputTypes` /
+* `FieldInputTypes` do: inline type params win over the family resolver, and a family-resolved
+* value set renders as a literal union.
+*/
+function resolveModelFieldType(modelName, fieldName, field, model, resolvers) {
+	const resolvedTypeParams = (field.type.kind === "scalar" && field.type.typeParams && Object.keys(field.type.typeParams).length > 0 ? field.type.typeParams : void 0) ?? resolvers.resolveFieldTypeParams?.(modelName, fieldName, model);
+	const resolvedValueSet = resolvers.resolveFieldValueSet?.(modelName, fieldName, model);
+	return resolveFieldType(field, resolvers.codecLookup, resolvedTypeParams, resolvedValueSet);
+}
 function generateBothFieldTypesMaps(models, codecLookup, resolveFieldTypeParams, resolveFieldValueSet) {
 	if (!models || Object.keys(models).length === 0) return {
 		output: "Record<string, never>",
 		input: "Record<string, never>"
 	};
+	const resolvers = {
+		codecLookup,
+		resolveFieldTypeParams,
+		resolveFieldValueSet
+	};
 	const outputModelEntries = [];
 	const inputModelEntries = [];
 	for (const [modelName, model] of Object.entries(models).sort(([a], [b]) => a.localeCompare(b))) {
@@ -234,9 +250,7 @@ function generateBothFieldTypesMaps(models, codecLookup, resolveFieldTypeParams,
 		const outputFieldEntries = [];
 		const inputFieldEntries = [];
 		for (const [fieldName, field] of Object.entries(model.fields)) {
-			const resolvedTypeParams = (field.type.kind === "scalar" && field.type.typeParams && Object.keys(field.type.typeParams).length > 0 ? field.type.typeParams : void 0) ?? resolveFieldTypeParams?.(modelName, fieldName, model);
-			const resolvedValueSet = resolveFieldValueSet?.(modelName, fieldName, model);
-			const resolved = resolveFieldType(field, codecLookup, resolvedTypeParams, resolvedValueSet);
+			const resolved = resolveModelFieldType(modelName, fieldName, field, model, resolvers);
 			const key = `readonly ${serializeObjectKey(fieldName)}`;
 			outputFieldEntries.push(`${key}: ${resolved.output}`);
 			inputFieldEntries.push(`${key}: ${resolved.input}`);
@@ -329,6 +343,6 @@ function generateValueObjectTypeAliases(valueObjects, codecLookup) {
 	return aliases.join("\n");
 }
 //#endregion
-export { serializeCrossReference as C, serializeValue as D, serializeObjectKey as E, resolveValueObjectType as S, serializeNamespaceId as T, generateValueObjectType as _, generateContractFieldDescriptor as a, renderValueSetType as b, generateFieldResolvedType as c, generateImportLines as d, generateModelFieldEntry as f, generateRootsType as g, generateModelsType as h, generateCodecTypeIntersection as i, generateFieldTypesMapsByNamespace as l, generateModelRelationsType as m, emitterError as n, generateFieldInputTypesMap as o, generateModelFieldsType as p, generateBothFieldTypesMaps as r, generateFieldOutputTypesMap as s, deduplicateImports as t, generateHashTypeAliases as u, generateValueObjectTypeAliases as v, serializeExecutionType as w, resolveFieldType as x, generateValueObjectsDescriptorType as y };
+export { resolveValueObjectType as C, serializeObjectKey as D, serializeNamespaceId as E, serializeValue as O, resolveModelFieldType as S, serializeExecutionType as T, generateValueObjectType as _, generateContractFieldDescriptor as a, renderValueSetType as b, generateFieldResolvedType as c, generateImportLines as d, generateModelFieldEntry as f, generateRootsType as g, generateModelsType as h, generateCodecTypeIntersection as i, generateFieldTypesMapsByNamespace as l, generateModelRelationsType as m, emitterError as n, generateFieldInputTypesMap as o, generateModelFieldsType as p, generateBothFieldTypesMaps as r, generateFieldOutputTypesMap as s, deduplicateImports as t, generateHashTypeAliases as u, generateValueObjectTypeAliases as v, serializeCrossReference as w, resolveFieldType as x, generateValueObjectsDescriptorType as y };
 
-//# sourceMappingURL=domain-type-generation-bpSO3Y0L-jo2C7LlH.mjs.map
+//# sourceMappingURL=domain-type-generation-CR9ECUau-DOlKbcaE.mjs.map

package/dist/domain-type-generation-CR9ECUau-DOlKbcaE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-type-generation-CR9ECUau-DOlKbcaE.mjs","names":[],"sources":["../../../../1-framework/3-tooling/emitter/dist/domain-type-generation-CR9ECUau.mjs"],"sourcesContent":["import { isSafeTypeExpression } from \"./type-expression-safety.mjs\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { keepInternalSpecifiers } from \"@internal/framework-components/emission\";\nimport { renderImports, tsStringLiteral } from \"@internal/ts-render\";\nimport { blindCast } from \"@internal/utils/casts\";\n//#region src/emitter-errors.ts\nfunction emitterError(code, message, options) {\n\treturn structuredError(code, message, options);\n}\n//#endregion\n//#region src/domain-type-generation.ts\nfunction serializeValue(value) {\n\tif (value === null) return \"null\";\n\tif (value === void 0) return \"undefined\";\n\tif (typeof value === \"string\") return tsStringLiteral(value);\n\tif (typeof value === \"number\" || typeof value === \"boolean\") return String(value);\n\tif (typeof value === \"bigint\") return `${value}n`;\n\tif (Array.isArray(value)) return `readonly [${value.map((v) => serializeValue(v)).join(\", \")}]`;\n\tif (typeof value === \"object\") {\n\t\tconst entries = [];\n\t\tfor (const [k, v] of Object.entries(value)) entries.push(`readonly ${serializeObjectKey(k)}: ${serializeValue(v)}`);\n\t\treturn `{ ${entries.join(\"; \")} }`;\n\t}\n\treturn \"unknown\";\n}\nfunction serializeObjectKey(key) {\n\tif (/^[$A-Z_a-z][$\\w]*$/.test(key)) return key;\n\treturn serializeValue(key);\n}\nfunction serializeNamespaceId(value) {\n\treturn `${serializeValue(value)} & NamespaceId`;\n}\nfunction serializeCrossReference(ref) {\n\treturn `{ readonly namespace: ${serializeNamespaceId(String(ref.namespace))}; readonly model: ${serializeValue(ref.model)}${ref.space !== void 0 ? `; readonly space: ${serializeValue(ref.space)}` : \"\"} }`;\n}\nfunction generateRootsType(roots) {\n\tif (!roots || Object.keys(roots).length === 0) return \"Record<string, never>\";\n\treturn `{ ${Object.entries(roots).map(([key, value]) => `readonly ${serializeObjectKey(key)}: ${serializeCrossReference(value)}`).join(\"; \")} }`;\n}\nfunction contractFieldModifierSuffix(field) {\n\treturn (field.many === true ? \"; readonly many: true\" : \"\") + (field.dict === true ? \"; readonly dict: true\" : \"\");\n}\nfunction generateModelFieldEntry(fieldName, field) {\n\tconst mods = contractFieldModifierSuffix(field);\n\tconst { nullable, type } = field;\n\tif (type.kind === \"scalar\") {\n\t\tconst typeParamsSpec = type.typeParams && Object.keys(type.typeParams).length > 0 ? `; readonly typeParams: ${serializeValue(type.typeParams)}` : \"\";\n\t\treturn `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${nullable}; readonly type: { readonly kind: \"scalar\"; readonly codecId: ${serializeValue(type.codecId)}${typeParamsSpec} }${mods} }`;\n\t}\n\tif (type.kind === \"valueObject\") return `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${nullable}; readonly type: { readonly kind: \"valueObject\"; readonly name: ${serializeValue(type.name)} }${mods} }`;\n\treturn `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${nullable}; readonly type: ${serializeValue(type)}${mods} }`;\n}\nfunction generateModelFieldsType(fields) {\n\tconst fieldEntries = [];\n\tfor (const [fieldName, field] of Object.entries(fields)) fieldEntries.push(generateModelFieldEntry(fieldName, field));\n\treturn fieldEntries.length > 0 ? `{ ${fieldEntries.join(\"; \")} }` : \"Record<string, never>\";\n}\nfunction generateModelRelationsType(relations) {\n\tconst relationEntries = [];\n\tfor (const [relName, rel] of Object.entries(relations)) {\n\t\tif (typeof rel !== \"object\" || rel === null) continue;\n\t\tconst relObj = rel;\n\t\tconst toRef = relObj[\"to\"];\n\t\tif (toRef !== null && typeof toRef === \"object\" && \"space\" in toRef && toRef.space !== void 0) {\n\t\t\trelationEntries.push(`readonly ${serializeObjectKey(relName)}: never`);\n\t\t\tcontinue;\n\t\t}\n\t\tconst parts = [];\n\t\tif (toRef) parts.push(`readonly to: ${serializeCrossReference(blindCast(toRef))}`);\n\t\tif (relObj[\"cardinality\"]) parts.push(`readonly cardinality: ${serializeValue(relObj[\"cardinality\"])}`);\n\t\tif (typeof relObj[\"nullable\"] === \"boolean\") parts.push(`readonly nullable: ${relObj[\"nullable\"]}`);\n\t\tconst on = relObj[\"on\"];\n\t\tif (on && (!on.localFields || !on.targetFields)) throw emitterError(\"CONTRACT.RELATION_INVALID\", `Relation \"${relName}\" has an \"on\" block but is missing localFields or targetFields`, { meta: { relation: relName } });\n\t\tif (on?.localFields && on.targetFields) {\n\t\t\tconst localFields = on.localFields.map((f) => serializeValue(f)).join(\", \");\n\t\t\tconst targetFields = on.targetFields.map((f) => serializeValue(f)).join(\", \");\n\t\t\tparts.push(`readonly on: { readonly localFields: readonly [${localFields}]; readonly targetFields: readonly [${targetFields}] }`);\n\t\t}\n\t\tif (relObj[\"cardinality\"] === \"N:M\") {\n\t\t\tconst { through } = blindCast(relObj);\n\t\t\tconst table = serializeValue(through.table);\n\t\t\tconst namespaceId = serializeValue(through.namespaceId);\n\t\t\tconst parentColumns = through.parentColumns.map((c) => serializeValue(c)).join(\", \");\n\t\t\tconst childColumns = through.childColumns.map((c) => serializeValue(c)).join(\", \");\n\t\t\tconst targetColumns = through.targetColumns.map((c) => serializeValue(c)).join(\", \");\n\t\t\tparts.push(`readonly through: { readonly table: ${table}; readonly namespaceId: ${namespaceId}; readonly parentColumns: readonly [${parentColumns}]; readonly childColumns: readonly [${childColumns}]; readonly targetColumns: readonly [${targetColumns}] }`);\n\t\t}\n\t\tif (parts.length > 0) relationEntries.push(`readonly ${serializeObjectKey(relName)}: { ${parts.join(\"; \")} }`);\n\t}\n\tif (relationEntries.length === 0) return \"Record<string, never>\";\n\treturn `{ ${relationEntries.join(\"; \")} }`;\n}\nfunction generateModelsType(models, generateModelStorage) {\n\tif (!models || Object.keys(models).length === 0) return \"Record<string, never>\";\n\tconst modelTypes = [];\n\tfor (const [modelName, model] of Object.entries(models).sort(([a], [b]) => a.localeCompare(b))) {\n\t\tconst fieldsType = generateModelFieldsType(model.fields);\n\t\tconst relationsType = generateModelRelationsType(model.relations);\n\t\tconst storageType = generateModelStorage(modelName, model);\n\t\tconst modelParts = [\n\t\t\t`readonly fields: ${fieldsType}`,\n\t\t\t`readonly relations: ${relationsType}`,\n\t\t\t`readonly storage: ${storageType}`\n\t\t];\n\t\tif (model.owner) modelParts.push(`readonly owner: ${serializeValue(model.owner)}`);\n\t\tif (model.discriminator) modelParts.push(`readonly discriminator: ${serializeValue(model.discriminator)}`);\n\t\tif (model.variants) modelParts.push(`readonly variants: ${serializeValue(model.variants)}`);\n\t\tif (model.base) modelParts.push(`readonly base: ${serializeCrossReference(model.base)}`);\n\t\tmodelTypes.push(`readonly ${serializeObjectKey(modelName)}: { ${modelParts.join(\"; \")} }`);\n\t}\n\treturn `{ ${modelTypes.join(\"; \")} }`;\n}\nfunction deduplicateImports(imports) {\n\tconst seenKeys = /* @__PURE__ */ new Set();\n\tconst result = [];\n\tfor (const imp of imports) {\n\t\tconst key = `${imp.package}::${imp.named}`;\n\t\tif (!seenKeys.has(key)) {\n\t\t\tseenKeys.add(key);\n\t\t\tresult.push(imp);\n\t\t}\n\t}\n\treturn result;\n}\nfunction generateImportLines(imports, resolveImportSpecifier = keepInternalSpecifiers) {\n\tconst rendered = renderImports(imports.map((imp) => ({\n\t\tmoduleSpecifier: resolveImportSpecifier(imp.package),\n\t\tsymbol: imp.named,\n\t\talias: imp.alias,\n\t\ttypeOnly: true\n\t})));\n\treturn rendered === \"\" ? [] : rendered.split(\"\\n\");\n}\nfunction generateCodecTypeIntersection(imports, named) {\n\treturn imports.filter((imp) => imp.named === named).map((imp) => imp.alias).join(\" & \") || \"Record<string, never>\";\n}\nfunction serializeExecutionType(execution) {\n\tconst parts = [\"readonly executionHash: ExecutionHash\"];\n\tfor (const [key, value] of Object.entries(execution)) {\n\t\tif (key === \"executionHash\") continue;\n\t\tparts.push(`readonly ${serializeObjectKey(key)}: ${serializeValue(value)}`);\n\t}\n\treturn `{ ${parts.join(\"; \")} }`;\n}\nfunction generateHashTypeAliases(hashes) {\n\tconst executionHashType = hashes.executionHash ? `ExecutionHashBase<${serializeValue(hashes.executionHash)}>` : \"ExecutionHashBase<string>\";\n\treturn [\n\t\t`export type StorageHash = StorageHashBase<${serializeValue(hashes.storageHash)}>;`,\n\t\t`export type ExecutionHash = ${executionHashType};`,\n\t\t`export type ProfileHash = ProfileHashBase<${serializeValue(hashes.profileHash)}>;`\n\t].join(\"\\n\");\n}\nfunction applyModifiers(base, field) {\n\tlet result = base;\n\tif (field.many === true) result = `ReadonlyArray<${result}>`;\n\tif (field.dict === true) result = `Readonly<Record<string, ${result}>>`;\n\tif (field.nullable) result = `${result} | null`;\n\treturn result;\n}\n/**\n* Renders a value set (a field/column's permitted values, codec-encoded) into a TS literal union by\n* routing **each** value through the codec's `renderValueLiteral` — the seam owned by the codec, not\n* a generic serializer. `side`: `output` = read type, `input` = create/update type.\n*\n* Returns `undefined` — signalling the caller to fall back to the codec's full output type — when\n* the lookup is absent, has no `renderValueLiteralFor`, the value set is empty, or **any** value\n* isn't literal-expressible. A caller that needs column and field types to agree shares this so both\n* compute the union identically.\n*/\nfunction renderValueSetType(values, codecId, side, codecLookup) {\n\tif (values.length === 0 || codecLookup?.renderValueLiteralFor === void 0) return void 0;\n\tconst literals = [];\n\tfor (const value of values) {\n\t\tconst lit = codecLookup.renderValueLiteralFor(codecId, value, side);\n\t\tif (lit === void 0 || !isSafeTypeExpression(lit)) return void 0;\n\t\tliterals.push(lit);\n\t}\n\treturn literals.join(\" | \");\n}\nfunction resolveFieldType(field, codecLookup, resolvedTypeParams, resolvedValueSet) {\n\tconst { type } = field;\n\tswitch (type.kind) {\n\t\tcase \"scalar\": {\n\t\t\tif (resolvedValueSet) {\n\t\t\t\tconst output = renderValueSetType(resolvedValueSet.encodedValues, resolvedValueSet.codecId, \"output\", codecLookup);\n\t\t\t\tconst input = renderValueSetType(resolvedValueSet.encodedValues, resolvedValueSet.codecId, \"input\", codecLookup);\n\t\t\t\tif (output !== void 0 && input !== void 0) return {\n\t\t\t\t\toutput: applyModifiers(output, field),\n\t\t\t\t\tinput: applyModifiers(input, field)\n\t\t\t\t};\n\t\t\t}\n\t\t\tlet outputResolved;\n\t\t\tlet inputResolved;\n\t\t\tconst effectiveTypeParams = (type.typeParams && Object.keys(type.typeParams).length > 0 ? type.typeParams : void 0) ?? resolvedTypeParams;\n\t\t\tif (codecLookup && effectiveTypeParams && Object.keys(effectiveTypeParams).length > 0) {\n\t\t\t\tconst rendered = codecLookup.renderOutputTypeFor(type.codecId, effectiveTypeParams);\n\t\t\t\tif (rendered && isSafeTypeExpression(rendered)) outputResolved = rendered;\n\t\t\t\tconst renderedInput = codecLookup.renderInputTypeFor?.(type.codecId, effectiveTypeParams);\n\t\t\t\tif (renderedInput && isSafeTypeExpression(renderedInput)) inputResolved = renderedInput;\n\t\t\t}\n\t\t\tconst codecAccessor = `CodecTypes[${serializeValue(type.codecId)}]`;\n\t\t\treturn {\n\t\t\t\toutput: applyModifiers(outputResolved ?? `${codecAccessor}[\"output\"]`, field),\n\t\t\t\tinput: applyModifiers(inputResolved ?? `${codecAccessor}[\"input\"]`, field)\n\t\t\t};\n\t\t}\n\t\tcase \"valueObject\": return {\n\t\t\toutput: applyModifiers(`${type.name}Output`, field),\n\t\t\tinput: applyModifiers(`${type.name}Input`, field)\n\t\t};\n\t\tcase \"union\": {\n\t\t\tconst outputMembers = type.members.map((m) => m.kind === \"scalar\" ? `CodecTypes[${serializeValue(m.codecId)}][\"output\"]` : `${m.name}Output`);\n\t\t\tconst inputMembers = type.members.map((m) => m.kind === \"scalar\" ? `CodecTypes[${serializeValue(m.codecId)}][\"input\"]` : `${m.name}Input`);\n\t\t\treturn {\n\t\t\t\toutput: applyModifiers(outputMembers.join(\" | \"), field),\n\t\t\t\tinput: applyModifiers(inputMembers.join(\" | \"), field)\n\t\t\t};\n\t\t}\n\t\tdefault: return {\n\t\t\toutput: applyModifiers(\"unknown\", field),\n\t\t\tinput: applyModifiers(\"unknown\", field)\n\t\t};\n\t}\n}\nfunction generateFieldResolvedType(field, codecLookup, side = \"output\") {\n\treturn resolveFieldType(field, codecLookup)[side];\n}\n/**\n* Resolves one model field's input and output types the way `FieldOutputTypes` /\n* `FieldInputTypes` do: inline type params win over the family resolver, and a family-resolved\n* value set renders as a literal union.\n*/\nfunction resolveModelFieldType(modelName, fieldName, field, model, resolvers) {\n\tconst resolvedTypeParams = (field.type.kind === \"scalar\" && field.type.typeParams && Object.keys(field.type.typeParams).length > 0 ? field.type.typeParams : void 0) ?? resolvers.resolveFieldTypeParams?.(modelName, fieldName, model);\n\tconst resolvedValueSet = resolvers.resolveFieldValueSet?.(modelName, fieldName, model);\n\treturn resolveFieldType(field, resolvers.codecLookup, resolvedTypeParams, resolvedValueSet);\n}\nfunction generateBothFieldTypesMaps(models, codecLookup, resolveFieldTypeParams, resolveFieldValueSet) {\n\tif (!models || Object.keys(models).length === 0) return {\n\t\toutput: \"Record<string, never>\",\n\t\tinput: \"Record<string, never>\"\n\t};\n\tconst resolvers = {\n\t\tcodecLookup,\n\t\tresolveFieldTypeParams,\n\t\tresolveFieldValueSet\n\t};\n\tconst outputModelEntries = [];\n\tconst inputModelEntries = [];\n\tfor (const [modelName, model] of Object.entries(models).sort(([a], [b]) => a.localeCompare(b))) {\n\t\tif (!model) continue;\n\t\tconst outputFieldEntries = [];\n\t\tconst inputFieldEntries = [];\n\t\tfor (const [fieldName, field] of Object.entries(model.fields)) {\n\t\t\tconst resolved = resolveModelFieldType(modelName, fieldName, field, model, resolvers);\n\t\t\tconst key = `readonly ${serializeObjectKey(fieldName)}`;\n\t\t\toutputFieldEntries.push(`${key}: ${resolved.output}`);\n\t\t\tinputFieldEntries.push(`${key}: ${resolved.input}`);\n\t\t}\n\t\tconst outputFields = outputFieldEntries.length > 0 ? `{ ${outputFieldEntries.join(\"; \")} }` : \"Record<string, never>\";\n\t\tconst inputFields = inputFieldEntries.length > 0 ? `{ ${inputFieldEntries.join(\"; \")} }` : \"Record<string, never>\";\n\t\tconst modelKey = `readonly ${serializeObjectKey(modelName)}`;\n\t\toutputModelEntries.push(`${modelKey}: ${outputFields}`);\n\t\tinputModelEntries.push(`${modelKey}: ${inputFields}`);\n\t}\n\treturn {\n\t\toutput: `{ ${outputModelEntries.join(\"; \")} }`,\n\t\tinput: `{ ${inputModelEntries.join(\"; \")} }`\n\t};\n}\nfunction generateFieldTypesMapsByNamespace(namespaceModels, codecLookup, resolveFieldTypeParams, resolveFieldValueSet) {\n\tif (namespaceModels.length === 0) return {\n\t\toutput: \"Record<string, never>\",\n\t\tinput: \"Record<string, never>\"\n\t};\n\tconst outputNamespaceEntries = [];\n\tconst inputNamespaceEntries = [];\n\tfor (const [nsId, models] of namespaceModels) {\n\t\tconst inner = generateBothFieldTypesMaps(models, codecLookup, resolveFieldTypeParams, resolveFieldValueSet);\n\t\tconst nsKey = `readonly ${serializeObjectKey(nsId)}`;\n\t\toutputNamespaceEntries.push(`${nsKey}: ${inner.output}`);\n\t\tinputNamespaceEntries.push(`${nsKey}: ${inner.input}`);\n\t}\n\treturn {\n\t\toutput: `{ ${outputNamespaceEntries.join(\"; \")} }`,\n\t\tinput: `{ ${inputNamespaceEntries.join(\"; \")} }`\n\t};\n}\nfunction generateFieldOutputTypesMap(models, codecLookup, resolveFieldTypeParams) {\n\treturn generateBothFieldTypesMaps(models, codecLookup, resolveFieldTypeParams).output;\n}\nfunction generateFieldInputTypesMap(models, codecLookup, resolveFieldTypeParams) {\n\treturn generateBothFieldTypesMaps(models, codecLookup, resolveFieldTypeParams).input;\n}\nfunction generateValueObjectType(_voName, vo, _valueObjects, side = \"output\", codecLookup) {\n\treturn resolveValueObjectType(_voName, vo, _valueObjects, codecLookup)[side];\n}\nfunction resolveValueObjectType(_voName, vo, _valueObjects, codecLookup) {\n\tconst outputEntries = [];\n\tconst inputEntries = [];\n\tfor (const [fieldName, field] of Object.entries(vo.fields)) {\n\t\tconst resolved = resolveFieldType(field, codecLookup);\n\t\tconst key = `readonly ${serializeObjectKey(fieldName)}`;\n\t\toutputEntries.push(`${key}: ${resolved.output}`);\n\t\tinputEntries.push(`${key}: ${resolved.input}`);\n\t}\n\tconst empty = \"Record<string, never>\";\n\treturn {\n\t\toutput: outputEntries.length > 0 ? `{ ${outputEntries.join(\"; \")} }` : empty,\n\t\tinput: inputEntries.length > 0 ? `{ ${inputEntries.join(\"; \")} }` : empty\n\t};\n}\nfunction generateContractFieldDescriptor(fieldName, field) {\n\tconst mods = [];\n\tif (field.many === true) mods.push(\"; readonly many: true\");\n\tif (field.dict === true) mods.push(\"; readonly dict: true\");\n\tconst modStr = mods.join(\"\");\n\tconst { type } = field;\n\tif (type.kind === \"scalar\") {\n\t\tconst typeParamsSpec = type.typeParams && Object.keys(type.typeParams).length > 0 ? `; readonly typeParams: ${serializeValue(type.typeParams)}` : \"\";\n\t\treturn `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${field.nullable}; readonly type: { readonly kind: \"scalar\"; readonly codecId: ${serializeValue(type.codecId)}${typeParamsSpec} }${modStr} }`;\n\t}\n\tif (type.kind === \"valueObject\") return `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${field.nullable}; readonly type: { readonly kind: \"valueObject\"; readonly name: ${serializeValue(type.name)} }${modStr} }`;\n\treturn `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${field.nullable}; readonly type: ${serializeValue(type)}${modStr} }`;\n}\nfunction generateValueObjectsDescriptorType(valueObjects) {\n\tif (!valueObjects || Object.keys(valueObjects).length === 0) return \"Record<string, never>\";\n\tconst voEntries = [];\n\tfor (const [voName, vo] of Object.entries(valueObjects)) {\n\t\tconst fieldEntries = [];\n\t\tfor (const [fieldName, field] of Object.entries(vo.fields)) fieldEntries.push(generateContractFieldDescriptor(fieldName, field));\n\t\tconst fieldsType = fieldEntries.length > 0 ? `{ ${fieldEntries.join(\"; \")} }` : \"Record<string, never>\";\n\t\tvoEntries.push(`readonly ${serializeObjectKey(voName)}: { readonly fields: ${fieldsType} }`);\n\t}\n\treturn `{ ${voEntries.join(\"; \")} }`;\n}\nfunction generateValueObjectTypeAliases(valueObjects, codecLookup) {\n\tif (!valueObjects || Object.keys(valueObjects).length === 0) return \"\";\n\tconst aliases = [];\n\tfor (const [voName, vo] of Object.entries(valueObjects)) {\n\t\tconst resolved = resolveValueObjectType(voName, vo, valueObjects, codecLookup);\n\t\taliases.push(`export type ${voName}Output = ${resolved.output};`);\n\t\taliases.push(`export type ${voName}Input = ${resolved.input};`);\n\t}\n\treturn aliases.join(\"\\n\");\n}\n//#endregion\nexport { serializeCrossReference as C, serializeValue as D, serializeObjectKey as E, emitterError as O, resolveValueObjectType as S, serializeNamespaceId as T, generateValueObjectTypeAliases as _, generateFieldInputTypesMap as a, resolveFieldType as b, generateFieldTypesMapsByNamespace as c, generateModelFieldEntry as d, generateModelFieldsType as f, generateValueObjectType as g, generateRootsType as h, generateContractFieldDescriptor as i, generateHashTypeAliases as l, generateModelsType as m, generateBothFieldTypesMaps as n, generateFieldOutputTypesMap as o, generateModelRelationsType as p, generateCodecTypeIntersection as r, generateFieldResolvedType as s, deduplicateImports as t, generateImportLines as u, generateValueObjectsDescriptorType as v, serializeExecutionType as w, resolveModelFieldType as x, renderValueSetType as y };\n\n//# sourceMappingURL=domain-type-generation-CR9ECUau.mjs.map"],"mappings":";;;;;;AAMA,SAAS,aAAa,MAAM,SAAS,SAAS;CAC7C,OAAO,gBAAgB,MAAM,SAAS,OAAO;AAC9C;AAGA,SAAS,eAAe,OAAO;CAC9B,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,UAAU,KAAK,GAAG,OAAO;CAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,gBAAgB,KAAK;CAC3D,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW,OAAO,OAAO,KAAK;CAChF,IAAI,OAAO,UAAU,UAAU,OAAO,GAAG,MAAM;CAC/C,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,aAAa,MAAM,KAAK,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;CAC7F,IAAI,OAAO,UAAU,UAAU;EAC9B,MAAM,UAAU,CAAC;EACjB,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,KAAK,GAAG,QAAQ,KAAK,YAAY,mBAAmB,CAAC,EAAE,IAAI,eAAe,CAAC,GAAG;EAClH,OAAO,KAAK,QAAQ,KAAK,IAAI,EAAE;CAChC;CACA,OAAO;AACR;AACA,SAAS,mBAAmB,KAAK;CAChC,IAAI,qBAAqB,KAAK,GAAG,GAAG,OAAO;CAC3C,OAAO,eAAe,GAAG;AAC1B;AACA,SAAS,qBAAqB,OAAO;CACpC,OAAO,GAAG,eAAe,KAAK,EAAE;AACjC;AACA,SAAS,wBAAwB,KAAK;CACrC,OAAO,yBAAyB,qBAAqB,OAAO,IAAI,SAAS,CAAC,EAAE,oBAAoB,eAAe,IAAI,KAAK,IAAI,IAAI,UAAU,KAAK,IAAI,qBAAqB,eAAe,IAAI,KAAK,MAAM,GAAG;AAC1M;AACA,SAAS,kBAAkB,OAAO;CACjC,IAAI,CAAC,SAAS,OAAO,KAAK,KAAK,CAAC,CAAC,WAAW,GAAG,OAAO;CACtD,OAAO,KAAK,OAAO,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,YAAY,mBAAmB,GAAG,EAAE,IAAI,wBAAwB,KAAK,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE;AAC9I;AACA,SAAS,4BAA4B,OAAO;CAC3C,QAAQ,MAAM,SAAS,OAAO,0BAA0B,OAAO,MAAM,SAAS,OAAO,0BAA0B;AAChH;AACA,SAAS,wBAAwB,WAAW,OAAO;CAClD,MAAM,OAAO,4BAA4B,KAAK;CAC9C,MAAM,EAAE,UAAU,SAAS;CAC3B,IAAI,KAAK,SAAS,UAAU;EAC3B,MAAM,iBAAiB,KAAK,cAAc,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,0BAA0B,eAAe,KAAK,UAAU,MAAM;EAClJ,OAAO,YAAY,mBAAmB,SAAS,EAAE,yBAAyB,SAAS,gEAAgE,eAAe,KAAK,OAAO,IAAI,eAAe,IAAI,KAAK;CAC3M;CACA,IAAI,KAAK,SAAS,eAAe,OAAO,YAAY,mBAAmB,SAAS,EAAE,yBAAyB,SAAS,kEAAkE,eAAe,KAAK,IAAI,EAAE,IAAI,KAAK;CACzN,OAAO,YAAY,mBAAmB,SAAS,EAAE,yBAAyB,SAAS,mBAAmB,eAAe,IAAI,IAAI,KAAK;AACnI;AACA,SAAS,wBAAwB,QAAQ;CACxC,MAAM,eAAe,CAAC;CACtB,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,MAAM,GAAG,aAAa,KAAK,wBAAwB,WAAW,KAAK,CAAC;CACpH,OAAO,aAAa,SAAS,IAAI,KAAK,aAAa,KAAK,IAAI,EAAE,MAAM;AACrE;AACA,SAAS,2BAA2B,WAAW;CAC9C,MAAM,kBAAkB,CAAC;CACzB,KAAK,MAAM,CAAC,SAAS,QAAQ,OAAO,QAAQ,SAAS,GAAG;EACvD,IAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;EAC7C,MAAM,SAAS;EACf,MAAM,QAAQ,OAAO;EACrB,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAY,WAAW,SAAS,MAAM,UAAU,KAAK,GAAG;GAC9F,gBAAgB,KAAK,YAAY,mBAAmB,OAAO,EAAE,QAAQ;GACrE;EACD;EACA,MAAM,QAAQ,CAAC;EACf,IAAI,OAAO,MAAM,KAAK,gBAAgB,wBAAwB,UAAU,KAAK,CAAC,GAAG;EACjF,IAAI,OAAO,gBAAgB,MAAM,KAAK,yBAAyB,eAAe,OAAO,cAAc,GAAG;EACtG,IAAI,OAAO,OAAO,gBAAgB,WAAW,MAAM,KAAK,sBAAsB,OAAO,aAAa;EAClG,MAAM,KAAK,OAAO;EAClB,IAAI,OAAO,CAAC,GAAG,eAAe,CAAC,GAAG,eAAe,MAAM,aAAa,6BAA6B,aAAa,QAAQ,iEAAiE,EAAE,MAAM,EAAE,UAAU,QAAQ,EAAE,CAAC;EACtN,IAAI,IAAI,eAAe,GAAG,cAAc;GACvC,MAAM,cAAc,GAAG,YAAY,KAAK,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;GAC1E,MAAM,eAAe,GAAG,aAAa,KAAK,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;GAC5E,MAAM,KAAK,kDAAkD,YAAY,sCAAsC,aAAa,IAAI;EACjI;EACA,IAAI,OAAO,mBAAmB,OAAO;GACpC,MAAM,EAAE,YAAY,UAAU,MAAM;GACpC,MAAM,QAAQ,eAAe,QAAQ,KAAK;GAC1C,MAAM,cAAc,eAAe,QAAQ,WAAW;GACtD,MAAM,gBAAgB,QAAQ,cAAc,KAAK,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;GACnF,MAAM,eAAe,QAAQ,aAAa,KAAK,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;GACjF,MAAM,gBAAgB,QAAQ,cAAc,KAAK,MAAM,eAAe,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;GACnF,MAAM,KAAK,uCAAuC,MAAM,0BAA0B,YAAY,sCAAsC,cAAc,sCAAsC,aAAa,uCAAuC,cAAc,IAAI;EAC/P;EACA,IAAI,MAAM,SAAS,GAAG,gBAAgB,KAAK,YAAY,mBAAmB,OAAO,EAAE,MAAM,MAAM,KAAK,IAAI,EAAE,GAAG;CAC9G;CACA,IAAI,gBAAgB,WAAW,GAAG,OAAO;CACzC,OAAO,KAAK,gBAAgB,KAAK,IAAI,EAAE;AACxC;AACA,SAAS,mBAAmB,QAAQ,sBAAsB;CACzD,IAAI,CAAC,UAAU,OAAO,KAAK,MAAM,CAAC,CAAC,WAAW,GAAG,OAAO;CACxD,MAAM,aAAa,CAAC;CACpB,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,GAAG;EAC/F,MAAM,aAAa,wBAAwB,MAAM,MAAM;EACvD,MAAM,gBAAgB,2BAA2B,MAAM,SAAS;EAChE,MAAM,cAAc,qBAAqB,WAAW,KAAK;EACzD,MAAM,aAAa;GAClB,oBAAoB;GACpB,uBAAuB;GACvB,qBAAqB;EACtB;EACA,IAAI,MAAM,OAAO,WAAW,KAAK,mBAAmB,eAAe,MAAM,KAAK,GAAG;EACjF,IAAI,MAAM,eAAe,WAAW,KAAK,2BAA2B,eAAe,MAAM,aAAa,GAAG;EACzG,IAAI,MAAM,UAAU,WAAW,KAAK,sBAAsB,eAAe,MAAM,QAAQ,GAAG;EAC1F,IAAI,MAAM,MAAM,WAAW,KAAK,kBAAkB,wBAAwB,MAAM,IAAI,GAAG;EACvF,WAAW,KAAK,YAAY,mBAAmB,SAAS,EAAE,MAAM,WAAW,KAAK,IAAI,EAAE,GAAG;CAC1F;CACA,OAAO,KAAK,WAAW,KAAK,IAAI,EAAE;AACnC;AACA,SAAS,mBAAmB,SAAS;CACpC,MAAM,2BAA2B,IAAI,IAAI;CACzC,MAAM,SAAS,CAAC;CAChB,KAAK,MAAM,OAAO,SAAS;EAC1B,MAAM,MAAM,GAAG,IAAI,QAAQ,IAAI,IAAI;EACnC,IAAI,CAAC,SAAS,IAAI,GAAG,GAAG;GACvB,SAAS,IAAI,GAAG;GAChB,OAAO,KAAK,GAAG;EAChB;CACD;CACA,OAAO;AACR;AACA,SAAS,oBAAoB,SAAS,yBAAyB,wBAAwB;CACtF,MAAM,WAAW,cAAc,QAAQ,KAAK,SAAS;EACpD,iBAAiB,uBAAuB,IAAI,OAAO;EACnD,QAAQ,IAAI;EACZ,OAAO,IAAI;EACX,UAAU;CACX,EAAE,CAAC;CACH,OAAO,aAAa,KAAK,CAAC,IAAI,SAAS,MAAM,IAAI;AAClD;AACA,SAAS,8BAA8B,SAAS,OAAO;CACtD,OAAO,QAAQ,QAAQ,QAAQ,IAAI,UAAU,KAAK,CAAC,CAAC,KAAK,QAAQ,IAAI,KAAK,CAAC,CAAC,KAAK,KAAK,KAAK;AAC5F;AACA,SAAS,uBAAuB,WAAW;CAC1C,MAAM,QAAQ,CAAC,uCAAuC;CACtD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,GAAG;EACrD,IAAI,QAAQ,iBAAiB;EAC7B,MAAM,KAAK,YAAY,mBAAmB,GAAG,EAAE,IAAI,eAAe,KAAK,GAAG;CAC3E;CACA,OAAO,KAAK,MAAM,KAAK,IAAI,EAAE;AAC9B;AACA,SAAS,wBAAwB,QAAQ;CACxC,MAAM,oBAAoB,OAAO,gBAAgB,qBAAqB,eAAe,OAAO,aAAa,EAAE,KAAK;CAChH,OAAO;EACN,6CAA6C,eAAe,OAAO,WAAW,EAAE;EAChF,+BAA+B,kBAAkB;EACjD,6CAA6C,eAAe,OAAO,WAAW,EAAE;CACjF,CAAC,CAAC,KAAK,IAAI;AACZ;AACA,SAAS,eAAe,MAAM,OAAO;CACpC,IAAI,SAAS;CACb,IAAI,MAAM,SAAS,MAAM,SAAS,iBAAiB,OAAO;CAC1D,IAAI,MAAM,SAAS,MAAM,SAAS,2BAA2B,OAAO;CACpE,IAAI,MAAM,UAAU,SAAS,GAAG,OAAO;CACvC,OAAO;AACR;;;;;;;;;;;AAWA,SAAS,mBAAmB,QAAQ,SAAS,MAAM,aAAa;CAC/D,IAAI,OAAO,WAAW,KAAK,aAAa,0BAA0B,KAAK,GAAG,OAAO,KAAK;CACtF,MAAM,WAAW,CAAC;CAClB,KAAK,MAAM,SAAS,QAAQ;EAC3B,MAAM,MAAM,YAAY,sBAAsB,SAAS,OAAO,IAAI;EAClE,IAAI,QAAQ,KAAK,KAAK,CAAC,qBAAqB,GAAG,GAAG,OAAO,KAAK;EAC9D,SAAS,KAAK,GAAG;CAClB;CACA,OAAO,SAAS,KAAK,KAAK;AAC3B;AACA,SAAS,iBAAiB,OAAO,aAAa,oBAAoB,kBAAkB;CACnF,MAAM,EAAE,SAAS;CACjB,QAAQ,KAAK,MAAb;EACC,KAAK,UAAU;GACd,IAAI,kBAAkB;IACrB,MAAM,SAAS,mBAAmB,iBAAiB,eAAe,iBAAiB,SAAS,UAAU,WAAW;IACjH,MAAM,QAAQ,mBAAmB,iBAAiB,eAAe,iBAAiB,SAAS,SAAS,WAAW;IAC/G,IAAI,WAAW,KAAK,KAAK,UAAU,KAAK,GAAG,OAAO;KACjD,QAAQ,eAAe,QAAQ,KAAK;KACpC,OAAO,eAAe,OAAO,KAAK;IACnC;GACD;GACA,IAAI;GACJ,IAAI;GACJ,MAAM,uBAAuB,KAAK,cAAc,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,KAAK,aAAa,KAAK,MAAM;GACvH,IAAI,eAAe,uBAAuB,OAAO,KAAK,mBAAmB,CAAC,CAAC,SAAS,GAAG;IACtF,MAAM,WAAW,YAAY,oBAAoB,KAAK,SAAS,mBAAmB;IAClF,IAAI,YAAY,qBAAqB,QAAQ,GAAG,iBAAiB;IACjE,MAAM,gBAAgB,YAAY,qBAAqB,KAAK,SAAS,mBAAmB;IACxF,IAAI,iBAAiB,qBAAqB,aAAa,GAAG,gBAAgB;GAC3E;GACA,MAAM,gBAAgB,cAAc,eAAe,KAAK,OAAO,EAAE;GACjE,OAAO;IACN,QAAQ,eAAe,kBAAkB,GAAG,cAAc,aAAa,KAAK;IAC5E,OAAO,eAAe,iBAAiB,GAAG,cAAc,YAAY,KAAK;GAC1E;EACD;EACA,KAAK,eAAe,OAAO;GAC1B,QAAQ,eAAe,GAAG,KAAK,KAAK,SAAS,KAAK;GAClD,OAAO,eAAe,GAAG,KAAK,KAAK,QAAQ,KAAK;EACjD;EACA,KAAK,SAAS;GACb,MAAM,gBAAgB,KAAK,QAAQ,KAAK,MAAM,EAAE,SAAS,WAAW,cAAc,eAAe,EAAE,OAAO,EAAE,eAAe,GAAG,EAAE,KAAK,OAAO;GAC5I,MAAM,eAAe,KAAK,QAAQ,KAAK,MAAM,EAAE,SAAS,WAAW,cAAc,eAAe,EAAE,OAAO,EAAE,cAAc,GAAG,EAAE,KAAK,MAAM;GACzI,OAAO;IACN,QAAQ,eAAe,cAAc,KAAK,KAAK,GAAG,KAAK;IACvD,OAAO,eAAe,aAAa,KAAK,KAAK,GAAG,KAAK;GACtD;EACD;EACA,SAAS,OAAO;GACf,QAAQ,eAAe,WAAW,KAAK;GACvC,OAAO,eAAe,WAAW,KAAK;EACvC;CACD;AACD;AACA,SAAS,0BAA0B,OAAO,aAAa,OAAO,UAAU;CACvE,OAAO,iBAAiB,OAAO,WAAW,CAAC,CAAC;AAC7C;;;;;;AAMA,SAAS,sBAAsB,WAAW,WAAW,OAAO,OAAO,WAAW;CAC7E,MAAM,sBAAsB,MAAM,KAAK,SAAS,YAAY,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,MAAM,KAAK,aAAa,KAAK,MAAM,UAAU,yBAAyB,WAAW,WAAW,KAAK;CACtO,MAAM,mBAAmB,UAAU,uBAAuB,WAAW,WAAW,KAAK;CACrF,OAAO,iBAAiB,OAAO,UAAU,aAAa,oBAAoB,gBAAgB;AAC3F;AACA,SAAS,2BAA2B,QAAQ,aAAa,wBAAwB,sBAAsB;CACtG,IAAI,CAAC,UAAU,OAAO,KAAK,MAAM,CAAC,CAAC,WAAW,GAAG,OAAO;EACvD,QAAQ;EACR,OAAO;CACR;CACA,MAAM,YAAY;EACjB;EACA;EACA;CACD;CACA,MAAM,qBAAqB,CAAC;CAC5B,MAAM,oBAAoB,CAAC;CAC3B,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,GAAG;EAC/F,IAAI,CAAC,OAAO;EACZ,MAAM,qBAAqB,CAAC;EAC5B,MAAM,oBAAoB,CAAC;EAC3B,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,MAAM,MAAM,GAAG;GAC9D,MAAM,WAAW,sBAAsB,WAAW,WAAW,OAAO,OAAO,SAAS;GACpF,MAAM,MAAM,YAAY,mBAAmB,SAAS;GACpD,mBAAmB,KAAK,GAAG,IAAI,IAAI,SAAS,QAAQ;GACpD,kBAAkB,KAAK,GAAG,IAAI,IAAI,SAAS,OAAO;EACnD;EACA,MAAM,eAAe,mBAAmB,SAAS,IAAI,KAAK,mBAAmB,KAAK,IAAI,EAAE,MAAM;EAC9F,MAAM,cAAc,kBAAkB,SAAS,IAAI,KAAK,kBAAkB,KAAK,IAAI,EAAE,MAAM;EAC3F,MAAM,WAAW,YAAY,mBAAmB,SAAS;EACzD,mBAAmB,KAAK,GAAG,SAAS,IAAI,cAAc;EACtD,kBAAkB,KAAK,GAAG,SAAS,IAAI,aAAa;CACrD;CACA,OAAO;EACN,QAAQ,KAAK,mBAAmB,KAAK,IAAI,EAAE;EAC3C,OAAO,KAAK,kBAAkB,KAAK,IAAI,EAAE;CAC1C;AACD;AACA,SAAS,kCAAkC,iBAAiB,aAAa,wBAAwB,sBAAsB;CACtH,IAAI,gBAAgB,WAAW,GAAG,OAAO;EACxC,QAAQ;EACR,OAAO;CACR;CACA,MAAM,yBAAyB,CAAC;CAChC,MAAM,wBAAwB,CAAC;CAC/B,KAAK,MAAM,CAAC,MAAM,WAAW,iBAAiB;EAC7C,MAAM,QAAQ,2BAA2B,QAAQ,aAAa,wBAAwB,oBAAoB;EAC1G,MAAM,QAAQ,YAAY,mBAAmB,IAAI;EACjD,uBAAuB,KAAK,GAAG,MAAM,IAAI,MAAM,QAAQ;EACvD,sBAAsB,KAAK,GAAG,MAAM,IAAI,MAAM,OAAO;CACtD;CACA,OAAO;EACN,QAAQ,KAAK,uBAAuB,KAAK,IAAI,EAAE;EAC/C,OAAO,KAAK,sBAAsB,KAAK,IAAI,EAAE;CAC9C;AACD;AACA,SAAS,4BAA4B,QAAQ,aAAa,wBAAwB;CACjF,OAAO,2BAA2B,QAAQ,aAAa,sBAAsB,CAAC,CAAC;AAChF;AACA,SAAS,2BAA2B,QAAQ,aAAa,wBAAwB;CAChF,OAAO,2BAA2B,QAAQ,aAAa,sBAAsB,CAAC,CAAC;AAChF;AACA,SAAS,wBAAwB,SAAS,IAAI,eAAe,OAAO,UAAU,aAAa;CAC1F,OAAO,uBAAuB,SAAS,IAAI,eAAe,WAAW,CAAC,CAAC;AACxE;AACA,SAAS,uBAAuB,SAAS,IAAI,eAAe,aAAa;CACxE,MAAM,gBAAgB,CAAC;CACvB,MAAM,eAAe,CAAC;CACtB,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,MAAM,GAAG;EAC3D,MAAM,WAAW,iBAAiB,OAAO,WAAW;EACpD,MAAM,MAAM,YAAY,mBAAmB,SAAS;EACpD,cAAc,KAAK,GAAG,IAAI,IAAI,SAAS,QAAQ;EAC/C,aAAa,KAAK,GAAG,IAAI,IAAI,SAAS,OAAO;CAC9C;CACA,MAAM,QAAQ;CACd,OAAO;EACN,QAAQ,cAAc,SAAS,IAAI,KAAK,cAAc,KAAK,IAAI,EAAE,MAAM;EACvE,OAAO,aAAa,SAAS,IAAI,KAAK,aAAa,KAAK,IAAI,EAAE,MAAM;CACrE;AACD;AACA,SAAS,gCAAgC,WAAW,OAAO;CAC1D,MAAM,OAAO,CAAC;CACd,IAAI,MAAM,SAAS,MAAM,KAAK,KAAK,uBAAuB;CAC1D,IAAI,MAAM,SAAS,MAAM,KAAK,KAAK,uBAAuB;CAC1D,MAAM,SAAS,KAAK,KAAK,EAAE;CAC3B,MAAM,EAAE,SAAS;CACjB,IAAI,KAAK,SAAS,UAAU;EAC3B,MAAM,iBAAiB,KAAK,cAAc,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,0BAA0B,eAAe,KAAK,UAAU,MAAM;EAClJ,OAAO,YAAY,mBAAmB,SAAS,EAAE,yBAAyB,MAAM,SAAS,gEAAgE,eAAe,KAAK,OAAO,IAAI,eAAe,IAAI,OAAO;CACnN;CACA,IAAI,KAAK,SAAS,eAAe,OAAO,YAAY,mBAAmB,SAAS,EAAE,yBAAyB,MAAM,SAAS,kEAAkE,eAAe,KAAK,IAAI,EAAE,IAAI,OAAO;CACjO,OAAO,YAAY,mBAAmB,SAAS,EAAE,yBAAyB,MAAM,SAAS,mBAAmB,eAAe,IAAI,IAAI,OAAO;AAC3I;AACA,SAAS,mCAAmC,cAAc;CACzD,IAAI,CAAC,gBAAgB,OAAO,KAAK,YAAY,CAAC,CAAC,WAAW,GAAG,OAAO;CACpE,MAAM,YAAY,CAAC;CACnB,KAAK,MAAM,CAAC,QAAQ,OAAO,OAAO,QAAQ,YAAY,GAAG;EACxD,MAAM,eAAe,CAAC;EACtB,KAAK,MAAM,CAAC,WAAW,UAAU,OAAO,QAAQ,GAAG,MAAM,GAAG,aAAa,KAAK,gCAAgC,WAAW,KAAK,CAAC;EAC/H,MAAM,aAAa,aAAa,SAAS,IAAI,KAAK,aAAa,KAAK,IAAI,EAAE,MAAM;EAChF,UAAU,KAAK,YAAY,mBAAmB,MAAM,EAAE,uBAAuB,WAAW,GAAG;CAC5F;CACA,OAAO,KAAK,UAAU,KAAK,IAAI,EAAE;AAClC;AACA,SAAS,+BAA+B,cAAc,aAAa;CAClE,IAAI,CAAC,gBAAgB,OAAO,KAAK,YAAY,CAAC,CAAC,WAAW,GAAG,OAAO;CACpE,MAAM,UAAU,CAAC;CACjB,KAAK,MAAM,CAAC,QAAQ,OAAO,OAAO,QAAQ,YAAY,GAAG;EACxD,MAAM,WAAW,uBAAuB,QAAQ,IAAI,cAAc,WAAW;EAC7E,QAAQ,KAAK,eAAe,OAAO,WAAW,SAAS,OAAO,EAAE;EAChE,QAAQ,KAAK,eAAe,OAAO,UAAU,SAAS,MAAM,EAAE;CAC/D;CACA,OAAO,QAAQ,KAAK,IAAI;AACzB"}