@decohere/forge 0.0.1-dev.5

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

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

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

@@ -0,0 +1,41 @@
+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 { scribe } from "@decohere/scribe";
+export class Watch {
+    workspace;
+    #logger = scribe.logger(Watch.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        if (!options.watch) {
+            this.#logger.info(`Skipping ${Watch.name}`);
+            return ActionResponse.Skipped(Watch.name);
+        }
+        await this.workspace.watch(options.configuration);
+        return ActionResponse.Blocking(Watch.name);
+    };
+    [Symbol.dispose]() {
+        this.workspace.stopWatching();
+    }
+}
+Watch = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Watch);
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,34 @@
+import { CommandResponse, ConfigurationOption, DecohereCommand, NoCleanOptions } from "@decohere/nexus/cli";
+import auto from "async/auto.js";
+export class BuildCommand extends DecohereCommand {
+    constructor(name){
+        super(name ?? BuildCommand.name);
+        this.description("Build workspace projects");
+        this.addOption(new ConfigurationOption("debug"));
+        this.addOption(new NoCleanOptions(true));
+        this.option("--no-copy", "Will not copy files like package.json to outdir", true);
+        this.option("--watch", "Watches for changes in the source dir", false);
+        this.option("--file <file>", "File to build");
+    }
+    run = async (actions, options)=>{
+        const responses = await auto({
+            clean: async ()=>await actions.clean.run(options),
+            build: [
+                "clean",
+                async ()=>await actions.build.run(options)
+            ],
+            copy: [
+                "clean",
+                async ()=>await actions.copy.run(options)
+            ],
+            watch: [
+                "build",
+                "copy",
+                async ()=>await actions.watch.run(options)
+            ]
+        });
+        return CommandResponse.success(options, responses);
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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":["/src/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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2NvbW1hbmRzL2ZvcmdlLmNvbW1hbmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBBY3Rpb25zIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7XG5cdHR5cGUgQ29tbWFuZEhhbmRsZXIsXG5cdHR5cGUgQ29tbWFuZFJlc3BvbnNlLFxuXHR0eXBlIENvbW1hbmRUeXBlLFxuXHREZWNvaGVyZUNvbW1hbmQsXG59IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5cbmV4cG9ydCBjbGFzcyBGb3JnZUNvbW1hbmQgZXh0ZW5kcyBEZWNvaGVyZUNvbW1hbmQge1xuXHRwdWJsaWMgY29uc3RydWN0b3IoY29tbWFuZHM6IFJlY29yZDxzdHJpbmcsIENvbW1hbmRUeXBlPiwgaGFuZGxlcjogQ29tbWFuZEhhbmRsZXIpIHtcblx0XHRzdXBlcihGb3JnZUNvbW1hbmQpO1xuXHRcdHRoaXMuZGVzY3JpcHRpb24oXCJSdW4gZm9yZ2Ugd29ya3NwYWNlIHdvcmtmbG93c1wiKTtcblx0XHR0aGlzLmV4aXRPdmVycmlkZSgpO1xuXHRcdHRoaXMucmVnaXN0ZXJTdWJjb21tYW5kKGNvbW1hbmRzLCBoYW5kbGVyKTtcblx0fVxuXG5cdHB1YmxpYyBydW4oX2FjdGlvbnM6IEFjdGlvbnMsIF9vcHRpb25zOiBuZXZlcik6IFByb21pc2U8Q29tbWFuZFJlc3BvbnNlPiB7XG5cdFx0cmV0dXJuIHRoaXMuaGVscCgpO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiRGVjb2hlcmVDb21tYW5kIiwiRm9yZ2VDb21tYW5kIiwiY29tbWFuZHMiLCJoYW5kbGVyIiwiZGVzY3JpcHRpb24iLCJleGl0T3ZlcnJpZGUiLCJyZWdpc3RlclN1YmNvbW1hbmQiLCJydW4iLCJfYWN0aW9ucyIsIl9vcHRpb25zIiwiaGVscCJdLCJtYXBwaW5ncyI6IkFBQ0EsU0FJQ0EsZUFBZSxRQUNULHNCQUFzQjtBQUU3QixPQUFPLE1BQU1DLHFCQUFxQkQ7SUFDakMsWUFBbUJFLFFBQXFDLEVBQUVDLE9BQXVCLENBQUU7UUFDbEYsS0FBSyxDQUFDRjtRQUNOLElBQUksQ0FBQ0csV0FBVyxDQUFDO1FBQ2pCLElBQUksQ0FBQ0MsWUFBWTtRQUNqQixJQUFJLENBQUNDLGtCQUFrQixDQUFDSixVQUFVQztJQUNuQztJQUVPSSxJQUFJQyxRQUFpQixFQUFFQyxRQUFlLEVBQTRCO1FBQ3hFLE9BQU8sSUFBSSxDQUFDQyxJQUFJO0lBQ2pCO0FBQ0QifQ==

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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2NvbW1hbmRzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2J1aWxkLmNvbW1hbmQuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlcGVuZGVuY3kuY29tbWFuZC5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZm9yZ2UuY29tbWFuZC5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHVibGlzaC5jb21tYW5kLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90YWcuY29tbWFuZC5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdmVyc2lvbi5jb21tYW5kLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUI7QUFDbkMsY0FBYywwQkFBMEI7QUFDeEMsY0FBYyxxQkFBcUI7QUFDbkMsY0FBYyx1QkFBdUI7QUFDckMsY0FBYyxtQkFBbUI7QUFDakMsY0FBYyx1QkFBdUIifQ==

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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2NvbW1hbmRzL3RhZy5jb21tYW5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERlY29oZXJlQ29tbWFuZCwgRHJ5UnVuT3B0aW9uIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7IFRhZyB9IGZyb20gXCIuLi9hY3Rpb25zL3RhZy5hY3Rpb24uanNcIjtcblxuZXhwb3J0IGNsYXNzIFRhZ0NvbW1hbmQgZXh0ZW5kcyBEZWNvaGVyZUNvbW1hbmQge1xuXHRwdWJsaWMgb3ZlcnJpZGUgZ2V0IGFjdGlvbnMoKSB7XG5cdFx0cmV0dXJuIFtUYWddO1xuXHR9XG5cblx0cHVibGljIGNvbnN0cnVjdG9yKG5hbWU6IHN0cmluZykge1xuXHRcdHN1cGVyKG5hbWUpO1xuXHRcdHRoaXMuZGVzY3JpcHRpb24oXCJDcmVhdGUgYW5kIG9wdGlvbmFsbHkgcHVzaCBhIGdpdCB0YWcgZm9yIHRoZSB3b3Jrc3BhY2UgdmVyc2lvblwiKTtcblx0XHR0aGlzLm9wdGlvbihcIi0tcHJlZml4IDxwcmVmaXg+XCIsIFwiVGFnIHByZWZpeFwiLCBcInZcIik7XG5cdFx0dGhpcy5vcHRpb24oXCItLXB1c2hcIiwgXCJQdXNoIHRoZSB0YWcgYW5kIGN1cnJlbnQgYnJhbmNoIHRvIG9yaWdpbiBhZnRlciB0YWdnaW5nXCIsIGZhbHNlKTtcblx0XHR0aGlzLmFkZE9wdGlvbihuZXcgRHJ5UnVuT3B0aW9uKFwiUHJpbnQgdGhlIHRhZyB3aXRob3V0IGNyZWF0aW5nIGl0XCIpKTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIkRlY29oZXJlQ29tbWFuZCIsIkRyeVJ1bk9wdGlvbiIsIlRhZyIsIlRhZ0NvbW1hbmQiLCJhY3Rpb25zIiwibmFtZSIsImRlc2NyaXB0aW9uIiwib3B0aW9uIiwiYWRkT3B0aW9uIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxlQUFlLEVBQUVDLFlBQVksUUFBUSxzQkFBc0I7QUFDcEUsU0FBU0MsR0FBRyxRQUFRLDJCQUEyQjtBQUUvQyxPQUFPLE1BQU1DLG1CQUFtQkg7SUFDL0IsSUFBb0JJLFVBQVU7UUFDN0IsT0FBTztZQUFDRjtTQUFJO0lBQ2I7SUFFQSxZQUFtQkcsSUFBWSxDQUFFO1FBQ2hDLEtBQUssQ0FBQ0E7UUFDTixJQUFJLENBQUNDLFdBQVcsQ0FBQztRQUNqQixJQUFJLENBQUNDLE1BQU0sQ0FBQyxxQkFBcUIsY0FBYztRQUMvQyxJQUFJLENBQUNBLE1BQU0sQ0FBQyxVQUFVLDJEQUEyRDtRQUNqRixJQUFJLENBQUNDLFNBQVMsQ0FBQyxJQUFJUCxhQUFhO0lBQ2pDO0FBQ0QifQ==

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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2Vycm9ycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBXb3Jrc3BhY2VDb25maWd1cmF0aW9uRXJyb3IgfSBmcm9tIFwiQGRlY29oZXJlL21lc2hcIjtcbmV4cG9ydCBjbGFzcyBGb3JnZUVycm9yIGV4dGVuZHMgRXJyb3Ige31cblxuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdFVua25vd25FcnJvcihyZWFzb246IHVua25vd24pOiBzdHJpbmcge1xuXHRpZiAocmVhc29uIGluc3RhbmNlb2YgRXJyb3IpIHtcblx0XHRyZXR1cm4gcmVhc29uLm1lc3NhZ2U7XG5cdH1cblxuXHRpZiAodHlwZW9mIHJlYXNvbiA9PT0gXCJzdHJpbmdcIikge1xuXHRcdHJldHVybiByZWFzb247XG5cdH1cblxuXHR0cnkge1xuXHRcdHJldHVybiBKU09OLnN0cmluZ2lmeShyZWFzb24pO1xuXHR9IGNhdGNoIHtcblx0XHRyZXR1cm4gXCJVbmtub3duIGVycm9yXCI7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJXb3Jrc3BhY2VDb25maWd1cmF0aW9uRXJyb3IiLCJGb3JnZUVycm9yIiwiRXJyb3IiLCJmb3JtYXRVbmtub3duRXJyb3IiLCJyZWFzb24iLCJtZXNzYWdlIiwiSlNPTiIsInN0cmluZ2lmeSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsMkJBQTJCLFFBQVEsaUJBQWlCO0FBQzdELE9BQU8sTUFBTUMsbUJBQW1CQztBQUFPO0FBRXZDLE9BQU8sU0FBU0MsbUJBQW1CQyxNQUFlO0lBQ2pELElBQUlBLGtCQUFrQkYsT0FBTztRQUM1QixPQUFPRSxPQUFPQyxPQUFPO0lBQ3RCO0lBRUEsSUFBSSxPQUFPRCxXQUFXLFVBQVU7UUFDL0IsT0FBT0E7SUFDUjtJQUVBLElBQUk7UUFDSCxPQUFPRSxLQUFLQyxTQUFTLENBQUNIO0lBQ3ZCLEVBQUUsT0FBTTtRQUNQLE9BQU87SUFDUjtBQUNEIn0=