@mdbase-dev/connect 0.1.0-beta.30 → 0.1.0-beta.32

package/dist/outcomes.js

@@ -3,12 +3,15 @@ import { MdbaseConnectError, unknownConnectProblem } from "./errors.js";
 export const COMMON_OPERATION_PROBLEM_CODES = [
     "access_denied",
     "access_paused",
+    "authorization_binding_incompatible",
     "authorization_expired",
+    "capability_contract_incompatible",
     "collection_access_denied",
     "connector_identity_changed",
     "connector_offline",
     "connector_upgrade_required",
     "direct_operation_rejected",
+    "durable_mutation_unsupported",
     "operation_outcome_unknown",
     "encryption_required",
     "encrypted_relay_rejected",
@@ -18,6 +21,8 @@ export const COMMON_OPERATION_PROBLEM_CODES = [
     "invalid_operation_response",
     "invalid_request",
     "missing_grant_key",
+    "mutation_recovery_expired",
+    "mutation_request_conflict",
     "not_authorized",
     "operation_cancelled",
     "operation_failed",
@@ -26,11 +31,13 @@ export const COMMON_OPERATION_PROBLEM_CODES = [
     "relay_unavailable",
     "temporarily_unavailable",
     "timeout",
+    "transport_protocol_incompatible",
     "unsupported_operation"
 ];
 export const ALL_CONNECT_PROBLEM_CODES = Object.keys(CONNECT_PROBLEM_CATALOG);
 export const REGISTRATION_PROBLEM_CODES = [
     "discovery_failed",
+    "invalid_operation_response",
     "invalid_application_manifest",
     "invalid_request",
     "manifest_load_failed",
@@ -43,9 +50,11 @@ export const AUTHORIZATION_PROBLEM_CODES = [
     "access_denied",
     "application_identity_unavailable",
     "approval_window_blocked",
+    "authorization_binding_incompatible",
     "authorization_cancelled",
     "authorization_replayed",
     "browser_required",
+    "capability_contract_incompatible",
     "collection_access_denied",
     "collection_configuration_invalid",
     "collection_contracts_missing",
@@ -60,6 +69,7 @@ export const AUTHORIZATION_PROBLEM_CODES = [
     "connector_offline",
     "connector_upgrade_required",
     "device_authorization_failed",
+    "durable_mutation_unsupported",
     "encryption_required",
     "expired_token",
     "invalid_application_authorization",
@@ -68,11 +78,13 @@ export const AUTHORIZATION_PROBLEM_CODES = [
     "invalid_token_response",
     "scope_denied",
     "reconnect_required",
-    "token_exchange_failed"
+    "token_exchange_failed",
+    "transport_protocol_incompatible"
 ];
 export const NOTIFICATION_PROBLEM_CODES = [
     ...REGISTRATION_PROBLEM_CODES,
     "authorization_expired",
+    "invalid_operation_response",
     "invalid_push_subscription",
     "managed_fcm_not_declared",
     "not_authorized",

package/dist/pending-mutation-store.d.ts

@@ -0,0 +1,13 @@
+import { type MutationOperationIdentifier } from "@mdbase-dev/connect-protocol";
+import type { PendingMutation } from "./internal-types.js";
+export declare class PendingMutationStore {
+    private readonly storage;
+    private readonly baseKey;
+    constructor(storage: Storage, baseKey: string);
+    list(collectionId: string | null): PendingMutation[];
+    find(collectionId: string | null, requestId: string): PendingMutation | null;
+    identifier(pending: PendingMutation): MutationOperationIdentifier;
+    store(pending: PendingMutation): void;
+    take(requestId: string): PendingMutation | null;
+    private key;
+}

package/dist/pending-mutation-store.js

@@ -0,0 +1,64 @@
+import { isCollectionOperation, mutationOperationIdentifier } from "@mdbase-dev/connect-protocol";
+import { parseStored } from "./runtime-utils.js";
+export class PendingMutationStore {
+    storage;
+    baseKey;
+    constructor(storage, baseKey) {
+        this.storage = storage;
+        this.baseKey = baseKey;
+    }
+    list(collectionId) {
+        if (!collectionId)
+            return [];
+        const legacy = parseStored(this.storage.getItem(this.baseKey));
+        if (validPendingMutation(legacy) && legacy.collectionId === collectionId) {
+            const migratedKey = this.key(legacy.requestId);
+            if (!this.storage.getItem(migratedKey)) {
+                this.storage.setItem(migratedKey, JSON.stringify(legacy));
+            }
+            this.storage.removeItem(this.baseKey);
+        }
+        const keys = [];
+        for (let index = 0; index < this.storage.length; index += 1) {
+            const key = this.storage.key(index);
+            if (key?.startsWith(`${this.baseKey}:`))
+                keys.push(key);
+        }
+        return keys
+            .map((key) => parseStored(this.storage.getItem(key)))
+            .filter((pending) => validPendingMutation(pending) && pending.collectionId === collectionId)
+            .sort((left, right) => left.createdAt - right.createdAt
+            || left.requestId.localeCompare(right.requestId));
+    }
+    find(collectionId, requestId) {
+        return this.list(collectionId)
+            .find((pending) => pending.requestId === requestId) ?? null;
+    }
+    identifier(pending) {
+        return pending.mutation ?? mutationOperationIdentifier(pending.operation, pending.request?.input ?? (pending.operation === "sync" ? { action: "mutate" } : {})) ?? (pending.operation === "sync" ? "sync:mutate" : pending.operation);
+    }
+    store(pending) {
+        this.storage.setItem(this.key(pending.requestId), JSON.stringify(pending));
+    }
+    take(requestId) {
+        const key = this.key(requestId);
+        const pending = parseStored(this.storage.getItem(key));
+        this.storage.removeItem(key);
+        return pending;
+    }
+    key(requestId) {
+        return `${this.baseKey}:${encodeURIComponent(requestId)}`;
+    }
+}
+function validPendingMutation(pending) {
+    return Boolean(pending
+        && typeof pending.collectionId === "string"
+        && typeof pending.requestId === "string"
+        && pending.requestId.length > 0
+        && isCollectionOperation(pending.operation)
+        && typeof pending.inputFingerprint === "string"
+        && Number.isFinite(pending.createdAt)
+        && pending.createdAt > 0
+        && (pending.envelope || pending.request)
+        && (pending.operation === "sync" || mutationOperationIdentifier(pending.operation, pending.request?.input ?? {}) !== null));
+}

package/dist/request-budget.d.ts

@@ -0,0 +1,27 @@
+import type { ConnectRequestOptions } from "./operation-types.js";
+import type { MdbaseConnectTimeouts } from "./connect-options.js";
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+export declare const DEFAULT_STARTUP_TIMEOUT_MS = 10000;
+export declare const DEFAULT_UPLOAD_TIMEOUT_MS = 120000;
+export declare const DEFAULT_SYNC_TIMEOUT_MS = 60000;
+export interface ResolvedConnectTimeouts {
+    requestMs: number | null;
+    watchStartMs: number | null;
+    uploadMs: number | null;
+    syncMs: number | null;
+}
+export declare function resolveConnectTimeouts(timeouts?: MdbaseConnectTimeouts): ResolvedConnectTimeouts;
+export interface RequestBudget {
+    readonly signal: AbortSignal;
+    readonly deadline: number | null;
+    remainingMs(): number | null;
+    dispose(): void;
+}
+export declare function createRequestBudget(options?: ConnectRequestOptions, defaultTimeoutMs?: number | null, now?: () => number): RequestBudget;
+export declare function withRequestBudget<Result>(options: ConnectRequestOptions | undefined, defaultTimeoutMs: number | null, operation: (budget: RequestBudget) => Promise<Result>): Promise<Result>;
+/**
+ * Budget an operation whose transport cooperates with AbortSignal and must run
+ * its own bounded cleanup/recovery before the public promise settles.
+ */
+export declare function withCooperativeRequestBudget<Result>(options: ConnectRequestOptions | undefined, defaultTimeoutMs: number | null, operation: (budget: RequestBudget) => Promise<Result>): Promise<Result>;
+export declare function requestAbortReason(signal: AbortSignal): unknown;

package/dist/request-budget.js

@@ -0,0 +1,95 @@
+import { MdbaseConnectError, connectError } from "./errors.js";
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+export const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
+export const DEFAULT_UPLOAD_TIMEOUT_MS = 120_000;
+export const DEFAULT_SYNC_TIMEOUT_MS = 60_000;
+export function resolveConnectTimeouts(timeouts = {}) {
+    return {
+        requestMs: configuredTimeout(timeouts.requestMs, DEFAULT_REQUEST_TIMEOUT_MS, "requestMs"),
+        watchStartMs: configuredTimeout(timeouts.watchStartMs, DEFAULT_STARTUP_TIMEOUT_MS, "watchStartMs"),
+        uploadMs: configuredTimeout(timeouts.uploadMs, DEFAULT_UPLOAD_TIMEOUT_MS, "uploadMs"),
+        syncMs: configuredTimeout(timeouts.syncMs, DEFAULT_SYNC_TIMEOUT_MS, "syncMs")
+    };
+}
+export function createRequestBudget(options = {}, defaultTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, now = Date.now) {
+    const configured = options.timeoutMs === undefined ? defaultTimeoutMs : options.timeoutMs;
+    const timeoutMs = configured === null ? null : validTimeout(configured);
+    const controller = new AbortController();
+    const deadline = timeoutMs === null ? null : now() + timeoutMs;
+    const abortFromCaller = () => controller.abort(options.signal?.reason);
+    if (options.signal?.aborted)
+        abortFromCaller();
+    else
+        options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+    const timer = timeoutMs === null
+        ? undefined
+        : setTimeout(() => controller.abort(connectError("timeout", "The operation exceeded its request deadline.", { operationOutcome: "not_sent" })), timeoutMs);
+    let disposed = false;
+    return {
+        signal: controller.signal,
+        deadline,
+        remainingMs: () => deadline === null ? null : Math.max(0, deadline - now()),
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abortFromCaller);
+        }
+    };
+}
+export async function withRequestBudget(options, defaultTimeoutMs, operation) {
+    const budget = createRequestBudget(options, defaultTimeoutMs);
+    let rejectOnAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        rejectOnAbort = reject;
+    });
+    const abort = () => rejectOnAbort?.(requestAbortReason(budget.signal));
+    budget.signal.addEventListener("abort", abort, { once: true });
+    try {
+        if (budget.signal.aborted)
+            throw requestAbortReason(budget.signal);
+        return await Promise.race([operation(budget), aborted]);
+    }
+    finally {
+        budget.signal.removeEventListener("abort", abort);
+        budget.dispose();
+    }
+}
+/**
+ * Budget an operation whose transport cooperates with AbortSignal and must run
+ * its own bounded cleanup/recovery before the public promise settles.
+ */
+export async function withCooperativeRequestBudget(options, defaultTimeoutMs, operation) {
+    const budget = createRequestBudget(options, defaultTimeoutMs);
+    try {
+        if (budget.signal.aborted)
+            throw requestAbortReason(budget.signal);
+        return await operation(budget);
+    }
+    finally {
+        budget.dispose();
+    }
+}
+export function requestAbortReason(signal) {
+    if (signal.reason instanceof MdbaseConnectError)
+        return signal.reason;
+    return connectError("operation_cancelled", "The operation was cancelled before it changed the collection.", { operationOutcome: "not_sent", cause: signal.reason });
+}
+function validTimeout(value) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError("timeoutMs must be a positive safe integer or null.");
+    }
+    return value;
+}
+function configuredTimeout(value, fallback, name) {
+    if (value === undefined)
+        return fallback;
+    if (value === null)
+        return null;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError(`${name} must be a positive safe integer or null.`);
+    }
+    return value;
+}

