@sixb/core 0.1.8 → 0.1.10

package/src/testing/execution-storage-contract.ts

@@ -43,6 +43,56 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
   }
 
   describe(label, () => {
+    test("captures memberships once and inherits them independently of current authority", async () => {
+      // Removal proof: skip prepareExecutionRecord's membership capture or parent inheritance.
+      await withStorage(async (storage) => {
+        await seedAuth(storage.auth)
+        for (const groupId of ["support", "finance"]) {
+          await storage.auth.groupMemberships.upsert({
+            projectId,
+            userId: "user-one",
+            groupId,
+            source: "manual",
+          })
+        }
+        const parent = await storage.executions.create({
+          ...principalRequest({ id: "parent" }),
+          requesterGroupIds: undefined,
+        })
+        expect(parent.requesterGroupIds).toEqual(["finance", "support"])
+        await storage.auth.groupMemberships.remove({
+          projectId,
+          userId: "user-one",
+          groupId: "finance",
+        })
+        const childInput = trustedPrimitive("child", {
+          source: { type: "execution", executionId: parent.id },
+          correlationId: parent.correlationId,
+        })
+        const child = await storage.executions.create({
+          ...childInput,
+          requesterGroupIds: undefined,
+        })
+        expect(child.requesterGroupIds).toEqual(["finance", "support"])
+        ;(child.requesterGroupIds as string[]).push("mutated")
+        await expect(
+          storage.executions.getById({ projectId, id: child.id })
+        ).resolves.toMatchObject({ requesterGroupIds: ["finance", "support"] })
+        await expect(
+          storage.executions.create({
+            ...childInput,
+            id: "wrong-groups",
+            requesterGroupIds: ["support"],
+          })
+        ).rejects.toMatchObject({ code: "invalid_parent_execution" })
+        const next = await storage.executions.create({
+          ...principalRequest({ id: "next" }),
+          requesterGroupIds: undefined,
+        })
+        expect(next.requesterGroupIds).toEqual(["support"])
+      })
+    })
+
     test("round-trips every durable executor and authority shape", async () => {
       await withStorage(async (storage) => {
         await seedAuth(storage.auth)
@@ -69,7 +119,10 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
           const creationStartedAt = new Date()
           const created = await storage.executions.create(input)
           const { createdAt: persistedAt, ...persistedInput } = created
-          expect(persistedInput).toEqual(input)
+          expect(persistedInput).toEqual({
+            ...input,
+            requesterGroupIds: input.requesterGroupIds ?? [],
+          })
           expect(Number.isFinite(persistedAt.getTime())).toBe(true)
           expect(persistedAt.getTime()).toBeGreaterThanOrEqual(creationStartedAt.getTime())
           expect(
@@ -395,6 +448,7 @@ function principalRequest(input: {
     id: input.id,
     projectId,
     requestedBy: principal,
+    requesterGroupIds: [],
     executor: { type: "request", requestId: `request-${input.id}` },
     source: { type: "http", requestId: `request-${input.id}` },
     correlationId: input.id === "parent" ? "correlation-parent" : `correlation-${input.id}`,
@@ -410,6 +464,7 @@ function disabledRequest(id: string, inputProjectId = projectId): CreateExecutio
   return {
     id,
     projectId: inputProjectId,
+    requesterGroupIds: [],
     executor: { type: "request", requestId: `request-${id}` },
     source: { type: "http", requestId: `request-${id}` },
     correlationId: `correlation-${id}`,
@@ -445,6 +500,7 @@ function trustedPrimitive(
     id,
     projectId,
     requestedBy: { type: "user", id: "user-one" },
+    requesterGroupIds: [],
     executor: { type: "primitive", kind, runId },
     source: trustedPrimitiveSource(kind, id),
     correlationId: `correlation-${id}`,
@@ -491,6 +547,7 @@ function agentExecution(id: string): CreateExecutionInput {
     id,
     projectId,
     requestedBy: { type: "user", id: "user-one" },
+    requesterGroupIds: [],
     executor: { type: "agent", runId: `run-${id}` },
     source: { type: "execution", executionId: "principal-request" },
     correlationId: "correlation-principal-request",
@@ -507,6 +564,7 @@ function kernelExecution(id: string): CreateExecutionInput {
     id,
     projectId,
     executor: { type: "kernel", operation },
+    requesterGroupIds: [],
     source: { type: "event", eventId: `event-${id}` },
     correlationId: `correlation-${id}`,
     authorizationRef: { type: "kernel", operation },

package/src/testing/execution.ts

@@ -1,6 +1,7 @@
 import type { AuthorizationContext } from "../authorization"
 import { createTestingScope } from "../execution/scopes"
 import type { ExecutionScope } from "../execution/types"
+import { bindModelExecutionAttempt } from "../models/execution/binding"
 import type { OntologySource } from "../ontology"
 import { SixbHost, type SixbHostOptions } from "../runtime/host"
 import { isBoundSixb, type Sixb } from "../runtime/sixb"
@@ -8,6 +9,7 @@ import { isBoundSixb, type Sixb } from "../runtime/sixb"
 export type { AuthorizationContext } from "../authorization"
 
 export interface TestExecutionOptions {
+  readonly signal?: AbortSignal
   readonly authorization?: AuthorizationContext
   readonly executionId?: string
   readonly requestId?: string
@@ -44,5 +46,9 @@ export function createTestSixb<
   if (!isBoundSixb<TOntologySources>(sixb)) {
     throw new Error("[Sixb] Test host did not return an execution-bound Sixb SDK.")
   }
+  bindModelExecutionAttempt(sixb.models, {
+    attempt: 1,
+    signal: options.signal ?? new AbortController().signal,
+  })
   return sixb
 }

package/src/testing/index.ts

@@ -59,6 +59,7 @@ export {
   type ExecutionStorageContractSuiteOptions,
   runExecutionStorageContractSuite,
 } from "./execution-storage-contract"
+export { runLakeChangesContractSuite } from "./lake-changes-contract"
 export {
   type LakeMergeStorageContractSuiteOptions,
   runLakeMergeStorageContractSuite,

package/src/testing/lake-changes-contract.ts

@@ -0,0 +1,240 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { col, defineDataset } from "../datasets"
+import type { DatasetChanges, DatasetRow, DatasetRowChange, LakeStorage } from "../lake-storage"
+
+export function runLakeChangesContractSuite<T extends LakeStorage>(
+  name: string,
+  harness: {
+    readonly createStorage: () => T | Promise<T>
+    readonly teardown?: (storage: T) => void | Promise<void>
+  }
+): void {
+  describe(name, () => {
+    let storage: T
+    const dataset = defineDataset("delta.contract", {
+      schema: [
+        col("id", "string"),
+        col("part", "string"),
+        col("value", "string", { nullable: true }),
+        col("ignored", "string"),
+      ],
+    })
+    const row = (id: string, value: string | null, part = "x", ignored = "unused"): DatasetRow => ({
+      id,
+      part,
+      value,
+      ignored,
+    })
+    const columns = ["id", "part", "value"]
+    beforeEach(async () => {
+      storage = await harness.createStorage()
+      await storage.createDataset(dataset)
+    })
+    afterEach(async () => {
+      if (harness.teardown) await harness.teardown(storage)
+      else await storage.close?.()
+    })
+    async function write(rows: readonly DatasetRow[]) {
+      const writer = await storage.beginWrite({ dataset })
+      await writer.writeRows(rows)
+      return (await writer.commit()).versionId
+    }
+    async function read(fromVersionId: string, toVersionId: string, keyColumns = ["id"]) {
+      if (!storage.readChanges) throw new Error("Provider does not implement readChanges")
+      return storage.readChanges({
+        datasetId: dataset.id,
+        fromVersionId,
+        toVersionId,
+        columns,
+        keyColumns,
+      })
+    }
+    async function collect(reader: DatasetChanges | null) {
+      if (!reader) throw new Error("Expected a complete delta")
+      const changes: DatasetRowChange[] = []
+      try {
+        for await (const change of reader.changes) changes.push(change)
+      } finally {
+        await reader.close()
+      }
+      expect(changes).toHaveLength(reader.changeCount)
+      return changes.sort((a, b) =>
+        JSON.stringify(a.after ?? a.before).localeCompare(JSON.stringify(b.after ?? b.before))
+      )
+    }
+
+    // Red proof: remove the provider's readChanges implementation; this suite must fail.
+    test("compares pinned states across skipped versions, including removals and key changes", async () => {
+      const first = await write([row("A", "one"), row("B", "two"), row("C", "three")])
+      await write([row("A", "temporary"), row("B", "two"), row("C", "three")])
+      const last = await write([row("A", "one"), row("B", "new"), row("D", "three")])
+      const reader = await read(first, last)
+      expect(reader?.fromRowCount).toBe(3)
+      expect(reader?.toRowCount).toBe(3)
+      expect(await collect(reader)).toEqual([
+        {
+          before: { id: "B", part: "x", value: "two" },
+          after: { id: "B", part: "x", value: "new" },
+        },
+        { before: { id: "C", part: "x", value: "three" }, after: null },
+        { before: null, after: { id: "D", part: "x", value: "three" } },
+      ])
+    })
+    test("ignores row order and unrequested columns", async () => {
+      const first = await write([row("A", "one"), row("B", "two")])
+      const last = await write([row("B", "two", "x", "changed"), row("A", "one")])
+      expect(await collect(await read(first, last))).toEqual([])
+      expect(await collect(await read(last, last))).toEqual([])
+    })
+    test("distinguishes null from a value and handles an empty target", async () => {
+      const first = await write([row("A", null)])
+      const second = await write([row("A", "value")])
+      expect(await collect(await read(first, second))).toEqual([
+        {
+          before: { id: "A", part: "x", value: null },
+          after: { id: "A", part: "x", value: "value" },
+        },
+      ])
+      const empty = await write([])
+      expect(await collect(await read(second, empty))).toEqual([
+        { before: { id: "A", part: "x", value: "value" }, after: null },
+      ])
+      expect(await collect(await read(empty, second))).toEqual([
+        { before: null, after: { id: "A", part: "x", value: "value" } },
+      ])
+    })
+    test("supports composite keys without concatenation collisions", async () => {
+      const first = await write([row("a:b", "one", "c"), row("a", "two", "b:c")])
+      const last = await write([row("a:b", "new", "c"), row("a", "two", "b:c")])
+      expect(await collect(await read(first, last, ["id", "part"]))).toEqual([
+        {
+          before: { id: "a:b", part: "c", value: "one" },
+          after: { id: "a:b", part: "c", value: "new" },
+        },
+      ])
+    })
+    test("refuses duplicate keys in either snapshot rather than losing rows", async () => {
+      const first = await write([row("A", "one"), row("A", "two")])
+      const last = await write([row("A", "new")])
+      expect(await read(first, last)).toBeNull()
+      expect(await read(last, first)).toBeNull()
+    })
+    test("refuses blank identities and invalid column requests", async () => {
+      const first = await write([row(" ", "one")])
+      expect(await read(first, first)).toBeNull()
+      await expect(read(first, first, [])).rejects.toThrow("distinct columns")
+      await expect(read(first, first, ["missing"])).rejects.toThrow("distinct columns")
+    })
+    test("releases the connection between yielded changes and closes after early exit", async () => {
+      const first = await write([row("A", "one"), row("B", "two")])
+      const last = await write([row("A", "new"), row("B", "new")])
+      const reader = await read(first, last)
+      expect(reader).not.toBeNull()
+      try {
+        for await (const _change of reader!.changes) {
+          expect((await storage.getLatestVersion(dataset.id))?.versionId).toBe(last)
+          break
+        }
+      } finally {
+        await reader!.close()
+      }
+      expect((await storage.getLatestVersion(dataset.id))?.versionId).toBe(last)
+    })
+    test("pages a complete pinned delta while a newer snapshot is published", async () => {
+      const count = 5_007
+      const first = await write(Array.from({ length: count }, (_, i) => row(String(i), "old")))
+      const last = await write(Array.from({ length: count }, (_, i) => row(String(i), "new")))
+      const reader = await read(first, last)
+      expect(reader?.changeCount).toBe(count)
+      await write([row("later", "unrelated")])
+      const changes = await collect(reader)
+      expect(new Set(changes.map((change) => change.after?.id)).size).toBe(count)
+      expect(
+        changes.every((change) => change.before?.value === "old" && change.after?.value === "new")
+      ).toBe(true)
+    })
+    test("returns complete typed images without exposing mutable stored values", async () => {
+      const typed = defineDataset("delta.typed", {
+        schema: [
+          col("id", "string"),
+          col("payload", "json"),
+          col("at", "timestamp"),
+          col("amount", "int64"),
+        ],
+      })
+      await storage.createDataset(typed)
+      const writeTyped = async (value: number) => {
+        const writer = await storage.beginWrite({ dataset: typed })
+        await writer.writeRows([
+          {
+            id: "a",
+            payload: { nested: [value] },
+            at: "2026-01-01T00:00:00.000Z",
+            amount: "9007199254740993",
+          },
+        ])
+        return (await writer.commit()).versionId
+      }
+      const first = await writeTyped(1)
+      const last = await writeTyped(2)
+      const reader = await storage.readChanges!({
+        datasetId: typed.id,
+        fromVersionId: first,
+        toVersionId: last,
+        keyColumns: ["id"],
+        columns: ["id", "payload", "at", "amount"],
+      })
+      const changes = await collect(reader)
+      expect(changes).toEqual([
+        {
+          before: {
+            id: "a",
+            payload: { nested: [1] },
+            at: "2026-01-01T00:00:00.000Z",
+            amount: "9007199254740993",
+          },
+          after: {
+            id: "a",
+            payload: { nested: [2] },
+            at: "2026-01-01T00:00:00.000Z",
+            amount: "9007199254740993",
+          },
+        },
+      ])
+      ;(changes[0]!.after!.payload as { nested: number[] }).nested.push(3)
+      const rows: DatasetRow[] = []
+      for await (const value of storage.readRows({ datasetId: typed.id, versionId: last }))
+        rows.push(value)
+      expect(rows[0]?.payload).toEqual({ nested: [2] })
+    })
+    test("returns unavailable for a version belonging to another dataset", async () => {
+      const first = await write([row("A", "one")])
+      const other = defineDataset("delta.other", { schema: [col("id", "string")] })
+      await storage.createDataset(other)
+      const writer = await storage.beginWrite({ dataset: other })
+      await writer.writeRows([{ id: "other" }])
+      const otherVersion = await writer.commit()
+      expect(await read(otherVersion.versionId, first)).toBeNull()
+      expect(await read(first, otherVersion.versionId)).toBeNull()
+    })
+    test("can close an unread delta and observes cancellation", async () => {
+      const first = await write([row("A", "one")])
+      const last = await write([row("A", "new")])
+      const reader = await read(first, last)
+      await reader!.close()
+      await reader!.close()
+      const controller = new AbortController()
+      controller.abort(new Error("cancelled delta"))
+      await expect(
+        storage.readChanges!({
+          datasetId: dataset.id,
+          fromVersionId: first,
+          toVersionId: last,
+          columns,
+          keyColumns: ["id"],
+          signal: controller.signal,
+        })
+      ).rejects.toThrow("cancelled delta")
+    })
+  })
+}

package/src/testing/materializer-storage-contract.ts

@@ -19,6 +19,8 @@ import {
   createOntologyMaterializer,
   type OntologyEditOperation,
   ProjectionRegistry,
+  type ProjectionSourceBase,
+  type ProjectionSourceDeletion,
   type ProjectionSourceEntry,
 } from "../materializer"
 import type { ActionRunStorage, ProjectionRunStorage } from "../storage"
@@ -125,6 +127,175 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
   name: string,
   provider: MaterializerStorageContractProvider<TStorage>
 ): void {
+  // Regression: replacing previousSourceRows with only the latest manifest loses "a" at v3.
+  // Removing root retirement checks from cleanup deletes "a" when v1 becomes terminal.
+  test(`${name} retains current roots across deltas, cleanup, overrides and full replacement`, async () => {
+    const createdStorage = await provider.createStorage()
+    const storage = requireContractStorage(createdStorage)
+    let ordinal = 0
+    const projectId = "materializer-storage-contract"
+    const source = { projectionId: devices.id }
+    const materializer = createOntologyMaterializer({
+      projectId,
+      ontology,
+      projections,
+      storage,
+      dependencies: { batching: { sourceStageRows: 1, statePageRows: 1, planChunkRows: 1 } },
+    })
+    const active = async (): Promise<ProjectionSourceBase> => {
+      const current = await materializer.projections.getActive(source)
+      if (!current?.lastCommitId) throw new Error("Missing source head")
+      return { materializationId: current.materializationId, lastCommitId: current.lastCommitId }
+    }
+    const replace = async (
+      values: readonly (ProjectionSourceEntry | ProjectionSourceDeletion)[],
+      base?: ProjectionSourceBase,
+      interleave?: { readonly version: number; readonly beforeSeal?: () => Promise<void> }
+    ) => {
+      const version = interleave?.version ?? ++ordinal
+      const datasetVersion = {
+        datasetId: devices.id,
+        versionId: `delta-v${version}`,
+        createdAt: `2026-01-${String(version).padStart(2, "0")}T00:00:00.000Z`,
+      }
+      const execution = await claim(storage, {
+        runId: `delta-run-${version}`,
+        projectionId: devices.id,
+        protocol: "replacement",
+        datasetVersion,
+      })
+      const bound = await projectionMaterializer(
+        materializer,
+        storage,
+        devices.id,
+        execution.projectionRunId
+      )
+      return bound.projections.replace({
+        source,
+        datasetVersion,
+        execution,
+        entries: (async function* () {
+          yield* entries(values)
+          await interleave?.beforeSeal?.()
+        })(),
+        ...(base ? { base } : {}),
+      })
+    }
+    const ref = (primaryId: string) => ({ objectTypeId: Device.id, primaryId })
+    const object = (id: string) => storage.objects.getByPrimaryId({ projectId, ...ref(id) })
+    const remove = (id: string): ProjectionSourceDeletion => ({
+      root: { kind: "object", ref: ref(id) },
+      deleted: true,
+    })
+    try {
+      await replace([sourceEntry("a", "A"), sourceEntry("b", "B", "a"), sourceEntry("c", "C")])
+      const stale = await active()
+      const initialA = await object("a")
+      const initialB = await object("b")
+      const transact = storage.transaction.bind(storage)
+      // Fail after finalize has moved the source pointers, written the commit and its outbox.
+      // Removing the enclosing transaction rollback must fail these head/value assertions.
+      storage.transaction = (run, options) =>
+        transact(async (tx) => {
+          const materializations = new Proxy(tx.ontology.materializations, {
+            get(target, key) {
+              if (key !== "finalize") return Reflect.get(target, key)
+              return async (input: Parameters<typeof target.finalize>[0]) => {
+                await target.finalize(input)
+                throw new Error("injected after source activation")
+              }
+            },
+          })
+          const ontology = new Proxy(tx.ontology, {
+            get(target, key) {
+              return key === "materializations" ? materializations : Reflect.get(target, key)
+            },
+          })
+          return run(
+            new Proxy(tx, {
+              get(target, key) {
+                return key === "ontology" ? ontology : Reflect.get(target, key)
+              },
+            })
+          )
+        }, options)
+      try {
+        await expect(replace([remove("a"), sourceEntry("b", "Failed B")], stale)).rejects.toThrow(
+          "injected after source activation"
+        )
+      } finally {
+        storage.transaction = transact
+      }
+      expect(await active()).toEqual(stale)
+      expect(await object("a")).toEqual(initialA)
+      expect(await object("b")).toEqual(initialB)
+      await replace([sourceEntry("b", "B2", "c")], await active())
+      await replace([sourceEntry("c", "C2")], await active())
+      expect(await object("a")).toEqual(initialA)
+      expect(await object("b")).toMatchObject({ properties: { name: "B2" } })
+      for (let pass = 0; pass < 20; pass++) {
+        const result = await storage.ontology.sources.cleanupTerminal({
+          projectId,
+          terminalBefore: "2100-01-01T00:00:00.000Z",
+          limit: 2,
+        })
+        if (result.rowsDeleted + result.materializationsDeleted === 0) break
+      }
+      const scoped = materializer.withScope(runtimeScope())
+      const edit = (operations: readonly OntologyEditOperation[]) =>
+        scoped.edits.commit({
+          mode: "atomic",
+          source: { kind: "runtime", requestId: `delta-edit-${++ordinal}` },
+          operations,
+          expectedObjects: [],
+          expectedLinks: [],
+          expectedLinkScopes: [],
+        })
+      await edit([
+        { id: "edit-a", kind: "object.upsert", ref: ref("a"), properties: { name: "Edited A" } },
+      ])
+      await edit([
+        { id: "reset-a", kind: "object.patch", ref: ref("a"), set: {}, unset: [], reset: ["name"] },
+      ])
+      expect(await object("a")).toMatchObject({ properties: { name: "A" } })
+      await replace([], await active())
+      expect(await object("a")).toMatchObject({ properties: { name: "A" } })
+      await expect(replace([remove("a")], stale)).rejects.toMatchObject({
+        kind: "source-materialization",
+      })
+      expect(await object("a")).not.toBeNull()
+      await replace([remove("a")], await active())
+      expect(await object("a")).toBeNull()
+      expect(await object("b")).toMatchObject({ properties: { name: "B2" } })
+      await replace([sourceEntry("b", "B3")])
+      expect(await object("b")).toMatchObject({ properties: { name: "B3" } })
+      expect(await object("c")).toBeNull()
+      await replace([], await active())
+      expect(await object("b")).toMatchObject({ properties: { name: "B3" } })
+      await replace([])
+      expect(await object("b")).toBeNull()
+
+      // A different run commits after base validation but before this candidate is sealed.
+      // Only checking the base before reading the delta would allow a stale publication here.
+      const base = await active()
+      const earlier = ++ordinal
+      const later = ++ordinal
+      await expect(
+        replace([sourceEntry("a", "Stale delta")], base, {
+          version: later,
+          beforeSeal: async () => {
+            await replace([sourceEntry("a", "Concurrent value")], base, { version: earlier })
+          },
+        })
+      ).rejects.toMatchObject({ kind: "source-materialization" })
+      expect(await object("a")).toMatchObject({ properties: { name: "Concurrent value" } })
+      await replace([sourceEntry("a", "Fresh delta")], await active())
+      expect(await object("a")).toMatchObject({ properties: { name: "Fresh delta" } })
+    } finally {
+      await provider.cleanup?.(createdStorage)
+    }
+  })
+
   test(`${name} persists replacement, Action, and telemetry commits atomically`, async () => {
     const createdStorage = await provider.createStorage()
     const storage = requireContractStorage(createdStorage)
@@ -811,7 +982,7 @@ function sourceEntry(id: string, name: string, parentId?: string): ProjectionSou
   }
 }
 
-async function* entries(values: readonly ProjectionSourceEntry[]) {
+async function* entries(values: readonly (ProjectionSourceEntry | ProjectionSourceDeletion)[]) {
   for (const value of values) yield value
 }
 

package/src/testing/ontology-storage-contract.ts

@@ -383,6 +383,13 @@ export function runOntologyStorageContractSuite<TStorage extends OntologyStorage
             limit: 1,
           })
         ).toEqual({ rowsDeleted: 1, materializationsDeleted: 0 })
+        expect(
+          await storage.ontology.sources.cleanupTerminal({
+            projectId: "contract-project",
+            terminalBefore: "2026-02-01T00:00:00.000Z",
+            limit: 1,
+          })
+        ).toEqual({ rowsDeleted: 1, materializationsDeleted: 0 })
         expect(
           await storage.ontology.sources.cleanupTerminal({
             projectId: "contract-project",

package/src/testing/projection-run-storage-contract.ts

@@ -256,6 +256,40 @@ export function runProjectionRunStorageContractSuite<TStorage extends Projection
       })
     })
 
+    test("persists independent incremental progress across reclaim without a physical-row floor", async () => {
+      await withStorage(async (context) => {
+        const storage = context.projectionRuns
+        await admitProjectionRun(context, replacementInput("delta-progress"))
+        const first = await storage.startOrReclaim(replacementInput("delta-progress"))
+        const updated = await storage.update({
+          ...executionInput(first),
+          progress: { sourceChangesRead: 12 },
+        })
+        expect(updated.progress).toEqual({
+          sourceRowsRead: 0,
+          sourceRowsSkipped: 0,
+          sourceChangesRead: 12,
+        })
+        const second = await storage.startOrReclaim(replacementInput("delta-progress"))
+        expect(second.run.progress).toEqual(updated.progress)
+        await expect(
+          storage.update({ ...executionInput(first), progress: { sourceChangesRead: 13 } })
+        ).rejects.toThrow()
+        await expect(
+          storage.update({ ...executionInput(second), progress: { sourceChangesRead: 11 } })
+        ).rejects.toThrow("must not decrease")
+        const fallback = await storage.update({
+          ...executionInput(second),
+          progress: { sourceRowsRead: 2 },
+        })
+        expect(fallback.progress).toEqual({
+          sourceRowsRead: 2,
+          sourceRowsSkipped: 0,
+          sourceChangesRead: 12,
+        })
+      })
+    })
+
     test("rejects immutable dataset-version metadata reuse", async () => {
       await withStorage(async (context) => {
         await admitProjectionRun(context, replacementInput("dataset-metadata-first"))

package/src/testing/workflow-execution.ts

@@ -10,6 +10,7 @@ export async function createTestWorkflowExecution(
     readonly runId: string
     readonly executionId?: string
     readonly requestedBy?: AuthorizablePrincipal
+    readonly requesterGroupIds?: readonly string[]
   }
 ): Promise<string> {
   const parentExecutionId = `test_request_execution:${input.runId}`
@@ -22,6 +23,7 @@ export async function createTestWorkflowExecution(
 
   await executions.create({
     id: parentExecutionId,
+    requesterGroupIds: input.requesterGroupIds ?? [],
     projectId: input.projectId,
     executor: { type: "request", requestId: `test_request:${input.runId}` },
     source: { type: "http", requestId: `test_request:${input.runId}` },
@@ -34,6 +36,7 @@ export async function createTestWorkflowExecution(
   })
   await executions.create({
     id: executionId,
+    requesterGroupIds: input.requesterGroupIds ?? [],
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: { type: "execution", executionId: parentExecutionId },
@@ -66,6 +69,7 @@ export async function createTestAutomaticWorkflowExecution(
 
   await executions.create({
     id: executionId,
+    requesterGroupIds: [],
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: input.source ?? { type: "event", eventId: `test_event:${input.runId}` },