@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/substrate/gate-explain.js

@@ -1,424 +1 @@
-// gate-explain.ts — why a gate refused THIS node, in the words the reader can
-// act on: their own value on the left, the gate's demand on the right.
-//
-// This is a SECOND, opt-in read of the same predicate `evalCondition` already
-// judged (predicate.ts), never a replacement for it. It shares that engine's
-// leaf primitives (`matchField`, `getField`), so a leaf verdict cannot drift
-// between the verdict and its explanation; only the structural walk exists
-// twice, and the fallback covers the walk. It is never called while planning —
-// only while rendering a document a human is already looking at.
-//
-// It is advisory. When it cannot decompose a failure it returns nothing, and
-// every caller falls back to the planner's generic sentence rather than
-// inventing one.
-import { getField, matchField, evalCondition } from '../predicate.js';
-import { tildify } from '../fs-utils.js';
-/** The subject has no value at this field path — distinct from a value of
- *  `null`, which a gate can legitimately demand. */
-export const ABSENT = Symbol('absent');
-// The structural walk.
-/** The failing clauses of `condition` against `subject`, or an empty list when
- *  the failure cannot be decomposed — an `any`/`not` combinator swallowed it,
- *  or the predicate is a shape this walk does not recognise. An empty list is
- *  the caller's signal to print the generic reason instead. */
-export function explainGate(condition, subject) {
-    return walk(condition, subject) ?? [];
-}
-/** The failing clauses of one predicate, or `null` when its failure is opaque.
- *  Opacity travels outward: a sibling's mismatch is not the remedy when an
- *  undecomposable branch also failed, so the whole explanation is abandoned. */
-function walk(condition, subject) {
-    if (condition == null || typeof condition !== 'object')
-        return [];
-    if (Array.isArray(condition))
-        return collect(condition, subject);
-    const c = condition;
-    const clauses = [];
-    if ('any' in c || 'not' in c) {
-        // Neither is decomposed: an OR has no single failing branch to name, and a
-        // satisfied negation has no failing clause at all. When one of them is what
-        // failed, the whole explanation is abandoned — an honest generic sentence
-        // beats an invented clause. When it PASSED, the failure is elsewhere and
-        // the rest of the predicate still explains itself.
-        if ('any' in c && !evalCondition({ any: c['any'] }, subject))
-            return null;
-        if ('not' in c && !evalCondition({ not: c['not'] }, subject))
-            return null;
-    }
-    if ('all' in c) {
-        const nested = collect(Array.isArray(c['all']) ? c['all'] : [c['all']], subject);
-        if (nested === null)
-            return null;
-        clauses.push(...nested);
-    }
-    const fields = Object.keys(c).filter((key) => key !== 'all' && key !== 'any' && key !== 'not');
-    // An empty condition is inert — it matches nothing, and no field explains why.
-    if (fields.length === 0 && !('all' in c) && !('any' in c) && !('not' in c)) {
-        return [{ field: '', failure: 'malformed', actual: ABSENT, demand: c, defect: 'is empty, and an empty gate never matches' }];
-    }
-    for (const field of fields) {
-        const matcher = c[field];
-        if (matchField(getField(subject, field), matcher))
-            continue;
-        clauses.push(clauseFor(field, matcher, subject));
-    }
-    return clauses;
-}
-/** Every sub-predicate's clauses, or `null` as soon as one is opaque. */
-function collect(subs, subject) {
-    const clauses = [];
-    for (const sub of subs) {
-        const nested = walk(sub, subject);
-        if (nested === null)
-            return null;
-        clauses.push(...nested);
-    }
-    return clauses;
-}
-function clauseFor(field, matcher, subject) {
-    const raw = getField(subject, field);
-    const actual = raw === undefined ? ABSENT : raw;
-    const defect = matcherDefect(matcher);
-    return defect === null
-        ? { field, failure: 'mismatch', actual, demand: matcher }
-        : { field, failure: 'malformed', actual, demand: matcher, defect };
-}
-const KNOWN_OPS = new Set([
-    'eq', 'ne', 'in', 'nin', 'exists', 'contains', 'containsAll', 'containsAny',
-    'matches', 'imatches', 'gt', 'gte', 'lt', 'lte',
-]);
-/** What makes this matcher unsatisfiable by ANY node, or null when it is a
- *  well-formed demand this node merely does not meet. */
-function matcherDefect(matcher) {
-    // A scalar or an array is compared directly by the engine — a demand this
-    // node fails, never a defect of the gate.
-    if (matcher === null || Array.isArray(matcher) || typeof matcher !== 'object')
-        return null;
-    for (const [op, arg] of Object.entries(matcher)) {
-        if (!KNOWN_OPS.has(op))
-            return `uses unknown operator "${op}" \u2014 unknown operators never match`;
-        if (op === 'matches' || op === 'imatches') {
-            if (typeof arg !== 'string')
-                return 'is matched against something that is not a pattern \u2014 it never matches';
-            try {
-                new RegExp(arg, op === 'imatches' ? 'i' : '');
-            }
-            catch {
-                return 'has an invalid regular expression \u2014 an invalid pattern never matches';
-            }
-        }
-        if (['gt', 'gte', 'lt', 'lte'].includes(op) && Number.isNaN(Number(arg))) {
-            return `compares ${op} against something that is not a number \u2014 it never matches`;
-        }
-    }
-    return null;
-}
-// The single phrasing site.
-/** The rail row a gate field names, because that row is the remedy. */
-function labelFor(field) {
-    if (field === 'hasManager')
-        return 'manager';
-    if (field === 'orchestration.depth')
-        return 'depth';
-    return field;
-}
-/** The grammar's own break between the reader's value and the gate's demand —
- *  the only place a clause line may be split. */
-export const CLAUSE_SEPARATOR = ' | gate: ';
-/** One clause as one line of plain text — the ONLY place a gate failure is put
- *  into human words. Callers own indentation, colour, wrapping, and joining. */
-export function formatClause(clause) {
-    if (clause.failure === 'malformed') {
-        const label = clause.field === '' ? 'the gate' : labelFor(clause.field);
-        return `${label} ${clause.defect ?? 'never matches'}`;
-    }
-    return `${labelFor(clause.field)}: ${renderActual(clause.actual)}${CLAUSE_SEPARATOR}${renderDemand(clause.demand)}`;
-}
-function renderActual(value) {
-    if (value === ABSENT || value === null || value === undefined)
-        return 'none';
-    if (typeof value === 'boolean')
-        return value ? 'yes' : 'no';
-    if (Array.isArray(value))
-        return value.map((v) => renderActual(v)).join(', ');
-    if (typeof value === 'string')
-        return value === '' ? 'none' : shortPath(value);
-    if (typeof value === 'object')
-        return JSON.stringify(value);
-    return String(value);
-}
-/** The gate's demand, per matcher shape. Never regex source, never a full
- *  home-prefixed path. */
-function renderDemand(matcher) {
-    if (matcher === null || matcher === undefined)
-        return 'none';
-    if (typeof matcher === 'boolean')
-        return matcher ? 'yes' : 'no';
-    if (typeof matcher === 'string')
-        return matcher === '' ? 'none' : shortPath(matcher);
-    if (typeof matcher === 'number')
-        return String(matcher);
-    if (Array.isArray(matcher))
-        return orList(matcher);
-    const ops = Object.entries(matcher);
-    if (ops.length === 0)
-        return 'nothing';
-    return ops.map(([op, arg]) => renderOp(op, arg)).join(' and ');
-}
-function renderOp(op, arg) {
-    switch (op) {
-        case 'eq':
-            return renderDemand(arg);
-        case 'ne':
-            return `not ${renderDemand(arg)}`;
-        case 'in':
-            return orList(arg);
-        case 'nin':
-            return `not ${orList(arg)}`;
-        case 'exists':
-            return arg === false ? 'no value' : 'any value';
-        case 'contains':
-            return `includes ${renderDemand(arg)}`;
-        case 'containsAll':
-            return `includes all of ${commaList(arg)}`;
-        case 'containsAny':
-            return `includes any of ${commaList(arg)}`;
-        case 'matches':
-        case 'imatches':
-            return typeof arg === 'string' ? readableRegex(arg) : 'a pattern';
-        case 'gt':
-            return `> ${String(arg)}`;
-        case 'gte':
-            return `\u2265 ${String(arg)}`;
-        case 'lt':
-            return `< ${String(arg)}`;
-        case 'lte':
-            return `\u2264 ${String(arg)}`;
-        default:
-            return `${op} ${String(arg)}`;
-    }
-}
-function orList(arg) {
-    const items = (Array.isArray(arg) ? arg : [arg]).map((v) => renderDemand(v));
-    return items.length === 0 ? 'nothing' : items.join(' or ');
-}
-function commaList(arg) {
-    return (Array.isArray(arg) ? arg : [arg]).map((v) => renderDemand(v)).join(', ');
-}
-function shortPath(value) {
-    return value.startsWith('/') ? tildify(value) : value;
-}
-// Regex reduction — every real `cwd` gate is an anchored literal path, whole or
-// followed by one alternation of the projects it covers, and it should read as
-// the directory or directories it means.
-const META = new Set(['\\', '^', '$', '.', '|', '?', '*', '+', '(', ')', '[', ']', '{', '}']);
-/** The pattern as the thing it demands: an anchored literal path collapsed to
- *  the directory it names, else the longest literal run it insists on, else an
- *  admission that it is a pattern. The source is never printed. */
-export function readableRegex(source) {
-    let body = source;
-    if (body.startsWith('^'))
-        body = body.slice(1);
-    // The house `cwd` idiom: a trailing "this directory or anything under it".
-    body = body.replace(/\((?:\?:)?\\?\/\|\$\)\??$/, '');
-    if (body.endsWith('$') && !body.endsWith('\\$'))
-        body = body.slice(0, -1);
-    const literal = unescapeLiteral(body);
-    if (literal !== null && literal !== '')
-        return shortPath(literal);
-    const branches = distributeAlternation(body);
-    if (branches !== null)
-        return branches.map((branch) => shortPath(branch)).join(' or ');
-    const run = longestLiteralRun(source);
-    return run === null ? 'a pattern' : `contains "${shortPath(run)}"`;
-}
-/** The pattern's plain text when it holds no unescaped metacharacter, else
- *  null. `\/` and `\.` are literal characters and survive; `\d` and friends are
- *  classes and disqualify the whole pattern. */
-function unescapeLiteral(source) {
-    let out = '';
-    for (let i = 0; i < source.length; i++) {
-        const ch = source[i];
-        if (ch === '\\') {
-            const next = source[i + 1];
-            if (next === undefined || (!META.has(next) && next !== '/' && next !== '-'))
-                return null;
-            out += next;
-            i++;
-            continue;
-        }
-        if (META.has(ch))
-            return null;
-        out += ch;
-    }
-    return out;
-}
-/** The paths a literal prefix followed by ONE alternation group means: each
- *  branch appended to the prefix, so the reader is handed directories they can
- *  actually be in rather than the prefix they all share. Null when the body is
- *  any other shape — a second group, text after the group, or a branch holding
- *  a metacharacter outside the glob vocabulary. */
-function distributeAlternation(body) {
-    const open = body.indexOf('(');
-    if (open === -1 || !body.endsWith(')'))
-        return null;
-    const prefix = unescapeLiteral(body.slice(0, open));
-    if (prefix === null)
-        return null;
-    let inner = body.slice(open + 1, -1);
-    if (inner.startsWith('?:'))
-        inner = inner.slice(2);
-    // One group only: a nested group is a shape this reduction does not read.
-    if (inner.includes('(') || inner.includes(')'))
-        return null;
-    const branches = inner.split('|');
-    if (branches.length < 2)
-        return null;
-    const paths = [];
-    for (const branch of branches) {
-        const text = branchText(branch);
-        if (text === null)
-            return null;
-        paths.push(prefix + text);
-    }
-    return paths;
-}
-/** One branch as plain text, with a whole-segment wildcard rendered as the path
- *  glob it means. The vocabulary is exactly `[^/]+` and `.*`; any other
- *  metacharacter means the branch is not a path and the whole shape is
- *  abandoned. */
-function branchText(branch) {
-    let out = '';
-    for (let i = 0; i < branch.length; i++) {
-        if (branch.startsWith('[^/]+', i)) {
-            out += '*';
-            i += 4;
-            continue;
-        }
-        if (branch.startsWith('[^\\/]+', i)) {
-            out += '*';
-            i += 5;
-            continue;
-        }
-        if (branch.startsWith('.*', i)) {
-            out += '*';
-            i += 1;
-            continue;
-        }
-        const ch = branch[i];
-        if (ch === '\\') {
-            const next = branch[i + 1];
-            if (next === undefined || (!META.has(next) && next !== '/' && next !== '-'))
-                return null;
-            out += next;
-            i++;
-            continue;
-        }
-        if (META.has(ch))
-            return null;
-        out += ch;
-    }
-    return out;
-}
-/** The longest stretch of characters EVERY string the pattern accepts contains,
- *  or null when it guarantees nothing longer than a single character. Only text
- *  outside every group and character class counts: a group may be alternated or
- *  quantified away, so its contents are not guaranteed. A top-level alternation
- *  guarantees nothing at all. */
-function longestLiteralRun(source) {
-    let best = '';
-    let run = '';
-    let depth = 0;
-    let inClass = false;
-    const flush = () => {
-        if (run.length > best.length)
-            best = run;
-        run = '';
-    };
-    for (let i = 0; i < source.length; i++) {
-        const ch = source[i];
-        if (ch === '\\') {
-            const next = source[i + 1];
-            i++;
-            if (depth === 0 && !inClass && next !== undefined && (META.has(next) || next === '/' || next === '-')) {
-                run += next;
-                continue;
-            }
-            flush();
-            continue;
-        }
-        if (inClass) {
-            if (ch === ']')
-                inClass = false;
-            continue;
-        }
-        if (ch === '[') {
-            flush();
-            inClass = true;
-            continue;
-        }
-        if (ch === '(') {
-            flush();
-            depth++;
-            continue;
-        }
-        if (ch === ')') {
-            flush();
-            if (depth > 0)
-                depth--;
-            continue;
-        }
-        // Branches share no text, so nothing survives a top-level alternation.
-        if (ch === '|' && depth === 0)
-            return null;
-        if (ch === '{') {
-            // A repetition count can be zero — the character it applies to goes, and
-            // the count itself is syntax, not text the pattern matches.
-            if (run.length > 0)
-                run = run.slice(0, -1);
-            flush();
-            const close = source.indexOf('}', i);
-            if (close !== -1)
-                i = close;
-            continue;
-        }
-        if (META.has(ch) || depth > 0) {
-            // A quantifier applies to the character before it, which is therefore not
-            // guaranteed — drop it from the run.
-            if ((ch === '?' || ch === '*') && run.length > 0)
-                run = run.slice(0, -1);
-            flush();
-            continue;
-        }
-        run += ch;
-    }
-    flush();
-    return best.length > 1 ? best : null;
-}
-/** The failing clauses of one record's document or entry gate, or an empty list
- *  when there is nothing to explain — the gate passed, there is no subject to
- *  match against, or the predicate resists decomposition. An evaluator that
- *  throws is the planner's own `failed to evaluate` outcome and keeps its
- *  sentence. */
-export function explainRecordGate(record, side, subject) {
-    const outcome = side === 'doc' ? record.docGate : record.entryGate;
-    if (outcome === null || outcome.pass || subject === null)
-        return [];
-    const predicate = side === 'doc'
-        ? record.doc.gate
-        : record.authoredEntries.find((decision) => !decision.gate.pass)?.entry.gate;
-    if (predicate === undefined)
-        return [];
-    try {
-        return explainGate(predicate, subject);
-    }
-    catch {
-        return [];
-    }
-}
-/** Does every failing clause name a node value the reader can change? Only then
- *  is "dial the snapshot" a true instruction — a malformed gate is fixed in the
- *  document. */
-export function allMismatches(clauses) {
-    return clauses.length > 0 && clauses.every((clause) => clause.failure === 'mismatch');
-}
+var O=Object.defineProperty;var o=(n,t)=>O(n,"name",{value:t,configurable:!0});import{getField as y,matchField as W,evalCondition as m}from"../predicate.js";import{tildify as w}from"../fs-utils.js";const h=Symbol("absent");function N(n,t){return g(n,t)??[]}o(N,"explainGate");function g(n,t){if(n==null||typeof n!="object")return[];if(Array.isArray(n))return A(n,t);const e=n,r=[];if(("any"in e||"not"in e)&&("any"in e&&!m({any:e.any},t)||"not"in e&&!m({not:e.not},t)))return null;if("all"in e){const s=A(Array.isArray(e.all)?e.all:[e.all],t);if(s===null)return null;r.push(...s)}const i=Object.keys(e).filter(s=>s!=="all"&&s!=="any"&&s!=="not");if(i.length===0&&!("all"in e)&&!("any"in e)&&!("not"in e))return[{field:"",failure:"malformed",actual:h,demand:e,defect:"is empty, and an empty gate never matches"}];for(const s of i){const l=e[s];W(y(t,s),l)||r.push(E(s,l,t))}return r}o(g,"walk");function A(n,t){const e=[];for(const r of n){const i=g(r,t);if(i===null)return null;e.push(...i)}return e}o(A,"collect");function E(n,t,e){const r=y(e,n),i=r===void 0?h:r,s=j(t);return s===null?{field:n,failure:"mismatch",actual:i,demand:t}:{field:n,failure:"malformed",actual:i,demand:t,defect:s}}o(E,"clauseFor");const R=new Set(["eq","ne","in","nin","exists","contains","containsAll","containsAny","matches","imatches","gt","gte","lt","lte"]);function j(n){if(n===null||Array.isArray(n)||typeof n!="object")return null;for(const[t,e]of Object.entries(n)){if(!R.has(t))return`uses unknown operator "${t}" \u2014 unknown operators never match`;if(t==="matches"||t==="imatches"){if(typeof e!="string")return"is matched against something that is not a pattern \u2014 it never matches";try{new RegExp(e,t==="imatches"?"i":"")}catch{return"has an invalid regular expression \u2014 an invalid pattern never matches"}}if(["gt","gte","lt","lte"].includes(t)&&Number.isNaN(Number(e)))return`compares ${t} against something that is not a number \u2014 it never matches`}return null}o(j,"matcherDefect");function $(n){return n==="hasManager"?"manager":n==="orchestration.depth"?"depth":n}o($,"labelFor");const L=" | gate: ";function D(n){return n.failure==="malformed"?`${n.field===""?"the gate":$(n.field)} ${n.defect??"never matches"}`:`${$(n.field)}: ${x(n.actual)}${L}${a(n.demand)}`}o(D,"formatClause");function x(n){return n===h||n===null||n===void 0?"none":typeof n=="boolean"?n?"yes":"no":Array.isArray(n)?n.map(t=>x(t)).join(", "):typeof n=="string"?n===""?"none":d(n):typeof n=="object"?JSON.stringify(n):String(n)}o(x,"renderActual");function a(n){if(n==null)return"none";if(typeof n=="boolean")return n?"yes":"no";if(typeof n=="string")return n===""?"none":d(n);if(typeof n=="number")return String(n);if(Array.isArray(n))return p(n);const t=Object.entries(n);return t.length===0?"nothing":t.map(([e,r])=>C(e,r)).join(" and ")}o(a,"renderDemand");function C(n,t){switch(n){case"eq":return a(t);case"ne":return`not ${a(t)}`;case"in":return p(t);case"nin":return`not ${p(t)}`;case"exists":return t===!1?"no value":"any value";case"contains":return`includes ${a(t)}`;case"containsAll":return`includes all of ${S(t)}`;case"containsAny":return`includes any of ${S(t)}`;case"matches":case"imatches":return typeof t=="string"?F(t):"a pattern";case"gt":return`> ${String(t)}`;case"gte":return`\u2265 ${String(t)}`;case"lt":return`< ${String(t)}`;case"lte":return`\u2264 ${String(t)}`;default:return`${n} ${String(t)}`}}o(C,"renderOp");function p(n){const t=(Array.isArray(n)?n:[n]).map(e=>a(e));return t.length===0?"nothing":t.join(" or ")}o(p,"orList");function S(n){return(Array.isArray(n)?n:[n]).map(t=>a(t)).join(", ")}o(S,"commaList");function d(n){return n.startsWith("/")?w(n):n}o(d,"shortPath");const c=new Set(["\\","^","$",".","|","?","*","+","(",")","[","]","{","}"]);function F(n){let t=n;t.startsWith("^")&&(t=t.slice(1)),t=t.replace(/\((?:\?:)?\\?\/\|\$\)\??$/,""),t.endsWith("$")&&!t.endsWith("\\$")&&(t=t.slice(0,-1));const e=b(t);if(e!==null&&e!=="")return d(e);const r=G(t);if(r!==null)return r.map(s=>d(s)).join(" or ");const i=M(n);return i===null?"a pattern":`contains "${d(i)}"`}o(F,"readableRegex");function b(n){let t="";for(let e=0;e<n.length;e++){const r=n[e];if(r==="\\"){const i=n[e+1];if(i===void 0||!c.has(i)&&i!=="/"&&i!=="-")return null;t+=i,e++;continue}if(c.has(r))return null;t+=r}return t}o(b,"unescapeLiteral");function G(n){const t=n.indexOf("(");if(t===-1||!n.endsWith(")"))return null;const e=b(n.slice(0,t));if(e===null)return null;let r=n.slice(t+1,-1);if(r.startsWith("?:")&&(r=r.slice(2)),r.includes("(")||r.includes(")"))return null;const i=r.split("|");if(i.length<2)return null;const s=[];for(const l of i){const u=T(l);if(u===null)return null;s.push(e+u)}return s}o(G,"distributeAlternation");function T(n){let t="";for(let e=0;e<n.length;e++){if(n.startsWith("[^/]+",e)){t+="*",e+=4;continue}if(n.startsWith("[^\\/]+",e)){t+="*",e+=5;continue}if(n.startsWith(".*",e)){t+="*",e+=1;continue}const r=n[e];if(r==="\\"){const i=n[e+1];if(i===void 0||!c.has(i)&&i!=="/"&&i!=="-")return null;t+=i,e++;continue}if(c.has(r))return null;t+=r}return t}o(T,"branchText");function M(n){let t="",e="",r=0,i=!1;const s=o(()=>{e.length>t.length&&(t=e),e=""},"flush");for(let l=0;l<n.length;l++){const u=n[l];if(u==="\\"){const f=n[l+1];if(l++,r===0&&!i&&f!==void 0&&(c.has(f)||f==="/"||f==="-")){e+=f;continue}s();continue}if(i){u==="]"&&(i=!1);continue}if(u==="["){s(),i=!0;continue}if(u==="("){s(),r++;continue}if(u===")"){s(),r>0&&r--;continue}if(u==="|"&&r===0)return null;if(u==="{"){e.length>0&&(e=e.slice(0,-1)),s();const f=n.indexOf("}",l);f!==-1&&(l=f);continue}if(c.has(u)||r>0){(u==="?"||u==="*")&&e.length>0&&(e=e.slice(0,-1)),s();continue}e+=u}return s(),t.length>1?t:null}o(M,"longestLiteralRun");function _(n,t,e){const r=t==="doc"?n.docGate:n.entryGate;if(r===null||r.pass||e===null)return[];const i=t==="doc"?n.doc.gate:n.authoredEntries.find(s=>!s.gate.pass)?.entry.gate;if(i===void 0)return[];try{return N(i,e)}catch{return[]}}o(_,"explainRecordGate");function B(n){return n.length>0&&n.every(t=>t.failure==="mismatch")}o(B,"allMismatches");export{h as ABSENT,L as CLAUSE_SEPARATOR,B as allMismatches,N as explainGate,_ as explainRecordGate,D as formatClause,F as readableRegex};

