@decohere/forge 0.0.1-dev.5

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Build", {
+    enumerable: true,
+    get: function() {
+        return Build;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _diagnostics = require("@decohere/nexus/diagnostics");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+const _filewriterservice = require("../services/file-writer.service.js");
+const _transformertype = require("../types/transformer.type.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);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+class Build {
+    workspace;
+    transformers;
+    fileWriter;
+    #logger = _scribe.scribe.logger(Build.name);
+    constructor(workspace, transformers, fileWriter){
+        this.workspace = workspace;
+        this.transformers = transformers;
+        this.fileWriter = fileWriter;
+        if (!transformers || transformers.length === 0) {
+            throw new _errors.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 _errors.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 _cli.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([
+    _diagnostics.Trace,
+    (0, _decorators.injectable)(),
+    _ts_param(1, (0, _decorators.inject)(_transformertype.TransformerKey)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace,
+        Array,
+        typeof _filewriterservice.FileWriterService === "undefined" ? Object : _filewriterservice.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":["Build","scribe","logger","name","workspace","transformers","fileWriter","length","ForgeError","run","options","configuration","buildConfig","projects","getProjects","warmup","transformResults","build","errors","filter","response","outcome","messages","map","responses","join","transformer","watch","incrementalTransform$","subscribe","enqueueOutputs","writeOutput","ActionResponse","Success","projectArrayLike","Array","isArray","project","info","runTransformers","fileFilter","init","allResponses","Promise","all","t","transformProject","enqueueOutput","flat","flush"],"mappings":";;;;+BAsBaA;;;eAAAA;;;4BAtBsB;sBAGT;qBAEK;6BACT;wBAEC;wBACI;mCAEO;iCAEe;;;;;;;;;;;;;;;AAS1C,MAAMA;;;;IACZ,CAAA,MAAO,GAAGC,cAAM,CAACC,MAAM,CAACF,MAAMG,IAAI,EAAE;IACpC,YACC,AAAiBC,SAAoB,EACrC,AAAyCC,YAA2B,EACpE,AAAiBC,UAA6B,CAC7C;aAHgBF,YAAAA;aACwBC,eAAAA;aACxBC,aAAAA;QAEjB,IAAI,CAACD,gBAAgBA,aAAaE,MAAM,KAAK,GAAG;YAC/C,MAAM,IAAIC,kBAAU,CAAC;QACtB;IACD;IAEOC,MAAM,OAAOC;QACnB,MAAM,EAAEC,eAAeC,WAAW,EAAE,GAAGF;QACvC,MAAMG,WAAW,IAAI,CAACT,SAAS,CAACU,WAAW,CAACF;QAC5C,KAAK,IAAI,CAACN,UAAU,CAACS,MAAM,CAAC;eAAIF;SAAS;QACzC,MAAMG,mBAAmB,MAAM,IAAI,CAACC,KAAK,CAACJ;QAE1C,MAAMK,SAASF,iBAAiBG,MAAM,CAAC,CAACC,WAAaA,SAASC,OAAO,KAAK;QAC1E,IAAIH,OAAOX,MAAM,GAAG,GAAG;YACtB,MAAMe,WAAWN,iBAAiBO,GAAG,CAAC,CAACC,YAAcA,UAAUF,QAAQ,EAAEG,IAAI,CAAC;YAC9E,MAAM,IAAIjB,kBAAU,CAAC,CAAC,gBAAgB,EAAEc,UAAU;QACnD;QAEA,KAAK,MAAMI,eAAe,IAAI,CAACrB,YAAY,CAAE;YAC5C,IAAIqB,YAAYC,KAAK,IAAID,YAAYE,qBAAqB,EAAE;gBAC3DF,YAAYC,KAAK,CAAC,IAAI,CAACvB,SAAS;gBAChCsB,YAAYE,qBAAqB,CAACC,SAAS,CAAC,CAACL;oBAC5C,IAAI,CAAClB,UAAU,CAACwB,cAAc,CAACN;oBAC/B,KAAK,IAAI,CAACO,WAAW;gBACtB;YACD;QACD;QAEA,OAAOC,mBAAc,CAACC,OAAO,CAACjC,MAAMG,IAAI,EAAEa;IAC3C,EAAE;IAEF,MAAaC,MACZiB,gBAA8C,EACf;QAC/B,MAAMrB,WAAsBsB,MAAMC,OAAO,CAACF,oBACvCA,mBACA;YAACA;SAAiB;QACrB,KAAK,MAAMG,WAAWxB,SAAU;YAC/B,IAAI,CAAC,CAAA,MAAO,CAACyB,IAAI,CAAC,CAAC,SAAS,EAAED,QAAQlC,IAAI,EAAE;QAC7C;QACA,OAAO,IAAI,CAACoC,eAAe,CAAC1B;IAC7B;IAEA,MAAc0B,gBACb1B,QAA6B,EAC7B2B,UAAoD,EACnD;QACD,kFAAkF;QAClF,sEAAsE;QACtE,KAAK,MAAMd,eAAe,IAAI,CAACrB,YAAY,CAAE;YAC5C,MAAMqB,YAAYe,IAAI,GAAG5B,UAAU2B;QACpC;QACA,2EAA2E;QAC3E,8BAA8B;QAC9B,MAAME,eAAe,AACpB,CAAA,MAAMC,QAAQC,GAAG,CAChB,IAAI,CAACvC,YAAY,CAACkB,GAAG,CAAC,CAACsB,IACtBA,EAAEC,gBAAgB,CAACjC,UAAU2B,YAAY,CAACpB;gBACzC,IAAI,CAACd,UAAU,CAACyC,aAAa,CAAC3B;YAC/B,IAEF,EACC4B,IAAI;QACN,MAAM,IAAI,CAACjB,WAAW;QACtB,OAAOW;IACR;IAEA,MAAcX,cAAc;QAC3B,MAAM,IAAI,CAACzB,UAAU,CAAC2C,KAAK;IAC5B;AACD"}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Clean", {
+    enumerable: true,
+    get: function() {
+        return Clean;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _io = require("@decohere/nexus/io");
+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 Clean {
+    workspace;
+    #logger = _scribe.scribe.logger(Clean.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        if (!options.clean) {
+            this.#logger.info("Skipping clean");
+            return _cli.ActionResponse.Skipped(Clean.name);
+        }
+        await Promise.all(this.workspace.getProjects(options.configuration).map(async (proj)=>{
+            const outDir = proj.getRootOut();
+            await _io.io.removeDir(outDir, {
+                force: true,
+                recursive: true
+            });
+            this.#logger.trace(`Cleaned ${outDir}`);
+        }));
+        return _cli.ActionResponse.Success(Clean.name);
+    };
+}
+Clean = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Clean);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CommitFiles", {
+    enumerable: true,
+    get: function() {
+        return CommitFiles;
+    }
+});
+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");
+const _workspaceconfig = require("../workspace.config.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 KnownLockFiles = [
+    "pnpm-lock.yaml"
+];
+class CommitFiles {
+    workspace;
+    #logger = _scribe.scribe.logger(CommitFiles.name);
+    #git = new _interop.Git();
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        if (!options.commit) {
+            return _cli.ActionResponse.Skipped(CommitFiles.name);
+        }
+        if (options.dryRun) {
+            this.#logger.info("[dry-run] Skipping commit");
+            return _cli.ActionResponse.Skipped(CommitFiles.name);
+        }
+        const files = options.files ?? this.getDefaultFiles(options.configuration ?? _workspaceconfig.Release.name);
+        if (files.length === 0) {
+            this.#logger.info("No files provided for commit, skipping");
+            return _cli.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 _cli.ActionResponse.Success(CommitFiles.name);
+        } catch (reason) {
+            return _cli.ActionResponse.Error(CommitFiles.name, `Failed committing files: ${(0, _errors.formatUnknownError)(reason)}`);
+        }
+    }
+    getDefaultFiles(configuration) {
+        const manifestFiles = [
+            this.workspace.packageJsonPath,
+            ...this.workspace.getProjects(configuration).map((project)=>project.packageJsonPath)
+        ];
+        return [
+            ...manifestFiles,
+            ...KnownLockFiles
+        ];
+    }
+}
+CommitFiles = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], CommitFiles);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Copy", {
+    enumerable: true,
+    get: function() {
+        return Copy;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _io = require("@decohere/nexus/io");
+const _system = require("@decohere/nexus/system");
+const _scribe = require("@decohere/scribe");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+const COPY_RETRY_ATTEMPTS = 3;
+const COPY_RETRY_DELAY_MS = 25;
+class Copy {
+    workspace;
+    #logger = _scribe.scribe.logger(Copy.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        if (!options.copy) {
+            this.#logger.info("Skipping copy");
+            return _cli.ActionResponse.Skipped(Copy.name);
+        }
+        await Promise.all(this.workspace.getProjects(options.configuration).map(async (proj)=>{
+            const outDir = proj.getOutDir();
+            const pattern = proj.copyFiles;
+            const files = await _io.io.findFiles(pattern, {
+                cwd: proj.projectDirectory
+            });
+            await Promise.all(files.map((file)=>this.copyFileToOut(file, outDir)));
+        }));
+        return _cli.ActionResponse.Success(Copy.name);
+    };
+    async copyFileToOut(file, outDir) {
+        const dest = _nodepath.default.join(outDir, file.relativePath);
+        await _io.io.copyFile(file.fullPath, dest, {
+            mkdir: true
+        });
+        this.#logger.trace(`Copied ${file.fullPath} -> ${dest}`);
+    }
+}
+_ts_decorate([
+    (0, _system.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([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Copy);
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/actions/dependency-report.action.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReportDependencies", {
+    enumerable: true,
+    get: function() {
+        return ReportDependencies;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _io = require("@decohere/nexus/io");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+const _dependencyresolverservice = require("../services/dependency-resolver.service.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 ReportDependencies {
+    workspace;
+    resolver;
+    #logger = _scribe.scribe.logger(ReportDependencies.name);
+    constructor(workspace, resolver){
+        this.workspace = workspace;
+        this.resolver = resolver;
+    }
+    async run(options) {
+        const { configuration, file, failOnDrift } = options;
+        try {
+            const projectDeps = await this.analyzeWorkspace(this.workspace, configuration);
+            this.logReport(projectDeps);
+            if (file) {
+                await this.writeReportFile(file, projectDeps);
+            }
+            if (failOnDrift) {
+                const driftReport = this.buildDriftReport(projectDeps);
+                this.throwOnDrift(driftReport);
+            }
+            return _cli.ActionResponse.Success(ReportDependencies.name, projectDeps);
+        } catch (error) {
+            const message = (0, _errors.formatUnknownError)(error);
+            return _cli.ActionResponse.Error(ReportDependencies.name, message);
+        }
+    }
+    async analyzeWorkspace(workspace, configuration) {
+        const projects = workspace.getProjects(configuration);
+        const workspacePackages = await this.resolver.getWorkspacePackages(this.workspace, projects);
+        return Promise.all(projects.map((project)=>this.analyzeProject(project, workspacePackages)));
+    }
+    async analyzeProject(project, workspacePackages) {
+        const { entry, currentPackage, updatedPackage, warnings } = await this.getDependencies(project, workspacePackages);
+        const drift = this.resolver.computeDrift(currentPackage, updatedPackage);
+        return {
+            projectName: project.name,
+            entry,
+            drift,
+            warnings
+        };
+    }
+    async getDependencies(project, workspacePackages) {
+        const currentPackage = await project.getPackageJson();
+        const { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(project, workspacePackages);
+        const entry = {
+            projectName: project.name,
+            dependencies: Object.keys(updatedPackage.dependencies ?? {}),
+            devDependencies: Object.keys(updatedPackage.devDependencies ?? {})
+        };
+        return {
+            entry,
+            currentPackage,
+            updatedPackage,
+            warnings
+        };
+    }
+    buildDriftReport(reports) {
+        return Object.fromEntries(reports.filter((r)=>r.drift != null).map((r)=>[
+                r.projectName,
+                r.drift
+            ]));
+    }
+    throwOnDrift(driftReport) {
+        const driftedProjects = Object.keys(driftReport);
+        if (driftedProjects.length > 0) {
+            for (const [projectName, drift] of Object.entries(driftReport)){
+                this.#logger.warn(`Dependency drift in '${projectName}'`, {
+                    original: drift.original,
+                    updated: drift.updated
+                });
+            }
+            throw new Error(`Dependency drift detected in: ${driftedProjects.join(", ")}`);
+        }
+    }
+    logReport(reports) {
+        for (const { entry, warnings } of reports){
+            this.#logger.info(`${entry.projectName}:`);
+            if (entry.dependencies.length) {
+                this.#logger.info(`  dependencies: ${entry.dependencies.join(", ")}`);
+            }
+            if (entry.devDependencies.length) {
+                this.#logger.info(`  devDependencies: ${entry.devDependencies.join(", ")}`);
+            }
+            for (const warning of warnings){
+                this.#logger.warn(`  warning: ${warning.file}:${warning.line}: ${warning.message}`);
+            }
+        }
+    }
+    async writeReportFile(file, reports) {
+        const lines = reports.flatMap(({ entry, warnings })=>[
+                `${entry.projectName}:`,
+                ...entry.dependencies.length ? [
+                    `  dependencies: ${entry.dependencies.join(", ")}`
+                ] : [],
+                ...entry.devDependencies.length ? [
+                    `  devDependencies: ${entry.devDependencies.join(", ")}`
+                ] : [],
+                ...warnings.map((w)=>`  warning: ${w.file}:${w.line}: ${w.message}`),
+                ""
+            ]);
+        await _io.io.writeFile(file, lines.join("\n"), {
+            mkdir: true
+        });
+        this.#logger.info(`Report written to ${file}`);
+    }
+}
+ReportDependencies = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace,
+        typeof _dependencyresolverservice.DependencyResolver === "undefined" ? Object : _dependencyresolverservice.DependencyResolver
+    ])
+], ReportDependencies);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/actions/dependency-report.action.ts"],"sourcesContent":["import { injectable } from \"@decohere/crucible/decorators\";\nimport type { PackageJson, Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { io } from \"@decohere/nexus/io\";\nimport { scribe } from \"@decohere/scribe\";\nimport { formatUnknownError } from \"../errors.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { DependencyResolver } from \"../services/dependency-resolver.service.js\";\nimport type { DependencyWarning, DriftEntry, Package } from \"../types/dependency.types.js\";\n\ntype ReportOptions = {\n\tconfiguration: string;\n\tfile?: string;\n\tfailOnDrift?: boolean;\n};\n\ntype ReportEntry = {\n\tprojectName: string;\n\tdependencies: string[];\n\tdevDependencies: string[];\n};\n\ntype DriftReport = Record<string, DriftEntry>;\n\ntype ProjectReport = {\n\tprojectName: string;\n\tentry: ReportEntry;\n\tdrift: DriftEntry | null;\n\twarnings: DependencyWarning[];\n};\n\n@injectable()\nexport class ReportDependencies implements Action<ReportOptions> {\n\t#logger = scribe.logger(ReportDependencies.name);\n\n\tpublic constructor(\n\t\tprivate readonly workspace: Workspace,\n\t\tprivate readonly resolver: DependencyResolver,\n\t) {}\n\n\tpublic async run(options: ReportOptions): Promise<ActionResponse<ProjectReport>> {\n\t\tconst { configuration, file, failOnDrift } = options;\n\n\t\ttry {\n\t\t\tconst projectDeps = await this.analyzeWorkspace(this.workspace, configuration);\n\t\t\tthis.logReport(projectDeps);\n\n\t\t\tif (file) {\n\t\t\t\tawait this.writeReportFile(file, projectDeps);\n\t\t\t}\n\n\t\t\tif (failOnDrift) {\n\t\t\t\tconst driftReport = this.buildDriftReport(projectDeps);\n\t\t\t\tthis.throwOnDrift(driftReport);\n\t\t\t}\n\n\t\t\treturn ActionResponse.Success(ReportDependencies.name, projectDeps);\n\t\t} catch (error) {\n\t\t\tconst message = formatUnknownError(error);\n\t\t\treturn ActionResponse.Error<ProjectReport>(ReportDependencies.name, message);\n\t\t}\n\t}\n\n\tprivate async analyzeWorkspace(\n\t\tworkspace: Workspace,\n\t\tconfiguration: string,\n\t): Promise<ProjectReport[]> {\n\t\tconst projects = workspace.getProjects(configuration);\n\t\tconst workspacePackages = await this.resolver.getWorkspacePackages(\n\t\t\tthis.workspace,\n\t\t\tprojects,\n\t\t);\n\t\treturn Promise.all(\n\t\t\tprojects.map((project) => this.analyzeProject(project, workspacePackages)),\n\t\t);\n\t}\n\n\tprivate async analyzeProject(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<ProjectReport> {\n\t\tconst { entry, currentPackage, updatedPackage, warnings } = await this.getDependencies(\n\t\t\tproject,\n\t\t\tworkspacePackages,\n\t\t);\n\t\tconst drift = this.resolver.computeDrift(currentPackage, updatedPackage);\n\t\treturn { projectName: project.name, entry, drift, warnings };\n\t}\n\n\tprivate async getDependencies(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<{\n\t\tentry: ReportEntry;\n\t\tcurrentPackage: PackageJson;\n\t\tupdatedPackage: PackageJson;\n\t\twarnings: DependencyWarning[];\n\t}> {\n\t\tconst currentPackage = await project.getPackageJson();\n\t\tconst { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(\n\t\t\tproject,\n\t\t\tworkspacePackages,\n\t\t);\n\n\t\tconst entry: ReportEntry = {\n\t\t\tprojectName: project.name,\n\t\t\tdependencies: Object.keys(updatedPackage.dependencies ?? {}),\n\t\t\tdevDependencies: Object.keys(updatedPackage.devDependencies ?? {}),\n\t\t};\n\n\t\treturn { entry, currentPackage, updatedPackage, warnings };\n\t}\n\n\tprivate buildDriftReport(reports: ProjectReport[]): DriftReport {\n\t\treturn Object.fromEntries(\n\t\t\treports\n\t\t\t\t.filter((r): r is ProjectReport & { drift: DriftEntry } => r.drift != null)\n\t\t\t\t.map((r) => [r.projectName, r.drift]),\n\t\t);\n\t}\n\n\tprivate throwOnDrift(driftReport: DriftReport): void {\n\t\tconst driftedProjects = Object.keys(driftReport);\n\t\tif (driftedProjects.length > 0) {\n\t\t\tfor (const [projectName, drift] of Object.entries(driftReport)) {\n\t\t\t\tthis.#logger.warn(`Dependency drift in '${projectName}'`, {\n\t\t\t\t\toriginal: drift.original,\n\t\t\t\t\tupdated: drift.updated,\n\t\t\t\t});\n\t\t\t}\n\t\t\tthrow new Error(`Dependency drift detected in: ${driftedProjects.join(\", \")}`);\n\t\t}\n\t}\n\n\tprivate logReport(reports: ProjectReport[]) {\n\t\tfor (const { entry, warnings } of reports) {\n\t\t\tthis.#logger.info(`${entry.projectName}:`);\n\t\t\tif (entry.dependencies.length) {\n\t\t\t\tthis.#logger.info(`  dependencies: ${entry.dependencies.join(\", \")}`);\n\t\t\t}\n\t\t\tif (entry.devDependencies.length) {\n\t\t\t\tthis.#logger.info(`  devDependencies: ${entry.devDependencies.join(\", \")}`);\n\t\t\t}\n\t\t\tfor (const warning of warnings) {\n\t\t\t\tthis.#logger.warn(`  warning: ${warning.file}:${warning.line}: ${warning.message}`);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate async writeReportFile(file: string, reports: ProjectReport[]) {\n\t\tconst lines = reports.flatMap(({ entry, warnings }) => [\n\t\t\t`${entry.projectName}:`,\n\t\t\t...(entry.dependencies.length\n\t\t\t\t? [`  dependencies: ${entry.dependencies.join(\", \")}`]\n\t\t\t\t: []),\n\t\t\t...(entry.devDependencies.length\n\t\t\t\t? [`  devDependencies: ${entry.devDependencies.join(\", \")}`]\n\t\t\t\t: []),\n\t\t\t...warnings.map((w) => `  warning: ${w.file}:${w.line}: ${w.message}`),\n\t\t\t\"\",\n\t\t]);\n\t\tawait io.writeFile(file, lines.join(\"\\n\"), { mkdir: true });\n\t\tthis.#logger.info(`Report written to ${file}`);\n\t}\n}\n"],"names":["ReportDependencies","scribe","logger","name","workspace","resolver","run","options","configuration","file","failOnDrift","projectDeps","analyzeWorkspace","logReport","writeReportFile","driftReport","buildDriftReport","throwOnDrift","ActionResponse","Success","error","message","formatUnknownError","Error","projects","getProjects","workspacePackages","getWorkspacePackages","Promise","all","map","project","analyzeProject","entry","currentPackage","updatedPackage","warnings","getDependencies","drift","computeDrift","projectName","getPackageJson","computeProjectDependencies","dependencies","Object","keys","devDependencies","reports","fromEntries","filter","r","driftedProjects","length","entries","warn","original","updated","join","info","warning","line","lines","flatMap","w","io","writeFile","mkdir"],"mappings":"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"}

