@wovin/core 0.1.36 → 0.2.0

package/dist/chunk-QZXKQCAY.js

@@ -0,0 +1,1026 @@
+import {
+  StaticThread,
+  SubscribableArrayImpl,
+  SubscribableImpl,
+  ThreadInMemory,
+  applogsByEntity,
+  createDebugName,
+  hasFilter,
+  isArrayInitEvent,
+  isInitEvent,
+  isLaterByTsAndPv,
+  isVariable,
+  isoDateStrCompare,
+  joinThreads,
+  makeFilter,
+  memoizedFn,
+  resolveOrRemoveVariables,
+  rollingFilter,
+  rollingMapper,
+  sortApplogsByTs
+} from "./chunk-L5EEEGE6.js";
+
+// src/query/types.ts
+var QueryNode = class {
+  constructor(logsOfThisNode, variables, prevNode = null) {
+    this.logsOfThisNode = logsOfThisNode;
+    this.variables = variables;
+    this.prevNode = prevNode;
+  }
+  get record() {
+    return this.variables;
+  }
+  get threadOfTrail() {
+    if (!this.prevNode) return this.logsOfThisNode;
+    return joinThreads([
+      this.logsOfThisNode,
+      this.prevNode.threadOfTrail
+    ]);
+  }
+  get trailLogs() {
+    return this.threadOfTrail.applogs;
+  }
+};
+var QueryResult = class {
+  constructor(nodes) {
+    this.nodes = nodes;
+  }
+  get size() {
+    return this.nodes.length;
+  }
+  get isEmpty() {
+    return this.nodes.length === 0;
+  }
+  get untrackedSize() {
+    return this.nodes.length;
+  }
+  get records() {
+    return this.nodes.map(({ variables }) => variables);
+  }
+  get leafNodeThread() {
+    return joinThreads(
+      this.nodes.map(({ logsOfThisNode: thread }) => thread)
+    );
+  }
+  get leafNodeLogSet() {
+    return this.nodes.map(({ logsOfThisNode: thread }) => thread.applogs);
+  }
+  get leafNodeLogs() {
+    return this.nodes.flatMap(({ logsOfThisNode: thread }) => thread.applogs);
+  }
+  get threadOfAllTrails() {
+    return joinThreads(this.nodes.map((node) => node.threadOfTrail));
+  }
+  get thread() {
+    return this.threadOfAllTrails;
+  }
+  get allApplogs() {
+    return this.threadOfAllTrails.applogs;
+  }
+};
+var LiveQueryResult = class {
+  constructor(_source, activate = true) {
+    this._source = _source;
+    if (activate) {
+      this._activationUnsub = this._source.subscribe(() => {
+      });
+    }
+  }
+  _activationUnsub = null;
+  /** Subscribe to node change events. Callback fires on future changes only. */
+  subscribe(cb, type) {
+    return this._source.subscribe(cb, type);
+  }
+  /** Current nodes — live view, always up-to-date while not disposed */
+  get nodes() {
+    return this._source.items;
+  }
+  get size() {
+    return this._source.length;
+  }
+  get isEmpty() {
+    return this._source.length === 0;
+  }
+  get untrackedSize() {
+    return this._source.length;
+  }
+  get records() {
+    return this.nodes.map(({ variables }) => variables);
+  }
+  get leafNodeThread() {
+    return joinThreads(
+      this.nodes.map(({ logsOfThisNode: thread }) => thread)
+    );
+  }
+  get leafNodeLogSet() {
+    return this.nodes.map(({ logsOfThisNode: thread }) => thread.applogs);
+  }
+  get leafNodeLogs() {
+    return this.nodes.flatMap(({ logsOfThisNode: thread }) => thread.applogs);
+  }
+  get threadOfAllTrails() {
+    return joinThreads(this.nodes.map((node) => node.threadOfTrail));
+  }
+  get thread() {
+    return this.threadOfAllTrails;
+  }
+  get allApplogs() {
+    return this.threadOfAllTrails.applogs;
+  }
+  dispose() {
+    this._activationUnsub?.();
+    this._activationUnsub = null;
+    this._source.dispose();
+  }
+};
+
+// src/query/basic.ts
+import { Logger } from "besonders-logger";
+import stringify from "safe-stable-stringify";
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO, { prefix: "[q]" });
+function assertLWW(thread) {
+  if (!hasFilter(thread, "lastWriteWins")) {
+    throw ERROR(`requires lastWriteWins-filtered thread, got filters:`, thread.filters, { name: thread.name });
+  }
+}
+var globalQueryTimeoutTime = null;
+var lastWriteWins = memoizedFn("lastWriteWins", function lastWriteWins2(thread, { inverseToOnlyReturnFirstLogs, tolerateAlreadyFiltered } = {}) {
+  VERBOSE(`lastWriteWins${inverseToOnlyReturnFirstLogs ? ".inversed" : ""} < ${thread.nameAndSizeUntracked} > initializing`);
+  if (thread.filters.includes("lastWriteWins")) {
+    if (tolerateAlreadyFiltered) {
+      DEBUG(`[lastWriteWins] already filtered, but tolerateAlreadyFiltered=true, so returning`);
+      return thread;
+    }
+    throw ERROR(`thread already filtered lastWriteWins:`, thread.filters, { name: thread.name });
+  }
+  let rollingMap;
+  const processLogs = (newLogs, toRemove) => {
+    const toAdd = [];
+    let prevTs;
+    for (let i = inverseToOnlyReturnFirstLogs ? 0 : newLogs.length - 1; inverseToOnlyReturnFirstLogs ? i < newLogs.length : i >= 0; inverseToOnlyReturnFirstLogs ? i++ : i--) {
+      const log = newLogs[i];
+      const key = log.en + "|" + log.at;
+      if (prevTs !== void 0) {
+        const cmp = isoDateStrCompare(prevTs, log.ts);
+        if (inverseToOnlyReturnFirstLogs ? cmp > 0 : cmp < 0) {
+          throw ERROR(`lastWriteWins.processLogs logs not ts-sorted:`, prevTs, inverseToOnlyReturnFirstLogs ? ">" : "<", log.ts, {
+            log,
+            i,
+            newLogs,
+            inverseToOnlyReturnFirstLogs
+          });
+        }
+      }
+      prevTs = log.ts;
+      const existing = rollingMap.get(key);
+      const replaces = !existing || (inverseToOnlyReturnFirstLogs ? isLaterByTsAndPv(existing, log) : isLaterByTsAndPv(log, existing));
+      if (replaces) {
+        if (existing && toRemove) toRemove.push(existing);
+        toAdd.push(log);
+        rollingMap.set(key, log);
+      }
+    }
+    return toAdd;
+  };
+  const lwwName = `lastWriteWins${inverseToOnlyReturnFirstLogs ? ".inversed" : ""}`;
+  const derivation = {
+    compute(parents) {
+      if (parents.length !== 1) {
+        throw ERROR(`${lwwName} requires exactly one parent`, { parents: parents.length });
+      }
+      const [parent] = parents;
+      rollingMap = /* @__PURE__ */ new Map();
+      const toAdd = processLogs(parent.applogs, null);
+      sortApplogsByTs(toAdd);
+      VERBOSE.isDisabled || VERBOSE(`${lwwName}<${thread.nameAndSizeUntracked}> compute`, { toAdd: toAdd.length });
+      return toAdd;
+    },
+    mapDelta(delta) {
+      const toRemove = [];
+      const toAdd = processLogs(delta.added, toRemove);
+      sortApplogsByTs(toAdd);
+      VERBOSE.isDisabled || VERBOSE(`${lwwName}<${thread.nameAndSizeUntracked}> mapDelta`, { ...delta, toAdd, toRemove });
+      return { added: toAdd, removed: toRemove };
+    }
+  };
+  const mappedThread = rollingMapper(thread, derivation, { name: lwwName, extraFilterName: "lastWriteWins" });
+  VERBOSE.isDisabled || VERBOSE(`lastWriteWins<${thread.nameAndSizeUntracked}> filtered down to`, mappedThread.applogs.length);
+  return mappedThread;
+}, { argsDebugName: (thread) => createDebugName({ caller: "lastWriteWins", thread }) });
+var isDeletedAttrs = ["isDeleted", "relation/isDeleted", "block/isDeleted"];
+function isDeletionLog(log) {
+  return log.vl === true && isDeletedAttrs.includes(log.at);
+}
+var withoutDeleted = memoizedFn("withoutDeleted", function withoutDeleted2(thread) {
+  if (VERBOSE.isEnabled) VERBOSE(`withoutDeleted<${thread.nameAndSizeUntracked}>`);
+  if (thread.filters.includes("withoutDeleted")) {
+    throw ERROR(`thread already filtered withoutDeleted:`, thread.filters, { name: thread.name });
+  }
+  if (!thread.filters.includes("lastWriteWins")) {
+    WARN(`withoutDeleted on non-lastWriteWins thread: un-deletion (isDeleted: false) won't take effect`, { thread: thread.name });
+  }
+  const byEntity = applogsByEntity(thread);
+  const activeDeletionMarkers = /* @__PURE__ */ new Map();
+  for (const log of thread.applogs) {
+    if (isDeletionLog(log)) {
+      activeDeletionMarkers.set(log.en, (activeDeletionMarkers.get(log.en) ?? 0) + 1);
+    }
+  }
+  const isHidden = (en) => activeDeletionMarkers.has(en);
+  const derivation = {
+    compute(parents) {
+      if (parents.length !== 1) throw ERROR(`withoutDeleted requires exactly one parent`, { parents: parents.length });
+      const [parent] = parents;
+      activeDeletionMarkers.clear();
+      for (const log of parent.applogs) {
+        if (isDeletionLog(log)) {
+          activeDeletionMarkers.set(log.en, (activeDeletionMarkers.get(log.en) ?? 0) + 1);
+        }
+      }
+      return parent.applogs.filter((log) => !isHidden(log.en));
+    },
+    mapDelta: (delta) => {
+      const hiddenBefore = new Set(activeDeletionMarkers.keys());
+      const entitiesNowHidden = [];
+      const entitiesNowVisible = [];
+      for (const log of delta.added) {
+        if (!isDeletionLog(log)) continue;
+        const prev = activeDeletionMarkers.get(log.en) ?? 0;
+        activeDeletionMarkers.set(log.en, prev + 1);
+        if (prev === 0) entitiesNowHidden.push(log.en);
+      }
+      if (delta.removed) {
+        for (const log of delta.removed) {
+          if (!isDeletionLog(log)) continue;
+          const prev = activeDeletionMarkers.get(log.en) ?? 0;
+          const next = prev - 1;
+          if (next > 0) activeDeletionMarkers.set(log.en, next);
+          else {
+            activeDeletionMarkers.delete(log.en);
+            entitiesNowVisible.push(log.en);
+          }
+        }
+      }
+      const newAddedSet = new Set(delta.added);
+      const syntheticRemovals = [];
+      for (const en of entitiesNowHidden) {
+        const applogs = byEntity.get(en);
+        if (!applogs) continue;
+        for (const log of applogs) {
+          if (!newAddedSet.has(log)) syntheticRemovals.push(log);
+        }
+      }
+      const syntheticAdditions = [];
+      for (const en of entitiesNowVisible) {
+        const applogs = byEntity.get(en);
+        if (applogs) syntheticAdditions.push(...applogs);
+      }
+      const passAdded = delta.added.filter((log) => !hiddenBefore.has(log.en) && !isHidden(log.en));
+      const passRemoved = delta.removed?.filter((log) => !hiddenBefore.has(log.en)) ?? [];
+      return {
+        added: [...passAdded, ...syntheticAdditions],
+        removed: [...passRemoved, ...syntheticRemovals]
+      };
+    }
+  };
+  const result = rollingMapper(thread, derivation, { name: "withoutDeleted", extraFilterName: "withoutDeleted" });
+  return result;
+});
+function makeQueryNode(log, parentNode, varMapper, threadName) {
+  const nodeVars = Object.assign({}, parentNode?.variables, varMapper(log));
+  return new QueryNode(
+    StaticThread.fromArray([log], threadName),
+    nodeVars,
+    parentNode
+  );
+}
+var query = memoizedFn("query", function query2(threadOrLogs, patternOrPatterns, startVariables = {}, opts = {}) {
+  throwOnTimeout();
+  const thread = threadFromMaybeArray(threadOrLogs);
+  DEBUG(`query<${thread.nameAndSizeUntracked}>:`, patternOrPatterns);
+  const patterns = Array.isArray(patternOrPatterns) ? patternOrPatterns : [patternOrPatterns];
+  warnIfDisjointQuerySteps(patterns);
+  let prevNodes;
+  if (patterns.length === 1) {
+    prevNodes = null;
+  } else {
+    const patternsExceptLast = patterns.slice(0, -1);
+    prevNodes = query2(thread, patternsExceptLast, startVariables, opts).nodes;
+  }
+  const lastPattern = patterns[patterns.length - 1];
+  const stepResult = queryStepOnce(thread, prevNodes, lastPattern, opts);
+  VERBOSE.isDisabled || VERBOSE(`query result:`, stepResult.nodes);
+  return stepResult;
+}, {
+  argsDebugName: (thread, pattern, startVars) => createDebugName({ caller: "query", thread, args: startVars ? { pattern, startVars } : pattern })
+});
+function queryStepOnce(thread, prevNodes, pattern, opts = {}) {
+  DEBUG(`queryStepOnce<${thread.nameAndSizeUntracked}> with`, prevNodes?.length ?? "all", "nodes, pattern:", pattern);
+  if (!Object.entries(pattern).length) throw new Error(`Pattern is empty`);
+  function doQueryOnce(node) {
+    const [patternWithResolvedVars, variablesToFill] = resolveOrRemoveVariables(pattern, node?.variables ?? {});
+    VERBOSE(`[queryStepOnce.doQuery] patternWithoutVars: `, patternWithResolvedVars);
+    const filter = makeFilter(patternWithResolvedVars);
+    const matchingLogs = filter(thread.applogs);
+    const varMapper = createObjMapper(variablesToFill);
+    const nodes = matchingLogs.map((log) => makeQueryNode(
+      log,
+      node,
+      varMapper,
+      createDebugName({
+        caller: "QueryNode",
+        thread,
+        pattern: `${stringify(Object.assign({}, node?.variables, varMapper(log)))}@${stringify(patternWithResolvedVars)}`
+      })
+    ));
+    if (VERBOSE.isEnabled) VERBOSE(`[queryStepOnce.doQuery] nodes:`, nodes.map((n) => n.variables));
+    if (opts.debug) {
+      LOG(`[queryStepOnce] step result:`, nodes.map(({ variables, logsOfThisNode: thread2 }) => ({
+        variables,
+        thread: thread2
+      })));
+    }
+    return nodes;
+  }
+  if (!prevNodes) {
+    return new QueryResult(doQueryOnce(null));
+  }
+  const allNodes = prevNodes.flatMap((inputNode) => doQueryOnce(inputNode));
+  return new QueryResult(allNodes);
+}
+var liveQuery = memoizedFn("liveQuery", function liveQuery2(threadOrLogs, patternOrPatterns, startVariables = {}, opts = {}) {
+  throwOnTimeout();
+  const thread = threadFromMaybeArray(threadOrLogs);
+  DEBUG(`liveQuery<${thread.nameAndSizeUntracked}>:`, patternOrPatterns);
+  const patterns = Array.isArray(patternOrPatterns) ? patternOrPatterns : [patternOrPatterns];
+  let prevResult;
+  if (patterns.length === 1) {
+    prevResult = null;
+  } else {
+    const patternsExceptLast = patterns.slice(0, -1);
+    prevResult = liveQuery2(thread, patternsExceptLast, startVariables, opts);
+  }
+  const lastPattern = patterns[patterns.length - 1];
+  const stepResult = liveQueryStep(thread, prevResult, lastPattern, opts);
+  VERBOSE.isDisabled || VERBOSE(`liveQuery result:`, stepResult.nodes);
+  return stepResult;
+}, {
+  argsDebugName: (thread, pattern, startVars) => createDebugName({ caller: "liveQuery", thread, args: startVars ? { pattern, startVars } : pattern })
+});
+var liveQueryStep = memoizedFn("liveQueryStep", function liveQueryStep2(thread, nodeSet, pattern, opts = {}) {
+  DEBUG(`liveQueryStep<${thread.nameAndSizeUntracked}> with`, nodeSet?.untrackedSize ?? "all", "nodes, pattern:", pattern);
+  if (!Object.entries(pattern).length) throw new Error(`Pattern is empty`);
+  function doQuery(node) {
+    const [patternWithResolvedVars, variablesToFill] = resolveOrRemoveVariables(pattern, node?.variables ?? {});
+    VERBOSE(`[liveQueryStep.doQuery] patternWithoutVars: `, patternWithResolvedVars);
+    const applogsMatchingStatic = rollingFilter(thread, patternWithResolvedVars);
+    const varMapper = createObjMapper(variablesToFill);
+    function makeNode(log) {
+      return makeQueryNode(
+        log,
+        node,
+        varMapper,
+        createDebugName({
+          caller: "QueryNode",
+          thread: applogsMatchingStatic,
+          pattern: `${stringify(Object.assign({}, node?.variables, varMapper(log)))}@${stringify(patternWithResolvedVars)}`
+        })
+      );
+    }
+    const initialNodes = applogsMatchingStatic.applogs.map(makeNode);
+    if (VERBOSE.isEnabled) VERBOSE(`[liveQueryStep.doQuery] initial nodes:`, initialNodes.map((n) => n.variables));
+    if (opts.debug) {
+      LOG(`[liveQueryStep] step result:`, initialNodes.map(({ variables, logsOfThisNode: thread2 }) => ({
+        variables,
+        thread: thread2
+      })));
+    }
+    const result = new SubscribableArrayImpl(
+      initialNodes,
+      () => applogsMatchingStatic.subscribe((event) => {
+        if (isInitEvent(event)) {
+          result._reset(event.init.map(makeNode));
+        } else {
+          if (event.added.length) {
+            result._push(...event.added.map(makeNode));
+          }
+          if (event.removed?.length) {
+            const removedCids = new Set(event.removed.map((log) => log.cid));
+            const toRemove = result.items.filter(
+              (qn) => removedCids.has(qn.logsOfThisNode.applogs[0]?.cid)
+            );
+            if (toRemove.length) result._remove(toRemove);
+          }
+        }
+      }, "derived")
+    );
+    return result;
+  }
+  if (!nodeSet) {
+    return new LiveQueryResult(doQuery(null));
+  }
+  const initialInners = nodeSet.nodes.map((inputNode) => ({
+    inputNode,
+    inner: doQuery(inputNode)
+  }));
+  const initialItems = initialInners.flatMap(({ inner }) => [...inner.items]);
+  const aggregated = new SubscribableArrayImpl(
+    initialItems,
+    () => {
+      const subsByInputNode = /* @__PURE__ */ new Map();
+      function wireInner(inputNode, inner) {
+        const entry = { inner, unsub: null, nodes: [...inner.items] };
+        entry.unsub = inner.subscribe((event) => {
+          if (isArrayInitEvent(event)) {
+            if (entry.nodes.length) aggregated._remove(entry.nodes);
+            entry.nodes = [...event.init];
+            if (entry.nodes.length) aggregated._push(...entry.nodes);
+          } else {
+            if (event.added.length) {
+              entry.nodes.push(...event.added);
+              aggregated._push(...event.added);
+            }
+            if (event.removed?.length) {
+              for (const r of event.removed) {
+                const idx = entry.nodes.indexOf(r);
+                if (idx >= 0) entry.nodes.splice(idx, 1);
+              }
+              aggregated._remove(event.removed);
+            }
+          }
+        }, "derived");
+        subsByInputNode.set(inputNode, entry);
+        return entry.nodes;
+      }
+      function addInputNode(inputNode) {
+        return wireInner(inputNode, doQuery(inputNode));
+      }
+      function removeInputNode(inputNode) {
+        const entry = subsByInputNode.get(inputNode);
+        if (!entry) return [];
+        entry.unsub();
+        entry.inner.dispose();
+        const removed = entry.nodes;
+        subsByInputNode.delete(inputNode);
+        return removed;
+      }
+      for (const { inputNode, inner } of initialInners) {
+        wireInner(inputNode, inner);
+      }
+      const prevUnsub = nodeSet.subscribe((event) => {
+        if (isArrayInitEvent(event)) {
+          for (const [, entry] of subsByInputNode) {
+            entry.unsub();
+            entry.inner.dispose();
+          }
+          subsByInputNode.clear();
+          const allNodes = [];
+          for (const node of event.init) {
+            allNodes.push(...addInputNode(node));
+          }
+          aggregated._reset(allNodes);
+        } else {
+          if (event.added.length) {
+            const allAdded = [];
+            for (const node of event.added) {
+              allAdded.push(...addInputNode(node));
+            }
+            if (allAdded.length) aggregated._push(...allAdded);
+          }
+          if (event.removed?.length) {
+            const allRemoved = [];
+            for (const node of event.removed) {
+              allRemoved.push(...removeInputNode(node));
+            }
+            if (allRemoved.length) aggregated._remove(allRemoved);
+          }
+        }
+      }, "derived");
+      return () => {
+        prevUnsub();
+        for (const [, entry] of subsByInputNode) {
+          entry.unsub();
+          entry.inner.dispose();
+        }
+        subsByInputNode.clear();
+      };
+    }
+  );
+  if (VERBOSE.isEnabled) VERBOSE(`[liveQueryStep] aggregated initial:`, [...aggregated.items]);
+  return new LiveQueryResult(aggregated);
+}, { argsDebugName: (thread, _nodes, pattern) => createDebugName({ caller: "liveQueryStep", thread, pattern }) });
+var queryNot = memoizedFn("queryNot", function queryNot2(thread, startNodes, patternOrPatterns, opts = {}) {
+  const nodes = startNodes.nodes;
+  DEBUG(`queryNot<${thread.nameAndSizeUntracked}> from: ${nodes.length} nodes`);
+  const patterns = Array.isArray(patternOrPatterns) ? patternOrPatterns : [patternOrPatterns];
+  const filtered = nodes.filter(function innerNodeFilter({ variables }) {
+    let bindings = [variables ?? {}];
+    for (const pattern of patterns) {
+      if (!Object.entries(pattern).length) throw new Error(`Pattern is empty`);
+      const nextBindings = [];
+      for (const binding of bindings) {
+        const [resolved, varsToFill] = resolveOrRemoveVariables(pattern, binding);
+        const filter = makeFilter(resolved);
+        const matchingLogs = filter(thread.applogs);
+        const varMapper = createObjMapper(varsToFill);
+        for (const log of matchingLogs) {
+          nextBindings.push({ ...binding, ...varMapper(log) });
+        }
+      }
+      bindings = nextBindings;
+      if (bindings.length === 0) break;
+    }
+    VERBOSE(`[queryNot] node:`, variables, "=> bindings:", bindings.length);
+    if (opts.debug) LOG(`[queryNot] node result:`, variables, "=>", bindings);
+    return bindings.length === 0;
+  });
+  return new QueryResult([...filtered]);
+}, { argsDebugName: (thread, nodes, pattern) => createDebugName({ caller: "queryNot", thread, pattern }) });
+var liveQueryNot = memoizedFn("liveQueryNot", function liveQueryNot2(thread, upstream, patternOrPatterns, opts = {}) {
+  const patterns = Array.isArray(patternOrPatterns) ? patternOrPatterns : [patternOrPatterns];
+  function nodeMatchesNot(node, applogs) {
+    let bindings = [node.variables ?? {}];
+    for (const pattern of patterns) {
+      const nextBindings = [];
+      for (const binding of bindings) {
+        const [resolved, varsToFill] = resolveOrRemoveVariables(pattern, binding);
+        const filter = makeFilter(resolved);
+        const varMapper = createObjMapper(varsToFill);
+        for (const log of filter(applogs)) {
+          nextBindings.push({ ...binding, ...varMapper(log) });
+        }
+      }
+      bindings = nextBindings;
+      if (bindings.length === 0) return false;
+    }
+    return bindings.length > 0;
+  }
+  function computeAll() {
+    return upstream.nodes.filter((node) => !nodeMatchesNot(node, thread.applogs));
+  }
+  const result = new SubscribableArrayImpl(
+    computeAll(),
+    () => {
+      const threadUnsub = thread.subscribe((event) => {
+        if (isInitEvent(event)) {
+          result._reset(computeAll());
+          return;
+        }
+        if (event.removed?.length) {
+          result._reset(computeAll());
+          return;
+        }
+        if (event.added.length) {
+          const toRemove = result.items.filter((node) => nodeMatchesNot(node, event.added));
+          if (toRemove.length > 0) {
+            result._remove(toRemove);
+          }
+        }
+      }, "derived");
+      const upstreamUnsub = upstream.subscribe((event) => {
+        if (isArrayInitEvent(event)) {
+          result._reset(computeAll());
+          return;
+        }
+        if (event.added.length) {
+          const passing = event.added.filter((node) => !nodeMatchesNot(node, thread.applogs));
+          if (passing.length > 0) result._push(...passing);
+        }
+        if (event.removed?.length) {
+          const removedSet = new Set(event.removed);
+          const toRemove = result.items.filter((node) => removedSet.has(node));
+          if (toRemove.length > 0) result._remove(toRemove);
+        }
+      }, "derived");
+      return () => {
+        threadUnsub();
+        upstreamUnsub();
+      };
+    }
+  );
+  return new LiveQueryResult(result);
+}, { argsDebugName: (thread, _nodes, pattern) => createDebugName({ caller: "liveQueryNot", thread, pattern }) });
+var filterAndMap = memoizedFn("filterAndMap", function filterAndMap2(thread, pattern, mapper) {
+  DEBUG(`filterAndMap<${thread.nameAndSizeUntracked}>`, pattern);
+  const filter = makeFilter(pattern);
+  const filtered = filter(thread.applogs);
+  return mapApplogsWith(filtered, mapper);
+}, { argsDebugName: (thread, pattern) => createDebugName({ caller: "filterAndMap", thread, pattern }) });
+var liveFilterAndMap = memoizedFn("liveFilterAndMap", function liveFilterAndMap2(thread, pattern, mapper) {
+  DEBUG(`liveFilterAndMap<${thread.nameAndSizeUntracked}>`, pattern);
+  const filtered = rollingFilter(thread, pattern);
+  const mapFn = makeApplogMapper(mapper);
+  const cidToMapped = /* @__PURE__ */ new Map();
+  const mapAndTrack = (log) => {
+    const r = mapFn(log);
+    cidToMapped.set(log.cid, r);
+    return r;
+  };
+  const initial = filtered.applogs.map(mapAndTrack);
+  const result = new SubscribableArrayImpl(
+    initial,
+    () => filtered.subscribe((event) => {
+      if (isInitEvent(event)) {
+        cidToMapped.clear();
+        result._reset(event.init.map(mapAndTrack));
+      } else {
+        if (event.added.length) result._push(...event.added.map(mapAndTrack));
+        if (event.removed?.length) {
+          const toRemove = [];
+          for (const log of event.removed) {
+            const r = cidToMapped.get(log.cid);
+            if (r === void 0) {
+              WARN(`[liveFilterAndMap] removed log not in cidToMapped`, { log });
+              continue;
+            }
+            cidToMapped.delete(log.cid);
+            toRemove.push(r);
+          }
+          if (toRemove.length) result._remove(toRemove);
+        }
+      }
+    }, "derived")
+  );
+  return result;
+}, { argsDebugName: (thread, pattern) => createDebugName({ caller: "liveFilterAndMap", thread, pattern }) });
+var queryAndMap = memoizedFn("queryAndMap", function queryAndMap2(threadOrLogs, patternOrPatterns, mapDef, variables = {}) {
+  const thread = threadFromMaybeArray(threadOrLogs);
+  DEBUG(`queryAndMap<${thread.nameAndSizeUntracked}>`, { patternOrPatterns, variables, map: mapDef });
+  const queryResult = query(thread, patternOrPatterns);
+  return mapQueryResultWith(queryResult, mapDef);
+}, { argsDebugName: (thread, pattern) => createDebugName({ caller: "queryAndMap", thread, pattern }) });
+var liveQueryAndMap = memoizedFn("liveQueryAndMap", function liveQueryAndMap2(thread, patternOrPatterns, mapDef) {
+  DEBUG(`liveQueryAndMap<${thread.nameAndSizeUntracked}>`, { patternOrPatterns, map: mapDef });
+  const live = liveQuery(thread, patternOrPatterns);
+  function computeAll() {
+    const snapshot = new QueryResult(live.nodes);
+    return mapQueryResultWith(snapshot, mapDef);
+  }
+  const result = new SubscribableArrayImpl(
+    computeAll(),
+    () => live.subscribe(() => {
+      result._reset(computeAll());
+    }, "derived")
+  );
+  return result;
+}, { argsDebugName: (thread, pattern) => createDebugName({ caller: "liveQueryAndMap", thread, pattern }) });
+var queryEntity = memoizedFn("queryEntity", function queryEntity2(thread, name, entityID, attributes) {
+  assertLWW(thread);
+  DEBUG(`queryEntity<${thread.nameAndSizeUntracked}>`, entityID, name);
+  const filter = makeFilter({ en: entityID, at: prefixAttrs(name, attributes) });
+  const filtered = filter(thread.applogs);
+  VERBOSE(`queryEntity applogs:`, filtered);
+  if (filtered.length === 0) return null;
+  return Object.fromEntries(
+    filtered.map(({ at, vl }) => [at.slice(name.length + 1), vl])
+  );
+}, {
+  argsDebugName: (thread, name, entityID) => createDebugName({ caller: "queryEntity", thread, args: { name, entityID } })
+});
+var liveQueryEntity = memoizedFn("liveQueryEntity", function liveQueryEntity2(thread, name, entityID, attributes) {
+  assertLWW(thread);
+  DEBUG(`liveQueryEntity<${thread.nameAndSizeUntracked}>`, entityID, name);
+  const filtered = rollingFilter(thread, { en: entityID, at: prefixAttrs(name, attributes) });
+  function compute() {
+    if (filtered.isEmpty) return null;
+    return Object.fromEntries(
+      filtered.map(({ at, vl }) => [at.slice(name.length + 1), vl])
+    );
+  }
+  const result = new SubscribableImpl(
+    compute(),
+    () => filtered.subscribe(() => {
+      result._set(compute());
+    }, "derived")
+  );
+  return result;
+}, {
+  argsDebugName: (thread, name, entityID) => createDebugName({ caller: "liveQueryEntity", thread, args: { name, entityID } })
+});
+var liveEntityAt = memoizedFn("liveEntityAt", function liveEntityAt2(thread, entityID, at) {
+  assertLWW(thread);
+  DEBUG(`liveEntityAt<${thread.nameAndSizeUntracked}>`, entityID, at);
+  const filtered = rollingFilter(thread, { en: entityID, at });
+  function compute() {
+    if (filtered.isEmpty) return null;
+    return filtered.applogs[filtered.applogs.length - 1].vl;
+  }
+  const result = new SubscribableImpl(
+    compute(),
+    () => filtered.subscribe(() => {
+      result._set(compute());
+    }, "derived")
+  );
+  return result;
+}, {
+  argsDebugName: (thread, entityID, at) => createDebugName({ caller: "liveEntityAt", thread, args: { entityID, at } })
+});
+var agentsOfThread = memoizedFn("agentsOfThread", function agentsOfThread2(thread) {
+  DEBUG(`agentsOfThread<${thread.nameAndSizeUntracked}>`);
+  const mapped = /* @__PURE__ */ new Map();
+  const onEvent = (event) => {
+    for (const log of isInitEvent(event) ? event.init : event.added) {
+      const prev = mapped.get(log.ag) ?? 0;
+      mapped.set(log.ag, prev + 1);
+    }
+    for (const log of !isInitEvent(event) && event.removed || []) {
+      const prev = mapped.get(log.ag);
+      if (!prev || prev < 1) throw ERROR(`[agentsOfThread] number is now negative`, { log, event, mapped, prev });
+      mapped.set(log.ag, prev - 1);
+    }
+    LOG(`agentsOfThread<${thread.nameAndSizeUntracked}> processed event`, { event, mapped });
+  };
+  onEvent({ init: thread.applogs });
+  thread.subscribe(onEvent, "derived");
+  return mapped;
+});
+var entityOverlap = memoizedFn("entityOverlap", function entityOverlapCount(threadA, threadB) {
+  LOG(`entityOverlap<${threadA.nameAndSizeUntracked}, ${threadB.nameAndSizeUntracked}>`);
+  const entitiesA = new Set(threadA.map((log) => log.en));
+  const entitiesB = new Set(threadB.map((log) => log.en));
+  return [...entitiesA].filter((en) => entitiesB.has(en));
+});
+var entityOverlapMap = function entityOverlapMap2(threadA, threadB, threadAName = "incoming", threadBName = "current") {
+  const useInferredVM = (en, thread) => en;
+  const overlapping = entityOverlap(threadA, threadB);
+  const mapped = /* @__PURE__ */ new Map();
+  overlapping.forEach((eachEntityID) => mapped.set(eachEntityID, {
+    [threadAName]: useInferredVM(eachEntityID, threadA),
+    [threadBName]: useInferredVM(eachEntityID, threadB)
+  }));
+};
+var entityOverlapCount2 = memoizedFn(
+  "entityOverlapCount",
+  function entityOverlapCount3(threadA, threadB) {
+    return entityOverlap(threadA, threadB).length;
+  }
+);
+var liveEntityOverlapCount = memoizedFn(
+  "liveEntityOverlapCount",
+  function liveEntityOverlapCount2(threadA, threadB) {
+    function compute() {
+      const entitiesA = new Set(threadA.map((log) => log.en));
+      const entitiesB = new Set(threadB.map((log) => log.en));
+      return [...entitiesA].filter((en) => entitiesB.has(en)).length;
+    }
+    const result = new SubscribableImpl(
+      compute(),
+      () => {
+        const unsub1 = threadA.subscribe(() => result._set(compute()), "derived");
+        const unsub2 = threadB.subscribe(() => result._set(compute()), "derived");
+        return () => {
+          unsub1();
+          unsub2();
+        };
+      }
+    );
+    return result;
+  }
+);
+var querySingle = memoizedFn("querySingle", function querySingle2(threadOrLogs, patternOrPatterns, variables = {}) {
+  const result = query(threadOrLogs, patternOrPatterns, variables);
+  if (result.isEmpty) return null;
+  if (result.size > 1) throw ERROR(`[querySingle] got`, result.size, `results:`, result);
+  const logsOfThisNode = result.nodes[0].logsOfThisNode;
+  if (logsOfThisNode.size != 1) throw ERROR(`[querySingle] single result, but got`, logsOfThisNode.size, `logs:`, logsOfThisNode.applogs);
+  return logsOfThisNode.applogs[0];
+}, {
+  argsDebugName: (thread, pattern) => createDebugName({ caller: "querySingle", thread, pattern })
+});
+var querySingleAndMap = memoizedFn(
+  "querySingleAndMap",
+  function querySingleAndMap2(threadOrLogs, patternOrPatterns, mapDef, variables = {}) {
+    const log = querySingle(threadOrLogs, patternOrPatterns, variables);
+    if (!log) return void 0;
+    if (typeof mapDef === "string") {
+      return log[mapDef];
+    } else {
+      return createObjMapper(mapDef)(log);
+    }
+  },
+  {
+    argsDebugName: (thread, pattern) => createDebugName({ caller: "querySingleAndMap", thread, pattern })
+  }
+);
+var liveQuerySingle = memoizedFn("liveQuerySingle", function liveQuerySingle2(thread, patternOrPatterns) {
+  DEBUG(`liveQuerySingle<${thread.nameAndSizeUntracked}>`);
+  const live = liveQuery(thread, patternOrPatterns);
+  function compute() {
+    if (live.isEmpty) return null;
+    if (live.size > 1) throw ERROR(`[liveQuerySingle] got`, live.size, `results`);
+    const logsOfThisNode = live.nodes[0].logsOfThisNode;
+    if (logsOfThisNode.size !== 1) throw ERROR(`[liveQuerySingle] single result, but got`, logsOfThisNode.size, `logs`);
+    return logsOfThisNode.applogs[0];
+  }
+  const result = new SubscribableImpl(
+    compute(),
+    () => live.subscribe(() => {
+      result._set(compute());
+    })
+  );
+  return result;
+}, {
+  argsDebugName: (thread, pattern) => createDebugName({ caller: "liveQuerySingle", thread, pattern })
+});
+var liveQuerySingleAndMap = memoizedFn(
+  "liveQuerySingleAndMap",
+  function liveQuerySingleAndMap2(thread, patternOrPatterns, mapDef) {
+    DEBUG(`liveQuerySingleAndMap<${thread.nameAndSizeUntracked}>`);
+    const liveSingle = liveQuerySingle(thread, patternOrPatterns);
+    function compute() {
+      const log = liveSingle.value;
+      if (!log) return void 0;
+      if (typeof mapDef === "string") {
+        return log[mapDef];
+      } else {
+        return createObjMapper(mapDef)(log);
+      }
+    }
+    const result = new SubscribableImpl(
+      compute(),
+      () => liveSingle.subscribe(() => {
+        result._set(compute());
+      })
+    );
+    return result;
+  },
+  {
+    argsDebugName: (thread, pattern) => createDebugName({ caller: "liveQuerySingleAndMap", thread, pattern })
+  }
+);
+function makeApplogMapper(mapDef) {
+  if (typeof mapDef === "function") {
+    return mapDef;
+  } else if (typeof mapDef === "string") {
+    return (log) => log[mapDef];
+  } else {
+    return createObjMapper(mapDef);
+  }
+}
+function mapApplogsWith(applogs, mapDef) {
+  return applogs.map(makeApplogMapper(mapDef));
+}
+var mapThreadWith = function filterAndMapGetterFx(thread, mapDef) {
+  return mapApplogsWith(thread.applogs, mapDef);
+};
+var mapQueryResultWith = function filterAndMapGetterFx2(queryResult, mapDef) {
+  if (typeof mapDef === "function") {
+    return queryResult.records.map(mapDef);
+  } else if (typeof mapDef === "string") {
+    return queryResult.nodes.map((node) => {
+      if (!Object.hasOwn(node.record, mapDef)) {
+        if (node.logsOfThisNode.size !== 1) {
+          throw ERROR(`not sure what to map (it's not a var and a result node log count of ${node.logsOfThisNode.size})`);
+        }
+        return node.logsOfThisNode.firstLog[mapDef];
+      }
+      return node.record[mapDef];
+    });
+  } else {
+    return queryResult.nodes.map((node) => {
+      return createObjMapper(mapDef)(node.record);
+    });
+  }
+};
+function createObjMapper(applogFieldMap) {
+  return (applog) => {
+    return Object.entries(applogFieldMap).reduce((acc, [key, value]) => {
+      acc[value] = applog[key];
+      return acc;
+    }, {});
+  };
+}
+function startsWith(str) {
+  return (value) => value.startsWith(str);
+}
+function prefixAttrs(prefix, attrs) {
+  return attrs.map((at) => prefixAt(prefix, at));
+}
+function prefixAt(prefix, attr) {
+  return `${prefix}/${attr}`;
+}
+function stripAtPrefix(attr) {
+  const idx = attr.indexOf("/");
+  return idx >= 0 ? attr.slice(idx + 1) : attr;
+}
+function mapAttributes(mapping) {
+  return (attr) => mapping[attr] ?? attr;
+}
+function resolveKeyMapper(opts) {
+  if (!opts) return (attr) => attr;
+  if (opts.mapKeys) return opts.mapKeys;
+  if (opts.stripAtPrefix === true) return stripAtPrefix;
+  if (typeof opts.stripAtPrefix === "string") {
+    const prefix = opts.stripAtPrefix + "/";
+    return (attr) => attr.startsWith(prefix) ? attr.slice(prefix.length) : attr;
+  }
+  return (attr) => attr;
+}
+function threadFromMaybeArray(threadOrLogs, name) {
+  if (!Array.isArray(threadOrLogs)) {
+    return threadOrLogs;
+  }
+  return ThreadInMemory.fromArray(threadOrLogs, name || `threadFromArray[${threadOrLogs.length}]`, true);
+}
+function withTimeout(timeoutMilliseconds, func) {
+  if (globalQueryTimeoutTime) throw ERROR(`Nested timeout not supported`);
+  globalQueryTimeoutTime = performance.now() + timeoutMilliseconds;
+  try {
+    return func();
+  } finally {
+    globalQueryTimeoutTime = null;
+  }
+}
+function getPatternVariableNames(pattern) {
+  const vars = /* @__PURE__ */ new Set();
+  for (const value of Object.values(pattern)) {
+    if (isVariable(value)) {
+      vars.add(value.slice(1));
+    }
+  }
+  return vars;
+}
+function warnIfDisjointQuerySteps(patterns) {
+  if (patterns.length < 2) return;
+  const varSets = patterns.map(getPatternVariableNames);
+  const reachable = new Set(varSets[0]);
+  for (let i = 1; i < varSets.length; i++) {
+    const stepVars = varSets[i];
+    if (stepVars.size === 0) {
+      WARN(
+        `[query] Step ${i} has no variables \u2014 it produces identical results regardless of previous steps (cartesian product).`,
+        `Patterns:`,
+        patterns
+      );
+      continue;
+    }
+    const connected = [...stepVars].some((v) => reachable.has(v));
+    if (!connected) {
+      WARN(
+        `[query] Step ${i} is disconnected from previous steps \u2014 no shared variable.`,
+        `This produces a cartesian product instead of a join.`,
+        `Step ${i} variables: {${[...stepVars].join(", ")}}`,
+        `Reachable from prior steps: {${[...reachable].join(", ")}}`,
+        `Patterns:`,
+        patterns
+      );
+    }
+    for (const v of stepVars) reachable.add(v);
+  }
+}
+function throwOnTimeout() {
+  if (globalQueryTimeoutTime == null) return;
+  if (performance.now() >= globalQueryTimeoutTime) {
+    throw new QueryTimeoutError(globalQueryTimeoutTime);
+  }
+}
+var QueryTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+export {
+  QueryNode,
+  QueryResult,
+  LiveQueryResult,
+  lastWriteWins,
+  withoutDeleted,
+  query,
+  queryStepOnce,
+  liveQuery,
+  liveQueryStep,
+  queryNot,
+  liveQueryNot,
+  filterAndMap,
+  liveFilterAndMap,
+  queryAndMap,
+  liveQueryAndMap,
+  queryEntity,
+  liveQueryEntity,
+  liveEntityAt,
+  agentsOfThread,
+  entityOverlap,
+  entityOverlapMap,
+  entityOverlapCount2 as entityOverlapCount,
+  liveEntityOverlapCount,
+  querySingle,
+  querySingleAndMap,
+  liveQuerySingle,
+  liveQuerySingleAndMap,
+  makeApplogMapper,
+  mapApplogsWith,
+  mapThreadWith,
+  mapQueryResultWith,
+  createObjMapper,
+  startsWith,
+  prefixAttrs,
+  prefixAt,
+  stripAtPrefix,
+  mapAttributes,
+  resolveKeyMapper,
+  threadFromMaybeArray,
+  withTimeout,
+  throwOnTimeout
+};
+//# sourceMappingURL=chunk-QZXKQCAY.js.map