@aithos/sdk 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.1.0-alpha.3";
+export declare const VERSION = "0.1.0-alpha.5";
 export { AithosSDK } from "./sdk.js";
 export type { AithosSDKConfig } from "./types.js";
 export { AithosSDKError } from "./types.js";
@@ -9,9 +9,13 @@ export { ComputeNamespace } from "./compute.js";
 export type { CreditPackId, CreateTopupSessionArgs, CreateTopupSessionResult, GetBalanceArgs, GetBalanceResult, } from "./wallet.js";
 export { WalletNamespace } from "./wallet.js";
 export { AithosAuth, DEFAULT_AUTH_BASE_URL } from "./auth.js";
-export type { AithosAuthConfig, AithosSession, SignInWithGoogleOptions, } from "./auth.js";
-export * as ethos from "./ethos.js";
+export type { AithosAuthConfig, AithosSession, DelegateInfo, ImportMandateInput, OwnerInfo, SignInInput, SignInWithGoogleOptions, SignInWithRecoveryInput, SignUpInput, SignUpResult, } from "./auth.js";
+export { DEFAULT_SESSION_STORAGE_KEY, defaultSessionStore, localStorageStore, noopStore, sessionStorageStore, type AithosSessionStore, } from "./session-store.js";
+export { DEFAULT_KEYSTORE_DB_NAME, defaultKeyStore, indexedDbKeyStore, memoryKeyStore, type AithosKeyStore, type StoredDelegateKeys, type StoredOwnerKeys, } from "./key-store.js";
+export { EthosClient, EthosNamespace, EthosZone, ZONE_NAMES, } from "./ethos.js";
+export type { AddSectionInput, PublishResult, StagedChange, UpdateSectionPatch, ZoneName, } from "./ethos.js";
+export { MandatesNamespace } from "./mandates.js";
+export type { ActorSphere, CreateMandateInput, MintedMandate, OwnedMandate, Scope, } from "./mandates.js";
 export * as onboarding from "./onboarding.js";
-export * as mandates from "./mandates.js";
 export { createBrowserIdentity, browserIdentityFromStored, type BrowserIdentity, } from "@aithos/protocol-client";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -17,21 +17,39 @@
 // Public types specific to the SDK (`AithosSDKConfig`, `AithosSDKError`)
 // are exported from here. Endpoint config (`AithosSdkEndpoints`,
 // `DEFAULT_SDK_ENDPOINTS`) likewise.
-export const VERSION = "0.1.0-alpha.3";
+export const VERSION = "0.1.0-alpha.5";
 export { AithosSDK } from "./sdk.js";
 export { AithosSDKError } from "./types.js";
 export { DEFAULT_SDK_ENDPOINTS } from "./endpoints.js";
 export { ComputeNamespace } from "./compute.js";
 export { WalletNamespace } from "./wallet.js";
-// Sign in with Google (and future SSO providers). Lives outside the
-// AithosSDK class because the auth flow runs *before* the user has a
-// BrowserIdentity — that's what the flow returns (via the encrypted blob).
+// Sign-up, sign-in, sign-in-with-Google. Lives outside the AithosSDK
+// class because the auth flow runs *before* the user has a
+// BrowserIdentity (sign-up creates one, sign-in restores it from the
+// server). The class also owns the session store — see
+// ./session-store.ts for pluggable persistence.
 export { AithosAuth, DEFAULT_AUTH_BASE_URL } from "./auth.js";
