@decohere/forge 0.0.1-dev.12 → 0.0.1-dev.121

package/es6/src/actions/package.action.js

@@ -0,0 +1,219 @@
+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);
+}
+import fs from "node:fs/promises";
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Npm } from "@decohere/devkit/interop";
+import { io } from "@decohere/core/io";
+import { scribe } from "@decohere/scribe";
+import { ForgeError, formatUnknownError } from "../errors.js";
+import { DependencyPinner } from "../packaging/dependency-pinner.service.js";
+import { deployable, PACKAGE_DIR } from "../packaging/deployable.js";
+import { ImportGraph } from "../packaging/import-graph.service.js";
+import { releaseExports } from "../packaging/release-exports.js";
+import { uiAssets } from "../packaging/ui-assets.js";
+import { Release } from "../workspace.config.js";
+export class PackageDeployable {
+    workspace;
+    importGraph;
+    pinner;
+    #logger = scribe.logger(PackageDeployable.name);
+    npm = new Npm();
+    constructor(workspace, importGraph, pinner){
+        this.workspace = workspace;
+        this.importGraph = importGraph;
+        this.pinner = pinner;
+    }
+    async run(options) {
+        const projects = this.workspace.getProjects(Release.name);
+        const selected = await this.select(projects, options.project);
+        if (typeof selected === "string") {
+            return ActionResponse.Error(PackageDeployable.name, selected);
+        }
+        if (selected.length === 0) {
+            this.#logger.info("No projects found with a Dockerfile — nothing to package");
+            return ActionResponse.Success(PackageDeployable.name, []);
+        }
+        const releaseProjects = await this.releaseProjects(projects);
+        const responses = [];
+        for (const project of selected){
+            responses.push(await this.packageProject(project, releaseProjects, projects));
+        }
+        return responses.some((response)=>!response.succeeded) ? ActionResponse.Error(PackageDeployable.name, responses) : ActionResponse.Success(PackageDeployable.name, responses);
+    }
+    /** The deployables to package, or the reason a named project cannot be one. */ async select(projects, requested) {
+        if (requested == null || requested === "") {
+            const found = [];
+            for (const project of projects){
+                if (await deployable.isDeployable(project)) {
+                    found.push(project);
+                }
+            }
+            return found;
+        }
+        const project = projects.find((candidate)=>candidate.name === requested);
+        if (project == null) {
+            return `${requested} is not a workspace project. Known projects: ${projects.map((p)=>p.name).join(", ")}`;
+        }
+        if (!await deployable.isDeployable(project)) {
+            return `${requested} has no ${deployable.dockerfileName(project)}, so it is a library, not a deployable. ` + "Libraries are packaged into the deployables that import them.";
+        }
+        return [
+            project
+        ];
+    }
+    async releaseProjects(projects) {
+        const entries = await Promise.all(projects.map(async (project)=>{
+            const pkg = await project.getPackageJson();
+            return [
+                project.name,
+                {
+                    name: project.name,
+                    pkg,
+                    projectRoot: path.resolve(project.projectRoot),
+                    releaseDir: path.resolve(project.getOutDir())
+                }
+            ];
+        }));
+        return new Map(entries);
+    }
+    async packageProject(project, releaseProjects, projects) {
+        const outDir = path.join(path.resolve(project.projectRoot), PACKAGE_DIR);
+        const base = {
+            projectName: project.name,
+            outDir,
+            workspacePackages: [],
+            dependencies: {}
+        };
+        try {
+            const entry = releaseProjects.get(project.name);
+            if (!await io.directoryExists(path.join(entry.releaseDir, "es6"))) {
+                throw new ForgeError(`No release build for ${project.name}. Run \`forge build --configuration release\` first.`);
+            }
+            const ui = await uiAssets.resolve(project, projects);
+            const reached = await this.importGraph.walk(entry, releaseProjects);
+            const libraries = [
+                ...reached.workspace
+            ].filter((name)=>name !== project.name).sort().map((name)=>releaseProjects.get(name));
+            const dependencies = await this.pinner.pin(reached.thirdParty, [
+                entry,
+                ...libraries
+            ], releaseProjects, {
+                dir: path.resolve(this.workspace.rootDir),
+                pkg: await this.workspace.getPackageJson()
+            });
+            await this.write(entry, libraries, dependencies, outDir, ui);
+            const workspacePackages = [
+                ...reached.workspace
+            ].sort();
+            this.#logger.info(`Packaged ${project.name} to ${outDir}`, {
+                workspace: workspacePackages,
+                thirdParty: Object.keys(dependencies)
+            });
+            return {
+                projectName: project.name,
+                outDir,
+                workspacePackages,
+                dependencies,
+                succeeded: true,
+                message: `Packaged ${project.name} to ${outDir}`
+            };
+        } catch (reason) {
+            const message = formatUnknownError(reason);
+            return {
+                ...base,
+                succeeded: false,
+                message,
+                error: `${project.name}: ${message}`
+            };
+        }
+    }
+    async write(entry, libraries, dependencies, outDir, ui) {
+        await fs.rm(outDir, {
+            recursive: true,
+            force: true
+        });
+        await fs.mkdir(outDir, {
+            recursive: true
+        });
+        await this.writeJson(path.join(outDir, "package.json"), {
+            name: entry.name.replace(/^@/, "").replace("/", "-"),
+            version: entry.pkg.version,
+            private: true,
+            type: "module",
+            scripts: {
+                start: `node es6/${releaseExports.toJs(entry.pkg.main ?? "src/index.ts")}`
+            },
+            dependencies
+        });
+        // npm writes real folders. It also removes anything in node_modules it does not know,
+        // so the workspace libraries are copied in only after it has run.
+        if (Object.keys(dependencies).length > 0) {
+            await this.npm.installProduction({
+                cwd: outDir
+            });
+        }
+        await this.copyTree(path.join(entry.releaseDir, "es6"), path.join(outDir, "es6"));
+        const config = path.join(path.resolve(this.workspace.rootDir), "config");
+        if (await io.directoryExists(config)) {
+            await this.copyTree(config, path.join(outDir, "config"));
+        }
+        if (ui != null) {
+            await this.copyTree(ui.from, path.join(outDir, ui.to));
+        }
+        for (const library of libraries){
+            const target = path.join(outDir, "node_modules", ...library.name.split("/"));
+            await this.copyTree(path.join(library.releaseDir, "es6"), path.join(target, "es6"));
+            await this.writeJson(path.join(target, "package.json"), {
+                name: library.name,
+                version: library.pkg.version,
+                type: "module",
+                exports: releaseExports.build(library.pkg)
+            });
+        }
+        await this.assertNoSymlinks(outDir);
+    }
+    /** Copies file contents, never links: a symlink in the output would break outside the image. */ async copyTree(from, to) {
+        await fs.cp(from, to, {
+            recursive: true,
+            dereference: true
+        });
+    }
+    async writeJson(filePath, value) {
+        await io.writeFile(filePath, `${JSON.stringify(value, null, "\t")}\n`, {
+            mkdir: true,
+            encoding: "utf8"
+        });
+    }
+    async assertNoSymlinks(dir) {
+        for (const entry of (await fs.readdir(dir, {
+            withFileTypes: true
+        }))){
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isSymbolicLink()) {
+                throw new ForgeError(`The packaged output must hold no symlinks, but found ${entryPath}`);
+            }
+            if (entry.isDirectory()) {
+                await this.assertNoSymlinks(entryPath);
+            }
+        }
+    }
+}
+PackageDeployable = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace,
+        typeof ImportGraph === "undefined" ? Object : ImportGraph,
+        typeof DependencyPinner === "undefined" ? Object : DependencyPinner
+    ])
+], PackageDeployable);

