@decohere/forge 0.0.1-dev.13 → 0.0.1-dev.130

package/es6/src/services/dependency-resolver.service.js

@@ -5,30 +5,28 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { injectable } from "@decohere/crucible/decorators";
-import { io } from "@decohere/nexus/io";
+import { io } from "@decohere/core/io";
 import { parseImports } from "parse-imports";
 import { BUILT_IN_MODULES } from "../const.js";
 import { ForgeError } from "../errors.js";
 export class DependencyResolver {
     computeDrift(current, computed) {
-        const sortKeys = (obj)=>Object.fromEntries(Object.entries(obj).sort());
-        const currentDeps = sortKeys(current.dependencies ?? {});
-        const computedDeps = sortKeys(computed.dependencies ?? {});
-        const currentDevDeps = sortKeys(current.devDependencies ?? {});
-        const computedDevDeps = sortKeys(computed.devDependencies ?? {});
-        const hasDrift = JSON.stringify(currentDeps) !== JSON.stringify(computedDeps) || JSON.stringify(currentDevDeps) !== JSON.stringify(computedDevDeps);
-        if (!hasDrift) {
+        const lists = (pkg)=>{
+            const sortKeys = (obj)=>Object.fromEntries(Object.entries(obj ?? {}).sort());
+            return {
+                dependencies: sortKeys(pkg.dependencies),
+                devDependencies: sortKeys(pkg.devDependencies),
+                peerDependencies: sortKeys(pkg.peerDependencies)
+            };
+        };
+        const original = lists(current);
+        const updated = lists(computed);
+        if (JSON.stringify(original) === JSON.stringify(updated)) {
             return null;
         }
         return {
-            original: {
-                dependencies: currentDeps,
-                devDependencies: currentDevDeps
-            },
-            updated: {
-                dependencies: computedDeps,
-                devDependencies: computedDevDeps
-            }
+            original,
+            updated
         };
     }
     async getWorkspacePackages(workspace, projects) {
@@ -68,29 +66,77 @@ export class DependencyResolver {
         ]);
     }
     async computeProjectDependencies(project, workspacePackages) {
-        const { dependencies, devDependencies, warnings } = await this.getDependencies(project, workspacePackages);
         const pkg = await project.getPackageJson();
-        const updatedPackage = pkg.withDependencies(dependencies).withDevDependencies(devDependencies);
+        const peerNames = Object.keys(pkg.peerDependencies ?? {});
+        const peerDependencies = this.getPeerDependencies(project, peerNames, workspacePackages);
+        const { dependencies, devDependencies, warnings } = await this.getDependencies(project, workspacePackages, new Set(peerNames));
+        let updatedPackage = pkg.withDependencies(dependencies).withDevDependencies(devDependencies);
+        if (peerNames.length > 0) {
+            updatedPackage = updatedPackage.withPeerDependencies(peerDependencies);
+        }
         return {
             project,
             updatedPackage,
             warnings
         };
     }
-    async getDependencies(project, workspacePackages) {
+    /**
+	 * A package declares its peers by name in its own `peerDependencies` (and marks optional ones in
+	 * `peerDependenciesMeta`, which sync leaves as written). The root owns every version, so each
+	 * peer gets the root's range; a peer the root doesn't list is an error. A declared peer stays
+	 * even when no code imports it: a pino transport, say, is loaded by name.
+	 */ getPeerDependencies(project, peerNames, workspacePackages) {
+        const peers = {};
+        for (const name of [
+            ...peerNames
+        ].sort()){
+            const version = workspacePackages.get(name)?.version;
+            if (version == null) {
+                throw new ForgeError(`"${name}" is declared a peer of ${project.name}, but the root package.json doesn't list it. ` + "Add it there: the root owns every version.");
+            }
+            peers[name] = version;
+        }
+        return peers;
+    }
+    async getDependencies(project, workspacePackages, peers) {
         const files = await project.getAllFiles();
-        const results = await Promise.all(files.map((file)=>this.getFileImports(file)));
-        const imports = results.flatMap((r)=>r.imports);
+        const results = await Promise.all(files.map(async (file)=>({
+                file,
+                ...await this.getFileImports(file)
+            })));
         const warnings = results.flatMap((r)=>r.warnings);
-        const allDependencies = [
-            ...new Set(imports)
-        ].map((fileImport)=>this.getDependencyFrom(fileImport, workspacePackages)).filter((dep)=>dep != null);
+        /** Which files import each package, for errors that point at the code. */ const importedBy = new Map();
+        const allDependencies = [];
+        for (const { file, imports } of results){
+            for (const fileImport of imports){
+                const dep = this.getDependencyFrom(fileImport, workspacePackages);
+                if (dep == null || peers.has(dep.name)) {
+                    continue;
+                }
+                if (!importedBy.has(dep.name)) {
+                    importedBy.set(dep.name, new Set());
+                    allDependencies.push(dep);
+                }
+                importedBy.get(dep.name)?.add(file.relativePath);
+            }
+        }
         const missing = allDependencies.filter((dep)=>dep.missing);
         if (missing.length > 0) {
             const names = missing.map((dep)=>dep.name).join(", ");
             throw new ForgeError(`Missing packages in project "${project.name}": ${names}`);
         }
         const resolved = allDependencies.filter((dep)=>!dep.missing);
+        // A configuration that packs is the published shape: its files ship, so a package they
+        // import that the root keeps for development would be missing for the consumer.
+        if (project.configuration.pack === true) {
+            const devOnly = resolved.filter((dep)=>dep.isDev && !dep.internal);
+            if (devOnly.length > 0) {
+                const lines = devOnly.map((dep)=>`  - ${dep.name}, imported by ${[
+                        ...importedBy.get(dep.name) ?? []
+                    ].sort().join(", ")}`);
+                throw new ForgeError(`${project.name} ships code that imports packages the root lists only as a devDependency:\n` + `${lines.join("\n")}\n` + "Move each to the root's dependencies, or, if the consumer provides it, " + `declare it in ${project.name}'s peerDependencies.`);
+            }
+        }
         const dependencies = Object.fromEntries(resolved.filter((dep)=>!dep.isDev).map((dep)=>[
                 dep.name,
                 dep.version
@@ -158,5 +204,3 @@ export class DependencyResolver {
 DependencyResolver = _ts_decorate([
     injectable()
 ], DependencyResolver);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/services/dependency-resolver.service.ts"],"sourcesContent":["import { injectable } from \"@decohere/crucible/decorators\";\nimport type { PackageJson, Project, Workspace } from \"@decohere/mesh\";\nimport { type FileEx, io } from \"@decohere/nexus/io\";\nimport { parseImports } from \"parse-imports\";\nimport { BUILT_IN_MODULES } from \"../const.js\";\nimport { ForgeError } from \"../errors.js\";\nimport type {\n\tDependencyWarning,\n\tDriftEntry,\n\tPackage,\n\tResolvedDependency,\n} from \"../types/dependency.types.js\";\n\nexport type ProjectDependencies = {\n\tproject: Project;\n\tupdatedPackage: PackageJson;\n\twarnings: DependencyWarning[];\n};\n\n@injectable()\nexport class DependencyResolver {\n\tpublic computeDrift(current: PackageJson, computed: PackageJson): DriftEntry | null {\n\t\tconst sortKeys = (obj: Record<string, string>) =>\n\t\t\tObject.fromEntries(Object.entries(obj).sort());\n\n\t\tconst currentDeps = sortKeys(current.dependencies ?? {});\n\t\tconst computedDeps = sortKeys(computed.dependencies ?? {});\n\t\tconst currentDevDeps = sortKeys(current.devDependencies ?? {});\n\t\tconst computedDevDeps = sortKeys(computed.devDependencies ?? {});\n\n\t\tconst hasDrift =\n\t\t\tJSON.stringify(currentDeps) !== JSON.stringify(computedDeps) ||\n\t\t\tJSON.stringify(currentDevDeps) !== JSON.stringify(computedDevDeps);\n\n\t\tif (!hasDrift) {\n\t\t\treturn null;\n\t\t}\n\n\t\treturn {\n\t\t\toriginal: { dependencies: currentDeps, devDependencies: currentDevDeps },\n\t\t\tupdated: { dependencies: computedDeps, devDependencies: computedDevDeps },\n\t\t};\n\t}\n\n\tpublic async getWorkspacePackages(\n\t\tworkspace: Workspace,\n\t\tprojects: readonly Project[],\n\t): Promise<Map<string, Package>> {\n\t\tconst packageJson = await workspace.getPackageJson().catch(() => {\n\t\t\tthrow new Error(\n\t\t\t\t`Root package.json not found at \"${workspace.packageJsonDirectory}/package.json\". ` +\n\t\t\t\t\t`Ensure the workspace root has a package.json with dependencies listed.`,\n\t\t\t);\n\t\t});\n\n\t\tconst internals = new Map(\n\t\t\tawait Promise.all(\n\t\t\t\tprojects.map(async (proj): Promise<[string, Package]> => {\n\t\t\t\t\tconst packageJson = await proj.getPackageJson();\n\t\t\t\t\treturn [\n\t\t\t\t\t\tpackageJson.name,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tname: packageJson.name,\n\t\t\t\t\t\t\tversion: packageJson.version,\n\t\t\t\t\t\t\tisInternal: true,\n\t\t\t\t\t\t},\n\t\t\t\t\t];\n\t\t\t\t}),\n\t\t\t),\n\t\t);\n\n\t\tconst packages = Object.entries(packageJson.dependencies)\n\t\t\t.filter(([key]) => !internals.has(key))\n\t\t\t.map<[string, Package]>(([key, val]) => [key, { name: key, version: val }]);\n\n\t\tconst devPackages = Object.entries(packageJson.devDependencies)\n\t\t\t.filter(([key]) => !internals.has(key))\n\t\t\t.map<[string, Package]>(([key, val]) => [key, { name: key, version: val, isDev: true }]);\n\n\t\treturn new Map([...packages, ...devPackages, ...internals]);\n\t}\n\n\tpublic async computeProjectDependencies(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<ProjectDependencies> {\n\t\tconst { dependencies, devDependencies, warnings } = await this.getDependencies(\n\t\t\tproject,\n\t\t\tworkspacePackages,\n\t\t);\n\n\t\tconst pkg = await project.getPackageJson();\n\t\tconst updatedPackage = pkg\n\t\t\t.withDependencies(dependencies)\n\t\t\t.withDevDependencies(devDependencies);\n\n\t\treturn { project, updatedPackage, warnings };\n\t}\n\n\tprivate async getDependencies(project: Project, workspacePackages: Map<string, Package>) {\n\t\tconst files = await project.getAllFiles();\n\t\tconst results = await Promise.all(files.map((file) => this.getFileImports(file)));\n\t\tconst imports = results.flatMap((r) => r.imports);\n\t\tconst warnings = results.flatMap((r) => r.warnings);\n\n\t\tconst allDependencies = [...new Set(imports)]\n\t\t\t.map((fileImport) => this.getDependencyFrom(fileImport, workspacePackages))\n\t\t\t.filter((dep) => dep != null);\n\n\t\tconst missing = allDependencies.filter(\n\t\t\t(dep): dep is ResolvedDependency & { missing: true } => dep.missing,\n\t\t);\n\n\t\tif (missing.length > 0) {\n\t\t\tconst names = missing.map((dep) => dep.name).join(\", \");\n\t\t\tthrow new ForgeError(`Missing packages in project \"${project.name}\": ${names}`);\n\t\t}\n\n\t\tconst resolved = allDependencies.filter(\n\t\t\t(dep): dep is ResolvedDependency & { missing: false } => !dep.missing,\n\t\t);\n\n\t\tconst dependencies = Object.fromEntries(\n\t\t\tresolved\n\t\t\t\t.filter((dep) => !dep.isDev)\n\t\t\t\t.map<[string, string]>((dep) => [dep.name, dep.version]),\n\t\t);\n\n\t\tconst devDependencies = Object.fromEntries(\n\t\t\tresolved\n\t\t\t\t.filter((dep) => dep.isDev)\n\t\t\t\t.map<[string, string]>((dep) => [dep.name, dep.version]),\n\t\t);\n\n\t\treturn { dependencies, devDependencies, warnings };\n\t}\n\n\tprivate getDependencyFrom(\n\t\timportName: string,\n\t\tworkspacePackages: Map<string, Package>,\n\t): ResolvedDependency | undefined {\n\t\tif (importName.startsWith(\".\") || importName.startsWith(\"node:\")) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst packageNameMatch = importName.match(/^(?:(@[^/]+\\/[^/]+)|([^/]+))/);\n\t\tconst packageName = packageNameMatch?.[0];\n\n\t\tif (packageName == null || BUILT_IN_MODULES.includes(packageName)) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst packg = workspacePackages.get(packageName);\n\n\t\tif (packg == null) {\n\t\t\treturn {\n\t\t\t\tname: packageName,\n\t\t\t\tversion: undefined,\n\t\t\t\tinternal: undefined,\n\t\t\t\tmissing: true,\n\t\t\t\tisDev: false,\n\t\t\t};\n\t\t}\n\n\t\treturn {\n\t\t\tname: packageName,\n\t\t\tversion: packg.version ?? \"\",\n\t\t\tinternal: packg.isInternal ?? false,\n\t\t\tmissing: false,\n\t\t\tisDev: packg.isDev ?? false,\n\t\t};\n\t}\n\n\tprivate async getFileImports(\n\t\tfile: FileEx,\n\t): Promise<{ imports: string[]; warnings: DependencyWarning[] }> {\n\t\tconst contents = await io.readFile(file.fullPath);\n\t\tconst parsed = Array.from(await parseImports(contents));\n\n\t\tconst imports: string[] = [];\n\t\tconst warnings: DependencyWarning[] = [];\n\n\t\tfor (const impt of parsed) {\n\t\t\tif (impt.moduleSpecifier.value != null) {\n\t\t\t\timports.push(impt.moduleSpecifier.value);\n\t\t\t} else if (impt.isDynamicImport) {\n\t\t\t\tconst line = contents.substring(0, impt.startIndex).split(\"\\n\").length;\n\t\t\t\twarnings.push({\n\t\t\t\t\tfile: file.fullPath,\n\t\t\t\t\tline,\n\t\t\t\t\tmessage: `Dynamic import with non-literal specifier \\`${impt.moduleSpecifier.code}\\` cannot be statically resolved`,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn { imports, warnings };\n\t}\n}\n"],"names":["injectable","io","parseImports","BUILT_IN_MODULES","ForgeError","DependencyResolver","computeDrift","current","computed","sortKeys","obj","Object","fromEntries","entries","sort","currentDeps","dependencies","computedDeps","currentDevDeps","devDependencies","computedDevDeps","hasDrift","JSON","stringify","original","updated","getWorkspacePackages","workspace","projects","packageJson","getPackageJson","catch","Error","packageJsonDirectory","internals","Map","Promise","all","map","proj","name","version","isInternal","packages","filter","key","has","val","devPackages","isDev","computeProjectDependencies","project","workspacePackages","warnings","getDependencies","pkg","updatedPackage","withDependencies","withDevDependencies","files","getAllFiles","results","file","getFileImports","imports","flatMap","r","allDependencies","Set","fileImport","getDependencyFrom","dep","missing","length","names","join","resolved","importName","startsWith","packageNameMatch","match","packageName","includes","packg","get","undefined","internal","contents","readFile","fullPath","parsed","Array","from","impt","moduleSpecifier","value","push","isDynamicImport","line","substring","startIndex","split","message","code"],"mappings":"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"}

package/es6/src/services/file-writer.service.js

@@ -6,27 +6,20 @@ function _ts_decorate(decorators, target, key, desc) {
 }
 import fs from "node:fs/promises";
 import { injectable } from "@decohere/crucible/decorators";
-import { Trace } from "@decohere/nexus/diagnostics";
-import { io } from "@decohere/nexus/io";
+import { Trace } from "@decohere/devkit/diagnostics";
+import { io } from "@decohere/core/io";
 import "../extensions/project.extensions.js";
 const DEFAULT_WRITE_CONCURRENCY = 16;
 export class FileWriterService {
     #artifactByPath = new Map();
     #warmupSignature = "";
     #warmupPromise;
-    #initialized = false;
     #pendingWrites = [];
     #activeWorkers = 0;
     #drainResolvers = [];
     #ensuredDirs = new Set();
     #ensureDirPromises = new Map();
     #workerError;
-    async initialize() {
-        if (this.#initialized) {
-            return;
-        }
-        this.#initialized = true;
-    }
     async warmup(projects) {
         const outputDirs = this.getOutputDirs(projects);
         const signature = outputDirs.join("|");
@@ -213,5 +206,3 @@ FileWriterService = _ts_decorate([
     Trace,
     injectable()
 ], FileWriterService);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/services/file-writer.service.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport type { Project } from \"@decohere/mesh\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport { io } from \"@decohere/nexus/io\";\nimport \"../extensions/project.extensions.js\";\nimport type { BuildTarget } from \"../types/build-target.type.js\";\nimport type { TransformResponse } from \"../types/transform-response.model.js\";\n\nconst DEFAULT_WRITE_CONCURRENCY = 16;\n\n@Trace\n@injectable()\nexport class FileWriterService {\n\t#artifactByPath = new Map<string, string>();\n\t#warmupSignature = \"\";\n\t#warmupPromise: Promise<void> | undefined;\n\t#initialized = false;\n\t#pendingWrites: TransformResponse[] = [];\n\t#activeWorkers = 0;\n\t#drainResolvers: Array<() => void> = [];\n\t#ensuredDirs = new Set<string>();\n\t#ensureDirPromises = new Map<string, Promise<void>>();\n\t#workerError: unknown;\n\n\tpublic async initialize(): Promise<void> {\n\t\tif (this.#initialized) {\n\t\t\treturn;\n\t\t}\n\t\tthis.#initialized = true;\n\t}\n\n\tpublic async warmup(projects: Project[]): Promise<void> {\n\t\tconst outputDirs = this.getOutputDirs(projects);\n\t\tconst signature = outputDirs.join(\"|\");\n\t\tif (signature === this.#warmupSignature && this.#warmupPromise != null) {\n\t\t\treturn this.#warmupPromise;\n\t\t}\n\n\t\tthis.#warmupSignature = signature;\n\t\tthis.#ensuredDirs.clear();\n\t\tthis.#ensureDirPromises.clear();\n\t\tthis.#workerError = undefined;\n\t\tthis.#warmupPromise = this.loadExistingArtifacts(outputDirs);\n\t\treturn this.#warmupPromise;\n\t}\n\n\tpublic enqueueOutput(response: TransformResponse): void {\n\t\tif (this.#workerError != null) {\n\t\t\treturn;\n\t\t}\n\t\tif (response.outcome !== \"success\" || response.outputPath == null) {\n\t\t\treturn;\n\t\t}\n\t\tthis.#pendingWrites.push(response);\n\t\tthis.startWorkers();\n\t}\n\n\tpublic enqueueOutputs(responses: TransformResponse[]): void {\n\t\tfor (const response of responses) {\n\t\t\tthis.enqueueOutput(response);\n\t\t}\n\t}\n\n\tpublic async flush(): Promise<void> {\n\t\tif (this.#warmupPromise != null) {\n\t\t\tawait this.#warmupPromise;\n\t\t}\n\t\tif (this.#pendingWrites.length === 0 && this.#activeWorkers === 0) {\n\t\t\treturn;\n\t\t}\n\t\tawait new Promise<void>((resolve) => {\n\t\t\tthis.#drainResolvers.push(resolve);\n\t\t});\n\t\tif (this.#workerError != null) {\n\t\t\tthrow this.#workerError;\n\t\t}\n\t}\n\n\tprivate getOutputDirs(projects: Project[]): string[] {\n\t\tconst dirs = new Set<string>();\n\t\tfor (const project of projects) {\n\t\t\tfor (const target of project.getForgeConfiguration().targets) {\n\t\t\t\tdirs.add(project.getOutDir(target as BuildTarget));\n\t\t\t}\n\t\t}\n\t\treturn [...dirs].sort();\n\t}\n\n\tprivate async loadExistingArtifacts(outputDirs: string[]): Promise<void> {\n\t\tthis.#artifactByPath.clear();\n\n\t\tconst files: string[] = [];\n\t\tfor (const dir of outputDirs) {\n\t\t\tfiles.push(...(await this.collectFiles(dir)));\n\t\t}\n\n\t\tawait this.withConcurrency(files, this.getWriteConcurrency(), async (filePath) => {\n\t\t\tconst content = await fs.readFile(filePath, \"utf8\");\n\t\t\tthis.#artifactByPath.set(filePath, content);\n\t\t});\n\t}\n\n\tprivate async collectFiles(rootDir: string): Promise<string[]> {\n\t\ttry {\n\t\t\tconst entries = await fs.readdir(rootDir, { withFileTypes: true });\n\t\t\tconst files: string[] = [];\n\t\t\tfor (const entry of entries) {\n\t\t\t\tconst fullPath = `${rootDir}/${entry.name}`;\n\t\t\t\tif (entry.isDirectory()) {\n\t\t\t\t\tfiles.push(...(await this.collectFiles(fullPath)));\n\t\t\t\t} else if (entry.isFile()) {\n\t\t\t\t\tfiles.push(fullPath);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn files;\n\t\t} catch {\n\t\t\treturn [];\n\t\t}\n\t}\n\n\tprivate getWriteConcurrency(): number {\n\t\tconst requested = Number(process.env.FORGE_WRITE_CONCURRENCY);\n\t\tif (Number.isFinite(requested) && requested > 0) {\n\t\t\treturn Math.floor(requested);\n\t\t}\n\t\treturn DEFAULT_WRITE_CONCURRENCY;\n\t}\n\n\tprivate startWorkers(): void {\n\t\tif (this.#workerError != null) {\n\t\t\treturn;\n\t\t}\n\t\tconst maxWorkers = this.getWriteConcurrency();\n\t\twhile (this.#activeWorkers < maxWorkers && this.#pendingWrites.length > 0) {\n\t\t\tthis.#activeWorkers += 1;\n\t\t\tvoid this.runWorker().finally(() => {\n\t\t\t\tthis.#activeWorkers -= 1;\n\t\t\t\tif (this.#pendingWrites.length > 0) {\n\t\t\t\t\tthis.startWorkers();\n\t\t\t\t} else if (this.#activeWorkers === 0) {\n\t\t\t\t\tthis.resolveDrain();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate async runWorker(): Promise<void> {\n\t\twhile (true) {\n\t\t\tconst response = this.#pendingWrites.shift();\n\t\t\tif (response == null) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tif (this.#warmupPromise != null) {\n\t\t\t\t\tawait this.#warmupPromise;\n\t\t\t\t}\n\n\t\t\t\tconst outputPath = response.outputPath;\n\t\t\t\tif (outputPath == null) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tconst outputDir = response.outputDir;\n\t\t\t\tif (outputDir != null) {\n\t\t\t\t\tawait this.ensureDirectory(outputDir);\n\t\t\t\t}\n\n\t\t\t\tconst existing = this.#artifactByPath.get(outputPath);\n\t\t\t\tif (existing === response.code) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tawait io.writeFile(outputPath, response.code);\n\t\t\t\tthis.#artifactByPath.set(outputPath, response.code);\n\t\t\t} catch (error) {\n\t\t\t\tthis.#workerError = error;\n\t\t\t\tthis.#pendingWrites = [];\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate ensureDirectory(dir: string): Promise<void> {\n\t\tif (this.#ensuredDirs.has(dir)) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t\tconst existing = this.#ensureDirPromises.get(dir);\n\t\tif (existing != null) {\n\t\t\treturn existing;\n\t\t}\n\t\tconst mkdirPromise = fs.mkdir(dir, { recursive: true }).then(() => {\n\t\t\tthis.#ensuredDirs.add(dir);\n\t\t\tthis.#ensureDirPromises.delete(dir);\n\t\t});\n\t\tthis.#ensureDirPromises.set(dir, mkdirPromise);\n\t\treturn mkdirPromise;\n\t}\n\n\tprivate resolveDrain(): void {\n\t\tif (this.#pendingWrites.length > 0 || this.#activeWorkers > 0) {\n\t\t\treturn;\n\t\t}\n\t\tfor (const resolve of this.#drainResolvers) {\n\t\t\tresolve();\n\t\t}\n\t\tthis.#drainResolvers = [];\n\t}\n\n\tprivate async withConcurrency<T>(\n\t\titems: T[],\n\t\tconcurrency: number,\n\t\tworker: (item: T) => Promise<void>,\n\t): Promise<void> {\n\t\tlet cursor = 0;\n\t\tconst workerCount = Math.min(concurrency, items.length);\n\t\tconst workers = Array.from({ length: workerCount }, () =>\n\t\t\t(async () => {\n\t\t\t\twhile (true) {\n\t\t\t\t\tconst index = cursor;\n\t\t\t\t\tcursor += 1;\n\t\t\t\t\tif (index >= items.length) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tawait worker(items[index]);\n\t\t\t\t}\n\t\t\t})(),\n\t\t);\n\t\tawait Promise.all(workers);\n\t}\n}\n"],"names":["fs","injectable","Trace","io","DEFAULT_WRITE_CONCURRENCY","FileWriterService","Map","Set","initialize","warmup","projects","outputDirs","getOutputDirs","signature","join","clear","undefined","loadExistingArtifacts","enqueueOutput","response","outcome","outputPath","push","startWorkers","enqueueOutputs","responses","flush","length","Promise","resolve","dirs","project","target","getForgeConfiguration","targets","add","getOutDir","sort","files","dir","collectFiles","withConcurrency","getWriteConcurrency","filePath","content","readFile","set","rootDir","entries","readdir","withFileTypes","entry","fullPath","name","isDirectory","isFile","requested","Number","process","env","FORGE_WRITE_CONCURRENCY","isFinite","Math","floor","maxWorkers","runWorker","finally","resolveDrain","shift","outputDir","ensureDirectory","existing","get","code","writeFile","error","has","mkdirPromise","mkdir","recursive","then","delete","items","concurrency","worker","cursor","workerCount","min","workers","Array","from","index","all"],"mappings":"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"}

package/es6/src/services/incremental-watch.js

@@ -0,0 +1,18 @@
+import { Subject } from "rxjs";
+/**
+ * Runs a transformer's handler for every workspace file change and emits what it built. The
+ * handler invalidates the transformer's own caches, rebuilds, and returns the responses (empty
+ * for a deletion or when nothing was built).
+ */ export class IncrementalWatch {
+    #results = new Subject();
+    get results$() {
+        return this.#results.asObservable();
+    }
+    watch(workspace, handler) {
+        workspace.projectFileChanged$.subscribe((evt)=>{
+            void handler(evt).then((responses)=>{
+                this.#results.next(responses);
+            });
+        });
+    }
+}

package/es6/src/services/output-cache.js

@@ -0,0 +1,29 @@
+import { io } from "@decohere/core/io";
+/** The outputs each source file last built to, so watch mode can delete them when it goes. */ export class OutputCache {
+    #bySource = new Map();
+    get(sourcePath) {
+        return this.#bySource.get(sourcePath);
+    }
+    /** Records the successful outputs, replacing what each of their source files had before. */ record(responses) {
+        const bySource = new Map();
+        for (const response of responses){
+            if (response.outcome !== "success") continue;
+            const group = bySource.get(response.file.fullPath) ?? [];
+            group.push(response);
+            bySource.set(response.file.fullPath, group);
+        }
+        for (const [sourcePath, group] of bySource){
+            this.#bySource.set(sourcePath, group);
+        }
+    }
+    /** Deletes the files a source built to and forgets them. */ delete(sourcePath) {
+        const outputs = this.#bySource.get(sourcePath);
+        if (outputs == null) return;
+        for (const response of outputs){
+            if (response.outputPath != null) {
+                void io.deleteFile(response.outputPath);
+            }
+        }
+        this.#bySource.delete(sourcePath);
+    }
+}

package/es6/src/services/swc-transpiler.js

@@ -7,31 +7,46 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-import fs from "node:fs";
 import path from "node:path";
-import { cache, invalidateCache } from "@decohere/nexus/caching";
-import { Trace } from "@decohere/nexus/diagnostics";
-import { mixwith } from "@decohere/nexus/extensibility";
-import { io } from "@decohere/nexus/io";
+import { sourceExtensions } from "@decohere/workspace";
+import { cache, invalidateCache } from "@decohere/core/caching";
+import { Trace } from "@decohere/devkit/diagnostics";
+import { WatchEvents } from "@decohere/devkit/io";
 import { transform, transformSync } from "@swc/core";
 import { BuildTargets } from "../types/build-target.type.js";
 import "../extensions/project.extensions.js";
 import { SwcConfigFactory } from "../factories/swc-config.factory.js";
-import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
-import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
 import { TransformResponse } from "../types/transform-response.model.js";
-export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform) {
+import { IncrementalWatch } from "./incremental-watch.js";
+import { OutputCache } from "./output-cache.js";
+export class SwcTranspiler {
     buildTargets = [
         BuildTargets.es6,
         BuildTargets.commonjs
     ];
     #swcConfigFactory = new SwcConfigFactory();
+    #workspace;
+    #outputs = new OutputCache();
+    #incremental = new IncrementalWatch();
+    get incrementalTransform$() {
+        return this.#incremental.results$;
+    }
+    watch(workspace) {
+        this.#workspace = workspace;
+        this.#incremental.watch(workspace, (evt)=>this.onIncrementalFileEvent(evt));
+    }
+    withAliasContext(options = {}) {
+        return {
+            ...options,
+            workspace: options.workspace ?? this.#workspace
+        };
+    }
     async transformProject(projectArrayLike, fileFilter, onOutput) {
         const projects = Array.isArray(projectArrayLike) ? projectArrayLike : [
             projectArrayLike
         ];
         const responses = await Promise.all(projects.map(async (project)=>{
-            const { targets, aliasPaths } = project.getForgeConfiguration();
+            const { targets, aliasPaths, sourceMaps } = project.getForgeConfiguration();
             const transpileTargets = targets.filter((bt)=>bt !== BuildTargets.types);
             if (transpileTargets.length === 0) {
                 return [];
@@ -43,64 +58,34 @@ export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform)
                 return this.transformTarget(sourceFiles, target, {
                     tsConfig,
                     userConfig,
-                    aliasPaths
+                    aliasPaths,
+                    sourceMaps,
+                    workspace: this.#workspace,
+                    projects
                 }, project, onOutput);
             }));
             return responses.flat();
         }));
         const flat = responses.flat();
-        this.cacheOutputs(flat);
+        this.#outputs.record(flat);
         return flat;
     }
-    async transformFile(fileArrayLike, buildTarget, options = {}) {
-        const files = Array.isArray(fileArrayLike) ? fileArrayLike : [
-            fileArrayLike
-        ];
-        const responses = this.transformTarget(files, buildTarget, options);
-        return responses;
-    }
     /**
-	 * Synchronous, single-file variant of `transformFile`.
-	 * Reads the file with `fs.readFileSync` and transpiles via `swc.transformSync`.
-	 * Intended for callers that cannot await (e.g. Node.js `registerHooks` load hook).
-	 */ transformFileSync(file, buildTarget, options = {}) {
-        const baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, options);
+	 * The SWC options for one project and target, without a filename. Building them reads the
+	 * workspace's aliases and merges configs, so a caller that transpiles many files builds them
+	 * once and passes them to {@link transformCode}.
+	 */ createBaseConfig(buildTarget, options = {}) {
+        return this.#swcConfigFactory.createBaseConfig(buildTarget, this.withAliasContext(options));
+    }
+    /** Sync variant of {@link transformCode}, for the load hook, which cannot await. */ transformCodeSync(content, file, buildTarget, baseConfig) {
         const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
-        let content;
-        try {
-            content = fs.readFileSync(file.fullPath, "utf8");
-        } catch (error) {
-            return TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions
-            });
-        }
-        if (content === "") {
-            return TransformResponse.Skipped({
-                file,
-                messages: "File is empty",
-                config: swcOptions
-            });
-        }
+        if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions);
         try {
             const transformed = transformSync(content, swcOptions);
             if (transformed == null) {
                 throw new Error("swc.transformSync returned no result");
             }
-            const filePath = file.relativePath;
-            const extName = path.extname(filePath);
-            const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
-            return TransformResponse.Success({
-                file,
-                code: transformed.code,
-                sourceContent: content,
-                target: buildTarget,
-                fileName,
-                config: swcOptions
-            });
+            return SwcTranspiler.succeeded(file, buildTarget, swcOptions, content, transformed.code);
         } catch (error) {
             return TransformResponse.Error({
                 file,
@@ -111,51 +96,23 @@ export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform)
             });
         }
     }
