@vertesia/workflow 1.5.0-dev.20260714.072725Z → 1.5.0-dev.20260722.120446Z

package/src/activities/generateOrAssignContentType.test.ts

@@ -0,0 +1,196 @@
+import { MockActivityEnvironment } from '@temporalio/testing';
+import type { VertesiaClient } from '@vertesia/client';
+import {
+    ContentEventName,
+    type ContentObjectTypeItem,
+    type DSLActivityExecutionPayload,
+    PDF_RENDITION_NAME,
+    type Rendition,
+} from '@vertesia/common';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ActivityContext } from '../dsl/setup/ActivityContext.js';
+import { executeInteractionFromActivity } from './executeInteraction.js';
+import {
+    type GenerateOrAssignContentTypeParams,
+    type GenerateOrAssignContentTypeResult,
+    generateOrAssignContentType,
+} from './generateOrAssignContentType.js';
+
+vi.mock('../dsl/setup/ActivityContext.js', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('../dsl/setup/ActivityContext.js')>();
+    return { ...actual, setupActivity: vi.fn() };
+});
+
+vi.mock('./executeInteraction.js', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('./executeInteraction.js')>();
+    return { ...actual, executeInteractionFromActivity: vi.fn() };
+});
+
+let testEnv: MockActivityEnvironment;
+
+beforeAll(() => {
+    testEnv = new MockActivityEnvironment();
+});
+
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+
+function payload(
+    params: GenerateOrAssignContentTypeParams,
+): DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams> {
+    return {
+        account_id: 'test-account',
+        activity: { name: 'generateOrAssignContentType', params: {} },
+        auth_token: 'mock-token',
+        config: { studio_url: 'http://mock-studio', store_url: 'http://mock-store' },
+        event: ContentEventName.create,
+        input: { inputType: 'objectIds', objectIds: ['object-1'] },
+        objectIds: ['object-1'],
+        params,
+        project_id: 'test-project',
+        vars: {},
+        workflow_name: 'test-workflow',
+    };
+}
+
+function typeItem(name: string, status?: ContentObjectTypeItem['status']): ContentObjectTypeItem {
+    return {
+        id: `type-${name}`,
+        name,
+        status,
+    } as ContentObjectTypeItem;
+}
+
+function mockSelectionResult(documentType: string) {
+    vi.mocked(executeInteractionFromActivity).mockResolvedValue({
+        id: 'run-1',
+        modelId: 'model-1',
+        result: {
+            object: vi.fn(() => ({ document_type: documentType })),
+        },
+    } as unknown as Awaited<ReturnType<typeof executeInteractionFromActivity>>);
+}
+
+async function mockSetup(
+    types: ContentObjectTypeItem[],
+    options: {
+        contentType?: string;
+        renditions?: Rendition[];
+        text?: string;
+    } = {},
+) {
+    const { setupActivity } = await import('../dsl/setup/ActivityContext.js');
+    const update = vi.fn(() => Promise.resolve({}));
+    const retrieveObject = vi.fn(() =>
+        Promise.resolve({
+            id: 'object-1',
+            content: { type: options.contentType ?? 'text/plain' },
+            metadata: { renditions: options.renditions },
+            text: options.text ?? 'Document text',
+        }),
+    );
+    const listTypes = vi.fn(() => Promise.resolve(types));
+
+    vi.mocked(setupActivity).mockImplementation((activityPayload) =>
+        Promise.resolve({
+            client: {
+                objects: {
+                    retrieve: retrieveObject,
+                    update,
+                },
+                types: {
+                    catalog: {
+                        list: listTypes,
+                    },
+                },
+            } as unknown as VertesiaClient,
+            fetchProject: vi.fn(() => Promise.resolve({ configuration: {} })),
+            objectId: 'object-1',
+            params: activityPayload.params,
+        } as unknown as ActivityContext<GenerateOrAssignContentTypeParams>),
+    );
+
+    return { listTypes, update };
+}
+
+describe('generateOrAssignContentType', () => {
+    it('excludes draft types from selection and does not assign them if returned by the model', async () => {
+        const { update } = await mockSetup([
+            typeItem('Invoice', 'active'),
+            typeItem('DraftInvoice', 'draft'),
+            typeItem('DocumentPart', 'active'),
+            typeItem('GenericDocument', 'active'),
+            typeItem('Rendition', 'active'),
+        ]);
+        mockSelectionResult('DraftInvoice');
+
+        const result: GenerateOrAssignContentTypeResult = await testEnv.run(
+            generateOrAssignContentType,
+            payload({ allowNewContentTypes: false }),
+        );
+
+        expect(executeInteractionFromActivity).toHaveBeenCalledWith(
+            expect.anything(),
+            'sys:SelectDocumentType',
+            expect.objectContaining({ allowNewContentTypes: false }),
+            expect.objectContaining({
+                existing_types: [
+                    expect.objectContaining({ name: 'Invoice' }),
+                    expect.objectContaining({ name: 'GenericDocument' }),
+                ],
+            }),
+        );
+        expect(update).toHaveBeenCalledWith('object-1', { type: 'sys:GenericDocument' }, { suppressWorkflows: true });
+        expect(result).toEqual({
+            id: 'sys:GenericDocument',
+            isNew: false,
+            name: 'GenericDocument',
+        });
+    });
+
+    it('uses a PDF rendition as visual evidence for PowerPoint type selection', async () => {
+        const pdfRendition = {
+            name: PDF_RENDITION_NAME,
+            content: {
+                name: 'slides.pdf',
+                source: 'renditions/source-etag/slides.pdf',
+                type: 'application/pdf',
+            },
+        };
+        const { update } = await mockSetup(
+            [typeItem('MarketPresentation', 'active'), typeItem('GenericDocument', 'active')],
+            {
+                contentType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+                renditions: [pdfRendition],
+                text: '',
+            },
+        );
+        mockSelectionResult('MarketPresentation');
+
+        const result: GenerateOrAssignContentTypeResult = await testEnv.run(
+            generateOrAssignContentType,
+            payload({ allowNewContentTypes: false }),
+        );
+
+        expect(executeInteractionFromActivity).toHaveBeenCalledWith(
+            expect.anything(),
+            'sys:SelectDocumentType',
+            expect.objectContaining({ allowNewContentTypes: false }),
+            expect.objectContaining({
+                content: undefined,
+                image: pdfRendition.content,
+            }),
+        );
+        expect(update).toHaveBeenCalledWith(
+            'object-1',
+            { type: 'type-MarketPresentation' },
+            { suppressWorkflows: true },
+        );
+        expect(result).toEqual({
+            id: 'type-MarketPresentation',
+            isNew: false,
+            name: 'MarketPresentation',
+        });
+    });
+});

