@nekostack/schema 1.0.0

package/dist/src/ir/serialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.js","sourceRoot":"","sources":["../../../src/ir/serialize.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,IAAgB;IAC1C,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED,SAAS,YAAY,CAAC,KAAc;IAClC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IACzD,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAe,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QACtD,MAAM,CAAC,GAAI,KAAiC,CAAC,GAAG,CAAC,CAAC;QAClD,IAAI,CAAC,KAAK,SAAS;YAAE,SAAS;QAC9B,GAAG,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/src/migrations/build-migration-registry.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `buildMigrationRegistry(entries)` — pure migration-registry
+ * constructor (v0.8 Step 3).
+ *
+ * Walks the CLI-supplied `MigrationSourceEntry[]` (one per loaded
+ * `*.migration.ts` file) and builds the three-level lookup map
+ * `MigrationRegistry = ReadonlyMap<schemaId, ReadonlyMap<fromVersion,
+ * ReadonlyMap<toVersion, MigrationEntry>>>`. Returns
+ * `Result<MigrationRegistry>` — never throws.
+ *
+ * **Pure.** No `fs.*`, no `import()`, no `path.*`. The CLI is
+ * responsible for reading the source text and dynamic-importing the
+ * migration files; this function takes the loaded data and indexes
+ * it. Master plan Decision #1 boundary applies.
+ *
+ * Failure-mode contract (v0.8 Round-2 lock — intentional departure
+ * from v0.7 Decision #5):
+ *
+ * - **Malformed / missing provenance is fail-loud.** Every entry's
+ *   `sourceText` runs through `parseMigrationProvenanceFromText`.
+ *   Failures from the parser surface as `Result.failure` Issues
+ *   with the migration's `sourcePath` attached via the issue's
+ *   `path` so the CLI can pinpoint which file is bad.
+ * - **Duplicate `(schemaId, fromVersion, toVersion)` triples** are
+ *   collected as `duplicate_migration` Issues. The first-seen entry
+ *   stays in the partial map so a single call doesn't return a
+ *   torn lookup state.
+ *
+ * Both failure classes are **collected** across the full entry list
+ * — `buildMigrationRegistry` never short-circuits on the first
+ * problem. The returned `Result.failure` carries every Issue in one
+ * payload so the CLI can render a single human-readable report.
+ *
+ * **Provenance ↔ source-entry binding is a soft check.** The
+ * provenance header carries its own `schemaId / fromVersion /
+ * toVersion`; the `MigrationSourceEntry.migration` value also has
+ * `schemaId / from / to` fields. v0.8 indexes by the *provenance*
+ * triple. If the loaded `migration` default-export disagrees with
+ * its header, that's a separate verification concern (the runtime
+ * vs. recorded provenance) and is not a registry-construction
+ * failure. Step 5's verifier picks it up later if it matters.
+ */
+import type { Result } from "../errors/issue.js";
+import type { MigrationRegistry, MigrationSourceEntry } from "./types.js";
+export declare function buildMigrationRegistry(entries: readonly MigrationSourceEntry[]): Result<MigrationRegistry>;
+//# sourceMappingURL=build-migration-registry.d.ts.map

package/dist/src/migrations/build-migration-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-migration-registry.d.ts","sourceRoot":"","sources":["../../../src/migrations/build-migration-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAoB,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAKnE,OAAO,KAAK,EAEV,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAMpB,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,oBAAoB,EAAE,GACvC,MAAM,CAAC,iBAAiB,CAAC,CAuD3B"}

package/dist/src/migrations/build-migration-registry.js

