@adobe/ecs 0.2.1 → 0.2.4

package/src/guide/08-input.ts

@@ -30,7 +30,7 @@ const heal = System.create({
 });
 
 const healths: number[] = [];
-const read = System.create({ observer: true, components: { with: [health] } }, row => {
+const read = System.create({ readonly: true, components: { with: [health] } }, row => {
     healths.push(row[health]);
 });
 

package/src/guide/09-rules.ts

@@ -31,7 +31,7 @@ const hide = System.create({ components: { with: [sprite] } }, (row, { commands
 });
 
 const drawing: string[] = [];
-const read = System.create({ observer: true, components: { with: [layer, drawn], optional: [mesh, sprite] } }, row => {
+const read = System.create({ readonly: true, components: { with: [layer, drawn], optional: [mesh, sprite] } }, row => {
     drawing.push(`${row[mesh] === undefined ? `sprite ${row[sprite]}` : `mesh ${row[mesh]}`} on layer ${row[layer]}`);
 });
 /** Logs what's drawn, in order. */

package/src/guide/11-traits.ts

@@ -33,9 +33,9 @@ const destroy = System.create({ components: { with: [ship] } }, (row, { commands
 });
 
 const counts = { outlined: 0, targeting: 0, entities: 0 };
-const countOutlined = System.create({ observer: true, components: { with: [outline] } }, () => { counts.outlined += 1; });
-const countTargeting = System.create({ observer: true, components: { with: [target] } }, () => { counts.targeting += 1; });
-const countAll = System.create({ observer: true, components: {} }, () => { counts.entities += 1; });
+const countOutlined = System.create({ readonly: true, components: { with: [outline] } }, () => { counts.outlined += 1; });
+const countTargeting = System.create({ readonly: true, components: { with: [target] } }, () => { counts.targeting += 1; });
+const countAll = System.create({ readonly: true, components: {} }, () => { counts.entities += 1; });
 const count = System.create([countOutlined, countTargeting, countAll]);
 
 export const main = async (): Promise<void> => {

package/src/guide/12-lookups.ts

@@ -25,7 +25,7 @@ const track = System.create({
 
 const refreshed: boolean[] = [];
 const watch = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [target] },
     lookup: { enemy: { with: [health], changed: [health] } },
 }, (row, { lookup }) => {
@@ -34,7 +34,7 @@ const watch = System.create({
 });
 
 const aims: number[] = [];
-const readAims = System.create({ observer: true, components: { with: [aim] } }, row => {
+const readAims = System.create({ readonly: true, components: { with: [aim] } }, row => {
     aims.push(row[aim]);
 });
 

package/src/guide/13-indexes.ts

@@ -26,14 +26,14 @@ const count = System.create({ components: { with: [cell, crowded] }, lookup: { a
 
 const byScore = Index.create({ key: [score], sorted: true, components: { with: [player] } });
 
-const leaders = System.create({ observer: true, lookup: { scores: { index: byScore } } }, ({ lookup }) => {
+const leaders = System.create({ readonly: true, lookup: { scores: { index: byScore } } }, ({ lookup }) => {
     const winners: string[] = [];
     const high = lookup.scores({ ">=": 90 });
     for (let i = 0; i < high.length; i++) winners.push(high.at(i)[player]);
     return winners;
 });
 
-const list = System.create({ observer: true, components: { with: [player, score] }, order: byScore }, row => {
+const list = System.create({ readonly: true, components: { with: [player, score] }, order: byScore }, row => {
     console.log(row[player], row[score]);
 });
 
@@ -42,12 +42,12 @@ const find = System.create({ lookup: { byId: { index: byServerId } } }, ({ looku
     lookup.byId(input.id)?.[player] ?? null);
 
 const players = Index.create({ key: [], components: { with: [player] } });
-const countPlayers = System.create({ observer: true, lookup: { players: { index: players, changed: true } } }, ({ lookup }) => {
+const countPlayers = System.create({ readonly: true, lookup: { players: { index: players, changed: true } } }, ({ lookup }) => {
     console.log("players", lookup.players().length);
 });
 
 const crowds: number[] = [];
-const readCrowds = System.create({ observer: true, components: { with: [crowded] } }, row => {
+const readCrowds = System.create({ readonly: true, components: { with: [crowded] } }, row => {
     crowds.push(row[crowded]);
 });
 

package/src/guide/14-kernels.ts

@@ -29,7 +29,7 @@ const slow = System.create({ kernel: false, components: { with: [velocity] } },
 });
 
 const moved: string[] = [];
-const read = System.create({ observer: true, components: { with: [position, velocity] } }, row => {
+const read = System.create({ readonly: true, components: { with: [position, velocity] } }, row => {
     moved.push(`at ${row[position][0]}, moving at ${row[velocity][0]}`);
 });
 

package/src/guide/15-reductions.ts

@@ -23,7 +23,7 @@ const weigh = System.create({ components: { with: [mass] } }, (row, { reduce })
     reduce[count](1);
 });
 
-const report = System.create({ observer: true }, ({ resources }) =>
+const report = System.create({ readonly: true }, ({ resources }) =>
     `${resources[count]} weigh ${resources[total]}, at most ${resources[heaviest]}`);
 
 const spawn = System.create(({ commands }) => {

package/src/guide/16-gpu.ts

@@ -32,7 +32,7 @@ const draw = System.render({ shader: { accessors: { dotPosition: position, dotSi
 });
 const shaderCode = Gpu.wgsl(draw);
 
-const read = System.create({ observer: true, components: { with: [position] } }, row => {
+const read = System.create({ readonly: true, components: { with: [position] } }, row => {
     console.log("at", row[position]);
 });
 

package/src/guide/17-hierarchies.ts

@@ -21,7 +21,7 @@ const place = System.create({ components: { with: [offset, placed] }, up: { thro
 });
 
 const where: string[] = [];
-const read = System.create({ observer: true, components: { with: [label, placed] } }, row => {
+const read = System.create({ readonly: true, components: { with: [label, placed] } }, row => {
     where.push(`${row[label]} at ${row[placed]}`);
 });
 

package/src/guide/18-identity.out

@@ -1 +1 @@
-Error: System "explode" (@adobe/ecs@0.2.1/src/guide/18-identity.ts#explode) failed: boom
+Error: System "explode" (@adobe/ecs@0.2.4/src/guide/18-identity.ts#explode) failed: boom

package/src/guide/19-threads.md

@@ -11,6 +11,8 @@ A *logical thread* is where objects live and the code touching them runs: the pa
 `World.join(port, { threads: ["audio"] })`, claiming the threads it fills. Usually the other end of the channel goes
 to a worker; [here both ends](19-threads.ts#L44-L54) are on one thread.
 
-- `share` resolves once the thread joined, with the observer systems it added as `join` resolved, before awaiting
-  anything else. Those observers run there after the world's sync points: `listen` hears what `mix` wrote.
+- `share` resolves once the thread joined, with the readonly systems it added as `join` resolved, before awaiting
+  anything else. Those readonly systems run there after the world's sync points: `listen` hears what `mix` wrote.
+- A joined thread adds only [readonly systems](03-systems.md), which run on it; a system that writes is added on the
+  world's thread.
 - A joined world runs systems as the world does: [`audio.run`](19-threads.ts#L60-L61) spawns and mixes too.

package/src/guide/19-threads.ts

@@ -22,7 +22,7 @@ const mix = System.create({ components: { with: [volume] } }, (row, { resources
 });
 
 let heard = 0;
-const listen = System.create({ observer: true }, ({ resources }) => {
+const listen = System.create({ readonly: true }, ({ resources }) => {
     heard = resources[levels].size;
 });
 
@@ -31,7 +31,7 @@ const spawn = System.create(({ commands }) => {
     commands.spawn([volume])({ [volume]: 0.3 });
 });
 
-const countVoices = System.create({ observer: true }, ({ resources }) => resources[levels].size);
+const countVoices = System.create({ readonly: true }, ({ resources }) => resources[levels].size);
 
 /** Waits a turn of the event loop at a time until `done`, for two seconds at most. */
 const until = async (done: () => boolean): Promise<void> => {

package/src/guide/20-shared.ts

@@ -56,7 +56,7 @@ let drawn = 0;
 let left = Infinity;
 let right = -Infinity;
 const draw = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [position], where: { [cell]: (at, { resources }) => resources[camera]?.sees(at) === true } },
 }, row => {
     drawn += 1;
@@ -66,7 +66,7 @@ const draw = System.create({
 
 let refreshed = 0;
 const refresh = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [position], changed: [position], where: { [cell]: (at, { resources }) => resources[camera]?.sees(at) === true } },
 }, () => {
     refreshed += 1;
@@ -74,7 +74,7 @@ const refresh = System.create({
 
 // Only chunk [4, 0], which no unit is in until one crosses into it.
 let east = 0;
-const countEast = System.create({ observer: true, components: { with: [position], where: { [cell]: [4, 0] } } }, () => {
+const countEast = System.create({ readonly: true, components: { with: [position], where: { [cell]: [4, 0] } } }, () => {
     east += 1;
 });
 

package/src/guide/21-dom.md

@@ -13,9 +13,9 @@ same.
 Each tick runs one composite:
 
 1. [`move`](21-dom.ts#L38-L44) moves every particle and turns it back from the walls.
-2. [`create`](21-dom.ts#L46-L51) gives each particle without a dot an element, with `commands.add`. Observers can't
+2. [`create`](21-dom.ts#L46-L51) gives each particle without a dot an element, with `commands.add`. Readonly systems can't
    issue commands, so it ticks, and its condition `is: [stage]` waits for a stage.
-3. [`draw`](21-dom.ts#L52-L60), an observer, sets each moved dot's `style.translate`, a transform, which the page
+3. [`draw`](21-dom.ts#L52-L60), a readonly system, sets each moved dot's `style.translate`, a transform, which the page
    doesn't lay out again. `changed: [position]` skips the dots that didn't move.
 
 [A finalizer](21-dom.ts#L61-L63) removes a particle's element when the particle goes, and every element when the

package/src/guide/21-dom.ts

@@ -51,7 +51,7 @@ const create = System.create({ components: { with: [position], not: [dot] }, res
 });
 // Moves each dot whose particle moved, by a transform, which the page doesn't lay out again.
 const draw = System.create({
-    observer: true,
+    readonly: true,
     components: { with: [position, dot], optional: [traced], changed: [position] },
 }, (row, { resources }) => {
     const [x, y] = row[position];

package/src/guide/22-canvas.md

@@ -2,7 +2,7 @@
 
 The same particles, drawn in immediate mode: each frame, the canvas is cleared and drawn again whole.
 
-[`draw`](22-canvas.ts#L52-L80) is one observer without components, so it runs once per tick, not per particle.
+[`draw`](22-canvas.ts#L52-L80) is one readonly system without components, so it runs once per tick, not per particle.
 
 - `changed: [clock]` runs it after every tick, and `is: [pen]` waits for a 2D context.
 - It reads every particle through [an index without a key](22-canvas.ts#L50-L51), `key: []`, and the traced one

package/src/guide/22-canvas.ts

@@ -51,7 +51,7 @@ const particles = Index.create({ key: [], components: { with: [position] } });
 const tracedOnes = Index.create({ key: [], components: { with: [position, traced] } });
 // Clears the canvas and draws every particle, after each tick.
 const draw = System.create({
-    observer: true,
+    readonly: true,
     resources: { is: [pen], changed: [clock] },
     lookup: { particles: { index: particles }, traced: { index: tracedOnes } },
 }, ({ resources, lookup }) => {

package/src/guide/CLAUDE.md

@@ -45,5 +45,5 @@ it in `NN-name.type-test.ts`, under a `// @ts-expect-error` that the package's b
   before they're printed.
 - Keys are `Symbol()` with no description: the build's id names each by its binding.
 - Archetypes are types, so their names are PascalCase: `const Particle = [position, velocity] as const`.
-- Use the public API only, as a consumer imports it, not internal modules. Read a world through observer systems.
+- Use the public API only, as a consumer imports it, not internal modules. Read a world through readonly systems.
 - Lines change as code does: the test of links fails on any that no longer covers whole code, so move them with it.

package/src/guide/guide.test.ts

@@ -1,80 +1,15 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { formatWithOptions } from "node:util";
-import ts from "typescript";
-import { afterAll, expect, it, vi } from "vitest";
-
-/**
- * Each chapter here is its prose, `NN-name.md`, and a program, which its `main` runs. Run, it prints what the `.out`
- * file beside it says: a line per console call, as node writes its values, on one line each. Ids name the package's
- * version, which is left out of the comparison, so a new version changes no example. The folder is read as the test
- * runs, not through `import.meta.glob`, which vitest's cache of transformed modules would keep as of the test's first
- * run, missing a chapter added since.
- */
-const folder = new URL(".", import.meta.url);
-const files = readdirSync(folder);
-const read = (file: string): string => readFileSync(new URL(file, folder), "utf8");
-const names = files.filter(file => /^\d+-[\w-]+\.ts$/.test(file) && !file.endsWith(".type-test.ts")).map(file => file.slice(0, -".ts".length)).sort();
-const proseFiles = files.filter(file => /^\d+-[\w-]+\.md$/.test(file)).sort();
-/** Where the mutation tests write each program changed: `.mutants` in the package. */
-const mutants = new URL("../../.mutants/", import.meta.url);
-afterAll(() => rmSync(mutants, { recursive: true, force: true }));
-
-const levels = ["log", "info", "warn", "error", "debug"] as const;
-const unversioned = (text: string): string => text.replace(/@adobe\/ecs@[^/\s]+\//g, "@adobe/ecs/");
-const chapterOf = (file: string): number => Number(/^(\d+)-/.exec(file)?.[1]);
-
-/** What `main` prints, a line per console call, and how it failed, if it did. */
-const printed = async (main: () => Promise<void>): Promise<string> => {
-    const lines: string[] = [];
-    const spies = levels.map(level => vi.spyOn(console, level).mockImplementation((...values: unknown[]) => {
-        lines.push(formatWithOptions({ breakLength: Infinity, compact: true }, ...values));
-    }));
-    try {
-        await main();
-    } catch (error) {
-        lines.push(`main failed: ${String(error)}`);
-    } finally {
-        for (const spy of spies) spy.mockRestore();
-    }
-    return lines.map(line => `${line}\n`).join("");
-};
-
-/** What a program prints, run from its file, or how it failed, as a declaration the world rejects fails its import. */
-const run = (file: URL): Promise<string> => printed(async () => {
-    const program: unknown = await import(/* @vite-ignore */ file.href);
-    const main: unknown = Reflect.get(Object(program), "main");
-    if (typeof main !== "function") throw new Error(`${file.pathname} exports no main`);
-    await Reflect.apply(main, undefined, []);
-});
-
-/** Code without its comments, as TypeScript prints it. */
-const withoutComments = (source: string): string =>
-    ts.createPrinter({ removeComments: true }).printFile(ts.createSourceFile("program.ts", source, ts.ScriptTarget.ESNext, false));
-
-/** Each chapter's code: its files', without comments. */
-const codeOf = (chapter: number): string =>
-    files.filter(file => file.endsWith(".ts") && !file.endsWith(".test.ts") && chapterOf(file) === chapter).map(file => withoutComments(read(file))).join("\n");
-
-/** What prose shows as code: its inline code and its blocks. */
-const shownIn = (prose: string): readonly string[] => [...prose.matchAll(/```\w*\n([\s\S]*?)```|`([^`\n]+)`/g)].map(([, block, inline]) => block ?? inline ?? "");
-
-/** Each link of the prose to lines of a program, which the interactive guide shows in its editor: `NN-name.ts#L4-L9`. */
-const editorLinks = proseFiles.flatMap(prose => [...read(prose).matchAll(/\]\(([^)#\s]*)#L(\d+)(?:-L(\d+))?\)/g)].map(([, file = "", from = "", to]) =>
-    ({ prose, file, from: Number(from), to: Number(to ?? from) })));
-
-/** The chapters the guide's index lists, in order: each its number, title and prose. */
-const listed = [...read("README.md").matchAll(/^(?:- |(\d+)\. )\[([^\]]+)\]\(([^)]+)\)$/gm)].map(([, number = "0", title = "", file = ""]) => ({ number: Number(number), title, file }));
+import { checkChapters } from "ecs-guide-checks";
 
 /** What each chapter teaches, which its prose names as code and its program does; 0 is the unnumbered keys chapter's. */
 const teaches: { readonly [chapter: number]: readonly string[] } = {
     0: ["Symbol()", "declare module \"@adobe/ecs\"", "Components", "Resources", "row[score]", "resources[bonus]", "default"],
-    1: ["Resources", "default", "World.create", "observer: true", "run", "ReadonlyMap", "Entity"],
+    1: ["Resources", "default", "World.create", "readonly: true", "run", "ReadonlyMap", "Entity"],
     2: ["Components", "type: true", "as const", "commands.spawn", "commands.remove", "with: [...Particle]"],
-    3: ["System.create", "with", "not", "observer: true", "optional: [velocity]"],
+    3: ["System.create", "with", "not", "readonly: true", "optional: [velocity]"],
     4: ["clock", "delta", "cadence", "always", "resources: { changed: [elapsed] }", "wake", "reduce[wake]", "world.add", "world.remove"],
     5: ["after", "during", "System.create([heal, hit])", "during: [update]"],
-    6: ["commands.spawn", "commands.add", "commands.despawn", "after: [spawn]"],
+    6: ["commands.spawn", "commands.add", "commands.despawn", "after: [spawn]", "readonly: true"],
     7: ["resources: { changed: [level] }", "changed: [score]", "resources: { is: [map], not: [paused] }", "resources[map]"],
     8: ["world.run(hit, { amount: 3 })", "target: \"entity\""],
     9: ["Rule.create", "derived: true"],
@@ -106,10 +41,12 @@ const mutations: { readonly [chapter: number]: readonly (readonly [string, strin
     ],
     1: [["World.create({ [gravity]: -1.6 })", "World.create()"], ["default: -9.8 ", ""], ["{ default: -Infinity }", "{}"]],
     2: [["commands.remove(row.entity, enemy);", ""], ["{ [position]: [0, 10, 0] }", "{}"]],
-    3: [["not: [frozen]", "not: []"], ["System.create([count, fail])", "System.create([fail])"]],
+    3: [
+        ["not: [frozen]", "not: []"], ["System.create([count, fail])", "System.create([fail])"],
+    ],
     4: [["world.remove(advance);", ""]],
     5: [["after: [hit] ", ""], ["during: [update] ", ""]],
-    6: [["commands.add(hero, health, 5);", ""], ["commands.despawn(commands.spawn([health])({ [health]: 1 }));", "commands.spawn([health])({ [health]: 1 });"], ["watched.add(watch);", ""]],
+    6: [["commands.add(hero, health, 5);", ""], ["after: [spawn] ", ""], ["commands.despawn(commands.spawn([health])({ [health]: 1 }));", "commands.spawn([health])({ [health]: 1 });"], ["watched.add(watch);", ""], ["const watch = System.create({ readonly: true, ", "const watch = System.create({ "]],
     7: [["resources: { changed: [level] } ", ""], [", changed: [score]", ""], [", not: [paused]", ""], ["is: [map], ", ""]],
     8: [["target: \"entity\",", ""]],
     9: [["with: [mesh], not: [hidden]", "with: [mesh]"], ["Rule.create({ components: { with: [sprite], not: [hidden] }, derive: [drawn] });", ""], ["Rule.create({ components: { with: [drawn] }, derive: [layer] });", ""]],
@@ -130,86 +67,4 @@ const mutations: { readonly [chapter: number]: readonly (readonly [string, strin
     22: [["context.fill();", ""]],
 };
 
-it("has prose and an expected output beside each program, and none without one, and Setup's prose", () => {
-    expect(files.filter(file => file.endsWith(".out")).map(file => file.slice(0, -".out".length)).sort()).toEqual(names);
-    expect(proseFiles).toEqual(["00-setup.md", ...names.map(name => `${name}.md`)].sort());
-});
-
-it("lists every chapter in its index, the unnumbered first, numbered as its files are and by the title its prose gives", () => {
-    expect(listed.map(chapter => chapter.file).sort()).toEqual(proseFiles);
-    expect(listed.map(chapter => chapter.number)).toEqual(listed.map(chapter => chapter.number).sort((a, b) => a - b));
-    for (const { number, title, file } of listed) {
-        expect(number).toBe(chapterOf(file));
-        const [heading, ...rest] = read(file).split("\n");
-        expect(heading).toBe(`# ${title}`);
-        expect(rest.join("\n").trim()).not.toBe("");
-    }
-});
-
-it.each(names)("%s prints what its .out says", async name => {
-    const expected = read(`${name}.out`);
-    expect(expected.trim()).not.toBe("");
-    expect(unversioned(await run(new URL(`${name}.ts`, folder)))).toBe(unversioned(expected));
-});
-
-it.each(Object.entries(teaches))("chapter %s's prose names what it teaches, as code, and its program does it", (chapter, taught) => {
-    const prose = `${names.find(name => chapterOf(name) === Number(chapter)) ?? ""}.md`;
-    const shown = shownIn(read(prose)).join("\n");
-    const code = codeOf(Number(chapter));
-    expect(taught.filter(name => !shown.includes(name))).toEqual([]);
-    expect(taught.filter(name => !code.includes(name))).toEqual([]);
-});
-
-it("teaches something in every chapter", () => {
-    expect(Object.keys(teaches).map(Number)).toEqual(names.map(chapterOf));
-});
-
-it("keeps code in the prose to a line or two, the program in the editor showing the rest", () => {
-    const long = proseFiles.flatMap(file => [...read(file).matchAll(/```\w*\n([\s\S]*?)```/g)].filter(([, block = ""]) => block.split("\n").length > 3).map(() => file));
-    expect(long).toEqual([]);
-});
-
-it("links chapters only to chapters there are", () => {
-    const chapterLinks = proseFiles.flatMap(file => [...read(file).matchAll(/\]\(([^)#\s]+\.md)\)/g)].map(([, target = ""]) => target));
-    expect(chapterLinks.length).toBeGreaterThan(0);
-    expect(chapterLinks.filter(target => !proseFiles.includes(target))).toEqual([]);
-});
-
-/** The messages of TypeScript's syntax errors in code. */
-const syntaxErrors = (code: string): readonly string[] => {
-    const { diagnostics = [] } = ts.transpileModule(code, { reportDiagnostics: true, compilerOptions: { target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext } });
-    return diagnostics.map(diagnostic => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
-};
-
-it.each(editorLinks.map(link => [`${link.prose} to ${link.file}#L${link.from}-L${link.to}`, link] as const))("links %s, lines of its own program that are whole code", (_place, { prose, file, from, to }) => {
-    expect(file.startsWith(prose.replace(/\.md$/, "."))).toBe(true);
-    const lines = read(file).split("\n");
-    expect(from).toBeGreaterThanOrEqual(1);
-    expect(to).toBeGreaterThanOrEqual(from);
-    expect(to).toBeLessThanOrEqual(lines.length);
-    const code = lines.slice(from - 1, to).join("\n");
-    expect(withoutComments(code).trim()).not.toBe("");
-    expect(lines[from - 1]?.trim()).not.toBe("");
-    expect(lines[to - 1]?.trim()).not.toBe("");
-    // Lines cut short leave a brace or a call open, which parses neither as statements nor as a declaration's members.
-    expect(syntaxErrors(code).length === 0 || syntaxErrors(`interface Members {\n${code}\n}`).length === 0 ? [] : syntaxErrors(code)).toEqual([]);
-});
-
-it.each(Object.entries(mutations).flatMap(([chapter, changes]) => changes.map(([from, to, failure], index) => [Number(chapter), from, to, failure, index] as const)))(
-    "catches chapter %s's point taken away, %j, in its output", async (chapter, from, to, failure, index) => {
-        const name = names.find(item => chapterOf(item) === chapter) ?? "";
-        const source = read(`${name}.ts`);
-        expect(source.split(from).length).toBe(2);
-        // A file of the package's own, compiled as the program is, outside its sources, which other tests read.
-        const mutant = `${name}-${index}.ts`;
-        mkdirSync(mutants, { recursive: true });
-        const file = new URL(mutant, mutants);
-        writeFileSync(file, source.replace(from, to).replace(` from "../index.js";`, ` from "../src/index.js";`));
-        try {
-            const output = (await run(file)).replaceAll(`.mutants/${mutant}`, `src/guide/${name}.ts`);
-            expect(unversioned(output)).not.toBe(unversioned(read(`${name}.out`)));
-            if (failure !== undefined) expect(output).toContain(failure);
-        } finally {
-            rmSync(file, { force: true });
-        }
-    });
+checkChapters({ folder: new URL(".", import.meta.url), teaches, mutations });