@mdbase-dev/connect 0.1.0-beta.100

package/dist/browser/mdbase-connect.min.js.sha384

@@ -0,0 +1 @@
+sha384-qa5e6QDDjQFkjqKf4HstaDjyvJmQnvu4PkubKmMs2QIDou3qqMn+uYWQG2Z0ImA2

package/dist/browser.d.ts

@@ -0,0 +1,3 @@
+export * from "./index.js";
+export * from "./advanced.js";
+export * from "./crypto-entry.js";

package/dist/browser.js

@@ -0,0 +1,5 @@
+// The classic-script browser global retains opt-in primitives as properties;
+// ESM consumers use the explicit root, /advanced, and /crypto entry points.
+export * from "./index.js";
+export * from "./advanced.js";
+export * from "./crypto-entry.js";

package/dist/capabilities.d.ts

@@ -0,0 +1,24 @@
+import { type ApplicationCapabilityRequirements, type LegacyApplicationCapabilityRequirements } from "@mdbase-dev/connect-protocol";
+import type { MdbaseApplicationCapabilityId as ApplicationCapabilityId, MdbaseApplicationManifest as MdbaseAppManifest } from "./application-contract.js";
+import type { MdbaseConnectionInfo } from "./connection-types.js";
+export type MdbaseCapabilityState = "available" | "requires_authorization" | "requires_setup" | "temporarily_unavailable" | "unsupported";
+export interface MdbaseCapabilityEvidence {
+    source: "application" | "authorization" | "authority" | "runtime";
+    fact: string;
+}
+export interface MdbaseEffectiveCapability {
+    id: ApplicationCapabilityId;
+    requirement: "required" | "optional";
+    state: MdbaseCapabilityState;
+    operations: string[];
+    missingOperations: string[];
+    evidence: MdbaseCapabilityEvidence[];
+    reason?: string;
+    details?: Record<string, unknown>;
+}
+export interface MdbaseEffectiveCapabilities {
+    contractVersion: 1 | 2;
+    values: Partial<Record<ApplicationCapabilityId, MdbaseEffectiveCapability>>;
+    requiredAvailable: boolean;
+}
+export declare function effectiveCapabilities(requirements: ApplicationCapabilityRequirements | LegacyApplicationCapabilityRequirements, manifest: MdbaseAppManifest, connection: MdbaseConnectionInfo): MdbaseEffectiveCapabilities;

package/dist/capabilities.js

