@aithos/sdk 0.1.0-alpha.54 → 0.1.0-alpha.56

package/dist/test/migrate.test.js

@@ -0,0 +1,340 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Hermetic end-to-end tests for the legacy #data sphere migration
+// (src/migrate.ts). No network: an in-memory PDS + registry mock implements
+// the subset of primitives the flow touches. This also serves as the
+// conformance guard between src/internal/cmk-wrap.ts and src/data.ts — the
+// migration re-wraps with cmk-wrap, and a real DataClient (data.ts) must be
+// able to read the result, and vice-versa.
+import { test } from "node:test";
+import { strict as assert } from "node:assert";
+import { createBrowserIdentity } from "@aithos/protocol-client";
+import { createDataClient } from "../src/data.js";
+import { ensureDataSphere, rekeyLegacyCollections, addDataSphereWrap, migrateLegacyEthosToDataSphere, } from "../src/migrate.js";
+import { parseRecoveryFile } from "../src/internal/recovery-file.js";
+function makePds() {
+    const collections = new Map();
+    const records = new Map();
+    const augmentCalls = [];
+    const fetchImpl = (async (_url, init) => {
+        const body = JSON.parse(init.body);
+        const p = body.method;
+        const params = body.params ?? {};
+        const ok = (result) => new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, result }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+        const rpcErr = (code, message) => new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, error: { code, message } }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+        const urnFor = (did, name) => `urn:aithos:collection:${did}:${name}`;
+        switch (p) {
+            case "aithos.augment_identity": {
+                augmentCalls.push(params.did_document);
+                return ok({ did: params.did_document.id, idempotent: false, data_sphere_added: true });
+            }
+            case "aithos.data.create_collection": {
+                const urn = urnFor(params.subject_did, params.collection_name);
+                collections.set(urn, {
+                    urn,
+                    name: params.collection_name,
+                    schema: params.schema,
+                    subject_did: params.subject_did,
+                    cmk_envelope: params.cmk_envelope,
+                    record_count: 0,
+                });
+                records.set(urn, new Map());
+                return ok({ urn, name: params.collection_name, schema: params.schema, cmk_envelope: params.cmk_envelope });
+            }
+            case "aithos.data.get_collection": {
+                const urn = urnFor(params.subject_did, params.collection_name);
+                const c = collections.get(urn);
+                if (!c)
+                    return rpcErr(-32020, "not found");
+                return ok({ urn: c.urn, name: c.name, schema: c.schema, cmk_envelope: c.cmk_envelope, record_count: c.record_count });
+            }
+            case "aithos.data.list_collections": {
+                const items = [...collections.values()]
+                    .filter((c) => c.subject_did === params.subject_did)
+                    .map((c) => ({ name: c.name, schema: c.schema, record_count: c.record_count }));
+                return ok({ items });
+            }
+            case "aithos.data.insert_record": {
+                const recs = records.get(params.collection_urn);
+                if (!recs)
+                    return rpcErr(-32020, "no collection");
+                recs.set(params.record_id, {
+                    record_id: params.record_id,
+                    metadata: params.metadata,
+                    payload: params.payload,
+                });
+                const c = [...collections.values()].find((x) => x.urn === params.collection_urn);
+                if (c)
+                    c.record_count++;
+                return ok({ record_id: params.record_id });
+            }
+            case "aithos.data.get_record": {
+                const recs = records.get(params.collection_urn);
+                const r = recs?.get(params.record_id);
+                if (!r)
+                    return rpcErr(-32020, "not found");
+                return ok(r);
+            }
+            case "aithos.data.list_records": {
+                const recs = records.get(params.collection_urn) ?? new Map();
+                return ok({ items: [...recs.values()] });
+            }
+            case "aithos.data.rotate_cmk": {
+                const c = [...collections.values()].find((x) => x.urn === params.collection_urn);
+                if (!c)
+                    return rpcErr(-32020, "not found");
+                c.cmk_envelope = params.new_cmk_envelope;
+                return ok({ rotated_at: new Date().toISOString(), records_rewrapped: (params.re_wrapped_deks ?? []).length });
+            }
+            default:
+                return rpcErr(-32601, `method not found: ${p}`);
+        }
+    });
+    return { fetchImpl, collections, records, augmentCalls };
+}
+/* -------------------------------------------------------------------------- */
+/*  Helpers                                                                   */
+/* -------------------------------------------------------------------------- */
+function hex(b) {
+    let s = "";
+    for (const x of b)
+        s += x.toString(16).padStart(2, "0");
+    return s;
+}
+function hexToBytes(h) {
+    const out = new Uint8Array(h.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(h.substr(i * 2, 2), 16);
+    return out;
+}
+/** A legacy recovery file (root/public/circle/self only — NO #data). */
+function legacyRecoveryJson(id) {
+    return JSON.stringify({
+        aithos_recovery_version: "0.1.0-plaintext",
+        handle: id.handle,
+        display_name: id.displayName,
+        did: id.did,
+        seeds_hex: {
+            root: hex(id.root.seed),
+            public: hex(id.public.seed),
+            circle: hex(id.circle.seed),
+            self: hex(id.self.seed),
+        },
+        saved_at: new Date().toISOString(),
+    });
+}
+const API = "https://api.test";
+const PDS = "https://pds.test";
+/* -------------------------------------------------------------------------- */
+/*  Tests                                                                     */
+/* -------------------------------------------------------------------------- */
+test("migrate: legacy collection (self-sealed) → #data, record stays readable", async () => {
+    const id = createBrowserIdentity("legacy_user", "Legacy User");
+    const did = id.did;
+    const pds = makePds();
+    const recovery = legacyRecoveryJson(id);
+    // 1. Old app created the collection signing under #self (sphereSeed = self).
+    const legacyClient = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: id.self.seed,
+        verificationMethod: `${did}#self`,
+        fetch: pds.fetchImpl,
+    });
+    await legacyClient.createCollection({ name: "contacts", schema: "aithos.contacts.v1" });
+    const recId = await legacyClient.collection("contacts").insert({
+        name: "Jean Dupont",
+        phone: "+33612345678",
+        notes: "secret pre-migration note",
+    });
+    const before = await legacyClient.collection("contacts").get(recId);
+    assert.equal(before.phone, "+33612345678", "legacy read works pre-migration");
+    // Sanity: the stored owner wrap is labelled #data-kex but sealed to the self key.
+    const urn = `urn:aithos:collection:${did}:contacts`;
+    assert.equal(pds.collections.get(urn).cmk_envelope.wraps[0].recipient, `${did}#data-kex`, "owner wrap is labelled #data-kex regardless of the sealing seed");
+    // 2. ensureDataSphere — adds #data, returns a recovery file carrying it.
+    const ensure = await ensureDataSphere(recovery, { apiBaseUrl: API, pdsUrl: PDS, fetch: pds.fetchImpl });
+    assert.equal(ensure.added, true);
+    assert.equal(ensure.dataSeedHex.length, 64, "a 32-byte #data seed was generated");
+    assert.equal(pds.augmentCalls.length, 1, "augment_identity was called once");
+    // 3. rekey — re-wrap CMK from self to #data.
+    const rekey = await rekeyLegacyCollections(parseRecoveryFile(ensure.updatedRecoveryFile), {
+        pdsUrl: PDS,
+        fetch: pds.fetchImpl,
+    });
+    assert.equal(rekey.collections.length, 1);
+    assert.equal(rekey.collections[0].status, "rekeyed");
+    assert.equal(rekey.collections[0].unwrappedWith, "self", "auto-discovered the self seed");
+    // owner wrap recipient label unchanged; still exactly one owner wrap.
+    const envAfter = pds.collections.get(urn).cmk_envelope;
+    const ownerWraps = envAfter.wraps.filter((w) => w.recipient === `${did}#data-kex`);
+    assert.equal(ownerWraps.length, 1, "exactly one owner wrap after rekey");
+    // 4. A fresh #data client reads the SAME record and decrypts it.
+    const dataClient = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: hexToBytes(ensure.dataSeedHex),
+        verificationMethod: `${did}#data`,
+        fetch: pds.fetchImpl,
+    });
+    const after = await dataClient.collection("contacts").get(recId);
+    assert.ok(after, "record fetched post-migration");
+    assert.equal(after.phone, "+33612345678", "phone decrypts under #data");
+    assert.equal(after.notes, "secret pre-migration note", "notes decrypt under #data");
+    // 5. Idempotence — re-running rekey is a no-op (already-data).
+    const rekey2 = await rekeyLegacyCollections(parseRecoveryFile(ensure.updatedRecoveryFile), {
+        pdsUrl: PDS,
+        fetch: pds.fetchImpl,
+    });
+    assert.equal(rekey2.collections[0].status, "already-data");
+});
+test("migrate: dry-run reports a planned rekey without mutating the envelope", async () => {
+    const id = createBrowserIdentity("dry_user", "Dry User");
+    const did = id.did;
+    const pds = makePds();
+    const legacyClient = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: id.public.seed, // sealed under #public this time
+        verificationMethod: `${did}#public`,
+        fetch: pds.fetchImpl,
+    });
+    await legacyClient.createCollection({ name: "leads", schema: "aithos.contacts.v1" });
+    await legacyClient.collection("leads").insert({ name: "Ana", phone: "+34000" });
+    const urn = `urn:aithos:collection:${did}:leads`;
+    const envBefore = JSON.stringify(pds.collections.get(urn).cmk_envelope);
+    const ensure = await ensureDataSphere(legacyRecoveryJson(id), { apiBaseUrl: API, pdsUrl: PDS, fetch: pds.fetchImpl });
+    const rekey = await rekeyLegacyCollections(parseRecoveryFile(ensure.updatedRecoveryFile), {
+        pdsUrl: PDS,
+        fetch: pds.fetchImpl,
+        dryRun: true,
+    });
+    assert.equal(rekey.dryRun, true);
+    assert.equal(rekey.collections[0].status, "planned");
+    assert.equal(rekey.collections[0].unwrappedWith, "public");
+    assert.equal(JSON.stringify(pds.collections.get(urn).cmk_envelope), envBefore, "dry-run did NOT touch the stored envelope");
+});
+test("migrate: delegate wraps are preserved across rekey", async () => {
+    const id = createBrowserIdentity("deleg_user", "Deleg User");
+    const did = id.did;
+    const pds = makePds();
+    const legacyClient = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: id.self.seed,
+        verificationMethod: `${did}#self`,
+        fetch: pds.fetchImpl,
+    });
+    await legacyClient.createCollection({ name: "shared", schema: "aithos.contacts.v1" });
+    // Inject a fake delegate wrap (a did:key recipient) directly into the stored
+    // envelope to simulate a prior authorize_app.
+    const urn = `urn:aithos:collection:${did}:shared`;
+    const env = pds.collections.get(urn).cmk_envelope;
+    env.wraps.push({
+        recipient: "did:key:zDelegateKey#data-kex",
+        // The other fields aren't read by the migration (it filters by recipient).
+    });
+    const ensure = await ensureDataSphere(legacyRecoveryJson(id), { apiBaseUrl: API, pdsUrl: PDS, fetch: pds.fetchImpl });
+    const rekey = await rekeyLegacyCollections(parseRecoveryFile(ensure.updatedRecoveryFile), {
+        pdsUrl: PDS,
+        fetch: pds.fetchImpl,
+    });
+    assert.equal(rekey.collections[0].status, "rekeyed");
+    assert.equal(rekey.collections[0].delegateWrapsPreserved, 1);
+    const after = pds.collections.get(urn).cmk_envelope;
+    assert.ok(after.wraps.some((w) => w.recipient === "did:key:zDelegateKey#data-kex"), "delegate wrap survived the rekey");
+    assert.equal(after.wraps.filter((w) => w.recipient === `${did}#data-kex`).length, 1, "still exactly one owner wrap");
+});
+test("migrate: add-data-wrap keeps the legacy reader AND enables #data (dual-read)", async () => {
+    // Mirrors linkedone: a collection created+read under #root (post-store passes
+    // sphereSeed: rootSeed). We must NOT break the #root reader, but ALSO let a
+    // #data client read the same data.
+    const id = createBrowserIdentity("dual_user", "Dual User");
+    const did = id.did;
+    const pds = makePds();
+    // Legacy app wraps the CMK under #root (recipient label is #data-kex anyway).
+    const rootClient = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: id.root.seed,
+        verificationMethod: `${did}#root`,
+        fetch: pds.fetchImpl,
+    });
+    await rootClient.createCollection({ name: "posts", schema: "aithos.contacts.v1" });
+    const recId = await rootClient.collection("posts").insert({ name: "Léa", phone: "+33secret-root" });
+    // Onboard onto #data in ADD mode (non-destructive).
+    const ensure = await ensureDataSphere(legacyRecoveryJson(id), { apiBaseUrl: API, pdsUrl: PDS, fetch: pds.fetchImpl });
+    const report = await addDataSphereWrap(parseRecoveryFile(ensure.updatedRecoveryFile), {
+        pdsUrl: PDS,
+        fetch: pds.fetchImpl,
+    });
+    assert.equal(report.collections[0].status, "data-wrap-added");
+    assert.equal(report.collections[0].unwrappedWith, "root");
+    // Two owner wraps now share the #data-kex label.
+    const urn = `urn:aithos:collection:${did}:posts`;
+    const ownerWraps = pds.collections.get(urn).cmk_envelope.wraps.filter((w) => w.recipient === `${did}#data-kex`);
+    assert.equal(ownerWraps.length, 2, "legacy + #data owner wraps coexist");
+    // 1) The legacy #root reader STILL works (unchanged app).
+    const rootClient2 = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: id.root.seed,
+        verificationMethod: `${did}#root`,
+        fetch: pds.fetchImpl,
+    });
+    const viaRoot = await rootClient2.collection("posts").get(recId);
+    assert.equal(viaRoot.phone, "+33secret-root", "#root reader still decrypts (multi-wrap reader tries all)");
+    // 2) A #data client reads the SAME record.
+    const dataClient = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: hexToBytes(ensure.dataSeedHex),
+        verificationMethod: `${did}#data`,
+        fetch: pds.fetchImpl,
+    });
+    const viaData = await dataClient.collection("posts").get(recId);
+    assert.equal(viaData.phone, "+33secret-root", "#data reader decrypts the same data");
+    // Idempotent: re-running add is a no-op.
+    const again = await addDataSphereWrap(parseRecoveryFile(ensure.updatedRecoveryFile), { pdsUrl: PDS, fetch: pds.fetchImpl });
+    assert.equal(again.collections[0].status, "already-data");
+});
+test("migrate: combined helper runs ensure + rekey and returns updated recovery", async () => {
+    const id = createBrowserIdentity("combo_user", "Combo User");
+    const did = id.did;
+    const pds = makePds();
+    const legacyClient = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: id.self.seed,
+        verificationMethod: `${did}#self`,
+        fetch: pds.fetchImpl,
+    });
+    await legacyClient.createCollection({ name: "contacts", schema: "aithos.contacts.v1" });
+    const recId = await legacyClient.collection("contacts").insert({ name: "Zoe", phone: "+1999" });
+    const out = await migrateLegacyEthosToDataSphere(legacyRecoveryJson(id), {
+        apiBaseUrl: API,
+        pdsUrl: PDS,
+        fetch: pds.fetchImpl,
+    });
+    assert.equal(out.ensure.added, true);
+    assert.equal(out.rekey.collections[0].status, "rekeyed");
+    const parsed = parseRecoveryFile(out.updatedRecoveryFile);
+    assert.equal(typeof parsed.seedsHex.data, "string");
+    // Read back under #data via the returned seed.
+    const dataClient = createDataClient({
+        pdsUrl: PDS,
+        did,
+        sphereSeed: hexToBytes(out.ensure.dataSeedHex),
+        verificationMethod: `${did}#data`,
+        fetch: pds.fetchImpl,
+    });
+    const after = await dataClient.collection("contacts").get(recId);
+    assert.equal(after.phone, "+1999");
+});
+//# sourceMappingURL=migrate.test.js.map

