@archipelagolab/lobi 1.0.1 → 1.0.6

package/dist/chunk-THM2QV25.js

@@ -0,0 +1,108 @@
+import {
+  inspectMatrixDirectRooms,
+  persistMatrixDirectRoomMapping
+} from "./chunk-RPCVN3JA.js";
+import {
+  isStrictDirectRoom
+} from "./chunk-ALKRFDAW.js";
+import {
+  isMatrixQualifiedUserId,
+  normalizeMatrixResolvableTarget
+} from "./chunk-OQP4W4AR.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/send/targets.ts
+init_shims();
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalStringifiedId
+} from "openclaw/plugin-sdk/text-runtime";
+function normalizeTarget(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new Error("Matrix target is required (room:<id> or #alias)");
+  }
+  return trimmed;
+}
+function normalizeThreadId(raw) {
+  return normalizeOptionalStringifiedId(raw) ?? null;
+}
+var MAX_DIRECT_ROOM_CACHE_SIZE = 1024;
+var directRoomCacheByClient = /* @__PURE__ */ new WeakMap();
+function resolveDirectRoomCache(client) {
+  const existing = directRoomCacheByClient.get(client);
+  if (existing) {
+    return existing;
+  }
+  const created = /* @__PURE__ */ new Map();
+  directRoomCacheByClient.set(client, created);
+  return created;
+}
+function setDirectRoomCached(client, key, value) {
+  const directRoomCache = resolveDirectRoomCache(client);
+  directRoomCache.set(key, value);
+  if (directRoomCache.size > MAX_DIRECT_ROOM_CACHE_SIZE) {
+    const oldest = directRoomCache.keys().next().value;
+    if (oldest !== void 0) {
+      directRoomCache.delete(oldest);
+    }
+  }
+}
+async function resolveDirectRoomId(client, userId) {
+  const trimmed = userId.trim();
+  if (!isMatrixQualifiedUserId(trimmed)) {
+    throw new Error(`Matrix user IDs must be fully qualified (got "${trimmed}")`);
+  }
+  const selfUserId = (await client.getUserId().catch(() => null))?.trim() || null;
+  const directRoomCache = resolveDirectRoomCache(client);
+  const cached = directRoomCache.get(trimmed);
+  if (cached && await isStrictDirectRoom({ client, roomId: cached, remoteUserId: trimmed, selfUserId })) {
+    return cached;
+  }
+  if (cached) {
+    directRoomCache.delete(trimmed);
+  }
+  const inspection = await inspectMatrixDirectRooms({
+    client,
+    remoteUserId: trimmed
+  });
+  if (inspection.activeRoomId) {
+    setDirectRoomCached(client, trimmed, inspection.activeRoomId);
+    if (inspection.mappedRoomIds[0] !== inspection.activeRoomId) {
+      await persistMatrixDirectRoomMapping({
+        client,
+        remoteUserId: trimmed,
+        roomId: inspection.activeRoomId
+      }).catch(() => {
+      });
+    }
+    return inspection.activeRoomId;
+  }
+  throw new Error(`No direct room found for ${trimmed} (m.direct missing)`);
+}
+async function resolveMatrixRoomId(client, raw) {
+  const target = normalizeMatrixResolvableTarget(normalizeTarget(raw));
+  const lowered = normalizeLowercaseStringOrEmpty(target);
+  if (lowered.startsWith("user:")) {
+    return await resolveDirectRoomId(client, target.slice("user:".length));
+  }
+  if (isMatrixQualifiedUserId(target)) {
+    return await resolveDirectRoomId(client, target);
+  }
+  if (target.startsWith("#")) {
+    const resolved = await client.resolveRoom(target);
+    if (!resolved) {
+      throw new Error(`Matrix alias ${target} could not be resolved`);
+    }
+    return resolved;
+  }
+  return target;
+}
+
+export {
+  normalizeThreadId,
+  resolveMatrixRoomId
+};
+//# sourceMappingURL=chunk-THM2QV25.js.map

