@calimero-network/mero-js 26.10.0 → 27.0.0

package/dist/http-client/web-client.d.ts

@@ -1,80 +0,0 @@
-import { HttpClient, Transport, RequestOptions } from './http-types.js';
-export declare class HTTPError extends Error {
-    status: number;
-    statusText: string;
-    url: string;
-    headers: Headers;
-    bodyText?: string;
-    name: string;
-    /**
-     * The node's own words for the failure, without the `HTTP <status>` prefix
-     * `message` carries: the body's `error` (or `detail`) for a response, the
-     * thrown error's text for status 0. Undefined when there was none.
-     */
-    readonly explanation: string | undefined;
-    constructor(status: number, statusText: string, url: string, headers: Headers, bodyText?: string);
-    toJSON(): {
-        status: number;
-        statusText: string;
-        url: string;
-        headers: Record<string, string>;
-        bodyText?: string;
-    };
-}
-/**
- * Terminal authentication error: the refresh-token family was revoked (single-use
- * refresh token replayed, or the token was explicitly revoked). Never retried and
- * never refreshed — apps should catch this and force a re-login.
- *
- * Extends {@link HTTPError} so existing `instanceof HTTPError` handling keeps working.
- */
-export declare class AuthRevokedError extends HTTPError {
-    /** Value of the `x-auth-error` header, e.g. `token_reuse` or `token_revoked`. */
-    reason: string;
-    name: string;
-    constructor(
-    /** Value of the `x-auth-error` header, e.g. `token_reuse` or `token_revoked`. */
-    reason: string, status: number, statusText: string, url: string, headers: Headers, bodyText?: string);
-}
-/**
- * A failure of a transport's `getAuthToken` that must stop the request.
- *
- * Any other error from `getAuthToken` is ignored and the request goes out
- * without a token, which is right for a credential that is merely absent. This
- * one says the credential could not be obtained at all — the login it needed
- * was refused, or never reached the server — so sending the request anyway
- * would only trade the real cause for the server's 401, or for the same
- * transport error a second time. Thrown as is from the request.
- */
-export declare class RequestAuthError extends Error {
-    name: string;
-}
-/** Whether `headers` carry a request proof, which must never follow a redirect. */
-export declare function carriesProof(headers: Record<string, string>): boolean;
-/**
- * Throws when a proof-carrying request was answered with a redirect, which
- * fetch reports as an opaque response with status 0 under redirect: 'manual'.
- */
-export declare function refuseProofRedirect(response: Response, url: string): void;
-export declare class WebHttpClient implements HttpClient {
-    private transport;
-    private refreshTokenPromise;
-    private onTokenRefreshPromise;
-    constructor(transport: Transport);
-    get<T>(path: string, init?: RequestOptions): Promise<T>;
-    post<T>(path: string, body?: unknown, init?: RequestOptions): Promise<T>;
-    put<T>(path: string, body?: unknown, init?: RequestOptions): Promise<T>;
-    delete<T>(path: string, init?: RequestOptions): Promise<T>;
-    patch<T>(path: string, body?: unknown, init?: RequestOptions): Promise<T>;
-    head(path: string, init?: RequestOptions): Promise<{
-        headers: Record<string, string>;
-        status: number;
-    }>;
-    request<T>(path: string, init?: RequestOptions): Promise<T>;
-    private makeRequest;
-    private buildUrl;
-    private createAbortSignal;
-    private buildHeaders;
-    private parseResponse;
-    private getBodyText;
-}

package/dist/http-client/web-client.js