package/dist/test/rotate-ethos.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rotate-ethos.test.d.ts.map

package/dist/test/rotate-ethos.test.js

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Hermetic test of the rotateEthos orchestration, MINUS the live zone recopy
+// (the protocol-client editor uses ambient fetch and can't be mocked here, so
+// we drive the no-edition path). Covers: did.json rotation (rotate_sphere_key
+// with a root-verifiable rotated doc) + collections dual-wrapped toward the NEW
+// #data, readable under the new key while the old wrap is preserved.
+import { test } from "node:test";
+import { strict as assert } from "node:assert";
+import { createBrowserIdentity, signedDidDocument } from "@aithos/protocol-client";
+import { verifyDidDocument } from "@aithos/protocol-core";
+import { createDataClient } from "../src/data.js";
+import { rotateEthos } from "../src/rotate.js";
+import { parseRecoveryFile } from "../src/internal/recovery-file.js";
+const API = "https://api.test";
+const PDS = "https://pds.test";
+function hex(b) {
+    let s = "";
+    for (const x of b)
+        s += x.toString(16).padStart(2, "0");
+    return s;
+}
+function hexToBytes(h) {
+    const o = new Uint8Array(h.length / 2);
+    for (let i = 0; i < o.length; i++)
+        o[i] = parseInt(h.substr(i * 2, 2), 16);
+    return o;
+}
+/** Mock api.aithos.be (identity) + pds.aithos.be (data). No edition exists. */
+function makeMock(initialDidDoc) {
+    let didDoc = initialDidDoc;
+    const collections = new Map();
+    const records = new Map();
+    let rotateCalls = 0;
+    const fetchImpl = (async (url, init) => {
+        const body = JSON.parse(init.body);
+        const m = body.method;
+        const p = body.params ?? {};
+        const ok = (result) => new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, result }), { status: 200, headers: { "content-type": "application/json" } });
+        const rpcErr = (code, message) => new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, error: { code, message } }), { status: 200, headers: { "content-type": "application/json" } });
+        const urnFor = (did, name) => `urn:aithos:collection:${did}:${name}`;
+        switch (m) {
+            // --- identity (api) ---
+            case "aithos.get_identity":
+                return ok({ object: didDoc });
+            case "aithos.get_ethos_manifest":
+                return rpcErr(-32020, "not found: edition for " + p.did); // no edition
+            case "aithos.rotate_sphere_key":
+                didDoc = p.new_did_document;
+                rotateCalls++;
+                return ok({ did: p.new_did_document.id, rotated_spheres: ["public", "circle", "self"] });
+            // --- data (pds) ---
+            case "aithos.data.create_collection": {
+                const urn = urnFor(p.subject_did, p.collection_name);
+                collections.set(urn, { urn, name: p.collection_name, schema: p.schema, subject_did: p.subject_did, cmk_envelope: p.cmk_envelope, record_count: 0 });
+                records.set(urn, new Map());
+                return ok({ urn, name: p.collection_name, schema: p.schema, cmk_envelope: p.cmk_envelope });
+            }
+            case "aithos.data.get_collection": {
+                const c = collections.get(urnFor(p.subject_did, p.collection_name));
+                if (!c)
+                    return rpcErr(-32020, "not found");
+                return ok({ urn: c.urn, name: c.name, schema: c.schema, cmk_envelope: c.cmk_envelope, record_count: c.record_count });
+            }
+            case "aithos.data.list_collections":
+                return ok({ items: [...collections.values()].filter((c) => c.subject_did === p.subject_did).map((c) => ({ name: c.name, schema: c.schema, record_count: c.record_count })) });
+            case "aithos.data.insert_record": {
+                const recs = records.get(p.collection_urn);
+                recs.set(p.record_id, { record_id: p.record_id, metadata: p.metadata, payload: p.payload });
+                return ok({ record_id: p.record_id });
+            }
+            case "aithos.data.get_record": {
+                const r = records.get(p.collection_urn)?.get(p.record_id);
+                return r ? ok(r) : rpcErr(-32020, "not found");
+            }
+            case "aithos.data.rotate_cmk": {
+                const c = [...collections.values()].find((x) => x.urn === p.collection_urn);
+                c.cmk_envelope = p.new_cmk_envelope;
+                return ok({ rotated_at: new Date().toISOString() });
+            }
+            default:
+                return rpcErr(-32601, `method not found: ${m}`);
+        }
+    });
+    return { fetchImpl, getDidDoc: () => didDoc, collections, rotateCalls: () => rotateCalls };
+}
+test("rotateEthos: rotates did.json (verifiable) + dual-wraps collections to the new #data", async () => {
+    // Legacy identity: published did.json WITHOUT #data (strip it).
+    const id = createBrowserIdentity("rotee", "Rotee");
+    const legacyDoc = signedDidDocument({ ...id, data: undefined });
+    const mock = makeMock(legacyDoc);
+    const did = id.did;
+    const legacyRecovery = JSON.stringify({
+        aithos_recovery_version: "0.1.0-plaintext",
+        handle: id.handle,
+        display_name: id.displayName,
+        did,
+        seeds_hex: { root: hex(id.root.seed), public: hex(id.public.seed), circle: hex(id.circle.seed), self: hex(id.self.seed) },
+    });
+    // A collection created + sealed under the OLD #self key.
+    const oldClient = createDataClient({ pdsUrl: PDS, did, sphereSeed: id.self.seed, verificationMethod: `${did}#self`, fetch: mock.fetchImpl });
+    await oldClient.createCollection({ name: "contacts", schema: "aithos.contacts.v1" });
+    const recId = await oldClient.collection("contacts").insert({ name: "Iris", phone: "+33-rot-secret" });
+    // Rotate everything. No edition exists → zones skipped automatically.
+    const result = await rotateEthos(legacyRecovery, { apiBaseUrl: API, pdsUrl: PDS, fetch: mock.fetchImpl });
+    assert.equal(result.hadEdition, false);
+    assert.equal(result.editionRepublished, false);
+    assert.equal(mock.rotateCalls(), 1, "rotate_sphere_key called once");
+    // The newly published did.json verifies under root, rotated all 3 spheres, added #data.
+    const newDoc = mock.getDidDoc();
+    assert.equal(verifyDidDocument(newDoc), true, "rotated did.json verifies under root");
+    assert.equal(newDoc.aithos.rotated.length, 3);
+    assert.ok(newDoc.verificationMethod.some((v) => v.id === `${did}#data`), "#data added");
+    for (const s of ["public", "circle", "self"]) {
+        const oldK = legacyDoc.verificationMethod.find((v) => v.id === `${did}#${s}`).publicKeyMultibase;
+        const newK = newDoc.verificationMethod.find((v) => v.id === `${did}#${s}`).publicKeyMultibase;
+        assert.notEqual(newK, oldK, `${s} rotated`);
+    }
+    // Collections re-keyed toward the new #data (dual). Read under the NEW #data.
+    assert.equal(result.collections.collections[0].status, "data-wrap-added");
+    const newRec = parseRecoveryFile(result.updatedRecoveryFile);
+    assert.ok(newRec.seedsHex.data && newRec.seedsHex.data.length === 64, "new recovery carries #data");
+    // all sphere seeds changed
+    assert.notEqual(newRec.seedsHex.public, hex(id.public.seed));
+    const dataClient = createDataClient({ pdsUrl: PDS, did, sphereSeed: hexToBytes(newRec.seedsHex.data), verificationMethod: `${did}#data`, fetch: mock.fetchImpl });
+    const got = await dataClient.collection("contacts").get(recId);
+    assert.equal(got.phone, "+33-rot-secret", "record decrypts under the NEW #data");
+    // The OLD #self reader still works (dual: old wrap preserved).
+    const selfClient = createDataClient({ pdsUrl: PDS, did, sphereSeed: id.self.seed, verificationMethod: `${did}#self`, fetch: mock.fetchImpl });
+    const viaSelf = await selfClient.collection("contacts").get(recId);
+    assert.equal(viaSelf.phone, "+33-rot-secret", "old #self reader still decrypts");
+});
+test("rotateEthos: refuses to skip zones when an edition exists (no force)", async () => {
+    const id = createBrowserIdentity("rotee2", "Rotee2");
+    const mock = makeMock(signedDidDocument({ ...id, data: undefined }));
+    // Make get_ethos_manifest succeed → an edition "exists".
+    const patched = (async (url, init) => {
+        const body = JSON.parse(init.body);
+        if (body.method === "aithos.get_ethos_manifest") {
+            return new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, result: { object: { edition: { height: 0 } } } }), { status: 200 });
+        }
+        return mock.fetchImpl(url, init);
+    });
+    const legacyRecovery = JSON.stringify({
+        aithos_recovery_version: "0.1.0-plaintext",
+        handle: id.handle, display_name: id.displayName, did: id.did,
+        seeds_hex: { root: hex(id.root.seed), public: hex(id.public.seed), circle: hex(id.circle.seed), self: hex(id.self.seed) },
+    });
+    await assert.rejects(() => rotateEthos(legacyRecovery, { apiBaseUrl: API, pdsUrl: PDS, fetch: patched, skipZones: true }), /would orphan that content/);
+});
+//# sourceMappingURL=rotate-ethos.test.js.map

