@decohere/forge 0.0.1-dev.112 → 0.0.1-dev.114

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();
@@ -62,11 +57,10 @@ 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;
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/forge",
-  "version": "0.0.1-dev.112",
+  "version": "0.0.1-dev.114",
   "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.112",
-    "@decohere/mesh": "0.0.1-dev.112",
-    "@decohere/nexus": "0.0.1-dev.112",
-    "@decohere/scribe": "0.0.1-dev.112",
+    "@decohere/crucible": "0.0.1-dev.114",
+    "@decohere/mesh": "0.0.1-dev.114",
+    "@decohere/nexus": "0.0.1-dev.114",
+    "@decohere/scribe": "0.0.1-dev.114",
     "@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;
+}

package/types/src/services/swc-transpiler.d.ts

@@ -1,10 +1,9 @@
-import type { Project, ProjectFileEvent, Tsconfig, Workspace } from "@decohere/mesh";
+import { type Project, type Tsconfig, type Workspace } from "@decohere/mesh";
 import type { FileEx } from "@decohere/nexus/io";
 import { type Options } from "@swc/core";
+import type { Observable } from "rxjs";
 import { type BuildTarget, type TranspileTarget } from "../types/build-target.type.js";
 import "../extensions/project.extensions.js";
-import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
-import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
 import type { SwcConfig } from "../types/swc-config.type.js";
 import { TransformResponse } from "../types/transform-response.model.js";
 import type { Transformer } from "../types/transformer.type.js";
@@ -16,44 +15,33 @@ export type TranspileOptions = {
     workspace?: Workspace;
     projects?: readonly Project[];
 };
