@calimero-network/mero-js 26.10.0 → 27.0.0

package/dist/request-proof/request-proof.d.ts

@@ -1,53 +0,0 @@
-import type { Signer } from '../signer/index.js';
-/** The header a signed request carries. */
-export declare const REQUEST_PROOF_HEADER = "X-Calimero-Proof";
-export interface RequestProofInput {
-    /**
-     * The HTTP method, exactly as it will be sent.
-     *
-     * Not folded. `HEAD` and `GET` are the same *permission* and the node's
-     * permission table treats them so, but they are different *requests*: folding
-     * them here would let a proof minted for one be presented as the other.
-     */
-    method: string;
-    /**
-     * The path and query, exactly as on the request line, with no re-encoding or
-     * reordering. Use `signedPath` to take it from a URL.
-     */
-    path: string;
-    /**
-     * The body, exactly as it will be sent. Omit when there is none.
-     *
-     * There is no "absent body" case: an omitted body commits to the hash of no
-     * bytes, so a signer and a verifier cannot disagree about which encoding a
-     * bodyless request used.
-     */
-    body?: string | Uint8Array;
-    /** The `AccountProof<DeviceCert>` from `signDeviceCert`, hex. */
-    credential: string;
-    /** The certified device's ed25519 secret, hex. Or pass `signer`. */
-    deviceSecret?: string;
-    /** A signer, for a key that cannot be exported to hex. */
-    signer?: Signer;
-    /** Seconds the signature stays valid. Defaults to 300. */
-    validForSeconds?: number;
-    /** Override the clock, for tests. Unix seconds. */
-    now?: number;
-}
-/**
- * Sign one request and return the `X-Calimero-Proof` value, hex.
- *
- * The encoding is borsh, and it is assembled rather than re-derived: the
- * account proof is the **first** field of `CallerProof`, so the credential hex
- * a caller already holds is exactly its own prefix. Concatenating avoids a
- * second implementation of a structure the node deserializes — the class of bug
- * that surfaces far away, as a node refusing a credential nothing can explain.
- *
- *   CallerProof = <account_proof bytes> || 0x00 (no session) || RequestSig
- *   RequestSig  = u32le(len method) || method
- *               || u32le(len path)  || path (with its query)
- *               || body_hash[32]
- *               || u64le(issued_at) || u64le(expires_at)
- *               || signature[64]
- */
-export declare function signRequestProof(input: RequestProofInput): Promise<string>;

package/dist/request-proof/request-proof.js