@@ -0,0 +1,91 @@
+import { capabilityOperationsForContractVersion } from "@mdbase-dev/connect-protocol";
+export function effectiveCapabilities(requirements, manifest, connection) {
+    const required = new Set(requirements.required);
+    const declared = [...new Set([...requirements.required, ...(requirements.optional ?? [])])];
+    const values = {};
+    for (const id of declared) {
+        values[id] = effectiveCapability(id, required.has(id), connection, requirements.contract_version, manifest);
+    }
+    return {
+        contractVersion: requirements.contract_version,
+        values,
+        requiredAvailable: requirements.required.every((id) => values[id]?.state === "available")
+    };
+}
+function effectiveCapability(id, required, connection, version, manifest) {
+    const operations = capabilityOperationsForContractVersion(version, id) ?? [];
+    const missingOperations = operations.filter((operation) => !connection.operations.includes(operation));
+    const base = {
+        id,
+        requirement: required ? "required" : "optional",
+        operations,
+        missingOperations,
+        evidence: [{
+                source: "application",
+                fact: `${required ? "Required" : "Optional"} in capability contract v${version}.`
+            }]
+    };
+    if (missingOperations.length > 0) {
+        return {
+            ...base,
+            state: "requires_authorization",
+            evidence: [...base.evidence, {
+                    source: "authorization",
+                    fact: `Missing ${missingOperations.join(", ")}.`
+                }],
+            reason: "The current grant does not include every operation for this capability."
+        };
+    }
+    if (connection.scope.access !== "full_collection") {
+        return {
+            ...base,
+            state: "requires_authorization",
+            reason: "The current grant uses legacy contract scope and must be reauthorized for the entire collection.",
+            evidence: [...base.evidence, {
+                    source: "authorization",
+                    fact: "Legacy contract scope is compatibility evidence, not active data authority."
+                }]
+        };
+    }
+    // Compatibility readiness is deliberately limited to v1 aliases. V2 needs
+    // structured file/notification/runtime evidence, not these legacy shortcuts.
+    if (version === 1 && id.startsWith("files.")) {
+        const action = id.slice("files.".length);
+        if (!connection.fileCapability?.actions.includes(action)) {
+            return {
+                ...base,
+                state: connection.fileCapability ? "requires_authorization" : "unsupported",
+                reason: connection.fileCapability ? `The current file grant does not include ${action}.` : "This connection has no file capability."
+            };
+        }
+    }
+    if (version === 1 && id === "notifications.background-delivery" && (manifest.notifications?.criteria.length ?? 0) === 0) {
+        return { ...base, state: "requires_setup", reason: "The application manifest declares no notification criteria." };
+    }
+    return {
+        ...base,
+        state: "available",
+        evidence: [...base.evidence, {
+                source: "authorization",
+                fact: operations.length > 0
+                    ? `Granted operations: ${operations.join(", ")}.`
+                    : "No record operation is required."
+            }, {
+                source: "authority",
+                fact: connection.authority.kind === "hosted"
+                    ? "Backed by a durable hosted mdbase authority."
+                    : "Backed by a user-operated mdbase connector."
+            }],
+        ...(id === "offline.replica" || (version === 1 && id === "sync.offline-replica")
+            ? {
+                details: {
+                    durability: "device",
+                    writes: "queued",
+                    authority: connection.authority.kind
+                }
+            }
+            : {}),
+        ...(version === 1 && id === "notifications.background-delivery"
+            ? { details: { delivery: "authority", payload: "opaque" } } : {})
+    };
+}

package/dist/collection-client.d.ts

