@milaboratories/pl-tree 1.3.6 → 1.3.8

package/dist/index.mjs

@@ -0,0 +1,737 @@
+var P = Object.defineProperty;
+var N = (a, e, t) => e in a ? P(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var u = (a, e, t) => N(a, typeof e != "symbol" ? e + "" : e, t);
+import { resourceIdToString as m, resourceTypeToString as F, resourceTypesEqual as S, isNotNullResourceId as g, NullResourceId as R, isNullResourceId as A, stringifyWithResourceId as L, isTimeoutOrCancelError as W } from "@milaboratories/pl-client";
+import { ChangeSource as y, PollingComputableHooks as U } from "@milaboratories/computable";
+import { notEmpty as p } from "@milaboratories/ts-helpers";
+import K from "denque";
+import * as J from "node:timers/promises";
+function X(a, e) {
+  if (a !== void 0)
+    return x(a, e);
+}
+function x(a, e) {
+  const t = {};
+  return a.value !== void 0 && (t.value = e(a.value)), a.error !== void 0 && (t.error = e(a.error)), t;
+}
+class O extends Error {
+  constructor(e) {
+    super(e);
+  }
+}
+function Z(a) {
+  return typeof a == "object" && a !== null && a.__pl_tree_type_marker__ === "PlTreeEntry";
+}
+function ee(a) {
+  return typeof a == "object" && a !== null && a.__pl_tree_type_marker__ === "PlTreeEntryAccessor";
+}
+function te(a) {
+  return typeof a == "object" && a !== null && a.__pl_tree_type_marker__ === "PlTreeNodeAccessor";
+}
+class k {
+  constructor(e, t) {
+    u(this, "__pl_tree_type_marker__", "PlTreeEntry");
+    this.accessorData = e, this.rid = t;
+  }
+  createAccessor(e, t) {
+    return new E(this.accessorData, this.accessorData.treeProvider(), this.rid, {
+      ctx: e,
+      guard: t
+    });
+  }
+  toJSON() {
+    return this.toString();
+  }
+  toString() {
+    return `[ENTRY:${m(this.rid)}]`;
+  }
+}
+function $(a, e, t, r, s) {
+  const c = new M(
+    a,
+    e,
+    e.get(t.ctx.watcher, r),
+    t
+  );
+  if (!s.ignoreError) {
+    const n = c.getError();
+    if (n !== void 0)
+      throw new O(
+        `error encountered on resource ${m(c.id)} (${F(c.resourceType)}): ${n.getDataAsString()}`
+      );
+  }
+  if (s.assertResourceType !== void 0 && (Array.isArray(s.assertResourceType) ? s.assertResourceType.findIndex((n) => S(n, c.resourceType)) === -1 : !S(s.assertResourceType, c.resourceType)))
+    throw new Error(
+      `wrong resource type ${F(c.resourceType)} but expected ${s.assertResourceType}`
+    );
+  return c;
+}
+class E {
+  constructor(e, t, r, s) {
+    u(this, "__pl_tree_type_marker__", "PlTreeEntryAccessor");
+    this.accessorData = e, this.tree = t, this.rid = r, this.instanceData = s;
+  }
+  node(e = {}) {
+    return this.instanceData.guard(), this.accessorData.hooks !== void 0 && this.instanceData.ctx.attacheHooks(this.accessorData.hooks), $(this.accessorData, this.tree, this.instanceData, this.rid, e);
+  }
+}
+function re(a, e) {
+  return a instanceof k ? e.accessor(a).node().resourceInfo : a;
+}
+class M {
+  constructor(e, t, r, s) {
+    u(this, "__pl_tree_type_marker__", "PlTreeNodeAccessor");
+    u(this, "onUnstableLambda", (e) => {
+      this.instanceData.ctx.markUnstable(e);
+    });
+    this.accessorData = e, this.tree = t, this.resource = r, this.instanceData = s;
+  }
+  get id() {
+    return this.instanceData.guard(), this.resource.id;
+  }
+  get originalId() {
+    return this.instanceData.guard(), this.resource.originalResourceId;
+  }
+  get resourceType() {
+    return this.instanceData.guard(), this.resource.type;
+  }
+  get resourceInfo() {
+    return { id: this.id, type: this.resourceType };
+  }
+  getResourceFromTree(e, t) {
+    return $(this.accessorData, this.tree, this.instanceData, e, t);
+  }
+  traverse(...e) {
+    return this.traverseWithCommon({}, ...e);
+  }
+  traverseOrError(...e) {
+    return this.traverseOrErrorWithCommon({}, ...e);
+  }
+  traverseWithCommon(e, ...t) {
+    const r = this.traverseOrErrorWithCommon(e, ...t);
+    if (r !== void 0) {
+      if (!r.ok) throw new O(r.error);
+      return r.value;
+    }
+  }
+  traverseOrErrorWithCommon(e, ...t) {
+    let r = this;
+    for (const s of t) {
+      const c = typeof s == "string" ? {
+        ...e,
+        field: s
+      } : { ...e, ...s }, n = r.getField(s);
+      if (n === void 0 || c.pureFieldErrorToUndefined && n.value === void 0 && n.error !== void 0)
+        return;
+      if ((!c.ignoreError || n.value === void 0) && n.error !== void 0)
+        return {
+          ok: !1,
+          error: `error in field ${c.field} of ${m(r.id)}: ${n.error.getDataAsString()}`
+        };
+      if (n.value === void 0) {
+        if (c.errorIfFieldNotSet)
+          return {
+            ok: !1,
+            error: `field have no assigned value ${c.field} of ${m(r.id)}`
+          };
+        this.onUnstableLambda("unpopulated_field:" + c.field);
+        return;
+      }
+      r = n.value;
+    }
+    return { ok: !0, value: r };
+  }
+  getField(e) {
+    this.instanceData.guard();
+    const t = typeof e == "string" ? { field: e } : e, r = this.resource.getField(this.instanceData.ctx.watcher, t, this.onUnstableLambda);
+    if (r !== void 0)
+      return x(r, (s) => this.getResourceFromTree(s, { ignoreError: !0 }));
+  }
+  getInputsLocked() {
+    this.instanceData.guard();
+    const e = this.resource.getInputsLocked(this.instanceData.ctx.watcher);
+    return e || this.instanceData.ctx.markUnstable("inputs_unlocked:" + this.resourceType.name), e;
+  }
+  getOutputsLocked() {
+    this.instanceData.guard();
+    const e = this.resource.getOutputsLocked(this.instanceData.ctx.watcher);
+    return e || this.instanceData.ctx.markUnstable("outputs_unlocked:" + this.resourceType.name), e;
+  }
+  getIsReadyOrError() {
+    this.instanceData.guard();
+    const e = this.resource.getIsReadyOrError(this.instanceData.ctx.watcher);
+    return e || this.instanceData.ctx.markUnstable("not_ready:" + this.resourceType.name), e;
+  }
+  getIsFinal() {
+    return this.instanceData.guard(), this.resource.getIsFinal(this.instanceData.ctx.watcher);
+  }
+  getError() {
+    this.instanceData.guard();
+    const e = this.resource.getError(this.instanceData.ctx.watcher);
+    if (e !== void 0)
+      return this.getResourceFromTree(e, {});
+  }
+  getData() {
+    return this.resource.data;
+  }
+  getDataAsString() {
+    return this.resource.getDataAsString();
+  }
+  getDataAsJson() {
+    return this.resource.getDataAsJson();
+  }
+  listInputFields() {
+    return this.instanceData.guard(), this.getInputsLocked(), this.resource.listInputFields(this.instanceData.ctx.watcher);
+  }
+  listOutputFields() {
+    return this.instanceData.guard(), this.getOutputsLocked(), this.resource.listOutputFields(this.instanceData.ctx.watcher);
+  }
+  listDynamicFields() {
+    return this.instanceData.guard(), this.resource.listDynamicFields(this.instanceData.ctx.watcher);
+  }
+  getKeyValue(e, t = !1) {
+    this.instanceData.guard();
+    const r = this.resource.getKeyValue(this.instanceData.ctx.watcher, e);
+    return r === void 0 && t && this.instanceData.ctx.markUnstable("key_not_found_b:" + e), r;
+  }
+  /** @deprecated */
+  getKeyValueString(e) {
+    return this.getKeyValueAsString(e);
+  }
+  getKeyValueAsString(e, t = !1) {
+    this.instanceData.guard();
+    const r = this.resource.getKeyValueString(this.instanceData.ctx.watcher, e);
+    return r === void 0 && t && this.instanceData.ctx.markUnstable("key_not_found_s:" + e), r;
+  }
+  getKeyValueAsJson(e, t = !1) {
+    const r = this.resource.getKeyValueString(this.instanceData.ctx.watcher, e);
+    if (r === void 0) {
+      t && this.instanceData.ctx.markUnstable("key_not_found_j:" + e);
+      return;
+    }
+    return JSON.parse(r);
+  }
+  /**
+   * Can be used to passe a higher level accessor that will wrap the resource and throw its
+   * errors on node resolution.
+   * */
+  toEntryAccessor() {
+    return new E(this.accessorData, this.tree, this.id, this.instanceData);
+  }
+  /** Can be passed to nested computable. */
+  persist() {
+    return new k(this.accessorData, this.resource.id);
+  }
+}
+class w extends Error {
+  constructor(e) {
+    super(e);
+  }
+}
+class T {
+  constructor(e, t, r, s) {
+    u(this, "change", new y());
+    this.type = e, this.value = t, this.error = r, this.resourceVersion = s;
+  }
+}
+const D = 0, _ = new TextDecoder();
+class z {
+  constructor(e, t) {
+    /** Tracks number of other resources referencing this resource. Used to perform garbage collection in tree patching procedure */
+    u(this, "refCount", 0);
+    /** Increments each time resource is checked for difference with new state */
+    u(this, "version", D);
+    /** Set to resource version when resource state, or it's fields have changed */
+    u(this, "dataVersion", D);
+    u(this, "fields", /* @__PURE__ */ new Map());
+    u(this, "kv", /* @__PURE__ */ new Map());
+    u(this, "resourceRemoved", new y());
+    // following change source are removed when resource is marked as final
+    u(this, "finalChanged", new y());
+    u(this, "resourceStateChange", new y());
+    u(this, "lockedChange", new y());
+    u(this, "inputAndServiceFieldListChanged", new y());
+    u(this, "outputFieldListChanged", new y());
+    u(this, "dynamicFieldListChanged", new y());
+    u(this, "kvChanged", new y());
+    u(this, "id");
+    u(this, "originalResourceId");
+    u(this, "kind");
+    u(this, "type");
+    u(this, "data");
+    u(this, "dataAsString");
+    u(this, "dataAsJson");
+    u(this, "error");
+    u(this, "inputsLocked");
+    u(this, "outputsLocked");
+    u(this, "resourceReady");
+    u(this, "finalFlag");
+    /** Set externally by the tree, using {@link FinalPredicate} */
+    u(this, "_final", !1);
+    u(this, "logger");
+    this.id = e.id, this.originalResourceId = e.originalResourceId, this.kind = e.kind, this.type = e.type, this.data = e.data, this.error = e.error, this.inputsLocked = e.inputsLocked, this.outputsLocked = e.outputsLocked, this.resourceReady = e.resourceReady, this.finalFlag = e.final, this.logger = t;
+  }
+  // TODO add logging
+  info(e) {
+    this.logger !== void 0 && this.logger.info(e);
+  }
+  warn(e) {
+    this.logger !== void 0 && this.logger.warn(e);
+  }
+  get final() {
+    return this._final;
+  }
+  getField(e, t, r = () => {
+  }) {
+    var n, i, f;
+    const s = typeof t == "string" ? { field: t } : t, c = this.fields.get(s.field);
+    if (c === void 0) {
+      if (s.errorIfFieldNotFound || s.errorIfFieldNotSet)
+        throw new Error(
+          `Field "${s.field}" not found in resource ${m(this.id)}`
+        );
+      if (!this.inputsLocked) (n = this.inputAndServiceFieldListChanged) == null || n.attachWatcher(e);
+      else if (s.assertFieldType === "Service" || s.assertFieldType === "Input") {
+        if (s.allowPermanentAbsence)
+          return;
+        throw new Error(`Service or input field not found ${s.field}.`);
+      }
+      if (!this.outputsLocked) (i = this.outputFieldListChanged) == null || i.attachWatcher(e);
+      else if (s.assertFieldType === "Output") {
+        if (s.allowPermanentAbsence)
+          return;
+        throw new Error(`Output field not found ${s.field}.`);
+      }
+      (f = this.dynamicFieldListChanged) == null || f.attachWatcher(e), !this._final && !s.stableIfNotFound && r("field_not_found:" + s.field);
+      return;
+    } else {
+      if (s.assertFieldType !== void 0 && c.type !== s.assertFieldType)
+        throw new Error(
+          `Unexpected field type: expected ${s.assertFieldType} but got ${c.type} for the field name ${s.field}`
+        );
+      const d = {};
+      return g(c.value) && (d.value = c.value), g(c.error) && (d.error = c.error), d.value === void 0 && d.error === void 0 && r("field_not_resolved:" + s.field), c.change.attachWatcher(e), d;
+    }
+  }
+  getInputsLocked(e) {
+    var t;
+    return this.inputsLocked || (t = this.resourceStateChange) == null || t.attachWatcher(e), this.inputsLocked;
+  }
+  getOutputsLocked(e) {
+    var t;
+    return this.outputsLocked || (t = this.resourceStateChange) == null || t.attachWatcher(e), this.outputsLocked;
+  }
+  get isReadyOrError() {
+    return this.error !== R || this.resourceReady || this.originalResourceId !== R;
+  }
+  getIsFinal(e) {
+    var t;
+    return (t = this.finalChanged) == null || t.attachWatcher(e), this._final;
+  }
+  getIsReadyOrError(e) {
+    var t;
+    return this.isReadyOrError || (t = this.resourceStateChange) == null || t.attachWatcher(e), this.isReadyOrError;
+  }
+  getError(e) {
+    var t;
+    if (A(this.error)) {
+      (t = this.resourceStateChange) == null || t.attachWatcher(e);
+      return;
+    } else
+      return this.error;
+  }
+  listInputFields(e) {
+    var r;
+    const t = [];
+    return this.fields.forEach((s, c) => {
+      (s.type === "Input" || s.type === "Service") && t.push(c);
+    }), this.inputsLocked || (r = this.inputAndServiceFieldListChanged) == null || r.attachWatcher(e), t;
+  }
+  listOutputFields(e) {
+    var r;
+    const t = [];
+    return this.fields.forEach((s, c) => {
+      s.type === "Output" && t.push(c);
+    }), this.outputsLocked || (r = this.outputFieldListChanged) == null || r.attachWatcher(e), t;
+  }
+  listDynamicFields(e) {
+    var r;
+    const t = [];
+    return this.fields.forEach((s, c) => {
+      s.type !== "Input" && s.type !== "Output" && t.push(c);
+    }), (r = this.dynamicFieldListChanged) == null || r.attachWatcher(e), t;
+  }
+  getKeyValue(e, t) {
+    var r;
+    return (r = this.kvChanged) == null || r.attachWatcher(e), this.kv.get(t);
+  }
+  getKeyValueString(e, t) {
+    const r = this.getKeyValue(e, t);
+    if (r !== void 0)
+      return _.decode(r);
+  }
+  getDataAsString() {
+    if (this.data !== void 0)
+      return this.dataAsString === void 0 && (this.dataAsString = _.decode(this.data)), this.dataAsString;
+  }
+  getDataAsJson() {
+    if (this.data !== void 0)
+      return this.dataAsJson === void 0 && (this.dataAsJson = JSON.parse(this.getDataAsString())), this.dataAsJson;
+  }
+  verifyReadyState() {
+    if (this.resourceReady && !this.inputsLocked)
+      throw new Error(`ready without input or output lock: ${L(this.state)}`);
+  }
+  get state() {
+    return {
+      id: this.id,
+      kind: this.kind,
+      type: this.type,
+      data: this.data,
+      resourceReady: this.resourceReady,
+      inputsLocked: this.inputsLocked,
+      outputsLocked: this.outputsLocked,
+      error: this.error,
+      originalResourceId: this.originalResourceId,
+      final: this.finalFlag
+    };
+  }
+  markFinal() {
+    this._final || (this._final = !0, p(this.finalChanged).markChanged(), this.finalChanged = void 0, this.resourceStateChange = void 0, this.dynamicFieldListChanged = void 0, this.inputAndServiceFieldListChanged = void 0, this.outputFieldListChanged = void 0, this.lockedChange = void 0);
+  }
+  /** Used for invalidation */
+  markAllChanged() {
+    var e, t, r, s, c, n, i;
+    this.fields.forEach((f) => f.change.markChanged()), (e = this.finalChanged) == null || e.markChanged(), (t = this.resourceStateChange) == null || t.markChanged(), (r = this.lockedChange) == null || r.markChanged(), (s = this.inputAndServiceFieldListChanged) == null || s.markChanged(), (c = this.outputFieldListChanged) == null || c.markChanged(), (n = this.dynamicFieldListChanged) == null || n.markChanged(), (i = this.kvChanged) == null || i.markChanged(), this.resourceRemoved.markChanged();
+  }
+}
+class I {
+  constructor(e, t = (r) => !1) {
+    /** resource heap */
+    u(this, "resources", /* @__PURE__ */ new Map());
+    u(this, "resourcesAdded", new y());
+    /** Resets to false if any invalid state transitions are registered,
+     * after that tree will produce errors for any read or write operations */
+    u(this, "_isValid", !0);
+    u(this, "invalidationMessage");
+    this.root = e, this.isFinalPredicate = t;
+  }
+  forEachResource(e) {
+    this.resources.forEach((t) => e(t));
+  }
+  checkValid() {
+    if (!this._isValid) throw new Error(this.invalidationMessage ?? "tree is in invalid state");
+  }
+  get(e, t) {
+    this.checkValid();
+    const r = this.resources.get(t);
+    if (r === void 0)
+      throw this.resourcesAdded.attachWatcher(e), new Error(`resource ${m(t)} not found in the tree`);
+    return r.resourceRemoved.attachWatcher(e), r;
+  }
+  updateFromResourceData(e, t = !1) {
+    this.checkValid();
+    const r = [], s = [];
+    for (const n of e) {
+      let i = this.resources.get(n.id);
+      const f = i == null ? void 0 : i.state, d = (h) => {
+        const { fields: v, ...o } = n;
+        throw this.invalidateTree(), new w(
+          `Unexpected resource state transition (${h}): ${L(
+            o
+          )} -> ${L(f)}`
+        );
+      };
+      if (i !== void 0) {
+        i.final && d("resource state can	 be updated after it is marked as final");
+        let h = !1;
+        i.version += 1, i.originalResourceId !== n.originalResourceId && (i.originalResourceId !== R && d("originalResourceId can't change after it is set"), i.originalResourceId = n.originalResourceId, p(i.resourceStateChange).markChanged(), h = !0), i.error !== n.error && (g(i.error) && d("resource can't change attached error after it is set"), i.error = n.error, r.push(i.error), p(i.resourceStateChange).markChanged(), h = !0);
+        for (const o of n.fields) {
+          let l = i.fields.get(o.name);
+          l ? (l.type !== o.type && (l.type !== "Dynamic" && d(`field changed type ${l.type} -> ${o.type}`), p(i.dynamicFieldListChanged).markChanged(), (l.type === "Input" || l.type === "Service") && (i.inputsLocked && d(
+            `adding input field "${o.name}", while corresponding list is locked`
+          ), p(i.inputAndServiceFieldListChanged).markChanged()), l.type === "Output" && (i.outputsLocked && d(
+            `adding output field "${o.name}", while corresponding list is locked`
+          ), p(i.outputFieldListChanged).markChanged()), l.type = o.type, l.change.markChanged(), h = !0), l.value !== o.value && (g(l.value) && s.push(l.value), l.value = o.value, g(o.value) && r.push(o.value), l.change.markChanged(), h = !0), l.error !== o.error && (g(l.error) && s.push(l.error), l.error = o.error, g(o.error) && r.push(o.error), l.change.markChanged(), h = !0), l.resourceVersion = i.version) : (l = new T(o.type, o.value, o.error, i.version), g(o.value) && r.push(o.value), g(o.error) && r.push(o.error), o.type === "Input" || o.type === "Service" ? (i.inputsLocked && d(
+            `adding ${o.type} (${o.name}) field while inputs locked`
+          ), p(i.inputAndServiceFieldListChanged).markChanged()) : o.type === "Output" ? (i.outputsLocked && d(
+            `adding ${o.type} (${o.name}) field while outputs locked`
+          ), p(i.outputFieldListChanged).markChanged()) : p(i.dynamicFieldListChanged).markChanged(), i.fields.set(o.name, l), h = !0);
+        }
+        if (i.fields.forEach((o, l, C) => {
+          o.resourceVersion !== i.version && ((o.type === "Input" || o.type === "Service" || o.type === "Output") && d(`removal of ${o.type} field ${l}`), o.change.markChanged(), C.delete(l), g(o.value) && s.push(o.value), g(o.error) && s.push(o.error), p(i.dynamicFieldListChanged).markChanged());
+        }), i.inputsLocked !== n.inputsLocked && (i.inputsLocked && d("inputs unlocking is not permitted"), i.inputsLocked = n.inputsLocked, p(i.lockedChange).markChanged(), h = !0), i.outputsLocked !== n.outputsLocked && (i.outputsLocked && d("outputs unlocking is not permitted"), i.outputsLocked = n.outputsLocked, p(i.lockedChange).markChanged(), h = !0), i.resourceReady !== n.resourceReady) {
+          const o = i.resourceReady;
+          i.resourceReady = n.resourceReady, i.verifyReadyState(), i.isReadyOrError || d(
+            `resource can't lose it's ready or error state (ready state before ${o})`
+          ), p(i.resourceStateChange).markChanged(), h = !0;
+        }
+        let v = !1;
+        for (const o of n.kv) {
+          const l = i.kv.get(o.key);
+          (l === void 0 || Buffer.compare(l, o.value) !== 0) && (i.kv.set(o.key, o.value), v = !0);
+        }
+        if (i.kv.size > n.kv.length) {
+          const o = new Set(n.kv.map((l) => l.key));
+          i.kv.forEach((l, C, V) => {
+            o.has(C) || V.delete(C);
+          }), v = !0;
+        }
+        v && p(i.kvChanged).markChanged(), h && (i.dataVersion = i.version, this.isFinalPredicate(i) && i.markFinal());
+      } else {
+        i = new z(n), i.verifyReadyState(), g(i.error) && r.push(i.error);
+        for (const h of n.fields) {
+          const v = new T(h.type, h.value, h.error, D);
+          g(h.value) && r.push(h.value), g(h.error) && r.push(h.error), i.fields.set(h.name, v);
+        }
+        for (const h of n.kv) i.kv.set(h.key, h.value);
+        this.resources.set(i.id, i), this.resourcesAdded.markChanged();
+      }
+    }
+    for (const n of r) {
+      const i = this.resources.get(n);
+      if (!i)
+        throw this.invalidateTree(), new w(`orphan resource ${n}`);
+      i.refCount++;
+    }
+    let c = s;
+    for (; c.length > 0; ) {
+      const n = [];
+      for (const i of c) {
+        const f = this.resources.get(i);
+        if (!f)
+          throw this.invalidateTree(), new w(`orphan resource ${i}`);
+        f.refCount--, f.refCount === 0 && f.id !== this.root && (f.fields.forEach((d) => {
+          g(d.value) && n.push(d.value), g(d.error) && n.push(d.error), d.change.markChanged();
+        }), g(f.error) && n.push(f.error), f.resourceRemoved.markChanged(), this.resources.delete(i));
+      }
+      c = n;
+    }
+    if (!t) {
+      for (const n of e)
+        if (!this.resources.has(n.id))
+          throw this.invalidateTree(), new w(`orphan input resource ${n.id}`);
+    }
+  }
+  /** @deprecated use "entry" instead */
+  accessor(e = this.root) {
+    return this.checkValid(), this.entry(e);
+  }
+  entry(e = this.root) {
+    return this.checkValid(), new k({ treeProvider: () => this }, e);
+  }
+  invalidateTree(e) {
+    this._isValid = !1, this.invalidationMessage = e, this.resources.forEach((t) => {
+      t.markAllChanged();
+    });
+  }
+}
+function q(a, e) {
+  const t = [], r = /* @__PURE__ */ new Set();
+  return a.forEachResource((s) => {
+    s.final ? r.add(s.id) : t.push(s.id);
+  }), t.length === 0 && r.size === 0 && t.push(a.root), { seedResources: t, finalResources: r, pruningFunction: e };
+}
+async function B(a, e) {
+  const { seedResources: t, finalResources: r, pruningFunction: s } = e, c = new K(), n = /* @__PURE__ */ new Set(), i = (d) => {
+    if (A(d) || n.has(d) || r.has(d)) return;
+    n.add(d);
+    const h = a.getResourceDataIfExists(d, !0), v = a.listKeyValuesIfResourceExists(d);
+    c.push(
+      (async () => {
+        const o = await h, l = await v;
+        if (o !== void 0) {
+          if (l === void 0) throw new Error("Inconsistent replies");
+          return { ...o, kv: l };
+        }
+      })()
+    );
+  };
+  t.forEach((d) => i(d));
+  const f = [];
+  for (; ; ) {
+    const d = c.shift();
+    if (d === void 0)
+      break;
+    let h = await d;
+    if (h !== void 0) {
+      s !== void 0 && (h = { ...h, fields: s(h) }), i(h.error);
+      for (const v of h.fields)
+        i(v.value), i(v.error);
+      f.push(h);
+    }
+  }
+  return f;
+}
+function ie(a) {
+  return a;
+}
+function se(a, e, t) {
+  var n;
+  const r = a instanceof k ? p(t).accessor(a).node() : a instanceof E ? a.node() : a, c = { ...r.resourceInfo };
+  if (e.data !== void 0 && (e.data === "raw" ? c.data = r.getData() : c.data = e.data.parse(r.getDataAsJson())), e.fields !== void 0) {
+    const i = {};
+    for (const [f, d] of Object.entries(e.fields))
+      i[f] = (n = r.traverse({
+        field: f,
+        errorIfFieldNotSet: d,
+        stableIfNotFound: !d
+      })) == null ? void 0 : n.id;
+    c.fields = i;
+  }
+  if (e.kv !== void 0) {
+    const i = {};
+    for (const [f, d] of Object.entries(e.kv)) {
+      const h = r.getKeyValue(f);
+      if (h === void 0)
+        throw new Error(`Key not found ${f}`);
+      d === "raw" ? i[f] = h : i[f] = d.parse(JSON.parse(Buffer.from(h).toString("utf-8")));
+    }
+    c.kv = i;
+  }
+  return c;
+}
+function ne(a, e, t) {
+  if (a instanceof k) {
+    const r = t.accessor(a).node(), s = r.resourceInfo, c = e.map((n) => {
+      var i, f;
+      return [
+        n,
+        (f = (i = r.getField(n)) == null ? void 0 : i.value) == null ? void 0 : f.id
+      ];
+    });
+    return {
+      ...s,
+      fields: new Map(c),
+      data: r.getData() ?? new Uint8Array()
+    };
+  }
+  return a;
+}
+function ae(a, e, t) {
+  if (!(a instanceof k)) return a;
+  const r = t.accessor(a).node(), s = r.resourceInfo, c = e.map((n) => [n, r.getKeyValue(n)]);
+  return {
+    ...s,
+    metadata: Object.fromEntries(c)
+  };
+}
+class b {
+  constructor(e, t, r, s) {
+    u(this, "finalPredicate");
+    u(this, "state");
+    u(this, "pollingInterval");
+    u(this, "pruning");
+    u(this, "hooks");
+    u(this, "abortController", new AbortController());
+    u(this, "scheduledOnNextState", []);
+    /** If true, main loop will continue polling pl state. */
+    u(this, "keepRunning", !1);
+    /** Actual state of main loop. */
+    u(this, "currentLoop");
+    /** If true this tree state is permanently terminaed. */
+    u(this, "terminated", !1);
+    this.pl = e, this.root = t, this.logger = s;
+    const { finalPredicate: c, pruning: n, pollingInterval: i, stopPollingDelay: f } = r;
+    this.pruning = n, this.pollingInterval = i, this.finalPredicate = c, this.state = new I(t, c), this.hooks = new U(
+      () => this.startUpdating(),
+      () => this.stopUpdating(),
+      { stopDebounce: f },
+      (d, h) => this.scheduleOnNextState(d, h)
+    );
+  }
+  /** @deprecated use "entry" instead */
+  accessor(e = this.root) {
+    if (this.terminated) throw new Error("tree synchronization is terminated");
+    return this.entry(e);
+  }
+  entry(e = this.root) {
+    if (this.terminated) throw new Error("tree synchronization is terminated");
+    return new k({ treeProvider: () => this.state, hooks: this.hooks }, e);
+  }
+  /** Can be used to externally kick off the synchronization polling loop, and
+   * await for the first synchronization to happen. */
+  async refreshState() {
+    if (this.terminated) throw new Error("tree synchronization is terminated");
+    await this.hooks.refreshState();
+  }
+  scheduleOnNextState(e, t) {
+    this.terminated ? t(new Error("tree synchronization is terminated")) : this.scheduledOnNextState.push({ resolve: e, reject: t });
+  }
+  /** Called from observer */
+  startUpdating() {
+    this.terminated || (this.keepRunning = !0, this.currentLoop === void 0 && (this.currentLoop = this.mainLoop()));
+  }
+  /** Called from observer */
+  stopUpdating() {
+    this.keepRunning = !1;
+  }
+  /** Executed from the main loop, and initialization procedure. */
+  async refresh() {
+    if (this.terminated) throw new Error("tree synchronization is terminated");
+    const e = q(this.state, this.pruning), t = await this.pl.withReadTx("ReadingTree", async (r) => await B(r, e));
+    this.state.updateFromResourceData(t, !0);
+  }
+  async mainLoop() {
+    var e, t;
+    for (; this.keepRunning; ) {
+      let r;
+      this.scheduledOnNextState.length > 0 && (r = this.scheduledOnNextState, this.scheduledOnNextState = []);
+      try {
+        if (await this.refresh(), r !== void 0) for (const s of r) s.resolve();
+      } catch (s) {
+        if (r !== void 0) for (const c of r) c.reject(s);
+        if (s instanceof w) {
+          (e = this.logger) == null || e.error(s), this.state.invalidateTree("stat update error"), this.state = new I(this.root, this.finalPredicate);
+          continue;
+        } else (t = this.logger) == null || t.warn(s);
+      }
+      if (!this.keepRunning || this.terminated) break;
+      try {
+        await J.setTimeout(this.pollingInterval, this.abortController.signal);
+      } catch (s) {
+        if (!W(s)) throw new Error("Unexpected error", { cause: s });
+        break;
+      }
+    }
+    this.currentLoop = void 0;
+  }
+  /**
+   * Terminates the internal loop, and permanently destoys all internal state, so
+   * all computables using this state will resolve to errors.
+   * */
+  async terminate() {
+    this.keepRunning = !1, this.terminated = !0, this.abortController.abort(), this.currentLoop !== void 0 && (await this.currentLoop, this.state.invalidateTree("synchronization terminated for the tree"));
+  }
+  /** @deprecated */
+  async awaitSyncLoopTermination() {
+    this.currentLoop !== void 0 && await this.currentLoop;
+  }
+  static async init(e, t, r) {
+    const s = new b(e, t, r);
+    return await s.refresh(), s;
+  }
+}
+export {
+  O as PlError,
+  k as PlTreeEntry,
+  E as PlTreeEntryAccessor,
+  M as PlTreeNodeAccessor,
+  z as PlTreeResource,
+  I as PlTreeState,
+  b as SynchronizedTreeState,
+  w as TreeStateUpdateError,
+  q as constructTreeLoadingRequest,
+  Z as isPlTreeEntry,
+  ee as isPlTreeEntryAccessor,
+  te as isPlTreeNodeAccessor,
+  B as loadTreeState,
+  se as makeResourceSnapshot,
+  x as mapValueAndError,
+  X as mapValueAndErrorIfDefined,
+  ie as rsSchema,
+  re as treeEntryToResourceInfo,
+  ne as treeEntryToResourceWithData,
+  ae as treeEntryToResourceWithMetadata
+};
+//# sourceMappingURL=index.mjs.map