@unbrained/pm-cli 2026.8.7 → 2026.8.8

package/dist/sdk/environment/project-runtime-compatibility.js

@@ -0,0 +1,385 @@
+/**
+ * @module sdk/project-runtime-compatibility
+ *
+ * Protects project mutations from an older PATH-resolved pm executable while
+ * leaving diagnosis reads available.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="962636b0-ed3b-5ad0-ae0c-904435025986")}catch(e){}}();
+import fs from "node:fs";
+import path from "node:path";
+import { EXIT_CODE } from "../../core/shared/constants.js";
+import { PmCliError } from "../../core/shared/errors.js";
+export { PmCliError };
+const PACKAGE_NAME = "@unbrained/pm-cli";
+const MUTATING_COMMANDS = new Set([
+    "append",
+    "claim",
+    "changelog",
+    "close",
+    "close-many",
+    "close-task",
+    "comments",
+    "config",
+    "copy",
+    "create",
+    "dedupe-merge",
+    "delete",
+    "deps",
+    "docs",
+    "extension",
+    "event",
+    "events",
+    "files",
+    "focus",
+    "gc",
+    "history-author-acknowledge",
+    "history-compact",
+    "history-redact",
+    "history-repair",
+    "init",
+    "install",
+    "item",
+    "learnings",
+    "meet",
+    "merge",
+    "normalize",
+    "notes",
+    "package",
+    "packages",
+    "pause-task",
+    "plan",
+    "profile",
+    "reindex",
+    "release",
+    "remind",
+    "restore",
+    "schema",
+    "start-task",
+    "test",
+    "test-all",
+    "test-runs",
+    "test-runs-worker",
+    "telemetry",
+    "templates",
+    "twin",
+    "update",
+    "update-many",
+    "upgrade",
+    "vcs",
+    "workspace",
+]);
+const GLOBAL_VALUE_FLAGS = new Set([
+    "--author",
+    "--output-budget",
+    "--output-format",
+    "--output-include",
+    "--output-limit",
+    "--output-session",
+    "--path",
+    "--pm-path",
+]);
+const VERSION_PATTERN = /\b(\d{4})\.(\d{1,2})\.(\d{1,2})(?:-(\d+))?\b/u;
+/** Return whether an invocation includes one of the exact mutation switches. */
+function hasAnyToken(argv, tokens) {
+    return argv.some((token) => tokens.includes(token.split("=", 1)[0]));
+}
+/** Classify package/extension compatibility aliases from subcommands and legacy flags. */
+function isPackageMutation(argv, positionals) {
+    return ([
+        "activate",
+        "adopt",
+        "adopt-all",
+        "deactivate",
+        "init",
+        "install",
+        "migrate",
+        "reload",
+        "uninstall",
+    ].includes(positionals[0] ?? "") ||
+        hasAnyToken(argv, [
+            "--activate",
+            "--adopt",
+            "--adopt-all",
+            "--deactivate",
+            "--fix-managed-state",
+            "--init",
+            "--install",
+            "--output",
+            "--reload",
+            "--scaffold",
+            "--uninstall",
+        ]));
+}
+const MIXED_COMMAND_CLASSIFIERS = {
+    changelog: (argv, positionals) => {
+        if (positionals[0] === "generate")
+            return !hasAnyToken(argv, ["--check"]);
+        const exportIndex = argv.indexOf("export");
+        return (positionals[0] === "export" &&
+            (hasAnyToken(argv, ["--output"]) ||
+                (exportIndex >= 0 &&
+                    argv[exportIndex + 1] !== undefined &&
+                    !argv[exportIndex + 1].startsWith("-"))));
+    },
+    comments: (argv) => hasAnyToken(argv, ["--add", "--delete", "--edit", "--file", "--stdin"]),
+    config: (_argv, positionals) => (positionals[0] === "project" || positionals[0] === "global"
+        ? positionals[1]
+        : positionals[0]) === "set",
+    deps: () => false,
+    docs: (argv) => hasAnyToken(argv, ["--add", "--add-glob", "--migrate", "--remove"]),
+    duplicates: () => false,
+    events: () => false,
+    extension: isPackageMutation,
+    files: (argv, positionals) => hasAnyToken(argv, ["--add", "--add-glob", "--migrate", "--remove"]) ||
+        (positionals[0] === "discover" && hasAnyToken(argv, ["--apply"])),
+    health: (argv) => !hasAnyToken(argv, ["--check-only", "--no-refresh", "--skip-vectors"]),
+    learnings: (argv) => hasAnyToken(argv, ["--add", "--delete", "--edit", "--file", "--stdin"]),
+    merge: (_argv, positionals) => positionals[0] !== "report",
+    notes: (argv) => hasAnyToken(argv, ["--add", "--delete", "--edit", "--file", "--stdin"]),
+    package: isPackageMutation,
+    packages: isPackageMutation,
+    profile: (_argv, positionals) => positionals[0] === "apply",
+    schema: (argv, positionals) => [
+        "add-field",
+        "add-status",
+        "add-type",
+        "remove-field",
+        "remove-status",
+        "remove-type",
+        "remap-status",
+        "rename-field",
+        "rename-type",
+    ].includes(positionals[0] ?? "") &&
+        !(hasAnyToken(argv, ["--infer"]) && !hasAnyToken(argv, ["--apply"])),
+    telemetry: (_argv, positionals) => positionals.slice(0, 2).some((token) => ["clear", "flush"].includes(token)),
+    templates: (_argv, positionals) => positionals[0] === "save",
+    test: (argv) => hasAnyToken(argv, [
+        "--add",
+        "--add-json",
+        "--background",
+        "--measure",
+        "--remove",
+        "--resume",
+        "--run",
+        "--stop",
+    ]),
+    validate: (argv) => hasAnyToken(argv, ["--auto-fix", "--prune-missing"]),
+    vcs: (_argv, positionals) => ["abandon", "create", "merge", "propose", "ref-create"].includes(positionals[0] ?? ""),
+    workspace: (_argv, positionals) => positionals[0] === "snapshot" &&
+        ["create", "delete", "restore"].includes(positionals[1] ?? ""),
+};
+/** Parse the supported date-version coordinates used by pm releases. */
+function parseDateVersion(value) {
+    const match = value.match(VERSION_PATTERN);
+    return match
+        ? [
+            Number(match[1]),
+            Number(match[2]),
+            Number(match[3]),
+            Number(match[4] ?? 0),
+        ]
+        : null;
+}
+/** Compare pm date versions without accepting arbitrary semver-like prose. */
+export function comparePmDateVersions(left, right) {
+    const leftParts = parseDateVersion(left);
+    const rightParts = parseDateVersion(right);
+    if (!leftParts || !rightParts)
+        return null;
+    for (let index = 0; index < leftParts.length; index += 1) {
+        const delta = leftParts[index] - rightParts[index];
+        if (delta !== 0)
+            return Math.sign(delta);
+    }
+    return 0;
+}
+/** Read one optional JSON object without turning absence or corruption into startup failure. */
+function readJsonRecord(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Extract the highest explicit lower-bound pm date version from dependency declarations. */
+function dependencyPin(packageJson) {
+    const versions = [];
+    for (const field of [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+        "peerDependencies",
+    ]) {
+        const dependencies = packageJson[field];
+        if (typeof dependencies !== "object" || dependencies === null)
+            continue;
+        const value = dependencies[PACKAGE_NAME];
+        const specification = typeof value === "string" ? value.trim() : "";
+        const version = /^[<!]/u.test(specification)
+            ? undefined
+            : specification.match(VERSION_PATTERN)?.[0];
+        if (version)
+            versions.push(version);
+    }
+    return versions.sort((left, right) => comparePmDateVersions(right, left))[0];
+}
+/** Read npm's exact installed package coordinate from package-lock.json. */
+function packageLockPin(projectRoot) {
+    const lock = readJsonRecord(path.join(projectRoot, "package-lock.json"));
+    const packages = lock?.packages;
+    if (typeof packages !== "object" || packages === null)
+        return undefined;
+    const installed = packages["node_modules/@unbrained/pm-cli"];
+    if (typeof installed !== "object" || installed === null)
+        return undefined;
+    const version = installed.version;
+    return typeof version === "string" ? version : undefined;
+}
+/** Read the exact coordinate from the matching text lockfile package block. */
+function textLockPin(projectRoot, file) {
+    try {
+        const lines = fs
+            .readFileSync(path.join(projectRoot, file), "utf8")
+            .split(/\r?\n/u);
+        const packageLineIndex = lines.findIndex((line) => line.includes(PACKAGE_NAME));
+        if (packageLineIndex < 0)
+            return undefined;
+        const packageIndent = lines[packageLineIndex].match(/^\s*/u)[0].length;
+        const entry = [lines[packageLineIndex]];
+        for (let index = packageLineIndex + 1; index < lines.length; index += 1) {
+            const line = lines[index];
+            const trimmed = line.trim();
+            const indent = line.match(/^\s*/u)[0].length;
+            if (trimmed.length > 0 && indent <= packageIndent)
+                break;
+            entry.push(line);
+        }
+        const entrySource = entry.join("\n");
+        const explicitVersion = entrySource.match(/^\s*version(?::\s*|\s+)["']?(\d{4}\.\d{1,2}\.\d{1,2}(?:-\d+)?)/mu)?.[1];
+        return explicitVersion ?? entry[0].match(VERSION_PATTERN)?.[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Discover declared, installed, and lock-resolved versions without network I/O. */
+export function discoverProjectRuntimeVersionPins(projectRoot) {
+    const pins = [];
+    const projectPackage = readJsonRecord(path.join(projectRoot, "package.json"));
+    const declared = projectPackage ? dependencyPin(projectPackage) : undefined;
+    if (declared)
+        pins.push({ version: declared, source: "package.json" });
+    const installedPackage = readJsonRecord(path.join(projectRoot, "node_modules", "@unbrained", "pm-cli", "package.json"));
+    const installedVersion = installedPackage?.version;
+    if (typeof installedVersion === "string" &&
+        parseDateVersion(installedVersion)) {
+        pins.push({ version: installedVersion, source: "installed-package" });
+    }
+    const packageLockVersion = packageLockPin(projectRoot);
+    if (packageLockVersion && parseDateVersion(packageLockVersion)) {
+        pins.push({ version: packageLockVersion, source: "package-lock.json" });
+    }
+    for (const file of ["pnpm-lock.yaml", "yarn.lock"]) {
+        const version = textLockPin(projectRoot, file);
+        if (version)
+            pins.push({ version, source: file });
+    }
+    return pins;
+}
+/** Resolve the first command token and index while preserving global option values. */
+function commandTokenFromArgv(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (GLOBAL_VALUE_FLAGS.has(token)) {
+            index += 1;
+            continue;
+        }
+        if (!token.startsWith("-"))
+            return { command: token.toLowerCase(), index };
+    }
+    return undefined;
+}
+/** Classify mutation-capable invocations while preserving explicit read modes. */
+export function isProjectMutatingInvocation(argv) {
+    const commandToken = commandTokenFromArgv(argv);
+    if (!commandToken)
+        return false;
+    if (hasAnyToken(argv, ["--help", "-h", "--dry-run"]))
+        return false;
+    const { command, index: commandIndex } = commandToken;
+    const positionals = [];
+    for (let index = commandIndex + 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (GLOBAL_VALUE_FLAGS.has(token)) {
+            index += 1;
+            continue;
+        }
+        if (!token.startsWith("-"))
+            positionals.push(token.toLowerCase());
+    }
+    const mixedClassifier = MIXED_COMMAND_CLASSIFIERS[command];
+    return mixedClassifier
+        ? mixedClassifier(argv, positionals)
+        : MUTATING_COMMANDS.has(command);
+}
+/** Inspect whether one invocation is compatible with the project's newest pin. */
+export function inspectProjectRuntimeCompatibility(options) {
+    const command = commandTokenFromArgv(options.argv)?.command;
+    const mutating = isProjectMutatingInvocation(options.argv);
+    const pins = discoverProjectRuntimeVersionPins(options.projectRoot)
+        .filter((pin) => comparePmDateVersions(pin.version, options.executingVersion) !== null)
+        .sort((left, right) => comparePmDateVersions(right.version, left.version));
+    const newest = pins[0];
+    const stale = newest !== undefined &&
+        comparePmDateVersions(options.executingVersion, newest.version) === -1;
+    const warning = stale && !mutating
+        ? {
+            code: "project_runtime_stale_read",
+            executing_version: options.executingVersion,
+            project_version: newest.version,
+            source: newest.source,
+            message: "This read is using an older pm runtime than the project requires.",
+            next_steps: [
+                `Run the command through the project's installed ${PACKAGE_NAME} ${newest.version}.`,
+                "Install the project dependencies with its declared package manager if the local executable is missing.",
+            ],
+        }
+        : undefined;
+    return {
+        compatible: !mutating || !stale || options.allowStale === true,
+        executing_version: options.executingVersion,
+        ...(newest
+            ? { project_version: newest.version, source: newest.source }
+            : {}),
+        ...(command ? { command } : {}),
+        mutating,
+        stale,
+        ...(warning ? { warning } : {}),
+        override_applied: stale && mutating && options.allowStale === true,
+    };
+}
+/** Refuse stale mutations with a stable SDK error and package-neutral recovery. */
+export function assertProjectRuntimeCompatibility(options) {
+    const result = inspectProjectRuntimeCompatibility(options);
+    if (result.compatible)
+        return result;
+    throw new PmCliError(`pm ${result.executing_version} cannot mutate a project pinned to newer pm ${result.project_version}.`, EXIT_CODE.CONFLICT, {
+        code: "project_runtime_stale_mutation",
+        reason: result.source,
+        why: "An older runtime can write storage, history, and merge contracts it does not understand.",
+        nextSteps: [
+            `Run this command through the project's installed ${PACKAGE_NAME} ${result.project_version}.`,
+            "For an intentional recovery only, set PM_ALLOW_STALE_CLI=1 for this invocation and record why.",
+            "Read-only commands remain available without an override.",
+        ],
+    });
+}
+//# sourceMappingURL=project-runtime-compatibility.js.map
+//# debugId=962636b0-ed3b-5ad0-ae0c-904435025986

package/dist/sdk/environment/source-context.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module sdk/environment/source-context
+ *
+ * Defines the inherited source-workspace access contract used by sandboxed
+ * commands that retain read-only project identity.
+ */
+/** Environment key declaring how a child may use inherited source coordinates. */
+export declare const SOURCE_CONTEXT_ACCESS_ENV = "PM_SOURCE_CONTEXT_ACCESS";
+/** Environment key permitting one explicit source-context write invocation. */
+export declare const SOURCE_CONTEXT_WRITE_OVERRIDE_ENV = "PM_ALLOW_SOURCE_CONTEXT_WRITES";
+/** Supported inherited source-context access modes. */
+export type SourceContextAccessMode = "read_only" | "write";
+/** Structured policy used by SDK adapters before selecting source coordinates. */
+export interface SourceContextWritePolicy {
+    /** Declared access mode, with absent legacy context retaining write behavior. */
+    access: SourceContextAccessMode;
+    /** Whether the one-invocation write override was accepted. */
+    write_override_applied: boolean;
+    /** Whether a mutation may select inherited source coordinates. */
+    source_writes_allowed: boolean;
+}
+/** Resolve inherited source-coordinate write policy without reading filesystem state. */
+export declare function resolveSourceContextWritePolicy(environment: Readonly<Record<string, string | undefined>>): SourceContextWritePolicy;

package/dist/sdk/environment/source-context.js

@@ -0,0 +1,29 @@
+/**
+ * @module sdk/environment/source-context
+ *
+ * Defines the inherited source-workspace access contract used by sandboxed
+ * commands that retain read-only project identity.
+ */
+/** Environment key declaring how a child may use inherited source coordinates. */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="f97516b2-f75c-5ce0-82dc-f850466284c7")}catch(e){}}();
+export const SOURCE_CONTEXT_ACCESS_ENV = "PM_SOURCE_CONTEXT_ACCESS";
+/** Environment key permitting one explicit source-context write invocation. */
+export const SOURCE_CONTEXT_WRITE_OVERRIDE_ENV = "PM_ALLOW_SOURCE_CONTEXT_WRITES";
+/** Resolve inherited source-coordinate write policy without reading filesystem state. */
+export function resolveSourceContextWritePolicy(environment) {
+    const declaredAccess = environment[SOURCE_CONTEXT_ACCESS_ENV];
+    const access = declaredAccess === undefined ||
+        declaredAccess.trim().toLowerCase() === "write"
+        ? "write"
+        : "read_only";
+    const writeOverrideApplied = access === "read_only" &&
+        environment[SOURCE_CONTEXT_WRITE_OVERRIDE_ENV]?.trim() === "1";
+    return {
+        access,
+        write_override_applied: writeOverrideApplied,
+        source_writes_allowed: access === "write" || writeOverrideApplied,
+    };
+}
+//# sourceMappingURL=source-context.js.map
+//# debugId=f97516b2-f75c-5ce0-82dc-f850466284c7

package/dist/sdk/error-code-catalog.d.ts

@@ -43,8 +43,14 @@ export interface PmErrorCodeContract {
     sources: string[];
     /** CLI command roots inferred from executable declaration ownership. */
     emitting_commands: string[];
+    /** Canonical machine identifier for this compatibility group. */
+    canonical_code?: string;
+    /** Stable compatibility spellings that resolve to this canonical code. */
+    aliases?: string[];
 }
 /** Validate, normalize, sort, and freeze an error-code catalog. */
 export declare function definePmErrorCodeCatalog(declarations: readonly PmErrorCodeContract[]): readonly PmErrorCodeContract[];
+/** Resolve an emitted code through its stable compatibility alias group. */
+export declare function resolveCanonicalPmErrorCodeContract(code: string, catalog: readonly PmErrorCodeContract[]): PmErrorCodeContract;
 /** Resolve one declared error contract and fail closed for unknown vocabulary. */
 export declare function resolvePmErrorCodeContract(code: string, catalog: readonly PmErrorCodeContract[]): PmErrorCodeContract;

package/dist/sdk/error-code-catalog.js

@@ -6,7 +6,7 @@
  */
 /** Stable shell exit-code taxonomy shared by every structured error. */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="479dd590-7f54-54ae-bbaf-8f183fd6b6b4")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="393243a5-dd90-52c1-a9c1-588fd33f8b6a")}catch(e){}}();
 export const PM_ERROR_CODE_EXIT_CLASS_CONTRACTS = [
     { exit_code: 1, class: "generic_failure" },
     { exit_code: 2, class: "usage" },
@@ -21,6 +21,55 @@ function normalizeContractList(values) {
         ...new Set(values.map((value) => value.trim()).filter(Boolean)),
     ].sort();
 }
