@twentyhq/call-recorder 1.0.1 → 1.0.2

package/src/logic-functions/reconcile-stale-bot-state.mjs

@@ -0,0 +1,2268 @@
+import { createRequire as __createRequire } from 'module';
+const require = __createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e2) {
+    throw mod = 0, e2;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/@sniptt/guards/build/guards/primitives.js
+var require_primitives = __commonJS({
+  "node_modules/@sniptt/guards/build/guards/primitives.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isSymbol = exports.isBigInt = exports.isString = exports.isNumber = exports.isBoolean = exports.isUndefined = void 0;
+    var isUndefined26 = (term) => {
+      return typeof term === "undefined";
+    };
+    exports.isUndefined = isUndefined26;
+    var isBoolean = (term) => {
+      return typeof term === "boolean";
+    };
+    exports.isBoolean = isBoolean;
+    var isNumber = (term) => {
+      return typeof term === "number" && !Number.isNaN(term);
+    };
+    exports.isNumber = isNumber;
+    var isString8 = (term) => {
+      return typeof term === "string";
+    };
+    exports.isString = isString8;
+    var isBigInt = (term) => {
+      return typeof term === "bigint";
+    };
+    exports.isBigInt = isBigInt;
+    var isSymbol = (term) => {
+      return typeof term === "symbol";
+    };
+    exports.isSymbol = isSymbol;
+  }
+});
+
+// node_modules/@sniptt/guards/build/guards/structural.js
+var require_structural = __commonJS({
+  "node_modules/@sniptt/guards/build/guards/structural.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isDate = exports.isWeakSet = exports.isWeakMap = exports.isSet = exports.isMap = exports.isArray = exports.isObject = exports.isFunction = exports.isNull = void 0;
+    var isNull5 = (term) => {
+      return term === null;
+    };
+    exports.isNull = isNull5;
+    var isFunction = (term) => {
+      return typeof term === "function";
+    };
+    exports.isFunction = isFunction;
+    var isObject2 = (term) => {
+      return !exports.isNull(term) && typeof term === "object";
+    };
+    exports.isObject = isObject2;
+    var isArray4 = (term) => {
+      return Array.isArray(term);
+    };
+    exports.isArray = isArray4;
+    var isMap = (term) => {
+      return term instanceof Map;
+    };
+    exports.isMap = isMap;
+    var isSet = (term) => {
+      return term instanceof Set;
+    };
+    exports.isSet = isSet;
+    var isWeakMap = (term) => {
+      return term instanceof WeakMap;
+    };
+    exports.isWeakMap = isWeakMap;
+    var isWeakSet = (term) => {
+      return term instanceof WeakSet;
+    };
+    exports.isWeakSet = isWeakSet;
+    var isDate = (term) => {
+      return term instanceof Date;
+    };
+    exports.isDate = isDate;
+  }
+});
+
+// node_modules/@sniptt/guards/build/guards/convenience.js
+var require_convenience = __commonJS({
+  "node_modules/@sniptt/guards/build/guards/convenience.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isNegativeInteger = exports.isNonNegativeInteger = exports.isPositiveInteger = exports.isInteger = exports.isNumberOrNaN = exports.isNonEmptyString = exports.isNonEmptyArray = exports.isObjectOrNull = void 0;
+    var primitives_1 = require_primitives();
+    var structural_1 = require_structural();
+    var isObjectOrNull = (term) => {
+      return typeof term === "object";
+    };
+    exports.isObjectOrNull = isObjectOrNull;
+    var isNonEmptyArray3 = (term) => {
+      return structural_1.isArray(term) && term.length > 0;
+    };
+    exports.isNonEmptyArray = isNonEmptyArray3;
+    var isNonEmptyString2 = (term) => {
+      return primitives_1.isString(term) && term.length > 0;
+    };
+    exports.isNonEmptyString = isNonEmptyString2;
+    var isNumberOrNaN = (term) => {
+      return typeof term === "number";
+    };
+    exports.isNumberOrNaN = isNumberOrNaN;
+    var isInteger = (term) => {
+      return primitives_1.isNumber(term) && Number.isInteger(term);
+    };
+    exports.isInteger = isInteger;
+    var isPositiveInteger = (term) => {
+      return exports.isInteger(term) && term > 0;
+    };
+    exports.isPositiveInteger = isPositiveInteger;
+    var isNonNegativeInteger = (term) => {
+      return exports.isInteger(term) && term >= 0;
+    };
+    exports.isNonNegativeInteger = isNonNegativeInteger;
+    var isNegativeInteger = (term) => {
+      return exports.isInteger(term) && term < 0;
+    };
+    exports.isNegativeInteger = isNegativeInteger;
+  }
+});
+
+// node_modules/@sniptt/guards/build/index.js
+var require_build = __commonJS({
+  "node_modules/@sniptt/guards/build/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.structural = exports.primitives = exports.convenience = void 0;
+    exports.convenience = __importStar(require_convenience());
+    __exportStar(require_convenience(), exports);
+    exports.primitives = __importStar(require_primitives());
+    __exportStar(require_primitives(), exports);
+    exports.structural = __importStar(require_structural());
+    __exportStar(require_structural(), exports);
+  }
+});
+
+// src/logic-functions/reconcile-stale-bot-state.ts
+import { CoreApiClient } from "twenty-client-sdk/core";
+
+// twenty-sdk-define-stub:__twenty-sdk-define-stub__
+var __defineFactoryStub = (config) => ({
+  success: true,
+  config,
+  errors: []
+});
+var __anyHandler = {
+  get(_target, prop) {
+    if (prop === "__esModule") return true;
+    if (prop === Symbol.toPrimitive) return () => "";
+    if (typeof prop === "symbol") return void 0;
+    return new Proxy(() => void 0, __anyHandler);
+  },
+  apply() {
+    return new Proxy(() => void 0, __anyHandler);
+  }
+};
+var __anyStub = new Proxy(() => void 0, __anyHandler);
+var defineLogicFunction = __defineFactoryStub;
+
+// src/constants/stale-bot-state-logic-function-universal-identifier.ts
+var STALE_BOT_STATE_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER = "e362aa9b-52c6-4b7e-bb20-927e0e8d7cbe";
+
+// src/logic-functions/constants/stale-bot-state-cron-pattern.ts
+var STALE_BOT_STATE_CRON_PATTERN = "*/5 * * * *";
+
+// src/logic-functions/flows/converge-diverged-call-recordings.util.ts
+var import_guards20 = __toESM(require_build());
+
+// src/logic-functions/constants/non-terminal-call-recording-statuses.ts
+var NON_TERMINAL_CALL_RECORDING_STATUSES = [
+  "SCHEDULED" /* SCHEDULED */,
+  "JOINING" /* JOINING */,
+  "RECORDING" /* RECORDING */,
+  "PROCESSING" /* PROCESSING */
+];
+
+// src/logic-functions/constants/twenty-page-size.ts
+var TWENTY_PAGE_SIZE = 100;
+
+// src/logic-functions/recall-api/extract-recall-bot-convergence.util.ts
+var import_guards4 = __toESM(require_build());
+
+// src/logic-functions/utils/as-record.util.ts
+var import_guards = __toESM(require_build());
+var asRecord = (value) => (0, import_guards.isObject)(value) && !(0, import_guards.isArray)(value) ? value : void 0;
+
+// src/logic-functions/utils/is-non-empty-string.util.ts
+var import_guards2 = __toESM(require_build());
+var isNonEmptyString = (value) => (0, import_guards2.isString)(value) && value.trim() !== "";
+
+// src/logic-functions/utils/get-string.util.ts
+var getString = (value) => isNonEmptyString(value) ? value : void 0;
+
+// src/logic-functions/domain/map-recall-status-code-to-call-recording-status.util.ts
+var mapRecallStatusCodeToCallRecordingStatus = (statusCode) => {
+  switch (statusCode) {
+    case "joining_call":
+    case "in_waiting_room":
+      return "JOINING" /* JOINING */;
+    case "in_call_not_recording":
+    case "recording_permission_allowed":
+    case "in_call_recording":
+      return "RECORDING" /* RECORDING */;
+    // 'done' stays PROCESSING: COMPLETED is set only after all artifacts are ingested.
+    case "call_ended":
+    case "analysis_done":
+    case "done":
+      return "PROCESSING" /* PROCESSING */;
+    case "fatal":
+    case "analysis_failed":
+    case "recording_permission_denied":
+      return "FAILED" /* FAILED */;
+    default:
+      return void 0;
+  }
+};
+
+// src/logic-functions/recall-api/normalize-recall-timestamp.util.ts
+var import_guards3 = __toESM(require_build());
+var normalizeRecallTimestamp = (value) => {
+  if ((0, import_guards3.isUndefined)(value)) {
+    return void 0;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? void 0 : parsed.toISOString();
+};
+
+// src/logic-functions/recall-api/extract-recall-bot-convergence.util.ts
+var extractRecallBotConvergence = (bot) => {
+  const statusChanges = extractStatusChanges(bot);
+  const latestStatusChange = getLatestStatusChange(statusChanges);
+  const status = mapRecallStatusCodeToCallRecordingStatus(
+    latestStatusChange?.code
+  );
+  const recording = extractFirstRecording(bot);
+  return {
+    status,
+    failureReason: status === "FAILED" /* FAILED */ ? latestStatusChange?.code : void 0,
+    startedAt: normalizeRecallTimestamp(
+      recording?.startedAt ?? findStatusChangeTimestamp(statusChanges, "in_call_recording")
+    ),
+    endedAt: normalizeRecallTimestamp(
+      recording?.completedAt ?? findStatusChangeTimestamp(statusChanges, "call_ended")
+    ),
+    externalRecordingId: recording?.id,
+    isRecallRecordingDone: !(0, import_guards4.isUndefined)(recording?.completedAt) || statusChanges.some((statusChange) => statusChange.code === "done")
+  };
+};
+var extractStatusChanges = (bot) => {
+  if (!(0, import_guards4.isArray)(bot.status_changes)) {
+    return [];
+  }
+  return bot.status_changes.flatMap((statusChange) => {
+    const code = getString(asRecord(statusChange)?.code);
+    if ((0, import_guards4.isUndefined)(code)) {
+      return [];
+    }
+    return [{ code, createdAt: getString(asRecord(statusChange)?.created_at) }];
+  });
+};
+var getLatestStatusChange = (statusChanges) => statusChanges.reduce(
+  (latestStatusChange, statusChange) => {
+    if ((0, import_guards4.isUndefined)(latestStatusChange)) {
+      return statusChange;
+    }
+    const statusChangeTime = getStatusChangeTime(statusChange);
+    const latestStatusChangeTime = getStatusChangeTime(latestStatusChange);
+    if ((0, import_guards4.isUndefined)(statusChangeTime) && (0, import_guards4.isUndefined)(latestStatusChangeTime)) {
+      return statusChange;
+    }
+    if ((0, import_guards4.isUndefined)(statusChangeTime)) {
+      return latestStatusChange;
+    }
+    if ((0, import_guards4.isUndefined)(latestStatusChangeTime)) {
+      return statusChange;
+    }
+    return statusChangeTime >= latestStatusChangeTime ? statusChange : latestStatusChange;
+  },
+  void 0
+);
+var getStatusChangeTime = (statusChange) => {
+  const normalizedTimestamp = normalizeRecallTimestamp(statusChange.createdAt);
+  if ((0, import_guards4.isUndefined)(normalizedTimestamp)) {
+    return void 0;
+  }
+  return new Date(normalizedTimestamp).getTime();
+};
+var extractFirstRecording = (bot) => {
+  if (!(0, import_guards4.isArray)(bot.recordings)) {
+    return void 0;
+  }
+  const recording = asRecord(bot.recordings[0]);
+  if ((0, import_guards4.isUndefined)(recording)) {
+    return void 0;
+  }
+  return {
+    id: getString(recording.id),
+    startedAt: getString(recording.started_at),
+    completedAt: getString(recording.completed_at)
+  };
+};
+var findStatusChangeTimestamp = (statusChanges, code) => statusChanges.find((statusChange) => statusChange.code === code)?.createdAt;
+
+// src/logic-functions/data/fetch-all-nodes.util.ts
+var import_guards5 = __toESM(require_build());
+var fetchAllNodes = async (fetchPage) => {
+  const nodes = [];
+  let hasNextPage = true;
+  let afterCursor;
+  while (hasNextPage) {
+    const connection = await fetchPage(afterCursor);
+    if ((0, import_guards5.isUndefined)(connection)) {
+      throw new Error("Pagination query returned no connection");
+    }
+    for (const edge of connection.edges ?? []) {
+      nodes.push(edge.node);
+    }
+    hasNextPage = connection.pageInfo?.hasNextPage === true;
+    const endCursor = connection.pageInfo?.endCursor;
+    if (hasNextPage && !(0, import_guards5.isString)(endCursor)) {
+      throw new Error(
+        "Inconsistent pagination state: hasNextPage is true without an endCursor"
+      );
+    }
+    afterCursor = (0, import_guards5.isString)(endCursor) ? endCursor : void 0;
+  }
+  return nodes;
+};
+
+// src/logic-functions/recall-api/get-recall-api-config.util.ts
+var import_guards6 = __toESM(require_build());
+
+// src/logic-functions/constants/call-recorder-name-env-var-name.ts
+var CALL_RECORDER_NAME_ENV_VAR_NAME = "CALL_RECORDER_NAME";
+
+// src/logic-functions/constants/default-call-recorder-name.ts
+var DEFAULT_CALL_RECORDER_NAME = "Twenty.com";
+
+// src/logic-functions/constants/default-recall-region.ts
+var DEFAULT_RECALL_REGION = "eu-central-1";
+
+// src/logic-functions/constants/recall-api-key-env-var-name.ts
+var RECALL_API_KEY_ENV_VAR_NAME = "RECALL_API_KEY";
+
+// src/logic-functions/constants/recall-region-env-var-name.ts
+var RECALL_REGION_ENV_VAR_NAME = "RECALL_REGION";
+
+// src/logic-functions/utils/get-application-variable-value.util.ts
+var getApplicationVariableValue = (key) => process.env[key];
+
+// src/logic-functions/recall-api/get-recall-api-config.util.ts
+var getRecallApiConfig = () => {
+  const apiKey = normalizeOptionalString(
+    getApplicationVariableValue(RECALL_API_KEY_ENV_VAR_NAME)
+  );
+  if ((0, import_guards6.isUndefined)(apiKey)) {
+    return {
+      success: false,
+      error: "RECALL_API_KEY server variable is not set. A server admin must set it on the Call Recorder application registration before scheduling bots."
+    };
+  }
+  const region = normalizeOptionalString(
+    getApplicationVariableValue(RECALL_REGION_ENV_VAR_NAME)
+  ) ?? DEFAULT_RECALL_REGION;
+  const botName = normalizeOptionalString(
+    getApplicationVariableValue(CALL_RECORDER_NAME_ENV_VAR_NAME)
+  ) ?? DEFAULT_CALL_RECORDER_NAME;
+  return {
+    success: true,
+    config: {
+      apiKey,
+      baseUrl: `https://${region}.recall.ai/api/v1`,
+      botName
+    }
+  };
+};
+var normalizeOptionalString = (value) => isNonEmptyString(value) ? value.trim() : void 0;
+
+// src/logic-functions/recall-api/recall-bot-api-request.util.ts
+var import_guards7 = __toESM(require_build());
+
+// src/logic-functions/constants/recall-api-max-attempts.ts
+var RECALL_API_MAX_ATTEMPTS = 3;
+
+// src/logic-functions/constants/recall-api-retry-delay-ms.ts
+var RECALL_API_RETRY_DELAY_MS = 500;
+
+// src/logic-functions/recall-api/recall-bot-api-request.util.ts
+var recallBotApiRequest = async (requestArgs) => {
+  const maxAttempts = requestArgs.maxAttempts ?? RECALL_API_MAX_ATTEMPTS;
+  for (let attemptNumber = 1; ; attemptNumber++) {
+    const { result, isRetryable } = await performRecallBotApiRequestAttempt(requestArgs);
+    if (!isRetryable || attemptNumber >= maxAttempts) {
+      return result;
+    }
+    await sleep(RECALL_API_RETRY_DELAY_MS * attemptNumber);
+  }
+};
+var performRecallBotApiRequestAttempt = async ({
+  config,
+  path,
+  method,
+  body,
+  allowNotFound = false
+}) => {
+  let response;
+  try {
+    response = await fetch(`${config.baseUrl}${path}`, {
+      method,
+      headers: {
+        Authorization: buildRecallApiAuthorizationHeader(config.apiKey),
+        ...(0, import_guards7.isUndefined)(body) ? {} : { "Content-Type": "application/json" }
+      },
+      ...(0, import_guards7.isUndefined)(body) ? {} : { body: JSON.stringify(body) }
+    });
+  } catch (error) {
+    return {
+      isRetryable: true,
+      result: {
+        ok: false,
+        status: null,
+        errorMessage: `Recall API request failed: ${error instanceof Error ? error.message : String(error)}`
+      }
+    };
+  }
+  if (allowNotFound && response.status === 404) {
+    return {
+      isRetryable: false,
+      result: {
+        ok: true,
+        status: response.status,
+        data: void 0
+      }
+    };
+  }
+  if (response.status === 204) {
+    return {
+      isRetryable: false,
+      result: {
+        ok: true,
+        status: response.status,
+        data: void 0
+      }
+    };
+  }
+  if (!response.ok) {
+    return {
+      isRetryable: isRetryableRecallApiStatus(response.status),
+      result: {
+        ok: false,
+        status: response.status,
+        errorMessage: await extractRecallApiErrorMessage(response)
+      }
+    };
+  }
+  try {
+    return {
+      isRetryable: false,
+      result: {
+        ok: true,
+        status: response.status,
+        data: await response.json()
+      }
+    };
+  } catch (error) {
+    return {
+      isRetryable: false,
+      result: {
+        ok: false,
+        status: response.status,
+        errorMessage: `Recall API returned a non-JSON response: ${error instanceof Error ? error.message : String(error)}`
+      }
+    };
+  }
+};
+var isRetryableRecallApiStatus = (status) => status === 429 || status >= 500;
+var sleep = (delayMs) => new Promise((resolve) => {
+  setTimeout(resolve, delayMs);
+});
+var buildRecallApiAuthorizationHeader = (apiKey) => {
+  const trimmedApiKey = apiKey.trim();
+  return trimmedApiKey.toLowerCase().startsWith("token ") ? trimmedApiKey : `Token ${trimmedApiKey}`;
+};
+var extractRecallApiErrorMessage = async (response) => {
+  const fallback = `Recall API responded with HTTP ${response.status}`;
+  try {
+    const body = await response.json();
+    return `${fallback}: ${JSON.stringify(body)}`;
+  } catch {
+    return fallback;
+  }
+};
+
+// src/logic-functions/recall-api/get-recall-bot.util.ts
+var getRecallBot = async ({
+  externalBotId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/bot/${externalBotId}/`,
+    method: "GET"
+  });
+  if (!result.ok) {
+    return result;
+  }
+  const bot = asRecord(result.data);
+  if (bot === void 0) {
+    return {
+      ok: false,
+      status: result.status,
+      errorMessage: "Recall API returned an empty bot response"
+    };
+  }
+  return { ok: true, bot };
+};
+
+// src/logic-functions/flows/ingest-call-recording-media.util.ts
+var import_guards8 = __toESM(require_build());
+import { MetadataApiClient } from "twenty-client-sdk/metadata";
+
+// src/constants/call-recording-audio-field-universal-identifier.ts
+var CALL_RECORDING_AUDIO_FIELD_UNIVERSAL_IDENTIFIER = "2eafc2d0-8fec-430c-a939-65ca5fbc0f08";
+
+// src/constants/call-recording-video-field-universal-identifier.ts
+var CALL_RECORDING_VIDEO_FIELD_UNIVERSAL_IDENTIFIER = "bb9523d3-457e-4f4b-8c79-27a77afb87da";
+
+// src/logic-functions/utils/get-record-at-path.util.ts
+var getRecordAtPath = (record, path) => path.reduce(
+  (currentValue, pathPart) => asRecord(currentValue)?.[pathPart],
+  record
+);
+
+// src/logic-functions/recall-api/extract-recall-media-urls.util.ts
+var extractRecallMediaUrls = (recording) => {
+  const mediaShortcuts = asRecord(recording.media_shortcuts);
+  return {
+    videoUrl: extractArtifactDownloadUrl(mediaShortcuts, "video_mixed"),
+    audioUrl: extractArtifactDownloadUrl(mediaShortcuts, "audio_mixed")
+  };
+};
+var extractArtifactDownloadUrl = (mediaShortcuts, artifactKey) => getString(getRecordAtPath(mediaShortcuts, [artifactKey, "download_url"])) ?? getString(
+  getRecordAtPath(mediaShortcuts, [artifactKey, "data", "download_url"])
+);
+
+// src/logic-functions/recall-api/get-recall-recording.util.ts
+var getRecallRecording = async ({
+  externalRecordingId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/recording/${externalRecordingId}/`,
+    method: "GET"
+  });
+  if (!result.ok) {
+    return result;
+  }
+  return { ok: true, recording: result.data ?? {} };
+};
+
+// src/logic-functions/flows/ingest-call-recording-media.util.ts
+var MEDIA_DOWNLOAD_TIMEOUT_MS = 12e4;
+var ingestCallRecordingMedia = async ({
+  callRecordingId,
+  externalRecordingId,
+  hasAudio,
+  hasVideo
+}) => {
+  if (hasAudio && hasVideo) {
+    return {};
+  }
+  const recordingResult = await getRecallRecording({ externalRecordingId });
+  if (!recordingResult.ok) {
+    console.warn(
+      `[call-recorder] failed to fetch Recall recording ${externalRecordingId} while ingesting media for call recording ${callRecordingId}: ${recordingResult.errorMessage}`
+    );
+    return {};
+  }
+  const mediaUrls = extractRecallMediaUrls(recordingResult.recording);
+  const metadataClient = new MetadataApiClient();
+  const updateFields = {};
+  if (!hasVideo && !(0, import_guards8.isUndefined)(mediaUrls.videoUrl)) {
+    const video = await ingestMediaArtifact({
+      callRecordingId,
+      metadataClient,
+      url: mediaUrls.videoUrl,
+      fileName: "video.mp4",
+      fieldMetadataUniversalIdentifier: CALL_RECORDING_VIDEO_FIELD_UNIVERSAL_IDENTIFIER
+    });
+    if (!(0, import_guards8.isUndefined)(video)) {
+      updateFields.video = video;
+    }
+  }
+  if (!hasAudio && !(0, import_guards8.isUndefined)(mediaUrls.audioUrl)) {
+    const audio = await ingestMediaArtifact({
+      callRecordingId,
+      metadataClient,
+      url: mediaUrls.audioUrl,
+      fileName: "audio.mp3",
+      fieldMetadataUniversalIdentifier: CALL_RECORDING_AUDIO_FIELD_UNIVERSAL_IDENTIFIER
+    });
+    if (!(0, import_guards8.isUndefined)(audio)) {
+      updateFields.audio = audio;
+    }
+  }
+  return updateFields;
+};
+var ingestMediaArtifact = async ({
+  callRecordingId,
+  metadataClient,
+  url,
+  fileName,
+  fieldMetadataUniversalIdentifier
+}) => {
+  try {
+    const { buffer, contentType } = await downloadMediaFile(url);
+    const uploadedFile = await metadataClient.uploadFile(
+      buffer,
+      fileName,
+      contentType,
+      fieldMetadataUniversalIdentifier
+    );
+    return [{ fileId: uploadedFile.id, label: fileName }];
+  } catch (error) {
+    console.warn(
+      `[call-recorder] failed to ingest ${fileName} for call recording ${callRecordingId}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+};
+var downloadMediaFile = async (url) => {
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(MEDIA_DOWNLOAD_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`download failed with status ${response.status}`);
+  }
+  return {
+    buffer: Buffer.from(await response.arrayBuffer()),
+    contentType: response.headers.get("content-type") ?? "application/octet-stream"
+  };
+};
+
+// src/logic-functions/domain/is-call-recording-status-downgrade.util.ts
+var import_guards9 = __toESM(require_build());
+var CALL_RECORDING_STATUS_PROGRESSION = {
+  ["SCHEDULED" /* SCHEDULED */]: 0,
+  ["JOINING" /* JOINING */]: 1,
+  ["RECORDING" /* RECORDING */]: 2,
+  ["PROCESSING" /* PROCESSING */]: 3,
+  ["FAILED" /* FAILED */]: 4,
+  ["COMPLETED" /* COMPLETED */]: 5
+};
+var getCallRecordingStatusRank = (status) => status in CALL_RECORDING_STATUS_PROGRESSION ? CALL_RECORDING_STATUS_PROGRESSION[status] : void 0;
+var isCallRecordingStatusDowngrade = ({
+  fromStatus,
+  toStatus
+}) => {
+  const fromRank = (0, import_guards9.isUndefined)(fromStatus) ? void 0 : getCallRecordingStatusRank(fromStatus);
+  const toRank = getCallRecordingStatusRank(toStatus);
+  if ((0, import_guards9.isUndefined)(fromRank) || (0, import_guards9.isUndefined)(toRank)) {
+    return false;
+  }
+  return toRank < fromRank;
+};
+
+// src/logic-functions/domain/parse-transcript-marker.util.ts
+var import_guards10 = __toESM(require_build());
+var parseTranscriptMarker = (transcript) => {
+  const candidate = asRecord(transcript);
+  if ((0, import_guards10.isUndefined)(candidate)) {
+    return void 0;
+  }
+  if (candidate.status !== "PENDING" && candidate.status !== "FAILED") {
+    return void 0;
+  }
+  return {
+    recallTranscriptId: (0, import_guards10.isString)(candidate.recallTranscriptId) ? candidate.recallTranscriptId : null,
+    status: candidate.status,
+    ...(0, import_guards10.isString)(candidate.requestedAt) ? { requestedAt: candidate.requestedAt } : {},
+    ...(0, import_guards10.isString)(candidate.subCode) ? { subCode: candidate.subCode } : {}
+  };
+};
+
+// src/logic-functions/data/complete-call-recording-ingestion.util.ts
+var completeCallRecordingIngestion = async (client, { id }) => {
+  const result = await client.mutation({
+    updateCallRecordings: {
+      __args: {
+        filter: {
+          id: { eq: id },
+          status: { in: NON_TERMINAL_CALL_RECORDING_STATUSES }
+        },
+        data: { status: "COMPLETED" /* COMPLETED */ }
+      },
+      id: true
+    }
+  });
+  return (result.updateCallRecordings ?? []).length > 0;
+};
+
+// src/logic-functions/flows/charge-completed-call-recording.util.ts
+var import_guards12 = __toESM(require_build());
+
+// node_modules/twenty-sdk/dist/billing/index.mjs
+var e = "TWENTY_API_URL";
+var t = "TWENTY_APP_ACCESS_TOKEN";
+var n = 5e3;
+var r = async ({ creditsUsedMicro: r2, operationType: i, quantity: a = 1, resourceContext: o }) => {
+  let s = process.env[e], c = process.env[t];
+  if (!(!s || !c)) try {
+    let e2 = await fetch(`${s.replace(/\/$/, "")}/app/billing/charge`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${c}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        creditsUsedMicro: r2,
+        quantity: a,
+        operationType: i,
+        resourceContext: o
+      }),
+      signal: AbortSignal.timeout(n)
+    });
+    if (!e2.ok) {
+      let t2 = await e2.text().catch(() => "");
+      console.error(`chargeCredits: ${e2.status} ${e2.statusText}: ${t2}`);
+    }
+  } catch (e2) {
+    console.error(`chargeCredits: ${e2 instanceof Error ? e2.message : String(e2)}`);
+  }
+};
+
+// src/logic-functions/domain/compute-call-recording-charge.util.ts
+var import_guards11 = __toESM(require_build());
+
+// src/logic-functions/constants/call-recording-micro-credits-per-hour.ts
+var CALL_RECORDING_MICRO_CREDITS_PER_HOUR = 1e6;
+
+// src/logic-functions/constants/milliseconds-per-minute.ts
+var MILLISECONDS_PER_MINUTE = 6e4;
+
+// src/logic-functions/domain/compute-call-recording-charge.util.ts
+var MILLISECONDS_PER_HOUR = 36e5;
+var computeCallRecordingCharge = ({
+  startedAt,
+  endedAt
+}) => {
+  if ((0, import_guards11.isUndefined)(startedAt) || (0, import_guards11.isUndefined)(endedAt)) {
+    return void 0;
+  }
+  const durationMilliseconds = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+  if (!Number.isFinite(durationMilliseconds) || durationMilliseconds <= 0) {
+    return void 0;
+  }
+  return {
+    creditsUsedMicro: Math.round(
+      durationMilliseconds / MILLISECONDS_PER_HOUR * CALL_RECORDING_MICRO_CREDITS_PER_HOUR
+    ),
+    quantityMinutes: Math.max(
+      1,
+      Math.round(durationMilliseconds / MILLISECONDS_PER_MINUTE)
+    )
+  };
+};
+
+// src/logic-functions/flows/charge-completed-call-recording.util.ts
+var chargeCompletedCallRecording = async ({
+  callRecordingId,
+  startedAt,
+  endedAt
+}) => {
+  const charge = computeCallRecordingCharge({ startedAt, endedAt });
+  if ((0, import_guards12.isUndefined)(charge)) {
+    console.warn(
+      `[call-recorder] call recording ${callRecordingId} completed without usable recording timestamps; it will not be billed`
+    );
+    return;
+  }
+  await r({
+    creditsUsedMicro: charge.creditsUsedMicro,
+    quantity: charge.quantityMinutes,
+    operationType: "CALL_RECORDING",
+    resourceContext: "recall"
+  });
+};
+
+// src/logic-functions/flows/complete-and-charge-call-recording.util.ts
+var completeAndChargeCallRecording = async (client, {
+  id,
+  startedAt,
+  endedAt
+}) => {
+  const claimed = await completeCallRecordingIngestion(client, { id });
+  if (claimed) {
+    await chargeCompletedCallRecording({
+      callRecordingId: id,
+      startedAt,
+      endedAt
+    });
+  }
+  return claimed;
+};
+
+// src/logic-functions/domain/is-call-recording-ingestion-complete.util.ts
+var import_guards13 = __toESM(require_build());
+var isCallRecordingIngestionComplete = ({
+  transcript,
+  audio,
+  video
+}) => !(0, import_guards13.isNull)(transcript) && !(0, import_guards13.isUndefined)(transcript) && (0, import_guards13.isUndefined)(parseTranscriptMarker(transcript)) && (0, import_guards13.isNonEmptyArray)(audio) && (0, import_guards13.isNonEmptyArray)(video);
+
+// src/logic-functions/domain/should-complete-call-recording-ingestion.util.ts
+var shouldCompleteCallRecordingIngestion = ({
+  current,
+  updateData
+}) => current.status !== "COMPLETED" /* COMPLETED */ && current.status !== "FAILED" /* FAILED */ && updateData.status !== "FAILED" /* FAILED */ && computeCallRecordingCharge({
+  startedAt: updateData.startedAt ?? current.startedAt,
+  endedAt: updateData.endedAt ?? current.endedAt
+}) !== void 0 && isCallRecordingIngestionComplete({
+  transcript: updateData.transcript ?? current.transcript,
+  audio: updateData.audio ?? current.audio,
+  video: updateData.video ?? current.video
+});
+
+// src/logic-functions/data/update-call-recording.util.ts
+var updateCallRecording = async (client, {
+  id,
+  data
+}) => {
+  await client.mutation({
+    updateCallRecording: {
+      __args: {
+        id,
+        data
+      },
+      id: true
+    }
+  });
+};
+
+// src/logic-functions/flows/persist-call-recording-progress.util.ts
+var persistCallRecordingProgress = async (client, {
+  id,
+  current,
+  updateData
+}) => {
+  const completesIngestion = shouldCompleteCallRecordingIngestion({
+    current,
+    updateData
+  });
+  if (!completesIngestion) {
+    await updateCallRecording(client, { id, data: updateData });
+    return { completesIngestion: false };
+  }
+  const nonStatusUpdate = { ...updateData };
+  delete nonStatusUpdate.status;
+  delete nonStatusUpdate.callRecorderFailureReason;
+  if (Object.keys(nonStatusUpdate).length > 0) {
+    await updateCallRecording(client, { id, data: nonStatusUpdate });
+  }
+  await completeAndChargeCallRecording(client, {
+    id,
+    startedAt: updateData.startedAt ?? current.startedAt,
+    endedAt: updateData.endedAt ?? current.endedAt
+  });
+  return { completesIngestion: true };
+};
+
+// src/logic-functions/flows/reconcile-call-recording-transcript-artifact.util.ts
+var import_guards19 = __toESM(require_build());
+
+// src/logic-functions/domain/build-failed-transcript-marker.util.ts
+var buildFailedTranscriptMarker = ({
+  recallTranscriptId,
+  subCode
+}) => ({
+  recallTranscriptId,
+  status: "FAILED",
+  subCode
+});
+
+// src/logic-functions/domain/build-pending-transcript-marker.util.ts
+var buildPendingTranscriptMarker = ({
+  recallTranscriptId,
+  requestedAt
+}) => ({
+  recallTranscriptId,
+  status: "PENDING",
+  requestedAt
+});
+
+// src/logic-functions/domain/build-transcript-failure-reason.util.ts
+var import_guards14 = __toESM(require_build());
+var buildTranscriptFailureReason = (subCode) => {
+  return (0, import_guards14.isNull)(subCode) ? "transcript_failed" : `transcript_failed:${subCode}`;
+};
+
+// src/logic-functions/recall-api/create-async-recall-transcript.util.ts
+var import_guards15 = __toESM(require_build());
+var createAsyncRecallTranscript = async ({
+  externalRecordingId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/recording/${externalRecordingId}/create_transcript/`,
+    method: "POST",
+    body: {
+      provider: { recallai_async: { language_code: "auto" } },
+      diarization: { use_separate_streams_when_available: true }
+    },
+    maxAttempts: 1
+  });
+  if (!result.ok) {
+    return result;
+  }
+  if (!(0, import_guards15.isString)(result.data?.id)) {
+    return {
+      ok: false,
+      status: null,
+      errorMessage: "Recall API created a transcript but the response did not include a transcript id"
+    };
+  }
+  return { ok: true, transcriptId: result.data.id };
+};
+
+// src/logic-functions/recall-api/list-recall-transcripts.util.ts
+var import_guards16 = __toESM(require_build());
+var RECALL_TRANSCRIPT_LIST_MAX_PAGES = 10;
+var listRecallTranscripts = async ({
+  externalRecordingId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const transcripts = [];
+  let path = buildListRecallTranscriptsPath({
+    externalRecordingId
+  });
+  for (let pageIndex = 0; !(0, import_guards16.isUndefined)(path) && pageIndex < RECALL_TRANSCRIPT_LIST_MAX_PAGES; pageIndex++) {
+    const result = await recallBotApiRequest({
+      config: configResult.config,
+      path,
+      method: "GET"
+    });
+    if (!result.ok) {
+      return result;
+    }
+    const pageTranscripts = extractRecallTranscriptSummaries(result.data);
+    if ((0, import_guards16.isUndefined)(pageTranscripts)) {
+      return {
+        ok: false,
+        status: result.status,
+        errorMessage: "Recall API returned malformed transcript list"
+      };
+    }
+    transcripts.push(...pageTranscripts);
+    path = extractNextPath(result.data, configResult.config.baseUrl);
+  }
+  if (!(0, import_guards16.isUndefined)(path)) {
+    return {
+      ok: false,
+      status: null,
+      errorMessage: `Recall transcript list exceeded ${RECALL_TRANSCRIPT_LIST_MAX_PAGES} pages`
+    };
+  }
+  return { ok: true, transcripts };
+};
+var buildListRecallTranscriptsPath = ({
+  externalRecordingId
+}) => {
+  const searchParams = new URLSearchParams({
+    recording_id: externalRecordingId
+  });
+  return `/transcript/?${searchParams.toString()}`;
+};
+var extractRecallTranscriptSummaries = (response) => {
+  if (!(0, import_guards16.isArray)(response?.results)) {
+    return void 0;
+  }
+  const transcripts = [];
+  for (const result of response.results) {
+    const transcript = extractRecallTranscriptSummary(result);
+    if ((0, import_guards16.isUndefined)(transcript)) {
+      return void 0;
+    }
+    transcripts.push(transcript);
+  }
+  return transcripts;
+};
+var extractRecallTranscriptSummary = (transcript) => {
+  const transcriptRecord = asRecord(transcript);
+  const transcriptId = getString(transcriptRecord?.id);
+  if ((0, import_guards16.isUndefined)(transcriptRecord) || (0, import_guards16.isUndefined)(transcriptId)) {
+    return void 0;
+  }
+  const status = asRecord(transcriptRecord.status);
+  return {
+    id: transcriptId,
+    statusCode: getString(status?.code),
+    statusSubCode: getString(status?.sub_code)
+  };
+};
+var extractNextPath = (response, baseUrl) => {
+  const nextPage = getString(response?.next);
+  if ((0, import_guards16.isUndefined)(nextPage) || !nextPage.startsWith(baseUrl)) {
+    return void 0;
+  }
+  return nextPage.slice(baseUrl.length);
+};
+
+// src/logic-functions/flows/download-transcript.util.ts
+var import_guards18 = __toESM(require_build());
+
+// src/logic-functions/recall-api/retrieve-recall-transcript.util.ts
+var import_guards17 = __toESM(require_build());
+var retrieveRecallTranscript = async ({
+  transcriptId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/transcript/${transcriptId}/`,
+    method: "GET"
+  });
+  if (!result.ok) {
+    return result;
+  }
+  const transcript = extractRecallTranscriptDetails(result.data);
+  if (isMalformedRecallTranscriptDetails(transcript)) {
+    return {
+      ok: false,
+      status: result.status,
+      errorMessage: "Recall API returned malformed transcript details"
+    };
+  }
+  return { ok: true, transcript };
+};
+var extractRecallTranscriptDetails = (response) => {
+  const data = asRecord(response?.data);
+  const status = asRecord(response?.status);
+  return {
+    downloadUrl: getString(data?.download_url),
+    statusCode: getString(status?.code),
+    statusSubCode: getString(status?.sub_code)
+  };
+};
+var isMalformedRecallTranscriptDetails = ({
+  downloadUrl,
+  statusCode
+}) => (0, import_guards17.isUndefined)(downloadUrl) && (0, import_guards17.isUndefined)(statusCode) || (0, import_guards17.isUndefined)(downloadUrl) && statusCode === "done";
+
+// src/logic-functions/flows/download-transcript.util.ts
+var TRANSCRIPT_DOWNLOAD_TIMEOUT_MS = 2e4;
+var downloadTranscript = async ({
+  transcriptId
+}) => {
+  const retrieveResult = await retrieveRecallTranscript({ transcriptId });
+  if (!retrieveResult.ok) {
+    return { outcome: "error", errorMessage: retrieveResult.errorMessage };
+  }
+  const { downloadUrl, statusCode, statusSubCode } = retrieveResult.transcript;
+  if (!(0, import_guards18.isUndefined)(downloadUrl)) {
+    return downloadTranscriptContent(downloadUrl);
+  }
+  if (statusCode === "error" || statusCode === "failed") {
+    return { outcome: "failed", subCode: statusSubCode ?? null };
+  }
+  return { outcome: "pending" };
+};
+var downloadTranscriptContent = async (downloadUrl) => {
+  try {
+    const response = await fetch(downloadUrl, {
+      signal: AbortSignal.timeout(TRANSCRIPT_DOWNLOAD_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      console.warn(
+        `[call-recorder] transcript download responded with HTTP ${response.status}`
+      );
+      return {
+        outcome: "error",
+        errorMessage: "transcript download failed"
+      };
+    }
+    return { outcome: "filled", content: await response.json() };
+  } catch (error) {
+    console.warn(
+      `[call-recorder] transcript download failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {
+      outcome: "error",
+      errorMessage: "transcript download failed"
+    };
+  }
+};
+
+// src/logic-functions/flows/reconcile-call-recording-transcript-artifact.util.ts
+var reconcileCallRecordingTranscriptArtifact = async ({
+  callRecordingId,
+  currentStatus,
+  externalRecordingId,
+  requestedAt,
+  transcript
+}) => {
+  const existingTranscriptMarker = parseTranscriptMarker(transcript);
+  if (!(0, import_guards19.isNull)(transcript) && !(0, import_guards19.isUndefined)(transcript) && (0, import_guards19.isUndefined)(existingTranscriptMarker)) {
+    return buildEmptyTranscriptArtifactResult();
+  }
+  if (existingTranscriptMarker?.status === "FAILED") {
+    return buildEmptyTranscriptArtifactResult();
+  }
+  const listResult = await listRecallTranscripts({ externalRecordingId });
+  if (!listResult.ok) {
+    console.warn(
+      `[call-recorder] failed to list Recall transcripts for recording ${externalRecordingId}: ${listResult.errorMessage}`
+    );
+    return buildEmptyTranscriptArtifactResult();
+  }
+  const transcriptArtifact = selectRecallTranscriptArtifact(
+    listResult.transcripts
+  );
+  const pendingTranscriptMarkerRecallTranscriptId = existingTranscriptMarker?.status === "PENDING" ? existingTranscriptMarker.recallTranscriptId ?? void 0 : void 0;
+  const transcriptIdToDownload = transcriptArtifact?.id ?? pendingTranscriptMarkerRecallTranscriptId;
+  if ((0, import_guards19.isUndefined)(transcriptArtifact) && (0, import_guards19.isUndefined)(pendingTranscriptMarkerRecallTranscriptId)) {
+    const createResult = await createAsyncRecallTranscript({
+      externalRecordingId
+    });
+    if (!createResult.ok) {
+      console.warn(
+        `[call-recorder] failed to request transcript for Recall recording ${externalRecordingId}: ${createResult.errorMessage}`
+      );
+      return buildEmptyTranscriptArtifactResult();
+    }
+    return {
+      updateData: {
+        transcript: buildPendingTranscriptMarker({
+          recallTranscriptId: createResult.transcriptId,
+          requestedAt
+        })
+      },
+      requestedTranscript: true
+    };
+  }
+  if (!(0, import_guards19.isUndefined)(transcriptArtifact) && (transcriptArtifact.statusCode === "failed" || transcriptArtifact.statusCode === "error")) {
+    return {
+      updateData: buildTranscriptFailureUpdate({
+        currentStatus,
+        transcriptId: transcriptArtifact.id,
+        subCode: transcriptArtifact.statusSubCode ?? null
+      }),
+      requestedTranscript: false
+    };
+  }
+  if (!(0, import_guards19.isUndefined)(transcriptArtifact) && transcriptArtifact.statusCode !== "done") {
+    return buildEmptyTranscriptArtifactResult();
+  }
+  if ((0, import_guards19.isUndefined)(transcriptIdToDownload)) {
+    return buildEmptyTranscriptArtifactResult();
+  }
+  const downloadResult = await downloadTranscript({
+    transcriptId: transcriptIdToDownload
+  });
+  if (downloadResult.outcome === "filled") {
+    return {
+      updateData: {
+        transcript: downloadResult.content
+      },
+      requestedTranscript: false
+    };
+  }
+  if (downloadResult.outcome === "failed") {
+    return {
+      updateData: buildTranscriptFailureUpdate({
+        currentStatus,
+        transcriptId: transcriptIdToDownload,
+        subCode: downloadResult.subCode
+      }),
+      requestedTranscript: false
+    };
+  }
+  if (downloadResult.outcome === "error") {
+    console.warn(
+      `[call-recorder] could not fill transcript for call recording ${callRecordingId}: ${downloadResult.errorMessage}`
+    );
+  }
+  return buildEmptyTranscriptArtifactResult();
+};
+var buildEmptyTranscriptArtifactResult = () => ({
+  updateData: {},
+  requestedTranscript: false
+});
+var selectRecallTranscriptArtifact = (transcripts) => transcripts.find((transcript) => transcript.statusCode !== "deleted");
+var buildTranscriptFailureUpdate = ({
+  currentStatus,
+  transcriptId,
+  subCode
+}) => ({
+  transcript: buildFailedTranscriptMarker({
+    recallTranscriptId: transcriptId,
+    subCode
+  }),
+  callRecorderFailureReason: buildTranscriptFailureReason(subCode),
+  ...isCallRecordingStatusDowngrade({
+    fromStatus: currentStatus,
+    toStatus: "FAILED" /* FAILED */
+  }) ? {} : { status: "FAILED" /* FAILED */ }
+});
+
+// src/logic-functions/flows/converge-diverged-call-recordings.util.ts
+var CONVERGENCE_LOOKBACK_DAYS = 7;
+var convergeDivergedCallRecordings = async ({
+  client,
+  now
+}) => {
+  const candidates = await fetchDivergedCallRecordingCandidates(client);
+  const convergenceLowerBound = new Date(
+    now.getTime() - CONVERGENCE_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3
+  );
+  const result = {
+    candidateCount: candidates.length,
+    updatedCallRecordingIds: [],
+    markedFailedCallRecordingIds: [],
+    requestedTranscriptCallRecordingIds: [],
+    unconvergeableCallRecordingIds: [],
+    skippedNotStartedCallRecordingIds: []
+  };
+  for (const candidate of candidates) {
+    if (isOutsideConvergenceBound(candidate, convergenceLowerBound)) {
+      console.warn(
+        `[call-recorder] call recording ${candidate.id} diverged but its meeting ended more than ${CONVERGENCE_LOOKBACK_DAYS} days ago; it will not converge automatically`
+      );
+      result.unconvergeableCallRecordingIds.push(candidate.id);
+      continue;
+    }
+    if ((0, import_guards20.isUndefined)(candidate.externalBotId)) {
+      console.warn(
+        `[call-recorder] call recording ${candidate.id} diverged but has no Recall bot id; it will not converge automatically`
+      );
+      result.unconvergeableCallRecordingIds.push(candidate.id);
+      continue;
+    }
+    if (isBeforeMeetingStart(candidate, now)) {
+      result.skippedNotStartedCallRecordingIds.push(candidate.id);
+      continue;
+    }
+    await convergeCallRecording({
+      client,
+      candidate,
+      externalBotId: candidate.externalBotId,
+      now,
+      result
+    });
+  }
+  return result;
+};
+var fetchDivergedCallRecordingCandidates = async (client) => {
+  const filter = {
+    or: [
+      {
+        recordingRequestStatus: { eq: "REQUESTED" /* REQUESTED */ },
+        status: { in: NON_TERMINAL_CALL_RECORDING_STATUSES },
+        externalBotId: { is: "NOT_NULL" }
+      },
+      {
+        status: { eq: "COMPLETED" /* COMPLETED */ },
+        or: [{ startedAt: { is: "NULL" } }, { endedAt: { is: "NULL" } }]
+      }
+    ]
+  };
+  const candidateNodes = await fetchAllNodes(
+    async (afterCursor) => {
+      const queryResult = await client.query({
+        callRecordings: {
+          __args: {
+            filter,
+            first: TWENTY_PAGE_SIZE,
+            ...(0, import_guards20.isUndefined)(afterCursor) ? {} : { after: afterCursor }
+          },
+          pageInfo: {
+            hasNextPage: true,
+            endCursor: true
+          },
+          edges: {
+            node: {
+              id: true,
+              status: true,
+              startedAt: true,
+              endedAt: true,
+              externalBotId: true,
+              externalRecordingId: true,
+              transcript: true,
+              audio: { fileId: true },
+              video: { fileId: true },
+              createdAt: true,
+              calendarEvent: {
+                startsAt: true,
+                endsAt: true
+              }
+            }
+          }
+        }
+      });
+      return queryResult.callRecordings ?? void 0;
+    }
+  );
+  return candidateNodes.map((node) => ({
+    id: node.id,
+    status: node.status ?? void 0,
+    startedAt: node.startedAt ?? void 0,
+    endedAt: node.endedAt ?? void 0,
+    externalBotId: isNonEmptyString(node.externalBotId) ? node.externalBotId : void 0,
+    externalRecordingId: isNonEmptyString(node.externalRecordingId) ? node.externalRecordingId : void 0,
+    transcript: node.transcript ?? void 0,
+    audio: node.audio ?? void 0,
+    video: node.video ?? void 0,
+    createdAt: node.createdAt ?? void 0,
+    calendarEventStartsAt: node.calendarEvent?.startsAt ?? void 0,
+    calendarEventEndsAt: node.calendarEvent?.endsAt ?? void 0
+  }));
+};
+var isOutsideConvergenceBound = (candidate, convergenceLowerBound) => {
+  const meetingEndReference = candidate.calendarEventEndsAt ?? candidate.createdAt;
+  return !(0, import_guards20.isUndefined)(meetingEndReference) && new Date(meetingEndReference).getTime() < convergenceLowerBound.getTime();
+};
+var isBeforeMeetingStart = (candidate, now) => !(0, import_guards20.isUndefined)(candidate.calendarEventStartsAt) && new Date(candidate.calendarEventStartsAt).getTime() > now.getTime();
+var convergeCallRecording = async ({
+  client,
+  candidate,
+  externalBotId,
+  now,
+  result
+}) => {
+  const botResult = await getRecallBot({ externalBotId });
+  if (!botResult.ok) {
+    if (botResult.status === 404) {
+      await markCallRecordingFailedAfterBotLoss({
+        client,
+        candidate,
+        externalBotId,
+        result
+      });
+      return;
+    }
+    console.warn(
+      `[call-recorder] failed to fetch Recall bot ${externalBotId} for call recording ${candidate.id}: ${botResult.errorMessage}`
+    );
+    return;
+  }
+  const convergence = extractRecallBotConvergence(botResult.bot);
+  const updateData = buildConvergenceFieldUpdates({ candidate, convergence });
+  const externalRecordingId = candidate.externalRecordingId ?? convergence.externalRecordingId;
+  if (convergence.isRecallRecordingDone && !(0, import_guards20.isUndefined)(externalRecordingId)) {
+    const transcriptArtifactResult = await reconcileCallRecordingTranscriptArtifact({
+      callRecordingId: candidate.id,
+      currentStatus: candidate.status,
+      externalRecordingId,
+      requestedAt: now.toISOString(),
+      transcript: candidate.transcript
+    });
+    Object.assign(updateData, transcriptArtifactResult.updateData);
+    if (transcriptArtifactResult.requestedTranscript) {
+      result.requestedTranscriptCallRecordingIds.push(candidate.id);
+    }
+    Object.assign(
+      updateData,
+      await ingestCallRecordingMedia({
+        callRecordingId: candidate.id,
+        externalRecordingId,
+        hasAudio: (0, import_guards20.isNonEmptyArray)(candidate.audio),
+        hasVideo: (0, import_guards20.isNonEmptyArray)(candidate.video)
+      })
+    );
+  }
+  const terminalArtifactGateFailureUpdate = buildTerminalArtifactGateFailureUpdate({
+    candidate,
+    convergence,
+    externalRecordingId,
+    updateData
+  });
+  if (!(0, import_guards20.isUndefined)(terminalArtifactGateFailureUpdate)) {
+    Object.assign(updateData, terminalArtifactGateFailureUpdate);
+  }
+  const completesIngestion = shouldCompleteCallRecordingIngestion({
+    current: candidate,
+    updateData
+  });
+  if (Object.keys(updateData).length === 0 && !completesIngestion) {
+    return;
+  }
+  await persistCallRecordingProgress(client, {
+    id: candidate.id,
+    current: candidate,
+    updateData
+  });
+  result.updatedCallRecordingIds.push(candidate.id);
+};
+var buildConvergenceFieldUpdates = ({
+  candidate,
+  convergence
+}) => {
+  const updateData = {};
+  if (!(0, import_guards20.isUndefined)(convergence.status) && convergence.status !== candidate.status && !isCallRecordingStatusDowngrade({
+    fromStatus: candidate.status,
+    toStatus: convergence.status
+  })) {
+    updateData.status = convergence.status;
+    if (convergence.status === "FAILED" /* FAILED */) {
+      updateData.callRecorderFailureReason = convergence.failureReason ?? "recall_bot_failed";
+    }
+  }
+  if ((0, import_guards20.isUndefined)(candidate.startedAt) && !(0, import_guards20.isUndefined)(convergence.startedAt)) {
+    updateData.startedAt = convergence.startedAt;
+  }
+  if ((0, import_guards20.isUndefined)(candidate.endedAt) && !(0, import_guards20.isUndefined)(convergence.endedAt)) {
+    updateData.endedAt = convergence.endedAt;
+  }
+  if ((0, import_guards20.isUndefined)(candidate.externalRecordingId) && !(0, import_guards20.isUndefined)(convergence.externalRecordingId)) {
+    updateData.externalRecordingId = convergence.externalRecordingId;
+  }
+  return updateData;
+};
+var buildTerminalArtifactGateFailureUpdate = ({
+  candidate,
+  convergence,
+  externalRecordingId,
+  updateData
+}) => {
+  if (candidate.status === "COMPLETED" /* COMPLETED */ || updateData.status === "FAILED" /* FAILED */ || !convergence.isRecallRecordingDone || !(0, import_guards20.isUndefined)(externalRecordingId) || hasRecordingArtifactPath({ candidate, updateData })) {
+    return void 0;
+  }
+  return {
+    status: "FAILED" /* FAILED */,
+    callRecorderFailureReason: convergence.failureReason ?? "recording_artifacts_unavailable"
+  };
+};
+var hasRecordingArtifactPath = ({
+  candidate,
+  updateData
+}) => {
+  return (0, import_guards20.isNonEmptyArray)(updateData.audio ?? candidate.audio) || (0, import_guards20.isNonEmptyArray)(updateData.video ?? candidate.video) || hasReachableTranscript(updateData.transcript ?? candidate.transcript);
+};
+var hasReachableTranscript = (transcript) => {
+  if ((0, import_guards20.isUndefined)(transcript)) {
+    return false;
+  }
+  const marker = parseTranscriptMarker(transcript);
+  return (0, import_guards20.isUndefined)(marker) || marker.status === "PENDING";
+};
+var markCallRecordingFailedAfterBotLoss = async ({
+  client,
+  candidate,
+  externalBotId,
+  result
+}) => {
+  console.warn(
+    `[call-recorder] Recall bot ${externalBotId} for call recording ${candidate.id} no longer exists; it will not converge automatically`
+  );
+  if (isCallRecordingStatusDowngrade({
+    fromStatus: candidate.status,
+    toStatus: "FAILED" /* FAILED */
+  })) {
+    result.unconvergeableCallRecordingIds.push(candidate.id);
+    return;
+  }
+  await updateCallRecording(client, {
+    id: candidate.id,
+    data: {
+      status: "FAILED" /* FAILED */,
+      callRecorderFailureReason: "recall_bot_not_found"
+    }
+  });
+  result.markedFailedCallRecordingIds.push(candidate.id);
+};
+
+// src/logic-functions/flows/heal-call-recordings-missing-bot.util.ts
+var import_guards28 = __toESM(require_build());
+
+// src/logic-functions/flows/ensure-call-recorder.util.ts
+var import_guards25 = __toESM(require_build());
+
+// src/logic-functions/domain/build-recall-routing-metadata.util.ts
+var buildRecallRoutingMetadata = ({
+  callRecordingId,
+  workspaceId
+}) => ({
+  twentyWorkspaceId: workspaceId,
+  twentyCallRecordingId: callRecordingId
+});
+
+// src/logic-functions/constants/default-call-recorder-join-early-minutes.ts
+var DEFAULT_CALL_RECORDER_JOIN_EARLY_MINUTES = 1;
+
+// src/logic-functions/constants/call-recorder-join-early-minutes-env-var-name.ts
+var CALL_RECORDER_JOIN_EARLY_MINUTES_ENV_VAR_NAME = "CALL_RECORDER_JOIN_EARLY_MINUTES";
+
+// src/logic-functions/domain/compute-recall-bot-join-at.util.ts
+var computeRecallBotJoinAt = (meetingStartsAt) => {
+  const meetingStartTimeInMilliseconds = new Date(meetingStartsAt).getTime();
+  if (Number.isNaN(meetingStartTimeInMilliseconds)) {
+    return meetingStartsAt;
+  }
+  return new Date(
+    meetingStartTimeInMilliseconds - getRecallBotJoinEarlyMinutes() * MILLISECONDS_PER_MINUTE
+  ).toISOString();
+};
+var getRecallBotJoinEarlyMinutes = () => {
+  const rawValue = getApplicationVariableValue(
+    CALL_RECORDER_JOIN_EARLY_MINUTES_ENV_VAR_NAME
+  );
+  if (!isNonEmptyString(rawValue)) {
+    return DEFAULT_CALL_RECORDER_JOIN_EARLY_MINUTES;
+  }
+  const joinEarlyMinutes = Number(rawValue.trim());
+  return Number.isInteger(joinEarlyMinutes) && joinEarlyMinutes >= 0 ? joinEarlyMinutes : DEFAULT_CALL_RECORDER_JOIN_EARLY_MINUTES;
+};
+
+// src/logic-functions/data/find-call-recordings-by-filter.util.ts
+var import_guards21 = __toESM(require_build());
+var findCallRecordingsByFilter = async (client, filter) => {
+  const callRecordingNodes = await fetchAllNodes(
+    async (afterCursor) => {
+      const queryResult = await client.query({
+        callRecordings: {
+          __args: {
+            filter,
+            first: TWENTY_PAGE_SIZE,
+            ...(0, import_guards21.isUndefined)(afterCursor) ? {} : { after: afterCursor }
+          },
+          pageInfo: {
+            hasNextPage: true,
+            endCursor: true
+          },
+          edges: {
+            node: {
+              id: true,
+              title: true,
+              status: true,
+              recordingRequestStatus: true,
+              startedAt: true,
+              endedAt: true,
+              calendarEventId: true,
+              externalBotId: true,
+              externalRecordingId: true,
+              callRecorderFailureReason: true
+            }
+          }
+        }
+      });
+      return queryResult.callRecordings;
+    }
+  );
+  return callRecordingNodes.map((callRecording) => ({
+    id: callRecording.id,
+    title: callRecording.title ?? void 0,
+    status: callRecording.status ?? void 0,
+    recordingRequestStatus: normalizeCallRecordingRequestStatus(
+      callRecording.recordingRequestStatus
+    ),
+    startedAt: callRecording.startedAt ?? void 0,
+    endedAt: callRecording.endedAt ?? void 0,
+    calendarEventId: callRecording.calendarEventId ?? void 0,
+    externalBotId: normalizeOptionalString2(callRecording.externalBotId),
+    externalRecordingId: normalizeOptionalString2(
+      callRecording.externalRecordingId
+    ),
+    callRecorderFailureReason: normalizeOptionalString2(
+      callRecording.callRecorderFailureReason
+    )
+  }));
+};
+var normalizeOptionalString2 = (value) => isNonEmptyString(value) ? value : void 0;
+var normalizeCallRecordingRequestStatus = (recordingRequestStatus) => {
+  if (recordingRequestStatus === "REQUESTED" /* REQUESTED */) {
+    return recordingRequestStatus;
+  }
+  if (recordingRequestStatus === "CANCELED" /* CANCELED */) {
+    return recordingRequestStatus;
+  }
+  return void 0;
+};
+
+// src/logic-functions/data/find-call-recordings-by-ids.util.ts
+var findCallRecordingsByIds = async (client, callRecordingIds) => {
+  if (callRecordingIds.length === 0) {
+    return [];
+  }
+  return findCallRecordingsByFilter(client, {
+    id: { in: callRecordingIds }
+  });
+};
+
+// src/logic-functions/data/get-current-workspace-id.util.ts
+var import_guards22 = __toESM(require_build());
+var APP_ACCESS_TOKEN_ENV_VAR_NAME = "TWENTY_APP_ACCESS_TOKEN";
+var getCurrentWorkspaceId = () => {
+  const accessToken = getString(process.env[APP_ACCESS_TOKEN_ENV_VAR_NAME]);
+  if ((0, import_guards22.isUndefined)(accessToken)) {
+    return void 0;
+  }
+  return getWorkspaceIdFromAccessToken(accessToken);
+};
+var getWorkspaceIdFromAccessToken = (accessToken) => {
+  const encodedPayload = accessToken.split(".")[1];
+  if ((0, import_guards22.isUndefined)(encodedPayload)) {
+    return void 0;
+  }
+  try {
+    const payload = asRecord(
+      JSON.parse(Buffer.from(encodedPayload, "base64url").toString("utf8"))
+    );
+    return getString(payload?.workspaceId);
+  } catch {
+    return void 0;
+  }
+};
+
+// src/logic-functions/recall-api/schedule-recall-bot.util.ts
+var import_guards24 = __toESM(require_build());
+
+// src/logic-functions/constants/recall-bot-automatic-leave.ts
+var import_guards23 = __toESM(require_build());
+
+// src/logic-functions/constants/call-recorder-everyone-left-timeout-seconds-env-var-name.ts
+var CALL_RECORDER_EVERYONE_LEFT_TIMEOUT_SECONDS_ENV_VAR_NAME = "CALL_RECORDER_EVERYONE_LEFT_TIMEOUT_SECONDS";
+
+// src/logic-functions/constants/call-recorder-noone-joined-timeout-seconds-env-var-name.ts
+var CALL_RECORDER_NOONE_JOINED_TIMEOUT_SECONDS_ENV_VAR_NAME = "CALL_RECORDER_NOONE_JOINED_TIMEOUT_SECONDS";
+
+// src/logic-functions/constants/call-recorder-waiting-room-timeout-seconds-env-var-name.ts
+var CALL_RECORDER_WAITING_ROOM_TIMEOUT_SECONDS_ENV_VAR_NAME = "CALL_RECORDER_WAITING_ROOM_TIMEOUT_SECONDS";
+
+// src/logic-functions/constants/recall-bot-everyone-left-min-activate-after-seconds.ts
+var RECALL_BOT_EVERYONE_LEFT_MIN_ACTIVATE_AFTER_SECONDS = 1;
+
+// src/logic-functions/constants/recall-bot-automatic-leave.ts
+var getRecallBotAutomaticLeave = () => {
+  const waitingRoomTimeoutSeconds = getOptionalPositiveIntegerVariable(
+    CALL_RECORDER_WAITING_ROOM_TIMEOUT_SECONDS_ENV_VAR_NAME
+  );
+  const nooneJoinedTimeoutSeconds = getOptionalPositiveIntegerVariable(
+    CALL_RECORDER_NOONE_JOINED_TIMEOUT_SECONDS_ENV_VAR_NAME
+  );
+  const everyoneLeftTimeoutSeconds = getOptionalPositiveIntegerVariable(
+    CALL_RECORDER_EVERYONE_LEFT_TIMEOUT_SECONDS_ENV_VAR_NAME
+  );
+  const automaticLeave = {};
+  if (!(0, import_guards23.isUndefined)(waitingRoomTimeoutSeconds)) {
+    automaticLeave.waiting_room_timeout = waitingRoomTimeoutSeconds;
+  }
+  if (!(0, import_guards23.isUndefined)(nooneJoinedTimeoutSeconds)) {
+    automaticLeave.noone_joined_timeout = nooneJoinedTimeoutSeconds;
+  }
+  if (!(0, import_guards23.isUndefined)(everyoneLeftTimeoutSeconds)) {
+    automaticLeave.everyone_left_timeout = {
+      timeout: everyoneLeftTimeoutSeconds,
+      activate_after: RECALL_BOT_EVERYONE_LEFT_MIN_ACTIVATE_AFTER_SECONDS
+    };
+  }
+  return Object.keys(automaticLeave).length === 0 ? void 0 : automaticLeave;
+};
+var getOptionalPositiveIntegerVariable = (variableName) => {
+  const rawValue = normalizeOptionalString3(
+    getApplicationVariableValue(variableName)
+  );
+  if ((0, import_guards23.isUndefined)(rawValue)) {
+    return void 0;
+  }
+  const timeoutSeconds = Number(rawValue);
+  if (!Number.isInteger(timeoutSeconds) || timeoutSeconds <= 0) {
+    return void 0;
+  }
+  return timeoutSeconds;
+};
+var normalizeOptionalString3 = (value) => isNonEmptyString(value) ? value.trim() : void 0;
+
+// src/logic-functions/constants/call-recorder-recording-retention-hours-env-var-name.ts
+var CALL_RECORDER_RECORDING_RETENTION_HOURS_ENV_VAR_NAME = "CALL_RECORDER_RECORDING_RETENTION_HOURS";
+
+// src/logic-functions/constants/default-call-recorder-recording-retention-hours.ts
+var DEFAULT_CALL_RECORDER_RECORDING_RETENTION_HOURS = 166;
+
+// src/logic-functions/constants/recall-bot-recording-config.ts
+var getRecallBotRecordingConfig = () => {
+  const configuredRecordingRetentionHours = getApplicationVariableValue(
+    CALL_RECORDER_RECORDING_RETENTION_HOURS_ENV_VAR_NAME
+  );
+  const recordingRetentionHours = isNonEmptyString(
+    configuredRecordingRetentionHours
+  ) ? Number(configuredRecordingRetentionHours.trim()) : NaN;
+  const resolvedRecordingRetentionHours = Number.isInteger(recordingRetentionHours) && recordingRetentionHours > 0 ? recordingRetentionHours : DEFAULT_CALL_RECORDER_RECORDING_RETENTION_HOURS;
+  return {
+    video_mixed_mp4: {},
+    audio_mixed_mp3: {},
+    retention: { type: "timed", hours: resolvedRecordingRetentionHours }
+  };
+};
+
+// src/logic-functions/recall-api/extract-recall-bot-id.util.ts
+var extractRecallBotId = (response) => getString(response?.id) ?? getString(response?.bot_id);
+
+// src/logic-functions/recall-api/schedule-recall-bot.util.ts
+var scheduleRecallBot = async ({
+  meetingUrl,
+  joinAt,
+  metadata
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const automaticLeave = getRecallBotAutomaticLeave();
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: "/bot/",
+    method: "POST",
+    body: {
+      meeting_url: meetingUrl,
+      join_at: joinAt,
+      bot_name: configResult.config.botName,
+      ...(0, import_guards24.isUndefined)(automaticLeave) ? {} : { automatic_leave: automaticLeave },
+      recording_config: getRecallBotRecordingConfig(),
+      metadata
+    }
+  });
+  if (!result.ok) {
+    return result;
+  }
+  const externalBotId = extractRecallBotId(result.data);
+  if ((0, import_guards24.isUndefined)(externalBotId)) {
+    return {
+      ok: false,
+      status: null,
+      errorMessage: "Recall API created a bot but the response did not include a bot id"
+    };
+  }
+  return {
+    ok: true,
+    externalBotId
+  };
+};
+
+// src/logic-functions/flows/ensure-call-recorder.util.ts
+var ensureCallRecorder = async (client, { callRecording, calendarEvent }) => {
+  const meetingUrl = calendarEvent.conferenceLinkUrl;
+  const meetingStartsAt = calendarEvent.startsAt;
+  if ((0, import_guards25.isUndefined)(meetingUrl) || (0, import_guards25.isUndefined)(meetingStartsAt)) {
+    return false;
+  }
+  const joinAt = computeRecallBotJoinAt(meetingStartsAt);
+  const freshCallRecording = (await findCallRecordingsByIds(client, [callRecording.id]))[0];
+  if ((0, import_guards25.isUndefined)(freshCallRecording) || freshCallRecording.recordingRequestStatus !== "REQUESTED" /* REQUESTED */ || !(0, import_guards25.isUndefined)(freshCallRecording.externalBotId)) {
+    return false;
+  }
+  const workspaceId = getCurrentWorkspaceId();
+  if ((0, import_guards25.isUndefined)(workspaceId)) {
+    console.error(
+      `[call-recorder] cannot schedule Recall bot for callRecording ${callRecording.id}: workspace id unavailable, the shared webhook could not be routed back`
+    );
+    return false;
+  }
+  const scheduleResult = await scheduleRecallBot({
+    meetingUrl,
+    joinAt,
+    metadata: buildRecallRoutingMetadata({
+      callRecordingId: callRecording.id,
+      workspaceId
+    })
+  });
+  if (!scheduleResult.ok) {
+    console.warn(
+      `[call-recorder] failed to schedule Recall bot for callRecording ${callRecording.id}: ${scheduleResult.errorMessage}`
+    );
+    return false;
+  }
+  await updateCallRecording(client, {
+    id: callRecording.id,
+    data: { externalBotId: scheduleResult.externalBotId }
+  });
+  return true;
+};
+
+// src/logic-functions/data/fetch-calendar-events-by-filter.util.ts
+var import_guards26 = __toESM(require_build());
+
+// src/logic-functions/constants/restricted-field-placeholder.ts
+var RESTRICTED_FIELD_PLACEHOLDER = "FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED";
+
+// src/logic-functions/data/strip-restricted-field-value.util.ts
+var stripRestrictedFieldValue = (value) => value === RESTRICTED_FIELD_PLACEHOLDER ? void 0 : value;
+
+// src/logic-functions/data/fetch-calendar-events-by-filter.util.ts
+var fetchCalendarEventsByFilter = async (client, filter) => {
+  const calendarEventNodes = await fetchAllNodes(
+    async (afterCursor) => {
+      const queryResult = await client.query({
+        calendarEvents: {
+          __args: {
+            filter,
+            first: TWENTY_PAGE_SIZE,
+            ...(0, import_guards26.isUndefined)(afterCursor) ? {} : { after: afterCursor }
+          },
+          pageInfo: {
+            hasNextPage: true,
+            endCursor: true
+          },
+          edges: {
+            node: {
+              id: true,
+              title: true,
+              isCanceled: true,
+              startsAt: true,
+              endsAt: true,
+              iCalUid: true,
+              conferenceLink: {
+                primaryLinkUrl: true
+              },
+              callRecorderPreference: true
+            }
+          }
+        }
+      });
+      return queryResult.calendarEvents;
+    }
+  );
+  return calendarEventNodes.map((calendarEvent) => ({
+    id: calendarEvent.id,
+    title: stripRestrictedFieldValue(calendarEvent.title ?? void 0),
+    isCanceled: calendarEvent.isCanceled ?? false,
+    startsAt: calendarEvent.startsAt ?? void 0,
+    endsAt: calendarEvent.endsAt ?? void 0,
+    iCalUid: calendarEvent.iCalUid ?? void 0,
+    conferenceLinkUrl: isNonEmptyString(
+      calendarEvent.conferenceLink?.primaryLinkUrl
+    ) ? calendarEvent.conferenceLink.primaryLinkUrl : void 0,
+    callRecorderPreference: (0, import_guards26.isString)(calendarEvent.callRecorderPreference) ? calendarEvent.callRecorderPreference : void 0
+  }));
+};
+
+// src/logic-functions/utils/get-unique-sorted-ids.util.ts
+var import_guards27 = __toESM(require_build());
+var getUniqueSortedIds = (ids) => [...new Set(ids.filter(import_guards27.isString))].sort(
+  (firstId, secondId) => firstId.localeCompare(secondId)
+);
+
+// src/logic-functions/data/fetch-calendar-events-by-ids.util.ts
+var fetchCalendarEventsByIds = async (client, calendarEventIds) => {
+  const uniqueCalendarEventIds = getUniqueSortedIds(calendarEventIds);
+  if (uniqueCalendarEventIds.length === 0) {
+    return [];
+  }
+  return fetchCalendarEventsByFilter(client, {
+    id: { in: uniqueCalendarEventIds }
+  });
+};
+
+// src/logic-functions/data/find-open-scheduled-call-recordings.util.ts
+var findOpenScheduledCallRecordings = async (client) => findCallRecordingsByFilter(client, {
+  recordingRequestStatus: { eq: "REQUESTED" /* REQUESTED */ },
+  status: { eq: "SCHEDULED" /* SCHEDULED */ }
+});
+
+// src/logic-functions/flows/heal-call-recordings-missing-bot.util.ts
+var healCallRecordingsMissingBot = async ({
+  client,
+  now
+}) => {
+  const botlessCallRecordings = (await findOpenScheduledCallRecordings(client)).filter((callRecording) => (0, import_guards28.isUndefined)(callRecording.externalBotId));
+  if (botlessCallRecordings.length === 0) {
+    return { scheduledCallRecordingIds: [] };
+  }
+  const calendarEventsById = new Map(
+    (await fetchCalendarEventsByIds(
+      client,
+      getUniqueSortedIds(
+        botlessCallRecordings.map(
+          (callRecording) => callRecording.calendarEventId
+        )
+      )
+    )).map((calendarEvent) => [calendarEvent.id, calendarEvent])
+  );
+  const scheduledCallRecordingIds = [];
+  for (const callRecording of botlessCallRecordings) {
+    const calendarEvent = (0, import_guards28.isUndefined)(callRecording.calendarEventId) ? void 0 : calendarEventsById.get(callRecording.calendarEventId);
+    if ((0, import_guards28.isUndefined)(calendarEvent) || hasMeetingEnded({ calendarEvent, now })) {
+      continue;
+    }
+    const didScheduleCallRecorder = await ensureCallRecorder(client, {
+      callRecording,
+      calendarEvent
+    });
+    if (didScheduleCallRecorder) {
+      scheduledCallRecordingIds.push(callRecording.id);
+    }
+  }
+  return { scheduledCallRecordingIds };
+};
+var hasMeetingEnded = ({
+  calendarEvent,
+  now
+}) => {
+  const reference = calendarEvent.endsAt ?? calendarEvent.startsAt;
+  if ((0, import_guards28.isUndefined)(reference)) {
+    return false;
+  }
+  const referenceTime = new Date(reference).getTime();
+  return !Number.isNaN(referenceTime) && referenceTime <= now.getTime();
+};
+
+// src/logic-functions/flows/reap-orphaned-call-recorders.util.ts
+var import_guards30 = __toESM(require_build());
+
+// src/logic-functions/recall-api/cancel-recall-bot.util.ts
+var cancelRecallBot = async ({
+  externalBotId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/bot/${externalBotId}/`,
+    method: "DELETE",
+    allowNotFound: true
+  });
+  if (!result.ok) {
+    return result;
+  }
+  return { ok: true };
+};
+
+// src/logic-functions/recall-api/eject-recall-bot.util.ts
+var ejectRecallBot = async ({
+  externalBotId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/bot/${externalBotId}/leave_call/`,
+    method: "POST",
+    allowNotFound: true
+  });
+  if (!result.ok) {
+    return result;
+  }
+  return { ok: true };
+};
+
+// src/logic-functions/recall-api/list-scheduled-recall-bots.util.ts
+var import_guards29 = __toESM(require_build());
+var RECALL_BOT_LIST_MAX_PAGES = 10;
+var listScheduledRecallBots = async ({
+  joinAtAfter,
+  joinAtBefore
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const bots = [];
+  let path = `/bot/?join_at_after=${encodeURIComponent(
+    joinAtAfter
+  )}&join_at_before=${encodeURIComponent(joinAtBefore)}`;
+  for (let pageIndex = 0; !(0, import_guards29.isUndefined)(path) && pageIndex < RECALL_BOT_LIST_MAX_PAGES; pageIndex++) {
+    const result = await recallBotApiRequest({
+      config: configResult.config,
+      path,
+      method: "GET"
+    });
+    if (!result.ok) {
+      return result;
+    }
+    bots.push(...extractRecallBots(result.data));
+    path = extractNextPath2(result.data, configResult.config.baseUrl);
+  }
+  if (!(0, import_guards29.isUndefined)(path)) {
+    return {
+      ok: false,
+      status: null,
+      errorMessage: `Recall bot list exceeded ${RECALL_BOT_LIST_MAX_PAGES} pages`
+    };
+  }
+  return { ok: true, bots };
+};
+var extractRecallBots = (response) => {
+  if (!Array.isArray(response?.results)) {
+    return [];
+  }
+  return response.results.flatMap((candidate) => {
+    const bot = asRecord(candidate);
+    if ((0, import_guards29.isUndefined)(bot) || !(0, import_guards29.isString)(bot.id)) {
+      return [];
+    }
+    return [
+      {
+        id: bot.id,
+        metadata: asRecord(bot.metadata) ?? {}
+      }
+    ];
+  });
+};
+var extractNextPath2 = (response, baseUrl) => {
+  const next = response?.next;
+  if (!(0, import_guards29.isString)(next) || !next.startsWith(baseUrl)) {
+    return void 0;
+  }
+  return next.slice(baseUrl.length);
+};
+
+// src/logic-functions/flows/reap-orphaned-call-recorders.util.ts
+var reapOrphanedCallRecorders = async ({
+  client,
+  joinAtAfter,
+  joinAtBefore
+}) => {
+  const listResult = await listScheduledRecallBots({
+    joinAtAfter,
+    joinAtBefore
+  });
+  if (!listResult.ok) {
+    console.warn(
+      `[call-recorder] failed to list Recall bots for orphan reaping: ${listResult.errorMessage}`
+    );
+    return { scannedBotCount: 0, canceledExternalBotIds: [] };
+  }
+  const currentWorkspaceId = getCurrentWorkspaceId();
+  if ((0, import_guards30.isUndefined)(currentWorkspaceId)) {
+    console.warn(
+      "[call-recorder] cannot reap orphaned Recall bots: workspace id unavailable"
+    );
+    return {
+      scannedBotCount: listResult.bots.length,
+      canceledExternalBotIds: []
+    };
+  }
+  const workspaceManagedBots = listResult.bots.filter(
+    (bot) => isCurrentWorkspaceManagedBot({ bot, currentWorkspaceId })
+  );
+  if (workspaceManagedBots.length === 0) {
+    return {
+      scannedBotCount: listResult.bots.length,
+      canceledExternalBotIds: []
+    };
+  }
+  const callRecordings = await findCallRecordingsByIds(
+    client,
+    getUniqueSortedIds(
+      workspaceManagedBots.map((bot) => getClaimedCallRecordingId(bot))
+    )
+  );
+  const callRecordingsById = new Map(
+    callRecordings.map((callRecording) => [callRecording.id, callRecording])
+  );
+  const canceledExternalBotIds = [];
+  for (const bot of workspaceManagedBots) {
+    const claimedCallRecordingId = getClaimedCallRecordingId(bot);
+    const callRecording = (0, import_guards30.isUndefined)(claimedCallRecordingId) ? void 0 : callRecordingsById.get(claimedCallRecordingId);
+    if (isBotClaimed({ bot, callRecording })) {
+      continue;
+    }
+    console.warn(
+      `[call-recorder] canceling orphaned Recall bot ${bot.id} (claimed callRecording: ${claimedCallRecordingId})`
+    );
+    if (await cancelOrEjectRecallBot(bot.id)) {
+      canceledExternalBotIds.push(bot.id);
+    }
+  }
+  return {
+    scannedBotCount: listResult.bots.length,
+    canceledExternalBotIds
+  };
+};
+var getClaimedCallRecordingId = (bot) => {
+  const claimedCallRecordingId = bot.metadata.twentyCallRecordingId;
+  return normalizeOptionalString4(claimedCallRecordingId);
+};
+var getClaimedWorkspaceId = (bot) => {
+  const claimedWorkspaceId = bot.metadata.twentyWorkspaceId;
+  return normalizeOptionalString4(claimedWorkspaceId);
+};
+var isCurrentWorkspaceManagedBot = ({
+  bot,
+  currentWorkspaceId
+}) => {
+  if ((0, import_guards30.isUndefined)(getClaimedCallRecordingId(bot))) {
+    return false;
+  }
+  const claimedWorkspaceId = getClaimedWorkspaceId(bot);
+  return claimedWorkspaceId === currentWorkspaceId;
+};
+var isBotClaimed = ({
+  bot,
+  callRecording
+}) => {
+  if (callRecording?.recordingRequestStatus !== "REQUESTED" /* REQUESTED */) {
+    return false;
+  }
+  if (callRecording.externalBotId === bot.id) {
+    return true;
+  }
+  return (0, import_guards30.isUndefined)(callRecording.externalBotId);
+};
+var cancelOrEjectRecallBot = async (externalBotId) => {
+  const cancelResult = await cancelRecallBot({ externalBotId });
+  if (cancelResult.ok) {
+    return true;
+  }
+  if (!(0, import_guards30.isNull)(cancelResult.status)) {
+    const ejectResult = await ejectRecallBot({ externalBotId });
+    if (ejectResult.ok) {
+      return true;
+    }
+  }
+  console.warn(
+    `[call-recorder] failed to cancel orphaned Recall bot ${externalBotId}: ${cancelResult.errorMessage}`
+  );
+  return false;
+};
+var normalizeOptionalString4 = (value) => isNonEmptyString(value) ? value.trim() : void 0;
+
+// src/logic-functions/reconcile-stale-bot-state.ts
+var REAPER_JOIN_AT_LOOKBACK_HOURS = 4;
+var REAPER_JOIN_AT_LOOKAHEAD_HOURS = 24;
+var reconcileStaleBotStateHandler = async () => {
+  const now = /* @__PURE__ */ new Date();
+  const client = new CoreApiClient();
+  const botlessHealResult = await healCallRecordingsMissingBotSafely(
+    client,
+    now
+  );
+  const orphanedBotReapingResult = await reapOrphanedCallRecordersInJoinAtWindow(client, now);
+  const statusConvergenceResult = await convergeDivergedCallRecordingsSafely(
+    client,
+    now
+  );
+  return {
+    botlessHealResult,
+    orphanedBotReapingResult,
+    statusConvergenceResult
+  };
+};
+var healCallRecordingsMissingBotSafely = async (client, now) => {
+  try {
+    return await healCallRecordingsMissingBot({ client, now });
+  } catch (error) {
+    return buildStepFailure("botless call recording healing", error);
+  }
+};
+var reapOrphanedCallRecordersInJoinAtWindow = async (client, now) => {
+  try {
+    return await reapOrphanedCallRecorders({
+      client,
+      joinAtAfter: new Date(
+        now.getTime() - REAPER_JOIN_AT_LOOKBACK_HOURS * 60 * 60 * 1e3
+      ).toISOString(),
+      joinAtBefore: new Date(
+        now.getTime() + REAPER_JOIN_AT_LOOKAHEAD_HOURS * 60 * 60 * 1e3
+      ).toISOString()
+    });
+  } catch (error) {
+    return buildStepFailure("orphaned bot reaping", error);
+  }
+};
+var convergeDivergedCallRecordingsSafely = async (client, now) => {
+  try {
+    return await convergeDivergedCallRecordings({ client, now });
+  } catch (error) {
+    return buildStepFailure("call recording status convergence", error);
+  }
+};
+var buildStepFailure = (stepLabel, error) => {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (process.env.NODE_ENV !== "test") {
+    console.error(`[call-recorder] ${stepLabel} failed: ${errorMessage}`);
+  }
+  return { error: `${stepLabel} failed` };
+};
+var reconcile_stale_bot_state_default = defineLogicFunction({
+  universalIdentifier: STALE_BOT_STATE_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+  name: "reconcile-stale-bot-state",
+  description: "Converges call recordings with Recall on a schedule: pulls stale bot statuses and overdue transcripts, finishes failed cancellations, schedules bots for recordings still missing one, and reaps unclaimed bots. Reads calendar events only to heal already-decided recordings, never to discover meetings.",
+  timeoutSeconds: 250,
+  handler: reconcileStaleBotStateHandler,
+  cronTriggerSettings: {
+    pattern: STALE_BOT_STATE_CRON_PATTERN
+  }
+});
+export {
+  reconcile_stale_bot_state_default as default
+};
+//# sourceMappingURL=reconcile-stale-bot-state.mjs.map