@opencoredev/social-sdk 0.1.0 → 0.1.2

package/dist/core/client.js

@@ -1,893 +0,0 @@
-import { decodeCursor, encodeCursor, iterateItems } from "./pagination.js";
-import { createConcurrencyLimiter } from "./concurrency.js";
-import { SocialError } from "./errors.js";
-import { deriveTargetIdempotencyKey, fingerprint, } from "./idempotency.js";
-function targetKey(account) {
-    return JSON.stringify([account.backend, account.platform, account.accountId]);
-}
-function mergeContent(base, override) {
-    if (override === undefined)
-        return base;
-    const result = {};
-    if (Object.hasOwn(override, "text")) {
-        if (override.text !== undefined)
-            Object.assign(result, { text: override.text });
-    }
-    else if (base.text !== undefined)
-        Object.assign(result, { text: base.text });
-    if (Object.hasOwn(override, "media")) {
-        if (override.media !== undefined)
-            Object.assign(result, { media: override.media });
-    }
-    else if (base.media !== undefined)
-        Object.assign(result, { media: base.media });
-    if (Object.hasOwn(override, "link")) {
-        if (override.link !== undefined)
-            Object.assign(result, { link: override.link });
-    }
-    else if (base.link !== undefined)
-        Object.assign(result, { link: base.link });
-    return result;
-}
-function mediaFingerprintView(content) {
-    return {
-        ...content,
-        media: content.media?.map((media) => ({
-            ...media,
-            source: media.source.kind === "blob" || media.source.kind === "stream"
-                ? { kind: media.source.kind, fingerprint: media.source.fingerprint }
-                : media.source,
-            thumbnail: media.thumbnail?.kind === "blob" || media.thumbnail?.kind === "stream"
-                ? { kind: media.thumbnail.kind, fingerprint: media.thumbnail.fingerprint }
-                : media.thumbnail,
-        })),
-    };
-}
-function preparationIssue(code, message, targetIndex) {
-    return {
-        code,
-        message,
-        severity: "error",
-        ...(targetIndex === undefined ? {} : { targetIndex }),
-    };
-}
-function publicationStatus(outcomes) {
-    const pending = new Set(["scheduled", "accepted", "processing"]);
-    const success = new Set(["published"]);
-    const hasPending = outcomes.some((outcome) => pending.has(outcome.state));
-    const hasSuccess = outcomes.some((outcome) => success.has(outcome.state));
-    const hasOther = outcomes.some((outcome) => !pending.has(outcome.state) && !success.has(outcome.state));
-    if (hasPending && !hasSuccess && !hasOther)
-        return "pending";
-    if (!hasPending && !hasOther)
-        return "complete";
-    return "partial";
-}
-async function mapConcurrent(count, concurrency, execute) {
-    const results = [];
-    let next = 0;
-    async function worker() {
-        while (next < count) {
-            const index = next++;
-            results[index] = await execute(index);
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(count, concurrency) }, () => worker()));
-    return results;
-}
-function makeContext(backendInstance, correlationId, options, targetIdempotencyKey) {
-    return {
-        backendInstance,
-        correlationId,
-        retryBudget: options?.retryBudget ?? { maxAttempts: 1, maxElapsedMs: 30_000 },
-        ...(options?.signal === undefined ? {} : { signal: options.signal }),
-        ...(options?.authorization === undefined ? {} : { authorization: options.authorization }),
-        ...(targetIdempotencyKey === undefined
-            ? {}
-            : { idempotencyKey: targetIdempotencyKey, targetIdempotencyKey }),
-    };
-}
-function unsupported(operation, backend) {
-    throw new SocialError({
-        code: "unsupported_capability",
-        operation,
-        backend,
-        message: `${backend} does not implement ${operation}`,
-    });
-}
-function outcomeFromError(error, target, observedAt) {
-    if (error instanceof SocialError) {
-        if (error.code === "cancelled") {
-            return {
-                state: "unknown",
-                targetIndex: target.targetIndex,
-                account: target.account,
-                observedAt,
-                reason: "ambiguous-submission",
-                diagnostic: "Cancellation interrupted a dispatched request; reconcile before retrying",
-            };
-        }
-        if (error.code === "ambiguous_outcome" || error.code === "timeout") {
-            return {
-                state: "unknown",
-                targetIndex: target.targetIndex,
-                account: target.account,
-                observedAt,
-                reason: "ambiguous-submission",
-                diagnostic: "The request outcome is ambiguous; reconcile with the backend before retrying",
-            };
-        }
-        return {
-            state: "failed",
-            targetIndex: target.targetIndex,
-            account: target.account,
-            observedAt,
-            code: error.code,
-            message: error.message,
-            retryDisposition: error.retryDisposition,
-        };
-    }
-    return {
-        state: "unknown",
-        targetIndex: target.targetIndex,
-        account: target.account,
-        observedAt,
-        reason: "ambiguous-submission",
-        diagnostic: "Adapter failed after dispatch; reconcile with the backend before retrying",
-    };
-}
-function assertValidOutcome(outcome, target) {
-    return (outcome.targetIndex === target.targetIndex &&
-        outcome.account.backend === target.account.backend &&
-        outcome.account.platform === target.account.platform &&
-        outcome.account.accountId === target.account.accountId);
-}
-export function createSocial(config) {
-    const registry = "backend" in config && config.backend !== undefined
-        ? { default: config.backend }
-        : config.backends;
-    const entries = Object.entries(registry);
-    if (entries.length === 0) {
-        throw new SocialError({
-            code: "invalid_config",
-            operation: "createSocial",
-            message: "Configure at least one backend",
-        });
-    }
-    const concurrency = config.concurrency ?? 4;
-    if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 100) {
-        throw new SocialError({
-            code: "invalid_config",
-            operation: "createSocial",
-            message: "concurrency must be an integer from 1 through 100",
-        });
-    }
-    const maxQueued = config.maxQueued ?? 100;
-    if (!Number.isSafeInteger(maxQueued) || maxQueued < 0 || maxQueued > 10_000) {
-        throw new SocialError({
-            code: "invalid_config",
-            operation: "createSocial",
-            message: "maxQueued must be an integer from 0 through 10000",
-        });
-    }
-    const limiters = new Map(entries.map(([backend]) => [
-        backend,
-        createConcurrencyLimiter({ maxActive: concurrency, maxQueued, backend }),
-    ]));
-    function dispatch(backend, signal, operation, work) {
-        const limiter = limiters.get(backend);
-        if (limiter === undefined) {
-            throw new SocialError({
-                code: "invalid_input",
-                operation,
-                message: `Unknown backend instance: ${backend}`,
-            });
-        }
-        return limiter(signal, operation, work);
-    }
-    const clock = config.clock ?? (() => new Date());
-    let correlationSequence = 0;
-    function prepare(request) {
-        const issues = [];
-        const targets = [];
-        if (request.targets.length === 0) {
-            issues.push(preparationIssue("targets.required", "At least one target is required"));
-        }
-        if (request.content.text === undefined && (request.content.media?.length ?? 0) === 0) {
-            issues.push(preparationIssue("content.required", "Text or media is required"));
-        }
-        if (request.schedule !== undefined) {
-            const scheduledAt = Date.parse(request.schedule.at);
-            if (!Number.isFinite(scheduledAt)) {
-                issues.push(preparationIssue("schedule.invalid", "schedule.at must be an ISO timestamp"));
-            }
-            else if (scheduledAt <= clock().getTime()) {
-                issues.push(preparationIssue("schedule.in_past", "A scheduled time must be in the future"));
-            }
-        }
-        const seen = new Set();
-        for (const [targetIndex, target] of request.targets.entries()) {
-            if (target.account.kind !== "connected-account" ||
-                target.account.version !== 1 ||
-                target.account.backend.length === 0 ||
-                target.account.platform.length === 0 ||
-                target.account.accountId.length === 0) {
-                issues.push(preparationIssue("target.reference_invalid", "Target account reference must be a version 1 connected-account reference", targetIndex));
-                continue;
-            }
-            const key = targetKey(target.account);
-            if (seen.has(key)) {
-                issues.push(preparationIssue("target.duplicate", "Duplicate target", targetIndex));
-            }
-            seen.add(key);
-            const adapter = registry[target.account.backend];
-            if (adapter === undefined) {
-                issues.push(preparationIssue("target.backend_unknown", `Unknown backend instance: ${target.account.backend}`, targetIndex));
-                continue;
-            }
-            if (adapter.posts === undefined) {
-                issues.push(preparationIssue("target.posts_unavailable", `Backend ${target.account.backend} does not implement posts`, targetIndex));
-                continue;
-            }
-            const declaration = adapter.capabilities.capabilities.find((candidate) => candidate.operation === "posts.publish" &&
-                (candidate.platform === "*" || candidate.platform === target.account.platform));
-            if (declaration === undefined || declaration.availability !== "available") {
-                issues.push(preparationIssue("capability.unavailable", declaration?.notes ??
-                    `Backend ${target.account.backend} does not declare posts.publish for ${target.account.platform}`, targetIndex));
-                continue;
-            }
-            const replyTo = target.replyTo ?? request.replyTo;
-            if (replyTo &&
-                (replyTo.version !== 1 ||
-                    !["platform-post", "comment"].includes(replyTo.kind) ||
-                    replyTo.backend !== target.account.backend ||
-                    replyTo.platform !== target.account.platform ||
-                    replyTo.accountId !== target.account.accountId)) {
-                issues.push(preparationIssue("reply.reference_mismatch", "Reply references must use the selected account, backend, and platform", targetIndex));
-            }
-            const prepared = {
-                targetIndex,
-                targetKey: key,
-                account: target.account,
-                content: mergeContent(request.content, target.content),
-                ...(target.options === undefined ? {} : { options: target.options }),
-                ...(request.schedule === undefined ? {} : { schedule: request.schedule }),
-                ...(replyTo === undefined ? {} : { replyTo }),
-            };
-            targets.push(prepared);
-            try {
-                issues.push(...adapter.posts.prepareTarget(prepared));
-            }
-            catch (error) {
-                issues.push(preparationIssue("adapter.prepare_failed", error instanceof SocialError
-                    ? error.message
-                    : "The adapter could not validate this target locally", targetIndex));
-            }
-        }
-        return { ok: !issues.some((issue) => issue.severity === "error"), targets, issues };
-    }
-    async function authorizeRef(operation, account, options, correlationId) {
-        if (config.authorization === undefined)
-            return;
-        const decision = (await config.authorization.authorizeTargets({
-            operation,
-            accounts: [account],
-            context: makeContext("*", correlationId, options),
-        }))[0];
-        if (decision?.allowed !== true || targetKey(decision.account) !== targetKey(account)) {
-            throw new SocialError({
-                code: "unauthorized",
-                operation,
-                message: decision?.reason ?? "The account is not authorized for this operation",
-                account,
-                correlationId,
-            });
-        }
-    }
-    function selected(ref, operation) {
-        if (ref.kind !== undefined && (ref.kind === "" || ref.version !== 1)) {
-            throw new SocialError({
-                code: "invalid_input",
-                operation,
-                message: "Reference kind/version does not match the Social SDK contract",
-            });
-        }
-        const adapter = registry[ref.backend];
-        if (adapter === undefined) {
-            throw new SocialError({
-                code: "invalid_input",
-                operation,
-                message: `Unknown backend instance: ${ref.backend}`,
-            });
-        }
-        return adapter;
-    }
-    function requireCapability(adapter, operation, platform, backend) {
-        const declaration = adapter.capabilities.capabilities.find((candidate) => candidate.operation === operation &&
-            (platform === "*" || candidate.platform === "*" || candidate.platform === platform));
-        if (declaration?.availability !== "available")
-            unsupported(operation, backend);
-    }
-    async function publish(request, options) {
-        const correlationId = request.correlationId ?? `social-${++correlationSequence}`;
-        const authContext = makeContext("*", correlationId, options);
-        if (options?.signal?.aborted) {
-            throw new SocialError({
-                code: "cancelled",
-                operation: "posts.publish",
-                message: "Publishing was cancelled before authorization",
-                correlationId,
-            });
-        }
-        if (config.authorization !== undefined) {
-            const decisions = await config.authorization.authorizeTargets({
-                operation: "posts.publish",
-                accounts: request.targets.map((target) => target.account),
-                context: authContext,
-            });
-            for (const target of request.targets) {
-                const decision = decisions.find((candidate) => targetKey(candidate.account) === targetKey(target.account));
-                if (decision?.allowed !== true) {
-                    throw new SocialError({
-                        code: "unauthorized",
-                        operation: "posts.publish",
-                        message: decision?.reason ?? "A target is not authorized for this operation",
-                        account: target.account,
-                        correlationId,
-                    });
-                }
-            }
-        }
-        const plan = prepare(request);
-        if (!plan.ok) {
-            throw new SocialError({
-                code: "invalid_input",
-                operation: "posts.publish",
-                message: "Publication preparation failed; no targets were dispatched",
-                correlationId,
-                issues: plan.issues,
-            });
-        }
-        const targetViews = plan.targets.map((target) => ({
-            account: target.account,
-            content: mediaFingerprintView(target.content),
-            options: target.options,
-            replyTo: target.replyTo,
-            schedule: target.schedule,
-        }));
-        const payloadFingerprint = await fingerprint(targetViews);
-        const scope = JSON.stringify([
-            options?.authorization?.tenantId ?? "credential-ready",
-            "posts.publish",
-        ]);
-        let claim;
-        if (request.idempotencyKey !== undefined && config.idempotencyStore !== undefined) {
-            claim = await config.idempotencyStore.claim({
-                scope,
-                key: request.idempotencyKey,
-                fingerprint: payloadFingerprint,
-                targetKeys: plan.targets.map((target) => target.targetKey),
-            });
-            if (claim.kind === "conflict") {
-                throw new SocialError({
-                    code: "idempotency_conflict",
-                    operation: "posts.publish",
-                    message: "The idempotency key was already used with a different target or payload",
-                    correlationId,
-                });
-            }
-        }
-        const observedAt = () => clock().toISOString();
-        const outcomes = await mapConcurrent(plan.targets.length, Math.max(1, plan.targets.length), async (index) => {
-            const target = plan.targets[index];
-            if (target === undefined)
-                throw new Error("Prepared target index was lost");
-            if (claim !== undefined && claim.kind === "existing") {
-                const saved = claim.outcomes[target.targetKey];
-                if (saved !== undefined)
-                    return saved;
-                return {
-                    state: "unknown",
-                    targetIndex: target.targetIndex,
-                    account: target.account,
-                    observedAt: observedAt(),
-                    reason: "ambiguous-submission",
-                    diagnostic: "A previous execution claimed this target without recording an outcome",
-                };
-            }
-            const adapter = registry[target.account.backend];
-            if (adapter?.posts === undefined)
-                throw new Error("Prepared adapter disappeared");
-            const targetIdempotencyKey = request.idempotencyKey === undefined
-                ? undefined
-                : await deriveTargetIdempotencyKey({
-                    logicalKey: request.idempotencyKey,
-                    scope,
-                    backend: target.account.backend,
-                    targetKey: target.targetKey,
-                    payloadFingerprint,
-                });
-            let outcome;
-            let enteredAdapter = false;
-            try {
-                const candidate = await dispatch(target.account.backend, options?.signal, "posts.publish", () => {
-                    enteredAdapter = true;
-                    return adapter.posts.publishTarget(target, makeContext(target.account.backend, correlationId, options, targetIdempotencyKey));
-                });
-                outcome = assertValidOutcome(candidate, target)
-                    ? candidate
-                    : {
-                        state: "unknown",
-                        targetIndex: target.targetIndex,
-                        account: target.account,
-                        observedAt: observedAt(),
-                        reason: "unmapped-state",
-                        diagnostic: "Adapter returned an outcome for a different target",
-                    };
-            }
-            catch (error) {
-                outcome =
-                    !enteredAdapter && error instanceof SocialError && error.code === "cancelled"
-                        ? {
-                            state: "cancelled",
-                            targetIndex: target.targetIndex,
-                            account: target.account,
-                            observedAt: observedAt(),
-                            reason: "before-submission",
-                        }
-                        : !enteredAdapter && error instanceof SocialError && error.code === "rate_limited"
-                            ? {
-                                state: "not-submitted",
-                                targetIndex: target.targetIndex,
-                                account: target.account,
-                                observedAt: observedAt(),
-                                reason: "capacity",
-                            }
-                            : outcomeFromError(error, target, observedAt());
-            }
-            if (claim?.kind === "new" && config.idempotencyStore !== undefined) {
-                try {
-                    await config.idempotencyStore.saveOutcome({
-                        claimId: claim.claimId,
-                        targetKey: target.targetKey,
-                        outcome,
-                    });
-                }
-                catch {
-                    // Return the complete in-memory result even if durable persistence is unavailable.
-                }
-            }
-            return outcome;
-        });
-        outcomes.sort((left, right) => left.targetIndex - right.targetIndex);
-        const publicationBackend = new Set(plan.targets.map((target) => target.account.backend)).size === 1
-            ? (plan.targets[0]?.account.backend ?? "unknown")
-            : "multiple";
-        const publicationId = await fingerprint({
-            scope,
-            key: request.idempotencyKey ?? correlationId,
-            payloadFingerprint,
-        });
-        const publication = {
-            kind: "publication",
-            version: 1,
-            backend: publicationBackend,
-            publicationId,
-        };
-        return { status: publicationStatus(outcomes), publication, outcomes };
-    }
-    const accountsFacade = {
-        async list(callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            if (entries.length > 1 && callOptions?.backend === undefined)
-                throw new SocialError({
-                    code: "invalid_input",
-                    operation: "accounts.read",
-                    message: "Select a backend instance when listing accounts from a mixed registry.",
-                });
-            const first = callOptions?.backend === undefined
-                ? entries[0]
-                : entries.find(([key]) => key === callOptions.backend);
-            if (first === undefined || first[1].accounts === undefined)
-                unsupported("accounts.read", first?.[0] ?? "unknown");
-            requireCapability(first[1], "accounts.read", "*", first[0]);
-            const cursorScope = JSON.stringify([
-                first[0],
-                "accounts.read",
-                callOptions?.authorization?.tenantId ?? null,
-                callOptions?.limit ?? null,
-            ]);
-            const received = await dispatch(first[0], callOptions?.signal, "accounts.read", () => first[1].accounts.list({
-                ...(callOptions?.cursor === undefined
-                    ? {}
-                    : { cursor: decodeCursor(cursorScope, callOptions.cursor) }),
-                ...(callOptions?.limit === undefined ? {} : { limit: callOptions.limit }),
-            }, makeContext(first[0], correlationId, callOptions)));
-            const page = {
-                ...received,
-                ...(received.nextCursor === undefined
-                    ? {}
-                    : { nextCursor: encodeCursor(cursorScope, received.nextCursor) }),
-            };
-            if (config.authorization === undefined)
-                return page;
-            const decisions = await config.authorization.authorizeTargets({
-                operation: "accounts.read",
-                accounts: page.items.map((item) => item.ref),
-                context: makeContext(first[0], correlationId, callOptions),
-            });
-            const allowed = new Set(decisions.filter((item) => item.allowed).map((item) => targetKey(item.account)));
-            return {
-                items: page.items.filter((item) => allowed.has(targetKey(item.ref))),
-                ...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }),
-                ...(page.metadata === undefined ? {} : { metadata: page.metadata }),
-            };
-        },
-        iterate(callOptions) {
-            return iterateItems((cursor) => accountsFacade.list({ ...callOptions, ...(cursor === undefined ? {} : { cursor }) }), callOptions);
-        },
-        async get(ref, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            await authorizeRef("accounts.read", ref, callOptions, correlationId);
-            const adapter = selected(ref, "accounts.get");
-            requireCapability(adapter, "accounts.read", ref.platform, ref.backend);
-            if (adapter.accounts === undefined)
-                unsupported("accounts.read", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "accounts.read", () => adapter.accounts.get(ref, makeContext(ref.backend, correlationId, callOptions)));
-        },
-    };
-    async function lifecycle(ref, expectedKind, operation, callOptions) {
-        if (ref.kind !== expectedKind || ref.version !== 1 || !ref.accountId || !ref.platform)
-            throw new SocialError({
-                code: "invalid_input",
-                operation,
-                message: "Use the account-scoped reference returned for this resource kind.",
-            });
-        const correlationId = `social-${++correlationSequence}`;
-        await authorizeRef(operation, {
-            kind: "connected-account",
-            version: 1,
-            backend: ref.backend,
-            platform: ref.platform,
-            accountId: ref.accountId,
-        }, callOptions, correlationId);
-        const adapter = selected(ref, operation);
-        requireCapability(adapter, operation, ref.platform, ref.backend);
-        return { adapter, context: makeContext(ref.backend, correlationId, callOptions) };
-    }
-    const postsFacade = {
-        async list(account, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            await authorizeRef("posts.read", account, callOptions, correlationId);
-            const adapter = selected(account, "posts.list");
-            requireCapability(adapter, "posts.list", account.platform, account.backend);
-            if (!adapter.posts?.list)
-                unsupported("posts.list", account.backend);
-            const scope = JSON.stringify([
-                account.backend,
-                "posts.list",
-                callOptions?.authorization?.tenantId ?? null,
-                account.platform,
-                account.accountId,
-                callOptions?.limit ?? null,
-            ]);
-            const input = {
-                ...(callOptions?.cursor === undefined
-                    ? {}
-                    : { cursor: decodeCursor(scope, callOptions.cursor) }),
-                ...(callOptions?.limit === undefined ? {} : { limit: callOptions.limit }),
-            };
-            const page = await dispatch(account.backend, callOptions?.signal, "posts.list", () => adapter.posts.list(account, input, makeContext(account.backend, correlationId, callOptions)));
-            return {
-                ...page,
-                ...(page.nextCursor === undefined
-                    ? {}
-                    : { nextCursor: encodeCursor(scope, page.nextCursor) }),
-            };
-        },
-        iterate(account, callOptions) {
-            return iterateItems((cursor) => postsFacade.list(account, {
-                ...callOptions,
-                ...(cursor === undefined ? {} : { cursor }),
-            }), callOptions);
-        },
-        async cancelScheduled(ref, callOptions) {
-            const { adapter, context } = await lifecycle(ref, "scheduled-job", "posts.cancelScheduled", callOptions);
-            if (!adapter.posts?.cancelScheduled)
-                unsupported("posts.cancelScheduled", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "posts.cancelScheduled", () => adapter.posts.cancelScheduled(ref, context));
-        },
-        async deleteBackendRecord(ref, callOptions) {
-            const { adapter, context } = await lifecycle(ref, "backend-post", "posts.deleteBackendRecord", callOptions);
-            if (!adapter.posts?.deleteBackendRecord)
-                unsupported("posts.deleteBackendRecord", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "posts.deleteBackendRecord", () => adapter.posts.deleteBackendRecord(ref, context));
-        },
-        async removeFromPlatform(ref, callOptions) {
-            const { adapter, context } = await lifecycle(ref, "platform-post", "posts.removeFromPlatform", callOptions);
-            if (!adapter.posts?.removeFromPlatform)
-                unsupported("posts.removeFromPlatform", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "posts.removeFromPlatform", () => adapter.posts.removeFromPlatform(ref, context));
-        },
-        prepare,
-        publish,
-        async publishSequence(request, callOptions) {
-            if (request.items.length === 0)
-                throw new SocialError({
-                    code: "invalid_input",
-                    operation: "posts.publishSequence",
-                    message: "A sequence requires at least one item",
-                });
-            const results = [];
-            for (const [index, item] of request.items.entries()) {
-                const result = await publish({
-                    targets: item.targets,
-                    content: item.content,
-                    idempotencyKey: `${request.idempotencyKey}:${index}`,
-                    ...(item.replyTo === undefined ? {} : { replyTo: item.replyTo }),
-                }, callOptions);
-                results.push(result);
-                if (request.stopOnFailure !== false && result.status !== "complete")
-                    break;
-            }
-            const status = results.length === request.items.length &&
-                results.every((item) => item.status === "complete")
-                ? "complete"
-                : results.some((item) => item.status === "partial") || results.length > 0
-                    ? "partial"
-                    : "pending";
-            return { status, items: results };
-        },
-        async get(ref, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            await authorizeRef("posts.read", {
-                kind: "connected-account",
-                version: 1,
-                backend: ref.backend,
-                platform: ref.platform,
-                accountId: ref.accountId,
-            }, callOptions, correlationId);
-            const adapter = selected(ref, "posts.get");
-            requireCapability(adapter, "posts.read", ref.platform, ref.backend);
-            if (adapter.posts?.get === undefined)
-                unsupported("posts.read", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "posts.read", () => adapter.posts.get(ref, makeContext(ref.backend, correlationId, callOptions)));
-        },
-        async getDelivery(ref, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            const account = {
-                kind: "connected-account",
-                version: 1,
-                backend: ref.backend,
-                platform: ref.platform,
-                accountId: ref.accountId,
-            };
-            await authorizeRef("posts.read", account, callOptions, correlationId);
-            const adapter = selected(ref, "posts.getDelivery");
-            requireCapability(adapter, "posts.status", ref.platform, ref.backend);
-            if (adapter.posts?.getDelivery === undefined)
-                unsupported("posts.read", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "posts.status", () => adapter.posts.getDelivery(ref, makeContext(ref.backend, correlationId, callOptions)));
-        },
-    };
-    const mediaFacade = {
-        async upload(input, account, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            await authorizeRef("posts.publish", account, callOptions, correlationId);
-            const adapter = selected(account, "media.upload");
-            requireCapability(adapter, "media.upload", account.platform, account.backend);
-            if (adapter.media === undefined)
-                unsupported("media.upload", account.backend);
-            return dispatch(account.backend, callOptions?.signal, "media.upload", () => adapter.media.upload(input, account, makeContext(account.backend, correlationId, callOptions)));
-        },
-    };
-    const analyticsFacade = {
-        async getAccountMetrics(ref, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            await authorizeRef("analytics.read", ref, callOptions, correlationId);
-            const adapter = selected(ref, "analytics.getAccountMetrics");
-            requireCapability(adapter, "analytics.account.read", ref.platform, ref.backend);
-            if (!adapter.analytics?.getAccountMetrics)
-                unsupported("analytics.account.read", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "analytics.account.read", () => adapter.analytics.getAccountMetrics(ref, makeContext(ref.backend, correlationId, callOptions)));
-        },
-        async getPostMetrics(ref, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            const account = {
-                kind: "connected-account",
-                version: 1,
-                backend: ref.backend,
-                platform: ref.platform,
-                accountId: ref.accountId,
-            };
-            await authorizeRef("analytics.read", account, callOptions, correlationId);
-            const adapter = selected(ref, "analytics.getPostMetrics");
-            requireCapability(adapter, "analytics.read", ref.platform, ref.backend);
-            if (adapter.analytics === undefined)
-                unsupported("analytics.read", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "analytics.read", () => adapter.analytics.getPostMetrics(ref, makeContext(ref.backend, correlationId, callOptions)));
-        },
-    };
-    const commentsFacade = {
-        async list(ref, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            const account = {
-                kind: "connected-account",
-                version: 1,
-                backend: ref.backend,
-                platform: ref.platform,
-                accountId: ref.accountId,
-            };
-            await authorizeRef("comments.read", account, callOptions, correlationId);
-            const adapter = selected(ref, "comments.list");
-            requireCapability(adapter, "comments.read", ref.platform, ref.backend);
-            if (adapter.comments === undefined)
-                unsupported("comments.read", ref.backend);
-            const cursorScope = JSON.stringify([
-                ref.backend,
-                "comments.read",
-                callOptions?.authorization?.tenantId ?? null,
-                ref.platform,
-                ref.accountId,
-                ref.postId,
-                callOptions?.limit ?? null,
-            ]);
-            const received = await dispatch(ref.backend, callOptions?.signal, "comments.read", () => adapter.comments.list(ref, {
-                ...(callOptions?.cursor === undefined
-                    ? {}
-                    : { cursor: decodeCursor(cursorScope, callOptions.cursor) }),
-                ...(callOptions?.limit === undefined ? {} : { limit: callOptions.limit }),
-            }, makeContext(ref.backend, correlationId, callOptions)));
-            return {
-                ...received,
-                ...(received.nextCursor === undefined
-                    ? {}
-                    : { nextCursor: encodeCursor(cursorScope, received.nextCursor) }),
-            };
-        },
-        iterate(ref, callOptions) {
-            return iterateItems((cursor) => commentsFacade.list(ref, { ...callOptions, ...(cursor === undefined ? {} : { cursor }) }), callOptions);
-        },
-        async reply(ref, content, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            const account = {
-                kind: "connected-account",
-                version: 1,
-                backend: ref.backend,
-                platform: ref.platform,
-                accountId: ref.accountId,
-            };
-            await authorizeRef("comments.write", account, callOptions, correlationId);
-            const adapter = selected(ref, "comments.reply");
-            requireCapability(adapter, "comments.write", ref.platform, ref.backend);
-            if (adapter.comments === undefined)
-                unsupported("comments.write", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "comments.write", () => adapter.comments.reply(ref, content, makeContext(ref.backend, correlationId, callOptions)));
-        },
-    };
-    const messagesFacade = {
-        async listConversations(account, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            await authorizeRef("messages.read", account, callOptions, correlationId);
-            const adapter = selected(account, "messages.listConversations");
-            requireCapability(adapter, "messages.read", account.platform, account.backend);
-            if (adapter.messages === undefined)
-                unsupported("messages.read", account.backend);
-            const cursorScope = JSON.stringify([
-                account.backend,
-                "messages.read",
-                callOptions?.authorization?.tenantId ?? null,
-                account.platform,
-                account.accountId,
-                "conversations",
-                callOptions?.limit ?? null,
-            ]);
-            const received = await dispatch(account.backend, callOptions?.signal, "messages.read", () => adapter.messages.listConversations(account, {
-                ...(callOptions?.cursor === undefined
-                    ? {}
-                    : { cursor: decodeCursor(cursorScope, callOptions.cursor) }),
-                ...(callOptions?.limit === undefined ? {} : { limit: callOptions.limit }),
-            }, makeContext(account.backend, correlationId, callOptions)));
-            return {
-                ...received,
-                ...(received.nextCursor === undefined
-                    ? {}
-                    : { nextCursor: encodeCursor(cursorScope, received.nextCursor) }),
-            };
-        },
-        iterateConversations(account, callOptions) {
-            return iterateItems((cursor) => messagesFacade.listConversations(account, {
-                ...callOptions,
-                ...(cursor === undefined ? {} : { cursor }),
-            }), callOptions);
-        },
-        async listMessages(ref, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            const account = {
-                kind: "connected-account",
-                version: 1,
-                backend: ref.backend,
-                platform: ref.platform,
-                accountId: ref.accountId,
-            };
-            await authorizeRef("messages.read", account, callOptions, correlationId);
-            const adapter = selected(ref, "messages.listMessages");
-            requireCapability(adapter, "messages.read", ref.platform, ref.backend);
-            if (adapter.messages === undefined)
-                unsupported("messages.read", ref.backend);
-            const cursorScope = JSON.stringify([
-                ref.backend,
-                "messages.read",
-                callOptions?.authorization?.tenantId ?? null,
-                ref.platform,
-                ref.accountId,
-                ref.conversationId,
-                callOptions?.limit ?? null,
-            ]);
-            const received = await dispatch(ref.backend, callOptions?.signal, "messages.read", () => adapter.messages.listMessages(ref, {
-                ...(callOptions?.cursor === undefined
-                    ? {}
-                    : { cursor: decodeCursor(cursorScope, callOptions.cursor) }),
-                ...(callOptions?.limit === undefined ? {} : { limit: callOptions.limit }),
-            }, makeContext(ref.backend, correlationId, callOptions)));
-            return {
-                ...received,
-                ...(received.nextCursor === undefined
-                    ? {}
-                    : { nextCursor: encodeCursor(cursorScope, received.nextCursor) }),
-            };
-        },
-        iterateMessages(ref, callOptions) {
-            return iterateItems((cursor) => messagesFacade.listMessages(ref, {
-                ...callOptions,
-                ...(cursor === undefined ? {} : { cursor }),
-            }), callOptions);
-        },
-        async send(ref, content, callOptions) {
-            const correlationId = `social-${++correlationSequence}`;
-            const account = {
-                kind: "connected-account",
-                version: 1,
-                backend: ref.backend,
-                platform: ref.platform,
-                accountId: ref.accountId,
-            };
-            await authorizeRef("messages.write", account, callOptions, correlationId);
-            const adapter = selected(ref, "messages.send");
-            requireCapability(adapter, "messages.write", ref.platform, ref.backend);
-            if (adapter.messages === undefined)
-                unsupported("messages.write", ref.backend);
-            return dispatch(ref.backend, callOptions?.signal, "messages.write", () => adapter.messages.send(ref, content, makeContext(ref.backend, correlationId, callOptions)));
-        },
-    };
-    return {
-        accounts: accountsFacade,
-        posts: postsFacade,
-        media: mediaFacade,
-        analytics: analyticsFacade,
-        comments: commentsFacade,
-        messages: messagesFacade,
-        capabilities: () => Object.fromEntries(entries.map(([key, adapter]) => [key, adapter.capabilities])),
-        adapter: (backend, acknowledgement) => {
-            if (acknowledgement?.acknowledgeUnsafe !== true)
-                throw new SocialError({
-                    code: "invalid_input",
-                    operation: "native",
-                    message: "Raw adapter access bypasses client authorization. Explicit acknowledgeUnsafe: true is required.",
-                });
-            const selected = registry[String(backend)];
-            if (selected === undefined)
-                throw new Error(`Unknown backend: ${String(backend)}`);
-            return selected;
-        },
-        native: (backend, acknowledgement) => {
-            if (acknowledgement?.acknowledgeUnsafe !== true)
-                throw new Error("Native access requires acknowledgeUnsafe: true");
-            const selected = registry[String(backend)];
-            if (selected === undefined)
-                throw new Error(`Unknown backend: ${String(backend)}`);
-            return selected.native;
-        },
-    };
-}
-//# sourceMappingURL=client.js.map