package/dist/chunk-THM2QV25.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/send/targets.ts"],
+  "sourcesContent": ["import {\n  normalizeLowercaseStringOrEmpty,\n  normalizeOptionalStringifiedId,\n} from \"openclaw/plugin-sdk/text-runtime\";\nimport { inspectMatrixDirectRooms, persistMatrixDirectRoomMapping } from \"../direct-management.js\";\nimport { isStrictDirectRoom } from \"../direct-room.js\";\nimport type { MatrixClient } from \"../sdk.js\";\nimport { isMatrixQualifiedUserId, normalizeMatrixResolvableTarget } from \"../target-ids.js\";\n\nfunction normalizeTarget(raw: string): string {\n  const trimmed = raw.trim();\n  if (!trimmed) {\n    throw new Error(\"Matrix target is required (room:<id> or #alias)\");\n  }\n  return trimmed;\n}\n\nexport function normalizeThreadId(raw?: string | number | null): string | null {\n  return normalizeOptionalStringifiedId(raw) ?? null;\n}\n\n// Size-capped to prevent unbounded growth (#4948)\nconst MAX_DIRECT_ROOM_CACHE_SIZE = 1024;\nconst directRoomCacheByClient = new WeakMap<MatrixClient, Map<string, string>>();\n\nfunction resolveDirectRoomCache(client: MatrixClient): Map<string, string> {\n  const existing = directRoomCacheByClient.get(client);\n  if (existing) {\n    return existing;\n  }\n  const created = new Map<string, string>();\n  directRoomCacheByClient.set(client, created);\n  return created;\n}\n\nfunction setDirectRoomCached(client: MatrixClient, key: string, value: string): void {\n  const directRoomCache = resolveDirectRoomCache(client);\n  directRoomCache.set(key, value);\n  if (directRoomCache.size > MAX_DIRECT_ROOM_CACHE_SIZE) {\n    const oldest = directRoomCache.keys().next().value;\n    if (oldest !== undefined) {\n      directRoomCache.delete(oldest);\n    }\n  }\n}\n\nasync function resolveDirectRoomId(client: MatrixClient, userId: string): Promise<string> {\n  const trimmed = userId.trim();\n  if (!isMatrixQualifiedUserId(trimmed)) {\n    throw new Error(`Matrix user IDs must be fully qualified (got \"${trimmed}\")`);\n  }\n  const selfUserId = (await client.getUserId().catch(() => null))?.trim() || null;\n\n  const directRoomCache = resolveDirectRoomCache(client);\n  const cached = directRoomCache.get(trimmed);\n  if (\n    cached &&\n    (await isStrictDirectRoom({ client, roomId: cached, remoteUserId: trimmed, selfUserId }))\n  ) {\n    return cached;\n  }\n  if (cached) {\n    directRoomCache.delete(trimmed);\n  }\n\n  const inspection = await inspectMatrixDirectRooms({\n    client,\n    remoteUserId: trimmed,\n  });\n  if (inspection.activeRoomId) {\n    setDirectRoomCached(client, trimmed, inspection.activeRoomId);\n    if (inspection.mappedRoomIds[0] !== inspection.activeRoomId) {\n      await persistMatrixDirectRoomMapping({\n        client,\n        remoteUserId: trimmed,\n        roomId: inspection.activeRoomId,\n      }).catch(() => {\n        // Ignore persistence errors when send resolution has already found a usable room.\n      });\n    }\n    return inspection.activeRoomId;\n  }\n\n  throw new Error(`No direct room found for ${trimmed} (m.direct missing)`);\n}\n\nexport async function resolveMatrixRoomId(client: MatrixClient, raw: string): Promise<string> {\n  const target = normalizeMatrixResolvableTarget(normalizeTarget(raw));\n  const lowered = normalizeLowercaseStringOrEmpty(target);\n  if (lowered.startsWith(\"user:\")) {\n    return await resolveDirectRoomId(client, target.slice(\"user:\".length));\n  }\n  if (isMatrixQualifiedUserId(target)) {\n    return await resolveDirectRoomId(client, target);\n  }\n  if (target.startsWith(\"#\")) {\n    const resolved = await client.resolveRoom(target);\n    if (!resolved) {\n      throw new Error(`Matrix alias ${target} could not be resolved`);\n    }\n    return resolved;\n  }\n  return target;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAAA;AAAA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAMP,SAAS,gBAAgB,KAAqB;AAC5C,QAAM,UAAU,IAAI,KAAK;AACzB,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,iDAAiD;AAAA,EACnE;AACA,SAAO;AACT;AAEO,SAAS,kBAAkB,KAA6C;AAC7E,SAAO,+BAA+B,GAAG,KAAK;AAChD;AAGA,IAAM,6BAA6B;AACnC,IAAM,0BAA0B,oBAAI,QAA2C;AAE/E,SAAS,uBAAuB,QAA2C;AACzE,QAAM,WAAW,wBAAwB,IAAI,MAAM;AACnD,MAAI,UAAU;AACZ,WAAO;AAAA,EACT;AACA,QAAM,UAAU,oBAAI,IAAoB;AACxC,0BAAwB,IAAI,QAAQ,OAAO;AAC3C,SAAO;AACT;AAEA,SAAS,oBAAoB,QAAsB,KAAa,OAAqB;AACnF,QAAM,kBAAkB,uBAAuB,MAAM;AACrD,kBAAgB,IAAI,KAAK,KAAK;AAC9B,MAAI,gBAAgB,OAAO,4BAA4B;AACrD,UAAM,SAAS,gBAAgB,KAAK,EAAE,KAAK,EAAE;AAC7C,QAAI,WAAW,QAAW;AACxB,sBAAgB,OAAO,MAAM;AAAA,IAC/B;AAAA,EACF;AACF;AAEA,eAAe,oBAAoB,QAAsB,QAAiC;AACxF,QAAM,UAAU,OAAO,KAAK;AAC5B,MAAI,CAAC,wBAAwB,OAAO,GAAG;AACrC,UAAM,IAAI,MAAM,iDAAiD,OAAO,IAAI;AAAA,EAC9E;AACA,QAAM,cAAc,MAAM,OAAO,UAAU,EAAE,MAAM,MAAM,IAAI,IAAI,KAAK,KAAK;AAE3E,QAAM,kBAAkB,uBAAuB,MAAM;AACrD,QAAM,SAAS,gBAAgB,IAAI,OAAO;AAC1C,MACE,UACC,MAAM,mBAAmB,EAAE,QAAQ,QAAQ,QAAQ,cAAc,SAAS,WAAW,CAAC,GACvF;AACA,WAAO;AAAA,EACT;AACA,MAAI,QAAQ;AACV,oBAAgB,OAAO,OAAO;AAAA,EAChC;AAEA,QAAM,aAAa,MAAM,yBAAyB;AAAA,IAChD;AAAA,IACA,cAAc;AAAA,EAChB,CAAC;AACD,MAAI,WAAW,cAAc;AAC3B,wBAAoB,QAAQ,SAAS,WAAW,YAAY;AAC5D,QAAI,WAAW,cAAc,CAAC,MAAM,WAAW,cAAc;AAC3D,YAAM,+BAA+B;AAAA,QACnC;AAAA,QACA,cAAc;AAAA,QACd,QAAQ,WAAW;AAAA,MACrB,CAAC,EAAE,MAAM,MAAM;AAAA,MAEf,CAAC;AAAA,IACH;AACA,WAAO,WAAW;AAAA,EACpB;AAEA,QAAM,IAAI,MAAM,4BAA4B,OAAO,qBAAqB;AAC1E;AAEA,eAAsB,oBAAoB,QAAsB,KAA8B;AAC5F,QAAM,SAAS,gCAAgC,gBAAgB,GAAG,CAAC;AACnE,QAAM,UAAU,gCAAgC,MAAM;AACtD,MAAI,QAAQ,WAAW,OAAO,GAAG;AAC/B,WAAO,MAAM,oBAAoB,QAAQ,OAAO,MAAM,QAAQ,MAAM,CAAC;AAAA,EACvE;AACA,MAAI,wBAAwB,MAAM,GAAG;AACnC,WAAO,MAAM,oBAAoB,QAAQ,MAAM;AAAA,EACjD;AACA,MAAI,OAAO,WAAW,GAAG,GAAG;AAC1B,UAAM,WAAW,MAAM,OAAO,YAAY,MAAM;AAChD,QAAI,CAAC,UAAU;AACb,YAAM,IAAI,MAAM,gBAAgB,MAAM,wBAAwB;AAAA,IAChE;AACA,WAAO;AAAA,EACT;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/chunk-TMQMQ67T.js

@@ -0,0 +1,81 @@
+import {
+  isBunRuntime
+} from "./chunk-6HDYPVA4.js";
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/matrix/probe.ts
+init_shims();
+import { formatErrorMessage } from "openclaw/plugin-sdk/infra-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+var matrixProbeRuntimeDepsPromise;
+async function loadMatrixProbeRuntimeDeps() {
+  matrixProbeRuntimeDepsPromise ??= import("./src/matrix/probe.runtime.js").then((runtimeModule) => ({
+    createMatrixClient: runtimeModule.createMatrixClient
+  }));
+  return await matrixProbeRuntimeDepsPromise;
+}
+async function probeMatrix(params) {
+  const started = Date.now();
+  const result = {
+    ok: false,
+    status: null,
+    error: null,
+    elapsedMs: 0
+  };
+  if (isBunRuntime()) {
+    return {
+      ...result,
+      error: "Matrix probe requires Node (bun runtime not supported)",
+      elapsedMs: Date.now() - started
+    };
+  }
+  if (!params.homeserver?.trim()) {
+    return {
+      ...result,
+      error: "missing homeserver",
+      elapsedMs: Date.now() - started
+    };
+  }
+  if (!params.accessToken?.trim()) {
+    return {
+      ...result,
+      error: "missing access token",
+      elapsedMs: Date.now() - started
+    };
+  }
+  try {
+    const { createMatrixClient } = await loadMatrixProbeRuntimeDeps();
+    const inputUserId = normalizeOptionalString(params.userId);
+    const client = await createMatrixClient({
+      homeserver: params.homeserver,
+      userId: inputUserId,
+      accessToken: params.accessToken,
+      deviceId: params.deviceId,
+      persistStorage: false,
+      localTimeoutMs: params.timeoutMs,
+      accountId: params.accountId,
+      allowPrivateNetwork: params.allowPrivateNetwork,
+      ssrfPolicy: params.ssrfPolicy,
+      dispatcherPolicy: params.dispatcherPolicy
+    });
+    const userId = await client.getUserId();
+    result.ok = true;
+    result.userId = userId ?? null;
+    result.elapsedMs = Date.now() - started;
+    return result;
+  } catch (err) {
+    return {
+      ...result,
+      status: typeof err === "object" && err && "statusCode" in err ? Number(err.statusCode) : result.status,
+      error: formatErrorMessage(err),
+      elapsedMs: Date.now() - started
+    };
+  }
+}
+
+export {
+  probeMatrix
+};
+//# sourceMappingURL=chunk-TMQMQ67T.js.map

package/dist/chunk-TMQMQ67T.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/probe.ts"],
+  "sourcesContent": ["import { formatErrorMessage, type PinnedDispatcherPolicy } from \"openclaw/plugin-sdk/infra-runtime\";\nimport { normalizeOptionalString } from \"openclaw/plugin-sdk/text-runtime\";\nimport type { SsrFPolicy } from \"../runtime-api.js\";\nimport type { BaseProbeResult } from \"../runtime-api.js\";\nimport { isBunRuntime } from \"./client/runtime.js\";\n\ntype MatrixProbeRuntimeDeps = Pick<typeof import(\"./probe.runtime.js\"), \"createMatrixClient\">;\n\nlet matrixProbeRuntimeDepsPromise: Promise<MatrixProbeRuntimeDeps> | undefined;\n\nasync function loadMatrixProbeRuntimeDeps(): Promise<MatrixProbeRuntimeDeps> {\n  matrixProbeRuntimeDepsPromise ??= import(\"./probe.runtime.js\").then((runtimeModule) => ({\n    createMatrixClient: runtimeModule.createMatrixClient,\n  }));\n  return await matrixProbeRuntimeDepsPromise;\n}\n\nexport type MatrixProbe = BaseProbeResult & {\n  status?: number | null;\n  elapsedMs: number;\n  userId?: string | null;\n};\n\nexport async function probeMatrix(params: {\n  homeserver: string;\n  accessToken: string;\n  userId?: string;\n  deviceId?: string;\n  timeoutMs?: number;\n  accountId?: string | null;\n  allowPrivateNetwork?: boolean;\n  ssrfPolicy?: SsrFPolicy;\n  dispatcherPolicy?: PinnedDispatcherPolicy;\n}): Promise<MatrixProbe> {\n  const started = Date.now();\n  const result: MatrixProbe = {\n    ok: false,\n    status: null,\n    error: null,\n    elapsedMs: 0,\n  };\n  if (isBunRuntime()) {\n    return {\n      ...result,\n      error: \"Matrix probe requires Node (bun runtime not supported)\",\n      elapsedMs: Date.now() - started,\n    };\n  }\n  if (!params.homeserver?.trim()) {\n    return {\n      ...result,\n      error: \"missing homeserver\",\n      elapsedMs: Date.now() - started,\n    };\n  }\n  if (!params.accessToken?.trim()) {\n    return {\n      ...result,\n      error: \"missing access token\",\n      elapsedMs: Date.now() - started,\n    };\n  }\n  try {\n    const { createMatrixClient } = await loadMatrixProbeRuntimeDeps();\n    const inputUserId = normalizeOptionalString(params.userId);\n    const client = await createMatrixClient({\n      homeserver: params.homeserver,\n      userId: inputUserId,\n      accessToken: params.accessToken,\n      deviceId: params.deviceId,\n      persistStorage: false,\n      localTimeoutMs: params.timeoutMs,\n      accountId: params.accountId,\n      allowPrivateNetwork: params.allowPrivateNetwork,\n      ssrfPolicy: params.ssrfPolicy,\n      dispatcherPolicy: params.dispatcherPolicy,\n    });\n    // The client wrapper resolves user ID via whoami when needed.\n    const userId = await client.getUserId();\n    result.ok = true;\n    result.userId = userId ?? null;\n\n    result.elapsedMs = Date.now() - started;\n    return result;\n  } catch (err) {\n    return {\n      ...result,\n      status:\n        typeof err === \"object\" && err && \"statusCode\" in err\n          ? Number((err as { statusCode?: number }).statusCode)\n          : result.status,\n      error: formatErrorMessage(err),\n      elapsedMs: Date.now() - started,\n    };\n  }\n}\n"],
+  "mappings": ";;;;;;;;AAAA;AAAA,SAAS,0BAAuD;AAChE,SAAS,+BAA+B;AAOxC,IAAI;AAEJ,eAAe,6BAA8D;AAC3E,oCAAkC,OAAO,+BAAoB,EAAE,KAAK,CAAC,mBAAmB;AAAA,IACtF,oBAAoB,cAAc;AAAA,EACpC,EAAE;AACF,SAAO,MAAM;AACf;AAQA,eAAsB,YAAY,QAUT;AACvB,QAAM,UAAU,KAAK,IAAI;AACzB,QAAM,SAAsB;AAAA,IAC1B,IAAI;AAAA,IACJ,QAAQ;AAAA,IACR,OAAO;AAAA,IACP,WAAW;AAAA,EACb;AACA,MAAI,aAAa,GAAG;AAClB,WAAO;AAAA,MACL,GAAG;AAAA,MACH,OAAO;AAAA,MACP,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAAA,EACF;AACA,MAAI,CAAC,OAAO,YAAY,KAAK,GAAG;AAC9B,WAAO;AAAA,MACL,GAAG;AAAA,MACH,OAAO;AAAA,MACP,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAAA,EACF;AACA,MAAI,CAAC,OAAO,aAAa,KAAK,GAAG;AAC/B,WAAO;AAAA,MACL,GAAG;AAAA,MACH,OAAO;AAAA,MACP,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAAA,EACF;AACA,MAAI;AACF,UAAM,EAAE,mBAAmB,IAAI,MAAM,2BAA2B;AAChE,UAAM,cAAc,wBAAwB,OAAO,MAAM;AACzD,UAAM,SAAS,MAAM,mBAAmB;AAAA,MACtC,YAAY,OAAO;AAAA,MACnB,QAAQ;AAAA,MACR,aAAa,OAAO;AAAA,MACpB,UAAU,OAAO;AAAA,MACjB,gBAAgB;AAAA,MAChB,gBAAgB,OAAO;AAAA,MACvB,WAAW,OAAO;AAAA,MAClB,qBAAqB,OAAO;AAAA,MAC5B,YAAY,OAAO;AAAA,MACnB,kBAAkB,OAAO;AAAA,IAC3B,CAAC;AAED,UAAM,SAAS,MAAM,OAAO,UAAU;AACtC,WAAO,KAAK;AACZ,WAAO,SAAS,UAAU;AAE1B,WAAO,YAAY,KAAK,IAAI,IAAI;AAChC,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,WAAO;AAAA,MACL,GAAG;AAAA,MACH,QACE,OAAO,QAAQ,YAAY,OAAO,gBAAgB,MAC9C,OAAQ,IAAgC,UAAU,IAClD,OAAO;AAAA,MACb,OAAO,mBAAmB,GAAG;AAAA,MAC7B,WAAW,KAAK,IAAI,IAAI;AAAA,IAC1B;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/chunk-TPYWUZOR.js

@@ -0,0 +1,178 @@
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/matrix/monitor/room-history.ts
+init_shims();
+var DEFAULT_MAX_QUEUE_SIZE = 200;
+var DEFAULT_MAX_ROOM_QUEUES = 1e3;
+var MAX_WATERMARK_ENTRIES = 5e3;
+var MAX_PREPARED_TRIGGER_ENTRIES = 500;
+function createRoomHistoryTrackerInternal(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoomQueues = DEFAULT_MAX_ROOM_QUEUES, maxWatermarkEntries = MAX_WATERMARK_ENTRIES, maxPreparedTriggerEntries = MAX_PREPARED_TRIGGER_ENTRIES) {
+  const roomQueues = /* @__PURE__ */ new Map();
+  const agentWatermarks = /* @__PURE__ */ new Map();
+  let nextQueueGeneration = 1;
+  function clearRoomWatermarks(roomId) {
+    const roomSuffix = `:${roomId}`;
+    for (const key of agentWatermarks.keys()) {
+      if (key.endsWith(roomSuffix)) {
+        agentWatermarks.delete(key);
+      }
+    }
+  }
+  function getOrCreateQueue(roomId) {
+    let queue = roomQueues.get(roomId);
+    if (!queue) {
+      queue = {
+        entries: [],
+        baseIndex: 0,
+        generation: nextQueueGeneration++,
+        preparedTriggers: /* @__PURE__ */ new Map()
+      };
+      roomQueues.set(roomId, queue);
+      if (roomQueues.size > maxRoomQueues) {
+        const oldest = roomQueues.keys().next().value;
+        if (oldest !== void 0) {
+          roomQueues.delete(oldest);
+          clearRoomWatermarks(oldest);
+        }
+      }
+    }
+    return queue;
+  }
+  function appendToQueue(queue, entry) {
+    queue.entries.push(entry);
+    if (queue.entries.length > maxQueueSize) {
+      const overflow = queue.entries.length - maxQueueSize;
+      queue.entries.splice(0, overflow);
+      queue.baseIndex += overflow;
+    }
+    return {
+      snapshotIdx: queue.baseIndex + queue.entries.length,
+      queueGeneration: queue.generation
+    };
+  }
+  function wmKey(agentId, roomId) {
+    return `${agentId}:${roomId}`;
+  }
+  function preparedTriggerKey(agentId, messageId) {
+    if (!messageId?.trim()) {
+      return null;
+    }
+    return `${agentId}:${messageId.trim()}`;
+  }
+  function rememberWatermark(key, snapshotIdx) {
+    const nextSnapshotIdx = Math.max(agentWatermarks.get(key) ?? 0, snapshotIdx);
+    if (agentWatermarks.has(key)) {
+      agentWatermarks.delete(key);
+    }
+    agentWatermarks.set(key, nextSnapshotIdx);
+    if (agentWatermarks.size > maxWatermarkEntries) {
+      const oldest = agentWatermarks.keys().next().value;
+      if (oldest !== void 0) {
+        agentWatermarks.delete(oldest);
+      }
+    }
+  }
+  function rememberPreparedTrigger(queue, retryKey, prepared) {
+    if (queue.preparedTriggers.has(retryKey)) {
+      queue.preparedTriggers.delete(retryKey);
+    }
+    queue.preparedTriggers.set(retryKey, prepared);
+    if (queue.preparedTriggers.size > maxPreparedTriggerEntries) {
+      const oldest = queue.preparedTriggers.keys().next().value;
+      if (oldest !== void 0) {
+        queue.preparedTriggers.delete(oldest);
+      }
+    }
+    return prepared;
+  }
+  function computePendingHistory(queue, agentId, roomId, limit) {
+    if (limit <= 0 || queue.entries.length === 0) {
+      return [];
+    }
+    const wm = agentWatermarks.get(wmKey(agentId, roomId)) ?? 0;
+    const startAbs = Math.max(wm, queue.baseIndex);
+    const startRel = startAbs - queue.baseIndex;
+    const available = queue.entries.slice(startRel);
+    return available.length > limit ? available.slice(-limit) : available;
+  }
+  return {
+    recordPending(roomId, entry) {
+      const queue = getOrCreateQueue(roomId);
+      appendToQueue(queue, entry);
+    },
+    getPendingHistory(agentId, roomId, limit) {
+      const queue = roomQueues.get(roomId);
+      if (!queue) {
+        return [];
+      }
+      return computePendingHistory(queue, agentId, roomId, limit);
+    },
+    recordTrigger(roomId, entry) {
+      const queue = getOrCreateQueue(roomId);
+      return appendToQueue(queue, entry);
+    },
+    prepareTrigger(agentId, roomId, limit, entry) {
+      const queue = getOrCreateQueue(roomId);
+      const retryKey = preparedTriggerKey(agentId, entry.messageId);
+      if (retryKey) {
+        const prepared2 = queue.preparedTriggers.get(retryKey);
+        if (prepared2) {
+          return rememberPreparedTrigger(queue, retryKey, prepared2);
+        }
+      }
+      const prepared = {
+        history: computePendingHistory(queue, agentId, roomId, limit),
+        ...appendToQueue(queue, entry)
+      };
+      if (retryKey) {
+        return rememberPreparedTrigger(queue, retryKey, prepared);
+      }
+      return prepared;
+    },
+    consumeHistory(agentId, roomId, snapshot, messageId) {
+      const key = wmKey(agentId, roomId);
+      const queue = roomQueues.get(roomId);
+      if (!queue) {
+        agentWatermarks.delete(key);
+        return;
+      }
+      if (queue.generation !== snapshot.queueGeneration) {
+        return;
+      }
+      rememberWatermark(key, snapshot.snapshotIdx);
+      const retryKey = preparedTriggerKey(agentId, messageId);
+      if (queue && retryKey) {
+        queue.preparedTriggers.delete(retryKey);
+      }
+    }
+  };
+}
+function createRoomHistoryTracker(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoomQueues = DEFAULT_MAX_ROOM_QUEUES, maxWatermarkEntries = MAX_WATERMARK_ENTRIES, maxPreparedTriggerEntries = MAX_PREPARED_TRIGGER_ENTRIES) {
+  const tracker = createRoomHistoryTrackerInternal(
+    maxQueueSize,
+    maxRoomQueues,
+    maxWatermarkEntries,
+    maxPreparedTriggerEntries
+  );
+  return {
+    recordPending: tracker.recordPending,
+    prepareTrigger: tracker.prepareTrigger,
+    consumeHistory: tracker.consumeHistory
+  };
+}
+function createRoomHistoryTrackerForTests(maxQueueSize = DEFAULT_MAX_QUEUE_SIZE, maxRoomQueues = DEFAULT_MAX_ROOM_QUEUES, maxWatermarkEntries = MAX_WATERMARK_ENTRIES, maxPreparedTriggerEntries = MAX_PREPARED_TRIGGER_ENTRIES) {
+  return createRoomHistoryTrackerInternal(
+    maxQueueSize,
+    maxRoomQueues,
+    maxWatermarkEntries,
+    maxPreparedTriggerEntries
+  );
+}
+
+export {
+  createRoomHistoryTracker,
+  createRoomHistoryTrackerForTests
+};
+//# sourceMappingURL=chunk-TPYWUZOR.js.map

package/dist/chunk-TPYWUZOR.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/monitor/room-history.ts"],
+  "sourcesContent": ["/**\n * Per-room group chat history tracking for Matrix.\n *\n * Maintains a shared per-room message queue and per-(agentId, roomId) watermarks so\n * each agent independently tracks which messages it has already consumed. This design\n * lets multiple agents in the same room see independent history windows:\n *\n * - dev replies to @dev msgB (watermark advances to B) \u2192 room queue still has [A, B]\n * - spark replies to @spark msgC \u2192 spark watermark starts at 0 and sees [A, B, C]\n *\n * Race-condition safety: the watermark only advances to the snapshot index taken at\n * dispatch time, NOT to the queue's end at reply time.  Messages that land in the queue\n * while the agent is processing stay visible to the next trigger for that agent.\n */\n\nimport type { HistoryEntry } from \"openclaw/plugin-sdk/reply-history\";\n\n/** Maximum entries retained per room (hard cap to bound memory). */\nconst DEFAULT_MAX_QUEUE_SIZE = 200;\n/** Maximum number of rooms to retain queues for (FIFO eviction beyond this). */\nconst DEFAULT_MAX_ROOM_QUEUES = 1000;\n/** Maximum number of (agentId, roomId) watermark entries to retain. */\nconst MAX_WATERMARK_ENTRIES = 5000;\n/** Maximum prepared trigger snapshots retained per room for retry reuse. */\nconst MAX_PREPARED_TRIGGER_ENTRIES = 500;\n\nexport type { HistoryEntry };\n\nexport type HistorySnapshotToken = {\n  snapshotIdx: number;\n  queueGeneration: number;\n};\n\nexport type PreparedTriggerResult = {\n  history: HistoryEntry[];\n} & HistorySnapshotToken;\n\nexport type RoomHistoryTracker = {\n  /**\n   * Record a non-trigger message for future context.\n   * Call this when a room message arrives but does not mention the bot.\n   */\n  recordPending: (roomId: string, entry: HistoryEntry) => void;\n\n  /**\n   * Capture pending history and append the trigger as one idempotent operation.\n   * Retries of the same Matrix event reuse the original prepared history window.\n   */\n  prepareTrigger: (\n    agentId: string,\n    roomId: string,\n    limit: number,\n    entry: HistoryEntry,\n  ) => PreparedTriggerResult;\n\n  /**\n   * Advance the agent's watermark to the snapshot index returned by prepareTrigger\n   * (or the lower-level recordTrigger helper used in tests).\n   * Only messages appended after that snapshot remain visible on the next trigger.\n   */\n  consumeHistory: (\n    agentId: string,\n    roomId: string,\n    snapshot: HistorySnapshotToken,\n    messageId?: string,\n  ) => void;\n};\n\nexport type RoomHistoryTrackerTestApi = RoomHistoryTracker & {\n  /**\n   * Test-only helper for inspecting pending room history directly.\n   */\n  getPendingHistory: (agentId: string, roomId: string, limit: number) => HistoryEntry[];\n\n  /**\n   * Test-only helper for manually appending a trigger entry and snapshot index.\n   */\n  recordTrigger: (roomId: string, entry: HistoryEntry) => HistorySnapshotToken;\n};\n\ntype RoomQueue = {\n  entries: HistoryEntry[];\n  /** Absolute index of entries[0] \u2014 increases as old entries are trimmed. */\n  baseIndex: number;\n  generation: number;\n  preparedTriggers: Map<string, PreparedTriggerResult>;\n};\n\nfunction createRoomHistoryTrackerInternal(\n  maxQueueSize = DEFAULT_MAX_QUEUE_SIZE,\n  maxRoomQueues = DEFAULT_MAX_ROOM_QUEUES,\n  maxWatermarkEntries = MAX_WATERMARK_ENTRIES,\n  maxPreparedTriggerEntries = MAX_PREPARED_TRIGGER_ENTRIES,\n): RoomHistoryTrackerTestApi {\n  const roomQueues = new Map<string, RoomQueue>();\n  /** Maps `${agentId}:${roomId}` \u2192 absolute consumed-up-to index */\n  const agentWatermarks = new Map<string, number>();\n  let nextQueueGeneration = 1;\n\n  function clearRoomWatermarks(roomId: string): void {\n    const roomSuffix = `:${roomId}`;\n    for (const key of agentWatermarks.keys()) {\n      if (key.endsWith(roomSuffix)) {\n        agentWatermarks.delete(key);\n      }\n    }\n  }\n\n  function getOrCreateQueue(roomId: string): RoomQueue {\n    let queue = roomQueues.get(roomId);\n    if (!queue) {\n      queue = {\n        entries: [],\n        baseIndex: 0,\n        generation: nextQueueGeneration++,\n        preparedTriggers: new Map(),\n      };\n      roomQueues.set(roomId, queue);\n      // FIFO eviction to prevent unbounded growth across many rooms\n      if (roomQueues.size > maxRoomQueues) {\n        const oldest = roomQueues.keys().next().value;\n        if (oldest !== undefined) {\n          roomQueues.delete(oldest);\n          clearRoomWatermarks(oldest);\n        }\n      }\n    }\n    return queue;\n  }\n\n  function appendToQueue(queue: RoomQueue, entry: HistoryEntry): HistorySnapshotToken {\n    queue.entries.push(entry);\n    if (queue.entries.length > maxQueueSize) {\n      const overflow = queue.entries.length - maxQueueSize;\n      queue.entries.splice(0, overflow);\n      queue.baseIndex += overflow;\n    }\n    return {\n      snapshotIdx: queue.baseIndex + queue.entries.length,\n      queueGeneration: queue.generation,\n    };\n  }\n\n  function wmKey(agentId: string, roomId: string): string {\n    return `${agentId}:${roomId}`;\n  }\n\n  function preparedTriggerKey(agentId: string, messageId?: string): string | null {\n    if (!messageId?.trim()) {\n      return null;\n    }\n    return `${agentId}:${messageId.trim()}`;\n  }\n\n  function rememberWatermark(key: string, snapshotIdx: number): void {\n    const nextSnapshotIdx = Math.max(agentWatermarks.get(key) ?? 0, snapshotIdx);\n    if (agentWatermarks.has(key)) {\n      // Refresh insertion order so capped-map eviction removes the stalest pair, not an active one.\n      agentWatermarks.delete(key);\n    }\n    agentWatermarks.set(key, nextSnapshotIdx);\n    if (agentWatermarks.size > maxWatermarkEntries) {\n      const oldest = agentWatermarks.keys().next().value;\n      if (oldest !== undefined) {\n        agentWatermarks.delete(oldest);\n      }\n    }\n  }\n\n  function rememberPreparedTrigger(\n    queue: RoomQueue,\n    retryKey: string,\n    prepared: PreparedTriggerResult,\n  ): PreparedTriggerResult {\n    if (queue.preparedTriggers.has(retryKey)) {\n      // Refresh insertion order so capped eviction keeps actively retried events hot.\n      queue.preparedTriggers.delete(retryKey);\n    }\n    queue.preparedTriggers.set(retryKey, prepared);\n    if (queue.preparedTriggers.size > maxPreparedTriggerEntries) {\n      const oldest = queue.preparedTriggers.keys().next().value;\n      if (oldest !== undefined) {\n        queue.preparedTriggers.delete(oldest);\n      }\n    }\n    return prepared;\n  }\n\n  function computePendingHistory(\n    queue: RoomQueue,\n    agentId: string,\n    roomId: string,\n    limit: number,\n  ): HistoryEntry[] {\n    if (limit <= 0 || queue.entries.length === 0) {\n      return [];\n    }\n    const wm = agentWatermarks.get(wmKey(agentId, roomId)) ?? 0;\n    // startAbs: the first absolute index the agent hasn't seen yet\n    const startAbs = Math.max(wm, queue.baseIndex);\n    const startRel = startAbs - queue.baseIndex;\n    const available = queue.entries.slice(startRel);\n    return available.length > limit ? available.slice(-limit) : available;\n  }\n\n  return {\n    recordPending(roomId, entry) {\n      const queue = getOrCreateQueue(roomId);\n      appendToQueue(queue, entry);\n    },\n\n    getPendingHistory(agentId, roomId, limit) {\n      const queue = roomQueues.get(roomId);\n      if (!queue) {\n        return [];\n      }\n      return computePendingHistory(queue, agentId, roomId, limit);\n    },\n\n    recordTrigger(roomId, entry) {\n      const queue = getOrCreateQueue(roomId);\n      return appendToQueue(queue, entry);\n    },\n\n    prepareTrigger(agentId, roomId, limit, entry) {\n      const queue = getOrCreateQueue(roomId);\n      const retryKey = preparedTriggerKey(agentId, entry.messageId);\n      if (retryKey) {\n        const prepared = queue.preparedTriggers.get(retryKey);\n        if (prepared) {\n          return rememberPreparedTrigger(queue, retryKey, prepared);\n        }\n      }\n      const prepared = {\n        history: computePendingHistory(queue, agentId, roomId, limit),\n        ...appendToQueue(queue, entry),\n      };\n      if (retryKey) {\n        return rememberPreparedTrigger(queue, retryKey, prepared);\n      }\n      return prepared;\n    },\n\n    consumeHistory(agentId, roomId, snapshot, messageId) {\n      const key = wmKey(agentId, roomId);\n      const queue = roomQueues.get(roomId);\n      if (!queue) {\n        // The room was evicted while this trigger was in flight. Keep eviction authoritative\n        // so a late completion cannot recreate a stale watermark against a fresh queue.\n        agentWatermarks.delete(key);\n        return;\n      }\n      if (queue.generation !== snapshot.queueGeneration) {\n        // The room was evicted and recreated before this trigger completed. Reject the stale\n        // snapshot so it cannot advance or erase state for the new queue generation.\n        return;\n      }\n      // Monotone write: never regress an already-advanced watermark.\n      // Guards against out-of-order completion when two triggers for the same\n      // (agentId, roomId) are in-flight concurrently.\n      rememberWatermark(key, snapshot.snapshotIdx);\n      const retryKey = preparedTriggerKey(agentId, messageId);\n      if (queue && retryKey) {\n        queue.preparedTriggers.delete(retryKey);\n      }\n    },\n  };\n}\n\nexport function createRoomHistoryTracker(\n  maxQueueSize = DEFAULT_MAX_QUEUE_SIZE,\n  maxRoomQueues = DEFAULT_MAX_ROOM_QUEUES,\n  maxWatermarkEntries = MAX_WATERMARK_ENTRIES,\n  maxPreparedTriggerEntries = MAX_PREPARED_TRIGGER_ENTRIES,\n): RoomHistoryTracker {\n  const tracker = createRoomHistoryTrackerInternal(\n    maxQueueSize,\n    maxRoomQueues,\n    maxWatermarkEntries,\n    maxPreparedTriggerEntries,\n  );\n  return {\n    recordPending: tracker.recordPending,\n    prepareTrigger: tracker.prepareTrigger,\n    consumeHistory: tracker.consumeHistory,\n  };\n}\n\nexport function createRoomHistoryTrackerForTests(\n  maxQueueSize = DEFAULT_MAX_QUEUE_SIZE,\n  maxRoomQueues = DEFAULT_MAX_ROOM_QUEUES,\n  maxWatermarkEntries = MAX_WATERMARK_ENTRIES,\n  maxPreparedTriggerEntries = MAX_PREPARED_TRIGGER_ENTRIES,\n): RoomHistoryTrackerTestApi {\n  return createRoomHistoryTrackerInternal(\n    maxQueueSize,\n    maxRoomQueues,\n    maxWatermarkEntries,\n    maxPreparedTriggerEntries,\n  );\n}\n"],
+  "mappings": "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",
+  "names": ["prepared"]
+}