-    async transformTarget(files, buildTarget, options, project, onOutput) {
-        const baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, options ?? {});
-        return await Promise.all(files.map((file)=>{
-            const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
-            return this.runTransform(file, buildTarget, swcOptions, project, onOutput);
-        }));
-    }
-    async runTransform(file, target, swcOptions, project, onOutput) {
-        const content = await this.getFileContent(file);
-        if (content === "") {
-            const skipped = TransformResponse.Skipped({
-                file,
-                messages: "File is empty",
-                config: swcOptions,
-                project
-            });
-            onOutput?.(skipped);
-            return skipped;
-        }
+    /**
+	 * Compiles `content` as the source of `file`, without reading the file: for callers that
+	 * already hold the code, such as the Vitest plugin, which must compile what Vite passes it
+	 * rather than an earlier read of the disk. Async SWC, on the thread pool, so many
+	 * calls in flight compile in parallel. With a `project`, the response carries where
+	 * the build writes the output.
+	 */ async transformCode(content, file, buildTarget, baseConfig, project) {
+        const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
+        if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions, project);
         try {
-            const filePath = file.relativePath;
-            const extName = path.extname(filePath);
-            const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
-            const outBaseDir = project?.getOutDir(target);
-            const outputPath = outBaseDir ? path.join(outBaseDir, fileName) : undefined;
-            const outputDir = outputPath ? path.dirname(outputPath) : undefined;
             const transformed = await transform(content, swcOptions);
             if (transformed == null) {
                 throw new Error("swc.transform returned no result");
             }
-            const success = TransformResponse.Success({
-                file,
-                code: transformed.code,
-                sourceContent: content,
-                target,
-                fileName,
-                outputDir,
-                outputPath,
-                config: swcOptions,
-                project
-            });
-            onOutput?.(success);
-            return success;
+            return SwcTranspiler.succeeded(file, buildTarget, swcOptions, content, transformed.code, project);
         } catch (error) {
-            const failure = TransformResponse.Error({
+            return TransformResponse.Error({
                 file,
                 messages: [
                     String(error)
@@ -163,21 +120,52 @@ export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform)
                 config: swcOptions,
                 project
             });
-            onOutput?.(failure);
-            return failure;
         }
     }
+    static skippedEmpty(file, swcOptions, project) {
+        return TransformResponse.Skipped({
+            file,
+            messages: "File is empty",
+            config: swcOptions,
+            project
+        });
+    }
+    static succeeded(file, buildTarget, swcOptions, content, code, project) {
+        const fileName = sourceExtensions.outputPath(file.relativePath);
+        const outBaseDir = project?.getOutDir(buildTarget);
+        const outputPath = outBaseDir ? path.join(outBaseDir, fileName) : undefined;
+        return TransformResponse.Success({
+            file,
+            code,
+            sourceContent: content,
+            target: buildTarget,
+            fileName,
+            outputDir: outputPath ? path.dirname(outputPath) : undefined,
+            outputPath,
+            config: swcOptions,
+            project
+        });
+    }
+    async transformTarget(files, buildTarget, options, project, onOutput) {
+        const baseConfig = this.createBaseConfig(buildTarget, options);
+        return await Promise.all(files.map(async (file)=>{
+            const content = await this.getFileContent(file);
+            const response = await this.transformCode(content, file, buildTarget, baseConfig, project);
+            onOutput?.(response);
+            return response;
+        }));
+    }
     async onIncrementalFileEvent(evt) {
         const { file, project } = evt;
-        if (evt.eventName === io.WatchEvents.unlink) {
-            this.deleteCachedOutputs(file.fullPath);
+        if (evt.eventName === WatchEvents.unlink) {
+            this.#outputs.delete(file.fullPath);
             return [];
         }
         if (!project.isSourceFile(file)) {
             return [];
         }
         const freshContent = await file.getContent();
-        const cached = this.outputCache.get(file.fullPath);
+        const cached = this.#outputs.get(file.fullPath);
         if (cached != null && cached[0]?.sourceContent === freshContent) {
             return [];
         }
@@ -216,5 +204,3 @@ _ts_decorate([
 SwcTranspiler = _ts_decorate([
     Trace
 ], SwcTranspiler);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/services/swc-transpiler.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport type { Project } from \"@decohere/mesh\";\nimport { cache, invalidateCache } from \"@decohere/nexus/caching\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport { mixwith } from \"@decohere/nexus/extensibility\";\nimport type { FileEx } from \"@decohere/nexus/io\";\nimport { io } from \"@decohere/nexus/io\";\nimport { type Options, transform, transformSync } from \"@swc/core\";\nimport {\n\ttype BuildTarget,\n\tBuildTargets,\n\ttype TranspileTarget,\n} from \"../types/build-target.type.js\";\nimport \"../extensions/project.extensions.js\";\nimport type { ProjectFileEvent, Tsconfig } from \"@decohere/mesh\";\nimport { SwcConfigFactory } from \"../factories/swc-config.factory.js\";\nimport { CachesOutputs } from \"../mixins/caches-outputs.mixin.js\";\nimport { IncrementalTransform } from \"../mixins/incremental-transform.mixin.js\";\nimport type { SwcConfig } from \"../types/swc-config.type.js\";\nimport { TransformResponse } from \"../types/transform-response.model.js\";\nimport type { Transformer } from \"../types/transformer.type.js\";\n\nexport type TranspileOptions = {\n\taliasPaths?: boolean;\n\ttsConfig?: Tsconfig;\n\tuserConfig?: SwcConfig;\n};\n\n@Trace\nexport class SwcTranspiler\n\textends mixwith(CachesOutputs, IncrementalTransform)\n\timplements Transformer\n{\n\tpublic buildTargets: BuildTarget[] = [BuildTargets.es6, BuildTargets.commonjs];\n\t#swcConfigFactory = new SwcConfigFactory();\n\n\tpublic async transformProject(\n\t\tprojectArrayLike: Project | Project[],\n\t\tfileFilter?: (project: Project) => Promise<FileEx[]>,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse[]> {\n\t\tconst projects = Array.isArray(projectArrayLike) ? projectArrayLike : [projectArrayLike];\n\t\tconst responses = await Promise.all(\n\t\t\tprojects.map(async (project) => {\n\t\t\t\tconst { targets, aliasPaths } = project.getForgeConfiguration();\n\t\t\t\tconst transpileTargets = targets.filter((bt) => bt !== BuildTargets.types);\n\t\t\t\tif (transpileTargets.length === 0) {\n\t\t\t\t\treturn [];\n\t\t\t\t}\n\n\t\t\t\tconst sourceFiles = await (fileFilter?.(project) ?? project.getAllFiles());\n\t\t\t\tconst tsConfig = await project.getTsConfig();\n\t\t\t\tconst userConfig = await project.getSwcConfig();\n\t\t\t\tconst responses = await Promise.all(\n\t\t\t\t\ttranspileTargets.map((target) => {\n\t\t\t\t\t\treturn this.transformTarget(\n\t\t\t\t\t\t\tsourceFiles,\n\t\t\t\t\t\t\ttarget,\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\ttsConfig,\n\t\t\t\t\t\t\t\tuserConfig,\n\t\t\t\t\t\t\t\taliasPaths,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tproject,\n\t\t\t\t\t\t\tonOutput,\n\t\t\t\t\t\t);\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t\treturn responses.flat();\n\t\t\t}),\n\t\t);\n\n\t\tconst flat = responses.flat();\n\t\tthis.cacheOutputs(flat);\n\t\treturn flat;\n\t}\n\n\tpublic async transformFile(\n\t\tfileArrayLike: FileEx[] | FileEx,\n\t\tbuildTarget: TranspileTarget,\n\t\toptions: TranspileOptions = {},\n\t) {\n\t\tconst files = Array.isArray(fileArrayLike) ? fileArrayLike : [fileArrayLike];\n\t\tconst responses = this.transformTarget(files, buildTarget, options);\n\t\treturn responses;\n\t}\n\n\t/**\n\t * Synchronous, single-file variant of `transformFile`.\n\t * Reads the file with `fs.readFileSync` and transpiles via `swc.transformSync`.\n\t * Intended for callers that cannot await (e.g. Node.js `registerHooks` load hook).\n\t */\n\tpublic transformFileSync(\n\t\tfile: FileEx,\n\t\tbuildTarget: TranspileTarget,\n\t\toptions: TranspileOptions = {},\n\t): TransformResponse {\n\t\tconst baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, options);\n\t\tconst swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);\n\n\t\tlet content: string;\n\t\ttry {\n\t\t\tcontent = fs.readFileSync(file.fullPath, \"utf8\");\n\t\t} catch (error) {\n\t\t\treturn TransformResponse.Error({\n\t\t\t\tfile,\n\t\t\t\tmessages: [String(error)],\n\t\t\t\tconfig: swcOptions,\n\t\t\t});\n\t\t}\n\n\t\tif (content === \"\") {\n\t\t\treturn TransformResponse.Skipped({\n\t\t\t\tfile,\n\t\t\t\tmessages: \"File is empty\",\n\t\t\t\tconfig: swcOptions,\n\t\t\t});\n\t\t}\n\n\t\ttry {\n\t\t\tconst transformed = transformSync(content, swcOptions);\n\t\t\tif (transformed == null) {\n\t\t\t\tthrow new Error(\"swc.transformSync returned no result\");\n\t\t\t}\n\t\t\tconst filePath = file.relativePath;\n\t\t\tconst extName = path.extname(filePath);\n\t\t\tconst fileName = filePath.replace(new RegExp(`${extName}$`), \".js\");\n\t\t\treturn TransformResponse.Success({\n\t\t\t\tfile,\n\t\t\t\tcode: transformed.code,\n\t\t\t\tsourceContent: content,\n\t\t\t\ttarget: buildTarget,\n\t\t\t\tfileName,\n\t\t\t\tconfig: swcOptions,\n\t\t\t});\n\t\t} catch (error) {\n\t\t\treturn TransformResponse.Error({\n\t\t\t\tfile,\n\t\t\t\tmessages: [String(error)],\n\t\t\t\tconfig: swcOptions,\n\t\t\t});\n\t\t}\n\t}\n\n\tprivate async transformTarget(\n\t\tfiles: FileEx[],\n\t\tbuildTarget: TranspileTarget,\n\t\toptions?: TranspileOptions,\n\t\tproject?: Project,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t) {\n\t\tconst baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, options ?? {});\n\t\treturn await Promise.all(\n\t\t\tfiles.map((file) => {\n\t\t\t\tconst swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);\n\t\t\t\treturn this.runTransform(file, buildTarget, swcOptions, project, onOutput);\n\t\t\t}),\n\t\t);\n\t}\n\n\tprivate async runTransform(\n\t\tfile: FileEx,\n\t\ttarget: BuildTarget,\n\t\tswcOptions: Options,\n\t\tproject?: Project,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse> {\n\t\tconst content = await this.getFileContent(file);\n\t\tif (content === \"\") {\n\t\t\tconst skipped = TransformResponse.Skipped({\n\t\t\t\tfile,\n\t\t\t\tmessages: \"File is empty\",\n\t\t\t\tconfig: swcOptions,\n\t\t\t\tproject,\n\t\t\t});\n\t\t\tonOutput?.(skipped);\n\t\t\treturn skipped;\n\t\t}\n\n\t\ttry {\n\t\t\tconst filePath = file.relativePath;\n\t\t\tconst extName = path.extname(filePath);\n\t\t\tconst fileName = filePath.replace(new RegExp(`${extName}$`), \".js\");\n\t\t\tconst outBaseDir = project?.getOutDir(target);\n\t\t\tconst outputPath = outBaseDir ? path.join(outBaseDir, fileName) : undefined;\n\t\t\tconst outputDir = outputPath ? path.dirname(outputPath) : undefined;\n\t\t\tconst transformed = await transform(content, swcOptions);\n\t\t\tif (transformed == null) {\n\t\t\t\tthrow new Error(\"swc.transform returned no result\");\n\t\t\t}\n\n\t\t\tconst success = TransformResponse.Success({\n\t\t\t\tfile,\n\t\t\t\tcode: transformed.code,\n\t\t\t\tsourceContent: content,\n\t\t\t\ttarget,\n\t\t\t\tfileName,\n\t\t\t\toutputDir,\n\t\t\t\toutputPath,\n\t\t\t\tconfig: swcOptions,\n\t\t\t\tproject,\n\t\t\t});\n\t\t\tonOutput?.(success);\n\t\t\treturn success;\n\t\t} catch (error) {\n\t\t\tconst failure = TransformResponse.Error({\n\t\t\t\tfile,\n\t\t\t\tmessages: [String(error)],\n\t\t\t\tconfig: swcOptions,\n\t\t\t\tproject,\n\t\t\t});\n\t\t\tonOutput?.(failure);\n\t\t\treturn failure;\n\t\t}\n\t}\n\n\tprotected async onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]> {\n\t\tconst { file, project } = evt;\n\t\tif (evt.eventName === io.WatchEvents.unlink) {\n\t\t\tthis.deleteCachedOutputs(file.fullPath);\n\t\t\treturn [];\n\t\t}\n\t\tif (!project.isSourceFile(file)) {\n\t\t\treturn [];\n\t\t}\n\t\tconst freshContent = await file.getContent();\n\t\tconst cached = this.outputCache.get(file.fullPath);\n\t\tif (cached != null && cached[0]?.sourceContent === freshContent) {\n\t\t\treturn [];\n\t\t}\n\t\tthis.invalidateContentCache(file);\n\t\treturn this.transformProject(project, () => Promise.resolve([file]));\n\t}\n\n\t@invalidateCache(SwcTranspiler.prototype.getFileContent, {\n\t\tname: \"FILE_CONTENT\",\n\t\tkeyFn: (...args) => (args[0] as FileEx).fullPath,\n\t})\n\tpublic invalidateContentCache(_file: FileEx): void {}\n\n\t@cache({ name: \"FILE_CONTENT\", keyFn: (...args) => (args[0] as FileEx).fullPath })\n\tprivate async getFileContent(file: FileEx): Promise<string> {\n\t\treturn await file.getContent();\n\t}\n}\n"],"names":["fs","path","cache","invalidateCache","Trace","mixwith","io","transform","transformSync","BuildTargets","SwcConfigFactory","CachesOutputs","IncrementalTransform","TransformResponse","SwcTranspiler","buildTargets","es6","commonjs","transformProject","projectArrayLike","fileFilter","onOutput","projects","Array","isArray","responses","Promise","all","map","project","targets","aliasPaths","getForgeConfiguration","transpileTargets","filter","bt","types","length","sourceFiles","getAllFiles","tsConfig","getTsConfig","userConfig","getSwcConfig","target","transformTarget","flat","cacheOutputs","transformFile","fileArrayLike","buildTarget","options","files","transformFileSync","file","baseConfig","createBaseConfig","swcOptions","createFileConfig","content","readFileSync","fullPath","error","Error","messages","String","config","Skipped","transformed","filePath","relativePath","extName","extname","fileName","replace","RegExp","Success","code","sourceContent","runTransform","getFileContent","skipped","outBaseDir","getOutDir","outputPath","join","undefined","outputDir","dirname","success","failure","onIncrementalFileEvent","evt","eventName","WatchEvents","unlink","deleteCachedOutputs","isSourceFile","freshContent","getContent","cached","outputCache","get","invalidateContentCache","resolve","_file","prototype","name","keyFn","args"],"mappings":"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"}

package/es6/src/services/transpile-cache.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { version as swcVersion } from "@swc/core";
+/**
+ * Where compiled code is cached on disk, or null when caching is off:
+ *
+ * - `DECOHERE_CACHE=0` turns it off.
+ * - `DECOHERE_CACHE_DIR` puts it in that directory.
+ * - Otherwise `<root>/node_modules/.cache/decohere`, where tools keep caches, or when the
+ *   workspace has no `node_modules`, `$XDG_CACHE_HOME/decohere`, then the OS temp directory.
+ *
+ * Flux keeps its entries in the `flux` folder inside it; `forge clean` removes the folder.
+ */ function directory(rootDir, env = process.env) {
+    if (env.DECOHERE_CACHE === "0") return null;
+    if (env.DECOHERE_CACHE_DIR != null && env.DECOHERE_CACHE_DIR !== "") {
+        return path.resolve(env.DECOHERE_CACHE_DIR);
+    }
+    const nodeModules = path.join(rootDir, "node_modules");
+    if (existsSync(nodeModules)) return path.join(nodeModules, ".cache", "decohere");
+    if (env.XDG_CACHE_HOME != null && env.XDG_CACHE_HOME !== "") {
+        return path.join(env.XDG_CACHE_HOME, "decohere");
+    }
+    return path.join(os.tmpdir(), "decohere");
+}
+/** The SWC version compiling: part of every cache key, so upgrading SWC misses. */ export const transpileCache = {
+    directory,
+    swcVersion
+};