@intentius/chant 0.79.0 → 0.81.0

package/src/config.ts

@@ -10,6 +10,7 @@ import type { BuildParamsConfig } from "./build-params";
 import type { BuildParamProvenance } from "./provenance";
 import { findProjectConfig } from "./project-root";
 import { evaluateProjectConfig } from "./config-sandbox";
+import { lexiconNames, pathLexiconRoot, registerLexiconDeclarations, type LexiconDeclaration } from "./lexicon-module";
 
 /**
  * One project-declared environment (chant #1166). Historically always a bare
@@ -125,8 +126,17 @@ const EnvironmentEntrySchema = z.union([
   }),
 ]);
 
+const LexiconEntrySchema = z.union([
+  z.string().min(1),
+  z.object({
+    name: z.string().min(1),
+    module: z.string().min(1),
+    root: z.string().min(1).optional(),
+  }).strict(),
+]);
+
 export const ChantConfigSchema = z.object({
-  lexicons: z.array(z.string().min(1)).optional(),
+  lexicons: z.array(LexiconEntrySchema).optional(),
   capabilities: z.array(z.string().min(1)).optional(),
   environments: z.array(EnvironmentEntrySchema).optional(),
   sourceDir: z.string().min(1).optional(),
@@ -184,6 +194,9 @@ export const ChantConfigSchema = z.object({
   knowledge: z.object({
     dir: z.string().min(1).optional(),
   }).optional(),
+  exclude: z.array(z.string().min(1)).optional(),
+  include: z.array(z.string().min(1)).optional(),
+  rootOnly: z.boolean().optional(),
 }).passthrough();
 
 /**
@@ -192,8 +205,25 @@ export const ChantConfigSchema = z.object({
  * Loaded from `chant.config.ts` (preferred) or `chant.config.json`.
  */
 export interface ChantConfig {
-  /** Lexicon package names to load (e.g. ["aws"]) */
-  lexicons?: string[];
+  /**
+   * Lexicons to load. A bare name (`"aws"`) loads the package
+   * `@intentius/chant-lexicon-aws`. `{ name, module }` (#2520) loads a
+   * project-local lexicon from a module path, resolved against the directory
+   * holding this config; see `./lexicon-module.ts`. An optional `root`
+   * (chant#2590) names the directory holding the lexicon's other files.
+   *
+   * Once loaded, this holds names only: the loader replaces each
+   * `{ name, module }` entry with its name and records the path in
+   * {@link ChantConfig.lexiconModules}.
+   */
+  lexicons?: LexiconDeclaration[];
+
+  /**
+   * Set by the config loader, never written by hand: each path-declared
+   * lexicon's name mapped to its absolute module path. Absent when every
+   * `lexicons` entry is a bare name.
+   */
+  lexiconModules?: Record<string, string>;
 
   /**
    * Capability plugin package names to load in addition to the built-in
@@ -418,14 +448,57 @@ export interface ChantConfig {
     /** Bundle directory, relative to the project root. Defaults to `"knowledge"`. */
     dir?: string;
   };
+
+  /**
+   * Globs, relative to the directory holding this config, naming files that
+   * source discovery must skip (#2519): `build`, `lint`, `list`, `explain`
+   * and every other command that walks the project for declarations never
+   * import or lint a matching file. A pattern matches a file when it matches
+   * the file's path or the path of any directory above it, so `"ops"` and
+   * `"ops/**"` both skip everything under `ops/`. Matched with picomatch,
+   * dot files included. Op discovery and component discovery honour it too
+   * (#2527). See `./discovery/walk.ts`.
+   */
+  exclude?: string[];
+
+  /**
+   * Globs that re-admit files {@link exclude} would skip, and, since #2527,
+   * files the discovery walk skips by default: dot-directories, `dist`,
+   * git-ignored paths and child projects. `include` always wins over
+   * `exclude`, and it never narrows discovery on its own: a file nothing
+   * skips is discovered whether or not it matches an `include`. It never
+   * re-admits `node_modules`, `.git`, test files, workspace members, or
+   * files carrying the generated or skip marker.
+   */
+  include?: string[];
+
+  /**
+   * Lets `chant build` and `chant lint` run on this project when it is the
+   * root of a declared workspace (#2537, #2524 D0). Without it, or the
+   * `--root-only` flag, both commands refuse there with `WSP000` and point to
+   * `chant workspace build` and `lint`. With it they act on the root project
+   * alone. Member directories and example-group matches are left out of
+   * discovery either way, as they are for every walk under a declaration
+   * (#2527, `workspaceMemberDirs` in `./discovery/walk.ts`). It means nothing
+   * in a project with no `chant.workspace.json`.
+   */
+  rootOnly?: boolean;
 }
 
 /**
  * Resolved project configuration with metadata about how it was loaded.
  */