package/es6/src/actions/paths.action.js

@@ -0,0 +1,86 @@
+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);
+}
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { packageAliases, Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { scribe } from "@decohere/scribe";
+export const PATHS_FILE = "tsconfig.paths.json";
+export class Paths {
+    workspace;
+    #logger = scribe.logger(Paths.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const file = path.join(this.workspace.rootDir, PATHS_FILE);
+        const content = Paths.render(this.workspace);
+        const current = existsSync(file) ? await readFile(file, "utf8") : null;
+        const changed = current !== content;
+        if (options.check) {
+            if (!changed) {
+                return ActionResponse.Success(Paths.name, [
+                    {
+                        file,
+                        changed,
+                        succeeded: true
+                    }
+                ]);
+            }
+            const error = `${PATHS_FILE} is out of date. Run \`forge paths\` to update it.`;
+            this.#logger.error(error);
+            return ActionResponse.Error(Paths.name, [
+                {
+                    file,
+                    changed,
+                    succeeded: false,
+                    error
+                }
+            ]);
+        }
+        if (changed) {
+            await writeFile(file, content);
+            this.#logger.info(`Wrote ${PATHS_FILE}`);
+        }
+        return ActionResponse.Success(Paths.name, [
+            {
+                file,
+                changed,
+                succeeded: true
+            }
+        ]);
+    }
+    /** The file's content: convention and exported subpaths only, never the tsconfig's own paths. */ static render(workspace) {
+        const rootDir = path.resolve(workspace.rootDir);
+        const { paths } = packageAliases.build(workspace.getProjects("debug"), {
+            baseUrl: rootDir
+        });
+        const sorted = Object.fromEntries(Object.keys(paths).sort().map((key)=>[
+                key,
+                (paths[key] ?? []).map((target)=>`./${target}`)
+            ]));
+        const json = {
+            $comment: "Generated by `forge paths` from the workspace packages. Do not edit.",
+            compilerOptions: {
+                paths: sorted
+            }
+        };
+        return `${JSON.stringify(json, null, 2)}\n`;
+    }
+}
+Paths = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Paths);