package/dist/chunk-TRWT2N6Z.js

@@ -0,0 +1,15 @@
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/matrix/client/runtime.ts
+init_shims();
+function isBunRuntime() {
+  const versions = process.versions;
+  return typeof versions.bun === "string";
+}
+
+export {
+  isBunRuntime
+};
+//# sourceMappingURL=chunk-TRWT2N6Z.js.map

package/dist/chunk-TRWT2N6Z.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/client/runtime.ts"],
+  "sourcesContent": ["export function isBunRuntime(): boolean {\n  const versions = process.versions as { bun?: string };\n  return typeof versions.bun === \"string\";\n}\n"],
+  "mappings": ";;;;;AAAA;AAAO,SAAS,eAAwB;AACtC,QAAM,WAAW,QAAQ;AACzB,SAAO,OAAO,SAAS,QAAQ;AACjC;",
+  "names": []
+}

package/dist/chunk-TTXEM54Y.js

@@ -0,0 +1,76 @@
+import {
+  formatMatrixErrorMessage
+} from "./chunk-UWPHOAOC.js";
+import {
+  init_shims
+} from "./chunk-7FLQSTPG.js";
+
+// src/plugin-entry.runtime.ts
+init_shims();
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+function sendError(respond, err) {
+  respond(false, { error: formatMatrixErrorMessage(err) });
+}
+async function ensureMatrixCryptoRuntime(...args) {
+  const { ensureMatrixCryptoRuntime: ensureRuntime } = await import("./src/matrix/deps.js");
+  await ensureRuntime(...args);
+}
+async function handleVerifyRecoveryKey({
+  params,
+  respond
+}) {
+  try {
+    const { verifyMatrixRecoveryKey } = await import("./src/matrix/actions/verification.js");
+    const key = normalizeOptionalString(params?.key);
+    if (!key) {
+      respond(false, { error: "key required" });
+      return;
+    }
+    const accountId = normalizeOptionalString(params?.accountId);
+    const result = await verifyMatrixRecoveryKey(key, { accountId });
+    respond(result.success, result);
+  } catch (err) {
+    sendError(respond, err);
+  }
+}
+async function handleVerificationBootstrap({
+  params,
+  respond
+}) {
+  try {
+    const { bootstrapMatrixVerification } = await import("./src/matrix/actions/verification.js");
+    const accountId = normalizeOptionalString(params?.accountId);
+    const recoveryKey = typeof params?.recoveryKey === "string" ? params.recoveryKey : void 0;
+    const forceResetCrossSigning = params?.forceResetCrossSigning === true;
+    const result = await bootstrapMatrixVerification({
+      accountId,
+      recoveryKey,
+      forceResetCrossSigning
+    });
+    respond(result.success, result);
+  } catch (err) {
+    sendError(respond, err);
+  }
+}
+async function handleVerificationStatus({
+  params,
+  respond
+}) {
+  try {
+    const { getMatrixVerificationStatus } = await import("./src/matrix/actions/verification.js");
+    const accountId = normalizeOptionalString(params?.accountId);
+    const includeRecoveryKey = params?.includeRecoveryKey === true;
+    const status = await getMatrixVerificationStatus({ accountId, includeRecoveryKey });
+    respond(true, status);
+  } catch (err) {
+    sendError(respond, err);
+  }
+}
+
+export {
+  ensureMatrixCryptoRuntime,
+  handleVerifyRecoveryKey,
+  handleVerificationBootstrap,
+  handleVerificationStatus
+};
+//# sourceMappingURL=chunk-TTXEM54Y.js.map