@@ -0,0 +1,134 @@
+/**
+ * `buildMigrationRegistry(entries)` — pure migration-registry
+ * constructor (v0.8 Step 3).
+ *
+ * Walks the CLI-supplied `MigrationSourceEntry[]` (one per loaded
+ * `*.migration.ts` file) and builds the three-level lookup map
+ * `MigrationRegistry = ReadonlyMap<schemaId, ReadonlyMap<fromVersion,
+ * ReadonlyMap<toVersion, MigrationEntry>>>`. Returns
+ * `Result<MigrationRegistry>` — never throws.
+ *
+ * **Pure.** No `fs.*`, no `import()`, no `path.*`. The CLI is
+ * responsible for reading the source text and dynamic-importing the
+ * migration files; this function takes the loaded data and indexes
+ * it. Master plan Decision #1 boundary applies.
+ *
+ * Failure-mode contract (v0.8 Round-2 lock — intentional departure
+ * from v0.7 Decision #5):
+ *
+ * - **Malformed / missing provenance is fail-loud.** Every entry's
+ *   `sourceText` runs through `parseMigrationProvenanceFromText`.
+ *   Failures from the parser surface as `Result.failure` Issues
+ *   with the migration's `sourcePath` attached via the issue's
+ *   `path` so the CLI can pinpoint which file is bad.
+ * - **Duplicate `(schemaId, fromVersion, toVersion)` triples** are
+ *   collected as `duplicate_migration` Issues. The first-seen entry
+ *   stays in the partial map so a single call doesn't return a
+ *   torn lookup state.
+ *
+ * Both failure classes are **collected** across the full entry list
+ * — `buildMigrationRegistry` never short-circuits on the first
+ * problem. The returned `Result.failure` carries every Issue in one
+ * payload so the CLI can render a single human-readable report.
+ *
+ * **Provenance ↔ source-entry binding is a soft check.** The
+ * provenance header carries its own `schemaId / fromVersion /
+ * toVersion`; the `MigrationSourceEntry.migration` value also has
+ * `schemaId / from / to` fields. v0.8 indexes by the *provenance*
+ * triple. If the loaded `migration` default-export disagrees with
+ * its header, that's a separate verification concern (the runtime
+ * vs. recorded provenance) and is not a registry-construction
+ * failure. Step 5's verifier picks it up later if it matters.
+ */
+import { parseMigrationProvenanceFromText, } from "./parse-provenance.js";
+// =============================================================================
+// Public surface
+// =============================================================================
+export function buildMigrationRegistry(entries) {
+    const out = new Map();
+    const issues = [];
+    for (const entry of entries) {
+        const parsed = parseMigrationProvenanceFromText(entry.sourceText);
+        if (!parsed.success) {
+            // Re-key each parser failure to the offending file's
+            // sourcePath so the CLI can pinpoint the bad file without
+            // grepping the message text.
+            for (const issue of parsed.issues) {
+                issues.push(attachSourcePath(issue, entry.sourcePath));
+            }
+            continue;
+        }
+        const migrationEntry = buildEntry(entry, parsed.data);
+        const { schemaId, fromVersion, toVersion } = migrationEntry;
+        let byFrom = out.get(schemaId);
+        if (byFrom === undefined) {
+            byFrom = new Map();
+            out.set(schemaId, byFrom);
+        }
+        let byTo = byFrom.get(fromVersion);
+        if (byTo === undefined) {
+            byTo = new Map();
+            byFrom.set(fromVersion, byTo);
+        }
+        const existing = byTo.get(toVersion);
+        if (existing !== undefined) {
+            issues.push(duplicateMigrationIssue(schemaId, fromVersion, toVersion, [existing.sourcePath, entry.sourcePath]));
+            // Keep the first-seen entry. Same rule as `buildRegistry`'s
+            // duplicate handling (v0.7): re-indexing would let the
+            // duplicate replace the original silently — the exact failure
+            // mode this Result is meant to surface.
+            continue;
+        }
+        byTo.set(toVersion, migrationEntry);
+    }
+    if (issues.length > 0) {
+        return { success: false, issues };
+    }
+    return { success: true, data: out };
+}
+// =============================================================================
+// Entry construction
+// =============================================================================
+function buildEntry(entry, prov) {
+    return {
+        schemaId: prov.schemaId,
+        fromVersion: prov.fromVersion,
+        toVersion: prov.toVersion,
+        fromIrHash: prov.fromIrHash,
+        toIrHash: prov.toIrHash,
+        fromSourceHash: prov.fromSourceHash,
+        toSourceHash: prov.toSourceHash,
+        sourcePath: entry.sourcePath,
+        // Preserves object identity — the same `AnyMigration` reference
+        // the CLI handed in shows up on the indexed entry. Downstream
+        // code can `===` it against the original.
+        migration: entry.migration,
+    };
+}
+// =============================================================================
+// Issue helpers
+// =============================================================================
+function attachSourcePath(issue, sourcePath) {
+    const path = [sourcePath];
+    return {
+        ...issue,
+        path,
+        metadata: { ...(issue.metadata ?? {}), sourcePath },
+    };
+}
+function duplicateMigrationIssue(schemaId, fromVersion, toVersion, sourcePaths) {
+    return {
+        code: "duplicate_migration",
+        path: [],
+        message: `Duplicate migration for \`${schemaId}\` ${fromVersion} → ${toVersion} ` +
+            `found in: ${sourcePaths.join(", ")}`,
+        severity: "error",
+        metadata: {
+            schemaId,
+            fromVersion,
+            toVersion,
+            sourcePaths: [...sourcePaths],
+        },
+    };
+}
+//# sourceMappingURL=build-migration-registry.js.map

