@milaboratories/pl-tree 1.12.13 → 1.12.15

package/dist/synchronized_tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"synchronized_tree.js","names":[],"sources":["../src/synchronized_tree.ts"],"sourcesContent":["import { PollingComputableHooks } from \"@milaboratories/computable\";\nimport { PlTreeEntry } from \"./accessors\";\nimport type {\n  FinalResourceDataPredicate,\n  PlClient,\n  SignedResourceId,\n  TxOps,\n} from \"@milaboratories/pl-client\";\nimport type { Filter } from \"@milaboratories/pl-client\";\nimport { isTimeoutOrCancelError } from \"@milaboratories/pl-client\";\nimport type { ExtendedResourceData } from \"./state\";\nimport { PlTreeState, TreeStateUpdateError } from \"./state\";\nimport type { PruningFunction, TraversalMode, TreeLoadingStat } from \"./sync\";\nimport { constructTreeLoadingRequest, initialTreeLoadingStat, loadTreeState } from \"./sync\";\nimport * as tp from \"node:timers/promises\";\n\n/** Hard floor between consecutive tree-refresh calls.\n * Applies even when {@link scheduleOnNextState} has woken the loop early,\n * preventing tight polling loops during rapid state transitions. */\nconst MIN_POLLING_INTERVAL_MS = 100;\nimport type { MiLogger } from \"@milaboratories/ts-helpers\";\n\ntype StatLoggingMode = \"cumulative\" | \"per-request\";\n\nexport type SynchronizedTreeOps = {\n  /** Override final predicate from the PlClient */\n  finalPredicateOverride?: FinalResourceDataPredicate;\n\n  /** Pruning function for legacy fallback path. */\n  pruning?: PruningFunction;\n\n  /** ResourceTree field filter for modern backend path. */\n  fieldFilter?: Filter;\n\n  /** ResourceTree traversal stop rules for modern backend path. */\n  traverseStopRules?: Filter;\n\n  /** Interval after last sync to sleep before the next one */\n  pollingInterval: number;\n  /** For how long to continue polling after the last derived value access */\n  stopPollingDelay: number;\n\n  /** If one of the values, tree will log stats of each polling request */\n  logStat?: StatLoggingMode;\n\n  /** Timeout for initial tree loading. If not specified, will use default for RO tx from pl-client. */\n  initialTreeLoadingTimeout?: number;\n\n  /** Controls which tree-loading path to use.  Default `\"auto\"`. */\n  traversalMode?: TraversalMode;\n};\n\ntype ScheduledRefresh = {\n  resolve: () => void;\n  reject: (err: any) => void;\n};\n\nexport class SynchronizedTreeState {\n  private readonly finalPredicate: FinalResourceDataPredicate;\n  private state: PlTreeState;\n  private readonly pollingInterval: number;\n  private readonly pruning?: PruningFunction;\n  private readonly fieldFilter?: Filter;\n  private readonly traverseStopRules?: Filter;\n  private readonly traversalMode: TraversalMode;\n  private readonly logStat?: StatLoggingMode;\n  private readonly hooks: PollingComputableHooks;\n  private readonly abortController = new AbortController();\n\n  private constructor(\n    private readonly pl: PlClient,\n    private readonly root: SignedResourceId,\n    ops: SynchronizedTreeOps,\n    private readonly logger?: MiLogger,\n  ) {\n    const {\n      finalPredicateOverride,\n      pruning,\n      fieldFilter,\n      traverseStopRules,\n      traversalMode,\n      pollingInterval,\n      stopPollingDelay,\n      logStat,\n    } = ops;\n    this.pruning = pruning;\n    this.fieldFilter = fieldFilter;\n    this.traverseStopRules = traverseStopRules;\n    this.traversalMode = traversalMode ?? \"auto\";\n    this.pollingInterval = pollingInterval;\n    this.finalPredicate = finalPredicateOverride ?? pl.finalPredicate;\n    this.logStat = logStat;\n    this.state = new PlTreeState(root, this.finalPredicate);\n    this.hooks = new PollingComputableHooks(\n      () => this.startUpdating(),\n      () => this.stopUpdating(),\n      { stopDebounce: stopPollingDelay },\n      (resolve, reject) => this.scheduleOnNextState(resolve, reject),\n    );\n  }\n\n  /** @deprecated use \"entry\" instead */\n  public accessor(rid: SignedResourceId = this.root): PlTreeEntry {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    return this.entry(rid);\n  }\n\n  public entry(rid: SignedResourceId = this.root): PlTreeEntry {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    return new PlTreeEntry({ treeProvider: () => this.state, hooks: this.hooks }, rid);\n  }\n\n  /** Can be used to externally kick off the synchronization polling loop, and\n   * await for the first synchronization to happen. */\n  public async refreshState(): Promise<void> {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    await this.hooks.refreshState();\n  }\n\n  private currentLoopDelayInterrupt: AbortController | undefined = undefined;\n  private scheduledOnNextState: ScheduledRefresh[] = [];\n\n  /** Called from computable hooks when external observer asks for state refresh */\n  private scheduleOnNextState(resolve: () => void, reject: (err: any) => void): void {\n    if (this.terminated) reject(new Error(\"tree synchronization is terminated\"));\n    else {\n      this.scheduledOnNextState.push({ resolve, reject });\n      if (this.currentLoopDelayInterrupt) {\n        this.currentLoopDelayInterrupt.abort();\n        this.currentLoopDelayInterrupt = undefined;\n      }\n    }\n  }\n\n  /** Called from observer */\n  private startUpdating(): void {\n    if (this.terminated) return;\n    this.keepRunning = true;\n    if (this.currentLoop === undefined) this.currentLoop = this.mainLoop();\n  }\n\n  /** Called from observer */\n  private stopUpdating(): void {\n    this.keepRunning = false;\n  }\n\n  /** If true, main loop will continue polling pl state. */\n  private keepRunning = false;\n  /** Actual state of main loop. */\n  private currentLoop: Promise<void> | undefined = undefined;\n\n  /** Executed from the main loop, and initialization procedure. */\n  private async refresh(stats?: TreeLoadingStat, txOps?: TxOps): Promise<void> {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    const request = constructTreeLoadingRequest(this.state, {\n      pruningFunction: this.pruning,\n      fieldFilter: this.fieldFilter,\n      traverseStopRules: this.traverseStopRules,\n    });\n    const data = await this.pl.withReadTx(\n      \"ReadingTree\",\n      async (tx) => {\n        return await loadTreeState(\n          tx,\n          request,\n          stats,\n          this.pl.serverInfo.capabilities ?? [],\n          this.traversalMode,\n          this.logger,\n        );\n      },\n      txOps,\n    );\n    this.state.updateFromResourceData(data, true);\n  }\n\n  /** If true this tree state is permanently terminaed. */\n  private terminated = false;\n\n  private async mainLoop() {\n    // will hold request stats\n    let stat = this.logStat ? initialTreeLoadingStat() : undefined;\n\n    let lastUpdate = Date.now();\n\n    while (true) {\n      if (!this.keepRunning || this.terminated) break;\n\n      // saving those who want to be notified about new state here\n      // because those who will be added during the tree retrieval\n      // should be notified only on the next round\n      let toNotify: ScheduledRefresh[] | undefined = undefined;\n      if (this.scheduledOnNextState.length > 0) {\n        toNotify = this.scheduledOnNextState;\n        this.scheduledOnNextState = [];\n      }\n\n      try {\n        // resetting stats if we were asked to collect non-cumulative stats\n        if (this.logStat === \"per-request\") stat = initialTreeLoadingStat();\n\n        // actual tree synchronization\n        await this.refresh(stat);\n\n        // logging stats if we were asked to\n        if (stat && this.logger)\n          this.logger.info(\n            `Tree stat (success, after ${Date.now() - lastUpdate}ms): ${JSON.stringify(stat)}`,\n          );\n        lastUpdate = Date.now();\n\n        // notifying that we got new state\n        if (toNotify !== undefined) for (const n of toNotify) n.resolve();\n      } catch (e: any) {\n        // logging stats if we were asked to (even if error occured)\n        if (stat && this.logger)\n          this.logger.info(\n            `Tree stat (error, after ${Date.now() - lastUpdate}ms): ${JSON.stringify(stat)}`,\n          );\n        lastUpdate = Date.now();\n\n        // notifying that we failed to refresh the state\n        if (toNotify !== undefined) for (const n of toNotify) n.reject(e);\n\n        // catching tree update errors, as they may leave our tree in inconsistent state\n        if (e instanceof TreeStateUpdateError) {\n          // important error logging, this should never happen\n          this.logger?.error(e);\n\n          // marking everybody who used previous state as changed\n          this.state.invalidateTree(\"stat update error\");\n          // creating new tree\n          this.state = new PlTreeState(this.root, this.finalPredicate);\n\n          // scheduling state update without delay\n          continue;\n\n          // unfortunately external observer may still see tree in its default\n          // empty state, though this is best we can do in this exceptional\n          // situation, and hope on caching layers inside computables to present\n          // some stale state until we reconstruct the tree again\n        } else this.logger?.warn(e);\n      }\n\n      if (!this.keepRunning || this.terminated) break;\n\n      // Phase 1: mandatory floor — always wait at least MIN_POLLING_INTERVAL_MS.\n      // Not interruptible by scheduleOnNextState; only termination aborts it.\n      try {\n        await tp.setTimeout(MIN_POLLING_INTERVAL_MS, undefined, {\n          signal: this.abortController.signal,\n        });\n      } catch (e: unknown) {\n        if (!isTimeoutOrCancelError(e)) throw new Error(\"Unexpected error\", { cause: e });\n        if (this.abortController.signal.aborted) break;\n      }\n\n      if (!this.keepRunning || this.terminated) break;\n\n      // Phase 2: optional remainder up to pollingInterval — interruptible by\n      // scheduleOnNextState so that an external nudge wakes the loop promptly.\n      if (this.scheduledOnNextState.length === 0) {\n        const remaining = Math.max(0, this.pollingInterval - MIN_POLLING_INTERVAL_MS);\n        if (remaining > 0) {\n          try {\n            this.currentLoopDelayInterrupt = new AbortController();\n            await tp.setTimeout(remaining, undefined, {\n              signal: AbortSignal.any([\n                this.abortController.signal,\n                this.currentLoopDelayInterrupt.signal,\n              ]),\n            });\n          } catch (e: unknown) {\n            if (!isTimeoutOrCancelError(e)) throw new Error(\"Unexpected error\", { cause: e });\n            if (this.abortController.signal.aborted) break;\n            // Otherwise it was just the loop delay interrupt (scheduleOnNextState),\n            // continue to the next iteration\n          } finally {\n            this.currentLoopDelayInterrupt = undefined;\n          }\n        }\n      }\n    }\n\n    // reset only as a very last line\n    this.currentLoop = undefined;\n  }\n\n  /**\n   * Dumps the current state of the tree.\n   * @returns An array of ExtendedResourceData objects representing the current state of the tree.\n   */\n  public dumpState(): ExtendedResourceData[] {\n    return this.state.dumpState();\n  }\n\n  /**\n   * Terminates the internal loop, and permanently destoys all internal state, so\n   * all computables using this state will resolve to errors.\n   * */\n  public async terminate(): Promise<void> {\n    this.keepRunning = false;\n    this.terminated = true;\n    this.abortController.abort();\n\n    if (this.currentLoop === undefined) return;\n    await this.currentLoop;\n\n    this.state.invalidateTree(\"synchronization terminated for the tree\");\n  }\n\n  /** @deprecated */\n  public async awaitSyncLoopTermination(): Promise<void> {\n    if (this.currentLoop === undefined) return;\n    await this.currentLoop;\n  }\n\n  public static async init(\n    pl: PlClient,\n    root: SignedResourceId,\n    ops: SynchronizedTreeOps,\n    logger?: MiLogger,\n  ) {\n    const tree = new SynchronizedTreeState(pl, root, ops, logger);\n\n    const stat = ops.logStat ? initialTreeLoadingStat() : undefined;\n\n    let ok = false;\n\n    try {\n      await tree.refresh(stat, {\n        timeout: ops.initialTreeLoadingTimeout,\n      });\n      ok = true;\n    } finally {\n      // logging stats if we were asked to (even if error occured)\n      if (stat && logger)\n        logger.info(\n          `Tree stat (initial load, ${ok ? \"success\" : \"failure\"}): ${JSON.stringify(stat)}`,\n        );\n    }\n\n    return tree;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"synchronized_tree.js","names":[],"sources":["../src/synchronized_tree.ts"],"sourcesContent":["import { PollingComputableHooks } from \"@milaboratories/computable\";\nimport { PlTreeEntry, PlTreeRootsEntry } from \"./accessors\";\nimport type {\n  FinalResourceDataPredicate,\n  PlClient,\n  ResourceType,\n  SignedResourceId,\n  TxOps,\n} from \"@milaboratories/pl-client\";\nimport type { Filter } from \"@milaboratories/pl-client\";\nimport { isUnauthenticated, isTimeoutOrCancelError } from \"@milaboratories/pl-client\";\nimport type { ExtendedResourceData } from \"./state\";\nimport { PlTreeState, TreeStateUpdateError } from \"./state\";\nimport type { PruningFunction, TraversalMode, TreeLoadingStat } from \"./sync\";\nimport { constructTreeLoadingRequest, initialTreeLoadingStat, loadTreeState } from \"./sync\";\nimport * as tp from \"node:timers/promises\";\nimport type { MiLogger } from \"@milaboratories/ts-helpers\";\n\n/** Hard floor between consecutive tree-refresh calls.\n * Applies even when {@link scheduleOnNextState} has woken the loop early,\n * preventing tight polling loops during rapid state transitions. */\nconst MIN_POLLING_INTERVAL_MS = 100;\n\ntype StatLoggingMode = \"cumulative\" | \"per-request\";\n\nexport type SynchronizedTreeOps = {\n  /** Override final predicate from the PlClient */\n  finalPredicateOverride?: FinalResourceDataPredicate;\n\n  /** Pruning function for legacy fallback path. */\n  pruning?: PruningFunction;\n\n  /** ResourceTree field filter for modern backend path. */\n  fieldFilter?: Filter;\n\n  /** ResourceTree traversal stop rules for modern backend path. */\n  traverseStopRules?: Filter;\n\n  /** Interval after last sync to sleep before the next one */\n  pollingInterval: number;\n  /** For how long to continue polling after the last derived value access */\n  stopPollingDelay: number;\n\n  /** If one of the values, tree will log stats of each polling request */\n  logStat?: StatLoggingMode;\n\n  /** Timeout for initial tree loading. If not specified, will use default for RO tx from pl-client. */\n  initialTreeLoadingTimeout?: number;\n\n  /** Controls which tree-loading path to use.  Default `\"auto\"`. */\n  traversalMode?: TraversalMode;\n};\n\n/** An explicit resource to serve as a tree root. Several explicit seeds may be passed. */\nexport type ExplicitRootSeed = { kind: \"resource\"; root: SignedResourceId };\n\n/** Discovers, as roots, every resource of this type shared with the current user.\n *  Matched against SharedResource.resourceType by NAME (version optional/ignored). The\n *  discovered set is DYNAMIC — roots appear/disappear as grants are added/revoked/expire. */\nexport type SharedTypeSeed = { kind: \"shared\"; resourceType: ResourceType };\n\nexport type TreeSeed = ExplicitRootSeed | SharedTypeSeed;\n\n/** Normalizes the {@link SynchronizedTreeState.init} seed argument — a bare\n * {@link SignedResourceId}, a single {@link TreeSeed}, or an array — to `TreeSeed[]`, so\n * every existing single-root caller is unchanged. */\nfunction normalizeSeeds(seeds: SignedResourceId | TreeSeed | TreeSeed[]): TreeSeed[] {\n  if (Array.isArray(seeds)) return seeds;\n  if (typeof seeds === \"object\" && seeds !== null && \"kind\" in seeds) return [seeds];\n  // bare SignedResourceId\n  return [{ kind: \"resource\", root: seeds }];\n}\n\n/** How often, in main-loop iterations, a tree with shared-type seeds re-polls\n * ListUserResources to reconcile its discovered roots. 1 would mean every iteration.\n *\n * Discovery (a full ListUserResources stream) is far heavier than an ordinary incremental\n * refresh, so it must NOT run on every fast refresh tick. The refresh cadence is the tree's\n * `pollingInterval` floored by {@link MIN_POLLING_INTERVAL_MS} (~200ms-1s in practice — the\n * shared-seed discovery tree runs at the 200ms default). At N = 15 discovery fires roughly\n * every 15 × 200ms ≈ 3s, decoupling it from the fast refresh loop while keeping the latency\n * of noticing a new/removed share to a few seconds — acceptable for a human-driven share flow.\n *\n * Only trees with shared-type seeds gate on this; {@link discover} is a no-op for single-root\n * and explicit-seed trees (empty `sharedSeeds`), so the value never affects them. */\nconst DISCOVERY_EVERY_N_REFRESHES = 15;\n\ntype ScheduledRefresh = {\n  resolve: () => void;\n  reject: (err: any) => void;\n};\n\nexport class SynchronizedTreeState {\n  private readonly finalPredicate: FinalResourceDataPredicate;\n  private state: PlTreeState;\n  private readonly pollingInterval: number;\n  private readonly pruning?: PruningFunction;\n  private readonly fieldFilter?: Filter;\n  private readonly traverseStopRules?: Filter;\n  private readonly traversalMode: TraversalMode;\n  private readonly logStat?: StatLoggingMode;\n  private readonly hooks: PollingComputableHooks;\n  private readonly abortController = new AbortController();\n\n  /** Explicit-resource seeds: fixed roots, present from construction. */\n  private readonly explicitRoots: SignedResourceId[];\n  /** Shared-type seeds (discovered roots), if any. */\n  private readonly sharedSeeds: SharedTypeSeed[];\n  /** Roots discovered for shared-type seeds on the last discovery poll. */\n  private discoveredRoots: SignedResourceId[] = [];\n\n  private constructor(\n    private readonly pl: PlClient,\n    seeds: TreeSeed[],\n    ops: SynchronizedTreeOps,\n    private readonly logger?: MiLogger,\n  ) {\n    const {\n      finalPredicateOverride,\n      pruning,\n      fieldFilter,\n      traverseStopRules,\n      traversalMode,\n      pollingInterval,\n      stopPollingDelay,\n      logStat,\n    } = ops;\n    this.pruning = pruning;\n    this.fieldFilter = fieldFilter;\n    this.traverseStopRules = traverseStopRules;\n    this.traversalMode = traversalMode ?? \"auto\";\n    this.pollingInterval = pollingInterval;\n    this.finalPredicate = finalPredicateOverride ?? pl.finalPredicate;\n    this.logStat = logStat;\n\n    this.explicitRoots = seeds\n      .filter((s): s is ExplicitRootSeed => s.kind === \"resource\")\n      .map((s) => s.root);\n    this.sharedSeeds = seeds.filter((s): s is SharedTypeSeed => s.kind === \"shared\");\n\n    this.state = new PlTreeState(this.currentRootSet(), this.finalPredicate);\n    this.hooks = new PollingComputableHooks(\n      () => this.startUpdating(),\n      () => this.stopUpdating(),\n      { stopDebounce: stopPollingDelay },\n      (resolve, reject) => this.scheduleOnNextState(resolve, reject),\n    );\n  }\n\n  /** The current protected root set: explicit roots plus the latest discovered roots. */\n  private currentRootSet(): Set<SignedResourceId> {\n    return new Set([...this.explicitRoots, ...this.discoveredRoots]);\n  }\n\n  /** Resolves the single root for the backward-compatible single-root accessors, throwing\n   * if the tree does not have exactly one root (guards legacy callers against multi-root). */\n  private soleRoot(): SignedResourceId {\n    const roots = this.currentRootSet();\n    if (roots.size !== 1)\n      throw new Error(\n        `single-root accessor used on a tree with ${roots.size} roots; use rootsEntry() instead`,\n      );\n    return roots.values().next().value!;\n  }\n\n  /** @deprecated use \"entry\" instead */\n  public accessor(rid?: SignedResourceId): PlTreeEntry {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    return this.entry(rid);\n  }\n\n  /** Backward-compatible single-root entry. With no `rid` it returns the sole root's entry\n   * and THROWS if the tree has zero or more than one root. An explicit `rid` addresses any\n   * resource in the heap, as today. */\n  public entry(rid?: SignedResourceId): PlTreeEntry {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    return new PlTreeEntry(\n      { treeProvider: () => this.state, hooks: this.hooks },\n      rid ?? this.soleRoot(),\n    );\n  }\n\n  /** Reactive provider for the current root SET. Reading it inside a Computable tracks the\n   * set as a dependency, so the Computable recomputes when discovered roots appear/disappear. */\n  public rootsEntry(): PlTreeRootsEntry {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    return new PlTreeRootsEntry({ treeProvider: () => this.state, hooks: this.hooks });\n  }\n\n  /** Can be used to externally kick off the synchronization polling loop, and\n   * await for the first synchronization to happen. */\n  public async refreshState(): Promise<void> {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    await this.hooks.refreshState();\n  }\n\n  private currentLoopDelayInterrupt: AbortController | undefined = undefined;\n  private scheduledOnNextState: ScheduledRefresh[] = [];\n\n  /** Called from computable hooks when external observer asks for state refresh */\n  private scheduleOnNextState(resolve: () => void, reject: (err: any) => void): void {\n    if (this.terminated) reject(new Error(\"tree synchronization is terminated\"));\n    else {\n      this.scheduledOnNextState.push({ resolve, reject });\n      if (this.currentLoopDelayInterrupt) {\n        this.currentLoopDelayInterrupt.abort();\n        this.currentLoopDelayInterrupt = undefined;\n      }\n    }\n  }\n\n  /** Called from observer */\n  private startUpdating(): void {\n    if (this.terminated) return;\n    this.keepRunning = true;\n    if (this.currentLoop === undefined) this.currentLoop = this.mainLoop();\n  }\n\n  /** Called from observer */\n  private stopUpdating(): void {\n    this.keepRunning = false;\n  }\n\n  /** If true, main loop will continue polling pl state. */\n  private keepRunning = false;\n  /** Actual state of main loop. */\n  private currentLoop: Promise<void> | undefined = undefined;\n\n  /** Executed from the main loop, and initialization procedure. */\n  private async refresh(stats?: TreeLoadingStat, txOps?: TxOps): Promise<void> {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    try {\n      await this.loadAndApply(stats, txOps);\n    } catch (e) {\n      // Discovery-tree self-heal: a discovered root whose grant was revoked/expired fails the whole\n      // ResourceTree poll with Unauthenticated. Re-discover (drops dead roots) and retry once. This is\n      // self-discriminating — a genuinely dead session also fails discover()'s own call, so real auth\n      // loss still propagates. Only for discovery trees; explicit-root trees propagate as-is.\n      if (this.sharedSeeds.length > 0 && isUnauthenticated(e)) {\n        this.logger?.warn(\n          \"discovery tree: Unauthenticated on ResourceTree (likely revoked/expired root); re-discovering and retrying\",\n        );\n        await this.discover();\n        await this.loadAndApply(stats, txOps);\n      } else throw e;\n    }\n  }\n\n  private async loadAndApply(stats?: TreeLoadingStat, txOps?: TxOps): Promise<void> {\n    const request = constructTreeLoadingRequest(this.state, {\n      pruningFunction: this.pruning,\n      fieldFilter: this.fieldFilter,\n      traverseStopRules: this.traverseStopRules,\n    });\n    // A shared-type-seed tree with no currently-discovered roots is legitimately empty:\n    // there is nothing to traverse, and tx.resourceTree([]) would throw \"at least one seed\n    // must be provided\". Skip the backend load and leave the (empty) state as-is — discovery\n    // adds roots later via setRoots(), which schedules the next refresh. Explicit-root trees\n    // never hit this (their root set is non-empty by construction).\n    if (request.seedResources.length === 0 && request.finalResources.size === 0) return;\n    const data = await this.pl.withReadTx(\n      \"ReadingTree\",\n      async (tx) => {\n        return await loadTreeState(\n          tx,\n          request,\n          stats,\n          this.pl.serverInfo.capabilities ?? [],\n          this.traversalMode,\n          this.logger,\n        );\n      },\n      txOps,\n    );\n    this.state.updateFromResourceData(data, true);\n  }\n\n  /** Discovery sync for shared-type seeds: re-polls `ListUserResources` (gRPC-only) and\n   * reconciles the discovered root set against the heap. A longer poll result adds roots; a\n   * shorter one removes them (grant revoked/expired) — the removed roots' subtrees cascade\n   * to collection via the ordinary refcount GC ({@link PlTreeState.setRoots}). No-op when the\n   * tree has no shared-type seeds, or silently no-op on a REST client where `ListUserResources`\n   * is unavailable. */\n  private async discover(): Promise<void> {\n    if (this.terminated) throw new Error(\"tree synchronization is terminated\");\n    if (this.sharedSeeds.length === 0) return;\n\n    const discovered = new Set<SignedResourceId>();\n    for (const seed of this.sharedSeeds) {\n      // match by name only (permissive; ignores version, so it survives schema bumps)\n      const ids = await this.pl.userResources.listSharedResourcesByType(seed.resourceType.name);\n      for (const id of ids) discovered.add(id);\n    }\n\n    this.discoveredRoots = [...discovered];\n    this.state.setRoots(this.currentRootSet());\n  }\n\n  /** If true this tree state is permanently terminaed. */\n  private terminated = false;\n\n  private async mainLoop() {\n    // will hold request stats\n    let stat = this.logStat ? initialTreeLoadingStat() : undefined;\n\n    let lastUpdate = Date.now();\n\n    // counts refresh iterations to pace the discovery poll for shared-type seeds.\n    let iteration = 0;\n\n    while (true) {\n      if (!this.keepRunning || this.terminated) break;\n\n      // saving those who want to be notified about new state here\n      // because those who will be added during the tree retrieval\n      // should be notified only on the next round\n      let toNotify: ScheduledRefresh[] | undefined = undefined;\n      if (this.scheduledOnNextState.length > 0) {\n        toNotify = this.scheduledOnNextState;\n        this.scheduledOnNextState = [];\n      }\n\n      try {\n        // resetting stats if we were asked to collect non-cumulative stats\n        if (this.logStat === \"per-request\") stat = initialTreeLoadingStat();\n\n        // discovery sync for shared-type seeds: reconcile the discovered root set before\n        // refreshing, so newly discovered roots are materialized in this same iteration.\n        if (this.sharedSeeds.length > 0 && iteration % DISCOVERY_EVERY_N_REFRESHES === 0) {\n          await this.discover();\n        }\n        iteration++;\n\n        // actual tree synchronization\n        await this.refresh(stat);\n\n        // logging stats if we were asked to\n        if (stat && this.logger)\n          this.logger.info(\n            `Tree stat (success, after ${Date.now() - lastUpdate}ms): ${JSON.stringify(stat)}`,\n          );\n        lastUpdate = Date.now();\n\n        // notifying that we got new state\n        if (toNotify !== undefined) for (const n of toNotify) n.resolve();\n      } catch (e: any) {\n        // logging stats if we were asked to (even if error occured)\n        if (stat && this.logger)\n          this.logger.info(\n            `Tree stat (error, after ${Date.now() - lastUpdate}ms): ${JSON.stringify(stat)}`,\n          );\n        lastUpdate = Date.now();\n\n        // notifying that we failed to refresh the state\n        if (toNotify !== undefined) for (const n of toNotify) n.reject(e);\n\n        // catching tree update errors, as they may leave our tree in inconsistent state\n        if (e instanceof TreeStateUpdateError) {\n          // important error logging, this should never happen\n          this.logger?.error(e);\n\n          // marking everybody who used previous state as changed\n          this.state.invalidateTree(\"stat update error\");\n          // creating new tree with the full current root set (re-discovered on next iteration)\n          this.state = new PlTreeState(this.currentRootSet(), this.finalPredicate);\n\n          // scheduling state update without delay\n          continue;\n\n          // unfortunately external observer may still see tree in its default\n          // empty state, though this is best we can do in this exceptional\n          // situation, and hope on caching layers inside computables to present\n          // some stale state until we reconstruct the tree again\n        } else this.logger?.warn(e);\n      }\n\n      if (!this.keepRunning || this.terminated) break;\n\n      // Phase 1: mandatory floor — always wait at least MIN_POLLING_INTERVAL_MS.\n      // Not interruptible by scheduleOnNextState; only termination aborts it.\n      try {\n        await tp.setTimeout(MIN_POLLING_INTERVAL_MS, undefined, {\n          signal: this.abortController.signal,\n        });\n      } catch (e: unknown) {\n        if (!isTimeoutOrCancelError(e)) throw new Error(\"Unexpected error\", { cause: e });\n        if (this.abortController.signal.aborted) break;\n      }\n\n      if (!this.keepRunning || this.terminated) break;\n\n      // Phase 2: optional remainder up to pollingInterval — interruptible by\n      // scheduleOnNextState so that an external nudge wakes the loop promptly.\n      if (this.scheduledOnNextState.length === 0) {\n        const remaining = Math.max(0, this.pollingInterval - MIN_POLLING_INTERVAL_MS);\n        if (remaining > 0) {\n          try {\n            this.currentLoopDelayInterrupt = new AbortController();\n            await tp.setTimeout(remaining, undefined, {\n              signal: AbortSignal.any([\n                this.abortController.signal,\n                this.currentLoopDelayInterrupt.signal,\n              ]),\n            });\n          } catch (e: unknown) {\n            if (!isTimeoutOrCancelError(e)) throw new Error(\"Unexpected error\", { cause: e });\n            if (this.abortController.signal.aborted) break;\n            // Otherwise it was just the loop delay interrupt (scheduleOnNextState),\n            // continue to the next iteration\n          } finally {\n            this.currentLoopDelayInterrupt = undefined;\n          }\n        }\n      }\n    }\n\n    // reset only as a very last line\n    this.currentLoop = undefined;\n  }\n\n  /**\n   * Dumps the current state of the tree.\n   * @returns An array of ExtendedResourceData objects representing the current state of the tree.\n   */\n  public dumpState(): ExtendedResourceData[] {\n    return this.state.dumpState();\n  }\n\n  /**\n   * Terminates the internal loop, and permanently destoys all internal state, so\n   * all computables using this state will resolve to errors.\n   * */\n  public async terminate(): Promise<void> {\n    this.keepRunning = false;\n    this.terminated = true;\n    this.abortController.abort();\n\n    if (this.currentLoop === undefined) return;\n    await this.currentLoop;\n\n    this.state.invalidateTree(\"synchronization terminated for the tree\");\n  }\n\n  /** @deprecated */\n  public async awaitSyncLoopTermination(): Promise<void> {\n    if (this.currentLoop === undefined) return;\n    await this.currentLoop;\n  }\n\n  /**\n   * Initializes a synchronized tree from one or more seeds.\n   *\n   * @param seeds a bare {@link SignedResourceId} (the original single-root contract), a\n   *   single {@link TreeSeed}, or an array of seeds. Bare ids and explicit-resource seeds\n   *   become roots immediately; shared-type seeds discover their roots via `ListUserResources`.\n   */\n  public static async init(\n    pl: PlClient,\n    seeds: SignedResourceId | TreeSeed | TreeSeed[],\n    ops: SynchronizedTreeOps,\n    logger?: MiLogger,\n  ) {\n    const tree = new SynchronizedTreeState(pl, normalizeSeeds(seeds), ops, logger);\n\n    const stat = ops.logStat ? initialTreeLoadingStat() : undefined;\n\n    let ok = false;\n\n    try {\n      // resolve shared-type seeds before the first refresh so discovered roots load now\n      await tree.discover();\n      await tree.refresh(stat, {\n        timeout: ops.initialTreeLoadingTimeout,\n      });\n      ok = true;\n    } finally {\n      // logging stats if we were asked to (even if error occured)\n      if (stat && logger)\n        logger.info(\n          `Tree stat (initial load, ${ok ? \"success\" : \"failure\"}): ${JSON.stringify(stat)}`,\n        );\n    }\n\n    return tree;\n  }\n}\n"],"mappings":"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"}

