@sixb/core 0.1.14 → 0.1.16

package/dist/testing/index.js

@@ -2,24 +2,24 @@
 import {
   AuthStorageError2,
   SYSTEM_PRINCIPAL2
-} from "../chunk-6rzb1g6h.js";
+} from "../chunk-2xvgy3x5.js";
 import {
   defineProjection2,
   agentServiceAccountId2,
   MAX_OBJECT_READ_FACETS2
-} from "../chunk-rzcjp5m2.js";
-import"../chunk-rzkr70gr.js";
+} from "../chunk-69kt9q43.js";
+import"../chunk-6fsr7y93.js";
 import"../chunk-z3y5kg1x.js";
 import {
   compileSelectedObjectReadScope2
 } from "../chunk-v4jbb3rs.js";
-import"../chunk-d8yes9yx.js";
+import"../chunk-swxzncrv.js";
 import {
   ref2
-} from "../chunk-drz59ve0.js";
+} from "../chunk-tkdbge6v.js";
 import"../chunk-2jntasmh.js";
 import"../chunk-pqajwytd.js";
-import"../chunk-ky7zpbtt.js";
+import"../chunk-tnvafr7g.js";
 import"../chunk-gfdh9kqa.js";
 import {
   computeBlobDigest2,
@@ -31,7 +31,7 @@ import {
 import {
   AiUsageStorageError2
 } from "../chunk-xnx96gfy.js";
-import"../chunk-xgptywp0.js";
+import"../chunk-y2aq6ag9.js";
 import"../chunk-fc5zfxy1.js";
 import {
   aiLimitCalendarMonth2
@@ -39,7 +39,7 @@ import {
 import {
   DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS2
 } from "../chunk-h89wz928.js";
-import"../chunk-3a338wrp.js";
+import"../chunk-dp7yk20b.js";
 import"../chunk-tw03bsmb.js";
 import {
   OntologyRegistry2,
@@ -47,10 +47,10 @@ import {
   prop2,
   link2,
   stringEnum2
-} from "../chunk-3nx8vj5a.js";
+} from "../chunk-zvmr2hqk.js";
 import {
   createEventId2
-} from "../chunk-ht4a7mjg.js";
+} from "../chunk-g4rbm4a6.js";
 import {
   AGENT_MESSAGE_CONTENT_VERSION2,
   AiCostStorageError2,
@@ -59,54 +59,54 @@ import {
   objectLinkCursor2,
   WorkflowInterventionError2,
   InMemoryStorage2
-} from "../chunk-3fpgxpsq.js";
+} from "../chunk-6z1q7j19.js";
 import"../chunk-7ytf06d3.js";
 import"../chunk-mr60an99.js";
 import"../chunk-mmagke4x.js";
-import"../chunk-qma80ych.js";
-import"../chunk-znw0zvy4.js";
+import"../chunk-hn2r7z41.js";
+import"../chunk-4wn7bxxa.js";
 import"../chunk-jmfet9r4.js";
 import"../chunk-qf954wje.js";
-import"../chunk-gct3m1da.js";
+import"../chunk-667x4drs.js";
 import {
   ProjectionRegistry2,
   createLinkScopeFingerprint2,
   createOntologyMaterializer2
-} from "../chunk-00pfcqh4.js";
+} from "../chunk-h4138ww2.js";
 import {
   bindModelExecutionAttempt,
   isBoundSixb
-} from "../chunk-16jenmzw.js";
+} from "../chunk-3q7z9hd4.js";
 import"../chunk-5a4a52tq.js";
 import {
   SixbHost2
-} from "../chunk-hj0n3c2p.js";
-import"../chunk-y6vnvayj.js";
-import"../chunk-ypj2wqtj.js";
+} from "../chunk-vjqt7q3a.js";
+import"../chunk-vjcd8d27.js";
+import"../chunk-70jmg2zx.js";
 import"../chunk-r2y23egw.js";
 import"../chunk-dfm066qg.js";
 import {
-  planObjectQuery2,
   validateObjectQuery2,
   collectObjectQueryValidationIssues2,
+  planObjectQuery2,
   executeObjectQuery2,
   countObjects2,
   existsObjects2,
   facetObjects2,
   executeObjectQueryLinks2
-} from "../chunk-728fp090.js";
-import"../chunk-pvgpckm1.js";
+} from "../chunk-h044jb97.js";
+import"../chunk-8x74221e.js";
 import"../chunk-3qms4nax.js";
 import"../chunk-f85hpqnm.js";
