@milaboratories/pl-tree 1.9.22 → 1.10.0

package/src/accessors.ts

@@ -5,13 +5,17 @@ import type {
   ComputableHooks,
   UsageGuard,
 } from "@milaboratories/computable";
-import type { ResourceId, ResourceType, OptionalResourceId } from "@milaboratories/pl-client";
+import type {
+  SignedResourceId,
+  ResourceType,
+  OptionalSignedResourceId,
+} from "@milaboratories/pl-client";
 import {
   resourceIdToString,
   resourceTypesEqual,
   resourceTypeToString,
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  NullResourceId,
+  NullSignedResourceId,
 } from "@milaboratories/pl-client";
 import type { ValueAndError } from "./value_and_error";
 import { mapValueAndError } from "./value_and_error";
@@ -71,7 +75,7 @@ export class PlTreeEntry implements AccessorProvider<PlTreeEntryAccessor> {
 
   constructor(
     private readonly accessorData: TreeAccessorData,
-    public readonly rid: ResourceId,
+    public readonly rid: SignedResourceId, // only for runtime. Not exposing rid at all causes too much pain. Never persist this anywhere.
   ) {}
 
   public createAccessor(ctx: ComputableCtx, guard: UsageGuard): PlTreeEntryAccessor {
@@ -81,6 +85,14 @@ export class PlTreeEntry implements AccessorProvider<PlTreeEntryAccessor> {
     });
   }
 
+  /**
+   * Tree TreeEntry ID suitable for persistence and use in names (files/objects/whatever), as it does not
+   * contain signature which can change from session to session.
+   */
+  public get id(): string {
+    return resourceIdToString(this.rid);
+  }
+
   public toJSON(): string {
     return this.toString();
   }