package/dist/src/migrations/build-migration-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-migration-registry.js","sourceRoot":"","sources":["../../../src/migrations/build-migration-registry.ts"],"names":[],"mappings":"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"}

package/dist/src/migrations/handlers/list.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `listMigrationsHandler({ migrationRegistry })` — enumerate every
+ * `MigrationEntry` in a `MigrationRegistry`, in a stable order, as a
+ * `Result<{ entries }>` (v0.8 Step 7).
+ *
+ * The simplest of the four v0.8 handlers; landing this commit first
+ * pins the handler shape and the `Result<T>` discriminated-union
+ * contract before `plan` / `verify` / `stub` add per-handler
+ * complexity (Master plan sequencing step 7). Mirrors v0.7's
+ * `listHandler` shape exactly.
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. Takes an already-built `MigrationRegistry` (Step 3's
+ * `buildMigrationRegistry` output) and returns a `Result` over a flat
+ * array. Master plan Decision #1 boundary.
+ *
+ * Ordering (deterministic; documented in tests):
+ *
+ *   1. **Across `schemaId`** — alphabetical ascending.
+ *   2. **Within one `schemaId`, by `fromVersion`** — alphabetical
+ *      ascending.
+ *   3. **Within one `(schemaId, fromVersion)`, by `toVersion`** —
+ *      alphabetical ascending.
+ *
+ * The lexicographic compare matches `verify-provenance.ts` (Step 5).
+ * That means the list-handler's `entries` come out in the same order
+ * the verifier visits them for the same data — useful for consumers
+ * that join the two outputs by index.
+ *
+ * Never returns failure: enumeration has no failure mode. Empty
+ * registry → `{ success: true, data: { entries: [] } }`.
+ */
+import type { MigrationListOpts, MigrationListResult } from "../types.js";
+export declare function listMigrationsHandler(opts: MigrationListOpts): MigrationListResult;
+//# sourceMappingURL=list.d.ts.map

package/dist/src/migrations/handlers/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/migrations/handlers/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAEV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,iBAAiB,GACtB,mBAAmB,CAkBrB"}

package/dist/src/migrations/handlers/list.js

