@north-light/crouter 0.3.318 → 0.3.320

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

@@ -1,349 +1,3 @@
-import { dirname } from 'node:path';
-import { realpathOrSelf, readTextIfExists } from '../../core/fs-utils.js';
-import { parseFrontmatterGeneric } from '../../core/frontmatter.js';
-import { composeCanonicalName, explicitLocalName, localNameFromPath, validateExplicitLocalName, validateNamespace, } from '../../core/memory/identity.js';
-import { deriveProjectNamespace, } from '../../core/memory/project-namespace.js';
-import { associateRepository, } from '../../core/memory/repository-association.js';
-const SYNTHETIC_NAMESPACE = '__CROUTER_SYNTHETIC_NAMESPACE__';
-const SYNTHETIC_NAMESPACE_SCALAR = '__CROUTER_SYNTHETIC_NAMESPACE_SCALAR__';
-/** Exact source emitted by the superseded migration 003, with only its namespace
- * value parameterized. It is deliberately byte-shaped rather than prose-shaped:
- * a substantive nested guide is never deleted because it merely resembles this. */
-const SYNTHETIC_INDEX_TEMPLATE = [
-    '---',
-    'kind: knowledge',
-    `namespace: ${SYNTHETIC_NAMESPACE_SCALAR}`,
-    `when-and-why-to-read: When working in \`${SYNTHETIC_NAMESPACE}\`, this knowledge should be read because it names the namespace every document in this project answers under.`,
-    'surfaces:',
-    '  - on: workspace-open',
-    '    at: content',
-    '  - on: read',
-    '    match: "./**"',
-    '    at: content',
-    '---',
-    `# ${SYNTHETIC_NAMESPACE}`,
-    '',
-    `This project's memory store. Every document here answers at \`${SYNTHETIC_NAMESPACE}/<local name>\`.`,
-    '',
-].join('\n');
-export function planRepositories(corpus) {
-    const blockers = [];
-    const associated = [];
-    const groups = new Map();
-    const rootsInCorpusOrder = [];
-    for (const store of corpus.stores) {
-        if (!isNativeProjectStore(store))
-            continue;
-        const ownerDir = realpathOrSelf(ownerDirOf(store));
-        const result = associateRepository(ownerDir);
-        if (!result.ok) {
-            blockers.push({
-                kind: 'association',
-                message: `project memory store at ${store.key} owned by ${ownerDir} cannot be associated with a repository (${result.reason}) — repair the repository boundary and re-run`,
-                storeRoot: store.key,
-            });
-            continue;
-        }
-        const row = {
-            store,
-            ownerDir,
-            association: result.association,
-            rootDoc: store.snapshot.docs.find((doc) => localNameFromPath(doc.relPath) === '') ?? null,
-        };
-        associated.push(row);
-        const groupingKey = result.association.kind === 'git'
-            ? result.association.repositoryKey
-            : `path:${result.association.repositoryRoot}`;
-        let group = groups.get(groupingKey);
-        if (group === undefined) {
-            group = {
-                repositoryKey: result.association.repositoryKey,
-                roots: new Map(),
-            };
-            groups.set(groupingKey, group);
-        }
-        let root = group.roots.get(result.association.repositoryRoot);
-        if (root === undefined) {
-            root = {
-                association: result.association,
-                stores: [],
-                rootStore: null,
-                index: missingRootIndex(),
-                declaration: { state: 'missing' },
-            };
-            group.roots.set(result.association.repositoryRoot, root);
-            rootsInCorpusOrder.push(root);
-        }
-        root.stores.push(row);
-        if (result.association.ownerRelativePath === '' && root.rootStore === null)
-            root.rootStore = row;
-    }
-    const nestedByStore = new Map();
-    for (const row of associated) {
-        if (row.association.ownerRelativePath === '') {
-            nestedByStore.set(row.store.key, { declaration: { state: 'missing' }, action: 'none' });
-            continue;
-        }
-        const declaration = legacyNestedDeclarationFacts(row.rootDoc);
-        let action = 'none';
-        if (declaration.state === 'invalid') {
-            blockers.push(invalidDeclarationBlocker(row.store.key, row.rootDoc?.path ?? row.store.key, declaration, 'nested project memory store'));
-        }
-        else if (declaration.state === 'valid') {
-            action = row.rootDoc !== null && isSupersededSyntheticIndex(row.rootDoc.source, declaration.value)
-                ? 'synthetic-index-removed'
-                : 'removed';
-        }
-        nestedByStore.set(row.store.key, { declaration, action });
-    }
-    for (const root of rootsInCorpusOrder) {
-        root.index = readRootIndex(root);
-        root.declaration = root.index.error === null
-            ? declarationFacts(root.index.frontmatter?.['namespace'])
-            : { state: 'invalid', reason: root.index.error, raw: undefined };
-        if (root.declaration.state === 'invalid') {
-            blockers.push(invalidDeclarationBlocker(root.rootStore?.store.key ?? dirname(root.association.declarationPath), root.association.declarationPath, root.declaration, 'repository root'));
-        }
-    }
-    const selectedByRoot = new Map();
-    for (const group of groups.values())
-        selectGroup(group, selectedByRoot, blockers);
-    const repositories = [];
-    for (const root of rootsInCorpusOrder) {
-        const selected = selectedByRoot.get(root.association.repositoryRoot);
-        if (selected !== undefined)
-            repositories.push(selected.decision);
-    }
-    const prefixes = new Map();
-    for (const row of associated) {
-        const selected = selectedByRoot.get(row.association.repositoryRoot);
-        const nested = nestedByStore.get(row.store.key);
-        if (selected === undefined || nested.declaration.state === 'invalid')
-            continue;
-        const isRoot = row.association.ownerRelativePath === '';
-        const effectivePrefix = composeCanonicalName(selected.decision.namespace, row.association.ownerRelativePath);
-        const { oldPrefix, oldRule } = oldAuthority(row.store, isRoot, selected.declaration, nested.declaration, effectivePrefix);
-        prefixes.set(row.store.key, {
-            store: row.store,
-            storeKey: row.store.key,
-            storeRoot: row.store.key,
-            ownerDir: row.ownerDir,
-            repositoryKey: row.association.repositoryKey,
-            repositoryRoot: row.association.repositoryRoot,
-            ownerRelativePath: row.association.ownerRelativePath,
-            oldPrefix,
-            oldRule,
-            effectivePrefix,
-            nestedDeclarationAction: nested.action,
-            legacyDeclaration: !isRoot && nested.declaration.state === 'valid' ? nested.declaration.value : null,
-        });
-    }
-    addOwnerPathCollisionBlockers(associated, selectedByRoot, blockers);
-    return { repositories, prefixes, blockers };
-}
-/** What a store's documents answered under BEFORE this run, from file truth
- * alone. A store's own valid declaration proves its old prefix outright.
- *
- * A nested store that declares nothing is in one of two states, and they are not
- * the same authority: pre-003, where nothing up the tree declared anything and
- * its documents answered at bare local names; or already cut, where the
- * repository root's kept declaration is exactly what gave them their prefix. The
- * kept root declaration plus the absence of any explicit `name:` this cut would
- * have rewritten identifies the second — that pair is the corpus this migration
- * leaves behind, so reading it as pre-003 would report an identity rename for
- * every document that never moves. */
-function oldAuthority(store, isRoot, rootDeclaration, nestedDeclaration, effectivePrefix) {
-    const own = isRoot ? rootDeclaration : nestedDeclaration;
-    if (own.state === 'valid')
-        return { oldPrefix: own.value, oldRule: 'per-store-declaration' };
-    if (!isRoot && rootDeclaration.state === 'valid' && !carriesLegacyExplicitIdentity(store, effectivePrefix)) {
-        return { oldPrefix: effectivePrefix, oldRule: 'per-store-declaration' };
-    }
-    return { oldPrefix: '', oldRule: 'pre-003' };
-}
-/** An explicit `name:` this cut never leaves behind: one on a store root
- * document, or one that is not a store-local name under the store's own prefix —
- * a fully qualified pre-003 name is the shape that matters. Either proves the
- * store still carries pre-003 identity even though it declares nothing. */
-function carriesLegacyExplicitIdentity(store, effectivePrefix) {
-    return store.snapshot.docs.some((doc) => {
-        const explicit = explicitLocalName(doc.frontmatter);
-        if (explicit === null)
-            return false;
-        return localNameFromPath(doc.relPath) === '' || !validateExplicitLocalName(explicit, effectivePrefix).ok;
-    });
-}
-function selectGroup(group, selectedByRoot, blockers) {
-    const roots = [...group.roots.values()];
-    if (roots.some((root) => root.declaration.state === 'invalid'))
-        return;
-    const declared = roots.filter((root) => root.declaration.state === 'valid');
-    const values = [...new Set(declared.map((root) => root.declaration.value))];
-    if (values.length > 1) {
-        const paths = declared.map((root) => root.association.declarationPath);
-        blockers.push({
-            kind: 'namespace',
-            message: `linked repository roots for ${group.repositoryKey} declare different namespaces (${values.map((value) => `\`${value}\``).join(', ')}) — make every root declaration agree and re-run`,
-            paths,
-        });
-        return;
-    }
-    if (values.length === 1) {
-        const namespace = values[0];
-        for (const root of roots) {
-            const action = root.declaration.state === 'valid' ? 'kept' : 'filled-linked-root';
-            selectedByRoot.set(root.association.repositoryRoot, {
-                declaration: root.declaration,
-                decision: repositoryDecision(group, root, namespace, 'declared', action),
-            });
-        }
-        return;
-    }
-    const derivingRoot = roots[0];
-    const derived = deriveProjectNamespace({
-        ownerDir: derivingRoot.association.repositoryRoot,
-        rootFrontmatter: derivingRoot.index.frontmatter,
-        ...(derivingRoot.index.exists ? { rootBody: derivingRoot.index.body } : {}),
-    });
-    if (!derived.ok) {
-        blockers.push({
-            kind: 'namespace',
-            message: `repository at ${derivingRoot.association.repositoryRoot} cannot derive a namespace (${derived.reason}) — declare a valid \`namespace:\` on ${derivingRoot.association.declarationPath} and re-run`,
-            storeRoot: derivingRoot.rootStore?.store.key ?? dirname(derivingRoot.association.declarationPath),
-            ...(derivingRoot.index.exists ? { path: derivingRoot.association.declarationPath } : {}),
-        });
-        return;
-    }
-    for (const root of roots) {
-        selectedByRoot.set(root.association.repositoryRoot, {
-            declaration: root.declaration,
-            decision: repositoryDecision(group, root, derived.namespace, derived.source, root.index.exists ? 'kept' : 'created'),
-        });
-    }
-}
-function repositoryDecision(group, root, namespace, source, action) {
-    return {
-        repositoryKey: group.repositoryKey,
-        repositoryRoot: root.association.repositoryRoot,
-        declarationPath: root.association.declarationPath,
-        namespace,
-        source,
-        action,
-        storeKeys: root.stores.map((row) => row.store.key),
-    };
-}
-function readRootIndex(root) {
-    const declarationRealPath = realpathOrSelf(root.association.declarationPath);
-    const declarationDoc = root.rootStore?.store.snapshot.docs.find((doc) => realpathOrSelf(doc.path) === declarationRealPath);
-    if (declarationDoc !== undefined) {
-        return {
-            exists: true,
-            frontmatter: declarationDoc.frontmatter,
-            body: declarationDoc.body,
-            error: null,
-        };
-    }
-    try {
-        const source = readTextIfExists(root.association.declarationPath);
-        if (source === null)
-            return missingRootIndex();
-        const parsed = parseFrontmatterGeneric(source);
-        return {
-            exists: true,
-            frontmatter: parsed.data,
-            body: parsed.body,
-            error: null,
-        };
-    }
-    catch (error) {
-        return {
-            exists: true,
-            frontmatter: null,
-            body: '',
-            error: `cannot read or parse ${root.association.declarationPath} (${firstLine(error)})`,
-        };
-    }
-}
-function missingRootIndex() {
-    return { exists: false, frontmatter: null, body: '', error: null };
-}
-function legacyNestedDeclarationFacts(rootDoc) {
-    if (rootDoc?.frontmatter === null
-        || rootDoc?.frontmatter === undefined
-        || !Object.prototype.hasOwnProperty.call(rootDoc.frontmatter, 'namespace')) {
-        return { state: 'missing' };
-    }
-    return authoredDeclarationFacts(rootDoc.frontmatter['namespace']);
-}
-function declarationFacts(raw) {
-    if (raw === undefined || raw === null || raw === '')
-        return { state: 'missing' };
-    return authoredDeclarationFacts(raw);
-}
-function authoredDeclarationFacts(raw) {
-    if (typeof raw !== 'string') {
-        return {
-            state: 'invalid',
-            reason: `\`namespace:\` is non-string (${JSON.stringify(raw)})`,
-            raw,
-        };
-    }
-    const valid = validateNamespace(raw);
-    return valid.ok
-        ? { state: 'valid', value: raw }
-        : { state: 'invalid', reason: `\`namespace: ${raw}\` is invalid (${valid.reason})`, raw };
-}
-function invalidDeclarationBlocker(storeRoot, path, declaration, subject) {
-    return {
-        kind: 'namespace',
-        message: `${subject} has an invalid namespace declaration at ${path} (${declaration.reason}) — correct it and re-run; migration never replaces an unprovable identity`,
-        storeRoot,
-        path,
-        ...(typeof declaration.raw === 'string' ? { name: declaration.raw } : {}),
-    };
-}
-function addOwnerPathCollisionBlockers(associated, selectedByRoot, blockers) {
-    const collisions = new Map();
-    for (const row of associated) {
-        const key = `${row.association.repositoryRoot}\u0000${row.association.ownerRelativePath}`;
-        const bucket = collisions.get(key);
-        if (bucket === undefined)
-            collisions.set(key, [row]);
-        else
-            bucket.push(row);
-    }
-    for (const rows of collisions.values()) {
-        if (rows.length < 2)
-            continue;
-        const first = rows[0];
-        const selected = selectedByRoot.get(first.association.repositoryRoot);
-        const effectivePrefix = selected === undefined
-            ? first.association.ownerRelativePath
-            : composeCanonicalName(selected.decision.namespace, first.association.ownerRelativePath);
-        const paths = rows.map((row) => row.ownerDir);
-        blockers.push({
-            kind: 'collision',
-            message: `directories ${paths.join(', ')} in repository ${first.association.repositoryRoot} normalize to the same owner path \`${first.association.ownerRelativePath}\` and effective prefix \`${effectivePrefix}\` — rename one directory and re-run`,
-            storeRoot: first.store.key,
-            name: effectivePrefix,
-            paths,
-        });
-    }
-}
-function isSupersededSyntheticIndex(source, namespace) {
-    return source === SYNTHETIC_INDEX_TEMPLATE
-        .replaceAll(SYNTHETIC_NAMESPACE_SCALAR, renderScalar(namespace))
-        .replaceAll(SYNTHETIC_NAMESPACE, namespace);
-}
-function renderScalar(value) {
-    return /^[A-Za-z][A-Za-z0-9._\-/]*$/.test(value) ? value : JSON.stringify(value);
-}
-function ownerDirOf(store) {
-    return store.descriptor.ownerDir ?? dirname(dirname(store.descriptor.storeRoot));
-}
-function isNativeProjectStore(store) {
-    return store.descriptor.scope === 'project' && store.descriptor.plugin === undefined;
-}
-function firstLine(error) {
-    return (error instanceof Error ? error.message : String(error)).split('\n')[0] ?? String(error);
-}
+var A=Object.defineProperty;var p=(e,t)=>A(e,"name",{value:t,configurable:!0});import{dirname as v}from"node:path";import{realpathOrSelf as g,readTextIfExists as _}from"../../core/fs-utils.js";import{parseFrontmatterGeneric as C}from"../../core/frontmatter.js";import{composeCanonicalName as P,explicitLocalName as D,localNameFromPath as k,validateExplicitLocalName as T,validateNamespace as b}from"../../core/memory/identity.js";import{deriveProjectNamespace as I}from"../../core/memory/project-namespace.js";import{associateRepository as j}from"../../core/memory/repository-association.js";const R="__CROUTER_SYNTHETIC_NAMESPACE__",w="__CROUTER_SYNTHETIC_NAMESPACE_SCALAR__",K=["---","kind: knowledge",`namespace: ${w}`,`when-and-why-to-read: When working in \`${R}\`, this knowledge should be read because it names the namespace every document in this project answers under.`,"surfaces:","  - on: workspace-open","    at: content","  - on: read",'    match: "./**"',"    at: content","---",`# ${R}`,"",`This project's memory store. Every document here answers at \`${R}/<local name>\`.`,""].join(`
+`);function te(e){const t=[],r=[],n=new Map,a=[];for(const o of e.stores){if(!U(o))continue;const l=g(J(o)),d=j(l);if(!d.ok){t.push({kind:"association",message:`project memory store at ${o.key} owned by ${l} cannot be associated with a repository (${d.reason}) \u2014 repair the repository boundary and re-run`,storeRoot:o.key});continue}const m={store:o,ownerDir:l,association:d.association,rootDoc:o.snapshot.docs.find(N=>k(N.relPath)==="")??null};r.push(m);const h=d.association.kind==="git"?d.association.repositoryKey:`path:${d.association.repositoryRoot}`;let y=n.get(h);y===void 0&&(y={repositoryKey:d.association.repositoryKey,roots:new Map},n.set(h,y));let f=y.roots.get(d.association.repositoryRoot);f===void 0&&(f={association:d.association,stores:[],rootStore:null,index:$(),declaration:{state:"missing"}},y.roots.set(d.association.repositoryRoot,f),a.push(f)),f.stores.push(m),d.association.ownerRelativePath===""&&f.rootStore===null&&(f.rootStore=m)}const s=new Map;for(const o of r){if(o.association.ownerRelativePath===""){s.set(o.store.key,{declaration:{state:"missing"},action:"none"});continue}const l=H(o.rootDoc);let d="none";l.state==="invalid"?t.push(E(o.store.key,o.rootDoc?.path??o.store.key,l,"nested project memory store")):l.state==="valid"&&(d=o.rootDoc!==null&&z(o.rootDoc.source,l.value)?"synthetic-index-removed":"removed"),s.set(o.store.key,{declaration:l,action:d})}for(const o of a)o.index=F(o),o.declaration=o.index.error===null?Y(o.index.frontmatter?.namespace):{state:"invalid",reason:o.index.error,raw:void 0},o.declaration.state==="invalid"&&t.push(E(o.rootStore?.store.key??v(o.association.declarationPath),o.association.declarationPath,o.declaration,"repository root"));const i=new Map;for(const o of n.values())L(o,i,t);const u=[];for(const o of a){const l=i.get(o.association.repositoryRoot);l!==void 0&&u.push(l.decision)}const c=new Map;for(const o of r){const l=i.get(o.association.repositoryRoot),d=s.get(o.store.key);if(l===void 0||d.declaration.state==="invalid")continue;const m=o.association.ownerRelativePath==="",h=P(l.decision.namespace,o.association.ownerRelativePath),{oldPrefix:y,oldRule:f}=M(o.store,m,l.declaration,d.declaration,h);c.set(o.store.key,{store:o.store,storeKey:o.store.key,storeRoot:o.store.key,ownerDir:o.ownerDir,repositoryKey:o.association.repositoryKey,repositoryRoot:o.association.repositoryRoot,ownerRelativePath:o.association.ownerRelativePath,oldPrefix:y,oldRule:f,effectivePrefix:h,nestedDeclarationAction:d.action,legacyDeclaration:!m&&d.declaration.state==="valid"?d.declaration.value:null})}return B(r,i,t),{repositories:u,prefixes:c,blockers:t}}p(te,"planRepositories");function M(e,t,r,n,a){const s=t?r:n;return s.state==="valid"?{oldPrefix:s.value,oldRule:"per-store-declaration"}:!t&&r.state==="valid"&&!O(e,a)?{oldPrefix:a,oldRule:"per-store-declaration"}:{oldPrefix:"",oldRule:"pre-003"}}p(M,"oldAuthority");function O(e,t){return e.snapshot.docs.some(r=>{const n=D(r.frontmatter);return n===null?!1:k(r.relPath)===""||!T(n,t).ok})}p(O,"carriesLegacyExplicitIdentity");function L(e,t,r){const n=[...e.roots.values()];if(n.some(c=>c.declaration.state==="invalid"))return;const a=n.filter(c=>c.declaration.state==="valid"),s=[...new Set(a.map(c=>c.declaration.value))];if(s.length>1){const c=a.map(o=>o.association.declarationPath);r.push({kind:"namespace",message:`linked repository roots for ${e.repositoryKey} declare different namespaces (${s.map(o=>`\`${o}\``).join(", ")}) \u2014 make every root declaration agree and re-run`,paths:c});return}if(s.length===1){const c=s[0];for(const o of n){const l=o.declaration.state==="valid"?"kept":"filled-linked-root";t.set(o.association.repositoryRoot,{declaration:o.declaration,decision:x(e,o,c,"declared",l)})}return}const i=n[0],u=I({ownerDir:i.association.repositoryRoot,rootFrontmatter:i.index.frontmatter,...i.index.exists?{rootBody:i.index.body}:{}});if(!u.ok){r.push({kind:"namespace",message:`repository at ${i.association.repositoryRoot} cannot derive a namespace (${u.reason}) \u2014 declare a valid \`namespace:\` on ${i.association.declarationPath} and re-run`,storeRoot:i.rootStore?.store.key??v(i.association.declarationPath),...i.index.exists?{path:i.association.declarationPath}:{}});return}for(const c of n)t.set(c.association.repositoryRoot,{declaration:c.declaration,decision:x(e,c,u.namespace,u.source,c.index.exists?"kept":"created")})}p(L,"selectGroup");function x(e,t,r,n,a){return{repositoryKey:e.repositoryKey,repositoryRoot:t.association.repositoryRoot,declarationPath:t.association.declarationPath,namespace:r,source:n,action:a,storeKeys:t.stores.map(s=>s.store.key)}}p(x,"repositoryDecision");function F(e){const t=g(e.association.declarationPath),r=e.rootStore?.store.snapshot.docs.find(n=>g(n.path)===t);if(r!==void 0)return{exists:!0,frontmatter:r.frontmatter,body:r.body,error:null};try{const n=_(e.association.declarationPath);if(n===null)return $();const a=C(n);return{exists:!0,frontmatter:a.data,body:a.body,error:null}}catch(n){return{exists:!0,frontmatter:null,body:"",error:`cannot read or parse ${e.association.declarationPath} (${Z(n)})`}}}p(F,"readRootIndex");function $(){return{exists:!1,frontmatter:null,body:"",error:null}}p($,"missingRootIndex");function H(e){return e?.frontmatter===null||e?.frontmatter===void 0||!Object.prototype.hasOwnProperty.call(e.frontmatter,"namespace")?{state:"missing"}:S(e.frontmatter.namespace)}p(H,"legacyNestedDeclarationFacts");function Y(e){return e==null||e===""?{state:"missing"}:S(e)}p(Y,"declarationFacts");function S(e){if(typeof e!="string")return{state:"invalid",reason:`\`namespace:\` is non-string (${JSON.stringify(e)})`,raw:e};const t=b(e);return t.ok?{state:"valid",value:e}:{state:"invalid",reason:`\`namespace: ${e}\` is invalid (${t.reason})`,raw:e}}p(S,"authoredDeclarationFacts");function E(e,t,r,n){return{kind:"namespace",message:`${n} has an invalid namespace declaration at ${t} (${r.reason}) \u2014 correct it and re-run; migration never replaces an unprovable identity`,storeRoot:e,path:t,...typeof r.raw=="string"?{name:r.raw}:{}}}p(E,"invalidDeclarationBlocker");function B(e,t,r){const n=new Map;for(const a of e){const s=`${a.association.repositoryRoot}\0${a.association.ownerRelativePath}`,i=n.get(s);i===void 0?n.set(s,[a]):i.push(a)}for(const a of n.values()){if(a.length<2)continue;const s=a[0],i=t.get(s.association.repositoryRoot),u=i===void 0?s.association.ownerRelativePath:P(i.decision.namespace,s.association.ownerRelativePath),c=a.map(o=>o.ownerDir);r.push({kind:"collision",message:`directories ${c.join(", ")} in repository ${s.association.repositoryRoot} normalize to the same owner path \`${s.association.ownerRelativePath}\` and effective prefix \`${u}\` \u2014 rename one directory and re-run`,storeRoot:s.store.key,name:u,paths:c})}}p(B,"addOwnerPathCollisionBlockers");function z(e,t){return e===K.replaceAll(w,G(t)).replaceAll(R,t)}p(z,"isSupersededSyntheticIndex");function G(e){return/^[A-Za-z][A-Za-z0-9._\-/]*$/.test(e)?e:JSON.stringify(e)}p(G,"renderScalar");function J(e){return e.descriptor.ownerDir??v(v(e.descriptor.storeRoot))}p(J,"ownerDirOf");function U(e){return e.descriptor.scope==="project"&&e.descriptor.plugin===void 0}p(U,"isNativeProjectStore");function Z(e){return(e instanceof Error?e.message:String(e)).split(`
+`)[0]??String(e)}p(Z,"firstLine");export{te as planRepositories};

