@wovin/core 0.0.1-RC6 → 0.0.1-RC7

package/dist/chunk-LR7LTEQ6.cjs

@@ -0,0 +1,577 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkMS4K4RCZcjs = require('./chunk-MS4K4RCZ.cjs');
+
+
+var _chunkMLDNHGG3cjs = require('./chunk-MLDNHGG3.cjs');
+
+// src/stream/writeable.ts
+var _src = require('besonders-logger/src');
+var _mobx = require('mobx');
+
+// src/data/applog-helpers.ts
+
+
+
+// src/queries/basic.ts
+
+
+var _safestablestringify = require('safe-stable-stringify'); var _safestablestringify2 = _interopRequireDefault(_safestablestringify);
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = _src.Logger.setup(_src.Logger.INFO, { prefix: "[q]" });
+var QueryNode = class {
+  constructor(logsOfThisNode, variables, prev = null) {
+    this.logsOfThisNode = logsOfThisNode;
+    this.variables = variables;
+    this.prev = prev;
+    _mobx.makeObservable.call(void 0, this, {
+      allApplogs: _mobx.computed
+      // ? intuitively only put the ones here that felt expensive to compute (join)
+    });
+  }
+  get record() {
+    return this.variables;
+  }
+  get allApplogs() {
+    if (!this.prev)
+      return this.logsOfThisNode;
+    return joinStreams([
+      this.logsOfThisNode,
+      this.prev.allApplogs
+    ]);
+  }
+};
+var QueryNodes = class {
+  constructor(nodes) {
+    this.nodes = nodes;
+    _mobx.makeObservable.call(void 0, this, {
+      allApplogs: _mobx.computed,
+      // ? intuitively only put the ones here that felt expensive to compute (join)
+      size: _mobx.computed,
+      // ... or cheap to cache
+      isEmpty: _mobx.computed
+    });
+  }
+  get size() {
+    return this.records.length;
+  }
+  get isEmpty() {
+    return this.records.length === 0;
+  }
+  get untrackedSize() {
+    return _mobx.untracked.call(void 0, () => this.records.length);
+  }
+  get records() {
+    return this.nodes.map(({ variables }) => variables);
+  }
+  get applogSets() {
+    return this.nodes.map(({ logsOfThisNode: stream }) => stream.applogs);
+  }
+  get applogStreams() {
+    return this.nodes.map(({ logsOfThisNode: stream }) => stream);
+  }
+  get allApplogs() {
+    return joinStreams(this.nodes.map((node) => node.allApplogs));
+  }
+};
+var withoutHistory = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function withoutHistory2(stream, { inverseToOnlyReturnFirstLogs, tolerateAlreadyFiltered } = {}) {
+  VERBOSE(`withoutHistory${inverseToOnlyReturnFirstLogs ? ".inversed" : ""} < ${stream.nameAndSizeUntracked} > initializing`);
+  if (stream.filters.includes("withoutHistory")) {
+    if (tolerateAlreadyFiltered) {
+      DEBUG(`[withoutHistory] already filtered, but tolerateAlreadyFiltered=true, so returning`);
+      return stream;
+    }
+    throw ERROR(`stream already filtered withoutHistory:`, stream.filters, { name: stream.name });
+  }
+  let rollingMap;
+  const mappedStream = _chunkMS4K4RCZcjs.rollingMapper.call(void 0, stream, function(event, sourceStream) {
+    const isInitial = _chunkMS4K4RCZcjs.isInitEvent.call(void 0, event);
+    let newLogs;
+    const toAdd = [];
+    const toRemove = isInitial ? null : [];
+    if (isInitial) {
+      rollingMap = /* @__PURE__ */ new Map();
+      newLogs = event.init;
+    } else {
+      newLogs = event.added;
+    }
+    let tsCheck;
+    for (let i = inverseToOnlyReturnFirstLogs ? 0 : newLogs.length - 1; inverseToOnlyReturnFirstLogs ? i < newLogs.length : i >= 0; inverseToOnlyReturnFirstLogs ? i++ : i--) {
+      const log = newLogs[i];
+      const key = _safestablestringify2.default.call(void 0, [log.en, log.at]);
+      if (tsCheck && (inverseToOnlyReturnFirstLogs ? tsCheck > log.ts : tsCheck < log.ts)) {
+        throw ERROR(`withoutHistory.mapper logs not sorted:`, tsCheck, inverseToOnlyReturnFirstLogs ? ">" : "<", log.ts, {
+          log,
+          i,
+          newLogs,
+          inverseToOnlyReturnFirstLogs
+        });
+      }
+      tsCheck = log.ts;
+      const existing = rollingMap.get(key);
+      if (!existing || (inverseToOnlyReturnFirstLogs ? existing.ts > log.ts : existing.ts < log.ts)) {
+        if (existing && !isInitial)
+          toRemove.push(existing);
+        toAdd.push(log);
+        rollingMap.set(key, log);
+      }
+    }
+    _chunkMS4K4RCZcjs.sortApplogsByTs.call(void 0, toAdd);
+    VERBOSE.isDisabled || VERBOSE(
+      `withoutHistory${inverseToOnlyReturnFirstLogs ? ".inversed" : ""}<${stream.nameAndSizeUntracked}> mapped event`,
+      isInitial ? { ...Object.fromEntries(Object.entries(event).map(([k, v]) => [k, _optionalChain([v, 'optionalAccess', _ => _.length])])), toAdd: toAdd.length, toRemove } : { ...event, toAdd, toRemove }
+    );
+    return isInitial ? { init: toAdd } : { added: toAdd, removed: toRemove };
+  }, { name: `withoutHistory${inverseToOnlyReturnFirstLogs ? ".inversed" : ""}`, extraFilterName: "withoutHistory" });
+  VERBOSE.isDisabled || _mobx.autorun.call(void 0, () => {
+    VERBOSE(`withoutHistory<${stream.nameAndSizeUntracked}> filtered down to`, mappedStream.applogs.length);
+  });
+  return mappedStream;
+}, { equals: _chunkMS4K4RCZcjs.applogStreamComparer });
+var withoutDeleted = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function withoutDeleted2(stream) {
+  VERBOSE(`withoutDeleted<${stream.nameAndSizeUntracked}>`);
+  if (stream.filters.includes("withoutDeleted")) {
+    throw ERROR(`stream already filtered withoutDeleted:`, stream.filters, { name: stream.name });
+  }
+  const deletionLogs = _chunkMS4K4RCZcjs.rollingFilter.call(void 0, stream, { at: ["isDeleted", "relation/isDeleted", "block/isDeleted"], vl: true }, {
+    name: "isDeleted"
+  });
+  VERBOSE(`withoutDeleted<${stream.nameAndSizeUntracked}> deletionLogs:`, _mobx.untracked.call(void 0, () => [...deletionLogs.applogs]));
+  const obsArrMapName = _chunkMS4K4RCZcjs.createDebugName.call(void 0, { caller: "allDeletedEntities", stream });
+  const deleted = _chunkMS4K4RCZcjs.observableArrayMap.call(void 0, () => deletionLogs.map((log) => log.en), { name: obsArrMapName });
+  VERBOSE.isDisabled || _mobx.autorun.call(void 0, () => {
+    VERBOSE(`withoutDeleted<${stream.nameAndSizeUntracked}> deleted:`, [...deleted]);
+  });
+  return _chunkMS4K4RCZcjs.rollingFilter.call(void 0, stream, { "!en": deleted }, { name: `withoutDeleted`, extraFilterName: "withoutDeleted" });
+}, { equals: _chunkMS4K4RCZcjs.applogStreamComparer });
+var query = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function query2(stream, patternOrPatterns, startVariables = {}, opts = {}) {
+  DEBUG(`query<${stream.nameAndSizeUntracked}>:`, patternOrPatterns);
+  const patterns = Array.isArray(patternOrPatterns) ? patternOrPatterns : [patternOrPatterns];
+  let nodes;
+  if (patterns.length === 1) {
+    nodes = null;
+  } else {
+    const pattersExceptLast = patterns.slice(0, -1);
+    nodes = query2(stream, pattersExceptLast, startVariables, opts);
+  }
+  const lastPattern = patterns[patterns.length - 1];
+  const stepResult = queryStep(stream, nodes, lastPattern, opts);
+  VERBOSE.isDisabled || _mobx.autorun.call(void 0, () => VERBOSE(`query result:`, _mobx.toJS.call(void 0, stepResult)));
+  return stepResult;
+}, { equals: _chunkMS4K4RCZcjs.queryNodesComparer });
+var queryStep = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function queryStep2(stream, nodeSet, pattern, opts = {}) {
+  DEBUG(`queryStep<${stream.nameAndSizeUntracked}> with`, _nullishCoalesce(_optionalChain([nodeSet, 'optionalAccess', _2 => _2.untrackedSize]), () => ( "all")), "nodes, pattern:", pattern);
+  if (!Object.entries(pattern).length)
+    throw new Error(`Pattern is empty`);
+  const observableResultNodes = _chunkMS4K4RCZcjs.observableArrayMap.call(void 0, 
+    () => {
+      function doQuery(node) {
+        const [patternWithResolvedVars, variablesToFill] = _chunkMS4K4RCZcjs.resolveOrRemoveVariables.call(void 0, pattern, _nullishCoalesce(_optionalChain([node, 'optionalAccess', _3 => _3.variables]), () => ( {})));
+        VERBOSE(`[queryStep] patternWithoutVars: `, patternWithResolvedVars);
+        const applogsMatchingStatic = _chunkMS4K4RCZcjs.rollingFilter.call(void 0, stream, patternWithResolvedVars);
+        const varMapper = mapTo(variablesToFill);
+        const newVarsAndTheirLog = applogsMatchingStatic.map((log) => ({ log, vars: varMapper(log) }));
+        VERBOSE.isDisabled || VERBOSE(
+          `[queryStep] step node:`,
+          _optionalChain([node, 'optionalAccess', _4 => _4.variables]),
+          " =>",
+          newVarsAndTheirLog,
+          "from:",
+          _mobx.untracked.call(void 0, () => applogsMatchingStatic.applogs)
+        );
+        const resultNodes = newVarsAndTheirLog.map(({ log, vars }) => {
+          const nodeVars = Object.assign({}, _optionalChain([node, 'optionalAccess', _5 => _5.variables]), vars);
+          return new QueryNode(
+            new ApplogStreamInMemory(
+              [log],
+              stream.filters,
+              _chunkMS4K4RCZcjs.createDebugName.call(void 0, {
+                caller: "QueryNode",
+                stream: applogsMatchingStatic,
+                pattern: `${_safestablestringify2.default.call(void 0, nodeVars)}@${_safestablestringify2.default.call(void 0, patternWithResolvedVars)}`
+              }),
+              true,
+              applogsMatchingStatic
+            ),
+            nodeVars,
+            node
+          );
+        });
+        if (opts.debug) {
+          LOG(
+            `[queryStep] step result:`,
+            _mobx.untracked.call(void 0, 
+              () => resultNodes.map(({ variables, logsOfThisNode: stream2 }) => ({
+                variables,
+                stream: (
+                  /* util.inspect( */
+                  stream2.applogs
+                )
+                /* , { showHidden: false, depth: null }) */
+              }))
+            )
+          );
+        }
+        return resultNodes;
+      }
+      if (nodeSet) {
+        return nodeSet.nodes.flatMap(doQuery);
+      } else {
+        return doQuery(null);
+      }
+    },
+    { name: _chunkMS4K4RCZcjs.createDebugName.call(void 0, { caller: "queryStep", stream, pattern }) }
+  );
+  VERBOSE(`queryStep result:`, observableResultNodes);
+  return new QueryNodes(observableResultNodes);
+}, { equals: _chunkMS4K4RCZcjs.queryNodesComparer });
+var queryNot = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function queryNot2(stream, startNodes, patternOrPatterns, opts = {}) {
+  let nodes = startNodes.nodes;
+  DEBUG(`queryNot<${stream.nameAndSizeUntracked}> from: ${nodes.length} nodes`);
+  const patterns = Array.isArray(patternOrPatterns) ? patternOrPatterns : [patternOrPatterns];
+  for (const pattern of patterns) {
+    if (!Object.entries(patternOrPatterns).length)
+      throw new Error(`Pattern is empty`);
+    nodes = nodes.filter(({
+      /* applogs, */
+      variables
+    }) => {
+      const [patternWithResolvedVars, _variablesToFill] = _chunkMS4K4RCZcjs.resolveOrRemoveVariables.call(void 0, pattern, _nullishCoalesce(variables, () => ( {})));
+      VERBOSE(`[queryNot] patternWithoutVars: `, patternWithResolvedVars);
+      const newApplogs = _chunkMS4K4RCZcjs.rollingFilter.call(void 0, stream, patternWithResolvedVars);
+      VERBOSE(`[queryNot] step node:`, variables, " =>", newApplogs.size, "applogs");
+      VERBOSE.isDisabled || VERBOSE(`[queryNot] step node:`, variables, " => empty?", _mobx.untracked.call(void 0, () => newApplogs.applogs));
+      if (opts.debug)
+        LOG(`[queryNot] node result:`, variables, "=>", newApplogs.applogs);
+      return newApplogs.isEmpty;
+    });
+  }
+  return new QueryNodes(nodes);
+}, { equals: _chunkMS4K4RCZcjs.queryNodesComparer });
+var filterAndMap = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function filterAndMap2(stream, pattern, mapper) {
+  DEBUG(`filterAndMap<${stream.nameAndSizeUntracked}>`, pattern);
+  const filtered = _chunkMS4K4RCZcjs.rollingFilter.call(void 0, stream, pattern);
+  VERBOSE(`[filterAndMap] filtered:`, filtered.untrackedSize);
+  VERBOSE.isDisabled || _mobx.autorun.call(void 0, () => VERBOSE(`[filterAndMap] filtered:`, filtered.applogs));
+  const mapperFX = function filterAndMapGetterFx() {
+    if (typeof mapper === "function") {
+      return filtered.map(mapper);
+    } else if (typeof mapper === "string") {
+      return filtered.map((log) => log[mapper]);
+    } else {
+      return filtered.map(mapTo(mapper));
+    }
+  };
+  const name = _chunkMS4K4RCZcjs.createDebugName.call(void 0, { stream, pattern, caller: "filterAndMap" });
+  const mapped = _chunkMS4K4RCZcjs.observableArrayMap.call(void 0, mapperFX, { name });
+  VERBOSE.isDisabled || _mobx.autorun.call(void 0, () => VERBOSE(`[filterAndMap] mapped:`, mapped));
+  return mapped;
+}, { equals: _mobx.comparer.structural });
+var queryAndMap = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function queryAndMap2(stream, patternOrPatterns, map, variables = {}) {
+  DEBUG(`queryAndMap<${stream.nameAndSizeUntracked}>`, { patternOrPatterns, variables, map });
+  const debugName = _chunkMS4K4RCZcjs.createDebugName.call(void 0, { stream, caller: "queryAndMap" });
+  const filtered = query(stream, patternOrPatterns);
+  VERBOSE(`[queryAndMap] filtered count:`, filtered.untrackedSize);
+  const mapped = _chunkMS4K4RCZcjs.observableArrayMap.call(void 0, 
+    () => {
+      if (typeof map === "function") {
+        return filtered.records.map(map);
+      } else if (typeof map === "string") {
+        return filtered.records.map((log) => log[map]);
+      } else {
+        throw new Error("what's this map param about?");
+      }
+    },
+    { name: debugName }
+  );
+  VERBOSE.isDisabled || _mobx.autorun.call(void 0, () => VERBOSE(`[queryAndMap] result:`, _mobx.toJS.call(void 0, mapped)));
+  return mapped;
+}, { equals: _mobx.comparer.structural });
+var queryEntity = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function queryEntity2(stream, name, entityID, attributes) {
+  DEBUG(`queryEntity<${stream.nameAndSizeUntracked}>`, entityID, name);
+  const filtered = _chunkMS4K4RCZcjs.rollingFilter.call(void 0, stream, { en: entityID, at: prefixAttrs(name, attributes) });
+  VERBOSE(`queryEntity applogs:`, filtered.applogs);
+  return _mobx.computed.call(void 0, 
+    () => filtered.isEmpty ? null : Object.fromEntries(
+      filtered.map(({ at, vl }) => [at.slice(name.length + 1), vl])
+    )
+  );
+}, { equals: _chunkMS4K4RCZcjs.computedStructuralComparer });
+var agentsOfStream = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function agentsOfStream2(stream) {
+  LOG(`agentsOfStream<${stream.nameAndSizeUntracked}>`);
+  const mapped = _mobx.observable.map();
+  function onEvent(event) {
+    for (const log of _chunkMS4K4RCZcjs.isInitEvent.call(void 0, event) ? event.init : event.added) {
+      const prev = _nullishCoalesce(mapped.get(log.ag), () => ( 0));
+      mapped.set(log.ag, prev + 1);
+    }
+    for (const log of !_chunkMS4K4RCZcjs.isInitEvent.call(void 0, event) && event.removed || []) {
+      const prev = mapped.get(log.ag);
+      if (!prev || prev < 1)
+        throw ERROR(`[agentsOfStream] number is now negative`, { log, event, mapped, prev });
+      mapped.set(log.ag, prev - 1);
+    }
+    LOG(`agentsOfStream<${stream.nameAndSizeUntracked}> processed event`, { event, mapped });
+  }
+  _mobx.untracked.call(void 0, () => onEvent({ init: stream.applogs }));
+  stream.subscribe(onEvent);
+  _mobx.onBecomeObserved.call(void 0, mapped, () => stream.unsubscribe(onEvent));
+  return mapped;
+});
+var entityOverlap = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function entityOverlapCount(streamA, streamB) {
+  LOG(`entityOverlap<${streamA.nameAndSizeUntracked}, ${streamB.nameAndSizeUntracked}>`);
+  return _mobx.computed.call(void 0, () => {
+    const entitiesA = new Set(streamA.map((log) => log.en));
+    const entitiesB = new Set(streamB.map((log) => log.en));
+    return [...entitiesA].filter((en) => entitiesB.has(en));
+  });
+});
+var entityOverlapCount2 = _chunkMS4K4RCZcjs.computedFnDeepCompare.call(void 0, function entityOverlapCount3(streamA, streamB) {
+  return _mobx.computed.call(void 0, () => entityOverlap(streamA, streamB).get().length);
+});
+function mapTo(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}`;
+}
+
+// src/data/applog-helpers.ts
+var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = _src.Logger.setup(_src.Logger.INFO);
+var sortApplogByTs = (p, n) => p.ts < n.ts ? -1 : p.ts > n.ts ? 1 : 0;
+var sortApplogByTsDec = (p, n) => p.ts < n.ts ? 1 : p.ts > n.ts ? -1 : 0;
+function filterOnlyLatest(logs, onlyLatest) {
+  if (!onlyLatest || !_optionalChain([logs, 'optionalAccess', _6 => _6.length])) {
+    return logs;
+  }
+  logs = [...logs].sort((a, b) => a.ts < b.ts ? -1 : a.ts == b.ts ? 0 : 1);
+  const mapped = /* @__PURE__ */ new Map();
+  for (const log of logs) {
+    if (!log) {
+      continue;
+    }
+    mapped.set(JSON.stringify([log.en, log.at]), log);
+  }
+  return [...mapped.values()];
+}
+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 withPv(log, ds) {
+  const { en, at } = log;
+  const pvs = filterAndMap(withoutHistory(ds), { en, at }, "cid");
+  if (pvs.length > 1)
+    WARN2(`[withPv] unexpected result count:`, pvs.length);
+  let pv = pvs.length ? pvs[0] : null;
+  const isMatchingPv = !!(pv === log.pv);
+  if (log.pv && !isMatchingPv)
+    WARN2(`[withPv] different than pre-set pv:`, { queriedPv: pv, logPv: log.pv });
+  pv = _nullishCoalesce(log.pv, () => ( pv));
+  return { ...log, pv: _nullishCoalesce(pv, () => ( null)) };
+}
+function joinStreams(streams) {
+  if (streams.length === 0)
+    throw ERROR2(`joinStreams called with empty array`);
+  if (streams.length === 1)
+    return streams[0];
+  const fullJoin = () => _chunkMS4K4RCZcjs.sortApplogsByTs.call(void 0, 
+    _chunkMS4K4RCZcjs.removeDuplicateAppLogs.call(void 0, streams.flatMap((s) => {
+      const logs = s.applogs;
+      if (!logs) {
+        ERROR2(`falsy applogs of stream`, s);
+        throw new Error(`falsy applogs of stream`);
+      }
+      return logs;
+    }))
+  );
+  const initialMergeResult = _mobx.untracked.call(void 0, () => fullJoin());
+  const eventMapper = _mobx.action.call(void 0, function(event, sourceStream) {
+    if (_chunkMS4K4RCZcjs.isInitEvent.call(void 0, event)) {
+      return { init: _mobx.untracked.call(void 0, () => fullJoin()) };
+    } else {
+      return {
+        // TODO: test this stuff
+        added: event.added.filter((addedLog) => !this.hasApplog(addedLog, true)),
+        removed: event.added.filter(
+          (addedLog) => !this.parents.some((parent) => {
+            if (parent === sourceStream)
+              return false;
+            return parent.hasApplog(addedLog, true);
+          })
+        )
+      };
+    }
+  });
+  return new (0, _chunkMS4K4RCZcjs.MappedApplogStream)(streams, ["?"], initialMergeResult, eventMapper, `join(${streams.map((s) => s.name).join(", ")})`);
+}
+
+// src/data/datom-types.ts
+var _typebox = require('@sinclair/typebox');
+var _compiler = require('@sinclair/typebox/compiler');
+var Nullable = (schema) => _typebox.Type.Union([schema, _typebox.Type.Null()]);
+var EntityID_LENGTH = 7;
+var isCID = /^(k51qz|baguq)[0-9a-z]{56,57}$/;
+var isShortHash = /^[0-9A-Fa-f]{7,8}$/g;
+_typebox.FormatRegistry.Set("EntityID", (value) => !!value.match(isShortHash) || !!value.match(isCID));
+var EntityID = _typebox.Type.String({ format: "EntityID" });
+_typebox.FormatRegistry.Set("CID", (value) => !!value.match(isCID));
+var CIDTB = _typebox.Type.String({ format: "EntityID" });
+var isURL = /^http([s]?):\/\/.*\..*/;
+_typebox.FormatRegistry.Set("URL", (value) => !!value.match(isURL));
+var URL = _typebox.Type.String({ format: "URL" });
+var AppLogTB = _typebox.Type.Object({
+  en: EntityID,
+  // EntityID
+  at: _typebox.Type.String(),
+  // Attribute
+  vl: Nullable(_typebox.Type.Union([_typebox.Type.String(), _typebox.Type.Boolean(), _typebox.Type.Number()])),
+  // TODO refactor to semantic typesafe ApplogValue
+  ts: _typebox.Type.String(),
+  // Timestamp
+  ag: _typebox.Type.String()
+  // AgentHash
+});
+var AppLogTBC = _compiler.TypeCompiler.Compile(AppLogTB);
+var getApplogTypeErrors = (obj) => Array.from(AppLogTBC.Errors(obj));
+var isValidApplog = AppLogTBC.Check.bind(AppLogTBC);
+
+// src/stream/writeable.ts
+var { WARN: WARN3, LOG: LOG3, DEBUG: DEBUG3, VERBOSE: VERBOSE3, ERROR: ERROR3 } = _src.Logger.setup(_src.Logger.INFO);
+var WriteableApplogStream = class extends _chunkMS4K4RCZcjs.ApplogStream {
+  constructor(parents, filters, applogs = [], name) {
+    super(parents, filters, applogs, name);
+    _mobx.makeObservable.call(void 0, this, {
+      insert: _mobx.action
+      // ? is there an advantage to do this here instead of wrapping the fx in action below?
+    });
+  }
+  insert(appLogsToInsert) {
+    const ts = _chunkMS4K4RCZcjs.dateNowIso.call(void 0, );
+    const mapped = appLogsToInsert.map((log) => {
+      const logWithTs = withTs(log, ts);
+      if (!isValidApplog(logWithTs)) {
+        throw ERROR3(`Bogus Applog ${JSON.stringify(logWithTs)}`, getApplogTypeErrors(logWithTs));
+      }
+      const logWithPv = withPv(logWithTs, this);
+      const cid = _chunkMLDNHGG3cjs.encodeApplogAndGetCid.call(void 0, logWithPv).toString();
+      const logWithCid = { ...logWithPv, cid };
+      return Object.freeze(logWithCid);
+    });
+    const mappedLogs = _chunkMS4K4RCZcjs.removeDuplicateAppLogs.call(void 0, mapped);
+    if (appLogsToInsert.length !== mappedLogs.length) {
+      WARN3("request to insert duplicate log, inserting mappedLogs:", { appLogsToInsert, mappedLogs });
+    } else if (!appLogsToInsert.length) {
+      WARN3("request to insert empty logs array");
+    } else {
+      LOG3("Inserting:", mappedLogs.length === 1 ? mappedLogs[0] : mappedLogs, { ds: this });
+    }
+    if (!mappedLogs.length)
+      return [];
+    _chunkMS4K4RCZcjs.sortApplogsByTs.call(void 0, mappedLogs);
+    const sortNeeded = this._applogs.length && _chunkMS4K4RCZcjs.isTsBefore.call(void 0, mappedLogs[0], this._applogs[this._applogs.length - 1]);
+    this._applogs.push(...mappedLogs);
+    if (sortNeeded) {
+      _chunkMS4K4RCZcjs.sortApplogsByTs.call(void 0, this._applogs);
+    }
+    this.notifySubscribers({ added: mappedLogs, removed: null });
+    void this.persist(mappedLogs);
+    return mappedLogs;
+  }
+  get readOnly() {
+    return false;
+  }
+};
+var ApplogStreamInMemory = class extends WriteableApplogStream {
+  constructor(applogs, filters, name, _readOnly, parents = null) {
+    super(parents, filters, applogs, name);
+    this._readOnly = _readOnly;
+    _mobx.makeObservable.call(void 0, this, {
+      // @ts-expect-error bc it's private
+      _applogs: _mobx.observable.shallow
+    });
+  }
+  get readOnly() {
+    return this._readOnly;
+  }
+  persist(logs) {
+    VERBOSE3(`[InMem.persist] no persist for`, logs);
+    if (this.readOnly) {
+      throw ERROR3(`[persist] called for readOnly stream`);
+    }
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Nullable = Nullable; exports.EntityID_LENGTH = EntityID_LENGTH; exports.EntityID = EntityID; exports.CIDTB = CIDTB; exports.URL = URL; exports.AppLogTB = AppLogTB; exports.AppLogTBC = AppLogTBC; exports.getApplogTypeErrors = getApplogTypeErrors; exports.isValidApplog = isValidApplog; exports.WriteableApplogStream = WriteableApplogStream; exports.ApplogStreamInMemory = ApplogStreamInMemory; exports.QueryNode = QueryNode; exports.QueryNodes = QueryNodes; exports.withoutHistory = withoutHistory; exports.withoutDeleted = withoutDeleted; exports.query = query; exports.queryStep = queryStep; exports.queryNot = queryNot; exports.filterAndMap = filterAndMap; exports.queryAndMap = queryAndMap; exports.queryEntity = queryEntity; exports.agentsOfStream = agentsOfStream; exports.entityOverlap = entityOverlap; exports.entityOverlapCount = entityOverlapCount2; exports.mapTo = mapTo; exports.startsWith = startsWith; exports.prefixAttrs = prefixAttrs; exports.prefixAt = prefixAt; exports.sortApplogByTs = sortApplogByTs; exports.sortApplogByTsDec = sortApplogByTsDec; exports.filterOnlyLatest = filterOnlyLatest; exports.hasAg = hasAg; exports.hasTs = hasTs; exports.hasPv = hasPv; exports.withTs = withTs; exports.withPv = withPv; exports.joinStreams = joinStreams;
+//# sourceMappingURL=chunk-LR7LTEQ6.cjs.map