@north-light/crouter 0.3.318 → 0.3.320

package/dist/migrations/003-repository-root-memory-identity/index.js

@@ -1,513 +1,5 @@
-// 003 — replace per-store project identity with one repository-root declaration.
-//
-// The migration freezes both pre-003 identity shapes, resolves consumers against
-// that old corpus, then writes consumers before the repository identity cut.
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, matchesGlob } from 'node:path';
-import { realpathOrSelf } from '../../core/fs-utils.js';
-import { parseFrontmatterGeneric } from '../../core/frontmatter.js';
-import { loadStoreMemoryDocs, openProjectMemoryStore } from '../../core/memory-resolver.js';
-import { canonicalSegments, composeCanonicalName, explicitLocalName, INDEX_SEGMENT, localNameFromPath, normalizeDocName, normalizeNameSegment, resolveLocalName, stripNamespace, validateExplicitLocalName, validateNamespace, } from '../../core/memory/identity.js';
-import { lintMemoryStore, MEMORY_LINT_IDENTITY_RULES, resolvableCanonicalNames } from '../../core/memory/lint.js';
-import { completeRootFrontDoor, demoteLeafSurfaces, planFrontDoors, rootIndexSource, } from './front-door.js';
-import { planRepositories, } from './repository-facts.js';
-import { applySplices, itemFor, keyLineSpan, linkRewrites, OldCorpus, renderScalar, routeRewrites, valueSpan, viewsForStore, yamlBlock, yamlMap, } from './references.js';
-let planned = { links: [], routes: [], wrote: new Set(), repositories: [] };
-function emptyPlan(blockers = []) {
-    return {
-        blockers,
-        consumers: [],
-        identities: [],
-        repositories: [],
-        storePrefixes: [],
-        renames: [],
-        references: [],
-    };
-}
-/** Frozen pre-003 path-derived name: no project prefix and no INDEX collapse. */
-function pathNameNoCollapse(relPath) {
-    return canonicalSegments(relPath.replace(/\\/g, '/').replace(/\.md$/i, ''))
-        .map(normalizeNameSegment)
-        .join('/');
-}
-function rawExplicitName(doc) {
-    const raw = doc.frontmatter?.['name'];
-    return typeof raw === 'string' && raw.trim() !== '' ? raw.trim() : null;
-}
-function ownerDirOf(store) {
-    return store.descriptor.ownerDir ?? dirname(dirname(store.descriptor.storeRoot));
-}
-function isProjectStore(descriptor) {
-    return descriptor.scope === 'project' && descriptor.plugin === undefined;
-}
-function fallbackPrefix(store) {
-    const effectivePrefix = store.descriptor.namespace;
-    const ownerDir = ownerDirOf(store);
-    const oldPrefix = store.descriptor.plugin ?? '';
-    return {
-        store,
-        storeKey: store.key,
-        storeRoot: store.snapshot.root,
-        ownerDir,
-        repositoryKey: '',
-        repositoryRoot: ownerDir,
-        ownerRelativePath: '',
-        oldPrefix,
-        oldRule: 'pre-003',
-        effectivePrefix,
-        nestedDeclarationAction: 'none',
-        legacyDeclaration: null,
-    };
-}
-function repositoryForPrefix(prefix, repositories) {
-    return repositories.find((repository) => repository.repositoryRoot === prefix.repositoryRoot);
-}
-function buildDocFacts(store, prefix, repositories, blockers) {
-    const repository = repositoryForPrefix(prefix, repositories);
-    const facts = [];
-    if (store.snapshot.docs.length === 0)
-        return facts;
-    if (store.descriptor.plugin !== undefined) {
-        const valid = validateNamespace(prefix.effectivePrefix);
-        if (!valid.ok) {
-            blockers.push({
-                kind: 'namespace',
-                message: `plugin \`${store.descriptor.plugin}\` mounts its memory under \`${prefix.effectivePrefix}\`, which is not a valid namespace (${valid.reason}) — fix the plugin package and re-run`,
-                storeRoot: store.key,
-                name: prefix.effectivePrefix,
-            });
-        }
-    }
-    for (const doc of store.snapshot.docs) {
-        const pathLocal = localNameFromPath(doc.relPath);
-        if (pathLocal === '' && !isProjectStore(store.descriptor) && store.descriptor.plugin === undefined) {
-            blockers.push({
-                kind: 'namespace',
-                message: `a root ${INDEX_SEGMENT}.md in a ${store.descriptor.scope} store composes to the empty canonical name — only a project store's root document answers at its effective prefix; rename this file to a named document (\`<topic>.md\`) or fold its content into the docs it introduces, then re-run`,
-                storeRoot: store.key,
-                path: doc.path,
-            });
-        }
-        const raw = rawExplicitName(doc);
-        const frozenLocal = raw === null ? pathNameNoCollapse(doc.relPath) : normalizeDocName(raw);
-        const oldName = prefix.oldRule === 'per-store-declaration'
-            ? composeCanonicalName(prefix.oldPrefix, resolveLocalName(doc.frontmatter, pathLocal))
-            : composeCanonicalName(prefix.oldPrefix, frozenLocal);
-        let finalLocal = pathLocal;
-        let nameEdit = null;
-        if (pathLocal === '') {
-            if (raw !== null)
-                nameEdit = 'remove';
-        }
-        else {
-            const explicit = explicitLocalName(doc.frontmatter);
-            if (explicit !== null) {
-                const localized = stripNamespace(explicit, prefix.effectivePrefix) ?? explicit;
-                if (localized === '' || localized === pathLocal) {
-                    nameEdit = 'remove';
-                }
-                else {
-                    const valid = validateExplicitLocalName(localized, prefix.effectivePrefix);
-                    if (!valid.ok) {
-                        blockers.push({
-                            kind: 'namespace',
-                            message: `explicit \`name: ${raw}\` cannot become a store-local name (${valid.reason}) — correct it and re-run`,
-                            storeRoot: store.key,
-                            path: doc.path,
-                            name: raw ?? localized,
-                        });
-                    }
-                    finalLocal = localized;
-                    if (localized !== raw)
-                        nameEdit = { value: localized };
-                }
-            }
-        }
-        let namespaceEdit = null;
-        if (pathLocal === '' && isProjectStore(store.descriptor)) {
-            if (prefix.ownerRelativePath === '') {
-                const declared = doc.frontmatter?.['namespace'];
-                if (repository !== undefined && declared !== repository.namespace) {
-                    namespaceEdit = { value: repository.namespace };
-                }
-            }
-            else if (prefix.nestedDeclarationAction !== 'none') {
-                namespaceEdit = 'remove';
-            }
-        }
-        facts.push({
-            doc,
-            storeKey: store.key,
-            realPath: realpathOrSelf(doc.path),
-            oldName,
-            finalName: composeCanonicalName(prefix.effectivePrefix, finalLocal),
-            finalLocal,
-            nameEdit,
-            namespaceEdit,
-            oldPrefix: prefix.oldPrefix,
-            deleted: prefix.nestedDeclarationAction === 'synthetic-index-removed' && pathLocal === '',
-        });
-    }
-    return facts;
-}
-function addFinalCollisions(store, facts, blockers) {
-    const byFinalName = new Map();
-    for (const fact of facts) {
-        const bucket = byFinalName.get(fact.finalName);
-        if (bucket === undefined)
-            byFinalName.set(fact.finalName, [fact]);
-        else
-            bucket.push(fact);
-    }
-    for (const [name, bucket] of byFinalName) {
-        if (bucket.length < 2)
-            continue;
-        blockers.push({
-            kind: 'collision',
-            message: `${bucket.length} documents in this store would own canonical name \`${name}\` (${bucket.map((fact) => fact.doc.relPath).join(', ')}) — merge them into one document or rename one, then re-run`,
-            storeRoot: store.key,
-            name,
-            paths: bucket.map((fact) => fact.doc.path),
-        });
-    }
-}
-function packageOwnedCorpusMessage(store, fact) {
-    const owner = store.descriptor.plugin !== undefined ? `plugin \`${store.descriptor.plugin}\`` : "crouter's builtin corpus";
-    const remedy = store.descriptor.plugin !== undefined
-        ? `update the plugin package (\`crtr pkg plugin update ${store.descriptor.plugin}\`) once it ships the corrected corpus`
-        : 'update crouter (`crtr sys update`) to a release whose builtin corpus already uses repository-root identity';
-    return `${fact.doc.relPath} needs an identity rewrite (\`${fact.oldName}\` → \`${fact.finalName}\`) in ${owner}, a package-owned store this migration never writes — ${remedy}`;
-}
-function identityRewrites(source, store, fact, result) {
-    if (fact.nameEdit === null && fact.namespaceEdit === null)
-        return [];
-    const block = yamlBlock(source);
-    if (block === null) {
-        if (fact.namespaceEdit === null || fact.namespaceEdit === 'remove')
-            return [];
-        return [{ start: 0, end: 0, text: `---\nnamespace: ${renderScalar(fact.namespaceEdit.value)}\n---\n` }];
-    }
-    const map = yamlMap(block.raw);
-    if (map === null) {
-        result.blockers.push({
-            kind: 'parse-failure',
-            message: `${fact.doc.relPath}: frontmatter is not a YAML mapping, so its identity fields cannot be rewritten — fix the file and re-run`,
-            storeRoot: store.key,
-            path: fact.doc.path,
-        });
-        return [];
-    }
-    const splices = [];
-    if (fact.namespaceEdit !== null) {
-        const item = itemFor(map, 'namespace');
-        if (fact.namespaceEdit === 'remove') {
-            if (item !== null) {
-                const span = keyLineSpan(block.raw, item);
-                if (span !== null)
-                    splices.push({ start: block.base + span[0], end: block.base + span[1], text: '' });
-            }
-        }
-        else if (item === null) {
-            splices.push({
-                start: block.base,
-                end: block.base,
-                text: `namespace: ${renderScalar(fact.namespaceEdit.value)}\n`,
-            });
-        }
-        else {
-            const span = valueSpan(block.raw, item);
-            if (span !== null) {
-                splices.push({
-                    start: block.base + span[0],
-                    end: block.base + span[1],
-                    text: renderScalar(fact.namespaceEdit.value),
-                });
-            }
-        }
-    }
-    if (fact.nameEdit !== null) {
-        const item = itemFor(map, 'name');
-        if (item !== null) {
-            if (fact.nameEdit === 'remove') {
-                const span = keyLineSpan(block.raw, item);
-                if (span !== null)
-                    splices.push({ start: block.base + span[0], end: block.base + span[1], text: '' });
-            }
-            else {
-                const span = valueSpan(block.raw, item);
-                if (span !== null) {
-                    splices.push({
-                        start: block.base + span[0],
-                        end: block.base + span[1],
-                        text: renderScalar(fact.nameEdit.value),
-                    });
-                }
-            }
-        }
-    }
-    return splices;
-}
-function storePrefixRow(prefix, plans) {
-    const frontDoorAction = prefix.ownerRelativePath === ''
-        ? (plans.find((plan) => plan.storeKey === prefix.storeKey)?.action ?? 'none')
-        : 'none';
-    return {
-        storeRoot: prefix.storeRoot,
-        ownerDir: prefix.ownerDir,
-        repositoryRoot: prefix.repositoryRoot,
-        ownerRelativePath: prefix.ownerRelativePath,
-        oldPrefix: prefix.oldPrefix,
-        oldRule: prefix.oldRule,
-        effectivePrefix: prefix.effectivePrefix,
-        nestedDeclarationAction: prefix.nestedDeclarationAction,
-        frontDoorAction,
-    };
-}
-function repositoryRow(decision) {
-    return {
-        repositoryRoot: decision.repositoryRoot,
-        repositoryKey: decision.repositoryKey,
-        declarationPath: decision.declarationPath,
-        namespace: decision.namespace,
-        source: decision.source,
-        action: decision.action,
-    };
-}
-function plan(snapshot) {
-    planned = { links: [], routes: [], wrote: new Set(), repositories: [] };
-    const result = emptyPlan();
-    const repositoryPlan = planRepositories(snapshot);
-    if (repositoryPlan.blockers.length > 0)
-        return emptyPlan(repositoryPlan.blockers);
-    const docsByStoreKey = new Map();
-    const prefixByStoreKey = new Map();
-    for (const store of snapshot.stores) {
-        const prefix = repositoryPlan.prefixes.get(store.key) ?? fallbackPrefix(store);
-        prefixByStoreKey.set(store.key, prefix);
-        const facts = buildDocFacts(store, prefix, repositoryPlan.repositories, result.blockers);
-        docsByStoreKey.set(store.key, facts);
-        addFinalCollisions(store, facts, result.blockers);
-    }
-    const oldCorpus = new OldCorpus(docsByStoreKey);
-    const finalNameByPath = new Map();
-    for (const facts of docsByStoreKey.values()) {
-        for (const fact of facts)
-            finalNameByPath.set(fact.realPath, fact.finalName);
-    }
-    const frontDoorResult = planFrontDoors(repositoryPlan.repositories, repositoryPlan.prefixes, snapshot, (realPath) => finalNameByPath.get(realpathOrSelf(realPath)));
-    result.blockers.push(...frontDoorResult.blockers);
-    result.repositories.push(...repositoryPlan.repositories.map(repositoryRow));
-    result.storePrefixes.push(...[...repositoryPlan.prefixes.values()].map((prefix) => storePrefixRow(prefix, frontDoorResult.plans)));
-    const completeRoot = new Set(frontDoorResult.plans
-        .filter((frontDoor) => frontDoor.rootAction === 'completed')
-        .map((frontDoor) => realpathOrSelf(frontDoor.rootDocPath)));
-    const demotedLeaf = new Set(frontDoorResult.plans
-        .map((frontDoor) => frontDoor.leafDocPath)
-        .filter((path) => path !== null)
-        .map(realpathOrSelf));
-    const identityChanges = new Map();
-    for (const store of snapshot.stores) {
-        const prefix = prefixByStoreKey.get(store.key);
-        const facts = docsByStoreKey.get(store.key) ?? [];
-        const views = store.writable ? viewsForStore(snapshot, store) : [];
-        for (const fact of facts) {
-            const consumerSplices = store.writable
-                ? [
-                    ...linkRewrites(oldCorpus, views, store, fact, result, planned.links),
-                    ...routeRewrites(oldCorpus, views, store, fact, prefix, result, planned.routes),
-                ]
-                : [];
-            const text1 = applySplices(fact.doc.source, consumerSplices);
-            if (fact.deleted && store.writable) {
-                identityChanges.set(fact.realPath, { path: fact.doc.path, after: null });
-                continue;
-            }
-            const text2 = completeRoot.has(fact.realPath)
-                ? completeRootFrontDoor(text1, fact.doc.path)
-                : demotedLeaf.has(fact.realPath)
-                    ? demoteLeafSurfaces(text1, fact.doc.path)
-                    : text1;
-            const ownSplices = identityRewrites(text2, store, fact, result);
-            const finalText = applySplices(text2, ownSplices);
-            if (!store.writable) {
-                const prefixMoved = fact.oldPrefix !== prefix.effectivePrefix;
-                if ((prefixMoved || ownSplices.length > 0) && fact.oldName !== fact.finalName) {
-                    result.blockers.push({
-                        kind: 'package-owned-corpus',
-                        message: packageOwnedCorpusMessage(store, fact),
-                        storeRoot: store.key,
-                        path: fact.doc.path,
-                        name: fact.finalName,
-                    });
-                }
-                continue;
-            }
-            if (consumerSplices.length > 0)
-                result.consumers.push({ path: fact.doc.path, after: text1 });
-            if (text2 !== text1 || ownSplices.length > 0)
-                identityChanges.set(fact.realPath, { path: fact.doc.path, after: finalText });
-            const identityMoved = fact.oldPrefix !== prefix.effectivePrefix || fact.nameEdit !== null || fact.namespaceEdit !== null;
-            if (identityMoved && fact.oldName !== fact.finalName) {
-                result.renames.push({
-                    storeRoot: store.key,
-                    path: fact.doc.path,
-                    from: fact.oldName,
-                    to: fact.finalName,
-                });
-            }
-        }
-    }
-    // FrontDoorPlan alone creates repository-root indexes. Root writes precede
-    // leaf demotions so an interrupted phase always leaves an authoritative door.
-    for (const frontDoor of frontDoorResult.plans) {
-        if (frontDoor.rootAction === 'created') {
-            const repository = repositoryPlan.repositories.find((candidate) => candidate.repositoryRoot === frontDoor.repositoryRoot);
-            if (repository === undefined) {
-                throw new Error(`migration 003: no repository decision for ${frontDoor.repositoryRoot}`);
-            }
-            result.identities.push({
-                path: frontDoor.rootDocPath,
-                after: rootIndexSource(repository.namespace, frontDoor.leafCanonicalName),
-            });
-        }
-        else {
-            const rootKey = realpathOrSelf(frontDoor.rootDocPath);
-            const rootChange = identityChanges.get(rootKey);
-            if (rootChange !== undefined) {
-                result.identities.push(rootChange);
-                identityChanges.delete(rootKey);
-            }
-        }
-    }
-    for (const frontDoor of frontDoorResult.plans) {
-        if (frontDoor.leafDocPath === null)
-            continue;
-        const leafKey = realpathOrSelf(frontDoor.leafDocPath);
-        const leafChange = identityChanges.get(leafKey);
-        if (leafChange !== undefined) {
-            result.identities.push(leafChange);
-            identityChanges.delete(leafKey);
-        }
-    }
-    result.identities.push(...identityChanges.values());
-    for (const change of [...result.consumers, ...result.identities])
-        planned.wrote.add(change.path);
-    planned.repositories = result.repositories.map((row) => ({ ...row }));
-    return result;
-}
-function freshDescriptor(store) {
-    return isProjectStore(store.descriptor) ? openProjectMemoryStore(ownerDirOf(store)) : store.descriptor;
-}
-function sameSet(a, b) {
-    if (a.size !== b.size)
-        return false;
-    for (const value of a)
-        if (!b.has(value))
-            return false;
-    return true;
-}
-function safeGlob(target, glob) {
-    try {
-        return matchesGlob(target, glob);
-    }
-    catch {
-        return false;
-    }
-}
-function verify(snapshot) {
-    const findings = [];
-    for (const repository of planned.repositories) {
-        if (!existsSync(repository.declarationPath)) {
-            findings.push({
-                kind: 'verification',
-                message: `repository declaration ${repository.declarationPath} was not written`,
-                path: repository.declarationPath,
-                name: repository.namespace,
-            });
-            continue;
-        }
-        try {
-            const declared = parseFrontmatterGeneric(readFileSync(repository.declarationPath, 'utf8')).data?.['namespace'];
-            if (declared === repository.namespace)
-                continue;
-            findings.push({
-                kind: 'verification',
-                message: `repository declaration ${repository.declarationPath} declares ${JSON.stringify(declared)}, not the planned namespace \`${repository.namespace}\``,
-                path: repository.declarationPath,
-                name: repository.namespace,
-            });
-        }
-        catch (error) {
-            findings.push({
-                kind: 'verification',
-                message: `repository declaration ${repository.declarationPath} cannot be parsed after the write (${error instanceof Error ? error.message : String(error)})`,
-                path: repository.declarationPath,
-                name: repository.namespace,
-            });
-        }
-    }
-    for (const store of snapshot.stores) {
-        if (!store.writable || store.snapshot.docs.length === 0)
-            continue;
-        for (const finding of lintMemoryStore(freshDescriptor(store)).errors) {
-            const damage = finding.rule === 'yaml' && planned.wrote.has(finding.path);
-            if (!MEMORY_LINT_IDENTITY_RULES.has(finding.rule) && !damage)
-                continue;
-            findings.push({
-                kind: 'verification',
-                message: `${finding.rule}: ${finding.message}`,
-                storeRoot: store.key,
-                path: finding.path,
-                ...(finding.name === undefined ? {} : { name: finding.name }),
-            });
-        }
-    }
-    const viewCache = new Map();
-    const viewFor = (targetId) => {
-        const cached = viewCache.get(targetId);
-        if (cached !== undefined)
-            return cached;
-        const docs = snapshot.storesForTarget(targetId).flatMap((store) => loadStoreMemoryDocs(freshDescriptor(store), true));
-        const view = {
-            names: resolvableCanonicalNames(docs),
-            docs: docs.map((doc) => ({ name: doc.name, realPath: realpathOrSelf(doc.path) })),
-        };
-        viewCache.set(targetId, view);
-        return view;
-    };
-    for (const proof of planned.links) {
-        if (viewFor(proof.targetId).names.has(proof.name))
-            continue;
-        findings.push({
-            kind: 'verification',
-            message: `rewritten link [[${proof.name}]] resolves to no document in target ${proof.targetId} after the write phases`,
-            path: proof.carrier,
-            targetId: proof.targetId,
-            name: proof.name,
-        });
-    }
-    for (const proof of planned.routes) {
-        const view = viewFor(proof.targetId);
-        const actual = new Set();
-        for (const doc of view.docs) {
-            if (proof.globs.some((glob) => safeGlob(doc.name, glob)))
-                actual.add(doc.realPath);
-        }
-        if (sameSet(actual, new Set(proof.expected)))
-            continue;
-        findings.push({
-            kind: 'verification',
-            message: `rewritten memory-read route \`${proof.globs.join(', ')}\` names ${actual.size} document(s) in target ${proof.targetId}, not the ${proof.expected.length} it named before the cut`,
-            path: proof.carrier,
-            targetId: proof.targetId,
-        });
-    }
-    return findings;
-}
-export const repositoryRootMemoryIdentityMigration = {
-    id: '003-repository-root-memory-identity',
-    lane: 'corpus',
-    description: 'repository-root memory identity: one namespace per repository, nested stores derive their prefix from their path under it',
-    plan,
-    verify,
-};
+var K=Object.defineProperty;var f=(e,o)=>K(e,"name",{value:o,configurable:!0});import{existsSync as A,readFileSync as j}from"node:fs";import{dirname as N,matchesGlob as z}from"node:path";import{realpathOrSelf as g}from"../../core/fs-utils.js";import{parseFrontmatterGeneric as O}from"../../core/frontmatter.js";import{loadStoreMemoryDocs as T,openProjectMemoryStore as B}from"../../core/memory-resolver.js";import{canonicalSegments as G,composeCanonicalName as $,explicitLocalName as _,INDEX_SEGMENT as Y,localNameFromPath as J,normalizeDocName as U,normalizeNameSegment as X,resolveLocalName as q,stripNamespace as H,validateExplicitLocalName as Q,validateNamespace as V}from"../../core/memory/identity.js";import{lintMemoryStore as W,MEMORY_LINT_IDENTITY_RULES as Z,resolvableCanonicalNames as ee}from"../../core/memory/lint.js";import{completeRootFrontDoor as te,demoteLeafSurfaces as oe,planFrontDoors as ne,rootIndexSource as re}from"./front-door.js";import{planRepositories as ae}from"./repository-facts.js";import{applySplices as S,itemFor as D,keyLineSpan as E,linkRewrites as ie,OldCorpus as se,renderScalar as v,routeRewrites as ce,valueSpan as M,viewsForStore as le,yamlBlock as pe,yamlMap as de}from"./references.js";let h={links:[],routes:[],wrote:new Set,repositories:[]};function F(e=[]){return{blockers:e,consumers:[],identities:[],repositories:[],storePrefixes:[],renames:[],references:[]}}f(F,"emptyPlan");function fe(e){return G(e.replace(/\\/g,"/").replace(/\.md$/i,"")).map(X).join("/")}f(fe,"pathNameNoCollapse");function me(e){const o=e.frontmatter?.name;return typeof o=="string"&&o.trim()!==""?o.trim():null}f(me,"rawExplicitName");function C(e){return e.descriptor.ownerDir??N(N(e.descriptor.storeRoot))}f(C,"ownerDirOf");function x(e){return e.scope==="project"&&e.plugin===void 0}f(x,"isProjectStore");function ue(e){const o=e.descriptor.namespace,r=C(e),p=e.descriptor.plugin??"";return{store:e,storeKey:e.key,storeRoot:e.snapshot.root,ownerDir:r,repositoryKey:"",repositoryRoot:r,ownerRelativePath:"",oldPrefix:p,oldRule:"pre-003",effectivePrefix:o,nestedDeclarationAction:"none",legacyDeclaration:null}}f(ue,"fallbackPrefix");function he(e,o){return o.find(r=>r.repositoryRoot===e.repositoryRoot)}f(he,"repositoryForPrefix");function ye(e,o,r,p){const t=he(o,r),a=[];if(e.snapshot.docs.length===0)return a;if(e.descriptor.plugin!==void 0){const i=V(o.effectivePrefix);i.ok||p.push({kind:"namespace",message:`plugin \`${e.descriptor.plugin}\` mounts its memory under \`${o.effectivePrefix}\`, which is not a valid namespace (${i.reason}) \u2014 fix the plugin package and re-run`,storeRoot:e.key,name:o.effectivePrefix})}for(const i of e.snapshot.docs){const l=J(i.relPath);l===""&&!x(e.descriptor)&&e.descriptor.plugin===void 0&&p.push({kind:"namespace",message:`a root ${Y}.md in a ${e.descriptor.scope} store composes to the empty canonical name \u2014 only a project store's root document answers at its effective prefix; rename this file to a named document (\`<topic>.md\`) or fold its content into the docs it introduces, then re-run`,storeRoot:e.key,path:i.path});const c=me(i),k=c===null?fe(i.relPath):U(c),u=o.oldRule==="per-store-declaration"?$(o.oldPrefix,q(i.frontmatter,l)):$(o.oldPrefix,k);let n=l,d=null;if(l==="")c!==null&&(d="remove");else{const y=_(i.frontmatter);if(y!==null){const s=H(y,o.effectivePrefix)??y;if(s===""||s===l)d="remove";else{const w=Q(s,o.effectivePrefix);w.ok||p.push({kind:"namespace",message:`explicit \`name: ${c}\` cannot become a store-local name (${w.reason}) \u2014 correct it and re-run`,storeRoot:e.key,path:i.path,name:c??s}),n=s,s!==c&&(d={value:s})}}}let m=null;if(l===""&&x(e.descriptor))if(o.ownerRelativePath===""){const y=i.frontmatter?.namespace;t!==void 0&&y!==t.namespace&&(m={value:t.namespace})}else o.nestedDeclarationAction!=="none"&&(m="remove");a.push({doc:i,storeKey:e.key,realPath:g(i.path),oldName:u,finalName:$(o.effectivePrefix,n),finalLocal:n,nameEdit:d,namespaceEdit:m,oldPrefix:o.oldPrefix,deleted:o.nestedDeclarationAction==="synthetic-index-removed"&&l===""})}return a}f(ye,"buildDocFacts");function ge(e,o,r){const p=new Map;for(const t of o){const a=p.get(t.finalName);a===void 0?p.set(t.finalName,[t]):a.push(t)}for(const[t,a]of p)a.length<2||r.push({kind:"collision",message:`${a.length} documents in this store would own canonical name \`${t}\` (${a.map(i=>i.doc.relPath).join(", ")}) \u2014 merge them into one document or rename one, then re-run`,storeRoot:e.key,name:t,paths:a.map(i=>i.doc.path)})}f(ge,"addFinalCollisions");function we(e,o){const r=e.descriptor.plugin!==void 0?`plugin \`${e.descriptor.plugin}\``:"crouter's builtin corpus",p=e.descriptor.plugin!==void 0?`update the plugin package (\`crtr pkg plugin update ${e.descriptor.plugin}\`) once it ships the corrected corpus`:"update crouter (`crtr sys update`) to a release whose builtin corpus already uses repository-root identity";return`${o.doc.relPath} needs an identity rewrite (\`${o.oldName}\` \u2192 \`${o.finalName}\`) in ${r}, a package-owned store this migration never writes \u2014 ${p}`}f(we,"packageOwnedCorpusMessage");function Pe(e,o,r,p){if(r.nameEdit===null&&r.namespaceEdit===null)return[];const t=pe(e);if(t===null)return r.namespaceEdit===null||r.namespaceEdit==="remove"?[]:[{start:0,end:0,text:`---
+namespace: ${v(r.namespaceEdit.value)}
+---
+`}];const a=de(t.raw);if(a===null)return p.blockers.push({kind:"parse-failure",message:`${r.doc.relPath}: frontmatter is not a YAML mapping, so its identity fields cannot be rewritten \u2014 fix the file and re-run`,storeRoot:o.key,path:r.doc.path}),[];const i=[];if(r.namespaceEdit!==null){const l=D(a,"namespace");if(r.namespaceEdit==="remove"){if(l!==null){const c=E(t.raw,l);c!==null&&i.push({start:t.base+c[0],end:t.base+c[1],text:""})}}else if(l===null)i.push({start:t.base,end:t.base,text:`namespace: ${v(r.namespaceEdit.value)}
+`});else{const c=M(t.raw,l);c!==null&&i.push({start:t.base+c[0],end:t.base+c[1],text:v(r.namespaceEdit.value)})}}if(r.nameEdit!==null){const l=D(a,"name");if(l!==null)if(r.nameEdit==="remove"){const c=E(t.raw,l);c!==null&&i.push({start:t.base+c[0],end:t.base+c[1],text:""})}else{const c=M(t.raw,l);c!==null&&i.push({start:t.base+c[0],end:t.base+c[1],text:v(r.nameEdit.value)})}}return i}f(Pe,"identityRewrites");function ve(e,o){const r=e.ownerRelativePath===""?o.find(p=>p.storeKey===e.storeKey)?.action??"none":"none";return{storeRoot:e.storeRoot,ownerDir:e.ownerDir,repositoryRoot:e.repositoryRoot,ownerRelativePath:e.ownerRelativePath,oldPrefix:e.oldPrefix,oldRule:e.oldRule,effectivePrefix:e.effectivePrefix,nestedDeclarationAction:e.nestedDeclarationAction,frontDoorAction:r}}f(ve,"storePrefixRow");function ke(e){return{repositoryRoot:e.repositoryRoot,repositoryKey:e.repositoryKey,declarationPath:e.declarationPath,namespace:e.namespace,source:e.source,action:e.action}}f(ke,"repositoryRow");function Re(e){h={links:[],routes:[],wrote:new Set,repositories:[]};const o=F(),r=ae(e);if(r.blockers.length>0)return F(r.blockers);const p=new Map,t=new Map;for(const n of e.stores){const d=r.prefixes.get(n.key)??ue(n);t.set(n.key,d);const m=ye(n,d,r.repositories,o.blockers);p.set(n.key,m),ge(n,m,o.blockers)}const a=new se(p),i=new Map;for(const n of p.values())for(const d of n)i.set(d.realPath,d.finalName);const l=ne(r.repositories,r.prefixes,e,n=>i.get(g(n)));o.blockers.push(...l.blockers),o.repositories.push(...r.repositories.map(ke)),o.storePrefixes.push(...[...r.prefixes.values()].map(n=>ve(n,l.plans)));const c=new Set(l.plans.filter(n=>n.rootAction==="completed").map(n=>g(n.rootDocPath))),k=new Set(l.plans.map(n=>n.leafDocPath).filter(n=>n!==null).map(g)),u=new Map;for(const n of e.stores){const d=t.get(n.key),m=p.get(n.key)??[],y=n.writable?le(e,n):[];for(const s of m){const w=n.writable?[...ie(a,y,n,s,o,h.links),...ce(a,y,n,s,d,o,h.routes)]:[],P=S(s.doc.source,w);if(s.deleted&&n.writable){u.set(s.realPath,{path:s.doc.path,after:null});continue}const R=c.has(s.realPath)?te(P,s.doc.path):k.has(s.realPath)?oe(P,s.doc.path):P,b=Pe(R,n,s,o),L=S(R,b);if(!n.writable){(s.oldPrefix!==d.effectivePrefix||b.length>0)&&s.oldName!==s.finalName&&o.blockers.push({kind:"package-owned-corpus",message:we(n,s),storeRoot:n.key,path:s.doc.path,name:s.finalName});continue}w.length>0&&o.consumers.push({path:s.doc.path,after:P}),(R!==P||b.length>0)&&u.set(s.realPath,{path:s.doc.path,after:L}),(s.oldPrefix!==d.effectivePrefix||s.nameEdit!==null||s.namespaceEdit!==null)&&s.oldName!==s.finalName&&o.renames.push({storeRoot:n.key,path:s.doc.path,from:s.oldName,to:s.finalName})}}for(const n of l.plans)if(n.rootAction==="created"){const d=r.repositories.find(m=>m.repositoryRoot===n.repositoryRoot);if(d===void 0)throw new Error(`migration 003: no repository decision for ${n.repositoryRoot}`);o.identities.push({path:n.rootDocPath,after:re(d.namespace,n.leafCanonicalName)})}else{const d=g(n.rootDocPath),m=u.get(d);m!==void 0&&(o.identities.push(m),u.delete(d))}for(const n of l.plans){if(n.leafDocPath===null)continue;const d=g(n.leafDocPath),m=u.get(d);m!==void 0&&(o.identities.push(m),u.delete(d))}o.identities.push(...u.values());for(const n of[...o.consumers,...o.identities])h.wrote.add(n.path);return h.repositories=o.repositories.map(n=>({...n})),o}f(Re,"plan");function I(e){return x(e.descriptor)?B(C(e)):e.descriptor}f(I,"freshDescriptor");function be(e,o){if(e.size!==o.size)return!1;for(const r of e)if(!o.has(r))return!1;return!0}f(be,"sameSet");function $e(e,o){try{return z(e,o)}catch{return!1}}f($e,"safeGlob");function xe(e){const o=[];for(const t of h.repositories){if(!A(t.declarationPath)){o.push({kind:"verification",message:`repository declaration ${t.declarationPath} was not written`,path:t.declarationPath,name:t.namespace});continue}try{const a=O(j(t.declarationPath,"utf8")).data?.namespace;if(a===t.namespace)continue;o.push({kind:"verification",message:`repository declaration ${t.declarationPath} declares ${JSON.stringify(a)}, not the planned namespace \`${t.namespace}\``,path:t.declarationPath,name:t.namespace})}catch(a){o.push({kind:"verification",message:`repository declaration ${t.declarationPath} cannot be parsed after the write (${a instanceof Error?a.message:String(a)})`,path:t.declarationPath,name:t.namespace})}}for(const t of e.stores)if(!(!t.writable||t.snapshot.docs.length===0))for(const a of W(I(t)).errors){const i=a.rule==="yaml"&&h.wrote.has(a.path);!Z.has(a.rule)&&!i||o.push({kind:"verification",message:`${a.rule}: ${a.message}`,storeRoot:t.key,path:a.path,...a.name===void 0?{}:{name:a.name}})}const r=new Map,p=f(t=>{const a=r.get(t);if(a!==void 0)return a;const i=e.storesForTarget(t).flatMap(c=>T(I(c),!0)),l={names:ee(i),docs:i.map(c=>({name:c.name,realPath:g(c.path)}))};return r.set(t,l),l},"viewFor");for(const t of h.links)p(t.targetId).names.has(t.name)||o.push({kind:"verification",message:`rewritten link [[${t.name}]] resolves to no document in target ${t.targetId} after the write phases`,path:t.carrier,targetId:t.targetId,name:t.name});for(const t of h.routes){const a=p(t.targetId),i=new Set;for(const l of a.docs)t.globs.some(c=>$e(l.name,c))&&i.add(l.realPath);be(i,new Set(t.expected))||o.push({kind:"verification",message:`rewritten memory-read route \`${t.globs.join(", ")}\` names ${i.size} document(s) in target ${t.targetId}, not the ${t.expected.length} it named before the cut`,path:t.carrier,targetId:t.targetId})}return o}f(xe,"verify");const Oe={id:"003-repository-root-memory-identity",lane:"corpus",description:"repository-root memory identity: one namespace per repository, nested stores derive their prefix from their path under it",plan:Re,verify:xe};export{Oe as repositoryRootMemoryIdentityMigration};