@calimero-network/mero-js 28.1.1 → 29.1.0

package/README.md

@@ -98,6 +98,7 @@ Pinned measurements go through `policy.verifyQuote` (`createQuoteVerifier`).
 ## The API
 
 - **Credentials**: `signUp`, `signIn`, `refresh`, `signOut`, `signOutEverywhere`, `useSession`, `useApiKey`, `me`, `usage`, `addPasskey`, `labelPasskey`, `removePasskey`, `createApiKey`, `listApiKeys`, `revokeApiKey`. Adding or removing a passkey and creating an API key are approved with a passkey the account already has.
+- **Package origins**: `packageOrigins.list`, `packageOrigins.add`, `packageOrigins.remove`. A package's managers register the web origins of a frontend they host themselves (approved with a passkey); `signUp` and `signIn` on such a page send its origin, sign for that origin's relying-party id, and open a session bound to the package (`me()` answers its `app` and `origin`). An unregistered origin is refused with `OriginNotRegistered`.
 - **Packages**: `installPackage`, `uploadPackage`, `packages`, `package`, `uninstallPackage`; `uploadBundle` (raw WASM, development clusters only).
 - **Apps**: `createApp`, `listApps`, `getApp`, `deleteApp`, `setAccess`, `setAppMetadata`, `appStorage`, `appAbi`, `upgradeApp`, `transferApp`.
 - **Calls**: `call`, `callConfirmed`, `view`, `events`. A call always carries an idempotency key, and is sent again with it while the node answers `503`, then to the next node.
@@ -110,7 +111,7 @@ Pinned measurements go through `policy.verifyQuote` (`createQuoteVerifier`).
 
 Refusals are typed (`LoginRequired`, `WrongNode`, `NotFound`, `ConfirmRequired`, `ConfirmCancelled`,
 `ArgsTooLarge`, `IdempotencyMismatch`, `ReleaseDeadlineError`, `ConsentStale`, `AppError`, `TrapError`,
-`UnavailableError`),
+`UnavailableError`, `OriginNotRegistered`, `BadOrigin`, `OriginTaken`, `QuotaExceeded`),
 all extending `CalimeroError` with the node's `status` and `code`. A `401` once
 the node that issued the session is replaced or out of reach is answered by one
 refresh and a repeat; a `421 WRONG_NODE` by moving to the next of the `nodes` the client was

package/dist/cloud-v2/client.d.ts

@@ -12,7 +12,7 @@
 import { type AttestationDoc, type CloudPolicy } from './attestation.js';
 import { type PasskeyProvider } from './passkey.js';
 import { type AppsReport, type ConsentRequest, type ConsentResult, type ConsentStarted, type OpenConsentOptions, type OpsAppsReport, type OpsOrgsReport, type PageOptions, type PendingApprovals, type PublisherBindingInfo, type PublisherProof, type ReleaseRules } from './approvals.js';
