akm-cli 0.8.0-rc2 → 0.8.1

package/dist/indexer/memory-inference.js

@@ -1,42 +1,15 @@
-/**
- * Memory inference pass for `akm index` (#201).
- *
- * Detects memories pending inference, asks the configured LLM to compress each
- * into one higher-signal derived memory, and writes the result back as a new
- * memory file with frontmatter `inferred: true` + a `source:` backref to the
- * parent memory.
- *
- * Pending predicate (see {@link isPendingMemory}):
- *   - File lives under `<stashRoot>/memories/` and ends in `.md`.
- *   - Frontmatter does NOT have `inferenceProcessed: true` (parent already split).
- *   - Frontmatter does NOT have `inferred: true` (this is itself a child fact).
- *
- * Idempotency: after a successful split the parent's frontmatter is rewritten
- * with `inferenceProcessed: true`. A subsequent `akm index` therefore skips
- * the parent without re-running the LLM.
- *
- * Disabling — two orthogonal gates per v1 spec §14:
- *   1. `llm.features.memory_inference = false` blocks the pass at the
- *      locked feature-flag layer (no network call may ever issue).
- *   2. `index.memory.llm = false` (or no `akm.llm` block at all) opts the
- *      pass out at the per-pass layer (#208).
- *   A pass runs iff both layers allow it. Existing inferred children are
- *   NEVER deleted — the user keeps what was already produced.
- *
- * Locked v1 contract:
- *   - LLM access is exclusively via `resolveIndexPassLLM("memory", config)`.
- *   - All child memory writes go through `writeAssetToSource` in
- *     `src/core/write-source.ts`. The parent's frontmatter rewrite is an
- *     explicit narrow exception — see {@link markParentProcessed}.
- */
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
-import { stringify as yamlStringify } from "yaml";
 import { parseAssetRef } from "../core/asset-ref";
+import { assembleAsset } from "../core/asset-serialize";
 import { concurrentMap } from "../core/concurrent";
 import { parseFrontmatter, parseFrontmatterBlock } from "../core/frontmatter";
 import { warn } from "../core/warn";
 import { writeAssetToSource } from "../core/write-source";
+import { isProcessEnabled } from "../llm/feature-gate";
 import { resolveIndexPassLLM } from "../llm/index-passes";
 import * as memoryInfer from "../llm/memory-infer";
 import { withLlmCache } from "./llm-cache";
@@ -48,14 +21,15 @@ import { walkMarkdownFiles } from "./walker";
 const FM_INFERRED = "inferred";
 const FM_INFERENCE_PROCESSED = "inferenceProcessed";
 const FM_SOURCE = "source";