-// Re-exports under stable namespace modules. Apps may also import these
-// directly via `@aithos/protocol-client`; the SDK simply curates them.
-export * as ethos from "./ethos.js";
+// Session storage backends used by AithosAuth. `sessionStorageStore` is
+// the default in browser environments ; pass another store at construction
+// time if you need different persistence.
+export { DEFAULT_SESSION_STORAGE_KEY, defaultSessionStore, localStorageStore, noopStore, sessionStorageStore, } from "./session-store.js";
+// Key persistence (owner identity material + delegate bundles). Pluggable
+// like {@link AithosSessionStore}: `indexedDbKeyStore` is the browser
+// default, `memoryKeyStore` is a no-persist fallback used in tests / SSR.
+// Stored shapes ({@link StoredOwnerKeys}, {@link StoredDelegateKeys}) are
+// opaque from the consumer's point of view — round-trip them, don't peek
+// inside.
+export { DEFAULT_KEYSTORE_DB_NAME, defaultKeyStore, indexedDbKeyStore, memoryKeyStore, } from "./key-store.js";
+// `sdk.ethos` namespace — high-level ethos editing (load, mutate
+// staged, publish lazy). The class is constructed once by the
+// AithosSDK constructor; `sdk.ethos.me()` / `sdk.ethos.of(did)` are
+// the entry points.
+export { EthosClient, EthosNamespace, EthosZone, ZONE_NAMES, } from "./ethos.js";
+// `sdk.mandates` namespace — owner-side mandate lifecycle.
+export { MandatesNamespace } from "./mandates.js";
+// Onboarding re-exports kept for advanced callers — the curated API
+// for first-run flows is `auth.signUp` (already shipped in J3).
 export * as onboarding from "./onboarding.js";
-export * as mandates from "./mandates.js";
 // Convenience direct re-exports of the most-used identity primitives so the
 // quick-start example doesn't need a namespace import.
 export { createBrowserIdentity, browserIdentityFromStored, } from "@aithos/protocol-client";

package/dist/src/internal/delegate-bundle.d.ts

@@ -0,0 +1,18 @@
+export interface ParsedDelegateBundle {
+    readonly mandate: Record<string, unknown>;
+    readonly mandateId: string;
+    readonly subjectDid: string;
+    readonly granteeId: string;
+    readonly granteePubkeyMultibase: string;
+    readonly delegateSeedHex: string;
+}
+/**
+ * Read the bundle (Blob or already-decoded string) into UTF-8 text.
+ */
+export declare function readDelegateBundleText(file: Blob | string): Promise<string>;
+/**
+ * Parse a delegate-bundle JSON string. Throws {@link AithosSDKError}
+ * with `code === "auth_invalid_delegate_bundle"` if malformed.
+ */
+export declare function parseDelegateBundle(text: string): ParsedDelegateBundle;
+//# sourceMappingURL=delegate-bundle.d.ts.map

package/dist/src/internal/delegate-bundle.js

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Delegate-bundle format — parser for `.aithos-delegate.json` files
+// shipped by `mandate-mint`. The file is the only material a delegate
+// receives from an owner: the full SignedMandate + a fresh Ed25519
+// seed bound to that mandate via `mandate.grantee.pubkey`.
+//
+// Wire shape:
+//
+//     {
+//       aithos_delegate_version: "0.1.0",
+//       mandate: { id, scopes, grantee: { id, pubkey }, ... },
+//       delegate_seed_hex: "<64 lowercase hex chars>"
+//     }
+//
+// Anything else is rejected with `auth_invalid_delegate_bundle`.
+import { AithosSDKError } from "../types.js";
+const HEX_64 = /^[0-9a-f]{64}$/;
+/**
+ * Read the bundle (Blob or already-decoded string) into UTF-8 text.
+ */
+export async function readDelegateBundleText(file) {
+    if (typeof file === "string")
+        return file;
+    return file.text();
+}
+/**
+ * Parse a delegate-bundle JSON string. Throws {@link AithosSDKError}
+ * with `code === "auth_invalid_delegate_bundle"` if malformed.
+ */
+export function parseDelegateBundle(text) {
+    let obj;
+    try {
+        obj = JSON.parse(text);
+    }
+    catch {
+        throw bad("not valid JSON");
+    }
+    if (typeof obj !== "object" || obj === null) {
+        throw bad("not a JSON object");
+    }
+    const o = obj;
+    const ver = o["aithos_delegate_version"];
+    if (typeof ver !== "string" || !ver.startsWith("0.1.0")) {
+        throw bad(`unsupported aithos_delegate_version: ${String(ver)}`);
+    }
+    const mandate = o["mandate"];
+    if (typeof mandate !== "object" || mandate === null) {
+        throw bad("missing mandate");
+    }
+    const m = mandate;
+    const mandateId = m["id"];
+    const subjectDid = m["subject_did"] ?? m["subjectDid"];
+    const grantee = m["grantee"];
+    if (typeof mandateId !== "string" || !mandateId) {
+        throw bad("mandate.id missing");
+    }
+    if (typeof subjectDid !== "string" || !subjectDid.startsWith("did:")) {
+        throw bad("mandate.subject_did missing or malformed");
+    }
+    if (typeof grantee !== "object" || grantee === null) {
+        throw bad("mandate.grantee missing");
+    }
+    const g = grantee;
+    const granteeId = g["id"];
+    const pubkey = g["pubkey"];
+    if (typeof granteeId !== "string" || !granteeId) {
+        throw bad("mandate.grantee.id missing");
+    }
+    if (typeof pubkey !== "string" || !pubkey.startsWith("z")) {
+        throw bad("mandate.grantee.pubkey missing or not multibase");
+    }
+    const seed = o["delegate_seed_hex"];
+    if (typeof seed !== "string" || !HEX_64.test(seed)) {
+        throw bad("delegate_seed_hex: expected 64-char lowercase hex");
+    }
+    return {
+        mandate: mandate,
+        mandateId,
+        subjectDid,
+        granteeId,
+        granteePubkeyMultibase: pubkey,
+        delegateSeedHex: seed,
+    };
+}
+function bad(detail) {
+    return new AithosSDKError("auth_invalid_delegate_bundle", `delegate bundle is invalid: ${detail}`);
+}
+//# sourceMappingURL=delegate-bundle.js.map