package/dist/traversal_ops.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traversal_ops.d.ts","names":[],"sources":["../src/traversal_ops.ts"],"mappings":";;;KAEY,kBAAA;;AAAZ;;;;;EAOE,WAAA;AAAA;AAAA,KAGU,sBAAA;EAAsB;;;;;EAMhC,qBAAA,YAYU;EATV,gBAAA;;;;;EAMA,yBAAA;AAAA;AAAA,KAGU,oBAAA,GAAuB,kBAAA;EAKjC;;;;EAAA,kBAAA,GAAqB,YAAA,GAAe,YAAA;AAAA;AAAA,KAG1B,YAAA,GAAe,sBAAA;mBAEzB,KAAA,UAFyB;EAKzB,oBAAA;EAGA,kBAAA;EAMA;;;;EAAA,eAAA,GAAkB,SAAA;AAAA;AAAA,KAGR,kBAAA,GAAqB,YAAA,GAAe,oBAAA"}
+{"version":3,"file":"traversal_ops.d.ts","names":[],"sources":["../src/traversal_ops.ts"],"mappings":";;;KAEY,kBAAA;;AAAZ;;;;AAOa;EAAX,WAAW;AAAA;AAAA,KAGD,sBAAA;EAAsB;;;;;EAMhC,qBAAA,YAYU;EATV,gBAAA;;;;;EAMA,yBAAA;AAAA;AAAA,KAGU,oBAAA,GAAuB,kBAAA;EAKjC;;;;EAAA,kBAAA,GAAqB,YAAA,GAAe,YAAA;AAAA;AAAA,KAG1B,YAAA,GAAe,sBAAA;mBAEzB,KAAA,UAFyB;EAKzB,oBAAA;EAGA,kBAAA;EAMA;;;AAA2B;EAA3B,eAAA,GAAkB,SAAS;AAAA;AAAA,KAGjB,kBAAA,GAAqB,YAAA,GAAe,oBAAoB"}

