@prisma-next/migration-tools 0.5.0-dev.8 → 0.5.0-dev.81

package/dist/exports/aggregate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.mjs","names":[],"sources":["../../src/aggregate/loader.ts","../../src/aggregate/strategies/graph-walk.ts","../../src/aggregate/project-schema-to-space.ts","../../src/aggregate/strategies/synth.ts","../../src/aggregate/planner.ts","../../src/aggregate/verifier.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { notOk, ok, type Result } from '@prisma-next/utils/result';\nimport { EMPTY_CONTRACT_HASH } from '../constants';\nimport { detectSpaceContractDrift } from '../detect-space-contract-drift';\nimport { readMigrationsDir } from '../io';\nimport { reconstructGraph } from '../migration-graph';\nimport type { OnDiskMigrationPackage } from '../package';\nimport { readContractSpaceContract } from '../read-contract-space-contract';\nimport { readContractSpaceHeadRef } from '../read-contract-space-head-ref';\nimport { APP_SPACE_ID, spaceMigrationDirectory } from '../space-layout';\nimport { listContractSpaceDirectories } from '../verify-contract-spaces';\nimport type { ContractSpaceAggregate, ContractSpaceMember, HydratedMigrationGraph } from './types';\n\n/**\n * Hash function used by drift detection. Defaults to a canonical-JSON +\n * SHA-256 pipeline that mirrors the framework's contract-hash convention,\n * but the loader accepts a callback so SQL-family callers can pass their\n * `coreHash` / `storageHash` derivation through unchanged.\n *\n * The contract value passed in is the framework-neutral `unknown` form;\n * callers that have already validated typed contracts can simply hand\n * the validated value back through.\n */\nexport type AggregateContractHasher = (contract: unknown) => string;\n\n/**\n * Single declared extension entry the loader needs from `Config.extensionPacks`.\n *\n * Only the subset of fields the loader operates on:\n *\n * - `id` — the space id (also the directory name under `migrations/`).\n * - `targetId` — the configured `Config.adapter.targetId` value the\n *   declaring extension declared. The loader rejects mismatches against\n *   the aggregate's `targetId` with `targetMismatch`.\n * - `contractSpace` — present iff the descriptor declares a contract\n *   space (extensions can ship without one and remain runtime-only /\n *   codec-only). Drift detection compares the descriptor's\n *   `contractJson` hash against the on-disk on-disk head hash; the loader\n *   rejects drift fatally.\n *\n * Typed structurally so the migration-tools layer stays framework-neutral.\n */\nexport interface DeclaredExtensionEntry {\n  readonly id: string;\n  readonly targetId: string;\n  readonly contractSpace?: {\n    readonly contractJson: unknown;\n  };\n}\n\n/**\n * Inputs for {@link loadContractSpaceAggregate}.\n *\n * The loader is the **sole** descriptor-import boundary in the M2.5\n * pipeline: callers gather the descriptor data (already-validated app\n * contract, declared extension entries) and pass it through. Once the\n * loader returns, no descriptor module is imported again for this\n * aggregate's lifetime.\n */\nexport interface LoadAggregateInput {\n  readonly targetId: string;\n  readonly migrationsDir: string;\n  readonly appContract: Contract;\n  readonly declaredExtensions: ReadonlyArray<DeclaredExtensionEntry>;\n  readonly validateContract: (contractJson: unknown) => Contract;\n  readonly hashContract: AggregateContractHasher;\n  /**\n   * Hydrated migration graph for the **app member**.\n   *\n   * The framework-neutral migration-tools layer doesn't know how to read\n   * the user's authored `migrations/` directory (the app member's\n   * migration-package layout is family-aware: ops.json shape, manifest\n   * keys, etc.). Callers — the SQL family today — read the user's\n   * `migrations/` and hand the resulting `OnDiskMigrationPackage[]` through.\n   *\n   * Passing `[]` is valid (greenfield project, no authored migrations).\n   * Equivalent to `migrations/` not existing or being empty.\n   */\n  readonly appMigrationPackages: ReadonlyArray<OnDiskMigrationPackage>;\n}\n\n/**\n * Discriminated failure variants the loader emits.\n *\n * Every variant short-circuits at first hit; the loader does not keep\n * collecting after the first violation in any phase except for layout\n * (where every layout offence is bundled into one `layoutViolation`).\n */\nexport type LoadAggregateError =\n  | { readonly kind: 'layoutViolation'; readonly violations: readonly LayoutViolation[] }\n  | { readonly kind: 'integrityFailure'; readonly spaceId: string; readonly detail: string }\n  | { readonly kind: 'validationFailure'; readonly spaceId: string; readonly detail: string }\n  | {\n      readonly kind: 'driftViolation';\n      readonly spaceId: string;\n      readonly priorHeadHash: string;\n      readonly liveHash: string;\n    }\n  | {\n      readonly kind: 'disjointnessViolation';\n      readonly element: string;\n      readonly claimedBy: readonly string[];\n    }\n  | {\n      readonly kind: 'targetMismatch';\n      readonly spaceId: string;\n      readonly expected: string;\n      readonly actual: string;\n    };\n\n/**\n * Single layout violation; bundled into a `layoutViolation` error so\n * users see every layout offence at once rather than fixing them one\n * at a time across re-runs.\n *\n * - `declaredButUnmigrated`: extension declared in `extensionPacks` with\n *   a `contractSpace` but no contract-space dir on disk. Remediation:\n *   `prisma-next migrate`.\n * - `orphanSpaceDir`: contract-space dir under `migrations/` for an extension\n *   not in `extensionPacks`. Remediation: remove the directory, or\n *   re-add the extension to `extensionPacks`.\n */\nexport type LayoutViolation =\n  | { readonly kind: 'declaredButUnmigrated'; readonly spaceId: string }\n  | { readonly kind: 'orphanSpaceDir'; readonly spaceId: string };\n\nexport type LoadAggregateOutput = Result<\n  { readonly aggregate: ContractSpaceAggregate },\n  LoadAggregateError\n>;\n\ninterface LoadedExtensionState {\n  readonly entry: DeclaredExtensionEntry;\n  readonly contract: Contract;\n  readonly headRefHash: string;\n  readonly headRefInvariants: readonly string[];\n  readonly migrations: HydratedMigrationGraph;\n}\n\n/**\n * Hydrate a {@link ContractSpaceAggregate} from on-disk state and\n * caller-provided descriptor data.\n *\n * This is the **only** descriptor-import boundary in the post-M2.5\n * pipeline: callers read `extensionPacks` from `Config`, validate the\n * app contract, and pass everything through. The loader composes\n * existing migration-tools primitives — layout precheck (via\n * {@link listContractSpaceDirectories}), integrity checks (via\n * {@link readMigrationsDir} / {@link readContractSpaceHeadRef} /\n * {@link readContractSpaceContract} / `validateContract`), drift detection\n * (via {@link detectSpaceContractDrift}), and disjointness — into a\n * single typed value.\n *\n * Failure semantics: every failure variant in {@link LoadAggregateError}\n * short-circuits the load. Drift is fatal (M2.5 spec § Loader, step 5).\n */\nexport async function loadContractSpaceAggregate(\n  input: LoadAggregateInput,\n): Promise<LoadAggregateOutput> {\n  // 1. Validate target consistency on the app contract.\n  const appContractTarget = input.appContract.target;\n  if (appContractTarget !== input.targetId) {\n    return notOk({\n      kind: 'targetMismatch',\n      spaceId: APP_SPACE_ID,\n      expected: input.targetId,\n      actual: appContractTarget,\n    });\n  }\n\n  for (const entry of input.declaredExtensions) {\n    if (entry.targetId !== input.targetId) {\n      return notOk({\n        kind: 'targetMismatch',\n        spaceId: entry.id,\n        expected: input.targetId,\n        actual: entry.targetId,\n      });\n    }\n  }\n\n  // 2. Layout precheck: bundle every layout offence at once.\n  const declaredWithSpace = input.declaredExtensions.filter((e) => e.contractSpace !== undefined);\n  const declaredSpaceIds = new Set(declaredWithSpace.map((e) => e.id));\n  const allDirs = await listContractSpaceDirectories(input.migrationsDir);\n  // The app member is implicitly declared (it is always part of the\n  // aggregate); its `migrations/<APP_SPACE_ID>/` directory may exist or\n  // not (greenfield projects start with neither). Filter it out of the\n  // orphan / declared-but-unmigrated checks so the layout precheck is\n  // about extensions only.\n  const extensionDirsOnDisk = allDirs.filter((d) => d !== APP_SPACE_ID);\n  const spaceDirSet = new Set(extensionDirsOnDisk);\n\n  const layoutViolations: LayoutViolation[] = [];\n  for (const dir of extensionDirsOnDisk) {\n    if (!declaredSpaceIds.has(dir)) {\n      layoutViolations.push({ kind: 'orphanSpaceDir', spaceId: dir });\n    }\n  }\n  for (const id of [...declaredSpaceIds].sort()) {\n    if (!spaceDirSet.has(id)) {\n      layoutViolations.push({ kind: 'declaredButUnmigrated', spaceId: id });\n    }\n  }\n  if (layoutViolations.length > 0) {\n    return notOk({ kind: 'layoutViolation', violations: layoutViolations });\n  }\n\n  // 3-5. Per-extension: read + validate + integrity-check + drift.\n  const loadedExtensions: LoadedExtensionState[] = [];\n  for (const entry of [...declaredWithSpace].sort((a, b) => a.id.localeCompare(b.id))) {\n    const headRef = await readContractSpaceHeadRef(input.migrationsDir, entry.id);\n    if (headRef === null) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: `Head ref \\`refs/head.json\\` is missing for extension space \"${entry.id}\".`,\n      });\n    }\n\n    let spaceContractRaw: unknown;\n    try {\n      spaceContractRaw = await readContractSpaceContract(input.migrationsDir, entry.id);\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    let spaceContract: Contract;\n    try {\n      spaceContract = input.validateContract(spaceContractRaw);\n    } catch (error) {\n      return notOk({\n        kind: 'validationFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    if (spaceContract.target !== input.targetId) {\n      return notOk({\n        kind: 'targetMismatch',\n        spaceId: entry.id,\n        expected: input.targetId,\n        actual: spaceContract.target,\n      });\n    }\n\n    // Drift: compare descriptor's live `contractJson` to on-disk\n    // `refs/head.json.hash`.\n    if (entry.contractSpace) {\n      const liveHash = input.hashContract(entry.contractSpace.contractJson);\n      const drift = detectSpaceContractDrift(entry.id, {\n        descriptorHash: liveHash,\n        priorHeadHash: headRef.hash,\n      });\n      if (drift.kind === 'drift') {\n        return notOk({\n          kind: 'driftViolation',\n          spaceId: entry.id,\n          priorHeadHash: drift.priorHeadHash ?? '',\n          liveHash: drift.descriptorHash,\n        });\n      }\n    }\n\n    // Read + integrity-check the migration packages. `readMigrationsDir`\n    // re-derives `providedInvariants` and verifies migrationHash for\n    // every package.\n    let packages: readonly OnDiskMigrationPackage[];\n    try {\n      packages = await readMigrationsDir(spaceMigrationDirectory(input.migrationsDir, entry.id));\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    let graph: ReturnType<typeof reconstructGraph>;\n    try {\n      graph = reconstructGraph(packages);\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    // The on-disk head ref must be reachable in the graph. Empty graphs\n    // are tolerated only when the head ref points at the empty-contract\n    // sentinel (a never-emitted extension space; not a typical scenario\n    // because the layout precheck would have flagged the missing\n    // dir, but defensible).\n    if (graph.nodes.size === 0) {\n      if (headRef.hash !== EMPTY_CONTRACT_HASH) {\n        return notOk({\n          kind: 'integrityFailure',\n          spaceId: entry.id,\n          detail: `Head ref \"${headRef.hash}\" is not present in the (empty) on-disk migration graph.`,\n        });\n      }\n    } else if (!graph.nodes.has(headRef.hash)) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: `Head ref \"${headRef.hash}\" is not present in the on-disk migration graph.`,\n      });\n    }\n\n    const packagesByMigrationHash = new Map<string, OnDiskMigrationPackage>(\n      packages.map((p) => [p.metadata.migrationHash, p]),\n    );\n\n    loadedExtensions.push({\n      entry,\n      contract: spaceContract,\n      headRefHash: headRef.hash,\n      headRefInvariants: [...headRef.invariants].sort(),\n      migrations: { graph, packagesByMigrationHash },\n    });\n  }\n\n  // 6. Build app member with hydrated graph from caller-supplied packages.\n  let appGraph: ReturnType<typeof reconstructGraph>;\n  try {\n    appGraph = reconstructGraph(input.appMigrationPackages);\n  } catch (error) {\n    return notOk({\n      kind: 'integrityFailure',\n      spaceId: APP_SPACE_ID,\n      detail: error instanceof Error ? error.message : String(error),\n    });\n  }\n  const appPackagesByMigrationHash = new Map<string, OnDiskMigrationPackage>(\n    input.appMigrationPackages.map((p) => [p.metadata.migrationHash, p]),\n  );\n\n  const appMember: ContractSpaceMember = {\n    spaceId: APP_SPACE_ID,\n    contract: input.appContract,\n    headRef: {\n      hash: input.appContract.storage.storageHash,\n      invariants: [],\n    },\n    migrations: {\n      graph: appGraph,\n      packagesByMigrationHash: appPackagesByMigrationHash,\n    },\n  };\n\n  const extensionMembers: ContractSpaceMember[] = loadedExtensions.map((s) => ({\n    spaceId: s.entry.id,\n    contract: s.contract,\n    headRef: {\n      hash: s.headRefHash,\n      invariants: s.headRefInvariants,\n    },\n    migrations: s.migrations,\n  }));\n\n  // 7. Disjointness: no two members claim the same storage element.\n  const elementClaimedBy = new Map<string, string[]>();\n  for (const member of [appMember, ...extensionMembers]) {\n    const tables = extractTableNames(member.contract);\n    for (const tableName of tables) {\n      const claimers = elementClaimedBy.get(tableName);\n      if (claimers) claimers.push(member.spaceId);\n      else elementClaimedBy.set(tableName, [member.spaceId]);\n    }\n  }\n  for (const [element, claimedBy] of elementClaimedBy) {\n    if (claimedBy.length > 1) {\n      return notOk({\n        kind: 'disjointnessViolation',\n        element,\n        claimedBy: [...claimedBy].sort(),\n      });\n    }\n  }\n\n  return ok({\n    aggregate: {\n      targetId: input.targetId,\n      app: appMember,\n      extensions: extensionMembers,\n    },\n  });\n}\n\n/**\n * Extract the set of top-level storage table names from a contract.\n * Duck-typed: returns `[]` if the contract's storage shape doesn't\n * match the canonical `storage.tables: Record<string, ...>` form. A\n * future family with a different storage shape gets disjointness\n * effectively disabled (not enforced) rather than a hard failure.\n */\nfunction extractTableNames(contract: Contract): readonly string[] {\n  const storage = (contract as { readonly storage?: unknown }).storage;\n  if (typeof storage !== 'object' || storage === null) return [];\n  const tables = (storage as { readonly tables?: unknown }).tables;\n  if (typeof tables !== 'object' || tables === null) return [];\n  return Object.keys(tables as Record<string, unknown>);\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { MigrationPlan } from '@prisma-next/framework-components/control';\nimport { EMPTY_CONTRACT_HASH } from '../../constants';\nimport { findPathWithDecision } from '../../migration-graph';\nimport type { MigrationOps } from '../../package';\nimport type { ContractMarkerRecordLike } from '../marker-types';\nimport type { AggregatePerSpacePlan } from '../planner-types';\nimport type { ContractSpaceMember } from '../types';\n\n/**\n * Outcome variants for the graph-walk strategy. Mirrors\n * {@link import('../../compute-extension-space-apply-path').ExtensionSpaceApplyPathOutcome}\n * but operates against the **already-hydrated** `member.migrations.graph`\n * instead of re-reading from disk. The aggregate planner converts\n * these into {@link import('../planner-types').AggregatePlannerError}\n * variants.\n */\nexport type GraphWalkOutcome =\n  | { readonly kind: 'ok'; readonly result: AggregatePerSpacePlan }\n  | { readonly kind: 'unreachable' }\n  | { readonly kind: 'unsatisfiable'; readonly missing: readonly string[] };\n\nexport interface GraphWalkStrategyInputs {\n  readonly aggregateTargetId: string;\n  readonly member: ContractSpaceMember;\n  readonly currentMarker: ContractMarkerRecordLike | null;\n  /**\n   * Optional ref name to decorate the resulting `PathDecision`. Used by\n   * `migration apply` to surface the user-supplied `--ref <name>` in\n   * structured-progress events and invariant-path error envelopes. The\n   * strategy itself does not interpret it.\n   */\n  readonly refName?: string;\n}\n\n/**\n * Walk a member's hydrated migration graph from the live marker to\n * `member.headRef.hash`, covering every required invariant.\n *\n * Pure synchronous function — no I/O. The aggregate's loader has\n * already integrity-checked every package and reconstructed the graph;\n * this strategy just looks up ops by `migrationHash` and assembles a\n * `MigrationPlan` with `targetId` set from the aggregate (no\n * placeholder cast).\n *\n * Required invariants are computed as `headRef.invariants \\ marker.invariants`\n * — the marker already declares some invariants satisfied; the path\n * only needs to provide the remainder. Mirrors today's\n * `computeExtensionSpaceApplyPath` semantics.\n */\nexport function graphWalkStrategy(input: GraphWalkStrategyInputs): GraphWalkOutcome {\n  const { aggregateTargetId, member, currentMarker, refName } = input;\n  const { graph, packagesByMigrationHash } = member.migrations;\n\n  const fromHash = currentMarker?.storageHash ?? EMPTY_CONTRACT_HASH;\n  const markerInvariants = new Set(currentMarker?.invariants ?? []);\n  const required = new Set(member.headRef.invariants.filter((id) => !markerInvariants.has(id)));\n\n  const outcome = findPathWithDecision(graph, fromHash, member.headRef.hash, {\n    required,\n    ...(refName !== undefined ? { refName } : {}),\n  });\n\n  if (outcome.kind === 'unreachable') {\n    return { kind: 'unreachable' };\n  }\n  if (outcome.kind === 'unsatisfiable') {\n    return { kind: 'unsatisfiable', missing: outcome.missing };\n  }\n\n  const pathOps: MigrationOps[number][] = [];\n  const providedInvariantsSet = new Set<string>();\n  const edgeRefs: Array<{\n    migrationHash: string;\n    dirName: string;\n    from: string;\n    to: string;\n    operationCount: number;\n  }> = [];\n  for (const edge of outcome.decision.selectedPath) {\n    const pkg = packagesByMigrationHash.get(edge.migrationHash);\n    if (!pkg) {\n      throw new Error(\n        `Migration package missing for edge ${edge.migrationHash} in space \"${member.spaceId}\". The hydrated migration graph and packagesByMigrationHash map are out of sync — this should be unreachable; report.`,\n      );\n    }\n    for (const op of pkg.ops) pathOps.push(op);\n    for (const invariant of pkg.metadata.providedInvariants) providedInvariantsSet.add(invariant);\n    edgeRefs.push({\n      migrationHash: edge.migrationHash,\n      dirName: edge.dirName,\n      from: edge.from,\n      to: edge.to,\n      operationCount: pkg.ops.length,\n    });\n  }\n\n  const plan: MigrationPlan = {\n    targetId: aggregateTargetId,\n    spaceId: member.spaceId,\n    origin: currentMarker === null ? null : { storageHash: currentMarker.storageHash },\n    destination: { storageHash: member.headRef.hash },\n    operations: pathOps,\n    providedInvariants: [...providedInvariantsSet].sort(),\n  };\n\n  return {\n    kind: 'ok',\n    result: {\n      plan,\n      displayOps: pathOps,\n      destinationContract: member.contract as Contract,\n      strategy: 'graph-walk',\n      migrationEdges: edgeRefs,\n      pathDecision: outcome.decision,\n    },\n  };\n}\n","import type { ContractSpaceMember } from './types';\n\n/**\n * Project the introspected live schema to the slice claimed by a single\n * contract-space member.\n *\n * Returns the same `schema` value with every top-level table claimed by\n * **other** members of the aggregate removed. Tables not claimed by any\n * member flow through unchanged — the planner / verifier sees them as\n * orphans (extras in strict mode).\n *\n * Used by:\n *\n * - The aggregate planner's **synth strategy**: when synthesising a\n *   plan against a member's contract, the live schema must be projected\n *   to that member's slice so the planner doesn't treat tables claimed\n *   by other members as \"extras\" and emit destructive ops to drop\n *   them.\n * - The aggregate verifier's **schemaCheck**: projects per member so the\n *   single-contract `verifySqlSchema` only sees the slice claimed by\n *   the member it is checking. Closes the F23 architectural concern\n *   (multi-member deployments where each member's tables look like\n *   extras to every other member's verify pass).\n *\n * **Duck-typing semantics**: the helper operates on `unknown` for the\n * schema and falls through structurally if the shape doesn't match.\n * Every family today exposes `storage.tables: Record<string, ...>` and\n * the introspected schema mirrors the same shape; a future family with\n * a different storage shape gets the schema returned unchanged rather\n * than blowing up the aggregate planner.\n */\nexport function projectSchemaToSpace(\n  schema: unknown,\n  member: ContractSpaceMember,\n  otherMembers: ReadonlyArray<ContractSpaceMember>,\n): unknown {\n  if (typeof schema !== 'object' || schema === null) return schema;\n  const schemaObj = schema as { readonly tables?: unknown };\n  if (typeof schemaObj.tables !== 'object' || schemaObj.tables === null) return schema;\n  const schemaTables = schemaObj.tables as Record<string, unknown>;\n\n  const ownedByOthers = new Set<string>();\n  for (const other of otherMembers) {\n    if (other.spaceId === member.spaceId) continue;\n    const storage = (other.contract as { readonly storage?: unknown }).storage;\n    if (typeof storage !== 'object' || storage === null) continue;\n    const tables = (storage as { readonly tables?: unknown }).tables;\n    if (typeof tables !== 'object' || tables === null) continue;\n    for (const tableName of Object.keys(tables as Record<string, unknown>)) {\n      ownedByOthers.add(tableName);\n    }\n  }\n\n  if (ownedByOthers.size === 0) return schema;\n\n  const prunedTables: Record<string, unknown> = {};\n  for (const [name, table] of Object.entries(schemaTables)) {\n    if (!ownedByOthers.has(name)) {\n      prunedTables[name] = table;\n    }\n  }\n\n  return { ...schemaObj, tables: prunedTables };\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  ControlFamilyInstance,\n  MigrationOperationPolicy,\n  MigrationPlan,\n  MigrationPlannerConflict,\n  MigrationPlannerResult,\n  TargetMigrationsCapability,\n} from '@prisma-next/framework-components/control';\nimport type { AggregatePerSpacePlan } from '../planner-types';\nimport { projectSchemaToSpace } from '../project-schema-to-space';\nimport type { ContractSpaceMember } from '../types';\n\nexport interface SynthStrategyInputs<TFamilyId extends string, TTargetId extends string> {\n  readonly aggregateTargetId: string;\n  readonly member: ContractSpaceMember;\n  readonly otherMembers: ReadonlyArray<ContractSpaceMember>;\n  readonly schemaIntrospection: unknown;\n  readonly familyInstance: ControlFamilyInstance<TFamilyId, unknown>;\n  readonly migrations: TargetMigrationsCapability<\n    TFamilyId,\n    TTargetId,\n    ControlFamilyInstance<TFamilyId, unknown>\n  >;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;\n  readonly operationPolicy: MigrationOperationPolicy;\n}\n\nexport type SynthStrategyOutcome =\n  | { readonly kind: 'ok'; readonly result: AggregatePerSpacePlan }\n  | { readonly kind: 'failure'; readonly conflicts: readonly MigrationPlannerConflict[] };\n\n/**\n * The {@link MigrationPlanner.plan} interface is declared as synchronous,\n * but historical and test fixture call sites have always invoked it\n * with `await` (see prior `db-apply-per-space.ts`). Tolerating a\n * Promise here keeps existing test mocks working without changing the\n * declared family SPI.\n */\ntype MaybeAsyncPlannerResult = MigrationPlannerResult | Promise<MigrationPlannerResult>;\n\n/**\n * Synthesise a migration plan for a single member by projecting the\n * live schema down to that member's claimed slice and delegating to\n * the family's `createPlanner(...).plan(...)`.\n *\n * Pre-projection (via {@link projectSchemaToSpace}) closes the F23\n * concern: without it, the family's planner sees other members'\n * tables as \"extras\" and emits destructive ops to drop them. With it,\n * the planner only sees the slice this member claims.\n *\n * The synthesised plan's `targetId` is set from `aggregateTargetId`\n * (the aggregate's ambient target). The family's planner does not\n * stamp `targetId` on the produced plan; the aggregate planner is\n * the single point that knows the target.\n *\n * Used by:\n *\n * - The app member by default (CLI policy\n *   `ignoreGraphFor: { app.spaceId }`).\n * - Any extension member whose `headRef.invariants` is empty (the\n *   strategy selector falls back to synth when graph-walk isn't\n *   required).\n */\nexport async function synthStrategy<TFamilyId extends string, TTargetId extends string>(\n  input: SynthStrategyInputs<TFamilyId, TTargetId>,\n): Promise<SynthStrategyOutcome> {\n  const projectedSchema = projectSchemaToSpace(\n    input.schemaIntrospection,\n    input.member,\n    input.otherMembers,\n  );\n\n  const planner = input.migrations.createPlanner(input.familyInstance);\n  const plannerResult: MigrationPlannerResult = await (planner.plan({\n    contract: input.member.contract,\n    schema: projectedSchema,\n    policy: input.operationPolicy,\n    fromContract: null,\n    frameworkComponents: input.frameworkComponents,\n    spaceId: input.member.spaceId,\n  }) as MaybeAsyncPlannerResult);\n\n  if (plannerResult.kind === 'failure') {\n    return { kind: 'failure', conflicts: plannerResult.conflicts };\n  }\n\n  const synthedPlan = plannerResult.plan;\n  // The family planner returns a class-instance-shaped plan whose\n  // `destination` / `operations` are accessors on the prototype, often\n  // backed by private fields. A naive spread (`{ ...synthedPlan }`)\n  // would lose those accessors and produce a plan with\n  // `destination: undefined`; rebinding the prototype on a plain\n  // object would break private-field access. We instead wrap the plan\n  // in a Proxy that forwards every read except `targetId`, which is\n  // stamped from the aggregate's ambient target. This preserves the\n  // planner's class semantics while keeping the aggregate the single\n  // source of truth for `targetId`.\n  const plan: MigrationPlan = new Proxy(synthedPlan, {\n    get(target, prop) {\n      if (prop === 'targetId') return input.aggregateTargetId;\n      // Forward `this` as the original target so prototype-bound\n      // private fields (#destination, #operations, …) resolve.\n      return Reflect.get(target, prop, target);\n    },\n    has(target, prop) {\n      if (prop === 'targetId') return true;\n      return Reflect.has(target, prop);\n    },\n  });\n\n  return {\n    kind: 'ok',\n    result: {\n      plan,\n      displayOps: synthedPlan.operations,\n      destinationContract: input.member.contract as Contract,\n      strategy: 'synth',\n    },\n  };\n}\n","import { notOk, ok } from '@prisma-next/utils/result';\nimport type {\n  AggregatePerSpacePlan,\n  AggregatePlannerError,\n  AggregatePlannerInput,\n  AggregatePlannerOutput,\n} from './planner-types';\nimport { graphWalkStrategy } from './strategies/graph-walk';\nimport { synthStrategy } from './strategies/synth';\nimport type { ContractSpaceMember } from './types';\n\nexport type {\n  AggregateCurrentDBState,\n  AggregatePerSpacePlan,\n  AggregatePlannerError,\n  AggregatePlannerInput,\n  AggregatePlannerOutput,\n  AggregatePlannerSuccess,\n  CallerPolicy,\n} from './planner-types';\n\n/**\n * Plan a migration across every member of a {@link ContractSpaceAggregate}.\n *\n * Strategy selection per member, in order; first match wins:\n *\n * 1. If `callerPolicy.ignoreGraphFor.has(member.spaceId)`:\n *    - If `member.headRef.invariants` is empty → synth.\n *    - Else → `policyConflict` (synth cannot satisfy authored invariants).\n * 2. Else if `member.migrations.graph` is non-empty AND graph-walk\n *    succeeds → graph-walk.\n * 3. Else if `member.headRef.invariants` is empty → synth.\n * 4. Else → graph-walk failure → `extensionPathUnreachable` /\n *    `extensionPathUnsatisfiable`.\n *\n * Output `applyOrder` is `[...aggregate.extensions.map(spaceId), aggregate.app.spaceId]`\n * — extensions alphabetical, then app — matching today's\n * `concatenateSpaceApplyInputs` ordering. This preserves\n * `MultiSpaceRunnerFailure.failingSpace` attribution byte-for-byte.\n *\n * Every emitted `MigrationPlan` has `targetId = aggregate.targetId`.\n * No placeholder cast; no patch step.\n */\nexport async function planAggregate<TFamilyId extends string, TTargetId extends string>(\n  input: AggregatePlannerInput<TFamilyId, TTargetId>,\n): Promise<AggregatePlannerOutput> {\n  const { aggregate, currentDBState, callerPolicy } = input;\n  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];\n\n  const perSpace = new Map<string, AggregatePerSpacePlan>();\n\n  // Iterate in apply order so a per-member error short-circuits the\n  // walk in the same order the runner would walk inputs.\n  const orderedMembers: ReadonlyArray<ContractSpaceMember> = [\n    ...aggregate.extensions,\n    aggregate.app,\n  ];\n\n  for (const member of orderedMembers) {\n    const otherMembers = allMembers.filter((m) => m.spaceId !== member.spaceId);\n    const currentMarker = currentDBState.markersBySpaceId.get(member.spaceId) ?? null;\n\n    const ignoreGraph = callerPolicy.ignoreGraphFor.has(member.spaceId);\n    const invariantsRequired = member.headRef.invariants.length > 0;\n\n    if (ignoreGraph && invariantsRequired) {\n      const conflict: AggregatePlannerError = {\n        kind: 'policyConflict',\n        spaceId: member.spaceId,\n        detail: `\\`callerPolicy.ignoreGraphFor\\` requested for space \"${member.spaceId}\", but the member declares non-empty head-ref invariants (${member.headRef.invariants.join(', ')}). Synthesising a plan from the contract IR cannot satisfy authored invariants — the graph must be walked. Either remove \"${member.spaceId}\" from \\`ignoreGraphFor\\` or amend the on-disk head ref to declare zero invariants.`,\n      };\n      return notOk(conflict);\n    }\n\n    if (ignoreGraph) {\n      const synthOutcome = await synthStrategy({\n        aggregateTargetId: aggregate.targetId,\n        member,\n        otherMembers,\n        schemaIntrospection: currentDBState.schemaIntrospection,\n        familyInstance: input.familyInstance,\n        migrations: input.migrations,\n        frameworkComponents: input.frameworkComponents,\n        operationPolicy: input.operationPolicy,\n      });\n      if (synthOutcome.kind === 'failure') {\n        return notOk({\n          kind: 'appSynthFailure',\n          spaceId: member.spaceId,\n          conflicts: synthOutcome.conflicts,\n        });\n      }\n      perSpace.set(member.spaceId, synthOutcome.result);\n      continue;\n    }\n\n    // Try graph-walk first when the graph has nodes; fall back to synth\n    // when the graph is empty AND no invariants are required.\n    if (member.migrations.graph.nodes.size > 0) {\n      const walked = graphWalkStrategy({\n        aggregateTargetId: aggregate.targetId,\n        member,\n        currentMarker,\n      });\n      if (walked.kind === 'ok') {\n        perSpace.set(member.spaceId, walked.result);\n        continue;\n      }\n      if (walked.kind === 'unreachable') {\n        return notOk({\n          kind: 'extensionPathUnreachable',\n          spaceId: member.spaceId,\n          target: member.headRef.hash,\n        });\n      }\n      // unsatisfiable — surface\n      return notOk({\n        kind: 'extensionPathUnsatisfiable',\n        spaceId: member.spaceId,\n        missingInvariants: walked.missing,\n      });\n    }\n\n    // Empty graph: synth is the only option, and it can only satisfy\n    // empty-invariant members.\n    if (invariantsRequired) {\n      return notOk({\n        kind: 'extensionPathUnsatisfiable',\n        spaceId: member.spaceId,\n        missingInvariants: [...member.headRef.invariants].sort(),\n      });\n    }\n\n    const synthOutcome = await synthStrategy({\n      aggregateTargetId: aggregate.targetId,\n      member,\n      otherMembers,\n      schemaIntrospection: currentDBState.schemaIntrospection,\n      familyInstance: input.familyInstance,\n      migrations: input.migrations,\n      frameworkComponents: input.frameworkComponents,\n      operationPolicy: input.operationPolicy,\n    });\n    if (synthOutcome.kind === 'failure') {\n      return notOk({\n        kind: 'appSynthFailure',\n        spaceId: member.spaceId,\n        conflicts: synthOutcome.conflicts,\n      });\n    }\n    perSpace.set(member.spaceId, synthOutcome.result);\n  }\n\n  return ok({\n    perSpace,\n    applyOrder: [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId],\n  });\n}\n","import type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport type { ContractMarkerRecordLike } from './marker-types';\nimport { projectSchemaToSpace } from './project-schema-to-space';\nimport type { ContractSpaceAggregate, ContractSpaceMember } from './types';\n\n/**\n * Caller policy for the aggregate verifier. Today's only knob is\n * `mode`: `strict` treats orphan elements (live tables not claimed by\n * any aggregate member) as errors; `lenient` treats them as\n * informational. Maps directly to `db verify --strict`.\n */\nexport interface AggregateVerifierInput<TSchemaResult> {\n  readonly aggregate: ContractSpaceAggregate;\n  readonly markersBySpaceId: ReadonlyMap<string, ContractMarkerRecordLike | null>;\n  readonly schemaIntrospection: unknown;\n  readonly mode: 'strict' | 'lenient';\n  /**\n   * Caller-supplied per-space schema verifier. The CLI wires this to\n   * the family's `verifySqlSchema` (SQL) / equivalent (other\n   * families). The aggregate verifier projects the schema to the\n   * member's slice via {@link projectSchemaToSpace} before invoking\n   * the callback, so single-contract semantics are preserved.\n   *\n   * Typed structurally with a generic `TSchemaResult` so the\n   * migration-tools layer doesn't depend on the SQL family's\n   * `VerifySqlSchemaResult`. CLI callers pass the family's type\n   * through unchanged.\n   */\n  readonly verifySchemaForMember: (\n    projectedSchema: unknown,\n    member: ContractSpaceMember,\n    mode: 'strict' | 'lenient',\n  ) => TSchemaResult;\n}\n\n/**\n * Marker-check result per member. Mirrors the four cases the\n * `verifyContractSpaces` primitive surfaces today, plus an `'absent'`\n * case for greenfield spaces (no marker row written yet — `db init`\n * not run).\n */\nexport type MarkerCheckResult =\n  | { readonly kind: 'ok' }\n  | { readonly kind: 'absent' }\n  | {\n      readonly kind: 'hashMismatch';\n      readonly markerHash: string;\n      readonly expected: string;\n    }\n  | { readonly kind: 'missingInvariants'; readonly missing: readonly string[] };\n\nexport interface MarkerCheckSection {\n  readonly perSpace: ReadonlyMap<string, MarkerCheckResult>;\n  readonly orphanMarkers: readonly {\n    readonly spaceId: string;\n    readonly row: ContractMarkerRecordLike;\n  }[];\n}\n\n/**\n * A live storage element (today: a top-level table) not claimed by any\n * member of the aggregate. The aggregate verifier always reports these;\n * the caller decides what to do — `db verify --strict` treats them as\n * errors, the lenient default treats them as informational.\n *\n * Today only `kind: 'table'` exists. The discriminated shape leaves\n * room for orphan columns / indexes / sequences in the future without\n * breaking the type contract.\n */\nexport type OrphanElement = { readonly kind: 'table'; readonly name: string };\n\nexport interface SchemaCheckSection<TSchemaResult> {\n  readonly perSpace: ReadonlyMap<string, TSchemaResult>;\n  /**\n   * Live elements present in the introspected schema that are not\n   * claimed by **any** aggregate member. Sorted alphabetically by name.\n   */\n  readonly orphanElements: readonly OrphanElement[];\n}\n\nexport interface AggregateVerifierSuccess<TSchemaResult> {\n  readonly markerCheck: MarkerCheckSection;\n  readonly schemaCheck: SchemaCheckSection<TSchemaResult>;\n}\n\nexport type AggregateVerifierError = {\n  readonly kind: 'introspectionFailure';\n  readonly detail: string;\n};\n\nexport type AggregateVerifierOutput<TSchemaResult> = Result<\n  AggregateVerifierSuccess<TSchemaResult>,\n  AggregateVerifierError\n>;\n\n/**\n * Verify a {@link ContractSpaceAggregate} against the live database\n * state. Bundles two checks:\n *\n * - `markerCheck` per member: compare the live marker row against the\n *   member's `headRef.hash` + `headRef.invariants`. Absence is a\n *   distinct kind, not an error (callers — `db verify` strict vs\n *   `db init` precondition — choose how to interpret it).\n * - `schemaCheck` per member: project the live schema to the slice\n *   the member claims via {@link projectSchemaToSpace}, then delegate\n *   to the caller-supplied `verifySchemaForMember`. The pre-projection\n *   means the family's single-contract verifier no longer sees other\n *   members' tables as `extras`, so a multi-member deployment never\n *   surfaces cross-member tables as orphaned schema elements.\n *\n * `markerCheck.orphanMarkers` lists every marker row whose `space` is\n * not a member of the aggregate. `db verify` callers reject orphans;\n * future tooling may not.\n *\n * Pure synchronous function; no I/O. The caller (CLI) gathers\n * `markersBySpaceId` and `schemaIntrospection` ahead of the call.\n */\nexport function verifyAggregate<TSchemaResult>(\n  input: AggregateVerifierInput<TSchemaResult>,\n): AggregateVerifierOutput<TSchemaResult> {\n  try {\n    return runVerifyAggregate(input);\n  } catch (error) {\n    return notOk({\n      kind: 'introspectionFailure',\n      detail: error instanceof Error ? error.message : String(error),\n    });\n  }\n}\n\nfunction runVerifyAggregate<TSchemaResult>(\n  input: AggregateVerifierInput<TSchemaResult>,\n): AggregateVerifierOutput<TSchemaResult> {\n  const { aggregate, markersBySpaceId, schemaIntrospection, mode, verifySchemaForMember } = input;\n  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];\n  const memberSpaceIds = new Set(allMembers.map((m) => m.spaceId));\n\n  // Marker check per member.\n  const markerPerSpace = new Map<string, MarkerCheckResult>();\n  for (const member of allMembers) {\n    const marker = markersBySpaceId.get(member.spaceId) ?? null;\n    if (marker === null) {\n      markerPerSpace.set(member.spaceId, { kind: 'absent' });\n      continue;\n    }\n    if (marker.storageHash !== member.headRef.hash) {\n      markerPerSpace.set(member.spaceId, {\n        kind: 'hashMismatch',\n        markerHash: marker.storageHash,\n        expected: member.headRef.hash,\n      });\n      continue;\n    }\n    const markerInvariants = new Set(marker.invariants);\n    const missing = member.headRef.invariants.filter((id) => !markerInvariants.has(id));\n    if (missing.length > 0) {\n      markerPerSpace.set(member.spaceId, {\n        kind: 'missingInvariants',\n        missing: [...missing].sort(),\n      });\n      continue;\n    }\n    markerPerSpace.set(member.spaceId, { kind: 'ok' });\n  }\n\n  // Orphan markers: entries in markersBySpaceId whose spaceId is not a\n  // member of the aggregate.\n  const orphanMarkers: { spaceId: string; row: ContractMarkerRecordLike }[] = [];\n  for (const [spaceId, row] of markersBySpaceId) {\n    if (row !== null && !memberSpaceIds.has(spaceId)) {\n      orphanMarkers.push({ spaceId, row });\n    }\n  }\n  orphanMarkers.sort((a, b) => a.spaceId.localeCompare(b.spaceId));\n\n  // Schema check per member (with per-space pre-projection).\n  const schemaPerSpace = new Map<string, TSchemaResult>();\n  for (const member of allMembers) {\n    const others = allMembers.filter((m) => m.spaceId !== member.spaceId);\n    const projected = projectSchemaToSpace(schemaIntrospection, member, others);\n    schemaPerSpace.set(member.spaceId, verifySchemaForMember(projected, member, mode));\n  }\n\n  return ok({\n    markerCheck: {\n      perSpace: markerPerSpace,\n      orphanMarkers,\n    },\n    schemaCheck: {\n      perSpace: schemaPerSpace,\n      orphanElements: detectOrphanElements(schemaIntrospection, allMembers),\n    },\n  });\n}\n\n/**\n * Live tables not claimed by any aggregate member. Duck-typed against\n * the introspected schema's `tables` map; schemas whose shape doesn't\n * match return an empty list (consistent with\n * {@link projectSchemaToSpace}'s fall-through).\n */\nfunction detectOrphanElements(\n  schemaIntrospection: unknown,\n  members: ReadonlyArray<ContractSpaceMember>,\n): readonly OrphanElement[] {\n  if (typeof schemaIntrospection !== 'object' || schemaIntrospection === null) return [];\n  const liveTables = (schemaIntrospection as { readonly tables?: unknown }).tables;\n  if (typeof liveTables !== 'object' || liveTables === null) return [];\n\n  const claimedTables = new Set<string>();\n  for (const member of members) {\n    const storage = (member.contract as { readonly storage?: unknown }).storage;\n    if (typeof storage !== 'object' || storage === null) continue;\n    const tables = (storage as { readonly tables?: unknown }).tables;\n    if (typeof tables !== 'object' || tables === null) continue;\n    for (const tableName of Object.keys(tables as Record<string, unknown>)) {\n      claimedTables.add(tableName);\n    }\n  }\n\n  const orphans: OrphanElement[] = [];\n  for (const tableName of Object.keys(liveTables as Record<string, unknown>)) {\n    if (!claimedTables.has(tableName)) {\n      orphans.push({ kind: 'table', name: tableName });\n    }\n  }\n  orphans.sort((a, b) => a.name.localeCompare(b.name));\n  return orphans;\n}\n"],"mappings":"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"}

package/dist/exports/constants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","names":[],"sources":["../../src/constants.ts"],"sourcesContent":[],"mappings":";;AAIA;;;cAAa"}
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../../src/constants.ts"],"mappings":";;AAIA;;;cAAa,mBAAA"}

package/dist/exports/constants.mjs

@@ -1,3 +1,2 @@
-import { t as EMPTY_CONTRACT_HASH } from "../constants-BRi0X7B_.mjs";
-
-export { EMPTY_CONTRACT_HASH };
+import { t as EMPTY_CONTRACT_HASH } from "../constants-DWV9_o2Z.mjs";
+export { EMPTY_CONTRACT_HASH };

package/dist/exports/errors.d.mts

@@ -0,0 +1,68 @@
+//#region src/errors.d.ts
+/**
+ * Structured error for migration tooling operations.
+ *
+ * Follows the NAMESPACE.SUBCODE convention from ADR 027. All codes live under
+ * the MIGRATION namespace. These are tooling-time errors (file I/O, hash
+ * verification, migration history reconstruction), distinct from the runtime
+ * MIGRATION.* codes for apply-time failures (PRECHECK_FAILED, POSTCHECK_FAILED,
+ * etc.).
+ *
+ * Fields:
+ * - code:     Stable machine-readable code (MIGRATION.SUBCODE)
+ * - category: Always 'MIGRATION'
+ * - why:      Explains the cause in plain language
+ * - fix:      Actionable remediation step
+ * - details:  Machine-readable structured data for agents
+ */
+declare class MigrationToolsError extends Error {
+  readonly code: string;
+  readonly category: "MIGRATION";
+  readonly why: string;
+  readonly fix: string;
+  readonly details: Record<string, unknown> | undefined;
+  constructor(code: string, summary: string, options: {
+    readonly why: string;
+    readonly fix: string;
+    readonly details?: Record<string, unknown>;
+  });
+  static is(error: unknown): error is MigrationToolsError;
+}
+declare function errorInvalidJson(filePath: string, parseError: string): MigrationToolsError;
+declare function errorDescriptorHeadHashMismatch(args: {
+  readonly extensionId: string;
+  readonly recomputedHash: string;
+  readonly headRefHash: string;
+}): MigrationToolsError;
+/**
+ * Wire-shape edge surfaced through the JSON envelope's
+ * `meta.structuralPath` of `MIGRATION.NO_INVARIANT_PATH`. Slim by design —
+ * authoring metadata (`createdAt`, `labels`) lives on `MigrationEdge` but
+ * is intentionally dropped here so the envelope stays stable across
+ * graph-internal refactors.
+ *
+ * Stability: any field added here is part of the public CLI JSON contract.
+ * Callers (CLI consumers, agents) must be able to treat
+ * `(dirName, migrationHash, from, to, invariants)` as the canonical shape.
+ */
+interface NoInvariantPathStructuralEdge {
+  readonly dirName: string;
+  readonly migrationHash: string;
+  readonly from: string;
+  readonly to: string;
+  readonly invariants: readonly string[];
+}
+declare function errorNoInvariantPath(args: {
+  readonly refName?: string;
+  readonly required: readonly string[];
+  readonly missing: readonly string[];
+  readonly structuralPath: readonly NoInvariantPathStructuralEdge[];
+}): MigrationToolsError;
+declare function errorUnknownInvariant(args: {
+  readonly refName?: string;
+  readonly unknown: readonly string[];
+  readonly declared: readonly string[];
+}): MigrationToolsError;
+//#endregion
+export { MigrationToolsError, type NoInvariantPathStructuralEdge, errorDescriptorHeadHashMismatch, errorInvalidJson, errorNoInvariantPath, errorUnknownInvariant };
+//# sourceMappingURL=errors.d.mts.map

package/dist/exports/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../src/errors.ts"],"mappings":";;AAmCA;;;;;;;;;;;;;;;cAAa,mBAAA,SAA4B,KAAA;EAAA,SAC9B,IAAA;EAAA,SACA,QAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;EAAA,SACA,OAAA,EAAS,MAAA;cAGhB,IAAA,UACA,OAAA,UACA,OAAA;IAAA,SACW,GAAA;IAAA,SACA,GAAA;IAAA,SACA,OAAA,GAAU,MAAA;EAAA;EAAA,OAWhB,EAAA,CAAG,KAAA,YAAiB,KAAA,IAAS,mBAAA;AAAA;AAAA,iBA0BtB,gBAAA,CAAiB,QAAA,UAAkB,UAAA,WAAqB,mBAAA;AAAA,iBA6ExD,+BAAA,CAAgC,IAAA;EAAA,SACrC,WAAA;EAAA,SACA,cAAA;EAAA,SACA,WAAA;AAAA,IACP,mBAAA;;;;;;AA0NJ;;;;;;UAlCiB,6BAAA;EAAA,SACN,OAAA;EAAA,SACA,aAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,UAAA;AAAA;AAAA,iBAGK,oBAAA,CAAqB,IAAA;EAAA,SAC1B,OAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,cAAA,WAAyB,6BAAA;AAAA,IAChC,mBAAA;AAAA,iBAqBY,qBAAA,CAAsB,IAAA;EAAA,SAC3B,OAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;AAAA,IACP,mBAAA"}

package/dist/exports/errors.mjs

@@ -0,0 +1,2 @@
+import { E as errorUnknownInvariant, r as errorDescriptorHeadHashMismatch, t as MigrationToolsError, u as errorInvalidJson, x as errorNoInvariantPath } from "../errors-EPL_9p9f.mjs";
+export { MigrationToolsError, errorDescriptorHeadHashMismatch, errorInvalidJson, errorNoInvariantPath, errorUnknownInvariant };

package/dist/exports/graph.d.mts

@@ -0,0 +1,2 @@
+import { n as MigrationGraph, t as MigrationEdge } from "../graph-HMWAldoR.mjs";
+export { type MigrationEdge, type MigrationGraph };

package/dist/exports/graph.mjs

@@ -0,0 +1 @@
+export {};

package/dist/exports/hash.d.mts

@@ -0,0 +1,52 @@
+import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-BjiZ7KDy.mjs";
+import { n as MigrationMetadata } from "../metadata-CFvm3ayn.mjs";
+
+//#region src/hash.d.ts
+interface VerifyResult {
+  readonly ok: boolean;
+  readonly reason?: 'mismatch';
+  readonly storedHash: string;
+  readonly computedHash: string;
+}
+/**
+ * Content-addressed migration hash over (metadata envelope sans
+ * contracts/hints/signature, ops). See ADR 199 — Storage-only migration
+ * identity for the rationale: contracts are anchored separately by the
+ * storage-hash bookends inside the envelope; planner hints are advisory
+ * and must not affect identity.
+ *
+ * The integrity check is purely structural, not semantic. The function
+ * canonicalizes its inputs via `sortKeys` (recursive) + `JSON.stringify`
+ * and hashes the result. Target-specific operation payloads (`step.sql`,
+ * Mongo's pipeline AST, …) are hashed verbatim — no per-target
+ * normalization is required, because what's being verified is "do the
+ * on-disk bytes still produce their recorded hash", not "do two
+ * semantically-equivalent migrations hash the same". The latter is an
+ * emit-drift concern (ADR 192 step 2).
+ *
+ * The symmetry across write and read holds because `JSON.parse(
+ * JSON.stringify(x))` round-trips JSON-safe values losslessly and
+ * `sortKeys` is idempotent and deterministic — write-time and read-time
+ * canonicalization produce the same canonical bytes regardless of
+ * source-side key ordering or whitespace.
+ *
+ * The `migrationHash` field on the metadata is stripped before hashing
+ * so the function can be used both at write time (when no hash exists
+ * yet) and at verify time (rehashing an already-attested record).
+ */
+declare function computeMigrationHash(metadata: Omit<MigrationMetadata, 'migrationHash'> & {
+  readonly migrationHash?: string;
+}, ops: MigrationOps): string;
+/**
+ * Re-hash an in-memory migration package and compare against the stored
+ * `migrationHash`. See `computeMigrationHash` for the canonicalization rules.
+ *
+ * Returns `{ ok: true }` when the package is internally consistent, or
+ * `{ ok: false, reason: 'mismatch', storedHash, computedHash }` when it is
+ * not — typically a sign of FS corruption, partial writes, or a post-emit
+ * hand edit.
+ */
+declare function verifyMigrationHash(pkg: OnDiskMigrationPackage): VerifyResult;
+//#endregion
+export { type VerifyResult, computeMigrationHash, verifyMigrationHash };
+//# sourceMappingURL=hash.d.mts.map

package/dist/exports/hash.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.mts","names":[],"sources":["../../src/hash.ts"],"mappings":";;;;UAKiB,YAAA;EAAA,SACN,EAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;EAAA,SACA,YAAA;AAAA;;;;;;;AAiCX;;;;;;;;;;;;;;;;AA+BA;;;;iBA/BgB,oBAAA,CACd,QAAA,EAAU,IAAA,CAAK,iBAAA;EAAA,SAAiD,aAAA;AAAA,GAChE,GAAA,EAAK,YAAA;;;;;;;;;;iBA6BS,mBAAA,CAAoB,GAAA,EAAK,sBAAA,GAAyB,YAAA"}

package/dist/exports/hash.mjs

@@ -0,0 +1,2 @@
+import { n as verifyMigrationHash, t as computeMigrationHash } from "../hash-By50zM_E.mjs";
+export { computeMigrationHash, verifyMigrationHash };

package/dist/exports/invariants.d.mts

@@ -0,0 +1,34 @@
+import { t as MigrationOps } from "../package-BjiZ7KDy.mjs";
+
+//#region src/invariants.d.ts
+/**
+ * Hygiene check for `invariantId`. Rejects empty values plus any
+ * whitespace or control character (including Unicode whitespace like
+ * NBSP and em space, which are visually identical to ASCII space and
+ * routinely sneak in via paste).
+ */
+declare function validateInvariantId(invariantId: string): boolean;
+/**
+ * Walk a migration's operations and produce its `providedInvariants`
+ * aggregate: the sorted, deduplicated list of `invariantId`s declared
+ * by ops in the migration. Ops without an `invariantId` are skipped.
+ *
+ * Both `data`-class ops (data-transforms, e.g. backfills) and
+ * `additive`-class opaque DDL (e.g. cipherstash's vendored EQL bundle
+ * via `installEqlBundleOp`) may declare invariantIds: the
+ * `operationClass` axis classifies *policy gating* (which kinds of ops
+ * a `db init` / `db update` policy permits), while `invariantId`
+ * classifies *marker bookkeeping* (which named bundles of work a
+ * future regeneration knows to skip). The two concerns are
+ * intentionally orthogonal — an extension can ship additive
+ * non-IR-derivable DDL (the only way the planner can know the bundle
+ * is already applied is via the invariantId on the marker) without
+ * needing to mis-classify it as `data`-class.
+ *
+ * Throws `MIGRATION.INVALID_INVARIANT_ID` on a malformed id and
+ * `MIGRATION.DUPLICATE_INVARIANT_IN_EDGE` on duplicates.
+ */
+declare function deriveProvidedInvariants(ops: MigrationOps): readonly string[];
+//#endregion
+export { deriveProvidedInvariants, validateInvariantId };
+//# sourceMappingURL=invariants.d.mts.map

package/dist/exports/invariants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariants.d.mts","names":[],"sources":["../../src/invariants.ts"],"mappings":";;;;;AAUA;;;;iBAAgB,mBAAA,CAAoB,WAAA;AAyBpC;;;;;;;;;;;;;;;;;;;;AAAA,iBAAgB,wBAAA,CAAyB,GAAA,EAAK,YAAA"}

package/dist/exports/invariants.mjs

@@ -0,0 +1,2 @@
+import { n as validateInvariantId, t as deriveProvidedInvariants } from "../invariants-Duc8f9NM.mjs";
+export { deriveProvidedInvariants, validateInvariantId };

package/dist/exports/io.d.mts

@@ -1,7 +1,67 @@
-import { a as MigrationManifest, o as MigrationOps, t as MigrationBundle } from "../types-DyGXcWWp.mjs";
+import { n as OnDiskMigrationPackage, t as MigrationOps } from "../package-BjiZ7KDy.mjs";
+import { MigrationMetadata, MigrationPackage } from "@prisma-next/framework-components/control";
 
 //#region src/io.d.ts
-declare function writeMigrationPackage(dir: string, manifest: MigrationManifest, ops: MigrationOps): Promise<void>;
+declare function writeMigrationPackage(dir: string, metadata: MigrationMetadata, ops: MigrationOps): Promise<void>;
+/**
+ * Materialise an in-memory {@link MigrationPackage} to a per-space
+ * directory on disk.
+ *
+ * Writes three files under `<targetDir>/<pkg.dirName>/`:
+ *
+ * - `migration.json` — the manifest (pretty-printed, matches
+ *   {@link writeMigrationPackage}'s output for byte-for-byte parity with
+ *   app-space migrations).
+ * - `ops.json` — the operation list (pretty-printed).
+ * - `contract.json` — the canonical-JSON serialisation of
+ *   `metadata.toContract`. This is the per-package post-state contract
+ *   snapshot; the canonicalisation pass guarantees byte-determinism so
+ *   re-emitting the same package across machines / runs produces an
+ *   identical file.
+ *
+ * Distinct verb from the lower-level {@link writeMigrationPackage}
+ * (which takes constituent `(metadata, ops)`): callers reading
+ * `materialise…` know they are persisting a struct-typed package
+ * including its contract-snapshot side car.
+ *
+ * Overwrite-idempotent: the per-package directory is cleared before
+ * each emit, so re-running against the same `targetDir` produces
+ * byte-identical contents and never leaves stale files behind. The
+ * spec's "re-emitting the same package across runs / machines produces
+ * byte-identical files" guarantee (§ 3) covers both same-dir and
+ * fresh-dir re-emits. The lower-level {@link writeMigrationPackage}
+ * stays strict because the CLI authoring path (`migration plan` /
+ * `migration new`) deliberately refuses to clobber an existing
+ * authored migration; this helper is the re-emit path that is
+ * supposed to converge on a single canonical on-disk shape.
+ *
+ * @see specs/framework-mechanism.spec.md § 3 — Emission helper (T1.7).
+ */
+declare function materialiseMigrationPackage(targetDir: string, pkg: MigrationPackage): Promise<void>;
+/**
+ * Idempotent variant of {@link materialiseMigrationPackage}: writes the
+ * package only if `<targetDir>/<pkg.dirName>/` does not already exist on
+ * disk as a directory; returns `{ written: false }` when the package
+ * directory is present (no rewrite, no comparison — by-existence skip).
+ *
+ * Concretely:
+ *   - existing directory → skip silently, return `{ written: false }`.
+ *   - missing path → write three files via {@link materialiseMigrationPackage},
+ *     return `{ written: true }`.
+ *   - path exists but is not a directory (file/symlink) → treated as
+ *     missing; {@link materialiseMigrationPackage} will attempt creation
+ *     and fail with an appropriate OS error.
+ *   - any other I/O error from `stat` → propagated unchanged.
+ *
+ * Used by the CLI's `runContractSpaceExtensionMigrationsPass` to
+ * materialise extension migration packages into a project's
+ * `migrations/<spaceId>/` directory, and by extension-package tests
+ * that mirror the same idempotent-rematerialise property locally
+ * without taking a CLI dependency.
+ */
+declare function materialiseExtensionMigrationPackageIfMissing(targetDir: string, pkg: MigrationPackage): Promise<{
+  readonly written: boolean;
+}>;
 /**
  * Copy a list of files into `destDir`, optionally renaming each one.
  *
@@ -17,11 +77,11 @@ declare function copyFilesWithRename(destDir: string, files: readonly {
   readonly sourcePath: string;
   readonly destName: string;
 }[]): Promise<void>;
-declare function writeMigrationManifest(dir: string, manifest: MigrationManifest): Promise<void>;
+declare function writeMigrationMetadata(dir: string, metadata: MigrationMetadata): Promise<void>;
 declare function writeMigrationOps(dir: string, ops: MigrationOps): Promise<void>;
-declare function readMigrationPackage(dir: string): Promise<MigrationBundle>;
-declare function readMigrationsDir(migrationsRoot: string): Promise<readonly MigrationBundle[]>;
+declare function readMigrationPackage(dir: string): Promise<OnDiskMigrationPackage>;
+declare function readMigrationsDir(migrationsRoot: string): Promise<readonly OnDiskMigrationPackage[]>;
 declare function formatMigrationDirName(timestamp: Date, slug: string): string;
 //#endregion
-export { copyFilesWithRename, formatMigrationDirName, readMigrationPackage, readMigrationsDir, writeMigrationManifest, writeMigrationOps, writeMigrationPackage };
+export { copyFilesWithRename, formatMigrationDirName, materialiseExtensionMigrationPackageIfMissing, materialiseMigrationPackage, readMigrationPackage, readMigrationsDir, writeMigrationMetadata, writeMigrationOps, writeMigrationPackage };
 //# sourceMappingURL=io.d.mts.map

package/dist/exports/io.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"io.d.mts","names":[],"sources":["../../src/io.ts"],"sourcesContent":[],"mappings":";;;iBAwDsB,qBAAA,wBAEV,wBACL,eACJ;;AAJH;;;;;AA+BA;AAaA;AAOA;AAIA;AAkEA;AAiCgB,iBA3HM,mBAAA,CA2H4B,OAAI,EAAA,MAAA,EAAA,KAAA,EAAA,SAAA;;;MAxHnD;iBAUmB,sBAAA,wBAEV,oBACT;iBAImB,iBAAA,mBAAoC,eAAe;iBAInD,oBAAA,eAAmC,QAAQ;iBAkE3C,iBAAA,0BAEnB,iBAAiB;iBA+BJ,sBAAA,YAAkC"}
+{"version":3,"file":"io.d.mts","names":[],"sources":["../../src/io.ts"],"mappings":";;;;iBA0DsB,qBAAA,CACpB,GAAA,UACA,QAAA,EAAU,iBAAA,EACV,GAAA,EAAK,YAAA,GACJ,OAAA;AAJH;;;;;;;;;;;;;;;;AAwDA;;;;;;;;;;AAiCA;;;;;;;;AAzFA,iBAwDsB,2BAAA,CACpB,SAAA,UACA,GAAA,EAAK,gBAAA,GACJ,OAAA;;;AA8DH;;;;;;;;;;;AAaA;;;;;;;;iBA7CsB,6CAAA,CACpB,SAAA,UACA,GAAA,EAAK,gBAAA,GACJ,OAAA;EAAA,SAAmB,OAAA;AAAA;;;;;;;;;;AAqDtB;;iBAxBsB,mBAAA,CACpB,OAAA,UACA,KAAA;EAAA,SAA2B,UAAA;EAAA,SAA6B,QAAA;AAAA,MACvD,OAAA;AAAA,iBAUmB,sBAAA,CACpB,GAAA,UACA,QAAA,EAAU,iBAAA,GACT,OAAA;AAAA,iBAImB,iBAAA,CAAkB,GAAA,UAAa,GAAA,EAAK,YAAA,GAAe,OAAA;AAAA,iBAInD,oBAAA,CAAqB,GAAA,WAAc,OAAA,CAAQ,sBAAA;AAAA,iBAiG3C,iBAAA,CACpB,cAAA,WACC,OAAA,UAAiB,sBAAA;AAAA,iBA+BJ,sBAAA,CAAuB,SAAA,EAAW,IAAA,EAAM,IAAA"}

package/dist/exports/io.mjs

@@ -1,3 +1,2 @@
-import { a as writeMigrationManifest, i as readMigrationsDir, n as formatMigrationDirName, o as writeMigrationOps, r as readMigrationPackage, s as writeMigrationPackage, t as copyFilesWithRename } from "../io-Cd6GLyjK.mjs";
-
-export { copyFilesWithRename, formatMigrationDirName, readMigrationPackage, readMigrationsDir, writeMigrationManifest, writeMigrationOps, writeMigrationPackage };
+import { a as materialiseMigrationPackage, c as writeMigrationMetadata, i as materialiseExtensionMigrationPackageIfMissing, l as writeMigrationOps, n as copyFilesWithRename, o as readMigrationPackage, r as formatMigrationDirName, s as readMigrationsDir, u as writeMigrationPackage } from "../io-D13dLvUh.mjs";
+export { copyFilesWithRename, formatMigrationDirName, materialiseExtensionMigrationPackageIfMissing, materialiseMigrationPackage, readMigrationPackage, readMigrationsDir, writeMigrationMetadata, writeMigrationOps, writeMigrationPackage };

package/dist/exports/metadata.d.mts

@@ -0,0 +1,2 @@
+import { n as MigrationMetadata, t as MigrationHints } from "../metadata-CFvm3ayn.mjs";
+export { type MigrationHints, type MigrationMetadata };

package/dist/exports/metadata.mjs

@@ -0,0 +1 @@
+export {};

package/dist/exports/migration-graph.d.mts

@@ -0,0 +1,2 @@
+import { a as findLeaf, c as findPathWithInvariants, i as findLatestMigration, l as findReachableLeaves, n as detectCycles, o as findPath, r as detectOrphans, s as findPathWithDecision, t as PathDecision, u as reconstructGraph } from "../migration-graph-DulOITvG.mjs";
+export { type PathDecision, detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findPathWithInvariants, findReachableLeaves, reconstructGraph };

package/dist/exports/migration-graph.mjs

@@ -0,0 +1,2 @@
+import { a as findPath, c as findReachableLeaves, i as findLeaf, l as reconstructGraph, n as detectOrphans, o as findPathWithDecision, r as findLatestMigration, s as findPathWithInvariants, t as detectCycles } from "../migration-graph-DGNnKDY5.mjs";
+export { detectCycles, detectOrphans, findLatestMigration, findLeaf, findPath, findPathWithDecision, findPathWithInvariants, findReachableLeaves, reconstructGraph };

package/dist/exports/migration-ts.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-ts.d.mts","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"sourcesContent":[],"mappings":";;AA8BA;AAsBA;;;;ACpDA;AAEA;AAMA;;;;;;;;;;;;;;;iBDsBsB,gBAAA,uCAAuD;;;;iBAsBvD,cAAA,sBAAoC;;;KCpD9C,eAAA;AD8BU,iBC5BN,qBAAA,CAAA,CD4BoE,EC5B3C,eD4B2C;AAsB9D,iBC5CN,cAAA,CD4C0C,OAAO,EC5CzB,eD4CyB,CAAA,EAAA,MAAA"}
+{"version":3,"file":"migration-ts.d.mts","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"mappings":";;AA8BA;;;;;;;;;AAsBA;;;;;;;;ACpDA;;;;;iBD8BsB,gBAAA,CAAiB,UAAA,UAAoB,OAAA,WAAkB,OAAA;;;;iBAsBvD,cAAA,CAAe,UAAA,WAAqB,OAAA;;;KCpD9C,eAAA;AAAA,iBAEI,qBAAA,CAAA,GAAyB,eAAA;AAAA,iBAMzB,cAAA,CAAe,OAAA,EAAS,eAAA"}

package/dist/exports/migration-ts.mjs

@@ -1,7 +1,6 @@
-import { stat, writeFile } from "node:fs/promises";
 import { join } from "pathe";
+import { stat, writeFile } from "node:fs/promises";
 import { format } from "prettier";
-
 //#region src/migration-ts.ts
 /**
 * Utilities for reading/writing `migration.ts` files.
@@ -50,7 +49,6 @@ async function hasMigrationTs(packageDir) {
 		return false;
 	}
 }
-
 //#endregion
 //#region src/runtime-detection.ts
 function detectScaffoldRuntime() {
@@ -65,7 +63,7 @@ function shebangLineFor(runtime) {
 		case "node": return "#!/usr/bin/env -S node";
 	}
 }
-
 //#endregion
 export { detectScaffoldRuntime, hasMigrationTs, shebangLineFor, writeMigrationTs };
+
 //# sourceMappingURL=migration-ts.mjs.map

package/dist/exports/migration-ts.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"migration-ts.mjs","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"sourcesContent":["/**\n * Utilities for reading/writing `migration.ts` files.\n *\n * Rendering migration.ts source is the target's responsibility — the CLI\n * obtains source strings from a planner's `plan.renderTypeScript()`. The\n * helper here is limited to file I/O: writing the returned source with the\n * right executable bit and probing for existence.\n */\n\nimport { stat, writeFile } from 'node:fs/promises';\nimport { join } from 'pathe';\nimport { format } from 'prettier';\n\nconst MIGRATION_TS_FILE = 'migration.ts';\n\n/**\n * Writes a pre-rendered `migration.ts` source string to the given package\n * directory. If the source begins with a shebang, the file is written with\n * executable permissions (0o755) so it can be run directly via\n * `./migration.ts` — the rendered scaffold ends with\n * `MigrationCLI.run(import.meta.url, M)` from\n * `@prisma-next/cli/migration-cli` (re-exported by the postgres facade),\n * which guards on the entrypoint and serializes when the file is the main\n * module.\n *\n * The source is run through prettier before writing so migration renderers\n * can produce structurally-correct but loosely-indented source and rely on\n * a single canonical format on disk. Matches what `@prisma-next/emitter`\n * already does for generated `contract.d.ts`.\n */\nexport async function writeMigrationTs(packageDir: string, content: string): Promise<void> {\n  const formatted = await formatMigrationTsSource(content);\n  const isExecutable = formatted.startsWith('#!');\n  await writeFile(\n    join(packageDir, MIGRATION_TS_FILE),\n    formatted,\n    isExecutable ? { mode: 0o755 } : undefined,\n  );\n}\n\nasync function formatMigrationTsSource(source: string): Promise<string> {\n  return format(source, {\n    parser: 'typescript',\n    singleQuote: true,\n    semi: true,\n    printWidth: 100,\n  });\n}\n\n/**\n * Checks whether a migration.ts file exists in the package directory.\n */\nexport async function hasMigrationTs(packageDir: string): Promise<boolean> {\n  try {\n    const s = await stat(join(packageDir, MIGRATION_TS_FILE));\n    return s.isFile();\n  } catch {\n    return false;\n  }\n}\n","export type ScaffoldRuntime = 'node' | 'bun' | 'deno';\n\nexport function detectScaffoldRuntime(): ScaffoldRuntime {\n  if (typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined') return 'bun';\n  if (typeof (globalThis as { Deno?: unknown }).Deno !== 'undefined') return 'deno';\n  return 'node';\n}\n\nexport function shebangLineFor(runtime: ScaffoldRuntime): string {\n  switch (runtime) {\n    case 'bun':\n      return '#!/usr/bin/env -S bun';\n    case 'deno':\n      return '#!/usr/bin/env -S deno run -A';\n    case 'node':\n      return '#!/usr/bin/env -S node';\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAM,oBAAoB;;;;;;;;;;;;;;;;AAiB1B,eAAsB,iBAAiB,YAAoB,SAAgC;CACzF,MAAM,YAAY,MAAM,wBAAwB,QAAQ;CACxD,MAAM,eAAe,UAAU,WAAW,KAAK;AAC/C,OAAM,UACJ,KAAK,YAAY,kBAAkB,EACnC,WACA,eAAe,EAAE,MAAM,KAAO,GAAG,OAClC;;AAGH,eAAe,wBAAwB,QAAiC;AACtE,QAAO,OAAO,QAAQ;EACpB,QAAQ;EACR,aAAa;EACb,MAAM;EACN,YAAY;EACb,CAAC;;;;;AAMJ,eAAsB,eAAe,YAAsC;AACzE,KAAI;AAEF,UADU,MAAM,KAAK,KAAK,YAAY,kBAAkB,CAAC,EAChD,QAAQ;SACX;AACN,SAAO;;;;;;ACvDX,SAAgB,wBAAyC;AACvD,KAAI,OAAQ,WAAiC,QAAQ,YAAa,QAAO;AACzE,KAAI,OAAQ,WAAkC,SAAS,YAAa,QAAO;AAC3E,QAAO;;AAGT,SAAgB,eAAe,SAAkC;AAC/D,SAAQ,SAAR;EACE,KAAK,MACH,QAAO;EACT,KAAK,OACH,QAAO;EACT,KAAK,OACH,QAAO"}
+{"version":3,"file":"migration-ts.mjs","names":[],"sources":["../../src/migration-ts.ts","../../src/runtime-detection.ts"],"sourcesContent":["/**\n * Utilities for reading/writing `migration.ts` files.\n *\n * Rendering migration.ts source is the target's responsibility — the CLI\n * obtains source strings from a planner's `plan.renderTypeScript()`. The\n * helper here is limited to file I/O: writing the returned source with the\n * right executable bit and probing for existence.\n */\n\nimport { stat, writeFile } from 'node:fs/promises';\nimport { join } from 'pathe';\nimport { format } from 'prettier';\n\nconst MIGRATION_TS_FILE = 'migration.ts';\n\n/**\n * Writes a pre-rendered `migration.ts` source string to the given package\n * directory. If the source begins with a shebang, the file is written with\n * executable permissions (0o755) so it can be run directly via\n * `./migration.ts` — the rendered scaffold ends with\n * `MigrationCLI.run(import.meta.url, M)` from\n * `@prisma-next/cli/migration-cli` (re-exported by the postgres facade),\n * which guards on the entrypoint and serializes when the file is the main\n * module.\n *\n * The source is run through prettier before writing so migration renderers\n * can produce structurally-correct but loosely-indented source and rely on\n * a single canonical format on disk. Matches what `@prisma-next/emitter`\n * already does for generated `contract.d.ts`.\n */\nexport async function writeMigrationTs(packageDir: string, content: string): Promise<void> {\n  const formatted = await formatMigrationTsSource(content);\n  const isExecutable = formatted.startsWith('#!');\n  await writeFile(\n    join(packageDir, MIGRATION_TS_FILE),\n    formatted,\n    isExecutable ? { mode: 0o755 } : undefined,\n  );\n}\n\nasync function formatMigrationTsSource(source: string): Promise<string> {\n  return format(source, {\n    parser: 'typescript',\n    singleQuote: true,\n    semi: true,\n    printWidth: 100,\n  });\n}\n\n/**\n * Checks whether a migration.ts file exists in the package directory.\n */\nexport async function hasMigrationTs(packageDir: string): Promise<boolean> {\n  try {\n    const s = await stat(join(packageDir, MIGRATION_TS_FILE));\n    return s.isFile();\n  } catch {\n    return false;\n  }\n}\n","export type ScaffoldRuntime = 'node' | 'bun' | 'deno';\n\nexport function detectScaffoldRuntime(): ScaffoldRuntime {\n  if (typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined') return 'bun';\n  if (typeof (globalThis as { Deno?: unknown }).Deno !== 'undefined') return 'deno';\n  return 'node';\n}\n\nexport function shebangLineFor(runtime: ScaffoldRuntime): string {\n  switch (runtime) {\n    case 'bun':\n      return '#!/usr/bin/env -S bun';\n    case 'deno':\n      return '#!/usr/bin/env -S deno run -A';\n    case 'node':\n      return '#!/usr/bin/env -S node';\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,MAAM,oBAAoB;;;;;;;;;;;;;;;;AAiB1B,eAAsB,iBAAiB,YAAoB,SAAgC;CACzF,MAAM,YAAY,MAAM,wBAAwB,QAAQ;CACxD,MAAM,eAAe,UAAU,WAAW,KAAK;CAC/C,MAAM,UACJ,KAAK,YAAY,kBAAkB,EACnC,WACA,eAAe,EAAE,MAAM,KAAO,GAAG,KAAA,EAClC;;AAGH,eAAe,wBAAwB,QAAiC;CACtE,OAAO,OAAO,QAAQ;EACpB,QAAQ;EACR,aAAa;EACb,MAAM;EACN,YAAY;EACb,CAAC;;;;;AAMJ,eAAsB,eAAe,YAAsC;CACzE,IAAI;EAEF,QAAO,MADS,KAAK,KAAK,YAAY,kBAAkB,CAAC,EAChD,QAAQ;SACX;EACN,OAAO;;;;;ACvDX,SAAgB,wBAAyC;CACvD,IAAI,OAAQ,WAAiC,QAAQ,aAAa,OAAO;CACzE,IAAI,OAAQ,WAAkC,SAAS,aAAa,OAAO;CAC3E,OAAO;;AAGT,SAAgB,eAAe,SAAkC;CAC/D,QAAQ,SAAR;EACE,KAAK,OACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,QACH,OAAO"}

package/dist/exports/migration.d.mts

@@ -1,11 +1,10 @@
-import { a as MigrationManifest } from "../types-DyGXcWWp.mjs";
+import { n as MigrationMetadata$1 } from "../metadata-CFvm3ayn.mjs";
 import { ControlStack, MigrationPlan, MigrationPlanOperation } from "@prisma-next/framework-components/control";
 
 //#region src/migration-base.d.ts
 interface MigrationMeta {
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
-  readonly kind?: 'regular' | 'baseline';
   readonly labels?: readonly string[];
 }
 /**
@@ -13,7 +12,7 @@ interface MigrationMeta {
  *
  * A `Migration` subclass is itself a `MigrationPlan`: CLI commands and the
  * runner can consume it directly via `targetId`, `operations`, `origin`, and
- * `destination`. The manifest-shaped inputs come from `describe()`, which
+ * `destination`. The metadata-shaped inputs come from `describe()`, which
  * every migration must implement — `migration.json` is required for a
  * migration to be valid.
  */
@@ -58,30 +57,32 @@ declare abstract class Migration<TOperation extends MigrationPlanOperation = Mig
  * than executed directly.
  */
 declare function isDirectEntrypoint(importMetaUrl: string): boolean;
-declare function printMigrationHelp(): void;
 /**
  * In-memory artifacts produced from a `Migration` instance: the
- * serialized `ops.json` body, the `migration.json` manifest object, and
+ * serialized `ops.json` body, the `migration.json` metadata object, and
  * its serialized form. Returned by `buildMigrationArtifacts` so callers
  * (today: `MigrationCLI.run` in `@prisma-next/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 manifest: MigrationManifest;
-  readonly manifestJson: string;
+  readonly metadata: MigrationMetadata$1;
+  readonly metadataJson: string;
 }
 /**
  * Pure conversion from a `Migration` instance (plus the previously
- * scaffolded manifest, when one exists on disk) to the in-memory
+ * scaffolded metadata, when one exists on disk) to the in-memory
  * artifacts that downstream tooling persists. Owns metadata validation,
- * manifest synthesis/preservation, hint normalization, and the
- * content-addressed `migrationId` computation, but performs no file I/O
+ * metadata synthesis/preservation, hint normalization, and the
+ * content-addressed `migrationHash` computation, but performs no file I/O
  * — callers handle reads (to source `existing`) and writes (to persist
- * `opsJson` / `manifestJson`).
+ * `opsJson` / `metadataJson`).
  */
-declare function buildMigrationArtifacts(instance: Migration, existing: Partial<MigrationManifest> | null): MigrationArtifacts;
+declare function buildMigrationArtifacts(instance: Migration, existing: Partial<MigrationMetadata$1> | null): MigrationArtifacts;
 //#endregion
-export { Migration, type MigrationArtifacts, type MigrationMeta, buildMigrationArtifacts, isDirectEntrypoint, printMigrationHelp };
+export { Migration, type MigrationArtifacts, type MigrationMeta, buildMigrationArtifacts, isDirectEntrypoint };
 //# sourceMappingURL=migration.d.mts.map

package/dist/exports/migration.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration.d.mts","names":[],"sources":["../../src/migration-base.ts"],"sourcesContent":[],"mappings":";;;;UAaiB,aAAA;;EAAA,SAAA,EAAA,EAAA,MAAa;EAuBR,SAAA,IAAS,CAAA,EAAA,SAAA,GAAA,UAAA;EACV,SAAA,MAAA,CAAA,EAAA,SAAA,MAAA,EAAA;;;;;;;;;;;AAGK,uBAJJ,SAII,CAAA,mBAHL,sBAGK,GAHoB,sBAGpB,EAAA,kBAAA,MAAA,GAAA,MAAA,EAAA,kBAAA,MAAA,GAAA,MAAA,CAAA,YAAb,aAAa,CAAA;EAuDV,kBAAA,QAAkB,EAAA,MAAA;EAWlB;AAyBhB;AAyEA;;;;;;;4BAvJ4B,aAAa,WAAW;sBAE9B,aAAa,WAAW;;;;;;;sCAUR;;;;;;uBAOf;;;;;;;;;;;;;;;iBAuBP,kBAAA;iBAWA,kBAAA,CAAA;;;;;;;;;UAyBC,kBAAA;;qBAEI;;;;;;;;;;;;iBAuEL,uBAAA,WACJ,qBACA,QAAQ,4BACjB"}
+{"version":3,"file":"migration.d.mts","names":[],"sources":["../../src/migration-base.ts"],"mappings":";;;;UAiBiB,aAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA;EAAA,SACA,MAAA;AAAA;;;;;;;AAuBX;;;uBAAsB,SAAA,oBACD,sBAAA,GAAyB,sBAAA,mFAGjC,aAAA;EAAA,kBAEO,QAAA;EAWqB;;;;;;;;;EAAA,mBAApB,KAAA,EAAO,YAAA,CAAa,SAAA,EAAW,SAAA;cAEtC,KAAA,GAAQ,YAAA,CAAa,SAAA,EAAW,SAAA;EAlB5C;;;;;;EAAA,aA4Ba,UAAA,CAAA,YAAuB,UAAA;EAZjB;;;;;EAAA,SAmBV,QAAA,CAAA,GAAY,aAAA;EAAA,IAEjB,MAAA,CAAA;IAAA,SAAqB,WAAA;EAAA;EAAA,IAKrB,WAAA,CAAA;IAAA,SAA0B,WAAA;EAAA;AAAA;;;;;;;AAYhC;iBAAgB,kBAAA,CAAmB,aAAA;;;;AAsBnC;;;;;;;;UAAiB,kBAAA;EAAA,SACN,OAAA;EAAA,SACA,QAAA,EAAU,mBAAA;EAAA,SACV,YAAA;AAAA;;;;;;;;;;iBAmHK,uBAAA,CACd,QAAA,EAAU,SAAA,EACV,QAAA,EAAU,OAAA,CAAQ,mBAAA,WACjB,kBAAA"}