package/dist/core/substrate/gate.js

@@ -1,26 +1 @@
-// gate.ts — gate evaluation. A document's optional `gate` predicate decides
-// whether it is ELIGIBLE to surface at all for a given node (orthogonal to the
-// rung, which decides how much). See design-substrate.md §4 + §6. Pure function
-// over (parsed doc, assembled subject); the matcher engine in predicate.ts does
-// the actual matching — we do NOT reimplement it here.
-import { evalCondition } from '../predicate.js';
-/** Does `doc` pass its gate for `subject`?
- *
- *  - No gate (field absent) ⇒ `true`: always eligible (the common case).
- *  - A gate present ⇒ the matcher engine's verdict. An empty `gate: {}` is inert
- *    and returns `false` (never matches) per design §4 — so an author cannot
- *    write an always-eligible-via-empty-predicate doc.
- *
- *  Eligibility only. A failing gate excludes the doc from BOTH automatic hooks
- *  for this node; it remains findable by `crtr memory find` (search ignores
- *  gate + rung). */
-export function gatePasses(doc, subject) {
-    if (doc.gate === undefined)
-        return true;
-    return evalCondition(doc.gate, subject);
-}
-/** Does a surface entry participate for `subject`? A missing subject cannot
- * satisfy an entry gate; entries without one remain eligible. */
-export function surfaceEntryGatePasses(entry, subject) {
-    return entry.gate === undefined || (subject !== null && evalCondition(entry.gate, subject));
-}
+var a=Object.defineProperty;var n=(e,t)=>a(e,"name",{value:t,configurable:!0});import{evalCondition as r}from"../predicate.js";function f(e,t){return e.gate===void 0?!0:r(e.gate,t)}n(f,"gatePasses");function o(e,t){return e.gate===void 0||t!==null&&r(e.gate,t)}n(o,"surfaceEntryGatePasses");export{f as gatePasses,o as surfaceEntryGatePasses};

