@oxy.so/protocol 1.2.2 → 1.3.0

package/dist/types/chain/engine.d.ts

@@ -9,7 +9,7 @@
  * engine owns the verification + ordering policy.
  *
  * Storage and identity are both injected, so the engine has zero knowledge of
- * Mongo/SQLite, Oxy DIDs, or any app's lexicon — exactly what makes it reusable.
+ * the database, Oxy DIDs, or any app's lexicon — exactly what makes it reusable.
  */
 import type { SignedRecordEnvelope } from '@oxy.so/contracts';
 import type { VerificationMethodResolver } from '../identity/resolver';

package/dist/types/chain/recordStore.d.ts

@@ -4,8 +4,8 @@
  * The engine ({@link ./verify}, {@link ./engine}) is storage-agnostic: it owns
  * the verification state machine and continuity logic, and delegates EVERY read
  * and write to an injected {@link RecordStore}. An app supplies a store over its
- * own backend (oxy-api over Mongo `SignedRecord`/`RepoHead`, a node over SQLite,
- * Mention over its own Mongo) without the engine knowing anything Oxy- or
+ * own backend (oxy-api over Postgres `signed_records`/`repo_heads`, a node over
+ * SQLite, Mention over its own database) without the engine knowing anything Oxy- or
  * app-specific.
  *
  * All methods are **subject-keyed**: `subject` is the chain's subject DID
@@ -17,7 +17,7 @@
  * `append` MUST be atomic (record insert + head advance in one unit) and MUST
  * translate a duplicate-key collision on the unique `(subject, seq)` /
  * `recordId` index — i.e. a concurrent writer that already took this `seq` — into
- * `{ ok: false, reason: 'chain_conflict' }` (Mongo E11000 / SQLite
+ * `{ ok: false, reason: 'chain_conflict' }` (Postgres `23505` / SQLite
  * `SQLITE_CONSTRAINT`). That is the real multi-writer race guard; the engine's
  * pre-append continuity check is only the fast-path rejection.
  */

package/dist/types/chain/verify.d.ts

@@ -10,7 +10,8 @@
  *  - the {@link RecordStore} owns the monotonicity frontier + the chain head.
  *
  * The ordered checks (first failure wins):
- *  1. **shape** — the base `signedRecordEnvelopeSchema` (open `type`, opaque
+ *  1. **shape** — the base `signedRecordEnvelopeCheck`, the Zod-free twin of
+ *     `signedRecordEnvelopeSchema` (open `type`, opaque
  *     `record`). An app re-narrows `type` to its own set in its adapter.
  *  2. **signature** — `verifyEnvelopeSignature` recomputes the canonical signing
  *     input and checks the secp256k1 signature against the embedded `publicKey`.
@@ -24,7 +25,7 @@
  * subject?") is intentionally NOT here — it is an adapter-policy decision the
  * caller makes before invoking the engine, not a property of the envelope.
  */
-import { type SignedRecordEnvelope } from '@oxy.so/contracts';
+import type { SignedRecordEnvelope } from '@oxy.so/contracts';
 import { type VerificationMethodResolver } from '../identity/resolver';
 import type { RecordStore } from './recordStore';
 import type { VerifyOutcome } from './types';

package/dist/types/sign.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `@oxy.so/protocol/sign` — message and envelope signatures (secp256k1).
+ *
+ * The same functions the root entry exports, on their own entry so a client
+ * can load the signer (and `@noble/curves` under it) where it signs — inside
+ * `@oxy.so/core/crypto`, which apps load on first use — while the root entry
+ * it imports at startup for hashing and platform loaders stays free of the
+ * curve library once a bundler drops the root's unused re-exports.
+ */
+export { signEnvelope, signMessage, verifyEnvelopeSignature, verifySignature, } from './envelope/sign';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxy.so/protocol",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Oxy Protocol — the app-agnostic base substrate: signed-record envelope, canonical JSON, signature/verification, and platform crypto. Reused by any Oxy app to decentralize its own content.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -15,6 +15,9 @@
       ],
       "random": [
         "dist/types/random.d.ts"
+      ],
+      "sign": [
+        "dist/types/sign.d.ts"
       ]
     }
   },
