@adobe/ecs 0.1.0 → 0.2.0

package/src/implementation/compiler/link.ts

@@ -1,5 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Program } from 'estree';
 import { createModule, locateIn, type Module, type ModuleBinding } from './module-scope.js';
+import type { PackageCopies } from './package-copies.js';
 
 /**
  * Why a specifier names no file the linker can read. `unreadable` marks one the build leaves unread, such as a package
@@ -13,6 +15,12 @@ export type LinkHost = {
     readonly resolve: (specifier: string, importer: string) => Promise<string | Unresolved>;
     /** A file's code as JavaScript, and how offsets in it map to source lines when it was compiled from another language. */
     readonly load: (file: string) => Promise<{ readonly code: string; readonly locate?: Module["locate"] } | { readonly error: string }>;
+    /** The operator each resource a file declares with a `reduce` trait reduces with, by its key's binding. */
+    readonly reductions?: (file: string) => ReadonlyMap<string, string>;
+    /** The components a file declares `shared`, by their keys' bindings. */
+    readonly shared?: (file: string) => ReadonlySet<string>;
+    /** The copies of the package the files are in. */
+    readonly packages: PackageCopies;
 };
 
 /**
@@ -22,6 +30,12 @@ export type LinkHost = {
 export type Link = {
     readonly module: (file: string) => Module | { readonly error: string };
     readonly resolve: (specifier: string, importer: string) => string | Unresolved;
+    /** The operator the resource `binding` of `file` declares in its `reduce` trait, if the build can read one. */
+    readonly reductionOf?: (file: string, binding: string) => string | undefined;
+    /** Whether the component `binding` of `file` declares `shared: true`, so kernels read its value per call. */
+    readonly sharedOf?: (file: string, binding: string) => boolean;
+    /** The copies of the package the modules are in. */
+    readonly packages: PackageCopies;
 };
 
 /** A cache of modules and resolutions shared across transforms. */
@@ -107,12 +121,27 @@ export const createLinker = (host: LinkHost, parse: (code: string) => Program):
         for (const exported of module.exports.values()) if (exported.kind !== "local") void prefetch(exported.specifier, file);
         for (const star of module.stars) void prefetch(star, file);
     };