@@ -1,557 +0,0 @@
-import { combineSignals, createTimeoutSignal } from './signal-utils.js';
-import { signedPath } from '../request-proof/authorizer.js';
-import { REQUEST_PROOF_HEADER } from '../request-proof/request-proof.js';
-/**
- * `x-auth-error` reasons that mean the whole token family is gone.
- *
- * Refresh tokens are single-use (calimero-network/core#3083): presenting a
- * consumed refresh token is treated as token theft and the server revokes the
- * family. Refreshing or retrying afterwards is pointless — the only way out is
- * a fresh login.
- */
-const TERMINAL_AUTH_ERRORS = new Set(['token_reuse', 'token_revoked']);
-/**
- * Pull the node's explanation out of an error body. Core answers every handled
- * failure with `{"error": "<message>"}` (`ApiError::into_response`); the nested
- * `{"error": {"message": ...}}` form is what proxies in front of a node emit.
- * Returns undefined for a non-JSON, empty, or envelope-less body.
- */
-function extractErrorMessage(bodyText) {
-    if (!bodyText)
-        return undefined;
-    try {
-        const body = JSON.parse(bodyText);
-        const error = body?.error;
-        if (typeof error === 'string' && error.trim() !== '')
-            return error;
-        const nested = error?.message;
-        if (typeof nested === 'string' && nested.trim() !== '')
-            return nested;
-        // FastAPI's spelling, which is what every Calimero Cloud route answers
-        // with. Without it a manager's carefully worded refusal — "ownership is
-        // recorded, but the account is not linked" — reached callers as a bare
-        // "HTTP 403", and the one thing they could do about it was invisible.
-        const detail = body?.detail;
-        if (typeof detail === 'string' && detail.trim() !== '')
-            return detail;
-    }
-    catch {
-        // Not JSON — the status line is all we can honestly report.
-    }
-    return undefined;
-}
-// Custom error class for HTTP errors
-export class HTTPError extends Error {
-    constructor(status, statusText, url, headers, bodyText) {
-        // Status 0 means no response arrived: every client puts the thrown error's
-        // message in `bodyText`, as plain text. It is the only explanation there is
-        // — "The node refused to attest: HTTP 404" from a sealed fetch, or
-        // "This operation was aborted" from a timeout — so report it as is.
-        const explanation = extractErrorMessage(bodyText) ??
-            (status === 0 && bodyText?.trim() ? bodyText.trim() : undefined);
-        super(explanation
-            ? `HTTP ${status} ${statusText}: ${explanation}`
-            : `HTTP ${status} ${statusText}`);
-        this.status = status;
-        this.statusText = statusText;
-        this.url = url;
-        this.headers = headers;
-        this.bodyText = bodyText;
-        this.name = 'HTTPError';
-        this.explanation = explanation;
-    }
-    toJSON() {
-        return {
-            status: this.status,
-            statusText: this.statusText,
-            url: this.url,
-            headers: headersToRecord(this.headers),
-            bodyText: this.bodyText,
-        };
-    }
-}
-/**
- * Terminal authentication error: the refresh-token family was revoked (single-use
- * refresh token replayed, or the token was explicitly revoked). Never retried and
- * never refreshed — apps should catch this and force a re-login.
- *
- * Extends {@link HTTPError} so existing `instanceof HTTPError` handling keeps working.
- */
-export class AuthRevokedError extends HTTPError {
-    constructor(
-    /** Value of the `x-auth-error` header, e.g. `token_reuse` or `token_revoked`. */
-    reason, status, statusText, url, headers, bodyText) {
-        super(status, statusText, url, headers, bodyText);
-        this.reason = reason;
-        this.name = 'AuthRevokedError';
-        this.message = `Authentication revoked (${reason}): HTTP ${status} ${statusText}`;
-    }
-}
-/**
- * A failure of a transport's `getAuthToken` that must stop the request.
- *
- * Any other error from `getAuthToken` is ignored and the request goes out
- * without a token, which is right for a credential that is merely absent. This
- * one says the credential could not be obtained at all — the login it needed
- * was refused, or never reached the server — so sending the request anyway
- * would only trade the real cause for the server's 401, or for the same
- * transport error a second time. Thrown as is from the request.
- */
-export class RequestAuthError extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = 'RequestAuthError';
-    }
-}
-// Helper function to convert Headers to Record
-function headersToRecord(headers) {
-    const record = {};
-    headers.forEach((value, key) => {
-        record[key] = value;
-    });
-    return record;
-}
-/** Runtimes disagree on sending a bare `?`, so the URL parser drops it once and
- * the URL signed and the URL fetched are one string. */
-function withoutBareQuery(url) {
-    let parsed;
-    try {
-        parsed = new URL(url, globalThis.location?.href);
-    }
-    catch {
-        return url; // relative, with no page to resolve it against
-    }
-    if (parsed.search === '')
-        parsed.search = '';
-    return parsed.href;
-}
-/** Whether `headers` carry a request proof, which must never follow a redirect. */
-export function carriesProof(headers) {
-    return Object.keys(headers).some((name) => name.toLowerCase() === REQUEST_PROOF_HEADER.toLowerCase());
-}
-/**
- * Throws when a proof-carrying request was answered with a redirect, which
- * fetch reports as an opaque response with status 0 under redirect: 'manual'.
- */
-export function refuseProofRedirect(response, url) {
-    const redirected = response.type === 'opaqueredirect' || (response.status >= 300 && response.status < 400);
-    if (!redirected)
-        return;
-    // Status 0 marks a withheld response; its explanation is the body text.
-    throw new HTTPError(0, 'Redirect Not Followed', url, response.headers, `the node answered with a redirect; a request carrying ${REQUEST_PROOF_HEADER} is not followed to another location`);
-}
-// Web Standards HTTP client implementation
-export class WebHttpClient {
-    constructor(transport) {
-        this.transport = transport;
-        // Cache for concurrent refresh token calls to prevent race conditions
-        this.refreshTokenPromise = null;
-        // Cache for concurrent onTokenRefresh calls to prevent duplicate callbacks
-        this.onTokenRefreshPromise = null;
-    }
-    async get(path, init) {
-        return this.request(path, { ...init, method: 'GET' });
-    }
-    async post(path, body, init) {
-        return this.request(path, {
-            ...init,
-            method: 'POST',
-            body: body ? JSON.stringify(body) : undefined,
-            headers: {
-                'Content-Type': 'application/json',
-                ...init?.headers,
-            },
-        });
-    }
-    async put(path, body, init) {
-        return this.request(path, {
-            ...init,
-            method: 'PUT',
-            body: body ? JSON.stringify(body) : undefined,
-            headers: {
-                'Content-Type': 'application/json',
-                ...init?.headers,
-            },
-        });
-    }
-    async delete(path, init) {
-        return this.request(path, { ...init, method: 'DELETE' });
-    }
-    async patch(path, body, init) {
-        return this.request(path, {
-            ...init,
-            method: 'PATCH',
-            body: body ? JSON.stringify(body) : undefined,
-            headers: {
-                'Content-Type': 'application/json',
-                ...init?.headers,
-            },
-        });
-    }
-    async head(path, init) {
-        const response = await this.makeRequest(path, {
-            ...init,
-            method: 'HEAD',
-            parse: 'response',
-        });
-        return {
-            headers: headersToRecord(response.headers),
-            status: response.status,
-        };
-    }
-    async request(path, init) {
-        return this.makeRequest(path, init);
-    }
-    async makeRequest(path, init, retryCount = 0, requestStartTime) {
-        // Maximum retry attempts to prevent infinite loops
-        const MAX_RETRY_ATTEMPTS = 1;
-        const url = withoutBareQuery(this.buildUrl(path));
-        // Track request start time for timeout calculation (only on first attempt)
-        // Use per-request start time to avoid corruption from concurrent requests
-        const startTime = requestStartTime ?? Date.now();
-        // Note: Tauri proxy script now handles AbortSignal, so we can use full RequestInit
-        // Removed Tauri-specific minimal path - proxy script handles AbortSignal properly
-        const signal = this.createAbortSignal(init);
-        const headers = await this.buildHeaders(init?.headers);
-        let headersObj;
-        if (headers instanceof Headers) {
-            headersObj = {};
-            headers.forEach((value, key) => {
-                headersObj[key] = value;
-            });
-        }
-        else {
-            headersObj = headers;
-        }
-        const method = init?.method || 'GET';
-        // A credential that commits to the request can only be produced here, where
-        // the method, the assembled path and query, and the body are all known.
-        if (this.transport.authorizeRequest) {
-            const body = init?.body;
-            if (body !== undefined && typeof body !== 'string' && !(body instanceof Uint8Array)) {
-                throw new Error('this transport authorizes each request against its body, so the body must be a string ' +
-                    'or Uint8Array — a stream cannot be signed, because the signature would have to read ' +
-                    'bytes the request then cannot send.');
-            }
-            Object.assign(headersObj, await this.transport.authorizeRequest({
-                method,
-                path: signedPath(url),
-                // Narrowed by the guard above; `BodyInit` is wider than what can be
-                // signed.
-                body: body,
-            }));
-        }
-        const requestInit = {
-            method,
-            headers: headersObj,
-        };
-        // Check if body is a stream (ReadableStream) that can't be reused
-        // Note: Blob is reusable, so it's not included here
-        const isStreamBody = init?.body instanceof ReadableStream ||
-            (typeof init?.body === 'object' && init?.body !== null && 'getReader' in init.body && !(init.body instanceof Blob));
-        if (init?.body !== undefined && !isStreamBody) {
-            requestInit.body = init.body;
-        }
-        else if (init?.body !== undefined && isStreamBody && retryCount === 0) {
-            // Only include stream body on first attempt - can't retry with streams
-            requestInit.body = init.body;
-        }
-        // For retries, calculate remaining timeout to prevent timeout reset
-        // Track elapsed time and use remaining timeout for retry
-        // Note: This is calculated before the request, so it doesn't include token refresh time
-        // The actual remaining timeout check happens after token refresh completes
-        let retrySignal;
-        if (retryCount > 0 && requestStartTime !== undefined) {
-            const timeoutMs = init?.timeoutMs || this.transport.timeoutMs;
-            if (timeoutMs) {
-                // Calculate elapsed time (will be recalculated after token refresh if needed)
-                const elapsed = Date.now() - startTime;
-                const remaining = Math.max(0, timeoutMs - elapsed);
-                // Create signal with remaining timeout, preserving user's signal
-                retrySignal = this.createAbortSignal({ ...init, timeoutMs: remaining });
-            }
-            else {
-                // No timeout, just preserve user's signal
-                retrySignal = this.createAbortSignal(init);
-            }
-        }
-        else {
-            retrySignal = signal;
-        }
-        if (retrySignal) {
-            requestInit.signal = retrySignal;
-        }
-        if (this.transport.credentials !== undefined) {
-            requestInit.credentials = this.transport.credentials;
-        }
-        if (init?.mode !== undefined) {
-            requestInit.mode = init.mode;
-        }
-        if (init?.cache !== undefined) {
-            requestInit.cache = init.cache;
-        }
-        if (init?.redirect !== undefined) {
-            requestInit.redirect = init.redirect;
-        }
-        if (init?.referrer !== undefined) {
-            requestInit.referrer = init.referrer;
-        }
-        if (init?.referrerPolicy !== undefined) {
-            requestInit.referrerPolicy = init.referrerPolicy;
-        }
-        if (init?.integrity !== undefined) {
-            requestInit.integrity = init.integrity;
-        }
-        if (init?.keepalive !== undefined) {
-            requestInit.keepalive = init.keepalive;
-        }
-        // Signed here rather than in `buildHeaders`, which sees neither the method
-        // nor the body — and a proof commits to both. Signed AFTER the body is
-        // settled above, so what is hashed is what is sent.
-        //
-        // The path and query come from the built URL, not from the `path` argument,
-        // which may be relative to a base URL that contributes its own prefix.
-        if (this.transport.getProof) {
-            const proof = await this.transport.getProof({
-                method: requestInit.method ?? 'GET',
-                path: signedPath(url),
-                body: requestInit.body,
-            });
-            if (proof) {
-                headersObj['X-Calimero-Proof'] = proof;
-            }
-        }
-        // fetch forwards custom headers across redirects, so a proof must never be
-        // sent anywhere but where it was signed for.
-        const proofAttached = carriesProof(headersObj);
-        if (proofAttached && requestInit.redirect !== 'error') {
-            requestInit.redirect = 'manual';
-        }
-        try {
-            const response = await this.transport.fetch(url, requestInit);
-            if (proofAttached)
-                refuseProofRedirect(response, url);
-            if (!response.ok) {
-                const bodyText = await this.getBodyText(response);
-                const httpError = new HTTPError(response.status, response.statusText, url, response.headers, bodyText);
-                // Handle a revoked token family (single-use refresh token replayed, or an
-                // explicitly revoked token). This is terminal: refreshing would only burn
-                // another token and retrying would 401 again, so clear the tokens via the
-                // onAuthRevoked hook and surface a distinguishable error.
-                const authError = response.headers.get('x-auth-error');
-                if ((response.status === 401 || response.status === 403) &&
-                    authError &&
-                    TERMINAL_AUTH_ERRORS.has(authError)) {
-                    // Any in-flight refresh is based on a now-dead family — drop the caches.
-                    this.refreshTokenPromise = null;
-                    this.onTokenRefreshPromise = null;
-                    if (this.transport.onAuthRevoked) {
-                        try {
-                            await this.transport.onAuthRevoked();
-                        }
-                        catch {
-                            // Never mask the auth error with a cleanup failure.
-                        }
-                    }
-                    throw new AuthRevokedError(authError, response.status, response.statusText, url, response.headers, bodyText);
-                }
-                // Handle 401 with token_expired - attempt automatic token refresh
-                const userAborted = init?.signal?.aborted === true;
-                if (response.status === 401 &&
-                    this.transport.refreshToken &&
-                    authError === 'token_expired' &&
-                    retryCount < MAX_RETRY_ATTEMPTS &&
-                    !isStreamBody &&
-                    !userAborted) {
-                    try {
-                        // Use cached refresh promise if one is in progress (prevents race conditions)
-                        let refreshPromise = this.refreshTokenPromise;
-                        if (!refreshPromise) {
-                            refreshPromise = this.transport.refreshToken();
-                            this.refreshTokenPromise = refreshPromise;
-                        }
-                        // Attempt to refresh the token
-                        const newToken = await refreshPromise;
-                        // Validate token - must be non-empty
-                        if (!newToken || newToken.trim() === '') {
-                            // Clear caches on error
-                            this.refreshTokenPromise = null;
-                            this.onTokenRefreshPromise = null;
-                            throw new Error('Refresh token returned empty token');
-                        }
-                        // onTokenRefresh is required when refreshToken is provided
-                        // Without it, the new token cannot be stored and getAuthToken() will return the old token
-                        if (!this.transport.onTokenRefresh) {
-                            // Clear caches on error
-                            this.refreshTokenPromise = null;
-                            this.onTokenRefreshPromise = null;
-                            throw new Error('onTokenRefresh callback is required when refreshToken is provided. ' +
-                                'The callback must update the token storage so getAuthToken() returns the new token.');
-                        }
-                        // Use cached onTokenRefresh promise if one is in progress (prevents duplicate callbacks)
-                        // This ensures onTokenRefresh is only called once per token refresh, even with concurrent requests
-                        let onTokenRefreshPromise = this.onTokenRefreshPromise;
-                        if (!onTokenRefreshPromise) {
-                            onTokenRefreshPromise = this.transport.onTokenRefresh(newToken);
-                            this.onTokenRefreshPromise = onTokenRefreshPromise;
-                        }
-                        // Update token via callback (only called once per refresh, even with concurrent requests)
-                        // Errors from onTokenRefresh callback should be preserved (don't mask as 401)
-                        // This helps developers debug token storage issues
-                        await onTokenRefreshPromise;
-                        // Clear caches after both refresh and callback complete
-                        this.refreshTokenPromise = null;
-                        this.onTokenRefreshPromise = null;
-                        // Check if timeout has expired during token refresh
-                        // If so, throw the original 401 error instead of retrying with 0ms timeout
-                        // This prevents timeout/abort errors that obscure the root cause (expired token)
-                        const timeoutMs = init?.timeoutMs || this.transport.timeoutMs;
-                        if (timeoutMs && requestStartTime !== undefined) {
-                            const elapsed = Date.now() - startTime;
-                            const remaining = timeoutMs - elapsed;
-                            if (remaining <= 0) {
-                                // Timeout expired during token refresh - throw original 401 error
-                                // This is better than retrying with 0ms timeout which would cause confusing timeout errors
-                                throw httpError;
-                            }
-                        }
-                        // Retry the request with the new token (increment retry count)
-                        // Preserve user's abort signal and start time in retry
-                        return this.makeRequest(path, init, retryCount + 1, startTime);
-                    }
-                    catch (refreshError) {
-                        // Clear caches on error
-                        this.refreshTokenPromise = null;
-                        this.onTokenRefreshPromise = null;
-                        // Configuration errors (missing onTokenRefresh) should be thrown as-is
-                        if (refreshError instanceof Error && refreshError.message.includes('onTokenRefresh')) {
-                            throw refreshError;
-                        }
-                        // Errors from onTokenRefresh callback are already thrown above, so if we get here,
-                        // it's either a refreshToken() failure or empty token - throw original 401
-                        // This matches the PR description: "If refresh fails, throws the original 401 error"
-                        throw httpError;
-                    }
-                }
-                throw httpError;
-            }
-            return this.parseResponse(response, init?.parse);
-        }
-        catch (error) {
-            if (error instanceof HTTPError) {
-                throw error;
-            }
-            // Preserve configuration errors (like missing onTokenRefresh)
-            if (error instanceof Error && error.message.includes('onTokenRefresh')) {
-                throw error;
-            }
-            throw new HTTPError(0, 'Network Error', url, new Headers(), error instanceof Error ? error.message : 'Unknown error');
-        }
-    }
-    buildUrl(path) {
-        // Handle absolute URLs
-        if (path.startsWith('http://') || path.startsWith('https://')) {
-            return path;
-        }
-        // Handle baseUrl with path
-        const baseUrl = this.transport.baseUrl;
-        if (path.startsWith('/')) {
-            // If path starts with /, combine with baseUrl
-            const base = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
-            return `${base}${path}`;
-        }
-        else {
-            // If path doesn't start with /, append to baseUrl
-            const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
-            return `${base}${path}`;
-        }
-    }
-    createAbortSignal(init) {
-        const signals = [];
-        if (this.transport.defaultAbortSignal) {
-            signals.push(this.transport.defaultAbortSignal);
-        }
-        if (init?.signal) {
-            signals.push(init.signal);
-        }
-        const timeoutMs = init?.timeoutMs || this.transport.timeoutMs;
-        if (timeoutMs) {
-            signals.push(createTimeoutSignal(timeoutMs));
-        }
-        return signals.length > 0 ? combineSignals(signals) : undefined;
-    }
-    async buildHeaders(initHeaders) {
-        const headers = {
-            ...this.transport.defaultHeaders,
-        };
-        // Add auth token if available and not empty
-        if (this.transport.getAuthToken) {
-            try {
-                const token = await this.transport.getAuthToken();
-                if (token && token.trim() !== '') {
-                    headers.Authorization = `Bearer ${token}`;
-                }
-            }
-            catch (error) {
-                // A credential that could not be obtained stops the request; any other
-                // failure leaves it unauthenticated, as before.
-                if (error instanceof RequestAuthError)
-                    throw error;
-            }
-        }
-        // Add init headers
-        if (initHeaders) {
-            if (initHeaders instanceof Headers) {
-                initHeaders.forEach((value, key) => {
-                    headers[key] = value;
-                });
-            }
-            else if (Array.isArray(initHeaders)) {
-                initHeaders.forEach(([key, value]) => {
-                    headers[key] = value;
-                });
-            }
-            else {
-                Object.assign(headers, initHeaders);
-            }
-        }
-        return headers;
-    }
-    async parseResponse(response, parse) {
-        switch (parse) {
-            case 'text':
-                return (await response.text());
-            case 'blob':
-                return (await response.blob());
-            case 'arrayBuffer':
-                return (await response.arrayBuffer());
-            case 'response':
-                return response;
-            case 'json':
-            default: {
-                // Tolerate empty 2xx bodies (e.g. 204 No Content from delete/resync):
-                // `response.json()` throws on '', so read text and return null when empty.
-                const text = await response.text();
-                if (!text)
-                    return null;
-                try {
-                    return JSON.parse(text);
-                }
-                catch {
-                    // Non-JSON body on a 2xx (e.g. an HTML error page) — surface a clear
-                    // error with a snippet instead of a bare SyntaxError.
-                    throw new Error(`Expected a JSON response (status ${response.status}) but body was not JSON: ${text.slice(0, 200)}`);
-                }
-            }
-        }
-    }
-    async getBodyText(response) {
-        try {
-            const text = await response.text();
-            return text.length > 65536 ? text.slice(0, 65536) + '...' : text;
-        }
-        catch {
-            return '';
-        }
-    }
-}

package/dist/invitation/index.d.ts

@@ -1,2 +0,0 @@
-export { signGroupInvitation, encodeGroupInvitation, groupInvitationHash, defaultAdmitters, MAX_INVITATION_VALIDITY_SECS, INVITED_ROLE, } from './invitation.js';
-export type { GroupInvitationInput } from './invitation.js';

package/dist/invitation/index.js

@@ -1,2 +0,0 @@
-// Minting a group invitation off-node, with a device key.
-export { signGroupInvitation, encodeGroupInvitation, groupInvitationHash, defaultAdmitters, MAX_INVITATION_VALIDITY_SECS, INVITED_ROLE, } from './invitation.js';