@@ -1,95 +0,0 @@
-/**
- * Signing one request, so a caller's identity travels with it.
- *
- * This is the credential a keyholder presents when it has no session: the device
- * key signs the request itself, and the certificate its account signed says whose
- * key that is. The node verifies both with no store read and no prior
- * relationship — `crates/server/src/proof_auth.rs` — which is what lets a hosted
- * relay serve a caller it has never seen and holds no auth provider for.
- *
- * ## Why this exists alongside `login()`
- *
- * A session is a second link in the same chain, not an alternative to it. It
- * earns its place where the device key sits behind a boundary worth crossing
- * once — a hardware key, an extension — so a per-call signature becomes a
- * per-session one. A CLI, a server job, or a browser holding its device secret
- * in memory gains nothing from it, and `login()` additionally needs the node's
- * signing key learned out of band. This path needs neither.
- *
- * Measured against a node built from core `aecba573b`: a two-link proof is
- * served `200` on `/admin-api/namespaces`, `/contexts`, `/contexts/{id}`,
- * `/groups/{id}`, `/groups/{id}/contexts`, `/contexts/{id}/identities` and
- * `/storage`, and the listings are **filtered** — an account in one of a node's
- * two namespaces is shown one. `POST /admin-api/namespaces` is refused `403`, so
- * this authenticates a caller without granting operator actions.
- */
-import { concat, domainHash, fromHex, hex, importSigningKey, u32le, u64le, } from '../crypto/internal.js';
-import { requestBodyHash, SIGN_DOMAIN } from '../request/request-sig.js';
-const utf8 = (text) => new TextEncoder().encode(text);
-/** The header a signed request carries. */
-export const REQUEST_PROOF_HEADER = 'X-Calimero-Proof';
-/** Seconds a signature stays honourable. Short, because it bounds replay. */
-const DEFAULT_VALID_FOR = 300;
-/**
- * Sign one request and return the `X-Calimero-Proof` value, hex.
- *
- * The encoding is borsh, and it is assembled rather than re-derived: the
- * account proof is the **first** field of `CallerProof`, so the credential hex
- * a caller already holds is exactly its own prefix. Concatenating avoids a
- * second implementation of a structure the node deserializes — the class of bug
- * that surfaces far away, as a node refusing a credential nothing can explain.
- *
- *   CallerProof = <account_proof bytes> || 0x00 (no session) || RequestSig
- *   RequestSig  = u32le(len method) || method
- *               || u32le(len path)  || path (with its query)
- *               || body_hash[32]
- *               || u64le(issued_at) || u64le(expires_at)
- *               || signature[64]
- */
-export async function signRequestProof(input) {
-    const { method, path, credential } = input;
-    if (!method)
-        throw new Error('signRequestProof needs the method the request will use');
-    if (!path.startsWith('/')) {
-        throw new Error(`signRequestProof needs a path, got ${JSON.stringify(path)}`);
-    }
-    const bodyHash = await requestBodyHash(input.body);
-    const issuedAt = Math.floor(input.now ?? Date.now() / 1000);
-    const expiresAt = issuedAt + (input.validForSeconds ?? DEFAULT_VALID_FOR);
-    const payload = await domainHash(SIGN_DOMAIN, [
-        utf8(method),
-        utf8(path),
-        bodyHash,
-        u64le(issuedAt),
-        u64le(expiresAt),
-    ]);
-    const signature = await signPayload(payload, input);
-    if (signature.length !== 64) {
-        throw new Error(`the signer returned ${signature.length} bytes, not a 64-byte signature`);
-    }
-    const requestSig = concat(u32le(utf8(method).length), utf8(method), u32le(utf8(path).length), utf8(path), bodyHash, u64le(issuedAt), u64le(expiresAt), signature);
-    // The credential IS the account-proof prefix. Length is not asserted: it varies
-    // with the handoff chain, and a wrong one fails as a refused proof rather than
-    // silently as something else.
-    const accountProof = hexToBytes(credential, 'credential');
-    // 0x00: borsh's `None`. The device key signed the request, so there is no
-    // session link — a different encoding, not a shorter one.
-    return hex(concat(accountProof, new Uint8Array([0]), requestSig));
-}
-async function signPayload(payload, input) {
-    if (input.signer)
-        return input.signer.sign(payload);
-    if (!input.deviceSecret) {
-        throw new Error('signRequestProof needs either `deviceSecret` or `signer`');
-    }
-    const key = await importSigningKey(input.deviceSecret);
-    return new Uint8Array(await crypto.subtle.sign({ name: 'Ed25519' }, key, payload));
-}
-/** Hex of unknown length — `fromHex` requires a fixed byte count. */
-function hexToBytes(value, label) {
-    const clean = value.trim();
-    if (!/^[0-9a-fA-F]*$/.test(clean) || clean.length % 2 !== 0) {
-        throw new Error(`${label} is not an even-length hex string`);
-    }
-    return fromHex(clean, label, clean.length / 2);
-}

package/dist/rpc/index.d.ts

