@milaboratories/pl-middle-layer 1.74.19 → 1.76.0

package/src/model/project_model.ts

@@ -110,6 +110,7 @@ export interface ProjectField {
     | "prodArgs"
     | "currentArgs"
     | "currentPrerunArgs" // Derived args for staging/prerun rendering (from prerunArgs() or args())
+    | "inputsValid" // Model API v2: errors found in currentArgs, none when the block may run, with the fingerprint of those args; present while currentArgs are
     | "prodChainCtx" // Pre-built production context chain node (accumulated prodCtx from all blocks above)
     | "prodCtx"
     | "prodUiCtx"
@@ -122,7 +123,10 @@ export interface ProjectField {
     | "stagingOutput"
     | "stagingCtxPrevious"
     | "stagingUiCtxPrevious"
-    | "stagingOutputPrevious";
+    | "stagingOutputPrevious"
+    // Root action context of the current render. The project holds it so it outlives the render.
+    | "prodActionContext"
+    | "stagingActionContext";
 }
 
 export const FieldsToDuplicate: Set<ProjectField["fieldName"]> = new Set([
@@ -132,6 +136,7 @@ export const FieldsToDuplicate: Set<ProjectField["fieldName"]> = new Set([
   "prodArgs",
   "currentArgs",
   "currentPrerunArgs",
+  "inputsValid",
   "prodCtx",
   "prodUiCtx",
   "prodOutput",
@@ -142,7 +147,7 @@ export function projectFieldName(blockId: string, fieldName: ProjectField["field
 }
 
 const projectFieldPattern =
-  /^(?<blockId>.*)-(?<fieldName>blockPack|blockSettings|blockStorage|inputsValid|prodArgs|currentArgs|currentPrerunArgs|prodChainCtx|prodCtx|prodUiCtx|prodOutput|prodCtxPrevious|prodUiCtxPrevious|prodOutputPrevious|stagingCtx|stagingUiCtx|stagingOutput|stagingCtxPrevious|stagingUiCtxPrevious|stagingOutputPrevious)$/;
+  /^(?<blockId>.*)-(?<fieldName>blockPack|blockSettings|blockStorage|inputsValid|prodArgs|currentArgs|currentPrerunArgs|prodChainCtx|prodCtx|prodUiCtx|prodOutput|prodCtxPrevious|prodUiCtxPrevious|prodOutputPrevious|stagingCtx|stagingUiCtx|stagingOutput|stagingCtxPrevious|stagingUiCtxPrevious|stagingOutputPrevious|prodActionContext|stagingActionContext)$/;
 
 export function parseProjectField(name: string): ProjectField | undefined {
   const match = name.match(projectFieldPattern);

package/src/mutator/project-v3.test.ts

@@ -1,7 +1,9 @@
-import { field, poll, TestHelpers, toGlobalResourceId } from "@milaboratories/pl-client";
+import { field, Pl, poll, TestHelpers, toGlobalResourceId } from "@milaboratories/pl-client";
+import { canonicalJsonBytes } from "@milaboratories/ts-helpers";
 import { getQuickJS } from "quickjs-emscripten";
 import { expect, test } from "vitest";
 import { outputRef } from "../model/args";
+import { argsFingerprint } from "../model/args_derivation";
 import { ProjectHelper } from "../model/project_helper";
 import { blockArgsAuthorKey, projectFieldName } from "../model/project_model";
 import { TestBPPreparer } from "../test/block_packs";
@@ -622,3 +624,105 @@ test("v3 blocks: migrateBlockPack does not crash when args() returns undefined",
     });
   });
 });
+
+test("v3 blocks: every args derivation records the errors found in the args, none when there are none", async () => {
+  const quickJs = await getQuickJS();
+
+  await TestHelpers.withTempRoot(async (pl) => {
+    const prj = await pl.withWriteTx("CreatingProject", async (tx) => {
+      const prjRef = await createProject(tx);
+      tx.createField(field(tx.clientRoot, "prj"), "Dynamic", prjRef);
+      await tx.commit();
+      return await toGlobalResourceId(prjRef);
+    });
+
+    await pl.withWriteTx("AddBlock", async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.addBlock(
+        { id: "enter1", label: "Enter Numbers V3", renderingMode: "Heavy" },
+        { storageMode: "fromModel", blockPack: await TestBPPreparer.prepare(BPSpecEnterV3) },
+      );
+      mut.setStates([
+        {
+          modelAPIVersion: 2,
+          blockId: "enter1",
+          payload: { operation: "update-block-data", value: { numbers: [3, 1, 2] } },
+        },
+      ]);
+      mut.save();
+      await tx.commit();
+    });
+
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const record = await prjR.get(projectFieldName("enter1", "inputsValid"));
+      expect(jsonOf(record.data.data)).toStrictEqual({
+        argsFingerprint: argsFingerprint({ numbers: [1, 2, 3] }),
+        errors: [],
+      });
+    });
+  });
+});
+
+test("v3 blocks: args without an args errors record of their own are kept and run, as before the record", async () => {
+  const quickJs = await getQuickJS();
+
+  await TestHelpers.withTempRoot(async (pl) => {
+    const prj = await pl.withWriteTx("CreatingProject", async (tx) => {
+      const prjRef = await createProject(tx);
+      tx.createField(field(tx.clientRoot, "prj"), "Dynamic", prjRef);
+      await tx.commit();
+      return await toGlobalResourceId(prjRef);
+    });
+
+    await pl.withWriteTx("AddBlock", async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.addBlock(
+        { id: "enter1", label: "Enter Numbers V3", renderingMode: "Heavy" },
+        { storageMode: "fromModel", blockPack: await TestBPPreparer.prepare(BPSpecEnterV3) },
+      );
+      mut.setStates([
+        {
+          modelAPIVersion: 2,
+          blockId: "enter1",
+          payload: { operation: "update-block-data", value: { numbers: [3, 1, 2] } },
+        },
+      ]);
+      mut.save();
+      await tx.commit();
+    });
+
+    // What a middle layer that does not record args errors leaves behind: current args it wrote
+    // itself, and no record of their args errors.
+    await pl.withWriteTx("WriteArgsWithoutRecord", async (tx) => {
+      tx.removeField(field(prj, projectFieldName("enter1", "inputsValid")));
+      tx.setField(
+        field(prj, projectFieldName("enter1", "currentArgs")),
+        tx.createValue(Pl.JsonObject, canonicalJsonBytes({ numbers: [9] })),
+      );
+      await tx.commit();
+    });
+
+    await pl.withWriteTx("Run", async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.renderProduction(["enter1"]);
+      mut.save();
+      await tx.commit();
+    });
+
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      const currentArgs = await prjR.get(projectFieldName("enter1", "currentArgs"));
+      expect(jsonOf(currentArgs.data.data)).toStrictEqual({ numbers: [9] });
+      const prodArgs = await prjR.get(projectFieldName("enter1", "prodArgs"));
+      expect(jsonOf(prodArgs.data.data)).toStrictEqual({ numbers: [9] });
+    });
+  });
+});
+
+// Internals
+
+function jsonOf(data: Uint8Array | undefined): unknown {
+  if (data === undefined) throw new Error("The field holds no data");
+  return JSON.parse(Buffer.from(data).toString());
+}

