@prisma/orm-toolchain 0.16.0-dev.36

package/dist/migration-B2ljMJim.d.mts

@@ -0,0 +1,155 @@
+import { t as MigrationMetadata$1 } from "./metadata-2nbOAGsV-uYNeq2Cp.mjs";
+import { ControlStack, MigrationPlan, MigrationPlanOperation } from "@prisma/orm-framework/components/control";
+import { Contract } from "@prisma/orm-framework/contract/types";
+//#region ../../../1-framework/3-tooling/migration/dist/exports/migration.d.mts
+//#region src/migration-base.d.ts
+interface MigrationMeta {
+  readonly from: string | null;
+  readonly to: string;
+}
+/**
+ * Base class for migrations.
+ *
+ * A `Migration` subclass is itself a `MigrationPlan`: CLI commands and the
+ * runner can consume it directly via `targetId`, `operations`, `origin`, and
+ * `destination`.
+ *
+ * The from/to identities come from `describe()`. A migration provides them in
+ * one of two ways:
+ *  - **Contract-derived (default):** assign the `contract.json` imports from
+ *    the snapshot store (`migrations/snapshots/<hex>/contract.json`) to
+ *    `startContractJson` / `endContractJson`; the concrete `describe()` below
+ *    derives `to`/`from` from their
+ *    `storage.storageHash`. The family bases additionally expose typed view
+ *    getters (`startContract` / `endContract`) over the same JSON.
+ *  - **Override (e.g. extension migrations that carry no contract):** override
+ *    `describe()` directly; the override wins and the JSON fields are unused.
+ *
+ * The `Start` / `End` generics carry each migration's precise contract types so
+ * the family-base view getters resolve to fully-typed views.
+ */
+declare abstract class Migration<_TOperation extends MigrationPlanOperation = MigrationPlanOperation, TFamilyId extends string = string, TTargetId extends string = string, _Start extends Contract = Contract, _End extends Contract = Contract> implements MigrationPlan {
+  abstract readonly targetId: string;
+  /**
+   * The migration's end-state contract JSON (the `contract.json` import from
+   * the snapshot store). When set, the derived `describe()` reads `to` from its
+   * `storage.storageHash`. Family bases build the typed `endContract` view from
+   * it. Optional so `describe()`-overriding migrations (no contract) compile.
+   *
+   * Typed with a plain `storageHash: string`, not the branded
+   * `StorageHashBase`, so a raw `contract.json` import — whose `storageHash`
+   * is an untyped string literal — is assignable without a cast. The full
+   * `Start`/`End` contract typing is applied downstream in the family bases'
+   * view getters (via `<Family>ContractView.fromJson<…>`).
+   */
+  readonly endContractJson?: {
+    readonly storage: {
+      readonly storageHash: string;
+    };
+  };
+  /**
+   * The migration's start-state contract JSON (the `contract.json` import
+   * from the snapshot store). Absent for a baseline migration (`from`
+   * derives to `null`). Family bases build the typed `startContract` view from
+   * it.
+   */
+  readonly startContractJson?: {
+    readonly storage: {
+      readonly storageHash: string;
+    };
+  };
+  /**
+   * Assembled `ControlStack` injected by the orchestrator (`runMigration`).
+   *
+   * Subclasses (e.g. `PostgresMigration`) read the stack to materialize their
+   * adapter once per instance. Optional at the abstract level so unit tests can
+   * construct `Migration` instances purely for `operations` / `describe`
+   * assertions without needing a real stack; concrete subclasses that need the
+   * stack at runtime should narrow the parameter to required.
+   */
+  protected readonly stack: ControlStack<TFamilyId, TTargetId> | undefined;
+  constructor(stack?: ControlStack<TFamilyId, TTargetId>);
+  /**
+   * Ordered list of operations this migration performs.
+   *
+   * Implemented as a getter so that subclasses can either precompute the list
+   * in their constructor or build it lazily per access. Entries may be Promises
+   * when the target requires async codec resolution (e.g. DDL literal defaults).
+   */
+  abstract get operations(): readonly (MigrationPlanOperation | Promise<MigrationPlanOperation>)[];
+  /**
+   * Metadata inputs used to build `migration.json` and to derive the plan's
+   * origin/destination identities.
+   *
+   * Default derivation: `to = endContractJson.storage.storageHash`,
+   * `from = startContractJson?.storage.storageHash ?? null`. A migration that
+   * carries no contract JSON (e.g. an extension migration) must override this;
+   * otherwise it throws, since `migration.json` requires a `to` identity.
+   */
+  describe(): MigrationMeta;
+  get origin(): {
+    readonly storageHash: string;
+  } | null;
+  get destination(): {
+    readonly storageHash: string;
+  };
+}
+/**
+ * Lazy-memoized `endContract` / `startContract` view accessors, one instance
+ * held per migration. Each target base (`MongoMigration`, `SqliteMigration`,
+ * `PostgresMigration`) creates one `MigrationContractViews` field from
+ * `this` — passing its own `<Family>ContractView.fromJson<…>` as `fromJson`
+ * and a name for error messages — and forwards its
+ * `endContract`/`startContract` getters to it.
+ *
+ * `endContract` throws `MIGRATION.CONTRACT_VIEW_MISSING` when the migration
+ * has no `endContractJson` (mirrors `describe()`'s own requirement).
+ * `startContract` returns `null` for a baseline migration (no
+ * `startContractJson`) instead of throwing.
+ */
+declare class MigrationContractViews<TView> {
+  #private;
+  private readonly migration;
+  private readonly className;
+  private readonly fromJson;
+  constructor(migration: Migration, className: string, fromJson: (json: unknown) => TView);
+  get endContract(): TView;
+  get startContract(): TView | null;
+}
+/**
+ * Returns true when `import.meta.url` resolves to the same file that was
+ * invoked as the node entrypoint (`process.argv[1]`). Used by
+ * `MigrationCLI.run` (in `@internal/cli/migration-cli`) to no-op when
+ * the migration module is being imported (e.g. by another script) rather
+ * than executed directly.
+ */
+declare function isDirectEntrypoint(importMetaUrl: string): boolean;
+/**
+ * In-memory artifacts produced from a `Migration` instance: the
+ * serialized `ops.json` body, the `migration.json` metadata object, and
+ * its serialized form. Returned by `buildMigrationArtifacts` so callers
+ * (today: `MigrationCLI.run` in `@internal/cli/migration-cli`) can
+ * decide how to persist them — write to disk, print in dry-run, ship
+ * over the wire — without coupling artifact construction to file I/O.
+ *
+ * `metadataJson` is `JSON.stringify(metadata, null, 2)` — the canonical
+ * on-disk shape that the arktype loader-schema in `./io` validates.
+ */
+interface MigrationArtifacts {
+  readonly opsJson: string;
+  readonly metadata: MigrationMetadata$1;
+  readonly metadataJson: string;
+}
+/**
+ * Pure conversion from a `Migration` instance (plus the previously
+ * scaffolded metadata, when one exists on disk) to the in-memory
+ * artifacts that downstream tooling persists. Owns metadata validation,
+ * metadata synthesis/preservation, and the content-addressed
+ * `migrationHash` computation, but performs no file I/O — callers handle
+ * reads (to source `existing`) and writes (to persist `opsJson` /
+ * `metadataJson`).
+ */
+declare function buildMigrationArtifacts(instance: Migration, existing: Partial<MigrationMetadata$1> | null): Promise<MigrationArtifacts>;
+//#endregion
+export { buildMigrationArtifacts as a, MigrationMeta as i, MigrationArtifacts as n, isDirectEntrypoint as o, MigrationContractViews as r, Migration as t };
+//# sourceMappingURL=migration-B2ljMJim.d.mts.map