package/commonjs/src/actions/dependency-sync.action.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SyncDependencies", {
+    enumerable: true,
+    get: function() {
+        return SyncDependencies;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+const _dependencyresolverservice = require("../services/dependency-resolver.service.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 SyncDependencies {
+    workspace;
+    resolver;
+    #logger = _scribe.scribe.logger(SyncDependencies.name);
+    constructor(workspace, resolver){
+        this.workspace = workspace;
+        this.resolver = resolver;
+    }
+    async run(options) {
+        const { configuration, logDiff } = options;
+        const projects = this.workspace.getProjects(configuration);
+        const workspacePackages = await this.resolver.getWorkspacePackages(this.workspace, projects);
+        const computed = await Promise.all(projects.map((project)=>this.computeDependenciesFor(project, workspacePackages)));
+        const results = computed.map((c)=>c.syncResult);
+        if (results.some((r)=>!r.succeeded)) {
+            return _cli.ActionResponse.Error(SyncDependencies.name, results);
+        }
+        const succeeded = computed.filter((c)=>c.succeeded);
+        await Promise.all(succeeded.map((c)=>c.project.persistPackageJson(c.updatedPackage)));
+        const syncResults = succeeded.map((c)=>{
+            const drift = this.resolver.computeDrift(c.originalPackage, c.updatedPackage);
+            if (drift && logDiff) {
+                this.#logger.warn(`Dependency drift synced in '${c.syncResult.projectName}'`, drift);
+            }
+            return {
+                ...c.syncResult,
+                drift
+            };
+        });
+        const failedResults = results.filter((r)=>!r.succeeded);
+        return _cli.ActionResponse.Success(SyncDependencies.name, [
+            ...syncResults,
+            ...failedResults
+        ]);
+    }
+    async computeDependenciesFor(project, workspacePackages) {
+        try {
+            const originalPackage = await project.getPackageJson();
+            const { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(project, workspacePackages);
+            for (const warning of warnings){
+                this.#logger.warn(`${warning.file}:${warning.line}: ${warning.message}`);
+            }
+            return {
+                succeeded: true,
+                syncResult: {
+                    projectName: project.name,
+                    succeeded: true
+                },
+                project,
+                originalPackage,
+                updatedPackage
+            };
+        } catch (error) {
+            const message = (0, _errors.formatUnknownError)(error);
+            return {
+                succeeded: false,
+                syncResult: {
+                    projectName: project.name,
+                    error: `${project.name}: ${message}`,
+                    succeeded: false
+                }
+            };
+        }
+    }
+}
+SyncDependencies = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace,
+        typeof _dependencyresolverservice.DependencyResolver === "undefined" ? Object : _dependencyresolverservice.DependencyResolver
+    ])
+], SyncDependencies);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/actions/dependency-sync.action.ts"],"sourcesContent":["import { injectable } from \"@decohere/crucible/decorators\";\nimport type { PackageJson, Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { scribe } from \"@decohere/scribe\";\nimport { formatUnknownError } from \"../errors.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { DependencyResolver } from \"../services/dependency-resolver.service.js\";\nimport type { Package, SyncprojectResult } from \"../types/dependency.types.js\";\n\nexport type DependenciesOptions = {\n\tconfiguration: string;\n\tlogDiff?: boolean;\n};\n\ntype SyncComputed =\n\t| { succeeded: false; syncResult: SyncprojectResult }\n\t| {\n\t\t\tsucceeded: true;\n\t\t\tsyncResult: SyncprojectResult;\n\t\t\tproject: Project;\n\t\t\toriginalPackage: PackageJson;\n\t\t\tupdatedPackage: PackageJson;\n\t  };\n\n@injectable()\nexport class SyncDependencies implements Action<DependenciesOptions> {\n\t#logger = scribe.logger(SyncDependencies.name);\n\n\tpublic constructor(\n\t\tprivate readonly workspace: Workspace,\n\t\tprivate readonly resolver: DependencyResolver,\n\t) {}\n\n\tpublic async run(options: DependenciesOptions): Promise<ActionResponse<SyncprojectResult>> {\n\t\tconst { configuration, logDiff } = options;\n\n\t\tconst projects = this.workspace.getProjects(configuration);\n\t\tconst workspacePackages = await this.resolver.getWorkspacePackages(\n\t\t\tthis.workspace,\n\t\t\tprojects,\n\t\t);\n\n\t\tconst computed = await Promise.all(\n\t\t\tprojects.map((project) => this.computeDependenciesFor(project, workspacePackages)),\n\t\t);\n\n\t\tconst results = computed.map((c) => c.syncResult);\n\t\tif (results.some((r) => !r.succeeded)) {\n\t\t\treturn ActionResponse.Error(SyncDependencies.name, results);\n\t\t}\n\n\t\tconst succeeded = computed.filter(\n\t\t\t(c): c is SyncComputed & { succeeded: true } => c.succeeded,\n\t\t);\n\n\t\tawait Promise.all(succeeded.map((c) => c.project.persistPackageJson(c.updatedPackage)));\n\n\t\tconst syncResults = succeeded.map((c) => {\n\t\t\tconst drift = this.resolver.computeDrift(c.originalPackage, c.updatedPackage);\n\t\t\tif (drift && logDiff) {\n\t\t\t\tthis.#logger.warn(`Dependency drift synced in '${c.syncResult.projectName}'`, drift);\n\t\t\t}\n\t\t\treturn { ...c.syncResult, drift };\n\t\t});\n\n\t\tconst failedResults = results.filter((r) => !r.succeeded);\n\n\t\treturn ActionResponse.Success(SyncDependencies.name, [...syncResults, ...failedResults]);\n\t}\n\n\tprivate async computeDependenciesFor(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<SyncComputed> {\n\t\ttry {\n\t\t\tconst originalPackage = await project.getPackageJson();\n\t\t\tconst { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(\n\t\t\t\tproject,\n\t\t\t\tworkspacePackages,\n\t\t\t);\n\t\t\tfor (const warning of warnings) {\n\t\t\t\tthis.#logger.warn(`${warning.file}:${warning.line}: ${warning.message}`);\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tsucceeded: true,\n\t\t\t\tsyncResult: { projectName: project.name, succeeded: true },\n\t\t\t\tproject,\n\t\t\t\toriginalPackage,\n\t\t\t\tupdatedPackage,\n\t\t\t};\n\t\t} catch (error) {\n\t\t\tconst message = formatUnknownError(error);\n\t\t\treturn {\n\t\t\t\tsucceeded: false,\n\t\t\t\tsyncResult: {\n\t\t\t\t\tprojectName: project.name,\n\t\t\t\t\terror: `${project.name}: ${message}`,\n\t\t\t\t\tsucceeded: false,\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\t}\n}\n"],"names":["SyncDependencies","scribe","logger","name","workspace","resolver","run","options","configuration","logDiff","projects","getProjects","workspacePackages","getWorkspacePackages","computed","Promise","all","map","project","computeDependenciesFor","results","c","syncResult","some","r","succeeded","ActionResponse","Error","filter","persistPackageJson","updatedPackage","syncResults","drift","computeDrift","originalPackage","warn","projectName","failedResults","Success","getPackageJson","warnings","computeProjectDependencies","warning","file","line","message","error","formatUnknownError"],"mappings":";;;;+BA4BaA;;;eAAAA;;;4BA5Bc;sBAGD;qBAEK;wBACR;wBACY;2CAEA;;;;;;;;;;AAmB5B,MAAMA;;;IACZ,CAAA,MAAO,GAAGC,cAAM,CAACC,MAAM,CAACF,iBAAiBG,IAAI,EAAE;IAE/C,YACC,AAAiBC,SAAoB,EACrC,AAAiBC,QAA4B,CAC5C;aAFgBD,YAAAA;aACAC,WAAAA;IACf;IAEH,MAAaC,IAAIC,OAA4B,EAA8C;QAC1F,MAAM,EAAEC,aAAa,EAAEC,OAAO,EAAE,GAAGF;QAEnC,MAAMG,WAAW,IAAI,CAACN,SAAS,CAACO,WAAW,CAACH;QAC5C,MAAMI,oBAAoB,MAAM,IAAI,CAACP,QAAQ,CAACQ,oBAAoB,CACjE,IAAI,CAACT,SAAS,EACdM;QAGD,MAAMI,WAAW,MAAMC,QAAQC,GAAG,CACjCN,SAASO,GAAG,CAAC,CAACC,UAAY,IAAI,CAACC,sBAAsB,CAACD,SAASN;QAGhE,MAAMQ,UAAUN,SAASG,GAAG,CAAC,CAACI,IAAMA,EAAEC,UAAU;QAChD,IAAIF,QAAQG,IAAI,CAAC,CAACC,IAAM,CAACA,EAAEC,SAAS,GAAG;YACtC,OAAOC,mBAAc,CAACC,KAAK,CAAC3B,iBAAiBG,IAAI,EAAEiB;QACpD;QAEA,MAAMK,YAAYX,SAASc,MAAM,CAChC,CAACP,IAA+CA,EAAEI,SAAS;QAG5D,MAAMV,QAAQC,GAAG,CAACS,UAAUR,GAAG,CAAC,CAACI,IAAMA,EAAEH,OAAO,CAACW,kBAAkB,CAACR,EAAES,cAAc;QAEpF,MAAMC,cAAcN,UAAUR,GAAG,CAAC,CAACI;YAClC,MAAMW,QAAQ,IAAI,CAAC3B,QAAQ,CAAC4B,YAAY,CAACZ,EAAEa,eAAe,EAAEb,EAAES,cAAc;YAC5E,IAAIE,SAASvB,SAAS;gBACrB,IAAI,CAAC,CAAA,MAAO,CAAC0B,IAAI,CAAC,CAAC,4BAA4B,EAAEd,EAAEC,UAAU,CAACc,WAAW,CAAC,CAAC,CAAC,EAAEJ;YAC/E;YACA,OAAO;gBAAE,GAAGX,EAAEC,UAAU;gBAAEU;YAAM;QACjC;QAEA,MAAMK,gBAAgBjB,QAAQQ,MAAM,CAAC,CAACJ,IAAM,CAACA,EAAEC,SAAS;QAExD,OAAOC,mBAAc,CAACY,OAAO,CAACtC,iBAAiBG,IAAI,EAAE;eAAI4B;eAAgBM;SAAc;IACxF;IAEA,MAAclB,uBACbD,OAAgB,EAChBN,iBAAuC,EACf;QACxB,IAAI;YACH,MAAMsB,kBAAkB,MAAMhB,QAAQqB,cAAc;YACpD,MAAM,EAAET,cAAc,EAAEU,QAAQ,EAAE,GAAG,MAAM,IAAI,CAACnC,QAAQ,CAACoC,0BAA0B,CAClFvB,SACAN;YAED,KAAK,MAAM8B,WAAWF,SAAU;gBAC/B,IAAI,CAAC,CAAA,MAAO,CAACL,IAAI,CAAC,GAAGO,QAAQC,IAAI,CAAC,CAAC,EAAED,QAAQE,IAAI,CAAC,EAAE,EAAEF,QAAQG,OAAO,EAAE;YACxE;YACA,OAAO;gBACNpB,WAAW;gBACXH,YAAY;oBAAEc,aAAalB,QAAQf,IAAI;oBAAEsB,WAAW;gBAAK;gBACzDP;gBACAgB;gBACAJ;YACD;QACD,EAAE,OAAOgB,OAAO;YACf,MAAMD,UAAUE,IAAAA,0BAAkB,EAACD;YACnC,OAAO;gBACNrB,WAAW;gBACXH,YAAY;oBACXc,aAAalB,QAAQf,IAAI;oBACzB2C,OAAO,GAAG5B,QAAQf,IAAI,CAAC,EAAE,EAAE0C,SAAS;oBACpCpB,WAAW;gBACZ;YACD;QACD;IACD;AACD"}