@crewhaus/branch-history 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/branch-history",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Branch + diff helpers over checkpoint-store — time-travel utilities for the GRPH target",
   "main": "src/index.ts",
@@ -12,14 +12,14 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/checkpoint-store": "0.0.0",
-    "@crewhaus/errors": "0.0.0"
+    "@crewhaus/checkpoint-store": "0.1.2",
+    "@crewhaus/errors": "0.1.2"
   },
   "license": "Apache-2.0",
   "author": {
     "name": "Max Meier",
-    "email": "max@studiomax.io",
-    "url": "https://studiomax.io"
+    "email": "max@crewhaus.ai",
+    "url": "https://crewhaus.ai"
   },
   "repository": {
     "type": "git",
@@ -31,12 +31,7 @@
     "url": "https://github.com/crewhaus/factory/issues"
   },
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
-  "files": [
-    "src",
-    "README.md",
-    "LICENSE",
-    "NOTICE"
-  ]
+  "files": ["src", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.test.ts

@@ -76,4 +76,50 @@ describe("diff", () => {
     expect(d[0]?.kind).toBe("same");
     expect(d[1]?.kind).toBe("only-a");
   });
+
+  test("only-b reported when run B is longer than run A", async () => {
+    const a = newGraphRunId();
+    const b = newGraphRunId();
+    await store.save({ graphRunId: a, nodeName: "x", state: 0 });
+    await store.save({ graphRunId: b, nodeName: "x", state: 0 });
+    await new Promise((r) => setTimeout(r, 10));
+    const extra = await store.save({ graphRunId: b, nodeName: "y", state: 1 });
+    const d = await diff(store, a, b);
+    expect(d.length).toBe(2);
+    expect(d[0]?.kind).toBe("same");
+    expect(d[1]?.kind).toBe("only-b");
+    // The only-b row carries B's checkpoint metadata and no `a` side.
+    expect(d[1]?.a).toBeUndefined();
+    expect(d[1]?.b?.checkpointId).toBe(extra.id);
+    expect(d[1]?.b?.nodeName).toBe("y");
+    expect(typeof d[1]?.b?.stateHash).toBe("string");
+  });
+});
+
+describe("stateHash (via diff)", () => {
+  // Regression: a checkpoint whose `state` serializes to `undefined`
+  // (e.g. `state: undefined`) once crashed `diff` with a TypeError from
+  // `createHash().update(undefined)`. It must now hash to a stable sentinel.
+  test("checkpoints with undefined state diff without throwing", async () => {
+    const a = newGraphRunId();
+    const b = newGraphRunId();
+    await store.save({ graphRunId: a, nodeName: "x", state: undefined });
+    await store.save({ graphRunId: b, nodeName: "x", state: undefined });
+    const d = await diff(store, a, b);
+    expect(d.length).toBe(1);
+    // Two undefined states hash identically, so the row is `same`.
+    expect(d[0]?.kind).toBe("same");
+    expect(d[0]?.a?.stateHash).toBe(d[0]?.b?.stateHash);
+  });
+
+  test("undefined state differs from a defined state", async () => {
+    const a = newGraphRunId();
+    const b = newGraphRunId();
+    await store.save({ graphRunId: a, nodeName: "x", state: undefined });
+    await store.save({ graphRunId: b, nodeName: "x", state: { v: 1 } });
+    const d = await diff(store, a, b);
+    expect(d.length).toBe(1);
+    expect(d[0]?.kind).toBe("state-mismatch");
+    expect(d[0]?.a?.stateHash).not.toBe(d[0]?.b?.stateHash);
+  });
 });

package/src/index.ts

@@ -45,7 +45,12 @@ export type BranchAtResult = {
 };
 
 function stateHash(c: Checkpoint): string {
-  return createHash("sha256").update(JSON.stringify(c.state)).digest("hex").slice(0, 16);
+  // `JSON.stringify` returns `undefined` for `state === undefined` (and for
+  // values that serialize to nothing, e.g. functions/symbols). Feeding that
+  // straight into `createHash().update()` throws a TypeError, so coalesce to a
+  // stable sentinel — every other state serializes unchanged, preserving hashes.
+  const serialized = JSON.stringify(c.state) ?? "undefined";
+  return createHash("sha256").update(serialized).digest("hex").slice(0, 16);
 }
 
 export async function branchAt(