@decohere/forge 0.0.1-dev.5

package/commonjs/src/services/type-emission-program.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TypeEmissionProgram", {
+    enumerable: true,
+    get: function() {
+        return TypeEmissionProgram;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _diagnostics = require("@decohere/nexus/diagnostics");
+const _transformresponsemodel = require("../types/transform-response.model.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class TypeEmissionProgram {
+    #program;
+    #group;
+    #targetsByDtsPath;
+    #targetsByEmittedPath;
+    #host;
+    #compilerHost;
+    #allFiles;
+    #compilerOptions;
+    constructor(group, hostFactory){
+        this.#group = group;
+        const targets = this.buildTargetMaps(group);
+        this.#targetsByDtsPath = targets.byDtsPath;
+        this.#targetsByEmittedPath = targets.byEmittedPath;
+        this.#host = hostFactory;
+        this.#compilerOptions = group[0].tsconfig.compilerOptions;
+        this.#allFiles = group.flatMap(({ files })=>files);
+        this.#compilerHost = hostFactory.createHost(this.#compilerOptions);
+        this.#program = hostFactory.createProgram(this.#allFiles, this.#compilerOptions, this.#compilerHost);
+    }
+    toEmissionTarget(groupProject, file, outBaseDir) {
+        const extName = _nodepath.default.extname(file.relativePath);
+        const dtsRelative = file.relativePath.replace(new RegExp(`${extName}$`), ".d.ts");
+        const outputPath = _nodepath.default.join(outBaseDir, dtsRelative);
+        return {
+            file,
+            tsconfig: groupProject.tsconfig,
+            project: groupProject.project,
+            outputPath,
+            outputDir: _nodepath.default.dirname(outputPath),
+            dtsRelative
+        };
+    }
+    emittedKey(file) {
+        return file.fullPath.replace(/\.[^.]+$/, ".d.ts");
+    }
+    buildTargetMaps(group) {
+        const byDtsPath = new Map();
+        const byEmittedPath = new Map();
+        for (const groupProject of group){
+            const outBaseDir = groupProject.project.getOutDir("types");
+            for (const file of groupProject.files){
+                const target = this.toEmissionTarget(groupProject, file, outBaseDir);
+                byDtsPath.set(target.dtsRelative, target);
+                byEmittedPath.set(this.emittedKey(file), target);
+            }
+        }
+        return {
+            byDtsPath,
+            byEmittedPath
+        };
+    }
+    addFile(file, project) {
+        const groupProject = this.#group.find((g)=>g.project === project);
+        if (groupProject == null) return;
+        groupProject.files.push(file);
+        this.#allFiles.push(file);
+        const outBaseDir = groupProject.project.getOutDir("types");
+        const target = this.toEmissionTarget(groupProject, file, outBaseDir);
+        this.#targetsByDtsPath.set(target.dtsRelative, target);
+        this.#targetsByEmittedPath.set(this.emittedKey(file), target);
+        this.#host.invalidateSourceFile(file.fullPath);
+    }
+    async emit(fileFilter, onOutput) {
+        if (this.#host.hasInvalidated()) {
+            this.#program = this.#host.createProgram(this.#allFiles, this.#compilerOptions, this.#compilerHost, this.#program);
+        }
+        if (fileFilter == null) {
+            return this.emitAll(onOutput);
+        }
+        return this.emitFiltered(fileFilter, onOutput);
+    }
+    emitAll(onOutput) {
+        const responses = [];
+        this.#program.emit(undefined, (emittedPath, content)=>{
+            if (!emittedPath.endsWith(".d.ts")) {
+                return;
+            }
+            const response = this.toTransformResponse(emittedPath, content);
+            responses.push(response);
+            onOutput?.(response);
+        });
+        return responses;
+    }
+    async emitFiltered(fileFilter, onOutput) {
+        const files = await Promise.all(this.#group.map(({ project })=>fileFilter(project)));
+        const sourceFiles = files.flat().map((file)=>this.#program.getSourceFile(file.fullPath)).filter((sf)=>sf != null);
+        const responses = [];
+        for (const sourceFile of sourceFiles){
+            this.#program.emit(sourceFile, (emittedPath, content)=>{
+                if (!emittedPath.endsWith(".d.ts")) {
+                    return;
+                }
+                const response = this.toTransformResponse(emittedPath, content);
+                responses.push(response);
+                onOutput?.(response);
+            });
+        }
+        return responses;
+    }
+    toTransformResponse(emittedPath, content) {
+        const target = this.#targetsByEmittedPath.get(emittedPath);
+        if (target == null) {
+            throw new Error(`No matching emission target for: ${emittedPath}`);
+        }
+        return this.toTransformResponseFromTarget(target, content);
+    }
+    toTransformResponseFromTarget(target, content) {
+        const { file, tsconfig, project, outputPath, outputDir, dtsRelative } = target;
+        return _transformresponsemodel.TransformResponse.from({
+            file,
+            config: tsconfig,
+            outcome: "success",
+            fileName: dtsRelative,
+            code: content,
+            target: "types",
+            messages: [],
+            project,
+            outputDir,
+            outputPath
+        });
+    }
+}
+TypeEmissionProgram = _ts_decorate([
+    _diagnostics.Trace,
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        typeof TsProgramHost === "undefined" ? Object : TsProgramHost
+    ])
+], TypeEmissionProgram);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/services/type-emission-program.ts"],"sourcesContent":["import path from \"node:path\";\nimport type { Project, Tsconfig } from \"@decohere/mesh\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport type { FileEx } from \"@decohere/nexus/io\";\nimport type ts from \"typescript\";\nimport type { TsProgramHost } from \"../services/ts-program-host.js\";\nimport { TransformResponse } from \"../types/transform-response.model.js\";\n\nexport type TypeProgramProject = {\n\tproject: Project;\n\tfiles: FileEx[];\n\ttsconfig: Tsconfig;\n};\n\ntype EmissionTarget = {\n\tfile: FileEx;\n\ttsconfig: Tsconfig;\n\tproject: Project;\n\toutputPath: string;\n\toutputDir: string;\n\tdtsRelative: string;\n};\n\n@Trace\nexport class TypeEmissionProgram {\n\t#program: ts.Program;\n\t#group: TypeProgramProject[];\n\t#targetsByDtsPath: Map<string, EmissionTarget>;\n\t#targetsByEmittedPath: Map<string, EmissionTarget>;\n\t#host: TsProgramHost;\n\t#compilerHost: ts.CompilerHost;\n\t#allFiles: FileEx[];\n\t#compilerOptions: ts.CompilerOptions;\n\n\tpublic constructor(group: TypeProgramProject[], hostFactory: TsProgramHost) {\n\t\tthis.#group = group;\n\t\tconst targets = this.buildTargetMaps(group);\n\t\tthis.#targetsByDtsPath = targets.byDtsPath;\n\t\tthis.#targetsByEmittedPath = targets.byEmittedPath;\n\t\tthis.#host = hostFactory;\n\t\tthis.#compilerOptions = group[0].tsconfig.compilerOptions;\n\t\tthis.#allFiles = group.flatMap(({ files }) => files);\n\t\tthis.#compilerHost = hostFactory.createHost(this.#compilerOptions);\n\t\tthis.#program = hostFactory.createProgram(\n\t\t\tthis.#allFiles,\n\t\t\tthis.#compilerOptions,\n\t\t\tthis.#compilerHost,\n\t\t);\n\t}\n\n\tprivate toEmissionTarget(\n\t\tgroupProject: TypeProgramProject,\n\t\tfile: FileEx,\n\t\toutBaseDir: string,\n\t): EmissionTarget {\n\t\tconst extName = path.extname(file.relativePath);\n\t\tconst dtsRelative = file.relativePath.replace(new RegExp(`${extName}$`), \".d.ts\");\n\t\tconst outputPath = path.join(outBaseDir, dtsRelative);\n\t\treturn {\n\t\t\tfile,\n\t\t\ttsconfig: groupProject.tsconfig,\n\t\t\tproject: groupProject.project,\n\t\t\toutputPath,\n\t\t\toutputDir: path.dirname(outputPath),\n\t\t\tdtsRelative,\n\t\t};\n\t}\n\n\tprivate emittedKey(file: FileEx): string {\n\t\treturn file.fullPath.replace(/\\.[^.]+$/, \".d.ts\");\n\t}\n\n\tprivate buildTargetMaps(group: TypeProgramProject[]): {\n\t\tbyDtsPath: Map<string, EmissionTarget>;\n\t\tbyEmittedPath: Map<string, EmissionTarget>;\n\t} {\n\t\tconst byDtsPath = new Map<string, EmissionTarget>();\n\t\tconst byEmittedPath = new Map<string, EmissionTarget>();\n\n\t\tfor (const groupProject of group) {\n\t\t\tconst outBaseDir = groupProject.project.getOutDir(\"types\");\n\t\t\tfor (const file of groupProject.files) {\n\t\t\t\tconst target = this.toEmissionTarget(groupProject, file, outBaseDir);\n\t\t\t\tbyDtsPath.set(target.dtsRelative, target);\n\t\t\t\tbyEmittedPath.set(this.emittedKey(file), target);\n\t\t\t}\n\t\t}\n\n\t\treturn { byDtsPath, byEmittedPath };\n\t}\n\n\tpublic addFile(file: FileEx, project: Project): void {\n\t\tconst groupProject = this.#group.find((g) => g.project === project);\n\t\tif (groupProject == null) return;\n\n\t\tgroupProject.files.push(file);\n\t\tthis.#allFiles.push(file);\n\n\t\tconst outBaseDir = groupProject.project.getOutDir(\"types\");\n\t\tconst target = this.toEmissionTarget(groupProject, file, outBaseDir);\n\t\tthis.#targetsByDtsPath.set(target.dtsRelative, target);\n\t\tthis.#targetsByEmittedPath.set(this.emittedKey(file), target);\n\t\tthis.#host.invalidateSourceFile(file.fullPath);\n\t}\n\n\tpublic async emit(\n\t\tfileFilter?: (project: Project) => Promise<FileEx[]>,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse[]> {\n\t\tif (this.#host.hasInvalidated()) {\n\t\t\tthis.#program = this.#host.createProgram(\n\t\t\t\tthis.#allFiles,\n\t\t\t\tthis.#compilerOptions,\n\t\t\t\tthis.#compilerHost,\n\t\t\t\tthis.#program,\n\t\t\t);\n\t\t}\n\t\tif (fileFilter == null) {\n\t\t\treturn this.emitAll(onOutput);\n\t\t}\n\t\treturn this.emitFiltered(fileFilter, onOutput);\n\t}\n\n\tprivate emitAll(onOutput?: (response: TransformResponse) => void): TransformResponse[] {\n\t\tconst responses: TransformResponse[] = [];\n\t\tthis.#program.emit(undefined, (emittedPath, content) => {\n\t\t\tif (!emittedPath.endsWith(\".d.ts\")) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst response = this.toTransformResponse(emittedPath, content);\n\t\t\tresponses.push(response);\n\t\t\tonOutput?.(response);\n\t\t});\n\t\treturn responses;\n\t}\n\n\tprivate async emitFiltered(\n\t\tfileFilter: (project: Project) => Promise<FileEx[]>,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse[]> {\n\t\tconst files = await Promise.all(this.#group.map(({ project }) => fileFilter(project)));\n\t\tconst sourceFiles = files\n\t\t\t.flat()\n\t\t\t.map((file) => this.#program.getSourceFile(file.fullPath))\n\t\t\t.filter((sf): sf is ts.SourceFile => sf != null);\n\n\t\tconst responses: TransformResponse[] = [];\n\n\t\tfor (const sourceFile of sourceFiles) {\n\t\t\tthis.#program.emit(sourceFile, (emittedPath, content) => {\n\t\t\t\tif (!emittedPath.endsWith(\".d.ts\")) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tconst response = this.toTransformResponse(emittedPath, content);\n\t\t\t\tresponses.push(response);\n\t\t\t\tonOutput?.(response);\n\t\t\t});\n\t\t}\n\n\t\treturn responses;\n\t}\n\n\tprivate toTransformResponse(emittedPath: string, content: string): TransformResponse {\n\t\tconst target = this.#targetsByEmittedPath.get(emittedPath);\n\t\tif (target == null) {\n\t\t\tthrow new Error(`No matching emission target for: ${emittedPath}`);\n\t\t}\n\t\treturn this.toTransformResponseFromTarget(target, content);\n\t}\n\n\tprivate toTransformResponseFromTarget(\n\t\ttarget: EmissionTarget,\n\t\tcontent: string,\n\t): TransformResponse {\n\t\tconst { file, tsconfig, project, outputPath, outputDir, dtsRelative } = target;\n\t\treturn TransformResponse.from({\n\t\t\tfile,\n\t\t\tconfig: tsconfig,\n\t\t\toutcome: \"success\",\n\t\t\tfileName: dtsRelative,\n\t\t\tcode: content,\n\t\t\ttarget: \"types\",\n\t\t\tmessages: [],\n\t\t\tproject,\n\t\t\toutputDir,\n\t\t\toutputPath,\n\t\t});\n\t}\n}\n"],"names":["TypeEmissionProgram","group","hostFactory","targets","buildTargetMaps","byDtsPath","byEmittedPath","tsconfig","compilerOptions","flatMap","files","createHost","createProgram","toEmissionTarget","groupProject","file","outBaseDir","extName","path","extname","relativePath","dtsRelative","replace","RegExp","outputPath","join","project","outputDir","dirname","emittedKey","fullPath","Map","getOutDir","target","set","addFile","find","g","push","invalidateSourceFile","emit","fileFilter","onOutput","hasInvalidated","emitAll","emitFiltered","responses","undefined","emittedPath","content","endsWith","response","toTransformResponse","Promise","all","map","sourceFiles","flat","getSourceFile","filter","sf","sourceFile","get","Error","toTransformResponseFromTarget","TransformResponse","from","config","outcome","fileName","code","messages"],"mappings":";;;;+BAwBaA;;;eAAAA;;;iEAxBI;6BAEK;wCAIY;;;;;;;;;;;;;;;AAkB3B,MAAMA;IACZ,CAAA,OAAQ,CAAa;IACrB,CAAA,KAAM,CAAuB;IAC7B,CAAA,gBAAiB,CAA8B;IAC/C,CAAA,oBAAqB,CAA8B;IACnD,CAAA,IAAK,CAAgB;IACrB,CAAA,YAAa,CAAkB;IAC/B,CAAA,QAAS,CAAW;IACpB,CAAA,eAAgB,CAAqB;IAErC,YAAmBC,KAA2B,EAAEC,WAA0B,CAAE;QAC3E,IAAI,CAAC,CAAA,KAAM,GAAGD;QACd,MAAME,UAAU,IAAI,CAACC,eAAe,CAACH;QACrC,IAAI,CAAC,CAAA,gBAAiB,GAAGE,QAAQE,SAAS;QAC1C,IAAI,CAAC,CAAA,oBAAqB,GAAGF,QAAQG,aAAa;QAClD,IAAI,CAAC,CAAA,IAAK,GAAGJ;QACb,IAAI,CAAC,CAAA,eAAgB,GAAGD,KAAK,CAAC,EAAE,CAACM,QAAQ,CAACC,eAAe;QACzD,IAAI,CAAC,CAAA,QAAS,GAAGP,MAAMQ,OAAO,CAAC,CAAC,EAAEC,KAAK,EAAE,GAAKA;QAC9C,IAAI,CAAC,CAAA,YAAa,GAAGR,YAAYS,UAAU,CAAC,IAAI,CAAC,CAAA,eAAgB;QACjE,IAAI,CAAC,CAAA,OAAQ,GAAGT,YAAYU,aAAa,CACxC,IAAI,CAAC,CAAA,QAAS,EACd,IAAI,CAAC,CAAA,eAAgB,EACrB,IAAI,CAAC,CAAA,YAAa;IAEpB;IAEQC,iBACPC,YAAgC,EAChCC,IAAY,EACZC,UAAkB,EACD;QACjB,MAAMC,UAAUC,iBAAI,CAACC,OAAO,CAACJ,KAAKK,YAAY;QAC9C,MAAMC,cAAcN,KAAKK,YAAY,CAACE,OAAO,CAAC,IAAIC,OAAO,GAAGN,QAAQ,CAAC,CAAC,GAAG;QACzE,MAAMO,aAAaN,iBAAI,CAACO,IAAI,CAACT,YAAYK;QACzC,OAAO;YACNN;YACAR,UAAUO,aAAaP,QAAQ;YAC/BmB,SAASZ,aAAaY,OAAO;YAC7BF;YACAG,WAAWT,iBAAI,CAACU,OAAO,CAACJ;YACxBH;QACD;IACD;IAEQQ,WAAWd,IAAY,EAAU;QACxC,OAAOA,KAAKe,QAAQ,CAACR,OAAO,CAAC,YAAY;IAC1C;IAEQlB,gBAAgBH,KAA2B,EAGjD;QACD,MAAMI,YAAY,IAAI0B;QACtB,MAAMzB,gBAAgB,IAAIyB;QAE1B,KAAK,MAAMjB,gBAAgBb,MAAO;YACjC,MAAMe,aAAaF,aAAaY,OAAO,CAACM,SAAS,CAAC;YAClD,KAAK,MAAMjB,QAAQD,aAAaJ,KAAK,CAAE;gBACtC,MAAMuB,SAAS,IAAI,CAACpB,gBAAgB,CAACC,cAAcC,MAAMC;gBACzDX,UAAU6B,GAAG,CAACD,OAAOZ,WAAW,EAAEY;gBAClC3B,cAAc4B,GAAG,CAAC,IAAI,CAACL,UAAU,CAACd,OAAOkB;YAC1C;QACD;QAEA,OAAO;YAAE5B;YAAWC;QAAc;IACnC;IAEO6B,QAAQpB,IAAY,EAAEW,OAAgB,EAAQ;QACpD,MAAMZ,eAAe,IAAI,CAAC,CAAA,KAAM,CAACsB,IAAI,CAAC,CAACC,IAAMA,EAAEX,OAAO,KAAKA;QAC3D,IAAIZ,gBAAgB,MAAM;QAE1BA,aAAaJ,KAAK,CAAC4B,IAAI,CAACvB;QACxB,IAAI,CAAC,CAAA,QAAS,CAACuB,IAAI,CAACvB;QAEpB,MAAMC,aAAaF,aAAaY,OAAO,CAACM,SAAS,CAAC;QAClD,MAAMC,SAAS,IAAI,CAACpB,gBAAgB,CAACC,cAAcC,MAAMC;QACzD,IAAI,CAAC,CAAA,gBAAiB,CAACkB,GAAG,CAACD,OAAOZ,WAAW,EAAEY;QAC/C,IAAI,CAAC,CAAA,oBAAqB,CAACC,GAAG,CAAC,IAAI,CAACL,UAAU,CAACd,OAAOkB;QACtD,IAAI,CAAC,CAAA,IAAK,CAACM,oBAAoB,CAACxB,KAAKe,QAAQ;IAC9C;IAEA,MAAaU,KACZC,UAAoD,EACpDC,QAAgD,EACjB;QAC/B,IAAI,IAAI,CAAC,CAAA,IAAK,CAACC,cAAc,IAAI;YAChC,IAAI,CAAC,CAAA,OAAQ,GAAG,IAAI,CAAC,CAAA,IAAK,CAAC/B,aAAa,CACvC,IAAI,CAAC,CAAA,QAAS,EACd,IAAI,CAAC,CAAA,eAAgB,EACrB,IAAI,CAAC,CAAA,YAAa,EAClB,IAAI,CAAC,CAAA,OAAQ;QAEf;QACA,IAAI6B,cAAc,MAAM;YACvB,OAAO,IAAI,CAACG,OAAO,CAACF;QACrB;QACA,OAAO,IAAI,CAACG,YAAY,CAACJ,YAAYC;IACtC;IAEQE,QAAQF,QAAgD,EAAuB;QACtF,MAAMI,YAAiC,EAAE;QACzC,IAAI,CAAC,CAAA,OAAQ,CAACN,IAAI,CAACO,WAAW,CAACC,aAAaC;YAC3C,IAAI,CAACD,YAAYE,QAAQ,CAAC,UAAU;gBACnC;YACD;YACA,MAAMC,WAAW,IAAI,CAACC,mBAAmB,CAACJ,aAAaC;YACvDH,UAAUR,IAAI,CAACa;YACfT,WAAWS;QACZ;QACA,OAAOL;IACR;IAEA,MAAcD,aACbJ,UAAmD,EACnDC,QAAgD,EACjB;QAC/B,MAAMhC,QAAQ,MAAM2C,QAAQC,GAAG,CAAC,IAAI,CAAC,CAAA,KAAM,CAACC,GAAG,CAAC,CAAC,EAAE7B,OAAO,EAAE,GAAKe,WAAWf;QAC5E,MAAM8B,cAAc9C,MAClB+C,IAAI,GACJF,GAAG,CAAC,CAACxC,OAAS,IAAI,CAAC,CAAA,OAAQ,CAAC2C,aAAa,CAAC3C,KAAKe,QAAQ,GACvD6B,MAAM,CAAC,CAACC,KAA4BA,MAAM;QAE5C,MAAMd,YAAiC,EAAE;QAEzC,KAAK,MAAMe,cAAcL,YAAa;YACrC,IAAI,CAAC,CAAA,OAAQ,CAAChB,IAAI,CAACqB,YAAY,CAACb,aAAaC;gBAC5C,IAAI,CAACD,YAAYE,QAAQ,CAAC,UAAU;oBACnC;gBACD;gBACA,MAAMC,WAAW,IAAI,CAACC,mBAAmB,CAACJ,aAAaC;gBACvDH,UAAUR,IAAI,CAACa;gBACfT,WAAWS;YACZ;QACD;QAEA,OAAOL;IACR;IAEQM,oBAAoBJ,WAAmB,EAAEC,OAAe,EAAqB;QACpF,MAAMhB,SAAS,IAAI,CAAC,CAAA,oBAAqB,CAAC6B,GAAG,CAACd;QAC9C,IAAIf,UAAU,MAAM;YACnB,MAAM,IAAI8B,MAAM,CAAC,iCAAiC,EAAEf,aAAa;QAClE;QACA,OAAO,IAAI,CAACgB,6BAA6B,CAAC/B,QAAQgB;IACnD;IAEQe,8BACP/B,MAAsB,EACtBgB,OAAe,EACK;QACpB,MAAM,EAAElC,IAAI,EAAER,QAAQ,EAAEmB,OAAO,EAAEF,UAAU,EAAEG,SAAS,EAAEN,WAAW,EAAE,GAAGY;QACxE,OAAOgC,yCAAiB,CAACC,IAAI,CAAC;YAC7BnD;YACAoD,QAAQ5D;YACR6D,SAAS;YACTC,UAAUhD;YACViD,MAAMrB;YACNhB,QAAQ;YACRsC,UAAU,EAAE;YACZ7C;YACAC;YACAH;QACD;IACD;AACD"}

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_TYPE_EMITTER_OPTIONS () {
+        return DEFAULT_TYPE_EMITTER_OPTIONS;
+    },
+    get REQUIRED_TYPE_EMITTER_OPTIONS () {
+        return REQUIRED_TYPE_EMITTER_OPTIONS;
+    },
+    get TypeEmitter () {
+        return TypeEmitter;
+    }
+});
+const _caching = require("@decohere/nexus/caching");
+const _diagnostics = require("@decohere/nexus/diagnostics");
+const _extensibility = require("@decohere/nexus/extensibility");
+const _io = require("@decohere/nexus/io");
+require("../extensions/project.extensions.js");
+const _cachesoutputsmixin = require("../mixins/caches-outputs.mixin.js");
+const _incrementaltransformmixin = require("../mixins/incremental-transform.mixin.js");
+const _tsprogramhost = require("./ts-program-host.js");
+const _typeemissionprogram = require("./type-emission-program.js");
+const _buildtargettype = require("../types/build-target.type.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+const DEFAULT_TYPE_EMITTER_OPTIONS = {
+    lib: [
+        "lib.es2022.d.ts"
+    ],
+    types: [],
+    skipLibCheck: true
+};
+const REQUIRED_TYPE_EMITTER_OPTIONS = {
+    emitDeclarationOnly: true,
+    declaration: true
+};
+class TypeEmitter extends (0, _extensibility.mixwith)(_cachesoutputsmixin.CachesOutputs, _incrementaltransformmixin.IncrementalTransform) {
+    buildTargets = [
+        _buildtargettype.BuildTargets.types
+    ];
+    /** Prepared programs from init(), consumed once by the next transformProject() call. */ #programs;
+    #host = new _tsprogramhost.TsProgramHost();
+    /**
+	 * Phase 1: fetch files, create TypeScript programs sequentially.
+	 * Called before transformProject() so that the heavy createProgram work
+	 * completes before other transformers (SWC/Rayon) start running in parallel.
+	 */ async init(projectArrayLike, _filter) {
+        if (this.#programs == null) {
+            this.#programs = await this.preparePrograms(projectArrayLike);
+        }
+    }
+    async transformProject(projectArrayLike, filter, onOutput) {
+        // Consume prepared state from init() if available; otherwise do full setup
+        // (e.g. watch-mode single-file rebuilds that skip the init phase).
+        const programs = this.#programs ?? await this.preparePrograms(projectArrayLike);
+        this.#programs = programs;
+        if (programs.length === 0) {
+            return [];
+        }
+        const responses = (await Promise.all(programs.map((program)=>program.emit(filter, onOutput)))).flat();
+        this.cacheOutputs(responses);
+        return responses;
+    }
+    async preparePrograms(projectArrayLike) {
+        const allProjects = Array.isArray(projectArrayLike) ? projectArrayLike : [
+            projectArrayLike
+        ];
+        const projects = allProjects.filter((proj)=>proj.getForgeConfiguration().targets.includes(_buildtargettype.BuildTargets.types));
+        if (projects.length === 0) {
+            return [];
+        }
+        // Pre-fetch all files and tsconfigs in parallel across all projects
+        const projectData = await Promise.all(projects.map(async (proj)=>({
+                project: proj,
+                files: await proj.getAllFiles(),
+                tsconfig: await proj.getTsConfig()
+            })));
+        // Group projects by the resolved compiler options that affect the compiler
+        // host (lib loading, module resolution, path aliases). Projects sharing the
+        // same resolved values get one shared host AND one shared program — all their
+        // files are compiled together, matching v1's single-program approach which
+        // avoids re-parsing lib/node_modules .d.ts files per project.
+        const groups = Map.groupBy(projectData, ({ tsconfig })=>this.#host.hostKey(tsconfig.compilerOptions));
+        return [
+            ...groups.values()
+        ].map((group)=>new _typeemissionprogram.TypeEmissionProgram(group, this.#host));
+    }
+    async onIncrementalFileEvent(evt) {
+        const { file, project } = evt;
+        if (evt.eventName === _io.io.WatchEvents.unlink) {
+            this.deleteCachedOutputs(file.fullPath);
+            return [];
+        }
+        if (!project.isSourceFile(file)) {
+            return [];
+        }
+        if (evt.eventName === _io.io.WatchEvents.add) {
+            this.#programs?.forEach((p)=>{
+                p.addFile(file, project);
+            });
+        } else {
+            this.invalidateReadFileCache(file.fullPath);
+            this.#host.invalidateSourceFile(file.fullPath);
+        }
+        return this.transformProject(project, ()=>Promise.resolve([
+                file
+            ]));
+    }
+    invalidateReadFileCache(_path) {}
+}
+_ts_decorate([
+    (0, _caching.invalidateCache)(_tsprogramhost.TsProgramHost.prototype.readFileFromDisk, {
+        name: "FILE_CONTENT",
+        keyFn: (...args)=>args[0]
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], TypeEmitter.prototype, "invalidateReadFileCache", null);
+TypeEmitter = _ts_decorate([
+    _diagnostics.Trace
+], TypeEmitter);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/services/type-emitter.ts"],"sourcesContent":["import type { Project, ProjectFileEvent } from \"@decohere/mesh\";\nimport { 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 ts from \"typescript\";\nimport \"../extensions/project.extensions.js\";\nimport { CachesOutputs } from \"../mixins/caches-outputs.mixin.js\";\nimport { IncrementalTransform } from \"../mixins/incremental-transform.mixin.js\";\nimport { TsProgramHost } from \"../services/ts-program-host.js\";\nimport {\n\tTypeEmissionProgram,\n\ttype TypeProgramProject,\n} from \"../services/type-emission-program.js\";\nimport { type BuildTarget, BuildTargets } from \"../types/build-target.type.js\";\nimport type { TransformResponse } from \"../types/transform-response.model.js\";\nimport type { Transformer } from \"../types/transformer.type.js\";\n\n/**\n * Compiler option defaults applied before the user's tsconfig — the user's values override these.\n *\n * lib: ES2022 — avoids loading lib.dom.d.ts (1.8 MB) which TS includes by default\n * when no `lib` is set. Backend packages have no use for browser APIs.\n *\n * types: [] — disables ambient @types auto-discovery. Without this, TS scans\n * every @types/* package in the node_modules hierarchy; in a monorepo that can\n * pull in dozens of unrelated packages. Explicitly imported types still resolve\n * normally; only ambient globals (e.g. Buffer, process) are suppressed — add\n * `types: [\"node\"]` to a project's tsconfig to restore them.\n */\nexport const DEFAULT_TYPE_EMITTER_OPTIONS: Readonly<ts.CompilerOptions> = {\n\tlib: [\"lib.es2022.d.ts\"],\n\ttypes: [],\n\tskipLibCheck: true,\n};\n\n/**\n * Compiler options that TypeEmitter always enforces regardless of what the user's\n * tsconfig specifies. Applied after the user spread so they cannot be overridden.\n */\nexport const REQUIRED_TYPE_EMITTER_OPTIONS: Readonly<ts.CompilerOptions> = {\n\temitDeclarationOnly: true,\n\tdeclaration: true,\n};\n\n@Trace\nexport class TypeEmitter\n\textends mixwith(CachesOutputs, IncrementalTransform)\n\timplements Transformer\n{\n\tpublic buildTargets: BuildTarget[] = [BuildTargets.types];\n\t/** Prepared programs from init(), consumed once by the next transformProject() call. */\n\t#programs: TypeEmissionProgram[] | undefined;\n\t#host = new TsProgramHost();\n\n\t/**\n\t * Phase 1: fetch files, create TypeScript programs sequentially.\n\t * Called before transformProject() so that the heavy createProgram work\n\t * completes before other transformers (SWC/Rayon) start running in parallel.\n\t */\n\tpublic async init(\n\t\tprojectArrayLike: Project[] | Project,\n\t\t_filter?: (project: Project) => Promise<FileEx[]>,\n\t): Promise<void> {\n\t\tif (this.#programs == null) {\n\t\t\tthis.#programs = await this.preparePrograms(projectArrayLike);\n\t\t}\n\t}\n\n\tpublic async transformProject(\n\t\tprojectArrayLike: Project[] | Project,\n\t\tfilter?: (project: Project) => Promise<FileEx[]>,\n\t\tonOutput?: (response: TransformResponse) => void,\n\t): Promise<TransformResponse[]> {\n\t\t// Consume prepared state from init() if available; otherwise do full setup\n\t\t// (e.g. watch-mode single-file rebuilds that skip the init phase).\n\t\tconst programs = this.#programs ?? (await this.preparePrograms(projectArrayLike));\n\t\tthis.#programs = programs;\n\n\t\tif (programs.length === 0) {\n\t\t\treturn [];\n\t\t}\n\n\t\tconst responses = (\n\t\t\tawait Promise.all(programs.map((program) => program.emit(filter, onOutput)))\n\t\t).flat();\n\t\tthis.cacheOutputs(responses);\n\t\treturn responses;\n\t}\n\n\tprivate async preparePrograms(\n\t\tprojectArrayLike: Project[] | Project,\n\t): Promise<TypeEmissionProgram[]> {\n\t\tconst allProjects = Array.isArray(projectArrayLike)\n\t\t\t? projectArrayLike\n\t\t\t: [projectArrayLike];\n\t\tconst projects = allProjects.filter((proj) =>\n\t\t\tproj.getForgeConfiguration().targets.includes(BuildTargets.types),\n\t\t);\n\t\tif (projects.length === 0) {\n\t\t\treturn [];\n\t\t}\n\n\t\t// Pre-fetch all files and tsconfigs in parallel across all projects\n\t\tconst projectData: TypeProgramProject[] = await Promise.all(\n\t\t\tprojects.map(async (proj) => ({\n\t\t\t\tproject: proj,\n\t\t\t\tfiles: await proj.getAllFiles(),\n\t\t\t\ttsconfig: await proj.getTsConfig(),\n\t\t\t})),\n\t\t);\n\n\t\t// Group projects by the resolved compiler options that affect the compiler\n\t\t// host (lib loading, module resolution, path aliases). Projects sharing the\n\t\t// same resolved values get one shared host AND one shared program — all their\n\t\t// files are compiled together, matching v1's single-program approach which\n\t\t// avoids re-parsing lib/node_modules .d.ts files per project.\n\t\tconst groups = Map.groupBy(projectData, ({ tsconfig }) =>\n\t\t\tthis.#host.hostKey(tsconfig.compilerOptions),\n\t\t);\n\n\t\treturn [...groups.values()].map((group) => new TypeEmissionProgram(group, this.#host));\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\tif (evt.eventName === io.WatchEvents.add) {\n\t\t\tthis.#programs?.forEach((p) => {\n\t\t\t\tp.addFile(file, project);\n\t\t\t});\n\t\t} else {\n\t\t\tthis.invalidateReadFileCache(file.fullPath);\n\t\t\tthis.#host.invalidateSourceFile(file.fullPath);\n\t\t}\n\t\treturn this.transformProject(project, () => Promise.resolve([file]));\n\t}\n\n\t@invalidateCache(TsProgramHost.prototype.readFileFromDisk, {\n\t\tname: \"FILE_CONTENT\",\n\t\tkeyFn: (...args) => args[0] as string,\n\t})\n\tprivate invalidateReadFileCache(_path: string): void {}\n}\n"],"names":["DEFAULT_TYPE_EMITTER_OPTIONS","REQUIRED_TYPE_EMITTER_OPTIONS","TypeEmitter","lib","types","skipLibCheck","emitDeclarationOnly","declaration","mixwith","CachesOutputs","IncrementalTransform","buildTargets","BuildTargets","TsProgramHost","init","projectArrayLike","_filter","preparePrograms","transformProject","filter","onOutput","programs","length","responses","Promise","all","map","program","emit","flat","cacheOutputs","allProjects","Array","isArray","projects","proj","getForgeConfiguration","targets","includes","projectData","project","files","getAllFiles","tsconfig","getTsConfig","groups","Map","groupBy","hostKey","compilerOptions","values","group","TypeEmissionProgram","onIncrementalFileEvent","evt","file","eventName","io","WatchEvents","unlink","deleteCachedOutputs","fullPath","isSourceFile","add","forEach","p","addFile","invalidateReadFileCache","invalidateSourceFile","resolve","_path","prototype","readFileFromDisk","name","keyFn","args"],"mappings":"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"}

package/commonjs/src/types/build-target.type.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BuildTargets", {
+    enumerable: true,
+    get: function() {
+        return BuildTargets;
+    }
+});
+const BuildTargets = {
+    commonjs: "commonjs",
+    es6: "es6",
+    types: "types"
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL3R5cGVzL2J1aWxkLXRhcmdldC50eXBlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBCdWlsZFRhcmdldHMgPSB7XG5cdGNvbW1vbmpzOiBcImNvbW1vbmpzXCIsXG5cdGVzNjogXCJlczZcIixcblx0dHlwZXM6IFwidHlwZXNcIixcbn0gc2F0aXNmaWVzIFJlY29yZDxCdWlsZFRhcmdldCwgQnVpbGRUYXJnZXQ+O1xuXG5leHBvcnQgdHlwZSBCdWlsZFRhcmdldCA9IFwiZXM2XCIgfCBcImNvbW1vbmpzXCIgfCBcInR5cGVzXCI7XG5cbmV4cG9ydCB0eXBlIFRyYW5zcGlsZVRhcmdldCA9IEV4Y2x1ZGU8QnVpbGRUYXJnZXQsIFwidHlwZXNcIj47XG4iXSwibmFtZXMiOlsiQnVpbGRUYXJnZXRzIiwiY29tbW9uanMiLCJlczYiLCJ0eXBlcyJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFBYUE7OztlQUFBQTs7O0FBQU4sTUFBTUEsZUFBZTtJQUMzQkMsVUFBVTtJQUNWQyxLQUFLO0lBQ0xDLE9BQU87QUFDUiJ9

package/commonjs/src/types/configuration.type.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/commonjs/src/types/dependency.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/commonjs/src/types/swc-config.type.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SwcConfig", {
+    enumerable: true,
+    get: function() {
+        return SwcConfig;
+    }
+});
+class SwcConfig {
+    constructor(data = {}){
+        Object.assign(this, data);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL3R5cGVzL3N3Yy1jb25maWcudHlwZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFRzY29uZmlnIH0gZnJvbSBcIkBkZWNvaGVyZS9tZXNoXCI7XG5cbmV4cG9ydCB0eXBlIFN3Y0NvbmZpZ09wdGlvbnMgPSB7XG5cdGFsaWFzUGF0aHM/OiBib29sZWFuO1xuXHR0c0NvbmZpZz86IFRzY29uZmlnO1xuXHR1c2VyQ29uZmlnPzogU3djQ29uZmlnO1xufTtcblxuZXhwb3J0IGNsYXNzIFN3Y0NvbmZpZyB7XG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihkYXRhOiBQYXJ0aWFsPFN3Y0NvbmZpZz4gPSB7fSkge1xuXHRcdE9iamVjdC5hc3NpZ24odGhpcywgZGF0YSk7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJTd2NDb25maWciLCJkYXRhIiwiT2JqZWN0IiwiYXNzaWduIl0sIm1hcHBpbmdzIjoiOzs7OytCQVFhQTs7O2VBQUFBOzs7QUFBTixNQUFNQTtJQUNaLFlBQW1CQyxPQUEyQixDQUFDLENBQUMsQ0FBRTtRQUNqREMsT0FBT0MsTUFBTSxDQUFDLElBQUksRUFBRUY7SUFDckI7QUFDRCJ9

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get TransformOutcomes () {
+        return TransformOutcomes;
+    },
+    get TransformResponse () {
+        return TransformResponse;
+    }
+});
+const TransformOutcomes = {
+    success: "success",
+    failure: "failure",
+    skipped: "skipped"
+};
+class TransformResponse {
+    static Success(data) {
+        return new TransformResponse({
+            ...data,
+            outcome: "success"
+        });
+    }
+    static Error(data) {
+        return new TransformResponse({
+            ...data,
+            outcome: "failure"
+        });
+    }
+    static Skipped(data) {
+        return new TransformResponse({
+            ...data,
+            outcome: "skipped"
+        });
+    }
+    static from(data) {
+        return new TransformResponse({
+            ...data
+        });
+    }
+    constructor(data){
+        Object.assign(this, data);
+    }
+    // Properties are populated via Object.assign in the constructor.
+    file;
+    outcome;
+    target;
+    code;
+    fileName;
+    messages;
+    config;
+    project;
+    outputDir;
+    outputPath;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/types/transformer.type.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TransformerKey", {
+    enumerable: true,
+    get: function() {
+        return TransformerKey;
+    }
+});
+const TransformerKey = Symbol("TransformerKey");
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/types/workspace-config.type.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9