+function isValidNormalizedErrorCodeContract(declaration, sources, emittingCommands, canonicalCode, aliases) {
+    return ![
+        [1, 2, 3, 4, 5].includes(declaration.exit_code),
+        declaration.meaning.trim().length > 0,
+        declaration.recovery.trim().length > 0,
+        sources.length > 0,
+        emittingCommands.length > 0,
+        /^[a-z][a-z0-9_]*$/.test(canonicalCode),
+        aliases.every((alias) => /^[a-z][a-z0-9_]*$/.test(alias)),
+        ERROR_CLASS_BY_EXIT_CODE.get(declaration.exit_code) === declaration.class,
+    ].includes(false);
+}
+function resolveCanonicalErrorCodeDeclaration(declaration, byCode) {
+    let current = declaration;
+    const path = new Set();
+    while (current.canonical_code !== current.code) {
+        if (path.has(current.code)) {
+            throw new TypeError(`Alias cycle in pm error code catalog: ${declaration.code}`);
+        }
+        path.add(current.code);
+        const target = byCode.get(current.canonical_code);
+        if (!target) {
+            throw new TypeError(`Invalid pm error code contract: ${declaration.code}`);
+        }
+        current = target;
+    }
+    return current;
+}
+function validateErrorCodeAliases(declarations) {
+    const byCode = new Map(declarations.map((entry) => [entry.code, entry]));
+    for (const declaration of declarations) {
+        const canonical = resolveCanonicalErrorCodeDeclaration(declaration, byCode);
+        if (canonical.exit_code !== declaration.exit_code ||
+            canonical.class !== declaration.class) {
+            throw new TypeError(`Alias transport mismatch for pm error code: ${declaration.code}`);
+        }
+        const expectedAliases = declarations
+            .filter((candidate) => candidate.code !== canonical.code &&
+            candidate.canonical_code === canonical.code)
+            .map((candidate) => candidate.code)
+            .sort();
+        if (declaration.code === canonical.code
+            ? JSON.stringify(declaration.aliases) !==
+                JSON.stringify(expectedAliases)
+            : declaration.aliases.length > 0) {
+            throw new TypeError(`Invalid pm error code contract: ${declaration.code}`);
+        }
+    }
+}
 /** Validate, normalize, sort, and freeze an error-code catalog. */
 export function definePmErrorCodeCatalog(declarations) {
     const seen = new Set();
@@ -35,12 +84,9 @@ export function definePmErrorCodeCatalog(declarations) {
         seen.add(code);
         const sources = normalizeContractList(declaration.sources);
         const emittingCommands = normalizeContractList(declaration.emitting_commands);
-        if (![1, 2, 3, 4, 5].includes(declaration.exit_code) ||
-            declaration.meaning.trim().length === 0 ||
-            declaration.recovery.trim().length === 0 ||
-            sources.length === 0 ||
-            emittingCommands.length === 0 ||
-            ERROR_CLASS_BY_EXIT_CODE.get(declaration.exit_code) !== declaration.class) {
+        const canonicalCode = (declaration.canonical_code ?? code).trim();
+        const aliases = normalizeContractList(declaration.aliases ?? []);
+        if (!isValidNormalizedErrorCodeContract(declaration, sources, emittingCommands, canonicalCode, aliases)) {
             throw new TypeError(`Invalid pm error code contract: ${code}`);
         }
         return Object.freeze({
@@ -50,10 +96,18 @@ export function definePmErrorCodeCatalog(declarations) {
             recovery: declaration.recovery.trim(),
             sources,
             emitting_commands: emittingCommands,
+            canonical_code: canonicalCode,
+            aliases,
         });
     });
+    validateErrorCodeAliases(normalized);
     return Object.freeze(normalized.sort((left, right) => left.code.localeCompare(right.code)));
 }
+/** Resolve an emitted code through its stable compatibility alias group. */
+export function resolveCanonicalPmErrorCodeContract(code, catalog) {
+    const emitted = resolvePmErrorCodeContract(code, catalog);
+    return resolvePmErrorCodeContract(emitted.canonical_code ?? emitted.code, catalog);
+}
 /** Resolve one declared error contract and fail closed for unknown vocabulary. */
 export function resolvePmErrorCodeContract(code, catalog) {
     const normalized = code.trim();
@@ -64,4 +118,4 @@ export function resolvePmErrorCodeContract(code, catalog) {
     return contract;
 }
 //# sourceMappingURL=error-code-catalog.js.map
-//# debugId=479dd590-7f54-54ae-bbaf-8f183fd6b6b4
+//# debugId=393243a5-dd90-52c1-a9c1-588fd33f8b6a