@opencoredev/social-sdk 0.1.2 → 0.2.1

package/dist/core/client.js

@@ -0,0 +1,1285 @@
+/* oxlint-disable anti-slop/require-readable-spacing, anti-slop/no-conditional-empty-object-spread, anti-slop/require-safety-comment-for-type-assertion -- facade dispatch keeps capability-specific branches together. */
+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) {
+    const issue = { code, message, severity: "error" };
+    if (targetIndex !== undefined)
+        Object.assign(issue, { targetIndex });
+    return issue;
+}
+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) {
+    const context = {
+        backendInstance,
+        correlationId,
+        retryBudget: options?.retryBudget ?? { maxAttempts: 1, maxElapsedMs: 30_000 },
+    };
+    if (options?.signal !== undefined)
+        Object.assign(context, { signal: options.signal });
+    if (options?.authorization !== undefined)
+        Object.assign(context, { authorization: options.authorization });
+    if (targetIdempotencyKey !== undefined)
+        Object.assign(context, { idempotencyKey: targetIdempotencyKey, targetIdempotencyKey });
+    return context;
+}
+function unsupported(operation, backend) {
+    throw new SocialError({
+        code: "unsupported_capability",
+        operation,
+        backend,
+        message: `${backend} does not implement ${operation}`,
+    });
+}
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- Adapter rejections enter the error boundary here.
+function outcomeFromError(error, // Transport and adapter rejections can be arbitrary JavaScript values.
+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).catch((error) => {
+            if (error instanceof SocialError)
+                throw error;
+            throw new SocialError({
+                code: "upstream_failure",
+                operation,
+                backend,
+                message: "The adapter failed while processing the request",
+                cause: error,
+            });
+        });
+    }
+    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),
+            };
+            if (target.options !== undefined)
+                Object.assign(prepared, { options: target.options });
+            if (request.schedule !== undefined)
+                Object.assign(prepared, { schedule: request.schedule });
+            if (replyTo !== undefined)
+                Object.assign(prepared, { 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,
+            });
+        }
+    }
+    async function authorizeRefWithFallback(operation, fallback, account, options, correlationId) {
+        try {
+            await authorizeRef(operation, account, options, correlationId);
+        }
+        catch (error) {
+            if (!(error instanceof SocialError) || error.code !== "unauthorized")
+                throw error;
+            await authorizeRef(fallback, account, options, correlationId);
+        }
+    }
+    function validateAccountRef(account, operation) {
+        if (account === null ||
+            typeof account !== "object" ||
+            account.kind !== "connected-account" ||
+            account.version !== 1 ||
+            typeof account.backend !== "string" ||
+            !account.backend.trim() ||
+            !account.platform ||
+            typeof account.accountId !== "string" ||
+            !account.accountId.trim())
+            throw new SocialError({
+                code: "invalid_input",
+                operation,
+                message: "A valid connected account reference is required",
+            });
+    }
+    function validDateOnly(value) {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+            return false;
+        const parsed = new Date(`${value}T00:00:00Z`);
+        return !Number.isNaN(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
+    }
+    function validTimestamp(value) {
+        return typeof value === "string" && value.trim() !== "" && !Number.isNaN(Date.parse(value));
+    }
+    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(decodePageOptions(cursorScope, callOptions), makeContext(first[0], correlationId, callOptions)));
+            const page = encodePage(cursorScope, received);
+            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)));
+            const filtered = {
+                items: page.items.filter((item) => allowed.has(targetKey(item.ref))),
+            };
+            if (page.nextCursor !== undefined)
+                Object.assign(filtered, { nextCursor: page.nextCursor });
+            if (page.metadata !== undefined)
+                Object.assign(filtered, { metadata: page.metadata });
+            return filtered;
+        },
+        iterate(callOptions) {
+            return iterateItems((cursor) => accountsFacade.list(iterationPageOptions(callOptions, 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)));
+        },
+    };
+    const graphFacade = {
+        async getProfile(account, input, callOptions) {
+            validateAccountRef(account, "profiles.read");
+            if (input === null ||
+                typeof input !== "object" ||
+                (input.profileId !== undefined &&
+                    input.handle !== undefined &&
+                    typeof input.profileId !== "string" &&
+                    typeof input.handle !== "string") ||
+                (input.profileId !== undefined &&
+                    (typeof input.profileId !== "string" || input.profileId.trim() === "")) ||
+                (input.handle !== undefined &&
+                    (typeof input.handle !== "string" || input.handle.trim() === "")))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "profiles.read",
+                    message: "Profile selector fields must be nonempty strings when provided",
+                });
+            const correlationId = `social-${++correlationSequence}`;
+            await authorizeRef("profiles.read", account, callOptions, correlationId);
+            const adapter = selected(account, "profiles.read");
+            requireCapability(adapter, "profiles.read", account.platform, account.backend);
+            if (adapter.graph?.getProfile === undefined)
+                unsupported("profiles.read", account.backend);
+            return dispatch(account.backend, callOptions?.signal, "profiles.read", () => adapter.graph.getProfile(account, input, makeContext(account.backend, correlationId, callOptions)));
+        },
+        async listRelationships(account, input, callOptions) {
+            validateAccountRef(account, "graph.read");
+            if (input === null ||
+                typeof input !== "object" ||
+                !["following", "followers", "blocked", "muted"].includes(input.kind) ||
+                (input.limit !== undefined && (!Number.isSafeInteger(input.limit) || input.limit < 1)))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "graph.read",
+                    message: !["following", "followers", "blocked", "muted"].includes(input?.kind)
+                        ? "Relationship kind must be following, followers, blocked, or muted"
+                        : "Relationship page limit must be a positive integer",
+                });
+            const correlationId = `social-${++correlationSequence}`;
+            await authorizeRef("graph.read", account, callOptions, correlationId);
+            const adapter = selected(account, "graph.read");
+            requireCapability(adapter, "graph.read", account.platform, account.backend);
+            if (adapter.graph?.listRelationships === undefined)
+                unsupported("graph.read", account.backend);
+            const scope = JSON.stringify([
+                account.backend,
+                "graph.read",
+                callOptions?.authorization?.tenantId ?? null,
+                account.platform,
+                account.accountId,
+                input.kind,
+                input.limit ?? null,
+            ]);
+            const page = await dispatch(account.backend, callOptions?.signal, "graph.read", () => adapter.graph.listRelationships(account, {
+                ...input,
+                ...(input.cursor === undefined ? {} : { cursor: decodeCursor(scope, input.cursor) }),
+            }, makeContext(account.backend, correlationId, callOptions)));
+            return encodePage(scope, page);
+        },
+        follow: (target, options) => graphMutation(target, "graph.follow", options),
+        unfollow: (target, options) => graphMutation(target, "graph.unfollow", options),
+        block: (target, options) => graphMutation(target, "graph.block", options),
+        unblock: (target, options) => graphMutation(target, "graph.unblock", options),
+        mute: (target, options) => graphMutation(target, "graph.mute", options),
+        unmute: (target, options) => graphMutation(target, "graph.unmute", options),
+    };
+    async function graphMutation(target, operation, callOptions) {
+        if (target === null ||
+            typeof target !== "object" ||
+            target.kind !== "profile" ||
+            target.version !== 1 ||
+            typeof target.backend !== "string" ||
+            target.backend.trim() === "" ||
+            typeof target.platform !== "string" ||
+            target.platform.trim() === "" ||
+            typeof target.accountId !== "string" ||
+            target.accountId.trim() === "" ||
+            typeof target.profileId !== "string" ||
+            target.profileId.trim() === "")
+            throw new SocialError({
+                code: "invalid_input",
+                operation,
+                message: "A valid profile reference is required",
+            });
+        const account = {
+            kind: "connected-account",
+            version: 1,
+            backend: target.backend,
+            platform: target.platform,
+            accountId: target.accountId,
+        };
+        const correlationId = `social-${++correlationSequence}`;
+        await authorizeRef(operation, account, callOptions, correlationId);
+        const adapter = selected(target, operation);
+        requireCapability(adapter, operation, target.platform, target.backend);
+        if (adapter.graph === undefined)
+            unsupported(operation, target.backend);
+        const context = makeContext(target.backend, correlationId, callOptions);
+        return dispatch(target.backend, callOptions?.signal, operation, async () => {
+            switch (operation) {
+                case "graph.follow":
+                    if (adapter.graph.follow === undefined)
+                        unsupported(operation, target.backend);
+                    return await adapter.graph.follow(target, context);
+                case "graph.unfollow":
+                    if (adapter.graph.unfollow === undefined)
+                        unsupported(operation, target.backend);
+                    await adapter.graph.unfollow(target, context);
+                    return undefined;
+                case "graph.block":
+                    if (adapter.graph.block === undefined)
+                        unsupported(operation, target.backend);
+                    return await adapter.graph.block(target, context);
+                case "graph.unblock":
+                    if (adapter.graph.unblock === undefined)
+                        unsupported(operation, target.backend);
+                    await adapter.graph.unblock(target, context);
+                    return undefined;
+                case "graph.mute":
+                    if (adapter.graph.mute === undefined)
+                        unsupported(operation, target.backend);
+                    return await adapter.graph.mute(target, context);
+                case "graph.unmute":
+                    if (adapter.graph.unmute === undefined)
+                        unsupported(operation, target.backend);
+                    await adapter.graph.unmute(target, context);
+                    return undefined;
+            }
+        });
+    }
+    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 = decodePageOptions(scope, callOptions);
+            const page = await dispatch(account.backend, callOptions?.signal, "posts.list", () => adapter.posts.list(account, input, makeContext(account.backend, correlationId, callOptions)));
+            return encodePage(scope, page);
+        },
+        iterate(account, callOptions) {
+            return iterateItems((cursor) => postsFacade.list(account, iterationPageOptions(callOptions, 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",
+                });
+            if (typeof request.idempotencyKey !== "string" || request.idempotencyKey.trim() === "")
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "posts.publishSequence",
+                    message: "A nonempty idempotencyKey is required",
+                });
+            const prepared = [];
+            for (const [index, item] of request.items.entries()) {
+                const publishRequest = {
+                    targets: item.targets,
+                    content: item.content,
+                    idempotencyKey: `${request.idempotencyKey}:${index}`,
+                };
+                if (item.replyTo !== undefined)
+                    Object.assign(publishRequest, { replyTo: item.replyTo });
+                const chained = request.replyToPrevious === true && index > 0;
+                if (chained) {
+                    const account = item.targets[0]?.account;
+                    const parent = request.items[index - 1]?.targets[0]?.account;
+                    // A chain replies to the single post the previous item created, so every link
+                    // must publish to one target on the same account.
+                    if (item.targets.length !== 1 ||
+                        request.items[index - 1]?.targets.length !== 1 ||
+                        item.replyTo !== undefined ||
+                        item.targets[0]?.replyTo !== undefined ||
+                        account === undefined ||
+                        parent === undefined ||
+                        account.backend !== parent.backend ||
+                        account.platform !== parent.platform ||
+                        account.accountId !== parent.accountId)
+                        throw new SocialError({
+                            code: "invalid_input",
+                            operation: "posts.publishSequence",
+                            message: "replyToPrevious requires every item to publish to the same single account without its own replyTo",
+                        });
+                }
+                const plan = prepare(chained
+                    ? {
+                        ...publishRequest,
+                        // Placeholder parent so adapters validate reply support before anything is sent.
+                        replyTo: {
+                            kind: "platform-post",
+                            version: 1,
+                            backend: item.targets[0].account.backend,
+                            platform: item.targets[0].account.platform,
+                            accountId: item.targets[0].account.accountId,
+                            postId: "preflight",
+                        },
+                    }
+                    : publishRequest);
+                if (!plan.ok)
+                    throw new SocialError({
+                        code: "invalid_input",
+                        operation: "posts.publishSequence",
+                        message: "Publication preparation failed; no targets were dispatched",
+                        issues: plan.issues,
+                    });
+                for (const target of plan.targets)
+                    await authorizeRef("posts.publish", target.account, callOptions, `social-${++correlationSequence}`);
+                prepared.push(publishRequest);
+            }
+            const results = [];
+            const failures = [];
+            let previous;
+            for (const [index, publishRequest] of prepared.entries()) {
+                const chained = request.replyToPrevious === true && index > 0;
+                // Without a published parent the item would post as an unrelated root post.
+                if (chained && previous === undefined)
+                    break;
+                const nextRequest = chained && previous !== undefined
+                    ? { ...publishRequest, replyTo: previous }
+                    : publishRequest;
+                let result;
+                previous = undefined;
+                try {
+                    result = await publish(nextRequest, callOptions);
+                }
+                catch (error) {
+                    if (error instanceof SocialError) {
+                        failures.push({ index, code: error.code, message: error.message });
+                        if (request.stopOnFailure !== false)
+                            break;
+                        continue;
+                    }
+                    throw error;
+                }
+                results.push(result);
+                const published = result.outcomes.find((outcome) => outcome.state === "published");
+                if (published?.post !== undefined)
+                    previous = published.post;
+                if (request.stopOnFailure !== false && result.status === "partial")
+                    break;
+            }
+            const status = results.length < request.items.length || results.some((item) => item.status === "partial")
+                ? "partial"
+                : results.every((item) => item.status === "complete")
+                    ? "complete"
+                    : "pending";
+            return { status, items: results, failures };
+        },
+        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.status", ref.backend);
+            return dispatch(ref.backend, callOptions?.signal, "posts.status", () => adapter.posts.getDelivery(ref, makeContext(ref.backend, correlationId, callOptions)));
+        },
+    };
+    const searchFacade = {
+        async posts(account, input, callOptions) {
+            validateAccountRef(account, "search.posts");
+            if (input === null ||
+                input === undefined ||
+                typeof input.query !== "string" ||
+                !input.query.trim() ||
+                (input.limit !== undefined && (!Number.isSafeInteger(input.limit) || input.limit < 1)) ||
+                (input.startTime !== undefined &&
+                    (typeof input.startTime !== "string" || !validTimestamp(input.startTime))) ||
+                (input.endTime !== undefined &&
+                    (typeof input.endTime !== "string" || !validTimestamp(input.endTime))) ||
+                (input.startTime !== undefined &&
+                    input.endTime !== undefined &&
+                    Date.parse(input.startTime) > Date.parse(input.endTime)) ||
+                (input.scope !== undefined && input.scope !== "recent" && input.scope !== "all"))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "search.posts",
+                    message: "Search requires an account reference, a nonempty query, and a positive page limit.",
+                });
+            const correlationId = `social-${++correlationSequence}`;
+            await authorizeRef("search.posts", account, callOptions, correlationId);
+            const adapter = selected(account, "search.posts");
+            requireCapability(adapter, "search.posts", account.platform, account.backend);
+            const search = adapter.search;
+            if (search === undefined)
+                unsupported("search.posts", account.backend);
+            const scope = await fingerprint([
+                account.backend,
+                "search.posts",
+                callOptions?.authorization?.tenantId ?? null,
+                account.platform,
+                account.accountId,
+                input.query,
+                input.limit ?? null,
+                input.startTime ?? null,
+                input.endTime ?? null,
+                input.scope ?? "recent",
+            ]);
+            const providerInput = { ...input };
+            if (input.cursor !== undefined) {
+                Object.assign(providerInput, { cursor: decodeCursor(scope, input.cursor) });
+            }
+            const page = await dispatch(account.backend, callOptions?.signal, "search.posts", () => search.posts(account, providerInput, makeContext(account.backend, correlationId, callOptions)));
+            return encodePage(scope, page);
+        },
+        iteratePosts(account, input, callOptions) {
+            return iterateItems((cursor) => searchFacade.posts(account, { ...input, ...iterationPageOptions(undefined, cursor) }, callOptions), 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) {
+            validateAccountRef(ref, "analytics.account.read");
+            const correlationId = `social-${++correlationSequence}`;
+            await authorizeRefWithFallback("analytics.account.read", "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)));
+        },
+        async getReport(ref, query, callOptions) {
+            validateAccountRef(ref, "analytics.report.read");
+            if (query === undefined ||
+                query === null ||
+                !validDateOnly(query.from) ||
+                !validDateOnly(query.to) ||
+                query.from > query.to ||
+                !Array.isArray(query.metrics) ||
+                query.metrics.length === 0 ||
+                query.metrics.some(
+                // oxlint-disable-next-line anti-slop/no-runtime-typeof -- runtime query boundary.
+                (metric) => typeof metric !== "string" || !metric.trim()) ||
+                (query.dimensions !== undefined &&
+                    (!Array.isArray(query.dimensions) ||
+                        query.dimensions.some(
+                        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- runtime query boundary.
+                        (dimension) => typeof dimension !== "string" || !dimension.trim()))))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "analytics.report.read",
+                    message: "Reports require an ordered YYYY-MM-DD range, at least one metric, and nonempty dimensions.",
+                });
+            const correlationId = `social-${++correlationSequence}`;
+            await authorizeRef("analytics.report.read", ref, callOptions, correlationId);
+            const adapter = selected(ref, "analytics.getReport");
+            requireCapability(adapter, "analytics.report.read", ref.platform, ref.backend);
+            if (!adapter.analytics?.getReport)
+                unsupported("analytics.report.read", ref.backend);
+            return dispatch(ref.backend, callOptions?.signal, "analytics.report.read", () => adapter.analytics.getReport(ref, query, makeContext(ref.backend, correlationId, callOptions)));
+        },
+    };
+    const commentsFacade = {
+        async list(ref, callOptions) {
+            const correlationId = `social-${++correlationSequence}`;
+            if (callOptions?.limit !== undefined &&
+                (!Number.isSafeInteger(callOptions.limit) || callOptions.limit < 1))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "comments.read",
+                    message: "Comment page limit must be a positive integer",
+                });
+            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, decodePageOptions(cursorScope, callOptions), makeContext(ref.backend, correlationId, callOptions)));
+            return encodePage(cursorScope, received);
+        },
+        iterate(ref, callOptions) {
+            return iterateItems((cursor) => commentsFacade.list(ref, iterationPageOptions(callOptions, 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}`;
+            if (callOptions?.limit !== undefined &&
+                (!Number.isSafeInteger(callOptions.limit) || callOptions.limit < 1))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "messages.read",
+                    message: "Message page limit must be a positive integer",
+                });
+            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, decodePageOptions(cursorScope, callOptions), makeContext(account.backend, correlationId, callOptions)));
+            return encodePage(cursorScope, received);
+        },
+        iterateConversations(account, callOptions) {
+            return iterateItems((cursor) => messagesFacade.listConversations(account, iterationPageOptions(callOptions, cursor)), callOptions);
+        },
+        async listMessages(ref, callOptions) {
+            const correlationId = `social-${++correlationSequence}`;
+            if (callOptions?.limit !== undefined &&
+                (!Number.isSafeInteger(callOptions.limit) || callOptions.limit < 1))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "messages.read",
+                    message: "Message page limit must be a positive integer",
+                });
+            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, decodePageOptions(cursorScope, callOptions), makeContext(ref.backend, correlationId, callOptions)));
+            return encodePage(cursorScope, received);
+        },
+        iterateMessages(ref, callOptions) {
+            return iterateItems((cursor) => messagesFacade.listMessages(ref, iterationPageOptions(callOptions, 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)));
+        },
+    };
+    const notificationsFacade = {
+        async list(account, callOptions) {
+            validateAccountRef(account, "notifications.read");
+            if (callOptions?.limit !== undefined &&
+                (!Number.isSafeInteger(callOptions.limit) || callOptions.limit < 1))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "notifications.read",
+                    message: "Notification page limit must be a positive integer",
+                });
+            const correlationId = `social-${++correlationSequence}`;
+            await authorizeRef("notifications.read", account, callOptions, correlationId);
+            const adapter = selected(account, "notifications.list");
+            requireCapability(adapter, "notifications.read", account.platform, account.backend);
+            if (adapter.notifications === undefined)
+                unsupported("notifications.read", account.backend);
+            const cursorScope = JSON.stringify([
+                account.backend,
+                "notifications.read",
+                callOptions?.authorization?.tenantId ?? null,
+                account.platform,
+                account.accountId,
+                callOptions?.limit ?? null,
+            ]);
+            const received = await dispatch(account.backend, callOptions?.signal, "notifications.read", () => adapter.notifications.list(account, decodePageOptions(cursorScope, callOptions), makeContext(account.backend, correlationId, callOptions)));
+            return encodePage(cursorScope, received);
+        },
+        iterate(account, callOptions) {
+            return iterateItems((cursor) => notificationsFacade.list(account, iterationPageOptions(callOptions, cursor)), callOptions);
+        },
+        async markSeen(account, input = {}, callOptions) {
+            validateAccountRef(account, "notifications.seen");
+            if (input === null ||
+                typeof input !== "object" ||
+                (input.seenAt !== undefined && !validTimestamp(input.seenAt)))
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "notifications.seen",
+                    message: "seenAt must be a valid timestamp",
+                });
+            const correlationId = `social-${++correlationSequence}`;
+            await authorizeRef("notifications.seen", account, callOptions, correlationId);
+            const adapter = selected(account, "notifications.markSeen");
+            requireCapability(adapter, "notifications.seen", account.platform, account.backend);
+            if (adapter.notifications === undefined)
+                unsupported("notifications.seen", account.backend);
+            return dispatch(account.backend, callOptions?.signal, "notifications.seen", () => adapter.notifications.markSeen(account, input, makeContext(account.backend, correlationId, callOptions)));
+        },
+    };
+    return {
+        accounts: accountsFacade,
+        graph: graphFacade,
+        posts: postsFacade,
+        search: searchFacade,
+        media: mediaFacade,
+        analytics: analyticsFacade,
+        comments: commentsFacade,
+        messages: messagesFacade,
+        notifications: notificationsFacade,
+        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 SocialError({
+                    code: "invalid_input",
+                    operation: "adapter",
+                    message: `Unknown backend: ${String(backend)}`,
+                });
+            return selected;
+        },
+        native: (backend, acknowledgement) => {
+            if (acknowledgement?.acknowledgeUnsafe !== true)
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "native",
+                    message: "Native access requires acknowledgeUnsafe: true",
+                });
+            const selected = registry[String(backend)];
+            if (selected === undefined)
+                throw new SocialError({
+                    code: "invalid_input",
+                    operation: "native",
+                    message: `Unknown backend: ${String(backend)}`,
+                });
+            return selected.native;
+        },
+    };
+}
+function decodePageOptions(scope, options) {
+    const input = {};
+    if (options?.cursor !== undefined)
+        input.cursor = decodeCursor(scope, options.cursor);
+    if (options?.limit !== undefined)
+        input.limit = options.limit;
+    return input;
+}
+function encodePage(scope, page) {
+    const result = { ...page };
+    if (page.nextCursor !== undefined)
+        result.nextCursor = encodeCursor(scope, page.nextCursor);
+    return result;
+}
+function iterationPageOptions(options, cursor) {
+    const result = { ...options };
+    if (cursor !== undefined)
+        result.cursor = cursor;
+    return result;
+}