@prjct.app/pi-team 0.5.4 → 0.5.5

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.5.5](https://github.com/prjct-app/pi-team/compare/v0.5.4...v0.5.5) (2026-09-10)
+
+### Performance Improvements
+
+* carry the canonical payload serialization instead of recomputing it ([#24](https://github.com/prjct-app/pi-team/issues/24)) ([340c495](https://github.com/prjct-app/pi-team/commit/340c4954358e715c6aed5e37e9f0a78f33100877))
+
 ## [0.5.4](https://github.com/prjct-app/pi-team/compare/v0.5.3...v0.5.4) (2026-09-10)
 
 ### Performance Improvements

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prjct.app/pi-team",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "Coordinate independent PI Agent sessions with local team messaging, queued tasks, and shared results.",
   "type": "module",
   "keywords": [

package/src/mailbox.ts

@@ -150,15 +150,22 @@ export class Mailbox {
     for (const attempt of ATTEMPTS) {
       const record = await this.readState(team);
       const state = record.payload;
-      const before = JSON.stringify(state);
+      // The parser already produced this for the content hash. A pre-envelope
+      // record carries none, so that path serializes as before. A mismatch
+      // could only ever cause one redundant publication, never a lost write:
+      // `before` comes from the pre-action object and `after` from the
+      // post-action one, so they cannot coincide by accident.
+      const before = record.payloadJson ?? JSON.stringify(state);
       const presence = await this.readPresence(team);
       const swept = state.members.filter(member => member.status !== 'offline' && !this.alive(member, presence));
       for (const member of swept) this.disconnect(state, member);
       const result = action(state);
-      if (before === JSON.stringify(state)) return result;
+      const after = JSON.stringify(state);
+      if (before === after) return result;
       if (!Value.Check(StateSchema, state)) throw new Error('Invalid mailbox format; refusing to write');
       try {
-        await publish(this.recordPath(team), record.revision, state, this.normalize(team), { maxBytes: MAX_BYTES });
+        await publish(this.recordPath(team), record.revision, state, this.normalize(team),
+          { maxBytes: MAX_BYTES, payloadJson: after });
         await Promise.all(swept.map(member => unlink(this.presencePath(team, member.alias)).catch(() => {})));
         return result;
       } catch (error) {
@@ -223,7 +230,14 @@ export class Mailbox {
     await this.writePresence(member, status);
   }
 
-  /** Lock-free consistent view of the record with presence-based statuses. */
+  /**
+   * Lock-free consistent view of the record with presence-based statuses.
+   *
+   * The cached read returns a shared record, and the message objects below are
+   * the record's own, not copies. Never mutate them: it would corrupt both the
+   * process-wide cache and the `payloadJson` taken alongside it. `mutate` is
+   * safe because it reads uncached.
+   */
   async snapshot(member: Membership): Promise<Snapshot> {
     const record = await this.readState(member.team, true);
     this.owner(record.payload, member);

package/src/store.ts

@@ -14,7 +14,13 @@ import { dirname, join } from 'node:path';
  * hard-links its envelope into a bounded revisions/ history, which doubles as
  * recovery evidence for interrupted writes.
  */
-export type Record<T> = { revision: number; payload: T };
+/**
+ * `payloadJson` is the canonical `JSON.stringify(payload)`, carried when the
+ * parser already had to compute it for the content hash. It is consistent by
+ * construction, never derived from the raw file text, and always optional: a
+ * pre-envelope record has none and callers fall back to serializing.
+ */
+export type Record<T> = { revision: number; payload: T; payloadJson?: string };
 /** Parse raw file bytes into a record, throwing on corruption. Never deletes. */
 export type Normalize<T> = (raw: string) => Record<T>;
 /**
@@ -46,10 +52,11 @@ export function envelope<T>(raw: string): Record<T> {
   if (typeof parsed.revision !== 'number' || !Number.isSafeInteger(parsed.revision) || parsed.revision < 1) {
     throw Object.assign(new Error('Invalid record revision.'), { code: 'CORRUPT_RECORD' });
   }
-  if (parsed.contentHash !== sha256(JSON.stringify(parsed.payload))) {
+  const payloadJson = JSON.stringify(parsed.payload);
+  if (parsed.contentHash !== sha256(payloadJson)) {
     throw Object.assign(new Error('Record hash mismatch; preserved for manual recovery.'), { code: 'CORRUPT_RECORD' });
   }
-  return { revision: parsed.revision, payload: parsed.payload as T };
+  return { revision: parsed.revision, payload: parsed.payload as T, payloadJson };
 }
 
 function assertSafeFile(path: string, info: { isFile(): boolean; size: number; mode: number; uid: number }, maxBytes: number): void {
@@ -162,7 +169,7 @@ async function pruneRevisions(dir: string, latest: number): Promise<void> {
  */
 export async function publish<T>(
   path: string, expectedRevision: number, payload: T, normalize: Normalize<T>,
-  options: { maxBytes: number; durability?: Durability },
+  options: { maxBytes: number; durability?: Durability; payloadJson?: string },
 ): Promise<Record<T>> {
   const durability = options.durability ?? 'full';
   await mkdir(dirname(path), { recursive: true, mode: 0o700 });
@@ -175,12 +182,15 @@ export async function publish<T>(
       throw Object.assign(new Error(`Record changed before the write; current revision is ${revision}.`), { code: 'STALE_REVISION' });
     }
     const next = revision + 1;
-    const payloadJson = JSON.stringify(payload);
+    // Supplied by callers that already serialized this exact object; it must
+    // equal JSON.stringify(payload). The record stays self-consistent either
+    // way, because the hash is taken over the string that gets embedded.
+    const payloadJson = options.payloadJson ?? JSON.stringify(payload);
     const text = `{"schemaVersion":1,"revision":${next},"contentHash":"${sha256(payloadJson)}","payload":${payloadJson}}`;
     if (Buffer.byteLength(text) > options.maxBytes) throw new Error('Record size limit exceeded.');
     const historyPath = join(dirname(path), 'revisions', `${next}.json`);
     const previous = await readRecord(historyPath, (raw: string) => envelope<T>(raw), options.maxBytes);
-    if (previous && (previous.revision !== next || sha256(JSON.stringify(previous.payload)) !== sha256(payloadJson))) {
+    if (previous && (previous.revision !== next || (previous.payloadJson ?? JSON.stringify(previous.payload)) !== payloadJson)) {
       throw new Error('An interrupted publication owns this revision; explicit recovery is required.');
     }
     if (!previous) await writeAtomic(historyPath, text, durability);
@@ -195,7 +205,7 @@ export async function publish<T>(
     cache.delete(path);
     counters.publishes++;
     await pruneRevisions(dirname(path), next).catch(() => {});
-    return { revision: next, payload };
+    return { revision: next, payload, payloadJson };
   } finally {
     await lock.close();
     await unlink(lockPath).catch(() => {});