package/dist/value_and_error.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"value_and_error.cjs","names":[],"sources":["../src/value_and_error.ts"],"sourcesContent":["export interface ValueAndError<T> {\n  value?: T;\n  error?: T;\n}\n\nexport function mapValueAndErrorIfDefined<T1, T2>(\n  input: ValueAndError<T1> | undefined,\n  mapping: (v: T1) => T2,\n): ValueAndError<T2> | undefined {\n  if (input === undefined) return undefined;\n  else return mapValueAndError(input, mapping);\n}\n\nexport function mapValueAndError<T1, T2>(input: ValueAndError<T1>, mapping: (v: T1) => T2) {\n  const ret = {} as ValueAndError<T2>;\n  if (input.value !== undefined) ret.value = mapping(input.value);\n  if (input.error !== undefined) ret.error = mapping(input.error);\n  return ret;\n}\n"],"mappings":";AAKA,SAAgB,0BACd,OACA,SAC+B;AAC/B,KAAI,UAAU,KAAA,EAAW,QAAO,KAAA;KAC3B,QAAO,iBAAiB,OAAO,QAAQ;;AAG9C,SAAgB,iBAAyB,OAA0B,SAAwB;CACzF,MAAM,MAAM,EAAE;AACd,KAAI,MAAM,UAAU,KAAA,EAAW,KAAI,QAAQ,QAAQ,MAAM,MAAM;AAC/D,KAAI,MAAM,UAAU,KAAA,EAAW,KAAI,QAAQ,QAAQ,MAAM,MAAM;AAC/D,QAAO"}
+{"version":3,"file":"value_and_error.cjs","names":[],"sources":["../src/value_and_error.ts"],"sourcesContent":["export interface ValueAndError<T> {\n  value?: T;\n  error?: T;\n}\n\nexport function mapValueAndErrorIfDefined<T1, T2>(\n  input: ValueAndError<T1> | undefined,\n  mapping: (v: T1) => T2,\n): ValueAndError<T2> | undefined {\n  if (input === undefined) return undefined;\n  else return mapValueAndError(input, mapping);\n}\n\nexport function mapValueAndError<T1, T2>(input: ValueAndError<T1>, mapping: (v: T1) => T2) {\n  const ret = {} as ValueAndError<T2>;\n  if (input.value !== undefined) ret.value = mapping(input.value);\n  if (input.error !== undefined) ret.error = mapping(input.error);\n  return ret;\n}\n"],"mappings":";AAKA,SAAgB,0BACd,OACA,SAC+B;CAC/B,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;MAC3B,OAAO,iBAAiB,OAAO,OAAO;AAC7C;AAEA,SAAgB,iBAAyB,OAA0B,SAAwB;CACzF,MAAM,MAAM,CAAC;CACb,IAAI,MAAM,UAAU,KAAA,GAAW,IAAI,QAAQ,QAAQ,MAAM,KAAK;CAC9D,IAAI,MAAM,UAAU,KAAA,GAAW,IAAI,QAAQ,QAAQ,MAAM,KAAK;CAC9D,OAAO;AACT"}

