@unbrained/pm-cli 2026.7.20 → 2026.7.21

package/dist/cli-bundle/chunks/{chunk-SG74J6MV.js → chunk-ATBCUC7Y.js}

@@ -1,9 +1,24 @@
 
-!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]="ad0928de-27a9-5c52-9736-17eac79ff5da")}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]="69f422b7-7912-5517-91f9-247ad58bd84c")}catch(e){}}();
+import {
+  close,
+  commitWorkspaceTransaction,
+  create,
+  deleteItem,
+  get,
+  restore,
+  update
+} from "./chunk-RNPZYNHS.js";
+import {
+  CLOSE_FLAG_CONTRACTS,
+  CREATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS,
+  UPDATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS
+} from "./chunk-FSE2IKJQ.js";
 import {
   historyEntriesToRaw,
+  readHistoryEntries,
   reanchorHistoryEntries
-} from "./chunk-P7JTWYLH.js";
+} from "./chunk-PFNHX655.js";
 import {
   canonicalDocument,
   compareTimestampStrings,
@@ -20,6 +35,7 @@ import {
   PmCliError,
   collectRegisteredItemFieldNames,
   getSettingsPath,
+  levenshteinDistanceWithinLimit,
   pathExists,
   resolvePmRoot
 } from "./chunk-HYW67VJ5.js";
@@ -589,6 +605,553 @@ async function runMergeDriver(options, global) {
   };
 }
 
