@twentyhq/call-recorder 1.0.0

package/src/logic-functions/domain/__tests__/compute-call-recording-charge.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+
+import { computeCallRecordingCharge } from 'src/logic-functions/domain/compute-call-recording-charge.util';
+
+describe('computeCallRecordingCharge', () => {
+  it('charges one credit for a one-hour recording', () => {
+    expect(
+      computeCallRecordingCharge({
+        startedAt: '2026-06-10T09:00:00.000Z',
+        endedAt: '2026-06-10T10:00:00.000Z',
+      }),
+    ).toEqual({
+      creditsUsedMicro: 1_000_000,
+      quantityMinutes: 60,
+    });
+  });
+
+  it('prorates partial hours by duration', () => {
+    expect(
+      computeCallRecordingCharge({
+        startedAt: '2026-06-10T09:00:00.000Z',
+        endedAt: '2026-06-10T09:45:00.000Z',
+      }),
+    ).toEqual({
+      creditsUsedMicro: 750_000,
+      quantityMinutes: 45,
+    });
+  });
+
+  it('reports at least one minute for very short recordings', () => {
+    expect(
+      computeCallRecordingCharge({
+        startedAt: '2026-06-10T09:00:00.000Z',
+        endedAt: '2026-06-10T09:00:30.000Z',
+      }),
+    ).toEqual({
+      creditsUsedMicro: 8_333,
+      quantityMinutes: 1,
+    });
+  });
+
+  it('returns undefined when either timestamp is missing', () => {
+    expect(
+      computeCallRecordingCharge({
+        startedAt: undefined,
+        endedAt: '2026-06-10T10:00:00.000Z',
+      }),
+    ).toBeUndefined();
+    expect(
+      computeCallRecordingCharge({
+        startedAt: '2026-06-10T09:00:00.000Z',
+        endedAt: undefined,
+      }),
+    ).toBeUndefined();
+  });
+
+  it('returns undefined for non-positive or unparseable durations', () => {
+    expect(
+      computeCallRecordingCharge({
+        startedAt: '2026-06-10T10:00:00.000Z',
+        endedAt: '2026-06-10T09:00:00.000Z',
+      }),
+    ).toBeUndefined();
+    expect(
+      computeCallRecordingCharge({
+        startedAt: 'not-a-date',
+        endedAt: '2026-06-10T10:00:00.000Z',
+      }),
+    ).toBeUndefined();
+  });
+});

package/src/logic-functions/domain/__tests__/compute-call-recording-id-for-meeting.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { computeCallRecordingIdForMeeting } from 'src/logic-functions/domain/compute-call-recording-id-for-meeting.util';
+
+const UUID_V4_PATTERN =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+describe('computeCallRecordingIdForMeeting', () => {
+  it('returns the same id for the same real meeting key', () => {
+    const realMeetingKey =
+      'link:meet.example.com/sync:2026-01-01T13:00:00.000Z';
+
+    expect(computeCallRecordingIdForMeeting(realMeetingKey)).toBe(
+      computeCallRecordingIdForMeeting(realMeetingKey),
+    );
+  });
+
+  it('returns different ids for different real meeting keys', () => {
+    expect(
+      computeCallRecordingIdForMeeting(
+        'link:meet.example.com/sync:2026-01-01T13:00:00.000Z',
+      ),
+    ).not.toBe(
+      computeCallRecordingIdForMeeting(
+        'link:meet.example.com/sync:2026-01-02T13:00:00.000Z',
+      ),
+    );
+  });
+
+  it('returns a v4-shaped uuid', () => {
+    expect(
+      computeCallRecordingIdForMeeting(
+        'ical:some-uid:2026-01-01T13:00:00.000Z',
+      ),
+    ).toMatch(UUID_V4_PATTERN);
+  });
+});