package/dist/runtime-utils.d.ts

@@ -5,6 +5,8 @@ import type { MdbaseDeviceAuthorization } from "./authorization-types.js";
 type NetworkProblemCode = "notification_registration_failed" | "notification_unregistration_failed" | "notifications_unavailable" | "temporarily_unavailable";
 /** Normalize fetch rejection at the exact I/O boundary. */
 export declare function connectFetch(input: RequestInfo | URL, init: RequestInit | undefined, code: NetworkProblemCode, message: string): Promise<Response>;
+/** Decode JSON without allowing native syntax/body errors across the SDK boundary. */
+export declare function decodeJsonResponse(response: Response, code: string, message: string): Promise<any>;
 export declare function canonicalLoopbackUrl(value: string): string;
 export declare function createPkce(): Promise<{
     verifier: string;

package/dist/runtime-utils.js

@@ -11,6 +11,25 @@ export async function connectFetch(input, init, code, message) {
         throw connectError(code, message, { cause });
     }
 }
+/** Decode JSON without allowing native syntax/body errors across the SDK boundary. */
+export async function decodeJsonResponse(response, code, message) {
+    let text;
+    try {
+        text = await response.text();
+    }
+    catch (cause) {
+        throw serverConnectError(code, message, { status: response.status, cause });
+    }
+    if (text.trim() === "") {
+        throw serverConnectError(code, message, { status: response.status });
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (cause) {
+        throw serverConnectError(code, message, { status: response.status, cause });
+    }
+}
 export function canonicalLoopbackUrl(value) {
     const url = new URL(value);
     if (url.protocol !== "http:"

package/dist/session.d.ts

@@ -3,9 +3,10 @@ import { MdbaseConnection, type MdbaseAuthorizationOutcome, type MdbaseAuthoriza
 import type { MdbaseAuthorizationCapabilities, MdbaseConnectionInfo } from "./connection-types.js";
 import { type AuthorizationProblemCode, type ConnectOutcome, type SessionProblemCode } from "./outcomes.js";
 import type { MdbaseSelectionHistory, MdbaseApplicationSelection } from "./selection.js";
+import type { ConnectRequestOptions } from "./operation-types.js";
 export interface MdbaseSessionConnect<Frontmatter extends JsonObject> {
     authorize(options?: MdbaseAuthorizeOptions): Promise<ConnectOutcome<MdbaseAuthorizationOutcome<Frontmatter>, AuthorizationProblemCode>>;
-    completeAuthorization(callbackUrl: string): Promise<ConnectOutcome<MdbaseAuthorizationResult<Frontmatter>, AuthorizationProblemCode>>;
+    completeAuthorization(callbackUrl: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseAuthorizationResult<Frontmatter>, AuthorizationProblemCode>>;
     connections(): MdbaseConnectionInfo[];
     connection(collectionId: string): MdbaseConnection<Frontmatter> | null;
     unavailableReason(collectionId: string): MdbaseUnavailableReason | null;
@@ -52,7 +53,7 @@ export declare class MdbaseSession<Frontmatter extends JsonObject = JsonObject>
     private transactionDepth;
     private callbackPromise;
     constructor(connect: MdbaseSessionConnect<Frontmatter>, options: MdbaseSessionOptions);
-    start(): Promise<ConnectOutcome<MdbaseSessionSnapshot<Frontmatter>, SessionProblemCode>>;
+    start(options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseSessionSnapshot<Frontmatter>, SessionProblemCode>>;
     destroy(): void;
     getSnapshot(): MdbaseSessionSnapshot<Frontmatter>;
     subscribe(listener: () => void): () => void;
@@ -70,7 +71,7 @@ export declare class MdbaseSession<Frontmatter extends JsonObject = JsonObject>
         kind: "unchanged";
         connection: MdbaseConnection<Frontmatter>;
     }, SessionProblemCode>>;
-    handleAuthorizationCallback(callbackUrl: string): Promise<ConnectOutcome<MdbaseConnection<Frontmatter>, AuthorizationProblemCode>>;
+    handleAuthorizationCallback(callbackUrl: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseConnection<Frontmatter>, AuthorizationProblemCode>>;
     private autoSelectOnlyConnection;
     private refresh;
     private refreshOnce;

package/dist/session.js

@@ -29,7 +29,7 @@ export class MdbaseSession {
         this.snapshot = { status: "unselected", connections: [] };
         this.refresh();
     }
-    async start() {
+    async start(options) {
         if (!this.started) {
             this.started = true;
             this.stopConnections = this.connect.onConnectionsChange(() => this.refresh());
@@ -40,7 +40,7 @@ export class MdbaseSession {
         }
         const callback = this.selection.authorizationCallback();
         if (callback) {
-            const completed = await this.handleAuthorizationCallback(callback);
+            const completed = await this.handleAuthorizationCallback(callback, options);
             if (!completed.ok)
                 return completed;
         }
@@ -151,14 +151,14 @@ export class MdbaseSession {
             this.refresh();
         }
     }
-    handleAuthorizationCallback(callbackUrl) {
+    handleAuthorizationCallback(callbackUrl, options) {
         if (!isAuthorizationCallbackUrl(callbackUrl)) {
             return Promise.resolve(connectFailure(connectProblem("invalid_callback", "This URL is not an authorization callback.")));
         }
         if (this.callbackPromise)
             return this.callbackPromise;
         this.transactionDepth += 1;
-        const completion = this.connect.completeAuthorization(callbackUrl)
+        const completion = this.connect.completeAuthorization(callbackUrl, options)
             .then((outcome) => {
             if (!outcome.ok) {
                 const returnTo = authorizationReturnToFromProblem(outcome.problem);

package/dist/stored-token.d.ts

@@ -0,0 +1,10 @@
+import type { StoredToken } from "./internal-types.js";
+interface ReadStoredTokenOptions {
+    stored: string | null;
+    collectionId: string;
+    relayEncryption: "required" | "disabled";
+    invalidate(keyHandle?: string): void;
+    directCapable(token: StoredToken): boolean;
+}
+export declare function readStoredToken({ stored, collectionId, relayEncryption, invalidate, directCapable }: ReadStoredTokenOptions): StoredToken | null;
+export {};

package/dist/stored-token.js

@@ -0,0 +1,60 @@
+import { parseGrantScope, parseStored, validFileCapability, validStoredAuthority, validStoredEncryption } from "./runtime-utils.js";
+export function readStoredToken({ stored, collectionId, relayEncryption, invalidate, directCapable }) {
+    const token = parseStored(stored);
+    const reject = (keyHandle) => {
+        invalidate(typeof keyHandle === "string" ? keyHandle : undefined);
+        return null;
+    };
+    if (!token) {
+        if (stored)
+            reject();
+        return null;
+    }
+    if (token.version !== 1
+        || typeof token.accessToken !== "string"
+        || token.accessToken.length === 0
+        || typeof token.clientId !== "string"
+        || token.clientId.length === 0
+        || token.collectionId !== collectionId
+        || typeof token.collectionName !== "string"
+        || token.collectionName.length === 0
+        || !Array.isArray(token.operations)
+        || token.operations.some((operation) => typeof operation !== "string")
+        || typeof token.expiresAt !== "number"
+        || !Number.isFinite(token.expiresAt)
+        || (token.refreshToken !== undefined
+            && (typeof token.refreshToken !== "string" || token.refreshToken.length === 0))
+        || (token.refreshExpiresAt !== undefined
+            && (typeof token.refreshExpiresAt !== "number" || !Number.isFinite(token.refreshExpiresAt))))
+        return reject(token.keyHandle);
+    if (!parseGrantScope(token.scope))
+        return reject(token.keyHandle);
+    if (token.fileCapability && !validFileCapability(token.fileCapability)) {
+        return reject(token.keyHandle);
+    }
+    if (token.authority && !validStoredAuthority(token.authority, token.collectionId)) {
+        return reject(token.keyHandle);
+    }
+    if (relayEncryption === "required") {
+        if (token.authority) {
+            if (!token.keyHandle || !token.authority.proofPublicKey) {
+                return reject(token.keyHandle);
+            }
+        }
+        else if (!token.grantId
+            || !token.keyHandle
+            || !validStoredEncryption(token.encryption, token.collectionId)) {
+            return reject(token.keyHandle);
+        }
+    }
+    if (token.expiresAt <= Date.now()
+        && (!token.refreshToken || (token.refreshExpiresAt ?? 0) <= Date.now())) {
+        // The cloud bearer and local grant proof have separate lifetimes. Keep an
+        // encrypted local grant usable while the connector still recognizes it.
+        if (directCapable(token))
+            return token;
+        invalidate(token.keyHandle);
+        return null;
+    }
+    return token;
+}

package/dist/token-response.d.ts

@@ -0,0 +1,11 @@
+import type { StoredToken } from "./internal-types.js";
+interface StoredTokenResponseOptions {
+    body: any;
+    clientId: string;
+    keyHandle?: string;
+    previous: StoredToken | null;
+    defaultApplicationOrigin: string;
+    pinConnectorIdentity(connectorId: string, publicKey: string): void;
+}
+export declare function storedTokenFromResponse({ body, clientId, keyHandle, previous, defaultApplicationOrigin, pinConnectorIdentity }: StoredTokenResponseOptions): StoredToken;
+export {};

package/dist/token-response.js

@@ -0,0 +1,77 @@
+import { validateGrantEncryption } from "./crypto.js";
+import { connectError } from "./errors.js";
+import { parseGrantScope, validAuthorityTokenResponse, validFileCapability } from "./runtime-utils.js";
+export function storedTokenFromResponse({ body, clientId, keyHandle, previous, defaultApplicationOrigin, pinConnectorIdentity }) {
+    const collectionId = body.collection_id;
+    if (typeof collectionId !== "string") {
+        throw connectError("invalid_token_response", "Authorization returned no collection ID.");
+    }
+    const scope = parseGrantScope(body.scope);
+    if (!scope) {
+        throw connectError("invalid_token_response", "Authorization returned no valid collection scope.");
+    }
+    if (body.authority && !validAuthorityTokenResponse(body.authority, collectionId)) {
+        throw connectError("invalid_token_response", "Authorization returned an invalid remote authority capability.");
+    }
+    if (body.authority && body.encryption) {
+        throw connectError("invalid_token_response", "Authorization returned conflicting collection transports.");
+    }
+    if (body.file_capability !== null && body.file_capability !== undefined
+        && !validFileCapability(body.file_capability)) {
+        throw connectError("invalid_token_response", "Authorization returned an invalid file capability.");
+    }
+    if (body.encryption) {
+        try {
+            validateGrantEncryption(body.encryption);
+        }
+        catch {
+            throw connectError("invalid_token_response", "Authorization returned an invalid encrypted relay binding.");
+        }
+        pinConnectorIdentity(body.encryption.connector_id, body.encryption.connector_agreement_public_key);
+        if (body.encryption.collection_id !== collectionId
+            || typeof body.grant_id !== "string"
+            || body.grant_id.length === 0) {
+            throw connectError("invalid_token_response", "Authorization returned an encrypted relay binding for another grant.");
+        }
+    }
+    if (previous?.encryption
+        && body.encryption
+        && previous.keyHandle
+        && previous.keyHandle === keyHandle
+        && (previous.grantId !== body.grant_id
+            || previous.encryption.connector_id !== body.encryption.connector_id
+            || previous.encryption.connector_agreement_public_key
+                !== body.encryption.connector_agreement_public_key
+            || previous.encryption.application_agreement_public_key
+                !== body.encryption.application_agreement_public_key)) {
+        throw connectError("connector_identity_changed", "The connector identity changed during authorization renewal. Reauthorize before sending collection data.");
+    }
+    return {
+        version: 1,
+        accessToken: body.access_token,
+        refreshToken: body.refresh_token,
+        clientId,
+        collectionId,
+        collectionName: body.collection_name ?? `Collection ${collectionId.slice(0, 8)}`,
+        operations: body.operations,
+        scope,
+        expiresAt: Date.now() + body.expires_in * 1_000,
+        refreshExpiresAt: body.refresh_expires_in
+            ? Date.now() + body.refresh_expires_in * 1_000
+            : undefined,
+        grantId: body.grant_id,
+        encryption: body.encryption ?? undefined,
+        fileCapability: body.file_capability ?? undefined,
+        applicationOrigin: body.application_origin ?? defaultApplicationOrigin,
+        keyHandle,
+        savedAt: Date.now(),
+        authority: body.authority ? {
+            operationsUrl: body.authority.operations_url,
+            syncUrl: body.authority.sync_url,
+            filesUrl: body.authority.files_url,
+            replicaId: body.authority.replica_id,
+            accessToken: body.authority.access_token,
+            proofPublicKey: body.authority.proof_public_key
+        } : undefined
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mdbase-dev/connect",
-  "version": "0.1.0-beta.30",
+  "version": "0.1.0-beta.32",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -18,6 +18,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./advanced": {
+      "types": "./dist/advanced.d.ts",
+      "import": "./dist/advanced.js"
+    },
+    "./crypto": {
+      "types": "./dist/crypto-entry.d.ts",
+      "import": "./dist/crypto-entry.js"
     }
   },
   "files": [
@@ -25,7 +33,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@mdbase-dev/connect-protocol": "0.1.0-beta.30"
+    "@mdbase-dev/connect-protocol": "0.1.0-beta.32"
   },
   "devDependencies": {
     "esbuild": "^0.28.1",
@@ -36,6 +44,8 @@
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && node scripts/build-browser.mjs",
     "test": "vitest run",
     "test:browser-storage": "pnpm build && node scripts/browser-storage.test.mjs",
+    "test:consumer-spikes": "tsc -p tsconfig.consumer-spikes.json",
+    "test:public-api": "pnpm build && tsc -p tsconfig.public-api.json",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   }
 }