@unbrained/pm-cli 2026.7.18 → 2026.7.19

package/dist/cli-bundle/chunks/{chunk-SIPOACV5.js → chunk-46Z6FAVP.js}

@@ -1,10 +1,18 @@
 
-!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]="038cbba4-9d1e-5b41-b501-d40eec7260cd")}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]="46a874f8-2610-5028-8e18-b40e6110f614")}catch(e){}}();
 import {
-  assertHistoryRepairTarget,
-  runHistoryRepair,
-  runHistoryRepairAll
-} from "./chunk-R5XTTZSJ.js";
+  runUpdateMany
+} from "./chunk-6V4T4RD3.js";
+import {
+  runConfig,
+  runUpgrade
+} from "./chunk-IEMXESIS.js";
+import {
+  runAggregate,
+  runGet,
+  runGraph,
+  runSearch
+} from "./chunk-IR3GOO6E.js";
 import {
   resolveStartTaskInProgressStatus,
   runClaim,
@@ -18,110 +26,21 @@ import {
   runTest,
   runTestAll,
   runValidate
-} from "./chunk-6VHUGVNP.js";
-import {
-  runDocs
-} from "./chunk-X2MGQMZO.js";
-import {
-  runCopy
-} from "./chunk-633PKXLT.js";
-import {
-  runFocus
-} from "./chunk-IE5KRAKN.js";
-import {
-  runDelete
-} from "./chunk-47HXN6RX.js";
-import {
-  runAppend
-} from "./chunk-67RO3H4N.js";
-import {
-  runProfileApply,
-  runProfileLint,
-  runProfileList,
-  runProfileShow
-} from "./chunk-HYTOJW2Q.js";
-import {
-  runNotes
-} from "./chunk-FY4RLHSC.js";
-import {
-  runLearnings
-} from "./chunk-6O44IN44.js";
-import {
-  runFiles,
-  runFilesDiscover
-} from "./chunk-AFGKSHAM.js";
-import {
-  runCloseMany
-} from "./chunk-EWIT5WIC.js";
-import {
-  runUpdateMany
-} from "./chunk-43UMFKCK.js";
-import {
-  runRestore
-} from "./chunk-7H5NNCJ5.js";
+} from "./chunk-ODEIDKGW.js";
 import {
   runUpdate
-} from "./chunk-YIIIAKCE.js";
-import {
-  runPlan
-} from "./chunk-VE6ZSTQW.js";
-import {
-  assertHistoryCompactTarget,
-  runHistoryCompact,
-  runHistoryCompactBulk
-} from "./chunk-L337QKWJ.js";
-import {
-  runComments
-} from "./chunk-HSYV4ZYT.js";
-import {
-  runConfig,
-  runUpgrade
-} from "./chunk-IL5SPRMH.js";
+} from "./chunk-MRXAHR4B.js";
 import {
   SCAFFOLD_CAPABILITIES,
   runExtension,
   runInit
-} from "./chunk-QRZNCRNA.js";
-import {
-  runSchemaAddField,
-  runSchemaAddStatus,
-  runSchemaAddType,
-  runSchemaApplyPreset,
-  runSchemaInferTypes,
-  runSchemaList,
-  runSchemaListFields,
-  runSchemaRemoveField,
-  runSchemaRemoveStatus,
-  runSchemaRemoveType,
-  runSchemaShow,
-  runSchemaShowField,
-  runSchemaShowStatus
-} from "./chunk-FXFCFL73.js";
-import {
-  runAggregate,
-  runGet,
-  runGraph,
-  runSearch
-} from "./chunk-QPGQNLPI.js";
-import {
-  runDeps
-} from "./chunk-EX7OQT3Y.js";
+} from "./chunk-MI3346YW.js";
 import {
   runActivity,
   runContext,
   runHistory,
   runNext
-} from "./chunk-XPUTSGJU.js";
-import {
-  runList
-} from "./chunk-NCVT6XEL.js";
-import {
-  runHistoryRedact
-} from "./chunk-KH6QAHME.js";
-import {
-  resolveRegisteredSearchProvider,
-  resolveRegisteredVectorStoreAdapter
-} from "./chunk-M3JN6FPW.js";
+} from "./chunk-CZA2DXCV.js";
 import {
   REINDEX_LOCK_ID,
   buildSearchCorpus,
@@ -144,7 +63,32 @@ import {
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores,
   writeVectorizationStatusLedger
-} from "./chunk-E4FXM2XB.js";
+} from "./chunk-UE7LK3RE.js";
+import {
+  assertHistoryCompactTarget,
+  runHistoryCompact,
+  runHistoryCompactBulk
+} from "./chunk-DUDLSQFG.js";
+import {
+  assertHistoryRepairTarget,
+  runHistoryRepair,
+  runHistoryRepairAll
+} from "./chunk-SBW7EQC4.js";
+import {
+  runLearnings
+} from "./chunk-T6MOTLOJ.js";
+import {
+  runNotes
+} from "./chunk-IRJ6F23W.js";
+import {
+  runPlan
+} from "./chunk-2XPDCXK5.js";
+import {
+  runProfileApply,
+  runProfileLint,
+  runProfileList,
+  runProfileShow
+} from "./chunk-UW6HCMP2.js";
 import {
   ACTIVITY_FLAG_CONTRACTS,
   AGGREGATE_FLAG_CONTRACTS,
@@ -177,19 +121,83 @@ import {
   UPDATE_FLAG_CONTRACTS,
   UPDATE_MANY_FLAG_CONTRACTS,
   toCompletionFlagString
-} from "./chunk-7UCY6DR5.js";
+} from "./chunk-JPWUZOMR.js";
+import {
+  runSchemaAddField,
+  runSchemaAddStatus,
+  runSchemaAddType,
+  runSchemaApplyPreset,
+  runSchemaInferTypes,
+  runSchemaList,
+  runSchemaListFields,
+  runSchemaRemoveField,
+  runSchemaRemoveStatus,
+  runSchemaRemoveType,
+  runSchemaShow,
+  runSchemaShowField,
+  runSchemaShowStatus
+} from "./chunk-H3YKUVDR.js";
+import {
+  runComments
+} from "./chunk-TELI67UP.js";
 import {
   runCreate
-} from "./chunk-HTXXXF45.js";
+} from "./chunk-BDC4TW4B.js";
+import {
+  projectMutationResult
+} from "./chunk-2UCG5H6B.js";
+import {
+  runCopy
+} from "./chunk-BZKE2O5V.js";
+import {
+  runFocus
+} from "./chunk-QQ77W23U.js";
+import {
+  runDelete
+} from "./chunk-UWAQI3B7.js";
+import {
+  runDeps
+} from "./chunk-SUNZKVAH.js";
+import {
+  runDocs
+} from "./chunk-LT5UWU7H.js";
+import {
+  runFiles,
+  runFilesDiscover
+} from "./chunk-YGEA4CLH.js";
+import {
+  resolveRegisteredSearchProvider,
+  resolveRegisteredVectorStoreAdapter
+} from "./chunk-M3JN6FPW.js";
+import {
+  runAppend
+} from "./chunk-G33XIMRT.js";
 import {
   parseTags
-} from "./chunk-FHOBCGQO.js";
+} from "./chunk-SVAWG7EE.js";
 import {
-  projectMutationResult
-} from "./chunk-BIRYX32V.js";
+  runCloseMany
+} from "./chunk-U6RYD446.js";
+import {
+  runList
+} from "./chunk-YG56M3NE.js";
+import {
+  createQueryFingerprint,
+  decodeQueryCursorState,
+  paginateQueryRows
+} from "./chunk-UOIFZ66L.js";
 import {
   runClose
-} from "./chunk-35FHWD4C.js";
+} from "./chunk-EI3UIMZM.js";
+import {
+  runRestore
+} from "./chunk-FQF6VVPH.js";
+import {
+  getItemAt
+} from "./chunk-VA3H7VVC.js";
+import {
+  runHistoryRedact
+} from "./chunk-M4B4RK4J.js";
 import {
   acquireLock,
   appendHistoryEntry,
@@ -212,11 +220,12 @@ import {
   setActiveExtensionRegistrations,
   setActiveExtensionRenderers,
   setActiveExtensionServices
-} from "./chunk-P22HGFFI.js";
+} from "./chunk-QFG4MB7P.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
   PmCliError,