package/dist/src/internal/delegate-state.d.ts

@@ -0,0 +1,45 @@
+import type { StoredDelegateKeys } from "../key-store.js";
+import { type Signer } from "./signer.js";
+/**
+ * One active delegate session. Lives in {@link DelegateRegistry}'s
+ * map keyed by `mandateId`.
+ */
+export declare class DelegateActor {
+    #private;
+    readonly subjectDid: string;
+    readonly mandateId: string;
+    readonly granteeId: string;
+    readonly granteePubkeyMultibase: string;
+    /** Full §4.2 SignedMandate, opaque JSON object. */
+    readonly mandate: Record<string, unknown>;
+    readonly signer: Signer;
+    constructor(args: {
+        subjectDid: string;
+        mandateId: string;
+        granteeId: string;
+        granteePubkeyMultibase: string;
+        mandate: Record<string, unknown>;
+        signer: Signer;
+    });
+    /** Build from the persisted KeyStore shape. */
+    static fromStored(stored: StoredDelegateKeys): DelegateActor;
+    destroy(): void;
+    get destroyed(): boolean;
+}
+/**
+ * Map of active delegate sessions, keyed by `mandateId`. Provides
+ * lookup helpers used by the auth namespace and (later) by `sdk.ethos`.
+ */
+export declare class DelegateRegistry {
+    #private;
+    add(actor: DelegateActor): void;
+    remove(mandateId: string): void;
+    get(mandateId: string): DelegateActor | undefined;
+    /** Find any active actor whose subject matches `did`. */
+    findForSubject(did: string): DelegateActor | undefined;
+    list(): readonly DelegateActor[];
+    size(): number;
+    /** Zeroize every actor's signer and clear the registry. */
+    destroy(): void;
+}
+//# sourceMappingURL=delegate-state.d.ts.map