package/src/activities/generateOrAssignContentType.ts

@@ -1,10 +1,14 @@
+import type { JSONSchema } from '@llumiverse/common';
 import { ApplicationFailure, log } from '@temporalio/activity';
 import {
     type ContentObjectTypeItem,
+    type ContentSource,
     type CreateContentObjectTypePayload,
     type DSLActivityExecutionPayload,
     type DSLActivitySpec,
     ImageRenditionFormat,
+    PDF_RENDITION_NAME,
+    type Rendition,
 } from '@vertesia/common';
 import { type ActivityContext, setupActivity } from '../dsl/setup/ActivityContext.js';
 import { type TruncateSpec, truncByMaxTokens } from '../utils/tokens.js';
@@ -75,9 +79,39 @@ export interface GenerateOrAssignContentType extends DSLActivitySpec<GenerateOrA
     name: 'generateOrAssignContentType';
 }
 
+export type GenerateOrAssignContentTypeResult =
+    | {
+          status: 'skipped';
+          message: string;
+      }
+    | {
+          status: 'failed';
+          error: 'no-text';
+      }
+    | {
+          id: string;
+          name: string;
+          isNew: boolean;
+      };
+
+function getPdfRenditionContent(doc: { metadata?: { renditions?: unknown } }): ContentSource | undefined {
+    const renditions = doc.metadata?.renditions;
+    if (!Array.isArray(renditions)) {
+        return undefined;
+    }
+    const pdfRendition = renditions.find(
+        (rendition): rendition is Rendition =>
+            typeof rendition === 'object' &&
+            rendition !== null &&
+            (rendition as { name?: unknown }).name === PDF_RENDITION_NAME &&
+            typeof (rendition as { content?: { source?: unknown } }).content?.source === 'string',
+    );
+    return pdfRendition?.content;
+}
+
 export async function generateOrAssignContentType(
     payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>,
-) {
+): Promise<GenerateOrAssignContentTypeResult> {
     const context = await setupActivity<GenerateOrAssignContentTypeParams>(payload);
     const { params, client, objectId } = context;
 
@@ -85,7 +119,7 @@ export async function generateOrAssignContentType(
 
     log.debug(`SelectDocumentType for object: ${objectId}`, { payload });
 
-    const object = await client.objects.retrieve(objectId, '+text');
+    const object = await client.objects.retrieve(objectId, '+text +metadata +content');
 
     //Expects object.type to be null on first ingestion of content
     //User initiated Content Type change via the Composable UI,
@@ -99,12 +133,13 @@ export async function generateOrAssignContentType(
         };
     }
 
-    if (
-        !object ||
-        (!object.text &&
-            !object.content?.type?.startsWith('image/') &&
-            !object.content?.type?.startsWith('application/pdf'))
-    ) {
+    const pdfRendition = getPdfRenditionContent(object);
+    const hasVisionSource =
+        object.content?.type?.startsWith('image/') ||
+        object.content?.type?.startsWith('application/pdf') ||
+        !!pdfRendition?.type?.startsWith('application/pdf');
+
+    if (!object || (!object.text && !hasVisionSource)) {
         log.info(`Object ${objectId} not found or text is empty and not an image`, {
             object,
         });
@@ -116,10 +151,13 @@ export async function generateOrAssignContentType(
     });
 
     //make a list of all existing types, and add hints if any
-    const existing_types = types.filter((t) => !['DocumentPart', 'Rendition'].includes(t.name));
+    const existing_types = types.filter((t) => !['DocumentPart', 'Rendition'].includes(t.name) && t.status !== 'draft');
     const content = object.text ? truncByMaxTokens(object.text, params.truncate || 30000) : undefined;
 
-    const getImage = async () => {
+    const getImage = async (): Promise<string | ContentSource | undefined> => {
+        if (pdfRendition?.type?.startsWith('application/pdf')) {
+            return pdfRendition;
+        }
         if (object.content?.type?.includes('pdf') && object.text?.length && object.text?.length < 100) {
             return `store:${objectId}`;
         }
@@ -140,18 +178,48 @@ export async function generateOrAssignContentType(
 
     const fileRef = await getImage();
 
+    // Slim catalog for the selection prompt: names + identification guidance only, NO schemas
+    // (design intake-v2 §3). The full list (with schemas) is still used for matching and for
+    // new-type generation below.
+    const selectionCatalog = existing_types.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        guidance: t.intake?.identification?.guidance,
+        distinguish_from: t.intake?.identification?.distinguish_from,
+    }));
+
+    // Closed-world output: constrain the result to the eligible type names + 'other', which
+    // removes the exact-string-match fragility on the model's answer.
+    const selectionResultSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+            document_type: {
+                type: 'string',
+                enum: [...existing_types.map((t) => t.name), 'other'],
+                description: "Name of the matching document type, or 'other' when none matches.",
+            },
+        },
+        required: ['document_type'],
+    };
+
     log.info(
-        'Execute SelectDocumentType interaction on content with \nexisting types - passing full types: ' +
-            existing_types.filter((t) => !t.tags?.includes('system')),
+        'Execute SelectDocumentType interaction on content with \nexisting types - passing slim catalog: ' +
+            existing_types.filter((t) => !t.tags?.includes('system')).map((t) => t.name),
     );
 
     let res: Awaited<ReturnType<typeof executeInteractionFromActivity>>;
     try {
-        res = await executeInteractionFromActivity(client, interactionName, params, {
-            existing_types,
-            content,
-            image: fileRef,
-        });
+        res = await executeInteractionFromActivity(
+            client,
+            interactionName,
+            { ...params, result_schema: selectionResultSchema },
+            {
+                existing_types: selectionCatalog,
+                content,
+                image: fileRef,
+            },
+        );
     } catch (error: unknown) {
         const selectionError = toRetryableError(error);
         log.error(`Failed to select document type`, { error: selectionError, retryable: selectionError.retryable });
@@ -180,20 +248,31 @@ export async function generateOrAssignContentType(
     log.debug(`Selected Content Type Result: ${JSON.stringify(jsonResult)}`);
 
     //if type is not identified or not present in the database, generate a new type
-    let selectedType: { id: string; name: string } | undefined;
+    let selectedType: { id: string; name: string; isNew: boolean } | undefined;
 
-    selectedType = types.find((t) => t.name === jsonResult.document_type);
+    const existingMatch = existing_types.find((t) => t.name === jsonResult.document_type);
+    if (existingMatch) {
+        selectedType = { id: existingMatch.id, name: existingMatch.name, isNew: false };
+    }
 
     if (!selectedType) {
         if (params.allowNewContentTypes === false) {
             // Type generation is disabled (handled separately, e.g. via the Studio Assistant), so
             // fall back to the project's default type (or sys:GenericDocument) rather than leaving
-            // the document untyped.
+            // the document untyped. 'other' is the constrained schema's first-class no-match
+            // answer, not a selection defect — only warn on anything else.
+            if (jsonResult.document_type && jsonResult.document_type !== 'other') {
+                log.warn('Document type selection returned an ineligible or unknown type; assigning fallback', {
+                    objectId,
+                    selectedDocumentType: jsonResult.document_type,
+                    eligibleTypes: existing_types.map((type) => type.name),
+                });
+            }
             selectedType = await resolveFallbackType(context, params.fallbackTypeId, jsonResult.document_type);
         } else {
             log.warn('Document type not identified: starting type generation');
             const newType = await generateNewType(context, existing_types, content, fileRef);
-            selectedType = { id: newType.id, name: newType.name };
+            selectedType = { id: newType.id, name: newType.name, isNew: true };
         }
     }
 
@@ -202,15 +281,21 @@ export async function generateOrAssignContentType(
         throw new Error(`Type not found: ${jsonResult.document_type}`);
     }
 
-    //update object with selected type
-    await client.objects.update(objectId, {
-        type: selectedType.id,
-    });
+    // Update object with selected type. Suppress workflow triggers: this is an intake-internal
+    // self-write — type updates now emit dirty.type and match the StandardIntake trigger, so an
+    // unsuppressed write here would recursively re-run intake on every type assignment.
+    await client.objects.update(
+        objectId,
+        {
+            type: selectedType.id,
+        },
+        { suppressWorkflows: true },
+    );
 
     return {
         id: selectedType.id,
         name: selectedType.name,
-        isNew: !types.find((t) => t.name === selectedType.name),
+        isNew: selectedType.isNew,
     };
 }
 
@@ -222,7 +307,7 @@ async function resolveFallbackType(
     context: ActivityContext<GenerateOrAssignContentTypeParams>,
     fallbackTypeId: string | undefined,
     selectedDocumentType: unknown,
-): Promise<{ id: string; name: string }> {
+): Promise<{ id: string; name: string; isNew: false }> {
     if (fallbackTypeId && fallbackTypeId !== GENERIC_DOCUMENT_TYPE_ID) {
         try {
             const resolved = await context.client.types.catalog.resolve(fallbackTypeId);
@@ -230,7 +315,7 @@ async function resolveFallbackType(
                 fallbackTypeId,
                 selectedDocumentType,
             });
-            return { id: resolved.id ?? fallbackTypeId, name: resolved.name ?? fallbackTypeId };
+            return { id: resolved.id ?? fallbackTypeId, name: resolved.name ?? fallbackTypeId, isNew: false };
         } catch (error) {
             log.warn('Configured default content type not resolvable; using GenericDocument', {
                 fallbackTypeId,
@@ -239,14 +324,14 @@ async function resolveFallbackType(
         }
     }
     log.info('Document type not identified; assigning GenericDocument fallback', { selectedDocumentType });
-    return { id: GENERIC_DOCUMENT_TYPE_ID, name: GENERIC_DOCUMENT_TYPE_NAME };
+    return { id: GENERIC_DOCUMENT_TYPE_ID, name: GENERIC_DOCUMENT_TYPE_NAME, isNew: false };
 }
 
 async function generateNewType(
     context: ActivityContext<GenerateOrAssignContentTypeParams>,
     existing_types: ContentObjectTypeItem[],
     content?: string,
-    fileRef?: string,
+    fileRef?: string | ContentSource,
 ) {
     const { client, params } = context;
 

package/src/activities/media/exec.test.ts

@@ -0,0 +1,194 @@
+import { MockActivityEnvironment } from '@temporalio/testing';
+import { describe, expect, it } from 'vitest';
+import { createFfmpegProgressTracker, execActivityFile, execActivityFileWithProgress } from './exec.js';
+
+describe('execActivityFile', () => {
+    it('should execute a child process inside an Activity context', async () => {
+        const testEnv = new MockActivityEnvironment();
+
+        const result = await testEnv.run(() =>
+            execActivityFile(process.execPath, ['-e', "process.stdout.write('completed')"]),
+        );
+
+        expect(result).toEqual({ stdout: 'completed', stderr: '' });
+    });
+
+    it('should terminate the child process when the Activity is cancelled', async () => {
+        const testEnv = new MockActivityEnvironment();
+        const execution = testEnv.run(() =>
+            execActivityFile(process.execPath, ['-e', 'setInterval(() => undefined, 1_000)']),
+        );
+        const rejection = expect(execution).rejects.toMatchObject({ name: 'AbortError' });
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        testEnv.cancel();
+
+        await rejection;
+    });
+
+    it('should terminate the child process before the Activity StartToClose timeout', async () => {
+        const testEnv = new MockActivityEnvironment({
+            currentAttemptScheduledTimestampMs: Date.now(),
+            startToCloseTimeoutMs: 500,
+        });
+
+        const execution = testEnv.run(() =>
+            execActivityFile(process.execPath, ['-e', 'setInterval(() => undefined, 1_000)']),
+        );
+
+        await expect(execution).rejects.toMatchObject({ killed: true });
+    });
+});
+
+describe('createFfmpegProgressTracker', () => {
+    it('reports advancement only when a monotonic field increases', () => {
+        const tracker = createFfmpegProgressTracker();
+        expect(tracker.observe('frame=1 time=00:00:00.10\n')).toBe(true);
+        expect(tracker.observe('frame=2 time=00:00:00.20\n')).toBe(true);
+        // A wedged encoder re-emitting an identical status line must not be mistaken for progress (P1).
+        expect(tracker.observe('frame=2 time=00:00:00.20\n')).toBe(false);
+        expect(tracker.observe('frame=2 time=00:00:00.20\n')).toBe(false);
+    });
+
+    it('advances on time= for audio-only output with no frame= field', () => {
+        const tracker = createFfmpegProgressTracker();
+        expect(tracker.observe('size=1024kB time=00:00:01.00 bitrate=209.7kbits/s\n')).toBe(true);
+        expect(tracker.observe('size=1024kB time=00:00:01.00 bitrate=209.7kbits/s\n')).toBe(false);
+        expect(tracker.observe('size=2048kB time=00:00:02.00 bitrate=209.7kbits/s\n')).toBe(true);
+    });
+
+    it('recognizes a marker split across stream chunks (P2)', () => {
+        const tracker = createFfmpegProgressTracker();
+        // No delimiter yet: the partial record is buffered rather than parsed.
+        expect(tracker.observe('fra')).toBe(false);
+        // Reassembled to `frame=7` once the record completes.
+        expect(tracker.observe('me=7\n')).toBe(true);
+    });
+
+    it('treats carriage-return-delimited snapshots as complete records', () => {
+        const tracker = createFfmpegProgressTracker();
+        expect(tracker.observe('frame=1\rframe=2\r')).toBe(true);
+        expect(tracker.observe('frame=2\r')).toBe(false);
+    });
+});
+
+describe('execActivityFileWithProgress', () => {
+    const activityEnv = () =>
+        new MockActivityEnvironment({
+            currentAttemptScheduledTimestampMs: Date.now(),
+            startToCloseTimeoutMs: 60_000,
+        });
+
+    // Timing-based cases run with generous timeouts so shared-CI CPU contention cannot flake them. The stall window is
+    // kept far larger than the progress cadence so a delayed-but-alive child is never mistaken for a wedged one.
+    const TIMING_TEST_TIMEOUT_MS = 20_000;
+
+    it(
+        'captures output and resolves when the command completes',
+        async () => {
+            const result = (await activityEnv().run(() =>
+                execActivityFileWithProgress(process.execPath, [
+                    '-e',
+                    "process.stderr.write('frame=1\\n'); process.stdout.write('ok')",
+                ]),
+            )) as { stdout: string; stderr: string };
+
+            expect(result.stdout).toBe('ok');
+            expect(result.stderr).toContain('frame=1');
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'terminates a child that reports progress and then stops',
+        async () => {
+            const execution = activityEnv().run(() =>
+                execActivityFileWithProgress(
+                    process.execPath,
+                    ['-e', "process.stderr.write('frame=1\\n'); setInterval(() => undefined, 1_000)"],
+                    { stallTimeoutMs: 300 },
+                ),
+            );
+
+            await expect(execution).rejects.toMatchObject({ stalled: true, killed: true });
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'terminates a child that keeps repeating the same progress line',
+        async () => {
+            // A wedged encoder that keeps flushing an identical status line must still be detected as stalled (P1).
+            const execution = activityEnv().run(() =>
+                execActivityFileWithProgress(
+                    process.execPath,
+                    ['-e', "setInterval(() => process.stderr.write('frame=1 time=00:00:01.00\\n'), 40)"],
+                    { stallTimeoutMs: 300 },
+                ),
+            );
+
+            await expect(execution).rejects.toMatchObject({ stalled: true, killed: true });
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'keeps running while the child continues to report progress',
+        async () => {
+            // Emit progress every 100ms for ~500ms against a 2s stall window: a healthy child must never trip it, even
+            // if CI scheduling delays some ticks.
+            const script = [
+                'let n = 0;',
+                'const timer = setInterval(() => {',
+                '    process.stderr.write(`frame=${++n}\\n`);',
+                '    if (n >= 5) {',
+                '        clearInterval(timer);',
+                '        process.exit(0);',
+                '    }',
+                '}, 100);',
+            ].join('\n');
+
+            const result = (await activityEnv().run(() =>
+                execActivityFileWithProgress(process.execPath, ['-e', script], { stallTimeoutMs: 2_000 }),
+            )) as { stdout: string; stderr: string };
+
+            expect(result.stderr).toContain('frame=5');
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'rejects with the exit code when the command fails',
+        async () => {
+            const execution = activityEnv().run(() =>
+                execActivityFileWithProgress(process.execPath, ['-e', 'process.exit(3)']),
+            );
+
+            await expect(execution).rejects.toMatchObject({ code: 3, killed: false });
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'terminates a still-progressing child at the Activity start-to-close deadline',
+        async () => {
+            // The child keeps reporting advancing progress, so the stall watchdog never fires; the Activity deadline
+            // must still terminate it. This exercises a different path than execActivityFile — the spawn timeout, not
+            // execFile's timeout.
+            const deadlineEnv = new MockActivityEnvironment({
+                currentAttemptScheduledTimestampMs: Date.now(),
+                startToCloseTimeoutMs: 600,
+            });
+            const execution = deadlineEnv.run(() =>
+                execActivityFileWithProgress(
+                    process.execPath,
+                    ['-e', 'setInterval(() => process.stderr.write(`frame=${Date.now()}\\n`), 50)'],
+                    { stallTimeoutMs: 60_000 },
+                ),
+            );
+
+            await expect(execution).rejects.toMatchObject({ killed: true });
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+});