-export { AppError, ArgsTooLarge, CalimeroError, ConfirmCancelled, ConfirmRequired, IdempotencyMismatch, LoginRequired, ConsentStale, NotFound, ReleaseDeadlineError, TrapError, UnavailableError, WrongNode, errorFrom, } from './errors.js';
+export { AppError, ArgsTooLarge, BadOrigin, CalimeroError, ConfirmCancelled, ConfirmRequired, IdempotencyMismatch, LoginRequired, ConsentStale, NotFound, OriginNotRegistered, OriginTaken, QuotaExceeded, ReleaseDeadlineError, TrapError, UnavailableError, WrongNode, errorFrom, } from './errors.js';
 export type { Committed } from './errors.js';
 export interface CalimeroSession {
     accountId: string;
@@ -271,6 +271,73 @@ export declare function frontendManifest(origin?: string, fetcher?: typeof fetch
  * not opened through a deployment. `href` defaults to `window.location.href`.
  */
 export declare function pageDeployment(href?: string): string | null;
+/** `GET /auth/me`: who the credential is. */
+export interface MeInfo extends Record<string, unknown> {
+    accountId?: string;
+    /** `session` or `apikey`. */
+    via?: string;
+    /**
+     * The package the session is bound to: opened on an app's frontend or on
+     * an origin its manager registered ({@link CalimeroClient.packageOrigins}).
+     * `null` (or absent, on an older node) for an unbound session.
+     */
+    app?: string | null;
+    /** The web origin the session was opened on, when the node recorded one. */
+    origin?: string | null;
+}
+/** One web origin registered for a package (`GET /package-origins/{package}`). */
+export interface PackageOrigin {
+    /** `scheme://host[:port]`. */
+    origin: string;
+    /** The WebAuthn relying-party id passkeys made there are bound to. */
+    rpId: string;
+    /** The account that registered it. */
+    addedBy: string;
+    addedAt: string | number;
+}
+/** What registering an origin answers. */
+export interface PackageOriginAdded extends PackageOrigin {
+    package: string;
+}
+/** What removing an origin answers. */
+export interface PackageOriginRemoved {
+    package: string;
+    origin: string;
+    removed: true;
+}
+/**
+ * The web origins a package's frontend may sign users in from besides the
+ * cluster's own, so a developer can host it themselves. A session opened on
+ * one is bound to the package. For the package's managers.
+ */
+export interface PackageOrigins {
+    /** The origins registered for `pkg`. `NotFound` for an unknown package; `403` to anyone not managing it. */
+    list(pkg: string): Promise<PackageOrigin[]>;
+    /**
+     * Register `origin` for `pkg`, approved with `passkey` (`412
+     * CONFIRM_REQUIRED` over `__add_origin`; without a passkey it reaches the
+     * caller as {@link ConfirmRequired}). `rpId` defaults to the node's choice
+     * for the origin (its host). Refusals: {@link BadOrigin} (`BAD_ORIGIN`,
+     * `BAD_RP_ID`), {@link OriginTaken}, {@link QuotaExceeded}.
+     */
+    add(pkg: string, origin: string, passkey?: PasskeyProvider, options?: {
+        rpId?: string;
+    }): Promise<PackageOriginAdded>;
+    /**
+     * Remove `origin` from `pkg`, approved with `passkey` (`__remove_origin`).
+     * Sessions opened there stop working (`401`). `NotFound` if it was not registered.
+     */
+    remove(pkg: string, origin: string, passkey?: PasskeyProvider): Promise<PackageOriginRemoved>;
+}
+/**
+ * Where a sign-up or sign-in says it runs. By default the page's origin
+ * (`window.location.origin`) when it is not the origin of a node the client
+ * talks to; nothing outside a browser. A string sends that origin; `null`
+ * sends none (the cluster's own origins).
+ */
+export interface SignInOptions {
+    origin?: string | null;
+}
 /**
  * How a call or a view is sent again while the node is unavailable (D70): with
  * the same key, after a backoff that starts at `baseDelayMs` and doubles up to
@@ -445,10 +512,31 @@ export declare class CalimeroClient {
     get<T = Record<string, unknown>>(path: string): Promise<T>;
     put<T = Record<string, unknown>>(path: string, body?: unknown): Promise<T>;
     delete<T = Record<string, unknown>>(path: string, body?: unknown): Promise<T>;
-    /** Create an account with a new passkey, and sign in. */
-    signUp(passkey: PasskeyProvider, name: string): Promise<CalimeroSession>;
-    /** Sign in with an existing passkey. */
-    signIn(passkey: PasskeyProvider): Promise<CalimeroSession>;
+    /**
+     * Create an account with a new passkey, and sign in. The node then asks the
+     * new passkey to sign the account it creates (`412 CONFIRM_REQUIRED`), so a
+     * sign-up prompts twice: create, then sign. On a page whose origin is not
+     * the cluster's ({@link SignInOptions}), the node makes the passkey for that
+     * origin's relying party (the confirmation's `rpId` is that origin's too)
+     * and binds the session to the package the origin is registered for; an
+     * unregistered origin is refused with {@link OriginNotRegistered}.
+     */
+    signUp(passkey: PasskeyProvider, name: string, options?: SignInOptions): Promise<CalimeroSession>;
+    /**
+     * Sign in with an existing passkey. On a page whose origin is not the
+     * cluster's ({@link SignInOptions}), the assertion is made for that
+     * origin's relying-party id, as the node answers it, and the session is
+     * bound to the origin's package; an unregistered origin is refused with
+     * {@link OriginNotRegistered}.
+     */
+    signIn(passkey: PasskeyProvider, options?: SignInOptions): Promise<CalimeroSession>;
+    /**
+     * The origin a sign-up or sign-in sends: the one given, or the page's own
+     * when it is not a node's origin; `undefined` for none.
+     */
+    private pageOrigin;
+    /** POST a ceremony's `begin`, naming the page's `origin` in an {@link OriginNotRegistered} the node leaves it out of. */
+    private begin;
     /**
      * Swap the refresh token for a new session, on whichever node the client
      * uses: any node of the cluster takes it. A refresh token is used once, so
@@ -460,7 +548,8 @@ export declare class CalimeroClient {
     signOut(): Promise<void>;
     /** End every session of the signed-in account, on every device, this one too. */
     signOutEverywhere(): Promise<void>;
-    me(): Promise<Record<string, unknown>>;
+    /** Who the credential is: the account, how it signed in, and the package (`app`) and `origin` a session is bound to. */
+    me(): Promise<MeInfo>;
     /**
      * Add another passkey (another device, `passkey`) to the signed-in account;
      * answers its credential id. The node asks for the approval of a passkey
@@ -481,7 +570,8 @@ export declare class CalimeroClient {
     attestation(): Promise<AttestationDoc>;
     /** The account's API keys (never the keys themselves). */
     listApiKeys(): Promise<Array<Record<string, unknown>>>;
-    revokeApiKey(keyId: string): Promise<void>;
+    /** Revoke one of the account's API keys, approved with its `passkey` (`412 CONFIRM_REQUIRED`). */
+    revokeApiKey(keyId: string, passkey: PasskeyProvider): Promise<void>;
     /**
      * Create an API key for an agent or server, approved with the account's
      * `passkey` (`412 CONFIRM_REQUIRED`); needs a passkey session (an API key
@@ -856,6 +946,12 @@ export declare class CalimeroClient {
         uses?: number;
     }): Promise<string>;
     redeemInvite(token: string): Promise<Record<string, unknown>>;
+    /**
+     * The web origins `{package}`'s managers registered so a frontend they host
+     * themselves can sign users in with passkeys ({@link PackageOrigins}).
+     * Adding and removing one is approved with a passkey.
+     */
+    readonly packageOrigins: PackageOrigins;
     /**
      * Let an account or organization install apps where the cluster's
      * deployments are `granted`, until `until` (RFC 3339 or a `Date`; absent,

package/dist/cloud-v2/client.js

@@ -12,10 +12,10 @@
 import { SealedTransportError, createSealedFetch } from '../sealed/sealed.js';
 import { fetchAttestedKey } from './attestation.js';
 import { DEFAULT_DIRECTORY, orderNodes, readDirectory } from './directory.js';
-import { CalimeroError, ConfirmCancelled, ConfirmRequired, LoginRequired, UnavailableError, WrongNode, errorFrom, } from './errors.js';
+import { CalimeroError, ConfirmCancelled, ConfirmRequired, LoginRequired, OriginNotRegistered, UnavailableError, WrongNode, errorFrom, } from './errors.js';
 import { b64url, fromB64url } from './passkey.js';
 import { confirmationCode, pageQuery, pendingApprovalsFrom, } from './approvals.js';
-export { AppError, ArgsTooLarge, CalimeroError, ConfirmCancelled, ConfirmRequired, IdempotencyMismatch, LoginRequired, ConsentStale, NotFound, ReleaseDeadlineError, TrapError, UnavailableError, WrongNode, errorFrom, } from './errors.js';
+export { AppError, ArgsTooLarge, BadOrigin, CalimeroError, ConfirmCancelled, ConfirmRequired, IdempotencyMismatch, LoginRequired, ConsentStale, NotFound, OriginNotRegistered, OriginTaken, QuotaExceeded, ReleaseDeadlineError, TrapError, UnavailableError, WrongNode, errorFrom, } from './errors.js';
 /** A deployer's key, as `GET /deployers` lists it and `DELETE /deployers/{key}` takes it. */
 export function deployerKey(deployer) {
     return 'account' in deployer ? `account:${deployer.account}` : `org:${deployer.org}`;
@@ -186,6 +186,20 @@ export class CalimeroClient {
         this.channels = new Map();
         /** Rejections of the underlying `fetch` itself: the node could not be reached or dropped the connection. */
         this.networkFailures = new WeakSet();
+        // ---------------------------------------------------------------- package origins
+        /**
+         * The web origins `{package}`'s managers registered so a frontend they host
+         * themselves can sign users in with passkeys ({@link PackageOrigins}).
+         * Adding and removing one is approved with a passkey.
+         */
+        this.packageOrigins = {
+            list: async (pkg) => {
+                const { origins } = await this.get(`package-origins/${seg(pkg)}`);
+                return origins ?? [];
+            },
+            add: (pkg, origin, passkey, options = {}) => this.confirmed('POST', `package-origins/${seg(pkg)}`, options.rpId === undefined ? { origin } : { origin, rpId: options.rpId }, passkey),
+            remove: (pkg, origin, passkey) => this.confirmed('DELETE', `package-origins/${seg(pkg)}`, { origin }, passkey),
+        };
         const trim = (url) => url.replace(/\/+$/, '');
         this.nodeUrls = [...new Set([options.baseUrl, ...(options.nodes ?? [])].map(trim))];
         this.policy = options.policy;
@@ -440,21 +454,35 @@ export class CalimeroClient {
         return this.json('DELETE', path, body);
     }
     // ---------------------------------------------------------------- identity
-    /** Create an account with a new passkey, and sign in. */
-    async signUp(passkey, name) {
-        const begin = await this.post('auth/passkey/register/begin', { name });
+    /**
+     * Create an account with a new passkey, and sign in. The node then asks the
+     * new passkey to sign the account it creates (`412 CONFIRM_REQUIRED`), so a
+     * sign-up prompts twice: create, then sign. On a page whose origin is not
+     * the cluster's ({@link SignInOptions}), the node makes the passkey for that
+     * origin's relying party (the confirmation's `rpId` is that origin's too)
+     * and binds the session to the package the origin is registered for; an
+     * unregistered origin is refused with {@link OriginNotRegistered}.
+     */
+    async signUp(passkey, name, options = {}) {
+        const origin = this.pageOrigin(options);
+        const begin = await this.begin('auth/passkey/register/begin', origin === undefined ? { name } : { name, origin }, origin);
         const registration = await passkey.create(begin.options);
-        const session = await this.post('auth/passkey/register/finish', {
-            challengeId: begin.challengeId,
-            registration,
-        });
+        const session = await this.postConfirmed('auth/passkey/register/finish', { challengeId: begin.challengeId, registration }, passkey);
         this.useSession(session);
         return session;
     }
-    /** Sign in with an existing passkey. */
-    async signIn(passkey) {
-        const begin = await this.post('auth/passkey/login/begin');
-        const assertion = await passkey.get(fromB64url(begin.options.challenge), begin.options.rpId);
+    /**
+     * Sign in with an existing passkey. On a page whose origin is not the
+     * cluster's ({@link SignInOptions}), the assertion is made for that
+     * origin's relying-party id, as the node answers it, and the session is
+     * bound to the origin's package; an unregistered origin is refused with
+     * {@link OriginNotRegistered}.
+     */
+    async signIn(passkey, options = {}) {
+        const origin = this.pageOrigin(options);
+        const begin = await this.begin('auth/passkey/login/begin', origin === undefined ? undefined : { origin }, origin);
+        const rpId = begin.options.rpId ?? begin.options.rp?.id ?? '';
+        const assertion = await passkey.get(fromB64url(begin.options.challenge), rpId);
         const session = await this.post('auth/passkey/login/finish', {
             challengeId: begin.challengeId,
             assertion,
@@ -462,6 +490,38 @@ export class CalimeroClient {
         this.useSession(session);
         return session;
     }
+    /**
+     * The origin a sign-up or sign-in sends: the one given, or the page's own
+     * when it is not a node's origin; `undefined` for none.
+     */
+    pageOrigin(options) {
+        if (options.origin !== undefined)
+            return options.origin ?? undefined;
+        const page = globalThis.location?.origin;
+        if (!page || page === 'null')
+            return undefined;
+        const nodes = new Set(this.nodeUrls.map((url) => {
+            try {
+                return new URL(url).origin;
+            }
+            catch {
+                return url;
+            }
+        }));
+        return nodes.has(page) ? undefined : page;
+    }
+    /** POST a ceremony's `begin`, naming the page's `origin` in an {@link OriginNotRegistered} the node leaves it out of. */
+    async begin(path, body, origin) {
+        try {
+            return await this.post(path, body);
+        }
+        catch (error) {
+            if (error instanceof OriginNotRegistered && !error.origin && origin !== undefined) {
+                throw new OriginNotRegistered(error.nodeMessage, { ...error.details, origin });
+            }
+            throw error;
+        }
+    }
     /**
      * Swap the refresh token for a new session, on whichever node the client
      * uses: any node of the cluster takes it. A refresh token is used once, so
@@ -513,6 +573,7 @@ export class CalimeroClient {
         this.auth = undefined;
         this.current = undefined;
     }
+    /** Who the credential is: the account, how it signed in, and the package (`app`) and `origin` a session is bound to. */
     me() {
         return this.get('auth/me');
     }
@@ -556,8 +617,9 @@ export class CalimeroClient {
         const { keys } = await this.get('auth/apikeys');
         return keys;
     }
-    async revokeApiKey(keyId) {
-        await this.delete(`auth/apikeys/${seg(keyId)}`);
+    /** Revoke one of the account's API keys, approved with its `passkey` (`412 CONFIRM_REQUIRED`). */
+    async revokeApiKey(keyId, passkey) {
+        await this.deleteConfirmed(`auth/apikeys/${seg(keyId)}`, passkey);
     }
     /**
      * Create an API key for an agent or server, approved with the account's

package/dist/cloud-v2/errors.d.ts

@@ -100,6 +100,36 @@ export declare class ReleaseDeadlineError extends CalimeroError {
 export declare class ConsentStale extends CalimeroError {
     constructor(message: string, details?: Record<string, unknown>);
 }
+/**
+ * `403 ORIGIN_NOT_REGISTERED`: a sign-up or sign-in started on a web origin
+ * the cluster does not know: neither the cluster's own nor one a package's
+ * manager registered (`packageOrigins.add`). `origin` is the page's origin
+ * and `package` the package it was expected to be registered for, when known.
+ */
+export declare class OriginNotRegistered extends CalimeroError {
+    readonly origin: string;
+    readonly package: string;
+    /** What the node said, if anything. */
+    readonly nodeMessage: string;
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * `400 BAD_ORIGIN` or `400 BAD_RP_ID`: the node does not accept the origin a
+ * package's manager tried to register (it must be a bare web origin,
+ * `scheme://host[:port]`), or the relying-party id given for it (which must
+ * fit the origin's host). `code` says which.
+ */
+export declare class BadOrigin extends CalimeroError {
+    constructor(code: 'BAD_ORIGIN' | 'BAD_RP_ID', message: string, details?: Record<string, unknown>);
+}
+/** `409 ORIGIN_TAKEN`: the origin is registered already (for this package or another). */
+export declare class OriginTaken extends CalimeroError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/** `429 QUOTA_EXCEEDED`: the caller holds as many of something (origins, blobs, ...) as it may. */
+export declare class QuotaExceeded extends CalimeroError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
 /**
  * `422 APP_ERROR`: the app refused the call. `appCode` is the app's declared
  * error (`Taken`, `Forbidden`, ...) and `fields` its named fields. The call was

package/dist/cloud-v2/errors.js

@@ -128,6 +128,50 @@ export class ConsentStale extends CalimeroError {
         this.name = 'ConsentStale';
     }
 }
+/**
+ * `403 ORIGIN_NOT_REGISTERED`: a sign-up or sign-in started on a web origin
+ * the cluster does not know: neither the cluster's own nor one a package's
+ * manager registered (`packageOrigins.add`). `origin` is the page's origin
+ * and `package` the package it was expected to be registered for, when known.
+ */
+export class OriginNotRegistered extends CalimeroError {
+    constructor(message, details = {}) {
+        const origin = typeof details.origin === 'string' ? details.origin : '';
+        const pkg = typeof details.package === 'string' ? details.package : '';
+        const site = origin ? `this site (${origin})` : 'this site';
+        super(403, 'ORIGIN_NOT_REGISTERED', `${site} is not registered for ${pkg || 'any package'}${message ? ` (${message})` : ''}`, details);
+        this.name = 'OriginNotRegistered';
+        this.origin = origin;
+        this.package = pkg;
+        this.nodeMessage = message;
+    }
+}
+/**
+ * `400 BAD_ORIGIN` or `400 BAD_RP_ID`: the node does not accept the origin a
+ * package's manager tried to register (it must be a bare web origin,
+ * `scheme://host[:port]`), or the relying-party id given for it (which must
+ * fit the origin's host). `code` says which.
+ */
+export class BadOrigin extends CalimeroError {
+    constructor(code, message, details = {}) {
+        super(400, code, message, details);
+        this.name = 'BadOrigin';
+    }
+}
+/** `409 ORIGIN_TAKEN`: the origin is registered already (for this package or another). */
+export class OriginTaken extends CalimeroError {
+    constructor(message, details = {}) {
+        super(409, 'ORIGIN_TAKEN', message, details);
+        this.name = 'OriginTaken';
+    }
+}
+/** `429 QUOTA_EXCEEDED`: the caller holds as many of something (origins, blobs, ...) as it may. */
+export class QuotaExceeded extends CalimeroError {
+    constructor(message, details = {}) {
+        super(429, 'QUOTA_EXCEEDED', message, details);
+        this.name = 'QuotaExceeded';
+    }
+}
 /**
  * `422 APP_ERROR`: the app refused the call. `appCode` is the app's declared
  * error (`Taken`, `Forbidden`, ...) and `fields` its named fields. The call was
@@ -212,6 +256,15 @@ export function errorFrom(status, body, retryAfterHeader) {
             return new ReleaseDeadlineError(message, details);
         case '409 CONSENT_STALE':
             return new ConsentStale(message, details);
+        case '403 ORIGIN_NOT_REGISTERED':
+            return new OriginNotRegistered(message, details);
+        case '400 BAD_ORIGIN':
+        case '400 BAD_RP_ID':
+            return new BadOrigin(code, message, details);
+        case '409 ORIGIN_TAKEN':
+            return new OriginTaken(message, details);
+        case '429 QUOTA_EXCEEDED':
+            return new QuotaExceeded(message, details);
         case '412 CONFIRM_REQUIRED':
             return new ConfirmRequired(message, details);
         case '413 ARGS_TOO_LARGE':

package/dist/cloud-v2/index.d.ts

@@ -1,9 +1,9 @@
 export { CalimeroClient, deployerKey, frontendManifest, pageDeployment } from './client.js';
 export { DEFAULT_DIRECTORY, DirectoryError } from './directory.js';
 export type { DirectoryFailure } from './directory.js';
-export { AppError, ArgsTooLarge, CalimeroError, ConfirmCancelled, ConfirmRequired, IdempotencyMismatch, LoginRequired, ConsentStale, NotFound, ReleaseDeadlineError, TrapError, UnavailableError, WrongNode, errorFrom, } from './errors.js';
+export { AppError, ArgsTooLarge, BadOrigin, CalimeroError, ConfirmCancelled, ConfirmRequired, IdempotencyMismatch, LoginRequired, ConsentStale, NotFound, OriginNotRegistered, OriginTaken, QuotaExceeded, ReleaseDeadlineError, TrapError, UnavailableError, WrongNode, errorFrom, } from './errors.js';
 export type { Committed } from './errors.js';
-export type { AppInfo, AppXcalls, BlobContent, BlobInfo, DeadLetter, Deployer, DeployerGrant, DeployersInfo, DeploymentInfo, DeploymentOffer, DeploymentOrgs, FrontendManifest, PublicDeployment, CallResult, CalimeroClientOptions, CalimeroConnectOptions, CloudEvent, CalimeroSession, PackageInfo, PackageInstalled, CloudRetryOptions, OrgInfo, OrgUpgradeTarget, PresenceEntry, UpgradeRun, ViewResult, } from './client.js';
+export type { AppInfo, AppXcalls, BlobContent, BlobInfo, DeadLetter, Deployer, DeployerGrant, DeployersInfo, DeploymentInfo, DeploymentOffer, DeploymentOrgs, FrontendManifest, MeInfo, PackageOrigin, PackageOriginAdded, PackageOriginRemoved, PackageOrigins, SignInOptions, PublicDeployment, CallResult, CalimeroClientOptions, CalimeroConnectOptions, CloudEvent, CalimeroSession, PackageInfo, PackageInstalled, CloudRetryOptions, OrgInfo, OrgUpgradeTarget, PresenceEntry, UpgradeRun, ViewResult, } from './client.js';
 export { claimedRelease, fetchAttestedKey, freshCollateral, MOCK_QUOTE_HEADER } from './attestation.js';
 export type { AttestationDoc, CloudPolicy, CloudReleasePolicy } from './attestation.js';
 export { browserPasskey, b64url, fromB64url } from './passkey.js';

package/dist/cloud-v2/index.js

@@ -1,6 +1,6 @@
 export { CalimeroClient, deployerKey, frontendManifest, pageDeployment } from './client.js';
 export { DEFAULT_DIRECTORY, DirectoryError } from './directory.js';
-export { AppError, ArgsTooLarge, CalimeroError, ConfirmCancelled, ConfirmRequired, IdempotencyMismatch, LoginRequired, ConsentStale, NotFound, ReleaseDeadlineError, TrapError, UnavailableError, WrongNode, errorFrom, } from './errors.js';
+export { AppError, ArgsTooLarge, BadOrigin, CalimeroError, ConfirmCancelled, ConfirmRequired, IdempotencyMismatch, LoginRequired, ConsentStale, NotFound, OriginNotRegistered, OriginTaken, QuotaExceeded, ReleaseDeadlineError, TrapError, UnavailableError, WrongNode, errorFrom, } from './errors.js';
 export { claimedRelease, fetchAttestedKey, freshCollateral, MOCK_QUOTE_HEADER } from './attestation.js';
 export { browserPasskey, b64url, fromB64url } from './passkey.js';
 export { MAX_REPORT_PAGE, RELEASE_VERIFIER, compareVersions, confirmationCode, consentReturn, pageQuery, pendingApprovalsFrom, publisherBindingBytes, publisherBindingMessage, releaseConsent, releaseNotesUrl, stalledBy, upgradeConsent, verifyReleaseUrl, withdrawConsent, } from './approvals.js';