@@ -1,64 +0,0 @@
-import type { HttpClient } from '../http-client/index.js';
-/** Result of the owner-driven `migrate_my_entries` convert (counts are u32). */
-export interface MigrateMyEntriesSummary {
-    converted: number;
-    remaining: number;
-}
-export interface ExecuteParams {
-    contextId: string;
-    method: string;
-    argsJson?: Record<string, unknown>;
-    /** @deprecated No longer used by the server. Ignored if provided. */
-    executorPublicKey?: string;
-}
-export declare class RpcError extends Error {
-    code: number;
-    type?: string;
-    data?: unknown;
-    constructor(code: number, message: string, data?: unknown, type?: string);
-}
-/**
- * POST a JSON-RPC call and unwrap `result`, converting an `error` payload into
- * an `RpcError`. The node returns `{ type, data }` (not always `{ code,
- * message }`), so this is the one place that normalization lives — every
- * JSON-RPC caller in this SDK shares it rather than re-deriving a bare
- * `Error(message)` and dropping the typed detail.
- */
-export declare function jsonRpcCall<T>(httpClient: HttpClient, method: string, params: unknown): Promise<T>;
-export declare class RpcClient {
-    private httpClient;
-    /**
-     * Which write path this is. Present so `RpcClient` satisfies
-     * `ExecuteTransport` as-is — the transport abstraction adopted *this* class's
-     * `execute` shape as the canonical one, so the node side is the interface
-     * rather than an adapter onto it.
-     */
-    readonly kind: "node";
-    /** A node serves `/sse` and `/ws` to the credential it issued. */
-    readonly canSubscribe = true;
-    constructor(opts: {
-        httpClient: HttpClient;
-    });
-    execute<T = unknown>(params: ExecuteParams): Promise<T>;
-    /**
-     * The same call, in the shape the transport abstraction shares with the
-     * relay.
-     *
-     * `rootHash` is left absent rather than synthesized: JSON-RPC `execute` does
-     * not report the context's scope root, and inventing a value — or a `''` —
-     * would make "the node does not tell us" indistinguishable from an answer.
-     */
-    executeWithMetadata<T = unknown>(params: ExecuteParams): Promise<{
-        returns: T;
-        transport: 'node';
-    }>;
-    /**
-     * One-tap owner-driven convert: re-signs the caller's identity-gated entries
-     * to the current schema. The export converts all of the caller's
-     * below-target entries in a single sweep, so this issues one call and returns
-     * the resulting summary — it does not loop.
-     */
-    migrateMyEntries(contextId: string): Promise<MigrateMyEntriesSummary>;
-    /** Read-only count of the caller's entries still below the target schema. */
-    countMyPending(contextId: string): Promise<number>;
-}

package/dist/rpc/index.js

@@ -1,78 +0,0 @@
-export class RpcError extends Error {
-    constructor(code, message, data, type) {
-        super(message);
-        this.name = 'RpcError';
-        this.code = code;
-        this.data = data;
-        this.type = type;
-    }
-}
-/**
- * POST a JSON-RPC call and unwrap `result`, converting an `error` payload into
- * an `RpcError`. The node returns `{ type, data }` (not always `{ code,
- * message }`), so this is the one place that normalization lives — every
- * JSON-RPC caller in this SDK shares it rather than re-deriving a bare
- * `Error(message)` and dropping the typed detail.
- */
-export async function jsonRpcCall(httpClient, method, params) {
-    const response = await httpClient.post('/jsonrpc', {
-        jsonrpc: '2.0',
-        id: 1,
-        method,
-        params,
-    });
-    if (response.error) {
-        const err = response.error;
-        throw new RpcError(err.code ?? -1, err.message ?? err.type ?? 'RPC error', err.data, err.type);
-    }
-    return response.result;
-}
-export class RpcClient {
-    constructor(opts) {
-        /**
-         * Which write path this is. Present so `RpcClient` satisfies
-         * `ExecuteTransport` as-is — the transport abstraction adopted *this* class's
-         * `execute` shape as the canonical one, so the node side is the interface
-         * rather than an adapter onto it.
-         */
-        this.kind = 'node';
-        /** A node serves `/sse` and `/ws` to the credential it issued. */
-        this.canSubscribe = true;
-        this.httpClient = opts.httpClient;
-    }
-    async execute(params) {
-        const result = await jsonRpcCall(this.httpClient, 'execute', {
-            contextId: params.contextId,
-            method: params.method,
-            argsJson: params.argsJson ?? {},
-        });
-        if (result && 'output' in result) {
-            return result.output;
-        }
-        return result;
-    }
-    /**
-     * The same call, in the shape the transport abstraction shares with the
-     * relay.
-     *
-     * `rootHash` is left absent rather than synthesized: JSON-RPC `execute` does
-     * not report the context's scope root, and inventing a value — or a `''` —
-     * would make "the node does not tell us" indistinguishable from an answer.
-     */
-    async executeWithMetadata(params) {
-        return { returns: await this.execute(params), transport: 'node' };
-    }
-    /**
-     * One-tap owner-driven convert: re-signs the caller's identity-gated entries
-     * to the current schema. The export converts all of the caller's
-     * below-target entries in a single sweep, so this issues one call and returns
-     * the resulting summary — it does not loop.
-     */
-    async migrateMyEntries(contextId) {
-        return this.execute({ contextId, method: 'migrate_my_entries' });
-    }
-    /** Read-only count of the caller's entries still below the target schema. */
-    async countMyPending(contextId) {
-        return this.execute({ contextId, method: 'count_my_pending' });
-    }
-}