package/dist/value_and_error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value_and_error.d.ts","names":[],"sources":["../src/value_and_error.ts"],"mappings":";UAAiB,aAAA;EACf,KAAA,GAAQ,CAAA;EACR,KAAA,GAAQ,CAAA;AAAA;AAAA,iBAGM,yBAAA,QAAA,CACd,KAAA,EAAO,aAAA,CAAc,EAAA,eACrB,OAAA,GAAU,CAAA,EAAG,EAAA,KAAO,EAAA,GACnB,aAAA,CAAc,EAAA;AAAA,iBAKD,gBAAA,QAAA,CAAyB,KAAA,EAAO,aAAA,CAAc,EAAA,GAAK,OAAA,GAAU,CAAA,EAAG,EAAA,KAAO,EAAA,GAAE,aAAA,CAAA,EAAA"}
+{"version":3,"file":"value_and_error.d.ts","names":[],"sources":["../src/value_and_error.ts"],"mappings":";UAAiB,aAAA;EACf,KAAA,GAAQ,CAAA;EACR,KAAA,GAAQ,CAAC;AAAA;AAAA,iBAGK,yBAAA,SACd,KAAA,EAAO,aAAA,CAAc,EAAA,eACrB,OAAA,GAAU,CAAA,EAAG,EAAA,KAAO,EAAA,GACnB,aAAA,CAAc,EAAA;AAAA,iBAKD,gBAAA,SAAyB,KAAA,EAAO,aAAA,CAAc,EAAA,GAAK,OAAA,GAAU,CAAA,EAAG,EAAA,KAAO,EAAA,GAAE,aAAA,CAAA,EAAA"}