package/es6/src/actions/publish.action.js

@@ -8,10 +8,9 @@ function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 import { injectable } from "@decohere/crucible/decorators";
-// biome-ignore lint/style/useImportType: <DI>
-import { Workspace } from "@decohere/mesh";
-import { ActionResponse } from "@decohere/nexus/cli";
-import { Npm } from "@decohere/nexus/interop";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Npm } from "@decohere/devkit/interop";
 import { scribe } from "@decohere/scribe";
 import { ForgeError, formatUnknownError } from "../errors.js";
 export class Publish {
@@ -143,5 +142,3 @@ Publish = _ts_decorate([
         typeof Workspace === "undefined" ? Object : Workspace
     ])
 ], Publish);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/publish.action.ts"],"sourcesContent":["import { 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, ResultStatus } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { Npm } from \"@decohere/nexus/interop\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError, formatUnknownError } from \"../errors.js\";\n\nexport type PublishOptions = {\n\tconfiguration: string;\n\tchannel?: string;\n\tdryRun?: boolean;\n\ttoken?: string;\n\totp?: string;\n\tpromptAuth?: boolean;\n\tpromptOtp?: boolean;\n};\n\nexport type PublishResponse = ResultStatus & {\n\tprojectName: string;\n\tmessage: string;\n\tpackageName?: string;\n};\n\n@injectable()\nexport class Publish implements Action<PublishOptions> {\n\t// TODO: probably best to inject npm\n\tprivate readonly npm = new Npm();\n\t#logger = scribe.logger(Publish.name);\n\n\tpublic constructor(private readonly workspace: Workspace) {}\n\n\tpublic async run(options: PublishOptions): Promise<ActionResponse<PublishResponse>> {\n\t\tconst projects = this.workspace.getProjects(options.configuration);\n\t\tconst token = await this.resolveToken(options);\n\t\tconst otp = await this.resolveOtp(options);\n\n\t\tif (projects.length === 0) {\n\t\t\tthrow new ForgeError(`No projects found to publish`);\n\t\t}\n\t\tconst publishResponses = await this.publishProjects(projects, {\n\t\t\t...options,\n\t\t\ttoken,\n\t\t\totp,\n\t\t});\n\t\tconst failed = publishResponses.filter((r) => !r.succeeded);\n\t\tif (failed.length) {\n\t\t\treturn ActionResponse.Error(Publish.name, publishResponses);\n\t\t}\n\t\treturn ActionResponse.Success(Publish.name, publishResponses);\n\t}\n\n\tpublic async publishProjects(projects: readonly Project[], options: PublishOptions) {\n\t\treturn await Promise.all(\n\t\t\tprojects\n\t\t\t\t.filter((project) => {\n\t\t\t\t\tif (project.isPrivate) {\n\t\t\t\t\t\tthis.#logger.info(`Skipping private package: ${project.name}`);\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t\treturn true;\n\t\t\t\t})\n\t\t\t\t.map(async (project) => await this.publishProject(project, options)),\n\t\t);\n\t}\n\n\tprivate async publishProject(\n\t\tproject: Project,\n\t\toptions: PublishOptions,\n\t): Promise<PublishResponse> {\n\t\tconst { channel, dryRun, token, otp } = options;\n\t\tconst outDir = project.getOutDir();\n\t\tthis.#logger.info(`${dryRun ? \"[dry-run] \" : \"\"}Publishing ${project.name}`);\n\n\t\ttry {\n\t\t\tconst response = await this.npm.publish(outDir, {\n\t\t\t\tchannel,\n\t\t\t\tdryRun,\n\t\t\t\tauthToken: token,\n\t\t\t\totp,\n\t\t\t\tskipIfPublished: true,\n\t\t\t});\n\n\t\t\tconst packageName = response.data?.join(\"\");\n\t\t\tthis.#logger.trace(`${project.name} → ${packageName ?? response.message}`);\n\t\t\treturn {\n\t\t\t\tprojectName: project.name,\n\t\t\t\tsucceeded: true,\n\t\t\t\tmessage: response.message,\n\t\t\t\tpackageName,\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\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 async resolveToken(options: PublishOptions): Promise<string | undefined> {\n\t\tif (options.token?.trim()) {\n\t\t\treturn options.token.trim();\n\t\t}\n\n\t\tif (options.promptAuth) {\n\t\t\treturn await this.promptSecret(\"npm access token: \");\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tprivate async resolveOtp(options: PublishOptions): Promise<string | undefined> {\n\t\tif (options.otp?.trim()) {\n\t\t\treturn options.otp.trim();\n\t\t}\n\n\t\tif (options.promptAuth || options.promptOtp) {\n\t\t\treturn await this.promptSecret(\"npm OTP: \");\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tprivate async promptSecret(label: string): Promise<string | undefined> {\n\t\tif (!process.stdin.isTTY || !process.stdout.isTTY) {\n\t\t\tthrow new ForgeError(`Cannot prompt for secret without an interactive TTY`);\n\t\t}\n\n\t\tprocess.stdout.write(label);\n\t\tconst stdin = process.stdin;\n\t\tstdin.setEncoding(\"utf8\");\n\t\tstdin.resume();\n\t\tstdin.setRawMode?.(true);\n\n\t\tlet value = \"\";\n\n\t\treturn await new Promise<string>((resolve, reject) => {\n\t\t\tconst cleanup = () => {\n\t\t\t\tstdin.setRawMode?.(false);\n\t\t\t\tstdin.pause();\n\t\t\t\tstdin.removeListener(\"data\", onData);\n\t\t\t\tprocess.stdout.write(\"\\n\");\n\t\t\t};\n\n\t\t\tconst onData = (chunk: string) => {\n\t\t\t\tconst char = chunk;\n\t\t\t\tif (char === \"\\u0003\") {\n\t\t\t\t\tcleanup();\n\t\t\t\t\treject(new ForgeError(\"Input cancelled\"));\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (char === \"\\r\" || char === \"\\n\") {\n\t\t\t\t\tcleanup();\n\t\t\t\t\tresolve(value.trim());\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (char === \"\\u0008\" || char === \"\\u007f\") {\n\t\t\t\t\tvalue = value.slice(0, -1);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvalue += char;\n\t\t\t};\n\n\t\t\tstdin.on(\"data\", onData);\n\t\t});\n\t}\n}\n"],"names":["injectable","Workspace","ActionResponse","Npm","scribe","ForgeError","formatUnknownError","Publish","npm","logger","name","workspace","run","options","projects","getProjects","configuration","token","resolveToken","otp","resolveOtp","length","publishResponses","publishProjects","failed","filter","r","succeeded","Error","Success","Promise","all","project","isPrivate","info","map","publishProject","channel","dryRun","outDir","getOutDir","response","publish","authToken","skipIfPublished","packageName","data","join","trace","message","projectName","reason","error","trim","promptAuth","promptSecret","undefined","promptOtp","label","process","stdin","isTTY","stdout","write","setEncoding","resume","setRawMode","value","resolve","reject","cleanup","pause","removeListener","onData","chunk","char","slice","on"],"mappings":"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"}

