@decohere/forge 0.0.1-dev.5

package/commonjs/src/vitest/forge-build.plugin.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "forgeBuild", {
+    enumerable: true,
+    get: function() {
+        return forgeBuild;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _mesh = require("@decohere/mesh");
+const _io = require("@decohere/nexus/io");
+const _scribe = require("@decohere/scribe");
+const _swctranspiler = require("../services/swc-transpiler.js");
+const _buildtargettype = require("../types/build-target.type.js");
+const _workspaceconfig = require("../workspace.config.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// Above fatal (60) so all standard levels are nooped when logLevel is "silent"
+const SILENT_LEVEL = 999;
+const PLUGIN_NAME = "forge-vitest-source";
+const TS_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".mts"
+];
+function forgeBuild(options) {
+    const buildConfig = options?.buildConfig ?? "debug";
+    const workspaceRoot = options?.workspaceRoot ?? process.cwd();
+    const logLevel = options?.logLevel ?? "info";
+    const loggerFactory = _scribe.scribe.configure({
+        adapter: new _scribe.ConsoleAdapter(),
+        options: {
+            logLevel,
+            customLevels: {
+                silent: SILENT_LEVEL
+            }
+        }
+    });
+    const logger = loggerFactory(PLUGIN_NAME);
+    const skipBuild = options?.skipBuild ?? false;
+    const transpiler = new _swctranspiler.SwcTranspiler();
+    const warmedProjects = new Set();
+    const transformCache = new Map();
+    let workspace = null;
+    const initWorkspace = async ()=>{
+        if (workspace !== null) return;
+        logger.debug(`Loading Forge workspace (buildConfig: ${buildConfig}, workspaceRoot: ${workspaceRoot})`);
+        workspace = await _mesh.WorkspaceFactory.create({
+            ..._workspaceconfig.WorkspaceDefaults,
+            rootDir: workspaceRoot
+        });
+    };
+    const preWarmProject = (project)=>{
+        if (warmedProjects.has(project.projectDirectory)) return;
+        warmedProjects.add(project.projectDirectory);
+        void transpiler.transformProject(project).then(()=>logger.debug(`Pre-warm complete for ${project.name}`)).catch((err)=>logger.error(`Pre-warm error for ${project.name}: ${err.message}`));
+    };
+    return {
+        name: PLUGIN_NAME,
+        enforce: "pre",
+        configResolved () {
+            logger.debug("Plugin loaded");
+        },
+        resolveId (source, importer) {
+            if (importer != null && source.endsWith(".js") && source.startsWith(".")) {
+                const importerDirectory = _nodepath.default.dirname(importer);
+                const withoutExtension = source.slice(0, -3);
+                const candidates = TS_EXTENSIONS.map((ext)=>_nodepath.default.resolve(importerDirectory, `${withoutExtension}${ext}`));
+                return candidates.find((c)=>(0, _nodefs.existsSync)(c)) ?? null;
+            }
+            return null;
+        },
+        watchChange (id) {
+            const file = new _io.FileEx({
+                fullPath: id
+            });
+            transformCache.delete(id);
+            transpiler.invalidateContentCache(file);
+        },
+        async transform (code, id) {
+            if (id.includes("node_modules") || !/[.](ts|tsx|mts|cts)$/.test(id)) {
+                return null;
+            }
+            await initWorkspace();
+            const project = await workspace?.findProject(id, buildConfig);
+            if (project != null && !skipBuild) {
+                preWarmProject(project);
+            }
+            const cached = transformCache.get(id);
+            if (cached !== undefined && cached.content === code) {
+                return cached.result;
+            }
+            const file = new _io.FileEx({
+                fullPath: id,
+                content: code
+            });
+            if (cached !== undefined) {
+                // Content changed for a previously-seen file — invalidate the transpiler's
+                // FILE_CONTENT cache so the fresh content from Vite is used.
+                // The VS Code Vitest extension disables Vite's chokidar watcher
+                // (server.watch: null) and drives re-runs via vitest.watcher.onFileChange(),
+                // bypassing watchChange entirely — so we cannot rely on watchChange alone.
+                transpiler.invalidateContentCache(file);
+            }
+            const [response] = await transpiler.transformFile(file, _buildtargettype.BuildTargets.es6, {
+                aliasPaths: true,
+                tsConfig: project ? await project.getTsConfig() : undefined
+            });
+            if (!response || response.outcome !== "success") return null;
+            const result = {
+                code: response.code,
+                map: null
+            };
+            transformCache.set(id, {
+                content: code,
+                result
+            });
+            return result;
+        }
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/vitest/forge-build.plugin.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport type { Project, Workspace } from \"@decohere/mesh\";\nimport { WorkspaceFactory } from \"@decohere/mesh\";\nimport { FileEx } from \"@decohere/nexus/io\";\nimport { ConsoleAdapter, scribe } from \"@decohere/scribe\";\nimport { SwcTranspiler } from \"../services/swc-transpiler.js\";\nimport { BuildTargets } from \"../types/build-target.type.js\";\nimport { WorkspaceDefaults } from \"../workspace.config.js\";\n\n// Above fatal (60) so all standard levels are nooped when logLevel is \"silent\"\nconst SILENT_LEVEL = 999;\n\nconst PLUGIN_NAME = \"forge-vitest-source\";\nconst TS_EXTENSIONS = [\".ts\", \".tsx\", \".mts\"];\n\nexport type ForgeBuildOptions = {\n\tbuildConfig?: string;\n\tlogLevel?: string;\n\tworkspaceRoot?: string;\n\t/** Skip the build pre-warm entirely (e.g. when a pre-built artifact is already on disk). */\n\tskipBuild?: boolean;\n};\n\nexport function forgeBuild(options?: ForgeBuildOptions) {\n\tconst buildConfig = options?.buildConfig ?? \"debug\";\n\tconst workspaceRoot = options?.workspaceRoot ?? process.cwd();\n\tconst logLevel = options?.logLevel ?? \"info\";\n\tconst loggerFactory = scribe.configure({\n\t\tadapter: new ConsoleAdapter(),\n\t\toptions: { logLevel, customLevels: { silent: SILENT_LEVEL } },\n\t});\n\tconst logger = loggerFactory(PLUGIN_NAME);\n\n\tconst skipBuild = options?.skipBuild ?? false;\n\n\tconst transpiler = new SwcTranspiler();\n\tconst warmedProjects = new Set<string>();\n\tconst transformCache = new Map<\n\t\tstring,\n\t\t{ content: string; result: { code: string; map: null } }\n\t>();\n\n\tlet workspace: Workspace | null = null;\n\n\tconst initWorkspace = async () => {\n\t\tif (workspace !== null) return;\n\t\tlogger.debug(\n\t\t\t`Loading Forge workspace (buildConfig: ${buildConfig}, workspaceRoot: ${workspaceRoot})`,\n\t\t);\n\t\tworkspace = await WorkspaceFactory.create({\n\t\t\t...WorkspaceDefaults,\n\t\t\trootDir: workspaceRoot,\n\t\t});\n\t};\n\n\tconst preWarmProject = (project: Project) => {\n\t\tif (warmedProjects.has(project.projectDirectory)) return;\n\t\twarmedProjects.add(project.projectDirectory);\n\t\tvoid transpiler\n\t\t\t.transformProject(project)\n\t\t\t.then(() => logger.debug(`Pre-warm complete for ${project.name}`))\n\t\t\t.catch((err: Error) =>\n\t\t\t\tlogger.error(`Pre-warm error for ${project.name}: ${err.message}`),\n\t\t\t);\n\t};\n\n\treturn {\n\t\tname: PLUGIN_NAME,\n\t\tenforce: \"pre\" as const,\n\t\tconfigResolved(): void {\n\t\t\tlogger.debug(\"Plugin loaded\");\n\t\t},\n\t\tresolveId(source: string, importer: string | undefined): string | null {\n\t\t\tif (importer != null && source.endsWith(\".js\") && source.startsWith(\".\")) {\n\t\t\t\tconst importerDirectory = path.dirname(importer);\n\t\t\t\tconst withoutExtension = source.slice(0, -3);\n\t\t\t\tconst candidates = TS_EXTENSIONS.map((ext) =>\n\t\t\t\t\tpath.resolve(importerDirectory, `${withoutExtension}${ext}`),\n\t\t\t\t);\n\n\t\t\t\treturn candidates.find((c) => existsSync(c)) ?? null;\n\t\t\t}\n\n\t\t\treturn null;\n\t\t},\n\t\twatchChange(id: string): void {\n\t\t\tconst file = new FileEx({ fullPath: id });\n\t\t\ttransformCache.delete(id);\n\t\t\ttranspiler.invalidateContentCache(file);\n\t\t},\n\t\tasync transform(\n\t\t\tcode: string,\n\t\t\tid: string,\n\t\t): Promise<{ code: string; map: string | null } | null> {\n\t\t\tif (id.includes(\"node_modules\") || !/[.](ts|tsx|mts|cts)$/.test(id)) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tawait initWorkspace();\n\t\t\tconst project = await workspace?.findProject(id, buildConfig);\n\n\t\t\tif (project != null && !skipBuild) {\n\t\t\t\tpreWarmProject(project);\n\t\t\t}\n\n\t\t\tconst cached = transformCache.get(id);\n\t\t\tif (cached !== undefined && cached.content === code) {\n\t\t\t\treturn cached.result;\n\t\t\t}\n\n\t\t\tconst file = new FileEx({ fullPath: id, content: code });\n\t\t\tif (cached !== undefined) {\n\t\t\t\t// Content changed for a previously-seen file — invalidate the transpiler's\n\t\t\t\t// FILE_CONTENT cache so the fresh content from Vite is used.\n\t\t\t\t// The VS Code Vitest extension disables Vite's chokidar watcher\n\t\t\t\t// (server.watch: null) and drives re-runs via vitest.watcher.onFileChange(),\n\t\t\t\t// bypassing watchChange entirely — so we cannot rely on watchChange alone.\n\t\t\t\ttranspiler.invalidateContentCache(file);\n\t\t\t}\n\t\t\tconst [response] = await transpiler.transformFile(file, BuildTargets.es6, {\n\t\t\t\taliasPaths: true,\n\t\t\t\ttsConfig: project ? await project.getTsConfig() : undefined,\n\t\t\t});\n\t\t\tif (!response || response.outcome !== \"success\") return null;\n\n\t\t\tconst result = { code: response.code, map: null };\n\t\t\ttransformCache.set(id, { content: code, result });\n\t\t\treturn result;\n\t\t},\n\t};\n}\n"],"names":["forgeBuild","SILENT_LEVEL","PLUGIN_NAME","TS_EXTENSIONS","options","buildConfig","workspaceRoot","process","cwd","logLevel","loggerFactory","scribe","configure","adapter","ConsoleAdapter","customLevels","silent","logger","skipBuild","transpiler","SwcTranspiler","warmedProjects","Set","transformCache","Map","workspace","initWorkspace","debug","WorkspaceFactory","create","WorkspaceDefaults","rootDir","preWarmProject","project","has","projectDirectory","add","transformProject","then","name","catch","err","error","message","enforce","configResolved","resolveId","source","importer","endsWith","startsWith","importerDirectory","path","dirname","withoutExtension","slice","candidates","map","ext","resolve","find","c","existsSync","watchChange","id","file","FileEx","fullPath","delete","invalidateContentCache","transform","code","includes","test","findProject","cached","get","undefined","content","result","response","transformFile","BuildTargets","es6","aliasPaths","tsConfig","getTsConfig","outcome","set"],"mappings":"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"}

package/commonjs/src/vitest/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "forgeBuild", {
+    enumerable: true,
+    get: function() {
+        return _forgebuildplugin.forgeBuild;
+    }
+});
+const _forgebuildplugin = require("./forge-build.plugin.js");
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL3ZpdGVzdC9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEZvcmdlQnVpbGRPcHRpb25zIH0gZnJvbSBcIi4vZm9yZ2UtYnVpbGQucGx1Z2luLmpzXCI7XG5leHBvcnQgeyBmb3JnZUJ1aWxkIH0gZnJvbSBcIi4vZm9yZ2UtYnVpbGQucGx1Z2luLmpzXCI7XG4iXSwibmFtZXMiOlsiZm9yZ2VCdWlsZCJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFDU0E7OztlQUFBQSw0QkFBVTs7O2tDQUFRIn0=

package/commonjs/src/workspace.config.js

@@ -0,0 +1,73 @@
+"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 Debug () {
+        return Debug;
+    },
+    get DefaultConfigurations () {
+        return DefaultConfigurations;
+    },
+    get Release () {
+        return Release;
+    },
+    get WorkspaceDefaults () {
+        return WorkspaceDefaults;
+    }
+});
+const _mesh = require("@decohere/mesh");
+const _const = require("./const.js");
+const _buildtargettype = require("./types/build-target.type.js");
+const Debug = {
+    name: "debug",
+    targets: [
+        _buildtargettype.BuildTargets.es6
+    ],
+    aliasPaths: true
+};
+const Release = {
+    name: "release",
+    pack: true,
+    targets: [
+        _buildtargettype.BuildTargets.commonjs,
+        _buildtargettype.BuildTargets.es6,
+        _buildtargettype.BuildTargets.types
+    ],
+    ignore: [
+        "**/*.spec.ts",
+        "**/*.test.ts",
+        "tests/**",
+        "e2e/**"
+    ]
+};
+const DefaultConfigurations = [
+    Debug,
+    Release
+];
+const WorkspaceDefaults = {
+    rootDir: _mesh.WorkspaceDefaults.rootDir,
+    outDir: _mesh.WorkspaceDefaults.outDir,
+    includeProjects: _mesh.WorkspaceDefaults.includeProjects,
+    ignoreProjects: _mesh.WorkspaceDefaults.ignoreProjects,
+    include: [
+        "**/*.ts"
+    ],
+    ignore: [
+        "**/*.d.ts",
+        `**/${_const.NODE_MODULES}/**`
+    ],
+    copyFiles: [
+        "package.json",
+        "**/*.mjs"
+    ],
+    configurations: DefaultConfigurations
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,100 @@
+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);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { inject, injectable } from "@decohere/crucible/decorators";
+// biome-ignore lint/style/useImportType: <DI>
+import { Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { Trace } from "@decohere/nexus/diagnostics";
+import { scribe } from "@decohere/scribe";
+import { ForgeError } from "../errors.js";
+// biome-ignore lint/style/useImportType: <DI>
+import { FileWriterService } from "../services/file-writer.service.js";
+import { TransformerKey } from "../types/transformer.type.js";
+export class Build {
+    workspace;
+    transformers;
+    fileWriter;
+    #logger = scribe.logger(Build.name);
+    constructor(workspace, transformers, fileWriter){
+        this.workspace = workspace;
+        this.transformers = transformers;
+        this.fileWriter = fileWriter;
+        if (!transformers || transformers.length === 0) {
+            throw new ForgeError("At least one transformer is required");
+        }
+    }
+    run = async (options)=>{
+        const { configuration: buildConfig } = options;
+        const projects = this.workspace.getProjects(buildConfig);
+        void this.fileWriter.warmup([
+            ...projects
+        ]);
+        const transformResults = await this.build(projects);
+        const errors = transformResults.filter((response)=>response.outcome === "failure");
+        if (errors.length > 0) {
+            const messages = transformResults.map((responses)=>responses.messages).join("\n");
+            throw new ForgeError(`Error building: ${messages}`);
+        }
+        for (const transformer of this.transformers){
+            if (transformer.watch && transformer.incrementalTransform$) {
+                transformer.watch(this.workspace);
+                transformer.incrementalTransform$.subscribe((responses)=>{
+                    this.fileWriter.enqueueOutputs(responses);
+                    void this.writeOutput();
+                });
+            }
+        }
+        return ActionResponse.Success(Build.name, transformResults);
+    };
+    async build(projectArrayLike) {
+        const projects = Array.isArray(projectArrayLike) ? projectArrayLike : [
+            projectArrayLike
+        ];
+        for (const project of projects){
+            this.#logger.info(`Building ${project.name}`);
+        }
+        return this.runTransformers(projects);
+    }
+    async runTransformers(projects, fileFilter) {
+        // Phase 1: sequential init — runs expensive setup (e.g. TypeScript createProgram)
+        // before any transformer's parallel workload (e.g. SWC/Rayon) starts.
+        for (const transformer of this.transformers){
+            await transformer.init?.(projects, fileFilter);
+        }
+        // Phase 2: parallel transform — all transformers run concurrently now that
+        // CPU-heavy init is complete.
+        const allResponses = (await Promise.all(this.transformers.map((t)=>t.transformProject(projects, fileFilter, (response)=>{
+                this.fileWriter.enqueueOutput(response);
+            })))).flat();
+        await this.writeOutput();
+        return allResponses;
+    }
+    async writeOutput() {
+        await this.fileWriter.flush();
+    }
+}
+Build = _ts_decorate([
+    Trace,
+    injectable(),
+    _ts_param(1, inject(TransformerKey)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace,
+        Array,
+        typeof FileWriterService === "undefined" ? Object : FileWriterService
+    ])
+], Build);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/actions/build.action.ts"],"sourcesContent":["import { inject, injectable } from \"@decohere/crucible/decorators\";\nimport type { Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { Trace } from \"@decohere/nexus/diagnostics\";\nimport type { FileEx } from \"@decohere/nexus/io\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError } from \"../errors.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { FileWriterService } from \"../services/file-writer.service.js\";\nimport type { TransformResponse } from \"../types/transform-response.model.js\";\nimport { type Transformer, TransformerKey } from \"../types/transformer.type.js\";\n\nexport type BuildOptions = {\n\tconfiguration: string;\n\tfile: string;\n};\n\n@Trace\n@injectable()\nexport class Build implements Action<BuildOptions> {\n\t#logger = scribe.logger(Build.name);\n\tpublic constructor(\n\t\tprivate readonly workspace: Workspace,\n\t\t@inject(TransformerKey) private readonly transformers: Transformer[],\n\t\tprivate readonly fileWriter: FileWriterService,\n\t) {\n\t\tif (!transformers || transformers.length === 0) {\n\t\t\tthrow new ForgeError(\"At least one transformer is required\");\n\t\t}\n\t}\n\n\tpublic run = async (options: BuildOptions): Promise<ActionResponse<TransformResponse>> => {\n\t\tconst { configuration: buildConfig } = options;\n\t\tconst projects = this.workspace.getProjects(buildConfig);\n\t\tvoid this.fileWriter.warmup([...projects]);\n\t\tconst transformResults = await this.build(projects);\n\n\t\tconst errors = transformResults.filter((response) => response.outcome === \"failure\");\n\t\tif (errors.length > 0) {\n\t\t\tconst messages = transformResults.map((responses) => responses.messages).join(\"\\n\");\n\t\t\tthrow new ForgeError(`Error building: ${messages}`);\n\t\t}\n\n\t\tfor (const transformer of this.transformers) {\n\t\t\tif (transformer.watch && transformer.incrementalTransform$) {\n\t\t\t\ttransformer.watch(this.workspace);\n\t\t\t\ttransformer.incrementalTransform$.subscribe((responses) => {\n\t\t\t\t\tthis.fileWriter.enqueueOutputs(responses);\n\t\t\t\t\tvoid this.writeOutput();\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn ActionResponse.Success(Build.name, transformResults);\n\t};\n\n\tpublic async build(\n\t\tprojectArrayLike: readonly Project[] | Project,\n\t): Promise<TransformResponse[]> {\n\t\tconst projects: Project[] = Array.isArray(projectArrayLike)\n\t\t\t? projectArrayLike\n\t\t\t: [projectArrayLike];\n\t\tfor (const project of projects) {\n\t\t\tthis.#logger.info(`Building ${project.name}`);\n\t\t}\n\t\treturn this.runTransformers(projects);\n\t}\n\n\tprivate async runTransformers(\n\t\tprojects: Project | Project[],\n\t\tfileFilter?: (project: Project) => Promise<FileEx[]>,\n\t) {\n\t\t// Phase 1: sequential init — runs expensive setup (e.g. TypeScript createProgram)\n\t\t// before any transformer's parallel workload (e.g. SWC/Rayon) starts.\n\t\tfor (const transformer of this.transformers) {\n\t\t\tawait transformer.init?.(projects, fileFilter);\n\t\t}\n\t\t// Phase 2: parallel transform — all transformers run concurrently now that\n\t\t// CPU-heavy init is complete.\n\t\tconst allResponses = (\n\t\t\tawait Promise.all(\n\t\t\t\tthis.transformers.map((t) =>\n\t\t\t\t\tt.transformProject(projects, fileFilter, (response) => {\n\t\t\t\t\t\tthis.fileWriter.enqueueOutput(response);\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\t)\n\t\t).flat();\n\t\tawait this.writeOutput();\n\t\treturn allResponses;\n\t}\n\n\tprivate async writeOutput() {\n\t\tawait this.fileWriter.flush();\n\t}\n}\n"],"names":["inject","injectable","Workspace","ActionResponse","Trace","scribe","ForgeError","FileWriterService","TransformerKey","Build","logger","name","workspace","transformers","fileWriter","length","run","options","configuration","buildConfig","projects","getProjects","warmup","transformResults","build","errors","filter","response","outcome","messages","map","responses","join","transformer","watch","incrementalTransform$","subscribe","enqueueOutputs","writeOutput","Success","projectArrayLike","Array","isArray","project","info","runTransformers","fileFilter","init","allResponses","Promise","all","t","transformProject","enqueueOutput","flat","flush"],"mappings":"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"}

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