package/dist/value_and_error.js.map

@@ -1 +1 @@
-{"version":3,"file":"value_and_error.js","names":[],"sources":["../src/value_and_error.ts"],"sourcesContent":["export interface ValueAndError<T> {\n  value?: T;\n  error?: T;\n}\n\nexport function mapValueAndErrorIfDefined<T1, T2>(\n  input: ValueAndError<T1> | undefined,\n  mapping: (v: T1) => T2,\n): ValueAndError<T2> | undefined {\n  if (input === undefined) return undefined;\n  else return mapValueAndError(input, mapping);\n}\n\nexport function mapValueAndError<T1, T2>(input: ValueAndError<T1>, mapping: (v: T1) => T2) {\n  const ret = {} as ValueAndError<T2>;\n  if (input.value !== undefined) ret.value = mapping(input.value);\n  if (input.error !== undefined) ret.error = mapping(input.error);\n  return ret;\n}\n"],"mappings":";AAKA,SAAgB,0BACd,OACA,SAC+B;AAC/B,KAAI,UAAU,KAAA,EAAW,QAAO,KAAA;KAC3B,QAAO,iBAAiB,OAAO,QAAQ;;AAG9C,SAAgB,iBAAyB,OAA0B,SAAwB;CACzF,MAAM,MAAM,EAAE;AACd,KAAI,MAAM,UAAU,KAAA,EAAW,KAAI,QAAQ,QAAQ,MAAM,MAAM;AAC/D,KAAI,MAAM,UAAU,KAAA,EAAW,KAAI,QAAQ,QAAQ,MAAM,MAAM;AAC/D,QAAO"}
+{"version":3,"file":"value_and_error.js","names":[],"sources":["../src/value_and_error.ts"],"sourcesContent":["export interface ValueAndError<T> {\n  value?: T;\n  error?: T;\n}\n\nexport function mapValueAndErrorIfDefined<T1, T2>(\n  input: ValueAndError<T1> | undefined,\n  mapping: (v: T1) => T2,\n): ValueAndError<T2> | undefined {\n  if (input === undefined) return undefined;\n  else return mapValueAndError(input, mapping);\n}\n\nexport function mapValueAndError<T1, T2>(input: ValueAndError<T1>, mapping: (v: T1) => T2) {\n  const ret = {} as ValueAndError<T2>;\n  if (input.value !== undefined) ret.value = mapping(input.value);\n  if (input.error !== undefined) ret.error = mapping(input.error);\n  return ret;\n}\n"],"mappings":";AAKA,SAAgB,0BACd,OACA,SAC+B;CAC/B,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;MAC3B,OAAO,iBAAiB,OAAO,OAAO;AAC7C;AAEA,SAAgB,iBAAyB,OAA0B,SAAwB;CACzF,MAAM,MAAM,CAAC;CACb,IAAI,MAAM,UAAU,KAAA,GAAW,IAAI,QAAQ,QAAQ,MAAM,KAAK;CAC9D,IAAI,MAAM,UAAU,KAAA,GAAW,IAAI,QAAQ,QAAQ,MAAM,KAAK;CAC9D,OAAO;AACT"}

