@3fn/core 14.0.0 → 15.0.0

package/dist/cli/sync/Manifest.js

@@ -1,8 +1,23 @@
 "use strict";
 /**
- * Sync manifest — tracks what was last synced for edit detection.
+ * The DesignerPunk manifest — `designerpunk.manifest.json` at the repo root.
  *
- * @see Spec 111 — Requirement 3
+ * Spec 123 Task 5.2 (design.md § "C7 … Manifest" + its tasks-round erratum;
+ * DD21). Replaces Spec 111's `.kiro/sync-manifest.json` (now the LEGACY
+ * manifest: read once, relocated, and left with a one-line pointer).
+ *
+ * - **Path**: the repo root, beside the config (DD21 — a tool-dotdir gitignore
+ *   cannot silently remove the teammate's baseline).
+ * - **Format**: stable key order and ONE ENTRY PER LINE (merge-friendly).
+ *   `serializeManifest(parseManifest(text)) === text` for every file this module
+ *   writes — the re-serialize-equals-file property.
+ * - **Fields**: `{ version, posture, installedVersion, contractHash,
+ *   attachedTargets, entries }`; each entry `{ hash, grain, origin }` keyed by
+ *   `<path>` | `<path>#<region>` | `<path>#<key>`.
+ * - **Pruning**: entries under de-managed paths are dropped with one report line
+ *   per pruned group — never classified `removed` (D-B6).
+ *
+ * @see .kiro/specs/123-consumer-distribution/design.md § "C7"
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -38,48 +53,288 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_POINTER_TEXT = exports.SRC_TYPES_PRUNE_CLAUSE = exports.COPY_ROOTS = exports.DEMANAGED_ROOTS = exports.MANIFEST_SCHEMA_VERSION = exports.LEGACY_MANIFEST_PATH = exports.MANIFEST_FILE = void 0;
 exports.getManifestPath = getManifestPath;
+exports.getLegacyManifestPath = getLegacyManifestPath;
+exports.toManifestPath = toManifestPath;
+exports.isUnder = isUnder;
+exports.entryFilePath = entryFilePath;
+exports.parseManifest = parseManifest;
+exports.serializeManifest = serializeManifest;
 exports.loadManifest = loadManifest;
+exports.loadLegacyManifest = loadLegacyManifest;
 exports.saveManifest = saveManifest;
-exports.bootstrapManifest = bootstrapManifest;
+exports.pruneDemanaged = pruneDemanaged;
+exports.prunedMessage = prunedMessage;
+exports.pruneReportLines = pruneReportLines;
+exports.convertLegacyManifest = convertLegacyManifest;
+exports.writeLegacyPointer = writeLegacyPointer;
+exports.legacyHasPointer = legacyHasPointer;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const MANIFEST_PATH = '.kiro/sync-manifest.json';
+exports.MANIFEST_FILE = 'designerpunk.manifest.json';
+exports.LEGACY_MANIFEST_PATH = '.kiro/sync-manifest.json';
+/** The manifest-format schema marker written into `version` (distinct from `installedVersion`). */
+exports.MANIFEST_SCHEMA_VERSION = '1';
+/**
+ * Paths `sync` no longer manages under Model B (C7 managed-set table, rows
+ * REMOVED): the consumer's token language, the types it imports, and the
+ * pre-123 component copies (now the migration surface, judged against shipped
+ * content — never against a manifest baseline).
+ */
+exports.DEMANAGED_ROOTS = ['src/tokens', 'src/types', 'src/components/core'];
+/**
+ * The release-1 (and pre-123) copy roots `sync` RECOGNIZES — the roots under
+ * which an earlier `init` (release 1, U1) or Spec 111 `sync` recorded package
+ * copies as `origin: 'copy'` entries. Since Task 16.5 they are NO LONGER
+ * MANAGED (C7's managed-set row "`.kiro/steering`, `governance`, `.kiro/agents`,
+ * `.kiro/skills` (package copies) — REMOVED", gate 4b): the package stops
+ * shipping them, and `sync` never classifies, updates or re-adds a copy. A
+ * `copy` entry under one of these roots is a LEGACY COPY (C7 Migration item 4):
+ * reported, and offered `--migrate-legacy` only together with `attach`
+ * (`Migration.ts` § "Legacy copies"). `.kiro/skills` is here for legacy
+ * (Spec 111) manifests only — release-1 `init` never copied it.
+ *
+ * The name and membership are pinned by Spec 119-A's relocation-integrity gate
+ * (leg A7, relabelled "the release-1 copy roots `sync` recognizes"): keep the
+ * literal on one line.
+ */
+exports.COPY_ROOTS = ['.kiro/agents', '.kiro/steering', 'governance', '.kiro/skills'];
+const TOP_LEVEL_ORDER = [
+    'version',
+    'posture',
+    'installedVersion',
+    'contractHash',
+    'attachedTargets',
+    'entries',
+];
+const ENTRY_FIELD_ORDER = ['hash', 'grain', 'origin'];
 function getManifestPath(projectRoot) {
-    return path.join(projectRoot, MANIFEST_PATH);
+    return path.join(projectRoot, exports.MANIFEST_FILE);
+}
+function getLegacyManifestPath(projectRoot) {
+    return path.join(projectRoot, exports.LEGACY_MANIFEST_PATH);
+}
+/** Normalize a path to the manifest's forward-slash form. */
+function toManifestPath(relPath) {
+    return relPath.split(path.sep).join('/');
+}
+/** True iff `relPath` equals `root` or sits under it (forward-slash compare). */
+function isUnder(relPath, root) {
+    const p = toManifestPath(relPath);
+    return p === root || p.startsWith(`${root}/`);
+}
+/** The file path an entry key names (`<path>`, `<path>#<region>`, `<path>#<key>` → `<path>`). */
+function entryFilePath(entryKey) {
+    const hashIdx = entryKey.indexOf('#');
+    return hashIdx === -1 ? entryKey : entryKey.slice(0, hashIdx);
+}
+/**
+ * Parse manifest text. Throws on invalid JSON or a missing required field —
+ * a corrupt manifest is reported, never silently treated as "first sync"
+ * (Spec 111 did the latter; under Model B that would re-baseline edits away).
+ */
+function parseManifest(text) {
+    const raw = JSON.parse(text);
+    if (!raw || typeof raw !== 'object' || typeof raw.entries !== 'object' || raw.entries === null) {
+        throw new Error(`${exports.MANIFEST_FILE} is not a DesignerPunk manifest (no "entries" object)`);
+    }
+    return {
+        version: typeof raw.version === 'string' ? raw.version : exports.MANIFEST_SCHEMA_VERSION,
+        posture: raw.posture === 'consume' ? 'consume' : 'born',
+        installedVersion: typeof raw.installedVersion === 'string' ? raw.installedVersion : '',
+        contractHash: typeof raw.contractHash === 'string' ? raw.contractHash : '',
+        attachedTargets: Array.isArray(raw.attachedTargets)
+            ? raw.attachedTargets.filter((t) => t === 'cc' || t === 'kiro')
+            : [],
+        entries: raw.entries,
+    };
+}
+/**
+ * Serialize with a stable top-level key order, entries sorted by key
+ * (code-unit order — locale-independent), and ONE ENTRY PER LINE.
+ */
+function serializeManifest(manifest) {
+    const lines = ['{'];
+    const topKeys = TOP_LEVEL_ORDER;
+    topKeys.forEach((key, i) => {
+        const comma = i < topKeys.length - 1 ? ',' : '';
+        if (key === 'entries') {
+            const entryKeys = Object.keys(manifest.entries).sort(codeUnitCompare);
+            if (entryKeys.length === 0) {
+                lines.push(`  "entries": {}${comma}`);
+                return;
+            }
+            lines.push('  "entries": {');
+            entryKeys.forEach((ek, j) => {
+                const entry = manifest.entries[ek];
+                const ordered = {};
+                for (const f of ENTRY_FIELD_ORDER)
+                    ordered[f] = entry[f];
+                const entryComma = j < entryKeys.length - 1 ? ',' : '';
+                lines.push(`    ${JSON.stringify(ek)}: ${JSON.stringify(ordered)}${entryComma}`);
+            });
+            lines.push(`  }${comma}`);
+            return;
+        }
+        lines.push(`  ${JSON.stringify(key)}: ${JSON.stringify(manifest[key])}${comma}`);
+    });
+    lines.push('}');
+    return lines.join('\n') + '\n';
+}
+function codeUnitCompare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
 }
 function loadManifest(projectRoot) {
     const filePath = getManifestPath(projectRoot);
+    if (!fs.existsSync(filePath))
+        return { kind: 'absent' };
+    const text = fs.readFileSync(filePath, 'utf-8');
+    try {
+        return { kind: 'ok', manifest: parseManifest(text), text };
+    }
+    catch (err) {
+        return { kind: 'corrupt', error: err.message };
+    }
+}
+function loadLegacyManifest(projectRoot) {
+    const filePath = getLegacyManifestPath(projectRoot);
     if (!fs.existsSync(filePath))
         return null;
     try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (!raw || typeof raw !== 'object' || typeof raw.files !== 'object' || raw.files === null)
+            return null;
+        return raw;
     }
     catch {
-        return null; // Corrupt JSON treated as first-time
+        return null;
     }
 }