package/dist/core/substrate/index.js

@@ -1,30 +1 @@
-// substrate/ — the unified document-substrate keystone: the frontmatter schema,
-// the 4-rung visibility ladder, the node-config subject assembly, and gate
-// evaluation. Pure + well-typed; the shared base the CLI verbs, boot render,
-// on-read render, and migrator all build on. See design-substrate.md §4 +
-// plan-substrate.md §2.
-export { 
-// kinds
-KINDS, isDocKind, 
-// ladder
-RUNGS, rungRank, rungAtLeast, 
-// surfaces (event routing)
-SURFACE_EVENTS, SURFACE_RUNGS, 
-// parse + render-shared helpers
-parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, 
-// display-name normalization
-normalizeNameSegment, normalizeDocName, 
-// substrate identity (explicit-name-then-path-fallback)
-resolveDocName, } from './schema.js';
-export { lintSubstrateFrontmatter, lintSubstrateSchema, lintSubstrateSurfaces, parsedSubstrateSurfaces } from './frontmatter-validation.js';
-export { matchesReadEntry, matchesMemoryReadEntry, matchesCommandEntry, readDeliveryRung, workspaceOpenRung, memoryReadDeliveryRung, commandDeliveryRung, matchingSurfaceEntry, surfaceEntryParticipates, owningRootOf, underOwningRoot } from './surface-match.js';
-export { planDelivery, bootPartitionOf } from './plan.js';
-export { dirDedupKey, docsByName, isDirName, ancestorDirsOf, renderDirListing } from './listings.js';
-export { clearContextExposureState, cloneContextExposureState, cloneTranscriptExposureState, contentExposureIdentity, contextExposureStatesEqual, documentExposedAtOrAbove, emptyContextExposureState, exposedAtOrAbove, exposureTarget, freezePreferenceSnapshot, hasTranscriptExposure, initializeForkContextExposure, loadContextExposureState, mergeContextExposureState, registerDocumentExposure, registerExposure, replaceContextExposureState, saveContextExposureState, sharedContextExposureState, } from './injected-store.js';
-export { scopeForCwd, profileNameFor } from './subject-fields.js';
-export { spineDepth, assembleNodeSubject } from './subject.js';
-export { gatePasses } from './gate.js';
-export { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
-export { renderPreferencesSection, renderKnowledgeBlock } from './render-node.js';
-export { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject, renderOnCommandDocsForSubject, memoryReadDocBlocks } from './on-read.js';
-export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read-node.js';
+import{KINDS as t,isDocKind as o,RUNGS as n,rungRank as a,rungAtLeast as s,SURFACE_EVENTS as p,SURFACE_RUNGS as c,parseSubstrateFrontmatter as m,parseSubstrateDoc as u,previewLine as x,normalizeNameSegment as i,normalizeDocName as d,resolveDocName as S}from"./schema.js";import{lintSubstrateFrontmatter as f,lintSubstrateSchema as l,lintSubstrateSurfaces as D,parsedSubstrateSurfaces as g}from"./frontmatter-validation.js";import{matchesReadEntry as b,matchesMemoryReadEntry as y,matchesCommandEntry as C,readDeliveryRung as F,workspaceOpenRung as O,memoryReadDeliveryRung as N,commandDeliveryRung as h,matchingSurfaceEntry as v,surfaceEntryParticipates as k,owningRootOf as w,underOwningRoot as A}from"./surface-match.js";import{planDelivery as P,bootPartitionOf as K}from"./plan.js";import{dirDedupKey as T,docsByName as U,isDirName as B,ancestorDirsOf as L,renderDirListing as G}from"./listings.js";import{clearContextExposureState as W,cloneContextExposureState as _,cloneTranscriptExposureState as q,contentExposureIdentity as M,contextExposureStatesEqual as V,documentExposedAtOrAbove as H,emptyContextExposureState as J,exposedAtOrAbove as Q,exposureTarget as X,freezePreferenceSnapshot as Y,hasTranscriptExposure as Z,initializeForkContextExposure as $,loadContextExposureState as ee,mergeContextExposureState as re,registerDocumentExposure as te,registerExposure as oe,replaceContextExposureState as ne,saveContextExposureState as ae,sharedContextExposureState as se}from"./injected-store.js";import{scopeForCwd as ce,profileNameFor as me}from"./subject-fields.js";import{spineDepth as xe,assembleNodeSubject as ie}from"./subject.js";import{gatePasses as Se}from"./gate.js";import{renderPreferencesForSubject as fe,renderKnowledgeForSubject as le}from"./render.js";import{renderPreferencesSection as ge,renderKnowledgeBlock as Re}from"./render-node.js";import{renderOnReadDocsForSubject as ye,renderWorkspaceOpenDocsForSubject as Ce,renderOnCommandDocsForSubject as Fe,memoryReadDocBlocks as Oe}from"./on-read.js";import{renderOnReadDocs as he,renderWorkspaceOpenDocs as ve}from"./on-read-node.js";export{t as KINDS,n as RUNGS,p as SURFACE_EVENTS,c as SURFACE_RUNGS,L as ancestorDirsOf,ie as assembleNodeSubject,K as bootPartitionOf,W as clearContextExposureState,_ as cloneContextExposureState,q as cloneTranscriptExposureState,h as commandDeliveryRung,M as contentExposureIdentity,V as contextExposureStatesEqual,T as dirDedupKey,U as docsByName,H as documentExposedAtOrAbove,J as emptyContextExposureState,Q as exposedAtOrAbove,X as exposureTarget,Y as freezePreferenceSnapshot,Se as gatePasses,Z as hasTranscriptExposure,$ as initializeForkContextExposure,B as isDirName,o as isDocKind,f as lintSubstrateFrontmatter,l as lintSubstrateSchema,D as lintSubstrateSurfaces,ee as loadContextExposureState,C as matchesCommandEntry,y as matchesMemoryReadEntry,b as matchesReadEntry,v as matchingSurfaceEntry,N as memoryReadDeliveryRung,Oe as memoryReadDocBlocks,re as mergeContextExposureState,d as normalizeDocName,i as normalizeNameSegment,w as owningRootOf,u as parseSubstrateDoc,m as parseSubstrateFrontmatter,g as parsedSubstrateSurfaces,P as planDelivery,x as previewLine,me as profileNameFor,F as readDeliveryRung,te as registerDocumentExposure,oe as registerExposure,G as renderDirListing,Re as renderKnowledgeBlock,le as renderKnowledgeForSubject,Fe as renderOnCommandDocsForSubject,he as renderOnReadDocs,ye as renderOnReadDocsForSubject,fe as renderPreferencesForSubject,ge as renderPreferencesSection,ve as renderWorkspaceOpenDocs,Ce as renderWorkspaceOpenDocsForSubject,ne as replaceContextExposureState,S as resolveDocName,s as rungAtLeast,a as rungRank,ae as saveContextExposureState,ce as scopeForCwd,se as sharedContextExposureState,xe as spineDepth,k as surfaceEntryParticipates,A as underOwningRoot,O as workspaceOpenRung};