package/dist/migration-B2ljMJim.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-B2ljMJim.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/migration/dist/exports/migration.d.mts"],"mappings":";;;;;UAIU;WACC;WACA;;;;;;;;;;;;;;;;;;;;;;;uBAuBY,UAAU,oBAAoB,yBAAyB,wBAAwB,mCAAmC,mCAAmC,eAAe,WAAW,UAAU,aAAa,WAAW,qBAAqB;oBACzO;;;;;;;;;;;;;WAaT;aACE;eACE;;;;;;;;;WASJ;aACE;eACE;;;;;;;;;;;;qBAYM,OAAO,aAAa,WAAW;EAClD,YAAY,QAAQ,aAAa,WAAW;;;;;;;;eAQ/B,wBAAwB,yBAAyB,QAAQ;;;;;;;;;;EAUtE,YAAY;MACR;aACO;;MAEP;aACO;;;;;;;;;;;;;;;;cAgBC,uBAAuB;;mBAElB;mBACA;mBACA;EACjB,YAAY,WAAW,WAAW,mBAAmB,WAAW,kBAAkB;MAC9E,eAAe;MACf,iBAAiB;;;;;;;;;iBASN,mBAAmB;;;;;;;;;;;;UAY1B;WACC;WACA,UAAU;WACV;;;;;;;;;;;iBAWM,wBAAwB,UAAU,WAAW,UAAU,QAAQ,8BAA8B,QAAQ"}

