rename the sync layer off the chirp name: sync-coordinator/runner/transport/vault-adapter, device-identity, pairing-handshake, vault-adopt, and drop the orphaned audio-frame types (v4.0.32)

@@ -1,85 +0,0 @@1-import { beforeEach, describe, expect, it, vi } from "vitest";2-3-// PCH-01-004: deviceId must live in chrome.storage.local (device-local), never4-// in chrome.storage.sync (which roams across profiles and collides identities).5-6-type StorageShape = Record<string, unknown>;7-const DEVICE_ID_KEY = "peach_chirp_device_id";8-9-describe("chirp-identity getOrCreateDeviceId (PCH-01-004)", () => {10-  let local: StorageShape;11-  let sync: StorageShape;12-  let localSet: ReturnType<typeof vi.fn>;13-  let syncSet: ReturnType<typeof vi.fn>;14-  let syncRemove: ReturnType<typeof vi.fn>;15-16-  function makeArea(store: StorageShape, set: ReturnType<typeof vi.fn>, remove?: ReturnType<typeof vi.fn>) {17-    return {18-      get: vi.fn(async (key?: string | string[]) => {19-        if (!key) return store;20-        if (typeof key === "string") return { [key]: store[key] };21-        return key.reduce<Record<string, unknown>>((r, k) => {22-          r[k] = store[k];23-          return r;24-        }, {});25-      }),26-      set,27-      remove: remove ?? vi.fn(async () => undefined),28-    };29-  }30-31-  beforeEach(() => {32-    vi.resetModules();33-    local = {};34-    sync = {};35-    localSet = vi.fn(async (next: Record<string, unknown>) => {36-      Object.assign(local, next);37-    });38-    syncSet = vi.fn(async (next: Record<string, unknown>) => {39-      Object.assign(sync, next);40-    });41-    syncRemove = vi.fn(async (key: string) => {42-      delete sync[key];43-    });44-45-    const chromeMock = {46-      storage: {47-        local: makeArea(local, localSet),48-        sync: makeArea(sync, syncSet, syncRemove),49-      },50-    } as unknown as typeof chrome;51-    (globalThis as { chrome?: typeof chrome }).chrome = chromeMock;52-  });53-54-  it("migrates_legacy_sync_id_to_local_and_removes_from_sync", async () => {55-    sync[DEVICE_ID_KEY] = "legacy-roamed-id";56-    const { getOrCreateDeviceId } = await import("./chirp-identity");57-58-    const id = await getOrCreateDeviceId();59-60-    expect(id).toBe("legacy-roamed-id");61-    expect(local[DEVICE_ID_KEY]).toBe("legacy-roamed-id");62-    expect(syncRemove).toHaveBeenCalledWith(DEVICE_ID_KEY);63-    expect(sync[DEVICE_ID_KEY]).toBeUndefined();64-  });65-66-  it("fresh_install_writes_id_to_local_only", async () => {67-    const { getOrCreateDeviceId } = await import("./chirp-identity");68-69-    const id = await getOrCreateDeviceId();70-71-    expect(typeof id).toBe("string");72-    expect(id.length).toBeGreaterThan(0);73-    expect(local[DEVICE_ID_KEY]).toBe(id);74-    expect(syncSet).not.toHaveBeenCalled();75-  });76-77-  it("returns_a_stable_id_across_calls", async () => {78-    const { getOrCreateDeviceId } = await import("./chirp-identity");79-80-    const first = await getOrCreateDeviceId();81-    const second = await getOrCreateDeviceId();82-83-    expect(second).toBe(first);84-  });85-});

@@ -1,143 +0,0 @@1-// Local-device identity helpers for the chirp-sync architecture.2-//3-// `deviceId` is a stable UUID v4 generated on first call and persisted in4-// `chrome.storage.local`. It is deliberately device-local and must NOT roam:5-// it is the only symmetry-breaker in the sync-identity HKDF (see PCH-01-004),6-// so a shared id across profiles would collide derived sync keys. A first-read7-// migration moves any legacy value out of `chrome.storage.sync`.8-//9-// `deviceName` defaults to a short, friendly browser+OS description and10-// can be overridden by the user from Settings → Sync.11-//12-// The local sync identity itself is derived deterministically from the13-// vault master key (`deriveSyncIdentityKeypair`); the function below is a14-// thin coordinator that pulls the master key out of `vault.ts` and exposes15-// only the public half to callers that don't need to sign.16-17-import {18-  deriveSyncIdentityKeypair,19-  deriveSyncSigningKeypair,20-  pubkeyToHex,21-} from "../shared/sync-identity";22-import type { DeviceType } from "../shared/sync-types";23-24-const DEVICE_ID_KEY = "peach_chirp_device_id";25-const DEVICE_NAME_KEY = "peach_chirp_device_name";26-27-export interface LocalChirpIdentity {28-  deviceId: string;29-  deviceName: string;30-  deviceType: DeviceType;31-  longTermPublicKeyHex: string;32-  signingPublicKeyHex: string;33-}34-35-export async function getOrCreateDeviceId(): Promise<string> {36-  // PCH-01-004: deviceId is the ONLY symmetry-breaker in the sync-identity HKDF37-  // (sync-identity.ts:54). It must NOT roam across profiles via chrome.storage.sync,38-  // or two profiles on the same browser account sharing a vault derive identical39-  // static + signing keys and collide in the device graph. Keep it device-local.40-  const local = await chrome.storage.local.get(DEVICE_ID_KEY);41-  const localId = (local as Record<string, unknown>)[DEVICE_ID_KEY];42-  if (typeof localId === "string" && localId.length > 0) return localId;43-44-  // First-read migration: adopt a value previously stored in sync, then evict it45-  // from sync so a sibling profile cannot re-roam it back. Idempotent — once the46-  // id lives in local, this branch never runs again.47-  const synced = await chrome.storage.sync.get(DEVICE_ID_KEY);48-  const syncedId = (synced as Record<string, unknown>)[DEVICE_ID_KEY];49-  if (typeof syncedId === "string" && syncedId.length > 0) {50-    await chrome.storage.local.set({ [DEVICE_ID_KEY]: syncedId });51-    await chrome.storage.sync.remove(DEVICE_ID_KEY);52-    return syncedId;53-  }54-55-  const fresh = generateUuidV4();56-  await chrome.storage.local.set({ [DEVICE_ID_KEY]: fresh });57-  return fresh;58-}59-60-export async function getDeviceName(): Promise<string> {61-  const result = await chrome.storage.sync.get(DEVICE_NAME_KEY);62-  const stored = (result as Record<string, unknown>)[DEVICE_NAME_KEY];63-  if (typeof stored === "string" && stored.length > 0) return stored;64-  return defaultDeviceName();65-}66-67-export async function setDeviceName(name: string): Promise<void> {68-  const trimmed = name.trim();69-  if (!trimmed) throw new Error("device name must not be empty");70-  if (trimmed.length > 64) throw new Error("device name must be 64 chars or fewer");71-  await chrome.storage.sync.set({ [DEVICE_NAME_KEY]: trimmed });72-}73-74-/**75- * Build the public-facing identity record for the local extension. The76- * private key half (used only for ongoing Noise XX sessions) is not77- * exposed by this function — Phase-1 pairing uses ephemeral keys only.78- */79-export async function buildLocalIdentity(80-  masterKey: Uint8Array,81-): Promise<LocalChirpIdentity> {82-  const deviceId = await getOrCreateDeviceId();83-  const deviceName = await getDeviceName();84-  const kp = deriveSyncIdentityKeypair(masterKey, deviceId);85-  const signing = await deriveSyncSigningKeypair(masterKey, deviceId);86-  return {87-    deviceId,88-    deviceName,89-    deviceType: extensionDeviceType(),90-    longTermPublicKeyHex: pubkeyToHex(kp.publicKey),91-    signingPublicKeyHex: pubkeyToHex(signing.publicKeyRaw),92-  };93-}94-95-/**96- * Return the local sync identity keypair (public and private). Reserved97- * for the Phase-2 WebSocket sync coordinator that runs in the background.98- * Never surface the private key over a message handler.99- */100-export function deriveLocalSyncKeypair(masterKey: Uint8Array, deviceId: string) {101-  return deriveSyncIdentityKeypair(masterKey, deviceId);102-}103-104-function defaultDeviceName(): string {105-  // Best-effort browser + platform string. Avoids userAgent parsing — the106-  // user can rename via Settings.107-  const ua = (typeof navigator !== "undefined" ? navigator.userAgent : "") || "";108-  if (/Firefox/i.test(ua)) return "Firefox";109-  if (/Edg\//i.test(ua)) return "Edge";110-  if (/Chrome/i.test(ua)) return "Chrome";111-  if (/Safari/i.test(ua)) return "Safari";112-  return "Browser";113-}114-115-function extensionDeviceType(): DeviceType {116-  // The same module ships in both the Chrome extension and the Capacitor117-  // mobile build. On Capacitor, Peach acts as an iOS / Android sync host118-  // rather than an extension; the `isNativePlatform` check toggles the tag.119-  try {120-    const native = (globalThis as unknown as { Capacitor?: { isNativePlatform?: () => boolean } }).Capacitor;121-    if (native?.isNativePlatform?.()) {122-      const platform = (globalThis as unknown as { Capacitor?: { getPlatform?: () => string } }).Capacitor?.getPlatform?.();123-      if (platform === "ios") return "ios";124-      return "android";125-    }126-  } catch { /* not on Capacitor */ }127-  return "extension";128-}129-130-function generateUuidV4(): string {131-  // crypto.randomUUID is available in MV3 service workers, popup pages,132-  // and modern Capacitor WebView. Falls back to a manual assembly only if133-  // a runtime is missing it (effectively unreachable for our targets).134-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {135-    return crypto.randomUUID();136-  }137-  const bytes = new Uint8Array(16);138-  crypto.getRandomValues(bytes as Uint8Array<ArrayBuffer>);139-  bytes[6] = (bytes[6] & 0x0f) | 0x40;140-  bytes[8] = (bytes[8] & 0x3f) | 0x80;141-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");142-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;143-}