@@ -0,0 +1,55 @@
+/**
+ * `listMigrationsHandler({ migrationRegistry })` — enumerate every
+ * `MigrationEntry` in a `MigrationRegistry`, in a stable order, as a
+ * `Result<{ entries }>` (v0.8 Step 7).
+ *
+ * The simplest of the four v0.8 handlers; landing this commit first
+ * pins the handler shape and the `Result<T>` discriminated-union
+ * contract before `plan` / `verify` / `stub` add per-handler
+ * complexity (Master plan sequencing step 7). Mirrors v0.7's
+ * `listHandler` shape exactly.
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. Takes an already-built `MigrationRegistry` (Step 3's
+ * `buildMigrationRegistry` output) and returns a `Result` over a flat
+ * array. Master plan Decision #1 boundary.
+ *
+ * Ordering (deterministic; documented in tests):
+ *
+ *   1. **Across `schemaId`** — alphabetical ascending.
+ *   2. **Within one `schemaId`, by `fromVersion`** — alphabetical
+ *      ascending.
+ *   3. **Within one `(schemaId, fromVersion)`, by `toVersion`** —
+ *      alphabetical ascending.
+ *
+ * The lexicographic compare matches `verify-provenance.ts` (Step 5).
+ * That means the list-handler's `entries` come out in the same order
+ * the verifier visits them for the same data — useful for consumers
+ * that join the two outputs by index.
+ *
+ * Never returns failure: enumeration has no failure mode. Empty
+ * registry → `{ success: true, data: { entries: [] } }`.
+ */
+export function listMigrationsHandler(opts) {
+    const entries = [];
+    const schemaIds = [...opts.migrationRegistry.keys()].sort();
+    for (const schemaId of schemaIds) {
+        const byFrom = opts.migrationRegistry.get(schemaId);
+        if (byFrom === undefined)
+            continue; // unreachable given iteration source
+        const fromVersions = [...byFrom.keys()].sort();
+        for (const fromVersion of fromVersions) {
+            const byTo = byFrom.get(fromVersion);
+            if (byTo === undefined)
+                continue;
+            const toVersions = [...byTo.keys()].sort();
+            for (const toVersion of toVersions) {
+                const entry = byTo.get(toVersion);
+                if (entry !== undefined)
+                    entries.push(entry);
+            }
+        }
+    }
+    return { success: true, data: { entries } };
+}
+//# sourceMappingURL=list.js.map

package/dist/src/migrations/handlers/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../../src/migrations/handlers/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAQH,MAAM,UAAU,qBAAqB,CACnC,IAAuB;IAEvB,MAAM,OAAO,GAAqB,EAAE,CAAC;IACrC,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAC5D,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACpD,IAAI,MAAM,KAAK,SAAS;YAAE,SAAS,CAAC,qCAAqC;QACzE,MAAM,YAAY,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QAC/C,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;YACvC,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YACrC,IAAI,IAAI,KAAK,SAAS;gBAAE,SAAS;YACjC,MAAM,UAAU,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;YAC3C,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;gBACnC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;gBAClC,IAAI,KAAK,KAAK,SAAS;oBAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC;AAC9C,CAAC"}

package/dist/src/migrations/handlers/plan.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `planMigrationHandler(opts)` — handler wrapper around the
+ * diff-aware planner (v0.8 Step 8).
+ *
+ * Forwards directly to `planMigration` from `../plan-migration.js`.
+ * The wrapper exists so the four-handler surface
+ * (`list / plan / verify / stub`) reads uniformly to the CLI — and
+ * so future cross-cutting concerns (telemetry tagging, opts
+ * defaulting, etc.) have a single seam — but in v0.8 it is a thin
+ * pass-through.
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. **Never invokes `migration.transform`** —
+ * verification of the no-execute boundary lives in the planner
+ * implementation; the wrapper inherits it.
+ *
+ * **Throws** propagate. If `planMigration` raises
+ * `UnsupportedNodeKindError` (because `diffNodes` hit a `date` /
+ * `union` / `recursiveRef` / `transform` IR kind), this handler
+ * does NOT catch — the CLI dispatcher (Step 21) maps the throw to
+ * a non-zero exit code at the CLI boundary, matching the v0.6 /
+ * v0.7 fail-loud discipline.
+ */
+import type { MigrationPlanOpts, MigrationPlanResult } from "../types.js";
+export declare function planMigrationHandler(opts: MigrationPlanOpts): MigrationPlanResult;
+//# sourceMappingURL=plan.d.ts.map