+    const reductions = new Map<string, ReadonlyMap<string, string>>();
+    const shared = new Map<string, ReadonlySet<string>>();
     return {
         module: file => modules.get(file) ?? pending(startLoad(file)),
+        reductionOf: (file, binding) => {
+            let declared = reductions.get(file);
+            if (declared === undefined && host.reductions !== undefined) reductions.set(file, declared = host.reductions(file));
+            return declared?.get(binding);
+        },
+        sharedOf: (file, binding) => {
+            let declared = shared.get(file);
+            if (declared === undefined && host.shared !== undefined) shared.set(file, declared = host.shared(file));
+            return declared?.has(binding) === true;
+        },
         resolve: (specifier, importer) => resolutions.get(`${importer}\0${specifier}`) ?? pending(prefetch(specifier, importer)),
+        packages: host.packages,
         add: module => { modules.set(module.file, module); },
         forget: (file, all) => {
             modules.delete(file);
+            reductions.delete(file);
+            shared.delete(file);
             loading.delete(file);
             versions.set(file, (versions.get(file) ?? 0) + 1);
             if (all) {

package/src/implementation/compiler/lists.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { ArrayExpression, Expression, Node } from 'estree';
 import { children } from './estree.js';
 import { resolveBinding, resolveExport, type Link, type Resolved } from './link.js';
@@ -10,7 +11,7 @@ export type ListNames = readonly string[] | { readonly error: string };
 export type Lists = {
     /**
      * The keys a list names: an array literal of the kernel's module-scope identifiers, or a constant, of the kernel's
-     * module or imported through any re-exports and namespaces, holding an array literal or `Archetype.create` of one.
+     * module or imported through any re-exports and namespaces, holding an array literal.
      * A key of another module's list is named by the kernel's binding of the same definition, or else by the list
      * itself, as `List[k]`.
      */
@@ -22,6 +23,14 @@ export type Lists = {
      * external to it, is taken as a key, and registration rejects a list there. Anything else fails with the reason.
      */
     readonly component: (node: Node) => Named;
+    /** Whether the component the kernel's module names `name` is declared `shared`, read through the build from the module declaring it. */
+    readonly shared: (name: string) => boolean;
+    /**
+     * The operator the resource the kernel's module names `name` reduces with, its declaration's `reduce` trait, read
+     * through the build from the module declaring it, undefined where the build can't read one, and that module's file;
+     * null for a name the module doesn't bind.
+     */
+    readonly reduction: (name: string) => { readonly operator: string | undefined; readonly file: string } | null;
 };
 
 /** What a command's component argument names, or why the compiler can't tell. */
@@ -49,14 +58,11 @@ const isKey = (node: Expression, module: Module): boolean => {
     return module.bindings.get(node.callee.name)?.kind === "function" && symbol !== undefined && symbol.type !== "SpreadElement" && isSymbolCall(symbol, module);
 };
 
-/** `Archetype.create(<array literal>)`, with `Archetype` imported under any name: its array literal, else null. */
-const createdList = (node: Expression, module: Module): ArrayExpression | null => {
-    if (node.type !== "CallExpression" || node.arguments.length !== 1) return null;
-    const { callee } = node;
-    if (callee.type !== "MemberExpression" || callee.computed || callee.object.type !== "Identifier" || callee.property.type !== "Identifier" || callee.property.name !== "create") return null;
-    const binding = module.bindings.get(callee.object.name);
+/** A list's literal as the plugin gives it an index, `archetype$([...])` with its appended function: the literal, else null. */
+const indexedList = (node: Expression, module: Module): ArrayExpression | null => {
+    if (node.type !== "CallExpression" || node.arguments.length !== 1 || node.callee.type !== "Identifier" || !/^archetype\$\d*$/.test(node.callee.name)) return null;
     const [list] = node.arguments;
-    return binding?.kind === "import" && binding.imported === "Archetype" && list.type === "ArrayExpression" ? list : null;
+    return module.bindings.get(node.callee.name)?.kind === "function" && list.type === "ArrayExpression" ? list : null;
 };
 
 const fileOf = (module: Module, kernel: Module): string => module === kernel ? "this module" : module.file;
@@ -71,14 +77,14 @@ const follow = (name: string, binding: ModuleBinding, module: Module, kernel: Mo
         case "const": {
             const { init } = binding;
             if (init.type === "ArrayExpression") return { literal: init, module, reference };
-            const created = createdList(init, module);
-            if (created !== null) return { literal: created, module, reference };
+            const indexed = indexedList(init, module);
+            if (indexed !== null) return { literal: indexed, module, reference };
             if (init.type === "Identifier") {
                 const aliased = module.bindings.get(init.name);
                 if (aliased !== undefined) return follow(init.name, aliased, module, kernel, link, reference, wanted, seen);
             }
             if (isKey(init, module)) return { key: identity };
-            const declare = wanted === "list" ? "declare it as an array literal, or Archetype.create of one" : "declare a key as Symbol(...), or a list as an array literal or Archetype.create of one";
+            const declare = wanted === "list" ? "declare it as an array literal, `as const`" : "declare a key as Symbol(...), or a list as an array literal, `as const`";
             return { error: `${reference} is computed when ${fileOf(module, kernel)} runs, so ${unread}; ${declare}` };
         }
         case "import": case "importNamespace":
@@ -110,7 +116,7 @@ const chain = (node: Node): readonly string[] | null => {
 const find = (node: Node, kernel: Module, link: Link | null, wanted: Wanted): Followed => {
     if (node.type === "ArrayExpression") return { literal: node, module: kernel, reference: "" };
     const names = chain(node);
-    if (names === null) return { error: "commands and kernel declarations name a list as an array literal, or a constant holding one or Archetype.create of one" };
+    if (names === null) return { error: "commands and kernel declarations name a list as an array literal, or a constant holding one" };
     const [first, ...members] = names;
     const reference = names.join(".");
     const binding = kernel.bindings.get(first);
@@ -175,6 +181,13 @@ export const createLists = (kernel: Module, link: Link | null, nodes: readonly N
         const result: string[] = [];
         for (let k = 0; k < literal.elements.length; k++) {
             const element = literal.elements[k];
+            // The kernel's own list may spread another it can read: `with: [...Unit, tagged]`.
+            if (element?.type === "SpreadElement" && module === kernel) {
+                const spread = names(element.argument);
+                if ("error" in spread) return spread;
+                result.push(...spread);
+                continue;
+            }
             const binding = element?.type === "Identifier" ? module.bindings.get(element.name) : undefined;
             if (element?.type !== "Identifier" || binding === undefined) {
                 return { error: module === kernel ? "lists name keys by identifiers bound at module scope" : `${reference} names a key by something other than an identifier bound at the scope of ${module.file}` };
@@ -198,5 +211,20 @@ export const createLists = (kernel: Module, link: Link | null, nodes: readonly N
         // its definition where it has one.
         return { kind: "key", name: node.type === "Identifier" || found.key === null ? reference : nameOf(found.key, reference) };
     };
-    return { names, component };
+    const reduction = (name: string): { readonly operator: string | undefined; readonly file: string } | null => {
+        const binding = kernel.bindings.get(name);
+        const identity = binding === undefined ? null : definition(kernel, name, binding, link);
+        if (identity === null) return null;
+        const [file = "", defined = ""] = identity.split("\0");
+        return { operator: link?.reductionOf?.(file, defined), file };
+    };
+    /** Whether a key the kernel names is a shared component, as its declaration's module says. */
+    const shared = (name: string): boolean => {
+        const binding = kernel.bindings.get(name);
+        const identity = binding === undefined ? null : definition(kernel, name, binding, link);
+        if (identity === null) return false;
+        const [file = "", defined = ""] = identity.split("\0");
+        return link?.sharedOf?.(file, defined) === true;
+    };
+    return { names, component, reduction, shared };
 };

package/src/implementation/compiler/lookups.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import type { Expression, Node, ObjectExpression, Pattern, SpreadElement } from 'estree';
 import { children, declaredIn } from './estree.js';
 

package/src/implementation/compiler/math.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 /** The `Math` functions allowed in kernels: pure and deterministic. */
 export const mathFunctions: ReadonlySet<string> = new Set([
     "abs", "sign", "floor", "ceil", "round", "trunc", "min", "max", "sqrt", "cbrt", "hypot",

package/src/implementation/compiler/memory-compiler.browser.test.ts

@@ -0,0 +1,85 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="vite/client" />
+import { instantiate as instantiateParser } from "@oxc-parser/binding-wasm32-wasip1/workerd";
+import parserUrl from "@oxc-parser/binding-wasm32-wasip1/wasm?url";
+import { instantiate as instantiateTransformer } from "@oxc-transform/binding-wasm32-wasip1/workerd";
+import transformerUrl from "@oxc-transform/binding-wasm32-wasip1/wasm?url";
+import { expect, it } from "vitest";
+import { createMemoryCompiler, type MemoryCompiled } from "./memory-compiler.js";
+import { oxcParse, oxcStrip } from "./oxc.js";
+import { gpu } from "../world/gpu.test-helper.js";
+
+// The compiler's core in chromium: oxc's WASM bindings loaded as a page loads them, and the package's sources in
+// memory, laid out as installed.
+
+const root = "/node_modules/@adobe/ecs";
+const sources: { readonly [path: string]: string } = import.meta.glob(["../../index.ts", "../../interface/**/*.ts", "!../../**/*.test.ts", "!../../**/*.type-test.ts"], { query: "?raw", import: "default", eager: true });
+const guide: { readonly [path: string]: string } = import.meta.glob("../../guide/[0-9]*.ts", { query: "?raw", import: "default", eager: true });
+
+/** The package's files in memory: each path relative to `src/implementation/compiler`, at the package's `src`. */
+const files = new Map<string, string>([
+    [`${root}/package.json`, JSON.stringify({ name: "@adobe/ecs", version: "0.0.0", exports: { ".": { import: "./dist/index.js" } } })],
+    ...Object.entries({ ...sources, ...guide }).map(([path, text]): [string, string] => [`${root}/src/${path.slice("../../".length)}`, text]),
+]);
+
+const compilerOf = async () => {
+    const [parser, transformer] = await Promise.all([
+        WebAssembly.compileStreaming(fetch(parserUrl)).then(instantiateParser),
+        WebAssembly.compileStreaming(fetch(transformerUrl)).then(instantiateTransformer),
+    ]);
+    return createMemoryCompiler({ files, packageRoot: root, parse: oxcParse(parser), strip: oxcStrip(transformer) });
+};
+let loading: ReturnType<typeof compilerOf> | null = null;
+
+const compiled = async (file: string, code: string): Promise<MemoryCompiled> =>
+    (await (loading ??= compilerOf())).compile(file, code, index => JSON.stringify(`kernel:${index}`));
+
+it("compiles a guide module's kernels, keys and systems, from files in memory", async () => {
+    const file = `${root}/src/guide/14-kernels.ts`;
+    const result = await compiled(file, files.get(file) ?? "");
+    if ("failure" in result) throw new Error(result.failure);
+    expect(result.kernels).toHaveLength(2);
+    expect(result.code).toContain(`"@adobe/ecs@0.0.0/src/guide/14-kernels.ts#position"`);
+    expect(result.code).toContain(`"@adobe/ecs@0.0.0/src/guide/14-kernels.ts#drift"`);
+    expect(result.code).toContain(`from "${root}/dist/implementation/world/attach-kernel.js"`);
+    expect(result.code).toContain(`url: "kernel:1"`);
+    // Each kernel's module runs as a module of its own.
+    for (const kernel of result.kernels) {
+        const module: unknown = await import(/* @vite-ignore */ `data:text/javascript,${encodeURIComponent(kernel)}`);
+        expect(typeof Reflect.get(Object(module), "create")).toBe("function");
+    }
+});
+
+it("fails a body the build rejects, located in the module's source", async () => {
+    const file = `${root}/src/guide/03-systems.ts`;
+    const source = files.get(file) ?? "";
+    const edited = source.replace("(row, { resources }) => {\n    // Values", "async (row, { resources }) => {\n    // Values");
+    const result = await compiled(file, edited);
+    expect(result).toMatchObject({ failure: expect.stringContaining("a body can't be async"), location: { line: source.split("\n").findIndex(line => line.includes("// Values")) } });
+});
+
+it("fails a module that doesn't parse, at the error", async () => {
+    const result = await compiled(`${root}/src/guide/broken.ts`, "import { System } from \"../index.js\";\nconst a = ;\n");
+    expect(result).toMatchObject({ failure: expect.stringContaining("Unexpected token"), location: { line: 2 } });
+});
+
+it.runIf(gpu)("describes the systems of the kernel chapters, their WGSL a shader module the GPU compiles without an error", async () => {
+    const shaders: string[] = [];
+    for (const chapter of ["14-kernels", "16-gpu"]) {
+        const file = `${root}/src/guide/${chapter}.ts`;
+        const result = await (loading ??= compilerOf()).then(compiler => compiler.compile(file, files.get(file) ?? "", index => JSON.stringify(`kernel:${index}`), { describe: true }));
+        if ("failure" in result) throw new Error(result.failure);
+        const move = result.systems?.find(system => system.binding === "move");
+        expect(move?.wasm).toMatchObject({ kind: "compiled", code: expect.stringContaining("(func $run (type 0) (param $start i32)") });
+        for (const system of result.systems ?? []) if ("code" in system.wgsl) shaders.push(system.wgsl.code);
+    }
+    expect(shaders).toHaveLength(4);
+    const adapter = await navigator.gpu?.requestAdapter();
+    if (adapter === null || adapter === undefined) throw new Error("No WebGPU adapter.");
+    const device = await adapter.requestDevice();
+    for (const code of shaders) {
+        const info = await device.createShaderModule({ code }).getCompilationInfo();
+        expect(info.messages.filter(message => message.type === "error").map(message => message.message)).toEqual([]);
+    }
+    device.destroy();
+});

package/src/implementation/compiler/memory-compiler.test.ts

@@ -0,0 +1,147 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/// <reference types="node" />
+import { readdirSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+import { createServer, type ViteDevServer } from 'vite';
+import { createMemoryCompiler, type MemoryCompiler } from './memory-compiler.js';
+import { wasmHost } from './oxc.test-helper.js';
+import { plugin } from './plugin.js';
+
+const root = fileURLToPath(new URL("../../..", import.meta.url)).replace(/\/$/, "");
+const filesIn = (folder: string, extension: string): readonly string[] =>
+    readdirSync(`${root}/${folder}`, { recursive: true, encoding: "utf8" }).filter(file => file.endsWith(extension)).map(file => `${root}/${folder}/${file}`);
+/** The guide's examples: its programs and its type test. */
+const guide = filesIn("src/guide", ".ts").filter(file => /\/src\/guide\/\d+-[^/]+\.ts$/.test(file));
+
+/** The package's files where they are, its sources and its build, read into memory. */
+const files = new Map([`${root}/package.json`, ...filesIn("src", ".ts"), ...filesIn("dist", ".js")].map(file => [file, readFileSync(file, "utf8")]));
+
+/** Code with its imports' specifiers and its kernels' urls left out, which name files where each build serves them. */
+const normalized = (code: string): string => code.replace(/ from "[^"]*"/g, ` from "*"`).replace(/^url: "[^"]*",$/gm, "url: *,");
+
+let server: ViteDevServer;
+let compiler: MemoryCompiler;
+beforeAll(async () => {
+    server = await createServer({
+        root, configFile: false, logLevel: "silent", plugins: [plugin()], appType: "custom",
+        server: { middlewareMode: true, hmr: false, ws: false }, optimizeDeps: { noDiscovery: true, include: [] },
+    });
+    const { parse, strip } = await wasmHost();
+    compiler = createMemoryCompiler({ files, packageRoot: root, parse, strip });
+}, 60000);
+afterAll(async () => {
+    await server.close();
+});
+
+/** What the plugin, serving `file` with `code` in place of its own, gives: its code and its kernels' modules, or its error. */
+const served = async (file: string): Promise<{ readonly code: string; readonly kernels: readonly string[] } | { readonly failure: string }> => {
+    try {
+        const result = await server.transformRequest(file.slice(root.length));
+        if (result === null) return { failure: "nothing served" };
+        const urls = [...result.code.matchAll(/^url: "([^"]*)",$/gm)].map(([, url]) => url ?? "");
+        const kernels = await Promise.all(urls.map(async url => (await server.transformRequest(url))?.code ?? ""));
+        return { code: result.code, kernels };
+    } catch (error) {
+        return { failure: error instanceof Error ? error.message : String(error) };
+    }
+};
+
+describe("the memory compiler", () => {
+    test.each(guide.map(file => [file.slice(root.length + 1), file]))("compiles %s as the plugin serves it", async (_name, file) => {
+        const expected = await served(file);
+        const compiled = await compiler.compile(file, files.get(file) ?? "", index => JSON.stringify(`kernel:${index}`));
+        if ("failure" in expected || "failure" in compiled) throw new Error("failure" in expected ? expected.failure : "failure" in compiled ? compiled.failure : "");
+        expect(normalized(compiled.code)).toBe(normalized(expected.code));
+        expect(compiled.kernels.map(kernel => kernel.trim())).toEqual(expected.kernels.map(kernel => kernel.trim()));
+    });
+
+    test("compiles a module that isn't among its files as one that is, reading what the module declares from the code given", async () => {
+        const file = `${root}/src/guide/15-reductions.ts`;
+        const elsewhere = new Map([...files].filter(([path]) => path !== file));
+        const { parse, strip } = await wasmHost();
+        const compiled = await createMemoryCompiler({ files: elsewhere, packageRoot: root, parse, strip }).compile(file, files.get(file) ?? "", index => JSON.stringify(`kernel:${index}`));
+        const expected = await served(file);
+        if ("failure" in expected || "failure" in compiled) throw new Error("failure" in expected ? expected.failure : "failure" in compiled ? compiled.failure : "");
+        expect(compiled.kernels).toHaveLength(expected.kernels.length);
+        expect(normalized(compiled.code)).toBe(normalized(expected.code));
+    });
+
+    test("compiles a module of the package again after an edit from its new code, not the syntax it last parsed", async () => {
+        const file = `${root}/src/guide/13-indexes.ts`;
+        const source = files.get(file) ?? "";
+        const { parse, strip } = await wasmHost();
+        const again = createMemoryCompiler({ files, packageRoot: root, parse, strip });
+        await again.compile(file, source, index => JSON.stringify(`kernel:${index}`));
+        const edited = source.replace("        [cell]: { type: Vec2.I32 };\n", "        [cell]: { type: Vec2.I32 };\n        // An edit inside the block.\n");
+        expect(edited).not.toBe(source);
+        const compiled = await again.compile(file, edited, index => JSON.stringify(`kernel:${index}`));
+        const fresh = await createMemoryCompiler({ files, packageRoot: root, parse, strip }).compile(file, edited, index => JSON.stringify(`kernel:${index}`));
+        expect(compiled).toEqual(fresh);
+        expect(compiled).not.toHaveProperty("failure");
+    });
+
+    test("locates a failure after text beyond ASCII at its column, as the editor counts it", async () => {
+        const file = `${root}/src/guide/03-systems.ts`;
+        const source = files.get(file) ?? "";
+        const edited = source.replace("}, (row, { resources }) => {\n    // Values", "}, /* résumé — naïve 😀 */ async (row, { resources }) => {\n    // Values");
+        const lines = edited.split("\n");
+        const line = lines.findIndex(text => text.includes("async (row")) + 1;
+        const compiled = await compiler.compile(file, edited, index => JSON.stringify(`kernel:${index}`));
+        expect(compiled).toMatchObject({ location: { line, column: (lines[line - 1] ?? "").indexOf("async") + 1 } });
+    });
+
+    test("gives a failure, as data, when its parser or type stripper throws", async () => {
+        const { parse } = await wasmHost();
+        const panicking = createMemoryCompiler({ files, packageRoot: root, parse, strip: () => { throw new Error("unreachable executed"); } });
+        const file = `${root}/src/guide/14-kernels.ts`;
+        expect(await panicking.compile(file, files.get(file) ?? "", index => JSON.stringify(`kernel:${index}`))).toEqual({ failure: "The compiler failed: unreachable executed", location: null });
+    });
+
+    test("fails a module the build rejects, with the plugin's message, located in its source", async () => {
+        const file = `${root}/src/guide/03-systems.ts`;
+        const source = files.get(file) ?? "";
+        let edited = source;
+        const editing = await createServer({
+            root, configFile: false, logLevel: "silent", appType: "custom", server: { middlewareMode: true, hmr: false, ws: false },
+            optimizeDeps: { noDiscovery: true, include: [] }, plugins: [{ name: "edited", enforce: "pre", load: id => id === file ? edited : null }, ...plugin()],
+        });
+        try {
+            // A body that's async, and one using a key its declaration doesn't require.
+            for (const [from, to] of [["(row, { resources }) => {\n    // Values", "async (row, { resources }) => {\n    // Values"], ["with: [velocity, position], not:", "with: [position], not:"]]) {
+                edited = source.replace(from ?? "", to ?? "");
+                expect(edited).not.toBe(source);
+                const compiled = await compiler.compile(file, edited, index => JSON.stringify(`kernel:${index}`));
+                if (!("failure" in compiled)) throw new Error("compiled");
+                const line = edited.split("\n").findIndex((text, index) => text !== source.split("\n")[index]) + 1;
+                expect(compiled.location?.line).toBeGreaterThanOrEqual(line);
+                expect(compiled.location?.line).toBeLessThanOrEqual(line + 2);
+                editing.moduleGraph.invalidateAll();
+                const message = await editing.transformRequest(file.slice(root.length)).then(() => "served", (error: unknown) => error instanceof Error ? error.message : String(error));
+                expect(message).toContain(compiled.failure);
+            }
+        } finally {
+            await editing.close();
+        }
+    }, 60000);
+
+    test("compiles a module of a package of its own, its keys' and systems' ids naming that package", async () => {
+        const guideFiles = new Map(files);
+        const file = "/guide/src/move.ts";
+        guideFiles.set("/guide/package.json", JSON.stringify({ name: "guide", version: "0.0.0" }));
+        guideFiles.set(file, `import { System, Vec3 } from "@adobe/ecs";
+export const position = Symbol();
+declare module "@adobe/ecs" { interface Components { [position]: { type: Vec3 } } }
+export const move = System.create({ components: { with: [position] } }, row => { row[position] = Vec3.add(row[position], [1, 0, 0]); });
+`);
+        for (const path of files.keys()) if (path.startsWith(root)) guideFiles.set(`/node_modules/@adobe/ecs${path.slice(root.length)}`, files.get(path) ?? "");
+        const { parse, strip } = await wasmHost();
+        const ownCompiler = createMemoryCompiler({ files: guideFiles, packageRoot: "/node_modules/@adobe/ecs", parse, strip });
+        const compiled = await ownCompiler.compile(file, guideFiles.get(file) ?? "", index => JSON.stringify(`kernel:${index}`));
+        if ("failure" in compiled) throw new Error(compiled.failure);
+        expect(compiled.code).toContain(`"guide@0.0.0/src/move.ts#position"`);
+        expect(compiled.code).toContain(`"guide@0.0.0/src/move.ts#move"`);
+        expect(compiled.code).toContain(`from "/node_modules/@adobe/ecs/dist/implementation/world/attach-kernel.js"`);
+        expect(compiled.kernels).toHaveLength(1);
+    });
+});