@north-light/crouter 0.3.318 → 0.3.319

package/dist/migrations/corpus.js

@@ -1,483 +1,3 @@
-// The corpus-lane runner: discover EVERY memory store a machine can reach,
-// snapshot them together, let each corpus migration plan across the whole set,
-// then apply in two global phases.
-//
-// Why global: a document's canonical identity is an ADDRESS other stores point
-// at through `[[links]]` and `memory-read` routes. A per-store lane can rename
-// an identity it owns but cannot see the consumers that break, so the corpus
-// lane plans over every store at once — and one blocker anywhere writes nothing
-// anywhere, because a half-applied identity cut leaves dangling addresses.
-//
-// Why two phases: consumers are rewritten first, identities second, both across
-// the ENTIRE corpus. A store whose identity changed must not be readable at its
-// new address before every pointer to the old one has moved.
-//
-// Discovery is filesystem-only and never opens canvas.db. The daemon supplies
-// node target coordinates as plain values from its already-owned SQL roster.
-import { envProfileId } from '../shared/env.js';
-import { readdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { nodesRoot } from '../core/canvas/paths.js';
-import { atomicWriteText, listDirs, pathExists, realpathOrSelf, removePath, walkFiles } from '../core/fs-utils.js';
-import { memoryStoresInPrecedence, } from '../core/memory-resolver.js';
-import { descendantStoreRootsExhaustive } from '../core/nested-stores.js';
-import { profileMemoryDir } from '../core/profiles/manifest.js';
-import { listInstalledPlugins, listInstalledPluginsInRoot } from '../core/resolver.js';
-import { memoryDir as nodeMemoryDir } from '../core/runtime/memory.js';
-import { NEUTRAL_PROJECT_MEMORY, pluginMemoryDir, projectScopeRoots, scopeRoot } from '../core/scope.js';
-import { CRTR_DIR_NAME } from '../types.js';
-import { foldDocChange, loadStoreSnapshot } from './convergent.js';
-import { STATE_MIGRATIONS } from './registry.js';
-function firstLine(e) {
-    return (e instanceof Error ? e.message : String(e)).split('\n')[0] ?? '';
-}
-function targetId(target) {
-    return `${target.profileId ?? '-'}:${target.nodeId ?? '-'}:${realpathOrSelf(target.cwd)}`;
-}
-function pluginStoreDescriptor(plugin) {
-    const storeRoot = pluginMemoryDir(plugin);
-    return {
-        scope: plugin.scope,
-        storeRoot,
-        namespace: plugin.name,
-        plugin: plugin.name,
-        mountStatus: pathExists(storeRoot) ? 'ready' : 'absent',
-        projectMemory: NEUTRAL_PROJECT_MEMORY,
-    };
-}
-function nodeStoreDescriptor(storeRoot) {
-    return {
-        scope: 'node',
-        storeRoot,
-        namespace: '',
-        mountStatus: pathExists(storeRoot) ? 'ready' : 'absent',
-        projectMemory: NEUTRAL_PROJECT_MEMORY,
-    };
-}
-/** Node stores holding at least one document. An empty node store contributes
- *  no identity and no reference, so it stays out of the corpus — which is what
- *  keeps discovery cheap across thousands of nodes AND keeps the daemon
- *  optional on a home whose nodes have never written memory. */
-function nodeStoresWithDocs() {
-    const out = [];
-    for (const nodeId of listDirs(nodesRoot())) {
-        const storeRoot = nodeMemoryDir(nodeId);
-        if (!pathExists(storeRoot))
-            continue;
-        const docs = walkFiles(storeRoot, (n) => n.endsWith('.md') && n !== 'SKILL.md', (d) => d.startsWith('.'));
-        if (docs.length > 0)
-            out.push({ nodeId, storeRoot });
-    }
-    return out;
-}
-/** Discover the whole reachable corpus: every store, the targets that mount
- *  them, and the frontier searched to find them. `profiles` are the manifest
- *  lane's post-migration snapshots — a pre-migration manifest reads as corrupt,
- *  so discovery must run after that lane, not against `listProfiles()`. */
-export async function discoverCorpus(opts) {
-    const cwd = realpathOrSelf(opts.cwd ?? process.cwd());
-    const selectedProfileId = envProfileId() || null;
-    const explicitDirs = opts.explicitDirs ?? [];
-    const roots = [];
-    const rootSeen = new Set();
-    const addRoot = (row) => {
-        const key = `${row.reason}\u0000${realpathOrSelf(row.root)}\u0000${row.detail ?? ''}`;
-        if (rootSeen.has(key))
-            return;
-        rootSeen.add(key);
-        roots.push(row);
-    };
-    const projectRoots = new Map();
-    const addProjectRoot = (root, reason, profileId) => {
-        const key = realpathOrSelf(root);
-        let entry = projectRoots.get(key);
-        if (entry === undefined) {
-            entry = { root, reason, profileIds: [] };
-            projectRoots.set(key, entry);
-        }
-        if (!entry.profileIds.includes(profileId))
-            entry.profileIds.push(profileId);
-    };
-    const contexts = [
-        { reason: 'cwd-ancestor', profileId: selectedProfileId, roots: projectScopeRoots(cwd, selectedProfileId) },
-        ...opts.profiles.map(({ profileId, manifest }) => ({
-            reason: 'profile-project',
-            profileId,
-            detail: profileId,
-            roots: [
-                ...new Set(manifest.projects.flatMap((project) => [
-                    join(project.path, CRTR_DIR_NAME),
-                    ...projectScopeRoots(project.path, null),
-                ])),
-            ],
-        })),
-        ...explicitDirs.map((dir) => ({
-            reason: 'explicit-dir',
-            profileId: selectedProfileId,
-            detail: dir,
-            roots: [join(realpathOrSelf(dir), CRTR_DIR_NAME)],
-        })),
-    ];
-    const descendantCache = new Map();
-    /** Memoized by the root set: two profiles naming the same projects, or a
-     *  target-discovered root already walked, must not pay for the walk twice. */
-    const descendantsUnder = (rootsIn) => {
-        const key = rootsIn.map((root) => realpathOrSelf(root)).sort().join('\n');
-        let found = descendantCache.get(key);
-        if (found === undefined) {
-            found = descendantStoreRootsExhaustive([...rootsIn]);
-            descendantCache.set(key, found);
-        }
-        return found;
-    };
-    /** Take one set of project roots into discovery: the roots themselves, then
-     *  every store nested below them. Both kinds are project roots in their own
-     *  right — each earns a project target whose own precedence walk can reach
-     *  further roots, which is why the target loop below calls this again. */
-    const expandRoots = (rootsIn, reason, profileId, detail) => {
-        const detailRow = detail === undefined ? {} : { detail };
-        for (const root of rootsIn) {
-            addRoot({ reason, root, boundary: reason === 'explicit-dir' ? 'store' : 'ancestors', ...detailRow });
-            addProjectRoot(root, reason, profileId);
-        }
-        for (const descendant of descendantsUnder(rootsIn)) {
-            addRoot({ reason: 'descendant', root: descendant, boundary: 'descendants', ...detailRow });
-            addProjectRoot(descendant, 'descendant', profileId);
-        }
-    };
-    for (const context of contexts)
-        expandRoots(context.roots, context.reason, context.profileId, context.detail);
-    const blockers = [];
-    const stores = new Map();
-    const register = (descriptor, discovery, target) => {
-        const storeRoot = descriptor.storeRoot;
-        if (storeRoot === '' || !pathExists(storeRoot))
-            return;
-        const key = realpathOrSelf(storeRoot);
-        let record = stores.get(key);
-        if (record === undefined) {
-            record = {
-                key,
-                // First descriptor wins, matching the resolver's first-position dedup.
-                descriptor,
-                discovery: [],
-                discoverySeen: new Set(),
-                targets: [],
-                writable: descriptor.scope !== 'builtin',
-            };
-            stores.set(key, record);
-            try {
-                readdirSync(key);
-            }
-            catch (e) {
-                blockers.push({
-                    kind: 'inaccessible-root',
-                    message: `memory store cannot be listed (${firstLine(e)}) — discovery cannot see its documents; fix the permissions and re-run`,
-                    storeRoot: key,
-                });
-            }
-        }
-        const discoveryKey = `${discovery.reason}\u0000${discovery.root}\u0000${discovery.targetId ?? ''}`;
-        if (!record.discoverySeen.has(discoveryKey)) {
-            record.discoverySeen.add(discoveryKey);
-            record.discovery.push(discovery);
-        }
-        if (target !== undefined) {
-            if (!record.targets.includes(target.id))
-                record.targets.push(target.id);
-            if (!target.storeKeys.includes(key))
-                target.storeKeys.push(key);
-        }
-    };
-    const targets = [];
-    const targetsById = new Map();
-    const addTarget = (kind, origin, target) => {
-        const id = targetId(target);
-        if (targetsById.has(id))
-            return;
-        const record = { id, kind, origin, target, storeKeys: [] };
-        targetsById.set(id, record);
-        targets.push(record);
-    };
-    addTarget('cwd', cwd, { cwd, profileId: selectedProfileId, nodeId: null });
-    for (const { profileId, manifest } of opts.profiles) {
-        const home = manifest.home !== null && manifest.home !== '' ? manifest.home : null;
-        addTarget('profile', profileId, {
-            cwd: home ?? manifest.projects[0]?.path ?? cwd,
-            profileId,
-            nodeId: null,
-        });
-    }
-    /** One project target per (root, profile) membership. Re-run whenever the
-     *  root set grows: `addTarget` dedupes by target id. */
-    const addProjectTargets = () => {
-        for (const { root, profileIds } of [...projectRoots.values()]) {
-            for (const profileId of [...profileIds]) {
-                addTarget('project', dirname(root), { cwd: dirname(root), profileId, nodeId: null });
-            }
-        }
-    };
-    const nodeStores = nodeStoresWithDocs();
-    if (pathExists(nodesRoot()))
-        addRoot({ reason: 'node', root: nodesRoot(), boundary: 'nodes' });
-    const nodesById = new Map(opts.nodes.map((node) => [node.nodeId, node]));
-    for (const { nodeId, storeRoot } of nodeStores) {
-        const node = nodesById.get(nodeId);
-        if (node === undefined || node.cwd === '') {
-            const reason = node === undefined ? 'no row' : 'empty cwd';
-            blockers.push({
-                kind: 'inaccessible-target',
-                message: `node ${nodeId} holds memory documents but canvas.db has no usable row for it (${reason}) — the corpus cannot resolve its project or profile`,
-                storeRoot: realpathOrSelf(storeRoot),
-            });
-            register(nodeStoreDescriptor(storeRoot), { reason: 'node', root: storeRoot });
-            continue;
-        }
-        addTarget('node', nodeId, { cwd: node.cwd, profileId: node.profileId, nodeId });
-    }
-    // Runtime default `includeDescendants: false`: this is the store stack a link
-    // or route actually resolves through. A descendant store is reached by its
-    // own owner-dir target instead.
-    const walkTarget = (target) => {
-        for (const descriptor of memoryStoresInPrecedence(target.target)) {
-            if (descriptor.plugin !== undefined) {
-                addRoot({ reason: 'plugin', root: descriptor.storeRoot, boundary: 'store', detail: descriptor.plugin });
-                register(descriptor, { reason: 'plugin', root: descriptor.storeRoot, targetId: target.id }, target);
-                continue;
-            }
-            if (descriptor.scope === 'project') {
-                const crtrRoot = dirname(descriptor.storeRoot);
-                const known = projectRoots.get(realpathOrSelf(crtrRoot));
-                if (known === undefined) {
-                    // Reached only through this target's own ancestor walk — a node's cwd
-                    // or a profile home outside every manifest project. It enters
-                    // discovery WHOLE: the stores nested below it are corpus too, and the
-                    // loop below gives it and them their own project targets.
-                    expandRoots([crtrRoot], 'cwd-ancestor', target.target.profileId, target.id);
-                }
-                register(descriptor, { reason: known?.reason ?? 'cwd-ancestor', root: crtrRoot, targetId: target.id }, target);
-                continue;
-            }
-            const reason = descriptor.scope === 'user'
-                ? 'user'
-                : descriptor.scope === 'profile'
-                    ? 'profile'
-                    : descriptor.scope === 'node'
-                        ? 'node'
-                        : 'builtin';
-            addRoot({ reason, root: descriptor.storeRoot, boundary: 'store' });
-            register(descriptor, { reason, root: descriptor.storeRoot, targetId: target.id }, target);
-        }
-    };
-    // Discovery runs to a FIXPOINT: a target's store walk can name a project root
-    // no manifest and no ancestor walk knew, that root's descendants are corpus
-    // too, and each of them gets a target whose own walk can name another root.
-    // Terminates because a root expands once (`projectRoots` dedupes by realpath)
-    // and a target is walked once.
-    const walkedTargets = new Set();
-    for (;;) {
-        addProjectTargets();
-        const pending = targets.filter((target) => !walkedTargets.has(target.id));
-        if (pending.length === 0)
-            break;
-        for (const target of pending) {
-            walkedTargets.add(target.id);
-            walkTarget(target);
-        }
-    }
-    // Stores no target walk reaches. A DISABLED plugin's documents still hold
-    // identities and still point at other stores, so the corpus must see them —
-    // `memoryStoresInPrecedence` mounts only enabled ones.
-    const userRoot = scopeRoot('user');
-    if (userRoot !== null)
-        addRoot({ reason: 'plugin', root: userRoot, boundary: 'plugins' });
-    const extraPlugins = [...listInstalledPlugins('user')];
-    for (const { root } of projectRoots.values()) {
-        addRoot({ reason: 'plugin', root, boundary: 'plugins' });
-        extraPlugins.push(...listInstalledPluginsInRoot('project', root));
-    }
-    for (const plugin of extraPlugins) {
-        const descriptor = pluginStoreDescriptor(plugin);
-        addRoot({ reason: 'plugin', root: descriptor.storeRoot, boundary: 'store', detail: plugin.name });
-        register(descriptor, { reason: 'plugin', root: descriptor.storeRoot });
-    }
-    // A profile store the selected profile never mounts (no target selects it).
-    for (const { profileId } of opts.profiles) {
-        const storeRoot = profileMemoryDir(profileId);
-        addRoot({ reason: 'profile', root: storeRoot, boundary: 'store', detail: profileId });
-        register({ scope: 'profile', storeRoot, namespace: '', mountStatus: pathExists(storeRoot) ? 'ready' : 'absent', projectMemory: NEUTRAL_PROJECT_MEMORY }, { reason: 'profile', root: storeRoot });
-    }
-    return {
-        roots,
-        stores: [...stores.values()].map((record) => ({
-            key: record.key,
-            descriptor: record.descriptor,
-            discovery: record.discovery,
-            targets: record.targets,
-            writable: record.writable,
-        })),
-        targets: targets.map((record) => ({
-            id: record.id,
-            kind: record.kind,
-            origin: record.origin,
-            target: record.target,
-            storeKeys: record.storeKeys,
-        })),
-        blockers,
-    };
-}
-// Snapshots
-/** Read every discovered store's documents. `preloaded` supplies the per-store
- *  convergent lane's FOLDED snapshots so the corpus plans against the bytes a
- *  write run leaves behind — identical under `--dry-run`, where the same fold
- *  ran and nothing was written. */
-export function loadCorpusSnapshots(discovery, opts = {}) {
-    const snapshots = new Map();
-    const skipped = [];
-    for (const store of discovery.stores) {
-        const preloaded = opts.preloaded?.get(store.key);
-        if (preloaded !== undefined) {
-            snapshots.set(store.key, preloaded);
-            continue;
-        }
-        const loaded = loadStoreSnapshot(store.descriptor.storeRoot);
-        snapshots.set(store.key, loaded.snapshot);
-        for (const row of loaded.skipped)
-            skipped.push({ storeRoot: store.key, ...row });
-    }
-    return { snapshots, skipped };
-}
-export function parseFailureBlockers(skipped) {
-    return skipped.map((row) => ({
-        kind: 'parse-failure',
-        message: `${row.relPath}: frontmatter is not valid YAML (${row.error}) — the document's identity cannot be read; fix the file and re-run`,
-        storeRoot: row.storeRoot,
-        path: join(row.storeRoot, row.relPath),
-    }));
-}
-function makeCorpusSnapshot(stores, targets, roots) {
-    const byKey = new Map(stores.map((store) => [store.key, store]));
-    const byTarget = new Map(targets.map((target) => [target.id, target]));
-    return {
-        stores,
-        targets,
-        roots,
-        store: (key) => byKey.get(key),
-        storesForTarget: (id) => (byTarget.get(id)?.storeKeys ?? [])
-            .map((key) => byKey.get(key))
-            .filter((store) => store !== undefined),
-    };
-}
-export function buildCorpusSnapshot(discovery, snapshots) {
-    const stores = discovery.stores.map((store) => ({
-        ...store,
-        snapshot: snapshots.get(store.key) ?? { root: store.descriptor.storeRoot, docs: [] },
-    }));
-    return makeCorpusSnapshot(stores, discovery.targets, discovery.roots);
-}
-// The runner
-function cloneCorpus(corpus) {
-    const stores = corpus.stores.map((store) => ({
-        ...store,
-        snapshot: { root: store.snapshot.root, docs: [...store.snapshot.docs] },
-    }));
-    return makeCorpusSnapshot(stores, corpus.targets, corpus.roots);
-}
-/** Fold a planned change into the working corpus so migration k+1 plans against
- *  post-change state. A change outside every store is a migration defect, except
- *  an identity change creating this plan's repository-root declaration: absent
- *  root stores are intentionally not synthesized during planning. */
-function foldCorpusChange(corpus, change, allowedOutsidePaths = new Set()) {
-    let owner;
-    for (const store of corpus.stores) {
-        if (!change.path.startsWith(`${store.snapshot.root}/`))
-            continue;
-        if (owner === undefined || store.snapshot.root.length > owner.snapshot.root.length)
-            owner = store;
-    }
-    if (owner === undefined) {
-        if (allowedOutsidePaths.has(change.path))
-            return;
-        throw new Error(`corpus migration: planned change outside every discovered store: ${change.path}`);
-    }
-    foldDocChange(owner.snapshot, change);
-}
-/** Plan every corpus migration over the whole corpus, then — only when the
- *  global plan is blocker-free — write every migration's consumer rewrites
- *  before any identity rewrite. `rebuild` re-reads the corpus from file truth
- *  for the post-write `verify` pass. */
-export function runCorpusMigrations(corpus, opts = {}) {
-    const migrations = (opts.migrations ?? STATE_MIGRATIONS).filter((m) => m.lane === 'corpus');
-    const blockers = [...(opts.blockers ?? [])];
-    const planned = [];
-    const repositories = [];
-    const storePrefixes = [];
-    const renames = [];
-    const references = [];
-    const consumers = [];
-    const identities = [];
-    const result = (verified, wrote) => ({
-        migrations: migrations.length,
-        blocked: blockers.length > 0 && migrations.length > 0,
-        blockers,
-        planned,
-        repositories,
-        storePrefixes,
-        renames,
-        references,
-        wrote,
-        verified,
-    });
-    const noWrites = { consumers: [], identities: [] };
-    if (migrations.length === 0)
-        return result(false, noWrites);
-    const working = cloneCorpus(corpus);
-    for (const migration of migrations) {
-        const plan = migration.plan(working);
-        blockers.push(...plan.blockers);
-        repositories.push(...plan.repositories);
-        storePrefixes.push(...plan.storePrefixes);
-        renames.push(...plan.renames);
-        references.push(...plan.references);
-        for (const change of plan.consumers)
-            foldCorpusChange(working, change);
-        const allowedOutsidePaths = new Set(plan.repositories.map((repository) => repository.declarationPath));
-        for (const change of plan.identities)
-            foldCorpusChange(working, change, allowedOutsidePaths);
-        consumers.push(...plan.consumers);
-        identities.push(...plan.identities);
-        planned.push({
-            migration: migration.description,
-            consumers: plan.consumers.map((c) => c.path),
-            identities: plan.identities.map((c) => c.path),
-        });
-    }
-    const wrote = { consumers: consumers.map((c) => c.path), identities: identities.map((c) => c.path) };
-    if (blockers.length > 0)
-        return result(false, noWrites);
-    if (opts.dryRun === true)
-        return result(false, wrote);
-    // The phase barrier is GLOBAL: every migration's consumer rewrites land
-    // before any identity rewrite, so no pointer resolves to a moved address.
-    for (const change of consumers) {
-        if (change.after === null)
-            removePath(change.path);
-        else
-            atomicWriteText(change.path, change.after);
-    }
-    for (const change of identities) {
-        if (change.after === null)
-            removePath(change.path);
-        else
-            atomicWriteText(change.path, change.after);
-    }
-    if (opts.rebuild === undefined)
-        return result(false, wrote);
-    const rebuilt = opts.rebuild();
-    for (const migration of migrations) {
-        for (const finding of migration.verify?.(rebuilt) ?? []) {
-            blockers.push({ ...finding, kind: 'verification' });
-        }
-    }
-    return result(true, wrote);
-}
+var q=Object.defineProperty;var a=(t,s)=>q(t,"name",{value:s,configurable:!0});import{envProfileId as z}from"../shared/env.js";import{readdirSync as H}from"node:fs";import{dirname as j,join as T}from"node:path";import{nodesRoot as C}from"../core/canvas/paths.js";import{atomicWriteText as L,listDirs as Q,pathExists as x,realpathOrSelf as R,removePath as O,walkFiles as V}from"../core/fs-utils.js";import{memoryStoresInPrecedence as X}from"../core/memory-resolver.js";import{descendantStoreRootsExhaustive as Z}from"../core/nested-stores.js";import{profileMemoryDir as oo}from"../core/profiles/manifest.js";import{listInstalledPlugins as eo,listInstalledPluginsInRoot as to}from"../core/resolver.js";import{memoryDir as so}from"../core/runtime/memory.js";import{NEUTRAL_PROJECT_MEMORY as D,pluginMemoryDir as no,projectScopeRoots as _,scopeRoot as ro}from"../core/scope.js";import{CRTR_DIR_NAME as B}from"../types.js";import{foldDocChange as io,loadStoreSnapshot as ao}from"./convergent.js";import{STATE_MIGRATIONS as co}from"./registry.js";function po(t){return(t instanceof Error?t.message:String(t)).split(`
+`)[0]??""}a(po,"firstLine");function fo(t){return`${t.profileId??"-"}:${t.nodeId??"-"}:${R(t.cwd)}`}a(fo,"targetId");function uo(t){const s=no(t);return{scope:t.scope,storeRoot:s,namespace:t.name,plugin:t.name,mountStatus:x(s)?"ready":"absent",projectMemory:D}}a(uo,"pluginStoreDescriptor");function lo(t){return{scope:"node",storeRoot:t,namespace:"",mountStatus:x(t)?"ready":"absent",projectMemory:D}}a(lo,"nodeStoreDescriptor");function mo(){const t=[];for(const s of Q(C())){const r=so(s);if(!x(r))continue;V(r,d=>d.endsWith(".md")&&d!=="SKILL.md",d=>d.startsWith(".")).length>0&&t.push({nodeId:s,storeRoot:r})}return t}a(mo,"nodeStoresWithDocs");async function Co(t){const s=R(t.cwd??process.cwd()),r=z()||null,c=t.explicitDirs??[],d=[],m=new Set,u=a(o=>{const e=`${o.reason}\0${R(o.root)}\0${o.detail??""}`;m.has(e)||(m.add(e),d.push(o))},"addRoot"),y=new Map,v=a((o,e,n)=>{const f=R(o);let p=y.get(f);p===void 0&&(p={root:o,reason:e,profileIds:[]},y.set(f,p)),p.profileIds.includes(n)||p.profileIds.push(n)},"addProjectRoot"),P=[{reason:"cwd-ancestor",profileId:r,roots:_(s,r)},...t.profiles.map(({profileId:o,manifest:e})=>({reason:"profile-project",profileId:o,detail:o,roots:[...new Set(e.projects.flatMap(n=>[T(n.path,B),..._(n.path,null)]))]})),...c.map(o=>({reason:"explicit-dir",profileId:r,detail:o,roots:[T(R(o),B)]}))],S=new Map,b=a(o=>{const e=o.map(f=>R(f)).sort().join(`
+`);let n=S.get(e);return n===void 0&&(n=Z([...o]),S.set(e,n)),n},"descendantsUnder"),$=a((o,e,n,f)=>{const p=f===void 0?{}:{detail:f};for(const h of o)u({reason:e,root:h,boundary:e==="explicit-dir"?"store":"ancestors",...p}),v(h,e,n);for(const h of b(o))u({reason:"descendant",root:h,boundary:"descendants",...p}),v(h,"descendant",n)},"expandRoots");for(const o of P)$(o.roots,o.reason,o.profileId,o.detail);const I=[],k=new Map,w=a((o,e,n)=>{const f=o.storeRoot;if(f===""||!x(f))return;const p=R(f);let h=k.get(p);if(h===void 0){h={key:p,descriptor:o,discovery:[],discoverySeen:new Set,targets:[],writable:o.scope!=="builtin"},k.set(p,h);try{H(p)}catch(J){I.push({kind:"inaccessible-root",message:`memory store cannot be listed (${po(J)}) \u2014 discovery cannot see its documents; fix the permissions and re-run`,storeRoot:p})}}const A=`${e.reason}\0${e.root}\0${e.targetId??""}`;h.discoverySeen.has(A)||(h.discoverySeen.add(A),h.discovery.push(e)),n!==void 0&&(h.targets.includes(n.id)||h.targets.push(n.id),n.storeKeys.includes(p)||n.storeKeys.push(p))},"register"),i=[],l=new Map,M=a((o,e,n)=>{const f=fo(n);if(l.has(f))return;const p={id:f,kind:o,origin:e,target:n,storeKeys:[]};l.set(f,p),i.push(p)},"addTarget");M("cwd",s,{cwd:s,profileId:r,nodeId:null});for(const{profileId:o,manifest:e}of t.profiles){const n=e.home!==null&&e.home!==""?e.home:null;M("profile",o,{cwd:n??e.projects[0]?.path??s,profileId:o,nodeId:null})}const g=a(()=>{for(const{root:o,profileIds:e}of[...y.values()])for(const n of[...e])M("project",j(o),{cwd:j(o),profileId:n,nodeId:null})},"addProjectTargets"),U=mo();x(C())&&u({reason:"node",root:C(),boundary:"nodes"});const Y=new Map(t.nodes.map(o=>[o.nodeId,o]));for(const{nodeId:o,storeRoot:e}of U){const n=Y.get(o);if(n===void 0||n.cwd===""){const f=n===void 0?"no row":"empty cwd";I.push({kind:"inaccessible-target",message:`node ${o} holds memory documents but canvas.db has no usable row for it (${f}) \u2014 the corpus cannot resolve its project or profile`,storeRoot:R(e)}),w(lo(e),{reason:"node",root:e});continue}M("node",o,{cwd:n.cwd,profileId:n.profileId,nodeId:o})}const G=a(o=>{for(const e of X(o.target)){if(e.plugin!==void 0){u({reason:"plugin",root:e.storeRoot,boundary:"store",detail:e.plugin}),w(e,{reason:"plugin",root:e.storeRoot,targetId:o.id},o);continue}if(e.scope==="project"){const f=j(e.storeRoot),p=y.get(R(f));p===void 0&&$([f],"cwd-ancestor",o.target.profileId,o.id),w(e,{reason:p?.reason??"cwd-ancestor",root:f,targetId:o.id},o);continue}const n=e.scope==="user"?"user":e.scope==="profile"?"profile":e.scope==="node"?"node":"builtin";u({reason:n,root:e.storeRoot,boundary:"store"}),w(e,{reason:n,root:e.storeRoot,targetId:o.id},o)}},"walkTarget"),E=new Set;for(;;){g();const o=i.filter(e=>!E.has(e.id));if(o.length===0)break;for(const e of o)E.add(e.id),G(e)}const K=ro("user");K!==null&&u({reason:"plugin",root:K,boundary:"plugins"});const W=[...eo("user")];for(const{root:o}of y.values())u({reason:"plugin",root:o,boundary:"plugins"}),W.push(...to("project",o));for(const o of W){const e=uo(o);u({reason:"plugin",root:e.storeRoot,boundary:"store",detail:o.name}),w(e,{reason:"plugin",root:e.storeRoot})}for(const{profileId:o}of t.profiles){const e=oo(o);u({reason:"profile",root:e,boundary:"store",detail:o}),w({scope:"profile",storeRoot:e,namespace:"",mountStatus:x(e)?"ready":"absent",projectMemory:D},{reason:"profile",root:e})}return{roots:d,stores:[...k.values()].map(o=>({key:o.key,descriptor:o.descriptor,discovery:o.discovery,targets:o.targets,writable:o.writable})),targets:i.map(o=>({id:o.id,kind:o.kind,origin:o.origin,target:o.target,storeKeys:o.storeKeys})),blockers:I}}a(Co,"discoverCorpus");function Do(t,s={}){const r=new Map,c=[];for(const d of t.stores){const m=s.preloaded?.get(d.key);if(m!==void 0){r.set(d.key,m);continue}const u=ao(d.descriptor.storeRoot);r.set(d.key,u.snapshot);for(const y of u.skipped)c.push({storeRoot:d.key,...y})}return{snapshots:r,skipped:c}}a(Do,"loadCorpusSnapshots");function Eo(t){return t.map(s=>({kind:"parse-failure",message:`${s.relPath}: frontmatter is not valid YAML (${s.error}) \u2014 the document's identity cannot be read; fix the file and re-run`,storeRoot:s.storeRoot,path:T(s.storeRoot,s.relPath)}))}a(Eo,"parseFailureBlockers");function F(t,s,r){const c=new Map(t.map(m=>[m.key,m])),d=new Map(s.map(m=>[m.id,m]));return{stores:t,targets:s,roots:r,store:a(m=>c.get(m),"store"),storesForTarget:a(m=>(d.get(m)?.storeKeys??[]).map(u=>c.get(u)).filter(u=>u!==void 0),"storesForTarget")}}a(F,"makeCorpusSnapshot");function Ko(t,s){const r=t.stores.map(c=>({...c,snapshot:s.get(c.key)??{root:c.descriptor.storeRoot,docs:[]}}));return F(r,t.targets,t.roots)}a(Ko,"buildCorpusSnapshot");function ho(t){const s=t.stores.map(r=>({...r,snapshot:{root:r.snapshot.root,docs:[...r.snapshot.docs]}}));return F(s,t.targets,t.roots)}a(ho,"cloneCorpus");function N(t,s,r=new Set){let c;for(const d of t.stores)s.path.startsWith(`${d.snapshot.root}/`)&&(c===void 0||d.snapshot.root.length>c.snapshot.root.length)&&(c=d);if(c===void 0){if(r.has(s.path))return;throw new Error(`corpus migration: planned change outside every discovered store: ${s.path}`)}io(c.snapshot,s)}a(N,"foldCorpusChange");function Wo(t,s={}){const r=(s.migrations??co).filter(i=>i.lane==="corpus"),c=[...s.blockers??[]],d=[],m=[],u=[],y=[],v=[],P=[],S=[],b=a((i,l)=>({migrations:r.length,blocked:c.length>0&&r.length>0,blockers:c,planned:d,repositories:m,storePrefixes:u,renames:y,references:v,wrote:l,verified:i}),"result"),$={consumers:[],identities:[]};if(r.length===0)return b(!1,$);const I=ho(t);for(const i of r){const l=i.plan(I);c.push(...l.blockers),m.push(...l.repositories),u.push(...l.storePrefixes),y.push(...l.renames),v.push(...l.references);for(const g of l.consumers)N(I,g);const M=new Set(l.repositories.map(g=>g.declarationPath));for(const g of l.identities)N(I,g,M);P.push(...l.consumers),S.push(...l.identities),d.push({migration:i.description,consumers:l.consumers.map(g=>g.path),identities:l.identities.map(g=>g.path)})}const k={consumers:P.map(i=>i.path),identities:S.map(i=>i.path)};if(c.length>0)return b(!1,$);if(s.dryRun===!0)return b(!1,k);for(const i of P)i.after===null?O(i.path):L(i.path,i.after);for(const i of S)i.after===null?O(i.path):L(i.path,i.after);if(s.rebuild===void 0)return b(!1,k);const w=s.rebuild();for(const i of r)for(const l of i.verify?.(w)??[])c.push({...l,kind:"verification"});return b(!0,k)}a(Wo,"runCorpusMigrations");export{Ko as buildCorpusSnapshot,Co as discoverCorpus,Do as loadCorpusSnapshots,Eo as parseFailureBlockers,Wo as runCorpusMigrations};