-import"../chunk-4tnrzqqh.js";
-import"../chunk-wnxabtn4.js";
-import"../chunk-y487ywrv.js";
+import"../chunk-fj1dvp37.js";
+import"../chunk-gkxsenvp.js";
+import"../chunk-cq44v1a6.js";
 import"../chunk-fb3feg1e.js";
 import"../chunk-z5rnrmz1.js";
 import"../chunk-85cd7e8c.js";
 import"../chunk-wr8qp979.js";
-import"../chunk-dv4ct8mp.js";
-import"../chunk-dsfw1bdr.js";
+import"../chunk-dsv8kdgk.js";
+import"../chunk-f72rbvsb.js";
 import {
   col2,
   defineDataset2,
@@ -115,14 +115,14 @@ import {
 import"../chunk-e1c18xjx.js";
 import"../chunk-9vx5e9g1.js";
 import"../chunk-dmn70ztd.js";
-import"../chunk-cbn96bve.js";
+import"../chunk-nvymebc1.js";
 import {
   writeDataset2
 } from "../chunk-91kcnbf0.js";
-import"../chunk-vn3yh259.js";
+import"../chunk-4gmng3vf.js";
 import {
   workflowAgentStepActorId2
-} from "../chunk-wn7mznxc.js";
+} from "../chunk-kttr5ftm.js";
 import {
   BrokerError2,
   InMemoryBroker2
@@ -134,23 +134,23 @@ import {
 import"../chunk-mdnw7nj8.js";
 import {
   SandboxNotRunningError2
-} from "../chunk-vef6qa14.js";
-import"../chunk-e2c5yxfe.js";
-import"../chunk-yvf2jqj8.js";
+} from "../chunk-gmdvns8f.js";
+import"../chunk-zb47r1c8.js";
+import"../chunk-h866d223.js";
 import"../chunk-7n30ybym.js";
-import"../chunk-ma1mhh7w.js";
+import"../chunk-a7ne02hk.js";
 import {
   createTestingScope
-} from "../chunk-z9h698s8.js";
+} from "../chunk-vsvrv7n8.js";
 import"../chunk-x9v4cx1d.js";
-import"../chunk-ffwvdgk1.js";
-import"../chunk-q2xghyft.js";
-import"../chunk-ww185kt6.js";
-import"../chunk-4ypbe95r.js";
-import"../chunk-hxgj4kzd.js";
-import"../chunk-jfdggg1p.js";
-import"../chunk-bxx3ms5t.js";
-import"../chunk-kxea54yg.js";
+import"../chunk-nj0020ay.js";
+import"../chunk-nkbev3tr.js";
+import"../chunk-cxj8y8t0.js";
+import"../chunk-chdg6eqq.js";
+import"../chunk-b9y8hcm2.js";
+import"../chunk-kvysp909.js";
+import"../chunk-40qb8wpe.js";
+import"../chunk-sbcm1b92.js";
 import {
   LakeStorageError2
 } from "../chunk-rb143ggb.js";
@@ -160,12 +160,12 @@ import {
 } from "../chunk-a0073121.js";
 import {
   restoreTrustedPrimitiveExecutionScope
-} from "../chunk-m8zkvep1.js";
-import"../chunk-zdkcdshk.js";
+} from "../chunk-7g2gjvah.js";
 import"../chunk-br3k6qbf.js";
