@milaboratories/pl-middle-layer 1.73.4 → 1.73.6

package/src/middle_layer/finality_stop_rules.test.ts

@@ -0,0 +1,386 @@
+import { describe, expect, test } from "vitest";
+import type { FieldData, Filter, FinalityEntry, ResourceData } from "@milaboratories/pl-client";
+import {
+  CacheFinality,
+  createSignedResourceId,
+  FilterOperatorType,
+  FilterProperty,
+  FinalityTable,
+  NullSignedResourceId,
+  ResourceTypeName,
+  ResourceTypePrefix,
+  StrictFinality,
+  TreeFinality,
+  treeFilter,
+} from "@milaboratories/pl-client";
+import { finalityStopRuleClause, finalityStopRules } from "./finality_stop_rules";
+
+import { projectTreeTraverseStopRules } from "./project";
+
+/** Expected clauses of the project tree's stop rules, listed independently of the table. */
+function expectedStopRules(): Filter {
+  return treeFilter.or(
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.StreamManager),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.StdMap),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.StdMapSlash),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.EphStdMap),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.PFrame),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.ParquetChunk),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.BContext),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.BlockPackCustom),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.BinaryMap),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.BinaryValue),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.BlobMap),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.BResolveSingleNoResult),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.BQueryResult),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.TengoTemplate),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.TengoLib),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.SoftwareInfo),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeEq(ResourceTypeName.Dummy),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonResourceError),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonObject),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonGzObject),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonString),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonArray),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonNumber),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonBool),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonNull),
+    treeFilter.resourceTypeEq(ResourceTypeName.JsonErrorTrace),
+    treeFilter.resourceTypeEq(ResourceTypeName.BContextEnd),
+    treeFilter.resourceTypeEq(ResourceTypeName.FrontendFromUrl),
+    treeFilter.resourceTypeEq(ResourceTypeName.FrontendFromFolder),
+    treeFilter.resourceTypeEq(ResourceTypeName.FrontendFromLocalTgz),
+    treeFilter.resourceTypeEq(ResourceTypeName.BObjectSpec),
+    treeFilter.resourceTypeEq(ResourceTypeName.Blob),
+    treeFilter.resourceTypeEq(ResourceTypeName.Null),
+    treeFilter.resourceTypeEq(ResourceTypeName.Binary),
+    treeFilter.resourceTypeEq(ResourceTypeName.WorkingDirectory),
+    treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.Blob),
+    treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.LS),
+    treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.WorkingDirectory),
+    treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.StorageSpaceAllocation),
+    treeFilter.and(
+      treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.BlobUpload),
+      treeFilter.readyOrDuplicateOrError(),
+      treeFilter.outputsLocked(true),
+      treeFilter.allOutputsFinal(true),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.BlobIndex),
+      treeFilter.readyOrDuplicateOrError(),
+      treeFilter.outputsLocked(true),
+      treeFilter.allOutputsFinal(true),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.PColumnData),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+    treeFilter.and(
+      treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.StreamWorkdir),
+      treeFilter.readyOrDuplicateOrError(),
+    ),
+  );
+}
+
+function clauses(f: Filter): string[] {
+  if (f.value.oneofKind !== "filtersValue") throw new Error("expected a group filter");
+  return f.value.filtersValue.filters.map((c) => JSON.stringify(c)).sort();
+}
+
+describe("the project tree's stop rules come from TreeFinality", () => {
+  test("project stop rules contain the declared clause of every built-in type", () => {
+    const resolverAndCopyClauses = [
+      treeFilter.and(
+        treeFilter.resourceTypeEq(ResourceTypeName.BResolveSingle),
+        treeFilter.readyOrDuplicateOrError(),
+        treeFilter.outputsLocked(true),
+        treeFilter.allOutputsFinal(true),
+      ),
+      treeFilter.and(
+        treeFilter.resourceTypeEq(ResourceTypeName.BResolveChoice),
+        treeFilter.readyOrDuplicateOrError(),
+        treeFilter.outputsLocked(true),
+        treeFilter.allOutputsFinal(true),
+      ),
+      treeFilter.and(
+        treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.BlobCopy),
+        treeFilter.readyOrDuplicateOrError(),
+        treeFilter.outputsLocked(true),
+        treeFilter.allOutputsFinal(true),
+      ),
+    ];
+    const expected = [
+      ...clauses(expectedStopRules()),
+      ...resolverAndCopyClauses.map((c) => JSON.stringify(c)),
+    ];
+    expect(clauses(projectTreeTraverseStopRules())).toEqual(expected.sort());
+  });
+
+  test("an entry that is never final sends no stop rule", () => {
+    for (const e of TreeFinality.entries)
+      if (e.rule === "never") expect(finalityStopRuleClause(e)).toBeUndefined();
+  });
+
+  test("an approximated entry stops on its declared condition", () => {
+    const exact = TreeFinality.entries.find((e) => e.rule === "readyAndAllOutputsFilled");
+    expect(exact).toBeDefined();
+    const match = exact!.match;
+    expect(finalityStopRuleClause(exact!)).toEqual(
+      treeFilter.and(
+        "name" in match
+          ? treeFilter.resourceTypeEq(match.name)
+          : treeFilter.resourceTypeMatch("^" + match.prefix),
+        treeFilter.readyOrDuplicateOrError(),
+        treeFilter.outputsLocked(true),
+        treeFilter.allOutputsFinal(true),
+      ),
+    );
+  });
+
+  test("a prefix is matched literally", () => {
+    const f = finalityStopRules(
+      TreeFinality.extend("probe", [{ match: { prefix: "A.B/" }, rule: "always", why: "test" }]),
+    );
+    expect(JSON.stringify(f)).toContain(JSON.stringify("^A\\.B/"));
+  });
+});
+
+const target = createSignedResourceId(201n);
+const failure = createSignedResourceId(202n);
+function field(patch: Partial<FieldData> = {}): FieldData {
+  return {
+    name: "result",
+    type: "Output",
+    status: "Resolved",
+    value: target,
+    error: NullSignedResourceId,
+    valueIsFinal: true,
+    ...patch,
+  };
+}
+function resource(name: string, patch: Partial<ResourceData> = {}): ResourceData {
+  return {
+    id: createSignedResourceId(203n),
+    type: { name, version: "1" },
+    kind: "Structural",
+    data: undefined,
+    originalResourceId: NullSignedResourceId,
+    error: NullSignedResourceId,
+    inputsLocked: true,
+    outputsLocked: true,
+    resourceReady: true,
+    final: false,
+    fields: [field()],
+    ...patch,
+  };
+}
+function nameOf(e: FinalityEntry): string {
+  return "name" in e.match ? e.match.name : e.match.prefix + "probe";
+}
+
+/** A stop rule evaluated the way the backend does (core/pl tx_tree_iterator.go,
+ * evalTraverseStopRules): ALL_OUTPUTS_FINAL holds when every retained field has an error or a final
+ * value; HAS_ERRORS holds when the resource or any of its fields has an error. */
+function evaluate(f: Filter, r: ResourceData): boolean {
+  if (f.value.oneofKind === "filtersValue") {
+    const children = f.value.filtersValue.filters;
+    if (f.operator === FilterOperatorType.AND) return children.every((c) => evaluate(c, r));
+    if (f.operator === FilterOperatorType.OR) return children.some((c) => evaluate(c, r));
+    if (f.operator === FilterOperatorType.NOT) return !evaluate(children[0]!, r);
+  }
+  if (f.value.oneofKind === "stringValue" && f.key === FilterProperty.RESOURCE_TYPE) {
+    if (f.operator === FilterOperatorType.EQUAL) return r.type.name === f.value.stringValue;
+    if (f.operator === FilterOperatorType.MATCH)
+      return new RegExp(f.value.stringValue).test(r.type.name);
+  }
+  if (f.value.oneofKind === "boolValue" && f.operator === FilterOperatorType.EQUAL) {
+    let actual: boolean;
+    switch (f.key) {
+      case FilterProperty.RESOURCE_READY_FOR_CALCULATION:
+        actual = r.resourceReady;
+        break;
+      case FilterProperty.IS_DUPLICATE:
+        actual = r.originalResourceId !== NullSignedResourceId;
+        break;
+      case FilterProperty.HAS_ERRORS:
+        actual =
+          r.error !== NullSignedResourceId ||
+          r.fields.some((v) => v.error !== NullSignedResourceId);
+        break;
+      case FilterProperty.OUTPUTS_LOCKED:
+        actual = r.outputsLocked;
+        break;
+      case FilterProperty.ALL_OUTPUTS_FINAL:
+        actual = r.fields.every((v) => v.error !== NullSignedResourceId || v.valueIsFinal);
+        break;
+      default:
+        throw new Error(`unhandled boolean property ${f.key}`);
+    }
+    return actual === f.value.boolValue;
+  }
+  throw new Error(`unhandled filter ${JSON.stringify(f)}`);
+}
+
+test("an entry declared exact stops exactly where its predicate is final", () => {
+  const rules = finalityStopRules(TreeFinality);
+  const approximateNames = new Set(
+    TreeFinality.entries
+      .filter((e) => e.stopRule !== undefined && e.stopRule !== "exact")
+      .map(nameOf),
+  );
+  const names = [
+    ...new Set(
+      TreeFinality.entries.flatMap((e) =>
+        "name" in e.match
+          ? [e.match.name]
+          : [e.match.prefix, e.match.prefix + "probe", e.match.prefix + "BlobCopy/nested"],
+      ),
+    ),
+  ];
+  for (const name of names) {
+    if (approximateNames.has(name)) continue;
+    for (const version of ["", "1", "2"])
+      for (let bits = 0; bits < 16; bits++) {
+        for (const fields of [
+          [],
+          [field()],
+          [field({ valueIsFinal: false })],
+          [field({ value: NullSignedResourceId, valueIsFinal: false })],
+        ]) {
+          const r = resource(name, {
+            type: { name, version },
+            resourceReady: !!(bits & 1),
+            outputsLocked: !!(bits & 2),
+            originalResourceId: bits & 4 ? target : NullSignedResourceId,
+            error: bits & 8 ? failure : NullSignedResourceId,
+            fields,
+          });
+          expect(evaluate(rules, r), `${name}:${version}, state ${bits}`).toBe(
+            TreeFinality.isFinal(r),
+          );
+        }
+      }
+  }
+});
+
+test("an unresolved Service field keeps a resolver or copy from both the filter's stop and finality", () => {
+  const rules = finalityStopRules(TreeFinality);
+  for (const name of ["BResolveSingle", "BResolveChoice", "BlobCopy/aToB"]) {
+    const r = resource(name, {
+      fields: [
+        field(),
+        field({
+          name: "service",
+          type: "Service",
+          status: "Empty",
+          value: NullSignedResourceId,
+          valueIsFinal: false,
+        }),
+      ],
+    });
+    expect(TreeFinality.isFinal(r), name).toBe(false);
+    expect(evaluate(rules, r), name).toBe(false);
+  }
+});
+
+test("an error on a field alone: every ready-or-error clause stops early, as declared", () => {
+  for (const e of TreeFinality.entries) {
+    if (e.rule !== "readyOrDuplicateOrError" && e.rule !== "readyAndAllOutputsFilled") continue;
+    const name = nameOf(e);
+    expect(e.stopRule, name).toMatchObject({ approx: e.rule });
+    const r = resource(name, {
+      resourceReady: false,
+      fields: [
+        field(),
+        field({
+          name: "input",
+          type: "Input",
+          value: NullSignedResourceId,
+          valueIsFinal: false,
+          error: failure,
+        }),
+      ],
+    });
+    expect(TreeFinality.isFinal(r), name).toBe(false);
+    expect(evaluate(finalityStopRuleClause(e)!, r), name).toBe(true);
+  }
+});
+
+test("stop rules follow the layers: an inherited never neither hides nor revokes a child's entry", () => {
+  const table = FinalityTable.of("base", [
+    { match: { name: "A.B/child" }, rule: "never", why: "probe" },
+  ])
+    .extend("allow", [{ match: { prefix: "A.B/" }, rule: "always", why: "probe" }])
+    .extend("cannot revoke", [{ match: { prefix: "A.B/" }, rule: "never", why: "probe" }]);
+  const rules = finalityStopRules(table);
+  for (const name of ["A.B/child", "A.B/", "AXB/child", "A.B", "xA.B/child"]) {
+    const expected = name.startsWith("A.B/");
+    expect(table.isFinal(resource(name))).toBe(expected);
+    expect(evaluate(rules, resource(name))).toBe(expected);
+  }
+  for (const layer of [StrictFinality, CacheFinality, TreeFinality]) {
+    for (const name of [
+      "Blob",
+      "Blob/fs",
+      "BlobIndex/fs",
+      "BlobUpload/fs",
+      "BlobCopy/fs",
+      "WorkingDirectory",
+    ]) {
+      expect(evaluate(finalityStopRules(layer), resource(name)), `${layer.name}:${name}`).toBe(
+        layer.isFinal(resource(name)),
+      );
+    }
+  }
+});