package/src/logic-functions/domain/__tests__/compute-real-meeting-key.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+
+import { computeRealMeetingKey } from 'src/logic-functions/domain/compute-real-meeting-key.util';
+
+const STARTS_AT = '2026-01-01T13:00:00.000Z';
+
+const buildInput = (
+  overrides: Partial<Parameters<typeof computeRealMeetingKey>[0]> = {},
+) => ({
+  calendarEventId: 'calendar-event-1',
+  conferenceLinkUrl: 'https://meet.example.com/customer-sync',
+  iCalUid: 'calendar-event-uid',
+  startsAt: STARTS_AT,
+  ...overrides,
+});
+
+describe('computeRealMeetingKey', () => {
+  it.each([
+    [
+      'strips protocol, query, and fragment',
+      'https://zoom.us/j/123?pwd=abc#section',
+      `link:zoom.us/j/123:${STARTS_AT}`,
+    ],
+    [
+      'strips www and lowercases',
+      'HTTPS://WWW.Meet.Example.com/Customer-Sync',
+      `link:meet.example.com/customer-sync:${STARTS_AT}`,
+    ],
+    [
+      'strips trailing slashes',
+      'https://meet.example.com/customer-sync///',
+      `link:meet.example.com/customer-sync:${STARTS_AT}`,
+    ],
+    [
+      'supports plain http links',
+      'http://meet.example.com/customer-sync',
+      `link:meet.example.com/customer-sync:${STARTS_AT}`,
+    ],
+  ])('%s', (_label, conferenceLinkUrl, expectedKey) => {
+    expect(computeRealMeetingKey(buildInput({ conferenceLinkUrl }))).toBe(
+      expectedKey,
+    );
+  });
+
+  it('produces the same key for the same meeting synced from two calendars', () => {
+    const fromFirstAttendee = computeRealMeetingKey(
+      buildInput({
+        calendarEventId: 'calendar-event-1',
+        conferenceLinkUrl: 'https://zoom.us/j/123?pwd=first-attendee-token',
+      }),
+    );
+    const fromSecondAttendee = computeRealMeetingKey(
+      buildInput({
+        calendarEventId: 'calendar-event-2',
+        conferenceLinkUrl:
+          'https://www.zoom.us/j/123?pwd=second-attendee-token',
+      }),
+    );
+
+    expect(fromFirstAttendee).toBe(fromSecondAttendee);
+  });
+
+  it('falls back to the iCal uid when the link is blank', () => {
+    expect(
+      computeRealMeetingKey(buildInput({ conferenceLinkUrl: '   ' })),
+    ).toBe(`ical:calendar-event-uid:${STARTS_AT}`);
+  });
+
+  it('falls back to the iCal uid when the link is not a string', () => {
+    expect(computeRealMeetingKey(buildInput({ conferenceLinkUrl: 42 }))).toBe(
+      `ical:calendar-event-uid:${STARTS_AT}`,
+    );
+  });
+
+  it('falls back to the calendar event id when link and iCal uid are missing', () => {
+    expect(
+      computeRealMeetingKey(
+        buildInput({ conferenceLinkUrl: undefined, iCalUid: '' }),
+      ),
+    ).toBe('event:calendar-event-1');
+  });
+
+  it('keeps link keys distinct across start times', () => {
+    expect(computeRealMeetingKey(buildInput({ startsAt: undefined }))).toBe(
+      'link:meet.example.com/customer-sync:',
+    );
+  });
+});

package/src/logic-functions/domain/__tests__/is-call-recording-ingestion-complete.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+
+import { isCallRecordingIngestionComplete } from 'src/logic-functions/domain/is-call-recording-ingestion-complete.util';
+
+const AUDIO_VALUE = [{ fileId: 'file-audio-1', label: 'audio.mp3' }];
+const VIDEO_VALUE = [{ fileId: 'file-video-1', label: 'video.mp4' }];
+const TRANSCRIPT_CONTENT = [{ participant: { id: 1 }, words: [] }];
+
+describe('isCallRecordingIngestionComplete', () => {
+  it('is complete when transcript content and both media files are present', () => {
+    expect(
+      isCallRecordingIngestionComplete({
+        transcript: TRANSCRIPT_CONTENT,
+        audio: AUDIO_VALUE,
+        video: VIDEO_VALUE,
+      }),
+    ).toBe(true);
+  });
+
+  it('is incomplete while the transcript holds a marker', () => {
+    expect(
+      isCallRecordingIngestionComplete({
+        transcript: {
+          recallTranscriptId: 'recall-transcript-1',
+          status: 'PENDING',
+        },
+        audio: AUDIO_VALUE,
+        video: VIDEO_VALUE,
+      }),
+    ).toBe(false);
+  });
+
+  it('is incomplete when the transcript is unset', () => {
+    expect(
+      isCallRecordingIngestionComplete({
+        transcript: null,
+        audio: AUDIO_VALUE,
+        video: VIDEO_VALUE,
+      }),
+    ).toBe(false);
+  });
+
+  it('is incomplete while any media field is empty', () => {
+    expect(
+      isCallRecordingIngestionComplete({
+        transcript: TRANSCRIPT_CONTENT,
+        audio: undefined,
+        video: VIDEO_VALUE,
+      }),
+    ).toBe(false);
+    expect(
+      isCallRecordingIngestionComplete({
+        transcript: TRANSCRIPT_CONTENT,
+        audio: AUDIO_VALUE,
+        video: [],
+      }),
+    ).toBe(false);
+  });
+});