+/** Write the manifest. Returns true iff bytes changed (no write when identical). */
 function saveManifest(projectRoot, manifest) {
     const filePath = getManifestPath(projectRoot);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+    const text = serializeManifest(manifest);
+    if (fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf-8') === text)
+        return false;
+    fs.writeFileSync(filePath, text, 'utf-8');
+    return true;
 }
 /**
- * Bootstrap a manifest from current project state.
- * Records each project file's current hash as baseline — no conflicts on first sync.
+ * Drop entries under DEMANAGED_ROOTS from `entries` (in place). Returns one
+ * group per root with a nonzero count, in DEMANAGED_ROOTS order.
  */
-function bootstrapManifest(projectFiles, version) {
-    const files = {};
-    for (const file of projectFiles) {
-        files[file.relativePath] = {
-            hash: file.hash,
-            managed: file.tier === 'governance',
-        };
+function pruneDemanaged(entries) {
+    const counts = new Map();
+    for (const key of Object.keys(entries)) {
+        const file = entryFilePath(key);
+        const root = exports.DEMANAGED_ROOTS.find((r) => isUnder(file, r));
+        if (root) {
+            delete entries[key];
+            counts.set(root, (counts.get(root) ?? 0) + 1);
+        }
+    }
+    return exports.DEMANAGED_ROOTS.filter((r) => counts.has(r)).map((r) => ({ root: r, count: counts.get(r) }));
+}
+/**
+ * Design catalog row "managed manifest pruned (D-B6)":
+ * `no longer managing <N> files under <paths> — under the current contract they are yours (not removed from disk)`
+ */
+function prunedMessage(count, paths) {
+    return `no longer managing ${count} files under ${paths} — under the current contract they are yours (not removed from disk)`;
+}
+/**
+ * The clause appended to the `src/types` pruning line (Ada D-T-A5: a pre-123
+ * consumer's copied `src/tokens` still imports `../types` relatively, so the
+ * de-managed `src/types` must not read as "safe to delete"). Authored at Task
+ * 5.5 (Ada); text carried unchanged from Lina's draft — it already said the
+ * right thing.
+ */
+exports.SRC_TYPES_PRUNE_CLAUSE = ' — keep them: your token tier still imports them through relative ../types paths, so deleting src/types breaks generate';
+/** One report line per pruned group; the `src/types` line carries the D-T-A5 clause. */
+function pruneReportLines(groups) {
+    return groups.map((g) => {
+        const base = prunedMessage(g.count, g.root);
+        return g.root === 'src/types' ? `${base}${exports.SRC_TYPES_PRUNE_CLAUSE}` : base;
+    });
+}
+/**
+ * Convert a Spec 111 manifest. Copy-root entries become `{ grain: 'file',
+ * origin: 'copy' }` (their hash is the Spec 111 baseline — correct for these
+ * untransformed files); entries under DEMANAGED_ROOTS are pruned with a report.
+ * `attachedTargets` is EMPTY: no pre-123 install was attached, so no generated
+ * surface is managed until `attach` records one (U2).
+ *
+ * The legacy `version` is the LAST SYNC — never the copy version and never the
+ * installed version (C7 step 2) — so it is not carried into the new manifest.
+ */
+function convertLegacyManifest(legacy, installedVersion) {
+    const entries = {};
+    for (const [rel, e] of Object.entries(legacy.files)) {
+        entries[toManifestPath(rel)] = { hash: e.hash, grain: 'file', origin: 'copy' };
+    }
+    const pruned = pruneDemanaged(entries);
+    // Anything left outside the copy roots is not a surface sync manages; drop it
+    // into its own pruned group rather than carrying an unowned entry forward.
+    const stray = new Map();
+    for (const key of Object.keys(entries)) {
+        if (!exports.COPY_ROOTS.some((r) => isUnder(key, r))) {
+            const root = key.split('/')[0];
+            stray.set(root, (stray.get(root) ?? 0) + 1);
+            delete entries[key];
+        }
     }
+    for (const [root, count] of stray)
+        pruned.push({ root, count });
     return {
-        version,
-        syncedAt: new Date().toISOString(),
-        files,
+        manifest: {
+            version: exports.MANIFEST_SCHEMA_VERSION,
+            posture: 'born',
+            installedVersion,
+            contractHash: '',
+            attachedTargets: [],
+            entries,
+        },
+        pruned,
     };
 }
+/**
+ * The one-line pointer left in the legacy file for one release (C7 step 1).
+ * JSON has no comment syntax, so the pointer is a leading `"//"` member; the
+ * rest of the legacy content is preserved byte-for-byte in meaning.
+ */
+exports.LEGACY_POINTER_TEXT = `moved to ${exports.MANIFEST_FILE} at the repo root by 'npx designerpunk sync' — this file is no longer read and can be deleted after the next release`;
+/** Returns true iff the pointer was written (false when already present or unreadable). */
+function writeLegacyPointer(projectRoot) {
+    const filePath = getLegacyManifestPath(projectRoot);
+    if (!fs.existsSync(filePath))
+        return false;
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return false;
+    }
+    if (raw['//'] === exports.LEGACY_POINTER_TEXT)
+        return false;
+    const withPointer = { '//': exports.LEGACY_POINTER_TEXT };
+    for (const [k, v] of Object.entries(raw))
+        if (k !== '//')
+            withPointer[k] = v;
+    fs.writeFileSync(filePath, JSON.stringify(withPointer, null, 2) + '\n', 'utf-8');
+    return true;
+}
+/** True iff the legacy file already carries the relocation pointer. */
+function legacyHasPointer(projectRoot) {
+    const filePath = getLegacyManifestPath(projectRoot);
+    if (!fs.existsSync(filePath))
+        return false;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'))['//'] === exports.LEGACY_POINTER_TEXT;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=Manifest.js.map

package/dist/cli/sync/Migration.d.ts

@@ -0,0 +1,271 @@
+/**
+ * Component-copy migration — pre-123 consumers (Spec 123 Task 5.5; design.md
+ * § "C7" Migration steps 2–5; Lina L2-D2, Le-D1).
+ *
+ * Pre-123 `init` copied `src/components/core/**` into the consumer (with
+ * `rewriteBuildImports` applied to `.ts` files from Spec 104 on). Under Model B
+ * components are consumed BY NAME from the package, so every copy now SHADOWS
+ * the package's version. This module judges each copy:
+ *
+ *  - **Against SHIPPED content, never the first-sync baseline** (Le-D1(1)). The
+ *    content is fetched THE WAY THE CONSUMER INSTALLED: her own npm resolution
+ *    (`.npmrc` scope mapping), npm cache first (`--prefer-offline`), run in her
+ *    project directory — so pre-13 versions that exist only on GitHub Packages
+ *    stay fetchable. This runs BEFORE the registry-pin repair is offered.
+ *  - **Any version in the range** — earliest available through the installed
+ *    one. A legacy manifest's `version` is the LAST SYNC (it can lag the installed
+ *    version — dp-portfolio: 12.0.3 vs 12.0.5), so it is never the bound.
+ *  - **The transform, byte-exact, loaded from each fetched tarball itself**, and
+ *    applied to `.ts` files only; non-`.ts` files hash raw; `__tests__` excluded.
+ *  - **Per file**: a component is `unmodified` iff every file is; a file deleted
+ *    from a copy makes the component a fork.
+ *  - **Version unknown, fetch failed, or transform unknown → `cannot-tell`.**
+ *    Never "unmodified".
+ *
+ * Nothing is removed without `--migrate-components` (relocate forks to
+ * `src/components/<Name>/`, remove unmodified copies; `cannot-tell` stays).
+ */
+import type { ManifestEntry } from './Manifest';
+export declare const LEGACY_COMPONENT_ROOT = "src/components/core";
+export declare const CONSUMER_COMPONENT_ROOT = "src/components";
+export type MigrationVerdict = 'unmodified' | 'modified' | 'cannot-tell';
+export interface PackageFetcher {
+    /** Every published version visible through her resolution; null when it cannot be listed (offline, auth). */
+    listVersions(): string[] | null;
+    /** The unpacked package root for `version`, or null when the fetch fails. */
+    fetch(version: string): string | null;
+    /** Remove any scratch state. */
+    dispose?(): void;
+}
+/**
+ * The production fetcher: `npm view` / `npm pack --prefer-offline`, run with
+ * `cwd = projectRoot` so HER `.npmrc` (scope → registry mapping, auth) applies.
+ */
+export declare function npmRailFetcher(projectRoot: string): PackageFetcher;
+export type TransformLoad = {
+    kind: 'fn';
+    fn: (content: string) => string;
+    source: string;
+} | {
+    kind: 'identity';
+    source: string;
+} | {
+    kind: 'unknown';
+    reason: string;
+};
+/**
+ * Load the copy transform THIS version's `init` applied, from its own files:
+ *  1. `dist/cli/shared/transforms.js` (13.0.0+ ship compiled CLI modules);
+ *  2. `src/cli/shared/transforms.ts` (11.9.0–12.x ran the CLI from `src/` via
+ *     tsx and did not ship `dist/cli/shared/`) — loaded through tsx;
+ *  3. no module, and the version's `init` never mentions `rewriteBuildImports`
+ *     → the IDENTITY (before Spec 104);
+ *  4. otherwise (11.3.0–11.8.x: the transform is private to `init.ts`) → unknown.
+ */
+export declare function loadTransform(pkgRoot: string): TransformLoad;
+export declare function compareVersions(a: string, b: string): number;
+export interface UpperBound {
+    version: string | null;
+    source: 'manifest' | 'lockfile' | 'unknown';
+}
+/**
+ * The installed version bounding the range: the manifest's `installedVersion`,
+ * else `package-lock.json`, else unknown (→ every verdict `cannot-tell`).
+ */
+export declare function resolveUpperBound(projectRoot: string, manifestInstalledVersion: string | null): UpperBound;
+export interface FileVerdict {
+    /** Relative to the component directory. */
+    file: string;
+    verdict: MigrationVerdict;
+    /** The version whose shipped content it matched, if any. */
+    matchedVersion?: string;
+    /** Why the verdict is `cannot-tell` (design.md catalog row "migration — cannot tell", erratum 2026-09-26). */
+    cause?: CannotTellCause;
+}
+export interface ComponentVerdict {
+    name: string;
+    /** `copy`: a DesignerPunk component; `yours`: no fetched version ships it. */
+    kind: 'copy' | 'yours';
+    verdict: MigrationVerdict;
+    files: FileVerdict[];
+    /** Files every matched version ships that the copy lacks (a deletion makes a fork). */
+    deletedFiles: string[];
+}
+export interface MigrationAssessment {
+    trigger: 'legacy-manifest' | 'legacy-copies';
+    upperBound: UpperBound;
+    /** Versions in the range, newest first. */
+    range: string[];
+    fetched: string[];
+    failed: string[];
+    /** Version → why its transform is unknown. */
+    unknownTransform: Record<string, string>;
+    /** The order fetch attempts happened in — the ordering instrument for the pin repair. */
+    fetchLog: string[];
+    components: ComponentVerdict[];
+    /** Consumer-side token files found in the copied tree (Lina A5; token-side report strings). */
+    oldNameReferenceMaps: string[];
+    brandedTokenFiles: string[];
+}
+/** The migration trigger (C7): a legacy manifest, or legacy copies on disk. */
+export declare function migrationTrigger(projectRoot: string, legacyManifest: boolean): MigrationAssessment['trigger'] | null;
+export declare function hasLegacyCopies(projectRoot: string): boolean;
+export declare function assessComponentCopies(projectRoot: string, opts: {
+    fetcher: PackageFetcher;
+    upperBound: UpperBound;
+    trigger: MigrationAssessment['trigger'];
+}): MigrationAssessment;
+/**
+ * Comments blanked out (same approach as `scripts/floor-closure.ts`'s
+ * `stripComments`): block comments, then `//` line comments not preceded by `:`
+ * (so `https://` inside a string survives). Not a tokenizer.
+ */
+export declare function stripComments(content: string): string;
+/** Design catalog row "migration — modified copies (Le-D1(3))". */
+export declare function modifiedCopiesMessage(n: number, names: string[]): string;
+export type CannotTellCause = {
+    kind: 'fetch-failed';
+    version: string;
+} | {
+    kind: 'transform-unrecoverable';
+    version: string;
+} | {
+    kind: 'version-unknown';
+};
+/**
+ * Design catalog row "migration — cannot tell" — THREE-CAUSE per the design.md
+ * erratum of 2026-09-26 (Thurgood, `completion/task-5-erratum-cannot-tell.md`):
+ * `cannot tell whether <path> was modified — <the package content for version <v>
+ * could not be retrieved|version <v>'s copy transform cannot be recovered|the
+ * installed version is unknown>. Review before removing.`
+ */
+export declare function cannotTellMessage(p: string, cause: CannotTellCause): string;
+/**
+ * Follows the catalog `cannot tell` lines (Peter's 2026-09-26 ruling on the
+ * migration fork, condition 1: the cannot-tell outcome must be ACTIONABLE —
+ * both manual paths, and the legacy warning's persistence). The catalog row
+ * itself stays string-equal; this line is additional.
+ */
+export declare function cannotTellRemedyMessage(names: string[]): string;
+/** C7 step 3: unmodified copies shadow updates (the design's quoted phrase, verbatim inside). */
+export declare function unmodifiedCopiesMessage(n: number, names: string[]): string;
+/** Not in the catalog: a component under core/ that no fetched version ships. Authored at Task 5.5. */
+export declare function yoursUnderCoreMessage(n: number, names: string[]): string;
+/**
+ * Lina A5 / C7 step 5. Authored at Task 5.5 (Ada). Each takes the file list
+ * the assessment found (names are always printed with the line).
+ *
+ * `oldNameReferenceMaps` is deliberately ownership-agnostic: `scanTokenFiles`
+ * classifies by filename + content alone, so this list mixes DesignerPunk's
+ * own old-name files (the 7 renamed to `*.refs.ts` in #200 — a pre-123 copy
+ * predates that rename and still carries the old name) with a consumer's own
+ * semantic-reference map that happens to be named `tokens.ts` — the exact
+ * collision Req 8's user story names. The string must not claim authorship it
+ * cannot verify per-file.
+ */
+export declare const TOKEN_SIDE_SLOTS: {
+    /** C7 5 (i): old-name `tokens.ts` reference maps in the copied tree → C11's lint on first generate. */
+    oldNameReferenceMaps: (files: string[]) => string;
+    /** C7 5 (ii): branded copied `*.tokens.ts` now harvest as the consumer's component tokens. */
+    brandedTokenFiles: (files: string[]) => string;
+};
+export declare function migrationReportLines(a: MigrationAssessment): string[];
+export interface RelocationResult {
+    removed: string[];
+    relocated: string[];
+    /** Forks not moved because `src/components/<Name>/` already exists. */
+    skipped: string[];
+    /** `cannot-tell` components left in place. */
+    leftInPlace: string[];
+}
+export declare function relocateComponents(projectRoot: string, a: MigrationAssessment): RelocationResult;
+export interface RepairOffer {
+    kind: 'npmrc' | 'tsconfig';
+    /** The named explanation + the command (Req 5.1: never silently, never as fine print). */
+    lines: string[];
+}
+/** Req 5.1: detect the `@3fn` → GitHub Packages scope mapping in the consumer's `.npmrc`. Reads only that line's shape; never prints other lines. */
+export declare function detectRegistryPin(projectRoot: string): boolean;
+/** Req 5.2: the scaffolded `tsconfig.test.json` `paths` keys that re-pin `@3fn/core` subpaths to raw `src/`. */
+export declare function detectTsconfigPins(projectRoot: string): {
+    keys: string[];
+    unparseable: boolean;
+};
+export declare const REGISTRY_PIN_MESSAGE = ".npmrc maps @3fn to GitHub Packages (@3fn:registry=https://npm.pkg.github.com). An older 'init' wrote that line; DesignerPunk now publishes to the public npm registry, and the mapping makes every install of @3fn/core need a GitHub token and can leave you on versions npm no longer serves. To remove just that line (your other settings, including any auth lines, stay): npx designerpunk sync --repair-npmrc";
+export declare const REGISTRY_PIN_ORDER_CAUTION = "Do this after 'sync --migrate-components': once the mapping is gone, versions before 13.0.0 can no longer be fetched to judge your component copies.";
+export declare function tsconfigPinMessage(keys: string[]): string;
+export declare const TSCONFIG_UNPARSEABLE_MESSAGE = "tsconfig.test.json points @3fn/core subpaths at node_modules/@3fn/core/src, but it is not plain JSON (comments?), so sync will not rewrite it. Remove the compilerOptions.paths entries for @3fn/core/* by hand.";
+/**
+ * Build the offers. Called AFTER the migration assessment (the fetch runs
+ * through the pin the npmrc repair removes — L2-D2). `copiesPending` adds the
+ * ordering caution while pre-123 copies are still on disk.
+ */
+export declare function repairOffers(projectRoot: string, copiesPending: boolean): RepairOffer[];
+/** Remove only the pin line(s). Returns true iff the file changed. */
+export declare function repairRegistryPin(projectRoot: string): boolean;
+/** Remove only the re-pinning `paths` entries (and `paths` itself if emptied); `baseUrl` is kept. */
+export declare function repairTsconfigPins(projectRoot: string): boolean;
+/**
+ * The legacy-copy entries: `origin: 'copy'`, file grain, under one of the
+ * release-1 copy roots (`COPY_ROOTS`). Keyed on ORIGIN, never on the manifest's
+ * version (Ada D-T-B2, design C7 erratum): release-1 `init` wrote a
+ * CURRENT-format manifest, so a version key would miss the whole cohort.
+ */
+export declare function legacyCopyEntries(entries: Record<string, ManifestEntry>): string[];
+export interface LegacyCopyAssessment {
+    /** The release-1 copy roots holding at least one legacy entry, in `COPY_ROOTS` order. */
+    roots: string[];
+    /** On disk, bytes equal to the hash recorded when it was copied. */
+    unmodified: string[];
+    /** On disk, edited since it was copied — hers; never deleted. */
+    modified: string[];
+    /** Recorded, but gone from disk. */
+    missing: string[];
+}
+/** Judge each legacy copy against the hash recorded when it was copied. `null` when the manifest records none. */
+export declare function assessLegacyCopies(projectRoot: string, entries: Record<string, ManifestEntry>): LegacyCopyAssessment | null;
+/**
+ * Whether `attach` can run here, decided by the caller (`sync/index.ts`) through
+ * `attach`'s own code path: the installed package ships the agent-layer bundle,
+ * the repo is one `attach` does not refuse, and the emission succeeds for each
+ * target. `--migrate-legacy` is offered ONLY when this is `available` — it never
+ * runs without the attach step.
+ */
+export type AttachAvailability = {
+    available: true;
+    targets: string[];
+    declared: readonly string[];
+} | {
+    available: false;
+    reason: string;
+};
+export declare function legacyCopiesMessage(count: number, roots: string[]): string;
+export declare function legacyModifiedMessage(paths: string[]): string;
+export declare function legacyMissingMessage(count: number): string;
+/** The offer — printed ONLY when attach is available; it names the attach step it runs. */
+export declare function migrateLegacyOfferMessage(targets: string[], declared: readonly string[]): string;
+/** Printed INSTEAD of the offer when attach is not available. Nothing is offered for removal. */
+export declare function migrateLegacyUnavailableMessage(reason: string): string;
+/** `--migrate-legacy` was given, but there is no target to attach (the manifest records none and no --target was given). */
+export declare function migrateLegacyNeedsTargetMessage(declared: readonly string[]): string;
+/** `--migrate-legacy` was given while attach is unavailable — refused; nothing removed. */
+export declare function migrateLegacyRefusedMessage(reason: string): string;
+export declare function legacyCopyReportLines(a: LegacyCopyAssessment, availability: AttachAvailability): string[];
+export interface LegacyRemoval {
+    /** Unmodified copies deleted from disk; their entries dropped. */
+    removed: string[];
+    /** Edited copies left on disk as the consumer's own; their entries dropped. */
+    keptAsYours: string[];
+    /** Recorded copies already gone from disk; their entries dropped. */
+    dropped: string[];
+}
+/**
+ * The removal half of `--migrate-legacy` (the caller runs the attach half next,
+ * in the same flow). Every legacy entry leaves the manifest, so no `origin:
+ * 'copy'` entry remains under the release-1 copy roots; only files whose bytes
+ * still equal the recorded copy are deleted (re-checked here, not trusted from
+ * the report). Directories the deletions empty are removed, up to the copy root.
+ */
+export declare function removeLegacyCopies(projectRoot: string, entries: Record<string, ManifestEntry>): LegacyRemoval;
+export declare function legacyRemovalSummary(r: LegacyRemoval): string;
+//# sourceMappingURL=Migration.d.ts.map