package/es6/src/actions/sync-lock-file.action.js

@@ -5,8 +5,8 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { injectable } from "@decohere/crucible/decorators";
-import { ActionResponse } from "@decohere/nexus/cli";
-import { Pnpm } from "@decohere/nexus/interop";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Pnpm } from "@decohere/devkit/interop";
 import { scribe } from "@decohere/scribe";
 import { formatUnknownError } from "../errors.js";
 export class SyncLockFile {
@@ -29,5 +29,3 @@ export class SyncLockFile {
 SyncLockFile = _ts_decorate([
     injectable()
 ], SyncLockFile);
-
-//# sourceMappingURL=data:application/json;base64,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

package/es6/src/actions/tag.action.js

@@ -8,10 +8,9 @@ function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 import { injectable } from "@decohere/crucible/decorators";
-// biome-ignore lint/style/useImportType: <DI>
-import { Workspace } from "@decohere/mesh";
-import { ActionResponse } from "@decohere/nexus/cli";
-import { Git } from "@decohere/nexus/interop";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Git } from "@decohere/devkit/interop";
 import { scribe } from "@decohere/scribe";
 import { ForgeError, formatUnknownError } from "../errors.js";
 export class Tag {
@@ -38,9 +37,8 @@ export class Tag {
             const git = new Git();
             await git.tag(tag);
             if (options.push) {
-                const branch = await git.getBranchName();
-                this.#logger.info(`Pushing branch: ${branch}`);
-                await git.push(branch);
+                // Tag-only: Publish checks out a commit SHA (detached HEAD). Pushing a
+                // branch name is wrong there and unnecessary — the version label is the tag.
                 this.#logger.info(`Pushing tag: ${tag}`);
                 await git.pushTag(tag);
             }
@@ -63,5 +61,3 @@ Tag = _ts_decorate([
         typeof Workspace === "undefined" ? Object : Workspace
     ])
 ], Tag);
-
-//# sourceMappingURL=data:application/json;base64,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

package/es6/src/actions/typecheck.action.js

@@ -0,0 +1,52 @@
+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);
+}
+import { injectable } from "@decohere/crucible/decorators";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Trace } from "@decohere/devkit/diagnostics";
+import { scribe } from "@decohere/scribe";
+import ts from "typescript";
+import { ForgeError } from "../errors.js";
+import { TypeEmitter } from "../services/type-emitter.js";
+export class TypeCheck {
+    workspace;
+    typeEmitter;
+    #logger = scribe.logger(TypeCheck.name);
+    constructor(workspace, typeEmitter){
+        this.workspace = workspace;
+        this.typeEmitter = typeEmitter;
+    }
+    run = async (options)=>{
+        const projects = this.workspace.getProjects(options.configuration);
+        for (const project of projects){
+            this.#logger.info(`Type-checking ${project.name}`);
+        }
+        const { diagnostics, formatted } = await this.typeEmitter.checkProject([
+            ...projects
+        ]);
+        const errors = diagnostics.filter((diagnostic)=>diagnostic.category === ts.DiagnosticCategory.Error);
+        if (errors.length > 0) {
+            throw new ForgeError(formatted || "Type check failed");
+        }
+        if (formatted.length > 0) {
+            this.#logger.info(formatted);
+        }
+        return ActionResponse.Success(TypeCheck.name);
+    };
+}
+TypeCheck = _ts_decorate([
+    Trace,
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace,
+        typeof TypeEmitter === "undefined" ? Object : TypeEmitter
+    ])
+], TypeCheck);