package/dist/test/rotate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rotate.test.d.ts.map

package/dist/test/rotate.test.js

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Unit tests for buildSignedRotatedDidDocument: the rotated did.json must (1)
+// verify under the unchanged root key, (2) grow aithos.rotated[] by one entry
+// per changed Ethos sphere, (3) carry the #data sphere, (4) keep the DID.
+import { test } from "node:test";
+import { strict as assert } from "node:assert";
+import { randomBytes } from "node:crypto";
+import { createBrowserIdentity, signedDidDocument } from "@aithos/protocol-client";
+import { verifyDidDocument } from "@aithos/protocol-core";
+import { buildSignedRotatedDidDocument } from "../src/rotate.js";
+function seed() {
+    return new Uint8Array(randomBytes(32));
+}
+test("rotate: rotated did.json verifies under root, grows rotated[], carries #data, keeps DID", () => {
+    // Baseline: a legacy-style identity (no rotation history).
+    const id = createBrowserIdentity("rot_user", "Rot User");
+    const previousDoc = signedDidDocument(id);
+    assert.equal(previousDoc.aithos.rotated.length, 0, "baseline has empty rotation history");
+    // Rotate all three Ethos spheres + #data; keep root.
+    const seeds = { root: id.root.seed, public: seed(), circle: seed(), self: seed(), data: seed() };
+    const rotated = buildSignedRotatedDidDocument(seeds, previousDoc, "Rot User", "key-rotation");
+    // 1. Root signature still valid (root unchanged).
+    assert.equal(verifyDidDocument(rotated), true, "rotated doc verifies under root");
+    // 2. DID unchanged.
+    assert.equal(rotated.id, previousDoc.id);
+    // 3. rotated[] grew by exactly 3 (public, circle, self all changed).
+    assert.equal(rotated.aithos.rotated.length, 3);
+    const spheres = rotated.aithos.rotated.map((r) => r.sphere).sort();
+    assert.deepEqual(spheres, ["circle", "public", "self"]);
+    // Each entry records the OLD key.
+    for (const entry of rotated.aithos.rotated) {
+        const prev = previousDoc.verificationMethod.find((v) => v.id === `${rotated.id}#${entry.sphere}`);
+        assert.equal(entry.previous_key, prev.publicKeyMultibase, `${entry.sphere} records previous key`);
+    }
+    // 4. New keys actually differ + #data present.
+    for (const sphere of ["public", "circle", "self"]) {
+        const oldVm = previousDoc.verificationMethod.find((v) => v.id === `${rotated.id}#${sphere}`);
+        const newVm = rotated.verificationMethod.find((v) => v.id === `${rotated.id}#${sphere}`);
+        assert.notEqual(newVm.publicKeyMultibase, oldVm.publicKeyMultibase, `${sphere} key rotated`);
+    }
+    assert.ok(rotated.verificationMethod.some((v) => v.id === `${rotated.id}#data`), "#data VM present");
+    assert.ok((rotated.keyAgreement ?? []).some((v) => v.id === `${rotated.id}#data-kex`), "#data-kex present");
+});
+test("rotate: history is carried forward across a second rotation", () => {
+    const id = createBrowserIdentity("rot2", "Rot2");
+    const doc0 = signedDidDocument(id);
+    const seeds1 = { root: id.root.seed, public: seed(), circle: seed(), self: seed(), data: seed() };
+    const doc1 = buildSignedRotatedDidDocument(seeds1, doc0, "Rot2");
+    assert.equal(doc1.aithos.rotated.length, 3);
+    // Second rotation from doc1 → 3 more entries (total 6).
+    const seeds2 = { root: id.root.seed, public: seed(), circle: seed(), self: seed(), data: seeds1.data };
+    const doc2 = buildSignedRotatedDidDocument(seeds2, doc1, "Rot2");
+    assert.equal(doc2.aithos.rotated.length, 6, "prior history preserved + new entries appended");
+    assert.equal(verifyDidDocument(doc2), true);
+});
+test("rotate: refuses if root seed does not match the DID", () => {
+    const id = createBrowserIdentity("rot3", "Rot3");
+    const doc0 = signedDidDocument(id);
+    const seeds = { root: seed() /* WRONG root */, public: seed(), circle: seed(), self: seed() };
+    assert.throws(() => buildSignedRotatedDidDocument(seeds, doc0, "Rot3"), /root .* never rotated/);
+});
+//# sourceMappingURL=rotate.test.js.map

package/dist/test/schema-autoresolve.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema-autoresolve.test.d.ts.map