package/src/logic-functions/domain/__tests__/is-call-recording-status-downgrade.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { isCallRecordingStatusDowngrade } from 'src/logic-functions/domain/is-call-recording-status-downgrade.util';
+
+describe('isCallRecordingStatusDowngrade', () => {
+  it.each([
+    ['SCHEDULED', 'JOINING', false],
+    ['JOINING', 'RECORDING', false],
+    ['RECORDING', 'PROCESSING', false],
+    ['PROCESSING', 'FAILED', false],
+    ['PROCESSING', 'COMPLETED', false],
+    ['RECORDING', 'RECORDING', false],
+    ['COMPLETED', 'RECORDING', true],
+    ['PROCESSING', 'JOINING', true],
+    ['FAILED', 'RECORDING', true],
+    ['JOINING', 'SCHEDULED', true],
+  ])('from %s to %s -> %s', (fromStatus, toStatus, expected) => {
+    expect(isCallRecordingStatusDowngrade({ fromStatus, toStatus })).toBe(
+      expected,
+    );
+  });
+
+  it('never treats transitions from unknown statuses as downgrades', () => {
+    expect(
+      isCallRecordingStatusDowngrade({
+        fromStatus: undefined,
+        toStatus: 'COMPLETED',
+      }),
+    ).toBe(false);
+    expect(
+      isCallRecordingStatusDowngrade({
+        fromStatus: 'NOT_A_STATUS',
+        toStatus: 'SCHEDULED',
+      }),
+    ).toBe(false);
+  });
+});