package/dist/signer/index.d.ts

@@ -1,2 +0,0 @@
-export { signerFromSecret, signerFromCryptoKey } from './signer.js';
-export type { Signer } from './signer.js';

package/dist/signer/index.js

@@ -1,3 +0,0 @@
-// Who signs — a key's capability, separated from its material, so a
-// non-extractable `CryptoKey` can be used wherever a hex secret could.
-export { signerFromSecret, signerFromCryptoKey } from './signer.js';

package/dist/signer/signer.d.ts

@@ -1,92 +0,0 @@
-/**
- * Who signs, separated from what is signed.
- *
- * Every signing entry point in this package used to take 32 hex bytes. That is
- * fine for a CLI or a server holding a key file, and it is the one thing a
- * browser must not do: a secret that exists as a string can be read by anything
- * running on the origin, and a stolen account key is the account — permanently,
- * because unlike a device key there is nothing above it to revoke it with.
- *
- * WebCrypto can hold an Ed25519 key that **signs but cannot be exported**
- * (`generateKey(..., extractable: false, ...)`). Such a key has no hex
- * representation to pass, so it could not be used with this package at all —
- * which pushed consumers into reimplementing core's wire formats around their
- * own key. That is the failure `crates/account/src/tests/sdk_credential_fixture.rs`
- * exists to document: a second implementation of a byte contract agreed with
- * itself for a full release while core rejected every credential it produced.
- *
- * So the interface is the key's *capability*, not its material:
- *
- * ```ts
- * const signer = await signerFromSecret(deviceSecret);           // as before
- * const signer = await signerFromCryptoKey(privateKey, pubKey);  // unexportable
- * await signWarrant({ ...terms, signer });
- * ```
- *
- * `deviceSecret` and `rootSecret` keep working everywhere they did. They are
- * now one way of producing a `Signer` rather than the only way, and callers
- * that pass a secret get a signer built for them.
- */
-/**
- * Something that can produce Ed25519 signatures and name the key they verify
- * against.
- *
- * Deliberately the smallest surface that works: a signature and the public key
- * it belongs to. Anything larger would start describing *how* the key is held,
- * which is the detail this exists to hide — a hex seed, a non-extractable
- * `CryptoKey`, a hardware token behind an async prompt, and a remote signing
- * service all satisfy it.
- */
-export interface Signer {
-    /**
-     * The public half, 64 hex characters.
-     *
-     * Carried rather than derived on demand because a non-extractable private key
-     * cannot produce it: the public half has to be captured when the key is
-     * generated. A signer that could not name its key would force every caller to
-     * pass the public key alongside it, and the two could then disagree.
-     */
-    readonly publicKey: string;
-    /**
-     * Sign `payload` — the exact bytes, with no hashing or framing added.
-     *
-     * Every caller in this package passes a 32-byte domain-separated digest it
-     * has already computed, and an implementation that hashed again would produce
-     * signatures that verify nowhere.
-     */
-    sign(payload: Uint8Array): Promise<Uint8Array>;
-}
-/**
- * A signer over a raw 32-byte Ed25519 seed, hex.
- *
- * The public half is derived from the seed rather than accepted alongside it,
- * for the reason core does the same: a caller able to name a key it does not
- * hold could produce a statement it cannot sign, and the field would stop
- * meaning "who authorised this".
- *
- * @param secret the seed, 64 hex characters
- * @param label what to call it in an error — `deviceSecret`, `rootSecret`
- */
-export declare function signerFromSecret(secret: string, label?: string): Promise<Signer>;
-/**
- * A signer over a `CryptoKey` this process may use and cannot read.
- *
- * The point of the whole interface. Generate the key with
- * `generateKey({ name: 'Ed25519' }, false, ['sign', 'verify'])`, keep the pair's
- * private half (structured-clone it into IndexedDB if it must survive a reload),
- * and pass it here with its public half.
- *
- * @param privateKey the signing key — extractable or not, it is never exported
- * @param publicKey its public half: 64 hex, or the pair's `publicKey` (which
- *   WebCrypto leaves exportable even when the private half is not)
- */
-export declare function signerFromCryptoKey(privateKey: CryptoKey, publicKey: string | CryptoKey): Promise<Signer>;
-/**
- * Resolve the signer an input describes, accepting either form.
- *
- * Internal. Every signing entry point takes an optional secret *and* an
- * optional signer, and exactly one must be present — passing both is refused
- * rather than silently preferring one, because the two could name different
- * keys and the caller would have no way to tell which signed.
- */
-export declare function resolveSigner(secret: string | undefined, signer: Signer | undefined, label: string): Promise<Signer>;