package/dist/src/migrations/handlers/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../../src/migrations/handlers/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,iBAAiB,GACtB,mBAAmB,CAErB"}

package/dist/src/migrations/handlers/plan.js

@@ -0,0 +1,28 @@
+/**
+ * `planMigrationHandler(opts)` — handler wrapper around the
+ * diff-aware planner (v0.8 Step 8).
+ *
+ * Forwards directly to `planMigration` from `../plan-migration.js`.
+ * The wrapper exists so the four-handler surface
+ * (`list / plan / verify / stub`) reads uniformly to the CLI — and
+ * so future cross-cutting concerns (telemetry tagging, opts
+ * defaulting, etc.) have a single seam — but in v0.8 it is a thin
+ * pass-through.
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. **Never invokes `migration.transform`** —
+ * verification of the no-execute boundary lives in the planner
+ * implementation; the wrapper inherits it.
+ *
+ * **Throws** propagate. If `planMigration` raises
+ * `UnsupportedNodeKindError` (because `diffNodes` hit a `date` /
+ * `union` / `recursiveRef` / `transform` IR kind), this handler
+ * does NOT catch — the CLI dispatcher (Step 21) maps the throw to
+ * a non-zero exit code at the CLI boundary, matching the v0.6 /
+ * v0.7 fail-loud discipline.
+ */
+import { planMigration } from "../plan-migration.js";
+export function planMigrationHandler(opts) {
+    return planMigration(opts);
+}
+//# sourceMappingURL=plan.js.map

package/dist/src/migrations/handlers/plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../../src/migrations/handlers/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAMrD,MAAM,UAAU,oBAAoB,CAClC,IAAuB;IAEvB,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC;AAC7B,CAAC"}

package/dist/src/migrations/handlers/stub.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `stubMigrationHandler(opts)` — handler wrapper around the
+ * stub-content generator (v0.8 Step 10).
+ *
+ * Forwards directly to `stubMigration` from `../stub.js`. Same role
+ * as `planMigrationHandler` and `verifyMigrationsHandler` — a
+ * uniform four-handler surface for the CLI plus a future seam for
+ * cross-cutting concerns. In v0.8 it is a thin pass-through.
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. The stub is *generated*, not *written* — file I/O
+ * is the CLI's responsibility (Step 23 will `mkdir -p` +
+ * `writeFile` against the returned `suggestedPath`, refusing to
+ * overwrite an existing file at that path).
+ *
+ * **Never invokes `migration.transform`** — the stub generator
+ * emits a transform-body skeleton in the file content string but
+ * does not execute anything.
+ */
+import type { MigrationStubOpts, MigrationStubResult } from "../types.js";
+export declare function stubMigrationHandler(opts: MigrationStubOpts): MigrationStubResult;
+//# sourceMappingURL=stub.d.ts.map

package/dist/src/migrations/handlers/stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.d.ts","sourceRoot":"","sources":["../../../../src/migrations/handlers/stub.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,iBAAiB,GACtB,mBAAmB,CAErB"}

package/dist/src/migrations/handlers/stub.js

@@ -0,0 +1,24 @@
+/**
+ * `stubMigrationHandler(opts)` — handler wrapper around the
+ * stub-content generator (v0.8 Step 10).
+ *
+ * Forwards directly to `stubMigration` from `../stub.js`. Same role
+ * as `planMigrationHandler` and `verifyMigrationsHandler` — a
+ * uniform four-handler surface for the CLI plus a future seam for
+ * cross-cutting concerns. In v0.8 it is a thin pass-through.
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. The stub is *generated*, not *written* — file I/O
+ * is the CLI's responsibility (Step 23 will `mkdir -p` +
+ * `writeFile` against the returned `suggestedPath`, refusing to
+ * overwrite an existing file at that path).
+ *
+ * **Never invokes `migration.transform`** — the stub generator
+ * emits a transform-body skeleton in the file content string but
+ * does not execute anything.
+ */
+import { stubMigration } from "../stub.js";
+export function stubMigrationHandler(opts) {
+    return stubMigration(opts);
+}
+//# sourceMappingURL=stub.js.map