package/dist/src/internal/delegate-state.js

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// In-memory delegate registry — the runtime sibling of
+// {@link AithosKeyStore}'s delegate slot.
+//
+// A delegate session is a mandate + a single Ed25519 seed bound to
+// that mandate via `mandate.grantee.pubkey`. The SDK keeps these
+// active sessions hot in memory so signing operations don't need
+// IndexedDB on every call.
+//
+// {@link DelegateActor} bundles the in-memory signer with the public
+// metadata needed to drive an envelope (subject DID, grantee URN,
+// grantee pubkey multibase, mandate id). The full mandate JSON is
+// kept too because envelope signing for delegate writes must attach
+// the §4.2 mandate.
+import { getPublicKey } from "@noble/ed25519";
+import { RawSeedSigner } from "./signer.js";
+/**
+ * One active delegate session. Lives in {@link DelegateRegistry}'s
+ * map keyed by `mandateId`.
+ */
+export class DelegateActor {
+    subjectDid;
+    mandateId;
+    granteeId;
+    granteePubkeyMultibase;
+    /** Full §4.2 SignedMandate, opaque JSON object. */
+    mandate;
+    signer;
+    #destroyed = false;
+    constructor(args) {
+        this.subjectDid = args.subjectDid;
+        this.mandateId = args.mandateId;
+        this.granteeId = args.granteeId;
+        this.granteePubkeyMultibase = args.granteePubkeyMultibase;
+        this.mandate = args.mandate;
+        this.signer = args.signer;
+    }
+    /** Build from the persisted KeyStore shape. */
+    static fromStored(stored) {
+        const seed = hexToBytes(stored.delegateSeedHex);
+        try {
+            const pubkey = getPublicKey(seed);
+            const signer = new RawSeedSigner(seed, pubkey);
+            return new DelegateActor({
+                subjectDid: stored.subjectDid,
+                mandateId: stored.mandateId,
+                granteeId: stored.granteeId,
+                granteePubkeyMultibase: stored.granteePubkeyMultibase,
+                mandate: stored.mandate,
+                signer,
+            });
+        }
+        finally {
+            seed.fill(0);
+        }
+    }
+    destroy() {
+        if (this.#destroyed)
+            return;
+        this.signer.destroy();
+        this.#destroyed = true;
+    }
+    get destroyed() {
+        return this.#destroyed;
+    }
+}
+/**
+ * Map of active delegate sessions, keyed by `mandateId`. Provides
+ * lookup helpers used by the auth namespace and (later) by `sdk.ethos`.
+ */
+export class DelegateRegistry {
+    #actors = new Map();
+    add(actor) {
+        // Replace any existing entry for the same mandate (re-import).
+        const existing = this.#actors.get(actor.mandateId);
+        if (existing)
+            existing.destroy();
+        this.#actors.set(actor.mandateId, actor);
+    }
+    remove(mandateId) {
+        const a = this.#actors.get(mandateId);
+        if (a)
+            a.destroy();
+        this.#actors.delete(mandateId);
+    }
+    get(mandateId) {
+        return this.#actors.get(mandateId);
+    }
+    /** Find any active actor whose subject matches `did`. */
+    findForSubject(did) {
+        for (const a of this.#actors.values()) {
+            if (a.subjectDid === did)
+                return a;
+        }
+        return undefined;
+    }
+    list() {
+        return [...this.#actors.values()];
+    }
+    size() {
+        return this.#actors.size;
+    }
+    /** Zeroize every actor's signer and clear the registry. */
+    destroy() {
+        for (const a of this.#actors.values())
+            a.destroy();
+        this.#actors.clear();
+    }
+}
+function hexToBytes(hex) {
+    if (hex.length % 2 !== 0)
+        throw new Error("hex must be even-length");
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+}
+//# sourceMappingURL=delegate-state.js.map

package/dist/src/internal/owner-signers.d.ts

@@ -0,0 +1,78 @@
+import { type BlobPlaintext, type BrowserIdentity, type StoredIdentity } from "@aithos/protocol-client";
+import type { StoredOwnerKeys } from "../key-store.js";
+import { type Signer } from "./signer.js";
+/**
+ * The four signing capabilities of an authenticated owner.
+ *
+ * The `did`, `handle`, `displayName` fields are public metadata.
+ * The four signers expose only `publicKey` + `sign` — never the
+ * underlying seed bytes.
+ */
+export declare class OwnerSigners {
+    #private;
+    readonly did: string;
+    readonly handle: string;
+    readonly displayName: string;
+    readonly root: Signer;
+    readonly public: Signer;
+    readonly circle: Signer;
+    readonly self: Signer;
+    constructor(args: {
+        did: string;
+        handle: string;
+        displayName: string;
+        root: Signer;
+        public: Signer;
+        circle: Signer;
+        self: Signer;
+    });
+    /**
+     * Build from a {@link BrowserIdentity}. The seeds inside `identity`
+     * are defensively copied into fresh signers — mutating the
+     * BrowserIdentity afterwards does not affect the signers, and the
+     * caller may zeroize the original identity immediately.
+     */
+    static fromBrowserIdentity(identity: BrowserIdentity): OwnerSigners;
+    /**
+     * Build from a {@link StoredIdentity} — the persisted shape used by
+     * extension-kit's IndexedDbKeystore (hex-encoded seeds).
+     *
+     * Internally calls `browserIdentityFromStored` to derive
+     * `publicKey`s, then wraps. The caller may discard the StoredIdentity
+     * afterwards.
+     */
+    static fromStoredIdentity(stored: StoredIdentity): OwnerSigners;
+    /**
+     * Build from the SDK's own {@link StoredOwnerKeys} shape — what the
+     * KeyStore round-trips for owner-side resume.
+     */
+    static fromStoredOwnerKeys(stored: StoredOwnerKeys): OwnerSigners;
+    /**
+     * Build from a {@link BlobPlaintext} — the parsed payload of the
+     * password-decrypted vault blob returned by `loginVerify`. Hex
+     * seeds are turned into KeyPairs eagerly; the plaintext input is
+     * not retained.
+     */
+    static fromBlobPlaintext(plaintext: BlobPlaintext): OwnerSigners;
+    /**
+     * Resolve a sphere name to its signer. Convenience for callers that
+     * have the sphere as a string ("public" | "circle" | "self") rather
+     * than a typed accessor.
+     */
+    signerForSphere(sphere: "root" | "public" | "circle" | "self"): Signer;
+    /**
+     * Internal — project to a {@link StoredIdentity} for protocol-client
+     * interop. Reads seed bytes via {@link RawSeedSigner._unsafeKeyPair}
+     * on each signer and hex-encodes them. Throws if any signer is not
+     * a RawSeedSigner (which can happen post-migration to SubtleSigner;
+     * at that point protocol-client must accept Signer-shaped objects
+     * directly and this method goes away).
+     *
+     * @internal
+     */
+    _unsafeStoredIdentity(): StoredIdentity;
+    /** Zeroize all four private seeds. Idempotent. */
+    destroy(): void;
+    get destroyed(): boolean;
+}
+//# sourceMappingURL=owner-signers.d.ts.map

package/dist/src/internal/owner-signers.js

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// OwnerSigners — the four-keypair signing capability of an Aithos
+// owner identity, behind the {@link Signer} interface.
+//
+// SDK-internal only — NOT exported from the package barrel.
+//
+// An owner identity has four key roles: `root` (controls the DID
+// document), `public` (signs writes / envelopes for the public zone),
+// `circle` (signs writes for the friends zone), `self` (signs writes
+// for the private zone). All four are Ed25519. The X25519 keys used
+// for HPKE zone encryption are deterministically derived from the
+// Ed25519 seeds at use-site (see protocol-client/crypto/kex), so we
+// only need to hold the Ed25519 signers here.
+//
+// This class is the in-memory home for those signers throughout an
+// authenticated session. The auth namespace owns a single instance,
+// hands references to the compute / wallet / ethos namespaces, and
+// destroys it on `signOut`.
+import { browserIdentityFromStored, } from "@aithos/protocol-client";
+import { RawSeedSigner } from "./signer.js";
+/**
+ * The four signing capabilities of an authenticated owner.
+ *
+ * The `did`, `handle`, `displayName` fields are public metadata.
+ * The four signers expose only `publicKey` + `sign` — never the
+ * underlying seed bytes.
+ */
+export class OwnerSigners {
+    did;
+    handle;
+    displayName;
+    root;
+    public;
+    circle;
+    self;
+    #destroyed = false;
+    constructor(args) {
+        this.did = args.did;
+        this.handle = args.handle;
+        this.displayName = args.displayName;
+        this.root = args.root;
+        this.public = args.public;
+        this.circle = args.circle;
+        this.self = args.self;
+    }
+    /**
+     * Build from a {@link BrowserIdentity}. The seeds inside `identity`
+     * are defensively copied into fresh signers — mutating the
+     * BrowserIdentity afterwards does not affect the signers, and the
+     * caller may zeroize the original identity immediately.
+     */
+    static fromBrowserIdentity(identity) {
+        return new OwnerSigners({
+            did: identity.did,
+            handle: identity.handle,
+            displayName: identity.displayName,
+            root: new RawSeedSigner(identity.root.seed, identity.root.publicKey),
+            public: new RawSeedSigner(identity.public.seed, identity.public.publicKey),
+            circle: new RawSeedSigner(identity.circle.seed, identity.circle.publicKey),
+            self: new RawSeedSigner(identity.self.seed, identity.self.publicKey),
+        });
+    }
+    /**
+     * Build from a {@link StoredIdentity} — the persisted shape used by
+     * extension-kit's IndexedDbKeystore (hex-encoded seeds).
+     *
+     * Internally calls `browserIdentityFromStored` to derive
+     * `publicKey`s, then wraps. The caller may discard the StoredIdentity
+     * afterwards.
+     */
+    static fromStoredIdentity(stored) {
+        return OwnerSigners.fromBrowserIdentity(browserIdentityFromStored(stored));
+    }
+    /**
+     * Build from the SDK's own {@link StoredOwnerKeys} shape — what the
+     * KeyStore round-trips for owner-side resume.
+     */
+    static fromStoredOwnerKeys(stored) {
+        return OwnerSigners.fromStoredIdentity({
+            version: "0.1.0",
+            handle: stored.handle,
+            displayName: stored.displayName,
+            did: stored.did,
+            seeds: stored.seedsHex,
+            savedAt: stored.savedAt,
+        });
+    }
+    /**
+     * Build from a {@link BlobPlaintext} — the parsed payload of the
+     * password-decrypted vault blob returned by `loginVerify`. Hex
+     * seeds are turned into KeyPairs eagerly; the plaintext input is
+     * not retained.
+     */
+    static fromBlobPlaintext(plaintext) {
+        return OwnerSigners.fromStoredIdentity({
+            version: "0.1.0",
+            handle: plaintext.identity.handle,
+            displayName: plaintext.identity.displayName,
+            did: plaintext.identity.did,
+            seeds: plaintext.seeds,
+            savedAt: new Date().toISOString(),
+        });
+    }
+    /**
+     * Resolve a sphere name to its signer. Convenience for callers that
+     * have the sphere as a string ("public" | "circle" | "self") rather
+     * than a typed accessor.
+     */
+    signerForSphere(sphere) {
+        if (this.#destroyed) {
+            throw new Error("OwnerSigners: cannot use destroyed signers");
+        }
+        switch (sphere) {
+            case "root":
+                return this.root;
+            case "public":
+                return this.public;
+            case "circle":
+                return this.circle;
+            case "self":
+                return this.self;
+        }
+    }
+    /**
+     * Internal — project to a {@link StoredIdentity} for protocol-client
+     * interop. Reads seed bytes via {@link RawSeedSigner._unsafeKeyPair}
+     * on each signer and hex-encodes them. Throws if any signer is not
+     * a RawSeedSigner (which can happen post-migration to SubtleSigner;
+     * at that point protocol-client must accept Signer-shaped objects
+     * directly and this method goes away).
+     *
+     * @internal
+     */
+    _unsafeStoredIdentity() {
+        if (this.#destroyed) {
+            throw new Error("OwnerSigners: cannot project destroyed signers");
+        }
+        return {
+            version: "0.1.0",
+            handle: this.handle,
+            displayName: this.displayName,
+            did: this.did,
+            seeds: {
+                root: bytesToHexLocal(asRawSeed(this.root, "root")._unsafeKeyPair().seed),
+                public: bytesToHexLocal(asRawSeed(this.public, "public")._unsafeKeyPair().seed),
+                circle: bytesToHexLocal(asRawSeed(this.circle, "circle")._unsafeKeyPair().seed),
+                self: bytesToHexLocal(asRawSeed(this.self, "self")._unsafeKeyPair().seed),
+            },
+            savedAt: new Date().toISOString(),
+        };
+    }
+    /** Zeroize all four private seeds. Idempotent. */
+    destroy() {
+        if (this.#destroyed)
+            return;
+        this.root.destroy();
+        this.public.destroy();
+        this.circle.destroy();
+        this.self.destroy();
+        this.#destroyed = true;
+    }
+    get destroyed() {
+        return this.#destroyed;
+    }
+}
+function asRawSeed(s, role) {
+    if (!(s instanceof RawSeedSigner)) {
+        throw new Error(`OwnerSigners._unsafeStoredIdentity: signer for "${role}" is not a RawSeedSigner; this method is incompatible with non-extractable key implementations.`);
+    }
+    return s;
+}
+function bytesToHexLocal(b) {
+    let out = "";
+    for (let i = 0; i < b.length; i++)
+        out += b[i].toString(16).padStart(2, "0");
+    return out;
+}
+//# sourceMappingURL=owner-signers.js.map

package/dist/src/internal/protocol-client-bridge.d.ts

@@ -0,0 +1,8 @@
+import type { KeyPair } from "@aithos/protocol-client";
+import type { DelegateActor } from "./delegate-state.js";
+import type { OwnerSigners } from "./owner-signers.js";
+/** Extract the raw KeyPair for one of the owner's spheres. */
+export declare function ownerKeyPair(owner: OwnerSigners, sphere: "root" | "public" | "circle" | "self"): KeyPair;
+/** Extract the raw KeyPair held by a delegate actor. */
+export declare function delegateKeyPair(actor: DelegateActor): KeyPair;
+//# sourceMappingURL=protocol-client-bridge.d.ts.map

package/dist/src/internal/protocol-client-bridge.js

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+import { AithosSDKError } from "../types.js";
+import { RawSeedSigner } from "./signer.js";
+/** Extract the raw KeyPair for one of the owner's spheres. */
+export function ownerKeyPair(owner, sphere) {
+    const signer = owner.signerForSphere(sphere);
+    return rawKeyPair(signer, `owner.${sphere}`);
+}
+/** Extract the raw KeyPair held by a delegate actor. */
+export function delegateKeyPair(actor) {
+    return rawKeyPair(actor.signer, `delegate(${actor.mandateId})`);
+}
+function rawKeyPair(signer, role) {
+    if (!(signer instanceof RawSeedSigner)) {
+        throw new AithosSDKError("sdk_unsupported_signer", `${role}: signer is not RawSeedSigner — protocol-client interop requires raw seed access until upstream gains a Signer-shaped API`);
+    }
+    return signer._unsafeKeyPair();
+}
+//# sourceMappingURL=protocol-client-bridge.js.map

package/dist/src/internal/recovery-file.d.ts

@@ -0,0 +1,29 @@
+import type { BrowserIdentity } from "@aithos/protocol-client";
+export interface ParsedRecoveryFile {
+    readonly handle: string;
+    readonly displayName: string;
+    readonly did: string;
+    readonly seedsHex: {
+        readonly root: string;
+        readonly public: string;
+        readonly circle: string;
+        readonly self: string;
+    };
+}
+/**
+ * Parse a recovery JSON string. Throws {@link AithosSDKError} with
+ * `code === "auth_invalid_recovery_file"` if the input is malformed.
+ */
+export declare function parseRecoveryFile(text: string): ParsedRecoveryFile;
+/** Read the file (Blob or already-decoded string) into UTF-8 text. */
+export declare function readRecoveryFileText(file: Blob | string): Promise<string>;
+/**
+ * Build the recovery-file JSON blob from a fresh BrowserIdentity. Used
+ * by `signUp` so the same writer/reader code handles both ends of the
+ * round-trip.
+ */
+export declare function serializeRecoveryFile(identity: BrowserIdentity): {
+    readonly text: string;
+    readonly filename: string;
+};
+//# sourceMappingURL=recovery-file.d.ts.map