@decohere/forge 0.0.1-dev.5

package/commonjs/src/actions/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./build.action.js"), exports);
+_export_star(require("./clean.action.js"), exports);
+_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("./publish.action.js"), exports);
+_export_star(require("./sync-lock-file.action.js"), exports);
+_export_star(require("./tag.action.js"), exports);
+_export_star(require("./version.action.js"), exports);
+_export_star(require("./watch.action.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2FjdGlvbnMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYnVpbGQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jbGVhbi5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbW1pdC5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvcHkuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXBlbmRlbmN5LXJlcG9ydC5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlcGVuZGVuY3ktc3luYy5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3B1Ymxpc2guYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zeW5jLWxvY2stZmlsZS5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RhZy5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ZlcnNpb24uYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi93YXRjaC5hY3Rpb24uanNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O3FCQUFjO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBIn0=

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Publish", {
+    enumerable: true,
+    get: function() {
+        return Publish;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _interop = require("@decohere/nexus/interop");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class Publish {
+    workspace;
+    // TODO: probably best to inject npm
+    npm = new _interop.Npm();
+    #logger = _scribe.scribe.logger(Publish.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const projects = this.workspace.getProjects(options.configuration);
+        const token = await this.resolveToken(options);
+        const otp = await this.resolveOtp(options);
+        if (projects.length === 0) {
+            throw new _errors.ForgeError(`No projects found to publish`);
+        }
+        const publishResponses = await this.publishProjects(projects, {
+            ...options,
+            token,
+            otp
+        });
+        const failed = publishResponses.filter((r)=>!r.succeeded);
+        if (failed.length) {
+            return _cli.ActionResponse.Error(Publish.name, publishResponses);
+        }
+        return _cli.ActionResponse.Success(Publish.name, publishResponses);
+    }
+    async publishProjects(projects, options) {
+        return await Promise.all(projects.filter((project)=>{
+            if (project.isPrivate) {
+                this.#logger.info(`Skipping private package: ${project.name}`);
+                return false;
+            }
+            return true;
+        }).map(async (project)=>await this.publishProject(project, options)));
+    }
+    async publishProject(project, options) {
+        const { channel, dryRun, token, otp } = options;
+        const outDir = project.getOutDir();
+        this.#logger.info(`${dryRun ? "[dry-run] " : ""}Publishing ${project.name}`);
+        try {
+            const response = await this.npm.publish(outDir, {
+                channel,
+                dryRun,
+                authToken: token,
+                otp,
+                skipIfPublished: true
+            });
+            const packageName = response.data?.join("");
+            this.#logger.trace(`${project.name} → ${packageName ?? response.message}`);
+            return {
+                projectName: project.name,
+                succeeded: true,
+                message: response.message,
+                packageName
+            };
+        } catch (reason) {
+            const message = (0, _errors.formatUnknownError)(reason);
+            return {
+                projectName: project.name,
+                succeeded: false,
+                message,
+                error: `${project.name}: ${message}`
+            };
+        }
+    }
+    async resolveToken(options) {
+        if (options.token?.trim()) {
+            return options.token.trim();
+        }
+        if (options.promptAuth) {
+            return await this.promptSecret("npm access token: ");
+        }
+        return undefined;
+    }
+    async resolveOtp(options) {
+        if (options.otp?.trim()) {
+            return options.otp.trim();
+        }
+        if (options.promptAuth || options.promptOtp) {
+            return await this.promptSecret("npm OTP: ");
+        }
+        return undefined;
+    }
+    async promptSecret(label) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new _errors.ForgeError(`Cannot prompt for secret without an interactive TTY`);
+        }
+        process.stdout.write(label);
+        const stdin = process.stdin;
+        stdin.setEncoding("utf8");
+        stdin.resume();
+        stdin.setRawMode?.(true);
+        let value = "";
+        return await new Promise((resolve, reject)=>{
+            const cleanup = ()=>{
+                stdin.setRawMode?.(false);
+                stdin.pause();
+                stdin.removeListener("data", onData);
+                process.stdout.write("\n");
+            };
+            const onData = (chunk)=>{
+                const char = chunk;
+                if (char === "\u0003") {
+                    cleanup();
+                    reject(new _errors.ForgeError("Input cancelled"));
+                    return;
+                }
+                if (char === "\r" || char === "\n") {
+                    cleanup();
+                    resolve(value.trim());
+                    return;
+                }
+                if (char === "\u0008" || char === "\u007f") {
+                    value = value.slice(0, -1);
+                    return;
+                }
+                value += char;
+            };
+            stdin.on("data", onData);
+        });
+    }
+}
+Publish = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Publish);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/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":["Publish","npm","Npm","scribe","logger","name","workspace","run","options","projects","getProjects","configuration","token","resolveToken","otp","resolveOtp","length","ForgeError","publishResponses","publishProjects","failed","filter","r","succeeded","ActionResponse","Error","Success","Promise","all","project","isPrivate","info","map","publishProject","channel","dryRun","outDir","getOutDir","response","publish","authToken","skipIfPublished","packageName","data","join","trace","message","projectName","reason","formatUnknownError","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/commonjs/src/actions/sync-lock-file.action.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SyncLockFile", {
+    enumerable: true,
+    get: function() {
+        return SyncLockFile;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _cli = require("@decohere/nexus/cli");
+const _interop = require("@decohere/nexus/interop");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class SyncLockFile {
+    #logger = _scribe.scribe.logger(SyncLockFile.name);
+    #pnpm = new _interop.Pnpm();
+    async run(options) {
+        const shouldSync = options.sync ?? true;
+        if (options.dryRun || !shouldSync) {
+            this.#logger.info(options.dryRun ? "[dry-run] Skipping lockfile sync" : "Skipping lockfile sync");
+            return _cli.ActionResponse.Skipped(SyncLockFile.name);
+        }
+        try {
+            await this.#pnpm.syncLockFile();
+        } catch (reason) {
+            return _cli.ActionResponse.Error(SyncLockFile.name, `Failed syncing lockfile: ${(0, _errors.formatUnknownError)(reason)}`);
+        }
+        return _cli.ActionResponse.Success(SyncLockFile.name);
+    }
+}
+SyncLockFile = _ts_decorate([
+    (0, _decorators.injectable)()
+], SyncLockFile);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Tag", {
+    enumerable: true,
+    get: function() {
+        return Tag;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _interop = require("@decohere/nexus/interop");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+class Tag {
+    workspace;
+    #logger = _scribe.scribe.logger(Tag.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        try {
+            const version = await this.workspace.getVersion();
+            const prefix = options.prefix ?? "v";
+            const tag = `${prefix}${version}`;
+            if (options.dryRun) {
+                this.#logger.info(`[dry-run] ${tag}`);
+                return _cli.ActionResponse.Success(Tag.name, [
+                    {
+                        tag,
+                        succeeded: true
+                    }
+                ]);
+            }
+            this.#logger.info(`Creating tag: ${tag}`);
+            const git = new _interop.Git();
+            await git.tag(tag);
+            if (options.push) {
+                const branch = await git.getBranchName();
+                this.#logger.info(`Pushing branch: ${branch}`);
+                await git.push(branch);
+                this.#logger.info(`Pushing tag: ${tag}`);
+                await git.pushTag(tag);
+            }
+            return _cli.ActionResponse.Success(Tag.name, [
+                {
+                    tag,
+                    succeeded: true
+                }
+            ]);
+        } catch (reason) {
+            const error = (0, _errors.formatUnknownError)(reason);
+            throw new _errors.ForgeError(`Failed to create tag: ${error}`);
+        }
+    }
+}
+Tag = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Tag);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,209 @@
+"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 DefaultChannel () {
+        return DefaultChannel;
+    },
+    get DefaultReleaseType () {
+        return DefaultReleaseType;
+    },
+    get Version () {
+        return Version;
+    }
+});
+const _nodechild_process = require("node:child_process");
+const _promises = require("node:fs/promises");
+const _nodepath = 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 _semver = require("@decohere/nexus/semver");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+const DefaultChannel = "beta";
+const DefaultReleaseType = _semver.VersionTypes.prerelease;
+const DefaultVersionOptions = {
+    releaseType: DefaultReleaseType,
+    channel: DefaultChannel,
+    dryRun: false
+};
+class Version {
+    workspace;
+    #logger = _scribe.scribe.logger(Version.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const response = await this.version(this.workspace, options);
+        const messages = response.data.flatMap((d)=>!d.succeeded && d.error ? [
+                d.error
+            ] : []).join("\n");
+        if (messages) {
+            throw new _errors.ForgeError(`There was an error versioning the workspace ${messages}`);
+        }
+        return response;
+    }
+    async version(workspace, options = DefaultVersionOptions) {
+        const projects = workspace.getProjects("debug");
+        const rootVersion = await this.resolveBaseVersion(workspace, options);
+        const releaseType = options.fromChangesets ? await this.resolveReleaseTypeFromChangesets() : options.releaseType ?? DefaultReleaseType;
+        const channel = options.channel ?? DefaultChannel;
+        const nextVersion = this.getNextVersion(rootVersion, releaseType, channel);
+        this.#logger.info(`${rootVersion} → ${nextVersion} [${releaseType}]`);
+        if (options.dryRun) {
+            this.#logger.info(`[dry-run] Would bump all packages to ${nextVersion} — skipping file writes`);
+            return _cli.ActionResponse.Success(Version.name, [
+                {
+                    name: workspace.name,
+                    succeeded: true
+                },
+                ...projects.map((p)=>({
+                        name: p.name,
+                        succeeded: true
+                    }))
+            ]);
+        }
+        await workspace.persistPackageJson((await workspace.getPackageJson()).withVersion(nextVersion.toString()));
+        const responses = await Promise.all([
+            ...[
+                this.updatePackageJson(workspace.name, workspace, nextVersion)
+            ],
+            ...projects.map((project)=>this.updatePackageJson(project.name, project, nextVersion))
+        ]);
+        const failed = responses.filter((r)=>!r.succeeded);
+        if (failed.length) {
+            return _cli.ActionResponse.Error(Version.name, responses);
+        }
+        if (options.commit) {
+            const files = [
+                workspace.packageJsonPath,
+                ...projects.map((p)=>p.packageJsonPath)
+            ];
+            const message = options.message ?? `chore: version packages ${nextVersion}`;
+            this.#logger.info(`Committing: ${message}`);
+            await new _interop.Git().commit(message, {
+                files
+            });
+        }
+        return _cli.ActionResponse.Success(Version.name, responses);
+    }
+    async resolveBaseVersion(workspace, options) {
+        if (options.version != null && options.version.trim().length > 0) {
+            return options.version.trim();
+        }
+        const gitTagVersion = this.resolveVersionFromGitTag();
+        if (gitTagVersion != null) {
+            this.#logger.info(`Using latest git tag version as base: ${gitTagVersion}`);
+            return gitTagVersion;
+        }
+        const workspaceVersion = await workspace.getVersion();
+        this.#logger.info(`No semver git tags found, falling back to workspace package.json version: ${workspaceVersion}`);
+        return workspaceVersion;
+    }
+    resolveVersionFromGitTag() {
+        try {
+            const tags = (0, _nodechild_process.execSync)('git tag --list "v*" --sort=-version:refname', {
+                encoding: "utf8"
+            }).trim().split("\n").filter(Boolean);
+            if (tags.length === 0) {
+                return undefined;
+            }
+            return tags[0].replace(/^v/, "");
+        } catch  {
+            return undefined;
+        }
+    }
+    /**
+	 * Reads all pending .changeset/*.md entries and returns the highest bump type
+	 * found across all of them. Precedence: major > minor > patch.
+	 */ async resolveReleaseTypeFromChangesets() {
+        const changesetDir = (0, _nodepath.join)(process.cwd(), ".changeset");
+        let entries;
+        try {
+            entries = await (0, _promises.readdir)(changesetDir);
+        } catch  {
+            throw new _errors.ForgeError("No .changeset directory found. Run `pnpm changeset` to create an entry.");
+        }
+        const files = entries.filter((e)=>e.endsWith(".md") && e !== "README.md");
+        if (files.length === 0) {
+            throw new _errors.ForgeError("No pending changeset entries found in .changeset/. Run `pnpm changeset` to create one.");
+        }
+        const precedence = {
+            major: 3,
+            minor: 2,
+            patch: 1,
+            prerelease: 0
+        };
+        let maxType = _semver.VersionTypes.patch;
+        let maxPrecedence = 0;
+        for (const file of files){
+            const content = await (0, _promises.readFile)((0, _nodepath.join)(changesetDir, file), "utf8");
+            const match = content.match(/^---\n([\s\S]*?)\n---/);
+            if (!match) continue;
+            for (const line of match[1].split("\n")){
+                const bumpType = line.match(/^"[^"]+"\s*:\s*(\w+)/)?.[1];
+                const p = bumpType != null ? precedence[bumpType] ?? -1 : -1;
+                if (p > maxPrecedence) {
+                    maxType = bumpType;
+                    maxPrecedence = p;
+                }
+            }
+        }
+        this.#logger.info(`Resolved release type from ${files.length} changeset(s): ${maxType}`);
+        return maxType;
+    }
+    getNextVersion(currentVersion, versionType, preid) {
+        try {
+            return new _semver.Semver(currentVersion).increment(versionType, preid);
+        } catch (error) {
+            if (error instanceof _semver.SemverError) {
+                throw new _errors.ForgeError(error.message);
+            }
+            throw error;
+        }
+    }
+    async updatePackageJson(name, hasJson, version) {
+        try {
+            const packageJson = await hasJson.getPackageJson();
+            await hasJson.persistPackageJson(packageJson.withVersion(version.toString()));
+            this.#logger.trace(name);
+            return {
+                name,
+                succeeded: true
+            };
+        } catch (reason) {
+            return {
+                name,
+                succeeded: false,
+                error: `${name}: ${(0, _errors.formatUnknownError)(reason)}`
+            };
+        }
+    }
+}
+Version = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Version);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/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":["DefaultChannel","DefaultReleaseType","Version","VersionTypes","prerelease","DefaultVersionOptions","releaseType","channel","dryRun","scribe","logger","name","workspace","run","options","response","version","messages","data","flatMap","d","succeeded","error","join","ForgeError","projects","getProjects","rootVersion","resolveBaseVersion","fromChangesets","resolveReleaseTypeFromChangesets","nextVersion","getNextVersion","info","ActionResponse","Success","map","p","persistPackageJson","getPackageJson","withVersion","toString","responses","Promise","all","updatePackageJson","project","failed","filter","r","length","Error","commit","files","packageJsonPath","message","Git","trim","gitTagVersion","resolveVersionFromGitTag","workspaceVersion","getVersion","tags","execSync","encoding","split","Boolean","undefined","replace","changesetDir","process","cwd","entries","readdir","e","endsWith","precedence","major","minor","patch","maxType","maxPrecedence","file","content","readFile","match","line","bumpType","currentVersion","versionType","preid","Semver","increment","SemverError","hasJson","packageJson","trace","reason","formatUnknownError"],"mappings":";;;;;;;;;;;QAkBaA;eAAAA;;QACAC;eAAAA;;QAoBAC;eAAAA;;;mCAvCY;0BACS;0BACb;4BACM;sBAGD;qBAEK;yBACX;wBACgD;wBAC7C;wBACwB;;;;;;;;;;AAMxC,MAAMF,iBAAiB;AACvB,MAAMC,qBAAqBE,oBAAY,CAACC,UAAU;AAazD,MAAMC,wBAAwC;IAC7CC,aAAaL;IACbM,SAASP;IACTQ,QAAQ;AACT;AAGO,MAAMN;;IACZ,CAAA,MAAO,GAAGO,cAAM,CAACC,MAAM,CAACR,QAAQS,IAAI,EAAE;IACtC,YAAmB,AAAiBC,SAAoB,CAAE;aAAtBA,YAAAA;IAAuB;IAC3D,MAAaC,IAAIC,OAAuB,EAA2B;QAClE,MAAMC,WAAW,MAAM,IAAI,CAACC,OAAO,CAAC,IAAI,CAACJ,SAAS,EAAEE;QACpD,MAAMG,WAAWF,SAASG,IAAI,CAC5BC,OAAO,CAAC,CAACC,IAAO,CAACA,EAAEC,SAAS,IAAID,EAAEE,KAAK,GAAG;gBAACF,EAAEE,KAAK;aAAC,GAAG,EAAE,EACxDC,IAAI,CAAC;QACP,IAAIN,UAAU;YACb,MAAM,IAAIO,kBAAU,CAAC,CAAC,4CAA4C,EAAEP,UAAU;QAC/E;QAEA,OAAOF;IACR;IAEA,MAAaC,QACZJ,SAAoB,EACpBE,UAA0BT,qBAAqB,EACJ;QAC3C,MAAMoB,WAAWb,UAAUc,WAAW,CAAC;QACvC,MAAMC,cAAc,MAAM,IAAI,CAACC,kBAAkB,CAAChB,WAAWE;QAC7D,MAAMR,cAAcQ,QAAQe,cAAc,GACvC,MAAM,IAAI,CAACC,gCAAgC,KAC1ChB,QAAQR,WAAW,IAAIL;QAC3B,MAAMM,UAAUO,QAAQP,OAAO,IAAIP;QACnC,MAAM+B,cAAc,IAAI,CAACC,cAAc,CAACL,aAAarB,aAAaC;QAClE,IAAI,CAAC,CAAA,MAAO,CAAC0B,IAAI,CAAC,GAAGN,YAAY,GAAG,EAAEI,YAAY,EAAE,EAAEzB,YAAY,CAAC,CAAC;QAEpE,IAAIQ,QAAQN,MAAM,EAAE;YACnB,IAAI,CAAC,CAAA,MAAO,CAACyB,IAAI,CAChB,CAAC,qCAAqC,EAAEF,YAAY,uBAAuB,CAAC;YAE7E,OAAOG,mBAAc,CAACC,OAAO,CAACjC,QAAQS,IAAI,EAAE;gBAC3C;oBAAEA,MAAMC,UAAUD,IAAI;oBAAEU,WAAW;gBAAK;mBACrCI,SAASW,GAAG,CAAC,CAACC,IAAO,CAAA;wBAAE1B,MAAM0B,EAAE1B,IAAI;wBAAEU,WAAW;oBAAK,CAAA;aACxD;QACF;QAEA,MAAMT,UAAU0B,kBAAkB,CACjC,AAAC,CAAA,MAAM1B,UAAU2B,cAAc,EAAC,EAAGC,WAAW,CAACT,YAAYU,QAAQ;QAGpE,MAAMC,YAAY,MAAMC,QAAQC,GAAG,CAAC;eAChC;gBAAC,IAAI,CAACC,iBAAiB,CAACjC,UAAUD,IAAI,EAAEC,WAAWmB;aAAa;eAChEN,SAASW,GAAG,CAAC,CAACU,UAAY,IAAI,CAACD,iBAAiB,CAACC,QAAQnC,IAAI,EAAEmC,SAASf;SAC3E;QACD,MAAMgB,SAASL,UAAUM,MAAM,CAAC,CAACC,IAAM,CAACA,EAAE5B,SAAS;QACnD,IAAI0B,OAAOG,MAAM,EAAE;YAClB,OAAOhB,mBAAc,CAACiB,KAAK,CAACjD,QAAQS,IAAI,EAAE+B;QAC3C;QAEA,IAAI5B,QAAQsC,MAAM,EAAE;YACnB,MAAMC,QAAQ;gBAACzC,UAAU0C,eAAe;mBAAK7B,SAASW,GAAG,CAAC,CAACC,IAAMA,EAAEiB,eAAe;aAAE;YACpF,MAAMC,UAAUzC,QAAQyC,OAAO,IAAI,CAAC,wBAAwB,EAAExB,aAAa;YAC3E,IAAI,CAAC,CAAA,MAAO,CAACE,IAAI,CAAC,CAAC,YAAY,EAAEsB,SAAS;YAC1C,MAAM,IAAIC,YAAG,GAAGJ,MAAM,CAACG,SAAS;gBAAEF;YAAM;QACzC;QAEA,OAAOnB,mBAAc,CAACC,OAAO,CAACjC,QAAQS,IAAI,EAAE+B;IAC7C;IAEA,MAAcd,mBACbhB,SAAoB,EACpBE,OAAuB,EACL;QAClB,IAAIA,QAAQE,OAAO,IAAI,QAAQF,QAAQE,OAAO,CAACyC,IAAI,GAAGP,MAAM,GAAG,GAAG;YACjE,OAAOpC,QAAQE,OAAO,CAACyC,IAAI;QAC5B;QAEA,MAAMC,gBAAgB,IAAI,CAACC,wBAAwB;QACnD,IAAID,iBAAiB,MAAM;YAC1B,IAAI,CAAC,CAAA,MAAO,CAACzB,IAAI,CAAC,CAAC,sCAAsC,EAAEyB,eAAe;YAC1E,OAAOA;QACR;QAEA,MAAME,mBAAmB,MAAMhD,UAAUiD,UAAU;QACnD,IAAI,CAAC,CAAA,MAAO,CAAC5B,IAAI,CAChB,CAAC,0EAA0E,EAAE2B,kBAAkB;QAEhG,OAAOA;IACR;IAEQD,2BAA+C;QACtD,IAAI;YACH,MAAMG,OAAOC,IAAAA,2BAAQ,EAAC,+CAA+C;gBACpEC,UAAU;YACX,GACEP,IAAI,GACJQ,KAAK,CAAC,MACNjB,MAAM,CAACkB;YAET,IAAIJ,KAAKZ,MAAM,KAAK,GAAG;gBACtB,OAAOiB;YACR;YAEA,OAAOL,IAAI,CAAC,EAAE,CAACM,OAAO,CAAC,MAAM;QAC9B,EAAE,OAAM;YACP,OAAOD;QACR;IACD;IAEA;;;EAGC,GACD,MAAcrC,mCAAyD;QACtE,MAAMuC,eAAe9C,IAAAA,cAAI,EAAC+C,QAAQC,GAAG,IAAI;QACzC,IAAIC;QACJ,IAAI;YACHA,UAAU,MAAMC,IAAAA,iBAAO,EAACJ;QACzB,EAAE,OAAM;YACP,MAAM,IAAI7C,kBAAU,CACnB;QAEF;QAEA,MAAM6B,QAAQmB,QAAQxB,MAAM,CAAC,CAAC0B,IAAMA,EAAEC,QAAQ,CAAC,UAAUD,MAAM;QAC/D,IAAIrB,MAAMH,MAAM,KAAK,GAAG;YACvB,MAAM,IAAI1B,kBAAU,CACnB;QAEF;QAEA,MAAMoD,aAAqC;YAAEC,OAAO;YAAGC,OAAO;YAAGC,OAAO;YAAG3E,YAAY;QAAE;QACzF,IAAI4E,UAAuB7E,oBAAY,CAAC4E,KAAK;QAC7C,IAAIE,gBAAgB;QAEpB,KAAK,MAAMC,QAAQ7B,MAAO;YACzB,MAAM8B,UAAU,MAAMC,IAAAA,kBAAQ,EAAC7D,IAAAA,cAAI,EAAC8C,cAAca,OAAO;YACzD,MAAMG,QAAQF,QAAQE,KAAK,CAAC;YAC5B,IAAI,CAACA,OAAO;YACZ,KAAK,MAAMC,QAAQD,KAAK,CAAC,EAAE,CAACpB,KAAK,CAAC,MAAO;gBACxC,MAAMsB,WAAWD,KAAKD,KAAK,CAAC,yBAAyB,CAAC,EAAE;gBACxD,MAAMhD,IAAIkD,YAAY,OAAQX,UAAU,CAACW,SAAS,IAAI,CAAC,IAAK,CAAC;gBAC7D,IAAIlD,IAAI4C,eAAe;oBACtBD,UAAUO;oBACVN,gBAAgB5C;gBACjB;YACD;QACD;QAEA,IAAI,CAAC,CAAA,MAAO,CAACJ,IAAI,CAAC,CAAC,2BAA2B,EAAEoB,MAAMH,MAAM,CAAC,eAAe,EAAE8B,SAAS;QACvF,OAAOA;IACR;IAEQhD,eACPwD,cAAsB,EACtBC,WAAwB,EACxBC,KAAa,EACJ;QACT,IAAI;YACH,OAAO,IAAIC,cAAM,CAACH,gBAAgBI,SAAS,CAACH,aAAaC;QAC1D,EAAE,OAAOpE,OAAO;YACf,IAAIA,iBAAiBuE,mBAAW,EAAE;gBACjC,MAAM,IAAIrE,kBAAU,CAACF,MAAMiC,OAAO;YACnC;YAEA,MAAMjC;QACP;IACD;IAEA,MAAcuB,kBACblC,IAAY,EACZmF,OAAuB,EACvB9E,OAAe,EACY;QAC3B,IAAI;YACH,MAAM+E,cAAc,MAAMD,QAAQvD,cAAc;YAChD,MAAMuD,QAAQxD,kBAAkB,CAACyD,YAAYvD,WAAW,CAACxB,QAAQyB,QAAQ;YACzE,IAAI,CAAC,CAAA,MAAO,CAACuD,KAAK,CAACrF;YACnB,OAAO;gBACNA;gBACAU,WAAW;YACZ;QACD,EAAE,OAAO4E,QAAQ;YAChB,OAAO;gBACNtF;gBACAU,WAAW;gBACXC,OAAO,GAAGX,KAAK,EAAE,EAAEuF,IAAAA,0BAAkB,EAACD,SAAS;YAChD;QACD;IACD;AACD"}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Watch", {
+    enumerable: true,
+    get: function() {
+        return Watch;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _scribe = require("@decohere/scribe");
+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 Watch {
+    workspace;
+    #logger = _scribe.scribe.logger(Watch.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        if (!options.watch) {
+            this.#logger.info(`Skipping ${Watch.name}`);
+            return _cli.ActionResponse.Skipped(Watch.name);
+        }
+        await this.workspace.watch(options.configuration);
+        return _cli.ActionResponse.Blocking(Watch.name);
+    };
+    [Symbol.dispose]() {
+        this.workspace.stopWatching();
+    }
+}
+Watch = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Watch);
+
+//# sourceMappingURL=data:application/json;base64,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