@sema-agent/core 7.47.0 → 7.49.0

package/dist/tools/fs/read-deny-home.d.ts

@@ -15,51 +15,54 @@ export declare function declaredReadDenyHomes(env: Pick<ExecutionEnv, "homeDir">
  *  gave no answer, or where the declared home's own probe did not answer (ask again later). */
 export declare function readDenyHomesOf(env: Pick<ExecutionEnv, "homeDir" | "canonicalPath">, signal?: AbortSignal): Promise<string[]>;
 /**
- * Where the home-anchored rows of a table LEAD beyond the home's own spellings, keyed by the row's pattern — the
- * `linked` argument of `compileReadDeny`. For each row, its LITERAL HEAD (`readDenyRunHead`: the run's segments before
- * the first one carrying `*`) is spelled under each home and resolved the way the read faces mint their keys
- * (`canonicalizeTarget`: the longest existing prefix resolved, the rest rejoined); a location that differs from every
- * home's own spelling of the head is where one of the head's segments is a link, and the row is placed there too.
- *  · a head that resolves to its own spelling under a home adds nothing (the row is already placed there);
+ * Where a table's deny rows LEAD past the places their own runs anchor them, keyed by the row's pattern — the `linked`
+ * argument of `compileReadDeny`. ONE constructor for every anchor ({@link ReadDenyRowAnchor}): the rows the anchor
+ * places, each row's LITERAL HEAD ({@link literalHeadOf}) spelled under each of the anchor's places and resolved the way the
+ * read faces mint their keys (`canonicalizeTarget`: the longest existing prefix resolved, the rest rejoined); a location
+ * that differs from the spellings the row is already anchored at is where one of the head's segments is a link (`~/.sema`
+ * into a dotfiles directory, `/app` a link to `/data/app`), and the row is placed there too.
+ *  · a head that resolves to its own spelling at an anchored place adds nothing (the row is already placed there);
  *  · a head under a spelling that is no directory (a segment of it is a file, a symlink to a file, a device node or a
  *    socket — the environment answers `not_directory` for the head) has nothing below it: an answer that adds nothing;
  *  · any other head that cannot be resolved (an unanswered or refused probe — a directory the probe may not enter — a
- *    probe that throws) adds nothing, and the answer is not WHOLE (`whole: false`): the row stays placed at the home's
- *    spellings until the mount places again;
- *  · a row whose head is empty (`~/.sema.*`) has no location to resolve and adds nothing;
+ *    probe that throws) adds nothing, and the answer is not WHOLE (`whole: false`): the row stays at the places its run
+ *    anchors until the mount places again;
  *  · the heads are resolved together, so one placement waits at most one probe bound — or, with `deadline` (an absolute
  *    time), each head until then: a head still unresolved at the deadline is a head that did not answer;
  *  · read per placement — a link created afterwards is followed from the next placement on.
  */
-export declare function readDenyHomeLinksOf(env: ExecutionEnv, entries: readonly {
+export declare function readDenyLinksOf(env: ExecutionEnv, entries: readonly {
     readonly pattern: string;
     readonly caseSensitive?: boolean;
-}[], homes: readonly string[], signal?: AbortSignal, deadline?: number): Promise<{
+}[], anchor: ReadDenyRowAnchor, signal?: AbortSignal, deadline?: number): Promise<{
     readonly linked: Map<string, string[]>;
     readonly whole: boolean;
 }>;
 /**
- * Where the rows that open with the configuration directory's name (`~/.sema/…`, {@link agentConfigDirTail}) lead when
- * the host declares the directory's root (`RunnerDeps.agentConfigDir`) — the same `linked` answer
- * {@link readDenyHomeLinksOf} gives, for the same rows: the row's literal head below the directory name is spelled under
- * each spelling of the root and resolved the way the read faces mint their keys. A row is not anchored at the root by
- * its own run (it is anchored at the homes), so every location here — the spelling itself and where it leads — is one the
- * row is placed at in addition; the home spelling stays placed. The row's name in every refusal is unchanged.
- *  · a row whose run does not open with the directory's name (`~/.sema.*`, the external tools' files) adds nothing;
- *  · a row whose head ends at the directory name (`~/.sema/*.json`, `~/.sema`) is placed at the root itself, the rest of
- *    its run matched below it.
+ * Which rows one placement reads, and where their heads are spelled:
+ *  · `home` — the home-anchored rows (`~/…`), under each home; the row's run anchors it there;
+ *  · `root` — the ROOTED rows (`/app/config-lkg.json`, {@link isRootedReadDenyPattern}), under the filesystem root; the run
+ *    anchors it there. A root is no home: read whether or not a home answered;
+ *  · `unanchored` — the rows that open with the configuration directory's name (`~/.sema/…`, {@link agentConfigDirTail})
+ *    under each spelling of the root the host declares for that directory (`RunnerDeps.agentConfigDir`): the head BELOW
+ *    the directory name, a head that ends at it (`~/.sema/*.json`, `~/.sema`) the root itself. The row's run does not
+ *    anchor it there (it is anchored at the homes), so every location — the spelling itself and where it leads — is one
+ *    the row is placed at in addition; the row's name in every refusal is unchanged.
+ * A home or rooted row whose head is empty (`~/.sema.*`, `/*.json`) has no location to resolve and adds nothing.
  */
-export declare function readDenyConfigRootLinksOf(env: ExecutionEnv, entries: readonly {
-    readonly pattern: string;
-    readonly caseSensitive?: boolean;
-}[], roots: readonly string[], signal?: AbortSignal, deadline?: number): Promise<{
-    readonly linked: Map<string, string[]>;
-    readonly whole: boolean;
-}>;
+export type ReadDenyRowAnchor = {
+    readonly at: "home";
+    readonly homes: readonly string[];
+} | {
+    readonly at: "root";
+} | {
+    readonly at: "unanchored";
+    readonly roots: readonly string[];
+};
 /** Where an absolute location LEADS in one environment — resolved the way the read and write faces mint their keys
  *  (`canonicalizeTarget`: the longest existing prefix resolved, the rest rejoined). `undefined` when the environment
  *  does not answer (a refused or failed probe, one that throws). The one resolution a deny row's placement reads: a
- *  home-anchored row's head ({@link readDenyHomeLinksOf}) and a rule row's head ({@link whereItsAnsweredPrefixLeads}). */
+ *  deny row's head ({@link readDenyLinksOf}) and a rule row's head ({@link whereItsAnsweredPrefixLeads}). */
 export declare function whereItLeads(env: ExecutionEnv, at: string, family?: PathFamily, signal?: AbortSignal): Promise<string | undefined>;
 /** {@link whereItLeads} with a floor: where the environment does not answer for `at` (a probe that fails), the longest
  *  prefix it does answer for is resolved and the rest rejoined — a rule row's head below a base that resolves is never
@@ -133,12 +136,14 @@ export declare function carryHomeViews<T extends object>(judge: T, source: HomeV
  *  · the HOME SET — `homes` when the mount carries a list (the account is not asked and no home is added), else the
  *    declared home and the account lookup's answer ({@link declaredReadDenyHomes}); every home of the set is anchored at
  *    its spelling and, where the environment answered one, its canonical spelling — one rule for both forms;
- *  · the DECLARED home's canonical spelling under the tree's gate bound, and its rows' heads ({@link readDenyHomeLinksOf}):
+ *  · the DECLARED home's canonical spelling under the tree's gate bound, and its rows' heads ({@link readDenyLinksOf}):
  *    a declared home, or a head under it, that did not answer leaves the placement not WHOLE — and an account lookup
  *    with no answer, or a declared home that did not answer, places nothing: the rows are held anywhere (`compile([])`)
  *    rather than at a spelling that may miss the home's canonical one;
  *  · each AUXILIARY home (see the module head) read once under {@link AUXILIARY_HOME_PROBE_MS} — its spellings, its
- *    chain, its rows' heads — at the same time; whatever of it did not answer costs that home alone and never `whole`.
+ *    chain, its rows' heads — at the same time; whatever of it did not answer costs that home alone and never `whole`;
+ *  · the ROOTED rows' heads ({@link readDenyLinksOf}), read whether or not a home answered: a head that did not answer
+ *    leaves the placement not WHOLE, and a placement that held the rows anywhere still places them.
  *  `compile` is the mount's own compile; the rows' patterns are read off its compile at no home. */
 export declare function placeReadDenyAtHome(env: ExecutionEnv, compile: (homes: readonly string[], linked?: ReadonlyMap<string, readonly string[]>) => ReadDenyMatcher, homes?: readonly string[], signal?: AbortSignal, configRoot?: string): Promise<{
     readonly matcher: PlacedReadDenyMatcher;

package/dist/tools/fs/read-deny-home.js

@@ -1,9 +1,10 @@
 import { userInfo } from "node:os";
-import { canonicalizeTarget, isAbsolutePathForm, joinForFamily, normalizeAbsPathLexically, pathFamilyOf } from "./safety.js";
+import { canonicalizeTarget, isAbsoluteForFamily, joinForFamily, normalizeAbsPathLexically, pathFamilyOf } from "./safety.js";
 import { DEFAULT_GATE_AWAIT_TIMEOUT_MS, withGateTimeout } from "../../core/gate-bounded-await.js";
 import { thrownText } from "../../core/thrown-value.js";
 import { agentConfigDirTail } from "../../core/agent-config-dir.js";
-import { readDenyPatternRun, readDenyRunHead } from "./read-deny.js";
+import { validatePath } from "../../core/effective-path-target.js";
+import { isRootedReadDenyPattern, readDenyPatternRun, readDenyRunHead } from "./read-deny.js";
 export const AUXILIARY_HOME_PROBE_MS = 2_000;
 const said = new Set();
 function sayOnce(kind, line) {
@@ -36,8 +37,9 @@ function valueText(v) {
 function accountHomeOf() {
     try {
         const home = userInfo().homedir;
-        if (typeof home === "string" && isAbsolutePathForm(home))
-            return { state: "home", home };
+        const valid = validatePath(home, { intent: "validate-coordinate" });
+        if (valid !== undefined)
+            return { state: "home", home: valid };
         sayOnce("bad_value", `read-deny homes: the account home lookup answered ${valueText(home)}, not an absolute path — home-anchored read-deny rows are placed under the environment's declared home only.`);
         return { state: "none" };
     }
@@ -49,8 +51,7 @@ function accountHomeOf() {
     }
 }
 function declaredHomeOf(env) {
-    const home = env.homeDir;
-    return home !== undefined && isAbsolutePathForm(home) ? home : undefined;
+    return validatePath(env.homeDir, { intent: "validate-coordinate" });
 }
 function declaredReadDenyHomesAnswered(env) {
     const home = declaredHomeOf(env);
@@ -105,39 +106,43 @@ function sayAuxiliary(what, subject = "auxiliary") {
     }
     sayOnce("auxiliary", `read-deny homes: a home beside the environment's declared home did not answer its probes within ${AUXILIARY_HOME_PROBE_MS} ms (${what}) — its home-anchored read-deny rows sit at its spelling only, and a path through an alias of it is judged as spelled, until the next placement.`);
 }
-export async function readDenyHomeLinksOf(env, entries, homes, signal, deadline) {
-    const rows = [];
-    for (const { pattern, caseSensitive } of entries) {
-        const { homeAnchored, run } = readDenyPatternRun(pattern);
-        if (!homeAnchored)
-            continue;
-        const head = run.split("/").filter(Boolean).slice(0, readDenyRunHead(run)).join("/");
-        if (head.length === 0)
-            continue;
-        const spelled = homes.map((home) => normalizeAbsPathLexically(joinForFamily(pathFamilyOf({ root: home }), home, head)));
-        rows.push({ pattern, caseSensitive: caseSensitive === true, spelled, anchored: spelled });
-    }
-    return await linkedLocationsOf(env, rows, signal, deadline);
+export async function readDenyLinksOf(env, entries, anchor, signal, deadline) {
+    return await linkedLocationsOf(env, anchoredRowsOf(entries, anchor), signal, deadline);
 }
-export async function readDenyConfigRootLinksOf(env, entries, roots, signal, deadline) {
-    return await linkedLocationsOf(env, configRootRowsOf(entries, roots), signal, deadline);
+const ROOT = "/";
+function literalHeadOf(run) {
+    return run.split("/").filter(Boolean).slice(0, readDenyRunHead(run)).join("/");
 }
-function configRootRowsOf(entries, roots) {
+function anchoredRowsOf(entries, anchor) {
+    const places = anchor.at === "home" ? anchor.homes : anchor.at === "root" ? [ROOT] : anchor.roots;
     const rows = [];
     for (const { pattern, caseSensitive } of entries) {
-        const { homeAnchored, run } = readDenyPatternRun(pattern);
-        const tail = homeAnchored ? agentConfigDirTail(run, caseSensitive === true) : undefined;
-        if (tail === undefined)
+        const head = rowHeadOf(pattern, caseSensitive === true, anchor);
+        if (head === undefined)
             continue;
-        const head = tail.split("/").filter(Boolean).slice(0, readDenyRunHead(tail)).join("/");
-        const spelled = roots.map((root) => normalizeAbsPathLexically(head.length === 0 ? root : joinForFamily(pathFamilyOf({ root }), root, head)));
-        rows.push({ pattern, caseSensitive: caseSensitive === true, spelled, anchored: [] });
+        const spelled = places.map((place) => normalizeAbsPathLexically(head.length === 0 ? place : joinForFamily(pathFamilyOf({ root: place }), place, head)));
+        rows.push({ pattern, caseSensitive: caseSensitive === true, spelled, anchored: anchor.at === "unanchored" ? [] : spelled });
     }
     return rows;
 }
+function rowHeadOf(pattern, caseSensitive, anchor) {
+    if (anchor.at === "root") {
+        const head = isRootedReadDenyPattern(pattern) ? literalHeadOf(pattern) : "";
+        return head.length > 0 ? head : undefined;
+    }
+    const { homeAnchored, run } = readDenyPatternRun(pattern);
+    if (!homeAnchored)
+        return undefined;
+    if (anchor.at === "unanchored") {
+        const tail = agentConfigDirTail(run, caseSensitive);
+        return tail === undefined ? undefined : literalHeadOf(tail);
+    }
+    const head = literalHeadOf(run);
+    return head.length > 0 ? head : undefined;
+}
 function configRootSpelledLinks(entries, roots) {
     const out = new Map();
-    for (const { pattern, spelled } of configRootRowsOf(entries, roots))
+    for (const { pattern, spelled } of anchoredRowsOf(entries, { at: "unanchored", roots }))
         out.set(pattern, [...new Set(spelled)]);
     return out;
 }
@@ -242,9 +247,7 @@ async function readAuxiliaryHome(env, home, opts, signal) {
             typeof identity === "function" ? chainAbove(env, identity, spelled.canonical, signal, deadline) : Promise.resolve({ ancestors: [], whole: true }),
             opts.entries === undefined
                 ? Promise.resolve({ linked: new Map(), whole: true })
-                : opts.configRoot === true
-                    ? readDenyConfigRootLinksOf(env, opts.entries, place, signal, deadline)
-                    : readDenyHomeLinksOf(env, opts.entries, place, signal, deadline),
+                : readDenyLinksOf(env, opts.entries, opts.configRoot === true ? { at: "unanchored", roots: place } : { at: "home", homes: place }, signal, deadline),
         ]);
         reading = { place, chain, linked: heads.linked, answered: chain.whole && heads.whole };
     }
@@ -320,7 +323,7 @@ function homeViewSourceOver(env, auxiliary) {
             };
             return {
                 async of(path, opts) {
-                    if (typeof identity !== "function" || (declared === undefined && auxiliary.length === 0) || !isAbsolutePathForm(path))
+                    if (typeof identity !== "function" || (declared === undefined && auxiliary.length === 0) || !isAbsoluteForFamily("own", path))
                         return undefined;
                     const spelled = normalizeAbsPathLexically(path);
                     const view = await viewOf(spelled, opts?.leaf === "file");
@@ -348,7 +351,7 @@ export function sayPlacementLost() {
 }
 function readAuxiliaryHomes(env, homes, opts, signal) {
     const declared = declaredHomeOf(env);
-    return [...new Set(homes.filter((h) => isAbsolutePathForm(h) && !isDeclared(declared, h)))].map((home) => readAuxiliaryHome(env, home, opts, signal));
+    return [...new Set(homes.filter((h) => isAbsoluteForFamily("own", h) && !isDeclared(declared, h)))].map((home) => readAuxiliaryHome(env, home, opts, signal));
 }
 export function homeViewsAt(env, homes) {
     return homeViewSourceOver(env, readAuxiliaryHomes(env, homes, {}));
@@ -363,8 +366,12 @@ export async function placeReadDenyAtHome(env, compile, homes, signal, configRoo
     const entries = compile([]).entries;
     const declared = declaredHomeOf(env);
     const relocated = configRoot === undefined ? undefined : readAuxiliaryHome(env, configRoot, { entries, configRoot: true }, signal);
+    const rooted = readDenyLinksOf(env, entries, { at: "root" }, signal);
     const heldAnywhere = async (whole) => {
-        const linked = (await relocated)?.linked ?? new Map();
+        const linked = new Map();
+        for (const map of [(await relocated)?.linked, (await rooted).linked])
+            for (const [pattern, locations] of map ?? [])
+                linked.set(pattern, locations);
         return placementOf(carryHomeViews(linked.size === 0 ? compile([]) : compile([], linked), homeViewSourceOver(env, relocated === undefined ? [] : [relocated])), [], linked, whole);
     };
     const listed = homes === undefined ? declaredReadDenyHomesAnswered(env) : { homes, whole: true };
@@ -379,15 +386,15 @@ export async function placeReadDenyAtHome(env, compile, homes, signal, configRoo
         declaredAt = [...new Set([...own, ...ownSpellings.spellings])];
     }
     const auxiliary = readAuxiliaryHomes(env, listed.homes, { entries }, signal);
-    const [heads, readings, root] = await Promise.all([readDenyHomeLinksOf(env, entries, declaredAt, signal), Promise.all(auxiliary), relocated]);
+    const [heads, readings, root, rootedHeads] = await Promise.all([readDenyLinksOf(env, entries, { at: "home", homes: declaredAt }, signal), Promise.all(auxiliary), relocated, rooted]);
     const at = [...new Set([...declaredAt, ...readings.flatMap((r) => r.place)])];
     const linked = new Map();
-    for (const map of [heads.linked, ...readings.map((r) => r.linked), ...(root === undefined ? [] : [root.linked])]) {
+    for (const map of [heads.linked, ...readings.map((r) => r.linked), ...(root === undefined ? [] : [root.linked]), rootedHeads.linked]) {
         for (const [pattern, locations] of map)
             linked.set(pattern, [...new Set([...(linked.get(pattern) ?? []), ...locations])]);
     }
     const matcher = linked.size === 0 ? compile(at) : compile(at, linked);
-    return placementOf(carryHomeViews(matcher, homeViewSourceOver(env, relocated === undefined ? auxiliary : [...auxiliary, relocated])), at, linked, heads.whole);
+    return placementOf(carryHomeViews(matcher, homeViewSourceOver(env, relocated === undefined ? auxiliary : [...auxiliary, relocated])), at, linked, heads.whole && rootedHeads.whole);
 }
 export function readDenyPlacedLater(unplaced, place) {
     let current = unplaced;

package/dist/tools/fs/read-deny.d.ts

@@ -1,3 +1,4 @@
+import { type PathGuardFold, type PathGuardRow, type PathRowsHit, type TargetViews } from "../../core/path-guard-rows.js";
 /**
  * One deny entry: a `/`-separated run of path SEGMENTS. `*` matches any run of non-separator
  * characters within one segment and is the ONLY metacharacter (everything else is literal). The run
@@ -5,7 +6,10 @@
  * unless the pattern opens with the HOME word ({@link READ_DENY_HOME_WORD}): `~/<run>` matches only where
  * the run starts right below the execution environment's home directory (`~/.sema/settings.json` is the
  * home's file, never a project's `.sema/settings.json`). Only a FIRST segment that is exactly `~` is the
- * word; `~user` and a `~` further along are literal segments.
+ * word; `~user` and a `~` further along are literal segments. A pattern that opens with `/` (and is not home-anchored)
+ * is ROOTED, the same kind of anchor with the filesystem root as its place: `/app/config-lkg.json` names the file
+ * at exactly that location, never a project's `app/config-lkg.json` — the run must start at the first segment of an
+ * absolute path (a path that is not absolute is not placed, and the row does not judge it).
  * String shorthand ≡ `{ pattern }`. Matching is ASCII-case-insensitive by default (a case-insensitive
  * filesystem serves `.SSH` and `.ssh` as the same directory); `caseSensitive: true` opts a single
  * entry out. Unicode normalization (NFC/NFD) and volume-level case semantics are NOT modeled (v1
@@ -83,28 +87,12 @@ export type PathRowReach = {
 export interface JudgedPathRow extends PathRuleDenyRow {
     readonly reach?: (absolutePath: string) => PathRowReach;
 }
-/** A call's target as a judgment reads it: the absolute spellings of its views (lexical, canonical, the leaf chain's hops —
- *  any order the caller holds), or `unreadable` when the call names a target this reading cannot locate. */
-export interface TargetViews {
-    readonly spellings: readonly string[];
-    readonly unreadable?: string;
-}
-/** What {@link pathRowsReach} found: the row, the view it met there (absent on an unreadable hold), and — when nothing was
- *  reached and some row could not be judged — the reason of the first such row. */
-export interface PathRowsHit<R> {
-    readonly row: R;
-    readonly view?: string;
-    readonly unreadable?: string;
-}
 /**
- * THE one judgment of path rule rows over a call's target, for the gate's rule lanes and the tool's deny table alike: rows
- * outer, views inner — the first row (in the caller's order) that some view reaches is the answer, so the rule a refusal
- * names does not depend on which view happened to meet it. `tighten` (deny / ask): any view reaching the row reaches it; a
- * row that cannot be judged (or a target that cannot be read) is held and answered only when no row reaches. `allow`: a
- * row admits the call only when it admits EVERY view (a link out of an allowed directory is not admitted through its
- * spelling); an unreadable target is admitted by nothing.
+ * Rule rows judged by THE one judgment ({@link judgePathRows}): each rule row read as a guarded row whose reach over a view
+ * is the rule's own reach over the view's spelling (never exemptible — a rule says exactly where it reaches). Same rows
+ * outer, views inner, same tighten / allow law as every other row; the hit names the rule row itself.
  */
-export declare function pathRowsReach<R extends JudgedPathRow>(rows: readonly R[], views: TargetViews, direction: "tighten" | "allow"): PathRowsHit<R> | undefined;
+export declare function judgeRuleRows<R extends JudgedPathRow>(rows: readonly R[], views: TargetViews, direction: "tighten" | "allow"): PathRowsHit<R> | undefined;
 /** The locations a row is also judged at (each leading part of its HEAD: the anchor's children down to the head itself,
  *  a share's root for a UNC head) — what a leg resolves once, for every row whose head it holds. */
 export declare function ruleHeadParts(rows: readonly Pick<PathRuleDenyRow, "head">[]): string[];
@@ -126,10 +114,23 @@ export declare function rowsWhereTheyLead<R extends JudgedPathRow>(rows: readonl
 export declare function locationLeadsTo(path: string, leads: ReadonlyMap<string, string | undefined>): string | undefined;
 /** {@link rowsWhereTheyLead} with each part resolved by `leadsTo` (the leg's resolution; each part once). */
 export declare function withRuleRowsWhereTheyLead<R extends JudgedPathRow>(rows: readonly R[], leadsTo: (head: string) => Promise<string | undefined>): Promise<R[]>;
+/** A rule row as a row of the one table: its name is the rule text, its reach the rule's own over a view's spelling. */
+export declare function ruleGuardRow<R extends JudgedPathRow>(rule: R): PathGuardRow & {
+    readonly rule: R;
+};
+/** A compiled segment-glob row as a row of the one table (`faces`, `polarity`, `exemptible` and `origin` are the table's). */
+export declare function segmentGuardRow(pat: CompiledSegmentPattern, columns: {
+    readonly faces: readonly DenyFace[];
+    readonly polarity: "deny" | "ask";
+    readonly exemptible: boolean;
+    readonly fold: PathGuardFold;
+    readonly origin: PathGuardRow["origin"];
+    readonly tier?: string;
+}): PathGuardRow;
 /**
  * The WRITE face of the deny table: the rule rows whose faces include `write` — the judge the shell station reads for a
  * command's write targets (a redirection, `tee`, `sed -i`, `cp` / `mv` / `touch` / `mkdir` / `rm` operands). Same row
- * type, same judgment ({@link pathRowsReach}) as the read face's rule rows; a hit names the row by its rule text.
+ * type, same judgment ({@link judgePathRows}) as the read face's rows; a hit names the row by its rule text.
  */
 export interface WriteDenyMatcher {
     /** Which face this judge is — the write tools' path resolution reads it to word and code the refusal as a write. */
@@ -384,8 +385,9 @@ export interface CompiledSegmentPattern {
     /** The segment lists of the directories the run is ANCHORED at (folded as the pattern folds): the run must start
      *  right after one of them. Absent = the run matches anywhere. */
     anchors?: readonly (readonly string[])[];
-    /** Judged in a ROOTED view only: an extra location of a home-anchored row (where its literal head leads). A view that
-     *  is not rooted cannot be placed and is covered by the row's own run, held anywhere. */
+    /** Judged in a ROOTED view only: an extra location of a home-anchored row (where its literal head leads), or a row that is
+     *  itself rooted (anchored at the filesystem root, {@link ReadDenyEntry}). A view that is not rooted cannot be placed: a
+     *  home-anchored row's own run is held anywhere in it (the row cannot be placed, so it holds wider); these two judge it not. */
     rootedOnly?: true;
 }
 /**
@@ -408,6 +410,12 @@ export declare function compileSegmentPattern(raw: string, fold: "none" | "ascii
 export declare function matchSegmentPatterns(path: string, compiled: readonly CompiledSegmentPattern[], opts?: {
     readonly aliasResolved?: boolean;
 }): string | null;
+/** One entry's refusal under the deny list's entry law ({@link normalizeEntry}, the compiler's own), or `undefined` when the
+ *  entry is lawful — the law read without compiling, for a door that judges a list before anything folds it. */
+export declare function readDenyEntryProblem(entry: unknown, layer: string): string | undefined;
+/** Is a canonical pattern ROOTED — placed at the filesystem root ({@link ReadDenyEntry})? Only {@link canonicalReadDenyPattern}
+ *  puts a leading `/` on a canonical pattern, so the text is the whole answer. */
+export declare function isRootedReadDenyPattern(canonical: string): boolean;
 /**
  * the PURE validation/canonicality predicate over a PERSISTED deny entry (checkpoint v9
  * face section), for the resume pre-CAS ladder: it must refuse BEFORE the approval CAS everything
@@ -437,9 +445,9 @@ export declare function checkedReadDenyHomes(homes: unknown, seat?: string): rea
  * spellings only — any other shape refuses loudly, naming `readDenyHomes`. EMPTY = the environment declares no
  * home: a home-anchored entry then matches its run anywhere — a row that cannot be placed holds wider, never narrower.
  *
- * `linked` — where a home-anchored row's LITERAL HEAD ({@link readDenyRunHead}) really leads, keyed by the row's
- * pattern: the canonical locations a mount resolved (`readDenyHomeLinksOf`, read-deny-home.ts) where one of the
- * head's segments is a link (`~/.sema` linked into a dotfiles directory). The row is placed at each location too —
+ * `linked` — where a home-anchored or a rooted row's LITERAL HEAD ({@link readDenyRunHead}) really leads, keyed by the row's
+ * pattern: the canonical locations a mount resolved (`readDenyLinksOf`, read-deny-home.ts) where
+ * one of the head's segments is a link (`~/.sema` linked into a dotfiles directory; `/app` a link to `/data/app`). The row is placed at each location too —
  * the same row, the same name in every refusal — with the rest of its run matched below it. The read faces judge
  * canonical keys, so every spelling that reaches the linked file meets the row there. Absolute locations only.
  */