package/dist/migration-BuUmO7It.mjs

@@ -0,0 +1,209 @@
+import { A as errorOperationsNotArray, c as errorDescribeMissingEndContract, s as errorDescribeInvalidMetadata, v as errorInvalidOperationEntry, w as errorMigrationContractViewMissing } from "./errors-IpZm1Skp-BH495dRd.mjs";
+import { t as computeMigrationHash } from "./hash-DH8hl5Rq-BpM2t3Nu.mjs";
+import { t as deriveProvidedInvariants } from "./invariants-lXzy6txi-DAoP4nTE.mjs";
+import { t as MigrationOpSchema } from "./op-schema-BSVHzEQN-DIWt28D8.mjs";
+import { type } from "arktype";
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region ../../../1-framework/3-tooling/migration/dist/exports/migration.mjs
+const MigrationMetaSchema = type({
+	from: "string > 0 | null",
+	to: "string"
+});
+/**
+* Base class for migrations.
+*
+* A `Migration` subclass is itself a `MigrationPlan`: CLI commands and the
+* runner can consume it directly via `targetId`, `operations`, `origin`, and
+* `destination`.
+*
+* The from/to identities come from `describe()`. A migration provides them in
+* one of two ways:
+*  - **Contract-derived (default):** assign the `contract.json` imports from
+*    the snapshot store (`migrations/snapshots/<hex>/contract.json`) to
+*    `startContractJson` / `endContractJson`; the concrete `describe()` below
+*    derives `to`/`from` from their
+*    `storage.storageHash`. The family bases additionally expose typed view
+*    getters (`startContract` / `endContract`) over the same JSON.
+*  - **Override (e.g. extension migrations that carry no contract):** override
+*    `describe()` directly; the override wins and the JSON fields are unused.
+*
+* The `Start` / `End` generics carry each migration's precise contract types so
+* the family-base view getters resolve to fully-typed views.
+*/
+var Migration = class {
+	/**
+	* The migration's end-state contract JSON (the `contract.json` import from
+	* the snapshot store). When set, the derived `describe()` reads `to` from its
+	* `storage.storageHash`. Family bases build the typed `endContract` view from
+	* it. Optional so `describe()`-overriding migrations (no contract) compile.
+	*
+	* Typed with a plain `storageHash: string`, not the branded
+	* `StorageHashBase`, so a raw `contract.json` import — whose `storageHash`
+	* is an untyped string literal — is assignable without a cast. The full
+	* `Start`/`End` contract typing is applied downstream in the family bases'
+	* view getters (via `<Family>ContractView.fromJson<…>`).
+	*/
+	endContractJson;
+	/**
+	* The migration's start-state contract JSON (the `contract.json` import
+	* from the snapshot store). Absent for a baseline migration (`from`
+	* derives to `null`). Family bases build the typed `startContract` view from
+	* it.
+	*/
+	startContractJson;
+	/**
+	* Assembled `ControlStack` injected by the orchestrator (`runMigration`).
+	*
+	* Subclasses (e.g. `PostgresMigration`) read the stack to materialize their
+	* adapter once per instance. Optional at the abstract level so unit tests can
+	* construct `Migration` instances purely for `operations` / `describe`
+	* assertions without needing a real stack; concrete subclasses that need the
+	* stack at runtime should narrow the parameter to required.
+	*/
+	stack;
+	constructor(stack) {
+		this.stack = stack;
+	}
+	/**
+	* Metadata inputs used to build `migration.json` and to derive the plan's
+	* origin/destination identities.
+	*
+	* Default derivation: `to = endContractJson.storage.storageHash`,
+	* `from = startContractJson?.storage.storageHash ?? null`. A migration that
+	* carries no contract JSON (e.g. an extension migration) must override this;
+	* otherwise it throws, since `migration.json` requires a `to` identity.
+	*/
+	describe() {
+		const end = this.endContractJson;
+		if (end === void 0) throw errorDescribeMissingEndContract();
+		return {
+			from: this.startContractJson?.storage.storageHash ?? null,
+			to: end.storage.storageHash
+		};
+	}
+	get origin() {
+		const from = this.describe().from;
+		return from === null ? null : { storageHash: from };
+	}
+	get destination() {
+		return { storageHash: this.describe().to };
+	}
+};
+/**
+* Lazy-memoized `endContract` / `startContract` view accessors, one instance
+* held per migration. Each target base (`MongoMigration`, `SqliteMigration`,
+* `PostgresMigration`) creates one `MigrationContractViews` field from
+* `this` — passing its own `<Family>ContractView.fromJson<…>` as `fromJson`
+* and a name for error messages — and forwards its
+* `endContract`/`startContract` getters to it.
+*
+* `endContract` throws `MIGRATION.CONTRACT_VIEW_MISSING` when the migration
+* has no `endContractJson` (mirrors `describe()`'s own requirement).
+* `startContract` returns `null` for a baseline migration (no
+* `startContractJson`) instead of throwing.
+*/
+var MigrationContractViews = class {
+	migration;
+	className;
+	fromJson;
+	#endView;
+	#startView;
+	constructor(migration, className, fromJson) {
+		this.migration = migration;
+		this.className = className;
+		this.fromJson = fromJson;
+	}
+	get endContract() {
+		if (this.#endView === void 0) {
+			const json = this.migration.endContractJson;
+			if (json === void 0) throw errorMigrationContractViewMissing(this.className, "endContract", "endContractJson");
+			this.#endView = this.fromJson(json);
+		}
+		return this.#endView;
+	}
+	get startContract() {
+		if (this.#startView === void 0) {
+			const json = this.migration.startContractJson;
+			this.#startView = json === void 0 ? null : this.fromJson(json);
+		}
+		return this.#startView;
+	}
+};
+/**
+* Returns true when `import.meta.url` resolves to the same file that was
+* invoked as the node entrypoint (`process.argv[1]`). Used by
+* `MigrationCLI.run` (in `@internal/cli/migration-cli`) to no-op when
+* the migration module is being imported (e.g. by another script) rather
+* than executed directly.
+*/
+function isDirectEntrypoint(importMetaUrl) {
+	const metaFilename = fileURLToPath(importMetaUrl);
+	const argv1 = process.argv[1];
+	if (!argv1) return false;
+	try {
+		return realpathSync(metaFilename) === realpathSync(argv1);
+	} catch {
+		return false;
+	}
+}
+/**
+* Build the attested metadata from `describe()`-derived metadata, the
+* operations list, and the previously-scaffolded metadata (if any).
+*
+* When a `migration.json` already exists for this package (the common
+* case: it was scaffolded by `migration plan`), preserve `createdAt`
+* set there — that field is owned by the CLI scaffolder, not the authored
+* class. Only the `describe()`-derived fields (`from`, `to`) and the
+* operations change as the author iterates. When no metadata exists yet
+* (a bare `migration.ts` run from scratch), synthesize a minimal but
+* schema-conformant record so the resulting package can still be read,
+* verified, and applied.
+*
+* The `migrationHash` is recomputed against the current metadata + ops so
+* the on-disk artifacts are always fully attested.
+*/
+function buildAttestedMetadata(meta, ops, existing) {
+	const baseMetadata = {
+		from: meta.from,
+		to: meta.to,
+		providedInvariants: deriveProvidedInvariants(ops),
+		createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const migrationHash = computeMigrationHash(baseMetadata, ops);
+	return {
+		...baseMetadata,
+		migrationHash
+	};
+}
+/**
+* Pure conversion from a `Migration` instance (plus the previously
+* scaffolded metadata, when one exists on disk) to the in-memory
+* artifacts that downstream tooling persists. Owns metadata validation,
+* metadata synthesis/preservation, and the content-addressed
+* `migrationHash` computation, but performs no file I/O — callers handle
+* reads (to source `existing`) and writes (to persist `opsJson` /
+* `metadataJson`).
+*/
+async function buildMigrationArtifacts(instance, existing) {
+	const rawOps = instance.operations;
+	if (!Array.isArray(rawOps)) throw errorOperationsNotArray();
+	const ops = await Promise.all(rawOps);
+	for (let index = 0; index < ops.length; index++) {
+		const result = MigrationOpSchema(ops[index]);
+		if (result instanceof type.errors) throw errorInvalidOperationEntry(index, result.summary);
+	}
+	const rawMeta = instance.describe();
+	const parsed = MigrationMetaSchema(rawMeta);
+	if (parsed instanceof type.errors) throw errorDescribeInvalidMetadata(parsed.summary);
+	const metadata = buildAttestedMetadata(parsed, ops, existing);
+	return {
+		opsJson: JSON.stringify(ops, null, 2),
+		metadata,
+		metadataJson: JSON.stringify(metadata, null, 2)
+	};
+}
+//#endregion
+export { isDirectEntrypoint as i, MigrationContractViews as n, buildMigrationArtifacts as r, Migration as t };
+
+//# sourceMappingURL=migration-BuUmO7It.mjs.map

package/dist/migration-BuUmO7It.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-BuUmO7It.mjs","names":["#endView","#startView"],"sources":["../../../../1-framework/3-tooling/migration/dist/exports/migration.mjs"],"sourcesContent":["import { A as errorOperationsNotArray, c as errorDescribeMissingEndContract, s as errorDescribeInvalidMetadata, v as errorInvalidOperationEntry, w as errorMigrationContractViewMissing } from \"../errors-IpZm1Skp.mjs\";\nimport { t as computeMigrationHash } from \"../hash-DH8hl5Rq.mjs\";\nimport { t as deriveProvidedInvariants } from \"../invariants-lXzy6txi.mjs\";\nimport { t as MigrationOpSchema } from \"../op-schema-BSVHzEQN.mjs\";\nimport { type } from \"arktype\";\nimport { realpathSync } from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\n//#region src/migration-base.ts\nconst MigrationMetaSchema = type({\n\tfrom: \"string > 0 | null\",\n\tto: \"string\"\n});\n/**\n* Base class for migrations.\n*\n* A `Migration` subclass is itself a `MigrationPlan`: CLI commands and the\n* runner can consume it directly via `targetId`, `operations`, `origin`, and\n* `destination`.\n*\n* The from/to identities come from `describe()`. A migration provides them in\n* one of two ways:\n*  - **Contract-derived (default):** assign the `contract.json` imports from\n*    the snapshot store (`migrations/snapshots/<hex>/contract.json`) to\n*    `startContractJson` / `endContractJson`; the concrete `describe()` below\n*    derives `to`/`from` from their\n*    `storage.storageHash`. The family bases additionally expose typed view\n*    getters (`startContract` / `endContract`) over the same JSON.\n*  - **Override (e.g. extension migrations that carry no contract):** override\n*    `describe()` directly; the override wins and the JSON fields are unused.\n*\n* The `Start` / `End` generics carry each migration's precise contract types so\n* the family-base view getters resolve to fully-typed views.\n*/\nvar Migration = class {\n\t/**\n\t* The migration's end-state contract JSON (the `contract.json` import from\n\t* the snapshot store). When set, the derived `describe()` reads `to` from its\n\t* `storage.storageHash`. Family bases build the typed `endContract` view from\n\t* it. Optional so `describe()`-overriding migrations (no contract) compile.\n\t*\n\t* Typed with a plain `storageHash: string`, not the branded\n\t* `StorageHashBase`, so a raw `contract.json` import — whose `storageHash`\n\t* is an untyped string literal — is assignable without a cast. The full\n\t* `Start`/`End` contract typing is applied downstream in the family bases'\n\t* view getters (via `<Family>ContractView.fromJson<…>`).\n\t*/\n\tendContractJson;\n\t/**\n\t* The migration's start-state contract JSON (the `contract.json` import\n\t* from the snapshot store). Absent for a baseline migration (`from`\n\t* derives to `null`). Family bases build the typed `startContract` view from\n\t* it.\n\t*/\n\tstartContractJson;\n\t/**\n\t* Assembled `ControlStack` injected by the orchestrator (`runMigration`).\n\t*\n\t* Subclasses (e.g. `PostgresMigration`) read the stack to materialize their\n\t* adapter once per instance. Optional at the abstract level so unit tests can\n\t* construct `Migration` instances purely for `operations` / `describe`\n\t* assertions without needing a real stack; concrete subclasses that need the\n\t* stack at runtime should narrow the parameter to required.\n\t*/\n\tstack;\n\tconstructor(stack) {\n\t\tthis.stack = stack;\n\t}\n\t/**\n\t* Metadata inputs used to build `migration.json` and to derive the plan's\n\t* origin/destination identities.\n\t*\n\t* Default derivation: `to = endContractJson.storage.storageHash`,\n\t* `from = startContractJson?.storage.storageHash ?? null`. A migration that\n\t* carries no contract JSON (e.g. an extension migration) must override this;\n\t* otherwise it throws, since `migration.json` requires a `to` identity.\n\t*/\n\tdescribe() {\n\t\tconst end = this.endContractJson;\n\t\tif (end === void 0) throw errorDescribeMissingEndContract();\n\t\treturn {\n\t\t\tfrom: this.startContractJson?.storage.storageHash ?? null,\n\t\t\tto: end.storage.storageHash\n\t\t};\n\t}\n\tget origin() {\n\t\tconst from = this.describe().from;\n\t\treturn from === null ? null : { storageHash: from };\n\t}\n\tget destination() {\n\t\treturn { storageHash: this.describe().to };\n\t}\n};\n/**\n* Lazy-memoized `endContract` / `startContract` view accessors, one instance\n* held per migration. Each target base (`MongoMigration`, `SqliteMigration`,\n* `PostgresMigration`) creates one `MigrationContractViews` field from\n* `this` — passing its own `<Family>ContractView.fromJson<…>` as `fromJson`\n* and a name for error messages — and forwards its\n* `endContract`/`startContract` getters to it.\n*\n* `endContract` throws `MIGRATION.CONTRACT_VIEW_MISSING` when the migration\n* has no `endContractJson` (mirrors `describe()`'s own requirement).\n* `startContract` returns `null` for a baseline migration (no\n* `startContractJson`) instead of throwing.\n*/\nvar MigrationContractViews = class {\n\tmigration;\n\tclassName;\n\tfromJson;\n\t#endView;\n\t#startView;\n\tconstructor(migration, className, fromJson) {\n\t\tthis.migration = migration;\n\t\tthis.className = className;\n\t\tthis.fromJson = fromJson;\n\t}\n\tget endContract() {\n\t\tif (this.#endView === void 0) {\n\t\t\tconst json = this.migration.endContractJson;\n\t\t\tif (json === void 0) throw errorMigrationContractViewMissing(this.className, \"endContract\", \"endContractJson\");\n\t\t\tthis.#endView = this.fromJson(json);\n\t\t}\n\t\treturn this.#endView;\n\t}\n\tget startContract() {\n\t\tif (this.#startView === void 0) {\n\t\t\tconst json = this.migration.startContractJson;\n\t\t\tthis.#startView = json === void 0 ? null : this.fromJson(json);\n\t\t}\n\t\treturn this.#startView;\n\t}\n};\n/**\n* Returns true when `import.meta.url` resolves to the same file that was\n* invoked as the node entrypoint (`process.argv[1]`). Used by\n* `MigrationCLI.run` (in `@internal/cli/migration-cli`) to no-op when\n* the migration module is being imported (e.g. by another script) rather\n* than executed directly.\n*/\nfunction isDirectEntrypoint(importMetaUrl) {\n\tconst metaFilename = fileURLToPath(importMetaUrl);\n\tconst argv1 = process.argv[1];\n\tif (!argv1) return false;\n\ttry {\n\t\treturn realpathSync(metaFilename) === realpathSync(argv1);\n\t} catch {\n\t\treturn false;\n\t}\n}\n/**\n* Build the attested metadata from `describe()`-derived metadata, the\n* operations list, and the previously-scaffolded metadata (if any).\n*\n* When a `migration.json` already exists for this package (the common\n* case: it was scaffolded by `migration plan`), preserve `createdAt`\n* set there — that field is owned by the CLI scaffolder, not the authored\n* class. Only the `describe()`-derived fields (`from`, `to`) and the\n* operations change as the author iterates. When no metadata exists yet\n* (a bare `migration.ts` run from scratch), synthesize a minimal but\n* schema-conformant record so the resulting package can still be read,\n* verified, and applied.\n*\n* The `migrationHash` is recomputed against the current metadata + ops so\n* the on-disk artifacts are always fully attested.\n*/\nfunction buildAttestedMetadata(meta, ops, existing) {\n\tconst baseMetadata = {\n\t\tfrom: meta.from,\n\t\tto: meta.to,\n\t\tprovidedInvariants: deriveProvidedInvariants(ops),\n\t\tcreatedAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()\n\t};\n\tconst migrationHash = computeMigrationHash(baseMetadata, ops);\n\treturn {\n\t\t...baseMetadata,\n\t\tmigrationHash\n\t};\n}\n/**\n* Pure conversion from a `Migration` instance (plus the previously\n* scaffolded metadata, when one exists on disk) to the in-memory\n* artifacts that downstream tooling persists. Owns metadata validation,\n* metadata synthesis/preservation, and the content-addressed\n* `migrationHash` computation, but performs no file I/O — callers handle\n* reads (to source `existing`) and writes (to persist `opsJson` /\n* `metadataJson`).\n*/\nasync function buildMigrationArtifacts(instance, existing) {\n\tconst rawOps = instance.operations;\n\tif (!Array.isArray(rawOps)) throw errorOperationsNotArray();\n\tconst ops = await Promise.all(rawOps);\n\tfor (let index = 0; index < ops.length; index++) {\n\t\tconst result = MigrationOpSchema(ops[index]);\n\t\tif (result instanceof type.errors) throw errorInvalidOperationEntry(index, result.summary);\n\t}\n\tconst rawMeta = instance.describe();\n\tconst parsed = MigrationMetaSchema(rawMeta);\n\tif (parsed instanceof type.errors) throw errorDescribeInvalidMetadata(parsed.summary);\n\tconst metadata = buildAttestedMetadata(parsed, ops, existing);\n\treturn {\n\t\topsJson: JSON.stringify(ops, null, 2),\n\t\tmetadata,\n\t\tmetadataJson: JSON.stringify(metadata, null, 2)\n\t};\n}\n//#endregion\nexport { Migration, MigrationContractViews, buildMigrationArtifacts, isDirectEntrypoint };\n\n//# sourceMappingURL=migration.mjs.map"],"mappings":";;;;;;;;AAQA,MAAM,sBAAsB,KAAK;CAChC,MAAM;CACN,IAAI;AACL,CAAC;;;;;;;;;;;;;;;;;;;;;;AAsBD,IAAI,YAAY,MAAM;;;;;;;;;;;;;CAarB;;;;;;;CAOA;;;;;;;;;;CAUA;CACA,YAAY,OAAO;EAClB,KAAK,QAAQ;CACd;;;;;;;;;;CAUA,WAAW;EACV,MAAM,MAAM,KAAK;EACjB,IAAI,QAAQ,KAAK,GAAG,MAAM,gCAAgC;EAC1D,OAAO;GACN,MAAM,KAAK,mBAAmB,QAAQ,eAAe;GACrD,IAAI,IAAI,QAAQ;EACjB;CACD;CACA,IAAI,SAAS;EACZ,MAAM,OAAO,KAAK,SAAS,CAAC,CAAC;EAC7B,OAAO,SAAS,OAAO,OAAO,EAAE,aAAa,KAAK;CACnD;CACA,IAAI,cAAc;EACjB,OAAO,EAAE,aAAa,KAAK,SAAS,CAAC,CAAC,GAAG;CAC1C;AACD;;;;;;;;;;;;;;AAcA,IAAI,yBAAyB,MAAM;CAClC;CACA;CACA;CACA;CACA;CACA,YAAY,WAAW,WAAW,UAAU;EAC3C,KAAK,YAAY;EACjB,KAAK,YAAY;EACjB,KAAK,WAAW;CACjB;CACA,IAAI,cAAc;EACjB,IAAI,KAAKA,aAAa,KAAK,GAAG;GAC7B,MAAM,OAAO,KAAK,UAAU;GAC5B,IAAI,SAAS,KAAK,GAAG,MAAM,kCAAkC,KAAK,WAAW,eAAe,iBAAiB;GAC7G,KAAKA,WAAW,KAAK,SAAS,IAAI;EACnC;EACA,OAAO,KAAKA;CACb;CACA,IAAI,gBAAgB;EACnB,IAAI,KAAKC,eAAe,KAAK,GAAG;GAC/B,MAAM,OAAO,KAAK,UAAU;GAC5B,KAAKA,aAAa,SAAS,KAAK,IAAI,OAAO,KAAK,SAAS,IAAI;EAC9D;EACA,OAAO,KAAKA;CACb;AACD;;;;;;;;AAQA,SAAS,mBAAmB,eAAe;CAC1C,MAAM,eAAe,cAAc,aAAa;CAChD,MAAM,QAAQ,QAAQ,KAAK;CAC3B,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI;EACH,OAAO,aAAa,YAAY,MAAM,aAAa,KAAK;CACzD,QAAQ;EACP,OAAO;CACR;AACD;;;;;;;;;;;;;;;;;AAiBA,SAAS,sBAAsB,MAAM,KAAK,UAAU;CACnD,MAAM,eAAe;EACpB,MAAM,KAAK;EACX,IAAI,KAAK;EACT,oBAAoB,yBAAyB,GAAG;EAChD,WAAW,UAAU,8BAA8B,IAAI,KAAK,EAAA,CAAG,YAAY;CAC5E;CACA,MAAM,gBAAgB,qBAAqB,cAAc,GAAG;CAC5D,OAAO;EACN,GAAG;EACH;CACD;AACD;;;;;;;;;;AAUA,eAAe,wBAAwB,UAAU,UAAU;CAC1D,MAAM,SAAS,SAAS;CACxB,IAAI,CAAC,MAAM,QAAQ,MAAM,GAAG,MAAM,wBAAwB;CAC1D,MAAM,MAAM,MAAM,QAAQ,IAAI,MAAM;CACpC,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,QAAQ,SAAS;EAChD,MAAM,SAAS,kBAAkB,IAAI,MAAM;EAC3C,IAAI,kBAAkB,KAAK,QAAQ,MAAM,2BAA2B,OAAO,OAAO,OAAO;CAC1F;CACA,MAAM,UAAU,SAAS,SAAS;CAClC,MAAM,SAAS,oBAAoB,OAAO;CAC1C,IAAI,kBAAkB,KAAK,QAAQ,MAAM,6BAA6B,OAAO,OAAO;CACpF,MAAM,WAAW,sBAAsB,QAAQ,KAAK,QAAQ;CAC5D,OAAO;EACN,SAAS,KAAK,UAAU,KAAK,MAAM,CAAC;EACpC;EACA,cAAc,KAAK,UAAU,UAAU,MAAM,CAAC;CAC/C;AACD"}