+/**
+ * A configuration as the loader returns it. `lexicons` holds names only: each
+ * `{ name, module }` entry has been replaced by its name and its path moved
+ * to `lexiconModules` (chant #2520), so a reader of a loaded config never
+ * sees the object form.
+ */
+export type LoadedChantConfig = Omit<ChantConfig, "lexicons"> & { lexicons?: string[] };
+
 export interface ResolvedConfig {
   /** The loaded configuration */
-  config: ChantConfig;
+  config: LoadedChantConfig;
 
   /** Path to the config file that was loaded, or undefined if defaults */
   configPath?: string;
@@ -434,7 +507,7 @@ export interface ResolvedConfig {
 /**
  * Default configuration when no config file exists.
  */
-export const DEFAULT_CHANT_CONFIG: ChantConfig = {};
+export const DEFAULT_CHANT_CONFIG: LoadedChantConfig = {};
 
 /**
  * Load project configuration from a directory.
@@ -499,14 +572,56 @@ export async function loadChantConfig(dir: string): Promise<ResolvedConfig> {
  * config declaring any project-level key still wins where it stands.
  */
 export async function loadChantConfigUpward(startDir: string): Promise<ResolvedConfig> {
+  const { dir, configPath } = findProjectConfigPastFragments(startDir);
+  if (configPath) warnIfFragmentShadowsProjectConfig(configPath);
+  return loadChantConfig(dir);
+}
+
+/** The walk {@link loadChantConfigUpward} makes, lint-only fragments skipped, without its warning. */
+export function findProjectConfigPastFragments(startDir: string): { dir: string; configPath?: string } {
   let { dir, configPath } = findProjectConfig(startDir);
   while (configPath && isLintOnlyFragment(configPath)) {
     const parent = dirname(dir);
     if (parent === dir) break;
     ({ dir, configPath } = findProjectConfig(parent));
   }
-  if (configPath) warnIfFragmentShadowsProjectConfig(configPath);
-  return loadChantConfig(dir);
+  return { dir, configPath };
+}
+
+/** A project's discovery globs (#2519) and the directory they are relative to. */
+export interface DiscoveryGlobs {
+  /** The directory holding the config that declared the globs. */
+  root: string;
+  exclude: string[];
+  include: string[];
+}
+
+/**
+ * The `exclude`/`include` globs of the project `startDir` belongs to, found by
+ * the same upward walk as {@link loadChantConfigUpward}. `undefined` when the
+ * project declares neither. `include` re-admits what `exclude` skips, and
+ * also what the discovery walk skips by default (#2527), so it means
+ * something on its own.
+ *
+ * A config that fails to load is left to the command's own config load to
+ * report, so discovery keeps working where it did before, unless the failure
+ * is in `exclude` or `include` themselves: ignoring those would discover the
+ * very files the project asked to skip.
+ */
+export async function resolveDiscoveryGlobs(startDir: string): Promise<DiscoveryGlobs | undefined> {
+  const { dir, configPath } = findProjectConfigPastFragments(startDir);
+  if (!configPath) return undefined;
+  let config: ChantConfig;
+  try {
+    ({ config } = await loadChantConfig(dir));
+  } catch (err) {
+    if (err instanceof InvalidChantConfigError && (err.key === "exclude" || err.key === "include")) throw err;
+    return undefined;
+  }
+  const exclude = config.exclude ?? [];
+  const include = config.include ?? [];
+  if (exclude.length === 0 && include.length === 0) return undefined;
+  return { root: dir, exclude, include };
 }
 
 /**
@@ -531,7 +646,7 @@ const LINT_FRAGMENT_KEYS = new Set(["$schema", "extends", "rules", "overrides",
  */
 const isCommentKey = (k: string): boolean => k.startsWith("_");
 
-function isLintOnlyFragment(configPath: string): boolean {
+export function isLintOnlyFragment(configPath: string): boolean {
   if (!configPath.endsWith("chant.config.json")) return false;
   try {
     const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as unknown;
@@ -813,10 +928,20 @@ export function resolveKnowledgeDir(config: ChantConfig, projectPath: string): s
   return join(projectPath, config.knowledge?.dir ?? "knowledge");
 }
 
+/**
+ * A config that failed schema validation. `key` is the top-level key of the
+ * first problem. `name` stays `"Error"`, so the printed error reads as before.
+ */
+export class InvalidChantConfigError extends Error {
+  constructor(message: string, readonly key?: string) {
+    super(message);
+  }
+}
+
 /**
  * Validate and normalize a raw config object into ChantConfig shape.
  */
-function normalizeConfig(raw: Record<string, unknown>, source?: string): ChantConfig {
+function normalizeConfig(raw: Record<string, unknown>, source?: string): LoadedChantConfig {
   if (typeof raw !== "object" || raw === null) {
     return DEFAULT_CHANT_CONFIG;
   }
@@ -826,8 +951,33 @@ function normalizeConfig(raw: Record<string, unknown>, source?: string): ChantCo
     const issue = result.error.issues[0];
     const path = issue.path.length > 0 ? issue.path.join(".") : undefined;
     const loc = source ? ` in ${source}` : "";
-    throw new Error(`Invalid chant config${loc}: ${path ? `${path}: ` : ""}${issue.message}`);
+    throw new InvalidChantConfigError(
+      `Invalid chant config${loc}: ${path ? `${path}: ` : ""}${issue.message}`,
+      issue.path.length > 0 ? String(issue.path[0]) : undefined,
+    );
+  }
+
+  // chant #2520 — a lexicon declared by module path. The path is recorded for
+  // the loaders and the entry becomes its name, so every reader of `lexicons`
+  // keeps seeing names. A config of plain names is returned untouched.
+  const lexicons = (raw as ChantConfig).lexicons;
+  const baseDir = source !== undefined ? dirname(source) : process.cwd();
+  const sourceDir = (raw as ChantConfig).sourceDir;
+  // chant#2590 — a declared `root` must stay inside the project and must not
+  // contain its source directory. Refused here rather than narrowed, since
+  // the project asked for it by name.
+  for (const [i, entry] of (lexicons ?? []).entries()) {
+    if (typeof entry === "string" || entry.root === undefined) continue;
+    const { problem } = pathLexiconRoot(entry, baseDir, sourceDir);
+    if (problem !== undefined) {
+      const loc = source ? ` in ${source}` : "";
+      throw new InvalidChantConfigError(`Invalid chant config${loc}: lexicons.${i}.root: ${problem}`, "lexicons");
+    }
+  }
+  const recorded = registerLexiconDeclarations(lexicons, baseDir, sourceDir);
+  if (Object.keys(recorded).length > 0) {
+    return { ...(raw as ChantConfig), lexicons: lexiconNames(lexicons), lexiconModules: recorded };
   }
 
-  return raw as ChantConfig;
+  return raw as LoadedChantConfig;
 }

package/src/content-digest.test.ts

@@ -0,0 +1,120 @@
+/**
+ * chant #2514 — `contentDigest` is real SHA-256 over UTF-8, and the manifest
+ * and SBOM digests built on it separate inputs one byte apart.
+ */
+import { describe, expect, test } from "vitest";
+import { createHash } from "node:crypto";
+import { contentDigest } from "./content-digest";
+import { canonicalJson } from "./effect-receipt";
+import {
+  addArchiveEntry,
+  computeManifestDigest,
+  contentDigest as archiveContentDigest,
+  createBuildArchiveManifest,
+} from "./components/verbs/build-archive";
+import { createGenerateSbomCapability } from "./components/verbs/sbom";
+import type { SbomDocument, SbomGenerator } from "./components/verbs/sbom-generator";
+import { computePlanDigest } from "./lifecycle/plan-digest";
+import { hashProps } from "./lifecycle/digest";
+import { isLegacyContentDigest } from "./lifecycle/legacy-digest";
+
+describe("contentDigest (#2514)", () => {
+  test("matches the FIPS 180-2 test vectors", () => {
+    expect(contentDigest("abc")).toBe("sha256:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
+    expect(contentDigest("")).toBe("sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
+  });
+
+  test("hashes the UTF-8 bytes, not UTF-16 code units", () => {
+    const text = "héllo, 世界 🌍";
+    const expected = createHash("sha256").update(Buffer.from(text, "utf8")).digest("hex");
+    expect(contentDigest(text)).toBe(`sha256:${expected}`);
+  });
+
+  test("the build archive exports the same function", () => {
+    expect(archiveContentDigest).toBe(contentDigest);
+  });
+
+  test("its output is never mistaken for the old form", () => {
+    for (const input of ["", "x", "hello", "{}"]) {
+      expect(isLegacyContentDigest(contentDigest(input))).toBe(false);
+    }
+  });
+
+  test("inputs one byte apart get different digests", () => {
+    expect(contentDigest("template-a")).not.toBe(contentDigest("template-b"));
+    expect(contentDigest("abc")).not.toBe(contentDigest("abc "));
+  });
+});
+
+describe("manifest digest (#2514)", () => {
+  const entry = (digest: string, path = "web.json") => ({ kind: "template" as const, path, digest });
+
+  test("is contentDigest over the canonical JSON of the sorted entries", () => {
+    const a = entry(contentDigest("{}"), "b.json");
+    const b = entry(contentDigest("[]"), "a.json");
+    const expected = contentDigest(
+      canonicalJson([
+        { kind: b.kind, path: b.path, digest: b.digest },
+        { kind: a.kind, path: a.path, digest: a.digest },
+      ]),
+    );
+    expect(computeManifestDigest([a, b])).toBe(expected);
+    expect(computeManifestDigest([b, a])).toBe(expected);
+  });
+
+  test("templates one byte apart give different entry and manifest digests", () => {
+    const base = createBuildArchiveManifest("web", { now: () => new Date(0) });
+    const one = addArchiveEntry(base, entry(contentDigest('{"Resources":{"A":1}}')));
+    const two = addArchiveEntry(base, entry(contentDigest('{"Resources":{"A":2}}')));
+    expect(one.contents[0]!.digest).not.toBe(two.contents[0]!.digest);
+    expect(one.manifestDigest).not.toBe(two.manifestDigest);
+  });
+
+  test("a path cannot be read as a separator", () => {
+    // Under the old `kind:path:digest` join these two could be confused.
+    const x = computeManifestDigest([entry("sha256:1", "a:template:b")]);
+    const y = computeManifestDigest([entry("template:b:sha256:1", "a")]);
+    expect(x).not.toBe(y);
+  });
+});
+
+describe("SBOM digest (#2514)", () => {
+  function fixedGenerator(bytes: string): SbomGenerator {
+    const doc = async (): Promise<SbomDocument> => ({
+      format: "spdx",
+      mediaType: "application/spdx+json",
+      bytes,
+      generator: "test",
+    });
+    return { forImage: doc, forJar: doc, forZip: doc, forDir: doc };
+  }
+
+  test("SBOMs one byte apart get different digests, each real SHA-256", async () => {
+    const ctx = { env: "dev", component: "web" };
+    const input = { artifactType: "image" as const, path: "archive/web.tar", digest: contentDigest("image") };
+    const a = await createGenerateSbomCapability(fixedGenerator('{"packages":[1]}')).run(ctx, input);
+    const b = await createGenerateSbomCapability(fixedGenerator('{"packages":[2]}')).run(ctx, input);
+    expect(a.digest).toBe(contentDigest('{"packages":[1]}'));
+    expect(a.digest).not.toBe(b.digest);
+    expect(a.manifest.manifestDigest).not.toBe(b.manifest.manifestDigest);
+  });
+});
+
+describe("other hashes use contentDigest over canonicalJson (#2514)", () => {
+  test("a plan digest", () => {
+    const subject = { b: 1, a: [true, null] };
+    expect(computePlanDigest("lifecycle-diff", subject)).toBe(
+      contentDigest(canonicalJson({ kind: "lifecycle-diff", subject })),
+    );
+  });
+
+  test("a plan digest orders keys by code unit, not by locale", () => {
+    // localeCompare puts "a" before "B"; canonicalJson puts "B" first.
+    expect(computePlanDigest("k", { a: 1, B: 2 })).toBe(contentDigest('{"kind":"k","subject":{"B":2,"a":1}}'));
+  });
+
+  test("a props hash, which drops what JSON cannot hold instead of throwing", () => {
+    const props = { Name: "x", fn: () => 1, nested: { z: 1, a: undefined } };
+    expect(hashProps(props)).toBe(contentDigest('{"Name":"x","nested":{"z":1}}').slice("sha256:".length));
+  });
+});

package/src/content-digest.ts

@@ -0,0 +1,21 @@
+/**
+ * The one content digest chant computes itself (chant #2514).
+ *
+ * `contentDigest(x)` is `"sha256:"` followed by the lowercase hex SHA-256 of
+ * the UTF-8 bytes of `x`. Anything core hashes goes through it, and anything
+ * structured is first put in canonical form with `canonicalJson`
+ * (./effect-receipt.ts), so the same value always hashes the same way. The
+ * build archive re-exports it from ./components/verbs/build-archive.ts, where
+ * it used to live.
+ *
+ * Before #2514 this function computed a 32-bit string hash and repeated its
+ * eight hex digits eight times. Values recorded then are recognised and
+ * flagged by ./lifecycle/legacy-digest.ts.
+ */
+
+import { createHash } from "node:crypto";
+
+/** `sha256:<64 hex>` over the UTF-8 bytes of `input`. */
+export function contentDigest(input: string): string {
+  return `sha256:${createHash("sha256").update(input, "utf8").digest("hex")}`;
+}

package/src/discovery/files.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from "vitest";
-import { findInfraFiles } from "./files";
+import { findInfraFiles, compileDiscoveryFilter, hasSkipMarker, SKIP_MARKER } from "./files";
 import { withTestDir } from "@intentius/chant-test-utils";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -169,3 +169,129 @@ describe("findInfraFiles", () => {
     });
   });
 });
+
+describe("findInfraFiles — project exclude/include globs (#2519)", () => {
+  /** Lay out a project: `files` maps a relative path to its contents. */
+  async function project(testDir: string, config: Record<string, unknown> | undefined, files: Record<string, string>) {
+    if (config) await writeFile(join(testDir, "chant.config.json"), JSON.stringify(config));
+    for (const [rel, body] of Object.entries(files)) {
+      await mkdir(join(testDir, rel, ".."), { recursive: true });
+      await writeFile(join(testDir, rel), body);
+    }
+  }
+  const rel = (testDir: string, files: string[]) => files.map((f) => f.slice(testDir.length + 1)).sort();
+
+  const LAYOUT = {
+    "src/app.ts": "export const app = {};",
+    "src/lib/util.ts": "export const util = {};",
+    "ops/run.ts": "process.exit(2);",
+    "ops/keep.ts": "export const keep = {};",
+    ".stage/copy.ts": "export const copy = {};",
+  };
+
+  test("with neither key configured, every file but the dot directory's is discovered", async () => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { lexicons: ["aws"] }, LAYOUT);
+      expect(rel(testDir, await findInfraFiles(testDir))).toEqual([
+        "ops/keep.ts", "ops/run.ts", "src/app.ts", "src/lib/util.ts",
+      ]);
+    });
+  });
+
+  test.each([["ops"], ["ops/**"], ["ops/*.ts"]])("exclude %s skips everything under ops/", async (pattern) => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { exclude: [pattern] }, LAYOUT);
+      expect(rel(testDir, await findInfraFiles(testDir))).toEqual(["src/app.ts", "src/lib/util.ts"]);
+    });
+  });
+
+  test("include re-admits a dot directory the walk skips by default (#2527)", async () => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { include: [".stage"] }, LAYOUT);
+      expect(rel(testDir, await findInfraFiles(testDir))).toContain(".stage/copy.ts");
+    });
+  });
+
+  test("include wins over exclude", async () => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { exclude: ["ops"], include: ["ops/keep.ts"] }, LAYOUT);
+      expect(rel(testDir, await findInfraFiles(testDir))).toEqual([
+        "ops/keep.ts", "src/app.ts", "src/lib/util.ts",
+      ]);
+    });
+  });
+
+  test("exclude everything and include a directory narrows discovery to it", async () => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { exclude: ["**"], include: ["src"] }, LAYOUT);
+      expect(rel(testDir, await findInfraFiles(testDir))).toEqual(["src/app.ts", "src/lib/util.ts"]);
+    });
+  });
+
+  test("include alone changes nothing", async () => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { include: ["src"] }, LAYOUT);
+      expect(await findInfraFiles(testDir)).toHaveLength(4);
+    });
+  });
+
+  test("patterns stay relative to the project root when discovery starts in a subdirectory", async () => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { exclude: ["src/lib"] }, LAYOUT);
+      expect(rel(testDir, await findInfraFiles(join(testDir, "src")))).toEqual(["src/app.ts"]);
+    });
+  });
+
+  test("include does not re-admit test files", async () => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { exclude: ["ops"], include: ["**"] }, { ...LAYOUT, "src/app.test.ts": "test();" });
+      expect(rel(testDir, await findInfraFiles(testDir))).not.toContain("src/app.test.ts");
+    });
+  });
+
+  test("explicit globs override the config; null applies none", async () => {
+    await withTestDir(async (testDir) => {
+      await project(testDir, { exclude: ["ops"] }, LAYOUT);
+      expect(await findInfraFiles(testDir, { globs: null })).toHaveLength(4);
+      const only = await findInfraFiles(testDir, { globs: { root: testDir, exclude: ["src"], include: [] } });
+      expect(rel(testDir, only)).toEqual(["ops/keep.ts", "ops/run.ts"]);
+    });
+  });
+});
+
+describe("compileDiscoveryFilter (#2519)", () => {
+  test("is undefined with no exclude patterns", () => {
+    expect(compileDiscoveryFilter(undefined)).toBeUndefined();
+    expect(compileDiscoveryFilter({ root: "/p", exclude: [], include: ["**"] })).toBeUndefined();
+  });
+
+  test("never skips a file outside the root", () => {
+    const skip = compileDiscoveryFilter({ root: "/p/app", exclude: ["**"], include: [] })!;
+    expect(skip("/p/app/x.ts")).toBe(true);
+    expect(skip("/p/other/x.ts")).toBe(false);
+  });
+});
+
+describe("findInfraFiles — skip marker (#2519)", () => {
+  test.each([
+    ["a line comment", `// ${SKIP_MARKER}\nprocess.exit(2);`],
+    ["a line comment after a shebang", `#!/usr/bin/env -S node --import tsx\n// ${SKIP_MARKER}: a runner, not a declaration\nprocess.exit(2);`],
+    ["a block comment", `/**\n * Runs an Op.\n * ${SKIP_MARKER}\n */\nprocess.exit(2);`],
+  ])("skips a file carrying the marker in %s", async (_label, body) => {
+    await withTestDir(async (testDir) => {
+      await writeFile(join(testDir, "app.ts"), "export const app = {};");
+      await writeFile(join(testDir, "run.ts"), body);
+      const files = await findInfraFiles(testDir);
+      expect(files).toHaveLength(1);
+      expect(files[0]).toMatch(/app\.ts$/);
+    });
+  });
+
+  test.each([
+    ["in a string", `export const s = "${SKIP_MARKER}";`],
+    ["as a longer word", `// ${SKIP_MARKER}-not\nexport const a = {};`],
+    ["past the head", `${"// padding\n".repeat(100)}// ${SKIP_MARKER}\nexport const a = {};`],
+  ])("does not treat the marker %s as a skip", (_label, body) => {
+    expect(hasSkipMarker(body)).toBe(false);
+  });
+});