@zhin.js/adapter-slack 1.0.77 → 1.1.0

package/agent/tools/unpin_message.ts

@@ -0,0 +1,23 @@
+import { defineAgentTool } from '@zhin.js/agent/tools';
+import { z } from 'zod';
+import { platformPermit } from '../../src/platform-permit.js';
+
+export default defineAgentTool<{
+  channel_id: string;
+  timestamp: string;
+}>({
+  description: '取消 Slack 频道中消息的置顶',
+  inputSchema: z.object({
+    channel_id: z.string().describe('频道 ID'),
+    timestamp: z.string().describe('消息时间戳'),
+  }),
+  adapter: 'slack',
+  tags: ['slack'],
+  permissions: [platformPermit('channel_manager')],
+  async execute({ channel_id, timestamp }, context) {
+    const client = context.$client;
+    await client.pins.remove({ channel: channel_id, timestamp });
+    const success = true;
+    return { success, message: success ? '已取消置顶' : '操作失败' };
+  },
+});

package/agent/tools/user_info.ts

@@ -0,0 +1,29 @@
+import { defineAgentTool } from '@zhin.js/agent/tools';
+import { z } from 'zod';
+import type { SlackUserInfo } from '../../src/client.js';
+
+export default defineAgentTool<{
+  user_id: string;
+}>({
+  description: '查询 Slack 用户详细信息',
+  inputSchema: z.object({
+    user_id: z.string().describe('用户 ID'),
+  }),
+  adapter: 'slack',
+  tags: ['slack'],
+  async execute({ user_id }, context) {
+    const client = context.$client;
+    const user = (await client.users.info({ user: user_id })).user as SlackUserInfo | undefined;
+    if (!user) throw new Error(`Slack 用户不存在: ${user_id}`);
+    return {
+      id: user.id,
+      name: user.name,
+      real_name: user.real_name,
+      display_name: user.profile?.display_name,
+      email: user.profile?.email,
+      is_admin: user.is_admin,
+      is_bot: user.is_bot,
+      status_text: user.profile?.status_text,
+    };
+  },
+});

package/commands/endpoint/add/[id].js

@@ -0,0 +1,3 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { slackEndpointCommands } from "../../../lib/slack-endpoint-commands.js";
+export default slackEndpointCommands.add;

package/commands/endpoint/add/[id].ts

@@ -0,0 +1,3 @@
+import { slackEndpointCommands } from '../../../src/slack-endpoint-commands.js';
+
+export default slackEndpointCommands.add;

package/commands/endpoint/list.js

@@ -0,0 +1,3 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { slackEndpointCommands } from "../../lib/slack-endpoint-commands.js";
+export default slackEndpointCommands.list;

package/commands/endpoint/list.ts

@@ -0,0 +1,3 @@
+import { slackEndpointCommands } from '../../src/slack-endpoint-commands.js';
+
+export default slackEndpointCommands.list;

package/commands/endpoint/remove/[id].js

@@ -0,0 +1,3 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { slackEndpointCommands } from "../../../lib/slack-endpoint-commands.js";
+export default slackEndpointCommands.remove;

package/commands/endpoint/remove/[id].ts

@@ -0,0 +1,3 @@
+import { slackEndpointCommands } from '../../../src/slack-endpoint-commands.js';
+
+export default slackEndpointCommands.remove;

package/lib/client.d.ts

@@ -0,0 +1,25 @@
+import type { SlackWebClientLike } from './endpoint.js';
+import type { SlackEvent } from './protocol.js';
+/** Slack users.info response fields projected by the bundled tools. */
+export interface SlackUserInfo {
+    id?: string;
+    name?: string;
+    real_name?: string;
+    is_admin?: boolean;
+    is_bot?: boolean;
+    profile?: {
+        display_name?: string;
+        email?: string;
+        status_text?: string;
+    };
+}
+export type SlackClientEventMap = Record<string, SlackEvent>;
+declare module '@zhin.js/feature-kit' {
+    interface AdapterClientRegistry {
+        readonly slack: {
+            readonly client: SlackWebClientLike;
+            readonly events: SlackClientEventMap;
+        };
+    }
+}
+export declare const slackClient: import("@zhin.js/adapter").EndpointClientToken<SlackWebClientLike, SlackClientEventMap>;