package/es6/src/actions/unlink.action.js

@@ -0,0 +1,59 @@
+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;
+}
+import fs from "node:fs/promises";
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { scribe } from "@decohere/scribe";
+import { ForgeError } from "../errors.js";
+import { LINK_MANIFEST } from "./link.action.js";
+export class Unlink {
+    #logger = scribe.logger(Unlink.name);
+    run = async (options)=>{
+        const targetDir = path.resolve(options.targetDir);
+        const manifestPath = path.join(targetDir, LINK_MANIFEST);
+        const manifestStat = await fs.stat(manifestPath).catch(()=>null);
+        if (manifestStat == null) {
+            throw new ForgeError(`No link manifest found at "${manifestPath}". Nothing to unlink.`);
+        }
+        const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        for (const { packageName, symlinkPath, originalPath } of manifest.links){
+            const stat = await fs.lstat(symlinkPath).catch(()=>null);
+            if (stat?.isSymbolicLink()) {
+                await fs.unlink(symlinkPath);
+                this.#logger.trace(`Removed symlink for ${packageName}`);
+            }
+            if (originalPath != null) {
+                const backupStat = await fs.stat(originalPath).catch(()=>null);
+                if (backupStat != null) {
+                    await fs.rename(originalPath, symlinkPath);
+                    this.#logger.trace(`Restored original dir for ${packageName}`);
+                } else {
+                    // originalPath is a symlink target string — recreate the symlink
+                    await fs.mkdir(path.dirname(symlinkPath), {
+                        recursive: true
+                    });
+                    await fs.symlink(originalPath, symlinkPath, "dir");
+                    this.#logger.trace(`Restored original symlink for ${packageName}`);
+                }
+            }
+            this.#logger.info(`Unlinked ${packageName}`);
+        }
+        await fs.unlink(manifestPath);
+        if (manifest.peerNodeModulesDir != null) {
+            await fs.rm(manifest.peerNodeModulesDir, {
+                recursive: true,
+                force: true
+            });
+            this.#logger.info(`Removed peer node_modules at ${manifest.peerNodeModulesDir}`);
+        }
+        return ActionResponse.Success(Unlink.name);
+    };
+}
+Unlink = _ts_decorate([
+    injectable()
+], Unlink);