+// dist/sdk/structured-mutations.js
+var MUTATION_ROW_KEYS = ["op", "id", "reason", "options"];
+var ITEM_ENVELOPE_KEYS = [
+  "item",
+  "linked",
+  "schedule",
+  "claim_state",
+  "children"
+];
+var READ_ONLY_ITEM_KEYS = /* @__PURE__ */ new Set([
+  "created_at",
+  "updated_at",
+  "closed_at",
+  "version",
+  "format_version",
+  "path",
+  "author"
+]);
+var UPDATE_READ_ONLY_ITEM_KEYS = /* @__PURE__ */ new Set([...READ_ONLY_ITEM_KEYS, "id"]);
+var ITEM_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "title",
+  "description",
+  "type",
+  "status",
+  "priority",
+  "tags",
+  "body",
+  "deadline",
+  "estimated_minutes",
+  "acceptance_criteria",
+  "definition_of_ready",
+  "order",
+  "rank",
+  "goal",
+  "objective",
+  "value",
+  "impact",
+  "outcome",
+  "why_now",
+  "assignee",
+  "parent",
+  "reviewer",
+  "risk",
+  "confidence",
+  "sprint",
+  "release",
+  "blocked_by",
+  "blocked_reason",
+  "unblock_note",
+  "reporter",
+  "severity",
+  "environment",
+  "repro_steps",
+  "resolution",
+  "expected_result",
+  "actual_result",
+  "affected_version",
+  "fixed_version",
+  "component",
+  "regression",
+  "customer_impact",
+  "close_reason",
+  "dependencies",
+  "comments",
+  "notes",
+  "learnings",
+  "files",
+  "tests",
+  "docs",
+  "reminders",
+  "events",
+  "type_options"
+]);
+var MUTATION_OPTION_KEYS = {
+  create: CREATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS.map((contract) => contract.target),
+  update: UPDATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS.map((contract) => contract.target),
+  close: CLOSE_FLAG_CONTRACTS.map((contract) => contract.flag.slice(2).replaceAll(/-([a-z])/gu, (_match, letter) => letter.toUpperCase())).filter((key) => key !== "reason")
+};
+function parseAtomicMutationControls(value) {
+  const controls = {};
+  const compensation = value.createCompensation;
+  if (compensation !== void 0) {
+    if (compensation !== "close" && compensation !== "delete") {
+      throw new PmCliError("createCompensation must be close or delete.", EXIT_CODE.USAGE);
+    }
+    controls.createCompensation = compensation;
+  }
+  for (const key of ["lockTtlSeconds", "lockWaitMs"]) {
+    const raw = value[key];
+    if (raw === void 0)
+      continue;
+    const parsed = typeof raw === "number" || typeof raw === "string" && raw.trim().length > 0 ? Number(raw) : Number.NaN;
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+      throw new PmCliError(`${key} must be a positive safe integer.`, EXIT_CODE.USAGE);
+    }
+    controls[key] = parsed;
+  }
+  return controls;
+}
+function isPlainObject2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function nearestKey(key, candidates) {
+  const limit = Math.max(1, Math.min(3, Math.floor(key.length / 4) + 1));
+  let best;
+  for (const candidate of candidates) {
+    const distance = levenshteinDistanceWithinLimit(key, candidate, limit);
+    if (distance !== null && (best === void 0 || distance < best.distance)) {
+      best = { key: candidate, distance };
+    }
+  }
+  return best?.key;
+}
+function unknownKeyError(scope, key, candidates) {
+  const suggestion = nearestKey(key, candidates);
+  return new PmCliError(suggestion === void 0 ? `${scope} does not recognize key "${key}". Allowed keys: ${candidates.join(", ")}.` : `${scope} does not recognize key "${key}". Did you mean "${suggestion}"?`, EXIT_CODE.USAGE, {
+    code: "stdin_json_unknown_key",
+    required: `Use documented ${scope} keys only.`,
+    why: "Strict structured input prevents silent typos from creating incomplete or unintended mutations.",
+    nextSteps: [
+      suggestion === void 0 ? `Remove or correct "${key}".` : `Replace "${key}" with "${suggestion}".`
+    ]
+  });
+}
+function parseJsonValue(input, label) {
+  try {
+    return JSON.parse(input);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new PmCliError(`${label} must be valid JSON: ${detail}`, EXIT_CODE.USAGE, {
+      code: "stdin_json_invalid",
+      required: `Pipe one valid JSON ${label.toLowerCase()} into stdin.`,
+      why: "Structured mutation input must parse deterministically before any tracker write begins."
+    });
+  }
+}
+function validateMutationObject(value, index) {
+  if (!isPlainObject2(value)) {
+    throw new PmCliError(`Mutation ${index + 1} must be an object.`, EXIT_CODE.USAGE);
+  }
+  for (const key of Object.keys(value)) {
+    if (!MUTATION_ROW_KEYS.includes(key)) {
+      throw unknownKeyError(`mutation ${index + 1}`, key, MUTATION_ROW_KEYS);
+    }
+  }
+  return value;
+}
+function validateMutationOptions(options, op, index) {
+  if (options === void 0)
+    return void 0;
+  if (!isPlainObject2(options)) {
+    throw new PmCliError(`Mutation ${index + 1} options must be an object.`, EXIT_CODE.USAGE);
+  }
+  for (const key of Object.keys(options)) {
+    if (!MUTATION_OPTION_KEYS[op].includes(key)) {
+      throw unknownKeyError(`mutation ${index + 1} ${op} options`, key, MUTATION_OPTION_KEYS[op]);
+    }
+  }
+  return options;
+}
+function validateMutationRow(value, index) {
+  const mutation = validateMutationObject(value, index);
+  const { op, id, reason } = mutation;
+  if (op !== "create" && op !== "update" && op !== "close") {
+    throw new PmCliError(`Mutation ${index + 1} op must be create, update, or close.`, EXIT_CODE.USAGE);
+  }
+  const options = validateMutationOptions(mutation.options, op, index);
+  if (typeof id !== "string" || id.trim().length === 0) {
+    throw new PmCliError(`Mutation ${index + 1} requires a non-empty id.`, EXIT_CODE.USAGE);
+  }
+  const normalizedId = id.trim();
+  if (op === "close") {
+    if (typeof reason !== "string" || reason.trim().length === 0) {
+      throw new PmCliError(`Mutation ${index + 1} close requires a non-empty reason.`, EXIT_CODE.USAGE);
+    }
+    return {
+      op,
+      id: normalizedId,
+      reason: reason.trim(),
+      ...options === void 0 ? {} : { options }
+    };
+  }
+  if (!isPlainObject2(options)) {
+    throw new PmCliError(`Mutation ${index + 1} ${op} requires an options object.`, EXIT_CODE.USAGE);
+  }
+  return {
+    op,
+    id: normalizedId,
+    options
+  };
+}
+function parseItemMutationBatch(input) {
+  const parsed = parseJsonValue(input, "Mutation batch");
+  const rows = Array.isArray(parsed) ? parsed : isPlainObject2(parsed) && Array.isArray(parsed.mutations) ? parsed.mutations : void 0;
+  if (rows === void 0 || rows.length === 0) {
+    throw new PmCliError("Mutation batch must be a non-empty JSON array or an object with a non-empty mutations array.", EXIT_CODE.USAGE);
+  }
+  return rows.map((row, index) => validateMutationRow(row, index));
+}
+function serializePairs(value, keys) {
+  return keys.filter((key) => value[key] !== void 0 && value[key] !== null).map((key) => {
+    const rendered = String(value[key]);
+    return `${key}=${/[",\n\r\\]/u.test(rendered) ? JSON.stringify(rendered) : rendered}`;
+  }).join(",");
+}
+function serializeObjectArray(value, keys, label) {
+  if (value === void 0)
+    return void 0;
+  if (!Array.isArray(value) || !value.every(isPlainObject2)) {
+    throw new PmCliError(`${label} must be an array of objects.`, EXIT_CODE.USAGE);
+  }
+  return value.map((entry) => serializePairs(entry, keys));
+}
+function scalarItemOption(key, value) {
+  if (key === "tags" && Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return value;
+}
+function appendFacetOptions(target, source, skipPersistedAnnotations = false) {
+  const mappings = [
+    ["dependencies", "dep", ["id", "kind", "created_at", "author"]],
+    ["comments", "comment", ["text", "created_at", "author"]],
+    ["notes", "note", ["text", "created_at", "author"]],
+    ["learnings", "learning", ["text", "created_at", "author"]],
+    ["files", "file", ["path", "scope", "note"]],
+    ["tests", "test", ["command", "scope", "timeout_seconds"]],
+    ["docs", "doc", ["path", "scope", "note"]],
+    ["reminders", "reminder", ["at", "text", "created_at"]],
+    ["events", "event", ["start_at", "end_at", "title", "location"]],
+    ["type_options", "typeOption", ["key", "value"]]
+  ];
+  for (const [sourceKey, targetKey, keys] of mappings) {
+    const sourceValue = source[sourceKey];
+    const serialized = serializeObjectArray(skipPersistedAnnotations && ["comments", "notes", "learnings"].includes(sourceKey) && Array.isArray(sourceValue) ? sourceValue.filter((entry) => !isPlainObject2(entry) || entry.created_at === void 0) : sourceValue, keys, sourceKey);
+    if (serialized !== void 0 && serialized.length > 0)
+      target[targetKey] = serialized;
+  }
+}
+function validateItemDocumentKeys(parsed, envelope) {
+  for (const key of Object.keys(parsed)) {
+    if (envelope) {
+      if (!ITEM_ENVELOPE_KEYS.includes(key))
+        throw unknownKeyError("item envelope", key, ITEM_ENVELOPE_KEYS);
+      continue;
+    }
+    if (!ITEM_FIELD_KEYS.has(key) && nearestKey(key, [...ITEM_FIELD_KEYS]) === void 0 && nearestKey(key, ITEM_ENVELOPE_KEYS) === "item")
+      throw unknownKeyError("item envelope", key, ITEM_ENVELOPE_KEYS);
+  }
+}
+function resolveItemDocument(parsed) {
+  const envelope = Object.hasOwn(parsed, "item");
+  validateItemDocumentKeys(parsed, envelope);
+  const item = envelope ? parsed.item : parsed;
+  if (!isPlainObject2(item)) {
+    throw new PmCliError("Item document item must be an object.", EXIT_CODE.USAGE);
+  }
+  return {
+    item,
+    ...envelope && isPlainObject2(parsed.linked) ? { linked: parsed.linked } : {}
+  };
+}
+function appendItemDocumentEntry(documentOptions, key, value, mode) {
+  const readOnlyKeys = mode === "update" ? UPDATE_READ_ONLY_ITEM_KEYS : READ_ONLY_ITEM_KEYS;
+  if (readOnlyKeys.has(key))
+    return;
+  if (!ITEM_FIELD_KEYS.has(key)) {
+    const suggestion = nearestKey(key, [...ITEM_FIELD_KEYS]);
+    if (suggestion !== void 0)
+      throw unknownKeyError("item document", key, [...ITEM_FIELD_KEYS]);
+    const fields = Array.isArray(documentOptions.field) ? documentOptions.field : [];
+    fields.push(serializePairs({
+      key,
+      value: typeof value === "string" ? value : JSON.stringify(value)
+    }, ["key", "value"]));
+    documentOptions.field = fields;
+    return;
+  }
+  if ([
+    "dependencies",
+    "comments",
+    "notes",
+    "learnings",
+    "files",
+    "tests",
+    "docs",
+    "reminders",
+    "events",
+    "type_options"
+  ].includes(key))
+    return;
+  documentOptions[key.replaceAll(/_([a-z])/gu, (_match, letter) => letter.toUpperCase())] = scalarItemOption(key, value);
+}
+function itemDocumentToMutationOptions(input, mode, explicitOptions = {}) {
+  const parsed = parseJsonValue(input, "Item document");
+  if (!isPlainObject2(parsed)) {
+    throw new PmCliError("Item document must be a JSON object.", EXIT_CODE.USAGE);
+  }
+  const { item, linked } = resolveItemDocument(parsed);
+  const documentOptions = {};
+  for (const [key, value] of Object.entries(item)) {
+    appendItemDocumentEntry(documentOptions, key, value, mode);
+  }
+  appendFacetOptions(documentOptions, item, mode === "update");
+  if (linked !== void 0)
+    appendFacetOptions(documentOptions, linked);
+  return {
+    ...documentOptions,
+    ...Object.fromEntries(Object.entries(explicitOptions).filter(([, value]) => value !== void 0)),
+    stdinJson: void 0
+  };
+}
+function validateItemMutationRows(value) {
+  return parseItemMutationBatch(JSON.stringify(value));
+}
+
+// dist/sdk/item-transaction.js
+import path2 from "node:path";
+async function readItemSnapshot(pmRoot, id) {
+  try {
+    const located = await get(id, {}, { pmRoot });
+    const item = located.item;
+    return {
+      id: item.id,
+      closedAt: item.closed_at,
+      updatedAt: item.updated_at
+    };
+  } catch (error) {
+    if (error instanceof PmCliError && error.exitCode === EXIT_CODE.NOT_FOUND) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function deriveStepId(mutation, index) {
+  const sanitizedTarget = mutation.id.replaceAll(/[^a-zA-Z0-9._-]/gu, "_");
+  return `${index + 1}-${mutation.op}-${sanitizedTarget}`;
+}
+function bulkHistoryMarker(transactionId, stepId, phase) {
+  return `bulk-item-transaction ${transactionId} ${stepId} ${phase}`;
+}
+async function isUpdateMarkerApplied(pmRoot, canonicalId, transactionId, stepId) {
+  const entries = await readHistoryEntries(path2.join(pmRoot, "history", `${canonicalId}.jsonl`), canonicalId);
+  const applyMarker = bulkHistoryMarker(transactionId, stepId, "apply");
+  const compensateMarker = bulkHistoryMarker(transactionId, stepId, "compensate");
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const message = entries[index].message;
+    if (message === applyMarker) {
+      return true;
+    }
+    if (message === compensateMarker) {
+      return false;
+    }
+  }
+  return false;
+}
+async function prepareRestoreCompensation(pmRoot, mutation) {
+  const snapshot = await readItemSnapshot(pmRoot, mutation.id);
+  if (snapshot?.updatedAt === void 0) {
+    throw new PmCliError(`Bulk ${mutation.op} target ${mutation.id} does not exist or has no restorable version`, EXIT_CODE.NOT_FOUND);
+  }
+  return { target_updated_at: snapshot.updatedAt };
+}
+async function compensateByRestore(config, itemId, stepId, data) {
+  const target = data !== null && typeof data === "object" && !Array.isArray(data) ? data.target_updated_at : void 0;
+  if (typeof target !== "string") {
+    return;
+  }
+  if (await readItemSnapshot(config.pmRoot, itemId) === void 0) {
+    return;
+  }
+  await restore(itemId, target, {
+    force: true,
+    author: config.author,
+    message: bulkHistoryMarker(config.transactionId, stepId, "compensate")
+  }, { pmRoot: config.pmRoot });
+}
+function buildCreateStep(config, mutation, stepId) {
+  return {
+    id: stepId,
+    async inspect() {
+      const snapshot = await readItemSnapshot(config.pmRoot, mutation.id);
+      if (snapshot === void 0) {
+        return { state: "pending" };
+      }
+      return { state: "applied", result: { id: snapshot.id, op: "create" } };
+    },
+    async apply() {
+      const created = await create({ ...mutation.options, author: config.author, id: mutation.id }, { pmRoot: config.pmRoot });
+      const createdItem = created.item;
+      return { id: String(createdItem.id), op: "create" };
+    },
+    async compensate() {
+      const snapshot = await readItemSnapshot(config.pmRoot, mutation.id);
+      if (snapshot === void 0) {
+        return;
+      }
+      if (config.createCompensation === "delete") {
+        await deleteItem(mutation.id, {
+          force: true,
+          author: config.author,
+          message: `Compensate interrupted bulk transaction ${config.transactionId}`
+        }, { pmRoot: config.pmRoot });
+        return;
+      }
+      if (snapshot.closedAt !== void 0) {
+        return;
+      }
+      await close(mutation.id, `Compensated: interrupted bulk transaction ${config.transactionId}`, { force: true, author: config.author }, { pmRoot: config.pmRoot });
+    }
+  };
+}
+function buildUpdateStep(config, mutation, stepId) {
+  return {
+    id: stepId,
+    async inspect() {
+      const snapshot = await readItemSnapshot(config.pmRoot, mutation.id);
+      if (snapshot === void 0) {
+        return { state: "pending" };
+      }
+      const applied = await isUpdateMarkerApplied(config.pmRoot, snapshot.id, config.transactionId, stepId);
+      if (!applied) {
+        return { state: "pending" };
+      }
+      return { state: "applied", result: { id: snapshot.id, op: "update" } };
+    },
+    async prepareCompensation() {
+      return prepareRestoreCompensation(config.pmRoot, mutation);
+    },
+    async apply() {
+      const updated = await update(mutation.id, {
+        ...mutation.options,
+        author: config.author,
+        message: bulkHistoryMarker(config.transactionId, stepId, "apply")
+      }, { pmRoot: config.pmRoot });
+      const updatedItem = updated.item;
+      return { id: String(updatedItem.id), op: "update" };
+    },
+    async compensate(data) {
+      await compensateByRestore(config, mutation.id, stepId, data);
+    }
+  };
+}
+function buildCloseStep(config, mutation, stepId) {
+  return {
+    id: stepId,
+    // An already-terminal target counts as applied: closing it again would
+    // fight legitimate prior closure, and recovery must adopt completed work.
+    async inspect() {
+      const snapshot = await readItemSnapshot(config.pmRoot, mutation.id);
+      if (snapshot?.closedAt === void 0) {
+        return { state: "pending" };
+      }
+      return { state: "applied", result: { id: snapshot.id, op: "close" } };
+    },
+    async prepareCompensation() {
+      return prepareRestoreCompensation(config.pmRoot, mutation);
+    },
+    async apply() {
+      const closed = await close(mutation.id, mutation.reason, { ...mutation.options, author: config.author }, { pmRoot: config.pmRoot });
+      const closedItem = closed.item;
+      return { id: String(closedItem.id), op: "close" };
+    },
+    async compensate(data) {
+      await compensateByRestore(config, mutation.id, stepId, data);
+    }
+  };
+}
+function buildStepForMutation(config, mutation, index) {
+  const stepId = deriveStepId(mutation, index);
+  if (mutation.op === "create") {
+    return buildCreateStep(config, mutation, stepId);
+  }
+  if (mutation.op === "update") {
+    return buildUpdateStep(config, mutation, stepId);
+  }
+  return buildCloseStep(config, mutation, stepId);
+}
+function assertValidBulkMutation(mutation, index) {
+  if (mutation === null || typeof mutation !== "object" || Array.isArray(mutation)) {
+    throw new TypeError(`Bulk mutation ${index + 1} must be an object`);
+  }
+  if (!["create", "update", "close"].includes(mutation.op)) {
+    throw new TypeError(`Bulk mutation ${index + 1} op must be create, update, or close`);
+  }
+  if (typeof mutation.id !== "string" || mutation.id.trim().length === 0) {
+    throw new TypeError(`Bulk mutation ${index + 1} requires a non-empty id`);
+  }
+  if (mutation.op === "close" && (typeof mutation.reason !== "string" || mutation.reason.trim().length === 0)) {
+    throw new TypeError(`Bulk close mutation ${index + 1} requires a non-empty reason`);
+  }
+}
+async function commitItemMutations(options) {
+  const mutations = [...options.mutations];
+  if (mutations.length === 0) {
+    throw new TypeError("Bulk item transaction requires at least one mutation");
+  }
+  for (const [index, mutation] of mutations.entries()) {
+    assertValidBulkMutation(mutation, index);
+  }
+  const createCompensation = options.createCompensation ?? "close";
+  if (!["close", "delete"].includes(createCompensation)) {
+    throw new TypeError("Bulk item transaction createCompensation must be close or delete");
+  }
+  const stepConfig = {
+    pmRoot: options.pmRoot,
+    author: options.author,
+    transactionId: options.transactionId,
+    createCompensation
+  };
+  const committed = await commitWorkspaceTransaction({
+    pmRoot: options.pmRoot,
+    transactionId: options.transactionId,
+    author: options.author,
+    steps: mutations.map((mutation, index) => buildStepForMutation(stepConfig, mutation, index)),
+    ...options.lockTtlSeconds === void 0 ? {} : { lockTtlSeconds: options.lockTtlSeconds },
+    ...options.lockWaitMs === void 0 ? {} : { lockWaitMs: options.lockWaitMs },
+    ...options.onTransition === void 0 ? {} : { onTransition: options.onTransition }
+  });
+  const results = {};
+  for (const [stepId, value] of Object.entries(committed.results)) {
+    results[stepId] = value;
+  }
+  return {
+    transactionId: committed.transactionId,
+    status: "committed",
+    recovered: committed.recovered,
+    results
+  };
+}
+var _testOnlyItemTransaction = {
+  buildCreateStep,
+  bulkHistoryMarker,
+  compensateByRestore,
+  deriveStepId,
+  isUpdateMarkerApplied,
+  readItemSnapshot
+};
+
 export {
   mergeHistoryStreams,
   mergeRelationshipEventStreams,
@@ -597,8 +1160,14 @@ export {
   mergeItemDocuments,
   mergeJsonDocuments,
   MERGE_DRIVER_ARTIFACT_VALUES,
-  runMergeDriver
+  runMergeDriver,
+  parseAtomicMutationControls,
+  parseItemMutationBatch,
+  itemDocumentToMutationOptions,
+  validateItemMutationRows,
+  commitItemMutations,
+  _testOnlyItemTransaction
 };
-//# sourceMappingURL=chunk-SG74J6MV.js.map
+//# sourceMappingURL=chunk-ATBCUC7Y.js.map
 
-//# debugId=ad0928de-27a9-5c52-9736-17eac79ff5da
+//# debugId=69f422b7-7912-5517-91f9-247ad58bd84c