@wovin/core 0.0.0-ciao-mobx-955482e8

package/dist/chunk-XIQSYEV3.js

@@ -0,0 +1,1604 @@
+import {
+  arrayIfSingle
+} from "./chunk-ZAADLBSB.js";
+
+// src/thread/basic.ts
+import { Logger } from "besonders-logger";
+
+// src/query/subscribable.ts
+var SubscribableImpl = class {
+  _value;
+  _derivedSubscribers = [];
+  _subscribers = [];
+  _upstreamActive = false;
+  _activateUpstream;
+  _deactivateUpstream = null;
+  _equals;
+  constructor(initialValue, activateUpstream, opts) {
+    this._value = initialValue;
+    this._activateUpstream = activateUpstream ?? null;
+    this._equals = opts?.equals === false ? () => false : opts?.equals ?? ((a, b) => a === b);
+  }
+  get value() {
+    return this._value;
+  }
+  subscribe(cb, type) {
+    if (!this._upstreamActive && this._activateUpstream) {
+      this._deactivateUpstream = this._activateUpstream();
+      this._upstreamActive = true;
+    }
+    const list = type === "derived" ? this._derivedSubscribers : this._subscribers;
+    list.push(cb);
+    return () => {
+      const idx = list.indexOf(cb);
+      if (idx >= 0) list.splice(idx, 1);
+      if (this._derivedSubscribers.length === 0 && this._subscribers.length === 0 && this._upstreamActive) {
+        this._deactivateUpstream?.();
+        this._deactivateUpstream = null;
+        this._upstreamActive = false;
+      }
+    };
+  }
+  /** Update value and notify subscribers (skips if equals check passes) */
+  _set(value) {
+    if (this._equals(value, this._value)) return;
+    this._value = value;
+    this._notify();
+  }
+  _notify() {
+    const derived = [...this._derivedSubscribers];
+    for (const sub of derived) sub();
+    const subs = [...this._subscribers];
+    for (const sub of subs) sub();
+  }
+  dispose() {
+    this._deactivateUpstream?.();
+    this._deactivateUpstream = null;
+    this._derivedSubscribers.length = 0;
+    this._subscribers.length = 0;
+    this._upstreamActive = false;
+  }
+};
+function isArrayInitEvent(event) {
+  return event.init !== void 0;
+}
+var SubscribableArrayImpl = class {
+  _items;
+  _derivedSubscribers = [];
+  _subscribers = [];
+  _upstreamActive = false;
+  _activateUpstream;
+  _deactivateUpstream = null;
+  constructor(initialItems, activateUpstream) {
+    this._items = initialItems;
+    this._activateUpstream = activateUpstream ?? null;
+  }
+  get items() {
+    return this._items;
+  }
+  get length() {
+    return this._items.length;
+  }
+  subscribe(cb, type) {
+    if (!this._upstreamActive && this._activateUpstream) {
+      this._deactivateUpstream = this._activateUpstream();
+      this._upstreamActive = true;
+    }
+    const list = type === "derived" ? this._derivedSubscribers : this._subscribers;
+    list.push(cb);
+    return () => {
+      const idx = list.indexOf(cb);
+      if (idx >= 0) list.splice(idx, 1);
+      if (this._derivedSubscribers.length === 0 && this._subscribers.length === 0 && this._upstreamActive) {
+        this._deactivateUpstream?.();
+        this._deactivateUpstream = null;
+        this._upstreamActive = false;
+      }
+    };
+  }
+  /** Push items and notify subscribers */
+  _push(...items) {
+    this._items.push(...items);
+    this._notify({ added: items, removed: null });
+  }
+  /** Remove items and notify subscribers */
+  _remove(items) {
+    for (const item of items) {
+      const idx = this._items.indexOf(item);
+      if (idx >= 0) this._items.splice(idx, 1);
+    }
+    this._notify({ added: [], removed: items });
+  }
+  /** Full reset — replace all items */
+  _reset(items) {
+    this._items = items;
+    this._notify({ init: [...this._items] });
+  }
+  _notify(event) {
+    const derived = [...this._derivedSubscribers];
+    for (const sub of derived) sub(event);
+    const subs = [...this._subscribers];
+    for (const sub of subs) sub(event);
+  }
+  dispose() {
+    this._deactivateUpstream?.();
+    this._deactivateUpstream = null;
+    this._derivedSubscribers.length = 0;
+    this._subscribers.length = 0;
+    this._upstreamActive = false;
+  }
+};
+
+// src/utils/debug-name.ts
+import stringify from "safe-stable-stringify";
+var createDebugName = ({ caller, thread, pattern, args }) => {
+  args = args || pattern;
+  const str = `${!Array.isArray(thread) && thread?.name ? thread.name + " | " : ""}${caller ?? "caller?"}${args ? `{${typeof args === "string" ? args : stringify(args)}}` : ""}`;
+  return str;
+};
+var createDebugNameObj = (args) => {
+  return { name: createDebugName(args) };
+};
+function prettifyThreadName(input) {
+  let depth = 0;
+  let result = "";
+  let insideCurlyBraces = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (char === "(") {
+      result += char + "\n" + "	".repeat(++depth);
+    } else if (char === ")") {
+      result += "\n" + "	".repeat(--depth) + char;
+    } else if (char === "," && insideCurlyBraces === 0) {
+      result += char + "\n" + "	".repeat(depth);
+    } else if (char === "{" && insideCurlyBraces === 0) {
+      insideCurlyBraces++;
+      result += char + "\n" + "	".repeat(depth + 1);
+    } else if (char === "}" && insideCurlyBraces === 1) {
+      insideCurlyBraces--;
+      result += "\n" + "	".repeat(depth) + char;
+    } else if (char === "{" && insideCurlyBraces > 0) {
+      insideCurlyBraces++;
+      result += char;
+    } else if (char === "}" && insideCurlyBraces > 1) {
+      insideCurlyBraces--;
+      result += char;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+
+// src/thread/basic.ts
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO, { prefix: "[thread]" });
+var isInitEvent = isArrayInitEvent;
+var Thread = class {
+  constructor(name, parents, filters, _applogs = []) {
+    this.name = name;
+    this._applogs = _applogs;
+    this.parents = parents === null ? null : arrayIfSingle(parents);
+    this.filters = filters;
+    if (this.parents?.length === 0) {
+      WARN(`[Thread] empty parents array`, name);
+    }
+  }
+  filters;
+  parents;
+  _derivedSubscribers = [];
+  _subscribers = [];
+  /** Monotonic counter incremented on every mutation. Used by memoizedFn to invalidate caches. */
+  _version = 0;
+  get readOnly() {
+    if (this.parents.length !== 1) return true;
+    return this.parents[0].readOnly;
+  }
+  insert(appLogsToInsert) {
+    if (this.readOnly) throw ERROR(`[Thread] insert() called on read-only thread:`, this.nameAndSizeUntracked);
+    if (!this.parents) throw ERROR(`[Thread] insert() called on non-writable thread without parents:`, this.nameAndSizeUntracked);
+    if (this.parents?.length !== 1) throw ERROR(`[Thread] insert() called on thread with multiple parents:`, this.nameAndSizeUntracked);
+    return this.parents[0].insert(appLogsToInsert);
+  }
+  insertRaw(appLogsToInsert) {
+    if (this.readOnly) throw ERROR(`[Thread] insertRaw() called on read-only thread:`, this.nameAndSizeUntracked);
+    if (!this.parents) throw ERROR(`[Thread] insertRaw() called on non-writable thread without parents:`, this.nameAndSizeUntracked);
+    if (this.parents?.length !== 1) throw ERROR(`[Thread] insertRaw() called on thread with multiple parents:`, this.nameAndSizeUntracked);
+    return this.parents[0].insertRaw(appLogsToInsert);
+  }
+  subscribe(callback, type) {
+    const list = type === "derived" ? this._derivedSubscribers : this._subscribers;
+    list.push(callback);
+    return () => {
+      const idx = list.indexOf(callback);
+      if (idx >= 0) list.splice(idx, 1);
+    };
+  }
+  notifySubscribers(event) {
+    this._version++;
+    DEBUG(`[thread: ${this.name}] notifying`, this._derivedSubscribers.length, "derived +", this._subscribers.length, "subscribers of", { ...event, subs: this._subscribers });
+    const derived = [...this._derivedSubscribers];
+    for (const subscriber of derived) {
+      subscriber(event);
+    }
+    const subs = [...this._subscribers];
+    for (const subscriber of subs) {
+      subscriber(event);
+    }
+  }
+  // ── SubscribableArray<Applog> ──
+  get items() {
+    return this._applogs;
+  }
+  dispose() {
+    this._derivedSubscribers.length = 0;
+    this._subscribers.length = 0;
+  }
+  get applogs() {
+    return this._applogs;
+  }
+  get applogsCids() {
+    return this._applogs.map((l) => l.cid);
+  }
+  get applogsCidSet() {
+    return new Set(this._applogs.map((l) => l.cid));
+  }
+  map(fn) {
+    return this.applogs.map(fn);
+  }
+  get findLast() {
+    return this.applogs.findLast.bind(this.applogs);
+  }
+  get findFirst() {
+    return this.applogs.find.bind(this.applogs);
+  }
+  get firstLog() {
+    return this.applogs[0];
+  }
+  get latestLog() {
+    return this.applogs[this.applogs.length - 1];
+  }
+  hasApplog(applog, byRef) {
+    if (byRef) {
+      return this.applogs.includes(applog);
+    } else {
+      if (!applog.cid) throw ERROR(`[hasApplogs] applog without CID:`, applog);
+      return this.hasApplogCid(applog.cid);
+    }
+  }
+  hasApplogCid(cid) {
+    return this.applogsCidSet.has(cid.toString());
+  }
+  get applogsByCid() {
+    return new Map(this.applogs.map((log) => [log.cid, log]));
+  }
+  getApplog(cid) {
+    return this.applogsByCid.get(cid.toString());
+  }
+  hasApplogWithDiffTs(applog) {
+    return this.applogs.find((existing) => existing.en === applog.en && existing.at === applog.at && existing.vl === applog.vl && existing.ag === applog.ag);
+  }
+  // get stateHash() {
+  // 	blakeHasher.init()
+  // 	for (const log of this.applogs) {
+  // 		blakeHasher.update(log.cid)
+  // 	}
+  // 	return blakeHasher.digest()
+  // }
+  get isEmpty() {
+    return this.size === 0;
+  }
+  get size() {
+    return this.applogs.length;
+  }
+  get length() {
+    return this.applogs.length;
+  }
+  get untrackedSize() {
+    return this.size;
+  }
+  get nameAndSizeUntracked() {
+    return `${this.name} (${this.size})`;
+  }
+  get prettyName() {
+    return prettifyThreadName(this.name);
+  }
+  get hasParents() {
+    return !!this.parents?.length;
+  }
+};
+var getLogsFromThread = (logsOrThread) => logsOrThread instanceof Thread ? logsOrThread.applogs : logsOrThread;
+var StaticThread = class _StaticThread extends Thread {
+  static fromArray(applogs, name) {
+    return new _StaticThread(name || "static", null, [], applogs);
+  }
+  constructor(name, parents, filters, _applogs) {
+    super(name, parents, filters, _applogs);
+  }
+  get readOnly() {
+    return true;
+  }
+};
+
+// src/thread/filters.ts
+import { Logger as Logger6 } from "besonders-logger";
+import stringify3 from "safe-stable-stringify";
+
+// src/applog/applog-helpers.ts
+import { Logger as Logger4 } from "besonders-logger";
+
+// src/ipfs/ipfs-utils.ts
+import * as dagJson from "@ipld/dag-json";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { Logger as Logger2 } from "besonders-logger";
+import { CID, digest as Digest } from "multiformats";
+import { encode as multiformatsEncode } from "multiformats/block";
+
+// src/applog/datom-types.ts
+import { FormatRegistry, Type } from "@sinclair/typebox";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+var Nullable = (schema) => Type.Union([schema, Type.Null()]);
+var EntityID_LENGTH = 7;
+var isCID = /^(k51qz|baguq)[0-9a-z]{56,57}$/;
+var isShortHash = /^[0-9A-Fa-f]{7,8}$/g;
+FormatRegistry.Set("EntityID", (value) => !!value.match(isShortHash) || !!value.match(isCID));
+var EntityID = Type.String();
+var isEncryptedApplog = (l) => l?.enc instanceof Uint8Array;
+FormatRegistry.Set("CID", (value) => !!value.match(isCID));
+var CIDTB = Type.String({ format: "CID" });
+var isURL = /^http([s]?):\/\/.*\..*/;
+FormatRegistry.Set("URL", (value) => !!value.match(isURL));
+var URL = Type.String({ format: "URL" });
+var AppLogNoCidTB = Type.Object({
+  en: EntityID,
+  // EntityID
+  at: Type.String(),
+  // Attribute
+  vl: Nullable(Type.Union([Type.String(), Type.Boolean(), Type.Number()])),
+  // TODO refactor to semantic typesafe ApplogValue
+  ts: Type.String(),
+  // Timestamp
+  ag: Type.String(),
+  // AgentHash
+  pv: Nullable(CIDTB)
+  // CidString
+});
+var AppLogNoCidTBC = TypeCompiler.Compile(AppLogNoCidTB);
+var getApplogNoCidTypeErrors = (obj) => Array.from(AppLogNoCidTBC.Errors(obj));
+var isValidApplogNoCid = AppLogNoCidTBC.Check.bind(AppLogNoCidTBC);
+var AppLogTB = Type.Composite([
+  Type.Object({
+    cid: CIDTB
+  }),
+  AppLogNoCidTB
+]);
+var AppLogTBC = TypeCompiler.Compile(AppLogTB);
+var getApplogTypeErrors = (obj) => Array.from(AppLogTBC.Errors(obj));
+var isValidApplog = AppLogTBC.Check.bind(AppLogTBC);
+
+// src/ipfs/ipfs-utils.ts
+import { base36 } from "multiformats/bases/base36";
+import { sha256 as sha265Hasher } from "multiformats/hashes/sha2";
+var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = Logger2.setup(Logger2.INFO);
+var MULTICODEC_IPNS_KEY = 114;
+function prepareForPub(log, without = ["cid"]) {
+  if (!log) throw ERROR2("falsy log", log);
+  let cid = log.cid;
+  if (isEncryptedApplog(log)) {
+    if (!cid) cid = getCidSync(encodeBlock(log).bytes).toString();
+    WARN2("preparing an encrypted applog - really?");
+    return { log, cid };
+  }
+  const logWithout = {};
+  for (let [key, val] of Object.entries(log)) {
+    if (val === void 0) {
+      WARN2(`log.${key} is undefined, which is not allowed - encoding as null`, log);
+      val = null;
+    }
+    if (!without.includes(key)) {
+      logWithout[key] = val;
+    } else {
+      VERBOSE2("excluding app log", { key, val });
+    }
+  }
+  return { log: logWithout, cid };
+}
+function encodeApplogAndGetCid(log) {
+  return getCidSync(encodeApplog(log).bytes);
+}
+function encodeApplog(log) {
+  return encodeBlock(prepareForPub(log)?.log);
+}
+function getCidSync(bytes) {
+  const hash = sha256(bytes);
+  const digest = Digest.create(sha265Hasher.code, hash);
+  const cid = CID.create(1, dagJson.code, digest);
+  VERBOSE2(`[getCidSync]`, { bytes, hash, digest, cid });
+  return cid;
+}
+function encodeBlock(jsonObject) {
+  DEBUG2("[encodeBlock]", jsonObject);
+  try {
+    const byteView = dagJson.encode(jsonObject);
+    return { bytes: byteView, cid: getCidSync(byteView) };
+  } catch (err) {
+    throw ERROR2("[encodeBlock] failed to encode:", jsonObject, err);
+  }
+}
+async function encodeBlockOriginal(jsonObject) {
+  const encoded = await multiformatsEncode({ value: jsonObject, codec: dagJson, hasher: sha265Hasher });
+  const syncVariant = encodeBlock(jsonObject);
+  if (syncVariant.cid.toString() !== encoded.cid.toString()) {
+    ERROR2(`[encodeBlockOriginal] sync cid mismatch`, { jsonObject, encoded, syncVariant });
+  }
+  return encoded;
+}
+function tryParseCID(cidString) {
+  let cid = null;
+  let errors = [];
+  try {
+    cid = CID.parse(cidString);
+  } catch (err) {
+    VERBOSE2(`[retrieveThread] couldn't parse pubID with default base`);
+    errors.push(err);
+  }
+  if (!cid) {
+    try {
+      cid = CID.parse(cidString, base36);
+    } catch (err) {
+      VERBOSE2(`[retrieveThread] couldn't parse pubID with base36`);
+      errors.push(err);
+    }
+  }
+  return {
+    cid,
+    errors: cid ? null : errors,
+    // we only care about errors if we failed to parse
+    isIpns: cid && isIpnsKeyCid(cid)
+  };
+}
+function isIpnsKeyCid(cid) {
+  return cid.code === MULTICODEC_IPNS_KEY;
+}
+function cidToString(cid) {
+  if (cid.code == MULTICODEC_IPNS_KEY) {
+    return toIpnsString(cid);
+  } else {
+    return cid.toString();
+  }
+}
+function toIpnsString(cid) {
+  if (cid.code !== MULTICODEC_IPNS_KEY) throw ERROR2(`Not an IPNS cid (${cid.code}):`, cid.toString());
+  return cid.toString(base36);
+}
+function ensureValidCIDinstance(cidOrStringA) {
+  return typeof cidOrStringA === "string" ? CID.parse(cidOrStringA) : typeof cidOrStringA.toV1 != "function" ? CID.decode(cidOrStringA.bytes) : cidOrStringA;
+}
+function areCidsEqual(cidOrStringA, cidOrStringB) {
+  if (!cidOrStringA || !cidOrStringB) throw new Error(`[areCidsEqual] invalid params: ${cidOrStringA}, ${cidOrStringB}`);
+  if (cidOrStringA === cidOrStringB) return true;
+  const cidA = ensureValidCIDinstance(cidOrStringA);
+  const cidB = ensureValidCIDinstance(cidOrStringB);
+  return cidA.toV1().toString() === cidB.toV1().toString();
+}
+function containsCid(list, needle) {
+  if (list instanceof Set) return list.has(typeof needle === "string" ? needle : needle.toV1().toString());
+  return list.some((cidOrString) => areCidsEqual(cidOrString, needle));
+}
+
+// src/applog/applog-utils.ts
+import { Logger as Logger3 } from "besonders-logger";
+import { isBefore } from "date-fns";
+import { partial, pick } from "lodash-es";
+import { isEqual } from "lodash-es";
+import stringify2 from "safe-stable-stringify";
+var { WARN: WARN3, LOG: LOG3, DEBUG: DEBUG3, VERBOSE: VERBOSE3, ERROR: ERROR3 } = Logger3.setup(Logger3.INFO);
+var isoDateStrCompare = (strA, strB, dir = "asc") => dir === "asc" ? strA.localeCompare(strB, "en-US") : strB.localeCompare(strA, "en-US");
+var objEqualByKeys = (keys, objA, objB) => {
+  return isEqual(pick(objA, keys), pick(objB, keys));
+};
+var compareApplogsByTs = (logA, logB, dir = "asc") => isoDateStrCompare(logA.ts, logB.ts, dir);
+var compareApplogsByEnAt = partial(objEqualByKeys, ["en", "at"]);
+function sortApplogsByTs(appLogArray, dir = "asc") {
+  return appLogArray.sort((a, b) => compareApplogsByTs(a, b, dir));
+}
+var isTsBefore = (log, logToCompare) => isBefore(new Date(log.ts), new Date(logToCompare.ts));
+var uniqueEnFromAppLogs = (appLogArray) => [...new Set(appLogArray.map((eachLog) => eachLog.en))];
+var areApplogsEqual = (logA, logB) => isEqual(logA, logB);
+var warnMissingRemoveDuplicateMode = () => {
+  WARN3(`[removeDuplicateAppLogs] mode not set; pass 'safety' or 'cleanup' for optimal behavior`);
+};
+var removeDuplicateAppLogsCleanup = (appLogArray) => {
+  const logMap = /* @__PURE__ */ new Map();
+  const verboseEnabled = VERBOSE3.isEnabled;
+  for (const eachLog of appLogArray) {
+    if (!eachLog) {
+      ERROR3(`falsy entry in applogs`, appLogArray);
+      throw new Error(`falsy entry in applogs`);
+    }
+    if (!eachLog.cid) {
+      ERROR3(`applog with missing CID`, eachLog);
+      throw new Error(`applog with missing CID`);
+    }
+    const key = eachLog.cid;
+    const existing = logMap.get(key);
+    if (existing) {
+      if (verboseEnabled) VERBOSE3(`Skipping duplicate applog:`, [existing, eachLog]);
+    } else {
+      logMap.set(key, eachLog);
+    }
+  }
+  return Array.from(logMap.values());
+};
+var removeDuplicateAppLogsSafety = (appLogArray) => {
+  const seen = /* @__PURE__ */ new Set();
+  const verboseEnabled = VERBOSE3.isEnabled;
+  const existingByCid = verboseEnabled ? /* @__PURE__ */ new Map() : null;
+  let result = null;
+  let index = 0;
+  for (const eachLog of appLogArray) {
+    if (!eachLog) {
+      ERROR3(`falsy entry in applogs`, appLogArray);
+      throw new Error(`falsy entry in applogs`);
+    }
+    if (!eachLog.cid) {
+      ERROR3(`applog with missing CID`, eachLog);
+      throw new Error(`applog with missing CID`);
+    }
+    const key = eachLog.cid;
+    if (seen.has(key)) {
+      if (!result) {
+        result = appLogArray.slice(0, index);
+      }
+      if (verboseEnabled) VERBOSE3(`Skipping duplicate applog:`, [existingByCid?.get(key), eachLog]);
+    } else {
+      seen.add(key);
+      if (existingByCid) existingByCid.set(key, eachLog);
+      if (result) result.push(eachLog);
+    }
+    index++;
+  }
+  return result ?? appLogArray;
+};
+var removeDuplicateAppLogs = (appLogArray, mode) => {
+  if (!mode) {
+    warnMissingRemoveDuplicateMode();
+    return removeDuplicateAppLogsCleanup(appLogArray);
+  }
+  return mode === "safety" ? removeDuplicateAppLogsSafety(appLogArray) : removeDuplicateAppLogsCleanup(appLogArray);
+};
+var getHashID = (stringifiable, lngth = 8) => cyrb53hash(stringify2(stringifiable), 31, lngth);
+function isVariable(x) {
+  return typeof x === "string" && x.startsWith("?");
+}
+function variableNameWithoutQuestionmark(str) {
+  return str.slice(1);
+}
+function isStaticPattern(x) {
+  if (!["string", "boolean", "number", "function"].includes(typeof x)) WARN3(`Unhandled pattern value type:`, typeof x, x);
+  return !isVariable(x) && ["string", "boolean", "number"].includes(typeof x);
+}
+function resolveOrRemoveVariables(pattern, candidate) {
+  let variablesToFill = {};
+  const newPattern = {};
+  for (const [patternKey, patternValue] of Object.entries(pattern)) {
+    if (isVariable(patternValue)) {
+      const varName = variableNameWithoutQuestionmark(patternValue);
+      const candidateValue = candidate[varName];
+      if (candidateValue) {
+        newPattern[patternKey] = candidateValue;
+      } else {
+        variablesToFill[patternKey] = varName;
+      }
+    } else {
+      newPattern[patternKey] = patternValue;
+    }
+  }
+  return [newPattern, variablesToFill];
+}
+function matchVariable(variable, triplePart, context) {
+  if (context.hasOwnProperty(variable)) {
+    const bound = context[variable];
+    const match = matchPart(bound, triplePart, context);
+    return match;
+  }
+  return { ...context, [variable]: triplePart };
+}
+function matchPartStatic(field, patternPart, atomPart) {
+  let result;
+  if (patternPart) {
+    const typ = typeof patternPart;
+    if (typ === "string") {
+      result = patternPart === atomPart;
+    } else if (typ === "function") {
+      result = patternPart(atomPart);
+    } else if (typeof patternPart.has === "function") {
+      result = patternPart.has(atomPart);
+    } else if (Array.isArray(patternPart) && !Array.isArray(atomPart)) {
+      result = patternPart.includes(atomPart);
+    } else {
+      result = patternPart === atomPart;
+    }
+  } else {
+    result = patternPart === atomPart;
+  }
+  if (field.charAt(0) === "!") {
+    return !result;
+  } else {
+    return result;
+  }
+}
+function matchPart(patternPart, atomPart, context) {
+  if (!context) {
+    return null;
+  }
+  if (typeof patternPart === "string") {
+    if (isVariable(patternPart)) {
+      return matchVariable(patternPart, atomPart, context);
+    }
+  }
+  if (typeof patternPart === "function") {
+    return patternPart(atomPart) ? context : null;
+  }
+  return patternPart === atomPart ? context : null;
+}
+function matchPattern(pattern, applog, context) {
+  return Object.entries(pattern).reduce((context2, [field, patternValue]) => {
+    const applogValue = applog[field];
+    const patternValT = patternValue;
+    return matchPart(patternValT, applogValue, context2);
+  }, context);
+}
+function actualize(context, find) {
+  return Object.fromEntries(find.map((findField) => {
+    if (context === null) {
+      throw new Error(`actualize context is null ${find}`);
+    }
+    return [
+      isVariable(findField) ? findField.replace(/^\?/, "") : findField,
+      isVariable(findField) ? context[findField] : findField
+    ];
+  }));
+}
+var sum = function sum2(array) {
+  var num = 0;
+  for (var i = 0, l = array.length; i < l; i++) num += array[i];
+  return num;
+};
+var mean = function mean2(array) {
+  return sum(array) / array.length;
+};
+var arrStats = {
+  max: function(array) {
+    return Math.max.apply(null, array);
+  },
+  min: function(array) {
+    return Math.min.apply(null, array);
+  },
+  range: function(array) {
+    return arrStats.max(array) - arrStats.min(array);
+  },
+  midrange: function(array) {
+    return arrStats.range(array) / 2;
+  },
+  sum,
+  mean,
+  average: mean,
+  median: function(array) {
+    array.sort(function(a, b) {
+      return a - b;
+    });
+    var mid = array.length / 2;
+    return mid % 1 ? array[mid - 0.5] : (array[mid - 1] + array[mid]) / 2;
+  },
+  modes: function(array) {
+    if (!array.length) return [];
+    var modeMap = {}, maxCount = 0, modes = [];
+    array.forEach(function(val) {
+      if (!modeMap[val]) modeMap[val] = 1;
+      else modeMap[val]++;
+      if (modeMap[val] > maxCount) {
+        modes = [val];
+        maxCount = modeMap[val];
+      } else if (modeMap[val] === maxCount) {
+        modes.push(val);
+        maxCount = modeMap[val];
+      }
+    });
+    return modes;
+  },
+  variance: function(array) {
+    var mean3 = arrStats.mean(array);
+    return arrStats.mean(array.map(function(num) {
+      return Math.pow(num - mean3, 2);
+    }));
+  },
+  standardDeviation: function(array) {
+    return Math.sqrt(arrStats.variance(array));
+  },
+  meanAbsoluteDeviation: function(array) {
+    var mean3 = arrStats.mean(array);
+    return arrStats.mean(array.map(function(num) {
+      return Math.abs(num - mean3);
+    }));
+  },
+  zScores: function(array) {
+    var mean3 = arrStats.mean(array);
+    var standardDeviation = arrStats.standardDeviation(array);
+    return array.map(function(num) {
+      return (num - mean3) / standardDeviation;
+    });
+  }
+};
+arrStats.average = arrStats.mean;
+var tsNearlySame = (timeA, timeB) => timeB.startsWith(timeA.slice(0, timeA.length - 4));
+var cyrb53hash = function(str, seed = 13, strLength) {
+  if (!str?.length) {
+    throw new Error(`Empty string: ${str}`);
+  }
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  const asHex = (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16);
+  return asHex.slice(-strLength).padStart(strLength, "0");
+};
+function arraysContainSameElements(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  const sortedArr1 = [...arr1].sort();
+  const sortedArr2 = [...arr2].sort();
+  for (let i = 0; i < sortedArr1.length; i++) {
+    if (sortedArr1[i] !== sortedArr2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function dateNowIso() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toISOString();
+}
+
+// src/applog/applog-helpers.ts
+var { WARN: WARN4, LOG: LOG4, DEBUG: DEBUG4, VERBOSE: VERBOSE4, ERROR: ERROR4 } = Logger4.setup(Logger4.INFO);
+function ensureTsPvAndFinalizeApplogs(appLogsToInsert, threadForPv) {
+  DEBUG4(`[ensureTsPvAndFinalizeApplogs] ENTER - ${appLogsToInsert.length} applogs, thread size=${threadForPv.size}`);
+  const ts = dateNowIso();
+  const currentThread = threadForPv;
+  DEBUG4(`[ensureTsPvAndFinalizeApplogs] About to map over applogs`);
+  const mapped = appLogsToInsert.map((log, idx) => {
+    DEBUG4(`[ensureTsPvAndFinalizeApplogs] Processing applog ${idx + 1}/${appLogsToInsert.length}`);
+    const result = finalizeApplogForInsert(log, { ts, threadForPv: currentThread });
+    DEBUG4(`[ensureTsPvAndFinalizeApplogs] Finalized applog ${idx + 1}/${appLogsToInsert.length}`);
+    return result;
+  });
+  DEBUG4(`[ensureTsPvAndFinalizeApplogs] EXIT - mapped ${mapped.length} applogs`);
+  return mapped;
+}
+function ensureTsPvAndFinalizeApplog(applogToInsert, threadForPv) {
+  return ensureTsPvAndFinalizeApplogs([applogToInsert], threadForPv)[0];
+}
+function finalizeApplogForInsert(log, { ts, threadForPv } = {}) {
+  DEBUG4(`[finalizeApplogForInsert] ENTER - en=${log.en}, at=${log.at}`);
+  DEBUG4(`[finalizeApplogForInsert] About to call withTs`);
+  const logWithTs = withTs(log, ts ?? dateNowIso());
+  DEBUG4(`[finalizeApplogForInsert] About to call withPvFrom (thread size=${threadForPv?.size ?? "null"})`);
+  const logWithPv = withPvFrom(logWithTs, threadForPv);
+  DEBUG4(`[finalizeApplogForInsert] About to call encodeApplogAndGetCid`);
+  const cid = encodeApplogAndGetCid(logWithPv).toString();
+  DEBUG4(`[finalizeApplogForInsert] CID created: ${cid}`);
+  if (log.cid && log.cid !== cid) WARN4(`[finalizeApplogForInsert] overwriting wrong CID`, { log, cid, logWithPv });
+  const logWithCid = { ...logWithPv, cid };
+  DEBUG4(`[finalizeApplogForInsert] About to validate applog`);
+  if (!isValidApplog(logWithCid)) {
+    throw ERROR4(`Bogus Applog ${JSON.stringify(logWithCid)}`, getApplogTypeErrors(logWithCid));
+  }
+  DEBUG4(`[finalizeApplogForInsert] EXIT - CID=${cid}`);
+  return Object.freeze(logWithCid);
+}
+function hasAg(log) {
+  return !!log.ag;
+}
+function hasTs(log) {
+  return !!log.ts;
+}
+function hasPv(log) {
+  return !!log.pv;
+}
+function withTs(log, ts) {
+  return hasTs(log) ? log : { ...log, ts };
+}
+function withAg(log, ag) {
+  return hasAg(log) ? log : { ...log, ag };
+}
+function withPvFrom(log, thread) {
+  DEBUG4(`[withPvFrom] ENTER - en=${log.en}, at=${log.at}, hasPv=${log.pv !== void 0}`);
+  if (log.pv !== void 0) {
+    DEBUG4(`[withPvFrom] EXIT early - pv already set`);
+    return log;
+  }
+  if (!thread) {
+    if (!hasPv(log)) throw ERROR4(`[withPvFrom] no thread and no pv:`, log);
+    DEBUG4(`[withPvFrom] EXIT - no thread, returning log with existing pv`);
+    return log;
+  } else {
+    const { en, at } = log;
+    DEBUG4(`[withPvFrom] About to call thread.findLast for en=${en}, at=${at}, thread.size=${thread.size}`);
+    const prevLog = thread.findLast((l) => l.en == en && l.at == at);
+    DEBUG4(`[withPvFrom] findLast completed, found=${!!prevLog}`);
+    DEBUG4(`[withPvFrom] About to check equality`);
+    if (objEqualByKeys(["en", "at", "vl", "ts", "ag"], log, prevLog)) {
+      throw ERROR4(`[withPvFrom] Same as previous:`, { log, pv: prevLog, thread });
+    }
+    const prevLogCid = (log.pv !== void 0 ? log.pv : prevLog?.cid) ?? null;
+    DEBUG4(`[withPvFrom] EXIT - prevLogCid=${prevLogCid}`);
+    return { ...log, pv: prevLogCid };
+  }
+}
+function joinThreads(threads) {
+  const fullJoin = () => {
+    if (threads.length < 2) DEBUG4(`joinThreads with count=${threads.length}`);
+    return sortApplogsByTs(
+      removeDuplicateAppLogs(threads.flatMap((s) => {
+        const logs = s.applogs;
+        if (!logs) {
+          ERROR4(`falsy applogs of thread`, s);
+          throw new Error(`falsy applogs of thread`);
+        }
+        return logs;
+      }), "cleanup")
+    );
+  };
+  let initialMergeResult = fullJoin();
+  const eventMapper = function(event, sourceThread) {
+    if (isInitEvent(event)) {
+      return { init: fullJoin() };
+    } else {
+      return {
+        // TODO: test this stuff
+        added: event.added.filter((addedLog) => !this.hasApplog(addedLog, true)),
+        removed: event.removed?.filter((removedLog) => {
+          const otherParentHasLog = !this.parents.some((parent) => {
+            if (parent === sourceThread) return false;
+            return parent.hasApplog(removedLog, true);
+          });
+          return !otherParentHasLog;
+        })
+      };
+    }
+  };
+  return new MappedThread(
+    `join(~ ${threads.map((s) => s.name).join(", ")})`,
+    threads,
+    ["?"],
+    // HACK this basically says "we're not sure what filters are applied"
+    initialMergeResult,
+    eventMapper
+  );
+}
+
+// src/query/memoized.ts
+import { isEqual as isEqual2 } from "lodash-es";
+function compareStructural(argsA, argsB, versionsA) {
+  if (argsA.length !== argsB.length) return false;
+  for (let i = 0; i < argsA.length; i++) {
+    if (argsA[i] instanceof Thread) {
+      if (argsB[i] !== argsA[i]) return false;
+      if (versionsA && versionsA[i] !== void 0 && argsB[i]._version !== versionsA[i]) return false;
+    } else {
+      if (!isEqual2(argsA[i], argsB[i])) return false;
+    }
+  }
+  return true;
+}
+function snapshotVersions(args) {
+  return args.map((a) => a instanceof Thread ? a._version : void 0);
+}
+function memoizedFn(name, fn, opts) {
+  const cache = [];
+  const argsEqual = opts?.argsEqual ?? compareStructural;
+  const maxSize = opts?.maxSize ?? Infinity;
+  return function(...args) {
+    const existing = cache.find((entry) => argsEqual(entry.args, args, entry.versions));
+    if (existing) return existing.result;
+    const result = fn.apply(this, args);
+    if (cache.length >= maxSize) {
+      cache.shift();
+    }
+    cache.push({ args, versions: snapshotVersions(args), result });
+    return result;
+  };
+}
+function refCountedMemoizedFn(name, fn, opts) {
+  const cache = [];
+  const argsEqual = opts?.argsEqual ?? compareStructural;
+  const gracePeriodMs = opts?.gracePeriodMs ?? 0;
+  function evict(entry, args) {
+    const idx = cache.indexOf(entry);
+    if (idx >= 0) cache.splice(idx, 1);
+    opts?.onCleanup?.(entry.result, ...args);
+  }
+  return function(...args) {
+    let entry = cache.find((e) => argsEqual(e.args, args));
+    if (entry) {
+      if (entry.graceTimer !== null) {
+        clearTimeout(entry.graceTimer);
+        entry.graceTimer = null;
+      }
+      entry.refCount++;
+    } else {
+      const result = fn.apply(this, args);
+      entry = { args, result, refCount: 1, graceTimer: null };
+      cache.push(entry);
+    }
+    const capturedEntry = entry;
+    let released = false;
+    return {
+      get value() {
+        return capturedEntry.result;
+      },
+      release() {
+        if (released) return;
+        released = true;
+        capturedEntry.refCount--;
+        if (capturedEntry.refCount <= 0) {
+          if (gracePeriodMs > 0) {
+            capturedEntry.graceTimer = setTimeout(() => {
+              if (capturedEntry.refCount <= 0) {
+                evict(capturedEntry, args);
+              }
+            }, gracePeriodMs);
+          } else {
+            evict(capturedEntry, args);
+          }
+        }
+      }
+    };
+  };
+}
+
+// src/thread/mapped.ts
+import { Logger as Logger5 } from "besonders-logger";
+import { sortedIndexBy } from "lodash-es";
+var { WARN: WARN5, LOG: LOG5, DEBUG: DEBUG5, VERBOSE: VERBOSE5, ERROR: ERROR5 } = Logger5.setup(Logger5.INFO);
+var MappedThread = class _MappedThread extends Thread {
+  // mapped to unsubscribe function
+  constructor(name, parents, filters, _initialLogs, _eventMapper, _writeMapper = null, _readOnly) {
+    super(
+      name,
+      parents,
+      filters,
+      _eventMapper ? [..._initialLogs] : _initialLogs
+      // if we don't map events, we just re-use the array and then don't need to subscribe
+    );
+    this.name = name;
+    this._initialLogs = _initialLogs;
+    this._eventMapper = _eventMapper;
+    this._writeMapper = _writeMapper;
+    this._readOnly = _readOnly;
+    if (_eventMapper) {
+      this.subscribeToParents();
+    }
+  }
+  static mapWrites(parent, name, mapper) {
+    return new _MappedThread(
+      `${name}<${parent.nameAndSizeUntracked}>`,
+      parent,
+      parent.filters,
+      // @ts-expect-error ? what's the proper way
+      parent._applogs,
+      null,
+      mapper
+    );
+  }
+  static asReadOnly(parent) {
+    if (parent.readOnly) return parent;
+    return new _MappedThread(
+      `readOnly(${parent.name})`,
+      parent,
+      parent.filters,
+      // @ts-expect-error ? what's the proper way
+      parent._applogs,
+      null,
+      null,
+      true
+      // readOnly
+    );
+  }
+  _parentSubscriptions = null;
+  insert(appLogsToInsert) {
+    if (this.readOnly) throw ERROR5(`[MappedThread] insert() called on read-only thread:`, this.nameAndSizeUntracked);
+    const mapped = this._writeMapper ? this._writeMapper(appLogsToInsert) : appLogsToInsert;
+    if (this._writeMapper && !mapped) return;
+    return this.parents.forEach((parent) => parent.insert(mapped));
+  }
+  insertRaw(appLogsToInsert) {
+    if (this.readOnly) throw ERROR5(`[MappedThread] insertRaw() called on read-only thread:`, this.nameAndSizeUntracked);
+    const mapped = this._writeMapper ? this._writeMapper(appLogsToInsert) : appLogsToInsert;
+    if (this._writeMapper && !mapped) return;
+    return this.parents.forEach((parent) => parent.insertRaw(mapped));
+  }
+  subscribeToParents() {
+    this._parentSubscriptions = /* @__PURE__ */ new Map();
+    if (!this.parents.length) {
+      WARN5(`MappedThread has no parents`, this);
+    }
+    VERBOSE5(`[MappedThread: ${this.name}] subscribing to parents:`, this.parents.map((p) => p.name));
+    for (const p of this.parents) {
+      VERBOSE5(`[MappedThread: ${this.name}] sub to parent`, p.nameAndSizeUntracked);
+      const sub = this.onParentUpdate.bind(this, p);
+      const unsubscribe = p.subscribe(sub, "derived");
+      this._parentSubscriptions.set(p, unsubscribe);
+    }
+  }
+  /** Tear down parent subscriptions and clear internal state */
+  dispose() {
+    if (this._parentSubscriptions) {
+      for (const [, unsubscribe] of this._parentSubscriptions) {
+        unsubscribe();
+      }
+      this._parentSubscriptions = null;
+    }
+  }
+  /** Swap parents at runtime — re-subscribes and recomputes applogs, notifying downstream */
+  setParents(newParents) {
+    this.dispose();
+    this.parents = newParents;
+    this.subscribeToParents();
+    this.triggerRemap();
+  }
+  subscribe(callback, type) {
+    if (!this._parentSubscriptions) {
+      this.subscribeToParents();
+    }
+    return super.subscribe(callback, type);
+  }
+  /**
+   * // HACK to trigger remap on pattern change in rollingFilter
+   * should not be used lightly
+   */
+  triggerRemap() {
+    if (!this._eventMapper) throw ERROR5(`triggerRemap on a thread that is not actually mapping?!`, this.nameAndSizeUntracked);
+    DEBUG5(`MappedThread{${this.nameAndSizeUntracked}} triggerRemap`);
+    if (this.parents.length !== 1) {
+      WARN5(`MappedThread{${this.nameAndSizeUntracked}} triggerRemap with parentCount=${this.parents.length} - not meant for this`);
+    }
+    this.parents.forEach((p) => {
+      this.onParentUpdate(p, { init: [...p.applogs] });
+    });
+  }
+  onParentUpdate(thread, event) {
+    VERBOSE5(`MappedThread{${this.nameAndSizeUntracked}} parentUpdate`, event);
+    const mapResult = this._eventMapper ? this._eventMapper(event, thread) : event;
+    if (this._eventMapper) {
+      VERBOSE5(`MappedThread{${this.nameAndSizeUntracked}} parentUpdate => mapped`, mapResult);
+      if (isInitEvent(mapResult)) {
+        this._applogs.length = 0;
+        this._applogs.push(...mapResult.init);
+      } else {
+        for (const log of mapResult.added) {
+          this._applogs.splice(sortedIndexBy(this._applogs, log, "ts"), 0, log);
+        }
+        if (mapResult.removed) {
+          for (const toRemove of mapResult.removed) {
+            const idx = this._applogs.indexOf(toRemove);
+            if (idx >= 0) {
+              this._applogs.splice(idx, 1);
+            } else if (!isInitEvent(event) && event.removed?.includes(toRemove)) {
+              DEBUG5(`Ignoring remove event for non-existent because it was part of parent event's removed`, toRemove, event);
+            } else {
+              throw ERROR5(`MappedThread{${this.name}} toRemove contained log that doesn't exist`, toRemove, {
+                thread: this,
+                event,
+                mapResult
+              });
+            }
+          }
+        }
+      }
+    }
+    this.notifySubscribers(mapResult);
+  }
+  get readOnly() {
+    return this._readOnly ?? false;
+  }
+};
+
+// src/thread/filters.ts
+var { WARN: WARN6, LOG: LOG6, DEBUG: DEBUG6, VERBOSE: VERBOSE6, ERROR: ERROR6 } = Logger6.setup(Logger6.INFO);
+var rollingFilter2 = memoizedFn("rollingFilter", function rollingFilter3(thread, pattern, opts = {}) {
+  const filter = makeFilter(pattern);
+  const initialLogs = filter(thread.applogs);
+  const handleUpdateEvent = (event) => {
+    let mappedEvent;
+    if (isInitEvent(event)) {
+      mappedEvent = { init: filter(event.init) };
+    } else {
+      mappedEvent = {
+        added: filter(event.added),
+        removed: event.removed
+        // whatever's removed shall be removed
+      };
+    }
+    VERBOSE6(
+      `rollingFilter{${thread.nameAndSizeUntracked} | ${opts.name ? ` '${opts.name}'}` : ""} parentUpdate`,
+      pattern,
+      event,
+      "=>",
+      mappedEvent
+    );
+    return mappedEvent;
+  };
+  const mappedThread = new MappedThread(
+    `${thread.name} | ${opts.name || `rollingFilter{${stringify3(pattern)}}`}`,
+    thread,
+    [...thread.filters, ...opts.extraFilterName ? [opts.extraFilterName] : []],
+    initialLogs,
+    handleUpdateEvent
+  );
+  return mappedThread;
+}, {
+  argsDebugName: (thread, pattern, opts) => createDebugName({ caller: "rollingFilter", thread, pattern, args: opts })
+});
+var rollingMapper = memoizedFn("rollingMapper", function rollingMapper2(thread, eventMapper, opts = {}) {
+  const initialMapResult = eventMapper.call(null, { init: thread.applogs }, thread);
+  if (!isInitEvent(initialMapResult)) {
+    throw ERROR6("Initial run must return init event");
+  }
+  const initialLogs = initialMapResult.init;
+  return new MappedThread(
+    `${thread.name} | ${opts.name || `rollingMapper`}`,
+    thread,
+    [...thread.filters, ...opts.extraFilterName ? [opts.extraFilterName] : []],
+    // @ts-expect-error readonly.... FIXME
+    initialLogs,
+    eventMapper
+  );
+}, {
+  argsDebugName: (thread, _mapper, opts) => createDebugName({ caller: "rollingMapper", thread, args: opts })
+});
+var rollingAcc = memoizedFn(
+  "rollingAcc",
+  function rollingAcc2(thread, acc, eventMapper, opts = {}) {
+    eventMapper({ init: thread.applogs }, acc);
+    const result = new SubscribableImpl(
+      acc,
+      () => thread.subscribe((event) => {
+        eventMapper(event, acc);
+        result._set(acc);
+      }, "derived"),
+      { equals: false }
+      // accumulator is mutated in-place
+    );
+    return result;
+  },
+  { argsDebugName: (thread, _acc, _mapper, opts) => `rollingAcc{${thread.nameAndSizeUntracked}${opts?.name ? ` | ${opts?.name}` : ""}}` }
+);
+var getUntrackedPattern = function getUntrackedPattern2(pattern) {
+  if (!Object.entries(pattern).length) {
+    throw new Error(`Pattern is empty`);
+  }
+  return pattern;
+};
+function makeFilter(pattern) {
+  return function madeFilter(logs) {
+    return logs.filter(function madeFilterSingleLog(applog) {
+      for (const field of Object.keys(pattern)) {
+        let patternValue = pattern[field];
+        if (patternValue === void 0) continue;
+        const applogValue = applog[field.startsWith("!") ? field.slice(1) : field];
+        const patternValT = patternValue;
+        if (!matchPartStatic(field, patternValT, applogValue)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  };
+}
+var getUntrackedFilterResults = function getUntrackedFilterResults2(thread, pattern, opts = {}) {
+  const untrackedPattern = getUntrackedPattern(pattern);
+  const filter = makeFilter(untrackedPattern);
+  return filter(thread.applogs);
+};
+function hasFilter(thread, filter) {
+  return thread.filters.includes(filter);
+}
+function assertRaw(thread) {
+  if (thread.filters.length) {
+    WARN6(`[assertRaw] but '${thread.nameAndSizeUntracked}' has filters:`, thread.filters);
+  }
+  return thread;
+}
+function assertOnlyCurrent(thread) {
+  if (!hasFilter(thread, "lastWriteWins") || !hasFilter(thread, "withoutDeleted")) throw ERROR6(`should be filtered thread, but is:`, thread.filters);
+  return thread;
+}
+var asReadOnly = MappedThread.asReadOnly;
+var simpleApplogMapper = function simpleApplogMapper2(thread, logMapper, opts = {}) {
+  const mappedTo = /* @__PURE__ */ new Map();
+  const mapLogs = (applogs, thread2) => {
+    const ts = dateNowIso();
+    return applogs.map((log) => {
+      const mapped = logMapper(log, thread2);
+      let mapTo;
+      if (mapped === log) {
+        mapTo = log;
+      } else {
+        if (mapped.cid === log.cid) {
+          delete mapped.cid;
+        }
+        mapTo = finalizeApplogForInsert(mapped, {
+          ts,
+          threadForPv: null
+          // ? should not be inferred, right?
+        });
+      }
+      mappedTo.set(log.cid, mapTo);
+      return mapTo;
+    });
+  };
+  const handleUpdateEvent = (event) => {
+    let mappedEvent;
+    if (isInitEvent(event)) {
+      mappedEvent = { init: mapLogs(event.init, thread) };
+    } else {
+      mappedEvent = {
+        added: mapLogs(event.added, thread),
+        removed: event.removed.map((removedSourceLog) => {
+          const mappedLog = mappedTo.get(removedSourceLog.cid);
+          if (!mappedLog) {
+            throw ERROR6(`[simpleApplogMapper] Parent remove event for Applog that we don't know about`, { removedSourceLog });
+          }
+          mappedTo.delete(removedSourceLog.cid);
+          return mappedLog;
+        })
+      };
+    }
+    VERBOSE6(
+      `simpleApplogMapper{${thread.nameAndSizeUntracked} | ${opts?.name ? ` '${opts?.name}'}` : ""} parentUpdate`,
+      event,
+      "=>",
+      mappedEvent
+    );
+    return mappedEvent;
+  };
+  const mappedThread = rollingMapper(thread, handleUpdateEvent, opts);
+  VERBOSE6.isDisabled || VERBOSE6(`simpleApplogMapper<${thread.nameAndSizeUntracked}> initial mapped to`, mappedThread.applogs);
+  return mappedThread;
+};
+
+// src/thread/writeable.ts
+import { Logger as Logger7 } from "besonders-logger";
+var { WARN: WARN7, LOG: LOG7, DEBUG: DEBUG7, VERBOSE: VERBOSE7, ERROR: ERROR7 } = Logger7.setup(Logger7.INFO);
+var WriteableThread = class extends Thread {
+  constructor(name, applogs = [], filters) {
+    super(name, null, filters, applogs);
+  }
+  purge(cidsToPurge) {
+    const beforeCount = this.applogs.length;
+    this._applogs = this.applogs.filter((log) => !cidsToPurge.includes(log.cid));
+    return beforeCount - this.applogs.length;
+  }
+  insert(appLogsToInsert) {
+    DEBUG7(`[WriteableThread.insert] ENTER - ${appLogsToInsert.length} applogs for thread "${this.name}"`);
+    DEBUG7(`[WriteableThread.insert] About to call ensureTsPvAndFinalizeApplogs`);
+    const mapped = ensureTsPvAndFinalizeApplogs(appLogsToInsert, this);
+    DEBUG7(`[WriteableThread.insert] ensureTsPvAndFinalizeApplogs completed, mapped=${mapped.length} applogs`);
+    DEBUG7(`[WriteableThread.insert] About to call insertRaw`);
+    const result = this.insertRaw(mapped);
+    DEBUG7(`[WriteableThread.insert] insertRaw completed`);
+    return result;
+  }
+  /**
+   * Insert only applogs not already in this thread.
+   * @param byRef If true, compares by reference; if false, compares by CID (default)
+   * @returns The applogs that were actually inserted
+   */
+  insertMissing(appLogsToInsert, byRef = false) {
+    const missing = appLogsToInsert.filter((log) => !this.hasApplog(log, byRef));
+    if (missing.length === 0) {
+      VERBOSE7(`[insertMissing] no missing applogs`);
+      return [];
+    }
+    return this.insertRaw(missing) ?? [];
+  }
+  /**
+   * Insert raw applogs directly into the thread.
+   *
+   * STRICT VALIDATION: This method throws errors for:
+   * - Duplicate applogs in input array (programming error)
+   * - Invalid applogs (missing required fields)
+   * - Applogs already in thread (programming error)
+   *
+   * For external imports where duplicates are expected, use removeDuplicateAppLogs(..., 'cleanup')
+   * before calling this method.
+   *
+   * @param appLogsToInsert Must be deduplicated and validated. Needs to be mutable because it will be sorted
+   * 	(and if you need to clone it, so do it when you need to) - this is weird as TS is slathering type safety onto ducks
+   * @throws Error if validation fails
+   */
+  insertRaw(appLogsToInsert) {
+    DEBUG7(`[WriteableThread.insertRaw] ENTER - ${appLogsToInsert.length} applogs for thread "${this.name}"`);
+    DEBUG7(`[WriteableThread.insertRaw] About to deduplicate`);
+    const deduplicated = removeDuplicateAppLogs(appLogsToInsert, "safety");
+    if (deduplicated.length !== appLogsToInsert.length) {
+      throw ERROR7(`[insertRaw] duplicate applogs passed: ${appLogsToInsert.length - deduplicated.length}`, {
+        appLogsToInsert,
+        deduplicated
+      });
+    }
+    DEBUG7(`[WriteableThread.insertRaw] Deduplication done`);
+    DEBUG7(`[WriteableThread.insertRaw] About to validate`);
+    const bogus = appLogsToInsert.filter((log) => !isValidApplog(log));
+    if (bogus.length) {
+      throw ERROR7(`[insertRaw] bogus applogs passed: ${bogus.length}`, { bogus });
+    }
+    DEBUG7(`[WriteableThread.insertRaw] Validation done`);
+    DEBUG7(`[WriteableThread.insertRaw] About to check for existing`);
+    const existing = appLogsToInsert.filter((log) => this.hasApplog(log, false));
+    if (existing.length) {
+      throw ERROR7(`[insertRaw] already existing applogs passed: ${existing.length}`, { existing });
+    }
+    DEBUG7(`[WriteableThread.insertRaw] Existing check done`);
+    if (!appLogsToInsert.length) {
+      WARN7("[insertRaw] skipping empty insert empty logs array");
+      return;
+    }
+    ;
+    (!this.hasParents && !(this instanceof ThreadInMemory) ? LOG7 : DEBUG7)(
+      "Inserting:",
+      appLogsToInsert.length === 1 ? appLogsToInsert[0] : appLogsToInsert,
+      { ds: this }
+    );
+    DEBUG7(`[WriteableThread.insertRaw] About to sort applogs`);
+    sortApplogsByTs(appLogsToInsert);
+    const sortNeeded = this._applogs.length && isTsBefore(appLogsToInsert[0], this._applogs[this._applogs.length - 1]);
+    DEBUG7(`[WriteableThread.insertRaw] About to push to _applogs array`);
+    const CHUNK_SIZE = 5e4;
+    for (let i = 0; i < appLogsToInsert.length; i += CHUNK_SIZE) {
+      this._applogs.push(...appLogsToInsert.slice(i, i + CHUNK_SIZE));
+    }
+    if (sortNeeded) {
+      DEBUG7(`[WriteableThread.insertRaw] About to sort _applogs (sortNeeded=true)`);
+      sortApplogsByTs(this._applogs);
+    }
+    DEBUG7(`[WriteableThread.insertRaw] About to notify subscribers`);
+    this.notifySubscribers({ added: appLogsToInsert, removed: null });
+    DEBUG7(`[WriteableThread.insertRaw] Subscribers notified`);
+    DEBUG7(`[WriteableThread.insertRaw] About to call persist (void - not awaited)`);
+    void this.persist(appLogsToInsert);
+    DEBUG7(`[WriteableThread.insertRaw] EXIT - returning ${appLogsToInsert.length} applogs`);
+    return appLogsToInsert;
+  }
+  get readOnly() {
+    return false;
+  }
+};
+var ThreadInMemory = class _ThreadInMemory extends WriteableThread {
+  constructor(name, applogs, filters, _readOnly) {
+    super(name, applogs, filters);
+    this._readOnly = _readOnly;
+  }
+  static empty(name) {
+    return _ThreadInMemory.fromArray([], name ?? "empty in-memory", false);
+  }
+  static fromArray(applogs, name, readOnly = false) {
+    return new _ThreadInMemory(name ?? "in-memory", applogs, [], readOnly);
+  }
+  static fromReadOnlyArray(applogs, name) {
+    return new _ThreadInMemory(name ?? "in-memory", applogs, [], true);
+  }
+  get readOnly() {
+    return this._readOnly;
+  }
+  async persist(logs) {
+    VERBOSE7(`[InMem.persist] no persist for`, logs);
+    if (this.readOnly) {
+      throw ERROR7(`[persist] called for readOnly thread`);
+    }
+  }
+};
+
+// src/thread/utils.ts
+import { Logger as Logger8 } from "besonders-logger";
+import { debounce, uniq, uniqWith } from "lodash-es";
+var { WARN: WARN8, LOG: LOG8, DEBUG: DEBUG8, VERBOSE: VERBOSE8, ERROR: ERROR8 } = Logger8.setup(Logger8.INFO);
+function entityCount(thread) {
+  return allEntityIDs(thread).size;
+}
+function allEntityIDs(thread) {
+  return accumulateLogsToSet(thread, (log) => log.en);
+}
+function accumulateLogsToSet(threadOrLogs, callback) {
+  const logs = threadOrLogs instanceof Thread ? threadOrLogs.applogs : threadOrLogs;
+  const set = /* @__PURE__ */ new Set();
+  for (const log of logs) {
+    set.add(callback(log, set));
+  }
+  return set;
+}
+function debounceWrites(thread, wait = 700, removeDuplicatesWith = compareApplogsByEnAt) {
+  if (thread.readOnly) throw ERROR8(`[debounceWrites] but readOnly thread`, thread.name);
+  let insertQueue = [];
+  const debouncedCommit = debounce(() => {
+    WARN8(`Debounce tail`, { thread, mappedThread, insertQueue });
+    const toInsert = ensureTsPvAndFinalizeApplogs(
+      // ? uniq, sure - but which one is used? (update: seems the first one, so reverse)
+      uniqWith(insertQueue.reverse(), removeDuplicatesWith),
+      thread
+    );
+    thread.insertRaw(toInsert);
+    insertQueue.splice(0, insertQueue.length);
+  }, wait);
+  const handleInsert = (applogs) => {
+    DEBUG8(`Debounce input:`, applogs, { thread, mappedThread, insertQueue });
+    insertQueue.push(...applogs);
+    debouncedCommit();
+    return null;
+  };
+  const mappedThread = MappedThread.mapWrites(
+    thread,
+    `Debounce(${wait})`,
+    handleInsert
+  );
+  return mappedThread;
+}
+function holdTillFirstWrite(thread, applogsToHold, opts) {
+  DEBUG8(`[holdTillFirstWrite] holding logs:`, { applogsToHold });
+  if (thread.readOnly) throw ERROR8(`[holdTillFirstWrite] but readOnly thread`, thread.nameAndSizeUntracked);
+  const heldLogs = ensureTsPvAndFinalizeApplogs([...applogsToHold], thread);
+  const heldThread = ThreadInMemory.fromArray(heldLogs);
+  let hasInserted = false;
+  const handleInsert = (realApplogs) => {
+    if (hasInserted) return realApplogs;
+    hasInserted = true;
+    let toInsert = [...heldLogs];
+    if (opts.deduplicateHoldItemsWith) {
+      toInsert = toInsert.filter(
+        (heldLog) => (
+          // some duplicate? so don't insert
+          !realApplogs.some((realLog) => opts.deduplicateHoldItemsWith(heldLog, realLog))
+        )
+      );
+    }
+    if (opts.onFirstWrite) {
+      const callbackResult = opts.onFirstWrite(toInsert);
+      if (callbackResult !== void 0) {
+        toInsert = callbackResult;
+      }
+    }
+    DEBUG8(`[holdTillFirstWrite] adding hold logs:`, { applogsToHold, heldLogs, toInsert, realApplogs });
+    return [...toInsert, ...realApplogs];
+  };
+  const joinedThread = joinThreads([thread, heldThread]);
+  return new MappedThread(
+    `HoldTillFirstWrite[${applogsToHold.length}]<${thread.nameAndSizeUntracked}>`,
+    joinedThread,
+    thread.filters,
+    // @ts-expect-error ? what's the proper way
+    joinedThread.applogs,
+    null,
+    (applogs) => {
+      const logsToInsert = handleInsert(applogs);
+      thread.insert(logsToInsert);
+      return null;
+    }
+  );
+}
+function getAgents(thread) {
+  return uniq(thread.map((l) => l.ag));
+}
+var excludeApplogsContainedIn = (applogs, exclude) => {
+  const excludeCids = exclude instanceof Set ? new Set([...exclude].map((c) => c.toString())) : exclude instanceof Thread ? new Set(exclude.applogsCids) : new Set(exclude.map((a) => a.cid));
+  return applogs.filter((applog) => {
+    if (!applog.cid) {
+      ERROR8(`applog with missing CID`, applog);
+      throw new Error(`applog with missing CID`);
+    }
+    return !excludeCids.has(applog.cid);
+  });
+};
+
+export {
+  Nullable,
+  EntityID_LENGTH,
+  EntityID,
+  isEncryptedApplog,
+  CIDTB,
+  URL,
+  AppLogNoCidTB,
+  AppLogNoCidTBC,
+  getApplogNoCidTypeErrors,
+  isValidApplogNoCid,
+  AppLogTB,
+  AppLogTBC,
+  getApplogTypeErrors,
+  isValidApplog,
+  MULTICODEC_IPNS_KEY,
+  prepareForPub,
+  encodeApplogAndGetCid,
+  encodeApplog,
+  getCidSync,
+  encodeBlock,
+  encodeBlockOriginal,
+  tryParseCID,
+  isIpnsKeyCid,
+  cidToString,
+  toIpnsString,
+  ensureValidCIDinstance,
+  areCidsEqual,
+  containsCid,
+  SubscribableImpl,
+  isArrayInitEvent,
+  SubscribableArrayImpl,
+  createDebugName,
+  createDebugNameObj,
+  prettifyThreadName,
+  isInitEvent,
+  Thread,
+  getLogsFromThread,
+  StaticThread,
+  isoDateStrCompare,
+  objEqualByKeys,
+  compareApplogsByTs,
+  compareApplogsByEnAt,
+  sortApplogsByTs,
+  isTsBefore,
+  uniqueEnFromAppLogs,
+  areApplogsEqual,
+  removeDuplicateAppLogs,
+  getHashID,
+  isVariable,
+  variableNameWithoutQuestionmark,
+  isStaticPattern,
+  resolveOrRemoveVariables,
+  matchPartStatic,
+  matchPart,
+  matchPattern,
+  actualize,
+  arrStats,
+  tsNearlySame,
+  cyrb53hash,
+  arraysContainSameElements,
+  dateNowIso,
+  memoizedFn,
+  refCountedMemoizedFn,
+  MappedThread,
+  rollingFilter2 as rollingFilter,
+  rollingMapper,
+  rollingAcc,
+  getUntrackedPattern,
+  makeFilter,
+  getUntrackedFilterResults,
+  hasFilter,
+  assertRaw,
+  assertOnlyCurrent,
+  asReadOnly,
+  simpleApplogMapper,
+  WriteableThread,
+  ThreadInMemory,
+  entityCount,
+  allEntityIDs,
+  debounceWrites,
+  holdTillFirstWrite,
+  getAgents,
+  excludeApplogsContainedIn,
+  ensureTsPvAndFinalizeApplogs,
+  ensureTsPvAndFinalizeApplog,
+  finalizeApplogForInsert,
+  hasAg,
+  hasTs,
+  hasPv,
+  withTs,
+  withAg,
+  withPvFrom,
+  joinThreads
+};
+//# sourceMappingURL=chunk-XIQSYEV3.js.map