@decohere/forge 0.0.1-dev.9 → 0.0.1-dev.90

package/commonjs/src/actions/build.action.js

@@ -44,6 +44,10 @@ class Build {
         }
     }
     run = async (options)=>{
+        if (options.build === false) {
+            this.#logger.info("Skipping build");
+            return _cli.ActionResponse.Skipped(Build.name);
+        }
         const { configuration: buildConfig } = options;
         const projects = this.workspace.getProjects(buildConfig);
         void this.fileWriter.warmup([
@@ -61,6 +65,10 @@ class Build {
                 transformer.incrementalTransform$.subscribe((responses)=>{
                     this.fileWriter.enqueueOutputs(responses);
                     void this.writeOutput();
+                    const succeeded = responses.some((r)=>r.outcome === "success");
+                    if (succeeded) {
+                        this.#logger.info(`Transpiled ${responses[0].file.fullPath}`);
+                    }
                 });
             }
         }
@@ -105,4 +113,4 @@ Build = _ts_decorate([
     ])
 ], Build);
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/build.action.ts"],"sourcesContent":["import { inject, injectable } from \"@decohere/crucible/decorators\";\nimport type { Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport type { FileEx } from \"@decohere/nexus/io\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError } from \"../errors.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { FileWriterService } from \"../services/file-writer.service.js\";\nimport type { TransformResponse } from \"../types/transform-response.model.js\";\nimport { type Transformer, TransformerKey } from \"../types/transformer.type.js\";\n\nexport type BuildOptions = {\n\tconfiguration: string;\n\tfile: string;\n};\n\n@Trace\n@injectable()\nexport class Build implements Action<BuildOptions> {\n\t#logger = scribe.logger(Build.name);\n\tpublic constructor(\n\t\tprivate readonly workspace: Workspace,\n\t\t@inject(TransformerKey) private readonly transformers: Transformer[],\n\t\tprivate readonly fileWriter: FileWriterService,\n\t) {\n\t\tif (!transformers || transformers.length === 0) {\n\t\t\tthrow new ForgeError(\"At least one transformer is required\");\n\t\t}\n\t}\n\n\tpublic run = async (options: BuildOptions): Promise<ActionResponse<TransformResponse>> => {\n\t\tconst { configuration: buildConfig } = options;\n\t\tconst projects = this.workspace.getProjects(buildConfig);\n\t\tvoid this.fileWriter.warmup([...projects]);\n\t\tconst transformResults = await this.build(projects);\n\n\t\tconst errors = transformResults.filter((response) => response.outcome === \"failure\");\n\t\tif (errors.length > 0) {\n\t\t\tconst messages = transformResults.map((responses) => responses.messages).join(\"\\n\");\n\t\t\tthrow new ForgeError(`Error building: ${messages}`);\n\t\t}\n\n\t\tfor (const transformer of this.transformers) {\n\t\t\tif (transformer.watch && transformer.incrementalTransform$) {\n\t\t\t\ttransformer.watch(this.workspace);\n\t\t\t\ttransformer.incrementalTransform$.subscribe((responses) => {\n\t\t\t\t\tthis.fileWriter.enqueueOutputs(responses);\n\t\t\t\t\tvoid this.writeOutput();\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn ActionResponse.Success(Build.name, transformResults);\n\t};\n\n\tpublic async build(\n\t\tprojectArrayLike: readonly Project[] | Project,\n\t): Promise<TransformResponse[]> {\n\t\tconst projects: Project[] = Array.isArray(projectArrayLike)\n\t\t\t? projectArrayLike\n\t\t\t: [projectArrayLike];\n\t\tfor (const project of projects) {\n\t\t\tthis.#logger.info(`Building ${project.name}`);\n\t\t}\n\t\treturn this.runTransformers(projects);\n\t}\n\n\tprivate async runTransformers(\n\t\tprojects: Project | Project[],\n\t\tfileFilter?: (project: Project) => Promise<FileEx[]>,\n\t) {\n\t\t// Phase 1: sequential init — runs expensive setup (e.g. TypeScript createProgram)\n\t\t// before any transformer's parallel workload (e.g. SWC/Rayon) starts.\n\t\tfor (const transformer of this.transformers) {\n\t\t\tawait transformer.init?.(projects, fileFilter);\n\t\t}\n\t\t// Phase 2: parallel transform — all transformers run concurrently now that\n\t\t// CPU-heavy init is complete.\n\t\tconst allResponses = (\n\t\t\tawait Promise.all(\n\t\t\t\tthis.transformers.map((t) =>\n\t\t\t\t\tt.transformProject(projects, fileFilter, (response) => {\n\t\t\t\t\t\tthis.fileWriter.enqueueOutput(response);\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\t)\n\t\t).flat();\n\t\tawait this.writeOutput();\n\t\treturn allResponses;\n\t}\n\n\tprivate async writeOutput() {\n\t\tawait this.fileWriter.flush();\n\t}\n}\n"],"names":["Build","scribe","logger","name","workspace","transformers","fileWriter","length","ForgeError","run","options","configuration","buildConfig","projects","getProjects","warmup","transformResults","build","errors","filter","response","outcome","messages","map","responses","join","transformer","watch","incrementalTransform$","subscribe","enqueueOutputs","writeOutput","ActionResponse","Success","projectArrayLike","Array","isArray","project","info","runTransformers","fileFilter","init","allResponses","Promise","all","t","transformProject","enqueueOutput","flat","flush"],"mappings":";;;;+BAsBaA;;;eAAAA;;;4BAtBsB;sBAGT;qBAEK;6BACT;wBAEC;wBACI;mCAEO;iCAEe;;;;;;;;;;;;;;;AAS1C,MAAMA;;;;IACZ,CAAA,MAAO,GAAGC,cAAM,CAACC,MAAM,CAACF,MAAMG,IAAI,EAAE;IACpC,YACC,AAAiBC,SAAoB,EACrC,AAAyCC,YAA2B,EACpE,AAAiBC,UAA6B,CAC7C;aAHgBF,YAAAA;aACwBC,eAAAA;aACxBC,aAAAA;QAEjB,IAAI,CAACD,gBAAgBA,aAAaE,MAAM,KAAK,GAAG;YAC/C,MAAM,IAAIC,kBAAU,CAAC;QACtB;IACD;IAEOC,MAAM,OAAOC;QACnB,MAAM,EAAEC,eAAeC,WAAW,EAAE,GAAGF;QACvC,MAAMG,WAAW,IAAI,CAACT,SAAS,CAACU,WAAW,CAACF;QAC5C,KAAK,IAAI,CAACN,UAAU,CAACS,MAAM,CAAC;eAAIF;SAAS;QACzC,MAAMG,mBAAmB,MAAM,IAAI,CAACC,KAAK,CAACJ;QAE1C,MAAMK,SAASF,iBAAiBG,MAAM,CAAC,CAACC,WAAaA,SAASC,OAAO,KAAK;QAC1E,IAAIH,OAAOX,MAAM,GAAG,GAAG;YACtB,MAAMe,WAAWN,iBAAiBO,GAAG,CAAC,CAACC,YAAcA,UAAUF,QAAQ,EAAEG,IAAI,CAAC;YAC9E,MAAM,IAAIjB,kBAAU,CAAC,CAAC,gBAAgB,EAAEc,UAAU;QACnD;QAEA,KAAK,MAAMI,eAAe,IAAI,CAACrB,YAAY,CAAE;YAC5C,IAAIqB,YAAYC,KAAK,IAAID,YAAYE,qBAAqB,EAAE;gBAC3DF,YAAYC,KAAK,CAAC,IAAI,CAACvB,SAAS;gBAChCsB,YAAYE,qBAAqB,CAACC,SAAS,CAAC,CAACL;oBAC5C,IAAI,CAAClB,UAAU,CAACwB,cAAc,CAACN;oBAC/B,KAAK,IAAI,CAACO,WAAW;gBACtB;YACD;QACD;QAEA,OAAOC,mBAAc,CAACC,OAAO,CAACjC,MAAMG,IAAI,EAAEa;IAC3C,EAAE;IAEF,MAAaC,MACZiB,gBAA8C,EACf;QAC/B,MAAMrB,WAAsBsB,MAAMC,OAAO,CAACF,oBACvCA,mBACA;YAACA;SAAiB;QACrB,KAAK,MAAMG,WAAWxB,SAAU;YAC/B,IAAI,CAAC,CAAA,MAAO,CAACyB,IAAI,CAAC,CAAC,SAAS,EAAED,QAAQlC,IAAI,EAAE;QAC7C;QACA,OAAO,IAAI,CAACoC,eAAe,CAAC1B;IAC7B;IAEA,MAAc0B,gBACb1B,QAA6B,EAC7B2B,UAAoD,EACnD;QACD,kFAAkF;QAClF,sEAAsE;QACtE,KAAK,MAAMd,eAAe,IAAI,CAACrB,YAAY,CAAE;YAC5C,MAAMqB,YAAYe,IAAI,GAAG5B,UAAU2B;QACpC;QACA,2EAA2E;QAC3E,8BAA8B;QAC9B,MAAME,eAAe,AACpB,CAAA,MAAMC,QAAQC,GAAG,CAChB,IAAI,CAACvC,YAAY,CAACkB,GAAG,CAAC,CAACsB,IACtBA,EAAEC,gBAAgB,CAACjC,UAAU2B,YAAY,CAACpB;gBACzC,IAAI,CAACd,UAAU,CAACyC,aAAa,CAAC3B;YAC/B,IAEF,EACC4B,IAAI;QACN,MAAM,IAAI,CAACjB,WAAW;QACtB,OAAOW;IACR;IAEA,MAAcX,cAAc;QAC3B,MAAM,IAAI,CAACzB,UAAU,CAAC2C,KAAK;IAC5B;AACD"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/build.action.ts"],"sourcesContent":["import { inject, injectable } from \"@decohere/crucible/decorators\";\nimport type { Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport type { FileEx } from \"@decohere/nexus/io\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError } from \"../errors.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { FileWriterService } from \"../services/file-writer.service.js\";\nimport type { TransformResponse } from \"../types/transform-response.model.js\";\nimport { type Transformer, TransformerKey } from \"../types/transformer.type.js\";\n\nexport type BuildOptions = {\n\tbuild?: boolean;\n\tconfiguration: string;\n\tfile: string;\n};\n\n@Trace\n@injectable()\nexport class Build implements Action<BuildOptions> {\n\t#logger = scribe.logger(Build.name);\n\tpublic constructor(\n\t\tprivate readonly workspace: Workspace,\n\t\t@inject(TransformerKey) private readonly transformers: Transformer[],\n\t\tprivate readonly fileWriter: FileWriterService,\n\t) {\n\t\tif (!transformers || transformers.length === 0) {\n\t\t\tthrow new ForgeError(\"At least one transformer is required\");\n\t\t}\n\t}\n\n\tpublic run = async (options: BuildOptions): Promise<ActionResponse<TransformResponse>> => {\n\t\tif (options.build === false) {\n\t\t\tthis.#logger.info(\"Skipping build\");\n\t\t\treturn ActionResponse.Skipped(Build.name) as ActionResponse<TransformResponse>;\n\t\t}\n\t\tconst { configuration: buildConfig } = options;\n\t\tconst projects = this.workspace.getProjects(buildConfig);\n\t\tvoid this.fileWriter.warmup([...projects]);\n\t\tconst transformResults = await this.build(projects);\n\n\t\tconst errors = transformResults.filter((response) => response.outcome === \"failure\");\n\t\tif (errors.length > 0) {\n\t\t\tconst messages = transformResults.map((responses) => responses.messages).join(\"\\n\");\n\t\t\tthrow new ForgeError(`Error building: ${messages}`);\n\t\t}\n\n\t\tfor (const transformer of this.transformers) {\n\t\t\tif (transformer.watch && transformer.incrementalTransform$) {\n\t\t\t\ttransformer.watch(this.workspace);\n\t\t\t\ttransformer.incrementalTransform$.subscribe((responses) => {\n\t\t\t\t\tthis.fileWriter.enqueueOutputs(responses);\n\t\t\t\t\tvoid this.writeOutput();\n\t\t\t\t\tconst succeeded = responses.some((r) => r.outcome === \"success\");\n\t\t\t\t\tif (succeeded) {\n\t\t\t\t\t\tthis.#logger.info(`Transpiled ${responses[0].file.fullPath}`);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn ActionResponse.Success(Build.name, transformResults);\n\t};\n\n\tpublic async build(\n\t\tprojectArrayLike: readonly Project[] | Project,\n\t): Promise<TransformResponse[]> {\n\t\tconst projects: Project[] = Array.isArray(projectArrayLike)\n\t\t\t? projectArrayLike\n\t\t\t: [projectArrayLike];\n\t\tfor (const project of projects) {\n\t\t\tthis.#logger.info(`Building ${project.name}`);\n\t\t}\n\t\treturn this.runTransformers(projects);\n\t}\n\n\tprivate async runTransformers(\n\t\tprojects: Project | Project[],\n\t\tfileFilter?: (project: Project) => Promise<FileEx[]>,\n\t) {\n\t\t// Phase 1: sequential init — runs expensive setup (e.g. TypeScript createProgram)\n\t\t// before any transformer's parallel workload (e.g. SWC/Rayon) starts.\n\t\tfor (const transformer of this.transformers) {\n\t\t\tawait transformer.init?.(projects, fileFilter);\n\t\t}\n\t\t// Phase 2: parallel transform — all transformers run concurrently now that\n\t\t// CPU-heavy init is complete.\n\t\tconst allResponses = (\n\t\t\tawait Promise.all(\n\t\t\t\tthis.transformers.map((t) =>\n\t\t\t\t\tt.transformProject(projects, fileFilter, (response) => {\n\t\t\t\t\t\tthis.fileWriter.enqueueOutput(response);\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\t)\n\t\t).flat();\n\t\tawait this.writeOutput();\n\t\treturn allResponses;\n\t}\n\n\tprivate async writeOutput() {\n\t\tawait this.fileWriter.flush();\n\t}\n}\n"],"names":["Build","scribe","logger","name","workspace","transformers","fileWriter","length","ForgeError","run","options","build","info","ActionResponse","Skipped","configuration","buildConfig","projects","getProjects","warmup","transformResults","errors","filter","response","outcome","messages","map","responses","join","transformer","watch","incrementalTransform$","subscribe","enqueueOutputs","writeOutput","succeeded","some","r","file","fullPath","Success","projectArrayLike","Array","isArray","project","runTransformers","fileFilter","init","allResponses","Promise","all","t","transformProject","enqueueOutput","flat","flush"],"mappings":"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"}