package/dist/value_or_error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"value_or_error.d.ts","names":[],"sources":["../src/value_or_error.ts"],"mappings":";KAAY,YAAA;EAEN,EAAA;EACA,KAAA,EAAO,CAAA;AAAA;EAGP,EAAA;EACA,KAAA,EAAO,CAAA;AAAA"}
+{"version":3,"file":"value_or_error.d.ts","names":[],"sources":["../src/value_or_error.ts"],"mappings":";KAAY,YAAA;EAEN,EAAA;EACA,KAAA,EAAO,CAAA;AAAA;EAGP,EAAA;EACA,KAAA,EAAO,CAAC;AAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-tree",
-  "version": "1.12.13",
+  "version": "1.12.15",
   "description": "Reactive pl tree state",
   "files": [
     "./dist/**/*",
@@ -21,10 +21,10 @@
     "denque": "^2.1.0",
     "utility-types": "^3.11.0",
     "zod": "~3.25.76",
+    "@milaboratories/ts-helpers": "1.8.3",
+    "@milaboratories/pl-client": "3.12.1",
     "@milaboratories/computable": "2.9.5",
-    "@milaboratories/pl-errors": "1.4.23",
-    "@milaboratories/pl-client": "3.11.5",
-    "@milaboratories/ts-helpers": "1.8.3"
+    "@milaboratories/pl-errors": "1.4.25"
   },
   "devDependencies": {
     "@types/node": "~24.5.2",
@@ -32,8 +32,8 @@
     "typescript": "~5.9.3",
     "vitest": "^4.1.3",
     "@milaboratories/build-configs": "2.0.0",
-    "@milaboratories/ts-configs": "1.2.3",
-    "@milaboratories/ts-builder": "1.5.2"
+    "@milaboratories/ts-builder": "1.6.0",
+    "@milaboratories/ts-configs": "1.3.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/src/accessors.ts

@@ -442,3 +442,82 @@ export class PlTreeNodeAccessor {
     return new PlTreeEntry(this.accessorData, this.resource.id);
   }
 }
+
+/** Reactive provider for the current root SET of a multi-root tree. Mirrors {@link PlTreeEntry}:
+ * reading it inside a Computable tracks the root set as a dependency, so the Computable
+ * recomputes when discovered roots appear or disappear. */
+export class PlTreeRootsEntry implements AccessorProvider<PlTreeRootsAccessor> {
+  private readonly __pl_tree_type_marker__ = "PlTreeRootsEntry";
+
+  constructor(private readonly accessorData: TreeAccessorData) {}
+
+  public createAccessor(ctx: ComputableCtx, guard: UsageGuard): PlTreeRootsAccessor {
+    return new PlTreeRootsAccessor(this.accessorData, this.accessorData.treeProvider(), {
+      ctx,
+      guard,
+    });
+  }
+
+  public toJSON(): string {
+    return "[ROOTS-ENTRY]";
+  }
+
+  public toString(): string {
+    return "[ROOTS-ENTRY]";
+  }
+}
+
+export function isPlTreeRootsEntry(obj: unknown): obj is PlTreeRootsEntry {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    (obj as any)["__pl_tree_type_marker__"] === "PlTreeRootsEntry"
+  );
+}
+
+/** Accessor over the current roots of a multi-root tree. Reading any of its methods tracks
+ * the root set as a dependency (via {@link PlTreeState.getRoots}). */
+export class PlTreeRootsAccessor {
+  private readonly __pl_tree_type_marker__ = "PlTreeRootsAccessor";
+
+  constructor(
+    private readonly accessorData: TreeAccessorData,
+    private readonly tree: PlTreeState,
+    private readonly instanceData: TreeAccessorInstanceData,
+  ) {}
+
+  /** Current root ids. */
+  public rootIds(): SignedResourceId[] {
+    this.instanceData.guard();
+    return this.tree.getRoots(this.instanceData.ctx.watcher);
+  }
+
+  /** Current roots as node accessors, ready to traverse. */
+  public nodes(ops: ResourceTraversalOps = {}): PlTreeNodeAccessor[] {
+    this.instanceData.guard();
+
+    // mirror PlTreeEntryAccessor.node(): attach polling hooks on first node acquisition
+    if (this.accessorData.hooks !== undefined)
+      this.instanceData.ctx.attacheHooks(this.accessorData.hooks);
+
+    return this.tree
+      .getRoots(this.instanceData.ctx.watcher)
+      .map((rid) => getResourceFromTree(this.accessorData, this.tree, this.instanceData, rid, ops));
+  }
+
+  /** Current roots as entries, for persisting per-root sub-Computables. */
+  public entries(): PlTreeEntry[] {
+    this.instanceData.guard();
+    return this.tree
+      .getRoots(this.instanceData.ctx.watcher)
+      .map((rid) => new PlTreeEntry(this.accessorData, rid));
+  }
+}
+
+export function isPlTreeRootsAccessor(obj: unknown): obj is PlTreeRootsAccessor {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    (obj as any)["__pl_tree_type_marker__"] === "PlTreeRootsAccessor"
+  );
+}

