@oxy.so/core 1.18.1 → 3.0.0

package/dist/esm/mixins/OxyServices.identityBackup.js

@@ -1,169 +0,0 @@
-import { KeyManager, IdentityAlreadyExistsError } from '../crypto/keyManager.js';
-import { RecoveryPhraseService, BACKUP_KDF_ENCRYPTION_INFO } from '../crypto/recoveryPhrase.js';
-import { encryptAead, decryptAead } from '../crypto/aead.js';
-/** Envelope/KDF version — bump only on a breaking scheme change. */
-const BACKUP_ENVELOPE_VERSION = 1;
-/** The AEAD the backup is sealed with. Pinned so a mismatched decryptor fails loudly. */
-const BACKUP_ALGORITHM = 'xchacha20poly1305';
-/**
- * Length (hex chars) of the public-key HINT stored/echoed with a backup — enough
- * to let the owner recognise WHICH identity a backup belongs to, but only a
- * prefix (the full key is public anyway; a prefix keeps the record minimal).
- */
-const PUBLIC_KEY_HINT_LENGTH = 16;
-/** Encode bytes as lowercase hex (cross-platform, no Buffer dependency). */
-function toHex(bytes) {
-    let out = '';
-    for (let i = 0; i < bytes.length; i += 1) {
-        out += bytes[i].toString(16).padStart(2, '0');
-    }
-    return out;
-}
-/** Decode a lowercase/uppercase hex string to bytes. Throws on malformed input. */
-function fromHex(hex) {
-    if (hex.length % 2 !== 0 || /[^0-9a-fA-F]/.test(hex)) {
-        throw new Error('Malformed hex in encrypted backup envelope.');
-    }
-    const out = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < out.length; i += 1) {
-        out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-    }
-    return out;
-}
-/**
- * The AEAD associated data binds the ciphertext to its `{version, publicKeyHint}`
- * context: the exact bytes must be reproduced at decrypt time, so a mismatched
- * version or hint (e.g. an envelope re-stamped by a tamperer) fails the
- * Poly1305 check. Deterministic: both sides build the SAME object literal, so
- * `JSON.stringify` yields identical bytes.
- */
-function buildBackupAad(version, publicKeyHint) {
-    return new TextEncoder().encode(JSON.stringify({ version, publicKeyHint }));
-}
-export function OxyServicesIdentityBackupMixin(Base) {
-    return class extends Base {
-        constructor(...args) {
-            super(...args);
-        }
-        /**
-         * Derive the backup key material from the recovery phrase, encrypt the
-         * identity's `{privateKey, publicKey, createdAt}` with it, and upload the
-         * ciphertext + raw `lookupId` (`POST /identity/backup`, bearer). The server
-         * stores only `sha256(lookupId)` + the ciphertext. Idempotent per user: a
-         * re-upload REPLACES the prior backup (upsert by user id).
-         *
-         * The identity is derived from the PHRASE (not read from SecureStore), so
-         * this works cross-platform and does not require an on-device key.
-         *
-         * @param phrase - The identity's BIP-39 recovery phrase.
-         * @returns The post-write backup status (`{ exists: true, publicKeyHint, createdAt }`).
-         */
-        async createEncryptedBackup(phrase) {
-            try {
-                const { backupKey, lookupId } = await RecoveryPhraseService.deriveBackupMaterial(phrase);
-                const privateKey = await RecoveryPhraseService.derivePrivateKeyFromPhrase(phrase);
-                const publicKey = KeyManager.derivePublicKey(privateKey);
-                const createdAt = new Date().toISOString();
-                const publicKeyHint = publicKey.slice(0, PUBLIC_KEY_HINT_LENGTH);
-                const payload = { privateKey, publicKey, createdAt };
-                const plaintext = new TextEncoder().encode(JSON.stringify(payload));
-                const aad = buildBackupAad(BACKUP_ENVELOPE_VERSION, publicKeyHint);
-                const { nonce, ciphertext } = encryptAead(backupKey, plaintext, aad);
-                const body = {
-                    version: BACKUP_ENVELOPE_VERSION,
-                    algorithm: BACKUP_ALGORITHM,
-                    kdfInfo: BACKUP_KDF_ENCRYPTION_INFO,
-                    nonce: toHex(nonce),
-                    ciphertext: toHex(ciphertext),
-                    publicKeyHint,
-                    createdAt,
-                    lookupId,
-                };
-                return await this.makeRequest('POST', '/identity/backup', body, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Whether the authenticated user has a stored encrypted backup, plus the
-         * non-sensitive hint + timestamp when one exists (`GET /identity/backup/status`,
-         * bearer). Returns no ciphertext and no locator.
-         */
-        async getBackupStatus() {
-            try {
-                return await this.makeRequest('GET', '/identity/backup/status', undefined, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Delete the authenticated user's stored backup (`DELETE /identity/backup`,
-         * bearer). Idempotent — deleting a non-existent backup still succeeds.
-         */
-        async deleteBackup() {
-            try {
-                return await this.makeRequest('DELETE', '/identity/backup', undefined, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Restore an identity from its encrypted off-device backup using ONLY the
-         * recovery phrase: re-derive `{backupKey, lookupId}`, fetch the envelope by
-         * `lookupId` (`GET /identity/backup/:lookupId`, PUBLIC — the 256-bit locator
-         * is the protection), decrypt + authenticate locally, then persist the key.
-         *
-         * NATIVE-ONLY persistence: `KeyManager.importKeyPair` throws on web. It also
-         * refuses to clobber a DIFFERENT existing on-device identity unless
-         * `overwrite: true` — the {@link import('../crypto/keyManager.js').IdentityAlreadyExistsError}
-         * propagates to the caller (never swallowed) so the UI can confirm before
-         * overwriting.
-         *
-         * @param phrase - The identity's BIP-39 recovery phrase.
-         * @param options.overwrite - Replace a different existing on-device identity.
-         * @returns The restored identity's public key.
-         * @throws if the phrase is invalid, no backup exists (404), the ciphertext
-         *   fails authentication (tamper), or an existing identity blocks the import.
-         */
-        async restoreFromEncryptedBackup(phrase, options) {
-            try {
-                const { backupKey, lookupId } = await RecoveryPhraseService.deriveBackupMaterial(phrase);
-                const envelope = await this.makeRequest('GET', `/identity/backup/${encodeURIComponent(lookupId)}`, undefined, { cache: false });
-                if (envelope.algorithm !== BACKUP_ALGORITHM) {
-                    throw new Error(`Unsupported backup algorithm: ${envelope.algorithm}`);
-                }
-                const aad = buildBackupAad(envelope.version, envelope.publicKeyHint);
-                const plaintext = decryptAead(backupKey, fromHex(envelope.nonce), fromHex(envelope.ciphertext), aad);
-                const payload = JSON.parse(new TextDecoder().decode(plaintext));
-                if (!payload.privateKey || !payload.publicKey) {
-                    throw new Error('Backup payload is missing key material');
-                }
-                const derivedFromPhrase = await RecoveryPhraseService.derivePublicKeyFromPhrase(phrase);
-                const derivedFromPrivate = KeyManager.derivePublicKey(payload.privateKey);
-                const phrasePk = derivedFromPhrase.toLowerCase();
-                const payloadPk = payload.publicKey.toLowerCase();
-                const privatePk = derivedFromPrivate.toLowerCase();
-                if (phrasePk !== payloadPk || privatePk !== payloadPk) {
-                    throw new Error('Backup payload does not match the recovery phrase');
-                }
-                // Persist the recovered key. Native-only; refuses to clobber a different
-                // identity unless overwrite — the IdentityAlreadyExistsError propagates.
-                return await KeyManager.importKeyPair(payload.privateKey, {
-                    overwrite: options?.overwrite === true,
-                });
-            }
-            catch (error) {
-                // Preserve the typed "an identity already exists" signal so the caller
-                // can prompt for overwrite. `handleError` would flatten it to a generic
-                // Error and lose that discrimination.
-                if (error instanceof IdentityAlreadyExistsError) {
-                    throw error;
-                }
-                throw this.handleError(error);
-            }
-        }
-    };
-}

package/dist/esm/mixins/OxyServices.inference.js

@@ -1,56 +0,0 @@
-/**
- * The inference API, reached with whatever bearer this session already holds
- * (issue #972, workstream 15).
- *
- * ```typescript
- * const models = await oxyServices.inference().listModels();
- * ```
- *
- * One method, and it is a FACTORY rather than a set of inference methods on
- * `OxyServices`. The calls themselves live once, in
- * {@link OxyInferenceClient} — which an external developer holding only an
- * `oxy_sk_…` machine key constructs directly, with no Oxy session anywhere in
- * the picture. Declaring the same calls a second time here would give the
- * ecosystem two spellings of one request, and only one of them would stay
- * correct.
- *
- * This is the reasoning `createLinkedClient` is already built on: the plumbing
- * that binds an Oxy bearer to a client belongs in core, once, rather than in
- * each app.
- *
- * The credential is a FUNCTION, not the current token: a session bearer rotates
- * on refresh and on account switch, and a client that captured one at
- * construction would start answering 401 an hour into the process's life.
- */
-import { OxyInferenceClient } from '../inference/OxyInferenceClient.js';
-export function OxyServicesInferenceMixin(Base) {
-    return class extends Base {
-        constructor() {
-            super(...arguments);
-            /** @internal Memoized so repeated calls return one object identity. */
-            this._inferenceClient = null;
-        }
-        /**
-         * The inference client for this session.
-         *
-         * Bound to this instance's base URL and to `getAccessToken()`, so it
-         * follows every refresh, sign-in and account switch without being
-         * rebuilt.
-         *
-         * A service-authenticated process wants a different credential and
-         * builds {@link OxyInferenceClient} directly:
-         * `new OxyInferenceClient({ credential: () => oxy.getServiceToken() })`.
-         * The mint is asynchronous and cached, which is exactly what a
-         * credential function is for.
-         */
-        inference() {
-            if (this._inferenceClient === null) {
-                this._inferenceClient = new OxyInferenceClient({
-                    baseURL: this.getBaseURL(),
-                    credential: () => this.getAccessToken(),
-                });
-            }
-            return this._inferenceClient;
-        }
-    };
-}

package/dist/esm/mixins/OxyServices.language.js

@@ -1,122 +0,0 @@
-/**
- * Language Methods Mixin
- */
-import { normalizeLocale, getPrimaryLanguage, getLanguageMetadata, getLanguageName, getNativeLanguageName } from '../utils/languageUtils.js';
-import { loadAsyncStorage } from '@oxy.so/protocol';
-import { logger } from '../logger/index.js';
-export function OxyServicesLanguageMixin(Base) {
-    return class extends Base {
-        constructor(...args) {
-            super(...args);
-        }
-        /**
-         * Get appropriate storage for the platform (similar to DeviceManager)
-         */
-        async getStorage() {
-            const isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-            if (isReactNative) {
-                try {
-                    // `loadAsyncStorage` is per-platform: the RN variant statically imports
-                    // @react-native-async-storage/async-storage, the default variant throws
-                    // (never called outside RN because of the `isReactNative` gate above).
-                    const asyncStorageModule = await loadAsyncStorage();
-                    const storage = asyncStorageModule.default;
-                    return {
-                        getItem: storage.getItem.bind(storage),
-                        setItem: storage.setItem.bind(storage),
-                        removeItem: storage.removeItem.bind(storage),
-                    };
-                }
-                catch (error) {
-                    logger.error('AsyncStorage not available in React Native', error, { component: 'OxyServices.language' });
-                    throw new Error('AsyncStorage is required in React Native environment');
-                }
-            }
-            else {
-                // Use localStorage for web
-                return {
-                    getItem: async (key) => {
-                        if (typeof window !== 'undefined' && window.localStorage) {
-                            return localStorage.getItem(key);
-                        }
-                        return null;
-                    },
-                    setItem: async (key, value) => {
-                        if (typeof window !== 'undefined' && window.localStorage) {
-                            localStorage.setItem(key, value);
-                        }
-                    },
-                    removeItem: async (key) => {
-                        if (typeof window !== 'undefined' && window.localStorage) {
-                            localStorage.removeItem(key);
-                        }
-                    }
-                };
-            }
-        }
-        /**
-         * Get the current locale from the user profile or local storage.
-         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
-         * @returns The current BCP-47 locale (e.g., 'en-US') or null if not set
-         */
-        async getCurrentLanguage(storageKeyPrefix = 'oxy_session') {
-            try {
-                // First try the authenticated user's primary account locale.
-                try {
-                    const user = await this.getCurrentUser();
-                    const primary = getPrimaryLanguage(user);
-                    if (primary) {
-                        return primary;
-                    }
-                }
-                catch {
-                    // Not authenticated or the profile fetch failed — fall through to the
-                    // locally stored preference below.
-                }
-                // Fall back to the locally stored locale preference.
-                const storage = await this.getStorage();
-                const storageKey = `${storageKeyPrefix}_language`;
-                const storedLanguage = await storage.getItem(storageKey);
-                if (storedLanguage) {
-                    return normalizeLocale(storedLanguage) ?? storedLanguage;
-                }
-                return null;
-            }
-            catch (error) {
-                logger.warn('Failed to get current language', { component: 'OxyServices.language' }, error);
-                return null;
-            }
-        }
-        /**
-         * Get the current language with metadata (name, nativeName, etc.)
-         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
-         * @returns Language metadata object or null if not set
-         */
-        async getCurrentLanguageMetadata(storageKeyPrefix = 'oxy_session') {
-            const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
-            return getLanguageMetadata(languageCode);
-        }
-        /**
-         * Get the current language name (e.g., 'English')
-         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
-         * @returns Language name or null if not set
-         */
-        async getCurrentLanguageName(storageKeyPrefix = 'oxy_session') {
-            const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
-            if (!languageCode)
-                return null;
-            return getLanguageName(languageCode);
-        }
-        /**
-         * Get the current native language name (e.g., 'Español')
-         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
-         * @returns Native language name or null if not set
-         */
-        async getCurrentNativeLanguageName(storageKeyPrefix = 'oxy_session') {
-            const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
-            if (!languageCode)
-                return null;
-            return getNativeLanguageName(languageCode);
-        }
-    };
-}

package/dist/esm/mixins/OxyServices.linkedAccounts.js

@@ -1,76 +0,0 @@
-export function OxyServicesLinkedAccountsMixin(Base) {
-    return class extends Base {
-        /**
-         * Begin linking an external account for the current user.
-         *
-         * @param network - `'activitypub'` (any Mastodon-API server) or `'atproto'` (Bluesky).
-         * @param options - `instance` for ActivityPub (`mastodon.social`, or
-         *   `@user@mastodon.social`), `handle` for atproto; `clientId` + `returnTo`
-         *   to be sent back to your app afterwards.
-         * @returns The URL to open, and when the attempt expires (ten minutes).
-         */
-        async startLinkedAccount(network, options) {
-            try {
-                return await this.makeRequest('POST', `/linked-accounts/${encodeURIComponent(network)}/start`, options, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Finish a link with the `link_code` the callback appended to `returnTo`.
-         * Must be the user who started the flow: for anyone else the API answers
-         * 403 and burns the code. 409 when the account is already someone else's
-         * link. Repeating it within the code's five minutes returns the same link.
-         */
-        async completeLinkedAccount(code) {
-            try {
-                const response = await this.makeRequest('POST', '/linked-accounts/complete', { code }, { cache: false });
-                return response.linkedAccount;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /** The current user's live linked accounts, oldest first. */
-        async listLinkedAccounts() {
-            try {
-                const response = await this.makeRequest('GET', '/linked-accounts', undefined, {
-                    cache: false,
-                });
-                return response.linkedAccounts;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Unlink one of the current user's accounts. An ActivityPub link stops being
-         * published as an `alsoKnownAs` alias, and the external account can then be
-         * linked to another Oxy account.
-         */
-        async revokeLinkedAccount(linkedAccountId) {
-            try {
-                await this.makeRequest('DELETE', `/linked-accounts/${encodeURIComponent(linkedAccountId)}`, undefined, {
-                    cache: false,
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * SERVICE: a user's live linked accounts, each with the federated shadow
-         * user Oxy already holds for it (`federatedUserId`). Requires a service
-         * credential whose application holds the privileged `linked-accounts:read`.
-         */
-        async getLinkedAccountsForUser(userId) {
-            try {
-                return await this.makeServiceRequest('GET', `/linked-accounts/by-user/${encodeURIComponent(userId)}`);
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-    };
-}

package/dist/esm/mixins/OxyServices.location.js

@@ -1,40 +0,0 @@
-export function OxyServicesLocationMixin(Base) {
-    return class extends Base {
-        constructor(...args) {
-            super(...args);
-        }
-        /**
-         * Update user location
-         * @param latitude - Latitude coordinate
-         * @param longitude - Longitude coordinate
-         * @returns Location update result
-         */
-        async updateLocation(latitude, longitude) {
-            try {
-                return await this.makeRequest('POST', '/location', {
-                    latitude,
-                    longitude
-                }, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get nearby users
-         * @param radius - Optional search radius in meters
-         * @returns Array of nearby users
-         */
-        async getNearbyUsers(radius) {
-            try {
-                const params = radius ? { radius } : undefined;
-                return await this.makeRequest('GET', '/location/nearby', params, {
-                    cache: false, // Don't cache location data - always get fresh data
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-    };
-}

package/dist/esm/mixins/OxyServices.nodes.js

@@ -1,172 +0,0 @@
-import { SignatureService } from '../crypto/signatureService.js';
-import { buildUserDid } from './OxyServices.identity.js';
-import { CACHE_TIMES } from './mixinHelpers.js';
-/**
- * AtProto-style collection (NSID) for a user-node registration record — matches
- * the server's `NODE_COLLECTION`. A user has exactly one node, so the record is
- * keyed by the constant {@link NODE_RKEY} (last-writer-wins): re-registering
- * over-writes the single `self` record rather than appending a second node.
- */
-const NODE_COLLECTION = 'app.oxy.node';
-/**
- * The AtProto-style record key for the single node registration — matches the
- * server's `NODE_RKEY`. Constant (`'self'`) because a user has one node.
- */
-const NODE_RKEY = 'self';
-/**
- * Cache-key prefix of every node read (`GET /nodes/me`). Swept after a
- * register / revoke / managed-provision so a re-read reflects the new node
- * (or its absence) instead of a stale cached one. The identity tag is a key
- * SUFFIX, so this prefix invalidates the resource for every cached identity.
- */
-const NODES_CACHE_PREFIX = 'GET:/nodes/';
-/**
- * Cache-key prefix of the current user's `GET /users/me`. Swept alongside the
- * node caches because the user's derived DID document embeds an `#oxy-node`
- * service entry derived from the node row, so registering / revoking / managing
- * a node changes user-facing identity state.
- */
-const USERS_ME_CACHE_PREFIX = 'GET:/users/me';
-export function OxyServicesNodesMixin(Base) {
-    return class extends Base {
-        constructor(...args) {
-            super(...args);
-        }
-        /**
-         * Register (or re-register) the caller's SELF-HOSTED personal data node.
-         *
-         * Builds the `{ endpoint, nodePublicKey, mode }` node record, signs a v2
-         * envelope on the caller's own per-subject hash chain (fetching the current
-         * chain head first so `seq`/`prev` are never stale), and publishes it through
-         * the EXISTING `POST /identity/records` path — which verifies the signature
-         * and materializes the operational node cache as a side effect. The signed
-         * record (not this call) is the authority; re-registering over-writes the
-         * single `self` record (last-writer-wins).
-         *
-         * NATIVE-ONLY: signs with the on-device identity key (throws on web / when no
-         * identity or no authenticated user — the guard fires before any network).
-         * `mode` defaults to `'pull'`. After a successful publish the node + `/users/me`
-         * GET caches are swept, then the freshly-materialized status is returned.
-         *
-         * Throws if the chain record stored but the server skipped materialization
-         * (e.g. a malformed endpoint the server rejected) — an unexpected state rather
-         * than a silent `null`.
-         *
-         * @param input - The node's endpoint, public key, and optional transport mode.
-         */
-        async registerNode(input) {
-            try {
-                const userId = this.getCurrentUserId();
-                if (!userId) {
-                    throw new Error('No authenticated user — sign in before registering a node.');
-                }
-                const subject = buildUserDid(userId);
-                const record = {
-                    endpoint: input.endpoint,
-                    nodePublicKey: input.nodePublicKey,
-                    mode: input.mode ?? 'pull',
-                };
-                // Fetch the caller's chain head fresh (uncached) so seq/prev are correct
-                // → no bad_seq / chain_fork — exactly as the identity/civic signers do.
-                const head = await this.makeRequest('GET', `/identity/records/${encodeURIComponent(userId)}/chain/head`, undefined, { cache: false });
-                const envelope = await SignatureService.signRecordV2('node', subject, record, {
-                    seq: head.seq + 1,
-                    prev: head.headRecordId,
-                    collection: NODE_COLLECTION,
-                    rkey: NODE_RKEY,
-                });
-                await this.makeRequest('POST', '/identity/records', envelope, { cache: false });
-                this._sweepNodeCaches();
-                const node = await this.getMyNode();
-                if (!node) {
-                    throw new Error('Node registration stored but the node could not be materialized.');
-                }
-                return node;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Read the caller's registered node status (`GET /nodes/me`), or `null` when
-         * the caller has no node. Auth required; short-TTL cached (the liveness badge
-         * is background-maintained) and swept after the caller's own
-         * register / revoke / managed-provision.
-         */
-        async getMyNode() {
-            try {
-                const res = await this.makeRequest('GET', '/nodes/me', undefined, { cache: true, cacheTTL: CACHE_TIMES.SHORT });
-                return res.node ?? null;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Revoke the caller's node registration (`DELETE /nodes/me`). The node flips
-         * to `revoked` server-side (leaving the DID document and liveness sweeps).
-         * Auth required; the node + `/users/me` GET caches are swept on success.
-         *
-         * Maps the server's `{ success }` to the SDK's `{ revoked }` semantic.
-         */
-        async removeMyNode() {
-            try {
-                const res = await this.makeRequest('DELETE', '/nodes/me', undefined, { cache: false });
-                this._sweepNodeCaches();
-                return { revoked: res.success === true };
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Provision (or refresh) an Oxy-operated MANAGED vault for the caller
-         * (`POST /nodes/managed`) — the "Create your vault" convenience for
-         * non-technical users. Oxy custodial-signs the node registration onto the
-         * caller's chain and returns the materialized node (`managed:true,
-         * controller:'oxy'`). Idempotent server-side. Auth required; the owner id is
-         * resolved from the session, never the body. The node + `/users/me` GET caches
-         * are swept on success.
-         */
-        async provisionManagedVault() {
-            try {
-                const res = await this.makeRequest('POST', '/nodes/managed', undefined, { cache: false });
-                this._sweepNodeCaches();
-                return res.node;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Send an ingest HINT that a user's node has new records
-         * (`POST /nodes/ingest/notify/:userId`). Unauthenticated by design and
-         * fire-and-forget on the server (it only schedules a background re-pull of the
-         * named user's OWN node, then fully re-verifies — a notify can never inject
-         * data), so this resolves once the 202 hint is accepted and returns nothing.
-         *
-         * @param userId - The user whose node may have new records. URL-encoded.
-         */
-        async notifyNodeIngest(userId) {
-            try {
-                await this.makeRequest('POST', `/nodes/ingest/notify/${encodeURIComponent(userId)}`, undefined, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Sweep the GET caches a node mutation invalidates: every node read
-         * (`GET:/nodes/`) so a re-read reflects the new node / its absence, and
-         * `/users/me` because the user's derived DID document embeds an `#oxy-node`
-         * service entry that changes on register / revoke / manage. Public rather
-         * than `private` because mixins compose into an exported anonymous class
-         * where TypeScript cannot represent a private member in the emitted
-         * declaration file (TS4094) — mirrors the civic / identity cache sweepers.
-         */
-        _sweepNodeCaches() {
-            this.clearCacheByPrefix(NODES_CACHE_PREFIX);
-            this.clearCacheByPrefix(USERS_ME_CACHE_PREFIX);
-        }
-    };
-}