@hotmeshio/long-tail 0.28.3 → 0.28.4

package/build/services/machines/gateway/plan-machine.js

@@ -141,7 +141,7 @@ function planJob(state, m, b, at, ttl) {
         const released = releasedAction(row, m, b);
         if (b.result === protocol_1.JOB_RESULT.OK)
             return ack([released]);
-        return ack([released, ...(0, plan_shared_1.failHandoff)(state, row, m, {
+        return ack([(0, plan_shared_1.holdForResolver)(row, m), released, ...(0, plan_shared_1.failHandoff)(state, row, m, {
                 received: false, unitId, errorCode: contracts_1.HANDOFF_ERROR.SENDER_REJECTED, result: b.result, reason: b.reason ?? null,
                 detail: `${m} finished ${unitId}: ${b.result}${b.reason ? ` (${b.reason})` : ''}`,
             })]);

package/build/services/machines/gateway/plan-shared.d.ts

@@ -18,3 +18,11 @@ export declare function cancelDispatch(state: GatewayState, row: HandoffRow): Ac
  * claimant may resolve a claimed row); `reportedBy` names who saw the failure.
  */
 export declare function failHandoff(state: GatewayState, row: HandoffRow, reporter: Actor, resolution: HandoffResolution): Action[];
+/** Who resolves a failed handoff: the receiver while it holds the claim, otherwise whoever reports. */
+export declare function resolverOf(row: HandoffRow, reporter: Actor): Actor;
+/**
+ * The row claimed for its resolver before anything else is written to it. A
+ * claimed row refuses every other resolver, so what the machine writes next
+ * and the resolution that follows land on a row nobody else can end meanwhile.
+ */
+export declare function holdForResolver(row: HandoffRow, reporter: Actor): Action;

package/build/services/machines/gateway/plan-shared.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cancelJobs = cancelJobs;
 exports.cancelDispatch = cancelDispatch;
 exports.failHandoff = failHandoff;
+exports.resolverOf = resolverOf;
+exports.holdForResolver = holdForResolver;
 const contracts_1 = require("../contracts");
 const protocol_1 = require("../../../lib/machines/protocol");
 const jobs_1 = require("./jobs");
@@ -32,7 +34,19 @@ function cancelDispatch(state, row) {
  * claimant may resolve a claimed row); `reportedBy` names who saw the failure.
  */
 function failHandoff(state, row, reporter, resolution) {
-    const claimant = row.dispatch === state_1.DISPATCH_STATE.ACCEPTED && row.toMachine ? row.toMachine : reporter;
+    const claimant = resolverOf(row, reporter);
     const payload = claimant === reporter ? { ...resolution } : { ...resolution, reportedBy: reporter };
     return [{ kind: 'resolve', as: claimant, rowId: row.id, payload }, ...cancelDispatch(state, row)];
 }
+/** Who resolves a failed handoff: the receiver while it holds the claim, otherwise whoever reports. */
+function resolverOf(row, reporter) {
+    return row.dispatch === state_1.DISPATCH_STATE.ACCEPTED && row.toMachine ? row.toMachine : reporter;
+}
+/**
+ * The row claimed for its resolver before anything else is written to it. A
+ * claimed row refuses every other resolver, so what the machine writes next
+ * and the resolution that follows land on a row nobody else can end meanwhile.
+ */
+function holdForResolver(row, reporter) {
+    return { kind: 'claim', as: resolverOf(row, reporter), rowId: row.id };
+}

package/docs/machines.md

@@ -115,7 +115,7 @@ When a sender finishes a unit, the gateway records the release on the row and, i
 | `trace` | One entry per unit: `{ unitId, machineId, jobId, result, materials: [{ material, lot }] }` |
 | `lots` | Every lot those units consumed, once each |
 
-Both are containment-searchable, so the rows that used a lot, and with them the units, are one query: `GET /escalations?facets={"lots":["LOT-7"]}`. A unit's whole path is every handoff row whose `units` holds it. The sender's full finished record stays on the row as its `released:<unit>` item. A codec maps its own lot fields into `materials`.
+Both are containment-searchable, so the rows that used a lot, and with them the units, are one query: `GET /escalations?facets={"lots":["LOT-7"]}`. A unit's whole path is every handoff row whose `units` holds it. The sender's full finished record stays on the row as its `released:<unit>` item. When that record is not ok, the row is first claimed for the machine that resolves it, so the record and the `sender-rejected` resolution land on a row no receiver can end in between. A codec maps its own lot fields into `materials`.
 
 ### Job lifecycle on the row
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/long-tail",
-  "version": "0.28.3",
+  "version": "0.28.4",
   "description": "Long Tail Workflows — Durable AI workflows with human-in-the-loop escalation. Powered by PostgreSQL.",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",