+const FM_CAPTURE_MODE = "captureMode";
 /**
  * Top-level entry point. Returns a no-op result when the pass is disabled.
  *
- * Two orthogonal gates per v1 spec §14:
+ * Two orthogonal gates:
  *
- *   1. **Feature gate** — `llm.features.memory_inference` (defaults to
- *      `true`). When `false`, no network call may issue regardless of
- *      per-pass settings. This is the locked spec-§14 gate.
+ *   1. **Feature gate** — `profiles.improve.default.processes.memoryInference.enabled`
+ *      (defaults to `true`). When `false`, no network call may issue regardless
+ *      of per-pass settings.
  *   2. **Per-pass gate** — `resolveIndexPassLLM("memory", config)` (which
  *      reads `index.memory.llm`). When `false`, the indexer simply skips
  *      this pass for the current run.
@@ -66,13 +40,18 @@ const FM_SOURCE = "source";
 export async function runMemoryInferencePass(config, sources, signal, db, reEnrich, onProgress, options = {}) {
     const result = {
         considered: 0,
+        cacheHits: 0,
         splitParents: 0,
         writtenFacts: 0,
         skippedNoFacts: 0,
+        skippedChildExists: 0,
+        skippedAborted: 0,
+        unaccounted: 0,
     };
-    // Gate 1 — locked feature flag (§14). Defaults to enabled; only an
-    // explicit `false` disables the pass entirely.
-    if (config.llm?.features?.memory_inference === false)
+    // Gate 1 — feature gate via isProcessEnabled, which reads the 0.8.0 path
+    // (profiles.improve.default.processes.memoryInference.enabled). Defaults to
+    // enabled when the key is absent.
+    if (!isProcessEnabled("index", "memory_inference", config))
         return result;
     // Gate 2 — per-pass opt-out (#208). Returns the resolved llm config or
     // `undefined` when the pass should not run.
@@ -93,8 +72,13 @@ export async function runMemoryInferencePass(config, sources, signal, db, reEnri
     const total = pending.length;
     onProgress?.({ processed, total, writtenFacts: 0, skippedNoFacts: 0 });
     const perRecordResults = await concurrentMap(pending, async (record) => {
+        // Aborted BEFORE a fresh LLM call. Returned as a typed outcome so the
+        // for-loop below increments `skippedAborted` instead of silently
+        // dropping the record (which historically inflated freshAttempts and
+        // dragged the health-reported yield rate down — see investigation
+        // 2026-05-26).
         if (signal?.aborted)
-            return undefined;
+            return { aborted: true };
         // Incremental cache: skip LLM call when body hash is unchanged and
         // --re-enrich was not requested. The cache ref is the absolute file path.
         const validate = (raw) => {
@@ -113,22 +97,37 @@ export async function runMemoryInferencePass(config, sources, signal, db, reEnri
             }
             return undefined;
         };
+        // Track whether THIS candidate's result came from the body-hash
+        // cache vs. a fresh LLM call. The cache short-circuits when the
+        // parent body has not changed since a prior derived write — surfacing
+        // the hit count separately so the operational yield rate
+        // (writtenFacts / freshAttempts) is interpretable as the cache warms.
+        let fromCache = false;
         const derived = db
             ? await withLlmCache(db, record.filePath, record.body, reEnrich ?? false, () => memoryInfer.compressMemoryToDerivedMemory(llmConfig, record.body, signal, config, (evt) => {
                 warn(`[akm] LLM fallback for ${evt.feature}: ${evt.reason}`);
-            }), validate)
+            }), validate, undefined, "", {
+                onCacheHit: () => {
+                    fromCache = true;
+                },
+            })
             : await memoryInfer.compressMemoryToDerivedMemory(llmConfig, record.body, signal, config, (evt) => {
                 warn(`[akm] LLM fallback for ${evt.feature}: ${evt.reason}`);
             });
         if (!derived) {
-            return { skipped: true };
+            return { skipped: true, fromCache };
         }
         const written = await writeDerivedMemory(record, derived);
         if (written > 0) {
             markParentProcessed(record);
-            return { skipped: false, splitParent: true, written };
+            return { skipped: false, splitParent: true, written, fromCache };
         }
-        return { skipped: false, splitParent: false, written: 0 };
+        // LLM produced a valid derived draft but no file was written — either
+        // because `<parent>.derived.md` already exists on disk or
+        // `writeAssetToSource` threw. Categorise as `childExists` so the
+        // attempt is accounted for in health metrics rather than vanishing
+        // into the freshAttempts denominator.
+        return { skipped: false, splitParent: false, written: 0, fromCache, childExists: true };
     }, 
     // Default concurrency of 4 for cloud APIs. Set `llm.concurrency: 1`
     // in config.json for local model servers (LM Studio, Ollama).
@@ -137,6 +136,21 @@ export async function runMemoryInferencePass(config, sources, signal, db, reEnri
         const res = perRecordResults[i];
         if (!res)
             continue;
+        if ("aborted" in res && res.aborted) {
+            result.skippedAborted += 1;
+            processed++;
+            onProgress?.({
+                processed,
+                total,
+                writtenFacts: result.writtenFacts,
+                skippedNoFacts: result.skippedNoFacts,
+                currentRef: pending[i]?.ref,
+            });
+            continue;
+        }
+        if (res.fromCache) {
+            result.cacheHits += 1;
+        }
         if (res.skipped) {
             result.skippedNoFacts += 1;
             // Intentionally NOT marked processed — a transient LLM failure should
@@ -146,6 +160,20 @@ export async function runMemoryInferencePass(config, sources, signal, db, reEnri
             result.splitParents += 1;
             result.writtenFacts += res.written;
         }
+        else if ("childExists" in res && res.childExists) {
+            // LLM call was consumed but the derived file already existed (or the
+            // write threw). Track separately so this category is observable in
+            // health output and stops bleeding into the freshAttempts denominator.
+            result.skippedChildExists += 1;
+            warn(`memory inference: derived child for ${pending[i]?.ref ?? "<unknown>"} already existed or write failed; counted as skippedChildExists`);
+        }
+        else {
+            // The per-record state machine should cover every outcome. A hit here
+            // means a new code path slipped past the categorisation — surface it
+            // loudly so health metrics stay honest and we get a signal to fix.
+            result.unaccounted += 1;
+            warn(`memory inference: unaccounted per-record outcome for ${pending[i]?.ref ?? "<unknown>"}`);
+        }
         processed++;
         onProgress?.({
             processed,
@@ -177,7 +205,7 @@ export function collectPendingMemories(stashRoot) {
             continue;
         }
         const parsed = parseFrontmatter(raw);
-        if (!isPendingMemory(parsed.data))
+        if (!isPendingMemory(parsed.data, filePath))
             continue;
         const relName = toMemoryName(memoriesDir, filePath);
         if (!relName)
@@ -197,10 +225,27 @@ export function collectPendingMemories(stashRoot) {
  * Predicate: true when the parsed frontmatter indicates the memory has not
  * yet been split AND is not itself an inferred child.
  *
+ * Also guards against `.derived` files whose `inferred:` frontmatter key has
+ * been dropped by a manual edit or schema-repair rewrite. The file name suffix
+ * is structural and immutable; frontmatter flags are mutable. A file whose
+ * path contains `.derived` is always treated as a derived child regardless of
+ * its frontmatter state — this prevents `<name>.derived.derived.md` chains.
+ *
+ * @param frontmatter - Parsed YAML frontmatter from the memory file.
+ * @param filePath    - Optional absolute path to the memory file. When
+ *                      supplied, the name-based guard is applied.
+ *
  * Exported for direct unit testing — keeping the predicate in one place
  * avoids drift between the walker, tests, and any future consumers.
  */