package/dist/src/migrations/handlers/stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub.js","sourceRoot":"","sources":["../../../../src/migrations/handlers/stub.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAM3C,MAAM,UAAU,oBAAoB,CAClC,IAAuB;IAEvB,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC;AAC7B,CAAC"}

package/dist/src/migrations/handlers/verify.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `verifyMigrationsHandler(opts)` — handler wrapper around the
+ * provenance verifier (v0.8 Step 9).
+ *
+ * Forwards directly to `verifyMigrationProvenance` from
+ * `../verify-provenance.js`. Same role as
+ * `planMigrationHandler` — a uniform four-handler surface for the
+ * CLI plus a future seam for cross-cutting concerns. In v0.8 it is
+ * a thin pass-through.
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. **Never invokes `migration.transform`** —
+ * verification is a `provenance-says-what-it-says` check, not a
+ * behavior check. Transform execution is deferred to v0.9+.
+ *
+ * The verifier never throws (provenance verification is
+ * structural; mismatches surface as `drift` /
+ * `missing_endpoint` verdicts on the failure branch). Even so the
+ * wrapper does not catch — any future throw from upstream code
+ * propagates to the CLI dispatcher (Step 22) and the locked
+ * fail-loud discipline.
+ */
+import type { MigrationVerifyOpts, MigrationVerifyResult } from "../types.js";
+export declare function verifyMigrationsHandler(opts: MigrationVerifyOpts): MigrationVerifyResult;
+//# sourceMappingURL=verify.d.ts.map

package/dist/src/migrations/handlers/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../../src/migrations/handlers/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAErB,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,mBAAmB,GACxB,qBAAqB,CAEvB"}

package/dist/src/migrations/handlers/verify.js

@@ -0,0 +1,27 @@
+/**
+ * `verifyMigrationsHandler(opts)` — handler wrapper around the
+ * provenance verifier (v0.8 Step 9).
+ *
+ * Forwards directly to `verifyMigrationProvenance` from
+ * `../verify-provenance.js`. Same role as
+ * `planMigrationHandler` — a uniform four-handler surface for the
+ * CLI plus a future seam for cross-cutting concerns. In v0.8 it is
+ * a thin pass-through.
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. **Never invokes `migration.transform`** —
+ * verification is a `provenance-says-what-it-says` check, not a
+ * behavior check. Transform execution is deferred to v0.9+.
+ *
+ * The verifier never throws (provenance verification is
+ * structural; mismatches surface as `drift` /
+ * `missing_endpoint` verdicts on the failure branch). Even so the
+ * wrapper does not catch — any future throw from upstream code
+ * propagates to the CLI dispatcher (Step 22) and the locked
+ * fail-loud discipline.
+ */
+import { verifyMigrationProvenance } from "../verify-provenance.js";
+export function verifyMigrationsHandler(opts) {
+    return verifyMigrationProvenance(opts);
+}
+//# sourceMappingURL=verify.js.map

package/dist/src/migrations/handlers/verify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.js","sourceRoot":"","sources":["../../../../src/migrations/handlers/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAMpE,MAAM,UAAU,uBAAuB,CACrC,IAAyB;IAEzB,OAAO,yBAAyB,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC"}

