@decohere/flux 0.0.1-dev.104 → 0.0.1-dev.106

package/README.md

@@ -2,7 +2,7 @@
 
 In-process TypeScript load for Node.js ESM apps — either one-shot (`flux run`) or hot-reload serve (`flux serve`).
 
-Use Flux when you want to run source `.ts` directly. Flux transpiles with the **Forge** SWC compiler; that compiler uses path aliases Mesh builds dynamically from the workspace (`package.json` `name` → source `main`). Do not use Flux as a browser bundler, a worker-thread HMR, or a production process manager.
+Use Flux when you want to run source `.ts` directly. Flux transpiles with the **Forge** SWC compiler and maps imports to source with path aliases Mesh builds dynamically from the workspace (`package.json` `name` → source `main`). Do not use Flux as a browser bundler, a worker-thread HMR, or a production process manager.
 
 Point Flux at a tree of TypeScript packages (`package.json` at each project root). [Mesh](../mesh/README.md) is how that tree is deduced — you do not run Flux against Mesh. Layout and glob overrides: [Mesh — workspace layout](../mesh/README.md#workspace-layout).
 
@@ -214,7 +214,7 @@ Only source files (`.ts`) that a served entry imports trigger a reboot.
 
 **Memory grows over a long session.** Each reboot imports changed modules under a new `?version=` URL, and Node's ES module cache never releases the old versions. That's fine for a working day; if a session runs for days with thousands of reboots, restart it.
 
-Flux uses **Forge’s compiler**. Forge debug builds path aliases from Mesh (`name` → source `main`) and rewrites `import "@scope/pkg"` to that `.ts` file. That is a debug rule so you can edit a library and hit HMR without a pre-build or `node_modules` workspace symlink. Release still resolves through real `node_modules` (published `exports` / `main`).
+Flux uses **Forge’s compiler**, with one SWC config per project built once per run. SWC leaves imports as written; Flux's resolve hook maps each one to its `.ts` source: `@scope/pkg` and `@scope/pkg/sub` through the Mesh aliases (and tsconfig `paths`), `./file.js` and `./file` to `file.ts`, and `./dir` to `dir/index.ts`. Doing it in one place, instead of in SWC (`jsc.paths`, `resolveFully`) and again in the hook, made loading about 20% faster once Node and SWC are warm (`pnpm bench:flux`, #513). That is a debug rule so you can edit a library and hit HMR without a pre-build or `node_modules` workspace symlink. Release still resolves through real `node_modules` (published `exports` / `main`).
 
 Why aliases, and a tree of where a symlink misses `src/index.ts`: [Forge — debug path aliases](../forge/README.md#debug-path-aliases-not-node_modules-links).
 

package/commonjs/bench/load.bench.js

@@ -0,0 +1,145 @@
+/**
+ * Cold-load benchmark for flux: how long the load hook takes to compile and import a workspace
+ * whose files import each other, the way an app's do (#513).
+ *
+ *   pnpm bench:flux                        # 8 libraries × 40 files, 10 processes
+ *   BENCH_LIBS=4 BENCH_FILES=100 BENCH_RUNS=5 pnpm bench:flux
+ *
+ * Generates the workspace in a temp directory: each library re-exports a `models/` directory
+ * through its index (a directory import), each model imports the previous one (relative, with
+ * `.js`) and the previous library by package name, and has a decorated class. Each process
+ * imports the last library twice under different URL versions with a fresh loader cache, so
+ * both loads transpile every file: the first is a real cold start, the second runs with Node
+ * and SWC warmed up. Prints the median of each and the time per file.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _nodechild_process = require("node:child_process");
+const _nodefs = require("node:fs");
+const _nodeos = require("node:os");
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _nodeurl = require("node:url");
+const _forge = require("@decohere/forge");
+const _sourcemoduleloader = require("../src/source-module-loader.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const libs = Number(process.env.BENCH_LIBS ?? 8);
+const filesPerLib = Number(process.env.BENCH_FILES ?? 40);
+const runs = Number(process.env.BENCH_RUNS ?? 10);
+function write(file, content) {
+    (0, _nodefs.mkdirSync)(_nodepath.default.dirname(file), {
+        recursive: true
+    });
+    (0, _nodefs.writeFileSync)(file, content);
+}
+function generate(root) {
+    write(_nodepath.default.join(root, "package.json"), JSON.stringify({
+        name: "flux-bench",
+        type: "module"
+    }));
+    write(_nodepath.default.join(root, "tsconfig.json"), JSON.stringify({
+        compilerOptions: {
+            experimentalDecorators: true
+        }
+    }));
+    for(let lib = 0; lib < libs; lib++){
+        const dir = _nodepath.default.join(root, "projects", `lib-${lib}`);
+        write(_nodepath.default.join(dir, "package.json"), JSON.stringify({
+            name: `@bench/lib-${lib}`,
+            type: "module",
+            main: "src/index.ts"
+        }));
+        const previousLib = lib > 0 ? `@bench/lib-${lib - 1}` : null;
+        write(_nodepath.default.join(dir, "src/index.ts"), `export * from "./models";\n`);
+        const exports1 = [];
+        for(let file = 0; file < filesPerLib; file++){
+            const name = `Model${lib}x${file}`;
+            const previous = file > 0 ? `Model${lib}x${file - 1}` : null;
+            write(_nodepath.default.join(dir, "src/models", `model-${file}.ts`), [
+                previous ? `import { ${previous} } from "./model-${file - 1}.js";` : "",
+                previousLib && file === 0 ? `import { Model${lib - 1}x0 } from "${previousLib}";` : "",
+                `const tag = (_target: unknown) => {};`,
+                `@tag`,
+                `export class ${name} {`,
+                `\tpublic readonly id: number = ${file};`,
+                `\tpublic constructor(public readonly label: string = "${name}") {}`,
+                `\tpublic describe(): string { return \`\${this.label}:\${this.id}\`; }`,
+                previous ? `\tpublic previous = ${previous};` : "",
+                previousLib && file === 0 ? `\tpublic upstream = Model${lib - 1}x0;` : "",
+                `}`
+            ].filter(Boolean).join("\n"));
+            exports1.push(`export * from "./model-${file}.js";`);
+        }
+        write(_nodepath.default.join(dir, "src/models/index.ts"), `${exports1.join("\n")}\n`);
+    }
+    return _nodepath.default.join(root, "projects", `lib-${libs - 1}`, "src/index.ts");
+}
+/** One sample, in this process: the first load (cold) and a second one (warm Node and SWC). */ async function sample() {
+    const root = (0, _nodefs.mkdtempSync)(_nodepath.default.join((0, _nodeos.tmpdir)(), "flux-bench-"));
+    try {
+        const entry = generate(root);
+        const workspace = await (0, _forge.createWorkspace)({
+            rootDir: root
+        });
+        const loader = new _sourcemoduleloader.SourceModuleLoader();
+        const load = async (version)=>{
+            const started = performance.now();
+            await loader.configure({
+                buildConfig: "debug",
+                workspace,
+                versionFileUrl: (fileUrl)=>`${fileUrl}?v=${version}`
+            });
+            loader.registerHooks();
+            await loader.importEntry(entry);
+            return performance.now() - started;
+        };
+        const cold = await load(1);
+        const warm = await load(2);
+        return {
+            files: [
+                ...loader.sourceFilePaths()
+            ].length,
+            cold,
+            warm
+        };
+    } finally{
+        (0, _nodefs.rmSync)(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+const median = (values)=>[
+        ...values
+    ].sort((a, b)=>a - b)[Math.floor(values.length / 2)] ?? 0;
+if (process.argv.includes("--sample")) {
+    console.log(JSON.stringify(await sample()));
+} else {
+    // Each sample runs in a fresh process: Node never unloads modules, so loads in one process
+    // slow down as the heap grows and the numbers drift.
+    const results = Array.from({
+        length: runs
+    }, ()=>{
+        const child = (0, _nodechild_process.spawnSync)(process.execPath, [
+            ...process.execArgv,
+            (0, _nodeurl.fileURLToPath)(require("url").pathToFileURL(__filename).toString()),
+            "--sample"
+        ], {
+            encoding: "utf8",
+            env: process.env
+        });
+        if (child.status !== 0) throw new Error(`sample failed:\n${child.stderr}`);
+        const last = child.stdout.trim().split("\n").at(-1) ?? "";
+        return JSON.parse(last);
+    });
+    const files = results[0]?.files ?? 0;
+    const report = (label, values)=>{
+        const ms = median(values);
+        return `${label} ${ms.toFixed(1)} ms (${(ms / files * 1000).toFixed(0)} µs/file)`;
+    };
+    console.log(`flux load, ${files} files, median of ${runs} processes: ` + `${report("first", results.map((r)=>r.cold))}, ` + `${report("second", results.map((r)=>r.warm))}`);
+}

package/commonjs/src/rewrite-serve-specifier.js

@@ -8,8 +8,14 @@ Object.defineProperty(exports, "rewriteServeSpecifier", {
         return rewriteServeSpecifier;
     }
 });
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
 const _nodeurl = require("node:url");
 const _mesh = require("@decohere/mesh");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function rewriteServeSpecifier(options) {
     const { specifier, parentUrl, isWatchedTs, resolveBare, versionFileUrl } = options;
     const relativeTs = resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs);
@@ -17,11 +23,26 @@ function rewriteServeSpecifier(options) {
         return versionFileUrl((0, _nodeurl.pathToFileURL)(relativeTs).toString());
     }
     const bareTarget = resolveBare(specifier);
-    if (bareTarget != null && isWatchedTs(bareTarget)) {
-        return versionFileUrl((0, _nodeurl.pathToFileURL)(bareTarget).toString());
+    const bareTs = bareTarget == null ? null : watchedTs(bareTarget, isWatchedTs);
+    if (bareTs != null) {
+        return versionFileUrl((0, _nodeurl.pathToFileURL)(bareTs).toString());
     }
     return null;
 }
+/**
+ * The watched `.ts` file a path names: itself (with `.js` read as `.ts`, or `.ts` added), else
+ * the `index.ts` of the directory it names. A file wins over a directory of the same name.
+ */ function watchedTs(filePath, isWatchedTs) {
+    const withoutSlash = filePath.replace(/[/\\]+$/, "");
+    const stem = withoutSlash.replace(/\.(js|ts)$/, "");
+    // From the stem: Mesh's alias lookup has already added `.ts` to a subpath that names a
+    // directory (`@lib/models` arrives as `…/models.ts`).
+    const candidates = [
+        `${stem}.ts`,
+        _nodepath.default.join(stem, "index.ts")
+    ];
+    return candidates.find((candidate)=>isWatchedTs(candidate)) ?? null;
+}
 function resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs) {
     if (_mesh.packageAliases.isBareSpecifier(specifier)) return null;
     if (!(specifier.startsWith(".") || specifier.startsWith("/"))) return null;
@@ -34,11 +55,5 @@ function resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs) {
         return null;
     }
     if (resolved.protocol !== "file:") return null;
-    let filePath = (0, _nodeurl.fileURLToPath)(resolved);
-    if (filePath.endsWith(".js")) {
-        filePath = `${filePath.slice(0, -3)}.ts`;
-    } else if (!filePath.endsWith(".ts")) {
-        filePath = `${filePath}.ts`;
-    }
-    return isWatchedTs(filePath) ? filePath : null;
+    return watchedTs((0, _nodeurl.fileURLToPath)(resolved), isWatchedTs);
 }

package/commonjs/src/source-module-loader.js

@@ -78,6 +78,7 @@ class SourceModuleLoader {
     buildConfig = "debug";
     fileInfoMap = new Map();
     transpileCache = new Map();
+    /** SWC options per project, built on first use and kept until the next `configure()`. */ swcConfigs = new Map();
     aliasPaths = {};
     aliasBaseUrl = _nodepath.default.resolve(".");
     versionFileUrl = (fileUrl)=>fileUrl;
@@ -102,6 +103,7 @@ class SourceModuleLoader {
     async configure(options) {
         this.disposed = false;
         this.transpileCache.clear();
+        this.swcConfigs.clear();
         this.buildConfig = options.buildConfig;
         this.workspace = options.workspace ?? await (0, _forge.createWorkspace)();
         this.versionFileUrl = options.versionFileUrl ?? ((fileUrl)=>fileUrl);
@@ -161,6 +163,7 @@ class SourceModuleLoader {
     dispose() {
         this.disposed = true;
         this.transpileCache.clear();
+        this.swcConfigs.clear();
         this.fileInfoMap.clear();
         this.workspace?.[Symbol.dispose]();
         this.workspace = undefined;
@@ -189,19 +192,10 @@ class SourceModuleLoader {
         if (cached != null) return {
             source: cached
         };
-        const { project } = fileInfo;
-        const tsConfig = project.getTsConfigSync();
-        const userConfig = project.getSwcConfigSync();
         const file = new _io.FileEx({
             fullPath: cleanPath
         });
-        const response = this.transpiler.transformFileSync(file, _forge.BuildTargets.es6, {
-            tsConfig,
-            aliasPaths: true,
-            userConfig,
-            workspace: this.workspace,
-            projects: this.workspace?.getProjects(this.buildConfig)
-        });
+        const response = this.transpiler.transformFileSync(file, _forge.BuildTargets.es6, {}, this.swcConfigFor(fileInfo.project));
         if (response.outcome !== "success") {
             this.logger.error(`Failed to transpile ${cleanPath}`, response);
             throw new Error(`Failed to transpile ${cleanPath}`);
@@ -211,6 +205,32 @@ class SourceModuleLoader {
             source: response.code
         };
     }
+    /**
+	 * The project's SWC options, built once: rebuilding them for every file was about a quarter
+	 * of load time (#513). Import specifiers are left as written, without `jsc.paths` or
+	 * `resolveFully`: the resolve hook maps them to source files (aliases, `.js` to `.ts`,
+	 * directory indexes), so SWC does not resolve them a second time against the disk.
+	 */ swcConfigFor(project) {
+        const cached = this.swcConfigs.get(project);
+        if (cached != null) return cached;
+        const base = this.transpiler.createBaseConfig(_forge.BuildTargets.es6, {
+            tsConfig: project.getTsConfigSync(),
+            userConfig: project.getSwcConfigSync(),
+            aliasPaths: false,
+            workspace: this.workspace
+        });
+        // `module` is the ES module config (`type: "es6"` above); the spread loses the narrowing.
+        const module = {
+            ...base.module,
+            resolveFully: false
+        };
+        const config = {
+            ...base,
+            module
+        };
+        this.swcConfigs.set(project, config);
+        return config;
+    }
 }
 SourceModuleLoader = _ts_decorate([
     (0, _decorators.injectable)()

package/es6/bench/load.bench.js

@@ -0,0 +1,136 @@
+/**
+ * Cold-load benchmark for flux: how long the load hook takes to compile and import a workspace
+ * whose files import each other, the way an app's do (#513).
+ *
+ *   pnpm bench:flux                        # 8 libraries × 40 files, 10 processes
+ *   BENCH_LIBS=4 BENCH_FILES=100 BENCH_RUNS=5 pnpm bench:flux
+ *
+ * Generates the workspace in a temp directory: each library re-exports a `models/` directory
+ * through its index (a directory import), each model imports the previous one (relative, with
+ * `.js`) and the previous library by package name, and has a decorated class. Each process
+ * imports the last library twice under different URL versions with a fresh loader cache, so
+ * both loads transpile every file: the first is a real cold start, the second runs with Node
+ * and SWC warmed up. Prints the median of each and the time per file.
+ */ import { spawnSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createWorkspace } from "@decohere/forge";
+import { SourceModuleLoader } from "../src/source-module-loader.js";
+const libs = Number(process.env.BENCH_LIBS ?? 8);
+const filesPerLib = Number(process.env.BENCH_FILES ?? 40);
+const runs = Number(process.env.BENCH_RUNS ?? 10);
+function write(file, content) {
+    mkdirSync(path.dirname(file), {
+        recursive: true
+    });
+    writeFileSync(file, content);
+}
+function generate(root) {
+    write(path.join(root, "package.json"), JSON.stringify({
+        name: "flux-bench",
+        type: "module"
+    }));
+    write(path.join(root, "tsconfig.json"), JSON.stringify({
+        compilerOptions: {
+            experimentalDecorators: true
+        }
+    }));
+    for(let lib = 0; lib < libs; lib++){
+        const dir = path.join(root, "projects", `lib-${lib}`);
+        write(path.join(dir, "package.json"), JSON.stringify({
+            name: `@bench/lib-${lib}`,
+            type: "module",
+            main: "src/index.ts"
+        }));
+        const previousLib = lib > 0 ? `@bench/lib-${lib - 1}` : null;
+        write(path.join(dir, "src/index.ts"), `export * from "./models";\n`);
+        const exports = [];
+        for(let file = 0; file < filesPerLib; file++){
+            const name = `Model${lib}x${file}`;
+            const previous = file > 0 ? `Model${lib}x${file - 1}` : null;
+            write(path.join(dir, "src/models", `model-${file}.ts`), [
+                previous ? `import { ${previous} } from "./model-${file - 1}.js";` : "",
+                previousLib && file === 0 ? `import { Model${lib - 1}x0 } from "${previousLib}";` : "",
+                `const tag = (_target: unknown) => {};`,
+                `@tag`,
+                `export class ${name} {`,
+                `\tpublic readonly id: number = ${file};`,
+                `\tpublic constructor(public readonly label: string = "${name}") {}`,
+                `\tpublic describe(): string { return \`\${this.label}:\${this.id}\`; }`,
+                previous ? `\tpublic previous = ${previous};` : "",
+                previousLib && file === 0 ? `\tpublic upstream = Model${lib - 1}x0;` : "",
+                `}`
+            ].filter(Boolean).join("\n"));
+            exports.push(`export * from "./model-${file}.js";`);
+        }
+        write(path.join(dir, "src/models/index.ts"), `${exports.join("\n")}\n`);
+    }
+    return path.join(root, "projects", `lib-${libs - 1}`, "src/index.ts");
+}
+/** One sample, in this process: the first load (cold) and a second one (warm Node and SWC). */ async function sample() {
+    const root = mkdtempSync(path.join(tmpdir(), "flux-bench-"));
+    try {
+        const entry = generate(root);
+        const workspace = await createWorkspace({
+            rootDir: root
+        });
+        const loader = new SourceModuleLoader();
+        const load = async (version)=>{
+            const started = performance.now();
+            await loader.configure({
+                buildConfig: "debug",
+                workspace,
+                versionFileUrl: (fileUrl)=>`${fileUrl}?v=${version}`
+            });
+            loader.registerHooks();
+            await loader.importEntry(entry);
+            return performance.now() - started;
+        };
+        const cold = await load(1);
+        const warm = await load(2);
+        return {
+            files: [
+                ...loader.sourceFilePaths()
+            ].length,
+            cold,
+            warm
+        };
+    } finally{
+        rmSync(root, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+const median = (values)=>[
+        ...values
+    ].sort((a, b)=>a - b)[Math.floor(values.length / 2)] ?? 0;
+if (process.argv.includes("--sample")) {
+    console.log(JSON.stringify(await sample()));
+} else {
+    // Each sample runs in a fresh process: Node never unloads modules, so loads in one process
+    // slow down as the heap grows and the numbers drift.
+    const results = Array.from({
+        length: runs
+    }, ()=>{
+        const child = spawnSync(process.execPath, [
+            ...process.execArgv,
+            fileURLToPath(import.meta.url),
+            "--sample"
+        ], {
+            encoding: "utf8",
+            env: process.env
+        });
+        if (child.status !== 0) throw new Error(`sample failed:\n${child.stderr}`);
+        const last = child.stdout.trim().split("\n").at(-1) ?? "";
+        return JSON.parse(last);
+    });
+    const files = results[0]?.files ?? 0;
+    const report = (label, values)=>{
+        const ms = median(values);
+        return `${label} ${ms.toFixed(1)} ms (${(ms / files * 1000).toFixed(0)} µs/file)`;
+    };
+    console.log(`flux load, ${files} files, median of ${runs} processes: ` + `${report("first", results.map((r)=>r.cold))}, ` + `${report("second", results.map((r)=>r.warm))}`);
+}

package/es6/src/rewrite-serve-specifier.js

@@ -1,9 +1,11 @@
+import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { packageAliases } from "@decohere/mesh";
 /**
  * Map a resolve-hook specifier to a versioned watched `.ts` file URL.
- * Covers relative `.js` / `.ts` / extensionless imports and bare workspace
- * package names (dynamic `import()` never goes through SWC path rewrite).
+ * Covers relative `.js` / `.ts` / extensionless imports, directory imports (`./models` is
+ * `./models/index.ts`), and bare workspace package names and subpaths. Flux compiles without
+ * SWC's own path resolution, so this is the only place imports are mapped to sources (#513).
  */ export function rewriteServeSpecifier(options) {
     const { specifier, parentUrl, isWatchedTs, resolveBare, versionFileUrl } = options;
     const relativeTs = resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs);
@@ -11,11 +13,26 @@ import { packageAliases } from "@decohere/mesh";
         return versionFileUrl(pathToFileURL(relativeTs).toString());
     }
     const bareTarget = resolveBare(specifier);
-    if (bareTarget != null && isWatchedTs(bareTarget)) {
-        return versionFileUrl(pathToFileURL(bareTarget).toString());
+    const bareTs = bareTarget == null ? null : watchedTs(bareTarget, isWatchedTs);
+    if (bareTs != null) {
+        return versionFileUrl(pathToFileURL(bareTs).toString());
     }
     return null;
 }
+/**
+ * The watched `.ts` file a path names: itself (with `.js` read as `.ts`, or `.ts` added), else
+ * the `index.ts` of the directory it names. A file wins over a directory of the same name.
+ */ function watchedTs(filePath, isWatchedTs) {
+    const withoutSlash = filePath.replace(/[/\\]+$/, "");
+    const stem = withoutSlash.replace(/\.(js|ts)$/, "");
+    // From the stem: Mesh's alias lookup has already added `.ts` to a subpath that names a
+    // directory (`@lib/models` arrives as `…/models.ts`).
+    const candidates = [
+        `${stem}.ts`,
+        path.join(stem, "index.ts")
+    ];
+    return candidates.find((candidate)=>isWatchedTs(candidate)) ?? null;
+}
 function resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs) {
     if (packageAliases.isBareSpecifier(specifier)) return null;
     if (!(specifier.startsWith(".") || specifier.startsWith("/"))) return null;
@@ -28,11 +45,5 @@ function resolveRelativeWatchedTs(specifier, parentUrl, isWatchedTs) {
         return null;
     }
     if (resolved.protocol !== "file:") return null;
-    let filePath = fileURLToPath(resolved);
-    if (filePath.endsWith(".js")) {
-        filePath = `${filePath.slice(0, -3)}.ts`;
-    } else if (!filePath.endsWith(".ts")) {
-        filePath = `${filePath}.ts`;
-    }
-    return isWatchedTs(filePath) ? filePath : null;
+    return watchedTs(fileURLToPath(resolved), isWatchedTs);
 }

package/es6/src/source-module-loader.js

@@ -22,6 +22,7 @@ export class SourceModuleLoader {
     buildConfig = "debug";
     fileInfoMap = new Map();
     transpileCache = new Map();
+    /** SWC options per project, built on first use and kept until the next `configure()`. */ swcConfigs = new Map();
     aliasPaths = {};
     aliasBaseUrl = path.resolve(".");
     versionFileUrl = (fileUrl)=>fileUrl;
@@ -46,6 +47,7 @@ export class SourceModuleLoader {
     async configure(options) {
         this.disposed = false;
         this.transpileCache.clear();
+        this.swcConfigs.clear();
         this.buildConfig = options.buildConfig;
         this.workspace = options.workspace ?? await createWorkspace();
         this.versionFileUrl = options.versionFileUrl ?? ((fileUrl)=>fileUrl);
@@ -105,6 +107,7 @@ export class SourceModuleLoader {
     dispose() {
         this.disposed = true;
         this.transpileCache.clear();
+        this.swcConfigs.clear();
         this.fileInfoMap.clear();
         this.workspace?.[Symbol.dispose]();
         this.workspace = undefined;
@@ -133,19 +136,10 @@ export class SourceModuleLoader {
         if (cached != null) return {
             source: cached
         };
-        const { project } = fileInfo;
-        const tsConfig = project.getTsConfigSync();
-        const userConfig = project.getSwcConfigSync();
         const file = new FileEx({
             fullPath: cleanPath
         });
-        const response = this.transpiler.transformFileSync(file, BuildTargets.es6, {
-            tsConfig,
-            aliasPaths: true,
-            userConfig,
-            workspace: this.workspace,
-            projects: this.workspace?.getProjects(this.buildConfig)
-        });
+        const response = this.transpiler.transformFileSync(file, BuildTargets.es6, {}, this.swcConfigFor(fileInfo.project));
         if (response.outcome !== "success") {
             this.logger.error(`Failed to transpile ${cleanPath}`, response);
             throw new Error(`Failed to transpile ${cleanPath}`);
@@ -155,6 +149,32 @@ export class SourceModuleLoader {
             source: response.code
         };
     }
+    /**
+	 * The project's SWC options, built once: rebuilding them for every file was about a quarter
+	 * of load time (#513). Import specifiers are left as written, without `jsc.paths` or
+	 * `resolveFully`: the resolve hook maps them to source files (aliases, `.js` to `.ts`,
+	 * directory indexes), so SWC does not resolve them a second time against the disk.
+	 */ swcConfigFor(project) {
+        const cached = this.swcConfigs.get(project);
+        if (cached != null) return cached;
+        const base = this.transpiler.createBaseConfig(BuildTargets.es6, {
+            tsConfig: project.getTsConfigSync(),
+            userConfig: project.getSwcConfigSync(),
+            aliasPaths: false,
+            workspace: this.workspace
+        });
+        // `module` is the ES module config (`type: "es6"` above); the spread loses the narrowing.
+        const module = {
+            ...base.module,
+            resolveFully: false
+        };
+        const config = {
+            ...base,
+            module
+        };
+        this.swcConfigs.set(project, config);
+        return config;
+    }
 }
 SourceModuleLoader = _ts_decorate([
     injectable()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/flux",
-  "version": "0.0.1-dev.104",
+  "version": "0.0.1-dev.106",
   "description": "Hot module reload server for Node.js ESM applications",
   "keywords": [
     "typescript",
@@ -25,11 +25,11 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/crucible": "0.0.1-dev.104",
-    "@decohere/forge": "0.0.1-dev.104",
-    "@decohere/mesh": "0.0.1-dev.104",
-    "@decohere/nexus": "0.0.1-dev.104",
-    "@decohere/scribe": "0.0.1-dev.104",
+    "@decohere/crucible": "0.0.1-dev.106",
+    "@decohere/forge": "0.0.1-dev.106",
+    "@decohere/mesh": "0.0.1-dev.106",
+    "@decohere/nexus": "0.0.1-dev.106",
+    "@decohere/scribe": "0.0.1-dev.106",
     "commander": "^13.1.0",
     "rxjs": "^7.8.2"
   },

package/types/bench/load.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/types/src/rewrite-serve-specifier.d.ts

@@ -7,7 +7,8 @@ export type RewriteServeSpecifierOptions = {
 };
 /**
  * Map a resolve-hook specifier to a versioned watched `.ts` file URL.
- * Covers relative `.js` / `.ts` / extensionless imports and bare workspace
- * package names (dynamic `import()` never goes through SWC path rewrite).
+ * Covers relative `.js` / `.ts` / extensionless imports, directory imports (`./models` is
+ * `./models/index.ts`), and bare workspace package names and subpaths. Flux compiles without
+ * SWC's own path resolution, so this is the only place imports are mapped to sources (#513).
  */
 export declare function rewriteServeSpecifier(options: RewriteServeSpecifierOptions): string | null;

package/types/src/source-module-loader.d.ts

@@ -30,6 +30,8 @@ export declare class SourceModuleLoader {
     private buildConfig;
     private fileInfoMap;
     private transpileCache;
+    /** SWC options per project, built on first use and kept until the next `configure()`. */
+    private swcConfigs;
     private aliasPaths;
     private aliasBaseUrl;
     private versionFileUrl;
@@ -46,4 +48,11 @@ export declare class SourceModuleLoader {
     dispose(): void;
     private buildFileInfoMap;
     private loadTs;
+    /**
+     * The project's SWC options, built once: rebuilding them for every file was about a quarter
+     * of load time (#513). Import specifiers are left as written, without `jsc.paths` or
+     * `resolveFully`: the resolve hook maps them to source files (aliases, `.js` to `.ts`,
+     * directory indexes), so SWC does not resolve them a second time against the disk.
+     */
+    private swcConfigFor;
 }