package/src/mutator/project.ts

@@ -22,6 +22,7 @@ import {
 } from "@milaboratories/pl-client";
 import {
   createRenderHeavyBlock,
+  type BlockActionContextBaggage,
   createBContextFromUpstreams,
   createBContextEnd,
 } from "./template/render_block";
@@ -77,6 +78,14 @@ import {
 } from "@milaboratories/ts-helpers";
 import { gzipSync } from "node:zlib";
 import type { ProjectHelper } from "../model/project_helper";
+import {
+  derivedArgsValue,
+  argsErrorsFieldChange,
+  argsErrorsOfBlock,
+  type DerivedArgs,
+  type ArgsErrorsFieldChange,
+} from "../model/args_derivation";
+import type { ArgsIssue } from "@milaboratories/pl-model-common";
 import {
   extractConfig,
   UiError,
@@ -273,6 +282,24 @@ class BlockInfo {
     return this.currentPrerunArgsC();
   }
 
+  private readonly argsErrorsC = cached(
+    () => `${this.fields.inputsValid?.modCount}:${this.fields.currentArgs?.modCount}`,
+    () =>
+      argsErrorsOfBlock({
+        modelAPIVersion: this.config.modelAPIVersion,
+        inputsValid: this.fields.inputsValid,
+        currentArgs: this.currentArgs,
+      }),
+  );
+
+  /**
+   * The errors the block's `argsIssues()` found in its current args. A block whose model API
+   * version has no args issues, or that has no current args, has none.
+   */
+  get argsErrors(): readonly ArgsIssue[] {
+    return this.argsErrorsC();
+  }
+
   get stagingRendered(): boolean {
     return this.fields.stagingCtx !== undefined;
   }
@@ -706,6 +733,15 @@ export class ProjectMutator {
     return { ref, value: jsonBytes, status: "Ready" };
   }
 
+  /** Baggage of the root action context of a block render. */
+  private blockActionContextBaggage(blockId: string, info: BlockInfo): BlockActionContextBaggage {
+    return {
+      name: this.getBlock(blockId).label,
+      blockPack: JSON.stringify(info.source),
+      blockId,
+    };
+  }
+
   private getBlock(blockId: string): Block {
     for (const block of allBlocks(this.struct)) if (block.id === blockId) return block;
     throw new Error("block not found");
@@ -756,6 +792,32 @@ export class ProjectMutator {
     return deleted;
   }
 
+  /**
+   * Brings the block's `inputsValid` field in line with what its args derivation found: the run
+   * errors of its args, none when it may run with them, and no field when it has no args.
+   */
+  private setArgsErrors(blockId: string, derivedArgs: DerivedArgs): void {
+    this.applyArgsErrorsChange(
+      blockId,
+      argsErrorsFieldChange(this.getBlockInfo(blockId).fields.inputsValid, derivedArgs),
+    );
+  }
+
+  private applyArgsErrorsChange(blockId: string, change: ArgsErrorsFieldChange): void {
+    switch (change.type) {
+      case "keep":
+        return;
+      case "delete":
+        this.deleteBlockFields(blockId, "inputsValid");
+        return;
+      case "write": {
+        const ref = this.tx.createValue(Pl.JsonObject, change.data);
+        this.setBlockField(blockId, "inputsValid", ref, "Ready", change.data);
+        return;
+      }
+    }
+  }
+
   private updateLastModified() {
     this.lastModified = Date.now();
     this.lastModifiedChanged = true;
@@ -782,6 +844,7 @@ export class ProjectMutator {
       this.setBlockFieldObj(blockId, "stagingCtxPrevious", fields.stagingCtx!);
       this.setBlockFieldObj(blockId, "stagingUiCtxPrevious", fields.stagingUiCtx!);
     }
+    this.deleteBlockFields(blockId, "stagingActionContext");
     if (this.deleteBlockFields(blockId, "stagingOutput", "stagingCtx", "stagingUiCtx"))
       this.resetStagingRefreshTimestamp();
   }
@@ -797,7 +860,14 @@ export class ProjectMutator {
       this.setBlockFieldObj(blockId, "prodCtxPrevious", fields.prodCtx!);
       this.setBlockFieldObj(blockId, "prodUiCtxPrevious", fields.prodUiCtx!);
     }
-    this.deleteBlockFields(blockId, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs");
+    this.deleteBlockFields(
+      blockId,
+      "prodOutput",
+      "prodCtx",
+      "prodUiCtx",
+      "prodArgs",
+      "prodActionContext",
+    );
   }
 
   /** Running blocks are reset, settled ones (Ready or finished Error) moved to limbo. Returns if
@@ -826,6 +896,7 @@ export class ProjectMutator {
       return true;
     } else {
       // reset - clean up any partial/inconsistent production stat
+      this.deleteBlockFields(blockId, "prodActionContext");
       return this.deleteBlockFields(
         blockId,
         "prodOutput",
@@ -908,21 +979,16 @@ export class ProjectMutator {
     }
 
     // Derive args from storage - set or clear currentArgs based on derivation result
-    const deriveArgsResult = this.projectHelper.deriveArgsFromStorage(
-      blockConfig,
-      initialStorageJson,
-    );
+    const derivedArgs = this.projectHelper.deriveArgsFromStorage(blockConfig, initialStorageJson);
     // args() legitimately returns undefined when inputs are incomplete/invalid;
     // treat that like a derivation failure and clear the field (never JSON-encode undefined).
-    if (!deriveArgsResult.error && deriveArgsResult.value !== undefined) {
-      this.setBlockFieldObj(
-        blockId,
-        "currentArgs",
-        this.createJsonFieldValue(deriveArgsResult.value),
-      );
+    const args = derivedArgsValue(derivedArgs);
+    if (args !== undefined) {
+      this.setBlockFieldObj(blockId, "currentArgs", this.createJsonFieldValue(args));
     } else {
       this.deleteBlockFields(blockId, "currentArgs");
     }
+    this.setArgsErrors(blockId, derivedArgs);
   }
 
   /** Optimally sets inputs for multiple blocks in one go */
@@ -974,11 +1040,12 @@ export class ProjectMutator {
         );
 
         // Derive args from storage (VM extracts data internally)
-        const derivedArgsResult = this.projectHelper.deriveArgsFromStorage(
+        const derivedArgs = this.projectHelper.deriveArgsFromStorage(
           blockConfig,
           updatedStorageJson,
         );
-        args = derivedArgsResult.error ? undefined : derivedArgsResult.value;
+        args = derivedArgsValue(derivedArgs);
+        this.setArgsErrors(req.blockId, derivedArgs);
       } else {
         this.setBlockFieldObj(req.blockId, "blockStorage", this.createGzJsonFieldValue(req.state));
         if (req.state !== null && typeof req.state === "object" && "args" in req.state) {
@@ -1166,12 +1233,17 @@ export class ProjectMutator {
     const tpl = info.getTemplate(this.tx);
 
     // Use currentPrerunArgs for staging rendering
-    const results = createRenderHeavyBlock(this.tx, tpl, {
-      args: prerunArgsRef,
-      blockId: this.tx.createValue(Pl.JsonString, JSON.stringify(blockId)),
-      isProduction: this.tx.createValue(Pl.JsonBool, JSON.stringify(false)),
-      context: ctx,
-    });
+    const results = createRenderHeavyBlock(
+      this.tx,
+      tpl,
+      {
+        args: prerunArgsRef,
+        blockId: this.tx.createValue(Pl.JsonString, JSON.stringify(blockId)),
+        isProduction: this.tx.createValue(Pl.JsonBool, JSON.stringify(false)),
+        context: ctx,
+      },
+      this.blockActionContextBaggage(blockId, info),
+    );
 
     // Here we set the staging ctx to the input context of the staging workflow, not the output because exports
     // of one staging context should stay within the same block, and not travel downstream.
@@ -1182,6 +1254,8 @@ export class ProjectMutator {
     // thus creating a certain discrepancy between staging workflow context behavior and desktop's result pool.
     this.setBlockField(blockId, "stagingUiCtx", this.exportCtx(results.context), "NotReady");
     this.setBlockField(blockId, "stagingOutput", results.result, "NotReady");
+    if (results.actionContext !== undefined)
+      this.setBlockField(blockId, "stagingActionContext", results.actionContext, "NotReady");
   }
 
   private renderProductionFor(blockId: string) {
@@ -1194,6 +1268,13 @@ export class ProjectMutator {
       throw new Error(`Can't render production for block ${blockId}: currentArgs not set`);
     }
 
+    // Nor if its argsIssues() found errors in them
+    const argsErrors = info.argsErrors;
+    if (argsErrors.length > 0) {
+      const messages = argsErrors.map(({ message }) => message).join("; ");
+      throw new Error(`Can't render production for block ${blockId}: ${messages}`);
+    }
+
     const ctx = this.createProdCtx(this.getPendingProductionGraph().nodes.get(blockId)!.upstream);
 
     if (this.getBlock(blockId).renderingMode === "Light")
@@ -1201,12 +1282,17 @@ export class ProjectMutator {
 
     const tpl = info.getTemplate(this.tx);
 
-    const results = createRenderHeavyBlock(this.tx, tpl, {
-      args: info.fields.currentArgs.ref!,
-      blockId: this.tx.createValue(Pl.JsonString, JSON.stringify(blockId)),
-      isProduction: this.tx.createValue(Pl.JsonBool, JSON.stringify(true)),
-      context: ctx,
-    });
+    const results = createRenderHeavyBlock(
+      this.tx,
+      tpl,
+      {
+        args: info.fields.currentArgs.ref!,
+        blockId: this.tx.createValue(Pl.JsonString, JSON.stringify(blockId)),
+        isProduction: this.tx.createValue(Pl.JsonBool, JSON.stringify(true)),
+        context: ctx,
+      },
+      this.blockActionContextBaggage(blockId, info),
+    );
     this.setBlockField(
       blockId,
       "prodCtx",
@@ -1215,6 +1301,8 @@ export class ProjectMutator {
     );
     this.setBlockField(blockId, "prodUiCtx", this.exportCtx(results.context), "NotReady");
     this.setBlockField(blockId, "prodOutput", results.result, "NotReady");
+    if (results.actionContext !== undefined)
+      this.setBlockField(blockId, "prodActionContext", results.actionContext, "NotReady");
 
     // saving inputs for which we rendered the production
     this.setBlockFieldObj(blockId, "prodArgs", info.fields.currentArgs);
@@ -1266,11 +1354,9 @@ export class ProjectMutator {
       prerunArgs = this.projectHelper.derivePrerunArgsFromStorage(blockConfig, storageToWrite);
 
       // Derive args from storage (VM extracts data internally)
-      const deriveArgsResult = this.projectHelper.deriveArgsFromStorage(
-        blockConfig,
-        storageToWrite,
-      );
-      args = deriveArgsResult.error ? undefined : deriveArgsResult.value;
+      const derivedArgs = this.projectHelper.deriveArgsFromStorage(blockConfig, storageToWrite);
+      args = derivedArgsValue(derivedArgs);
+      this.setArgsErrors(blockId, derivedArgs);
     } else if (spec.storageMode === "legacy") {
       // Model API v1: use legacyState from spec
       const parsedState = JSON.parse(spec.legacyState);
@@ -1560,18 +1646,16 @@ export class ProjectMutator {
         this.deleteBlockFields(blockId, "currentPrerunArgs");
       }
 
-      const deriveArgsResult = this.projectHelper.deriveArgsFromStorage(newConfig, storageJson);
+      const derivedArgs = this.projectHelper.deriveArgsFromStorage(newConfig, storageJson);
       // args() legitimately returns undefined when inputs are incomplete/invalid;
       // treat that like a derivation failure and clear the field (never JSON-encode undefined).
-      if (!deriveArgsResult.error && deriveArgsResult.value !== undefined) {
-        this.setBlockFieldObj(
-          blockId,
-          "currentArgs",
-          this.createJsonFieldValue(deriveArgsResult.value),
-        );
+      const args = derivedArgsValue(derivedArgs);
+      if (args !== undefined) {
+        this.setBlockFieldObj(blockId, "currentArgs", this.createJsonFieldValue(args));
       } else {
         this.deleteBlockFields(blockId, "currentArgs");
       }
+      this.setArgsErrors(blockId, derivedArgs);
     };
 
     if (newClearState !== undefined) {
@@ -1587,6 +1671,9 @@ export class ProjectMutator {
       } else {
         // V1: Use setStates with legacy state format
         persistBlockPack();
+        // A V1 model tells whether the block may run by itself; args errors of an earlier V2 model
+        // no longer apply.
+        this.deleteBlockFields(blockId, "inputsValid");
         this.setStates([{ modelAPIVersion: 1, blockId, state: newClearState.state }]);
       }
     } else {
@@ -1617,6 +1704,9 @@ export class ProjectMutator {
       } else {
         // Legacy blocks (modelAPIVersion 1): persist block pack, set prerunArgs = currentArgs
         persistBlockPack();
+        // A V1 model tells whether the block may run by itself; args errors of an earlier V2 model
+        // no longer apply.
+        this.deleteBlockFields(blockId, "inputsValid");
         if (info.fields.currentArgs !== undefined) {
           this.setBlockFieldObj(blockId, "currentPrerunArgs", info.fields.currentArgs);
         }
@@ -1737,6 +1827,7 @@ export class ProjectMutator {
         // skipping finished blocks
         continue;
 
+      this.deleteBlockFields(blockId, "prodActionContext");
       if (this.deleteBlockFields(blockId, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs")) {
         // was actually stopped
         stopped.push(blockId);

package/src/mutator/project_action_context.test.ts

@@ -0,0 +1,178 @@
+import type { PlClient, SignedResourceId } from "@milaboratories/pl-client";
+import { ActionContextLinkCapability } from "./template/render_block";
+import {
+  ContinuePolling,
+  field,
+  isNullSignedResourceId,
+  parseSignedResourceId,
+  poll,
+  TestHelpers,
+  toGlobalResourceId,
+} from "@milaboratories/pl-client";
+import { getQuickJS } from "quickjs-emscripten";
+import { expect, test } from "vitest";
+import { ProjectHelper } from "../model/project_helper";
+import { projectFieldName } from "../model/project_model";
+import { BPSpecEnterV041NotPrepared, TestBPPreparer } from "../test/block_packs";
+import { readBlockActionContextTree } from "../middle_layer/block_action_context";
+import { createProject, ProjectMutator } from "./project";
+
+type ActionContextBaggage = Record<string, string>;
+
+/** Reads the action context that prodActionContext points to, or undefined if the field is absent.
+ * Polls until the field reference is resolved: it resolves asynchronously after the commit. */
+async function readActionContext(
+  pl: PlClient,
+  prj: Awaited<ReturnType<typeof toGlobalResourceId>>,
+  blockId: string,
+): Promise<
+  { contextId: string; contextRef: SignedResourceId; baggage: ActionContextBaggage } | undefined
+> {
+  return await poll(pl, async ({ tx }) => {
+    const project = await tx.getResourceData(prj, true);
+    const actionContextField = project.fields.find(
+      (f) => f.name === projectFieldName(blockId, "prodActionContext"),
+    );
+    if (actionContextField === undefined) return undefined;
+
+    const contextRef = actionContextField.value;
+    if (isNullSignedResourceId(contextRef)) throw new ContinuePolling();
+    const context = await tx.getResourceData(contextRef, false);
+    expect(context.type.name).toEqual("ActionContext");
+    return {
+      contextId: String(parseSignedResourceId(contextRef).globalId),
+      contextRef,
+      baggage: JSON.parse(Buffer.from(context.data!).toString()) as ActionContextBaggage,
+    };
+  });
+}
+
+/** Returns the render an action context belongs to: the resource of the Running transition that the
+ * workflow controller records when it evaluates the render. The key names the decimal resource ID.
+ * Polls until the transition lands: reports are applied asynchronously after the commit. */
+async function contextRender(pl: PlClient, contextRef: SignedResourceId): Promise<string> {
+  return await poll(pl, async ({ tx }) => {
+    const kv = await tx.listKeyValuesString(contextRef);
+    const running = kv.find((e) => e.key.startsWith("transition/render/"));
+    if (running === undefined) throw new ContinuePolling();
+    expect(JSON.parse(running.value)).toMatchObject({ state: "Running" });
+    return running.key.split("/")[2];
+  });
+}
+
+test("block action context outlives its renderer and is replaced on re-render", async () => {
+  //
+  // Scenario:
+  //  1. Create a project and render production of one block.
+  //  2. Wait until the production output is final.
+  //  3. Without a link capability the render has no action context. Otherwise read the action
+  //     context through prodActionContext and check its baggage.
+  //  4. The context has the Running transition of the render. Wait until the render is garbage
+  //     collected; the context must stay readable.
+  //  5. Re-render production: prodActionContext must point at a new context with a new run-id.
+  //  6. Render and stop production in one transaction: prodActionContext must be removed.
+  //
+
+  const quickJs = await getQuickJS();
+
+  await TestHelpers.withTempRoot(async (pl) => {
+    // 1. Create a project and render production of one block.
+    const prj = await pl.withWriteTx("CreatingProject", async (tx) => {
+      const prjRef = await createProject(tx);
+      tx.createField(field(tx.clientRoot, "prj"), "Dynamic", prjRef);
+      await tx.commit();
+      return await toGlobalResourceId(prjRef);
+    });
+
+    const renderBlock = async (numbers: number[], addBlock: boolean) =>
+      await pl.withWriteTx("RenderBlock", async (tx) => {
+        const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+        if (addBlock)
+          mut.addBlock(
+            { id: "block1", label: "Block1", renderingMode: "Heavy" },
+            {
+              storageMode: "legacy",
+              legacyState: JSON.stringify({ args: { numbers } }),
+              blockPack: await TestBPPreparer.prepare(BPSpecEnterV041NotPrepared),
+            },
+          );
+        else
+          mut.setStates([
+            { modelAPIVersion: 1, blockId: "block1", state: { args: { numbers }, uiState: {} } },
+          ]);
+        mut.renderProduction(["block1"], true);
+        mut.save();
+        await tx.commit();
+      });
+
+    await renderBlock([1, 2, 3], true);
+
+    // 2. Wait until the production output is final.
+    await poll(pl, async (tx) => {
+      const prjR = await tx.get(prj);
+      await prjR.get(projectFieldName("block1", "prodOutput")).then((r) => r.final());
+    });
+
+    // 3. Read the action context through prodActionContext and check its baggage.
+    if (!pl.hasCapability(ActionContextLinkCapability)) {
+      expect(await readActionContext(pl, prj, "block1")).toBeUndefined();
+      return;
+    }
+    const first = (await readActionContext(pl, prj, "block1"))!;
+    expect(first).toBeDefined();
+    expect(Object.keys(first.baggage).sort()).toEqual(["block-id", "block-pack", "name", "run-id"]);
+    expect(first.baggage["block-id"]).toEqual("block1");
+    expect(first.baggage["name"]).toEqual("Block1");
+    expect(JSON.parse(first.baggage["block-pack"])).toBeTypeOf("object");
+    expect(first.baggage["run-id"]).toMatch(/^[0-9a-f-]{36}$/);
+
+    // 4. The Running transition names the render; the context outlives it. The render's own end is
+    //    awaited through its Completed report, which every reader can see: reading the render
+    //    itself needs a signed reference that no field of the project holds once it is done.
+    const firstRender = await contextRender(pl, first.contextRef);
+    await poll(pl, async ({ tx }) => {
+      const kv = await tx.listKeyValuesString(first.contextRef);
+      const completed = kv.some(
+        (e) =>
+          e.key.startsWith(`transition/render/${firstRender}/`) &&
+          JSON.parse(e.value).state === "Completed",
+      );
+      if (!completed) throw new ContinuePolling();
+    });
+    const afterRenderEnd = (await readActionContext(pl, prj, "block1"))!;
+    expect(afterRenderEnd.contextId).toEqual(first.contextId);
+    expect(afterRenderEnd.baggage).toEqual(first.baggage);
+
+    // 4b. The read-back sees the same context with its baggage, and names the render.
+    const tree = (await readBlockActionContextTree(pl, prj, "block1", "prod"))!;
+    expect(tree).toBeDefined();
+    expect(tree.contextId).toEqual(first.contextId);
+    expect(tree.baggage).toEqual(first.baggage);
+    expect(tree.resource).toEqual(firstRender);
+    expect(tree.transitions.map((t) => [t.namespace, t.resource, t.state])).toContainEqual([
+      "render",
+      firstRender,
+      "Running",
+    ]);
+
+    // 5. Re-render production: prodActionContext must point at a new context with a new run-id.
+    await renderBlock([4, 5, 6], false);
+    const second = (await readActionContext(pl, prj, "block1"))!;
+    expect(second.contextId).not.toEqual(first.contextId);
+    expect(second.baggage["run-id"]).not.toEqual(first.baggage["run-id"]);
+    expect(await contextRender(pl, second.contextRef)).not.toEqual(firstRender);
+
+    // 6. Render and stop production in one transaction: prodActionContext must be removed.
+    await pl.withWriteTx("RenderAndStop", async (tx) => {
+      const mut = await ProjectMutator.load(new ProjectHelper(quickJs), tx, prj);
+      mut.setStates([
+        { modelAPIVersion: 1, blockId: "block1", state: { args: { numbers: [7] }, uiState: {} } },
+      ]);
+      mut.renderProduction(["block1"], true);
+      mut.stopProduction("block1");
+      mut.save();
+      await tx.commit();
+    });
+    expect(await readActionContext(pl, prj, "block1")).toBeUndefined();
+  });
+});