@skill-map/cli 0.64.1 → 0.66.0

package/dist/conformance/index.js

@@ -1,10 +1,10 @@
 // conformance/index.ts
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="cc85d6cc-8968-5fbd-b7b7-eab3d298263d")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bc1fc06c-0be1-5b35-9ac6-cedcc9367962")}catch(e){}}();
 import { spawnSync } from "child_process";
 import { cpSync, existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync } from "fs";
 import { tmpdir } from "os";
-import { isAbsolute, join as join2, relative, resolve } from "path";
+import { isAbsolute, join as join2, relative, resolve as resolve2 } from "path";
 
 // kernel/util/format-error.ts
 function formatErrorMessage(err) {
@@ -12,7 +12,7 @@ function formatErrorMessage(err) {
 }
 
 // kernel/util/skill-map-paths.ts
-import { join } from "path";
+import { dirname, join, resolve } from "path";
 var SKILL_MAP_DIR = ".skill-map";
 var KERNEL_SKILL_MAP_DIR = SKILL_MAP_DIR;
 
@@ -200,7 +200,7 @@ function assertContained(root, rel, label) {
       tx(CONFORMANCE_RUNNER_TEXTS.pathMustBeRelative, { label, path: rel, anchor: root })
     );
   }
-  const abs = resolve(root, rel);
+  const abs = resolve2(root, rel);
   const r = relative(root, abs);
   if (r.startsWith("..") || isAbsolute(r)) {
     throw new Error(
@@ -227,7 +227,7 @@ function evaluateAssertion(a, ctx) {
       } catch (err) {
         return { ok: false, type: a.type, reason: formatErrorMessage(err) };
       }
-      const abs = resolve(ctx.scope, a.path);
+      const abs = resolve2(ctx.scope, a.path);
       return existsSync(abs) ? { ok: true, type: a.type } : {
         ok: false,
         type: a.type,
@@ -242,7 +242,7 @@ function evaluateAssertion(a, ctx) {
         return { ok: false, type: a.type, reason: formatErrorMessage(err) };
       }
       const fixturePath = join2(ctx.fixturesRoot, a.fixture);
-      const targetPath = resolve(ctx.scope, a.path);
+      const targetPath = resolve2(ctx.scope, a.path);
       if (!existsSync(targetPath)) {
         return {
           ok: false,
@@ -413,4 +413,4 @@ export {
   runConformanceCase
 };
 //# sourceMappingURL=index.js.map
-//# debugId=cc85d6cc-8968-5fbd-b7b7-eab3d298263d
+//# debugId=bc1fc06c-0be1-5b35-9ac6-cedcc9367962

package/dist/index.js

@@ -1,6 +1,6 @@
 // kernel/i18n/registry.texts.ts
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e05c9678-1319-58b6-9a51-61818bac9305")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="27ef1dc5-0da7-5a76-9fa8-d447025bd0d4")}catch(e){}}();
 var REGISTRY_TEXTS = {
   duplicateExtension: "Extension already registered: {{kind}}:{{qualifiedId}}",
   unknownKind: "Unknown extension kind: {{kind}}",
@@ -102,7 +102,7 @@ import { Tiktoken as Tiktoken2 } from "js-tiktoken/lite";
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.64.1",
+  version: "0.66.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -2349,24 +2349,31 @@ async function* walkContent(roots, options) {
   const filter = options.ignoreFilter ?? buildIgnoreFilter();
   const extensions = options.extensions;
   const sizeLimit = buildSizeLimit(options);
+  const bodyField = options.bodyField;
   if (options.scopedPaths !== void 0) {
-    yield* walkScoped(roots, options.scopedPaths, extensions, sizeLimit, parser);
+    yield* walkScoped(roots, options.scopedPaths, extensions, sizeLimit, parser, bodyField);
     return;
   }
   for (const root of roots) {
     for await (const entry of walkRoot(root, root, filter, extensions, sizeLimit)) {
       const relPath = relative2(root, entry.full).split(sep).join("/");
-      const rec = await traversedEntryToNode(entry, relPath, options.priorMtimes, parser);
+      const rec = await traversedEntryToNode(
+        entry,
+        relPath,
+        options.priorMtimes,
+        parser,
+        bodyField
+      );
       if (rec !== null) yield rec;
     }
   }
 }
-async function traversedEntryToNode(entry, relPath, priorMtimes, parser) {
+async function traversedEntryToNode(entry, relPath, priorMtimes, parser, bodyField) {
   const priorMtime = priorMtimes?.get(relPath);
   if (priorMtime !== void 0 && priorMtime === entry.modifiedAtMs) {
-    return buildUnchangedRecord(entry.full, relPath, entry.modifiedAtMs, parser);
+    return buildUnchangedRecord(entry.full, relPath, entry.modifiedAtMs, parser, bodyField);
   }
-  const parsed = await readAndParse(entry.full, relPath, parser);
+  const parsed = await readAndParse(entry.full, relPath, parser, bodyField);
   if (parsed === null) return null;
   return {
     path: relPath,
@@ -2383,7 +2390,7 @@ async function traversedEntryToNode(entry, relPath, priorMtimes, parser) {
     ...parsed.parseIssues ? { parseIssues: parsed.parseIssues } : {}
   };
 }
-function buildUnchangedRecord(full, relPath, modifiedAtMs, parser) {
+function buildUnchangedRecord(full, relPath, modifiedAtMs, parser, bodyField) {
   return {
     path: relPath,
     body: "",
@@ -2392,26 +2399,26 @@ function buildUnchangedRecord(full, relPath, modifiedAtMs, parser) {
     modifiedAtMs,
     unchanged: true,
     reread: async () => {
-      const re = await readAndParse(full, relPath, parser);
+      const re = await readAndParse(full, relPath, parser, bodyField);
       return re ?? { body: "", frontmatterRaw: "", frontmatter: {} };
     }
   };
 }
-async function* walkScoped(roots, scopedPaths, extensions, sizeLimit, parser) {
+async function* walkScoped(roots, scopedPaths, extensions, sizeLimit, parser, bodyField) {
   const absRoots = roots.map((r) => isAbsolute2(r) ? r : resolve7(r));
   for (const scoped of scopedPaths) {
-    const rec = await scopedPathToNode(scoped, absRoots, extensions, sizeLimit, parser);
+    const rec = await scopedPathToNode(scoped, absRoots, extensions, sizeLimit, parser, bodyField);
     if (rec !== null) yield rec;
   }
 }
-async function scopedPathToNode(scoped, absRoots, extensions, sizeLimit, parser) {
+async function scopedPathToNode(scoped, absRoots, extensions, sizeLimit, parser, bodyField) {
   const full = isAbsolute2(scoped) ? scoped : resolve7(scoped);
   const relPath = relativeFromRoots(full, absRoots);
   if (relPath === null) return null;
   if (!hasMatchingExtension(full, extensions)) return null;
   const s = await statRegularFile(full, relPath, sizeLimit);
   if (s === null) return null;
-  const parsed = await readAndParse(full, relPath, parser);
+  const parsed = await readAndParse(full, relPath, parser, bodyField);
   if (parsed === null) return null;
   return {
     path: relPath,
@@ -2444,7 +2451,7 @@ function relativeFromRoots(full, absRoots) {
   }
   return null;
 }
-async function readAndParse(full, relPath, parser) {
+async function readAndParse(full, relPath, parser, bodyField) {
   let raw;
   try {
     raw = await readFile(full, "utf8");
@@ -2453,12 +2460,19 @@ async function readAndParse(full, relPath, parser) {
   }
   const parsed = parser.parse(raw, relPath);
   return {
-    body: parsed.body,
+    body: resolveEffectiveBody(parsed.body, parsed.frontmatter, bodyField),
     frontmatterRaw: parsed.frontmatterRaw,
     frontmatter: parsed.frontmatter,
     ...parsed.issues && parsed.issues.length > 0 ? { parseIssues: parsed.issues } : {}
   };
 }
+function resolveEffectiveBody(parsedBody, frontmatter, bodyField) {
+  if (bodyField !== void 0) {
+    const candidate = frontmatter[bodyField];
+    if (typeof candidate === "string") return candidate;
+  }
+  return parsedBody;
+}
 function buildSizeLimit(options) {
   const sizeLimit = {};
   if (options.maxFileSizeBytes !== void 0) {
@@ -2514,13 +2528,19 @@ function resolveProviderWalk(provider) {
     return walk2;
   }
   const read = provider.read ?? DEFAULT_READ_CONFIG;
-  return (roots, options) => walkContent(roots, buildWalkContentOptions(read, options));
+  const rules = Array.isArray(read) ? read : [read];
+  return async function* walkRules(roots, options) {
+    for (const rule of rules) {
+      yield* walkContent(roots, buildWalkContentOptions(rule, options));
+    }
+  };
 }
 function buildWalkContentOptions(read, options) {
   const walkOptions = {
     extensions: read.extensions,
     parser: read.parser
   };
+  if (read.bodyField !== void 0) walkOptions.bodyField = read.bodyField;
   if (options) copyOptionalWalkOptions(walkOptions, options);
   return walkOptions;
 }
@@ -4130,4 +4150,4 @@ export {
   runScanWithRenames
 };
 //# sourceMappingURL=index.js.map
-//# debugId=e05c9678-1319-58b6-9a51-61818bac9305
+//# debugId=27ef1dc5-0da7-5a76-9fa8-d447025bd0d4

package/dist/kernel/index.d.ts

@@ -2541,8 +2541,12 @@ type TProviderKindIcon = {
 interface IProviderUi {
     /**
      * Human-readable Provider name shown in the lens dropdown, the topbar
-     * lens chip, and the per-node provider chip (e.g. `'Claude'`,
-     * `'OpenAI Codex'`, `'Antigravity'`, `'Open Skills'`, `'Markdown'`).
+     * lens chip, and the per-node provider chip. Vendor lenses use a
+     * possessive `<Vendor>'s <product>` form (`"Anthropic's Claude"`,
+     * `"OpenAI's Codex"`, `"Google's Antigravity"`); the vendor-neutral open
+     * standard uses a `'Standard: <name>'` prefix (`'Standard: Agent skills'`).
+     * The non-gated `'Markdown'` base keeps a label for internal lookups but
+     * is never a selectable lens.
      */
     label: string;
     /** Base hex color (`#RRGGBB`) for the light-theme provider chip. */
@@ -2598,7 +2602,7 @@ interface IProviderScaffold {
      * Display-only hints naming the agents that consume this scaffold
      * territory, rendered in parentheses next to the Provider label in the
      * `sm tutorial` destination prompt (e.g. `.agents/skills` is read by
-     * Antigravity and OpenAI Codex). Purely presentational: NOT matched by
+     * Google's Antigravity and OpenAI's Codex). Purely presentational: NOT matched by
      * `--for` (only registered Provider ids are) and has no runtime effect.
      */
     aka?: readonly string[];
@@ -2631,7 +2635,7 @@ interface IProvider extends IExtensionBase {
      * When present, the Provider is offered as a destination for newly
      * generated content (a skill folder dropped under `scaffold.skillDir`).
      * Absent means a materialising verb never offers this Provider, e.g.
-     * `openai` until Codex skills land, `antigravity` (skills live under
+     * `codex` until Codex skills land, `antigravity` (skills live under
      * the open-standard `agent-skills` territory), `core/markdown` (owns
      * no authoring convention).
      */
@@ -2686,19 +2690,31 @@ interface IProvider extends IExtensionBase {
      * applies the default `{ extensions: ['.md'], parser: 'frontmatter-yaml' }`
      * so the most common Provider shape needs zero configuration.
      *
+     * Either a SINGLE rule (the common case) or an ARRAY of rules. A
+     * Provider that reads several file families with different parsers
+     * declares an array, and `resolveProviderWalk` runs one walk pass per
+     * rule (each filtering by its own `extensions`). The codex provider
+     * uses this to read `.toml` sub-agents (`parser: 'toml'`,
+     * `bodyField: 'developer_instructions'`) AND `.md` open-standard skills
+     * (`parser: 'frontmatter-yaml'`) declaratively, without an escape-hatch
+     * `walk()`. Rules SHOULD use disjoint extensions; overlaps are
+     * tolerated because the orchestrator's first-wins `claimedPaths` dedup
+     * drops a path already claimed on an earlier pass.
+     *
      * Precedence: when both `walk()` (runtime field) and `read` are
      * declared, `walk()` wins, `read` is ignored. The escape-hatch
-     * relationship is intentional: most Providers should use `read`;
-     * Providers with non-standard discovery requirements (custom file
-     * naming, multi-pass walks, dynamic ignore logic) implement `walk()`
-     * directly and accept the duplication of audit-cleared defences.
+     * relationship is intentional: most Providers should use `read` (single
+     * or multi-rule); Providers with genuinely non-standard discovery
+     * requirements (custom file naming, dynamic ignore logic) implement
+     * `walk()` directly and accept the duplication of audit-cleared defences.
      *
      * Built-in parsers: `'frontmatter-yaml'` (markdown with `--- … ---`
      * YAML frontmatter; pollution-strip + JSON_SCHEMA-pinned), `'plain'`
-     * (entire body, empty frontmatter). The set is closed; user plugins
-     * cannot register their own.
+     * (entire body, empty frontmatter), `'toml'` (whole-file TOML as
+     * structured frontmatter). The set is closed; user plugins cannot
+     * register their own.
      */
-    read?: IProviderReadConfig;
+    read?: IProviderReadConfig | IProviderReadConfig[];
     /**
      * Walk the given roots and yield every node the Provider recognises.
      * Non-matching files are silently skipped. Unreadable files produce
@@ -2766,27 +2782,29 @@ interface IProvider extends IExtensionBase {
      */
     resolution?: Record<string, string[]>;
     /**
-     * Lens gating flag for vendor providers. When `true`, this Provider's
+     * Lens gating flag. When `true`, this Provider is a LENS: its
      * `classify()` only runs (and the walker only iterates its territory)
-     * if `provider.id === activeProvider` (the project's active lens).
-     * When `false` or omitted (default), the Provider is universal and
-     * classifies unconditionally, regardless of the active lens.
+     * if `provider.id === activeProvider` (the project's active lens), and
+     * it is offered as a selectable lens (the BFF projects `isLens: true`
+     * from this flag). When `false` or omitted (default), the Provider is a
+     * non-gated universal BASE and classifies unconditionally.
      *
-     * Vendor providers (`claude`, `openai`, `antigravity`) MUST set this
-     * to `true`: the actual runtimes never read each other's on-disk
-     * formats (Claude Code does not consume `.codex/`; Codex CLI does not
-     * consume `.claude/`), and offering every file to every provider
-     * fabricates cross-vendor graph edges the runtimes themselves reject.
+     * Vendor providers (`claude`, `codex`, `antigravity`) and the
+     * open-standard `agent-skills` provider MUST set this `true`: the actual
+     * runtimes never read each other's on-disk formats (Claude Code does not
+     * consume `.codex/`; Codex CLI does not consume `.claude/`), and offering
+     * every file to every provider fabricates cross-vendor graph edges the
+     * runtimes themselves reject.
      *
-     * Universal providers (the open-standard `agent-skills`, the markdown
-     * fallback `core/markdown`, any future format-based fallback) keep
-     * this `false`: their territory is consumed by every vendor and they
-     * MUST run on every scan, regardless of the active lens.
+     * Only the markdown fallback `core/markdown` (and any future
+     * format-based fallback) keeps this `false`: the single non-gated base,
+     * consumed by every lens and run on every scan. It is the substrate, NOT
+     * a selectable lens (`isLens: false`).
      *
-     * There is no unlensed state: a project with no provider markers
-     * resolves to the universal `core/markdown` lens (id `markdown`),
-     * under which every gated Provider stays off (only the universal
-     * Providers run). The resolver never yields a null lens.
+     * There is no unlensed state: a project with no vendor marker resolves
+     * to the open-standard `agent-skills` default lens, under which the
+     * open-standard classifier plus the universal base run. The resolver
+     * never yields a null lens.
      *
      * Default `undefined` ≡ `false` ≡ universal. The field affects
      * classification ONLY; extractors continue to filter via their own
@@ -2932,6 +2950,23 @@ interface IProviderReadConfig {
      * the error into a Provider issue with status `invalid-manifest`.
      */
     parser: string;
+    /**
+     * Name of a parsed-frontmatter field that carries the node's markdown
+     * body. When set, the walker feeds `frontmatter[bodyField]` (when it is
+     * a string) to every downstream consumer as the node `body` instead of
+     * the parser's own `body` output: the body hash, byte counts, and every
+     * body-scoped extractor (markdown-link, at-directive, slash, ...) then
+     * see this prose. For formats where the prompt lives inside structured
+     * frontmatter rather than after a fence: OpenAI Codex sub-agents are
+     * pure TOML (`read.parser: 'toml'`) whose markdown prompt is the
+     * triple-quoted `developer_instructions` field, so the codex provider
+     * declares `bodyField: 'developer_instructions'`. When the field is
+     * absent or not a string,
+     * the parser's own `body` is used unchanged (the default for `.md`
+     * providers). The field stays in `frontmatter` too, so frontmatter-scoped
+     * extractors (e.g. `core/mcp-tools` reading `tools`) are unaffected.
+     */
+    bodyField?: string;
 }
 
 /**

package/dist/kernel/index.js

@@ -1,6 +1,6 @@
 // kernel/i18n/registry.texts.ts
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="264b9eb8-acaa-57eb-af6d-7127c5145395")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ffec428d-8810-5e29-bc67-ad4ec917ce6f")}catch(e){}}();
 var REGISTRY_TEXTS = {
   duplicateExtension: "Extension already registered: {{kind}}:{{qualifiedId}}",
   unknownKind: "Unknown extension kind: {{kind}}",
@@ -102,7 +102,7 @@ import { Tiktoken as Tiktoken2 } from "js-tiktoken/lite";
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.64.1",
+  version: "0.66.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -2349,24 +2349,31 @@ async function* walkContent(roots, options) {
   const filter = options.ignoreFilter ?? buildIgnoreFilter();
   const extensions = options.extensions;
   const sizeLimit = buildSizeLimit(options);
+  const bodyField = options.bodyField;
   if (options.scopedPaths !== void 0) {
-    yield* walkScoped(roots, options.scopedPaths, extensions, sizeLimit, parser);
+    yield* walkScoped(roots, options.scopedPaths, extensions, sizeLimit, parser, bodyField);
     return;
   }
   for (const root of roots) {
     for await (const entry of walkRoot(root, root, filter, extensions, sizeLimit)) {
       const relPath = relative2(root, entry.full).split(sep).join("/");
-      const rec = await traversedEntryToNode(entry, relPath, options.priorMtimes, parser);
+      const rec = await traversedEntryToNode(
+        entry,
+        relPath,
+        options.priorMtimes,
+        parser,
+        bodyField
+      );
       if (rec !== null) yield rec;
     }
   }
 }
-async function traversedEntryToNode(entry, relPath, priorMtimes, parser) {
+async function traversedEntryToNode(entry, relPath, priorMtimes, parser, bodyField) {
   const priorMtime = priorMtimes?.get(relPath);
   if (priorMtime !== void 0 && priorMtime === entry.modifiedAtMs) {
-    return buildUnchangedRecord(entry.full, relPath, entry.modifiedAtMs, parser);
+    return buildUnchangedRecord(entry.full, relPath, entry.modifiedAtMs, parser, bodyField);
   }
-  const parsed = await readAndParse(entry.full, relPath, parser);
+  const parsed = await readAndParse(entry.full, relPath, parser, bodyField);
   if (parsed === null) return null;
   return {
     path: relPath,
@@ -2383,7 +2390,7 @@ async function traversedEntryToNode(entry, relPath, priorMtimes, parser) {
     ...parsed.parseIssues ? { parseIssues: parsed.parseIssues } : {}
   };
 }
-function buildUnchangedRecord(full, relPath, modifiedAtMs, parser) {
+function buildUnchangedRecord(full, relPath, modifiedAtMs, parser, bodyField) {
   return {
     path: relPath,
     body: "",
@@ -2392,26 +2399,26 @@ function buildUnchangedRecord(full, relPath, modifiedAtMs, parser) {
     modifiedAtMs,
     unchanged: true,
     reread: async () => {
-      const re = await readAndParse(full, relPath, parser);
+      const re = await readAndParse(full, relPath, parser, bodyField);
       return re ?? { body: "", frontmatterRaw: "", frontmatter: {} };
     }
   };
 }
-async function* walkScoped(roots, scopedPaths, extensions, sizeLimit, parser) {
+async function* walkScoped(roots, scopedPaths, extensions, sizeLimit, parser, bodyField) {
   const absRoots = roots.map((r) => isAbsolute2(r) ? r : resolve7(r));
   for (const scoped of scopedPaths) {
-    const rec = await scopedPathToNode(scoped, absRoots, extensions, sizeLimit, parser);
+    const rec = await scopedPathToNode(scoped, absRoots, extensions, sizeLimit, parser, bodyField);
     if (rec !== null) yield rec;
   }
 }
-async function scopedPathToNode(scoped, absRoots, extensions, sizeLimit, parser) {
+async function scopedPathToNode(scoped, absRoots, extensions, sizeLimit, parser, bodyField) {
   const full = isAbsolute2(scoped) ? scoped : resolve7(scoped);
   const relPath = relativeFromRoots(full, absRoots);
   if (relPath === null) return null;
   if (!hasMatchingExtension(full, extensions)) return null;
   const s = await statRegularFile(full, relPath, sizeLimit);
   if (s === null) return null;
-  const parsed = await readAndParse(full, relPath, parser);
+  const parsed = await readAndParse(full, relPath, parser, bodyField);
   if (parsed === null) return null;
   return {
     path: relPath,
@@ -2444,7 +2451,7 @@ function relativeFromRoots(full, absRoots) {
   }
   return null;
 }
-async function readAndParse(full, relPath, parser) {
+async function readAndParse(full, relPath, parser, bodyField) {
   let raw;
   try {
     raw = await readFile(full, "utf8");
@@ -2453,12 +2460,19 @@ async function readAndParse(full, relPath, parser) {
   }
   const parsed = parser.parse(raw, relPath);
   return {
-    body: parsed.body,
+    body: resolveEffectiveBody(parsed.body, parsed.frontmatter, bodyField),
     frontmatterRaw: parsed.frontmatterRaw,
     frontmatter: parsed.frontmatter,
     ...parsed.issues && parsed.issues.length > 0 ? { parseIssues: parsed.issues } : {}
   };
 }
+function resolveEffectiveBody(parsedBody, frontmatter, bodyField) {
+  if (bodyField !== void 0) {
+    const candidate = frontmatter[bodyField];
+    if (typeof candidate === "string") return candidate;
+  }
+  return parsedBody;
+}
 function buildSizeLimit(options) {
   const sizeLimit = {};
   if (options.maxFileSizeBytes !== void 0) {
@@ -2514,13 +2528,19 @@ function resolveProviderWalk(provider) {
     return walk2;
   }
   const read = provider.read ?? DEFAULT_READ_CONFIG;
-  return (roots, options) => walkContent(roots, buildWalkContentOptions(read, options));
+  const rules = Array.isArray(read) ? read : [read];
+  return async function* walkRules(roots, options) {
+    for (const rule of rules) {
+      yield* walkContent(roots, buildWalkContentOptions(rule, options));
+    }
+  };
 }
 function buildWalkContentOptions(read, options) {
   const walkOptions = {
     extensions: read.extensions,
     parser: read.parser
   };
+  if (read.bodyField !== void 0) walkOptions.bodyField = read.bodyField;
   if (options) copyOptionalWalkOptions(walkOptions, options);
   return walkOptions;
 }
@@ -4130,4 +4150,4 @@ export {
   runScanWithRenames
 };
 //# sourceMappingURL=index.js.map
-//# debugId=264b9eb8-acaa-57eb-af6d-7127c5145395
+//# debugId=ffec428d-8810-5e29-bc67-ad4ec917ce6f