@shipfox/api-integration-slack 10.2.0 → 12.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-integration-slack",
   "license": "MIT",
-  "version": "10.2.0",
+  "version": "12.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -15,22 +15,26 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./agent-tools": {
+      "types": "./dist/core/agent-tools.d.ts",
+      "default": "./dist/core/agent-tools.js"
     }
   },
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "ky": "^2.0.0",
     "zod": "^4.4.3",
-    "@shipfox/api-auth-context": "10.2.0",
-    "@shipfox/api-integration-spi": "0.2.2",
-    "@shipfox/api-integration-slack-dto": "9.0.2",
-    "@shipfox/api-workspaces-dto": "10.2.0",
+    "@shipfox/api-auth-context": "12.0.0",
+    "@shipfox/api-integration-spi": "1.0.0",
+    "@shipfox/api-integration-slack-dto": "12.0.0",
+    "@shipfox/api-workspaces-dto": "12.0.0",
     "@shipfox/config": "1.2.4",
-    "@shipfox/inter-module": "0.2.2",
-    "@shipfox/node-drizzle": "0.3.4",
-    "@shipfox/node-fastify": "0.4.0",
+    "@shipfox/inter-module": "0.2.3",
+    "@shipfox/node-drizzle": "0.3.5",
+    "@shipfox/node-fastify": "0.4.1",
     "@shipfox/node-opentelemetry": "0.6.3",