-export function isPendingMemory(frontmatter) {
+export function isPendingMemory(frontmatter, filePath) {
+    // Name-based guard: a `.derived` suffix in the path means this file is a
+    // derived child regardless of what its frontmatter currently says.
+    if (filePath !== undefined) {
+        const base = path.basename(filePath, ".md");
+        if (base.endsWith(".derived"))
+            return false;
+    }
     if (frontmatter[FM_INFERRED] === true)
         return false;
     if (frontmatter[FM_INFERENCE_PROCESSED] === true)
@@ -248,6 +293,7 @@ async function writeDerivedMemory(parent, derived) {
 function renderDerivedMemory(parent, derived) {
     const fm = {
         [FM_INFERRED]: true,
+        [FM_CAPTURE_MODE]: "background",
         [FM_SOURCE]: parent.ref,
         description: derived.description,
         tags: derived.tags,
@@ -255,8 +301,7 @@ function renderDerivedMemory(parent, derived) {
         title: derived.title,
         derivedFrom: parent.name,
     };
-    const yaml = yamlStringify(fm).trimEnd();
-    return `---\n${yaml}\n---\n\n# ${derived.title.trim()}\n\n${derived.content.trim()}\n`;
+    return assembleAsset(fm, `# ${derived.title.trim()}\n\n${derived.content.trim()}\n`);
 }
 function markParentProcessed(parent) {
     // Frontmatter-only rewrite of an existing asset: not a new asset write,
@@ -273,10 +318,9 @@ function markParentProcessed(parent) {
         return;
     }
     const updatedFm = { ...parent.data, [FM_INFERENCE_PROCESSED]: true };
-    const yaml = yamlStringify(updatedFm).trimEnd();
     const block = parseFrontmatterBlock(raw);
     const body = block?.content ?? raw;
-    const next = `---\n${yaml}\n---\n${body.startsWith("\n") ? "" : "\n"}${body}`;
+    const next = assembleAsset(updatedFm, body);
     try {
         fs.writeFileSync(parent.filePath, next, "utf8");
     }

package/dist/indexer/metadata-contributors.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 const contributors = [];
 let builtinsPromise;
 async function ensureBuiltinMetadataContributorsRegistered() {

package/dist/indexer/metadata.js

@@ -1,8 +1,11 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
 import { deriveCanonicalAssetName, deriveCanonicalAssetNameFromStashRoot, isRelevantAssetFile, } from "../core/asset-spec";
-import { isAssetType, writeFileAtomic } from "../core/common";
-import { parseFrontmatter, toStringOrUndefined } from "../core/frontmatter";
+import { asNonEmptyString, isAssetType, writeFileAtomic } from "../core/common";
+import { parseFrontmatter } from "../core/frontmatter";
 import { isVerbose, warn } from "../core/warn";
 import { buildFileContext, buildRenderContext, getRenderer, runMatchers } from "./file-context";
 import { applyMetadataContributors } from "./metadata-contributors";
@@ -173,43 +176,38 @@ export function validateStashEntry(entry) {
     if (typeof e.pageKind === "string" && e.pageKind.trim().length > 0) {
         result.pageKind = e.pageKind.trim();
     }
-    if (Array.isArray(e.xrefs)) {
-        const filtered = e.xrefs
-            .filter((x) => typeof x === "string" && x.trim().length > 0)
-            .map((x) => x.trim());
-        if (filtered.length > 0)
-            result.xrefs = filtered;
-    }
-    if (Array.isArray(e.sources)) {
-        const filtered = e.sources
-            .filter((s) => typeof s === "string" && s.trim().length > 0)
-            .map((s) => s.trim());
-        if (filtered.length > 0)
-            result.sources = filtered;
-    }
+    const xrefs = normalizeNonEmptyStringList(e.xrefs);
+    if (xrefs)
+        result.xrefs = xrefs;
+    const sources = normalizeNonEmptyStringList(e.sources);
+    if (sources)
+        result.sources = sources;
     if (typeof e.beliefState === "string" && e.beliefState.trim().length > 0) {
         result.beliefState = e.beliefState.trim();
     }
-    if (Array.isArray(e.supersededBy)) {
-        const filtered = e.supersededBy
-            .filter((s) => typeof s === "string" && s.trim().length > 0)
-            .map((s) => s.trim());
-        if (filtered.length > 0)
-            result.supersededBy = filtered;
+    const supersededBy = normalizeNonEmptyStringList(e.supersededBy);
+    if (supersededBy)
+        result.supersededBy = supersededBy;
+    const contradictedBy = normalizeNonEmptyStringList(e.contradictedBy);
+    if (contradictedBy)
+        result.contradictedBy = contradictedBy;
+    const currentBeliefRefs = normalizeNonEmptyStringList(e.currentBeliefRefs);
+    if (currentBeliefRefs)
+        result.currentBeliefRefs = currentBeliefRefs;
+    if (e.captureMode === "hot" || e.captureMode === "background") {
+        result.captureMode = e.captureMode;
     }
-    if (Array.isArray(e.contradictedBy)) {
-        const filtered = e.contradictedBy
-            .filter((s) => typeof s === "string" && s.trim().length > 0)
-            .map((s) => s.trim());
-        if (filtered.length > 0)
-            result.contradictedBy = filtered;
+    if (typeof e.whenToUse === "string" && e.whenToUse.trim().length > 0) {
+        result.whenToUse = e.whenToUse.trim();
     }
-    if (Array.isArray(e.currentBeliefRefs)) {
-        const filtered = e.currentBeliefRefs
-            .filter((s) => typeof s === "string" && s.trim().length > 0)
-            .map((s) => s.trim());
-        if (filtered.length > 0)
-            result.currentBeliefRefs = filtered;
+    if (typeof e.lessonStrength === "number" && Number.isFinite(e.lessonStrength) && e.lessonStrength >= 0) {
+        result.lessonStrength = Math.floor(e.lessonStrength);
+    }
+    const evidenceSources = normalizeNonEmptyStringList(e.evidenceSources);
+    if (evidenceSources)
+        result.evidenceSources = evidenceSources;
+    if (typeof e.derivedFrom === "string" && e.derivedFrom.trim().length > 0) {
+        result.derivedFrom = e.derivedFrom.trim();
     }
     if (typeof e.scope === "object" && e.scope !== null && !Array.isArray(e.scope)) {
         const scope = normalizeScopeObject(e.scope);
@@ -287,9 +285,9 @@ function normalizeIntent(value) {
         return undefined;
     const raw = value;
     const intent = {};
-    const when = toStringOrUndefined(raw.when);
-    const input = toStringOrUndefined(raw.input);
-    const output = toStringOrUndefined(raw.output);
+    const when = asNonEmptyString(raw.when);
+    const input = asNonEmptyString(raw.input);
+    const output = asNonEmptyString(raw.output);
     if (when)
         intent.when = when;
     if (input)
@@ -302,7 +300,7 @@ function normalizeStringListOrUndefined(value) {
     return normalizeNonEmptyStringList(value);
 }
 export function applyCuratedFrontmatter(entry, fmData) {
-    const description = toStringOrUndefined(fmData.description);
+    const description = asNonEmptyString(fmData.description);
     if (description) {
         entry.description = description;
         entry.source = "frontmatter";
@@ -323,19 +321,19 @@ export function applyCuratedFrontmatter(entry, fmData) {
     const examples = normalizeStringListOrUndefined(fmData.examples);
     if (examples)
         entry.examples = examples;
-    const run = toStringOrUndefined(fmData.run);
+    const run = asNonEmptyString(fmData.run);
     if (run)
         entry.run = run;
-    const setup = toStringOrUndefined(fmData.setup);
+    const setup = asNonEmptyString(fmData.setup);
     if (setup)
         entry.setup = setup;
-    const cwd = toStringOrUndefined(fmData.cwd);
+    const cwd = asNonEmptyString(fmData.cwd);
     if (cwd)
         entry.cwd = cwd;
-    const quality = toStringOrUndefined(fmData.quality);
+    const quality = asNonEmptyString(fmData.quality);
     if (quality)
         entry.quality = normalizeQuality(quality);
-    const beliefState = toStringOrUndefined(fmData.beliefState);
+    const beliefState = asNonEmptyString(fmData.beliefState);
     if (beliefState)
         entry.beliefState = beliefState;
     const supersededBy = normalizeStringListOrUndefined(fmData.supersededBy);
@@ -347,6 +345,48 @@ export function applyCuratedFrontmatter(entry, fmData) {
     const currentBeliefRefs = normalizeStringListOrUndefined(fmData.currentBeliefRefs);
     if (currentBeliefRefs)
         entry.currentBeliefRefs = currentBeliefRefs;
+    // captureMode: "hot" | "background" — strict whitelist; unknown values are ignored.
+    if (fmData.captureMode === "hot" || fmData.captureMode === "background") {
+        entry.captureMode = fmData.captureMode;
+    }
+    // when_to_use → whenToUse — free-form guidance for retrieval/intent matching.
+    const whenToUse = asNonEmptyString(fmData.when_to_use);
+    if (whenToUse)
+        entry.whenToUse = whenToUse;
+    // lessonStrength: array → length, number → direct. Negative numbers clamp to 0.
+    if (Array.isArray(fmData.lessonStrength)) {
+        entry.lessonStrength = fmData.lessonStrength.length;
+    }
+    else if (typeof fmData.lessonStrength === "number" && Number.isFinite(fmData.lessonStrength)) {
+        entry.lessonStrength = Math.max(0, Math.floor(fmData.lessonStrength));
+    }
+    const evidenceSources = normalizeStringListOrUndefined(fmData.evidenceSources);
+    if (evidenceSources)
+        entry.evidenceSources = evidenceSources;
+    // Phase 5A / Advantage D5: capture parent ref for derived memories.
+    // Memory-inference writes `source: "memory:<parent>"` and `inferred: true`
+    // (and a derived child name suffix `.derived`). We mirror that source ref
+    // into `entry.derivedFrom` so the indexer can populate the dedicated
+    // `derived_from` column. Non-derived entries leave this field unset.
+    if (entry.type === "memory") {
+        const isDerivedByName = entry.name.toLowerCase().endsWith(".derived");
+        const isDerivedByFm = fmData.inferred === true;
+        if (isDerivedByName || isDerivedByFm) {
+            const sourceStr = asNonEmptyString(fmData.source);
+            if (sourceStr?.includes(":")) {
+                entry.derivedFrom = sourceStr;
+            }
+            else {
+                // Fallback: some legacy renderings store only `derivedFrom: <name>`
+                // (a bare parent name). Promote it to a `memory:` ref so the lookup
+                // column stays consistent.
+                const derivedFromName = asNonEmptyString(fmData.derivedFrom);
+                if (derivedFromName) {
+                    entry.derivedFrom = derivedFromName.includes(":") ? derivedFromName : `memory:${derivedFromName}`;
+                }
+            }
+        }
+    }
     const intent = normalizeIntent(fmData.intent);
     if (intent)
         entry.intent = intent;
@@ -440,12 +480,29 @@ export function shouldIndexStashFile(stashRoot, file, options) {
     const segments = relPath.split(/[\\/]+/).filter(Boolean);
     if (segments.length === 0)
         return true;
-    // Skip vault .env files that have a sibling .sensitive marker file.
-    if (segments[0] === "vaults" && (file.endsWith(".env") || path.basename(file) === ".env")) {
+    // Skip env / vault .env files that have a sibling .sensitive marker file.
+    if ((segments[0] === "env" || segments[0] === "vaults") &&
+        (file.endsWith(".env") || path.basename(file) === ".env")) {
         const markerPath = file.replace(/\.env$/, ".sensitive");
         if (fs.existsSync(markerPath))
             return false;
     }
+    // Deprecation: once a stash has migrated to the `env/` directory, the legacy
+    // `vaults/` copy is frozen. Skip indexing it so the same keys are not
+    // double-surfaced under both `vault:` and `env:`. (Pre-migration stashes
+    // with no `env/` dir still index `vaults/` normally.)
+    if (segments[0] === "vaults" && fs.existsSync(path.join(stashRoot, "env"))) {
+        return false;
+    }
+    // Skip secret files that are themselves a `.sensitive` marker, or that have a
+    // sibling `<name>.sensitive` marker. Secrets are otherwise indexed by name
+    // only (their bytes are never read — see buildEntryFromFile guards).
+    if (segments[0] === "secrets") {
+        if (file.endsWith(".sensitive") || file.endsWith(".lock"))
+            return false;
+        if (fs.existsSync(`${file}.sensitive`))
+            return false;
+    }
     if (options?.treatStashRootAsWikiRoot) {
         return !(segments.length === 1 && WIKI_INFRA_FILES.has(segments[0]));
     }
@@ -775,7 +832,9 @@ async function buildEntryFromFile(file, assetType, canonicalName, dirPath, pkgMe
             entry.tags = normalizeTerms(pkgMeta.keywords);
     }
     // Priority 2: Frontmatter (for .md files -- overrides package.json description)
-    if (ext === ".md") {
+    // Secrets are excluded even when the file happens to be `.md`: the whole file
+    // is the secret value and must never be read for frontmatter or any metadata.
+    if (ext === ".md" && assetType !== "secret") {
         const content = ctx.content();
         const parsed = parseFrontmatter(content);
         applyCuratedFrontmatter(entry, parsed.data);
@@ -794,10 +853,11 @@ async function buildEntryFromFile(file, assetType, canonicalName, dirPath, pkgMe
         }
     }
     // Extract @param from script files.
-    // Vault files (.env) are deliberately excluded — their contents are secrets
-    // and must never be parsed for @param or any other metadata that could
-    // embed a value into the entry.
-    if (ext !== ".md" && assetType !== "vault") {
+    // Env / vault files (.env) and secret files (whole-file secrets) are
+    // deliberately excluded — their contents are secrets and must never be
+    // parsed for @param or any other metadata that could embed a value into the
+    // entry.
+    if (ext !== ".md" && assetType !== "env" && assetType !== "vault" && assetType !== "secret") {
         const content = ctx.content();
         const scriptParams = extractScriptParameters(file, content);
         if (scriptParams)

package/dist/indexer/path-resolver.js

@@ -1,3 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
 import { parseAssetRef } from "../core/asset-ref";