@@ -0,0 +1,46 @@
+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";
+// biome-ignore lint/style/useImportType: <DI>
+import { Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { io } from "@decohere/nexus/io";
+import { scribe } from "@decohere/scribe";
+export class Clean {
+    workspace;
+    #logger = scribe.logger(Clean.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        if (!options.clean) {
+            this.#logger.info("Skipping clean");
+            return ActionResponse.Skipped(Clean.name);
+        }
+        await Promise.all(this.workspace.getProjects(options.configuration).map(async (proj)=>{
+            const outDir = proj.getRootOut();
+            await io.removeDir(outDir, {
+                force: true,
+                recursive: true
+            });
+            this.#logger.trace(`Cleaned ${outDir}`);
+        }));
+        return ActionResponse.Success(Clean.name);
+    };
+}
+Clean = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Clean);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,71 @@
+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";
+// biome-ignore lint/style/useImportType: <DI>
+import { Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { Git } from "@decohere/nexus/interop";
+import { scribe } from "@decohere/scribe";
+import { formatUnknownError } from "../errors.js";
+import { Release } from "../workspace.config.js";
+const KnownLockFiles = [
+    "pnpm-lock.yaml"
+];
+export class CommitFiles {
+    workspace;
+    #logger = scribe.logger(CommitFiles.name);
+    #git = new Git();
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        if (!options.commit) {
+            return ActionResponse.Skipped(CommitFiles.name);
+        }
+        if (options.dryRun) {
+            this.#logger.info("[dry-run] Skipping commit");
+            return ActionResponse.Skipped(CommitFiles.name);
+        }
+        const files = options.files ?? this.getDefaultFiles(options.configuration ?? Release.name);
+        if (files.length === 0) {
+            this.#logger.info("No files provided for commit, skipping");
+            return ActionResponse.Skipped(CommitFiles.name);
+        }
+        const message = options.message ?? "chore: sync workspace package manifests [skip ci]";
+        this.#logger.info(`Committing synced manifests: ${message}`);
+        try {
+            await this.#git.commit(message, {
+                files
+            });
+            return ActionResponse.Success(CommitFiles.name);
+        } catch (reason) {
+            return ActionResponse.Error(CommitFiles.name, `Failed committing files: ${formatUnknownError(reason)}`);
+        }
+    }
+    getDefaultFiles(configuration) {
+        const manifestFiles = [
+            this.workspace.packageJsonPath,
+            ...this.workspace.getProjects(configuration).map((project)=>project.packageJsonPath)
+        ];
+        return [
+            ...manifestFiles,
+            ...KnownLockFiles
+        ];
+    }
+}
+CommitFiles = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], CommitFiles);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,69 @@
+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 path 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 { io } from "@decohere/nexus/io";
+import { retry } from "@decohere/nexus/system";
+import { scribe } from "@decohere/scribe";
+const COPY_RETRY_ATTEMPTS = 3;
+const COPY_RETRY_DELAY_MS = 25;
+export class Copy {
+    workspace;
+    #logger = scribe.logger(Copy.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        if (!options.copy) {
+            this.#logger.info("Skipping copy");
+            return ActionResponse.Skipped(Copy.name);
+        }
+        await Promise.all(this.workspace.getProjects(options.configuration).map(async (proj)=>{
+            const outDir = proj.getOutDir();
+            const pattern = proj.copyFiles;
+            const files = await io.findFiles(pattern, {
+                cwd: proj.projectDirectory
+            });
+            await Promise.all(files.map((file)=>this.copyFileToOut(file, outDir)));
+        }));
+        return ActionResponse.Success(Copy.name);
+    };
+    async copyFileToOut(file, outDir) {
+        const dest = path.join(outDir, file.relativePath);
+        await io.copyFile(file.fullPath, dest, {
+            mkdir: true
+        });
+        this.#logger.trace(`Copied ${file.fullPath} -> ${dest}`);
+    }
+}
+_ts_decorate([
+    retry({
+        attempts: COPY_RETRY_ATTEMPTS,
+        delayMs: COPY_RETRY_DELAY_MS
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof FileEx === "undefined" ? Object : FileEx,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], Copy.prototype, "copyFileToOut", null);
+Copy = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Copy);
+
+//# sourceMappingURL=data:application/json;base64,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