@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/memory/identity.js

@@ -1,181 +1 @@
-// identity.ts — the ONE memory-identity rule. Every loader, placement helper,
-// linter, and migration derives names here rather than reproducing string
-// arithmetic: a document has a store-local name, its store declares a namespace
-// (a project's declaration, an installed plugin's mount prefix, or empty), and
-// its canonical name — the only address resolution accepts — is namespace ⊕
-// local. Pure and side-effect free.
-// Segment normalization — the optional `NN-` ordering pin. A physical path may
-// carry a two-digit prefix on any segment (`00-runtime-base/`, `01-spine/`)
-// purely to pin structural order against natural sort. The prefix is NEVER part
-// of identity: only the physical path keeps it.
-const NUMERIC_PREFIX_RE = /^\d{2}-/;
-const SEGMENT_RE = /^[A-Za-z0-9._-]+$/;
-/** The filename (and path segment) whose document fronts its directory. */
-export const INDEX_SEGMENT = 'INDEX';
-/** Strip an optional `NN-` ordering prefix from ONE segment. */
-export function normalizeNameSegment(segment) {
-    return segment.replace(NUMERIC_PREFIX_RE, '');
-}
-/** Slugify one authored or filesystem label into a canonical segment. */
-export function slugCanonicalSegment(raw) {
-    return normalizeNameSegment(raw.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, ''));
-}
-/** Slugify a derived label into canonical path segments. Empty segments are
- * intentionally dropped; owner paths use slugCanonicalSegment directly. */
-export function slugCanonicalPath(raw) {
-    return raw
-        .replace(/\\/g, '/')
-        .replace(/\.md$/i, '')
-        .split('/')
-        .map(slugCanonicalSegment)
-        .filter(Boolean)
-        .join('/');
-}
-/** Strip the ordering prefix from EVERY segment of a slash-separated name:
- *  `01-spine/00-has-manager` -> `spine/has-manager`. */
-export function normalizeDocName(name) {
-    return name.split('/').map(normalizeNameSegment).join('/');
-}
-/** Split a name into segments, dropping empties from `//`, a leading `/`, or an
- *  empty name. */
-export function canonicalSegments(name) {
-    return name.split('/').filter((s) => s !== '');
-}
-/** The canonical directory containing `name`, or `''` at the top. */
-export function canonicalParent(name) {
-    const segments = canonicalSegments(name);
-    return segments.slice(0, -1).join('/');
-}
-/** Remove EXACTLY ONE trailing `INDEX` segment. `a/INDEX` -> `a`; `INDEX` ->
- *  `''` (a store root); `a/INDEX/INDEX` -> `a/INDEX` (the inner segment is an
- *  ordinary directory name). */
-export function collapseTrailingIndex(name) {
-    const segments = canonicalSegments(name);
-    if (segments[segments.length - 1] === INDEX_SEGMENT)
-        segments.pop();
-    return segments.join('/');
-}
-/** Normalized identity segments of a store-relative markdown path, extension
- *  stripped. */
-function pathIdentitySegments(physicalRelativePath) {
-    return canonicalSegments(physicalRelativePath.replace(/\\/g, '/').replace(/\.md$/i, '')).map(normalizeNameSegment);
-}
-/** Which form a store-relative markdown path takes. */
-export function representationForPath(physicalRelativePath) {
-    const segments = pathIdentitySegments(physicalRelativePath);
-    return segments[segments.length - 1] === INDEX_SEGMENT ? 'directory-index' : 'leaf-file';
-}
-/** Store-local name derived from a store-relative markdown path: ordering
- *  prefixes stripped from every segment and one trailing `INDEX` collapsed.
- *  Empty only for a store root `INDEX.md`. */
-export function localNameFromPath(physicalRelativePath) {
-    return collapseTrailingIndex(pathIdentitySegments(physicalRelativePath).join('/'));
-}
-/** The store-relative markdown path a local name occupies in a given form.
- *  Both forms are checked before any create or move, so occupancy never depends
- *  on which one a store happens to use. */
-export function physicalRelativePathFor(localName, representation) {
-    const local = canonicalSegments(localName).join('/');
-    if (local === '') {
-        if (representation === 'leaf-file')
-            throw new Error('a store root document has no leaf-file representation');
-        return `${INDEX_SEGMENT}.md`;
-    }
-    return representation === 'directory-index' ? `${local}/${INDEX_SEGMENT}.md` : `${local}.md`;
-}
-// Local name and canonical composition.
-/** A document's explicit frontmatter `name` as a local name — normalized with
- *  one trailing `INDEX` collapsed — or `null` when it carries none. */
-export function explicitLocalName(fm) {
-    const raw = fm?.['name'];
-    if (typeof raw !== 'string' || raw.trim() === '')
-        return null;
-    return collapseTrailingIndex(normalizeDocName(raw.trim()));
-}
-/** A document's store-local name: its explicit frontmatter `name` when present,
- *  else the path-derived local name. Explicit names are local to their store —
- *  they never carry the store's namespace. */
-export function resolveLocalName(fm, pathDerivedLocalName) {
-    return explicitLocalName(fm) ?? pathDerivedLocalName;
-}
-/** namespace ⊕ local — the only address. Composition is unconditional: a local
- *  name that already looks namespace-prefixed is composed anyway, so identity
- *  never depends on string coincidence. An empty result means a namespace-less
- *  store root, which has no valid canonical identity. */
-export function composeCanonicalName(namespace, localName) {
-    const ns = canonicalSegments(namespace).join('/');
-    const local = canonicalSegments(localName).join('/');
-    if (ns === '')
-        return local;
-    return local === '' ? ns : `${ns}/${local}`;
-}
-/** The canonical directory a document's `./` memory-read entries match against:
- *  a directory document anchors at its own name, an ordinary leaf at its
- *  canonical parent. */
-export function routingAnchorFor(canonicalName, representation) {
-    return representation === 'directory-index' ? canonicalSegments(canonicalName).join('/') : canonicalParent(canonicalName);
-}
-/** The local name a canonical name has inside `namespace`, or `null` when it
- *  falls outside it. Exact on segment boundaries: `a/bc` is not inside `a/b`.
- *  The namespace itself yields `''` — the store root document. */
-export function stripNamespace(canonicalName, namespace) {
-    const name = canonicalSegments(canonicalName);
-    const ns = canonicalSegments(namespace);
-    for (let i = 0; i < ns.length; i++) {
-        if (name[i] !== ns[i])
-            return null;
-    }
-    return name.slice(ns.length).join('/');
-}
-function invalidSegmentReason(name) {
-    for (const segment of name.split('/')) {
-        if (segment === '')
-            return `empty segment in \`${name}\``;
-        if (segment === '.' || segment === '..')
-            return `relative segment \`${segment}\` in \`${name}\``;
-        if (!SEGMENT_RE.test(segment))
-            return `segment \`${segment}\` is not [A-Za-z0-9._-]`;
-        if (NUMERIC_PREFIX_RE.test(segment)) {
-            return `segment \`${segment}\` carries an \`NN-\` ordering prefix, which is physical-path-only — use \`${normalizeNameSegment(segment)}\``;
-        }
-    }
-    return null;
-}
-/** A project store's declared namespace, or an installed plugin's mount prefix:
- *  one or more normalized segments, never ending in `INDEX`. */
-export function validateNamespace(namespace) {
-    if (namespace.trim() !== namespace)
-        return { ok: false, reason: 'namespace has surrounding whitespace' };
-    if (namespace === '')
-        return { ok: false, reason: 'namespace is empty' };
-    const badSegment = invalidSegmentReason(namespace);
-    if (badSegment !== null)
-        return { ok: false, reason: badSegment };
-    if (canonicalSegments(namespace).pop() === INDEX_SEGMENT) {
-        return { ok: false, reason: `namespace ends in \`${INDEX_SEGMENT}\`` };
-    }
-    return { ok: true };
-}
-/** An explicit non-root `name:`: a non-empty local name, never ending in
- *  `INDEX` (its directory name is the identity) and never carrying its own
- *  store's namespace. */
-export function validateExplicitLocalName(localName, namespace = '') {
-    if (localName.trim() !== localName)
-        return { ok: false, reason: 'name has surrounding whitespace' };
-    if (localName === '')
-        return { ok: false, reason: 'name is empty' };
-    const badSegment = invalidSegmentReason(localName);
-    if (badSegment !== null)
-        return { ok: false, reason: badSegment };
-    if (canonicalSegments(localName).pop() === INDEX_SEGMENT) {
-        const collapsed = collapseTrailingIndex(localName);
-        return {
-            ok: false,
-            reason: `name ends in \`${INDEX_SEGMENT}\` — a directory document answers at its directory name${collapsed === '' ? '' : `, so use \`${collapsed}\``}`,
-        };
-    }
-    if (namespace !== '' && stripNamespace(localName, namespace) !== null) {
-        return { ok: false, reason: `name repeats its store's namespace \`${namespace}\` — explicit names are store-local` };
-    }
-    return { ok: true };
-}
+var m=Object.defineProperty;var t=(e,n)=>m(e,"name",{value:n,configurable:!0});const c=/^\d{2}-/,g=/^[A-Za-z0-9._-]+$/,s="INDEX";function u(e){return e.replace(c,"")}t(u,"normalizeNameSegment");function d(e){return u(e.trim().toLowerCase().replace(/[^a-z0-9._-]+/g,"-").replace(/^-+|-+$/g,""))}t(d,"slugCanonicalSegment");function k(e){return e.replace(/\\/g,"/").replace(/\.md$/i,"").split("/").map(d).filter(Boolean).join("/")}t(k,"slugCanonicalPath");function x(e){return e.split("/").map(u).join("/")}t(x,"normalizeDocName");function o(e){return e.split("/").filter(n=>n!=="")}t(o,"canonicalSegments");function h(e){return o(e).slice(0,-1).join("/")}t(h,"canonicalParent");function l(e){const n=o(e);return n[n.length-1]===s&&n.pop(),n.join("/")}t(l,"collapseTrailingIndex");function f(e){return o(e.replace(/\\/g,"/").replace(/\.md$/i,"")).map(u)}t(f,"pathIdentitySegments");function j(e){const n=f(e);return n[n.length-1]===s?"directory-index":"leaf-file"}t(j,"representationForPath");function N(e){return l(f(e).join("/"))}t(N,"localNameFromPath");function S(e,n){const r=o(e).join("/");if(r===""){if(n==="leaf-file")throw new Error("a store root document has no leaf-file representation");return`${s}.md`}return n==="directory-index"?`${r}/${s}.md`:`${r}.md`}t(S,"physicalRelativePathFor");function $(e){const n=e?.name;return typeof n!="string"||n.trim()===""?null:l(x(n.trim()))}t($,"explicitLocalName");function w(e,n){return $(e)??n}t(w,"resolveLocalName");function _(e,n){const r=o(e).join("/"),i=o(n).join("/");return r===""?i:i===""?r:`${r}/${i}`}t(_,"composeCanonicalName");function v(e,n){return n==="directory-index"?o(e).join("/"):h(e)}t(v,"routingAnchorFor");function y(e,n){const r=o(e),i=o(n);for(let a=0;a<i.length;a++)if(r[a]!==i[a])return null;return r.slice(i.length).join("/")}t(y,"stripNamespace");function p(e){for(const n of e.split("/")){if(n==="")return`empty segment in \`${e}\``;if(n==="."||n==="..")return`relative segment \`${n}\` in \`${e}\``;if(!g.test(n))return`segment \`${n}\` is not [A-Za-z0-9._-]`;if(c.test(n))return`segment \`${n}\` carries an \`NN-\` ordering prefix, which is physical-path-only \u2014 use \`${u(n)}\``}return null}t(p,"invalidSegmentReason");function I(e){if(e.trim()!==e)return{ok:!1,reason:"namespace has surrounding whitespace"};if(e==="")return{ok:!1,reason:"namespace is empty"};const n=p(e);return n!==null?{ok:!1,reason:n}:o(e).pop()===s?{ok:!1,reason:`namespace ends in \`${s}\``}:{ok:!0}}t(I,"validateNamespace");function P(e,n=""){if(e.trim()!==e)return{ok:!1,reason:"name has surrounding whitespace"};if(e==="")return{ok:!1,reason:"name is empty"};const r=p(e);if(r!==null)return{ok:!1,reason:r};if(o(e).pop()===s){const i=l(e);return{ok:!1,reason:`name ends in \`${s}\` \u2014 a directory document answers at its directory name${i===""?"":`, so use \`${i}\``}`}}return n!==""&&y(e,n)!==null?{ok:!1,reason:`name repeats its store's namespace \`${n}\` \u2014 explicit names are store-local`}:{ok:!0}}t(P,"validateExplicitLocalName");export{s as INDEX_SEGMENT,h as canonicalParent,o as canonicalSegments,l as collapseTrailingIndex,_ as composeCanonicalName,$ as explicitLocalName,N as localNameFromPath,x as normalizeDocName,u as normalizeNameSegment,S as physicalRelativePathFor,j as representationForPath,w as resolveLocalName,v as routingAnchorFor,k as slugCanonicalPath,d as slugCanonicalSegment,y as stripNamespace,P as validateExplicitLocalName,I as validateNamespace};

package/dist/core/memory/inline-ref-grammar.js

@@ -1,98 +1 @@
-// inline-ref-grammar.ts — the single source of truth for the inline
-// memory-reference token grammar (spec §4.1). The broker and terminal attach
-// viewer import these zero-dependency string operations directly rather than
-// each re-implementing `[A-Za-z0-9_:-]`,
-// trimming, boundary detection, or `:` decoding. Divergence between the
-// viewer's highlight rule and the broker's resolution rule would let a
-// highlighted token yield no guidance (or vice versa) — see the spec and
-// `/Users/silasrhyneer/.crouter/canvas/nodes/3zl47w7d-mrxwyqvr-73569670/context/design-inline-memory-references.md`.
-//
-// This module never resolves anything: `findRefTokens` and
-// `findRefTokenAtCaret` return candidate tokens; a caller decides a token is a
-// *resolved ref* only when `candidate` is an exact, case-sensitive member of
-// the broker-supplied inventory `Set<string>` of visible canonical names.
-// §4.1 step 2: the maximal run captured after a token-starting `/`.
-const NAME_CHAR = /[A-Za-z0-9_:-]/;
-// §4.1 step 3: a run must trim down to end on one of these to survive.
-const KEEP_CHAR = /[A-Za-z0-9]/;
-// §4.1 step 1: "ASCII whitespace" only — not the broader Unicode `\s` class.
-const ASCII_WHITESPACE = /[ \t\n\r\f\v]/;
-function isNameChar(ch) {
-    return NAME_CHAR.test(ch);
-}
-function isAsciiWhitespace(ch) {
-    return ASCII_WHITESPACE.test(ch);
-}
-// A `/` at `index` is a valid token start iff it is at the very start of the
-// string or immediately preceded by an ASCII whitespace character. This is
-// what makes `http://x`, `and/or`, and `/usr/local/bin`'s later segments
-// non-triggers by construction (§4.1 step 1).
-function isTokenStart(text, index) {
-    return index === 0 || isAsciiWhitespace(text[index - 1]);
-}
-/**
- * Find every resolved-ref CANDIDATE in `text` per the §4.1 grammar. Does not
- * consult any inventory — callers resolve a token by testing
- * `token.candidate` against a `Set<string>` of visible canonical names.
- */
-export function findRefTokens(text) {
-    const tokens = [];
-    const len = text.length;
-    for (let i = 0; i < len; i++) {
-        if (text[i] !== '/' || !isTokenStart(text, i))
-            continue;
-        // Step 2: capture the maximal run of [A-Za-z0-9_:-] after the slash.
-        let j = i + 1;
-        while (j < len && isNameChar(text[j]))
-            j++;
-        if (j === i + 1)
-            continue; // nothing captured at all
-        // Step 3: trim trailing characters that are not [A-Za-z0-9].
-        let end = j;
-        while (end > i + 1 && !KEEP_CHAR.test(text[end - 1]))
-            end--;
-        if (end === i + 1)
-            continue; // nothing survives the trim
-        const raw = text.slice(i, end);
-        // Step 4: decode ':' -> '/'.
-        const candidate = raw.slice(1).replace(/:/g, '/');
-        tokens.push({ start: i, end, raw, candidate });
-    }
-    return tokens;
-}
-/**
- * Render a canonical name back into its surface slash-token form:
- * `'dev' -> '/dev'`, `'taste/foo' -> '/taste:foo'`.
- */
-export function formatRefToken(canonicalName) {
-    return '/' + canonicalName.replace(/\//g, ':');
-}
-/**
- * Classify the in-progress token (if any) touching `caret` in `text`, for
- * completion UX. Reuses the same whitespace/name-char predicates as
- * `findRefTokens`, but reports the UNTRIMMED maximal run so an incomplete
- * prefix (`/taste:` with nothing typed after the colon yet) or a caret sitting
- * mid-token (with more valid characters after it) both produce a full,
- * suffix-inclusive replacement range. Returns `null` when the caret is not
- * touching a token-shaped run.
- */
-export function findRefTokenAtCaret(text, caret) {
-    const len = text.length;
-    const pos = Math.max(0, Math.min(caret, len));
-    // Walk backward from the caret to the start of the contiguous name-char
-    // run it sits in (or after); the token's slash must sit immediately
-    // before that run.
-    let nameStart = pos;
-    while (nameStart > 0 && isNameChar(text[nameStart - 1]))
-        nameStart--;
-    const slashPos = nameStart - 1;
-    if (slashPos < 0 || text[slashPos] !== '/' || !isTokenStart(text, slashPos))
-        return null;
-    // The maximal run from the slash is a single scan forward — equivalent to
-    // walking both directions from the caret, since the run is contiguous by
-    // construction (NAME_CHAR excludes '/' and whitespace).
-    let end = slashPos + 1;
-    while (end < len && isNameChar(text[end]))
-        end++;
-    return { start: slashPos, end, surfacePrefix: text.slice(slashPos, pos) };
-}
+var u=Object.defineProperty;var s=(n,o)=>u(n,"name",{value:o,configurable:!0});const h=/[A-Za-z0-9_:-]/,A=/[A-Za-z0-9]/,p=/[ \t\n\r\f\v]/;function a(n){return h.test(n)}s(a,"isNameChar");function C(n){return p.test(n)}s(C,"isAsciiWhitespace");function l(n,o){return o===0||C(n[o-1])}s(l,"isTokenStart");function k(n){const o=[],c=n.length;for(let e=0;e<c;e++){if(n[e]!=="/"||!l(n,e))continue;let i=e+1;for(;i<c&&a(n[i]);)i++;if(i===e+1)continue;let t=i;for(;t>e+1&&!A.test(n[t-1]);)t--;if(t===e+1)continue;const r=n.slice(e,t),f=r.slice(1).replace(/:/g,"/");o.push({start:e,end:t,raw:r,candidate:f})}return o}s(k,"findRefTokens");function m(n){return"/"+n.replace(/\//g,":")}s(m,"formatRefToken");function w(n,o){const c=n.length,e=Math.max(0,Math.min(o,c));let i=e;for(;i>0&&a(n[i-1]);)i--;const t=i-1;if(t<0||n[t]!=="/"||!l(n,t))return null;let r=t+1;for(;r<c&&a(n[r]);)r++;return{start:t,end:r,surfacePrefix:n.slice(t,e)}}s(w,"findRefTokenAtCaret");export{w as findRefTokenAtCaret,k as findRefTokens,m as formatRefToken};

package/dist/core/memory/inline-ref-guidance.js

@@ -1,35 +1,2 @@
-// inline-ref-guidance.ts — builds the single hidden directive message the
-// broker hands the model when a human submission contains one or more
-// resolved inline memory references (spec §4.6, design "Guidance builder").
-//
-// Pure over its inputs: given the verbatim frame text and the inventory's
-// resolution `Set<string>`, this module never re-resolves scope, never
-// touches the filesystem, and never depends on which viewer sent the text.
-// The broker (src/core/runtime/broker.ts) is the only caller — it wraps the
-// returned string in a `{ role: 'custom', customType: 'crtr-memory-refs',
-// display: false, ... }` message and delivers it alongside the human turn.
-import { findRefTokens } from './inline-ref-grammar.js';
-const GUIDANCE_HEADER = 'The user explicitly called out specific memories. Read the relevant mentioned memory files:';
-/**
- * Resolve every slash token in `text` against `names` (the exact canonical
- * `buildRefInventory().names` set), collapse duplicates, and return one
- * directive line per distinct resolved ref in FIRST-APPEARANCE order.
- * Returns `null` when no token resolves, so the broker sends no guidance
- * message for prose with no refs.
- */
-export function buildGuidance(text, names) {
-    const seen = new Set();
-    const resolved = [];
-    for (const token of findRefTokens(text)) {
-        if (seen.has(token.candidate))
-            continue;
-        if (!names.has(token.candidate))
-            continue;
-        seen.add(token.candidate);
-        resolved.push(token.candidate);
-    }
-    if (resolved.length === 0)
-        return null;
-    const lines = resolved.map((name) => `- crtr memory read ${name}`);
-    return [GUIDANCE_HEADER, ...lines].join('\n');
-}
+var a=Object.defineProperty;var c=(n,t)=>a(n,"name",{value:t,configurable:!0});import{findRefTokens as r}from"./inline-ref-grammar.js";const s="The user explicitly called out specific memories. Read the relevant mentioned memory files:";function u(n,t){const o=new Set,i=[];for(const e of r(n))o.has(e.candidate)||t.has(e.candidate)&&(o.add(e.candidate),i.push(e.candidate));if(i.length===0)return null;const d=i.map(e=>`- crtr memory read ${e}`);return[s,...d].join(`
+`)}c(u,"buildGuidance");export{u as buildGuidance};

package/dist/core/memory/inline-ref-inventory.js

@@ -1,59 +1 @@
-// Authoritative broker-side inventory for inline memory references. It uses one
-// target view, exact canonical winners, and the canonical tree for directory
-// browse names; gates, rungs, and slash flags do not affect referenceability.
-import { envNodeId, envProfileId } from '../../shared/env.js';
-import { loadMemoryTargetView } from '../memory-resolver.js';
-import { buildMemoryTree } from './tree.js';
-import { memoryExtensionEffectiveCatalog, projectEffectiveMemoryExtensions } from './extensions.js';
-import { parseSubstrateDoc } from '../substrate/schema.js';
-// Display-sort weight matching resolution precedence (node > project >
-// profile > user > builtin) — display-only; resolution itself is exact
-// canonical-name membership (`names.has(candidate)`).
-const SCOPE_SORT_RANK = {
-    node: 0,
-    project: 1,
-    profile: 2,
-    user: 3,
-    builtin: 4,
-};
-/** Build the inline inventory from exact target-view winners. `refs` carries
- * metadata rows; `names` adds only canonical directory nodes with members for
- * browse links. Gates, rungs, and `slash` do not affect referenceability. */
-export function buildRefInventory() {
-    const target = {
-        cwd: process.cwd(),
-        profileId: envProfileId() || null,
-        nodeId: envNodeId() || null,
-    };
-    const view = loadMemoryTargetView(target, { quiet: true });
-    const winners = new Map();
-    for (const candidateSet of view.candidateSets()) {
-        const memoryDoc = candidateSet.winner;
-        const doc = parseSubstrateDoc(memoryDoc);
-        if (doc !== null)
-            winners.set(candidateSet.name, { doc, memoryDoc });
-    }
-    const refs = [];
-    for (const [name, { doc, memoryDoc }] of winners) {
-        const gatewayVisible = doc.scope !== 'builtin'
-            && projectEffectiveMemoryExtensions(memoryDoc.frontmatter?.['extensions'], memoryExtensionEffectiveCatalog(memoryDoc))['northlight']?.['visibility'] !== false;
-        refs.push({ name, kind: doc.kind, scope: doc.scope, shortForm: doc.shortForm, gatewayVisible });
-    }
-    refs.sort((a, b) => {
-        const scopeDelta = SCOPE_SORT_RANK[a.scope] - SCOPE_SORT_RANK[b.scope];
-        if (scopeDelta !== 0)
-            return scopeDelta;
-        return a.name.localeCompare(b.name);
-    });
-    const names = new Set(refs.map((r) => r.name));
-    const tree = buildMemoryTree([...winners.values()].map(({ memoryDoc }) => memoryDoc));
-    const addDirectoryNames = (node) => {
-        if (node.name !== '' && (node.childDirectories.length > 0 || node.childDocuments.length > 0)) {
-            names.add(node.name);
-        }
-        for (const child of node.childDirectories)
-            addDirectoryNames(child);
-    };
-    addDirectoryNames(tree.root);
-    return { refs, names };
-}
+var p=Object.defineProperty;var c=(n,i)=>p(n,"name",{value:i,configurable:!0});import{envNodeId as u,envProfileId as h}from"../../shared/env.js";import{loadMemoryTargetView as y}from"../memory-resolver.js";import{buildMemoryTree as w}from"./tree.js";import{memoryExtensionEffectiveCatalog as v,projectEffectiveMemoryExtensions as D}from"./extensions.js";import{parseSubstrateDoc as g}from"../substrate/schema.js";const l={node:0,project:1,profile:2,user:3,builtin:4};function C(){const n={cwd:process.cwd(),profileId:h()||null,nodeId:u()||null},i=y(n,{quiet:!0}),s=new Map;for(const e of i.candidateSets()){const o=e.winner,t=g(o);t!==null&&s.set(e.name,{doc:t,memoryDoc:o})}const r=[];for(const[e,{doc:o,memoryDoc:t}]of s){const d=o.scope!=="builtin"&&D(t.frontmatter?.extensions,v(t)).northlight?.visibility!==!1;r.push({name:e,kind:o.kind,scope:o.scope,shortForm:o.shortForm,gatewayVisible:d})}r.sort((e,o)=>{const t=l[e.scope]-l[o.scope];return t!==0?t:e.name.localeCompare(o.name)});const m=new Set(r.map(e=>e.name)),f=w([...s.values()].map(({memoryDoc:e})=>e)),a=c(e=>{e.name!==""&&(e.childDirectories.length>0||e.childDocuments.length>0)&&m.add(e.name);for(const o of e.childDirectories)a(o)},"addDirectoryNames");return a(f.root),{refs:r,names:m}}c(C,"buildRefInventory");export{C as buildRefInventory};