+import"../chunk-zdkcdshk.js";
 import"../chunk-s3csryxe.js";
-import"../chunk-bdhfn0ww.js";
-import"../chunk-2fv8sajb.js";
+import"../chunk-kkqwzy6h.js";
+import"../chunk-qnd7ehe5.js";
 import {
   blobIdFromDigest2
 } from "../chunk-h3v76ams.js";
@@ -13160,33 +13160,140 @@ function runOntologyStorageContractSuite(label, options) {
           execution,
           abandonedAt: "2026-01-01T00:03:00.000Z"
         })).rejects.toMatchObject({ kind: "execution-lost" });
+        const adopted = await storage.ontology.sources.adopt({
+          projectId: "contract-project",
+          source,
+          execution: reclaimed.execution,
+          adoptedAt: "2026-01-01T00:01:30.000Z"
+        });
+        expect21(adopted).toMatchObject({
+          record: {
+            materializationId: "staging-candidate",
+            status: "ready",
+            executionToken: reclaimed.execution.executionToken,
+            updatedAt: "2026-01-01T00:01:30.000Z"
+          },
+          resumeStagingOrdinal: 1
+        });
+        expect21(await storage.ontology.sources.adopt({
+          projectId: "contract-project",
+          source,
+          execution: reclaimed.execution,
+          adoptedAt: "2026-01-01T00:01:40.000Z"
+        })).toMatchObject({ record: { executionToken: reclaimed.execution.executionToken } });
         const abandoned = await storage.ontology.sources.abandon({
-          kind: "reclaim",
+          kind: "run",
           projectId: "contract-project",
           source,
           execution: reclaimed.execution,
           abandonedAt: "2026-01-01T00:02:00.000Z"
         });
         expect21(abandoned).toMatchObject({ status: "abandoned", executionToken: null });
-        expect21(await storage.ontology.sources.summarizeTerminal({ projectId: "contract-project" })).toEqual({ count: 1, oldestTerminalAt: "2026-01-01T00:02:00.000Z" });
-        expect21(await storage.ontology.sources.cleanupTerminal({
+        expect21(await storage.ontology.sources.abandon({
+          kind: "run",
           projectId: "contract-project",
-          terminalBefore: "2026-02-01T00:00:00.000Z",
-          limit: 1
-        })).toEqual({ rowsDeleted: 1, materializationsDeleted: 0 });
-        expect21(await storage.ontology.sources.cleanupTerminal({
+          source,
+          execution: reclaimed.execution,
+          abandonedAt: "2026-01-01T00:02:00.000Z"
+        })).toBeNull();
+        expect21(await storage.ontology.sources.adopt({
           projectId: "contract-project",
-          terminalBefore: "2026-02-01T00:00:00.000Z",
-          limit: 1
-        })).toEqual({ rowsDeleted: 1, materializationsDeleted: 0 });
+          source,
+          execution: reclaimed.execution,
+          adoptedAt: "2026-01-01T00:02:10.000Z"
+        })).toBeNull();
+        expect21(await storage.ontology.sources.summarizeTerminal({ projectId: "contract-project" })).toEqual({ count: 1, oldestTerminalAt: "2026-01-01T00:02:00.000Z" });
         expect21(await storage.ontology.sources.cleanupTerminal({
           projectId: "contract-project",
           terminalBefore: "2026-02-01T00:00:00.000Z",
-          limit: 1
-        })).toEqual({ rowsDeleted: 0, materializationsDeleted: 1 });
+          limit: 10
+        })).toEqual({ rowsDeleted: 0, materializationsDeleted: 0 });
+        expect21(await storage.ontology.sources.purgeAbandoned({ projectId: "contract-project", limit: 1 })).toEqual({ rowsDeleted: 1, materializationsDeleted: 0 });
+        expect21(await storage.ontology.sources.purgeAbandoned({ projectId: "contract-project", limit: 1 })).toEqual({ rowsDeleted: 1, materializationsDeleted: 0 });
+        expect21(await storage.ontology.sources.purgeAbandoned({ projectId: "contract-project", limit: 1 })).toEqual({ rowsDeleted: 0, materializationsDeleted: 1 });
         expect21(await storage.ontology.sources.summarizeTerminal({ projectId: "contract-project" })).toEqual({ count: 0, oldestTerminalAt: null });
       });
     });