package/lib/client.js

@@ -0,0 +1,2 @@
+import { defineEndpointClient } from 'zhin.js/adapter';
+export const slackClient = defineEndpointClient('slack');

package/lib/endpoint.d.ts

@@ -0,0 +1,153 @@
+import { Endpoint } from 'zhin.js/adapter';
+import type { EndpointControl, EndpointManagement, EndpointSendRequest } from 'zhin.js/adapter';
+import type { HttpHost } from '@zhin.js/host-http';
+import type { CapabilityId } from 'zhin.js';
+import { type ResolvedSlackConfig, type SlackEvent, type SlackInteractionPayload, type SlackMessageEvent, type SlackSlashCommand } from './protocol.js';
+import { type SlackChatClient } from './slack-outbound.js';
+import { type SlackWebhookHandler } from './webhook.js';
+export interface SlackSocketLike {
+    on(event: string, handler: (args: {
+        ack: () => Promise<void>;
+        body: unknown;
+    }) => void | Promise<void>): void;
+    start(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export interface SlackWebClientLike extends SlackChatClient {
+    auth: {
+        test(): Promise<{
+            user_id?: string;
+            user?: string;
+        }>;
+    };
+    conversations: {
+        invite(opts: {
+            channel: string;
+            users: string;
+        }): Promise<unknown>;
+        kick(opts: {
+            channel: string;
+            user: string;
+        }): Promise<unknown>;
+        setTopic(opts: {
+            channel: string;
+            topic: string;
+        }): Promise<unknown>;
+        setPurpose(opts: {
+            channel: string;
+            purpose: string;
+        }): Promise<unknown>;
+        archive(opts: {
+            channel: string;
+        }): Promise<unknown>;
+        unarchive(opts: {
+            channel: string;
+        }): Promise<unknown>;
+        rename(opts: {
+            channel: string;
+            name: string;
+        }): Promise<unknown>;
+        members(opts: {
+            channel: string;
+        }): Promise<{
+            members?: string[];
+        }>;
+        info(opts: {
+            channel: string;
+        }): Promise<{
+            channel?: unknown;
+        }>;
+        list(opts?: {
+            types?: string;
+            limit?: number;
+            cursor?: string;
+            exclude_archived?: boolean;
+        }): Promise<{
+            channels?: unknown[];
+            response_metadata?: {
+                next_cursor?: string;
+            };
+        }>;
+    };
+    users: {
+        info(opts: {
+            user: string;
+        }): Promise<{
+            user?: unknown;
+        }>;
+        list(opts?: {
+            limit?: number;
+            cursor?: string;
+        }): Promise<{
+            members?: unknown[];
+            response_metadata?: {
+                next_cursor?: string;
+            };
+        }>;
+    };
+    reactions: {
+        add(opts: {
+            channel: string;
+            timestamp: string;
+            name: string;
+        }): Promise<unknown>;
+        remove(opts: {
+            channel: string;
+            timestamp: string;
+            name: string;
+        }): Promise<unknown>;
+    };
+    pins: {
+        add(opts: {
+            channel: string;
+            timestamp: string;
+        }): Promise<unknown>;
+        remove(opts: {
+            channel: string;
+            timestamp: string;
+        }): Promise<unknown>;
+    };
+    chat: SlackChatClient['chat'] & {
+        delete(opts: {
+            channel: string;
+            ts: string;
+        }): Promise<unknown>;
+    };
+}
+export interface SlackEndpointOptions {
+    readonly id: CapabilityId;
+    readonly config: ResolvedSlackConfig;
+    readonly http?: HttpHost;
+    readonly createClient?: (token: string) => SlackWebClientLike;
+    readonly createSocket?: (opts: {
+        readonly appToken: string;
+        readonly clientPingTimeout: number;
+    }) => SlackSocketLike;
+}
+export declare class SlackEndpoint extends Endpoint<SlackWebClientLike> implements SlackWebhookHandler {
+    #private;
+    readonly management: EndpointManagement;
+    readonly control: EndpointControl;
+    constructor(options: SlackEndpointOptions);
+    /** Console 展示 / AdapterIndex live name（多 endpoint 时与 entry name 一致）。 */
+    get name(): string;
+    get client(): SlackWebClientLike;
+    get platformUserId(): string | undefined;
+    get config(): ResolvedSlackConfig;
+    start(): Promise<void>;
+    open(): void;
+    close(): void;
+    stop(): Promise<void>;
+    send({ conversation, payload }: EndpointSendRequest): Promise<string>;
+    /** Test / internal: admit a message event when open. */
+    admit(event: SlackMessageEvent | SlackEvent): void;
+    admitInteraction(payload: SlackInteractionPayload): void;
+    admitSlashCommand(cmd: SlackSlashCommand): void;
+    handleEnvelope(body: unknown): void;
+    trackMessageChannel(ts: string, channel: string): void;
+    resolveMessageRef(messageId: string, channelHint?: string): {
+        channel: string;
+        ts: string;
+    } | null;
+    recallMessage(messageId: string): Promise<void>;
+}

package/lib/endpoint.js

@@ -0,0 +1,425 @@
+import { Endpoint } from 'zhin.js/adapter';
+/**
+ * SlackEndpoint — lifecycle, outbound, admit, Socket Mode, agent tool surface.
+ */
+import { SocketModeClient } from '@slack/socket-mode';
+import { WebClient } from '@slack/web-api';
+import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
+import { formatInboundContent, formatInteractionContent, formatSlashContent, resolveSlackChannelType, slackInboundConversation, } from './protocol.js';
+import { createSlackInboundFilterState, shouldDropSlackInboundMessage, } from './slack-inbound-filter.js';
+import { formatSlackMessageRef, parseSlackMessageRef } from './slack-message-ref.js';
+import { normalizeSlackReactionName } from './slack-reaction.js';
+import { postSlackEphemeral } from './slack-response-url.js';
+import { editSlackContent, sendSlackContent } from './slack-outbound.js';
+import { registerSlackWebhookRoutes } from './webhook.js';
+import { receiveSlackSideEvent } from './side-event-dispatch.js';
+export class SlackEndpoint extends Endpoint {
+    #logger;
+    #options;
+    #inboundFilter = createSlackInboundFilterState();
+    #messageChannelMap = new Map();
+    #client;
+    #socket;
+    #routeReleases = [];
+    #botUserId;
+    #open = false;
+    #started = false;
+    management = createSlackEndpointManagement(() => this.client);
+    control = Object.freeze({
+        recall: async (message) => {
+            const ref = this.resolveMessageRef(message.id, message.conversation.id);
+            if (!ref || !this.#client)
+                return;
+            await this.#client.chat.delete(ref);
+        },
+        edit: async (message, content) => {
+            const ref = this.resolveMessageRef(message.id, message.conversation.id);
+            if (!ref)
+                return null;
+            await this.#editMessage(ref.channel, ref.ts, content);
+            return message.id;
+        },
+        addReaction: async (message, emoji) => {
+            const ref = this.resolveMessageRef(message.id, message.conversation.id);
+            if (!ref)
+                return null;
+            const reaction = normalizeSlackReactionName(emoji);
+            await this.#addReaction(ref.channel, ref.ts, reaction);
+            return reaction;
+        },
+        removeReaction: async (message, reactionId) => {
+            const ref = this.resolveMessageRef(message.id, message.conversation.id);
+            if (!ref)
+                return;
+            await this.#removeReaction(ref.channel, ref.ts, reactionId);
+        },
+    });
+    constructor(options) {
+        super();
+        this.#logger = getAdapterLogger('slack', options.config.id);
+        this.#options = options;
+    }
+    /** Console 展示 / AdapterIndex live name（多 endpoint 时与 entry name 一致）。 */
+    get name() {
+        return this.#options.config.id;
+    }
+    get client() {
+        if (!this.#client)
+            throw new Error('Slack client not connected');
+        return this.#client;
+    }
+    get platformUserId() {
+        return this.#botUserId;
+    }
+    get config() {
+        return this.#options.config;
+    }
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        try {
+            const { config } = this.#options;
+            this.#client = this.#options.createClient?.(config.token)
+                ?? new WebClient(config.token);
+            if (config.mode === 'socket') {
+                await this.#startSocket();
+            }
+            else {
+                const http = this.#options.http;
+                if (!http) {
+                    throw new Error('Slack HTTP Events API requires httpHostToken (Runtime Host)');
+                }
+                this.#routeReleases.push(...registerSlackWebhookRoutes(http, this));
+                this.#logger.debug(formatCompact({
+                    endpoint: config.id,
+                    op: 'webhook',
+                    path: config.webhookPath,
+                }));
+            }
+            const authTest = await this.#client.auth.test();
+            if (authTest.user_id)
+                this.#botUserId = String(authTest.user_id);
+            this.#logger.info(`connected (${config.mode})`
+                + (this.#botUserId ? ` | user: ${this.#botUserId}` : ''));
+        }
+        catch (error) {
+            await this.stop();
+            this.#logger.error('Failed to connect Slack endpoint:', error);
+            throw error;
+        }
+    }
+    open() {
+        this.#open = true;
+    }
+    close() {
+        this.#open = false;
+    }
+    async stop() {
+        this.#open = false;
+        if (this.#socket) {
+            try {
+                await this.#socket.disconnect();
+            }
+            catch {
+                /* ignore */
+            }
+            this.#socket = undefined;
+        }
+        for (const release of this.#routeReleases.splice(0))
+            release();
+        this.#client = undefined;
+        this.#started = false;
+        this.#logger.debug(formatCompact({ op: 'disconnect' }));
+    }
+    async send({ conversation, payload }) {
+        if (!this.#client)
+            throw new Error('Slack client not connected');
+        const channel = conversation.id;
+        const threadTs = conversation.threadId;
+        const result = await sendSlackContent(this.#client, payload, { channel, threadTs }, this.#logger);
+        this.trackMessageChannel(result.ts, channel);
+        return formatSlackMessageRef(channel, result.ts);
+    }
+    /** Test / internal: admit a message event when open. */
+    admit(event) {
+        if (!this.#open)
+            return;
+        void this.#emitPlatformEvent(event.type || 'event', event);
+        if (event.type !== 'message' && event.type !== 'app_mention')
+            return;
+        const msg = event;
+        if (shouldDropSlackInboundMessage(msg, this.#inboundFilter, this.#botUserId))
+            return;
+        if (!msg.channel || !msg.ts)
+            return;
+        this.trackMessageChannel(msg.ts, msg.channel);
+        const threadTs = msg.thread_ts && msg.thread_ts !== msg.ts ? msg.thread_ts : undefined;
+        const conversation = slackInboundConversation(String(this.#options.id), {
+            channelId: msg.channel,
+            channelType: msg.channel_type,
+            threadId: threadTs,
+        });
+        void this.emit('message.receive', {
+            conversation,
+            message: { conversation, id: msg.ts },
+            content: formatInboundContent(msg),
+            sender: { id: msg.user ?? msg.channel ?? '' },
+            endpointId: this.#options.config.id,
+            ...(msg.type === 'app_mention' ? { mentioned: true } : {}),
+            metadata: Object.freeze({
+                channelType: resolveSlackChannelType(msg),
+                userId: msg.user,
+                threadTs,
+                ts: msg.ts,
+            }),
+        }).catch((err) => {
+            this.#logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: `${conversation.kind}:${conversation.id}`,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    admitInteraction(payload) {
+        if (!this.#open)
+            return;
+        void this.#emitPlatformEvent(`interaction.${payload.type}`, payload);
+        if (payload.type !== 'block_actions' || !payload.actions?.length)
+            return;
+        const channelId = payload.channel?.id ?? '';
+        const userId = payload.user.id;
+        const messageTs = payload.message?.ts ?? '';
+        if (payload.response_url) {
+            postSlackEphemeral(payload.response_url, '已收到', this.#logger);
+        }
+        const actionTs = payload.actions[0]?.action_ts ?? messageTs ?? `action-${Date.now()}`;
+        const conversation = slackInboundConversation(String(this.#options.id), {
+            channelId: channelId || userId,
+            // block_actions 无 channel_type；无 channel 时按与发起用户的 DM 处理
+            channelType: channelId ? undefined : 'im',
+        });
+        void this.emit('message.receive', {
+            conversation,
+            message: { conversation, id: actionTs },
+            content: formatInteractionContent(payload),
+            sender: { id: userId },
+            endpointId: this.#options.config.id,
+            metadata: Object.freeze({
+                eventType: 'block_actions',
+                actionId: payload.actions[0]?.action_id,
+                threadTs: messageTs || undefined,
+            }),
+        }).catch((err) => {
+            this.#logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: `${conversation.kind}:${conversation.id}`,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    admitSlashCommand(cmd) {
+        if (!this.#open)
+            return;
+        void this.#emitPlatformEvent(`slash.${cmd.command}`, cmd);
+        postSlackEphemeral(cmd.response_url, '处理中…', this.#logger);
+        const conversation = slackInboundConversation(String(this.#options.id), {
+            channelId: cmd.channel_id,
+        });
+        void this.emit('message.receive', {
+            conversation,
+            message: { conversation, id: cmd.trigger_id },
+            content: formatSlashContent(cmd),
+            sender: { id: cmd.user_id, name: cmd.user_name },
+            endpointId: this.#options.config.id,
+            metadata: Object.freeze({
+                eventType: 'slash_command',
+                command: cmd.command,
+            }),
+        }).catch((err) => {
+            this.#logger.warn(formatCompact({
+                op: 'slack_gateway_receive_failed',
+                target: `${conversation.kind}:${conversation.id}`,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+    }
+    handleEnvelope(body) {
+        const envelope = body;
+        if (envelope?.type === 'event_callback' && envelope.event) {
+            const event = envelope.event;
+            if (event.type !== 'message' && event.type !== 'app_mention') {
+                void this.#emitPlatformEvent(event.type || 'event', event);
+                receiveSlackSideEvent((name, payload) => this.emit(name, payload), String(this.#options.id), this.#options.config.id, event, this.#logger);
+                return;
+            }
+            this.admit(event);
+        }
+    }
+    trackMessageChannel(ts, channel) {
+        if (!ts || !channel)
+            return;
+        // LRU：超 1024 条淘汰最久未更新的记录，避免无界增长。
+        if (this.#messageChannelMap.has(ts))
+            this.#messageChannelMap.delete(ts);
+        this.#messageChannelMap.set(ts, channel);
+        if (this.#messageChannelMap.size > 1024) {
+            const oldest = this.#messageChannelMap.keys().next().value;
+            if (oldest != null)
+                this.#messageChannelMap.delete(oldest);
+        }
+    }
+    resolveMessageRef(messageId, channelHint) {
+        const parsed = parseSlackMessageRef(messageId);
+        if (parsed) {
+            this.trackMessageChannel(parsed.ts, parsed.channel);
+            return parsed;
+        }
+        if (channelHint)
+            return { channel: channelHint, ts: messageId };
+        const channel = this.#messageChannelMap.get(messageId);
+        return channel ? { channel, ts: messageId } : null;
+    }
+    async recallMessage(messageId) {
+        if (!this.#client)
+            return;
+        const ref = this.resolveMessageRef(messageId);
+        if (!ref)
+            return;
+        await this.#client.chat.delete({ channel: ref.channel, ts: ref.ts });
+    }
+    async #editMessage(channel, messageTs, content) {
+        if (!this.#client)
+            throw new Error('Slack client not connected');
+        await editSlackContent(this.#client, channel, messageTs, content);
+    }
+    async #addReaction(channel, timestamp, name) {
+        const reaction = normalizeSlackReactionName(name);
+        try {
+            await this.#client.reactions.add({ channel, timestamp, name: reaction });
+        }
+        catch (error) {
+            const code = error?.data?.error;
+            if (code === 'already_reacted')
+                return;
+            throw error;
+        }
+    }
+    async #removeReaction(channel, timestamp, name) {
+        const reaction = normalizeSlackReactionName(name);
+        try {
+            await this.#client.reactions.remove({ channel, timestamp, name: reaction });
+        }
+        catch (error) {
+            const code = error?.data?.error;
+            if (code === 'no_reaction')
+                return;
+            throw error;
+        }
+    }
+    async #emitPlatformEvent(name, event) {
+        await this.emitPlatform(name, event).catch((error) => {
+            this.#logger.warn(formatCompact({
+                op: 'slack_platform_event_failed',
+                event: name,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        });
+    }
+    async #startSocket() {
+        const { config } = this.#options;
+        if (!config.appToken) {
+            throw new Error('Slack Socket Mode 需要 appToken（xapp- 前缀的 App-Level Token）；注意 bot token 填 token 字段（xoxb- 前缀），两者不可混用');
+        }
+        if (!config.appToken.startsWith('xapp-')) {
+            throw new Error(`Slack appToken 格式不正确：Socket Mode 需要 xapp- 前缀的 App-Level Token（当前看起来是 ${config.appToken.slice(0, 5)}…，xoxb- 是 bot token，请填到 token 字段）`);
+        }
+        this.#socket = this.#options.createSocket?.({
+            appToken: config.appToken,
+            clientPingTimeout: config.clientPingTimeout,
+        }) ?? new SocketModeClient({
+            appToken: config.appToken,
+            clientPingTimeout: config.clientPingTimeout,
+        });
+        this.#socket.on('slack_event', async ({ ack, body }) => {
+            await ack();
+            this.handleEnvelope(body);
+        });
+        this.#socket.on('interactive', async ({ ack, body }) => {
+            await ack();
+            this.admitInteraction(body);
+        });
+        this.#socket.on('slash_commands', async ({ ack, body }) => {
+            await ack();
+            this.admitSlashCommand(body);
+        });
+        await this.#socket.start();
+    }
+}
+/** Slack Web API 分页上限（每页 1000，cursor 翻页直到 next_cursor 为空）。 */
+const SLACK_LIST_PAGE_SIZE = 1000;
+function createSlackEndpointManagement(requireClient) {
+    return Object.freeze({
+        // Slack 无"群"概念：public channel 归一为 group（channel 语义由 listChannels 之外省略，
+        // Slack channel 本身就是会话载体，避免同一批数据在两个列表里重复）。
+        async listGroups() {
+            const client = requireClient();
+            const groups = [];
+            let cursor;
+            do {
+                const page = await client.conversations.list({
+                    types: 'public_channel',
+                    exclude_archived: true,
+                    limit: SLACK_LIST_PAGE_SIZE,
+                    ...(cursor ? { cursor } : {}),
+                });
+                for (const value of page.channels ?? []) {
+                    const channel = asRecord(value);
+                    const id = typeof channel.id === 'string' ? channel.id : '';
+                    if (!id)
+                        continue;
+                    groups.push({ group_id: id, name: String(channel.name ?? id) });
+                }
+                cursor = page.response_metadata?.next_cursor || undefined;
+            } while (cursor);
+            return groups;
+        },
+        // Slack 无"好友"概念：workspace 成员归一为 friend；nickname 取 real_name 回退 name。
+        async listFriends() {
+            const client = requireClient();
+            const friends = [];
+            let cursor;
+            do {
+                const page = await client.users.list({
+                    limit: SLACK_LIST_PAGE_SIZE,
+                    ...(cursor ? { cursor } : {}),
+                });
+                for (const value of page.members ?? []) {
+                    const user = asRecord(value);
+                    const id = typeof user.id === 'string' ? user.id : '';
+                    if (!id || user.deleted === true)
+                        continue;
+                    const profile = asRecord(user.profile);
+                    friends.push({
+                        user_id: id,
+                        nickname: String(profile.real_name ?? user.real_name ?? user.name ?? id),
+                        remark: '',
+                    });
+                }
+                cursor = page.response_metadata?.next_cursor || undefined;
+            } while (cursor);
+            return friends;
+        },
+        // conversations.members 只回 user id 列表（平台形状），逐 user 拉 profile 成本由调用方决定。
+        async listGroupMembers(groupId) {
+            const client = requireClient();
+            const result = await client.conversations.members({ channel: groupId });
+            return result.members ?? [];
+        },
+    });
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object'
+        ? value
+        : {};
+}