package/dist/src/migrations/parse-provenance.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Provenance parser for `*.migration.ts` files (v0.8 Step 2).
+ *
+ * Reads the migration-header metadata out of an authored migration
+ * file so `buildMigrationRegistry` can index by
+ * `(schemaId, fromVersion, toVersion)` and `verifyMigrationProvenance`
+ * can compare the recorded hashes against the current schema
+ * registry. Migration files use **JSDoc-only** carriers — there is
+ * no JSON variant because migrations are TypeScript modules, not
+ * data documents.
+ *
+ * Expected header shape (generated by the v0.8 stub generator;
+ * humans edit the body, not the header):
+ *
+ *     /**
+ *      * @migration by @nekostack/schema
+ *      * schemaId:         com.x.User
+ *      * fromVersion:      1.0.0
+ *      * toVersion:        2.0.0
+ *      * fromIrHash:       sha256:<64-hex>
+ *      * toIrHash:         sha256:<64-hex>
+ *      * fromSourceHash:   sha256:<64-hex>
+ *      * toSourceHash:     sha256:<64-hex>
+ *      * generator:        neko-schema-migrate-stub
+ *      * generatorVersion: @nekostack/schema@0.8.0
+ *      *
+ *      * DO NOT REMOVE THE HEADER. Authors EDIT THE BODY.
+ *      * /
+ *
+ * The function is **pure**: no `fs.*`, no `import()`, no path
+ * argument, no module evaluation. The CLI reads the migration file
+ * text from disk and hands it in; this module parses and returns.
+ * Master plan Decision #1 boundary applies.
+ *
+ * **Fail-loud, never silent** (v0.8 Round-2 lock — intentional
+ * departure from v0.7 Decision #5). A `.migration.ts` file exists
+ * specifically to declare a `(schemaId, fromVersion, toVersion)`
+ * transition. Missing or malformed provenance is treated as an
+ * invalid declaration, not a "skip and continue" condition.
+ * Malformed input surfaces as `Result<...>` failure with one
+ * `integrity_error` `Issue` whose `metadata.reason` records the
+ * sub-mode (`missing_migration_provenance`, `missing_field`,
+ * `malformed_hash`, `malformed_field`, `unknown_format`).
+ *
+ * The shape of `reason` deliberately overlaps with the v0.7
+ * provenance-parser reasons where the failure mode is the same —
+ * a missing JSDoc block reads identically in both worlds, so
+ * `missing_provenance` would have worked, but the migration-specific
+ * `missing_migration_provenance` name lets downstream consumers
+ * disambiguate without parsing `message`.
+ */
+import type { Result } from "../errors/issue.js";
+/**
+ * Parsed migration provenance fields. All fields are required —
+ * unlike v0.7's `ParsedProvenance` which tolerates v0.6-era artifacts
+ * missing `sourceHash`, the migration carrier has no backward-
+ * compatibility window. v0.8 is the first phase that emits migration
+ * files; every header it emits carries all four hashes.
+ */
+export interface ParsedMigrationProvenance {
+    readonly generator: string;
+    readonly generatorVersion: string;
+    readonly schemaId: string;
+    readonly fromVersion: string;
+    readonly toVersion: string;
+    readonly fromIrHash: `sha256:${string}`;
+    readonly toIrHash: `sha256:${string}`;
+    readonly fromSourceHash: `sha256:${string}`;
+    readonly toSourceHash: `sha256:${string}`;
+}
+/**
+ * Parse the migration JSDoc header out of a migration file's text
+ * content. Returns `Result.success` with the parsed fields on a
+ * valid header, `Result.failure` with an `integrity_error` `Issue`
+ * on every failure mode.
+ */
+export declare function parseMigrationProvenanceFromText(content: string): Result<ParsedMigrationProvenance>;
+//# sourceMappingURL=parse-provenance.d.ts.map

package/dist/src/migrations/parse-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-provenance.d.ts","sourceRoot":"","sources":["../../../src/migrations/parse-provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,KAAK,EAAS,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAIxD;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,UAAU,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,UAAU,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,cAAc,EAAE,UAAU,MAAM,EAAE,CAAC;IAC5C,QAAQ,CAAC,YAAY,EAAE,UAAU,MAAM,EAAE,CAAC;CAC3C;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,yBAAyB,CAAC,CASnC"}