@@ -1,305 +0,0 @@1-import { describe, expect, it, vi } from "vitest";2-import { runChirpSyncInitiator, type ChirpSyncVaultAdapter } from "./chirp-sync-coordinator";3-import type { ChirpSyncMessage, SignedDeviceManifest } from "../shared/sync-types";4-import type { ChirpSyncSession } from "../shared/chirp-sync-transport";5-import { buildSignedDeviceManifest } from "../shared/device-manifest";6-import { deriveSyncSigningKeypair } from "../shared/sync-identity";7-8-function inMemoryPair(): [ChirpSyncSession, FakePeer] {9-  const a: Uint8Array[] = [];10-  const b: Uint8Array[] = [];11-  const aR: Array<(v: Uint8Array) => void> = [];12-  const bR: Array<(v: Uint8Array) => void> = [];13-14-  const ourSession: ChirpSyncSession = {15-    send(bytes) {16-      const r = bR.shift();17-      if (r) r(bytes); else b.push(bytes);18-    },19-    receive(): Promise<Uint8Array> {20-      const v = a.shift();21-      if (v) return Promise.resolve(v);22-      return new Promise<Uint8Array>((res) => aR.push(res));23-    },24-    async close() { /* no-op */ },25-    remoteStaticPublicKey: new Uint8Array(32),26-  };27-28-  const peer: FakePeer = {29-    async send(msg: ChirpSyncMessage) {30-      const bytes = new TextEncoder().encode(JSON.stringify(msg));31-      const r = aR.shift();32-      if (r) r(bytes); else a.push(bytes);33-    },34-    async receive(): Promise<ChirpSyncMessage> {35-      const v = b.shift();36-      const bytes = v ?? await new Promise<Uint8Array>((res) => bR.push(res));37-      return JSON.parse(new TextDecoder().decode(bytes)) as ChirpSyncMessage;38-    },39-  };40-  return [ourSession, peer];41-}42-43-interface FakePeer {44-  send(msg: ChirpSyncMessage): Promise<void>;45-  receive(): Promise<ChirpSyncMessage>;46-}47-48-function makeVaultAdapter(opts: {49-  vaultId?: string;50-  deviceId?: string;51-  localVersion?: number;52-  entries?: Record<string, number>;53-  tombstones?: Record<string, number>;54-  ciphertext?: Record<string, string>;55-}): ChirpSyncVaultAdapter & {56-  appliedEntries: Record<string, string>[];57-  appliedTombstones: Record<string, number>[];58-} {59-  const appliedEntries: Record<string, string>[] = [];60-  const appliedTombstones: Record<string, number>[] = [];61-  return {62-    async computeVaultId() { return opts.vaultId ?? "vault-abc"; },63-    async getOurDeviceId() { return opts.deviceId ?? "device-init"; },64-    // Use a non-zero default so the equal-version short circuit doesn't fire in65-    // tests that aren't explicitly testing that path.66-    async getLocalVersion() { return opts.localVersion ?? 5; },67-    async buildEntryManifest() { return { ...(opts.entries ?? {}) }; },68-    async buildTombstoneManifest() { return { ...(opts.tombstones ?? {}) }; },69-    async getEncryptedEntries(ids) {70-      const out: Record<string, string> = {};71-      const cipher = opts.ciphertext ?? {};72-      for (const id of ids) if (cipher[id] !== undefined) out[id] = cipher[id];73-      return out;74-    },75-    async applyEntries(entries) { appliedEntries.push(entries); },76-    async applyTombstones(t) { appliedTombstones.push(t); },77-    appliedEntries,78-    appliedTombstones,79-  };80-}81-82-describe("runChirpSyncInitiator — HELLO fields and version optimisation", () => {83-  it("sends HELLO with version and deviceTime", async () => {84-    const [session, peer] = inMemoryPair();85-    const vault = makeVaultAdapter({ localVersion: 7 });86-87-    const initPromise = runChirpSyncInitiator(session, vault);88-89-    const sentHello = await peer.receive();90-    expect(sentHello.type).toBe("SYNC_HELLO");91-    if (sentHello.type === "SYNC_HELLO") {92-      expect(sentHello.version).toBe(7);93-      expect(typeof sentHello.deviceTime).toBe("number");94-      expect(sentHello.deviceTime).toBeGreaterThan(0);95-    }96-    // Send a mismatched vaultId to abort early so the test doesn't hang.97-    await peer.send({ type: "SYNC_HELLO", vaultId: "different-vault", deviceId: "p", version: 7, deviceTime: Date.now() });98-    await peer.receive(); // SYNC_ERROR99-    await initPromise;100-  });101-102-  it("skips manifest exchange and returns completed when versions are equal", async () => {103-    const [session, peer] = inMemoryPair();104-    const vault = makeVaultAdapter({ localVersion: 10 });105-106-    const initPromise = runChirpSyncInitiator(session, vault);107-108-    await peer.receive(); // SYNC_HELLO109-    await peer.send({ type: "SYNC_HELLO", vaultId: "vault-abc", deviceId: "p", version: 10, deviceTime: Date.now() });110-111-    // Coordinator should send SYNC_DONE without any manifest exchange.112-    const done = await peer.receive();113-    expect(done.type).toBe("SYNC_DONE");114-115-    // No SYNC_MANIFEST was sent — peer's queue only has the DONE.116-    await peer.send({ type: "SYNC_DONE" });117-118-    const outcome = await initPromise;119-    expect(outcome.status).toBe("completed");120-    expect(outcome.entriesReceived).toBe(0);121-    expect(outcome.entriesSent).toBe(0);122-  });123-124-  it("logs a clock-skew warning but does not abort when clocks differ by > 120s", async () => {125-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);126-    const [session, peer] = inMemoryPair();127-    const vault = makeVaultAdapter({ localVersion: 5 });128-129-    const initPromise = runChirpSyncInitiator(session, vault);130-131-    await peer.receive(); // SYNC_HELLO132-    // Peer reports a deviceTime 200 s in the past — beyond the 120 s threshold.133-    await peer.send({134-      type: "SYNC_HELLO",135-      vaultId: "vault-abc",136-      deviceId: "p",137-      version: 3, // different version so exchange proceeds138-      deviceTime: Date.now() - 200_000,139-    });140-    // Yield so the coordinator's async continuation can run the clock-skew check.141-    await new Promise((r) => setTimeout(r, 0));142-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("clock skew"));143-144-    // Drive the sync to completion so the test doesn't leak.145-    await peer.receive(); // SYNC_MANIFEST146-    await peer.send({ type: "SYNC_MANIFEST", entries: {}, tombstones: {} });147-    await peer.receive(); // SYNC_REQUEST148-    await peer.send({ type: "SYNC_REQUEST", entryIds: [] });149-    await peer.receive(); // SYNC_ENTRIES150-    await peer.receive(); // SYNC_TOMBSTONES151-    await peer.send({ type: "SYNC_TOMBSTONES", tombstones: {} });152-    await peer.receive(); // SYNC_DONE153-    await peer.send({ type: "SYNC_DONE" });154-155-    const outcome = await initPromise;156-    expect(outcome.status).toBe("completed");157-    warnSpy.mockRestore();158-  });159-});160-161-describe("runChirpSyncInitiator", () => {162-  it("completes a full sync with bi-directional updates", async () => {163-    const [session, peer] = inMemoryPair();164-    const vault = makeVaultAdapter({165-      entries: { a: 100, b: 50 }, // we have 'a' at t=100, 'b' at t=50166-      tombstones: { x: 70 },167-      ciphertext: { a: "ct-a", b: "ct-b" },168-    });169-170-    const initPromise = runChirpSyncInitiator(session, vault);171-172-    const peerProtocol = (async () => {173-      const hello = await peer.receive();174-      expect(hello.type).toBe("SYNC_HELLO");175-      await peer.send({ type: "SYNC_HELLO", vaultId: "vault-abc", deviceId: "device-peer", version: 3, deviceTime: Date.now() });176-177-      const ourManifest = await peer.receive();178-      expect(ourManifest.type).toBe("SYNC_MANIFEST");179-      await peer.send({180-        type: "SYNC_MANIFEST",181-        entries: { a: 80, b: 90, c: 200 }, // we have newer 'a'; peer has newer 'b' and 'c'182-        tombstones: { x: 60, y: 99 },        // peer has newer tombstone for 'y'183-      });184-185-      const ourRequest = await peer.receive();186-      expect(ourRequest.type).toBe("SYNC_REQUEST");187-      // We should request the entries the peer reported newer188-      if (ourRequest.type === "SYNC_REQUEST") {189-        expect(ourRequest.entryIds.sort()).toEqual(["b", "c"]);190-      }191-      // Peer asks us for entries the peer claimed it had older versions of192-      await peer.send({ type: "SYNC_REQUEST", entryIds: ["a"] });193-194-      const ourEntries = await peer.receive();195-      expect(ourEntries.type).toBe("SYNC_ENTRIES");196-      if (ourEntries.type === "SYNC_ENTRIES") {197-        expect(ourEntries.entries).toEqual({ a: "ct-a" });198-      }199-      await peer.send({ type: "SYNC_ENTRIES", entries: { b: "ct-b-new", c: "ct-c" } });200-201-      const ourTombs = await peer.receive();202-      expect(ourTombs.type).toBe("SYNC_TOMBSTONES");203-      if (ourTombs.type === "SYNC_TOMBSTONES") {204-        // We had x@70, peer had x@60, so we ship x@70205-        expect(ourTombs.tombstones).toEqual({ x: 70 });206-      }207-      await peer.send({ type: "SYNC_TOMBSTONES", tombstones: { y: 99 } });208-209-      const ourDone = await peer.receive();210-      expect(ourDone.type).toBe("SYNC_DONE");211-      await peer.send({ type: "SYNC_DONE" });212-    })();213-214-    const outcome = await initPromise;215-    await peerProtocol;216-217-    expect(outcome.status).toBe("completed");218-    expect(outcome.entriesSent).toBe(1);219-    expect(outcome.entriesReceived).toBe(2);220-    expect(outcome.tombstonesSent).toBe(1);221-    expect(outcome.tombstonesReceived).toBe(1);222-    expect(vault.appliedEntries).toEqual([{ b: "ct-b-new", c: "ct-c" }]);223-    expect(vault.appliedTombstones).toEqual([{ y: 99 }]);224-  });225-226-  it("aborts with vault_mismatch on a peer with a different vault_id", async () => {227-    const [session, peer] = inMemoryPair();228-    const vault = makeVaultAdapter({ vaultId: "vault-A" });229-230-    const initPromise = runChirpSyncInitiator(session, vault);231-    const peerProtocol = (async () => {232-      const hello = await peer.receive();233-      expect(hello.type).toBe("SYNC_HELLO");234-      await peer.send({ type: "SYNC_HELLO", vaultId: "vault-B", deviceId: "evil", version: 3, deviceTime: Date.now() });235-      // Peer should receive a SYNC_ERROR and we should stop.236-      const err = await peer.receive();237-      expect(err.type).toBe("SYNC_ERROR");238-    })();239-240-    const outcome = await initPromise;241-    await peerProtocol;242-    expect(outcome.status).toBe("vault_mismatch");243-  });244-245-  it("exchanges device manifests when both adapters opt in", async () => {246-    const [session, peer] = inMemoryPair();247-    const ourKp = await deriveSyncSigningKeypair(new Uint8Array(32).fill(0x11), "us");248-    const peerKp = await deriveSyncSigningKeypair(new Uint8Array(32).fill(0x22), "them");249-250-    const outgoing = await buildSignedDeviceManifest("us", [], ourKp.privateKey);251-    const incomingFromPeer = await buildSignedDeviceManifest("them", [], peerKp.privateKey);252-    const applied: SignedDeviceManifest[] = [];253-254-    const base = makeVaultAdapter({});255-    const vault: ChirpSyncVaultAdapter = {256-      ...base,257-      async buildOutgoingDeviceManifest() { return outgoing; },258-      async applyIncomingDeviceManifest(m) { applied.push(m); },259-    };260-261-    const initPromise = runChirpSyncInitiator(session, vault);262-    const peerProtocol = (async () => {263-      await peer.receive(); // hello264-      await peer.send({ type: "SYNC_HELLO", vaultId: "vault-abc", deviceId: "p", version: 3, deviceTime: Date.now() });265-      await peer.receive(); // manifest266-      await peer.send({ type: "SYNC_MANIFEST", entries: {}, tombstones: {} });267-      await peer.receive(); // request268-      await peer.send({ type: "SYNC_REQUEST", entryIds: [] });269-      await peer.receive(); // entries270-      await peer.receive(); // tombstones271-      await peer.send({ type: "SYNC_TOMBSTONES", tombstones: {} });272-      const ourManifest = await peer.receive();273-      expect(ourManifest.type).toBe("SYNC_DEVICE_MANIFEST");274-      if (ourManifest.type === "SYNC_DEVICE_MANIFEST") {275-        expect(ourManifest.manifest.body.issuerDeviceId).toBe("us");276-      }277-      await peer.send({ type: "SYNC_DEVICE_MANIFEST", manifest: incomingFromPeer });278-      await peer.receive(); // done279-      await peer.send({ type: "SYNC_DONE" });280-    })();281-282-    const outcome = await initPromise;283-    await peerProtocol;284-    expect(outcome.status).toBe("completed");285-    expect(applied).toHaveLength(1);286-    expect(applied[0].body.issuerDeviceId).toBe("them");287-  });288-289-  it("returns errored when peer sends a wrong frame", async () => {290-    const [session, peer] = inMemoryPair();291-    const vault = makeVaultAdapter({ vaultId: "v" });292-293-    const initPromise = runChirpSyncInitiator(session, vault);294-    void (async () => {295-      await peer.receive(); // hello296-      await peer.send({ type: "SYNC_HELLO", vaultId: "v", deviceId: "p", version: 3, deviceTime: Date.now() });297-      await peer.receive(); // our manifest298-      await peer.send({ type: "SYNC_DONE" }); // wrong frame299-    })();300-301-    const outcome = await initPromise;302-    expect(outcome.status).toBe("errored");303-    expect(outcome.error).toMatch(/SYNC_MANIFEST/);304-  });305-});

@@ -1,295 +0,0 @@1-// Chirp Sync — Phase 2 manifest-diff coordinator.2-//3-// After Noise XX is open and the responder's static key has been verified4-// against the paired-device registry, this coordinator drives the5-// manifest exchange:6-//7-//   ->  SYNC_HELLO { vaultId, deviceId }8-//   <-  SYNC_HELLO { vaultId, deviceId }       (mismatch → SYNC_ERROR)9-//   <-> SYNC_MANIFEST { entries, tombstones }  (each side sends one)10-//   ->  SYNC_REQUEST { entryIds }              (entries newer on the peer)11-//   <-  SYNC_ENTRIES { entries }12-//   <-  SYNC_REQUEST { entryIds }              (entries newer on us)13-//   ->  SYNC_ENTRIES { entries }14-//   <-> SYNC_TOMBSTONES { tombstones }15-//   <-> SYNC_DONE16-//17-// Entries are opaque base64 ciphertext — the coordinator never decrypts.18-// Last-write-wins at the entry level by mtime; tombstones override updates19-// with a later deletion timestamp.20-21-import type { ChirpSyncMessage, SignedDeviceManifest } from "../shared/sync-types";22-import type { ChirpSyncSession } from "../shared/chirp-sync-transport";23-import { SYNC_LIMITS } from "../shared/sync-limits";24-25-const SESSION_TIMEOUT_MS = 30_000;26-27-// Sentinel signature used when an adapter can't build a real manifest (e.g.28-// the master key isn't accessible from the coordinator context). The peer29-// recognises this exact value and skips signature verification. 64 hex30-// chars of zero is impossible to produce as a real Ed25519 signature for a31-// fresh body, so collisions are negligible.32-const EMPTY_MANIFEST_PLACEHOLDER: SignedDeviceManifest = {33-  body: { manifestVersion: 1, issuerDeviceId: "", issuedAt: 0, devices: [] },34-  signatureHex: "0".repeat(128),35-};36-37-/**38- * Vault-side adapter — the coordinator's dependency on the vault layer.39- * The vault holds the canonical entry/tombstone tables; the coordinator40- * pulls a manifest, requests entries by id, applies remote entries, and41- * applies remote tombstones.42- */43-export interface ChirpSyncVaultAdapter {44-  computeVaultId(): Promise<string>;45-  getOurDeviceId(): Promise<string>;46-  /** Returns the vault's monotonic version (`peach_last_modified_at`). */47-  getLocalVersion(): Promise<number>;48-  /** Returns the per-entry mtimes for our active entries. */49-  buildEntryManifest(): Promise<Record<string, number>>;50-  /** Returns the per-entry deletion timestamps for our tombstones. */51-  buildTombstoneManifest(): Promise<Record<string, number>>;52-  /** Returns base64 ciphertext for each requested entry id. */53-  getEncryptedEntries(entryIds: string[]): Promise<Record<string, string>>;54-  /** Apply incoming encrypted entries; vault decides per-entry overwrite. */55-  applyEntries(entries: Record<string, string>): Promise<void>;56-  /** Apply incoming tombstones; vault retains the latest deletion ts. */57-  applyTombstones(tombstones: Record<string, number>): Promise<void>;58-  /**59-   * Optional — v2 brief §4.3 device manifest exchange. The extension (as60-   * the trust anchor for the device graph) returns a signed manifest61-   * enumerating every paired device it knows about; the peer verifies it62-   * against the extension's known Ed25519 signing pubkey and upserts any63-   * newly-vouched devices into its own registry.64-   *65-   * When this method is undefined, the coordinator skips the manifest66-   * step entirely. Both ends must opt in for the exchange to occur.67-   */68-  buildOutgoingDeviceManifest?(): Promise<SignedDeviceManifest | null>;69-  /** v2 brief §4.3 — handle a manifest received from the peer. */70-  applyIncomingDeviceManifest?(manifest: SignedDeviceManifest): Promise<void>;71-}72-73-export interface SyncOutcome {74-  status: "completed" | "vault_mismatch" | "errored" | "timeout";75-  entriesReceived: number;76-  entriesSent: number;77-  tombstonesReceived: number;78-  tombstonesSent: number;79-  error?: string;80-}81-82-/**83- * Run one sync round as the initiator. The extension is always the84- * initiator (it is the WebSocket client). The peer's role is symmetric85- * after SYNC_HELLO, so a corresponding responder helper exists for the86- * mobile-side coordinator that calls this same protocol the other way.87- */88-export async function runChirpSyncInitiator(89-  session: ChirpSyncSession,90-  vault: ChirpSyncVaultAdapter,91-): Promise<SyncOutcome> {92-  const result: SyncOutcome = {93-    status: "errored",94-    entriesReceived: 0,95-    entriesSent: 0,96-    tombstonesReceived: 0,97-    tombstonesSent: 0,98-  };99-100-  const timer = scheduleTimeout(SESSION_TIMEOUT_MS);101-  try {102-    const ourVaultId = await vault.computeVaultId();103-    const ourDeviceId = await vault.getOurDeviceId();104-    const localVersion = await vault.getLocalVersion();105-    const localTime = Date.now();106-107-    await sendMessage(session, {108-      type: "SYNC_HELLO",109-      vaultId: ourVaultId,110-      deviceId: ourDeviceId,111-      version: localVersion,112-      deviceTime: localTime,113-    });114-    const helloIn = await receiveMessage(session, timer);115-    if (helloIn.type !== "SYNC_HELLO") {116-      return errorOutcome(result, `expected SYNC_HELLO, got ${helloIn.type}`);117-    }118-    if (helloIn.vaultId !== ourVaultId) {119-      await sendMessage(session, { type: "SYNC_ERROR", error: "vault_id_mismatch" });120-      result.status = "vault_mismatch";121-      return result;122-    }123-124-    if (Math.abs(localTime - (helloIn.deviceTime ?? 0)) > 120_000) {125-      console.warn(`[chirp-sync] clock skew detected: local=${localTime} remote=${helloIn.deviceTime ?? "unknown"}`);126-    }127-128-    // Equal versions — nothing to exchange.129-    if (typeof helloIn.version === "number" && helloIn.version === localVersion) {130-      await sendMessage(session, { type: "SYNC_DONE", entriesReceived: 0, entriesSent: 0 });131-      const done = await receiveMessage(session, timer);132-      if (done.type !== "SYNC_DONE") {133-        return errorOutcome(result, `expected SYNC_DONE, got ${done.type}`);134-      }135-      result.status = "completed";136-      return result;137-    }138-139-    const ourEntries = await vault.buildEntryManifest();140-    const ourTombstones = await vault.buildTombstoneManifest();141-    await sendMessage(session, {142-      type: "SYNC_MANIFEST",143-      entries: ourEntries,144-      tombstones: ourTombstones,145-    });146-    const manifestIn = await receiveMessage(session, timer);147-    if (manifestIn.type !== "SYNC_MANIFEST") {148-      return errorOutcome(result, `expected SYNC_MANIFEST, got ${manifestIn.type}`);149-    }150-151-    const wantFromPeer = diffNewer(manifestIn.entries, ourEntries);152-    await sendMessage(session, { type: "SYNC_REQUEST", entryIds: wantFromPeer });153-154-    const requestIn = await receiveMessage(session, timer);155-    if (requestIn.type !== "SYNC_REQUEST") {156-      return errorOutcome(result, `expected SYNC_REQUEST, got ${requestIn.type}`);157-    }158-    // Sanity: the peer's request must be a subset of what its manifest159-    // declared as newer. A malformed/over-eager request is a protocol160-    // violation but not a data-safety problem — we just send what they ask.161-162-    const ourPayload = await vault.getEncryptedEntries(requestIn.entryIds);163-    await sendMessage(session, { type: "SYNC_ENTRIES", entries: ourPayload });164-    result.entriesSent = Object.keys(ourPayload).length;165-166-    if (wantFromPeer.length > 0) {167-      const entriesIn = await receiveMessage(session, timer);168-      if (entriesIn.type !== "SYNC_ENTRIES") {169-        return errorOutcome(result, `expected SYNC_ENTRIES, got ${entriesIn.type}`);170-      }171-      await vault.applyEntries(entriesIn.entries);172-      result.entriesReceived = Object.keys(entriesIn.entries).length;173-    }174-175-    // Tombstones: each side ships the tombstones that the other does not176-    // yet have a newer record for.177-    const newerTombstonesForPeer: Record<string, number> = {};178-    for (const [id, ts] of Object.entries(ourTombstones)) {179-      const peerTs = manifestIn.tombstones[id] ?? 0;180-      if (ts > peerTs) newerTombstonesForPeer[id] = ts;181-    }182-    await sendMessage(session, { type: "SYNC_TOMBSTONES", tombstones: newerTombstonesForPeer });183-    result.tombstonesSent = Object.keys(newerTombstonesForPeer).length;184-185-    const tombstonesIn = await receiveMessage(session, timer);186-    if (tombstonesIn.type !== "SYNC_TOMBSTONES") {187-      return errorOutcome(result, `expected SYNC_TOMBSTONES, got ${tombstonesIn.type}`);188-    }189-    await vault.applyTombstones(tombstonesIn.tombstones);190-    result.tombstonesReceived = Object.keys(tombstonesIn.tombstones).length;191-192-    // v2 brief §5.6 / §4.3 — device manifest exchange. Optional: both ends193-    // must expose the adapter methods. Disabling on either side cleanly194-    // bypasses the step. The exchange is symmetric on the wire; the195-    // production adapter still treats the extension as the trust anchor and196-    // only applies extension-issued manifests.197-    if (vault.buildOutgoingDeviceManifest && vault.applyIncomingDeviceManifest) {198-      const ours = await vault.buildOutgoingDeviceManifest();199-      if (ours) {200-        await sendMessage(session, { type: "SYNC_DEVICE_MANIFEST", manifest: ours });201-      } else {202-        // No manifest to send (e.g. master key unavailable) — still emit a203-        // protocol frame so the peer's recv doesn't hang. Empty body is204-        // serialised by the adapter when present; if it returned null we205-        // synthesise a no-op shape the receiver can ignore.206-        await sendMessage(session, {207-          type: "SYNC_DEVICE_MANIFEST",208-          manifest: EMPTY_MANIFEST_PLACEHOLDER,209-        });210-      }211-      const manifestIn = await receiveMessage(session, timer);212-      if (manifestIn.type !== "SYNC_DEVICE_MANIFEST") {213-        return errorOutcome(result, `expected SYNC_DEVICE_MANIFEST, got ${manifestIn.type}`);214-      }215-      if (manifestIn.manifest && manifestIn.manifest.signatureHex !== EMPTY_MANIFEST_PLACEHOLDER.signatureHex) {216-        await vault.applyIncomingDeviceManifest(manifestIn.manifest);217-      }218-    }219-220-    await sendMessage(session, {221-      type: "SYNC_DONE",222-      entriesReceived: result.entriesReceived,223-      entriesSent: result.entriesSent,224-    });225-    const done = await receiveMessage(session, timer);226-    if (done.type !== "SYNC_DONE") {227-      return errorOutcome(result, `expected SYNC_DONE, got ${done.type}`);228-    }229-    result.status = "completed";230-    return result;231-  } catch (err) {232-    if ((err as Error).message === "chirp_sync_timeout") {233-      result.status = "timeout";234-      result.error = "session timed out after 30s";235-      return result;236-    }237-    return errorOutcome(result, (err as Error).message);238-  } finally {239-    // Session lifetime is owned by the runner (chirp-sync-runner.ts), which240-    // closes it in its own finally block. The coordinator must not close it241-    // here — the runner still needs to record the outcome after we return.242-    timer.cancel();243-  }244-}245-246-function diffNewer(remote: Record<string, number>, local: Record<string, number>): string[] {247-  const want: string[] = [];248-  for (const [id, ts] of Object.entries(remote)) {249-    const ours = local[id];250-    if (ours === undefined || ts > ours) want.push(id);251-  }252-  return want;253-}254-255-interface Timer {256-  signal: AbortSignal;257-  cancel(): void;258-}259-260-function scheduleTimeout(ms: number): Timer {261-  const ctrl = new AbortController();262-  const t = setTimeout(() => ctrl.abort(new Error("chirp_sync_timeout")), ms);263-  return {264-    signal: ctrl.signal,265-    cancel: () => clearTimeout(t),266-  };267-}268-269-async function sendMessage(session: ChirpSyncSession, msg: ChirpSyncMessage): Promise<void> {270-  session.send(new TextEncoder().encode(JSON.stringify(msg)));271-}272-273-async function receiveMessage(session: ChirpSyncSession, timer: Timer): Promise<ChirpSyncMessage> {274-  const pending = session.receive();275-  const aborted = new Promise<never>((_, reject) => {276-    if (timer.signal.aborted) reject(new Error("chirp_sync_timeout"));277-    timer.signal.addEventListener("abort", () => reject(new Error("chirp_sync_timeout")));278-  });279-  const bytes = await Promise.race([pending, aborted]);280-  // MV-3: decrypted plaintext can exceed the wire frame (and a non-WS281-  // transport may not have enforced anything) — re-check before JSON.parse282-  // materialises a multi-GB string/object graph.283-  if (bytes.length > SYNC_LIMITS.MAX_FRAME_BYTES) {284-    throw new Error(`sync frame exceeds max size (${SYNC_LIMITS.MAX_FRAME_BYTES} bytes)`);285-  }286-  const parsed = JSON.parse(new TextDecoder().decode(bytes));287-  if (typeof parsed?.type !== "string") throw new Error("malformed SyncMessage");288-  return parsed as ChirpSyncMessage;289-}290-291-function errorOutcome(outcome: SyncOutcome, error: string): SyncOutcome {292-  outcome.status = "errored";293-  outcome.error = error;294-  return outcome;295-}

@@ -1,415 +0,0 @@1-import { beforeEach, describe, expect, it, vi } from "vitest";2-import type { PairedDevice, ChirpSyncMessage } from "../shared/sync-types";3-import type {4-  ChirpSyncSession,5-  SyncEndpoint,6-} from "../shared/chirp-sync-transport";7-import type { ChirpSyncVaultAdapter } from "./chirp-sync-coordinator";8-import type { SyncRunnerDeps } from "./chirp-sync-runner";9-10-type StorageShape = Record<string, unknown>;11-12-function makeChromeMock(local: StorageShape, sync: StorageShape): typeof chrome {13-  const area = (store: StorageShape) => ({14-    get: vi.fn(async (key?: string | string[]) => {15-      if (!key) return store;16-      if (typeof key === "string") return { [key]: store[key] };17-      return key.reduce<Record<string, unknown>>((acc, k) => { acc[k] = store[k]; return acc; }, {});18-    }),19-    set: vi.fn(async (next: Record<string, unknown>) => { Object.assign(store, next); }),20-    remove: vi.fn(async (keys: string | string[]) => {21-      const list = Array.isArray(keys) ? keys : [keys];22-      for (const k of list) delete store[k];23-    }),24-  });25-  return {26-    storage: { local: area(local), sync: area(sync) },27-    alarms: {28-      clear: vi.fn(),29-      create: vi.fn(),30-      onAlarm: { addListener: vi.fn() },31-    },32-    idle: { setDetectionInterval: vi.fn(), onStateChanged: { addListener: vi.fn() } },33-    runtime: { sendMessage: vi.fn(async () => undefined) },34-  } as unknown as typeof chrome;35-}36-37-const REMOTE_PUBKEY_HEX = "ab".repeat(32);38-39-function makeDevice(overrides: Partial<PairedDevice> = {}): PairedDevice {40-  return {41-    deviceId: "pixel-xyz",42-    deviceName: "Pixel",43-    deviceType: "android",44-    longTermPublicKeyHex: REMOTE_PUBKEY_HEX,45-    wsPort: 8765,46-    pairedAt: 1700000000000,47-    ...overrides,48-  };49-}50-51-interface FakePeer {52-  send(msg: ChirpSyncMessage): Promise<void>;53-  receive(): Promise<ChirpSyncMessage>;54-}55-56-/**57- * In-memory ChirpSyncSession ↔ FakePeer pair. The session is what the58- * runner passes to runChirpSyncInitiator; the peer is the other end of the59- * wire, controlled by the test body. Mirrors the pattern in60- * chirp-sync-coordinator.test.ts.61- */62-function inMemoryPair(): { session: ChirpSyncSession; peer: FakePeer; closed: { v: boolean } } {63-  const inboundToSession: Uint8Array[] = [];64-  const outboundFromSession: Uint8Array[] = [];65-  const sessionReaders: Array<(v: Uint8Array) => void> = [];66-  const peerReaders: Array<(v: Uint8Array) => void> = [];67-  const closed = { v: false };68-69-  const session: ChirpSyncSession = {70-    send(bytes) {71-      const r = peerReaders.shift();72-      if (r) r(bytes); else outboundFromSession.push(bytes);73-    },74-    receive(): Promise<Uint8Array> {75-      const v = inboundToSession.shift();76-      if (v) return Promise.resolve(v);77-      return new Promise<Uint8Array>((res) => sessionReaders.push(res));78-    },79-    async close() { closed.v = true; },80-    remoteStaticPublicKey: new Uint8Array(32),81-  };82-  const peer: FakePeer = {83-    async send(msg) {84-      const bytes = new TextEncoder().encode(JSON.stringify(msg));85-      const r = sessionReaders.shift();86-      if (r) r(bytes); else inboundToSession.push(bytes);87-    },88-    async receive() {89-      const v = outboundFromSession.shift();90-      const bytes = v ?? await new Promise<Uint8Array>((res) => peerReaders.push(res));91-      return JSON.parse(new TextDecoder().decode(bytes)) as ChirpSyncMessage;92-    },93-  };94-  return { session, peer, closed };95-}96-97-/**98- * Drive a happy-path SYNC_DONE handshake on the peer side, matching the99- * coordinator's HELLO → MANIFEST → REQUEST → ENTRIES → TOMBSTONES → DONE100- * sequence. `peerEntries` lets the peer send a SYNC_ENTRIES payload of any101- * size for the entriesReceived assertion; `wantFromUs` requests N entries102- * from our side (drives entriesSent).103- */104-async function runPeer(105-  peer: FakePeer,106-  opts: {107-    vaultId?: string;108-    peerEntriesB64?: Record<string, string>;109-    wantFromUsIds?: string[];110-  } = {},111-): Promise<void> {112-  const hello = await peer.receive();113-  if (hello.type !== "SYNC_HELLO") throw new Error("expected HELLO from initiator");114-  await peer.send({115-    type: "SYNC_HELLO",116-    vaultId: opts.vaultId ?? hello.vaultId,117-    deviceId: "peer-device",118-    version: 0,119-    deviceTime: Date.now(),120-  });121-  const manifest = await peer.receive();122-  if (manifest.type !== "SYNC_MANIFEST") throw new Error("expected MANIFEST");123-124-  // Peer manifest declares the entries it will ship in SYNC_ENTRIES.125-  const peerEntryManifest: Record<string, number> = {};126-  for (const id of Object.keys(opts.peerEntriesB64 ?? {})) {127-    peerEntryManifest[id] = Date.now();128-  }129-  await peer.send({130-    type: "SYNC_MANIFEST",131-    entries: peerEntryManifest,132-    tombstones: {},133-  });134-135-  const ourRequest = await peer.receive();136-  if (ourRequest.type !== "SYNC_REQUEST") throw new Error("expected REQUEST from initiator");137-138-  // Peer asks for the ids it wants from us.139-  await peer.send({ type: "SYNC_REQUEST", entryIds: opts.wantFromUsIds ?? [] });140-141-  const ourEntries = await peer.receive();142-  if (ourEntries.type !== "SYNC_ENTRIES") throw new Error("expected ENTRIES from initiator");143-144-  // Only ship SYNC_ENTRIES when the initiator actually requested any. The145-  // coordinator only awaits this frame when wantFromPeer.length > 0.146-  if (Object.keys(peerEntryManifest).length > 0) {147-    await peer.send({ type: "SYNC_ENTRIES", entries: opts.peerEntriesB64 ?? {} });148-  }149-150-  const ourTombstones = await peer.receive();151-  if (ourTombstones.type !== "SYNC_TOMBSTONES") throw new Error("expected TOMBSTONES");152-  await peer.send({ type: "SYNC_TOMBSTONES", tombstones: {} });153-154-  const done = await peer.receive();155-  if (done.type !== "SYNC_DONE") throw new Error("expected DONE");156-  await peer.send({ type: "SYNC_DONE" });157-}158-159-function emptyAdapter(): ChirpSyncVaultAdapter {160-  return {161-    async computeVaultId() { return "vault-abc"; },162-    async getOurDeviceId() { return "device-init"; },163-    // Non-zero so the equal-version short circuit doesn't fire in runner tests164-    // that exercise the full manifest-diff flow.165-    async getLocalVersion() { return 5; },166-    async buildEntryManifest() { return {}; },167-    async buildTombstoneManifest() { return {}; },168-    async getEncryptedEntries() { return {}; },169-    async applyEntries() { /* no-op */ },170-    async applyTombstones() { /* no-op */ },171-  };172-}173-174-describe("productionSyncRunner", () => {175-  let local: StorageShape;176-  let sync: StorageShape;177-178-  beforeEach(() => {179-    vi.resetModules();180-    local = {};181-    sync = {};182-    (globalThis as { chrome?: typeof chrome }).chrome = makeChromeMock(local, sync);183-    vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("network disabled"); }));184-  });185-186-  async function bootVault(): Promise<typeof import("./vault")> {187-    const vault = await import("./vault");188-    await vault.createVault("correct horse battery staple");189-    return vault;190-  }191-192-  it("returns VAULT_LOCKED result (does not throw) when the vault is locked", async () => {193-    const vault = await bootVault();194-    vault.lock();195-    const { runWithDeps } = await import("./chirp-sync-runner");196-    const deps: SyncRunnerDeps = {197-      openSession: vi.fn(),198-      probeSubnet: vi.fn(),199-      getSubnet: vi.fn(async () => "192.168.1"),200-      createAdapter: emptyAdapter,201-    };202-    const result = await runWithDeps(makeDevice(), deps);203-    expect(result).toEqual({ ok: false, error: "VAULT_LOCKED" });204-    expect(deps.openSession).not.toHaveBeenCalled();205-  });206-207-  it("throws when the device has no longTermPublicKeyHex", async () => {208-    await bootVault();209-    const { runWithDeps } = await import("./chirp-sync-runner");210-    const deps: SyncRunnerDeps = {211-      openSession: vi.fn(),212-      probeSubnet: vi.fn(),213-      getSubnet: vi.fn(),214-      createAdapter: emptyAdapter,215-    };216-    await expect(217-      runWithDeps(makeDevice({ longTermPublicKeyHex: undefined }), deps),218-    ).rejects.toThrow("paired_device_missing_pubkey");219-  });220-221-  it("uses the cached last-known IP first and skips the subnet probe", async () => {222-    await bootVault();223-    const { setLastKnownIp } = await import("./paired-devices");224-    await setLastKnownIp(REMOTE_PUBKEY_HEX, "192.168.1.42");225-226-    const { session, peer } = inMemoryPair();227-    const openSession = vi.fn(async (_e: SyncEndpoint) => session);228-    const probeSubnet = vi.fn();229-    const deps: SyncRunnerDeps = {230-      openSession,231-      probeSubnet,232-      getSubnet: vi.fn(async () => "192.168.1"),233-      createAdapter: emptyAdapter,234-    };235-236-    const { runWithDeps } = await import("./chirp-sync-runner");237-    const runPromise = runWithDeps(makeDevice(), deps);238-    await runPeer(peer);239-    const result = await runPromise;240-    expect(result).toEqual({ ok: true, entriesReceived: 0, entriesSent: 0 });241-    expect(openSession).toHaveBeenCalledTimes(1);242-    expect(openSession.mock.calls[0][0]).toEqual({ ip: "192.168.1.42", port: 8765 });243-    expect(probeSubnet).not.toHaveBeenCalled();244-  });245-246-  it("falls back to subnet probe when cached IP fails to connect", async () => {247-    await bootVault();248-    const { setLastKnownIp, getLastKnownIp } = await import("./paired-devices");249-    await setLastKnownIp(REMOTE_PUBKEY_HEX, "192.168.1.13");250-251-    const { session, peer } = inMemoryPair();252-    const openSession = vi.fn()253-      .mockRejectedValueOnce(new Error("ECONNREFUSED"))254-      .mockResolvedValueOnce(session);255-    const probeSubnet = vi.fn(async () => ({ ip: "192.168.1.99", port: 8765 }));256-    const deps: SyncRunnerDeps = {257-      openSession,258-      probeSubnet,259-      getSubnet: vi.fn(async () => "192.168.1"),260-      createAdapter: emptyAdapter,261-    };262-263-    const { runWithDeps } = await import("./chirp-sync-runner");264-    const runPromise = runWithDeps(makeDevice(), deps);265-    await runPeer(peer);266-    await runPromise;267-    expect(openSession).toHaveBeenCalledTimes(2);268-    expect(openSession.mock.calls[1][0]).toEqual({ ip: "192.168.1.99", port: 8765 });269-    expect(probeSubnet).toHaveBeenCalledTimes(1);270-    expect(await getLastKnownIp(REMOTE_PUBKEY_HEX)).toBe("192.168.1.99");271-  });272-273-  it("throws host_unreachable when cached IP fails AND subnet probe returns null", async () => {274-    await bootVault();275-    const { setLastKnownIp } = await import("./paired-devices");276-    await setLastKnownIp(REMOTE_PUBKEY_HEX, "192.168.1.13");277-278-    const deps: SyncRunnerDeps = {279-      openSession: vi.fn().mockRejectedValue(new Error("ECONNREFUSED")),280-      probeSubnet: vi.fn(async () => null),281-      getSubnet: vi.fn(async () => "192.168.1"),282-      createAdapter: emptyAdapter,283-    };284-    const { runWithDeps } = await import("./chirp-sync-runner");285-    await expect(runWithDeps(makeDevice(), deps)).rejects.toThrow("host_unreachable");286-  });287-288-  it("throws subnet_unknown when no cached IP and the local subnet can't be determined", async () => {289-    await bootVault();290-    const deps: SyncRunnerDeps = {291-      openSession: vi.fn(),292-      probeSubnet: vi.fn(),293-      getSubnet: vi.fn(async () => null),294-      createAdapter: emptyAdapter,295-    };296-    const { runWithDeps } = await import("./chirp-sync-runner");297-    await expect(runWithDeps(makeDevice(), deps)).rejects.toThrow("subnet_unknown");298-  });299-300-  it("surfaces entriesReceived from the peer's SYNC_ENTRIES payload", async () => {301-    await bootVault();302-    const { session, peer } = inMemoryPair();303-    const openSession = vi.fn(async () => session);304-    const deps: SyncRunnerDeps = {305-      openSession,306-      probeSubnet: vi.fn(async () => ({ ip: "192.168.1.1", port: 8765 })),307-      getSubnet: vi.fn(async () => "192.168.1"),308-      createAdapter: emptyAdapter,309-    };310-    const { runWithDeps } = await import("./chirp-sync-runner");311-    const runPromise = runWithDeps(makeDevice(), deps);312-    await runPeer(peer, {313-      peerEntriesB64: { "id-1": "AAAA", "id-2": "BBBB", "id-3": "CCCC" },314-    });315-    const result = await runPromise;316-    expect(result.ok).toBe(true);317-    if (result.ok) {318-      expect(result.entriesReceived).toBe(3);319-      expect(result.entriesSent).toBe(0);320-    }321-  });322-323-  it("surfaces entriesSent from the adapter's encrypted-entry response", async () => {324-    await bootVault();325-    const { session, peer } = inMemoryPair();326-    const adapter: ChirpSyncVaultAdapter = {327-      ...emptyAdapter(),328-      async getEncryptedEntries(ids) {329-        const out: Record<string, string> = {};330-        for (const id of ids) out[id] = "ENVELOPE_" + id;331-        return out;332-      },333-    };334-    const deps: SyncRunnerDeps = {335-      openSession: vi.fn(async () => session),336-      probeSubnet: vi.fn(async () => ({ ip: "192.168.1.1", port: 8765 })),337-      getSubnet: vi.fn(async () => "192.168.1"),338-      createAdapter: () => adapter,339-    };340-    const { runWithDeps } = await import("./chirp-sync-runner");341-    const runPromise = runWithDeps(makeDevice(), deps);342-    await runPeer(peer, { wantFromUsIds: ["a", "b"] });343-    const result = await runPromise;344-    expect(result.ok).toBe(true);345-    if (result.ok) expect(result.entriesSent).toBe(2);346-  });347-348-  it("translates a vault_id_mismatch coordinator outcome into an error throw", async () => {349-    await bootVault();350-    const { session, peer } = inMemoryPair();351-    const deps: SyncRunnerDeps = {352-      openSession: vi.fn(async () => session),353-      probeSubnet: vi.fn(async () => ({ ip: "192.168.1.1", port: 8765 })),354-      getSubnet: vi.fn(async () => "192.168.1"),355-      createAdapter: emptyAdapter,356-    };357-    const { runWithDeps } = await import("./chirp-sync-runner");358-    const runPromise = runWithDeps(makeDevice(), deps);359-    // Peer responds with a vault_id that does NOT match ours, forcing the360-    // coordinator to send SYNC_ERROR and return status:"vault_mismatch".361-    (async () => {362-      const hello = await peer.receive();363-      if (hello.type === "SYNC_HELLO") {364-        await peer.send({365-          type: "SYNC_HELLO",366-          vaultId: "wrong-vault-id",367-          deviceId: "peer-device",368-          version: 0,369-          deviceTime: Date.now(),370-        });371-      }372-    })().catch(() => undefined);373-    await expect(runPromise).rejects.toThrow("vault_id_mismatch");374-  });375-});376-377-describe("sync-trigger persistence", () => {378-  let local: StorageShape;379-  let sync: StorageShape;380-381-  beforeEach(() => {382-    vi.resetModules();383-    local = {};384-    sync = {};385-    (globalThis as { chrome?: typeof chrome }).chrome = makeChromeMock(local, sync);386-    vi.stubGlobal("fetch", vi.fn(async () => { throw new Error("network disabled"); }));387-  });388-389-  it("persists lastSyncAt to chrome.storage.local on a successful sync", async () => {390-    const trigger = await import("./sync-trigger");391-    const paired = await import("./paired-devices");392-    trigger._resetSyncTriggerForTest();393-    await paired.upsertPairedDevice({394-      deviceId: "P",395-      deviceName: "Pixel",396-      deviceType: "android",397-      longTermPublicKeyHex: "a".repeat(64),398-      trustSource: "direct",399-      pairedAt: 1700000000000,400-    });401-    trigger.setSyncRunner(async () => ({ ok: true, entriesReceived: 1, entriesSent: 0 }));402-    await trigger.triggerSyncIfReachable({ reason: "manual" });403-    expect(typeof local.peach_last_sync_at).toBe("number");404-    expect(local.peach_last_sync_at).toBeGreaterThan(0);405-  });406-407-  it("hydratePersistedSyncState fills lastSyncAt from storage when in-memory state is empty", async () => {408-    local.peach_last_sync_at = 1_700_005_000_000;409-    const trigger = await import("./sync-trigger");410-    trigger._resetSyncTriggerForTest();411-    expect(trigger.getSyncState().lastSyncAt).toBeUndefined();412-    await trigger.hydratePersistedSyncState();413-    expect(trigger.getSyncState().lastSyncAt).toBe(1_700_005_000_000);414-  });415-});