-declare const SwcTranspiler_base: abstract new (...args: unknown[]) => CachesOutputs & IncrementalTransform;
-export declare class SwcTranspiler extends SwcTranspiler_base implements Transformer {
+export declare class SwcTranspiler implements Transformer {
     #private;
     buildTargets: BuildTarget[];
+    get incrementalTransform$(): Observable<TransformResponse[]>;
     watch(workspace: Workspace): void;
     private withAliasContext;
     transformProject(projectArrayLike: Project | Project[], fileFilter?: (project: Project) => Promise<FileEx[]>, onOutput?: (response: TransformResponse) => void): Promise<TransformResponse[]>;
-    transformFile(fileArrayLike: FileEx[] | FileEx, buildTarget: TranspileTarget, options?: TranspileOptions): Promise<TransformResponse[]>;
     /**
      * 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: TranspileTarget, options?: TranspileOptions): 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: FileEx, buildTarget: TranspileTarget, options?: TranspileOptions, baseConfig?: Options): TransformResponse;
-    /**
-     * 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).
-     */
-    transformFileAsync(file: FileEx, buildTarget: TranspileTarget, options?: TranspileOptions, baseConfig?: Options): Promise<TransformResponse>;
+    /** Sync variant of {@link transformCode}, for the load hook, which cannot await (#514). */
+    transformCodeSync(content: string, file: FileEx, buildTarget: TranspileTarget, baseConfig: Options): TransformResponse;
     /**
      * 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.
+     * 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.
      */
-    transformCode(content: string, file: FileEx, buildTarget: TranspileTarget, baseConfig: Options): Promise<TransformResponse>;
+    transformCode(content: string, file: FileEx, buildTarget: TranspileTarget, baseConfig: Options, project?: Project): Promise<TransformResponse>;
     private static skippedEmpty;
     private static succeeded;
     private transformTarget;
-    private runTransform;
-    protected onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+    private onIncrementalFileEvent;
     invalidateContentCache(_file: FileEx): void;
     private getFileContent;
 }
-export {};

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

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+declare function directory(rootDir: string, env?: NodeJS.ProcessEnv): string | null;
+/** The SWC version compiling: part of every cache key, so upgrading SWC misses. */
+export declare const transpileCache: {
+    directory: typeof directory;
+    swcVersion: string;
+};
+export {};

package/types/src/services/type-emitter.d.ts

@@ -1,9 +1,8 @@
-import type { Project, ProjectFileEvent } from "@decohere/mesh";
+import type { Project, Workspace } from "@decohere/mesh";
 import type { FileEx } from "@decohere/nexus/io";
+import type { Observable } from "rxjs";
 import type ts from "typescript";
 import "../extensions/project.extensions.js";
-import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
-import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
 import { type BuildTarget } from "../types/build-target.type.js";
 import type { TransformResponse } from "../types/transform-response.model.js";
 import type { Transformer } from "../types/transformer.type.js";
@@ -31,10 +30,11 @@ export type PrepareProgramsOptions = {
     includeAllProjects?: boolean;
     requiredCompilerOptions?: ts.CompilerOptions;
 };
-declare const TypeEmitter_base: abstract new (...args: unknown[]) => CachesOutputs & IncrementalTransform;
-export declare class TypeEmitter extends TypeEmitter_base implements Transformer {
+export declare class TypeEmitter implements Transformer {
     #private;
     buildTargets: BuildTarget[];
+    get incrementalTransform$(): Observable<TransformResponse[]>;
+    watch(workspace: Workspace): void;
     /**
      * Phase 1: fetch files, create TypeScript programs sequentially.
      * Called before transformProject() so that the heavy createProgram work
@@ -51,7 +51,6 @@ export declare class TypeEmitter extends TypeEmitter_base implements Transformer
         formatted: string;
     }>;
     private preparePrograms;
-    protected onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+    private onIncrementalFileEvent;
     private invalidateReadFileCache;
 }
-export {};

package/types/src/types/transform-response.model.d.ts

@@ -2,11 +2,6 @@ import type { Project } from "@decohere/mesh";
 import type { File } from "@decohere/nexus/io";
 import type { BuildTarget } from "./build-target.type.js";
 export type TransformOutcome = "success" | "failure" | "skipped";
-export declare const TransformOutcomes: {
-    success: "success";
-    failure: "failure";
-    skipped: "skipped";
-};
 type TransformResponseBase = {
     file: File;
     config: unknown;

package/types/src/types/transformer.type.d.ts

@@ -3,15 +3,6 @@ import type { FileEx } from "@decohere/nexus/io";
 import type { Observable } from "rxjs";
 import type { BuildTarget } from "../types/build-target.type.js";
 import type { TransformResponse } from "./transform-response.model.js";
-export type FileEvent = {
-    type: "changed" | "added";
-    file: FileEx;
-    project?: Project;
-} | {
-    type: "deleted";
-    file: FileEx;
-    project: Project;
-};
 export declare const TransformerKey: unique symbol;
 export interface Transformer {
     readonly buildTargets: BuildTarget[];

package/commonjs/src/mixins/caches-outputs.mixin.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "CachesOutputs", {
-    enumerable: true,
-    get: function() {
-        return CachesOutputs;
-    }
-});
-const _io = require("@decohere/nexus/io");
-class CachesOutputs {
-    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */ get outputCache() {
-        const self = this;
-        if (self.__outputCache == null) {
-            self.__outputCache = new Map();
-        }
-        return self.__outputCache;
-    }
-    cacheOutputs(responses) {
-        const byFile = new Map();
-        for (const response of responses){
-            if (response.outcome !== "success") continue;
-            const group = byFile.get(response.file.fullPath) ?? [];
-            group.push(response);
-            byFile.set(response.file.fullPath, group);
-        }
-        for (const [fullPath, group] of byFile){
-            this.outputCache.set(fullPath, group);
-        }
-    }
-    deleteCachedOutputs(filePath) {
-        const outputs = this.outputCache.get(filePath);
-        if (outputs == null) return;
-        for (const response of outputs){
-            if (response.outputPath != null) {
-                void _io.io.deleteFile(response.outputPath);
-            }
-        }
-        this.outputCache.delete(filePath);
-    }
-}

package/commonjs/src/mixins/incremental-transform.mixin.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "IncrementalTransform", {
-    enumerable: true,
-    get: function() {
-        return IncrementalTransform;
-    }
-});
-const _rxjs = require("rxjs");
-// WeakMap avoids the private-field-in-mixin problem: private class fields (#x)
-// are not accessible when methods are copied onto a different class prototype.
-const subjects = new WeakMap();
-function getSubject(instance) {
-    let subject = subjects.get(instance);
-    if (subject == null) {
-        subject = new _rxjs.Subject();
-        subjects.set(instance, subject);
-    }
-    return subject;
-}
-class IncrementalTransform {
-    get incrementalTransform$() {
-        return getSubject(this).asObservable();
-    }
-    watch(workspace) {
-        workspace.projectFileChanged$.subscribe((evt)=>{
-            void this.onIncrementalFileEvent(evt).then((responses)=>{
-                getSubject(this).next(responses);
-            });
-        });
-    }
-}

package/es6/src/mixins/caches-outputs.mixin.js

@@ -1,32 +0,0 @@
-import { io } from "@decohere/nexus/io";
-export class CachesOutputs {
-    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */ get outputCache() {
-        const self = this;
-        if (self.__outputCache == null) {
-            self.__outputCache = new Map();
-        }
-        return self.__outputCache;
-    }
-    cacheOutputs(responses) {
-        const byFile = new Map();
-        for (const response of responses){
-            if (response.outcome !== "success") continue;
-            const group = byFile.get(response.file.fullPath) ?? [];
-            group.push(response);
-            byFile.set(response.file.fullPath, group);
-        }
-        for (const [fullPath, group] of byFile){
-            this.outputCache.set(fullPath, group);
-        }
-    }
-    deleteCachedOutputs(filePath) {
-        const outputs = this.outputCache.get(filePath);
-        if (outputs == null) return;
-        for (const response of outputs){
-            if (response.outputPath != null) {
-                void io.deleteFile(response.outputPath);
-            }
-        }
-        this.outputCache.delete(filePath);
-    }
-}

package/es6/src/mixins/incremental-transform.mixin.js

@@ -1,24 +0,0 @@
-import { Subject } from "rxjs";
-// WeakMap avoids the private-field-in-mixin problem: private class fields (#x)
-// are not accessible when methods are copied onto a different class prototype.
-const subjects = new WeakMap();
-function getSubject(instance) {
-    let subject = subjects.get(instance);
-    if (subject == null) {
-        subject = new Subject();
-        subjects.set(instance, subject);
-    }
-    return subject;
-}
-export class IncrementalTransform {
-    get incrementalTransform$() {
-        return getSubject(this).asObservable();
-    }
-    watch(workspace) {
-        workspace.projectFileChanged$.subscribe((evt)=>{
-            void this.onIncrementalFileEvent(evt).then((responses)=>{
-                getSubject(this).next(responses);
-            });
-        });
-    }
-}

package/types/src/mixins/caches-outputs.mixin.d.ts

@@ -1,7 +0,0 @@
-import type { TransformResponse } from "../types/transform-response.model.js";
-export declare abstract class CachesOutputs {
-    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */
-    protected get outputCache(): Map<string, TransformResponse[]>;
-    protected cacheOutputs(responses: TransformResponse[]): void;
-    protected deleteCachedOutputs(filePath: string): void;
-}

package/types/src/mixins/incremental-transform.mixin.d.ts

@@ -1,13 +0,0 @@
-import type { ProjectFileEvent, Workspace } from "@decohere/mesh";
-import type { Observable } from "rxjs";
-import type { TransformResponse } from "../types/transform-response.model.js";
-export declare abstract class IncrementalTransform {
-    get incrementalTransform$(): Observable<TransformResponse[]>;
-    watch(workspace: Workspace): void;
-    /**
-     * Called for every workspace file change. Implementations should invalidate
-     * any internal caches, perform the incremental transform, and return the results.
-     * Return an empty array for deletions or when no output is produced.
-     */
-    protected abstract onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
-}