package/src/middle_layer/finality_stop_rules.ts

@@ -0,0 +1,58 @@
+import type {
+  Filter,
+  FinalityEntry,
+  FinalityTable,
+  TranslatableFinalityRule,
+} from "@milaboratories/pl-client";
+import { treeFilter } from "@milaboratories/pl-client";
+
+function escapeRegExp(literal: string): string {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function typeFilter(match: FinalityEntry["match"]): Filter {
+  return "name" in match
+    ? treeFilter.resourceTypeEq(match.name)
+    : treeFilter.resourceTypeMatch("^" + escapeRegExp(match.prefix));
+}
+
+function conditionFilter(type: Filter, rule: TranslatableFinalityRule): Filter {
+  switch (rule) {
+    case "always":
+      return type;
+    case "readyOrDuplicateOrError":
+      return treeFilter.and(type, treeFilter.readyOrDuplicateOrError());
+    case "readyAndAllOutputsFilled":
+      return treeFilter.and(
+        type,
+        treeFilter.readyOrDuplicateOrError(),
+        treeFilter.outputsLocked(true),
+        treeFilter.allOutputsFinal(true),
+      );
+  }
+}
+
+/** The stop-rule clause of one entry, or undefined when the entry sends none: a `never` rule,
+ * or a `none` declaration. */
+export function finalityStopRuleClause(entry: FinalityEntry): Filter | undefined {
+  if (entry.rule === "never") return undefined;
+  const declared = entry.stopRule ?? "exact";
+  if (typeof declared === "object" && "none" in declared) return undefined;
+  if (declared !== "exact") return conditionFilter(typeFilter(entry.match), declared.approx);
+  if (typeof entry.rule === "object") return undefined;
+  return conditionFilter(typeFilter(entry.match), entry.rule);
+}
+
+/**
+ * Traversal stop rules for a finality table: the OR of every entry's declared clause. An
+ * approximated clause may stop before the table calls a resource final; an entry with no clause
+ * contributes nothing. The backend applies stop rules on walks without a change token only.
+ */
+export function finalityStopRules(table: FinalityTable): Filter {
+  const clauses: Filter[] = [];
+  for (const e of table.entries) {
+    const clause = finalityStopRuleClause(e);
+    if (clause !== undefined) clauses.push(clause);
+  }
+  return treeFilter.or(...clauses);
+}

package/src/middle_layer/project.ts

@@ -17,10 +17,10 @@ import {
   parseSignedResourceId,
   Pl,
   resourceIdToString,
-  ResourceTypeName,
-  ResourceTypePrefix,
   treeFilter,
+  TreeFinality,
 } from "@milaboratories/pl-client";
+import { finalityStopRules } from "./finality_stop_rules";
 import type { ComputableStableDefined, ComputableValueOrErrors } from "@milaboratories/computable";
 import { Computable } from "@milaboratories/computable";
 import { projectOverview } from "./project_overview";
@@ -1018,148 +1018,10 @@ export function projectTreeFieldFilter(): Filter {
   );
 }
 