@@ -71,6 +74,18 @@
       },
       "default": "./dist/esm/random.js"
     },
+    "./sign": {
+      "react-native": "./dist/esm/sign.js",
+      "import": {
+        "types": "./dist/types/sign.d.ts",
+        "default": "./dist/esm/sign.js"
+      },
+      "require": {
+        "types": "./dist/types/sign.d.ts",
+        "default": "./dist/cjs/sign.js"
+      },
+      "default": "./dist/esm/sign.js"
+    },
     "./package.json": "./package.json"
   },
   "react-native": {
@@ -131,7 +146,7 @@
   },
   "dependencies": {
     "@noble/curves": "^1.9.7",
-    "@oxy.so/contracts": "^4.9.0",
+    "@oxy.so/contracts": "^4.17.0",
     "zod": "^3.25.64"
   },
   "peerDependencies": {
@@ -156,14 +171,13 @@
     }
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.9.4",
     "@react-native-async-storage/async-storage": "^2.2.0",
     "@types/express": "^4.17.25",
     "@types/node": "^22.20.1",
     "@types/supertest": "^6.0.2",
     "expo-crypto": "~56.0.3",
     "expo-modules-core": "~57.0.17",
-    "expo-secure-store": "~56.0.4",
+    "expo-secure-store": "~57.0.4",
     "express": "^4.22.2",
     "jest": "^30.5.1",
     "release-it": "^19.0.6",

package/src/__tests__/canonicalJson.test.ts