package/src/logic-functions/domain/__tests__/resolve-call-recorder-policy-result.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+
+import { CallRecorderPreference } from 'src/constants/call-recorder-preference';
+import { resolveCallRecorderPolicyResult } from 'src/logic-functions/domain/resolve-call-recorder-policy-result.util';
+
+const NOW = new Date('2026-01-01T12:00:00.000Z');
+const FUTURE_STARTS_AT = '2026-01-01T13:00:00.000Z';
+const FUTURE_ENDS_AT = '2026-01-01T14:00:00.000Z';
+const PAST_STARTS_AT = '2026-01-01T09:00:00.000Z';
+const PAST_ENDS_AT = '2026-01-01T10:00:00.000Z';
+
+describe('resolveCallRecorderPolicyResult', () => {
+  it('requires a bot when preference is ON and the event is upcoming', () => {
+    expect(
+      resolveCallRecorderPolicyResult({
+        input: {
+          callRecorderPreference: CallRecorderPreference.ON,
+          isCanceled: false,
+          startsAt: FUTURE_STARTS_AT,
+          endsAt: FUTURE_ENDS_AT,
+          conferenceLinkUrl: 'https://meet.example.com/team-sync',
+        },
+        now: NOW,
+      }),
+    ).toEqual({
+      shouldRequestBot: true,
+      reason: 'RECORDING_ENABLED',
+    });
+  });
+
+  it('does not request a bot for ON when the meeting has no conference link', () => {
+    expect(
+      resolveCallRecorderPolicyResult({
+        input: {
+          callRecorderPreference: CallRecorderPreference.ON,
+          isCanceled: false,
+          startsAt: FUTURE_STARTS_AT,
+          endsAt: FUTURE_ENDS_AT,
+          conferenceLinkUrl: undefined,
+        },
+        now: NOW,
+      }),
+    ).toEqual({
+      shouldRequestBot: false,
+      reason: 'MISSING_CONFERENCE_LINK',
+    });
+  });
+
+  it('requires a bot without an event preference override', () => {
+    expect(
+      resolveCallRecorderPolicyResult({
+        input: {
+          callRecorderPreference: undefined,
+          isCanceled: false,
+          startsAt: FUTURE_STARTS_AT,
+          endsAt: FUTURE_ENDS_AT,
+          conferenceLinkUrl: 'https://meet.example.com/team-sync',
+        },
+        now: NOW,
+      }),
+    ).toEqual({
+      shouldRequestBot: true,
+      reason: 'RECORDING_ENABLED',
+    });
+  });
+
+  it('lets an OFF event preference opt out of workspace auto-recording', () => {
+    expect(
+      resolveCallRecorderPolicyResult({
+        input: {
+          callRecorderPreference: CallRecorderPreference.OFF,
+          isCanceled: false,
+          startsAt: FUTURE_STARTS_AT,
+          endsAt: FUTURE_ENDS_AT,
+          conferenceLinkUrl: 'https://meet.example.com/team-sync',
+        },
+        now: NOW,
+      }),
+    ).toEqual({
+      shouldRequestBot: false,
+      reason: 'PREFERENCE_OFF',
+    });
+  });
+
+  it('does not request a bot for a meeting that already ended', () => {
+    expect(
+      resolveCallRecorderPolicyResult({
+        input: {
+          callRecorderPreference: undefined,
+          isCanceled: false,
+          startsAt: PAST_STARTS_AT,
+          endsAt: PAST_ENDS_AT,
+          conferenceLinkUrl: 'https://meet.example.com/team-sync',
+        },
+        now: NOW,
+      }),
+    ).toEqual({
+      shouldRequestBot: false,
+      reason: 'EVENT_NOT_UPCOMING',
+    });
+  });
+
+  it('does not request a bot for a canceled meeting', () => {
+    expect(
+      resolveCallRecorderPolicyResult({
+        input: {
+          callRecorderPreference: undefined,
+          isCanceled: true,
+          startsAt: FUTURE_STARTS_AT,
+          endsAt: FUTURE_ENDS_AT,
+          conferenceLinkUrl: 'https://meet.example.com/team-sync',
+        },
+        now: NOW,
+      }),
+    ).toEqual({
+      shouldRequestBot: false,
+      reason: 'EVENT_CANCELED',
+    });
+  });
+});

