@decohere/forge 0.0.1-dev.10

package/es6/src/commands/dependency.command.js

@@ -0,0 +1,78 @@
+import { CommandResponse, ConfigurationOption, DecohereCommand } from "@decohere/nexus/cli";
+import { CommitFiles } from "../actions/commit.action.js";
+import { ReportDependencies } from "../actions/dependency-report.action.js";
+import { SyncDependencies as DependencySync } from "../actions/dependency-sync.action.js";
+import { SyncLockFile } from "../actions/sync-lock-file.action.js";
+import { Release } from "../workspace.config.js";
+export class DependencyCommand extends DecohereCommand {
+    constructor(name, handler){
+        super(name ?? DependencyCommand);
+        this.description("Analyze and sync workspace dependencies");
+        this.addOption(new ConfigurationOption("release"));
+        this.registerSubcommand(ReportCommand, handler);
+        this.registerSubcommand(SyncCommand, handler);
+    }
+}
+class SyncCommand extends DecohereCommand {
+    get actions() {
+        return [
+            DependencySync,
+            SyncLockFile,
+            CommitFiles
+        ];
+    }
+    constructor(){
+        super(SyncCommand);
+        this.description("Sync workspace dependency manifests");
+        this.option("--log-diff", "Log what changed in each project's dependencies after syncing", false);
+        this.option("--no-sync", "Skip lockfile sync after syncing dependencies", true);
+        this.option("--commit", "Commit synced workspace manifest changes", false);
+        this.option("--message <message>", "Commit message (used with --commit)");
+    }
+    async run(actions, options) {
+        const responses = {};
+        const configuration = typeof options.configuration === "string" ? options.configuration : Release.name;
+        const syncDependencyOptions = {
+            configuration,
+            logDiff: options.logDiff === true
+        };
+        const syncLockOptions = {
+            sync: options.sync !== false,
+            dryRun: options.dryRun === true
+        };
+        const commitOptions = {
+            configuration,
+            commit: options.commit === true,
+            dryRun: options.dryRun === true,
+            message: typeof options.message === "string" ? options.message : undefined
+        };
+        responses.syncDependencies = await actions.syncDependencies.run(syncDependencyOptions);
+        this.throwOnErrors({
+            syncDependencies: responses.syncDependencies
+        });
+        responses.syncLockFile = await actions.syncLockFile.run(syncLockOptions);
+        this.throwOnErrors({
+            syncLockFile: responses.syncLockFile
+        });
+        responses.commitFiles = await actions.commitFiles.run(commitOptions);
+        this.throwOnErrors({
+            commitFiles: responses.commitFiles
+        });
+        return CommandResponse.success(options, responses);
+    }
+}
+class ReportCommand extends DecohereCommand {
+    get actions() {
+        return [
+            ReportDependencies
+        ];
+    }
+    constructor(){
+        super(ReportCommand);
+        this.description("Report resolved dependencies for workspace projects");
+        this.option("--file <file>", "Optional file path to write the report to");
+        this.option("--fail-on-drift", "Exit with an error if resolved dependencies differ from what is declared in package.json", false);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/commands/dependency.command.ts"],"sourcesContent":["import type { CommandHandler } from \"@decohere/nexus/cli\";\nimport { CommandResponse, ConfigurationOption, DecohereCommand } from \"@decohere/nexus/cli\";\nimport type { CommitFilesOptions } from \"../actions/commit.action.js\";\nimport { CommitFiles } from \"../actions/commit.action.js\";\nimport { ReportDependencies } from \"../actions/dependency-report.action.js\";\nimport type { DependenciesOptions } from \"../actions/dependency-sync.action.js\";\nimport { SyncDependencies as DependencySync } from \"../actions/dependency-sync.action.js\";\nimport type { SyncLockFileOptions } from \"../actions/sync-lock-file.action.js\";\nimport { SyncLockFile } from \"../actions/sync-lock-file.action.js\";\nimport { Release } from \"../workspace.config.js\";\n\nexport class DependencyCommand extends DecohereCommand {\n\tpublic constructor(name?: string, handler?: CommandHandler) {\n\t\tsuper(name ?? DependencyCommand);\n\t\tthis.description(\"Analyze and sync workspace dependencies\");\n\t\tthis.addOption(new ConfigurationOption(\"release\"));\n\t\tthis.registerSubcommand(ReportCommand, handler);\n\t\tthis.registerSubcommand(SyncCommand, handler);\n\t}\n}\n\ntype SyncActions = {\n\tsyncDependencies: DependencySync;\n\tsyncLockFile: SyncLockFile;\n\tcommitFiles: CommitFiles;\n};\n\nclass SyncCommand extends DecohereCommand<SyncActions> {\n\tpublic override get actions() {\n\t\treturn [DependencySync, SyncLockFile, CommitFiles];\n\t}\n\n\tpublic constructor() {\n\t\tsuper(SyncCommand);\n\t\tthis.description(\"Sync workspace dependency manifests\");\n\t\tthis.option(\n\t\t\t\"--log-diff\",\n\t\t\t\"Log what changed in each project's dependencies after syncing\",\n\t\t\tfalse,\n\t\t);\n\t\tthis.option(\"--no-sync\", \"Skip lockfile sync after syncing dependencies\", true);\n\t\tthis.option(\"--commit\", \"Commit synced workspace manifest changes\", false);\n\t\tthis.option(\"--message <message>\", \"Commit message (used with --commit)\");\n\t}\n\n\tpublic override async run(actions: SyncActions, options: Record<string, unknown>) {\n\t\tconst responses: CommandResponse<SyncActions> = {};\n\t\tconst configuration =\n\t\t\ttypeof options.configuration === \"string\" ? options.configuration : Release.name;\n\n\t\tconst syncDependencyOptions: DependenciesOptions = {\n\t\t\tconfiguration,\n\t\t\tlogDiff: options.logDiff === true,\n\t\t};\n\n\t\tconst syncLockOptions: SyncLockFileOptions = {\n\t\t\tsync: options.sync !== false,\n\t\t\tdryRun: options.dryRun === true,\n\t\t};\n\n\t\tconst commitOptions: CommitFilesOptions = {\n\t\t\tconfiguration,\n\t\t\tcommit: options.commit === true,\n\t\t\tdryRun: options.dryRun === true,\n\t\t\tmessage: typeof options.message === \"string\" ? options.message : undefined,\n\t\t};\n\n\t\tresponses.syncDependencies = await actions.syncDependencies.run(syncDependencyOptions);\n\t\tthis.throwOnErrors({ syncDependencies: responses.syncDependencies });\n\n\t\tresponses.syncLockFile = await actions.syncLockFile.run(syncLockOptions);\n\t\tthis.throwOnErrors({ syncLockFile: responses.syncLockFile });\n\n\t\tresponses.commitFiles = await actions.commitFiles.run(commitOptions);\n\t\tthis.throwOnErrors({ commitFiles: responses.commitFiles });\n\n\t\treturn CommandResponse.success(options, responses);\n\t}\n}\n\nclass ReportCommand extends DecohereCommand {\n\tpublic override get actions() {\n\t\treturn [ReportDependencies];\n\t}\n\n\tpublic constructor() {\n\t\tsuper(ReportCommand);\n\t\tthis.description(\"Report resolved dependencies for workspace projects\");\n\t\tthis.option(\"--file <file>\", \"Optional file path to write the report to\");\n\t\tthis.option(\n\t\t\t\"--fail-on-drift\",\n\t\t\t\"Exit with an error if resolved dependencies differ from what is declared in package.json\",\n\t\t\tfalse,\n\t\t);\n\t}\n}\n"],"names":["CommandResponse","ConfigurationOption","DecohereCommand","CommitFiles","ReportDependencies","SyncDependencies","DependencySync","SyncLockFile","Release","DependencyCommand","name","handler","description","addOption","registerSubcommand","ReportCommand","SyncCommand","actions","option","run","options","responses","configuration","syncDependencyOptions","logDiff","syncLockOptions","sync","dryRun","commitOptions","commit","message","undefined","syncDependencies","throwOnErrors","syncLockFile","commitFiles","success"],"mappings":"AACA,SAASA,eAAe,EAAEC,mBAAmB,EAAEC,eAAe,QAAQ,sBAAsB;AAE5F,SAASC,WAAW,QAAQ,8BAA8B;AAC1D,SAASC,kBAAkB,QAAQ,yCAAyC;AAE5E,SAASC,oBAAoBC,cAAc,QAAQ,uCAAuC;AAE1F,SAASC,YAAY,QAAQ,sCAAsC;AACnE,SAASC,OAAO,QAAQ,yBAAyB;AAEjD,OAAO,MAAMC,0BAA0BP;IACtC,YAAmBQ,IAAa,EAAEC,OAAwB,CAAE;QAC3D,KAAK,CAACD,QAAQD;QACd,IAAI,CAACG,WAAW,CAAC;QACjB,IAAI,CAACC,SAAS,CAAC,IAAIZ,oBAAoB;QACvC,IAAI,CAACa,kBAAkB,CAACC,eAAeJ;QACvC,IAAI,CAACG,kBAAkB,CAACE,aAAaL;IACtC;AACD;AAQA,MAAMK,oBAAoBd;IACzB,IAAoBe,UAAU;QAC7B,OAAO;YAACX;YAAgBC;YAAcJ;SAAY;IACnD;IAEA,aAAqB;QACpB,KAAK,CAACa;QACN,IAAI,CAACJ,WAAW,CAAC;QACjB,IAAI,CAACM,MAAM,CACV,cACA,iEACA;QAED,IAAI,CAACA,MAAM,CAAC,aAAa,iDAAiD;QAC1E,IAAI,CAACA,MAAM,CAAC,YAAY,4CAA4C;QACpE,IAAI,CAACA,MAAM,CAAC,uBAAuB;IACpC;IAEA,MAAsBC,IAAIF,OAAoB,EAAEG,OAAgC,EAAE;QACjF,MAAMC,YAA0C,CAAC;QACjD,MAAMC,gBACL,OAAOF,QAAQE,aAAa,KAAK,WAAWF,QAAQE,aAAa,GAAGd,QAAQE,IAAI;QAEjF,MAAMa,wBAA6C;YAClDD;YACAE,SAASJ,QAAQI,OAAO,KAAK;QAC9B;QAEA,MAAMC,kBAAuC;YAC5CC,MAAMN,QAAQM,IAAI,KAAK;YACvBC,QAAQP,QAAQO,MAAM,KAAK;QAC5B;QAEA,MAAMC,gBAAoC;YACzCN;YACAO,QAAQT,QAAQS,MAAM,KAAK;YAC3BF,QAAQP,QAAQO,MAAM,KAAK;YAC3BG,SAAS,OAAOV,QAAQU,OAAO,KAAK,WAAWV,QAAQU,OAAO,GAAGC;QAClE;QAEAV,UAAUW,gBAAgB,GAAG,MAAMf,QAAQe,gBAAgB,CAACb,GAAG,CAACI;QAChE,IAAI,CAACU,aAAa,CAAC;YAAED,kBAAkBX,UAAUW,gBAAgB;QAAC;QAElEX,UAAUa,YAAY,GAAG,MAAMjB,QAAQiB,YAAY,CAACf,GAAG,CAACM;QACxD,IAAI,CAACQ,aAAa,CAAC;YAAEC,cAAcb,UAAUa,YAAY;QAAC;QAE1Db,UAAUc,WAAW,GAAG,MAAMlB,QAAQkB,WAAW,CAAChB,GAAG,CAACS;QACtD,IAAI,CAACK,aAAa,CAAC;YAAEE,aAAad,UAAUc,WAAW;QAAC;QAExD,OAAOnC,gBAAgBoC,OAAO,CAAChB,SAASC;IACzC;AACD;AAEA,MAAMN,sBAAsBb;IAC3B,IAAoBe,UAAU;QAC7B,OAAO;YAACb;SAAmB;IAC5B;IAEA,aAAqB;QACpB,KAAK,CAACW;QACN,IAAI,CAACH,WAAW,CAAC;QACjB,IAAI,CAACM,MAAM,CAAC,iBAAiB;QAC7B,IAAI,CAACA,MAAM,CACV,mBACA,4FACA;IAEF;AACD"}