package/dist/migrations/activation.js

@@ -1,89 +1,2 @@
-import { mkdirSync, rmSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { onDiskMigrationLockPath, onDiskMigrationMarkerPath } from '../core/canvas/paths.js';
-import { withExclusiveDirectoryLockAsync } from '../core/exclusive-lock.js';
-import { DAEMON_STARTUP_WINDOW_MS } from '../daemon/startup-policy.js';
-import { atomicWriteJson, readJsonOrNull } from '../core/fs-utils.js';
-import { onDiskMigrationIdentity } from './registry.js';
-import { runOnDiskMigrations } from './runner.js';
-function markerIsCurrent() {
-    const stored = readJsonOrNull(onDiskMigrationMarkerPath());
-    return JSON.stringify(stored) === JSON.stringify(onDiskMigrationIdentity());
-}
-function writeCurrentMarker() {
-    atomicWriteJson(onDiskMigrationMarkerPath(), onDiskMigrationIdentity());
-}
-function blockerPaths(result) {
-    return [...new Set(result.blockers.flatMap((blocker) => [
-            ...(blocker.path === undefined ? [] : [blocker.path]),
-            ...(blocker.paths ?? []),
-            ...(blocker.storeRoot === undefined ? [] : [blocker.storeRoot]),
-        ]))];
-}
-/** A migration blocker is a STANDING condition, not a transient fault: the same
- *  corpus produces the same blockers on every boot, so a caller that retries a
- *  daemon start against one retries forever. Typing it lets the startup path
- *  tell "try again" apart from "this needs a human", and carry the repair line
- *  to whoever can act on it. */
-export class MigrationBlockedError extends Error {
-    blockerPaths;
-    constructor(message, blockerPaths) {
-        super(message);
-        this.name = 'MigrationBlockedError';
-        this.blockerPaths = blockerPaths;
-    }
-}
-function activationError(result) {
-    const paths = blockerPaths(result);
-    const findings = result.blockers.map((blocker) => `${blocker.kind}: ${blocker.message}`);
-    const writes = [
-        ...result.wrote.profileManifests,
-        ...result.wrote.documents,
-        ...result.wrote.corpusConsumers,
-        ...result.wrote.corpusIdentities,
-    ];
-    const lines = result.blockers.length > 0
-        ? [`on-disk migration blocked by ${result.blockers.length} finding(s)`, ...findings]
-        : ['on-disk migration did not complete final verification'];
-    if (paths.length > 0)
-        lines.push(`Blocker paths: ${paths.join(', ')}`);
-    if (writes.length > 0)
-        lines.push(`Writes completed before failure: ${writes.join(', ')}`);
-    lines.push('Repair: crtr sys migrate');
-    return new MigrationBlockedError(lines.join('\n'), paths);
-}
-async function coordinate(mode, options) {
-    const lockPath = onDiskMigrationLockPath();
-    mkdirSync(dirname(lockPath), { recursive: true, mode: 0o700 });
-    return withExclusiveDirectoryLockAsync(lockPath, async () => {
-        if (mode === 'activation' && markerIsCurrent())
-            return null;
-        const dryRun = options.dryRun === true;
-        if (!dryRun)
-            rmSync(onDiskMigrationMarkerPath(), { force: true });
-        const result = await (options.runner ?? runOnDiskMigrations)({
-            dryRun,
-            explicitDirs: options.explicitDirs,
-            nodes: options.nodes,
-        });
-        if (!dryRun && result.finalVerificationSucceeded)
-            writeCurrentMarker();
-        if (mode === 'activation' && !result.finalVerificationSucceeded)
-            throw activationError(result);
-        return result;
-    }, {
-        timeoutMs: options.timeoutMs ?? DAEMON_STARTUP_WINDOW_MS,
-        timeoutError: () => new Error(`timed out waiting for on-disk migration lock: ${lockPath}`),
-    });
-}
-/** Run startup migration only when this home lacks the current completion marker. */
-export async function activateOnDiskMigrations(options) {
-    return coordinate('activation', options);
-}
-/** Run migrations regardless of the marker; dry runs leave marker state untouched. */
-export async function runForcedOnDiskMigrations(options) {
-    const result = await coordinate('forced', options);
-    if (result === null)
-        throw new Error('forced on-disk migration unexpectedly skipped');
-    return result;
-}
+var f=Object.defineProperty;var t=(r,i)=>f(r,"name",{value:i,configurable:!0});import{mkdirSync as d,rmSync as m}from"node:fs";import{dirname as p}from"node:path";import{onDiskMigrationLockPath as l,onDiskMigrationMarkerPath as s}from"../core/canvas/paths.js";import{withExclusiveDirectoryLockAsync as k}from"../core/exclusive-lock.js";import{DAEMON_STARTUP_WINDOW_MS as g}from"../daemon/startup-policy.js";import{atomicWriteJson as h,readJsonOrNull as w}from"../core/fs-utils.js";import{onDiskMigrationIdentity as a}from"./registry.js";import{runOnDiskMigrations as y}from"./runner.js";function M(){const r=w(s());return JSON.stringify(r)===JSON.stringify(a())}t(M,"markerIsCurrent");function D(){h(s(),a())}t(D,"writeCurrentMarker");function E(r){return[...new Set(r.blockers.flatMap(i=>[...i.path===void 0?[]:[i.path],...i.paths??[],...i.storeRoot===void 0?[]:[i.storeRoot]]))]}t(E,"blockerPaths");class S extends Error{static{t(this,"MigrationBlockedError")}blockerPaths;constructor(i,o){super(i),this.name="MigrationBlockedError",this.blockerPaths=o}}function v(r){const i=E(r),o=r.blockers.map(c=>`${c.kind}: ${c.message}`),e=[...r.wrote.profileManifests,...r.wrote.documents,...r.wrote.corpusConsumers,...r.wrote.corpusIdentities],n=r.blockers.length>0?[`on-disk migration blocked by ${r.blockers.length} finding(s)`,...o]:["on-disk migration did not complete final verification"];return i.length>0&&n.push(`Blocker paths: ${i.join(", ")}`),e.length>0&&n.push(`Writes completed before failure: ${e.join(", ")}`),n.push("Repair: crtr sys migrate"),new S(n.join(`
+`),i)}t(v,"activationError");async function u(r,i){const o=l();return d(p(o),{recursive:!0,mode:448}),k(o,async()=>{if(r==="activation"&&M())return null;const e=i.dryRun===!0;e||m(s(),{force:!0});const n=await(i.runner??y)({dryRun:e,explicitDirs:i.explicitDirs,nodes:i.nodes});if(!e&&n.finalVerificationSucceeded&&D(),r==="activation"&&!n.finalVerificationSucceeded)throw v(n);return n},{timeoutMs:i.timeoutMs??g,timeoutError:t(()=>new Error(`timed out waiting for on-disk migration lock: ${o}`),"timeoutError")})}t(u,"coordinate");async function W(r){return u("activation",r)}t(W,"activateOnDiskMigrations");async function j(r){const i=await u("forced",r);if(i===null)throw new Error("forced on-disk migration unexpectedly skipped");return i}t(j,"runForcedOnDiskMigrations");export{S as MigrationBlockedError,W as activateOnDiskMigrations,j as runForcedOnDiskMigrations};

package/dist/migrations/convergent.js

@@ -1,82 +1,2 @@
-// The convergent-lane runner: snapshot one memory store, let each registered
-// convergent migration plan full-text rewrites, write them atomically.
-// Convergence, not journaling — every run re-scans the store and rewrites
-// whatever still matches an old shape, so a doc that arrives later (sync,
-// restore, hand-edit) is caught by the next run.
-import { relative, sep } from 'node:path';
-import { atomicWriteText, readText, removePath, walkFiles } from '../core/fs-utils.js';
-import { parseFrontmatterGeneric } from '../core/frontmatter.js';
-import { STATE_MIGRATIONS } from './registry.js';
-function parseDoc(root, file) {
-    const relPath = relative(root, file).split(sep).join('/');
-    const source = readText(file);
-    try {
-        const { data, body } = parseFrontmatterGeneric(source);
-        return { doc: { path: file, relPath, source, frontmatter: data, body } };
-    }
-    catch (e) {
-        return { error: (e instanceof Error ? e.message : String(e)).split('\n')[0] };
-    }
-}
-/** Snapshot every parseable `.md` under `root` (hidden dirs — `.history`
- *  sidecars and the like — skipped, mirroring substrate doc enumeration).
- *  `SKILL.md` bundles are Agent Skills, not memory docs: they carry no
- *  canonical identity and are never rewritten. */
-export function loadStoreSnapshot(root) {
-    const docs = [];
-    const skipped = [];
-    for (const file of walkFiles(root, (n) => n.endsWith('.md') && n !== 'SKILL.md', (d) => d.startsWith('.'))) {
-        const parsed = parseDoc(root, file);
-        if ('doc' in parsed)
-            docs.push(parsed.doc);
-        else
-            skipped.push({ relPath: relative(root, file).split(sep).join('/'), error: parsed.error });
-    }
-    return { snapshot: { root, docs }, skipped };
-}
-/** Fold one applied change back into the in-memory snapshot so the NEXT
- *  migration plans against post-change state (dry runs included — that is what
- *  makes a dry-run diff equal the real run's writes). A migration that emits
- *  invalid YAML is a defect and throws here, before anything else compounds
- *  on its output. */
-export function foldDocChange(snapshot, change) {
-    const i = snapshot.docs.findIndex((d) => d.path === change.path);
-    if (change.after === null) {
-        if (i >= 0)
-            snapshot.docs.splice(i, 1);
-        return;
-    }
-    const relPath = relative(snapshot.root, change.path).split(sep).join('/');
-    const { data, body } = parseFrontmatterGeneric(change.after);
-    const doc = { path: change.path, relPath, source: change.after, frontmatter: data, body };
-    if (i >= 0)
-        snapshot.docs[i] = doc;
-    else
-        snapshot.docs.push(doc);
-}
-/** Run every registered convergent migration over the store at `root`, in
- *  registry order. No-op changes (identical text) are filtered; each real
- *  change is written atomically unless `dryRun`. Journaled migrations in the
- *  list are the db chain's business and are skipped here. */
-export function runConvergentMigrations(root, opts = {}) {
-    const migrations = (opts.migrations ?? STATE_MIGRATIONS).filter((m) => m.lane === 'convergent');
-    const { snapshot, skipped } = loadStoreSnapshot(root);
-    const applied = [];
-    for (const migration of migrations) {
-        const bySource = new Map(snapshot.docs.map((d) => [d.path, d.source]));
-        const changes = migration.apply(snapshot).filter((change) => change.after === null ? bySource.has(change.path) : bySource.get(change.path) !== change.after);
-        if (changes.length === 0)
-            continue;
-        for (const change of changes) {
-            if (opts.dryRun !== true) {
-                if (change.after === null)
-                    removePath(change.path);
-                else
-                    atomicWriteText(change.path, change.after);
-            }
-            foldDocChange(snapshot, change);
-        }
-        applied.push({ migration: migration.description, files: changes.map((c) => c.path) });
-    }
-    return { root, applied, skipped, snapshot };
-}
+var m=Object.defineProperty;var p=(o,t)=>m(o,"name",{value:t,configurable:!0});import{relative as l,sep as d}from"node:path";import{atomicWriteText as h,readText as S,removePath as g,walkFiles as x}from"../core/fs-utils.js";import{parseFrontmatterGeneric as u}from"../core/frontmatter.js";import{STATE_MIGRATIONS as y}from"./registry.js";function T(o,t){const s=l(o,t).split(d).join("/"),n=S(t);try{const{data:r,body:a}=u(n);return{doc:{path:t,relPath:s,source:n,frontmatter:r,body:a}}}catch(r){return{error:(r instanceof Error?r.message:String(r)).split(`
+`)[0]}}}p(T,"parseDoc");function v(o){const t=[],s=[];for(const n of x(o,r=>r.endsWith(".md")&&r!=="SKILL.md",r=>r.startsWith("."))){const r=T(o,n);"doc"in r?t.push(r.doc):s.push({relPath:l(o,n).split(d).join("/"),error:r.error})}return{snapshot:{root:o,docs:t},skipped:s}}p(v,"loadStoreSnapshot");function I(o,t){const s=o.docs.findIndex(c=>c.path===t.path);if(t.after===null){s>=0&&o.docs.splice(s,1);return}const n=l(o.root,t.path).split(d).join("/"),{data:r,body:a}=u(t.after),i={path:t.path,relPath:n,source:t.after,frontmatter:r,body:a};s>=0?o.docs[s]=i:o.docs.push(i)}p(I,"foldDocChange");function W(o,t={}){const s=(t.migrations??y).filter(i=>i.lane==="convergent"),{snapshot:n,skipped:r}=v(o),a=[];for(const i of s){const c=new Map(n.docs.map(e=>[e.path,e.source])),f=i.apply(n).filter(e=>e.after===null?c.has(e.path):c.get(e.path)!==e.after);if(f.length!==0){for(const e of f)t.dryRun!==!0&&(e.after===null?g(e.path):h(e.path,e.after)),I(n,e);a.push({migration:i.description,files:f.map(e=>e.path)})}}return{root:o,applied:a,skipped:r,snapshot:n}}p(W,"runConvergentMigrations");export{I as foldDocChange,v as loadStoreSnapshot,W as runConvergentMigrations};