@milaboratories/pl-middle-layer 1.73.3 → 1.73.5

package/src/middle_layer/project_pruning.test.ts

@@ -18,6 +18,7 @@ import { projectsListFieldFilter, ProjectsListTreePruningFunction } from "./proj
 import type { Filter } from "@milaboratories/pl-client";
 import {
   DefaultFinalResourceDataPredicate,
+  TreeFinality,
   FilterOperatorType,
   FilterProperty,
   NullSignedResourceId,
@@ -65,7 +66,7 @@ function makeReadyResource(typeName: string, version = "1"): ExtendedResourceDat
 }
 
 /**
- * Build a resource that satisfies readyAndHasAllOutputsFilled:
+ * Build a resource that satisfies readyAndAllOutputsFilled:
  *   resourceReady=true, outputsLocked=true, one field with valueIsFinal=true.
  */
 function makeAllOutputsFinalResource(typeName: string): ExtendedResourceData {
@@ -285,6 +286,23 @@ describe("§4.1 projects-list pruning parity", () => {
 
 // ── §4.2 — traverseStopRules coverage ────────────────────────────────────────
 
+describe("the pruning the finality table relies on", () => {
+  for (const e of TreeFinality.entries) {
+    if (e.requiresPruning === undefined) continue;
+    const { type, fields } = e.requiresPruning;
+    it(`${type}: projectTreePruning and projectTreeFieldFilter drop ${fields === "all" ? "every field" : fields.join(", ")}`, () => {
+      const names = fields === "all" ? ["incarnation", "any"] : [...fields];
+      const r = makeResource(type, names);
+      const kept = projectTreePruning(noopLogger)(r).map((f) => f.name);
+      const keptByFilter = evaluateFieldFilter(projectTreeFieldFilter(), r);
+      for (const name of names) {
+        expect(kept).not.toContain(name);
+        expect(keptByFilter).not.toContain(name);
+      }
+    });
+  }
+});
+
 describe("§4.2 projectTreeTraverseStopRules", () => {
   const rule = projectTreeTraverseStopRules();
 
@@ -301,8 +319,11 @@ describe("§4.2 projectTreeTraverseStopRules", () => {
     "BObjectSpec",
     "BContextEnd",
     "Null",
-    "LSProvider",
     "Blob",
+    "Frontend/FromLocalTgz",
+    "json/bool",
+    "json/null",
+    "json/errorTrace",
   ];
   for (const t of alwaysTerminalTypes) {
     it(`always-terminal: ${t}`, () => {
@@ -436,15 +457,14 @@ describe("§4.2 projectTreeTraverseStopRules", () => {
 //   1. DefaultFinalResourceDataPredicate(resource) === expectedPredicate
 //   2. evaluateStopRule(rule, flags) === expectedStop
 //
-// `flags` encodes what the backend would emit for the same resource state:
+// `flags` compress several independent backend properties into two:
 //   - isFinal   = resource is "ready/error/duplicate" (or always-final type)
 //   - allOutputsFinal = outputsLocked && every field value is final
 //
 // The parity contract: when the predicate says "final" AND the type is one the
-// stop rule covers, the stop rule must also fire.  Types that are final only due
-// to runtime state (StdMap, BlockPackCustom, …) are NOT in the stop rules —
-// those are left to the backend's own isFinal flag (`item.final`) and are
-// documented as intentional gaps below.
+// stop rule covers, the stop rule must also fire. Where the backend's filter
+// differs from the predicate, finality_stop_rules.test.ts checks it against the
+// backend's semantics.
 
 describe("§4.3 final-predicate parity: DefaultFinalResourceDataPredicate ⇄ projectTreeTraverseStopRules", () => {
   const rule = projectTreeTraverseStopRules();
@@ -463,8 +483,11 @@ describe("§4.3 final-predicate parity: DefaultFinalResourceDataPredicate ⇄ pr
     { typeName: "BObjectSpec" },
     { typeName: "BContextEnd" },
     { typeName: "Null" },
-    { typeName: "LSProvider" },
     { typeName: "Blob" },
+    { typeName: "Frontend/FromLocalTgz" },
+    { typeName: "json/bool" },
+    { typeName: "json/null" },
+    { typeName: "json/errorTrace" },
     { typeName: "Blob/v2" },
     { typeName: "LS/remote" },
     { typeName: "WorkingDirectory/1" },
@@ -551,7 +574,7 @@ describe("§4.3 final-predicate parity: DefaultFinalResourceDataPredicate ⇄ pr
     );
   });
 
-  // ── Group C: isFinal+allOutputsFinal-conditional — readyAndHasAllOutputsFilled ──
+  // ── Group C: isFinal+allOutputsFinal-conditional — readyAndAllOutputsFilled ──
 
   it("BlobUpload/v1 — all outputs final: predicate=true, stop fires with isFinal+allOutputsFinal=true", () => {
     const r = makeAllOutputsFinalResource("BlobUpload/v1");
@@ -615,15 +638,13 @@ describe("§4.3 final-predicate parity: DefaultFinalResourceDataPredicate ⇄ pr
 
   // ── Group E: never-final types — predicate=false, stop rule does not fire ──
   //
-  // Covers the explicit `return false` cases in DefaultFinalResourceDataPredicate
-  // (UserProject, Projects, ClientRoot) and the `default` else-branch for unknown
-  // types.  Both paths agree: not final, traversal continues.
+  // Types declared `never`, and types no entry matches: not final, and no stop clause.
 
   const neverFinalCases: Array<{ typeName: string; label: string }> = [
-    { typeName: "UserProject", label: "explicit false in predicate" },
-    { typeName: "Projects", label: "explicit false in predicate" },
-    { typeName: "ClientRoot", label: "explicit false in predicate" },
-    { typeName: "SomeUnknownType", label: "default branch else → false" },
+    { typeName: "UserProject", label: "declared never" },
+    { typeName: "Projects", label: "declared never" },
+    { typeName: "ClientRoot", label: "declared never" },
+    { typeName: "SomeUnknownType", label: "unmatched type" },
   ];
 
   for (const { typeName, label } of neverFinalCases) {
@@ -633,4 +654,26 @@ describe("§4.3 final-predicate parity: DefaultFinalResourceDataPredicate ⇄ pr
       expect(evaluateStopRule(rule, { resourceType: typeName, isFinal: false })).toBe(false);
     });
   }
+
+  it("LSProvider: never final, stop does NOT fire even when ready", () => {
+    expect(DefaultFinalResourceDataPredicate(makeReadyResource("LSProvider"))).toBe(false);
+    expect(
+      evaluateStopRule(rule, { resourceType: "LSProvider", isFinal: true, allOutputsFinal: true }),
+    ).toBe(false);
+  });
+
+  // For these ready fixtures, locked outputs and settled fields satisfy both checks.
+  for (const typeName of ["BResolveSingle", "BResolveChoice", "BlobCopy/aToB"]) {
+    it(`${typeName}: final with outputs locked and settled, stop fires only then`, () => {
+      expect(DefaultFinalResourceDataPredicate(makeAllOutputsFinalResource(typeName))).toBe(true);
+      // a synthetic unlocked snapshot: schema-created resolvers and copies have locked outputs
+      expect(DefaultFinalResourceDataPredicate(makeReadyResource(typeName))).toBe(false);
+      expect(
+        evaluateStopRule(rule, { resourceType: typeName, isFinal: true, allOutputsFinal: true }),
+      ).toBe(true);
+      expect(
+        evaluateStopRule(rule, { resourceType: typeName, isFinal: true, allOutputsFinal: false }),
+      ).toBe(false);
+    });
+  }
 });

package/src/middle_layer/sharing_list.ts

@@ -325,8 +325,8 @@ const SharingOutboxPruningFunction: PruningFunction = (resource) => {
 
 // Server-side traversal scope (modern resourceTree path). Pruning is client-side ONLY and does
 // NOT stop the backend walk — without a fieldFilter the backend descends through the envelope's
-// project/{uuid} snapshots into the whole project graph (StreamManager etc.), whose field-driven
-// finality predicate then throws on the pruned-to-[] fields. Following fields only FROM the outbox
+// project/{uuid} snapshots into the whole project graph (StreamManager etc.), which the tree would
+// then hold, with its fields pruned to [], and re-poll for nothing. Following fields only FROM the outbox
 // and the envelope stops the walk at the project snapshots (UserProject), which we never traverse.
 const SharingOutboxFieldFilter: Filter = treeFilter.or(
   treeFilter.resourceTypeEq(SharingOutboxResourceType.name),