@abelxiaoxing/cadence 1.1.0 → 1.1.1

package/src/run-state.ts

@@ -47,6 +47,11 @@ export interface DeliveryBindingProjection {
   gate: DeliveryGate;
   revision: number;
   receiptHash: string;
+  approvalProof?: {
+    revision: number;
+    contractHash: string;
+    recordHash: string;
+  };
 }
 
 export interface RunProjection {
@@ -133,6 +138,7 @@ const LEGAL_TRANSITIONS: Readonly<Record<RunState, readonly RunState[]>> = {
     "running",
     "approval-needed",
     "recovering",
+    "completed",
     "discarded",
     "rejected",
   ],
@@ -263,12 +269,31 @@ function applyVerifiedEvent(
       const gate = event.payload.gate;
       const revision = event.payload.revision;
       const receiptHash = event.payload.receiptHash;
+      const approvalProof = event.payload.approvalProof;
       if (
         (gate !== "gate-a" && gate !== "gate-b") ||
         !Number.isSafeInteger(revision) ||
         (revision as number) < 1 ||
         typeof receiptHash !== "string" ||
-        !SHA256.test(receiptHash)
+        !SHA256.test(receiptHash) ||
+        (approvalProof !== undefined &&
+          (!approvalProof ||
+            typeof approvalProof !== "object" ||
+            Array.isArray(approvalProof) ||
+            !Number.isSafeInteger(
+              (approvalProof as Record<string, unknown>).revision,
+            ) ||
+            Number((approvalProof as Record<string, unknown>).revision) < 1 ||
+            typeof (approvalProof as Record<string, unknown>).contractHash !==
+              "string" ||
+            !SHA256.test(
+              String((approvalProof as Record<string, unknown>).contractHash),
+            ) ||
+            typeof (approvalProof as Record<string, unknown>).recordHash !==
+              "string" ||
+            !SHA256.test(
+              String((approvalProof as Record<string, unknown>).recordHash),
+            )))
       ) {
         throw new Error("event-integrity-delivery-binding");
       }
@@ -276,13 +301,25 @@ function applyVerifiedEvent(
         gate: gate as DeliveryGate,
         revision: revision as number,
         receiptHash,
+        ...(approvalProof
+          ? {
+              approvalProof: structuredClone(
+                approvalProof as DeliveryBindingProjection["approvalProof"],
+              ),
+            }
+          : {}),
       };
       const existing = projection.deliveryBindings.find(
         (candidate) =>
           candidate.gate === binding.gate &&
           candidate.revision === binding.revision,
       );
-      if (existing && existing.receiptHash !== binding.receiptHash) {
+      if (
+        existing &&
+        (existing.receiptHash !== binding.receiptHash ||
+          canonicalJson(existing.approvalProof) !==
+            canonicalJson(binding.approvalProof))
+      ) {
         throw new Error("event-integrity-delivery-conflict");
       }
       const deliveryBindings = existing

package/src/run-store.ts

@@ -17,7 +17,7 @@ import {
   StateRootError,
 } from "./state-root.ts";
 
-export const RUN_STORE_SCHEMA_VERSION = 2 as const;
+export const RUN_STORE_SCHEMA_VERSION = 4 as const;
 
 const CHANGE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,126}[a-z0-9])?$/u;
 const IDENTIFIER = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
@@ -60,6 +60,11 @@ export interface BindDeliveryInput {
   gate: DeliveryGate;
   revision: number;
   receiptHash: string;
+  approvalProof?: {
+    revision: number;
+    contractHash: string;
+    recordHash: string;
+  };
   operationId: string;
   lease?: OperationLease;
 }
@@ -79,7 +84,7 @@ export interface OperationLeaseStatus {
 
 const SCHEMA = `
   CREATE TABLE IF NOT EXISTS schema_meta (
-    version INTEGER PRIMARY KEY CHECK (version = 2)
+    version INTEGER PRIMARY KEY CHECK (version = 4)
   ) STRICT;
 
   CREATE TABLE IF NOT EXISTS runs (
@@ -103,6 +108,9 @@ const SCHEMA = `
     gate TEXT NOT NULL,
     revision INTEGER NOT NULL,
     receipt_hash TEXT NOT NULL,
+    approval_revision INTEGER,
+    contract_hash TEXT,
+    record_hash TEXT,
     operation_id TEXT NOT NULL,
     PRIMARY KEY (run_id, gate, revision),
     UNIQUE (run_id, operation_id)
@@ -433,7 +441,7 @@ export class RunStore {
     }
     const key = lookupKey(input);
     return this.#transaction(() => {
-      const existing = this.#database
+      let existing = this.#database
         .prepare(
           `SELECT run_id, projection_json FROM runs
            WHERE root_hash = ? AND stage = ? AND lookup_key = ?`,
@@ -441,6 +449,18 @@ export class RunStore {
         .get(this.stateRoot.consumerRootHash, input.stage, key) as
         | RunRow
         | undefined;
+      if (existing) {
+        const projection = parseProjection(existing.projection_json);
+        if (
+          input.stage === "abel-design" &&
+          ["completed", "discarded", "rejected"].includes(projection.state)
+        ) {
+          this.#database
+            .prepare("UPDATE runs SET lookup_key = ? WHERE run_id = ?")
+            .run(`terminal:${existing.run_id}`, existing.run_id);
+          existing = undefined;
+        }
+      }
       if (existing) {
         const replay = this.#operationOutcome(
           existing.run_id,
@@ -561,7 +581,12 @@ export class RunStore {
       (input.gate !== "gate-a" && input.gate !== "gate-b") ||
       !Number.isSafeInteger(input.revision) ||
       input.revision < 1 ||
-      !SHA256.test(input.receiptHash)
+      !SHA256.test(input.receiptHash) ||
+      (input.approvalProof !== undefined &&
+        (!Number.isSafeInteger(input.approvalProof.revision) ||
+          input.approvalProof.revision < 1 ||
+          !SHA256.test(input.approvalProof.contractHash) ||
+          !SHA256.test(input.approvalProof.recordHash)))
     ) {
       throw new Error("invalid-delivery-binding");
     }
@@ -576,14 +601,27 @@ export class RunStore {
     if (replay) return replay;
     const existing = this.#database
       .prepare(
-        `SELECT receipt_hash FROM delivery_bindings
+        `SELECT receipt_hash, approval_revision, contract_hash, record_hash
+         FROM delivery_bindings
          WHERE run_id = ? AND gate = ? AND revision = ?`,
       )
       .get(input.runId, input.gate, input.revision) as
-      | { receipt_hash: string }
+      | {
+          receipt_hash: string;
+          approval_revision: number | null;
+          contract_hash: string | null;
+          record_hash: string | null;
+        }
       | undefined;
     if (existing) {
-      if (existing.receipt_hash !== input.receiptHash) {
+      if (
+        existing.receipt_hash !== input.receiptHash ||
+        existing.approval_revision !==
+          (input.approvalProof?.revision ?? null) ||
+        existing.contract_hash !==
+          (input.approvalProof?.contractHash ?? null) ||
+        existing.record_hash !== (input.approvalProof?.recordHash ?? null)
+      ) {
         throw new Error("delivery-revision-conflict");
       }
       const projection = this.status(input.runId);
@@ -599,20 +637,27 @@ export class RunStore {
     this.#database
       .prepare(
         `INSERT INTO delivery_bindings(
-           run_id, gate, revision, receipt_hash, operation_id
-         ) VALUES (?, ?, ?, ?, ?)`,
+           run_id, gate, revision, receipt_hash, approval_revision,
+           contract_hash, record_hash, operation_id
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
       )
       .run(
         input.runId,
         input.gate,
         input.revision,
         input.receiptHash,
+        input.approvalProof?.revision ?? null,
+        input.approvalProof?.contractHash ?? null,
+        input.approvalProof?.recordHash ?? null,
         input.operationId,
       );
     const projection = this.#appendEvent(input.runId, "delivery-bound", {
       gate: input.gate,
       revision: input.revision,
       receiptHash: input.receiptHash,
+      ...(input.approvalProof
+        ? { approvalProof: structuredClone(input.approvalProof) }
+        : {}),
     });
     this.#recordOperation(
       input.runId,
@@ -643,6 +688,33 @@ export class RunStore {
     });
   }
 
+  bindDeliveriesAtomically(
+    inputs: readonly BindDeliveryInput[],
+    write: (database: DatabaseSync) => void,
+  ): RunProjection {
+    if (inputs.length === 0) throw new Error("delivery-binding-empty");
+    for (const input of inputs) this.#requireDeliveryBinding(input);
+    const runId = inputs[0]?.runId;
+    if (
+      !runId ||
+      inputs.some(
+        (input) =>
+          input.runId !== runId ||
+          (input.lease?.token ?? null) !== (inputs[0]?.lease?.token ?? null),
+      ) ||
+      typeof write !== "function"
+    ) {
+      throw new Error("delivery-binding-write-invalid");
+    }
+    return this.#transaction(() => {
+      let projection: RunProjection | undefined;
+      for (const input of inputs) projection = this.#bindDelivery(input);
+      write(this.#database);
+      if (!projection) throw new Error("delivery-binding-empty");
+      return projection;
+    });
+  }
+
   acquireLease(input: {
     runId: string;
     operationId: string;

package/src/subagent-activity.ts

@@ -1320,7 +1320,7 @@ export function renderActivityCall(
   context?: ActivityRenderContext,
 ): Component {
   const value = asRecord(args);
-  if (typeof value?.command === "string" && value.version === 2) {
+  if (typeof value?.command === "string") {
     if (context?.executionStarted || context?.isError) return new Text("");
     const projected = projectWorkflowActivity(value, { state: "queued" }, 0);
     const display: ActivitySnapshot = {

package/src/verification-capability.ts

@@ -166,17 +166,39 @@ function localExecutable(
   }
 }
 
+function pathApi(
+  platform: NodeJS.Platform,
+  ...values: readonly string[]
+): typeof path.posix {
+  if (platform !== "win32") return path.posix;
+  if (
+    process.platform === "win32" ||
+    values.some(
+      (value) => /^[a-z]:[\\/]/iu.test(value) || value.startsWith("\\\\"),
+    )
+  ) {
+    return path.win32;
+  }
+  // Tests may model Windows executable semantics over a POSIX fixture tree.
+  return path.posix;
+}
+
 function pathWithin(
   root: string,
   candidate: string,
   platform: NodeJS.Platform,
 ): boolean {
-  const normalizedRoot = platform === "win32" ? root.toLowerCase() : root;
-  const normalizedCandidate =
-    platform === "win32" ? candidate.toLowerCase() : candidate;
+  const platformPath = pathApi(platform, root, candidate);
+  const normalizedRoot = platformPath.resolve(root);
+  const relative = platformPath.relative(
+    normalizedRoot,
+    platformPath.resolve(candidate),
+  );
   return (
-    normalizedCandidate === normalizedRoot ||
-    normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`)
+    relative === "" ||
+    (relative !== ".." &&
+      !relative.startsWith(`..${platformPath.sep}`) &&
+      !platformPath.isAbsolute(relative))
   );
 }
 
@@ -261,13 +283,24 @@ function within(root: string, candidate: string): boolean {
   return candidate === root || candidate.startsWith(`${root}${path.sep}`);
 }
 
-function commonDirectory(
+export function commonDirectory(
   left: string,
   right: string,
   platform: NodeJS.Platform = process.platform,
 ): string {
-  const leftParts = path.resolve(left).split(path.sep).filter(Boolean);
-  const rightParts = path.resolve(right).split(path.sep).filter(Boolean);
+  const platformPath = pathApi(platform, left, right);
+  const leftResolved = platformPath.resolve(left);
+  const rightResolved = platformPath.resolve(right);
+  const leftRoot = platformPath.parse(leftResolved).root;
+  const rightRoot = platformPath.parse(rightResolved).root;
+  const comparable = (value: string) =>
+    platform === "win32" ? value.toLowerCase() : value;
+  if (comparable(leftRoot) !== comparable(rightRoot)) return leftRoot;
+
+  const parts = (value: string, root: string) =>
+    platformPath.relative(root, value).split(platformPath.sep).filter(Boolean);
+  const leftParts = parts(leftResolved, leftRoot);
+  const rightParts = parts(rightResolved, rightRoot);
   const common: string[] = [];
   for (
     let index = 0;
@@ -276,15 +309,10 @@ function commonDirectory(
   ) {
     const leftPart = leftParts[index] as string;
     const rightPart = rightParts[index] as string;
-    if (
-      (platform === "win32" ? leftPart.toLowerCase() : leftPart) !==
-      (platform === "win32" ? rightPart.toLowerCase() : rightPart)
-    ) {
-      break;
-    }
+    if (comparable(leftPart) !== comparable(rightPart)) break;
     common.push(leftPart);
   }
-  return path.join(path.parse(path.resolve(left)).root, ...common);
+  return platformPath.join(leftRoot, ...common);
 }
 
 function unsafeMountSource(source: string): boolean {