package/es6/src/actions/version.action.js

@@ -11,11 +11,10 @@ import { execSync } from "node:child_process";
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { injectable } from "@decohere/crucible/decorators";
-// biome-ignore lint/style/useImportType: <DI>
-import { Workspace } from "@decohere/mesh";
-import { ActionResponse } from "@decohere/nexus/cli";
-import { Git } from "@decohere/nexus/interop";
-import { Semver, SemverError, VersionTypes } from "@decohere/nexus/semver";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { Git } from "@decohere/devkit/interop";
+import { Semver, SemverError, VersionTypes } from "../semver/index.js";
 import { scribe } from "@decohere/scribe";
 import { ForgeError, formatUnknownError } from "../errors.js";
 export const DefaultChannel = "beta";
@@ -63,9 +62,7 @@ export class Version {
         }
         await workspace.persistPackageJson((await workspace.getPackageJson()).withVersion(nextVersion.toString()));
         const responses = await Promise.all([
-            ...[
-                this.updatePackageJson(workspace.name, workspace, nextVersion)
-            ],
+            this.updatePackageJson(workspace.name, workspace, nextVersion),
             ...projects.map((project)=>this.updatePackageJson(project.name, project, nextVersion))
         ]);
         const failed = responses.filter((r)=>!r.succeeded);
