@decohere/forge 0.0.1-dev.111 → 0.0.1-dev.113

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

@@ -7,29 +7,33 @@ 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 { sourceExtensions } from "@decohere/mesh";
 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 { 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;
-        super.watch(workspace);
+        this.#incremental.watch(workspace, (evt)=>this.onIncrementalFileEvent(evt));
     }
     withAliasContext(options = {}) {
         return {
@@ -63,42 +67,18 @@ export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform)
             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;
-    }
     /**
 	 * 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 transformFileSync}.
+	 * once and passes them to {@link transformCode}.
 	 */ createBaseConfig(buildTarget, options = {}) {
         return this.#swcConfigFactory.createBaseConfig(buildTarget, this.withAliasContext(options));
     }
-    /**
-	 * 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).
-	 * Pass `baseConfig` from {@link createBaseConfig} to skip rebuilding it for every file.
-	 */ transformFileSync(file, buildTarget, options = {}, baseConfig = this.createBaseConfig(buildTarget, options)) {
+    /** Sync variant of {@link transformCode}, for the load hook, which cannot await (#514). */ 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 SwcTranspiler.skippedEmpty(file, swcOptions);
         try {
             const transformed = transformSync(content, swcOptions);
@@ -117,126 +97,75 @@ export class SwcTranspiler extends mixwith(CachesOutputs, IncrementalTransform)
         }
     }
     /**
-	 * Async variant of {@link transformFileSync}, with the same result for the same file. SWC
-	 * runs it on libuv's thread pool, so many calls in flight compile in parallel (#661).
-	 */ async transformFileAsync(file, buildTarget, options = {}, baseConfig = this.createBaseConfig(buildTarget, options)) {
+	 * 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 (#517). Async SWC, on the thread pool, so many
+	 * calls in flight compile in parallel (#661). 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);
-        let content;
-        try {
-            content = await fs.promises.readFile(file.fullPath, "utf8");
-        } catch (error) {
-            return TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions
-            });
-        }
-        if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions);
+        if (content === "") return SwcTranspiler.skippedEmpty(file, swcOptions, project);
         try {
             const transformed = await transform(content, swcOptions);
             if (transformed == null) {
                 throw new Error("swc.transform returned no result");
             }
-            return SwcTranspiler.succeeded(file, buildTarget, swcOptions, content, transformed.code);
+            return SwcTranspiler.succeeded(file, buildTarget, swcOptions, content, transformed.code, project);
         } catch (error) {
             return TransformResponse.Error({
                 file,
                 messages: [
                     String(error)
                 ],
-                config: swcOptions
+                config: swcOptions,
+                project
             });
         }
     }