package/dist/chunk-TTXEM54Y.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/plugin-entry.runtime.ts"],
+  "sourcesContent": ["import type { GatewayRequestHandlerOptions } from \"openclaw/plugin-sdk/gateway-runtime\";\nimport { normalizeOptionalString } from \"openclaw/plugin-sdk/text-runtime\";\nimport { formatMatrixErrorMessage } from \"./matrix/errors.js\";\n\nfunction sendError(respond: (ok: boolean, payload?: unknown) => void, err: unknown) {\n  respond(false, { error: formatMatrixErrorMessage(err) });\n}\n\nexport async function ensureMatrixCryptoRuntime(\n  ...args: Parameters<typeof import(\"./matrix/deps.js\").ensureMatrixCryptoRuntime>\n): Promise<void> {\n  const { ensureMatrixCryptoRuntime: ensureRuntime } = await import(\"./matrix/deps.js\");\n  await ensureRuntime(...args);\n}\n\nexport async function handleVerifyRecoveryKey({\n  params,\n  respond,\n}: GatewayRequestHandlerOptions): Promise<void> {\n  try {\n    const { verifyMatrixRecoveryKey } = await import(\"./matrix/actions/verification.js\");\n    const key = normalizeOptionalString(params?.key);\n    if (!key) {\n      respond(false, { error: \"key required\" });\n      return;\n    }\n    const accountId = normalizeOptionalString(params?.accountId);\n    const result = await verifyMatrixRecoveryKey(key, { accountId });\n    respond(result.success, result);\n  } catch (err) {\n    sendError(respond, err);\n  }\n}\n\nexport async function handleVerificationBootstrap({\n  params,\n  respond,\n}: GatewayRequestHandlerOptions): Promise<void> {\n  try {\n    const { bootstrapMatrixVerification } = await import(\"./matrix/actions/verification.js\");\n    const accountId = normalizeOptionalString(params?.accountId);\n    const recoveryKey = typeof params?.recoveryKey === \"string\" ? params.recoveryKey : undefined;\n    const forceResetCrossSigning = params?.forceResetCrossSigning === true;\n    const result = await bootstrapMatrixVerification({\n      accountId,\n      recoveryKey,\n      forceResetCrossSigning,\n    });\n    respond(result.success, result);\n  } catch (err) {\n    sendError(respond, err);\n  }\n}\n\nexport async function handleVerificationStatus({\n  params,\n  respond,\n}: GatewayRequestHandlerOptions): Promise<void> {\n  try {\n    const { getMatrixVerificationStatus } = await import(\"./matrix/actions/verification.js\");\n    const accountId = normalizeOptionalString(params?.accountId);\n    const includeRecoveryKey = params?.includeRecoveryKey === true;\n    const status = await getMatrixVerificationStatus({ accountId, includeRecoveryKey });\n    respond(true, status);\n  } catch (err) {\n    sendError(respond, err);\n  }\n}\n"],
+  "mappings": ";;;;;;;;AAAA;AACA,SAAS,+BAA+B;AAGxC,SAAS,UAAU,SAAmD,KAAc;AAClF,UAAQ,OAAO,EAAE,OAAO,yBAAyB,GAAG,EAAE,CAAC;AACzD;AAEA,eAAsB,6BACjB,MACY;AACf,QAAM,EAAE,2BAA2B,cAAc,IAAI,MAAM,OAAO,sBAAkB;AACpF,QAAM,cAAc,GAAG,IAAI;AAC7B;AAEA,eAAsB,wBAAwB;AAAA,EAC5C;AAAA,EACA;AACF,GAAgD;AAC9C,MAAI;AACF,UAAM,EAAE,wBAAwB,IAAI,MAAM,OAAO,sCAAkC;AACnF,UAAM,MAAM,wBAAwB,QAAQ,GAAG;AAC/C,QAAI,CAAC,KAAK;AACR,cAAQ,OAAO,EAAE,OAAO,eAAe,CAAC;AACxC;AAAA,IACF;AACA,UAAM,YAAY,wBAAwB,QAAQ,SAAS;AAC3D,UAAM,SAAS,MAAM,wBAAwB,KAAK,EAAE,UAAU,CAAC;AAC/D,YAAQ,OAAO,SAAS,MAAM;AAAA,EAChC,SAAS,KAAK;AACZ,cAAU,SAAS,GAAG;AAAA,EACxB;AACF;AAEA,eAAsB,4BAA4B;AAAA,EAChD;AAAA,EACA;AACF,GAAgD;AAC9C,MAAI;AACF,UAAM,EAAE,4BAA4B,IAAI,MAAM,OAAO,sCAAkC;AACvF,UAAM,YAAY,wBAAwB,QAAQ,SAAS;AAC3D,UAAM,cAAc,OAAO,QAAQ,gBAAgB,WAAW,OAAO,cAAc;AACnF,UAAM,yBAAyB,QAAQ,2BAA2B;AAClE,UAAM,SAAS,MAAM,4BAA4B;AAAA,MAC/C;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AACD,YAAQ,OAAO,SAAS,MAAM;AAAA,EAChC,SAAS,KAAK;AACZ,cAAU,SAAS,GAAG;AAAA,EACxB;AACF;AAEA,eAAsB,yBAAyB;AAAA,EAC7C;AAAA,EACA;AACF,GAAgD;AAC9C,MAAI;AACF,UAAM,EAAE,4BAA4B,IAAI,MAAM,OAAO,sCAAkC;AACvF,UAAM,YAAY,wBAAwB,QAAQ,SAAS;AAC3D,UAAM,qBAAqB,QAAQ,uBAAuB;AAC1D,UAAM,SAAS,MAAM,4BAA4B,EAAE,WAAW,mBAAmB,CAAC;AAClF,YAAQ,MAAM,MAAM;AAAA,EACtB,SAAS,KAAK;AACZ,cAAU,SAAS,GAAG;AAAA,EACxB;AACF;",
+  "names": []
+}