+  RelationshipGraph,
   STATUS_VALUES,
   activateExtensions,
   asRecordClone,
@@ -228,6 +237,7 @@ import {
   createEmptyExtensionRegistrationRegistry,
   createEmptyExtensionRendererRegistry,
   createEmptyExtensionServiceRegistry,
+  createRelationshipKindRegistry,
   deactivateExtensions,
   getHistoryPath,
   getSettingsPath,
@@ -240,10 +250,10 @@ import {
   resolveRuntimeStatusRegistry,
   toNonEmptyStringOrUndefined,
   writeFileAtomic
-} from "./chunk-KX62NMZC.js";
+} from "./chunk-D35WYXWC.js";
 
 // dist/sdk/runtime.js
-import path3 from "node:path";
+import path5 from "node:path";
 
 // dist/core/output/query-summary.js
 function isRecord(value) {
@@ -301,6 +311,740 @@ function memoizeWorkspaceExtensionRegistrations(cacheKey, loadRegistrations) {
   return registrations;
 }
 
+// dist/sdk/relationship-history.js
+import { constants } from "node:fs";
+import { lstat, mkdir, open } from "node:fs/promises";
+import path from "node:path";
+function requiredText(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0)
+    throw new TypeError(`Relationship event ${field} must be non-empty`);
+  return value.trim();
+}
+function edgeIdentity(edge, registry) {
+  const definition = registry.require(edge.kind);
+  const endpoints = definition.direction === "undirected" ? [edge.source, edge.target].sort().join("\0") : `${edge.source}\0${edge.target}`;
+  return `${definition.kind}\0${endpoints}`;
+}
+function freezeEdge(edge) {
+  return Object.freeze({
+    ...edge,
+    ...edge.payload === void 0 ? {} : { payload: Object.freeze(structuredClone(edge.payload)) }
+  });
+}
+function assertCardinality(candidate, excludeRelationshipId, registry, indexes) {
+  const definition = registry.require(candidate.kind);
+  const outgoingOwner = indexes.outgoingOne.get(`${definition.kind}\0${candidate.source}`);
+  if (outgoingOwner !== void 0 && outgoingOwner !== excludeRelationshipId)
+    throw new TypeError(`Relationship outgoing cardinality exceeded for ${definition.kind}`);
+  const incomingOwner = indexes.incomingOne.get(`${definition.kind}\0${candidate.target}`);
+  if (incomingOwner !== void 0 && incomingOwner !== excludeRelationshipId)
+    throw new TypeError(`Relationship incoming cardinality exceeded for ${definition.kind}`);
+  const identity = edgeIdentity(candidate, registry);
+  const identityOwner = indexes.identities.get(identity);
+  if (identityOwner !== void 0 && identityOwner !== excludeRelationshipId)
+    throw new TypeError(`Relationship edge already active: ${identity}`);
+}
+function replayEvents(events) {
+  const active = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.action === "remove")
+      active.delete(event.relationshipId);
+    else
+      active.set(event.relationshipId, event.edge);
+  }
+  return active;
+}
+function normalizeEventHeader(input, currentVersion, eventIds) {
+  if (input.expectedVersion !== void 0 && input.expectedVersion !== currentVersion)
+    throw new TypeError(`Relationship event version conflict: expected ${input.expectedVersion}, current ${currentVersion}`);
+  const eventId = requiredText(input.eventId, "eventId");
+  if (eventIds.has(eventId))
+    throw new TypeError(`Relationship event already exists: ${eventId}`);
+  if (input.action !== "add" && input.action !== "remove" && input.action !== "supersede")
+    throw new TypeError(`Unknown relationship event action: ${input.action}`);
+  if (!Number.isFinite(Date.parse(input.timestamp)))
+    throw new TypeError("Relationship event timestamp must be valid");
+  return {
+    eventId,
+    relationshipId: requiredText(input.relationshipId, "relationshipId"),
+    author: requiredText(input.author, "author"),
+    timestamp: new Date(input.timestamp).toISOString()
+  };
+}
+function resolveMutationEdge(input, relationshipId, active, nodes, registry, indexes) {
+  const isActive = active.has(relationshipId);
+  if (input.action === "add" && isActive)
+    throw new TypeError(`Relationship is already active: ${relationshipId}`);
+  if (input.action !== "add" && !isActive)
+    throw new TypeError(`Relationship is not active: ${relationshipId}`);
+  if (input.action === "remove")
+    return void 0;
+  if (!input.edge)
+    throw new TypeError(`Relationship ${input.action} event requires an edge`);
+  const source = typeof input.edge.source === "string" ? input.edge.source.trim() : "";
+  const target = typeof input.edge.target === "string" ? input.edge.target.trim() : "";
+  if (!nodes.has(source) || !nodes.has(target))
+    throw new TypeError(`Relationship endpoint not found: ${source} -> ${target}`);
+  const canonical = new RelationshipGraph([source, target], [input.edge], registry).edges()[0];
+  assertCardinality(canonical, relationshipId, registry, indexes);
+  return freezeEdge(canonical);
+}
+var RelationshipEventLog = class {
+  #nodes;
+  #registry;
+  #events = [];
+  #eventIds = /* @__PURE__ */ new Set();
+  #active = /* @__PURE__ */ new Map();
+  #cardinalityIndexes = {
+    identities: /* @__PURE__ */ new Map(),
+    outgoingOne: /* @__PURE__ */ new Map(),
+    incomingOne: /* @__PURE__ */ new Map()
+  };
+  /** Create an empty relationship ledger for a fixed node universe. */
+  constructor(nodes, options = {}) {
+    this.#nodes = new Set([...nodes].filter((node) => typeof node === "string").map((node) => node.trim()).filter(Boolean));
+    this.#registry = options.registry ?? createRelationshipKindRegistry();
+  }
+  /** Current append sequence. */
+  get version() {
+    return this.#events.length;
+  }
+  /** Return an immutable copy of the full event stream. */
+  events() {
+    return Object.freeze([...this.#events]);
+  }
+  /**
+   * Iterate a stable event prefix in immutable, bounded batches. Consumers can
+   * build streaming projections without copying or exposing the mutable ledger.
+   * `fromVersion === toVersion + 1` is the intentional empty checkpoint range;
+   * larger watermarks are rejected as invalid for the selected prefix.
+   */
+  *stream(options = {}) {
+    const fromVersion = options.fromVersion ?? 1;
+    const toVersion = options.toVersion ?? this.version;
+    const batchSize = options.batchSize ?? 100;
+    if (!Number.isInteger(fromVersion) || fromVersion < 1)
+      throw new TypeError("Relationship event stream fromVersion must be positive");
+    if (!Number.isInteger(toVersion) || toVersion < 0 || toVersion > this.version)
+      throw new TypeError(`Relationship event stream toVersion out of range: ${toVersion}`);
+    if (!Number.isInteger(batchSize) || batchSize < 1)
+      throw new TypeError("Relationship event stream batchSize must be positive");
+    if (fromVersion > toVersion + 1)
+      throw new TypeError("Relationship event stream fromVersion exceeds the selected prefix");
+    for (let offset = fromVersion - 1; offset < toVersion; offset += batchSize) {
+      yield Object.freeze(this.#events.slice(offset, Math.min(offset + batchSize, toVersion)));
+    }
+  }
+  /** Fold a selected immutable event prefix into caller-owned domain state. */
+  project(initialState, reducer, options = {}) {
+    if (typeof reducer !== "function")
+      throw new TypeError("Relationship event projection requires a reducer");
+    let state = initialState;
+    let processed = 0;
+    let finalEvent;
+    for (const batch of this.stream({ ...options, batchSize: 256 })) {
+      for (const event of batch) {
+        state = reducer(state, event);
+        processed += 1;
+        finalEvent = event;
+      }
+    }
+    return Object.freeze({
+      state,
+      version: finalEvent?.sequence ?? Math.max(0, (options.fromVersion ?? 1) - 1),
+      processed,
+      ...finalEvent === void 0 ? {} : { asOf: finalEvent.timestamp }
+    });
+  }
+  /** Add one active relationship to constant-time validation indexes. */
+  #indexActive(relationshipId, edge) {
+    const definition = this.#registry.require(edge.kind);
+    this.#cardinalityIndexes.identities.set(edgeIdentity(edge, this.#registry), relationshipId);
+    if (definition.outgoing === "one")
+      this.#cardinalityIndexes.outgoingOne.set(`${definition.kind}\0${edge.source}`, relationshipId);
+    if (definition.incoming === "one")
+      this.#cardinalityIndexes.incomingOne.set(`${definition.kind}\0${edge.target}`, relationshipId);
+  }
+  /** Remove one superseded or deleted relationship from validation indexes. */
+  #unindexActive(edge) {
+    const definition = this.#registry.require(edge.kind);
+    this.#cardinalityIndexes.identities.delete(edgeIdentity(edge, this.#registry));
+    if (definition.outgoing === "one")
+      this.#cardinalityIndexes.outgoingOne.delete(`${definition.kind}\0${edge.source}`);
+    if (definition.incoming === "one")
+      this.#cardinalityIndexes.incomingOne.delete(`${definition.kind}\0${edge.target}`);
+  }
+  /** Validate and append one attributable relationship mutation. */
+  append(input) {
+    const header = normalizeEventHeader(input, this.version, this.#eventIds);
+    const previous = this.#active.get(header.relationshipId);
+    const edge = resolveMutationEdge(input, header.relationshipId, this.#active, this.#nodes, this.#registry, this.#cardinalityIndexes);
+    const event = Object.freeze({
+      eventId: header.eventId,
+      relationshipId: header.relationshipId,
+      action: input.action,
+      ...edge === void 0 ? {} : { edge },
+      author: header.author,
+      timestamp: header.timestamp,
+      ...input.reason?.trim() ? { reason: input.reason.trim() } : {},
+      sequence: this.version + 1
+    });
+    this.#events.push(event);
+    this.#eventIds.add(header.eventId);
+    if (previous)
+      this.#unindexActive(previous);
+    if (input.action === "remove")
+      this.#active.delete(header.relationshipId);
+    else {
+      this.#active.set(header.relationshipId, edge);
+      this.#indexActive(header.relationshipId, edge);
+    }
+    return event;
+  }
+  /** Materialize an exact point-in-time graph without mutating the ledger. */
+  snapshot(options = {}) {
+    if (options.atVersion !== void 0 && options.atTimestamp !== void 0)
+      throw new TypeError("Relationship snapshot accepts one target");
+    let included;
+    if (options.atTimestamp !== void 0) {
+      const timestamp = Date.parse(options.atTimestamp);
+      if (!Number.isFinite(timestamp))
+        throw new TypeError("Relationship snapshot timestamp must be valid");
+      let lastIndex = -1;
+      for (let index = this.#events.length - 1; index >= 0; index -= 1) {
+        if (Date.parse(this.#events[index].timestamp) > timestamp)
+          continue;
+        lastIndex = index;
+        break;
+      }
+      included = lastIndex === -1 ? [] : this.#events.slice(0, lastIndex + 1);
+    } else {
+      const version = options.atVersion ?? this.version;
+      if (!Number.isInteger(version) || version < 0 || version > this.version)
+        throw new TypeError(`Relationship snapshot version out of range: ${version}`);
+      included = this.#events.slice(0, version);
+    }
+    const active = replayEvents(included);
+    const graph2 = new RelationshipGraph(this.#nodes, active.values(), this.#registry);
+    return Object.freeze({
+      version: included.length,
+      ...included.at(-1) ? { asOf: included.at(-1).timestamp } : {},
+      edges: graph2.edges(),
+      graph: graph2
+    });
+  }
+  /** Page the immutable event stream with a cursor bound to this log version. */
+  page(options) {
+    if (!Number.isInteger(options.limit) || options.limit < 1)
+      throw new TypeError("Relationship event page limit must be positive");
+    const fingerprint = createQueryFingerprint("relationship-events", {
+      order: "append-sequence"
+    });
+    const snapshot = options.cursor === void 0 ? this.version : Number(decodeQueryCursorState(options.cursor, fingerprint).snapshot);
+    if (!Number.isSafeInteger(snapshot) || snapshot < 0 || snapshot > this.version)
+      throw new TypeError("Relationship event cursor snapshot version is invalid");
+    const page = paginateQueryRows(this.#events.slice(0, snapshot), {
+      cursor: options.cursor,
+      fingerprint,
+      limit: options.limit,
+      readId: (event) => event.eventId,
+      snapshot: String(snapshot)
+    });
+    return {
+      version: snapshot,
+      events: page.rows,
+      hasMore: page.has_more,
+      ...page.next_cursor ? { nextCursor: page.next_cursor } : {}
+    };
+  }
+};
+var RELATIONSHIP_STORE_LOCK_ID = "relationship-event-store";
+var RELATIONSHIP_NOFOLLOW_FLAG = constants.O_NOFOLLOW;
+function acquireRelationshipStoreLock(pmRoot) {
+  return acquireLock(pmRoot, RELATIONSHIP_STORE_LOCK_ID, 30, `relationship-store:${process.pid}`, false, false, 3e3);
+}
+async function resolveRelationshipEventStorePath(pmRoot, relativePath = "relationships/events.jsonl") {
+  const root = path.resolve(pmRoot);
+  const target = path.resolve(root, relativePath);
+  const relative = path.relative(root, target);
+  if (relative.length === 0)
+    throw new TypeError("Relationship event path must name a file within the tracker root");
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+    throw new TypeError("Relationship event path must stay within the tracker root");
+  await mkdir(root, { recursive: true });
+  const rootStats = await lstat(root);
+  if (rootStats.isSymbolicLink())
+    throw new TypeError("Relationship event tracker root must not be a symbolic link");
+  let current = root;
+  for (const segment of relative.split(path.sep)) {
+    current = path.join(current, segment);
+    try {
+      if ((await lstat(current)).isSymbolicLink())
+        throw new TypeError("Relationship event path must not contain symbolic links");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        break;
+      throw error;
+    }
+  }
+  return target;
+}
+async function loadRelationshipEventLog(target, nodes, registry) {
+  const log = new RelationshipEventLog(nodes, { registry });
+  let raw;
+  let handle;
+  try {
+    handle = await open(target, constants.O_RDONLY | RELATIONSHIP_NOFOLLOW_FLAG);
+    raw = await handle.readFile("utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return log;
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+  const lines = raw.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    if (!line)
+      continue;
+    let stored;
+    try {
+      stored = JSON.parse(line);
+    } catch {
+      throw new TypeError(`Invalid relationship event JSONL at line ${index + 1}`);
+    }
+    if (stored.sequence !== log.version + 1)
+      throw new TypeError(`Invalid relationship event sequence at line ${index + 1}`);
+    log.append({
+      eventId: stored.eventId,
+      relationshipId: stored.relationshipId,
+      action: stored.action,
+      ...stored.edge === void 0 ? {} : { edge: stored.edge },
+      author: stored.author,
+      timestamp: stored.timestamp,
+      ...stored.reason === void 0 ? {} : { reason: stored.reason },
+      expectedVersion: log.version
+    });
+  }
+  return log;
+}
+var RelationshipEventStore = class _RelationshipEventStore {
+  #pmRoot;
+  #nodes;
+  #registry;
+  #path;
+  #log;
+  constructor(options, nodes, target, log) {
+    this.#pmRoot = options.pmRoot;
+    this.#nodes = nodes;
+    this.#registry = options.registry;
+    this.#path = target;
+    this.#log = log;
+  }
+  /** Open and validate an existing stream or create an empty store view. */
+  static async open(options) {
+    const nodes = Object.freeze([...options.nodes]);
+    const target = await resolveRelationshipEventStorePath(options.pmRoot, options.relativePath);
+    const release2 = await acquireRelationshipStoreLock(options.pmRoot);
+    try {
+      await resolveRelationshipEventStorePath(options.pmRoot, target);
+      const log = await loadRelationshipEventLog(target, nodes, options.registry);
+      return new _RelationshipEventStore(options, nodes, target, log);
+    } finally {
+      await release2();
+    }
+  }
+  /** Absolute JSONL path, exposed for diagnostics and backup tooling. */
+  get path() {
+    return this.#path;
+  }
+  /** Refresh from durable history and return the current validated append sequence. */
+  async currentVersion() {
+    this.#log = await this.#refreshFromDurableHistory();
+    return this.#log.version;
+  }
+  /** Append one event after refreshing under the shared workspace lock. */
+  async append(input) {
+    const release2 = await acquireRelationshipStoreLock(this.#pmRoot);
+    try {
+      const target = await resolveRelationshipEventStorePath(this.#pmRoot, this.#path);
+      const refreshed = await loadRelationshipEventLog(target, this.#nodes, this.#registry);
+      const event = refreshed.append(input);
+      await mkdir(path.dirname(target), { recursive: true });
+      await resolveRelationshipEventStorePath(this.#pmRoot, target);
+      const handle = await open(target, constants.O_APPEND | constants.O_CREAT | constants.O_WRONLY | RELATIONSHIP_NOFOLLOW_FLAG);
+      try {
+        await handle.appendFile(`${JSON.stringify(event)}
+`, "utf8");
+      } finally {
+        await handle.close();
+      }
+      this.#log = refreshed;
+      return event;
+    } finally {
+      await release2();
+    }
+  }
+  /** Refresh from durable history and materialize an exact validated snapshot. */
+  async snapshot(options = {}) {
+    this.#log = await this.#refreshFromDurableHistory();
+    return this.#log.snapshot(options);
+  }
+  /** Refresh from durable history and page immutable events. */
+  async page(options) {
+    this.#log = await this.#refreshFromDurableHistory();
+    return this.#log.page(options);
+  }
+  /**
+   * Refresh once under the shared store lock, then stream a coherent immutable
+   * prefix without holding the writer lock while the consumer processes batches.
+   */
+  async *stream(options = {}) {
+    this.#log = await this.#refreshFromDurableHistory();
+    yield* this.#log.stream(options);
+  }
+  /** Refresh once and fold a coherent durable prefix into application state. */
+  async project(initialState, reducer, options = {}) {
+    this.#log = await this.#refreshFromDurableHistory();
+    return this.#log.project(initialState, reducer, options);
+  }
+  /** Serialize a durable refresh with writers so readers never observe a torn JSONL tail. */
+  async #refreshFromDurableHistory() {
+    const release2 = await acquireRelationshipStoreLock(this.#pmRoot);
+    try {
+      const target = await resolveRelationshipEventStorePath(this.#pmRoot, this.#path);
+      return await loadRelationshipEventLog(target, this.#nodes, this.#registry);
+    } finally {
+      await release2();
+    }
+  }
+};
+
+// dist/sdk/workspace-transaction.js
+import { mkdir as mkdir2, readFile } from "node:fs/promises";
+import path2 from "node:path";
+var WorkspaceTransactionInterruptedError = class extends Error {
+  /** Create one explicit crash-boundary interruption. */
+  constructor(message = "Workspace transaction interrupted") {
+    super(message);
+    this.name = "WorkspaceTransactionInterruptedError";
+  }
+};
+var WORKSPACE_TRANSACTION_LOCK_ID = "sdk-workspace-transaction";
+var TRANSACTION_ID_PATTERN = /^[a-zA-Z0-9._-]+$/;
+var DEFAULT_LOCK_TTL_SECONDS = 30;
+var DEFAULT_LOCK_WAIT_MS = 3e3;
+function requiredIdentifier(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`${label} must be a string`);
+  const normalized = value.trim();
+  if (!normalized || !TRANSACTION_ID_PATTERN.test(normalized))
+    throw new TypeError(`${label} must match [a-zA-Z0-9._-]+`);
+  return normalized;
+}
+function requiredText2(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`${label} must be a string`);
+  const normalized = value.trim();
+  if (!normalized)
+    throw new TypeError(`${label} must be non-empty`);
+  return normalized;
+}
+function positiveInteger(value, fallback, label) {
+  const resolved = value ?? fallback;
+  if (!Number.isInteger(resolved) || resolved <= 0)
+    throw new TypeError(`${label} must be a positive integer`);
+  return resolved;
+}
+function journalPath(pmRoot, transactionId) {
+  return path2.join(pmRoot, "transactions", "sdk", `${transactionId}.json`);
+}
+async function writeJournal(pmRoot, journal) {
+  journal.updatedAt = nowIso();
+  const target = journalPath(pmRoot, journal.transactionId);
+  await mkdir2(path2.dirname(target), { recursive: true });
+  await writeFileAtomic(target, `${JSON.stringify(journal, null, 2)}
+`);
+}
+function hasValidJournalMetadata(journal) {
+  return Number.isInteger(journal.attempt) && typeof journal.author === "string" && typeof journal.createdAt === "string" && typeof journal.updatedAt === "string";
+}
+function createResultMap(source) {
+  return Object.assign(/* @__PURE__ */ Object.create(null), source);
+}
+function cloneJournalValue(value, label) {
+  try {
+    const serialized = JSON.stringify(value, (_key, nestedValue) => {
+      if (typeof nestedValue === "number" && !Number.isFinite(nestedValue))
+        throw new TypeError(`${label} contains a non-finite number`);
+      if (nestedValue === void 0 || typeof nestedValue === "function" || typeof nestedValue === "symbol")
+        throw new TypeError(`${label} contains a non-JSON value`);
+      return nestedValue;
+    });
+    return JSON.parse(serialized);
+  } catch (error) {
+    throw new TypeError(`${label} must be JSON serializable`, { cause: error });
+  }
+}
+function cloneOptionalJournalValue(value, label) {
+  return value === void 0 ? void 0 : cloneJournalValue(value, label);
+}
+function setJournalEntry(target, stepId, value, label) {
+  const cloned = cloneOptionalJournalValue(value, label);
+  if (cloned === void 0)
+    delete target[stepId];
+  else
+    target[stepId] = cloned;
+}
+function isJournalMap(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasUniqueKnownStepIds(value, stepIds) {
+  return Array.isArray(value) && new Set(value).size === value.length && value.every((stepId) => typeof stepId === "string" && stepIds.includes(stepId));
+}
+function hasValidJournalLifecycle(journal, stepIds) {
+  if (!hasUniqueKnownStepIds(journal.startedStepIds, stepIds) || !hasUniqueKnownStepIds(journal.completedStepIds, stepIds) || !isJournalMap(journal.results) || !isJournalMap(journal.compensationData))
+    return false;
+  const startedStepIds = journal.startedStepIds;
+  const started = new Set(startedStepIds);
+  const completedStepIds = journal.completedStepIds;
+  const completed = new Set(completedStepIds);
+  if (Object.keys(journal.compensationData).some((stepId) => !started.has(stepId)) || Object.keys(journal.results).some((stepId) => !completed.has(stepId)))
+    return false;
+  if (journal.status === "committed")
+    return stepIds.every((stepId) => completed.has(stepId));
+  return journal.status !== "compensated" || completed.size === 0 && started.size === 0;
+}
+function parseJournal(raw, transactionId, stepIds) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new TypeError(`Workspace transaction ${transactionId} journal is invalid JSON`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new TypeError(`Workspace transaction ${transactionId} journal is invalid`);
+  const journal = parsed;
+  const identityMatches = journal.schemaVersion === 1 && journal.transactionId === transactionId;
+  const stepsMatch = Array.isArray(journal.stepIds) && journal.stepIds.length === stepIds.length && journal.stepIds.every((stepId, index) => stepId === stepIds[index]);
+  const lifecycleMatches = hasValidJournalLifecycle(journal, stepIds);
+  const metadataMatches = hasValidJournalMetadata(journal);
+  const statusMatches = [
+    "applying",
+    "compensating",
+    "compensated",
+    "committed"
+  ].includes(String(journal.status));
+  if (!identityMatches || !stepsMatch || !lifecycleMatches || !metadataMatches || !statusMatches)
+    throw new TypeError(`Workspace transaction ${transactionId} journal does not match the supplied plan`);
+  return {
+    ...journal,
+    results: createResultMap(journal.results),
+    compensationData: createResultMap(journal.compensationData)
+  };
+}
+async function prepareJournalForApply(options, transactionId, author, stepIds, existing) {
+  let journal = existing;
+  const recovered = journal !== void 0;
+  if (journal?.status === "compensating")
+    await compensateAppliedSteps(options, journal);
+  if (journal === void 0 || journal.status === "compensated") {
+    const timestamp = nowIso();
+    journal = {
+      schemaVersion: 1,
+      transactionId,
+      author,
+      status: "applying",
+      attempt: (journal?.attempt ?? 0) + 1,
+      createdAt: journal?.createdAt ?? timestamp,
+      updatedAt: timestamp,
+      stepIds,
+      startedStepIds: [],
+      completedStepIds: [],
+      results: createResultMap(),
+      compensationData: createResultMap()
+    };
+    await writeJournal(options.pmRoot, journal);
+    await emitTransition(options, journal, "prepared");
+  }
+  return { journal, recovered };
+}
+async function applyPreparedTransaction(options, journal, recovered) {
+  try {
+    await discoverAppliedSteps(journal, options.steps);
+    await writeJournal(options.pmRoot, journal);
+    const completed = new Set(journal.completedStepIds);
+    const started = new Set(journal.startedStepIds);
+    for (const step of options.steps) {
+      if (completed.has(step.id))
+        continue;
+      const inspection = await step.inspect();
+      let result = cloneOptionalJournalValue(inspection.result, `Step ${step.id} result`);
+      if (inspection.state !== "applied") {
+        const compensationData = await step.prepareCompensation?.();
+        setJournalEntry(journal.compensationData, step.id, compensationData, `Step ${step.id} compensation data`);
+        started.add(step.id);
+        journal.startedStepIds = options.steps.map((candidate) => candidate.id).filter((stepId) => started.has(stepId));
+        await writeJournal(options.pmRoot, journal);
+        const appliedResult = await step.apply();
+        result = cloneOptionalJournalValue(appliedResult, `Step ${step.id} result`);
+      }
+      await emitTransition(options, journal, "step_applied", step.id);
+      completed.add(step.id);
+      journal.completedStepIds = options.steps.map((candidate) => candidate.id).filter((stepId) => completed.has(stepId));
+      setJournalEntry(journal.results, step.id, result, `Step ${step.id} result`);
+      await writeJournal(options.pmRoot, journal);
+      await emitTransition(options, journal, "step_recorded", step.id);
+    }
+    await emitTransition(options, journal, "committing");
+    journal.status = "committed";
+    await writeJournal(options.pmRoot, journal);
+    await emitTransition(options, journal, "committed");
+    return {
+      transactionId: journal.transactionId,
+      status: "committed",
+      recovered,
+      results: createResultMap(journal.results)
+    };
+  } catch (error) {
+    if (error instanceof WorkspaceTransactionInterruptedError || journal.status === "committed")
+      throw error;
+    try {
+      await compensateAppliedSteps(options, journal);
+    } catch (compensationError) {
+      throw new AggregateError([error, compensationError], `Workspace transaction failed and compensation failed: ${String(compensationError)}`, { cause: compensationError });
+    }
+    throw error;
+  }
+}
+async function loadJournal(pmRoot, transactionId, stepIds) {
+  try {
+    return parseJournal(await readFile(journalPath(pmRoot, transactionId), "utf8"), transactionId, stepIds);
+  } catch (error) {
+    if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+}
+async function emitTransition(options, journal, transition, stepId) {
+  await options.onTransition?.({
+    transactionId: journal.transactionId,
+    attempt: journal.attempt,
+    transition,
+    ...stepId === void 0 ? {} : { stepId }
+  });
+}
+async function discoverAppliedSteps(journal, steps) {
+  const completed = /* @__PURE__ */ new Set();
+  const results = createResultMap();
+  for (const step of steps) {
+    const inspection = await step.inspect();
+    if (inspection.state === "applied") {
+      completed.add(step.id);
+      setJournalEntry(results, step.id, inspection.result, `Step ${step.id} result`);
+    }
+  }
+  journal.results = results;
+  journal.completedStepIds = steps.map((step) => step.id).filter((stepId) => completed.has(stepId));
+}
+async function compensateAppliedSteps(options, journal) {
+  journal.status = "compensating";
+  await writeJournal(options.pmRoot, journal);
+  await emitTransition(options, journal, "compensating");
+  const completed = new Set(journal.completedStepIds);
+  const started = new Set(journal.startedStepIds);
+  for (const step of [...options.steps].reverse()) {
+    if (!started.has(step.id) && !completed.has(step.id))
+      continue;
+    let shouldCompensate;
+    try {
+      shouldCompensate = started.has(step.id) && (await step.inspect()).state === "applied";
+    } catch {
+      shouldCompensate = started.has(step.id);
+    }
+    if (shouldCompensate) {
+      await emitTransition(options, journal, "step_compensating", step.id);
+      await step.compensate(journal.compensationData[step.id]);
+    }
+    completed.delete(step.id);
+    started.delete(step.id);
+    journal.completedStepIds = options.steps.map((candidate) => candidate.id).filter((stepId) => completed.has(stepId));
+    journal.startedStepIds = options.steps.map((candidate) => candidate.id).filter((stepId) => started.has(stepId));
+    delete journal.results[step.id];
+    delete journal.compensationData[step.id];
+    await writeJournal(options.pmRoot, journal);
+    await emitTransition(options, journal, "step_compensated", step.id);
+  }
+  journal.status = "compensated";
+  await writeJournal(options.pmRoot, journal);
+  await emitTransition(options, journal, "compensated");
+}
+async function commitWorkspaceTransaction(options) {
+  const pmRoot = requiredText2(options.pmRoot, "Transaction pmRoot");
+  const transactionId = requiredIdentifier(options.transactionId, "Transaction id");
+  const author = requiredText2(options.author, "Transaction author");
+  const lockTtlSeconds = positiveInteger(options.lockTtlSeconds, DEFAULT_LOCK_TTL_SECONDS, "Transaction lock TTL");
+  const lockWaitMs = positiveInteger(options.lockWaitMs, DEFAULT_LOCK_WAIT_MS, "Transaction lock wait");
+  const steps = [...options.steps];
+  if (steps.length === 0)
+    throw new TypeError("Workspace transaction requires at least one step");
+  const stepIds = steps.map((step) => {
+    const stepId = requiredIdentifier(step.id, "Transaction step id");
+    if (stepId !== step.id)
+      throw new TypeError("Transaction step id must not contain surrounding whitespace");
+    return stepId;
+  });
+  if (new Set(stepIds).size !== stepIds.length)
+    throw new TypeError("Workspace transaction step ids must be unique");
+  const stableOptions = {
+    ...options,
+    pmRoot,
+    transactionId,
+    author,
+    steps,
+    lockTtlSeconds,
+    lockWaitMs
+  };
+  const release2 = await acquireLock(pmRoot, WORKSPACE_TRANSACTION_LOCK_ID, lockTtlSeconds, author, false, false, lockWaitMs);
+  try {
+    const existing = await loadJournal(pmRoot, transactionId, stepIds);
+    const recovered = existing !== void 0;
+    if (existing?.status === "committed")
+      return {
+        transactionId,
+        status: "committed",
+        recovered: true,
+        results: createResultMap(existing.results)
+      };
+    const prepared = await prepareJournalForApply(stableOptions, transactionId, author, stepIds, existing);
+    return await applyPreparedTransaction(stableOptions, prepared.journal, recovered || prepared.recovered);
+  } finally {
+    await release2();
+  }
+}
+
+// dist/sdk/extension-command-context.js
+function createExtensionCommandSdk(pmRoot, client) {
+  return {
+    client,
+    getItemAt: (id, target) => getItemAt(id, target, { pmRoot }),
+    openRelationshipEventStore: (options) => {
+      const registry = createRelationshipKindRegistry();
+      for (const definition of options.definitions) {
+        registry.register(definition);
+      }
+      return RelationshipEventStore.open({
+        pmRoot,
+        nodes: options.nodes,
+        registry,
+        ...options.relativePath === void 0 ? {} : { relativePath: options.relativePath }
+      });
+    },
+    commitWorkspaceTransaction: (options) => commitWorkspaceTransaction({ ...options, pmRoot })
+  };
+}
+
 // dist/sdk/runtime-input.js
 function readRuntimeString(args, key) {
   const value = args[key];
@@ -343,6 +1087,7 @@ function actionGlobalOptions(args) {
   return {
     json: true,
     quiet: true,
+    author: readRuntimeString(args, "author"),
     path: readRuntimeString(args, "path"),
     noExtensions: args.noExtensions === true || args.no_extensions === true,
     noPager: true
@@ -1176,8 +1921,8 @@ async function commitImportedItem(params) {
 }
 
 // dist/cli/commands/guide.js
-import { readFile } from "node:fs/promises";
-import path from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import path3 from "node:path";
 
 // dist/cli/guide-topics.js
 function normalizeTopicToken(value) {
@@ -1613,7 +2358,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
   const contentMode = includeContent ? depth === "deep" ? "full" : "excerpt" : "none";
   const docs2 = [];
   for (const doc of topic.docs) {
-    const absolutePath = path.resolve(packageRoot, doc.path);
+    const absolutePath = path3.resolve(packageRoot, doc.path);
     if (!includeContent) {
       docs2.push({
         path: doc.path,
@@ -1628,7 +2373,7 @@ async function renderGuideDocs(topic, depth, packageRoot) {
       continue;
     }
     try {
-      const rawContent = await readFile(absolutePath, "utf8");
+      const rawContent = await readFile2(absolutePath, "utf8");
       if (depth === "deep") {
         const normalized = normalizeLineEndings(rawContent).trimEnd();
         docs2.push({
@@ -4314,7 +5059,7 @@ function runCompletion(shell, itemTypes = [], tags = [], eagerTagExpansion = fal
 
 // dist/cli/commands/reindex.js
 import fs from "node:fs/promises";
-import path2 from "node:path";
+import path4 from "node:path";
 var MANIFEST_PATH = "index/manifest.json";
 var EMBEDDINGS_PATH = "search/embeddings.jsonl";
 var EMBEDDING_MIGRATION_REINDEX_HINT = "Provider or model has changed since last index. Run pm reindex --mode semantic to rebuild.";
@@ -4376,7 +5121,7 @@ async function hydrateDocuments(pmRoot, candidates, schema2, warnings, itemIds)
         body: parsed.body
       });
     } catch {
-      warnings.push(`item_list_item_read_failed:${path2.relative(pmRoot, candidate.item_path)}`);
+      warnings.push(`item_list_item_read_failed:${path4.relative(pmRoot, candidate.item_path)}`);
       hydrated.push({
         metadata: candidate.metadata,
         body: ""
@@ -4846,8 +5591,8 @@ async function runSemanticReindex(params) {
   };
 }
 async function writeReindexArtifacts(params) {
-  const manifestPath = path2.join(params.pmRoot, MANIFEST_PATH);
-  const embeddingsPath = path2.join(params.pmRoot, EMBEDDINGS_PATH);
+  const manifestPath = path4.join(params.pmRoot, MANIFEST_PATH);
+  const embeddingsPath = path4.join(params.pmRoot, EMBEDDINGS_PATH);
   const keywordCorpusFields = resolveSearchCorpusFields(params.settings);
   const embeddingsLines = params.documentsForKeywordArtifacts.map((document) => JSON.stringify(buildKeywordRecord(document, params.mode, keywordCorpusFields))).join("\n");
   emitReindexProgress(params.progressEnabled, "writing keyword artifacts");
@@ -4911,8 +5656,8 @@ async function runReindex(options, global) {
     emitReindexProgress(progressEnabled, `loaded_items=${metadataDocuments.length}`);
     const generatedAt = nowIso();
     const manifest = buildReindexManifest(mode, generatedAt, metadataDocuments);
-    const manifestPath = path2.join(pmRoot, MANIFEST_PATH);
-    const embeddingsPath = path2.join(pmRoot, EMBEDDINGS_PATH);
+    const manifestPath = path4.join(pmRoot, MANIFEST_PATH);
+    const embeddingsPath = path4.join(pmRoot, EMBEDDINGS_PATH);
     let documentsForKeywordArtifacts = mode === "keyword" ? await hydrateDocuments(pmRoot, documentCandidates, settings.schema, reindexWarnings) : metadataDocuments;
     const semanticWarnings = [];
     let vectorizationLedgerEntries = {};
@@ -4999,10 +5744,11 @@ async function runReindex(options, global) {
 }
 
 // dist/sdk/runtime.js
+var ACTIVE_EXTENSION_HOST_CONTEXT = /* @__PURE__ */ Symbol("pm.active-extension-host-context");
 function splitFullClientMutationOptions(options) {
   return { fullChangedFields: true, options };
 }
-var PmClient = class {
+var PmClient = class _PmClient {
   defaults;
   /** Create a client with workspace, author, and extension-loading defaults. */
   constructor(options = {}) {
@@ -5013,6 +5759,12 @@ var PmClient = class {
       ...options.noExtensions === void 0 ? {} : { noExtensions: options.noExtensions }
     };
   }
+  /** Create a native-action client that reuses an extension host's active schema context. */
+  static forActiveExtensionHost(options) {
+    const client = new _PmClient({ ...options, noExtensions: true });
+    client.defaults[ACTIVE_EXTENSION_HOST_CONTEXT] = true;
+    return client;
+  }
   /** Run any native or extension-contributed action through the SDK dispatcher. */
   run(action, args = {}) {
     return runAction({ ...this.defaults, ...args, action });
@@ -5714,8 +6466,8 @@ function upgrade(target, options = {}, clientOptions = {}) {
 }
 function buildWorkspaceExtensionRegistrationsCacheKey(pmRoot, settings, cwd) {
   return JSON.stringify([
-    path3.resolve(pmRoot),
-    path3.resolve(cwd ?? process.cwd()),
+    path5.resolve(pmRoot),
+    path5.resolve(cwd ?? process.cwd()),
     settings.extensions.enabled,
     settings.extensions.disabled,
     settings.extensions.policy
@@ -5835,7 +6587,11 @@ async function dispatchActiveExtensionAction(action, args, options, global, acti
     args: readRuntimeStringArray(options.args ?? args.args),
     options: extensionOptionsFromArgs(args, options),
     global,
-    pm_root: active.pmRoot
+    pm_root: active.pmRoot,
+    sdk: createExtensionCommandSdk(active.pmRoot, PmClient.forActiveExtensionHost({
+      pmRoot: active.pmRoot,
+      author: typeof global.author === "string" && global.author.trim() ? global.author.trim() : "pm-extension"
+    }))
   });
   if (!handlerResult.handled) {
     const suffix = handlerResult.warnings.length > 0 ? ` (${handlerResult.warnings.join(", ")})` : "";
@@ -6002,6 +6758,9 @@ async function runAction(args) {
   const explicitCwd = readRuntimeString(resolved.args, "cwd");
   const resolutionCwd = explicitCwd ?? process.cwd();
   try {
+    if (args[ACTIVE_EXTENSION_HOST_CONTEXT] === true) {
+      return await dispatchAction(resolved.action, resolved.args, global, null);
+    }
     return await withActiveExtensions(global, explicitCwd, resolutionCwd, (activeExtensions) => dispatchAction(resolved.action, resolved.args, global, activeExtensions));
   } finally {
     if (invalidateWorkspaceContractsCache) {
@@ -6462,6 +7221,11 @@ async function loadWorkspaceExtensionRegistrations(pmRoot, settings, cwd) {
 }
 
 export {
+  RelationshipEventLog,
+  RelationshipEventStore,
+  WorkspaceTransactionInterruptedError,
+  commitWorkspaceTransaction,
+  createExtensionCommandSdk,
   clearWorkspaceContractsCache,
   readStringOption,
   readBooleanOption,
@@ -6574,6 +7338,6 @@ export {
   readRequiredString,
   runAction
 };
-//# sourceMappingURL=chunk-SIPOACV5.js.map
+//# sourceMappingURL=chunk-46Z6FAVP.js.map
 
-//# debugId=038cbba4-9d1e-5b41-b501-d40eec7260cd
+//# debugId=46a874f8-2610-5028-8e18-b40e6110f614