@mdbase-dev/connect 0.1.0-beta.100

package/dist/shared-operation.js

@@ -0,0 +1,41 @@
+import { requestAbortReason, withRequestBudget } from "./request-budget.js";
+export class SharedOperationMap {
+    operations = new Map();
+    run(key, options, defaultTimeoutMs, start) {
+        if (options?.signal?.aborted)
+            return Promise.reject(requestAbortReason(options.signal));
+        const operation = this.operations.get(key) ?? this.begin(key, start);
+        return this.wait(key, operation, options, defaultTimeoutMs);
+    }
+    begin(key, start) {
+        const controller = new AbortController();
+        const operation = {
+            controller,
+            waiters: 0,
+            settled: false,
+            promise: undefined
+        };
+        operation.promise = Promise.resolve()
+            .then(() => start(controller.signal))
+            .finally(() => {
+            operation.settled = true;
+            if (this.operations.get(key) === operation)
+                this.operations.delete(key);
+        });
+        this.operations.set(key, operation);
+        return operation;
+    }
+    async wait(key, operation, options, defaultTimeoutMs) {
+        operation.waiters += 1;
+        try {
+            return await withRequestBudget(options, defaultTimeoutMs, () => operation.promise);
+        }
+        finally {
+            operation.waiters -= 1;
+            if (operation.waiters === 0 && !operation.settled && this.operations.get(key) === operation) {
+                this.operations.delete(key);
+                operation.controller.abort();
+            }
+        }
+    }
+}

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, reason?: "invalid_stored_grant" | "legacy_scope_reauthorization_required"): 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,64 @@
+import { isCanonicalGrantScope, parseGrantScope, parseStored, validFileCapability, validStoredAuthority, validStoredEncryption } from "./runtime-utils.js";
+export function readStoredToken({ stored, collectionId, relayEncryption, invalidate, directCapable }) {
+    const token = parseStored(stored);
+    const reject = (keyHandle, reason = "invalid_stored_grant") => {
+        invalidate(typeof keyHandle === "string" ? keyHandle : undefined, reason);
+        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);
+    const scope = parseGrantScope(token.scope);
+    if (!scope)
+        return reject(token.keyHandle);
+    if (!isCanonicalGrantScope(scope)) {
+        return reject(token.keyHandle, "legacy_scope_reauthorization_required");
+    }
+    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/structured-readiness.d.ts

@@ -0,0 +1,77 @@
+import type { ContractRequirement, FileAction, JsonObject } from "@mdbase-dev/connect-protocol";
+import type { MdbaseApplicationManifest } from "./application-contract.js";
+import type { MdbaseConnectionInfo } from "./connection-types.js";
+import { type MdbaseEffectiveCapabilities, type MdbaseCapabilityEvidence } from "./capabilities.js";
+import type { MdbaseConnection } from "./connection.js";
+import type { ConnectRequestOptions } from "./operation-types.js";
+type ReadinessPublication = {
+    status: "authorization_required";
+} | {
+    status: "blocked";
+    problem: {
+        code: string;
+        message: string;
+    };
+};
+/** Live verification owns no session state; callers supply identity and cancellation guards. */
+export declare function verifyStructuredReadiness<Frontmatter extends JsonObject>(input: {
+    collectionId: string;
+    readiness: MdbaseStructuredReadiness;
+    contracts: ContractRequirement[];
+    connection: MdbaseConnection<Frontmatter>;
+    controller: AbortController;
+    options?: ConnectRequestOptions;
+    requestMs: number | null;
+    isCurrent: () => boolean;
+    publish: (result: ReadinessPublication) => void;
+}): Promise<boolean>;
+export declare function publishedStructuredReadiness(source: MdbaseStructuredReadiness, status: string, verification?: "cached" | "verified"): MdbaseStructuredReadiness;
+export interface ApplicationSessionContext {
+    collectionId: string;
+    info: MdbaseConnectionInfo;
+    capabilities: MdbaseEffectiveCapabilities;
+    /** Present only for semantic contract v2. */
+    readiness?: MdbaseStructuredReadiness;
+    connections: MdbaseConnectionInfo[];
+}
+export declare function applicationReadinessContext(manifest: MdbaseApplicationManifest, collectionId: string, info: MdbaseConnectionInfo, connections: MdbaseConnectionInfo[]): ApplicationSessionContext;
+export declare function verificationKey(manifest: MdbaseApplicationManifest, collectionId: string): string;
+export declare function verificationValue(manifest: MdbaseApplicationManifest): string;
+export declare function collectionSetupInput(manifest: MdbaseApplicationManifest, applicationId: string, declarationDigest: string, typePackAdoptions?: Record<string, Record<string, string>>): {
+    applicationId: string;
+    declarationDigest: string;
+    requirements: {
+        configuration: import("@mdbase-dev/connect-protocol").ConfigurationRequirement[];
+    };
+    provisions: {
+        configuration: import("@mdbase-dev/connect-protocol").ConfigurationProvision[];
+        typePacks: import("@mdbase-dev/connect-protocol").TypePackProvision[];
+    };
+    typePackAdoptions?: Record<string, Record<string, string>> | undefined;
+};
+/** Independent v2 declarations; never legacy capability aliases. */
+export interface MdbaseStructuredReadiness {
+    files: {
+        state: "not_required" | "available" | "requires_authorization";
+        missingRequiredActions: FileAction[];
+        missingOptionalActions: FileAction[];
+        scopeMatches: boolean;
+        evidence: MdbaseCapabilityEvidence[];
+    };
+    contracts: {
+        state: "not_required" | "checking" | "verified" | "requires_setup" | "requires_authorization" | "temporarily_unavailable";
+        missing: ContractRequirement[];
+        evidence: MdbaseCapabilityEvidence[];
+    };
+    setup: {
+        state: "not_required" | "checking" | "review_required" | "current" | "cached" | "blocked" | "requires_authorization";
+        evidence: MdbaseCapabilityEvidence[];
+    };
+    notifications: {
+        state: "not_required" | "requires_registration";
+        registration: "unverified";
+        evidence: MdbaseCapabilityEvidence[];
+    };
+}
+export declare function structuredReadiness(manifest: MdbaseApplicationManifest, info: MdbaseConnectionInfo): MdbaseStructuredReadiness;
+export {};

package/dist/structured-readiness.js

@@ -0,0 +1,126 @@
+/* The versioned protocol package is the sole capability-to-operation compiler. */
+import { effectiveCapabilities } from "./capabilities.js";
+import { MdbaseConnectError } from "./errors.js";
+import { withRequestBudget } from "./request-budget.js";
+/** Live verification owns no session state; callers supply identity and cancellation guards. */
+export async function verifyStructuredReadiness(input) {
+    const { collectionId, readiness, contracts, connection, controller, options, requestMs, isCurrent, publish } = input;
+    const abort = () => controller.abort(options?.signal?.reason);
+    if (options?.signal?.aborted)
+        abort();
+    else
+        options?.signal?.addEventListener("abort", abort, { once: true });
+    try {
+        const outcome = await withRequestBudget({ ...options, signal: controller.signal }, requestMs, request => connection.describe(request));
+        if (!isCurrent())
+            return false;
+        if (!outcome.ok) {
+            const authorizationRequired = ["access_denied", "collection_access_denied", "insufficient_access", "not_authorized", "authorization_expired", "application_declaration_mismatch"].includes(outcome.problem.code);
+            readiness.contracts = { state: authorizationRequired ? "requires_authorization" : "temporarily_unavailable", missing: [], evidence: [{ source: "runtime", fact: outcome.problem.message }] };
+            publish(authorizationRequired
+                ? { status: "authorization_required" }
+                : { status: "blocked", problem: outcome.problem });
+            return false;
+        }
+        if (outcome.value.collectionId !== collectionId) {
+            readiness.contracts = { state: "temporarily_unavailable", missing: [], evidence: [] };
+            publish({ status: "blocked", problem: { code: "collection_not_ready", message: "Description belongs to a different collection." } });
+            return false;
+        }
+        const missing = contracts.filter(required => !outcome.value.contracts.some(actual => actual.id === required.id && actual.version === required.version && actual.digest === required.digest));
+        readiness.contracts = { state: missing.length ? "requires_setup" : "verified", missing,
+            evidence: [{ source: "authority", fact: "Exact contract ID, version and digest checked by live describe for this collection." }] };
+        if (missing.length) {
+            publish({ status: "blocked", problem: { code: "collection_not_ready", message: "The collection is missing required exact contracts." } });
+            return false;
+        }
+    }
+    catch (error) {
+        if (!isCurrent())
+            return false;
+        if (!(error instanceof MdbaseConnectError))
+            throw error;
+        readiness.contracts = { state: "temporarily_unavailable", missing: [], evidence: [{ source: "runtime", fact: error.problem.message }] };
+        publish({ status: "blocked", problem: error.problem });
+        return false;
+    }
+    finally {
+        options?.signal?.removeEventListener("abort", abort);
+    }
+    return true;
+}
+export function publishedStructuredReadiness(source, status, verification) {
+    const readiness = structuredClone(source);
+    if (readiness.setup.state !== "not_required" && readiness.setup.state !== "current") {
+        readiness.setup.state = status === "ready" ? (verification === "cached" ? "cached" : "current")
+            : status === "setup_review_required" ? "review_required"
+                : status === "authorization_required" ? "requires_authorization"
+                    : status === "blocked" ? "blocked" : "checking";
+        readiness.setup.evidence = [{ source: status === "ready" && verification === "cached" ? "runtime" : "authority",
+                fact: `Collection setup verification: ${readiness.setup.state}.` }];
+    }
+    return readiness;
+}
+export function applicationReadinessContext(manifest, collectionId, info, connections) {
+    return {
+        collectionId, info,
+        capabilities: effectiveCapabilities(manifest.requirements.capabilities, manifest, info),
+        ...(manifest.requirements?.capabilities?.contract_version === 2
+            ? { readiness: structuredReadiness(manifest, info) } : {}),
+        connections
+    };
+}
+export function verificationKey(manifest, collectionId) {
+    return `mdbase-application-session:v1:${manifest.id}:${collectionId}`;
+}
+export function verificationValue(manifest) {
+    return JSON.stringify({
+        capabilities: manifest.requirements?.capabilities,
+        requirements: manifest.requirements?.configuration ?? [],
+        provisions: manifest.provisions ?? {}
+    });
+}
+export function collectionSetupInput(manifest, applicationId, declarationDigest, typePackAdoptions) {
+    return {
+        applicationId, declarationDigest,
+        requirements: { configuration: manifest.requirements?.configuration ?? [] },
+        provisions: {
+            configuration: manifest.provisions?.configuration ?? [],
+            typePacks: manifest.provisions?.type_packs ?? []
+        },
+        ...(typePackAdoptions ? { typePackAdoptions } : {})
+    };
+}
+function sameScope(left, right) {
+    if (!right || left.kind !== right.kind)
+        return false;
+    if (left.kind === "collection" || right.kind === "collection")
+        return true;
+    const a = [...new Set(left.folders)].sort();
+    const b = [...new Set(right.folders)].sort();
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+export function structuredReadiness(manifest, info) {
+    const files = manifest.requirements?.files;
+    const requirement = files && "required" in files ? files : undefined;
+    const scopeMatches = !requirement || sameScope(requirement.scope, info.fileCapability?.scope);
+    const missing = (actions) => actions.filter(action => !scopeMatches || !info.fileCapability?.actions.includes(action));
+    const missingRequiredActions = missing(requirement?.required ?? []);
+    const missingOptionalActions = missing(requirement?.optional ?? []);
+    const contracts = manifest.requirements?.contracts ?? [];
+    const setup = (manifest.provisions?.type_packs.length ?? 0) > 0 || (manifest.provisions?.configuration?.length ?? 0) > 0;
+    return {
+        files: {
+            state: !requirement ? "not_required" : missingRequiredActions.length ? "requires_authorization" : "available",
+            missingRequiredActions, missingOptionalActions, scopeMatches,
+            evidence: [{ source: "authorization", fact: "Compared exact file actions and folder scope with connection.info().fileCapability." }]
+        },
+        contracts: { state: contracts.length ? "checking" : "not_required", missing: [], evidence: [] },
+        setup: { state: setup ? "checking" : "not_required", evidence: [] },
+        notifications: {
+            state: manifest.notifications?.criteria.length ? "requires_registration" : "not_required",
+            registration: "unverified",
+            evidence: [{ source: "runtime", fact: "The connection API exposes registration commands but no current delivery-registration query. Manifest criteria do not prove approval or delivery registration." }]
+        }
+    };
+}

package/dist/token-response.d.ts

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

package/dist/token-response.js

@@ -0,0 +1,81 @@
+import { validateGrantEncryption } from "./crypto.js";
+import { connectError } from "./errors.js";
+import { isCanonicalGrantScope, parseGrantScope, validAuthorityTokenResponse, validFileCapability } from "./runtime-utils.js";
+export function storedTokenFromResponse({ body, clientId, keyHandle, previous, retiredKeyHandles, 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 (!isCanonicalGrantScope(scope)) {
+        throw connectError("legacy_scope_reauthorization_required", "Authorization returned a legacy contract-scoped grant. Reauthorize for the entire collection.");
+    }
+    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,
+        ...(retiredKeyHandles?.length ? { retiredKeyHandles } : {}),
+        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/dist/transient-retry.d.ts

@@ -0,0 +1,22 @@
+import { MdbaseConnectError } from "./errors.js";
+import type { OperationAttempt, PendingMutation } from "./internal-types.js";
+export declare const MAX_CONNECTOR_BUSY_RETRIES = 8;
+export declare const MAX_TRANSIENT_CHUNK_ATTEMPTS = 10;
+export declare function isConnectorBusy(error: unknown): error is MdbaseConnectError;
+export declare function retryExplicitConnectorBusy<Result>(options: {
+    error: unknown;
+    attempt: OperationAttempt;
+    completedRetries: number;
+    signal?: AbortSignal;
+    knownRejectedMutationRetry: boolean;
+    clearPending(requestId: string): void;
+    retry(pending: PendingMutation | undefined, knownRejected: boolean): Promise<Result>;
+}): Promise<{
+    retried: false;
+} | {
+    retried: true;
+    result: Result;
+}>;
+export declare function isExplicitConnectorBusyResponse(response: Response): Promise<boolean>;
+export declare function waitForConnectorAvailability(retryIndex: number, signal?: AbortSignal): Promise<void>;
+export declare function waitForTransientChunkRetry(completedAttempt: number, signal?: AbortSignal): Promise<void>;

package/dist/transient-retry.js

@@ -0,0 +1,59 @@
+import { abortableDelay } from "./async.js";
+import { MdbaseConnectError, connectError } from "./errors.js";
+export const MAX_CONNECTOR_BUSY_RETRIES = 8;
+export const MAX_TRANSIENT_CHUNK_ATTEMPTS = 10;
+export function isConnectorBusy(error) {
+    return error instanceof MdbaseConnectError && error.code === "connector_busy";
+}
+export async function retryExplicitConnectorBusy(options) {
+    if (!isConnectorBusy(options.error)
+        || options.completedRetries >= MAX_CONNECTOR_BUSY_RETRIES) {
+        return { retried: false };
+    }
+    try {
+        await waitForConnectorAvailability(options.completedRetries, options.signal);
+    }
+    catch (error) {
+        if (options.attempt.pendingMutation
+            && (options.knownRejectedMutationRetry || !options.attempt.resumingMutation)) {
+            options.clearPending(options.attempt.requestId);
+        }
+        throw error;
+    }
+    return {
+        retried: true,
+        result: await options.retry(options.attempt.pendingMutationRecord, options.knownRejectedMutationRetry
+            || (options.attempt.pendingMutation === true && !options.attempt.resumingMutation))
+    };
+}
+export async function isExplicitConnectorBusyResponse(response) {
+    if (response.status !== 502 && response.status !== 503)
+        return false;
+    const body = await response.clone().json().catch(() => null);
+    return body?.error === "connector_busy"
+        || (typeof body?.error === "object"
+            && body.error?.code === "connector_busy");
+}
+export function waitForConnectorAvailability(retryIndex, signal) {
+    return retryDelay(jitteredBackoff(50, 800, retryIndex), signal);
+}
+export function waitForTransientChunkRetry(completedAttempt, signal) {
+    return retryDelay(jitteredBackoff(100, 1_000, completedAttempt - 1), signal);
+}
+async function retryDelay(milliseconds, signal) {
+    try {
+        await abortableDelay(milliseconds, signal);
+    }
+    catch (cause) {
+        if (signal?.aborted) {
+            if (signal.reason instanceof MdbaseConnectError)
+                throw signal.reason;
+            throw connectError("operation_cancelled", "The operation was cancelled while waiting for connector capacity.", { operationOutcome: "not_sent", cause });
+        }
+        throw cause;
+    }
+}
+function jitteredBackoff(base, cap, exponent) {
+    const bounded = Math.min(cap, base * (2 ** Math.max(0, exponent)));
+    return Math.max(1, Math.round(bounded * (0.75 + Math.random() * 0.5)));
+}

package/dist/watch-policy.d.ts

@@ -0,0 +1,8 @@
+import type { WatchOptions } from "./operation-types.js";
+export interface ResolvedWatchRetryOptions {
+    initialDelayMs: number;
+    maxDelayMs: number;
+    multiplier: number;
+    maxAttempts?: number;
+}
+export declare function watchRetryPolicy(options: WatchOptions["retry"]): ResolvedWatchRetryOptions | undefined;

package/dist/watch-policy.js

@@ -0,0 +1,12 @@
+export function watchRetryPolicy(options) {
+    if (options === false)
+        return undefined;
+    return {
+        initialDelayMs: Math.max(0, options?.initialDelayMs ?? 500),
+        maxDelayMs: Math.max(0, options?.maxDelayMs ?? 15_000),
+        multiplier: Math.max(1, options?.multiplier ?? 2),
+        ...(options?.maxAttempts === undefined
+            ? {}
+            : { maxAttempts: Math.max(0, options.maxAttempts) })
+    };
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@mdbase-dev/connect",
+  "version": "0.1.0-beta.100",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mdbase-dev/mdbase-connect.git",
+    "directory": "packages/client"
+  },
+  "homepage": "https://mdbase.dev/sdk/",
+  "sideEffects": false,
+  "browser": "./dist/browser/mdbase-connect.min.js",
+  "unpkg": "./dist/browser/mdbase-connect.min.js",
+  "jsdelivr": "./dist/browser/mdbase-connect.min.js",
+  "exports": {
+    ".": {
+      "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": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@mdbase-dev/connect-protocol": "0.1.0-beta.100"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "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 && pnpm --filter @mdbase-dev/connect-protocol build && pnpm --filter @mdbase-dev/connect-testing build && tsc -p tsconfig.public-api.json && node scripts/check-public-api.mjs && node scripts/test-packed-api.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}