@@ -26,9 +26,7 @@ describe('canonicalize', () => {
         z: { y: 1, x: 2 },
         a: { c: 3, b: { e: 5, d: 4 } },
       };
-      expect(canonicalize(value)).toBe(
-        '{"a":{"b":{"d":4,"e":5},"c":3},"z":{"x":2,"y":1}}',
-      );
+      expect(canonicalize(value)).toBe('{"a":{"b":{"d":4,"e":5},"c":3},"z":{"x":2,"y":1}}');
     });
 
     it('is order-insensitive across deep nesting', () => {
@@ -91,9 +89,7 @@ describe('canonicalize', () => {
     it('respects toJSON (Date and its ISO string canonicalize identically)', () => {
       const date = new Date('2026-06-26T00:00:00.000Z');
       expect(canonicalize(date)).toBe(JSON.stringify(date.toISOString()));
-      expect(canonicalize({ at: date })).toBe(
-        canonicalize({ at: '2026-06-26T00:00:00.000Z' }),
-      );
+      expect(canonicalize({ at: date })).toBe(canonicalize({ at: '2026-06-26T00:00:00.000Z' }));
     });
   });
 

package/src/__tests__/chain.test.ts

@@ -80,11 +80,22 @@ function stubStore(overrides: Partial<RecordStore> = {}): RecordStore {
 const FAR_FUTURE_NOW = 1_700_000_000_000 + 1_000;
 
 describe('checkContinuity', () => {
-  const head = (headRecordId: string, seq: number): ChainHead => ({ headRecordId, seq, recordCount: seq + 1 });
+  const head = (headRecordId: string, seq: number): ChainHead => ({
+    headRecordId,
+    seq,
+    recordCount: seq + 1,
+  });
 
   it('accepts a v1 record (unchained) regardless of head', async () => {
     const env = await signEnvelope(
-      { version: 1, type: 'identity', subject: SUBJECT, issuer: SUBJECT, record: { a: 1 }, issuedAt: 1 },
+      {
+        version: 1,
+        type: 'identity',
+        subject: SUBJECT,
+        issuer: SUBJECT,
+        record: { a: 1 },
+        issuedAt: 1,
+      },
       PRIVATE_KEY,
     );
     expect(checkContinuity(head('a'.repeat(64), 3), env)).toEqual({ ok: true });
@@ -102,7 +113,10 @@ describe('checkContinuity', () => {
 
   it('rejects a wrong prev as chain_fork', async () => {
     const env = await signEnvelope(v2Fields({ seq: 1, prev: 'b'.repeat(64) }), PRIVATE_KEY);
-    expect(checkContinuity(head('a'.repeat(64), 0), env)).toEqual({ ok: false, reason: 'chain_fork' });
+    expect(checkContinuity(head('a'.repeat(64), 0), env)).toEqual({
+      ok: false,
+      reason: 'chain_fork',
+    });
   });
 
   it('rejects a seq gap (correct prev) as bad_seq', async () => {
@@ -157,7 +171,9 @@ describe('isAuthorizedKey', () => {
 describe('verifyEnvelope', () => {
   it('accepts a fresh, well-signed genesis record', async () => {
     const env = await signEnvelope(v2Fields(), PRIVATE_KEY);
-    await expect(verifyEnvelope(stubStore(), resolver(SELF_RESOLVED), env, { now: FAR_FUTURE_NOW })).resolves.toEqual({
+    await expect(
+      verifyEnvelope(stubStore(), resolver(SELF_RESOLVED), env, { now: FAR_FUTURE_NOW }),
+    ).resolves.toEqual({
       ok: true,
     });
   });
@@ -186,7 +202,9 @@ describe('verifyEnvelope', () => {
       const stripped = { ...env };
       delete (stripped as Record<string, unknown>)[field];
       await expect(
-        verifyEnvelope(stubStore(), resolver(SELF_RESOLVED), stripped as SignedRecordEnvelope, { now: FAR_FUTURE_NOW }),
+        verifyEnvelope(stubStore(), resolver(SELF_RESOLVED), stripped as SignedRecordEnvelope, {
+          now: FAR_FUTURE_NOW,
+        }),
       ).resolves.toEqual({ ok: false, reason: 'invalid_envelope' });
     },
   );
@@ -203,7 +221,9 @@ describe('verifyEnvelope', () => {
   it('rejects an unauthorized key as public_key_not_a_current_verification_method', async () => {
     const env = await signEnvelope(v2Fields(), PRIVATE_KEY);
     await expect(
-      verifyEnvelope(stubStore(), resolver({ currentPublicKeys: ['cafe'] }), env, { now: FAR_FUTURE_NOW }),
+      verifyEnvelope(stubStore(), resolver({ currentPublicKeys: ['cafe'] }), env, {
+        now: FAR_FUTURE_NOW,
+      }),
     ).resolves.toEqual({ ok: false, reason: 'public_key_not_a_current_verification_method' });
   });
 
@@ -224,7 +244,9 @@ describe('verifyEnvelope', () => {
   it('rejects an issuedAt not newer than the latest stored record as stale_issued_at', async () => {
     const env = await signEnvelope(v2Fields({ issuedAt: 1_700_000_000_000 }), PRIVATE_KEY);
     const store = stubStore({ latestIssuedAtForKey: async () => 1_700_000_000_000 });
-    await expect(verifyEnvelope(store, resolver(SELF_RESOLVED), env, { now: FAR_FUTURE_NOW })).resolves.toEqual({
+    await expect(
+      verifyEnvelope(store, resolver(SELF_RESOLVED), env, { now: FAR_FUTURE_NOW }),
+    ).resolves.toEqual({
       ok: false,
       reason: 'stale_issued_at',
     });
@@ -249,7 +271,9 @@ describe('verifyAndAppend', () => {
       }),
     );
     const store = stubStore({ append });
-    const result = await verifyAndAppend(store, resolver(SELF_RESOLVED), env, { now: FAR_FUTURE_NOW });
+    const result = await verifyAndAppend(store, resolver(SELF_RESOLVED), env, {
+      now: FAR_FUTURE_NOW,
+    });
     expect(result.ok).toBe(true);
     expect(append).toHaveBeenCalledTimes(1);
     const [subject, passedEnv, recordId] = append.mock.calls[0];
@@ -260,10 +284,15 @@ describe('verifyAndAppend', () => {
   });
 
   it('does NOT append when verification fails', async () => {
-    const tampered = { ...(await signEnvelope(v2Fields(), PRIVATE_KEY)), record: { x: 'tampered' } };
+    const tampered = {
+      ...(await signEnvelope(v2Fields(), PRIVATE_KEY)),
+      record: { x: 'tampered' },
+    };
     const append = jest.fn();
     const store = stubStore({ append });
-    const result = await verifyAndAppend(store, resolver(SELF_RESOLVED), tampered, { now: FAR_FUTURE_NOW });
+    const result = await verifyAndAppend(store, resolver(SELF_RESOLVED), tampered, {
+      now: FAR_FUTURE_NOW,
+    });
     expect(result).toEqual({ ok: false, reason: 'bad_signature' });
     expect(append).not.toHaveBeenCalled();
   });
@@ -271,7 +300,9 @@ describe('verifyAndAppend', () => {
   it('surfaces the store chain_conflict backstop', async () => {
     const env = await signEnvelope(v2Fields(), PRIVATE_KEY);
     const store = stubStore({ append: async () => ({ ok: false, reason: 'chain_conflict' }) });
-    await expect(verifyAndAppend(store, resolver(SELF_RESOLVED), env, { now: FAR_FUTURE_NOW })).resolves.toEqual({
+    await expect(
+      verifyAndAppend(store, resolver(SELF_RESOLVED), env, { now: FAR_FUTURE_NOW }),
+    ).resolves.toEqual({
       ok: false,
       reason: 'chain_conflict',
     });

package/src/__tests__/commonsIdentityBridge.test.ts

@@ -9,7 +9,9 @@
 const PUBLIC_KEY = `04${'ab'.repeat(64)}`;
 
 function mockNative(native: unknown): void {
-  jest.doMock('expo-modules-core', () => ({ requireOptionalNativeModule: () => native }), { virtual: true });
+  jest.doMock('expo-modules-core', () => ({ requireOptionalNativeModule: () => native }), {
+    virtual: true,
+  });
 }
 
 async function loadBridge() {
@@ -102,7 +104,10 @@ describe('tweakAddSecp256k1PrivateKey', () => {
     expect(() => tweakAddSecp256k1PrivateKey(nMinusOne, `${'0'.repeat(63)}1`)).toThrow('zero');
     // A tweak at or above n is invalid.
     expect(() =>
-      tweakAddSecp256k1PrivateKey('01', 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),
+      tweakAddSecp256k1PrivateKey(
+        '01',
+        'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141',
+      ),
     ).toThrow('curve order');
     expect(() => tweakAddSecp256k1PrivateKey('01', 'zz')).toThrow();
   });

package/src/__tests__/didWebResolver.test.ts

@@ -19,7 +19,12 @@ function didDoc(overrides: Partial<DidDocument> = {}): DidDocument {
     id: SUBJECT,
     controller: [SUBJECT],
     verificationMethod: [
-      { id: `${SUBJECT}#key-1`, type: 'EcdsaSecp256k1VerificationKey2019', controller: SUBJECT, publicKeyHex: KEY_A },
+      {
+        id: `${SUBJECT}#key-1`,
+        type: 'EcdsaSecp256k1VerificationKey2019',
+        controller: SUBJECT,
+        publicKeyHex: KEY_A,
+      },
     ],
     authentication: [`${SUBJECT}#key-1`],
     assertionMethod: [`${SUBJECT}#key-1`],
@@ -50,7 +55,9 @@ describe('didWebToUrl', () => {
   });
 
   it('decodes a %3A port in the host segment', () => {
-    expect(didWebToUrl('did:web:localhost%3A3000')).toBe('https://localhost:3000/.well-known/did.json');
+    expect(didWebToUrl('did:web:localhost%3A3000')).toBe(
+      'https://localhost:3000/.well-known/did.json',
+    );
   });
 
   it('returns null for a non-did:web identifier', () => {
@@ -75,8 +82,18 @@ describe('createDidWebResolver', () => {
   it('collects every assertionMethod key (deduped)', async () => {
     const doc = didDoc({
       verificationMethod: [
-        { id: `${SUBJECT}#key-1`, type: 'EcdsaSecp256k1VerificationKey2019', controller: SUBJECT, publicKeyHex: KEY_A },
-        { id: `${SUBJECT}#key-2`, type: 'EcdsaSecp256k1VerificationKey2019', controller: SUBJECT, publicKeyHex: KEY_B },
+        {
+          id: `${SUBJECT}#key-1`,
+          type: 'EcdsaSecp256k1VerificationKey2019',
+          controller: SUBJECT,
+          publicKeyHex: KEY_A,
+        },
+        {
+          id: `${SUBJECT}#key-2`,
+          type: 'EcdsaSecp256k1VerificationKey2019',
+          controller: SUBJECT,
+          publicKeyHex: KEY_B,
+        },
       ],
       assertionMethod: [`${SUBJECT}#key-1`, `${SUBJECT}#key-2`],
     });
@@ -90,8 +107,18 @@ describe('createDidWebResolver', () => {
     // the hex signing key only.
     const doc = didDoc({
       verificationMethod: [
-        { id: `${SUBJECT}#key-1`, type: 'EcdsaSecp256k1VerificationKey2019', controller: SUBJECT, publicKeyHex: KEY_A },
-        { id: `${SUBJECT}#atproto`, type: 'Multikey', controller: SUBJECT, publicKeyMultibase: 'zQ3shFakeMultibaseKey' },
+        {
+          id: `${SUBJECT}#key-1`,
+          type: 'EcdsaSecp256k1VerificationKey2019',
+          controller: SUBJECT,
+          publicKeyHex: KEY_A,
+        },
+        {
+          id: `${SUBJECT}#atproto`,
+          type: 'Multikey',
+          controller: SUBJECT,
+          publicKeyMultibase: 'zQ3shFakeMultibaseKey',
+        },
       ],
       authentication: [`${SUBJECT}#key-1`, `${SUBJECT}#atproto`],
       assertionMethod: [`${SUBJECT}#key-1`, `${SUBJECT}#atproto`],
@@ -113,7 +140,9 @@ describe('createDidWebResolver', () => {
   });
 
   it('returns null when the document id does not match the subject', async () => {
-    const resolver = createDidWebResolver(async () => jsonResponse(didDoc({ id: 'did:web:other.example' })));
+    const resolver = createDidWebResolver(async () =>
+      jsonResponse(didDoc({ id: 'did:web:other.example' })),
+    );
     expect(await resolver.resolve(SUBJECT)).toBeNull();
   });
 

package/src/__tests__/nodeApp.test.ts

@@ -91,7 +91,11 @@ describe('createNodeApp', () => {
     const empty = await request(app).get('/oxy/head');
     expect(empty.body).toEqual({ seq: null, headRecordId: null, recordCount: 0 });
 
-    const envelope = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 0, prev: null });
+    const envelope = await buildSignedEnvelope({
+      privateKey: owner.privateKey,
+      seq: 0,
+      prev: null,
+    });
     const recordId = await computeRecordId(envelope);
     const write = await request(app).post('/records').send(envelope);
     expect(write.status).toBe(201);
@@ -107,7 +111,12 @@ describe('createNodeApp', () => {
     const genesisId = await computeRecordId(genesis);
     await request(app).post('/records').send(genesis).expect(201);
 
-    const second = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 1, prev: genesisId, record: { step: 2 } });
+    const second = await buildSignedEnvelope({
+      privateKey: owner.privateKey,
+      seq: 1,
+      prev: genesisId,
+      record: { step: 2 },
+    });
     const secondId = await computeRecordId(second);
     const res = await request(app).post('/records').send(second);
     expect(res.status).toBe(201);
@@ -117,7 +126,11 @@ describe('createNodeApp', () => {
   it('POST /records rejects a record signed by a NON-owner key (403 not_owner)', async () => {
     const { app } = buildApp(owner);
     const attacker = generateKeyPair();
-    const envelope = await buildSignedEnvelope({ privateKey: attacker.privateKey, seq: 0, prev: null });
+    const envelope = await buildSignedEnvelope({
+      privateKey: attacker.privateKey,
+      seq: 0,
+      prev: null,
+    });
     const res = await request(app).post('/records').send(envelope);
     expect(res.status).toBe(403);
     expect(res.body).toEqual({ error: 'not_owner' });
@@ -132,7 +145,11 @@ describe('createNodeApp', () => {
 
   it('POST /records rejects a chain gap (422 chain_gap)', async () => {
     const { app } = buildApp(owner);
-    const envelope = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 3, prev: null });
+    const envelope = await buildSignedEnvelope({
+      privateKey: owner.privateKey,
+      seq: 3,
+      prev: null,
+    });
     const res = await request(app).post('/records').send(envelope);
     expect(res.status).toBe(422);
     expect(res.body).toEqual({ error: 'chain_gap' });
@@ -162,8 +179,14 @@ describe('createNodeApp', () => {
   it('POST /sync/push verifies + appends a batch in order', async () => {
     const { app } = buildApp(owner);
     const genesis = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 0, prev: null });
-    const second = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 1, prev: await computeRecordId(genesis) });
-    const res = await request(app).post('/sync/push').send({ records: [genesis, second] });
+    const second = await buildSignedEnvelope({
+      privateKey: owner.privateKey,
+      seq: 1,
+      prev: await computeRecordId(genesis),
+    });
+    const res = await request(app)
+      .post('/sync/push')
+      .send({ records: [genesis, second] });
     expect(res.status).toBe(200);
     expect(res.body.accepted).toBe(2);
     expect(res.body.results.every((r: { ok: boolean }) => r.ok)).toBe(true);
@@ -174,7 +197,12 @@ describe('createNodeApp', () => {
     let prev: string | null = null;
     const ids: string[] = [];
     for (let seq = 0; seq < 4; seq += 1) {
-      const envelope = await buildSignedEnvelope({ privateKey: owner.privateKey, seq, prev, record: { seq } });
+      const envelope = await buildSignedEnvelope({
+        privateKey: owner.privateKey,
+        seq,
+        prev,
+        record: { seq },
+      });
       const id = await computeRecordId(envelope);
       await request(app).post('/records').send(envelope).expect(201);
       ids.push(id);
@@ -193,7 +221,9 @@ describe('createNodeApp', () => {
     const sinceCursor = await request(app).get('/oxy/log').query({ since: ids[1] });
     expect(sinceCursor.body.records.map((entry: { seq: number }) => entry.seq)).toEqual([2, 3]);
 
-    const unknownCursor = await request(app).get('/oxy/log').query({ since: 'f'.repeat(64) });
+    const unknownCursor = await request(app)
+      .get('/oxy/log')
+      .query({ since: 'f'.repeat(64) });
     expect(unknownCursor.body.records).toEqual([]);
   });
 
@@ -215,11 +245,14 @@ describe('createNodeApp', () => {
     expect(put.status).toBe(201);
     expect(put.body).toEqual({ hash, size: bytes.length });
 
-    const get = await request(app).get(`/blobs/${hash}`).buffer(true).parse((res, cb) => {
-      const chunks: Buffer[] = [];
-      res.on('data', (chunk: Buffer) => chunks.push(chunk));
-      res.on('end', () => cb(null, Buffer.concat(chunks)));
-    });
+    const get = await request(app)
+      .get(`/blobs/${hash}`)
+      .buffer(true)
+      .parse((res, cb) => {
+        const chunks: Buffer[] = [];
+        res.on('data', (chunk: Buffer) => chunks.push(chunk));
+        res.on('end', () => cb(null, Buffer.concat(chunks)));
+      });
     expect(get.status).toBe(200);
     expect(Buffer.isBuffer(get.body) ? get.body : Buffer.from(get.body)).toEqual(bytes);
   });
@@ -269,7 +302,9 @@ describe('createNodeApp', () => {
     const auth = await signBlobPin(hash, owner);
 
     const server = createServer(app);
-    await new Promise<void>((resolve) => { server.listen(0, '127.0.0.1', resolve); });
+    await new Promise<void>((resolve) => {
+      server.listen(0, '127.0.0.1', resolve);
+    });
     const { port } = server.address() as AddressInfo;
 
     const raw = await new Promise<string>((resolve, reject) => {
@@ -284,12 +319,14 @@ describe('createNodeApp', () => {
             'Connection: close',
             '',
             '',
-          ].join('\r\n')
+          ].join('\r\n'),
         );
       });
       let received = '';
       socket.setEncoding('utf8');
-      socket.on('data', (chunk: string) => { received += chunk; });
+      socket.on('data', (chunk: string) => {
+        received += chunk;
+      });
       socket.on('error', reject);
       socket.on('end', () => resolve(received));
     });
@@ -360,7 +397,11 @@ describe('createNodeApp', () => {
     // within the window is rejected 429 BEFORE the handler runs, regardless of
     // each request's chain outcome.
     const { app } = buildApp(owner, [], { windowMs: 60_000, max: 2 });
-    const envelope = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 0, prev: null });
+    const envelope = await buildSignedEnvelope({
+      privateKey: owner.privateKey,
+      seq: 0,
+      prev: null,
+    });
 
     const first = await request(app).post('/records').send(envelope);
     expect(first.status).toBe(201);
@@ -379,7 +420,12 @@ describe('createNodeApp', () => {
     let prev: string | null = null;
     const ids: string[] = [];
     for (let seq = 0; seq < 3; seq += 1) {
-      const envelope = await buildSignedEnvelope({ privateKey: owner.privateKey, seq, prev, record: { seq } });
+      const envelope = await buildSignedEnvelope({
+        privateKey: owner.privateKey,
+        seq,
+        prev,
+        record: { seq },
+      });
       const id = await computeRecordId(envelope);
       await request(app).post('/records').send(envelope).expect(201);
       ids.push(id);
@@ -388,7 +434,9 @@ describe('createNodeApp', () => {
 
     // `?since[]=<id1>&since[]=<id2>` arrives as a string[] — the handler must
     // take the FIRST value (a tampered array can never cause type confusion).
-    const res = await request(app).get('/oxy/log').query({ 'since[]': [ids[0], ids[2]] });
+    const res = await request(app)
+      .get('/oxy/log')
+      .query({ 'since[]': [ids[0], ids[2]] });
     expect(res.status).toBe(200);
     // Cursor resolves off ids[0] → records strictly after seq 0 → [1, 2].
     expect(res.body.records.map((entry: { seq: number }) => entry.seq)).toEqual([1, 2]);
@@ -398,12 +446,19 @@ describe('createNodeApp', () => {
     const { app } = buildApp(owner);
     let prev: string | null = null;
     for (let seq = 0; seq < 4; seq += 1) {
-      const envelope = await buildSignedEnvelope({ privateKey: owner.privateKey, seq, prev, record: { seq } });
+      const envelope = await buildSignedEnvelope({
+        privateKey: owner.privateKey,
+        seq,
+        prev,
+        record: { seq },
+      });
       await request(app).post('/records').send(envelope).expect(201);
       prev = await computeRecordId(envelope);
     }
 
-    const res = await request(app).get('/oxy/log').query({ 'limit[]': ['2', '99'] });
+    const res = await request(app)
+      .get('/oxy/log')
+      .query({ 'limit[]': ['2', '99'] });
     expect(res.status).toBe(200);
     expect(res.body.records.map((entry: { seq: number }) => entry.seq)).toEqual([0, 1]);
   });

package/src/__tests__/nodeClient.test.ts

@@ -71,7 +71,9 @@ describe('trimTrailingSlashes', () => {
   });
 
   it('preserves interior slashes and the empty string', () => {
-    expect(trimTrailingSlashes('https://node.example/oxy/log')).toBe('https://node.example/oxy/log');
+    expect(trimTrailingSlashes('https://node.example/oxy/log')).toBe(
+      'https://node.example/oxy/log',
+    );
     expect(trimTrailingSlashes('')).toBe('');
     expect(trimTrailingSlashes('///')).toBe('');
   });
@@ -127,7 +129,11 @@ describe('NodeClient (end-to-end against createNodeApp)', () => {
     const genesisId = await computeRecordId(genesis);
     await client.writeRecord(genesis);
 
-    const second = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 1, prev: genesisId });
+    const second = await buildSignedEnvelope({
+      privateKey: owner.privateKey,
+      seq: 1,
+      prev: genesisId,
+    });
     const secondId = await computeRecordId(second);
     expect(await client.writeRecord(second)).toEqual({ recordId: secondId, seq: 1 });
 
@@ -143,7 +149,10 @@ describe('NodeClient (end-to-end against createNodeApp)', () => {
 
   it('writeRecord surfaces a chain gap as a NodeClientError (422 chain_gap)', async () => {
     const gap = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 3, prev: null });
-    await expect(client.writeRecord(gap)).rejects.toMatchObject({ status: 422, reason: 'chain_gap' });
+    await expect(client.writeRecord(gap)).rejects.toMatchObject({
+      status: 422,
+      reason: 'chain_gap',
+    });
     await expect(client.writeRecord(gap)).rejects.toBeInstanceOf(NodeClientError);
   });
 
@@ -151,14 +160,28 @@ describe('NodeClient (end-to-end against createNodeApp)', () => {
     const genesis = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 0, prev: null });
     await client.writeRecord(genesis);
 
-    const fork = await buildSignedEnvelope({ privateKey: owner.privateKey, seq: 1, prev: 'f'.repeat(64) });
-    await expect(client.writeRecord(fork)).rejects.toMatchObject({ status: 422, reason: 'chain_fork' });
+    const fork = await buildSignedEnvelope({
+      privateKey: owner.privateKey,
+      seq: 1,
+      prev: 'f'.repeat(64),
+    });
+    await expect(client.writeRecord(fork)).rejects.toMatchObject({
+      status: 422,
+      reason: 'chain_fork',
+    });
   });
 
   it('writeRecord surfaces a non-owner write as a NodeClientError (403 not_owner)', async () => {
     const attacker = generateKeyPair();
-    const envelope = await buildSignedEnvelope({ privateKey: attacker.privateKey, seq: 0, prev: null });
-    await expect(client.writeRecord(envelope)).rejects.toMatchObject({ status: 403, reason: 'not_owner' });
+    const envelope = await buildSignedEnvelope({
+      privateKey: attacker.privateKey,
+      seq: 0,
+      prev: null,
+    });
+    await expect(client.writeRecord(envelope)).rejects.toMatchObject({
+      status: 403,
+      reason: 'not_owner',
+    });
   });
 
   it('putBlob then getBlob round-trips; getBlob returns null when absent', async () => {

package/src/__tests__/nodeHarness.ts

@@ -95,14 +95,18 @@ export function createInMemoryNodeStore(): RecordStore & BlobStore {
     },
     async resolveCursorSeq(_subject, recordId): Promise<number | null> {
       const found = records.find((r) => r.recordId === recordId);
-      return found ? found.env.seq ?? -1 : null;
+      return found ? (found.env.seq ?? -1) : null;
     },
     async materializeCurrent(_subject, collection, rkey): Promise<SignedRecordEnvelope | null> {
-      const matching = records.filter((r) => r.env.collection === collection && r.env.rkey === rkey);
+      const matching = records.filter(
+        (r) => r.env.collection === collection && r.env.rkey === rkey,
+      );
       return matching.length ? matching[matching.length - 1].env : null;
     },
     async latestIssuedAtForKey(_subject, env): Promise<number | null> {
-      const matching = records.filter((r) => r.env.collection === env.collection && r.env.rkey === env.rkey);
+      const matching = records.filter(
+        (r) => r.env.collection === env.collection && r.env.rkey === env.rkey,
+      );
       return matching.length ? matching[matching.length - 1].env.issuedAt : null;
     },
     async putBlob(hash, bytes): Promise<void> {