-    "@shipfox/node-postgres": "0.4.4"
+    "@shipfox/node-postgres": "0.5.0"
   },
   "imports": {
     "#*": "./dist/*"

package/src/core/agent-tools-provider.test.ts

@@ -92,17 +92,17 @@ describe('SlackAgentToolsProvider', () => {
   it('dispatches a read method and returns the Slack response as structured content', async () => {
     const body = {ok: true, messages: [{text: 'Hello'}]};
     const options = providerOptions(async () => body);
-    const session = await openSession(options, ['conversations_history']);
+    const session = await openSession(options, ['read_channel']);
 
     const result = await session.call({
-      toolId: 'conversations_history',
-      arguments: {channel: 'C123', limit: 10},
+      toolId: 'read_channel',
+      arguments: {channel_id: 'C123', limit: 10},
     });
 
     expect(options.slack.callMethod).toHaveBeenCalledWith({
       method: 'conversations.history',
       token: 'xoxb-token',
-      arguments: {channel: 'C123', limit: 10},
+      arguments: expect.objectContaining({channel: 'C123', limit: 10}),
     });
     expect(result).toEqual({
       content: [{type: 'text', text: JSON.stringify(body)}],
@@ -110,58 +110,105 @@ describe('SlackAgentToolsProvider', () => {
     });
   });
 
-  it('passes a thread timestamp through to the message-posting method', async () => {
+  it('translates message parameters to their Slack Web API names', async () => {
     const options = providerOptions(async () => ({ok: true, ts: '456.000'}));
-    const session = await openSession(options, ['chat_postMessage']);
+    const session = await openSession(options, ['send_message']);
 
     await session.call({
-      toolId: 'chat_postMessage',
-      arguments: {channel: 'C123', text: 'Reply', thread_ts: '123.000'},
+      toolId: 'send_message',
+      arguments: {channel_id: 'C123', message: 'Reply', thread_ts: '123.000'},
     });
 
     expect(options.slack.callMethod).toHaveBeenCalledWith({
       method: 'chat.postMessage',
       token: 'xoxb-token',
-      arguments: {channel: 'C123', text: 'Reply', thread_ts: '123.000'},
+      arguments: {
+        channel: 'C123',
+        text: 'Reply',
+        blocks: [{type: 'markdown', text: 'Reply'}],
+        thread_ts: '123.000',
+        reply_broadcast: undefined,
+      },
     });
   });
 
+  it('applies the tool result mapping before returning content to the agent', async () => {
+    const body = {
+      ok: true,
+      channels: [
+        {id: 'C1', name: 'deploy-prod'},
+        {id: 'C2', name: 'design'},
+      ],
+    };
+    const options = providerOptions(async () => body);
+    const session = await openSession(options, ['search_channels']);
+
+    const result = await session.call({
+      toolId: 'search_channels',
+      arguments: {query: 'deploy'},
+    });
+
+    expect(result.structuredContent).toEqual({...body, channels: [body.channels[0]]});
+  });
+
   it('rejects a tool that was not selected for the session', async () => {
     const options = providerOptions(async () => ({ok: true}));
-    const session = await openSession(options, ['conversations_history']);
+    const session = await openSession(options, ['read_channel']);
 
-    const result = await session.call({toolId: 'users_info', arguments: {user: 'U123'}});
+    const result = await session.call({
+      toolId: 'read_user_profile',
+      arguments: {user_id: 'U123'},
+    });
 
     expect(result).toEqual({
       isError: true,
-      content: [{type: 'text', text: 'Unknown Slack tool: users_info'}],
+      content: [{type: 'text', text: 'Unknown Slack tool: read_user_profile'}],
     });
     expect(options.slack.callMethod).not.toHaveBeenCalled();
   });
 
   it('rejects a call missing a required parameter', async () => {
     const options = providerOptions(async () => ({ok: true}));
-    const session = await openSession(options, ['conversations_replies']);
+    const session = await openSession(options, ['read_thread']);
 
     const result = await session.call({
-      toolId: 'conversations_replies',
-      arguments: {channel: 'C123'},
+      toolId: 'read_thread',
+      arguments: {channel_id: 'C123'},
     });
 
     expect(result).toEqual({
       isError: true,
-      content: [{type: 'text', text: 'Missing required parameter: ts'}],
+      content: [{type: 'text', text: 'Missing required parameter: message_ts'}],
+    });
+    expect(options.slack.callMethod).not.toHaveBeenCalled();
+  });
+
+  it('rejects a message over the Slack Markdown block limit before calling Slack', async () => {
+    const options = providerOptions(async () => ({ok: true, ts: '456.000'}));
+    const session = await openSession(options, ['send_message']);
+
+    const result = await session.call({
+      toolId: 'send_message',
+      arguments: {channel_id: 'C123', message: 'a'.repeat(12_001)},
+    });
+
+    expect(result).toMatchObject({
+      isError: true,
+      content: [
+        {type: 'text', text: expect.stringContaining('12,000-character Markdown block limit')},
+      ],
+      structuredContent: {code: 'content-too-large'},
     });
     expect(options.slack.callMethod).not.toHaveBeenCalled();
   });
 
   it('returns a Slack application error to the agent', async () => {
     const options = providerOptions(async () => ({ok: false, error: 'channel_not_found'}));
-    const session = await openSession(options, ['conversations_history']);
+    const session = await openSession(options, ['read_channel']);
 
     const result = await session.call({
-      toolId: 'conversations_history',
-      arguments: {channel: 'C123'},
+      toolId: 'read_channel',
+      arguments: {channel_id: 'C123'},
     });
 
     expect(result).toEqual({
@@ -172,11 +219,11 @@ describe('SlackAgentToolsProvider', () => {
 
   it('returns auth failures with a stable access-denied code and logs only metadata', async () => {
     const options = providerOptions(async () => ({ok: false, error: 'invalid_auth'}));
-    const session = await openSession(options, ['conversations_history']);
+    const session = await openSession(options, ['read_channel']);
 
     const result = await session.call({
-      toolId: 'conversations_history',
-      arguments: {channel: 'C123'},
+      toolId: 'read_channel',
+      arguments: {channel_id: 'C123'},
     });
 
     expect(result).toMatchObject({
@@ -193,9 +240,9 @@ describe('SlackAgentToolsProvider', () => {
 
   it('returns an HTTP-200 rate-limit response with a stable code', async () => {
     const options = providerOptions(async () => ({ok: false, error: 'ratelimited'}));
-    const session = await openSession(options, ['conversations_list']);
+    const session = await openSession(options, ['search_channels']);
 
-    const result = await session.call({toolId: 'conversations_list', arguments: {}});
+    const result = await session.call({toolId: 'search_channels', arguments: {query: 'deploy'}});
 
     expect(result).toMatchObject({
       isError: true,
@@ -207,9 +254,9 @@ describe('SlackAgentToolsProvider', () => {
     const options = providerOptions(() =>
       Promise.reject(new SlackIntegrationProviderError('rate-limited', 'Try again later', 19)),
     );
-    const session = await openSession(options, ['conversations_list']);
+    const session = await openSession(options, ['search_channels']);
 
-    const result = await session.call({toolId: 'conversations_list', arguments: {}});
+    const result = await session.call({toolId: 'search_channels', arguments: {query: 'deploy'}});
 
     expect(result).toMatchObject({
       isError: true,
@@ -224,11 +271,11 @@ describe('SlackAgentToolsProvider', () => {
         new SlackIntegrationProviderError('content-too-large', 'Slack content was too large'),
       ),
     );
-    const session = await openSession(options, ['chat_postMessage']);
+    const session = await openSession(options, ['send_message']);
 
     const result = await session.call({
-      toolId: 'chat_postMessage',
-      arguments: {channel: 'C123', blocks: []},
+      toolId: 'send_message',
+      arguments: {channel_id: 'C123', message: 'Too large'},
     });
 
     expect(result).toMatchObject({
@@ -246,7 +293,7 @@ describe('SlackAgentToolsProvider', () => {
 
     const result = provider.openSession({
       connection: slackConnection(),
-      tools: [catalogTool('conversations_list')],
+      tools: [catalogTool('search_channels')],
       scope: {provider: 'slack'},
     });
 

package/src/core/agent-tools-provider.ts

@@ -7,10 +7,11 @@ import type {
 import {logger} from '@shipfox/node-opentelemetry';
 import type {SlackApiClient, SlackWebApiResponse} from '#api/client.js';
 import {
-  SLACK_TOOL_METHODS,
+  SLACK_TOOL_OPERATIONS,
   type SlackAgentToolCatalogEntry,
   type SlackAgentToolId,
   type SlackAgentToolRequiredScope,
+  type SlackToolOperation,
   slackAgentToolCatalog,
   slackAgentToolSelectionCatalog,
 } from '#core/agent-tools.js';
@@ -62,19 +63,23 @@ export class SlackAgentToolsProvider
       call: async (call) => {
         const tool = input.tools.find((candidate) => candidate.id === call.toolId);
         if (!tool) return slackToolError(`Unknown Slack tool: ${call.toolId}`);
-        const method = slackToolMethod(tool.id);
-        if (!method) return slackToolError(`Unknown Slack tool method: ${tool.id}`);
+        const operation = slackToolOperation(tool.id);
+        if (!operation) return slackToolError(`Unknown Slack tool method: ${tool.id}`);
         const missingParameter = missingRequiredParameter(tool, call.arguments);
         if (missingParameter) {
           return slackToolError(`Missing required parameter: ${missingParameter}`);
         }
+        const validationError = operation.validate?.(call.arguments);
+        if (validationError) {
+          return slackToolError(validationError.message, {code: validationError.code});
+        }
 
         let body: SlackWebApiResponse;
         try {
           body = await this.options.slack.callMethod({
-            method,
+            method: operation.method,
             token,
-            arguments: call.arguments,
+            arguments: operation.mapArguments(call.arguments),
           });
         } catch (error) {
           if (error instanceof SlackIntegrationProviderError) {
@@ -86,7 +91,9 @@ export class SlackAgentToolsProvider
           throw error;
         }
 
-        if (body.ok) return slackToolResult(body);
+        if (body.ok) {
+          return slackToolResult(operation.mapOutput?.(body, call.arguments) ?? body);
+        }
         const slackError = typeof body.error === 'string' ? body.error : 'Slack request failed';
         if (isSlackAccessError(slackError)) {
           logger().warn(
@@ -105,8 +112,8 @@ export class SlackAgentToolsProvider
   }
 }
 
-function slackToolMethod(toolId: string): string | undefined {
-  return SLACK_TOOL_METHODS[toolId as SlackAgentToolId];
+function slackToolOperation(toolId: string): SlackToolOperation | undefined {
+  return SLACK_TOOL_OPERATIONS[toolId as SlackAgentToolId];
 }
 
 function missingRequiredParameter(

package/src/core/agent-tools.test.ts

@@ -1,22 +1,36 @@
 import {
-  SLACK_TOOL_METHODS,
+  SLACK_TOOL_OPERATIONS,
   type SlackAgentToolId,
+  type SlackToolOperation,
   slackAgentToolCatalog,
   slackAgentToolSelectionCatalog,
 } from './agent-tools.js';
 
 const expectedTools = [
-  {id: 'conversations_history', sensitivity: 'read', requiredScope: 'read'},
-  {id: 'conversations_replies', sensitivity: 'read', requiredScope: 'read'},
-  {id: 'conversations_list', sensitivity: 'read', requiredScope: 'read'},
-  {id: 'users_info', sensitivity: 'read', requiredScope: 'read'},
-  {id: 'chat_postMessage', sensitivity: 'write', requiredScope: 'write'},
-  {id: 'chat_update', sensitivity: 'write', requiredScope: 'write'},
-  {id: 'reactions_add', sensitivity: 'write', requiredScope: 'write'},
+  {id: 'read_channel', sensitivity: 'read', requiredScope: 'read'},
+  {id: 'read_thread', sensitivity: 'read', requiredScope: 'read'},
+  {id: 'read_channel_info', sensitivity: 'read', requiredScope: 'read'},
+  {id: 'read_channel_members', sensitivity: 'read', requiredScope: 'read'},
+  {id: 'read_user_profile', sensitivity: 'read', requiredScope: 'read'},
+  {id: 'search_channels', sensitivity: 'read', requiredScope: 'read'},
+  {id: 'send_message', sensitivity: 'write', requiredScope: 'write'},
+  {id: 'schedule_message', sensitivity: 'write', requiredScope: 'write'},
+  {id: 'update_message', sensitivity: 'write', requiredScope: 'write'},
+  {id: 'add_reaction', sensitivity: 'write', requiredScope: 'write'},
+  {id: 'create_canvas', sensitivity: 'write', requiredScope: 'write'},
 ] as const;
 
+function operation(id: SlackAgentToolId): SlackToolOperation {
+  return SLACK_TOOL_OPERATIONS[id];
+}
+
+function channelIdDescription(inputSchema: Record<string, unknown>): string | undefined {
+  const properties = inputSchema.properties as Record<string, {description?: string}> | undefined;
+  return properties?.channel_id?.description;
+}
+
 describe('slackAgentToolCatalog', () => {
-  it('defines the seven Slack tools with their access requirements', () => {
+  it('defines the Slack tools with their access requirements', () => {
     const tools = slackAgentToolCatalog.map(({id, sensitivity, requiredScope, sensitive}) => ({
       id,
       sensitivity,
@@ -33,46 +47,203 @@ describe('slackAgentToolCatalog', () => {
       type: inputSchema.type,
     }));
 
-    expect(schemas).toHaveLength(7);
+    expect(schemas).toHaveLength(expectedTools.length);
     expect(
       schemas.every(({description, type}) => description.length > 0 && type === 'object'),
     ).toBe(true);
   });
 
-  it('models Block Kit messages and Slack scalar parameters without narrowing valid calls', () => {
-    const postMessage = slackAgentToolCatalog.find(({id}) => id === 'chat_postMessage');
-    const listConversations = slackAgentToolCatalog.find(({id}) => id === 'conversations_list');
-    const history = slackAgentToolCatalog.find(({id}) => id === 'conversations_history');
+  it('names message parameters the way the Slack MCP server does', () => {
+    const sendMessage = slackAgentToolCatalog.find(({id}) => id === 'send_message');
+    const readThread = slackAgentToolCatalog.find(({id}) => id === 'read_thread');
 
-    expect(postMessage?.inputSchema).toMatchObject({
-      required: ['channel'],
-      properties: {
-        blocks: {type: 'array', items: {type: 'object'}},
-        thread_ts: {type: 'string'},
-      },
-    });
-    expect(listConversations?.inputSchema).toMatchObject({
-      properties: {types: {type: 'string'}, limit: {type: 'number'}},
+    expect(sendMessage?.inputSchema).toMatchObject({
+      required: ['channel_id', 'message'],
+      properties: {message: {type: 'string', maxLength: 12_000}, thread_ts: {type: 'string'}},
     });
-    expect(history?.inputSchema).toMatchObject({
-      properties: {oldest: {type: 'string'}, latest: {type: 'string'}},
+    expect(readThread?.inputSchema).toMatchObject({
+      required: ['channel_id', 'message_ts'],
+      properties: {limit: {type: 'integer'}, cursor: {type: 'string'}},
     });
   });
 
+  it('offers user-ID targeting only on the tools whose Slack method resolves one', () => {
+    const targetDescriptions = new Map(
+      slackAgentToolCatalog
+        .filter(({inputSchema}) => channelIdDescription(inputSchema) !== undefined)
+        .map(({id, inputSchema}) => [id, channelIdDescription(inputSchema) ?? '']),
+    );
+    const acceptsUserId = [...targetDescriptions]
+      .filter(([, description]) => description.includes('Pass a user ID'))
+      .map(([id]) => id);
+
+    expect(acceptsUserId).toEqual(['send_message', 'schedule_message']);
+    expect(targetDescriptions.get('read_channel')).toContain('not accepted');
+  });
+
   it('maps every tool id to its dotted Slack Web API method', () => {
     const methods = Object.fromEntries(
-      slackAgentToolCatalog.map(({id}) => [id, SLACK_TOOL_METHODS[id as SlackAgentToolId]]),
+      slackAgentToolCatalog.map(({id}) => [id, operation(id).method]),
     );
 
     expect(methods).toEqual({
-      conversations_history: 'conversations.history',
-      conversations_replies: 'conversations.replies',
-      conversations_list: 'conversations.list',
-      users_info: 'users.info',
-      chat_postMessage: 'chat.postMessage',
-      chat_update: 'chat.update',
-      reactions_add: 'reactions.add',
+      read_channel: 'conversations.history',
+      read_thread: 'conversations.replies',
+      read_channel_info: 'conversations.info',
+      read_channel_members: 'conversations.members',
+      read_user_profile: 'users.info',
+      search_channels: 'conversations.list',
+      send_message: 'chat.postMessage',
+      schedule_message: 'chat.scheduleMessage',
+      update_message: 'chat.update',
+      add_reaction: 'reactions.add',
+      create_canvas: 'canvases.create',
+    });
+  });
+
+  it('translates channel and message identifiers to Slack Web API parameters', () => {
+    expect(
+      operation('read_channel').mapArguments({channel_id: 'C123', limit: 10, cursor: 'next'}),
+    ).toMatchObject({channel: 'C123', limit: 10, cursor: 'next'});
+    expect(
+      operation('read_thread').mapArguments({channel_id: 'C123', message_ts: '123.000'}),
+    ).toMatchObject({channel: 'C123', ts: '123.000'});
+    expect(operation('read_user_profile').mapArguments({user_id: 'U123'})).toMatchObject({
+      user: 'U123',
+    });
+    expect(operation('read_channel_info').mapArguments({channel_id: 'C123'})).toMatchObject({
+      channel: 'C123',
+    });
+    expect(
+      operation('read_channel_members').mapArguments({channel_id: 'C123', cursor: 'next'}),
+    ).toMatchObject({channel: 'C123', cursor: 'next'});
+    expect(
+      operation('add_reaction').mapArguments({
+        channel_id: 'C123',
+        message_ts: '123.000',
+        emoji: 'tada',
+      }),
+    ).toMatchObject({channel: 'C123', timestamp: '123.000', name: 'tada'});
+  });
+
+  it('sends message content as a Markdown block with a stripped plain-text fallback', () => {
+    const args = {channel_id: 'C123', message: '**Deployed** to production'};
+
+    expect(operation('send_message').mapArguments(args)).toMatchObject({
+      channel: 'C123',
+      text: 'Deployed to production',
+      blocks: [{type: 'markdown', text: '**Deployed** to production'}],
     });
+    expect(
+      operation('update_message').mapArguments({...args, message_ts: '123.000'}),
+    ).toMatchObject({ts: '123.000', blocks: [{type: 'markdown', text: args.message}]});
+  });
+
+  it('strips Markdown syntax from the notification fallback but not the Markdown block', () => {
+    const message = '**bold** _italic_ ~~gone~~ `code` [docs](https://example.com/x)\n> a quote';
+
+    const {text, blocks} = operation('send_message').mapArguments({channel_id: 'C123', message});
+
+    expect(text).toBe('bold italic gone code docs (https://example.com/x)\na quote');
+    expect(blocks).toEqual([{type: 'markdown', text: message}]);
+  });
+
+  it('preserves Markdown-looking characters inside code spans in the fallback', () => {
+    const message = 'run `*args, **kwargs` then\n```py\n**not bold**\n```\ndone';
+
+    const {text} = operation('send_message').mapArguments({channel_id: 'C123', message});
+
+    expect(text).toBe('run *args, **kwargs then\n**not bold**\ndone');
+  });
+
+  it('does not let a NUL-delimited numeric sequence in the message collide with the internal code-span placeholder', () => {
+    const nul = String.fromCharCode(0);
+    const message = `call me at ${nul}0${nul} please and \`use code\``;
+
+    const {text} = operation('send_message').mapArguments({channel_id: 'C123', message});
+
+    expect(text).toBe('call me at 0 please and use code');
+  });
+
+  it('schedules a message with its send time and thread target', () => {
+    expect(
+      operation('schedule_message').mapArguments({
+        channel_id: 'C123',
+        message: 'Standup in 5',
+        post_at: 1700000000,
+        thread_ts: '123.000',
+        reply_broadcast: true,
+      }),
+    ).toMatchObject({
+      channel: 'C123',
+      text: 'Standup in 5',
+      blocks: [{type: 'markdown', text: 'Standup in 5'}],
+      post_at: 1700000000,
+      thread_ts: '123.000',
+      reply_broadcast: true,
+    });
+  });
+
+  it('rejects a message over the Slack Markdown block limit', () => {
+    const oversized = 'a'.repeat(12_001);
+    const fits = 'a'.repeat(12_000);
+
+    expect(operation('send_message').validate?.({message: oversized})).toMatchObject({
+      message: expect.stringContaining('12,000-character Markdown block limit'),
+      code: 'content-too-large',
+    });
+    expect(operation('schedule_message').validate?.({message: oversized})).toBeDefined();
+    expect(operation('update_message').validate?.({message: oversized})).toBeDefined();
+    expect(operation('send_message').validate?.({message: fits})).toBeUndefined();
+  });
+
+  it('counts Unicode code points, not UTF-16 code units, against the length limit', () => {
+    const emoji = '\u{1F600}';
+    // Each 😀 is a surrogate pair (2 UTF-16 units) but 1 code point: 6,001 code points fits the
+    // 12,000-character schema limit even though .length would report 12,002.
+    const sixThousandOneEmoji = emoji.repeat(6001);
+
+    expect(operation('send_message').validate?.({message: sixThousandOneEmoji})).toBeUndefined();
+    expect(operation('send_message').validate?.({message: emoji.repeat(12_001)})).toBeDefined();
+  });
+
+  it('wraps canvas content as a Markdown document', () => {
+    expect(operation('create_canvas').mapArguments({title: 'Runbook', content: '# Steps'})).toEqual(
+      {
+        title: 'Runbook',
+        document_content: {type: 'markdown', markdown: '# Steps'},
+      },
+    );
+  });
+
+  it('excludes archived channels unless the caller asks for them', () => {
+    expect(operation('search_channels').mapArguments({query: 'deploy'})).toMatchObject({
+      exclude_archived: true,
+    });
+    expect(
+      operation('search_channels').mapArguments({query: 'deploy', include_archived: true}),
+    ).toMatchObject({exclude_archived: false});
+  });
+
+  it('keeps only the channels matching every search term', () => {
+    const body = {
+      ok: true,
+      channels: [
+        {id: 'C1', name: 'deploy-prod', topic: {value: 'Release coordination'}},
+        {id: 'C2', name: 'deploy-staging', topic: {value: 'Scratch'}},
+        {id: 'C3', name: 'design', purpose: {value: 'Release notes'}},
+      ],
+    };
+
+    const result = operation('search_channels').mapOutput?.(body, {query: 'Deploy release'});
+
+    expect(result).toEqual({...body, channels: [body.channels[0]]});
+  });
+
+  it('returns the Slack response unchanged when the search query is empty', () => {
+    const body = {ok: true, channels: [{id: 'C1', name: 'deploy-prod'}]};
+
+    expect(operation('search_channels').mapOutput?.(body, {query: '   '})).toBe(body);
   });
 
   it('exposes one standalone selector per tool with matching sensitivity', () => {