+    test21("adopts a staging candidate at its last staged root", async () => {
+      await withStorage(async (storage) => {
+        const identity = replacementIdentity("01");
+        const claimed = await startTestProjectionRun(storage, {
+          id: "resumed-run",
+          projectId: "contract-project",
+          identity,
+          target: { objectTypeId: "ContractDevice" }
+        });
+        const source = { projectionId: identity.projectionId };
+        await storage.ontology.sources.beginMaterialization({
+          projectId: "contract-project",
+          source,
+          materializationId: "resumed-candidate",
+          execution: claimed.execution,
+          projectionKind: "object",
+          protocol: "replacement",
+          datasetVersion: identity.datasetVersion,
+          projectionRevision: identity.projectionRevision,
+          ownershipHash: identity.ownershipHash,
+          ontologyRevision: identity.ontologyRevision,
+          createdAt: "2026-01-01T00:00:00.000Z"
+        });
+        const row = (primaryId, stagingOrdinal) => ({
+          root: { kind: "object", ref: { objectTypeId: "ContractDevice", primaryId } },
+          assertion: {
+            kind: "object",
+            ref: { objectTypeId: "ContractDevice", primaryId },
+            properties: { name: primaryId }
+          },
+          stagingOrdinal
+        });
+        await storage.ontology.sources.stageRows({
+          projectId: "contract-project",
+          source,
+          materializationId: "resumed-candidate",
+          execution: claimed.execution,
+          rows: [row("zero", 0), row("one", 1)]
+        });
+        const reclaimed = await storage.projectionRuns.startOrReclaim({
+          id: claimed.run.id,
+          projectId: claimed.run.projectId,
+          identity,
+          target: { objectTypeId: "ContractDevice" }
+        });
+        const adopted = await storage.ontology.sources.adopt({
+          projectId: "contract-project",
+          source,
+          execution: reclaimed.execution,
+          adoptedAt: "2026-01-01T00:01:00.000Z"
+        });
+        expect21(adopted).toMatchObject({
+          record: { status: "staging", executionToken: reclaimed.execution.executionToken },
+          resumeStagingOrdinal: 1
+        });
+        await expect21(storage.ontology.sources.stageRows({
+          projectId: "contract-project",
+          source,
+          materializationId: "resumed-candidate",
+          execution: claimed.execution,
+          rows: [row("two", 2)]
+        })).rejects.toMatchObject({ kind: "execution-lost" });
+        expect21(await storage.ontology.sources.stageRows({
+          projectId: "contract-project",
+          source,
+          materializationId: "resumed-candidate",
+          execution: reclaimed.execution,
+          rows: [row("one", 1), row("two", 2)]
+        })).toEqual({ inserted: 1, unchanged: 1 });
+        expect21(await storage.ontology.sources.markReady({
+          projectId: "contract-project",
+          source,
+          materializationId: "resumed-candidate",
+          execution: reclaimed.execution,
+          rootCount: 3,
+          assertionCount: 3,
+          readyAt: "2026-01-01T00:02:00.000Z"
+        })).toMatchObject({ status: "ready", rootCount: 3 });
+      });
+    });
     test21("atomically activates explicit empty candidates and rejects competing stale heads", async () => {
       await withStorage(async (storage) => {
         const first = await createReadyEmptyCandidate(storage, "run-one", "candidate-one", "01");
@@ -13225,15 +13332,14 @@ function runOntologyStorageContractSuite(label, options) {
         });
         await expect21(activateEmptyCandidate(storage, stale, currentActive, "commit-stale-activation", "2026-01-06T00:00:00.000Z")).rejects.toThrow("execution token is stale");
         await storage.ontology.sources.abandon({
-          kind: "reclaim",
+          kind: "run",
           projectId: "contract-project",
           source: stale.source,
           execution: reclaimed.execution,
           abandonedAt: "2026-01-06T00:01:00.000Z"
         });
-        const cleanup = await storage.ontology.sources.cleanupTerminal({
+        const cleanup = await storage.ontology.sources.purgeAbandoned({
           projectId: "contract-project",
-          terminalBefore: "2026-02-01T00:00:00.000Z",
           limit: 10
         });
         expect21(cleanup.materializationsDeleted).toBeGreaterThanOrEqual(1);
@@ -13731,6 +13837,12 @@ var failure2 = {
   at: "2026-06-01T12:00:00.000Z",
   details: { projectionId: "contract.devices", runId: "failed-run" }
 };
+var attemptFailure = {
+  code: "storage.unavailable",
+  message: "Storage is temporarily unavailable.",
+  retryable: true,
+  at: "2026-06-01T11:00:00.000Z"
+};
 var replacementIdentity2 = {
   projectionId: "contract.devices",
   projectionKind: "object",
@@ -13818,11 +13930,120 @@ function runProjectionRunStorageContractSuite(label, options) {
           status: "failed",
           error: { code: "queue.enqueue_failed", message: "queue unavailable" }
         });
-        await expect22(context.projectionRuns.queue(admission)).resolves.toMatchObject({
+        const requeued = await context.projectionRuns.queue(admission);
+        expect22(requeued).toMatchObject({
           executionId: admission.executionId,
           status: "queued",
           attempt: 0
         });
+        expect22(requeued.error).toBeUndefined();
+      });
+    });
+    test22("keeps the failure of a retried attempt until the run ends", async () => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns;
+        const input = replacementInput("retried-run");
+        await admitProjectionRun(context, input);
+        const first = await storage.startOrReclaim(input);
+        const failed = await storage.recordAttemptFailure({
+          ...executionInput(first),
+          error: attemptFailure
+        });
+        expect22(failed).toMatchObject({ status: "running", error: attemptFailure });
+        const second = await storage.startOrReclaim(input);
+        expect22(second.run).toMatchObject({ attempt: 2, error: attemptFailure });
+        await expect22(storage.recordAttemptFailure({ ...executionInput(first), error: failure2 })).rejects.toThrow("execution token is stale");
+        await expect22(storage.recordAttemptFailure({
+          ...executionInput(second),
+          error: { ...failure2, code: "dataset.not_found" }
+        })).rejects.toThrow("code is not allowed by this failure contract");
+        const succeeded = await storage.finish({
+          ...executionInput(second),
+          protocol: "replacement",
+          status: "succeeded"
+        });
+        expect22(succeeded).toMatchObject({ status: "succeeded" });
+        expect22(succeeded.error).toBeUndefined();
+        await expect22(storage.recordAttemptFailure({ ...executionInput(second), error: failure2 })).rejects.toThrow("already terminal");
+      });
+    });
+    test22("finds the newest later run that still stands to replace a source", async () => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns;
+        const current = replacementInput("current-run");
+        const earlier = versionedReplacementInput("earlier-run", "version-0", "2025-12-31");
+        const later = versionedReplacementInput("later-run", "version-2", "2026-01-02");
+        const latest = versionedReplacementInput("latest-run", "version-3", "2026-01-03");
+        const otherProjection = {
+          ...versionedReplacementInput("other-projection-run", "version-4", "2026-01-04"),
+          identity: {
+            ...versionedReplacementInput("other", "version-4", "2026-01-04").identity,
+            projectionId: "contract.rooms"
+          }
+        };
+        for (const input of [current, earlier, later, latest, otherProjection]) {
+          await admitProjectionRun(context, input);
+        }
+        const superseding = () => storage.findSupersedingRun({ projectId: projectId13, id: current.id });
+        await expect22(superseding()).resolves.toMatchObject({ id: latest.id, status: "queued" });
+        await expect22(storage.findSupersedingRun({ projectId: projectId13, id: latest.id })).resolves.toBeNull();
+        await finishClaimed(context, latest, "failed");
+        await expect22(superseding()).resolves.toMatchObject({ id: later.id });
+        await finishClaimed(context, later, "cancelled");
+        await expect22(superseding()).resolves.toBeNull();
+        const telemetry = {
+          id: "telemetry-run",
+          projectId: projectId13,
+          identity: telemetryIdentity,
+          target: objectTarget,
+          fixedBatchSize: 2
+        };
+        await admitProjectionRun(context, telemetry);
+        await expect22(storage.findSupersedingRun({ projectId: projectId13, id: telemetry.id })).resolves.toBeNull();
+        await expect22(storage.findSupersedingRun({ projectId: projectId13, id: "missing-run" })).rejects.toThrow("not found");
+      });
+    });
+    test22("ends a superseded run without a failure and never reports it as the latest", async () => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns;
+        const stale = replacementInput("stale-run");
+        const newer = versionedReplacementInput("newer-run", "version-2", "2026-01-02");
+        await admitProjectionRun(context, stale);
+        await admitProjectionRun(context, newer);
+        const claim = await storage.startOrReclaim({
+          ...stale,
+          startedAt: new Date("2026-01-01T00:00:05.000Z")
+        });
+        const superseded = await storage.finish({
+          ...executionInput(claim),
+          protocol: "replacement",
+          status: "superseded"
+        });
+        expect22(superseded).toMatchObject({ status: "superseded", attempt: 1 });
+        expect22(superseded.error).toBeUndefined();
+        expect22(superseded.finishedAt).toBeInstanceOf(Date);
+        await expect22(storage.listLatestByProjectionIds({
+          projectId: projectId13,
+          projectionIds: [replacementIdentity2.projectionId]
+        })).resolves.toMatchObject({ runs: [{ id: newer.id, status: "queued" }] });
+        await expect22(storage.list({ projectId: projectId13, statuses: ["superseded"] })).resolves.toMatchObject({
+          runs: [{ id: stale.id }],
+          total: 1
+        });
+        const telemetry = {
+          id: "telemetry-run",
+          projectId: projectId13,
+          identity: telemetryIdentity,
+          target: objectTarget,
+          fixedBatchSize: 2
+        };
+        await admitProjectionRun(context, telemetry);
+        const telemetryClaim = await storage.startOrReclaim(telemetry);
+        await expect22(storage.finish({
+          ...executionInput(telemetryClaim),
+          protocol: "telemetry",
+          status: "superseded"
+        })).rejects.toThrow("cannot be superseded");
       });
     });
     test22("keeps one run while reclaim rotates its execution", async () => {
@@ -14164,6 +14385,27 @@ async function admitProjectionRun(context, input) {
 function replacementInput(id) {
   return { id, projectId: projectId13, identity: replacementIdentity2, target: objectTarget };
 }
+function versionedReplacementInput(id, versionId, day) {
+  return {
+    ...replacementInput(id),
+    identity: {
+      ...replacementIdentity2,
+      datasetVersion: {
+        ...replacementIdentity2.datasetVersion,
+        versionId,
+        createdAt: `${day}T00:00:00.000Z`
+      }
+    }
+  };
+}
+async function finishClaimed(context, input, status) {
+  const claim = await context.projectionRuns.startOrReclaim(input);
+  await context.projectionRuns.finish({
+    ...executionInput(claim),
+    protocol: "replacement",
+    status
+  });
+}
 function executionInput(claim) {
   return {
     id: claim.run.id,
@@ -15992,4 +16234,4 @@ export {
   startTestWebhookRun
 };
 
-//# debugId=3E6B1E78CE757E1764756E2164756E21
+//# debugId=C29F884EB428EEBD64756E2164756E21