package/commonjs/src/actions/clean.action.js

@@ -33,8 +33,8 @@ class Clean {
             this.#logger.info("Skipping clean");
             return _cli.ActionResponse.Skipped(Clean.name);
         }
-        await Promise.all(this.workspace.getProjects(options.configuration).map(async (proj)=>{
-            const outDir = proj.getRootOut();
+        const outDirs = this.workspace.getProjects(options.configuration).map((proj)=>proj.getRootOut()).filter((dir, i, arr)=>arr.indexOf(dir) === i); // dedupe
+        await Promise.all(outDirs.map(async (outDir)=>{
             await _io.io.removeDir(outDir, {
                 force: true,
                 recursive: true
@@ -52,4 +52,4 @@ Clean = _ts_decorate([
     ])
 ], Clean);
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/actions/copy.action.js

@@ -43,15 +43,47 @@ class Copy {
             return _cli.ActionResponse.Skipped(Copy.name);
         }
         await Promise.all(this.workspace.getProjects(options.configuration).map(async (proj)=>{
-            const outDir = proj.getOutDir();
-            const pattern = proj.copyFiles;
-            const files = await _io.io.findFiles(pattern, {
-                cwd: proj.projectDirectory
+            const cwd = proj.projectDirectory;
+            const root = proj.getOutDir();
+            // Workspace + configuration copyFiles → package root (historic behaviour).
+            const rootFiles = await _io.io.findFiles(proj.copyFiles, {
+                cwd
             });
-            await Promise.all(files.map((file)=>this.copyFileToOut(file, outDir)));
+            await Promise.all(rootFiles.map((file)=>this.copyFileToOut(file, root)));
+            // Configuration-only globs → each pack target outDir (next to emitted JS).
+            await this.copyColocatedPackAssets(proj, cwd);
         }));
         return _cli.ActionResponse.Success(Copy.name);
     };
+    /**
+	 * Packed builds emit JS under `<out>/<target>/` (e.g. `es6/`). Assets listed on
+	 * the *configuration* `copyFiles` (not the workspace defaults) are also copied
+	 * into each target so `import.meta.url` resolves them beside that JS.
+	 *
+	 * Workspace `copyFiles` (e.g. `package.json`) stay root-only — nesting a
+	 * package manifest under `es6/` makes `npm install --install-links` drop the
+	 * parent's `es6/` tree when packing `file:` deps.
+	 */ async copyColocatedPackAssets(proj, cwd) {
+        const colocatedPatterns = proj.configuration.copyFiles ?? [];
+        if (colocatedPatterns.length === 0) {
+            return;
+        }
+        const config = proj.configuration;
+        if (!config.pack) {
+            return;
+        }
+        const targets = config.targets ?? [];
+        if (targets.length === 0) {
+            return;
+        }
+        const files = await _io.io.findFiles(colocatedPatterns, {
+            cwd
+        });
+        const targetDirs = [
+            ...new Set(targets.map((target)=>proj.getOutDir(target)))
+        ];
+        await Promise.all(targetDirs.flatMap((outDir)=>files.map((file)=>this.copyFileToOut(file, outDir))));
+    }
     async copyFileToOut(file, outDir) {
         const dest = _nodepath.default.join(outDir, file.relativePath);
         await _io.io.copyFile(file.fullPath, dest, {
@@ -80,4 +112,4 @@ Copy = _ts_decorate([
     ])
 ], Copy);
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/actions/docker.action.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Docker", {
+    enumerable: true,
+    get: function() {
+        return Docker;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _interop = require("@decohere/nexus/interop");
+const _io = require("@decohere/nexus/io");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.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 Docker {
+    workspace;
+    #logger = _scribe.scribe.logger(Docker.name);
+    docker = new _interop.Docker();
+    #defaultRegistry = process.env.FORGE_DOCKER_REGISTRY?.trim() || "ghcr.io";
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const projects = await this.getDockerProjects(this.workspace.getProjects(options.configuration));
+        if (projects.length === 0) {
+            this.#logger.info("No projects found with a Dockerfile — nothing to dockerize");
+            return _cli.ActionResponse.Success(Docker.name, []);
+        }
+        const workspacePackageJson = await this.workspace.getPackageJson();
+        const version = await this.workspace.getVersion();
+        const responses = await Promise.all(projects.map(async (project)=>await this.buildProject(project, workspacePackageJson, version, options)));
+        const failed = responses.filter((response)=>!response.succeeded);
+        if (failed.length > 0) {
+            return _cli.ActionResponse.Error(Docker.name, responses);
+        }
+        return _cli.ActionResponse.Success(Docker.name, responses);
+    }
+    async getDockerProjects(projects) {
+        const result = [];
+        for (const project of projects){
+            const dockerfile = project.dockerConfig?.dockerfile ?? "Dockerfile";
+            const dockerfilePath = _nodepath.default.join(project.projectRoot, dockerfile);
+            if (!await _io.io.fileExists(dockerfilePath)) {
+                this.#logger.info(`Skipping ${project.name}: missing ${dockerfile}`);
+                continue;
+            }
+            result.push(project);
+        }
+        return result;
+    }
+    async buildProject(project, workspacePackageJson, version, options) {
+        const dockerConfig = project.dockerConfig ?? {};
+        const envBuildArgs = this.parseJsonEnv("FORGE_DOCKER_BUILD_ARGS_JSON", {});
+        const envSecrets = this.parseJsonEnv("FORGE_DOCKER_SECRETS_JSON", {});
+        const envTags = this.parseJsonEnv("FORGE_DOCKER_EXTRA_TAGS_JSON", []);
+        const image = dockerConfig.image ?? this.defaultImageName(project.name, workspacePackageJson);
+        const dockerfile = dockerConfig.dockerfile ?? "Dockerfile";
+        const extraTags = this.extraTagsForImage(image, [
+            ...dockerConfig.tags ?? [],
+            ...envTags
+        ]);
+        const tags = [
+            `${image}:${version}`,
+            ...extraTags
+        ];
+        const buildArgs = this.interpolateBuildArgs({
+            ...dockerConfig.buildArgs ?? {},
+            ...envBuildArgs
+        }, version);
+        const secrets = {
+            ...dockerConfig.secrets ?? {},
+            ...envSecrets
+        };
+        this.#logger.info(`${options.dryRun ? "[dry-run] " : ""}Building ${project.name}`);
+        try {
+            await this.docker.build(project.projectRoot, {
+                cwd: project.projectRoot,
+                dockerfile: _nodepath.default.join(project.projectRoot, dockerfile),
+                tags,
+                buildArgs,
+                secrets
+            });
+            const shouldPush = options.push || dockerConfig.push;
+            if (shouldPush && !options.dryRun) {
+                for (const tag of tags){
+                    await this.docker.push(tag, {
+                        cwd: project.projectRoot
+                    });
+                }
+            } else if (shouldPush && options.dryRun) {
+                this.#logger.info(`[dry-run] Skipping push for ${project.name}`);
+            }
+            return {
+                projectName: project.name,
+                image,
+                tags,
+                succeeded: true,
+                message: options.dryRun ? `Built ${image} (not pushed)` : `Built ${image}`
+            };
+        } catch (reason) {
+            const message = (0, _errors.formatUnknownError)(reason);
+            return {
+                projectName: project.name,
+                image,
+                tags,
+                succeeded: false,
+                message,
+                error: `${project.name}: ${message}`
+            };
+        }
+    }
+    interpolateBuildArgs(buildArgs, version) {
+        const result = {};
+        const versionPlaceholder = "$" + "{version}";
+        for (const [key, value] of Object.entries(buildArgs ?? {})){
+            result[key] = value.split(versionPlaceholder).join(version);
+        }
+        return result;
+    }
+    /**
+	 * Keep FORGE_DOCKER_EXTRA_TAGS_JSON scoped to this image so multi-image
+	 * publishes do not stamp create:latest onto the app Dev Container (and vice versa).
+	 */ extraTagsForImage(image, tags) {
+        const prefix = `${image}:`;
+        const seen = new Set();
+        const result = [];
+        for (const tag of tags){
+            if (tag === image || tag.startsWith(prefix)) {
+                if (!seen.has(tag)) {
+                    seen.add(tag);
+                    result.push(tag);
+                }
+            }
+        }
+        return result;
+    }
+    defaultImageName(projectName, workspacePackageJson) {
+        const repositoryPath = process.env.FORGE_DOCKER_NAMESPACE?.trim() || workspacePackageJson.getRepositoryFullName() || this.normalizeDockerRepository(projectName);
+        const projectSlug = this.normalizeProjectSlug(projectName);
+        if (repositoryPath.includes("/") && projectSlug !== "") {
+            return `${this.#defaultRegistry}/${repositoryPath}/${projectSlug}`;
+        }
+        return `${this.#defaultRegistry}/${repositoryPath}`;
+    }
+    normalizeDockerRepository(name) {
+        const repository = name.replace(/^@/, "").split("/").map((segment)=>segment.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")).filter(Boolean).join("/");
+        if (repository === "") {
+            throw new _errors.ForgeError(`Could not derive a Docker repository from project name "${name}"`);
+        }
+        return repository;
+    }
+    normalizeProjectSlug(name) {
+        const unscoped = name.includes("/") ? name.split("/").at(-1) ?? name : name;
+        const slug = unscoped.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+        if (slug === "") {
+            throw new _errors.ForgeError(`Could not derive a Docker project slug from project name "${name}"`);
+        }
+        return slug;
+    }
+    parseJsonEnv(name, fallback) {
+        const value = process.env[name];
+        if (value == null || value.trim() === "") {
+            return fallback;
+        }
+        try {
+            return JSON.parse(value);
+        } catch (reason) {
+            throw new _errors.ForgeError(`Invalid JSON in ${name}: ${(0, _errors.formatUnknownError)(reason)}`);
+        }
+    }
+}
+Docker = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Docker);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/docker.action.ts"],"sourcesContent":["import path from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport type { PackageJson, Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action, ResultStatus } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { Docker as DockerInterop } from \"@decohere/nexus/interop\";\nimport { io } from \"@decohere/nexus/io\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError, formatUnknownError } from \"../errors.js\";\n\nexport type DockerOptions = {\n\tconfiguration: string;\n\tdryRun?: boolean;\n\tpush?: boolean;\n};\n\nexport type DockerResponse = ResultStatus & {\n\tprojectName: string;\n\timage: string;\n\ttags: string[];\n\tmessage: string;\n};\n\n@injectable()\nexport class Docker implements Action<DockerOptions> {\n\t#logger = scribe.logger(Docker.name);\n\tprivate readonly docker = new DockerInterop();\n\treadonly #defaultRegistry = process.env.FORGE_DOCKER_REGISTRY?.trim() || \"ghcr.io\";\n\n\tpublic constructor(private readonly workspace: Workspace) {}\n\n\tpublic async run(options: DockerOptions): Promise<ActionResponse<DockerResponse>> {\n\t\tconst projects = await this.getDockerProjects(\n\t\t\tthis.workspace.getProjects(options.configuration),\n\t\t);\n\t\tif (projects.length === 0) {\n\t\t\tthis.#logger.info(\"No projects found with a Dockerfile — nothing to dockerize\");\n\t\t\treturn ActionResponse.Success(Docker.name, []);\n\t\t}\n\n\t\tconst workspacePackageJson = await this.workspace.getPackageJson();\n\t\tconst version = await this.workspace.getVersion();\n\t\tconst responses = await Promise.all(\n\t\t\tprojects.map(\n\t\t\t\tasync (project) =>\n\t\t\t\t\tawait this.buildProject(project, workspacePackageJson, version, options),\n\t\t\t),\n\t\t);\n\t\tconst failed = responses.filter((response) => !response.succeeded);\n\t\tif (failed.length > 0) {\n\t\t\treturn ActionResponse.Error(Docker.name, responses);\n\t\t}\n\t\treturn ActionResponse.Success(Docker.name, responses);\n\t}\n\n\tprivate async getDockerProjects(projects: readonly Project[]) {\n\t\tconst result: Project[] = [];\n\t\tfor (const project of projects) {\n\t\t\tconst dockerfile = project.dockerConfig?.dockerfile ?? \"Dockerfile\";\n\t\t\tconst dockerfilePath = path.join(project.projectRoot, dockerfile);\n\t\t\tif (!(await io.fileExists(dockerfilePath))) {\n\t\t\t\tthis.#logger.info(`Skipping ${project.name}: missing ${dockerfile}`);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tresult.push(project);\n\t\t}\n\t\treturn result;\n\t}\n\n\tprivate async buildProject(\n\t\tproject: Project,\n\t\tworkspacePackageJson: PackageJson,\n\t\tversion: string,\n\t\toptions: DockerOptions,\n\t): Promise<DockerResponse> {\n\t\tconst dockerConfig = project.dockerConfig ?? {};\n\t\tconst envBuildArgs = this.parseJsonEnv<Record<string, string>>(\n\t\t\t\"FORGE_DOCKER_BUILD_ARGS_JSON\",\n\t\t\t{},\n\t\t);\n\t\tconst envSecrets = this.parseJsonEnv<Record<string, string>>(\n\t\t\t\"FORGE_DOCKER_SECRETS_JSON\",\n\t\t\t{},\n\t\t);\n\t\tconst envTags = this.parseJsonEnv<string[]>(\"FORGE_DOCKER_EXTRA_TAGS_JSON\", []);\n\n\t\tconst image =\n\t\t\tdockerConfig.image ?? this.defaultImageName(project.name, workspacePackageJson);\n\t\tconst dockerfile = dockerConfig.dockerfile ?? \"Dockerfile\";\n\t\tconst extraTags = this.extraTagsForImage(image, [\n\t\t\t...(dockerConfig.tags ?? []),\n\t\t\t...envTags,\n\t\t]);\n\t\tconst tags = [`${image}:${version}`, ...extraTags];\n\t\tconst buildArgs = this.interpolateBuildArgs(\n\t\t\t{ ...(dockerConfig.buildArgs ?? {}), ...envBuildArgs },\n\t\t\tversion,\n\t\t);\n\t\tconst secrets = { ...(dockerConfig.secrets ?? {}), ...envSecrets };\n\n\t\tthis.#logger.info(`${options.dryRun ? \"[dry-run] \" : \"\"}Building ${project.name}`);\n\t\ttry {\n\t\t\tawait this.docker.build(project.projectRoot, {\n\t\t\t\tcwd: project.projectRoot,\n\t\t\t\tdockerfile: path.join(project.projectRoot, dockerfile),\n\t\t\t\ttags,\n\t\t\t\tbuildArgs,\n\t\t\t\tsecrets,\n\t\t\t});\n\n\t\t\tconst shouldPush = options.push || dockerConfig.push;\n\t\t\tif (shouldPush && !options.dryRun) {\n\t\t\t\tfor (const tag of tags) {\n\t\t\t\t\tawait this.docker.push(tag, { cwd: project.projectRoot });\n\t\t\t\t}\n\t\t\t} else if (shouldPush && options.dryRun) {\n\t\t\t\tthis.#logger.info(`[dry-run] Skipping push for ${project.name}`);\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tprojectName: project.name,\n\t\t\t\timage,\n\t\t\t\ttags,\n\t\t\t\tsucceeded: true,\n\t\t\t\tmessage: options.dryRun ? `Built ${image} (not pushed)` : `Built ${image}`,\n\t\t\t};\n\t\t} catch (reason) {\n\t\t\tconst message = formatUnknownError(reason);\n\t\t\treturn {\n\t\t\t\tprojectName: project.name,\n\t\t\t\timage,\n\t\t\t\ttags,\n\t\t\t\tsucceeded: false,\n\t\t\t\tmessage,\n\t\t\t\terror: `${project.name}: ${message}`,\n\t\t\t};\n\t\t}\n\t}\n\n\tprivate interpolateBuildArgs(\n\t\tbuildArgs: Record<string, string> | undefined,\n\t\tversion: string,\n\t) {\n\t\tconst result: Record<string, string> = {};\n\t\tconst versionPlaceholder = \"$\" + \"{version}\";\n\t\tfor (const [key, value] of Object.entries(buildArgs ?? {})) {\n\t\t\tresult[key] = value.split(versionPlaceholder).join(version);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * Keep FORGE_DOCKER_EXTRA_TAGS_JSON scoped to this image so multi-image\n\t * publishes do not stamp create:latest onto the app Dev Container (and vice versa).\n\t */\n\tprivate extraTagsForImage(image: string, tags: readonly string[]): string[] {\n\t\tconst prefix = `${image}:`;\n\t\tconst seen = new Set<string>();\n\t\tconst result: string[] = [];\n\t\tfor (const tag of tags) {\n\t\t\tif (tag === image || tag.startsWith(prefix)) {\n\t\t\t\tif (!seen.has(tag)) {\n\t\t\t\t\tseen.add(tag);\n\t\t\t\t\tresult.push(tag);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\n\tprivate defaultImageName(projectName: string, workspacePackageJson: PackageJson) {\n\t\tconst repositoryPath =\n\t\t\tprocess.env.FORGE_DOCKER_NAMESPACE?.trim() ||\n\t\t\tworkspacePackageJson.getRepositoryFullName() ||\n\t\t\tthis.normalizeDockerRepository(projectName);\n\t\tconst projectSlug = this.normalizeProjectSlug(projectName);\n\t\tif (repositoryPath.includes(\"/\") && projectSlug !== \"\") {\n\t\t\treturn `${this.#defaultRegistry}/${repositoryPath}/${projectSlug}`;\n\t\t}\n\t\treturn `${this.#defaultRegistry}/${repositoryPath}`;\n\t}\n\n\tprivate normalizeDockerRepository(name: string) {\n\t\tconst repository = name\n\t\t\t.replace(/^@/, \"\")\n\t\t\t.split(\"/\")\n\t\t\t.map((segment) =>\n\t\t\t\tsegment\n\t\t\t\t\t.toLowerCase()\n\t\t\t\t\t.replace(/[^a-z0-9]+/g, \"-\")\n\t\t\t\t\t.replace(/^-+|-+$/g, \"\"),\n\t\t\t)\n\t\t\t.filter(Boolean)\n\t\t\t.join(\"/\");\n\n\t\tif (repository === \"\") {\n\t\t\tthrow new ForgeError(`Could not derive a Docker repository from project name \"${name}\"`);\n\t\t}\n\n\t\treturn repository;\n\t}\n\n\tprivate normalizeProjectSlug(name: string) {\n\t\tconst unscoped = name.includes(\"/\") ? (name.split(\"/\").at(-1) ?? name) : name;\n\t\tconst slug = unscoped\n\t\t\t.toLowerCase()\n\t\t\t.replace(/[^a-z0-9]+/g, \"-\")\n\t\t\t.replace(/^-+|-+$/g, \"\");\n\t\tif (slug === \"\") {\n\t\t\tthrow new ForgeError(\n\t\t\t\t`Could not derive a Docker project slug from project name \"${name}\"`,\n\t\t\t);\n\t\t}\n\t\treturn slug;\n\t}\n\n\tprivate parseJsonEnv<T>(name: string, fallback: T): T {\n\t\tconst value = process.env[name];\n\t\tif (value == null || value.trim() === \"\") {\n\t\t\treturn fallback;\n\t\t}\n\n\t\ttry {\n\t\t\treturn JSON.parse(value) as T;\n\t\t} catch (reason) {\n\t\t\tthrow new ForgeError(`Invalid JSON in ${name}: ${formatUnknownError(reason)}`);\n\t\t}\n\t}\n}\n"],"names":["Docker","scribe","logger","name","docker","DockerInterop","process","env","FORGE_DOCKER_REGISTRY","trim","workspace","run","options","projects","getDockerProjects","getProjects","configuration","length","info","ActionResponse","Success","workspacePackageJson","getPackageJson","version","getVersion","responses","Promise","all","map","project","buildProject","failed","filter","response","succeeded","Error","result","dockerfile","dockerConfig","dockerfilePath","path","join","projectRoot","io","fileExists","push","envBuildArgs","parseJsonEnv","envSecrets","envTags","image","defaultImageName","extraTags","extraTagsForImage","tags","buildArgs","interpolateBuildArgs","secrets","dryRun","build","cwd","shouldPush","tag","projectName","message","reason","formatUnknownError","error","versionPlaceholder","key","value","Object","entries","split","prefix","seen","Set","startsWith","has","add","repositoryPath","FORGE_DOCKER_NAMESPACE","getRepositoryFullName","normalizeDockerRepository","projectSlug","normalizeProjectSlug","includes","repository","replace","segment","toLowerCase","Boolean","ForgeError","unscoped","at","slug","fallback","JSON","parse"],"mappings":"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"}

package/commonjs/src/actions/index.js

@@ -8,9 +8,13 @@ _export_star(require("./commit.action.js"), exports);
 _export_star(require("./copy.action.js"), exports);
 _export_star(require("./dependency-report.action.js"), exports);
 _export_star(require("./dependency-sync.action.js"), exports);
+_export_star(require("./docker.action.js"), exports);
+_export_star(require("./link.action.js"), exports);
 _export_star(require("./publish.action.js"), exports);
 _export_star(require("./sync-lock-file.action.js"), exports);
 _export_star(require("./tag.action.js"), exports);
+_export_star(require("./typecheck.action.js"), exports);
+_export_star(require("./unlink.action.js"), exports);
 _export_star(require("./version.action.js"), exports);
 _export_star(require("./watch.action.js"), exports);
 function _export_star(from, to) {
@@ -27,4 +31,4 @@ function _export_star(from, to) {
     return from;
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9hY3Rpb25zL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2J1aWxkLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2xlYW4uYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21taXQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3B5LmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVwZW5kZW5jeS1yZXBvcnQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXBlbmRlbmN5LXN5bmMuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9wdWJsaXNoLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc3luYy1sb2NrLWZpbGUuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90YWcuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi92ZXJzaW9uLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vd2F0Y2guYWN0aW9uLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztxQkFBYztxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9hY3Rpb25zL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2J1aWxkLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vY2xlYW4uYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21taXQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb3B5LmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVwZW5kZW5jeS1yZXBvcnQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXBlbmRlbmN5LXN5bmMuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kb2NrZXIuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saW5rLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHVibGlzaC5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N5bmMtbG9jay1maWxlLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdGFnLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZWNoZWNrLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdW5saW5rLmFjdGlvbi5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdmVyc2lvbi5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3dhdGNoLmFjdGlvbi5qc1wiO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWM7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0E7cUJBQ0EifQ==

package/commonjs/src/actions/link.action.js

@@ -0,0 +1,156 @@
+"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_LINK_CONFIGURATION () {
+        return DEFAULT_LINK_CONFIGURATION;
+    },
+    get LINK_MANIFEST () {
+        return LINK_MANIFEST;
+    },
+    get Link () {
+        return Link;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _scribe = require("@decohere/scribe");
+require("../extensions/project.extensions.js");
+const _errors = require("../errors.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);
+}
+const LINK_MANIFEST = ".forge-link.json";
+const DEFAULT_LINK_CONFIGURATION = "link";
+class Link {
+    workspace;
+    #logger = _scribe.scribe.logger(Link.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        const targetDir = _nodepath.default.resolve(options.targetDir);
+        const nodeModulesDir = _nodepath.default.join(targetDir, "node_modules");
+        const stat = await _promises.default.stat(nodeModulesDir).catch(()=>null);
+        if (stat == null) {
+            throw new _errors.ForgeError(`node_modules not found in "${targetDir}". Run pnpm install first.`);
+        }
+        const projects = this.workspace.getProjects(options.configuration);
+        if (projects.length === 0) {
+            throw new _errors.ForgeError(`No projects found for configuration "${options.configuration}"`);
+        }
+        // Load any existing manifest so originalPath values are preserved on re-link
+        const manifestPath = _nodepath.default.join(targetDir, LINK_MANIFEST);
+        const existingManifestText = await _promises.default.readFile(manifestPath, "utf8").catch(()=>null);
+        const existingManifest = existingManifestText != null ? JSON.parse(existingManifestText) : null;
+        const manifest = {
+            workspaceRoot: this.workspace.rootDir,
+            links: []
+        };
+        for (const project of projects){
+            const pkg = await project.getPackageJson();
+            const packageName = pkg.name;
+            if (!packageName) {
+                this.#logger.trace(`Skipping project "${project.name}" — no package name`);
+                continue;
+            }
+            // Resolve the build output directory (no target arg — debug config is not packed)
+            const outDir = project.getOutDir();
+            const absoluteOutDir = _nodepath.default.resolve(outDir);
+            // Pre-create the output dir so the symlink is valid even before a build completes.
+            await _promises.default.mkdir(absoluteOutDir, {
+                recursive: true
+            });
+            // Compute symlink path inside target node_modules
+            const symlinkPath = _nodepath.default.join(nodeModulesDir, ...packageName.split("/"));
+            const symlinkParent = _nodepath.default.dirname(symlinkPath);
+            // Capture any existing entry so we can restore it on unlink.
+            // If a manifest already exists for this package, preserve its originalPath —
+            // the current symlink is our own and must not be treated as the original.
+            let originalPath = null;
+            const existingStat = await _promises.default.lstat(symlinkPath).catch(()=>null);
+            if (existingStat != null) {
+                const existingEntry = existingManifest?.links.find((l)=>l.packageName === packageName);
+                if (existingEntry != null) {
+                    // Already linked — preserve the recorded originalPath and replace the symlink
+                    originalPath = existingEntry.originalPath;
+                    if (existingStat.isSymbolicLink()) {
+                        await _promises.default.unlink(symlinkPath);
+                    }
+                } else if (existingStat.isSymbolicLink()) {
+                    originalPath = await _promises.default.readlink(symlinkPath);
+                    await _promises.default.unlink(symlinkPath);
+                } else {
+                    // Real directory — back it up by renaming
+                    originalPath = `${symlinkPath}.__forge_backup__`;
+                    await _promises.default.rename(symlinkPath, originalPath);
+                }
+            }
+            await _promises.default.mkdir(symlinkParent, {
+                recursive: true
+            });
+            await _promises.default.symlink(absoluteOutDir, symlinkPath, "dir");
+            manifest.links.push({
+                packageName,
+                symlinkPath,
+                originalPath
+            });
+            this.#logger.info(`Linked ${packageName} → ${absoluteOutDir}`);
+        }
+        // Create a peer node_modules at the build output root so Node can resolve
+        // bare specifiers from the real (non-symlink) paths of linked packages.
+        if (manifest.links.length > 0) {
+            const buildRoot = _nodepath.default.resolve(projects[0].getRootOut());
+            const peerNodeModulesDir = _nodepath.default.join(buildRoot, "node_modules");
+            await _promises.default.rm(peerNodeModulesDir, {
+                recursive: true,
+                force: true
+            });
+            for (const project of projects){
+                const pkg = await project.getPackageJson();
+                if (!pkg.name) continue;
+                const outDir = _nodepath.default.resolve(project.getOutDir());
+                const peerSymlink = _nodepath.default.join(peerNodeModulesDir, ...pkg.name.split("/"));
+                await _promises.default.mkdir(_nodepath.default.dirname(peerSymlink), {
+                    recursive: true
+                });
+                await _promises.default.symlink(outDir, peerSymlink, "dir");
+                this.#logger.trace(`Peer-linked ${pkg.name} → ${outDir}`);
+            }
+            manifest.peerNodeModulesDir = peerNodeModulesDir;
+            this.#logger.info(`Created peer node_modules at ${peerNodeModulesDir}`);
+        }
+        await _promises.default.writeFile(_nodepath.default.join(targetDir, LINK_MANIFEST), JSON.stringify(manifest, null, 2));
+        return _cli.ActionResponse.Success(Link.name);
+    };
+}
+Link = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Link);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/link.action.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { scribe } from \"@decohere/scribe\";\nimport \"../extensions/project.extensions.js\";\nimport { ForgeError } from \"../errors.js\";\n\nexport const LINK_MANIFEST = \".forge-link.json\";\n\nexport type LinkOptions = {\n\tconfiguration: string;\n\ttargetDir: string;\n};\n\nexport const DEFAULT_LINK_CONFIGURATION = \"link\";\n\nexport type LinkManifest = {\n\tworkspaceRoot: string;\n\tpeerNodeModulesDir?: string;\n\tlinks: Array<{ packageName: string; symlinkPath: string; originalPath: string | null }>;\n};\n\n@injectable()\nexport class Link implements Action<LinkOptions> {\n\t#logger = scribe.logger(Link.name);\n\n\tpublic constructor(private readonly workspace: Workspace) {}\n\n\tpublic run = async (options: LinkOptions): Promise<ActionResponse> => {\n\t\tconst targetDir = path.resolve(options.targetDir);\n\t\tconst nodeModulesDir = path.join(targetDir, \"node_modules\");\n\n\t\tconst stat = await fs.stat(nodeModulesDir).catch(() => null);\n\t\tif (stat == null) {\n\t\t\tthrow new ForgeError(\n\t\t\t\t`node_modules not found in \"${targetDir}\". Run pnpm install first.`,\n\t\t\t);\n\t\t}\n\n\t\tconst projects = this.workspace.getProjects(options.configuration);\n\t\tif (projects.length === 0) {\n\t\t\tthrow new ForgeError(`No projects found for configuration \"${options.configuration}\"`);\n\t\t}\n\n\t\t// Load any existing manifest so originalPath values are preserved on re-link\n\t\tconst manifestPath = path.join(targetDir, LINK_MANIFEST);\n\t\tconst existingManifestText = await fs.readFile(manifestPath, \"utf8\").catch(() => null);\n\t\tconst existingManifest: LinkManifest | null =\n\t\t\texistingManifestText != null ? JSON.parse(existingManifestText) : null;\n\n\t\tconst manifest: LinkManifest = {\n\t\t\tworkspaceRoot: this.workspace.rootDir,\n\t\t\tlinks: [],\n\t\t};\n\n\t\tfor (const project of projects) {\n\t\t\tconst pkg = await project.getPackageJson();\n\t\t\tconst packageName = pkg.name;\n\t\t\tif (!packageName) {\n\t\t\t\tthis.#logger.trace(`Skipping project \"${project.name}\" — no package name`);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Resolve the build output directory (no target arg — debug config is not packed)\n\t\t\tconst outDir = project.getOutDir();\n\t\t\tconst absoluteOutDir = path.resolve(outDir);\n\n\t\t\t// Pre-create the output dir so the symlink is valid even before a build completes.\n\t\t\tawait fs.mkdir(absoluteOutDir, { recursive: true });\n\n\t\t\t// Compute symlink path inside target node_modules\n\t\t\tconst symlinkPath = path.join(nodeModulesDir, ...packageName.split(\"/\"));\n\t\t\tconst symlinkParent = path.dirname(symlinkPath);\n\n\t\t\t// Capture any existing entry so we can restore it on unlink.\n\t\t\t// If a manifest already exists for this package, preserve its originalPath —\n\t\t\t// the current symlink is our own and must not be treated as the original.\n\t\t\tlet originalPath: string | null = null;\n\t\t\tconst existingStat = await fs.lstat(symlinkPath).catch(() => null);\n\t\t\tif (existingStat != null) {\n\t\t\t\tconst existingEntry = existingManifest?.links.find(\n\t\t\t\t\t(l) => l.packageName === packageName,\n\t\t\t\t);\n\t\t\t\tif (existingEntry != null) {\n\t\t\t\t\t// Already linked — preserve the recorded originalPath and replace the symlink\n\t\t\t\t\toriginalPath = existingEntry.originalPath;\n\t\t\t\t\tif (existingStat.isSymbolicLink()) {\n\t\t\t\t\t\tawait fs.unlink(symlinkPath);\n\t\t\t\t\t}\n\t\t\t\t} else if (existingStat.isSymbolicLink()) {\n\t\t\t\t\toriginalPath = await fs.readlink(symlinkPath);\n\t\t\t\t\tawait fs.unlink(symlinkPath);\n\t\t\t\t} else {\n\t\t\t\t\t// Real directory — back it up by renaming\n\t\t\t\t\toriginalPath = `${symlinkPath}.__forge_backup__`;\n\t\t\t\t\tawait fs.rename(symlinkPath, originalPath);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tawait fs.mkdir(symlinkParent, { recursive: true });\n\t\t\tawait fs.symlink(absoluteOutDir, symlinkPath, \"dir\");\n\n\t\t\tmanifest.links.push({ packageName, symlinkPath, originalPath });\n\t\t\tthis.#logger.info(`Linked ${packageName} → ${absoluteOutDir}`);\n\t\t}\n\n\t\t// Create a peer node_modules at the build output root so Node can resolve\n\t\t// bare specifiers from the real (non-symlink) paths of linked packages.\n\t\tif (manifest.links.length > 0) {\n\t\t\tconst buildRoot = path.resolve(projects[0].getRootOut());\n\t\t\tconst peerNodeModulesDir = path.join(buildRoot, \"node_modules\");\n\t\t\tawait fs.rm(peerNodeModulesDir, { recursive: true, force: true });\n\t\t\tfor (const project of projects) {\n\t\t\t\tconst pkg = await project.getPackageJson();\n\t\t\t\tif (!pkg.name) continue;\n\t\t\t\tconst outDir = path.resolve(project.getOutDir());\n\t\t\t\tconst peerSymlink = path.join(peerNodeModulesDir, ...pkg.name.split(\"/\"));\n\t\t\t\tawait fs.mkdir(path.dirname(peerSymlink), { recursive: true });\n\t\t\t\tawait fs.symlink(outDir, peerSymlink, \"dir\");\n\t\t\t\tthis.#logger.trace(`Peer-linked ${pkg.name} → ${outDir}`);\n\t\t\t}\n\t\t\tmanifest.peerNodeModulesDir = peerNodeModulesDir;\n\t\t\tthis.#logger.info(`Created peer node_modules at ${peerNodeModulesDir}`);\n\t\t}\n\n\t\tawait fs.writeFile(path.join(targetDir, LINK_MANIFEST), JSON.stringify(manifest, null, 2));\n\n\t\treturn ActionResponse.Success(Link.name);\n\t};\n}\n"],"names":["DEFAULT_LINK_CONFIGURATION","LINK_MANIFEST","Link","scribe","logger","name","workspace","run","options","targetDir","path","resolve","nodeModulesDir","join","stat","fs","catch","ForgeError","projects","getProjects","configuration","length","manifestPath","existingManifestText","readFile","existingManifest","JSON","parse","manifest","workspaceRoot","rootDir","links","project","pkg","getPackageJson","packageName","trace","outDir","getOutDir","absoluteOutDir","mkdir","recursive","symlinkPath","split","symlinkParent","dirname","originalPath","existingStat","lstat","existingEntry","find","l","isSymbolicLink","unlink","readlink","rename","symlink","push","info","buildRoot","getRootOut","peerNodeModulesDir","rm","force","peerSymlink","writeFile","stringify","ActionResponse","Success"],"mappings":";;;;;;;;;;;QAkBaA;eAAAA;;QAPAC;eAAAA;;QAgBAC;eAAAA;;;iEA3BE;iEACE;4BACU;sBAED;qBAEK;wBACR;QAChB;wBACoB;;;;;;;;;;;;;;;AAEpB,MAAMD,gBAAgB;AAOtB,MAAMD,6BAA6B;AASnC,MAAME;;IACZ,CAAA,MAAO,GAAGC,cAAM,CAACC,MAAM,CAACF,KAAKG,IAAI,EAAE;IAEnC,YAAmB,AAAiBC,SAAoB,CAAE;aAAtBA,YAAAA;IAAuB;IAEpDC,MAAM,OAAOC;QACnB,MAAMC,YAAYC,iBAAI,CAACC,OAAO,CAACH,QAAQC,SAAS;QAChD,MAAMG,iBAAiBF,iBAAI,CAACG,IAAI,CAACJ,WAAW;QAE5C,MAAMK,OAAO,MAAMC,iBAAE,CAACD,IAAI,CAACF,gBAAgBI,KAAK,CAAC,IAAM;QACvD,IAAIF,QAAQ,MAAM;YACjB,MAAM,IAAIG,kBAAU,CACnB,CAAC,2BAA2B,EAAER,UAAU,0BAA0B,CAAC;QAErE;QAEA,MAAMS,WAAW,IAAI,CAACZ,SAAS,CAACa,WAAW,CAACX,QAAQY,aAAa;QACjE,IAAIF,SAASG,MAAM,KAAK,GAAG;YAC1B,MAAM,IAAIJ,kBAAU,CAAC,CAAC,qCAAqC,EAAET,QAAQY,aAAa,CAAC,CAAC,CAAC;QACtF;QAEA,6EAA6E;QAC7E,MAAME,eAAeZ,iBAAI,CAACG,IAAI,CAACJ,WAAWR;QAC1C,MAAMsB,uBAAuB,MAAMR,iBAAE,CAACS,QAAQ,CAACF,cAAc,QAAQN,KAAK,CAAC,IAAM;QACjF,MAAMS,mBACLF,wBAAwB,OAAOG,KAAKC,KAAK,CAACJ,wBAAwB;QAEnE,MAAMK,WAAyB;YAC9BC,eAAe,IAAI,CAACvB,SAAS,CAACwB,OAAO;YACrCC,OAAO,EAAE;QACV;QAEA,KAAK,MAAMC,WAAWd,SAAU;YAC/B,MAAMe,MAAM,MAAMD,QAAQE,cAAc;YACxC,MAAMC,cAAcF,IAAI5B,IAAI;YAC5B,IAAI,CAAC8B,aAAa;gBACjB,IAAI,CAAC,CAAA,MAAO,CAACC,KAAK,CAAC,CAAC,kBAAkB,EAAEJ,QAAQ3B,IAAI,CAAC,mBAAmB,CAAC;gBACzE;YACD;YAEA,kFAAkF;YAClF,MAAMgC,SAASL,QAAQM,SAAS;YAChC,MAAMC,iBAAiB7B,iBAAI,CAACC,OAAO,CAAC0B;YAEpC,mFAAmF;YACnF,MAAMtB,iBAAE,CAACyB,KAAK,CAACD,gBAAgB;gBAAEE,WAAW;YAAK;YAEjD,kDAAkD;YAClD,MAAMC,cAAchC,iBAAI,CAACG,IAAI,CAACD,mBAAmBuB,YAAYQ,KAAK,CAAC;YACnE,MAAMC,gBAAgBlC,iBAAI,CAACmC,OAAO,CAACH;YAEnC,6DAA6D;YAC7D,6EAA6E;YAC7E,0EAA0E;YAC1E,IAAII,eAA8B;YAClC,MAAMC,eAAe,MAAMhC,iBAAE,CAACiC,KAAK,CAACN,aAAa1B,KAAK,CAAC,IAAM;YAC7D,IAAI+B,gBAAgB,MAAM;gBACzB,MAAME,gBAAgBxB,kBAAkBM,MAAMmB,KAC7C,CAACC,IAAMA,EAAEhB,WAAW,KAAKA;gBAE1B,IAAIc,iBAAiB,MAAM;oBAC1B,8EAA8E;oBAC9EH,eAAeG,cAAcH,YAAY;oBACzC,IAAIC,aAAaK,cAAc,IAAI;wBAClC,MAAMrC,iBAAE,CAACsC,MAAM,CAACX;oBACjB;gBACD,OAAO,IAAIK,aAAaK,cAAc,IAAI;oBACzCN,eAAe,MAAM/B,iBAAE,CAACuC,QAAQ,CAACZ;oBACjC,MAAM3B,iBAAE,CAACsC,MAAM,CAACX;gBACjB,OAAO;oBACN,0CAA0C;oBAC1CI,eAAe,GAAGJ,YAAY,iBAAiB,CAAC;oBAChD,MAAM3B,iBAAE,CAACwC,MAAM,CAACb,aAAaI;gBAC9B;YACD;YAEA,MAAM/B,iBAAE,CAACyB,KAAK,CAACI,eAAe;gBAAEH,WAAW;YAAK;YAChD,MAAM1B,iBAAE,CAACyC,OAAO,CAACjB,gBAAgBG,aAAa;YAE9Cd,SAASG,KAAK,CAAC0B,IAAI,CAAC;gBAAEtB;gBAAaO;gBAAaI;YAAa;YAC7D,IAAI,CAAC,CAAA,MAAO,CAACY,IAAI,CAAC,CAAC,OAAO,EAAEvB,YAAY,GAAG,EAAEI,gBAAgB;QAC9D;QAEA,0EAA0E;QAC1E,wEAAwE;QACxE,IAAIX,SAASG,KAAK,CAACV,MAAM,GAAG,GAAG;YAC9B,MAAMsC,YAAYjD,iBAAI,CAACC,OAAO,CAACO,QAAQ,CAAC,EAAE,CAAC0C,UAAU;YACrD,MAAMC,qBAAqBnD,iBAAI,CAACG,IAAI,CAAC8C,WAAW;YAChD,MAAM5C,iBAAE,CAAC+C,EAAE,CAACD,oBAAoB;gBAAEpB,WAAW;gBAAMsB,OAAO;YAAK;YAC/D,KAAK,MAAM/B,WAAWd,SAAU;gBAC/B,MAAMe,MAAM,MAAMD,QAAQE,cAAc;gBACxC,IAAI,CAACD,IAAI5B,IAAI,EAAE;gBACf,MAAMgC,SAAS3B,iBAAI,CAACC,OAAO,CAACqB,QAAQM,SAAS;gBAC7C,MAAM0B,cAActD,iBAAI,CAACG,IAAI,CAACgD,uBAAuB5B,IAAI5B,IAAI,CAACsC,KAAK,CAAC;gBACpE,MAAM5B,iBAAE,CAACyB,KAAK,CAAC9B,iBAAI,CAACmC,OAAO,CAACmB,cAAc;oBAAEvB,WAAW;gBAAK;gBAC5D,MAAM1B,iBAAE,CAACyC,OAAO,CAACnB,QAAQ2B,aAAa;gBACtC,IAAI,CAAC,CAAA,MAAO,CAAC5B,KAAK,CAAC,CAAC,YAAY,EAAEH,IAAI5B,IAAI,CAAC,GAAG,EAAEgC,QAAQ;YACzD;YACAT,SAASiC,kBAAkB,GAAGA;YAC9B,IAAI,CAAC,CAAA,MAAO,CAACH,IAAI,CAAC,CAAC,6BAA6B,EAAEG,oBAAoB;QACvE;QAEA,MAAM9C,iBAAE,CAACkD,SAAS,CAACvD,iBAAI,CAACG,IAAI,CAACJ,WAAWR,gBAAgByB,KAAKwC,SAAS,CAACtC,UAAU,MAAM;QAEvF,OAAOuC,mBAAc,CAACC,OAAO,CAAClE,KAAKG,IAAI;IACxC,EAAE;AACH"}