package/dist/signer/signer.js

@@ -1,147 +0,0 @@
-/**
- * Who signs, separated from what is signed.
- *
- * Every signing entry point in this package used to take 32 hex bytes. That is
- * fine for a CLI or a server holding a key file, and it is the one thing a
- * browser must not do: a secret that exists as a string can be read by anything
- * running on the origin, and a stolen account key is the account — permanently,
- * because unlike a device key there is nothing above it to revoke it with.
- *
- * WebCrypto can hold an Ed25519 key that **signs but cannot be exported**
- * (`generateKey(..., extractable: false, ...)`). Such a key has no hex
- * representation to pass, so it could not be used with this package at all —
- * which pushed consumers into reimplementing core's wire formats around their
- * own key. That is the failure `crates/account/src/tests/sdk_credential_fixture.rs`
- * exists to document: a second implementation of a byte contract agreed with
- * itself for a full release while core rejected every credential it produced.
- *
- * So the interface is the key's *capability*, not its material:
- *
- * ```ts
- * const signer = await signerFromSecret(deviceSecret);           // as before
- * const signer = await signerFromCryptoKey(privateKey, pubKey);  // unexportable
- * await signWarrant({ ...terms, signer });
- * ```
- *
- * `deviceSecret` and `rootSecret` keep working everywhere they did. They are
- * now one way of producing a `Signer` rather than the only way, and callers
- * that pass a secret get a signer built for them.
- */
-import { concat, fromHex, hex } from '../crypto/internal.js';
-/** Ed25519 PKCS#8 prefix, so a raw 32-byte seed can be imported by WebCrypto. */
-const PKCS8_ED25519_PREFIX = new Uint8Array([
-    0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x04,
-    0x22, 0x04, 0x20,
-]);
-/** Turn WebCrypto's bare `NotSupportedError` into something actionable. */
-function unsupported(cause) {
-    // The original is folded into the message rather than passed as `cause`:
-    // this package targets ES2020, where `Error` has no `cause` option.
-    const detail = cause instanceof Error ? `: ${cause.message}` : '';
-    return new Error('this runtime has no WebCrypto Ed25519, so nothing can be signed here. ' +
-        'Node 18.4+, Safari 17+, Firefox 129+ and Chrome 137+ have it' +
-        detail);
-}
-/**
- * A signer over a raw 32-byte Ed25519 seed, hex.
- *
- * The public half is derived from the seed rather than accepted alongside it,
- * for the reason core does the same: a caller able to name a key it does not
- * hold could produce a statement it cannot sign, and the field would stop
- * meaning "who authorised this".
- *
- * @param secret the seed, 64 hex characters
- * @param label what to call it in an error — `deviceSecret`, `rootSecret`
- */
-export async function signerFromSecret(secret, label = 'secret') {
-    const seed = fromHex(secret, label, 32);
-    const pkcs8 = concat(PKCS8_ED25519_PREFIX, seed);
-    let privateKey;
-    let publicKey;
-    try {
-        // Imported twice on purpose: `extractable: true` is needed to read the
-        // public half out of a JWK, and the signing key is then re-imported
-        // unexportable so a `Signer` built from a secret is no more powerful than
-        // one built from a `CryptoKey`.
-        const exportable = await crypto.subtle.importKey('pkcs8', pkcs8, { name: 'Ed25519' }, true, ['sign']);
-        const jwk = (await crypto.subtle.exportKey('jwk', exportable));
-        publicKey = hex(Uint8Array.from(atob(jwk.x.replace(/-/g, '+').replace(/_/g, '/')), (c) => c.charCodeAt(0)));
-        privateKey = await crypto.subtle.importKey('pkcs8', pkcs8, { name: 'Ed25519' }, false, ['sign']);
-    }
-    catch (cause) {
-        throw unsupported(cause);
-    }
-    return fromKeyAndPublic(privateKey, publicKey);
-}
-/**
- * A signer over a `CryptoKey` this process may use and cannot read.
- *
- * The point of the whole interface. Generate the key with
- * `generateKey({ name: 'Ed25519' }, false, ['sign', 'verify'])`, keep the pair's
- * private half (structured-clone it into IndexedDB if it must survive a reload),
- * and pass it here with its public half.
- *
- * @param privateKey the signing key — extractable or not, it is never exported
- * @param publicKey its public half: 64 hex, or the pair's `publicKey` (which
- *   WebCrypto leaves exportable even when the private half is not)
- */
-export async function signerFromCryptoKey(privateKey, publicKey) {
-    if (privateKey.type !== 'private') {
-        throw new Error(`signerFromCryptoKey needs the private half of the pair, got a ${privateKey.type} key`);
-    }
-    if (!privateKey.usages.includes('sign')) {
-        throw new Error("this CryptoKey cannot sign: generate it with usages ['sign', 'verify']");
-    }
-    let publicHex;
-    if (typeof publicKey === 'string') {
-        // Validated rather than trusted: a wrong public key produces signatures
-        // that verify nowhere, and the refusal arrives at a relay as a 403 —
-        // nowhere near this call.
-        fromHex(publicKey, 'publicKey', 32);
-        publicHex = publicKey.trim().toLowerCase();
-    }
-    else {
-        try {
-            publicHex = hex(new Uint8Array(await crypto.subtle.exportKey('raw', publicKey)));
-        }
-        catch (cause) {
-            const detail = cause instanceof Error ? `: ${cause.message}` : '';
-            throw new Error('could not read the public half of this key pair; pass the public key ' +
-                'as 64 hex instead' +
-                detail);
-        }
-    }
-    return fromKeyAndPublic(privateKey, publicHex);
-}
-/** The shared tail of both constructors. */
-function fromKeyAndPublic(privateKey, publicKey) {
-    return {
-        publicKey,
-        async sign(payload) {
-            try {
-                return new Uint8Array(await crypto.subtle.sign({ name: 'Ed25519' }, privateKey, payload));
-            }
-            catch (cause) {
-                throw unsupported(cause);
-            }
-        },
-    };
-}
-/**
- * Resolve the signer an input describes, accepting either form.
- *
- * Internal. Every signing entry point takes an optional secret *and* an
- * optional signer, and exactly one must be present — passing both is refused
- * rather than silently preferring one, because the two could name different
- * keys and the caller would have no way to tell which signed.
- */
-export async function resolveSigner(secret, signer, label) {
-    if (signer && secret !== undefined) {
-        throw new Error(`pass either ${label} or signer, not both — they may name different keys`);
-    }
-    if (signer)
-        return signer;
-    if (secret !== undefined)
-        return signerFromSecret(secret, label);
-    throw new Error(`${label} or signer is required`);
-}