package/es6/src/commands/forge.command.js

@@ -0,0 +1,14 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+export class ForgeCommand extends DecohereCommand {
+    constructor(commands, handler){
+        super(ForgeCommand);
+        this.description("Run forge workspace workflows");
+        this.exitOverride();
+        this.registerSubcommand(commands, handler);
+    }
+    run(_actions, _options) {
+        return this.help();
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9jb21tYW5kcy9mb3JnZS5jb21tYW5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQWN0aW9ucyB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQge1xuXHR0eXBlIENvbW1hbmRIYW5kbGVyLFxuXHR0eXBlIENvbW1hbmRSZXNwb25zZSxcblx0dHlwZSBDb21tYW5kVHlwZSxcblx0RGVjb2hlcmVDb21tYW5kLFxufSBmcm9tIFwiQGRlY29oZXJlL25leHVzL2NsaVwiO1xuXG5leHBvcnQgY2xhc3MgRm9yZ2VDb21tYW5kIGV4dGVuZHMgRGVjb2hlcmVDb21tYW5kIHtcblx0cHVibGljIGNvbnN0cnVjdG9yKGNvbW1hbmRzOiBSZWNvcmQ8c3RyaW5nLCBDb21tYW5kVHlwZT4sIGhhbmRsZXI6IENvbW1hbmRIYW5kbGVyKSB7XG5cdFx0c3VwZXIoRm9yZ2VDb21tYW5kKTtcblx0XHR0aGlzLmRlc2NyaXB0aW9uKFwiUnVuIGZvcmdlIHdvcmtzcGFjZSB3b3JrZmxvd3NcIik7XG5cdFx0dGhpcy5leGl0T3ZlcnJpZGUoKTtcblx0XHR0aGlzLnJlZ2lzdGVyU3ViY29tbWFuZChjb21tYW5kcywgaGFuZGxlcik7XG5cdH1cblxuXHRwdWJsaWMgcnVuKF9hY3Rpb25zOiBBY3Rpb25zLCBfb3B0aW9uczogbmV2ZXIpOiBQcm9taXNlPENvbW1hbmRSZXNwb25zZT4ge1xuXHRcdHJldHVybiB0aGlzLmhlbHAoKTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIkRlY29oZXJlQ29tbWFuZCIsIkZvcmdlQ29tbWFuZCIsImNvbW1hbmRzIiwiaGFuZGxlciIsImRlc2NyaXB0aW9uIiwiZXhpdE92ZXJyaWRlIiwicmVnaXN0ZXJTdWJjb21tYW5kIiwicnVuIiwiX2FjdGlvbnMiLCJfb3B0aW9ucyIsImhlbHAiXSwibWFwcGluZ3MiOiJBQUNBLFNBSUNBLGVBQWUsUUFDVCxzQkFBc0I7QUFFN0IsT0FBTyxNQUFNQyxxQkFBcUJEO0lBQ2pDLFlBQW1CRSxRQUFxQyxFQUFFQyxPQUF1QixDQUFFO1FBQ2xGLEtBQUssQ0FBQ0Y7UUFDTixJQUFJLENBQUNHLFdBQVcsQ0FBQztRQUNqQixJQUFJLENBQUNDLFlBQVk7UUFDakIsSUFBSSxDQUFDQyxrQkFBa0IsQ0FBQ0osVUFBVUM7SUFDbkM7SUFFT0ksSUFBSUMsUUFBaUIsRUFBRUMsUUFBZSxFQUE0QjtRQUN4RSxPQUFPLElBQUksQ0FBQ0MsSUFBSTtJQUNqQjtBQUNEIn0=

package/es6/src/commands/index.js

@@ -0,0 +1,8 @@
+export * from "./build.command.js";
+export * from "./dependency.command.js";
+export * from "./forge.command.js";
+export * from "./publish.command.js";
+export * from "./tag.command.js";
+export * from "./version.command.js";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9jb21tYW5kcy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9idWlsZC5jb21tYW5kLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXBlbmRlbmN5LmNvbW1hbmQuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2ZvcmdlLmNvbW1hbmQuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3B1Ymxpc2guY29tbWFuZC5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdGFnLmNvbW1hbmQuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ZlcnNpb24uY29tbWFuZC5qc1wiO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCO0FBQ25DLGNBQWMsMEJBQTBCO0FBQ3hDLGNBQWMscUJBQXFCO0FBQ25DLGNBQWMsdUJBQXVCO0FBQ3JDLGNBQWMsbUJBQW1CO0FBQ2pDLGNBQWMsdUJBQXVCIn0=

package/es6/src/commands/publish.command.js

@@ -0,0 +1,22 @@
+import { ConfigurationOption, DecohereCommand, DryRunOption } from "@decohere/nexus/cli";
+import { Publish } from "../actions/publish.action.js";
+export class PublishCommand extends DecohereCommand {
+    get actions() {
+        return [
+            Publish
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Publish workspace packages");
+        this.addOption(new ConfigurationOption("release"));
+        this.addOption(new DryRunOption("Run npm publish using dry-run flag"));
+        this.option("--channel <channel>", "The release channel", "beta");
+        this.option("--token <token>", "npm access token (used only for this command)");
+        this.option("--otp <otp>", "npm one-time password for 2FA-protected publish");
+        this.option("--prompt-auth", "Prompt interactively for npm token and OTP", false);
+        this.option("--prompt-otp", "Prompt interactively for npm OTP only (use when already logged in)", false);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/commands/tag.command.js

@@ -0,0 +1,18 @@
+import { DecohereCommand, DryRunOption } from "@decohere/nexus/cli";
+import { Tag } from "../actions/tag.action.js";
+export class TagCommand extends DecohereCommand {
+    get actions() {
+        return [
+            Tag
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Create and optionally push a git tag for the workspace version");
+        this.option("--prefix <prefix>", "Tag prefix", "v");
+        this.option("--push", "Push the tag and current branch to origin after tagging", false);
+        this.addOption(new DryRunOption("Print the tag without creating it"));
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9jb21tYW5kcy90YWcuY29tbWFuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEZWNvaGVyZUNvbW1hbmQsIERyeVJ1bk9wdGlvbiB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQgeyBUYWcgfSBmcm9tIFwiLi4vYWN0aW9ucy90YWcuYWN0aW9uLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBUYWdDb21tYW5kIGV4dGVuZHMgRGVjb2hlcmVDb21tYW5kIHtcblx0cHVibGljIG92ZXJyaWRlIGdldCBhY3Rpb25zKCkge1xuXHRcdHJldHVybiBbVGFnXTtcblx0fVxuXG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihuYW1lOiBzdHJpbmcpIHtcblx0XHRzdXBlcihuYW1lKTtcblx0XHR0aGlzLmRlc2NyaXB0aW9uKFwiQ3JlYXRlIGFuZCBvcHRpb25hbGx5IHB1c2ggYSBnaXQgdGFnIGZvciB0aGUgd29ya3NwYWNlIHZlcnNpb25cIik7XG5cdFx0dGhpcy5vcHRpb24oXCItLXByZWZpeCA8cHJlZml4PlwiLCBcIlRhZyBwcmVmaXhcIiwgXCJ2XCIpO1xuXHRcdHRoaXMub3B0aW9uKFwiLS1wdXNoXCIsIFwiUHVzaCB0aGUgdGFnIGFuZCBjdXJyZW50IGJyYW5jaCB0byBvcmlnaW4gYWZ0ZXIgdGFnZ2luZ1wiLCBmYWxzZSk7XG5cdFx0dGhpcy5hZGRPcHRpb24obmV3IERyeVJ1bk9wdGlvbihcIlByaW50IHRoZSB0YWcgd2l0aG91dCBjcmVhdGluZyBpdFwiKSk7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJEZWNvaGVyZUNvbW1hbmQiLCJEcnlSdW5PcHRpb24iLCJUYWciLCJUYWdDb21tYW5kIiwiYWN0aW9ucyIsIm5hbWUiLCJkZXNjcmlwdGlvbiIsIm9wdGlvbiIsImFkZE9wdGlvbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsZUFBZSxFQUFFQyxZQUFZLFFBQVEsc0JBQXNCO0FBQ3BFLFNBQVNDLEdBQUcsUUFBUSwyQkFBMkI7QUFFL0MsT0FBTyxNQUFNQyxtQkFBbUJIO0lBQy9CLElBQW9CSSxVQUFVO1FBQzdCLE9BQU87WUFBQ0Y7U0FBSTtJQUNiO0lBRUEsWUFBbUJHLElBQVksQ0FBRTtRQUNoQyxLQUFLLENBQUNBO1FBQ04sSUFBSSxDQUFDQyxXQUFXLENBQUM7UUFDakIsSUFBSSxDQUFDQyxNQUFNLENBQUMscUJBQXFCLGNBQWM7UUFDL0MsSUFBSSxDQUFDQSxNQUFNLENBQUMsVUFBVSwyREFBMkQ7UUFDakYsSUFBSSxDQUFDQyxTQUFTLENBQUMsSUFBSVAsYUFBYTtJQUNqQztBQUNEIn0=

package/es6/src/commands/version.command.js

@@ -0,0 +1,26 @@
+import { ConfigurationOption, DecohereCommand, DryRunOption } from "@decohere/nexus/cli";
+import { SyncLockFile } from "../actions/sync-lock-file.action.js";
+import { DefaultChannel, DefaultReleaseType, Version } from "../actions/version.action.js";
+export class VersionCommand extends DecohereCommand {
+    get actions() {
+        return [
+            Version,
+            SyncLockFile
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Bump workspace package versions");
+        this.addOption(new ConfigurationOption("release"));
+        this.addOption(new DryRunOption("Run npm publish using dry-run flag"));
+        this.option("--release-type <releaseType>", "The semver release type: major, minor, patch, prerelease", DefaultReleaseType);
+        this.option("--channel <channel>", "The release channel (preid for prereleases, dist-tag for publish)", DefaultChannel);
+        this.option("--version <version>", "Explicit base version to increment (overrides git tag discovery)");
+        this.option("--no-sync", "Skip lockfile sync after versioning", true);
+        this.option("--commit", "Commit versioned package.json files after bumping", false);
+        this.option("--message <message>", "Commit message (used with --commit)");
+        this.option("--from-changesets", "Read pending .changeset entries to determine the highest bump type (major > minor > patch)", false);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/const.js

@@ -0,0 +1,60 @@
+export const SWC_CONFIG = ".swcrc";
+export const NODE_MODULES = "node_modules";
+export const BUILT_IN_MODULES = [
+    "assert",
+    "assert/strict",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "dns",
+    "dns/promises",
+    "domain",
+    "events",
+    "fs",
+    "fs/promises",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "inspector/promises",
+    "module",
+    "net",
+    "os",
+    "path",
+    "path/posix",
+    "path/win32",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "readline/promises",
+    "repl",
+    "stream",
+    "stream/consumers",
+    "stream/promises",
+    "stream/web",
+    "string_decoder",
+    "sys",
+    "timers",
+    "timers/promises",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "util/types",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib"
+];
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/errors.js

@@ -0,0 +1,18 @@
+export { WorkspaceConfigurationError } from "@decohere/mesh";
+export class ForgeError extends Error {
+}
+export function formatUnknownError(reason) {
+    if (reason instanceof Error) {
+        return reason.message;
+    }
+    if (typeof reason === "string") {
+        return reason;
+    }
+    try {
+        return JSON.stringify(reason);
+    } catch  {
+        return "Unknown error";
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9lcnJvcnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgV29ya3NwYWNlQ29uZmlndXJhdGlvbkVycm9yIH0gZnJvbSBcIkBkZWNvaGVyZS9tZXNoXCI7XG5leHBvcnQgY2xhc3MgRm9yZ2VFcnJvciBleHRlbmRzIEVycm9yIHt9XG5cbmV4cG9ydCBmdW5jdGlvbiBmb3JtYXRVbmtub3duRXJyb3IocmVhc29uOiB1bmtub3duKTogc3RyaW5nIHtcblx0aWYgKHJlYXNvbiBpbnN0YW5jZW9mIEVycm9yKSB7XG5cdFx0cmV0dXJuIHJlYXNvbi5tZXNzYWdlO1xuXHR9XG5cblx0aWYgKHR5cGVvZiByZWFzb24gPT09IFwic3RyaW5nXCIpIHtcblx0XHRyZXR1cm4gcmVhc29uO1xuXHR9XG5cblx0dHJ5IHtcblx0XHRyZXR1cm4gSlNPTi5zdHJpbmdpZnkocmVhc29uKTtcblx0fSBjYXRjaCB7XG5cdFx0cmV0dXJuIFwiVW5rbm93biBlcnJvclwiO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiV29ya3NwYWNlQ29uZmlndXJhdGlvbkVycm9yIiwiRm9yZ2VFcnJvciIsIkVycm9yIiwiZm9ybWF0VW5rbm93bkVycm9yIiwicmVhc29uIiwibWVzc2FnZSIsIkpTT04iLCJzdHJpbmdpZnkiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLDJCQUEyQixRQUFRLGlCQUFpQjtBQUM3RCxPQUFPLE1BQU1DLG1CQUFtQkM7QUFBTztBQUV2QyxPQUFPLFNBQVNDLG1CQUFtQkMsTUFBZTtJQUNqRCxJQUFJQSxrQkFBa0JGLE9BQU87UUFDNUIsT0FBT0UsT0FBT0MsT0FBTztJQUN0QjtJQUVBLElBQUksT0FBT0QsV0FBVyxVQUFVO1FBQy9CLE9BQU9BO0lBQ1I7SUFFQSxJQUFJO1FBQ0gsT0FBT0UsS0FBS0MsU0FBUyxDQUFDSDtJQUN2QixFQUFFLE9BQU07UUFDUCxPQUFPO0lBQ1I7QUFDRCJ9

package/es6/src/extensions/project.extensions.js

@@ -0,0 +1,79 @@
+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";
+import path from "node:path";
+import { Project } from "@decohere/mesh";
+import { memoize } from "@decohere/nexus/caching";
+import { extension } from "@decohere/nexus/extensibility";
+import { io } from "@decohere/nexus/io";
+import { SWC_CONFIG } from "../const.js";
+import { SwcConfig } from "../types/swc-config.type.js";
+export class ProjectExtensions {
+    static getForgeConfiguration(project) {
+        return project.configuration;
+    }
+    static async getSwcConfig(project) {
+        for (const configPath of ProjectExtensions.swcConfigPaths(project)){
+            if (await io.fileExists(configPath)) {
+                return new SwcConfig(await io.readJsonFile(configPath));
+            }
+        }
+        return new SwcConfig();
+    }
+    static getSwcConfigSync(project) {
+        for (const configPath of ProjectExtensions.swcConfigPaths(project)){
+            if (ProjectExtensions.fileExistsSync(configPath)) {
+                return new SwcConfig(JSON.parse(fs.readFileSync(configPath, "utf8")));
+            }
+        }
+        return new SwcConfig();
+    }
+    static swcConfigPaths(project) {
+        return [
+            path.join(project.projectDirectory, SWC_CONFIG),
+            path.join(project.rootDir, SWC_CONFIG)
+        ];
+    }
+    static fileExistsSync(filePath) {
+        try {
+            return fs.statSync(filePath).isFile();
+        } catch  {
+            return false;
+        }
+    }
+}
+_ts_decorate([
+    extension(Project),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Project === "undefined" ? Object : Project
+    ]),
+    _ts_metadata("design:returntype", typeof ForgeConfiguration === "undefined" ? Object : ForgeConfiguration)
+], ProjectExtensions, "getForgeConfiguration", null);
+_ts_decorate([
+    extension(Project),
+    memoize(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Project === "undefined" ? Object : Project
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ProjectExtensions, "getSwcConfig", null);
+_ts_decorate([
+    extension(Project),
+    memoize(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Project === "undefined" ? Object : Project
+    ]),
+    _ts_metadata("design:returntype", typeof SwcConfig === "undefined" ? Object : SwcConfig)
+], ProjectExtensions, "getSwcConfigSync", null);
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/factories/swc-config.factory.js

@@ -0,0 +1,83 @@
+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 path from "node:path";
+import { Trace } from "@decohere/nexus/diagnostics";
+import { merge } from "@decohere/nexus/objects";
+import { ForgeError } from "../errors.js";
+const defaultOptions = {
+    jsc: {
+        parser: {
+            syntax: "typescript",
+            decorators: true
+        },
+        target: "esnext",
+        transform: {
+            decoratorMetadata: true
+        },
+        experimental: {
+            keepImportAttributes: true
+        }
+    },
+    module: {
+        resolveFully: true
+    },
+    sourceMaps: "inline"
+};
+export class SwcConfigFactory {
+    /**
+	 * Creates a base config for a project+target combination, without a filename.
+	 * Call once per (project, target) and then use createFileConfig() per file.
+	 */ createBaseConfig(buildTarget, configOptions) {
+        const { userConfig, tsConfig, aliasPaths } = configOptions;
+        const { compilerOptions } = tsConfig ?? {};
+        const paths = aliasPaths ? compilerOptions?.paths : undefined;
+        const baseUrl = SwcConfigFactory.getBaseUrl(tsConfig) ?? (paths != null ? path.resolve(".") : undefined);
+        const options = {
+            jsc: {
+                baseUrl,
+                paths
+            },
+            module: {
+                type: buildTarget
+            }
+        };
+        return merge.withOptions({
+            mergeArrays: false
+        }, defaultOptions, options, userConfig ?? {});
+    }
+    /** Stamps a per-file filename onto a pre-built base config. */ createFileConfig(file, baseConfig) {
+        const config = {
+            ...baseConfig,
+            filename: file.fullPath
+        };
+        this.validate(config);
+        return config;
+    }
+    /**
+	 * Validates SWC options against known causes of Rust/NAPI process crashes.
+	 * Throws a ForgeError with a descriptive message instead of letting the
+	 * NAPI layer abort the process.
+	 *
+	 * Known crash causes:
+	 * - `jsc.baseUrl` set to a relative path (SWC requires an absolute path)
+	 */ validate(options) {
+        const baseUrl = options.jsc?.baseUrl;
+        if (baseUrl != null && !path.isAbsolute(baseUrl)) {
+            throw new ForgeError(`SWC config: jsc.baseUrl must be an absolute path to avoid a process crash, got: "${baseUrl}". Use path.resolve() to convert it.`);
+        }
+    }
+    /** Resolves tsconfig baseUrl to an absolute path. Returns undefined if not set. */ static getBaseUrl(tsConfig) {
+        const baseUrl = tsConfig?.compilerOptions?.baseUrl;
+        if (baseUrl == null) return undefined;
+        return path.resolve(baseUrl);
+    }
+}
+SwcConfigFactory = _ts_decorate([
+    Trace
+], SwcConfigFactory);
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/forge.module.js

@@ -0,0 +1,58 @@
+import { UserConfigFactory, WorkspaceFactory } from "@decohere/mesh";
+import { ModuleManifest } from "@decohere/nexus/cli";
+import * as Actions from "./actions/index.js";
+import * as Commands from "./commands/index.js";
+import { DependencyResolver } from "./services/dependency-resolver.service.js";
+import { FileWriterService } from "./services/file-writer.service.js";
+import { SwcTranspiler } from "./services/swc-transpiler.js";
+import { TypeEmitter } from "./services/type-emitter.js";
+import { TransformerKey } from "./types/transformer.type.js";
+import { DefaultConfigurations, WorkspaceDefaults } from "./workspace.config.js";
+export class ForgeModule extends ModuleManifest {
+    id = "forge";
+    command = Commands.ForgeCommand;
+    actions = {
+        clean: Actions.Clean,
+        copy: Actions.Copy,
+        build: Actions.Build,
+        watch: Actions.Watch,
+        publish: Actions.Publish,
+        syncDependencies: Actions.SyncDependencies,
+        syncLockFile: Actions.SyncLockFile,
+        reportDependencies: Actions.ReportDependencies,
+        version: Actions.Version,
+        tag: Actions.Tag,
+        commitFiles: Actions.CommitFiles
+    };
+    commands = {
+        build: Commands.BuildCommand,
+        publish: Commands.PublishCommand,
+        dependencies: Commands.DependencyCommand,
+        version: Commands.VersionCommand,
+        tag: Commands.TagCommand
+    };
+    registerServices(builder) {
+        builder.registerSingleton(TransformerKey, SwcTranspiler);
+        builder.registerSingleton(TransformerKey, TypeEmitter);
+        builder.registerSingleton(DependencyResolver);
+        builder.registerSingleton(FileWriterService);
+    }
+    async createWorkspace(options) {
+        const { configurations: _, ...forgeDefaults } = WorkspaceDefaults;
+        const userConfig = await UserConfigFactory.getUserConfig(options.configFile);
+        // Only apply forge default configurations when user config doesn't provide any.
+        // This ensures user-defined configurations take priority while still providing
+        // sensible defaults (debug + release) when no config file is present.
+        const configurations = userConfig.configurations?.length ? undefined : DefaultConfigurations;
+        return WorkspaceFactory.create({
+            ...forgeDefaults,
+            ...configurations ? {
+                configurations
+            } : {},
+            configFile: options.configFile,
+            rootDir: options.rootDir ?? WorkspaceDefaults.rootDir
+        });
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/index.js

@@ -0,0 +1,7 @@
+export { ForgeError } from "./errors.js";
+export { ForgeModule } from "./forge.module.js";
+export { SwcTranspiler } from "./services/swc-transpiler.js";
+export { BuildTargets } from "./types/build-target.type.js";
+export { Debug as DebugConfiguration, DefaultConfigurations, Release as ReleaseConfiguration, WorkspaceDefaults } from "./workspace.config.js";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBGb3JnZUVycm9yIH0gZnJvbSBcIi4vZXJyb3JzLmpzXCI7XG5leHBvcnQgeyBGb3JnZU1vZHVsZSB9IGZyb20gXCIuL2ZvcmdlLm1vZHVsZS5qc1wiO1xuZXhwb3J0IHR5cGUgeyBUcmFuc3BpbGVPcHRpb25zIH0gZnJvbSBcIi4vc2VydmljZXMvc3djLXRyYW5zcGlsZXIuanNcIjtcbmV4cG9ydCB7IFN3Y1RyYW5zcGlsZXIgfSBmcm9tIFwiLi9zZXJ2aWNlcy9zd2MtdHJhbnNwaWxlci5qc1wiO1xuZXhwb3J0IHR5cGUgeyBCdWlsZFRhcmdldCwgVHJhbnNwaWxlVGFyZ2V0IH0gZnJvbSBcIi4vdHlwZXMvYnVpbGQtdGFyZ2V0LnR5cGUuanNcIjtcbmV4cG9ydCB7IEJ1aWxkVGFyZ2V0cyB9IGZyb20gXCIuL3R5cGVzL2J1aWxkLXRhcmdldC50eXBlLmpzXCI7XG5leHBvcnQgdHlwZSB7IEZvcmdlQ29uZmlndXJhdGlvbiB9IGZyb20gXCIuL3R5cGVzL2NvbmZpZ3VyYXRpb24udHlwZS5qc1wiO1xuZXhwb3J0IHR5cGUgeyBXb3Jrc3BhY2VPcHRpb25zIH0gZnJvbSBcIi4vdHlwZXMvd29ya3NwYWNlLWNvbmZpZy50eXBlLmpzXCI7XG5leHBvcnQge1xuXHREZWJ1ZyBhcyBEZWJ1Z0NvbmZpZ3VyYXRpb24sXG5cdERlZmF1bHRDb25maWd1cmF0aW9ucyxcblx0UmVsZWFzZSBhcyBSZWxlYXNlQ29uZmlndXJhdGlvbixcblx0V29ya3NwYWNlRGVmYXVsdHMsXG59IGZyb20gXCIuL3dvcmtzcGFjZS5jb25maWcuanNcIjtcbiJdLCJuYW1lcyI6WyJGb3JnZUVycm9yIiwiRm9yZ2VNb2R1bGUiLCJTd2NUcmFuc3BpbGVyIiwiQnVpbGRUYXJnZXRzIiwiRGVidWciLCJEZWJ1Z0NvbmZpZ3VyYXRpb24iLCJEZWZhdWx0Q29uZmlndXJhdGlvbnMiLCJSZWxlYXNlIiwiUmVsZWFzZUNvbmZpZ3VyYXRpb24iLCJXb3Jrc3BhY2VEZWZhdWx0cyJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsVUFBVSxRQUFRLGNBQWM7QUFDekMsU0FBU0MsV0FBVyxRQUFRLG9CQUFvQjtBQUVoRCxTQUFTQyxhQUFhLFFBQVEsK0JBQStCO0FBRTdELFNBQVNDLFlBQVksUUFBUSwrQkFBK0I7QUFHNUQsU0FDQ0MsU0FBU0Msa0JBQWtCLEVBQzNCQyxxQkFBcUIsRUFDckJDLFdBQVdDLG9CQUFvQixFQUMvQkMsaUJBQWlCLFFBQ1gsd0JBQXdCIn0=

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

@@ -0,0 +1,32 @@
+import { io } from "@decohere/nexus/io";
+export class CachesOutputs {
+    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */ get outputCache() {
+        const self = this;
+        if (self.__outputCache == null) {
+            self.__outputCache = new Map();
+        }
+        return self.__outputCache;
+    }
+    cacheOutputs(responses) {
+        for (const response of responses){
+            if (response.outcome !== "success") continue;
+            const existing = this.outputCache.get(response.file.fullPath) ?? [];
+            this.outputCache.set(response.file.fullPath, [
+                ...existing,
+                response
+            ]);
+        }
+    }
+    deleteCachedOutputs(filePath) {
+        const outputs = this.outputCache.get(filePath);
+        if (outputs == null) return;
+        for (const response of outputs){
+            if (response.outputPath != null) {
+                void io.deleteFile(response.outputPath);
+            }
+        }
+        this.outputCache.delete(filePath);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

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