package/src/state.ts

@@ -389,16 +389,38 @@ export class PlTreeState {
   /** resource heap */
   private resources: Map<SignedResourceId, PlTreeResource> = new Map();
   private readonly resourcesAdded = new ChangeSource();
+  /** Marked when the root set changes (roots discovered or removed), so multi-root
+   * accessors that read the set recompute. */
+  private readonly rootsChanged = new ChangeSource();
   /** Resets to false if any invalid state transitions are registered,
    * after that tree will produce errors for any read or write operations */
   private _isValid: boolean = true;
   private invalidationMessage?: string;
 
+  /** The set of roots — resources protected from GC. Originally a single `root`,
+   * generalized to a set so several explicit roots and dynamically-discovered shared
+   * roots can coexist in one heap. Mutated through {@link setRoots}. */
+  public readonly roots: Set<SignedResourceId>;
+
   constructor(
-    /** This will be the only resource not deleted during GC round */
-    public readonly root: SignedResourceId,
+    /** Resources protected from GC. Accepts a single id (single-root, the original
+     * contract) or a set of ids (multi-root). */
+    roots: SignedResourceId | Set<SignedResourceId>,
     public readonly isFinalPredicate: FinalResourceDataPredicate,
-  ) {}
+  ) {
+    this.roots = roots instanceof Set ? new Set(roots) : new Set([roots]);
+  }
+
+  /** Backward-compatible single-root accessor. Returns the sole root and THROWS if the
+   * tree has zero or more than one root, so a multi-root tree can never be read as if it
+   * had one. Mirrors the {@link entry} guard. */
+  public get root(): SignedResourceId {
+    if (this.roots.size !== 1)
+      throw new Error(
+        `single-root accessor used on a tree with ${this.roots.size} roots; use the multi-root API`,
+      );
+    return this.roots.values().next().value!;
+  }
 
   public forEachResource(cb: (res: ResourceDataWithFinalState) => void): void {
     this.resources.forEach((v) => cb(v));
@@ -408,6 +430,14 @@ export class PlTreeState {
     if (!this._isValid) throw new Error(this.invalidationMessage ?? "tree is in invalid state");
   }
 
+  /** Reactive read of the current root set. Attaches the watcher to {@link rootsChanged}
+   * so a Computable recomputes when discovered roots appear or disappear. */
+  public getRoots(watcher: Watcher): SignedResourceId[] {
+    this.checkValid();
+    this.rootsChanged.attachWatcher(watcher);
+    return [...this.roots];
+  }
+
   public get(watcher: Watcher, rid: SignedResourceId): PlTreeResource {
     this.checkValid();
     const res = this.resources.get(rid);
@@ -739,6 +769,24 @@ export class PlTreeState {
     }
 
     // recursively applying refCount decrements / doing garbage collection
+    this.collectGarbage(decrementRefs);
+
+    // checking for orphans (maybe removed in the future)
+    if (!allowOrphanInputs) {
+      for (const rd of resourceData) {
+        if (!this.resources.has(rd.id)) {
+          this.invalidateTree();
+          throw new TreeStateUpdateError(`orphan input resource ${rd.id}`);
+        }
+      }
+    }
+  }
+
+  /** Runs the refcount-decrement garbage-collection cascade over the given worklist.
+   * A resource reaching refCount 0 that is not a root is removed, and its outgoing
+   * references are decremented in turn, until the worklist drains. Factored out of
+   * {@link updateFromResourceData} so {@link setRoots} can reuse the same cascade. */
+  private collectGarbage(decrementRefs: SignedResourceId[]) {
     let currentRefs = decrementRefs;
     while (currentRefs.length > 0) {
       const nextRefs: SignedResourceId[] = [];
@@ -751,7 +799,7 @@ export class PlTreeState {
         res.refCount--;
 
         // garbage collection
-        if (res.refCount === 0 && res.id !== this.root) {
+        if (res.refCount === 0 && !this.roots.has(res.id)) {
           // removing fields
           res.fieldsMap.forEach((field) => {
             if (isNotNullSignedResourceId(field.value)) nextRefs.push(field.value);
@@ -769,15 +817,55 @@ export class PlTreeState {
       }
       currentRefs = nextRefs;
     }
+  }
 
-    // checking for orphans (maybe removed in the future)
-    if (!allowOrphanInputs) {
-      for (const rd of resourceData) {
-        if (!this.resources.has(rd.id)) {
-          this.invalidateTree();
-          throw new TreeStateUpdateError(`orphan input resource ${rd.id}`);
-        }
-      }
+  /** Replaces the current root set with `newRoots`.
+   *
+   * Roots that leave the set lose their GC protection: each removed root present in the
+   * heap is collected directly (a root sits at refCount 0, so it is never enqueued by an
+   * ordinary decrement), and its subtree cascades to collection through the existing
+   * refcount GC — the standard removal mechanic, applied to a root. Roots newly added to
+   * the set are protected immediately; their resources arrive on the next refresh poll. */
+  public setRoots(newRoots: Set<SignedResourceId>) {
+    this.checkValid();
+
+    const removed: SignedResourceId[] = [];
+    for (const rid of this.roots) if (!newRoots.has(rid)) removed.push(rid);
+    let added = false;
+    for (const rid of newRoots) if (!this.roots.has(rid)) added = true;
+    if (removed.length === 0 && !added) return; // no change
+
+    // commit the new protected set before collecting, so a removed root is no longer
+    // protected while its subtree cascades.
+    this.roots.clear();
+    for (const rid of newRoots) this.roots.add(rid);
+
+    this.rootsChanged.markChanged("root set changed");
+
+    for (const rid of removed) {
+      const res = this.resources.get(rid);
+      if (res === undefined) continue; // root not yet materialized in the heap
+
+      // if the (former) root is still referenced by another resource, dropping protection
+      // is enough — ordinary refcounting keeps it alive and will collect it later.
+      if (res.refCount > 0) continue;
+
+      // collect the (now-unprotected) root itself and seed the cascade with the refs it holds
+      const seed: SignedResourceId[] = [];
+      res.fieldsMap.forEach((field) => {
+        if (isNotNullSignedResourceId(field.value)) seed.push(field.value);
+        if (isNotNullSignedResourceId(field.error)) seed.push(field.error);
+        field.change.markChanged(
+          `field ${field.name} removed after root ${resourceIdToString(res.id)} left the root set`,
+        );
+      });
+      if (isNotNullSignedResourceId(res.error)) seed.push(res.error);
+      res.resourceRemoved.markChanged(
+        `resource removed after leaving the root set: ${resourceIdToString(res.id)}`,
+      );
+      this.resources.delete(rid);
+
+      this.collectGarbage(seed);
     }
   }
 
@@ -795,6 +883,7 @@ export class PlTreeState {
   public invalidateTree(msg?: string) {
     this._isValid = false;
     this.invalidationMessage = msg;
+    this.rootsChanged.markChanged("tree invalidated");
     this.resources.forEach((res) => {
       res.markAllChanged();
     });

package/src/sync.ts

@@ -52,13 +52,14 @@ export function constructTreeLoadingRequest(
 ): TreeLoadingRequest {
   const seedResources: SignedResourceId[] = [];
   const finalResources = new Set<SignedResourceId>();
+  const materialized = new Set<SignedResourceId>();
   tree.forEachResource((res) => {
+    materialized.add(res.id);
     if (res.finalState) finalResources.add(res.id);
     else seedResources.push(res.id);
   });
 
-  // if tree is empty, seeding tree reconstruction from the specified root
-  if (seedResources.length === 0 && finalResources.size === 0) seedResources.push(tree.root);
+  for (const root of tree.roots) if (!materialized.has(root)) seedResources.push(root);
 
   return {
     seedResources,