package/dist/token-store/index.d.ts

@@ -1,27 +0,0 @@
-import type { TokenData } from '../mero-js.js';
-export interface TokenStore {
-    getTokens(): TokenData | null;
-    setTokens(data: TokenData): void;
-    clear(): void;
-    /**
-     * Run `fn` holding a lock that every process sharing this store respects.
-     * MeroJs holds it around a token refresh, so two processes on one store never
-     * spend the same single-use refresh token. Web Locks cover tabs of one
-     * browser; a store shared across processes (a file read by several CLIs, say)
-     * needs its own lock, and implements this. Takes precedence over Web Locks.
-     */
-    withLock?<T>(fn: () => Promise<T>): Promise<T>;
-}
-export declare class MemoryTokenStore implements TokenStore {
-    private tokens;
-    getTokens(): TokenData | null;
-    setTokens(data: TokenData): void;
-    clear(): void;
-}
-export declare class LocalStorageTokenStore implements TokenStore {
-    private readonly key;
-    constructor(key?: string);
-    getTokens(): TokenData | null;
-    setTokens(data: TokenData): void;
-    clear(): void;
-}

package/dist/token-store/index.js

@@ -1,62 +0,0 @@
-export class MemoryTokenStore {
-    constructor() {
-        this.tokens = null;
-    }
-    getTokens() {
-        return this.tokens;
-    }
-    setTokens(data) {
-        this.tokens = data;
-    }
-    clear() {
-        this.tokens = null;
-    }
-}
-const STORAGE_KEY = 'mero-tokens';
-export class LocalStorageTokenStore {
-    constructor(key = STORAGE_KEY) {
-        this.key = key;
-    }
-    getTokens() {
-        try {
-            if (typeof localStorage === 'undefined')
-                return null;
-            const raw = localStorage.getItem(this.key);
-            if (!raw)
-                return null;
-            const parsed = JSON.parse(raw);
-            if (parsed && parsed.access_token && parsed.refresh_token) {
-                return {
-                    access_token: parsed.access_token,
-                    refresh_token: parsed.refresh_token,
-                    expires_at: typeof parsed.expires_at === 'number' ? parsed.expires_at : Date.now() + 3600000,
-                    ...(typeof parsed.node_origin === 'string' && { node_origin: parsed.node_origin }),
-                };
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    setTokens(data) {
-        try {
-            if (typeof localStorage === 'undefined')
-                return;
-            localStorage.setItem(this.key, JSON.stringify(data));
-        }
-        catch {
-            // Storage unavailable
-        }
-    }
-    clear() {
-        try {
-            if (typeof localStorage === 'undefined')
-                return;
-            localStorage.removeItem(this.key);
-        }
-        catch {
-            // Storage unavailable
-        }
-    }
-}

package/dist/transport/index.d.ts

@@ -1,6 +0,0 @@
-export { MeroClient, createMeroClient } from './mero-client.js';
-export type { MeroClientConfig, NodeTransportConfig, RelayTransportConfig, } from './mero-client.js';
-export { RelayTransport } from './relay-transport.js';
-export { RelayObserver, defaultAudience } from './relay-observer.js';
-export type { RelayObserveConfig } from './relay-observer.js';
-export type { ExecuteTransport, ExecuteResult, TransportKind } from './types.js';

package/dist/transport/index.js

@@ -1,3 +0,0 @@
-export { MeroClient, createMeroClient } from './mero-client.js';
-export { RelayTransport } from './relay-transport.js';
-export { RelayObserver, defaultAudience } from './relay-observer.js';