package/dist/chunk-U2O4LE6S.js

@@ -0,0 +1,22 @@
+import {
+  init_shims
+} from "./chunk-G4TIS2SC.js";
+
+// src/matrix/sync-state.ts
+init_shims();
+function isMatrixReadySyncState(state) {
+  return state === "PREPARED" || state === "SYNCING" || state === "CATCHUP";
+}
+function isMatrixDisconnectedSyncState(state) {
+  return state === "RECONNECTING" || state === "ERROR" || state === "STOPPED";
+}
+function isMatrixTerminalSyncState(state) {
+  return state === "STOPPED";
+}
+
+export {
+  isMatrixReadySyncState,
+  isMatrixDisconnectedSyncState,
+  isMatrixTerminalSyncState
+};
+//# sourceMappingURL=chunk-U2O4LE6S.js.map

package/dist/chunk-U2O4LE6S.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/matrix/sync-state.ts"],
+  "sourcesContent": ["export type MatrixSyncState =\n  | \"PREPARED\"\n  | \"SYNCING\"\n  | \"CATCHUP\"\n  | \"RECONNECTING\"\n  | \"ERROR\"\n  | \"STOPPED\"\n  | (string & {});\n\nexport function isMatrixReadySyncState(\n  state: MatrixSyncState | null | undefined,\n): state is \"PREPARED\" | \"SYNCING\" | \"CATCHUP\" {\n  return state === \"PREPARED\" || state === \"SYNCING\" || state === \"CATCHUP\";\n}\n\nexport function isMatrixDisconnectedSyncState(\n  state: MatrixSyncState | null | undefined,\n): state is \"RECONNECTING\" | \"ERROR\" | \"STOPPED\" {\n  return state === \"RECONNECTING\" || state === \"ERROR\" || state === \"STOPPED\";\n}\n\nexport function isMatrixTerminalSyncState(\n  state: MatrixSyncState | null | undefined,\n): state is \"STOPPED\" {\n  // matrix-js-sdk can recover from ERROR to PREPARED during initial sync.\n  return state === \"STOPPED\";\n}\n"],
+  "mappings": ";;;;;AAAA;AASO,SAAS,uBACd,OAC6C;AAC7C,SAAO,UAAU,cAAc,UAAU,aAAa,UAAU;AAClE;AAEO,SAAS,8BACd,OAC+C;AAC/C,SAAO,UAAU,kBAAkB,UAAU,WAAW,UAAU;AACpE;AAEO,SAAS,0BACd,OACoB;AAEpB,SAAO,UAAU;AACnB;",
+  "names": []
+}