@@ -94,7 +106,7 @@ function getResourceFromTree(
   accessorData: TreeAccessorData,
   tree: PlTreeState,
   instanceData: TreeAccessorInstanceData,
-  rid: ResourceId,
+  rid: SignedResourceId,
   ops: ResourceTraversalOps,
 ): PlTreeNodeAccessor {
   const acc = new PlTreeNodeAccessor(
@@ -130,7 +142,7 @@ export class PlTreeEntryAccessor {
   constructor(
     private readonly accessorData: TreeAccessorData,
     private readonly tree: PlTreeState,
-    private readonly rid: ResourceId,
+    private readonly rid: SignedResourceId,
     private readonly instanceData: TreeAccessorInstanceData,
   ) {}
 
@@ -150,7 +162,7 @@ export class PlTreeEntryAccessor {
  * Helper type to simplify implementation of APIs requiring type information.
  * */
 export type ResourceInfo = {
-  readonly id: ResourceId;
+  readonly id: SignedResourceId;
   readonly type: ResourceType;
 };
 
@@ -166,7 +178,7 @@ export function treeEntryToResourceInfo(res: PlTreeEntry | ResourceInfo, ctx: Co
 
 /**
  * API contracts:
- *   - API never return {@link NullResourceId}, absence of link is always modeled as `undefined`
+ *   - API never return {@link NullSignedResourceId}, absence of link is always modeled as `undefined`
  *
  * Important: never store instances of this class, always get fresh instance from {@link PlTreeState} accessor.
  * */
@@ -180,12 +192,12 @@ export class PlTreeNodeAccessor {
     private readonly instanceData: TreeAccessorInstanceData,
   ) {}
 
-  public get id(): ResourceId {
+  public get id(): SignedResourceId {
     this.instanceData.guard();
     return this.resource.id;
   }
 
-  public get originalId(): OptionalResourceId {
+  public get originalId(): OptionalSignedResourceId {
     this.instanceData.guard();
     return this.resource.originalResourceId;
   }
@@ -199,7 +211,10 @@ export class PlTreeNodeAccessor {
     return { id: this.id, type: this.resourceType };
   }
 
-  private getResourceFromTree(rid: ResourceId, ops: ResourceTraversalOps): PlTreeNodeAccessor {
+  private getResourceFromTree(
+    rid: SignedResourceId,
+    ops: ResourceTraversalOps,
+  ): PlTreeNodeAccessor {
     return getResourceFromTree(this.accessorData, this.tree, this.instanceData, rid, ops);
   }
 

package/src/snapshot.test.ts

@@ -1,6 +1,9 @@
 import { expect, test } from "vitest";
 import { Computable } from "@milaboratories/computable";
-import { DefaultFinalResourceDataPredicate, ResourceId } from "@milaboratories/pl-client";
+import {
+  createSignedResourceId,
+  DefaultFinalResourceDataPredicate,
+} from "@milaboratories/pl-client";
 import { z } from "zod";
 import { InferSnapshot, makeResourceSnapshot, rsSchema } from "./snapshot";
 import { PlTreeState } from "./state";
@@ -14,6 +17,8 @@ import {
   iField,
 } from "./test_utils";
 
+const rid = createSignedResourceId;
+
 // schema definition
 const MyTestResourceState = rsSchema({
   data: z.object({
@@ -96,7 +101,3 @@ test("simple snapshot test", async () => {
   expect((await c1.getValueOrError()).type).toStrictEqual("error");
   expect(c1.isChanged()).toBeFalsy();
 });
-
-function rid(id: bigint): ResourceId {
-  return id as ResourceId;
-}

package/src/snapshot.ts

@@ -1,4 +1,4 @@
-import type { ResourceId, ResourceType } from "@milaboratories/pl-client";
+import type { SignedResourceId, ResourceType } from "@milaboratories/pl-client";
 import type { Optional, Writable } from "utility-types";
 import type { ZodType, z } from "zod";
 import type { PlTreeNodeAccessor } from "./accessors";
@@ -13,10 +13,10 @@ import { notEmpty } from "@milaboratories/ts-helpers";
  */
 export type ResourceSnapshot<
   Data = undefined,
-  Fields extends Record<string, ResourceId | undefined> | undefined = undefined,
+  Fields extends Record<string, SignedResourceId | undefined> | undefined = undefined,
   KV extends Record<string, unknown> | undefined = undefined,
 > = {
-  readonly id: ResourceId;
+  readonly id: SignedResourceId;
   readonly type: ResourceType;
   readonly data: Data;
   readonly fields: Fields;
@@ -26,7 +26,7 @@ export type ResourceSnapshot<
 /** The most generic type of ResourceSnapshot. */
 type ResourceSnapshotGeneric = ResourceSnapshot<
   unknown,
-  Record<string, ResourceId | undefined> | undefined,
+  Record<string, SignedResourceId | undefined> | undefined,
   Record<string, unknown> | undefined
 >;
 
@@ -80,8 +80,8 @@ type InferFieldsType<Fields extends Record<string, boolean> | undefined> = Field
   ? undefined
   : {
       [FieldName in keyof Fields]: Fields[FieldName] extends true
-        ? ResourceId
-        : ResourceId | undefined;
+        ? SignedResourceId
+        : SignedResourceId | undefined;
     };
 
 /**
@@ -132,7 +132,7 @@ export function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneri
   }
 
   if (schema.fields !== undefined) {
-    const fields: Record<string, ResourceId | undefined> = {};
+    const fields: Record<string, SignedResourceId | undefined> = {};
     // even if field is not defined, corresponding object field
     // with "undefined" value will still be added
     for (const [fieldName, required] of Object.entries(schema.fields))
@@ -165,9 +165,9 @@ export function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneri
 
 /** @deprecated */
 export type ResourceWithData = {
-  readonly id: ResourceId;
+  readonly id: SignedResourceId;
   readonly type: ResourceType;
-  readonly fields: Map<string, ResourceId | undefined>;
+  readonly fields: Map<string, SignedResourceId | undefined>;
   readonly data?: Uint8Array;
 };
 
@@ -181,7 +181,7 @@ export function treeEntryToResourceWithData(
     const node = ctx.accessor(res).node();
     const info = node.resourceInfo;
 
-    const fValues: [string, ResourceId | undefined][] = fields.map((name) => [
+    const fValues: [string, SignedResourceId | undefined][] = fields.map((name) => [
       name,
       node.getField(name)?.value?.id,
     ]);
@@ -198,7 +198,7 @@ export function treeEntryToResourceWithData(
 
 /** @deprecated */
 export type ResourceWithMetadata = {
-  readonly id: ResourceId;
+  readonly id: SignedResourceId;
   readonly type: ResourceType;
   readonly metadata: Record<string, any>;
 };

package/src/state.test.ts

@@ -1,9 +1,9 @@
 import { expect, test } from "vitest";
 import { Computable } from "@milaboratories/computable";
 import {
+  createSignedResourceId,
   DefaultFinalResourceDataPredicate,
-  NullResourceId,
-  ResourceId,
+  NullSignedResourceId,
 } from "@milaboratories/pl-client";
 import { isPlTreeEntry, isPlTreeEntryAccessor, isPlTreeNodeAccessor } from "./accessors";
 import { PlTreeState } from "./state";
@@ -18,9 +18,7 @@ import {
   TestValueResourceState1,
 } from "./test_utils";
 
-function rid(id: bigint): ResourceId {
-  return id as ResourceId;
-}
+const rid = createSignedResourceId;
 
 test("simple tree test 1", async () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
@@ -54,11 +52,11 @@ test("simple tree test 1", async () => {
   expect(c1.isChanged()).toBeFalsy();
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(rid(1n)))] },
-    { ...TestStructuralResourceState1, id: rid(rid(1n)), fields: [iField("b", rid(rid(2n)))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(1n))] },
+    { ...TestStructuralResourceState1, id: rid(1n), fields: [iField("b", rid(2n))] },
     {
       ...TestValueResourceState1,
-      id: rid(rid(2n)),
+      id: rid(2n),
       data: new TextEncoder().encode("Test1"),
     },
   ]);
@@ -85,11 +83,11 @@ test("simple tree kv test", async () => {
   expect(c1.isChanged()).toBeFalsy();
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(rid(1n)))] },
-    { ...TestStructuralResourceState1, id: rid(rid(1n)), fields: [iField("b", rid(rid(2n)))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(1n))] },
+    { ...TestStructuralResourceState1, id: rid(1n), fields: [iField("b", rid(2n))] },
     {
       ...TestValueResourceState1,
-      id: rid(rid(2n)),
+      id: rid(2n),
       data: new TextEncoder().encode("Test1"),
     },
   ]);
@@ -101,7 +99,7 @@ test("simple tree kv test", async () => {
   tree.updateFromResourceData([
     {
       ...TestValueResourceState1,
-      id: rid(rid(2n)),
+      id: rid(2n),
       data: new TextEncoder().encode("Test1"),
       kv: [{ key: "thekey", value: Buffer.from("thevalue") }],
     },
@@ -114,7 +112,7 @@ test("simple tree kv test", async () => {
   tree.updateFromResourceData([
     {
       ...TestValueResourceState1,
-      id: rid(rid(2n)),
+      id: rid(2n),
       data: new TextEncoder().encode("Test1"),
       kv: [],
     },
@@ -197,7 +195,7 @@ test("field error", async () => {
   tree.updateFromResourceData([
     {
       ...TestDynamicRootState1,
-      fields: [dField("b", NullResourceId, rid(7n))],
+      fields: [dField("b", NullSignedResourceId, rid(7n))],
     },
     {
       ...TestErrorResourceState2,

package/src/state.ts

@@ -4,16 +4,16 @@ import type {
   FieldStatus,
   FieldType,
   KeyValue,
-  OptionalResourceId,
+  OptionalSignedResourceId,
   ResourceData,
-  ResourceId,
+  SignedResourceId,
   ResourceKind,
   ResourceType,
 } from "@milaboratories/pl-client";
 import {
-  isNotNullResourceId,
-  isNullResourceId,
-  NullResourceId,
+  isNotNullSignedResourceId,
+  isNullSignedResourceId,
+  NullSignedResourceId,
   resourceIdToString,
   stringifyWithResourceId,
 } from "@milaboratories/pl-client";
@@ -42,8 +42,8 @@ class PlTreeField implements FieldData {
   constructor(
     public readonly name: string,
     public type: FieldType,
-    public value: OptionalResourceId,
-    public error: OptionalResourceId,
+    public value: OptionalSignedResourceId,
+    public error: OptionalSignedResourceId,
     public status: FieldStatus,
     public valueIsFinal: boolean,
     /** Last version of resource this field was observed, used to garbage collect fields in tree patching procedure */
@@ -98,8 +98,8 @@ export class PlTreeResource implements ResourceDataWithFinalState {
   // kvChangedGlobal? = new ChangeSource();
   kvChangedPerKey? = new KeyedChangeSource();
 
-  readonly id: ResourceId;
-  originalResourceId: OptionalResourceId;
+  readonly id: SignedResourceId;
+  originalResourceId: OptionalSignedResourceId;
 
   readonly kind: ResourceKind;
   readonly type: ResourceType;
@@ -108,7 +108,7 @@ export class PlTreeResource implements ResourceDataWithFinalState {
   private dataAsString?: string;
   private dataAsJson?: unknown;
 
-  error: OptionalResourceId;
+  error: OptionalSignedResourceId;
 
   inputsLocked: boolean;
   outputsLocked: boolean;
@@ -162,17 +162,17 @@ export class PlTreeResource implements ResourceDataWithFinalState {
       | (Omit<GetFieldStep, "errorIfFieldNotFound"> & { errorIfFieldNotFound: true })
       | (Omit<GetFieldStep, "errorIfFieldNotSet"> & { errorIfFieldNotSet: true }),
     onUnstable: (marker: string) => void,
-  ): ValueAndError<ResourceId>;
+  ): ValueAndError<SignedResourceId>;
   public getField(
     watcher: Watcher,
     _step: string | GetFieldStep,
     onUnstable: (marker: string) => void,
-  ): ValueAndError<ResourceId> | undefined;
+  ): ValueAndError<SignedResourceId> | undefined;
   public getField(
     watcher: Watcher,
     _step: string | GetFieldStep,
     onUnstable: (marker: string) => void = () => {},
-  ): ValueAndError<ResourceId> | undefined {
+  ): ValueAndError<SignedResourceId> | undefined {
     const step: FieldTraversalStep = typeof _step === "string" ? { field: _step } : _step;
 
     const field = this.fieldsMap.get(step.field);
@@ -208,9 +208,9 @@ export class PlTreeResource implements ResourceDataWithFinalState {
           `Unexpected field type: expected ${step.assertFieldType} but got ${field.type} for the field name ${step.field}`,
         );
 
-      const ret = {} as ValueAndError<ResourceId>;
-      if (isNotNullResourceId(field.value)) ret.value = field.value;
-      if (isNotNullResourceId(field.error)) ret.error = field.error;
+      const ret = {} as ValueAndError<SignedResourceId>;
+      if (isNotNullSignedResourceId(field.value)) ret.value = field.value;
+      if (isNotNullSignedResourceId(field.error)) ret.error = field.error;
       if (ret.value === undefined && ret.error === undefined)
         // this method returns value and error of the field, thus those values are considered to be accessed;
         // any existing but not resolved field here is considered to be unstable, in the sense it is
@@ -237,9 +237,9 @@ export class PlTreeResource implements ResourceDataWithFinalState {
 
   public get isReadyOrError(): boolean {
     return (
-      this.error !== NullResourceId ||
+      this.error !== NullSignedResourceId ||
       this.resourceReady ||
-      this.originalResourceId !== NullResourceId
+      this.originalResourceId !== NullSignedResourceId
     );
   }
 
@@ -255,8 +255,8 @@ export class PlTreeResource implements ResourceDataWithFinalState {
     return this.isReadyOrError;
   }
 
-  public getError(watcher: Watcher): ResourceId | undefined {
-    if (isNullResourceId(this.error)) {
+  public getError(watcher: Watcher): SignedResourceId | undefined {
+    if (isNullSignedResourceId(this.error)) {
       this.resourceStateChange?.attachWatcher(watcher);
       return undefined;
     } else {
@@ -387,7 +387,7 @@ export class PlTreeResource implements ResourceDataWithFinalState {
 
 export class PlTreeState {
   /** resource heap */
-  private resources: Map<ResourceId, PlTreeResource> = new Map();
+  private resources: Map<SignedResourceId, PlTreeResource> = new Map();
   private readonly resourcesAdded = new ChangeSource();
   /** Resets to false if any invalid state transitions are registered,
    * after that tree will produce errors for any read or write operations */
@@ -396,7 +396,7 @@ export class PlTreeState {
 
   constructor(
     /** This will be the only resource not deleted during GC round */
-    public readonly root: ResourceId,
+    public readonly root: SignedResourceId,
     public readonly isFinalPredicate: FinalResourceDataPredicate,
   ) {}
 
@@ -408,7 +408,7 @@ export class PlTreeState {
     if (!this._isValid) throw new Error(this.invalidationMessage ?? "tree is in invalid state");
   }
 
-  public get(watcher: Watcher, rid: ResourceId): PlTreeResource {
+  public get(watcher: Watcher, rid: SignedResourceId): PlTreeResource {
     this.checkValid();
     const res = this.resources.get(rid);
     if (res === undefined) {
@@ -425,8 +425,8 @@ export class PlTreeState {
     this.checkValid();
 
     // All resources for which recount should be incremented, first are aggregated in this list
-    const incrementRefs: ResourceId[] = [];
-    const decrementRefs: ResourceId[] = [];
+    const incrementRefs: SignedResourceId[] = [];
+    const decrementRefs: SignedResourceId[] = [];
 
     // patching / creating resources
     for (const rd of resourceData) {
@@ -456,7 +456,7 @@ export class PlTreeState {
 
         // duplicate / original
         if (resource.originalResourceId !== rd.originalResourceId) {
-          if (resource.originalResourceId !== NullResourceId)
+          if (resource.originalResourceId !== NullSignedResourceId)
             unexpectedTransitionError("originalResourceId can't change after it is set");
           resource.originalResourceId = rd.originalResourceId;
           // duplicate status of the resource counts as ready for the external observer
@@ -467,11 +467,11 @@ export class PlTreeState {
         }
 
         // error
-        if (resource.error !== rd.error) {
-          if (isNotNullResourceId(resource.error))
+        if (isNotNullSignedResourceId(rd.error) && resource.error !== rd.error) {
+          if (isNotNullSignedResourceId(resource.error))
             unexpectedTransitionError("resource can't change attached error after it is set");
           resource.error = rd.error;
-          incrementRefs.push(resource.error as ResourceId);
+          incrementRefs.push(resource.error);
           notEmpty(resource.resourceStateChange).markChanged(
             `error changed for ${resourceIdToString(resource.id)}`,
           );
@@ -494,8 +494,8 @@ export class PlTreeState {
               fd.valueIsFinal,
               resource.version,
             );
-            if (isNotNullResourceId(fd.value)) incrementRefs.push(fd.value);
-            if (isNotNullResourceId(fd.error)) incrementRefs.push(fd.error);
+            if (isNotNullSignedResourceId(fd.value)) incrementRefs.push(fd.value);
+            if (isNotNullSignedResourceId(fd.error)) incrementRefs.push(fd.error);
 
             if (fd.type === "Input" || fd.type === "Service") {
               if (resource.inputsLocked)
@@ -559,9 +559,9 @@ export class PlTreeState {
 
             // field value
             if (field.value !== fd.value) {
-              if (isNotNullResourceId(field.value)) decrementRefs.push(field.value);
+              if (isNotNullSignedResourceId(field.value)) decrementRefs.push(field.value);
               field.value = fd.value;
-              if (isNotNullResourceId(fd.value)) incrementRefs.push(fd.value);
+              if (isNotNullSignedResourceId(fd.value)) incrementRefs.push(fd.value);
               field.change.markChanged(
                 `field ${fd.name} value changed in ${resourceIdToString(resource.id)}`,
               );
@@ -570,9 +570,9 @@ export class PlTreeState {
 
             // field error
             if (field.error !== fd.error) {
-              if (isNotNullResourceId(field.error)) decrementRefs.push(field.error);
+              if (isNotNullSignedResourceId(field.error)) decrementRefs.push(field.error);
               field.error = fd.error;
-              if (isNotNullResourceId(fd.error)) incrementRefs.push(fd.error);
+              if (isNotNullSignedResourceId(fd.error)) incrementRefs.push(fd.error);
               field.change.markChanged(
                 `field ${fd.name} error changed in ${resourceIdToString(resource.id)}`,
               );
@@ -611,8 +611,8 @@ export class PlTreeState {
             );
             fields.delete(fieldName);
 
-            if (isNotNullResourceId(field.value)) decrementRefs.push(field.value);
-            if (isNotNullResourceId(field.error)) decrementRefs.push(field.error);
+            if (isNotNullSignedResourceId(field.value)) decrementRefs.push(field.value);
+            if (isNotNullSignedResourceId(field.error)) decrementRefs.push(field.error);
 
             notEmpty(resource!.dynamicFieldListChanged).markChanged(
               `dynamic field ${fieldName} removed from ${resourceIdToString(resource!.id)}`,
@@ -700,7 +700,7 @@ export class PlTreeState {
 
         resource = new PlTreeResource(rd);
         resource.verifyReadyState();
-        if (isNotNullResourceId(resource.error)) incrementRefs.push(resource.error);
+        if (isNotNullSignedResourceId(resource.error)) incrementRefs.push(resource.error);
         for (const fd of rd.fields) {
           const field = new PlTreeField(
             fd.name,
@@ -711,8 +711,8 @@ export class PlTreeState {
             fd.valueIsFinal,
             InitialResourceVersion,
           );
-          if (isNotNullResourceId(fd.value)) incrementRefs.push(fd.value);
-          if (isNotNullResourceId(fd.error)) incrementRefs.push(fd.error);
+          if (isNotNullSignedResourceId(fd.value)) incrementRefs.push(fd.value);
+          if (isNotNullSignedResourceId(fd.error)) incrementRefs.push(fd.error);
           resource.fieldsMap.set(fd.name, field);
         }
 
@@ -741,7 +741,7 @@ export class PlTreeState {
     // recursively applying refCount decrements / doing garbage collection
     let currentRefs = decrementRefs;
     while (currentRefs.length > 0) {
-      const nextRefs: ResourceId[] = [];
+      const nextRefs: SignedResourceId[] = [];
       for (const rid of currentRefs) {
         const res = this.resources.get(rid);
         if (!res) {
@@ -754,13 +754,13 @@ export class PlTreeState {
         if (res.refCount === 0 && res.id !== this.root) {
           // removing fields
           res.fieldsMap.forEach((field) => {
-            if (isNotNullResourceId(field.value)) nextRefs.push(field.value);
-            if (isNotNullResourceId(field.error)) nextRefs.push(field.error);
+            if (isNotNullSignedResourceId(field.value)) nextRefs.push(field.value);
+            if (isNotNullSignedResourceId(field.error)) nextRefs.push(field.error);
             field.change.markChanged(
               `field ${field.name} removed during garbage collection of ${resourceIdToString(res.id)}`,
             );
           });
-          if (isNotNullResourceId(res.error)) nextRefs.push(res.error);
+          if (isNotNullSignedResourceId(res.error)) nextRefs.push(res.error);
           res.resourceRemoved.markChanged(
             `resource removed during garbage collection: ${resourceIdToString(res.id)}`,
           );
@@ -782,12 +782,12 @@ export class PlTreeState {
   }
 
   /** @deprecated use "entry" instead */
-  public accessor(rid: ResourceId = this.root): PlTreeEntry {
+  public accessor(rid: SignedResourceId = this.root): PlTreeEntry {
     this.checkValid();
     return this.entry(rid);
   }
 
-  public entry(rid: ResourceId = this.root): PlTreeEntry {
+  public entry(rid: SignedResourceId = this.root): PlTreeEntry {
     this.checkValid();
     return new PlTreeEntry({ treeProvider: () => this }, rid);
   }

package/src/sync.ts

@@ -1,11 +1,11 @@
 import type {
   FieldData,
-  OptionalResourceId,
+  OptionalSignedResourceId,
   PlTransaction,
-  ResourceId,
+  SignedResourceId,
 } from "@milaboratories/pl-client";
 import Denque from "denque";
-import { isNullResourceId } from "@milaboratories/pl-client";
+import { isNullSignedResourceId } from "@milaboratories/pl-client";
 import type { ExtendedResourceData, PlTreeState } from "./state";
 import { ConcurrencyLimitingExecutor, msToHumanReadable } from "@milaboratories/ts-helpers";
 
@@ -16,12 +16,12 @@ export interface TreeLoadingRequest {
   /** Resource to prime the traversal algorithm. It is ok, if some of them
    * doesn't exist anymore. Should not contain elements from final resource
    * set. */
-  readonly seedResources: ResourceId[];
+  readonly seedResources: SignedResourceId[];
 
   /** Resource ids for which state is already known and not expected to change.
    * Algorithm will not continue traversal over those ids, and states will not
    * be retrieved for them. */
-  readonly finalResources: Set<ResourceId>;
+  readonly finalResources: Set<SignedResourceId>;
 
   /** This function is applied to each resource data field list, before
    * using it continue traversal. This modification also is applied to
@@ -37,8 +37,8 @@ export function constructTreeLoadingRequest(
   tree: PlTreeState,
   pruningFunction?: PruningFunction,
 ): TreeLoadingRequest {
-  const seedResources: ResourceId[] = [];
-  const finalResources = new Set<ResourceId>();
+  const seedResources: SignedResourceId[] = [];
+  const finalResources = new Set<SignedResourceId>();
   tree.forEachResource((res) => {
     if (res.finalState) finalResources.add(res.id);
     else seedResources.push(res.id);
@@ -120,11 +120,11 @@ export async function loadTreeState(
   let numberOfRoundTrips = 0;
 
   // tracking resources we already requested or queued
-  const requested = new Set<ResourceId>();
+  const requested = new Set<SignedResourceId>();
 
   /** Mark a resource for fetching. Deduplicates and respects final-resource set. */
-  const requestState = (rid: OptionalResourceId) => {
-    if (isNullResourceId(rid) || requested.has(rid)) return;
+  const requestState = (rid: OptionalSignedResourceId) => {
+    if (isNullSignedResourceId(rid) || requested.has(rid)) return;
 
     if (finalResources.has(rid)) {
       if (stats) stats.finalResourcesSkipped++;

package/src/synchronized_tree.ts

@@ -3,7 +3,7 @@ import { PlTreeEntry } from "./accessors";
 import type {
   FinalResourceDataPredicate,
   PlClient,
-  ResourceId,
+  SignedResourceId,
   TxOps,
 } from "@milaboratories/pl-client";
 import { isTimeoutOrCancelError } from "@milaboratories/pl-client";
@@ -52,7 +52,7 @@ export class SynchronizedTreeState {
 
   private constructor(
     private readonly pl: PlClient,
-    private readonly root: ResourceId,
+    private readonly root: SignedResourceId,
     ops: SynchronizedTreeOps,
     private readonly logger?: MiLogger,
   ) {
@@ -71,12 +71,12 @@ export class SynchronizedTreeState {
   }
 
   /** @deprecated use "entry" instead */
-  public accessor(rid: ResourceId = this.root): PlTreeEntry {
+  public accessor(rid: SignedResourceId = this.root): PlTreeEntry {
     if (this.terminated) throw new Error("tree synchronization is terminated");
     return this.entry(rid);
   }
 
-  public entry(rid: ResourceId = this.root): PlTreeEntry {
+  public entry(rid: SignedResourceId = this.root): PlTreeEntry {
     if (this.terminated) throw new Error("tree synchronization is terminated");
     return new PlTreeEntry({ treeProvider: () => this.state, hooks: this.hooks }, rid);
   }
@@ -260,7 +260,7 @@ export class SynchronizedTreeState {
 
   public static async init(
     pl: PlClient,
-    root: ResourceId,
+    root: SignedResourceId,
     ops: SynchronizedTreeOps,
     logger?: MiLogger,
   ) {