-/**
- * Stop-rules for the ResourceTree backend path.
- *
- * Mirrors every case of DefaultFinalResourceDataPredicate in the same order.
- * The mapping from BFS predicate logic to backend filter conditions:
- *
- *   BFS predicate always true
- *     → no readyOrDuplicateOrError guard; backend stops traversal unconditionally.
- *
- *   BFS predicate: readyOrDuplicateOrError(r)
- *     → readyOrDuplicateOrError(): stops when resource_ready_for_calculation,
- *       is_duplicate, or has_errors is true — exactly mirroring the BFS predicate.
- *
- *   BFS predicate: readyAndHasAllOutputsFilled(r)
- *     → isFinal(true) + allOutputsFinal(true).
- *
- *   BFS predicate always false (UserProject, Projects, ClientRoot)
- *     → no entry here; traversal always continues into them.
- */
+/** Stop rules for the project tree's ResourceTree walks: {@link TreeFinality}'s declared clauses,
+ * which may stop before the predicate calls a resource final where an entry declares so. */
 export function projectTreeTraverseStopRules(): Filter {
-  return treeFilter.or(
-    // BFS: readyOrDuplicateOrError(r) AND (fields===undefined OR error OR stream.value===downloadable.value).
-    // datactl sets stream field to point at the same resource as downloadable once processing
-    // is complete, so stream.value===downloadable.value is the "done" signal.
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.StreamManager),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    // BFS: readyOrDuplicateOrError(r)
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.StdMap),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.StdMapSlash),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.EphStdMap),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.PFrame),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.ParquetChunk),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.BContext),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.BlockPackCustom),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.BinaryMap),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.BinaryValue),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.BlobMap),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.BResolveSingle),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.BResolveSingleNoResult),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.BQueryResult),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.TengoTemplate),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.TengoLib),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.SoftwareInfo),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeEq(ResourceTypeName.Dummy),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    // BFS: r.type.version === "1" → always true → no state guard needed
-    treeFilter.resourceTypeEq(ResourceTypeName.JsonResourceError),
-    // BFS: return true (unconditionally) → no readyOrDuplicateOrError guard needed
-    treeFilter.resourceTypeEq(ResourceTypeName.JsonObject),
-    treeFilter.resourceTypeEq(ResourceTypeName.JsonGzObject),
-    treeFilter.resourceTypeEq(ResourceTypeName.JsonString),
-    treeFilter.resourceTypeEq(ResourceTypeName.JsonArray),
-    treeFilter.resourceTypeEq(ResourceTypeName.JsonNumber),
-    treeFilter.resourceTypeEq(ResourceTypeName.BContextEnd),
-    treeFilter.resourceTypeEq(ResourceTypeName.FrontendFromUrl),
-    treeFilter.resourceTypeEq(ResourceTypeName.FrontendFromFolder),
-    treeFilter.resourceTypeEq(ResourceTypeName.BObjectSpec),
-    treeFilter.resourceTypeEq(ResourceTypeName.Blob),
-    treeFilter.resourceTypeEq(ResourceTypeName.Null),
-    treeFilter.resourceTypeEq(ResourceTypeName.Binary),
-    treeFilter.resourceTypeEq(ResourceTypeName.LSProvider),
-    treeFilter.resourceTypeEq(ResourceTypeName.WorkingDirectory),
-    // BFS default branch: startsWith prefix → return true → no guard needed
-    treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.Blob),
-    treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.LS),
-    treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.WorkingDirectory),
-    treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.StorageSpaceAllocation),
-    // BFS default branch: readyAndHasAllOutputsFilled → readyOrDuplicateOrError() + outputsLocked(true) + allOutputsFinal(true)
-    treeFilter.and(
-      treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.BlobUpload),
-      treeFilter.readyOrDuplicateOrError(),
-      treeFilter.outputsLocked(true),
-      treeFilter.allOutputsFinal(true),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.BlobIndex),
-      treeFilter.readyOrDuplicateOrError(),
-      treeFilter.outputsLocked(true),
-      treeFilter.allOutputsFinal(true),
-    ),
-    // BFS default branch: readyOrDuplicateOrError
-    treeFilter.and(
-      treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.PColumnData),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-    treeFilter.and(
-      treeFilter.resourceTypeMatch("^" + ResourceTypePrefix.StreamWorkdir),
-      treeFilter.readyOrDuplicateOrError(),
-    ),
-  );
+  return finalityStopRules(TreeFinality);
 }
 
 /** Returns true if sdk version of the block is old and we need to convert