@@ -185,5 +182,3 @@ Version = _ts_decorate([
         typeof Workspace === "undefined" ? Object : Workspace
     ])
 ], Version);
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/version.action.ts"],"sourcesContent":["import { execSync } from \"node:child_process\";\nimport { readdir, readFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport type { HasPackageJson } 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 { Git } from \"@decohere/nexus/interop\";\nimport { Semver, SemverError, type VersionType, VersionTypes } from \"@decohere/nexus/semver\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError, formatUnknownError } from \"../errors.js\";\n\nexport type VersionResponse = ResultStatus & {\n\tname: string;\n};\n\nexport const DefaultChannel = \"beta\";\nexport const DefaultReleaseType = VersionTypes.prerelease;\n\nexport type VersionOptions = {\n\treleaseType?: VersionType;\n\tchannel?: string;\n\tversion?: string;\n\tdryRun?: boolean;\n\tcommit?: boolean;\n\tmessage?: string;\n\t/** Read pending .changeset entries to determine the highest bump type */\n\tfromChangesets?: boolean;\n};\n\nconst DefaultVersionOptions: VersionOptions = {\n\treleaseType: DefaultReleaseType,\n\tchannel: DefaultChannel,\n\tdryRun: false,\n};\n\n@injectable()\nexport class Version implements Action<VersionOptions> {\n\t#logger = scribe.logger(Version.name);\n\tpublic constructor(private readonly workspace: Workspace) {}\n\tpublic async run(options: VersionOptions): Promise<ActionResponse> {\n\t\tconst response = await this.version(this.workspace, options);\n\t\tconst messages = response.data\n\t\t\t.flatMap((d) => (!d.succeeded && d.error ? [d.error] : []))\n\t\t\t.join(\"\\n\");\n\t\tif (messages) {\n\t\t\tthrow new ForgeError(`There was an error versioning the workspace ${messages}`);\n\t\t}\n\n\t\treturn response;\n\t}\n\n\tpublic async version(\n\t\tworkspace: Workspace,\n\t\toptions: VersionOptions = DefaultVersionOptions,\n\t): Promise<ActionResponse<VersionResponse>> {\n\t\tconst projects = workspace.getProjects(\"debug\");\n\t\tconst rootVersion = await this.resolveBaseVersion(workspace, options);\n\t\tconst releaseType = options.fromChangesets\n\t\t\t? await this.resolveReleaseTypeFromChangesets()\n\t\t\t: (options.releaseType ?? DefaultReleaseType);\n\t\tconst channel = options.channel ?? DefaultChannel;\n\t\tconst nextVersion = this.getNextVersion(rootVersion, releaseType, channel);\n\t\tthis.#logger.info(`${rootVersion} → ${nextVersion} [${releaseType}]`);\n\n\t\tif (options.dryRun) {\n\t\t\tthis.#logger.info(\n\t\t\t\t`[dry-run] Would bump all packages to ${nextVersion} — skipping file writes`,\n\t\t\t);\n\t\t\treturn ActionResponse.Success(Version.name, [\n\t\t\t\t{ name: workspace.name, succeeded: true },\n\t\t\t\t...projects.map((p) => ({ name: p.name, succeeded: true })),\n\t\t\t]);\n\t\t}\n\n\t\tawait workspace.persistPackageJson(\n\t\t\t(await workspace.getPackageJson()).withVersion(nextVersion.toString()),\n\t\t);\n\n\t\tconst responses = await Promise.all([\n\t\t\t...[this.updatePackageJson(workspace.name, workspace, nextVersion)],\n\t\t\t...projects.map((project) => this.updatePackageJson(project.name, project, nextVersion)),\n\t\t]);\n\t\tconst failed = responses.filter((r) => !r.succeeded);\n\t\tif (failed.length) {\n\t\t\treturn ActionResponse.Error(Version.name, responses);\n\t\t}\n\n\t\tif (options.commit) {\n\t\t\tconst files = [workspace.packageJsonPath, ...projects.map((p) => p.packageJsonPath)];\n\t\t\tconst message = options.message ?? `chore: version packages ${nextVersion}`;\n\t\t\tthis.#logger.info(`Committing: ${message}`);\n\t\t\tawait new Git().commit(message, { files });\n\t\t}\n\n\t\treturn ActionResponse.Success(Version.name, responses);\n\t}\n\n\tprivate async resolveBaseVersion(\n\t\tworkspace: Workspace,\n\t\toptions: VersionOptions,\n\t): Promise<string> {\n\t\tif (options.version != null && options.version.trim().length > 0) {\n\t\t\treturn options.version.trim();\n\t\t}\n\n\t\tconst gitTagVersion = this.resolveVersionFromGitTag();\n\t\tif (gitTagVersion != null) {\n\t\t\tthis.#logger.info(`Using latest git tag version as base: ${gitTagVersion}`);\n\t\t\treturn gitTagVersion;\n\t\t}\n\n\t\tconst workspaceVersion = await workspace.getVersion();\n\t\tthis.#logger.info(\n\t\t\t`No semver git tags found, falling back to workspace package.json version: ${workspaceVersion}`,\n\t\t);\n\t\treturn workspaceVersion;\n\t}\n\n\tprivate resolveVersionFromGitTag(): string | undefined {\n\t\ttry {\n\t\t\tconst tags = execSync('git tag --list \"v*\" --sort=-version:refname', {\n\t\t\t\tencoding: \"utf8\",\n\t\t\t})\n\t\t\t\t.trim()\n\t\t\t\t.split(\"\\n\")\n\t\t\t\t.filter(Boolean);\n\n\t\t\tif (tags.length === 0) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\treturn tags[0].replace(/^v/, \"\");\n\t\t} catch {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Reads all pending .changeset/*.md entries and returns the highest bump type\n\t * found across all of them. Precedence: major > minor > patch.\n\t */\n\tprivate async resolveReleaseTypeFromChangesets(): Promise<VersionType> {\n\t\tconst changesetDir = join(process.cwd(), \".changeset\");\n\t\tlet entries: string[];\n\t\ttry {\n\t\t\tentries = await readdir(changesetDir);\n\t\t} catch {\n\t\t\tthrow new ForgeError(\n\t\t\t\t\"No .changeset directory found. Run `pnpm changeset` to create an entry.\",\n\t\t\t);\n\t\t}\n\n\t\tconst files = entries.filter((e) => e.endsWith(\".md\") && e !== \"README.md\");\n\t\tif (files.length === 0) {\n\t\t\tthrow new ForgeError(\n\t\t\t\t\"No pending changeset entries found in .changeset/. Run `pnpm changeset` to create one.\",\n\t\t\t);\n\t\t}\n\n\t\tconst precedence: Record<string, number> = { major: 3, minor: 2, patch: 1, prerelease: 0 };\n\t\tlet maxType: VersionType = VersionTypes.patch;\n\t\tlet maxPrecedence = 0;\n\n\t\tfor (const file of files) {\n\t\t\tconst content = await readFile(join(changesetDir, file), \"utf8\");\n\t\t\tconst match = content.match(/^---\\n([\\s\\S]*?)\\n---/);\n\t\t\tif (!match) continue;\n\t\t\tfor (const line of match[1].split(\"\\n\")) {\n\t\t\t\tconst bumpType = line.match(/^\"[^\"]+\"\\s*:\\s*(\\w+)/)?.[1] as VersionType | undefined;\n\t\t\t\tconst p = bumpType != null ? (precedence[bumpType] ?? -1) : -1;\n\t\t\t\tif (p > maxPrecedence) {\n\t\t\t\t\tmaxType = bumpType as VersionType;\n\t\t\t\t\tmaxPrecedence = p;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis.#logger.info(`Resolved release type from ${files.length} changeset(s): ${maxType}`);\n\t\treturn maxType;\n\t}\n\n\tprivate getNextVersion(\n\t\tcurrentVersion: string,\n\t\tversionType: VersionType,\n\t\tpreid: string,\n\t): Semver {\n\t\ttry {\n\t\t\treturn new Semver(currentVersion).increment(versionType, preid);\n\t\t} catch (error) {\n\t\t\tif (error instanceof SemverError) {\n\t\t\t\tthrow new ForgeError(error.message);\n\t\t\t}\n\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tprivate async updatePackageJson(\n\t\tname: string,\n\t\thasJson: HasPackageJson,\n\t\tversion: Semver,\n\t): Promise<VersionResponse> {\n\t\ttry {\n\t\t\tconst packageJson = await hasJson.getPackageJson();\n\t\t\tawait hasJson.persistPackageJson(packageJson.withVersion(version.toString()));\n\t\t\tthis.#logger.trace(name);\n\t\t\treturn {\n\t\t\t\tname,\n\t\t\t\tsucceeded: true,\n\t\t\t};\n\t\t} catch (reason) {\n\t\t\treturn {\n\t\t\t\tname,\n\t\t\t\tsucceeded: false,\n\t\t\t\terror: `${name}: ${formatUnknownError(reason)}`,\n\t\t\t};\n\t\t}\n\t}\n}\n"],"names":["execSync","readdir","readFile","join","injectable","Workspace","ActionResponse","Git","Semver","SemverError","VersionTypes","scribe","ForgeError","formatUnknownError","DefaultChannel","DefaultReleaseType","prerelease","DefaultVersionOptions","releaseType","channel","dryRun","Version","logger","name","workspace","run","options","response","version","messages","data","flatMap","d","succeeded","error","projects","getProjects","rootVersion","resolveBaseVersion","fromChangesets","resolveReleaseTypeFromChangesets","nextVersion","getNextVersion","info","Success","map","p","persistPackageJson","getPackageJson","withVersion","toString","responses","Promise","all","updatePackageJson","project","failed","filter","r","length","Error","commit","files","packageJsonPath","message","trim","gitTagVersion","resolveVersionFromGitTag","workspaceVersion","getVersion","tags","encoding","split","Boolean","undefined","replace","changesetDir","process","cwd","entries","e","endsWith","precedence","major","minor","patch","maxType","maxPrecedence","file","content","match","line","bumpType","currentVersion","versionType","preid","increment","hasJson","packageJson","trace","reason"],"mappings":"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"}

package/es6/src/actions/watch.action.js

@@ -8,9 +8,8 @@ function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 import { injectable } from "@decohere/crucible/decorators";
-// biome-ignore lint/style/useImportType: <DI>
-import { Workspace } from "@decohere/mesh";
-import { ActionResponse } from "@decohere/nexus/cli";
+import { Workspace } from "@decohere/workspace";
+import { ActionResponse } from "@decohere/devkit/cli";
 import { scribe } from "@decohere/scribe";
 export class Watch {
     workspace;
@@ -38,5 +37,3 @@ Watch = _ts_decorate([
         typeof Workspace === "undefined" ? Object : Workspace
     ])
 ], Watch);
-
-//# sourceMappingURL=data:application/json;base64,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