-    static skippedEmpty(file, swcOptions) {
+    static skippedEmpty(file, swcOptions, project) {
         return TransformResponse.Skipped({
             file,
             messages: "File is empty",
-            config: swcOptions
+            config: swcOptions,
+            project
         });
     }
-    static succeeded(file, buildTarget, swcOptions, content, code) {
-        const filePath = file.relativePath;
-        const extName = path.extname(filePath);
-        const fileName = filePath.replace(new RegExp(`${extName}$`), ".js");
+    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,
-            config: swcOptions
+            outputDir: outputPath ? path.dirname(outputPath) : undefined,
+            outputPath,
+            config: swcOptions,
+            project
         });
     }
     async transformTarget(files, buildTarget, options, project, onOutput) {
-        const baseConfig = this.#swcConfigFactory.createBaseConfig(buildTarget, this.withAliasContext(options));
-        return await Promise.all(files.map((file)=>{
-            const swcOptions = this.#swcConfigFactory.createFileConfig(file, baseConfig);
-            return this.runTransform(file, buildTarget, swcOptions, 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 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;
-        }
-        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;
-        } catch (error) {
-            const failure = TransformResponse.Error({
-                file,
-                messages: [
-                    String(error)
-                ],
-                config: swcOptions,
-                project
-            });
-            onOutput?.(failure);
-            return failure;
-        }
-    }
     async onIncrementalFileEvent(evt) {
         const { file, project } = evt;
         if (evt.eventName === io.WatchEvents.unlink) {
-            this.deleteCachedOutputs(file.fullPath);
+            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 [];
         }

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 (#514), 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
+};

package/es6/src/services/type-emitter.js

@@ -9,11 +9,10 @@ function _ts_metadata(k, v) {
 }
 import { invalidateCache } from "@decohere/nexus/caching";
 import { Trace } from "@decohere/nexus/diagnostics";
-import { mixwith } from "@decohere/nexus/extensibility";
 import { io } from "@decohere/nexus/io";
 import "../extensions/project.extensions.js";
-import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
-import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
+import { IncrementalWatch } from "./incremental-watch.js";
+import { OutputCache } from "./output-cache.js";
 import { TsProgramHost } from "./ts-program-host.js";
 import { TypeEmissionProgram } from "./type-emission-program.js";
 import { BuildTargets } from "../types/build-target.type.js";
@@ -45,12 +44,20 @@ import { BuildTargets } from "../types/build-target.type.js";
 /** Compiler options enforced for `forge typecheck` — never emit JS or declarations. */ export const REQUIRED_TYPE_CHECK_OPTIONS = {
     noEmit: true
 };
-export class TypeEmitter extends mixwith(CachesOutputs, IncrementalTransform) {
+export class TypeEmitter {
     buildTargets = [
         BuildTargets.types
     ];
     /** Prepared programs from init(), consumed once by the next transformProject() call. */ #programs;
     #host = new TsProgramHost();
+    #outputs = new OutputCache();
+    #incremental = new IncrementalWatch();
+    get incrementalTransform$() {
+        return this.#incremental.results$;
+    }
+    watch(workspace) {
+        this.#incremental.watch(workspace, (evt)=>this.onIncrementalFileEvent(evt));
+    }
     /**
 	 * Phase 1: fetch files, create TypeScript programs sequentially.
 	 * Called before transformProject() so that the heavy createProgram work
@@ -69,7 +76,7 @@ export class TypeEmitter extends mixwith(CachesOutputs, IncrementalTransform) {
             return [];
         }
         const responses = (await Promise.all(programs.map((program)=>program.emit(filter, onOutput)))).flat();
-        this.cacheOutputs(responses);
+        this.#outputs.record(responses);
         return responses;
     }
     /**
@@ -123,7 +130,7 @@ export class TypeEmitter extends mixwith(CachesOutputs, IncrementalTransform) {
     async onIncrementalFileEvent(evt) {
         const { file, project } = evt;
         if (evt.eventName === io.WatchEvents.unlink) {
-            this.deleteCachedOutputs(file.fullPath);
+            this.#outputs.delete(file.fullPath);
             return [];
         }
         if (!project.isSourceFile(file)) {

package/es6/src/types/transform-response.model.js

@@ -1,8 +1,3 @@
-export const TransformOutcomes = {
-    success: "success",
-    failure: "failure",
-    skipped: "skipped"
-};
 export class TransformResponse {
     static Success(data) {
         return new TransformResponse({

package/es6/src/vitest/forge-build.plugin.js

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
-import { WorkspaceFactory } from "@decohere/mesh";
+import { sourceExtensions, WorkspaceFactory } from "@decohere/mesh";
 import { FileEx } from "@decohere/nexus/io";
 import { ConsoleAdapter, scribe } from "@decohere/scribe";
 import { SwcTranspiler } from "../services/swc-transpiler.js";
@@ -9,11 +9,6 @@ import { WorkspaceDefaults } from "../workspace.config.js";
 // Above fatal (60) so all standard levels are nooped when logLevel is "silent"
 const SILENT_LEVEL = 999;
 const PLUGIN_NAME = "forge-vitest-source";
-const TS_EXTENSIONS = [
-    ".ts",
-    ".tsx",
-    ".mts"
-];
 export function forgeBuild(options) {
     const buildConfig = options?.buildConfig ?? "debug";
     const workspaceRoot = options?.workspaceRoot ?? process.cwd();
@@ -28,9 +23,11 @@ export function forgeBuild(options) {
         }
     });
     const logger = loggerFactory(PLUGIN_NAME);
-    const skipBuild = options?.skipBuild ?? false;
     const transpiler = new SwcTranspiler();
-    const warmedProjects = new Set();
+    /**
+	 * SWC options per project (tsconfig, `.swcrc`, path aliases), built once: rebuilding them for
+	 * every file was most of the plugin's per-file cost, as it was in flux (#513, #517).
+	 */ const baseConfigs = new Map();
     const transformCache = new Map();
     let workspace = null;
     const initWorkspace = async ()=>{
@@ -41,10 +38,17 @@ export function forgeBuild(options) {
             rootDir: workspaceRoot
         });
     };
-    const preWarmProject = (project)=>{
-        if (warmedProjects.has(project.projectDirectory)) return;
-        warmedProjects.add(project.projectDirectory);
-        void transpiler.transformProject(project).then(()=>logger.debug(`Pre-warm complete for ${project.name}`)).catch((err)=>logger.error(`Pre-warm error for ${project.name}: ${err.message}`));
+    const baseConfigFor = (project)=>{
+        const cached = baseConfigs.get(project);
+        if (cached != null) return cached;
+        const config = transpiler.createBaseConfig(BuildTargets.es6, {
+            aliasPaths: true,
+            tsConfig: project?.getTsConfigSync(),
+            userConfig: project?.getSwcConfigSync(),
+            workspace: workspace ?? undefined
+        });
+        baseConfigs.set(project, config);
+        return config;
     };
     return {
         name: PLUGIN_NAME,
@@ -53,51 +57,32 @@ export function forgeBuild(options) {
             logger.debug("Plugin loaded");
         },
         resolveId (source, importer) {
-            if (importer != null && source.endsWith(".js") && source.startsWith(".")) {
-                const importerDirectory = path.dirname(importer);
-                const withoutExtension = source.slice(0, -3);
-                const candidates = TS_EXTENSIONS.map((ext)=>path.resolve(importerDirectory, `${withoutExtension}${ext}`));
-                return candidates.find((c)=>existsSync(c)) ?? null;
+            // `./a.js` is `a.ts` or `a.tsx`, `./a.mjs` is `a.mts`, `./a.cjs` is `a.cts` (#518).
+            if (importer != null && /\.[mc]?jsx?$/.test(source) && source.startsWith(".")) {
+                const written = path.resolve(path.dirname(importer), source);
+                return sourceExtensions.candidates(written).find((c)=>existsSync(c)) ?? null;
             }
             return null;
         },
         watchChange (id) {
-            const file = new FileEx({
-                fullPath: id
-            });
             transformCache.delete(id);
-            transpiler.invalidateContentCache(file);
         },
         async transform (code, id) {
             if (id.includes("node_modules") || !/[.](ts|tsx|mts|cts)$/.test(id)) {
                 return null;
             }
-            await initWorkspace();
-            const project = await workspace?.findProject(id, buildConfig);
-            if (project != null && !skipBuild) {
-                preWarmProject(project);
-            }
             const cached = transformCache.get(id);
             if (cached !== undefined && cached.content === code) {
                 return cached.result;
             }
-            const file = new FileEx({
+            await initWorkspace();
+            const project = await workspace?.findProject(id, buildConfig);
+            // The code Vite passes, not a read of the file: no content cache can serve an older
+            // version, and there is no pre-warm compiling files ahead from disk (#517).
+            const response = await transpiler.transformCode(code, new FileEx({
                 fullPath: id,
                 content: code
-            });
-            if (cached !== undefined) {
-                // Content changed for a previously-seen file — invalidate the transpiler's
-                // FILE_CONTENT cache so the fresh content from Vite is used.
-                // The VS Code Vitest extension disables Vite's chokidar watcher
-                // (server.watch: null) and drives re-runs via vitest.watcher.onFileChange(),
-                // bypassing watchChange entirely — so we cannot rely on watchChange alone.
-                transpiler.invalidateContentCache(file);
-            }
-            const [response] = await transpiler.transformFile(file, BuildTargets.es6, {
-                aliasPaths: true,
-                tsConfig: project ? await project.getTsConfig() : undefined,
-                workspace: workspace ?? undefined
-            });
+            }), BuildTargets.es6, baseConfigFor(project));
             if (!response || response.outcome !== "success") return null;
             const result = {
                 code: response.code,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/forge",
-  "version": "0.0.1-dev.111",
+  "version": "0.0.1-dev.113",
   "description": "TypeScript monorepo build system — zero config, fast compilation, streamlined developer workflow",
   "keywords": [
     "typescript",
@@ -29,10 +29,10 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/crucible": "0.0.1-dev.111",
-    "@decohere/mesh": "0.0.1-dev.111",
-    "@decohere/nexus": "0.0.1-dev.111",
-    "@decohere/scribe": "0.0.1-dev.111",
+    "@decohere/crucible": "0.0.1-dev.113",
+    "@decohere/mesh": "0.0.1-dev.113",
+    "@decohere/nexus": "0.0.1-dev.113",
+    "@decohere/scribe": "0.0.1-dev.113",
     "@swc/core": "^1.11.11",
     "async": "^3.2.6",
     "parse-imports": "^2.2.1",

package/types/src/actions/index.d.ts

@@ -7,6 +7,7 @@ export * from "./dependency-sync.action.js";
 export * from "./docker.action.js";
 export * from "./link.action.js";
 export * from "./package.action.js";
+export * from "./paths.action.js";
 export * from "./publish.action.js";
 export * from "./sync-lock-file.action.js";
 export * from "./tag.action.js";

package/types/src/actions/paths.action.d.ts

@@ -0,0 +1,28 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+export declare const PATHS_FILE = "tsconfig.paths.json";
+export type PathsOptions = {
+    /** Fail if the file is missing or out of date, instead of writing it. */
+    check?: boolean;
+};
+export type PathsResponse = {
+    file: string;
+    changed: boolean;
+    succeeded: boolean;
+    error?: string;
+};
+/**
+ * Writes `tsconfig.paths.json`: tsconfig `paths` for every workspace package and the subpaths it
+ * exports, from Mesh's aliases (#518). Without `node_modules` links, `tsc` finds workspace
+ * packages only through `paths`; generating them keeps them in step with what Flux, the Vitest
+ * plugin and builds resolve. The root tsconfig extends the file.
+ */
+export declare class Paths implements Action<PathsOptions> {
+    #private;
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    run(options: PathsOptions): Promise<ActionResponse<PathsResponse>>;
+    /** The file's content: convention and exported subpaths only, never the tsconfig's own paths. */
+    static render(workspace: Workspace): string;
+}

package/types/src/commands/index.d.ts

@@ -4,6 +4,7 @@ export * from "./docker.command.js";
 export * from "./forge.command.js";
 export * from "./link.command.js";
 export * from "./package.command.js";
+export * from "./paths.command.js";
 export * from "./publish.command.js";
 export * from "./tag.command.js";
 export * from "./typecheck.command.js";

package/types/src/commands/paths.command.d.ts

@@ -0,0 +1,6 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { Paths } from "../actions/paths.action.js";
+export declare class PathsCommand extends DecohereCommand {
+    get actions(): (typeof Paths)[];
+    constructor(name: string);
+}

package/types/src/factories/swc-config.factory.d.ts

@@ -8,7 +8,7 @@ export declare class SwcConfigFactory {
      * Call once per (project, target) and then use createFileConfig() per file.
      */
     createBaseConfig(buildTarget: TranspileTarget, configOptions: SwcConfigOptions): Options;
-    /** Stamps a per-file filename onto a pre-built base config. */
+    /** Stamps a per-file filename onto a pre-built base config; `.tsx` also turns on JSX (#518). */
     createFileConfig(file: FileEx, baseConfig: Options): Options;
     private static nonemptyPaths;
     /**

package/types/src/forge.module.d.ts

@@ -19,6 +19,7 @@ export declare class ForgeModule extends ModuleManifest {
         reportDependencies: typeof Actions.ReportDependencies;
         version: typeof Actions.Version;
         tag: typeof Actions.Tag;
+        paths: typeof Actions.Paths;
         typecheck: typeof Actions.TypeCheck;
         commitFiles: typeof Actions.CommitFiles;
         link: typeof Actions.Link;
@@ -32,6 +33,7 @@ export declare class ForgeModule extends ModuleManifest {
         package: typeof Commands.PackageCommand;
         version: typeof Commands.VersionCommand;
         tag: typeof Commands.TagCommand;
+        paths: typeof Commands.PathsCommand;
         typecheck: typeof Commands.TypeCheckCommand;
         link: typeof Commands.LinkCommand;
         unlink: typeof Commands.UnlinkCommand;

package/types/src/index.d.ts

@@ -3,6 +3,7 @@ export { ForgeError } from "./errors.js";
 export { ForgeModule } from "./forge.module.js";
 export type { TranspileOptions } from "./services/swc-transpiler.js";
 export { SwcTranspiler } from "./services/swc-transpiler.js";
+export { transpileCache } from "./services/transpile-cache.js";
 export type { BuildTarget, TranspileTarget } from "./types/build-target.type.js";
 export { BuildTargets } from "./types/build-target.type.js";
 export type { ForgeConfiguration } from "./types/configuration.type.js";

package/types/src/packaging/release-exports.d.ts

@@ -1,7 +1,7 @@
-import type { PackageJson } from "@decohere/mesh";
+import { type PackageJson } from "@decohere/mesh";
 /** Release `exports`: subpath (`.`, `./testing`) to a file path inside the release output. */
 export type ReleaseExports = Record<string, string>;
-/** `src/main.ts` becomes `src/main.js`, with any leading `./` dropped. */
+/** `src/main.ts` becomes `src/main.js` (`.mts` `.mjs`, `.cts` `.cjs`), with any leading `./` dropped. */
 declare function toJs(filePath: string): string;
 /**
  * The `exports` a library needs once only its `es6/` output is shipped: the library's own

package/types/src/services/file-writer.service.d.ts

@@ -3,7 +3,6 @@ import "../extensions/project.extensions.js";
 import type { TransformResponse } from "../types/transform-response.model.js";
 export declare class FileWriterService {
     #private;
-    initialize(): Promise<void>;
     warmup(projects: Project[]): Promise<void>;
     enqueueOutput(response: TransformResponse): void;
     enqueueOutputs(responses: TransformResponse[]): void;

package/types/src/services/incremental-watch.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectFileEvent, Workspace } from "@decohere/mesh";
+import type { Observable } from "rxjs";
+import type { TransformResponse } from "../types/transform-response.model.js";
+/**
+ * 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 declare class IncrementalWatch {
+    #private;
+    get results$(): Observable<TransformResponse[]>;
+    watch(workspace: Workspace, handler: (evt: ProjectFileEvent) => Promise<TransformResponse[]>): void;
+}

package/types/src/services/output-cache.d.ts

@@ -0,0 +1,10 @@
+import type { TransformResponse } from "../types/transform-response.model.js";
+/** The outputs each source file last built to, so watch mode can delete them when it goes. */
+export declare class OutputCache {
+    #private;
+    get(sourcePath: string): TransformResponse[] | undefined;
+    /** Records the successful outputs, replacing what each of their source files had before. */
+    record(responses: TransformResponse[]): void;
+    /** Deletes the files a source built to and forgets them. */
+    delete(sourcePath: string): void;
+}