@@ -0,0 +1,66 @@
+import type { CollectionOperation, CollectionTypeDocument, JsonObject } from "@mdbase-dev/connect-protocol";
+import { type CollectionChangesProblemCode, type CollectionDescriptionProblemCode, type CollectionMutationProblemCode, type CollectionQueryProblemCode, type CollectionReadProblemCode, type CollectionTypeProblemCode, type ConnectOutcome } from "./outcomes.js";
+import type { ChangesInput, CollectionChange, CollectionChangesPage, CollectionDescription, CollectionSetupApplyResult, CollectionSetupAssessment, AssessCollectionSetupInput, AssessTypePackInput, ApplyCollectionSetupInput, ApplyTypePackInput, CreateInput, CreateTypeInput, CreateViewSourceInput, DeleteInput, DeletePreflightResult, DeleteResult, DeleteViewSourceInput, DeleteViewSourceResult, ExecuteViewInput, MdbaseCollectionTransport, MdbaseDesiredTimer, MdbaseTimer, MdbaseTimerList, MdbaseTimerReconciliation, ConnectRequestOptions, QueryAllOptions, QueryInput, QueryPage, QueryPagesOptions, QueryResult, ReadInput, ReadTypeInput, ReadViewSourceInput, RenameInput, RenamePreflightResult, RenameResult, RecordDocument, SavedViewExecution, SavedViewPage, SavedViewPagesOptions, SavedViewList, SavedViewSourceDocument, TypePackApplyResult, TypePackAssessment, UpdateInput, UpdateTypeInput, UpdateViewSourceInput, WatchOptions } from "./operation-types.js";
+/**
+ * Typed collection operations independent of OAuth, HTTP, or storage.
+ *
+ * Application code can use this surface against Connect, the developer
+ * sandbox, or another provider without changing its record logic.
+ */
+export declare class MdbaseCollectionClient<Frontmatter extends JsonObject = JsonObject> {
+    private readonly transport;
+    private readonly requestTimeoutMs;
+    constructor(transport: MdbaseCollectionTransport, requestTimeoutMs?: number | null);
+    operation<Result>(operation: CollectionOperation, input: unknown, options?: ConnectRequestOptions): Promise<ConnectOutcome<Result>>;
+    describe(options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionDescription, CollectionDescriptionProblemCode>>;
+    changes(input?: ChangesInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionChangesPage, CollectionChangesProblemCode>>;
+    read(input: ReadInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionReadProblemCode>>;
+    query(input?: QueryInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
+    queryPages(input?: QueryInput, options?: QueryPagesOptions<Frontmatter>): AsyncGenerator<ConnectOutcome<QueryPage<Frontmatter>, CollectionQueryProblemCode>>;
+    queryAll(input?: QueryInput, options?: QueryAllOptions<Frontmatter>): Promise<ConnectOutcome<QueryResult<Frontmatter>, CollectionQueryProblemCode>>;
+    listViews(options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewList, CollectionReadProblemCode>>;
+    executeView(input: ExecuteViewInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewExecution<Frontmatter>, CollectionReadProblemCode>>;
+    executeViewPages(input: ExecuteViewInput, options?: SavedViewPagesOptions<Frontmatter>): AsyncGenerator<ConnectOutcome<SavedViewPage<Frontmatter>, CollectionReadProblemCode>>;
+    readViewSource(input: ReadViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionReadProblemCode>>;
+    createViewSource(input: CreateViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionMutationProblemCode>>;
+    updateViewSource(input: UpdateViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<SavedViewSourceDocument, CollectionMutationProblemCode>>;
+    deleteViewSource(input: DeleteViewSourceInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<DeleteViewSourceResult, CollectionMutationProblemCode>>;
+    create(input: CreateInput<Frontmatter>, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionMutationProblemCode>>;
+    update(input: UpdateInput<Frontmatter>, options?: ConnectRequestOptions): Promise<ConnectOutcome<RecordDocument<Frontmatter>, CollectionMutationProblemCode>>;
+    delete(input: DeleteInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<DeleteResult, CollectionMutationProblemCode>>;
+    preflightDelete(input: DeleteInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<DeletePreflightResult, CollectionMutationProblemCode>>;
+    rename(input: RenameInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RenameResult, CollectionMutationProblemCode>>;
+    preflightRename(input: RenameInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<RenamePreflightResult, CollectionMutationProblemCode>>;
+    validate(input?: JsonObject, options?: ConnectRequestOptions): Promise<ConnectOutcome<JsonObject, CollectionReadProblemCode>>;
+    readType(input: ReadTypeInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
+    createType(input: CreateTypeInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
+    updateType(input: UpdateTypeInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionTypeDocument, CollectionTypeProblemCode>>;
+    assessTypePack(input: AssessTypePackInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<TypePackAssessment, CollectionTypeProblemCode>>;
+    applyTypePack(input: ApplyTypePackInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<TypePackApplyResult, CollectionTypeProblemCode>>;
+    assessCollectionSetup(input: AssessCollectionSetupInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionSetupAssessment, CollectionTypeProblemCode>>;
+    applyCollectionSetup(input: ApplyCollectionSetupInput, options?: ConnectRequestOptions): Promise<ConnectOutcome<CollectionSetupApplyResult, CollectionTypeProblemCode>>;
+    listTimers(namespace: string, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimerList, CollectionReadProblemCode>>;
+    putTimer(input: {
+        namespace: string;
+        criterionId: string;
+        timer: MdbaseDesiredTimer;
+    }, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimer, CollectionMutationProblemCode>>;
+    cancelTimer(input: {
+        namespace: string;
+        id: string;
+        generation?: number;
+    }, options?: ConnectRequestOptions): Promise<ConnectOutcome<{
+        namespace: string;
+        id: string;
+        cancelled: boolean;
+    }, CollectionMutationProblemCode>>;
+    reconcileTimers(input: {
+        namespace: string;
+        criterionId: string;
+        timers: MdbaseDesiredTimer[];
+    }, options?: ConnectRequestOptions): Promise<ConnectOutcome<MdbaseTimerReconciliation, CollectionMutationProblemCode>>;
+    watch(options?: WatchOptions): AsyncGenerator<ConnectOutcome<CollectionChange, CollectionChangesProblemCode>>;
+    private rawOperation;
+    private releaseQueryCursor;
+    private envelopeOperation;
+}