package/src/logic-functions/domain/__tests__/should-complete-call-recording-ingestion.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+
+import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';
+import { shouldCompleteCallRecordingIngestion } from 'src/logic-functions/domain/should-complete-call-recording-ingestion.util';
+
+const filledTranscript = [{ participant: { id: 1 }, words: [] }];
+const filledAudio = [{ fileId: 'file-audio-1', label: 'audio.mp3' }];
+const filledVideo = [{ fileId: 'file-video-1', label: 'video.mp4' }];
+
+describe('shouldCompleteCallRecordingIngestion', () => {
+  it('requires complete artifacts and billable timestamps before completion', () => {
+    expect(
+      shouldCompleteCallRecordingIngestion({
+        current: {
+          status: CallRecordingStatus.PROCESSING,
+          startedAt: '2026-06-10T09:00:00.000Z',
+          endedAt: '2026-06-10T10:00:00.000Z',
+          transcript: filledTranscript,
+          audio: filledAudio,
+          video: filledVideo,
+        },
+        updateData: {},
+      }),
+    ).toBe(true);
+
+    expect(
+      shouldCompleteCallRecordingIngestion({
+        current: {
+          status: CallRecordingStatus.PROCESSING,
+          endedAt: '2026-06-10T10:00:00.000Z',
+          transcript: filledTranscript,
+          audio: filledAudio,
+          video: filledVideo,
+        },
+        updateData: {},
+      }),
+    ).toBe(false);
+
+    expect(
+      shouldCompleteCallRecordingIngestion({
+        current: {
+          status: CallRecordingStatus.PROCESSING,
+          transcript: filledTranscript,
+          audio: filledAudio,
+          video: filledVideo,
+        },
+        updateData: {
+          startedAt: '2026-06-10T09:00:00.000Z',
+          endedAt: '2026-06-10T10:00:00.000Z',
+        },
+      }),
+    ).toBe(true);
+
+    expect(
+      shouldCompleteCallRecordingIngestion({
+        current: {
+          status: CallRecordingStatus.PROCESSING,
+          startedAt: '2026-06-10T10:00:00.000Z',
+          endedAt: '2026-06-10T09:00:00.000Z',
+          transcript: filledTranscript,
+          audio: filledAudio,
+          video: filledVideo,
+        },
+        updateData: {},
+      }),
+    ).toBe(false);
+  });
+
+  it('does not complete a persisted failed recording', () => {
+    expect(
+      shouldCompleteCallRecordingIngestion({
+        current: {
+          status: CallRecordingStatus.FAILED,
+          startedAt: '2026-06-10T09:00:00.000Z',
+          endedAt: '2026-06-10T10:00:00.000Z',
+          transcript: filledTranscript,
+          audio: filledAudio,
+          video: filledVideo,
+        },
+        updateData: {},
+      }),
+    ).toBe(false);
+  });
+
+  it('does not complete when the incoming update marks the recording as failed', () => {
+    expect(
+      shouldCompleteCallRecordingIngestion({
+        current: {
+          status: CallRecordingStatus.PROCESSING,
+          startedAt: '2026-06-10T09:00:00.000Z',
+          endedAt: '2026-06-10T10:00:00.000Z',
+          transcript: filledTranscript,
+          audio: filledAudio,
+          video: filledVideo,
+        },
+        updateData: {
+          status: CallRecordingStatus.FAILED,
+        },
+      }),
+    ).toBe(false);
+  });
+});

package/src/logic-functions/domain/aggregate-call-recorder-policy-results-by-meeting.util.ts

@@ -0,0 +1,42 @@
+import { type CallRecorderPolicyResultForCalendarEvent } from 'src/logic-functions/types/call-recorder-policy-result-for-calendar-event.type';
+import { type CallRecorderPolicyResultForMeeting } from 'src/logic-functions/types/call-recorder-policy-result-for-meeting.type';
+
+type CallRecorderPolicyResultForMeetingInput = Pick<
+  CallRecorderPolicyResultForCalendarEvent,
+  'calendarEventId' | 'realMeetingKey' | 'shouldRequestBot'
+>;
+
+export const aggregateCallRecorderPolicyResultsByMeeting = (
+  perCalendarEventPolicyResults: CallRecorderPolicyResultForMeetingInput[],
+): CallRecorderPolicyResultForMeeting[] => {
+  const meetingPolicyResultsByMeetingKey = new Map<
+    string,
+    CallRecorderPolicyResultForMeeting
+  >();
+
+  for (const {
+    calendarEventId,
+    realMeetingKey,
+    shouldRequestBot,
+  } of perCalendarEventPolicyResults) {
+    const meetingPolicyResult = meetingPolicyResultsByMeetingKey.get(
+      realMeetingKey,
+    ) ?? {
+      realMeetingKey,
+      shouldRequestBot: false,
+      calendarEventIds: [],
+      requestingCalendarEventIds: [],
+    };
+
+    meetingPolicyResult.calendarEventIds.push(calendarEventId);
+
+    if (shouldRequestBot) {
+      meetingPolicyResult.shouldRequestBot = true;
+      meetingPolicyResult.requestingCalendarEventIds.push(calendarEventId);
+    }
+
+    meetingPolicyResultsByMeetingKey.set(realMeetingKey, meetingPolicyResult);
+  }
+
+  return [...meetingPolicyResultsByMeetingKey.values()];
+};

package/src/logic-functions/domain/build-call-recorder-policy-result.util.ts

