@event4u/agent-config 16.5.0 → 17.0.0

package/dist/scripts/_lib/environment_detector.js

@@ -74,38 +74,29 @@ import { parseVersionOutput } from '../../install/agentSwitchDetection.js';
 import { claude_config_dir } from './claude_plugin.js';
 import { hardenedSpawnEnv } from './spawn_env.js';
 import { resolve_with_fallback } from './user_global_paths.js';
-/**
- * Provider → (default CLI binary, community-wrapper flag).
- *
- * Mirrors the `CliClient` subclass attributes without importing the client
- * layer. The boolean is the load-bearing billing input: a VENDOR-OFFICIAL CLI
- * (`false`) runs under the user's subscription; a COMMUNITY wrapper (`true`)
- * shells out to the same paid API and stays metered. Canonical here so
- * `cmd_doctor` and this module cannot drift.
- */
-export const PROVIDER_CLI_META = {
-    anthropic: ['claude', false],
-    openai: ['codex', false],
-    gemini: ['gemini', false],
-    xai: ['grok', true],
-    perplexity: ['perplexity', true],
-};
-/** Provider → environment variable carrying a raw API key. */
-const PROVIDER_ENV_KEY = {
-    anthropic: 'ANTHROPIC_API_KEY',
-    openai: 'OPENAI_API_KEY',
-    gemini: 'GEMINI_API_KEY',
-    xai: 'XAI_API_KEY',
-    perplexity: 'PERPLEXITY_API_KEY',
-};
-/** Provider → key-file name under the user-global root (`file:` ref target). */
-const PROVIDER_KEY_FILE = {
-    anthropic: 'anthropic.key',
-    openai: 'openai.key',
-    gemini: 'gemini.key',
-    xai: 'xai.key',
-    perplexity: 'perplexity.key',
+export const PROVIDER_TABLE = {
+    anthropic: { cli: 'claude', community: false, envKey: 'ANTHROPIC_API_KEY', keyFile: 'anthropic.key' },
+    openai: { cli: 'codex', community: false, envKey: 'OPENAI_API_KEY', keyFile: 'openai.key' },
+    gemini: { cli: 'gemini', community: false, envKey: 'GEMINI_API_KEY', keyFile: 'gemini.key' },
+    xai: { cli: 'grok', community: true, envKey: 'XAI_API_KEY', keyFile: 'xai.key' },
+    perplexity: { cli: 'perplexity', community: true, envKey: 'PERPLEXITY_API_KEY', keyFile: 'perplexity.key' },
 };
+/** The complete row for `provider`, or null when it is absent or any field is missing. */
+export function providerRow(provider, table = PROVIDER_TABLE) {
+    const row = table[provider];
+    if (row === undefined)
+        return null;
+    const complete = typeof row.cli === 'string' && row.cli !== '' &&
+        typeof row.community === 'boolean' &&
+        typeof row.envKey === 'string' && row.envKey !== '' &&
+        typeof row.keyFile === 'string' && row.keyFile !== '';
+    return complete ? row : null;
+}
+/** Provider → (default CLI binary, community-wrapper flag); a projection of `PROVIDER_TABLE`. */
+export const PROVIDER_CLI_META = Object.fromEntries(Object.keys(PROVIDER_TABLE).flatMap((p) => {
+    const row = providerRow(p);
+    return row === null ? [] : [[p, [row.cli, row.community]]];
+}));
 /** Providers this module knows how to classify, in a stable order. */
 export function knownProviders() {
     return Object.keys(PROVIDER_CLI_META);
@@ -327,7 +318,7 @@ function detectAuth(opts) {
         if (cli !== null) {
             auth.push({ provider, source: cli.source, evidence: cli.evidence });
         }
-        const keyFile = PROVIDER_KEY_FILE[provider];
+        const keyFile = providerRow(provider)?.keyFile;
         if (keyFile !== undefined) {
             let resolved = null;
             try {
@@ -341,7 +332,7 @@ function detectAuth(opts) {
                 keys.push({ provider, ref: `file:${keyFile}` });
             }
         }
-        const envVar = PROVIDER_ENV_KEY[provider];
+        const envVar = providerRow(provider)?.envKey;
         if (envVar !== undefined && (env[envVar] ?? '').trim() !== '') {
             auth.push({ provider, source: 'env-key', evidence: `env:${envVar}` });
             keys.push({ provider, ref: `env:${envVar}` });

package/dist/scripts/_lib/global_deploy_inventory.js

@@ -35,21 +35,33 @@
  * Schema (JSON):
  *
  *     {
- *       "schema_version": 1,
+ *       "schema_version": 2,
  *       "tools": {
  *         "<tool_id>": {
  *           "anchor": "/abs/path/to/anchor",
- *           "files": ["skills/foo/SKILL.md", ...]   // anchor-relative, sorted
+ *           "files": ["skills/foo/SKILL.md", ...],  // anchor-relative, sorted
+ *           "digests": {                             // schema 2, additive
+ *             "skills/foo/SKILL.md": {
+ *               "installed_sha256": "…",             // the bytes we wrote
+ *               "packaged_sha256": "…"               // the bytes we ship now; null = retired
+ *             }
+ *           }
  *         }
  *       }
  *     }
+ *
+ * Schema 2 is ADDITIVE: `files` keeps its schema-1 meaning, so every reader that treats it
+ * as a path allowlist works unchanged on either schema, and a schema-1 file
+ * loads as an inventory without digests. The digests are the user-scoped
+ * ownership ledger: written on every global deploy whatever directory the
+ * install ran from, and read by the reaper so an edit is seen before an unlink.
  */
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as user_global_paths from "./user_global_paths.js";
-export const SCHEMA_VERSION = 1;
+export const SCHEMA_VERSION = 2;
 export const INVENTORY_BASENAME = "deployed-files.json";
 export const INVENTORY_ENV = "AGENT_CONFIG_DEPLOY_INVENTORY";
 /** Expand a leading `~` like Python's `Path.expanduser()`. */
@@ -349,8 +361,15 @@ function as_posix(p) {
  * directories — the preview surface for `agent-config install --dry-run`. The selection
  * logic (orphan diff, containment proof, directory guard) is identical to the
  * live path, so the preview is exact.
+ *
+ * An orphan whose bytes differ from the digest the ledger recorded writing is
+ * NOT deleted: the user edited a file the package retired, and an unlink would
+ * destroy that edit without it ever being seen. Its absolute path is pushed to
+ * `retained` instead, so the caller can say so and keep the record. Orphans are
+ * read from `files` AND from the recorded digests, because a retained file is
+ * no longer shipped and stays recorded only there.
  */
-export function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false) {
+export function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false, retained = null) {
     const tools = inventory["tools"] ?? {};
     const entry = tools[tool_id];
     if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
@@ -370,7 +389,11 @@ export function reap_stale(tool_id, anchor, current_files, inventory, dry_run =
     }
     const deleted = [];
     const prune_candidates = new Set();
-    const orphans = difference(prev_files, current_files);
+    const digests = digests_of_entry(e);
+    // A preview cannot know which sidecars the real run stages again, and a
+    // staged sidecar is kept — so the preview never names one as would-delete.
+    const recorded = [...digests].filter(([, d]) => !(dry_run && d.kind === "sidecar")).map(([rel]) => rel);
+    const orphans = difference([...prev_files, ...recorded], current_files);
     for (const rel of sorted_strings(orphans)) {
         if (typeof rel !== "string" || !rel || rel.startsWith("/") || rel.startsWith("..")) {
             continue;
@@ -394,6 +417,10 @@ export function reap_stale(tool_id, anchor, current_files, inventory, dry_run =
         if (lst && lst.isDirectory() && !lst.isSymbolicLink()) {
             continue; // never delete directories
         }
+        if (lst !== null && edited_since_install(target, digests.get(rel))) {
+            retained?.push(target);
+            continue;
+        }
         if (dry_run) {
             // Preview: report only what is actually on disk and would go.
             if (path_exists(target) || (lst !== null && lst.isSymbolicLink())) {
@@ -441,8 +468,14 @@ export function reap_stale(tool_id, anchor, current_files, inventory, dry_run =
  * `dry_run=true` returns the would-delete set (tagged orphans actually present
  * on disk) WITHOUT unlinking or pruning — the preview surface for
  * `agent-config install --dry-run`. Selection logic is identical to the live path.
+ *
+ * The tag survives a user's edit, so it proves we WROTE the file, never that it
+ * is still what we wrote. A tagged orphan the ledger (`digests`) recorded with
+ * a digest its bytes no longer match is pushed to `retained` and kept, exactly
+ * as {@link reap_stale} keeps it. A tagged orphan with no recorded digest — an
+ * install older than the ledger — is still reaped: there is nothing to compare.
  */
-export function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_run = false) {
+export function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_run = false, digests = new Map(), retained = null) {
     const anchor_resolved = resolve_path(expanduser(anchor));
     const deleted = [];
     const prune_candidates = new Set();
@@ -496,6 +529,10 @@ export function reap_tagged_orphans(anchor, dest_subs, current_files, package_ta
             if (!hit) {
                 continue;
             }
+            if (edited_since_install(md, digests.get(rel))) {
+                retained?.push(md);
+                continue;
+            }
             if (dry_run) {
                 deleted.push(md);
                 continue;
@@ -521,20 +558,120 @@ export function reap_tagged_orphans(anchor, dest_subs, current_files, package_ta
  * survives a home relocation. {@link reap_stale} expands the recorded value at
  * comparison time.
  */
-export function record_deploy(tool_id, anchor, current_files, inventory) {
+export function record_deploy(tool_id, anchor, current_files, inventory, digests = null) {
     if (typeof inventory["tools"] !== "object" ||
         inventory["tools"] === null ||
         Array.isArray(inventory["tools"])) {
         inventory["tools"] = {};
     }
     const tools = inventory["tools"];
-    tools[tool_id] = {
+    const record = {
         anchor: String(anchor),
         files: sorted_strings([...current_files]),
     };
+    // Omitted rather than emptied when the caller has none: an entry written by a
+    // caller that computes no digests reads exactly as a schema-1 entry did.
+    if (digests !== null && digests.size > 0) {
+        record["digests"] = Object.fromEntries(sorted_strings([...digests.keys()]).map((rel) => [rel, { ...digests.get(rel) }]));
+    }
+    tools[tool_id] = record;
     inventory["schema_version"] = SCHEMA_VERSION;
     return inventory;
 }
+/** SHA-256 of the bytes at `p`, or `null` when they cannot be read. */
+export function file_sha256(p) {
+    try {
+        return createHash("sha256").update(fs.readFileSync(p)).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+/** True when `target` is readable and its bytes differ from the recorded installed digest. */
+function edited_since_install(target, rec) {
+    if (rec === undefined)
+        return false;
+    const on_disk = file_sha256(target);
+    if (on_disk !== null)
+        return on_disk !== rec.installed_sha256;
+    // Unreadable bytes are an unknown edit state, so a real file is kept and
+    // reported. A dangling symlink holds no bytes to lose and may still go.
+    try {
+        return !fs.lstatSync(target).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/** Parse a tool entry's `digests` map; a malformed record contributes nothing. */
+function digests_of_entry(e) {
+    const out = new Map();
+    const raw = e["digests"];
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return out;
+    for (const [rel, rec] of Object.entries(raw)) {
+        if (typeof rec !== "object" || rec === null || Array.isArray(rec))
+            continue;
+        const r = rec;
+        const installed = r["installed_sha256"];
+        const packaged = r["packaged_sha256"];
+        if (typeof installed !== "string" || installed === "")
+            continue;
+        out.set(rel, {
+            installed_sha256: installed,
+            packaged_sha256: typeof packaged === "string" && packaged !== "" ? packaged : null,
+            ...(r["kind"] === "sidecar" ? { kind: "sidecar" } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * The ledger records of `tool_id`, keyed anchor-relative. Empty under the same
+ * "not provably ours anymore" conditions as {@link recorded_rel_files} (no
+ * entry, moved anchor, malformed entry), and empty for a schema-1 entry.
+ */
+export function recorded_digests(tool_id, anchor, inventory) {
+    const inv = inventory ?? load_inventory();
+    const tools = inv["tools"] ?? {};
+    const entry = tools[tool_id];
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+        return new Map();
+    const e = entry;
+    const recorded_anchor = e["anchor"];
+    if (typeof recorded_anchor !== "string")
+        return new Map();
+    if (resolve_path(expanduser(recorded_anchor)) !== resolve_path(expanduser(anchor))) {
+        return new Map();
+    }
+    return digests_of_entry(e);
+}
+/**
+ * Every recorded INSTALLED digest across all tools, keyed by absolute path in
+ * both spellings — the lookup the install conflict tracker needs, emitted in
+ * both spellings for the reason {@link recorded_absolute_files} gives.
+ */
+export function recorded_absolute_digests(inventory, home) {
+    const inv = inventory ?? load_inventory();
+    const tools = inv["tools"] ?? {};
+    const out = new Map();
+    if (typeof tools !== "object" || tools === null || Array.isArray(tools))
+        return out;
+    for (const entry of Object.values(tools)) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            continue;
+        const e = entry;
+        const anchor = e["anchor"];
+        if (typeof anchor !== "string")
+            continue;
+        const expanded = expanduser_at(anchor, home);
+        for (const [rel, rec] of digests_of_entry(e)) {
+            const lexical = path.resolve(expanded, rel);
+            out.set(lexical, rec.installed_sha256);
+            out.set(resolve_path(lexical), rec.installed_sha256);
+        }
+    }
+    return out;
+}
 // --- helpers ---------------------------------------------------------------
 /** Prune now-empty directories up to (exclusive) the anchor. */
 function prune_empty_dirs(prune_candidates, anchor_resolved) {

package/dist/scripts/_lib/guidelines_lane.js

@@ -118,7 +118,8 @@ export function rewriteProjectedBodyLinks(body, prefix) {
     return body
         .replace(BODY_DOCS_RE, (_m, t) => prefix + t.replace(/^docs\/guidelines\//, 'guidelines/'))
         .replace(BODY_SRC_FLAT_RE, (_m, t) => prefix + t)
-        .replace(BODY_SRC_AGENT_RE, (_m, t) => prefix + t);
+        .replace(BODY_SRC_AGENT_RE, (_m, t) => prefix + t)
+        .replace(LINK_AGENT_SRC_RE, (_m, t) => '](' + prefix + t);
 }
 /**
  * `docs/guidelines/` is projected and loses its `docs/` segment;
@@ -155,4 +156,12 @@ const BODY_DOCS_RE = /(?:\.\.\/)+(docs\/(?:guidelines|contracts)\/[^)\s]+\.md)/g
  */
 const BODY_SRC_FLAT_RE = /(?:\.\.\/)+src\/((?:rules|skills)\/[^)\s]+\.md)/g;
 const BODY_SRC_AGENT_RE = /(?:\.\.\/)+src\/agent-src\/((?:commands|contexts|personas|user-types|templates|scripts)\/[^)\s]+\.md)/g;
+/**
+ * A link written from inside `src/` that climbs to `src/agent-src/` without
+ * naming `src/` — `](../../agent-src/contexts/x.md)` from `src/skills/<slug>/`.
+ * It resolves in the source tree and to nothing in the projection, where the
+ * `agent-src/` segment does not exist. Anchored on `](` so only a link target
+ * moves, never a path mentioned in prose or an inline code span.
+ */
+const LINK_AGENT_SRC_RE = /\]\((?:\.\.\/)+agent-src\/((?:commands|contexts|personas|user-types|templates|scripts)\/[^)\s]*)/g;
 //# sourceMappingURL=guidelines_lane.js.map

package/dist/scripts/_lib/identifier_redaction.js

@@ -0,0 +1,24 @@
+/**
+ * Class-tag redaction of identifiers for stores that keep text (knowledge
+ * ingestion, cross-repo retrieval).
+ *
+ * Detection is the rule table's identifier rows, read recall-first: a store
+ * that persists text has no reviewer after it, so a missed value is the costly
+ * error and a context word is not required here. The rows' checksums still
+ * hold — a number that fails Luhn is not a card, a string that fails mod-97 is
+ * not an IBAN. The tag spelling and the counter keys are this consumer's.
+ */
+import { detect, IDENTIFIER_RULES, replaceSpans } from './egress_rules.js';
+/** The identifier rows with every context requirement dropped. */
+export const STORAGE_IDENTIFIER_RULES = IDENTIFIER_RULES.map(({ context: _context, ...rest }) => rest);
+/** Counter key and tag per placeholder type; `CC` predates the table's `CARD`. */
+const TAG = { CARD: 'CC' };
+export function redactIdentifiers(text, counters) {
+    const spans = detect(text, STORAGE_IDENTIFIER_RULES);
+    return replaceSpans(text, spans, (s) => {
+        const tag = TAG[s.type] ?? s.type;
+        counters[tag] = (counters[tag] ?? 0) + 1;
+        return `[${tag}]`;
+    });
+}
+//# sourceMappingURL=identifier_redaction.js.map

package/dist/scripts/_lib/installed_layer.js

@@ -48,6 +48,7 @@ import { NO_RECORDED_HASHES, readRecordedHashes } from '../../install/recordedOw
 import { INVENTORY_BASENAME, inventory_path, load_inventory, recorded_absolute_files, } from './global_deploy_inventory.js';
 import { DEFAULT_EVENT4U_ROOT_RELATIVE } from './user_global_paths.js';
 import { ruleBody, splitFrontmatter } from './rule_law_section.js';
+import { normaliseLayerText } from './installed_layer_normalise.js';
 /** How many files the per-directory ranking carries. Step 0.1 fixes it at 20. */
 export const TOP_FILES = 20;
 /**
@@ -155,6 +156,7 @@ export function readLayer(host, scope, dir, recorded) {
         files: 0,
         unconditional: 0,
         chars: 0,
+        normalised_chars: 0,
         package_owned: 0,
         foreign: 0,
         package_owned_chars: 0,
@@ -197,6 +199,10 @@ export function readLayer(host, scope, dir, recorded) {
             // a host loads" and "what a delivery carries" cannot drift into two
             // spellings of the same measurement.
             chars: ruleBody(text).length,
+            // THE SAME STRING, MEASURED TWICE. `chars` is what the host loads;
+            // this is that text with every absolute path substituted, so two
+            // machines with different package roots read one figure in common.
+            normalised_chars: normaliseLayerText(ruleBody(text)).length,
             unconditional: isUnconditional(text),
             package_owned: owned,
         });
@@ -216,6 +222,7 @@ export function readLayer(host, scope, dir, recorded) {
         files: readings.length,
         unconditional: readings.filter((r) => r.unconditional).length,
         chars: readings.reduce((n, r) => n + r.chars, 0),
+        normalised_chars: readings.reduce((n, r) => n + r.normalised_chars, 0),
         package_owned: readings.filter((r) => r.package_owned).length,
         foreign: readings.filter((r) => !r.package_owned).length,
         package_owned_chars: readings.reduce((n, r) => n + (r.package_owned ? r.chars : 0), 0),
@@ -587,6 +594,7 @@ export function buildInstalledLayerReport(opts) {
         files: acc.files + l.files,
         unconditional: acc.unconditional + l.unconditional,
         chars: acc.chars + l.chars,
+        normalised_chars: acc.normalised_chars + l.normalised_chars,
         package_owned: acc.package_owned + l.package_owned,
         foreign: acc.foreign + l.foreign,
         package_owned_chars: acc.package_owned_chars + l.package_owned_chars,
@@ -597,6 +605,7 @@ export function buildInstalledLayerReport(opts) {
         files: 0,
         unconditional: 0,
         chars: 0,
+        normalised_chars: 0,
         package_owned: 0,
         foreign: 0,
         package_owned_chars: 0,
@@ -667,6 +676,14 @@ export function renderInstalledLayerReport(report) {
         `${String(t.chars)} chars ` +
         `(${String(t.unconditional_chars)} standing + ${String(t.scoped_chars)} path-scoped), ` +
         `${String(t.package_owned)} package-owned / ${String(t.foreign)} foreign`);
+    // THE COMPARABLE FIGURE, ON ITS OWN LINE AND LABELLED AS WHAT IT IS. The
+    // TOTAL above is what the host loads on THIS machine and moves with the
+    // package root; this one does not, and is therefore the only one two runs
+    // may be compared in. Printing them adjacent is deliberate — a reader who
+    // sees one number cannot tell which question it answers.
+    out.push(`  TOTAL (normalised) — ${String(t.normalised_chars)} chars, ` +
+        'every absolute path substituted; comparable across machines and revisions, ' +
+        'NOT what the host loads');
     out.push(...renderHostLimitRows(report.limits));
     return out;
 }

package/dist/scripts/_lib/installed_layer_normalise.js

@@ -0,0 +1,72 @@
+/**
+ * Make the installed-layer character measurement independent of where the
+ * package happens to live on the machine that measured it.
+ *
+ * WHY THIS EXISTS, AND WHY IT IS NOT A CEILING. D7 of
+ * `road-to-an-installed-layer-that-is-thinned` records that a ceiling over the
+ * installed layer "may not rest on a STORED baseline, in any shape, until the
+ * measurement is environment-independent", and names two acceptable forms: a
+ * normalised total, or a base-ref comparison that stores nothing. This module
+ * is the first form and nothing more — it changes what the report CAN be read
+ * against and introduces no gate, no threshold and no stored number. The
+ * ratchet the council returned REQUEST_CHANGES on (2026-10-12, one seat
+ * present) was a stored baseline over an UN-normalised figure; that mechanism
+ * is untouched here and stays rejected.
+ *
+ * THE DEFECT, CONCRETELY. Every thinned stub the installer writes ends in an
+ * absolute body pointer built by `absoluteBodyLinkPrefix`, so the layer's
+ * character total moves by one character per stub for every character of
+ * package-root prefix — 89 characters per character on the real corpus. A
+ * number that moves with the runner's directory name measures the runner as
+ * much as the corpus, which is why `estate-count-budget.json` was deleted from
+ * this repository.
+ *
+ * SUBSTITUTED, NOT STRIPPED. Every absolute path becomes a fixed-width token
+ * rather than vanishing, so the figure still accounts for the fact that a
+ * pointer is there. Stripping would make a stub with a pointer and a stub
+ * without one read alike, which is a different measurement than the one a
+ * ceiling wants.
+ *
+ * THE NORMALISED FIGURE IS NOT "WHAT THE HOST LOADS". The host loads the real
+ * text, absolute path and all, and {@link
+ * import('./installed_layer.js').LayerReading.chars} stays the figure for that
+ * question. This one answers "is the corpus growing", which is the only
+ * question a comparison across two machines or two revisions can honestly ask.
+ */
+/**
+ * What every absolute path is replaced with.
+ *
+ * Fixed width by construction — it contains no path separator, which is also
+ * what makes {@link normaliseLayerText} idempotent.
+ */
+export const ABSOLUTE_PATH_TOKEN = '<abs>';
+/**
+ * A POSIX absolute path: two or more `/`-led segments.
+ *
+ * TWO, NOT ONE. A single segment admits ordinary prose — `and/or`, a bare
+ * `/rules` in a sentence — and a one-segment path cannot carry a root prefix
+ * long enough to be the drift this module is about.
+ *
+ * The lookbehind refuses a start that is already inside something: a word
+ * character (so `and/or` is prose), another separator (so the `//` of a URL
+ * authority is not entered), and `:` (so a scheme is not split).
+ */
+const POSIX_ABSOLUTE = /(?<![A-Za-z0-9._~%@+:/\\-])(?:\/[A-Za-z0-9._@+~-]+){2,}/g;
+/**
+ * A Windows drive path. The installer runs there too, and its pointer carries
+ * the same drift with `\` for `/`.
+ */
+const WINDOWS_ABSOLUTE = /(?<![A-Za-z0-9._~%@+:/\\-])[A-Za-z]:(?:[\\/][A-Za-z0-9._@+~-]+)+/g;
+/**
+ * Substitute every absolute-path occurrence in one rule's loaded text.
+ *
+ * Pure, total and idempotent: the token contains no separator, so a second
+ * pass finds nothing left to replace. Callers measure `.length` of the result;
+ * they never ship it as text a host reads.
+ */
+export function normaliseLayerText(text) {
+    return text
+        .replace(WINDOWS_ABSOLUTE, ABSOLUTE_PATH_TOKEN)
+        .replace(POSIX_ABSOLUTE, ABSOLUTE_PATH_TOKEN);
+}
+//# sourceMappingURL=installed_layer_normalise.js.map