@@ -0,0 +1,53 @@
+import { CallRecorderPreference } from 'src/constants/call-recorder-preference';
+import { type CallRecorderPolicyCalendarEventInput } from 'src/logic-functions/types/call-recorder-policy-calendar-event-input.type';
+import { type CallRecorderPolicyResultForCalendarEvent } from 'src/logic-functions/types/call-recorder-policy-result-for-calendar-event.type';
+import { computeRealMeetingKey } from 'src/logic-functions/domain/compute-real-meeting-key.util';
+import { resolveCallRecorderPolicyResult } from 'src/logic-functions/domain/resolve-call-recorder-policy-result.util';
+
+export const buildCallRecorderPolicyResult = (
+  calendarEvent: CallRecorderPolicyCalendarEventInput,
+  now: Date,
+): CallRecorderPolicyResultForCalendarEvent => {
+  const realMeetingKey = computeRealMeetingKey({
+    calendarEventId: calendarEvent.id,
+    conferenceLinkUrl: calendarEvent.conferenceLinkUrl,
+    iCalUid: calendarEvent.iCalUid,
+    startsAt: calendarEvent.startsAt,
+  });
+
+  const callRecorderPreference = normalizeCallRecorderPreference(
+    calendarEvent.callRecorderPreference,
+  );
+
+  const policyResult = resolveCallRecorderPolicyResult({
+    input: {
+      callRecorderPreference,
+      isCanceled: calendarEvent.isCanceled,
+      startsAt: calendarEvent.startsAt,
+      endsAt: calendarEvent.endsAt,
+      conferenceLinkUrl: calendarEvent.conferenceLinkUrl,
+    },
+    now,
+  });
+
+  return {
+    calendarEventId: calendarEvent.id,
+    callRecorderPreference,
+    realMeetingKey,
+    ...policyResult,
+  };
+};
+
+const normalizeCallRecorderPreference = (
+  callRecorderPreference: string | undefined,
+): CallRecorderPreference | undefined =>
+  isCallRecorderPreference(callRecorderPreference)
+    ? callRecorderPreference
+    : undefined;
+
+const isCallRecorderPreference = (
+  callRecorderPreference: string | undefined,
+): callRecorderPreference is CallRecorderPreference =>
+  Object.values(CallRecorderPreference).some(
+    (preference) => preference === callRecorderPreference,
+  );

package/src/logic-functions/domain/build-failed-transcript-marker.util.ts

@@ -0,0 +1,13 @@
+import { type TranscriptMarker } from 'src/logic-functions/types/transcript-marker.type';
+
+export const buildFailedTranscriptMarker = ({
+  recallTranscriptId,
+  subCode,
+}: {
+  recallTranscriptId: string | null;
+  subCode: string | null;
+}): TranscriptMarker => ({
+  recallTranscriptId,
+  status: 'FAILED',
+  subCode,
+});

package/src/logic-functions/domain/build-pending-transcript-marker.util.ts

@@ -0,0 +1,13 @@
+import { type TranscriptMarker } from 'src/logic-functions/types/transcript-marker.type';
+
+export const buildPendingTranscriptMarker = ({
+  recallTranscriptId,
+  requestedAt,
+}: {
+  recallTranscriptId: string;
+  requestedAt: string;
+}): TranscriptMarker => ({
+  recallTranscriptId,
+  status: 'PENDING',
+  requestedAt,
+});

package/src/logic-functions/domain/build-recall-routing-metadata.util.ts

@@ -0,0 +1,12 @@
+import { type RecallRoutingMetadata } from 'src/logic-functions/types/recall-routing-metadata.type';
+
+export const buildRecallRoutingMetadata = ({
+  callRecordingId,
+  workspaceId,
+}: {
+  callRecordingId: string;
+  workspaceId: string;
+}): RecallRoutingMetadata => ({
+  twentyWorkspaceId: workspaceId,
+  twentyCallRecordingId: callRecordingId,
+});

package/src/logic-functions/domain/build-transcript-failure-reason.util.ts

@@ -0,0 +1,7 @@
+import { isNull } from '@sniptt/guards';
+
+export const buildTranscriptFailureReason = (
+  subCode: string | null,
+): string => {
+  return isNull(subCode) ? 'transcript_failed' : `transcript_failed:${subCode}`;
+};