@twentyhq/call-recorder 1.0.1 → 1.0.2

package/src/logic-functions/reconcile-call-recorder-calendar-event.mjs

@@ -0,0 +1,1602 @@
+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 (e) {
+    throw mod = 0, e;
+  }
+};
+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 isUndefined17 = (term) => {
+      return typeof term === "undefined";
+    };
+    exports.isUndefined = isUndefined17;
+    var isBoolean = (term) => {
+      return typeof term === "boolean";
+    };
+    exports.isBoolean = isBoolean;
+    var isNumber = (term) => {
+      return typeof term === "number" && !Number.isNaN(term);
+    };
+    exports.isNumber = isNumber;
+    var isString5 = (term) => {
+      return typeof term === "string";
+    };
+    exports.isString = isString5;
+    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 isNull = (term) => {
+      return term === null;
+    };
+    exports.isNull = isNull;
+    var isFunction = (term) => {
+      return typeof term === "function";
+    };
+    exports.isFunction = isFunction;
+    var isObject2 = (term) => {
+      return !exports.isNull(term) && typeof term === "object";
+    };
+    exports.isObject = isObject2;
+    var isArray2 = (term) => {
+      return Array.isArray(term);
+    };
+    exports.isArray = isArray2;
+    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 isNonEmptyArray = (term) => {
+      return structural_1.isArray(term) && term.length > 0;
+    };
+    exports.isNonEmptyArray = isNonEmptyArray;
+    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-call-recorder-calendar-event.ts
+var import_guards19 = __toESM(require_build());
+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/calendar-event-reconciliation-logic-function-universal-identifier.ts
+var CALENDAR_EVENT_RECONCILIATION_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER = "1f28c477-6423-4911-85bf-2296ef112be9";
+
+// src/logic-functions/domain/compute-real-meeting-key.util.ts
+var import_guards2 = __toESM(require_build());
+
+// src/logic-functions/utils/is-non-empty-string.util.ts
+var import_guards = __toESM(require_build());
+var isNonEmptyString = (value) => (0, import_guards.isString)(value) && value.trim() !== "";
+
+// src/logic-functions/domain/compute-real-meeting-key.util.ts
+var computeRealMeetingKey = ({
+  calendarEventId,
+  conferenceLinkUrl,
+  iCalUid,
+  startsAt
+}) => {
+  const normalizedConferenceLink = normalizeConferenceLink(conferenceLinkUrl);
+  if (!(0, import_guards2.isUndefined)(normalizedConferenceLink)) {
+    return `link:${normalizedConferenceLink}:${startsAt ?? ""}`;
+  }
+  if (isNonEmptyString(iCalUid)) {
+    return `ical:${iCalUid}:${startsAt ?? ""}`;
+  }
+  return `event:${calendarEventId}`;
+};
+var normalizeConferenceLink = (conferenceLinkUrl) => {
+  if (!isNonEmptyString(conferenceLinkUrl)) {
+    return void 0;
+  }
+  const withoutProtocol = conferenceLinkUrl.trim().toLowerCase().replace(/^https?:\/\//, "").replace(/^www\./, "");
+  const withoutQueryAndFragment = withoutProtocol.split(/[?#]/)[0];
+  const withoutTrailingSlash = withoutQueryAndFragment.replace(/\/+$/, "");
+  return withoutTrailingSlash === "" ? void 0 : withoutTrailingSlash;
+};
+
+// src/logic-functions/utils/get-unique-sorted-ids.util.ts
+var import_guards3 = __toESM(require_build());
+var getUniqueSortedIds = (ids) => [...new Set(ids.filter(import_guards3.isString))].sort(
+  (firstId, secondId) => firstId.localeCompare(secondId)
+);
+
+// src/logic-functions/flows/reconcile-call-recorder.util.ts
+var import_guards18 = __toESM(require_build());
+
+// src/logic-functions/domain/aggregate-call-recorder-policy-results-by-meeting.util.ts
+var aggregateCallRecorderPolicyResultsByMeeting = (perCalendarEventPolicyResults) => {
+  const meetingPolicyResultsByMeetingKey = /* @__PURE__ */ new Map();
+  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()];
+};
+
+// src/constants/call-recorder-preference.ts
+var CallRecorderPreference = /* @__PURE__ */ ((CallRecorderPreference2) => {
+  CallRecorderPreference2["ON"] = "ON";
+  CallRecorderPreference2["OFF"] = "OFF";
+  return CallRecorderPreference2;
+})(CallRecorderPreference || {});
+
+// src/logic-functions/domain/resolve-call-recorder-policy-result.util.ts
+var resolveCallRecorderPolicyResult = ({
+  input,
+  now
+}) => {
+  if (input.isCanceled) {
+    return botNotRequired("EVENT_CANCELED");
+  }
+  if (input.callRecorderPreference === "OFF" /* OFF */) {
+    return botNotRequired("PREFERENCE_OFF");
+  }
+  if (!isNonEmptyString(input.conferenceLinkUrl)) {
+    return botNotRequired("MISSING_CONFERENCE_LINK");
+  }
+  if (!isCalendarEventInFuture({
+    startsAt: input.startsAt,
+    endsAt: input.endsAt,
+    now
+  })) {
+    return botNotRequired("EVENT_NOT_UPCOMING");
+  }
+  return botRequired("RECORDING_ENABLED");
+};
+var isCalendarEventInFuture = ({
+  startsAt,
+  endsAt,
+  now
+}) => {
+  const reference = endsAt ?? startsAt;
+  if (!isNonEmptyString(reference)) {
+    return false;
+  }
+  const referenceTime = new Date(reference).getTime();
+  if (Number.isNaN(referenceTime)) {
+    return false;
+  }
+  return referenceTime > now.getTime();
+};
+var botRequired = (reason) => ({ shouldRequestBot: true, reason });
+var botNotRequired = (reason) => ({ shouldRequestBot: false, reason });
+
+// src/logic-functions/domain/build-call-recorder-policy-result.util.ts
+var buildCallRecorderPolicyResult = (calendarEvent, now) => {
+  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
+  };
+};
+var normalizeCallRecorderPreference = (callRecorderPreference) => isCallRecorderPreference(callRecorderPreference) ? callRecorderPreference : void 0;
+var isCallRecorderPreference = (callRecorderPreference) => Object.values(CallRecorderPreference).some(
+  (preference) => preference === callRecorderPreference
+);
+
+// src/logic-functions/flows/cancel-call-recording-request.util.ts
+var import_guards6 = __toESM(require_build());
+
+// src/logic-functions/recall-api/get-recall-api-config.util.ts
+var import_guards4 = __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_guards4.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_guards5 = __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_guards5.isUndefined)(body) ? {} : { "Content-Type": "application/json" }
+      },
+      ...(0, import_guards5.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/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/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/cancel-call-recording-request.util.ts
+var cancelCallRecordingRequest = async ({
+  client,
+  callRecording
+}) => {
+  await updateCallRecording(client, {
+    id: callRecording.id,
+    data: {
+      recordingRequestStatus: "CANCELED" /* CANCELED */
+    }
+  });
+  if ((0, import_guards6.isUndefined)(callRecording.externalBotId)) {
+    return;
+  }
+  const cancelResult = await cancelRecallBot({
+    externalBotId: callRecording.externalBotId
+  });
+  if (!cancelResult.ok) {
+    console.warn(
+      `[call-recorder] failed to cancel Recall bot for callRecording ${callRecording.id}, leaving it for the stale-state cron: ${cancelResult.errorMessage}`
+    );
+    return;
+  }
+  await updateCallRecording(client, {
+    id: callRecording.id,
+    data: {
+      externalBotId: null
+    }
+  });
+};
+
+// src/logic-functions/domain/compute-call-recording-id-for-meeting.util.ts
+import { createHash } from "crypto";
+var computeCallRecordingIdForMeeting = (realMeetingKey) => {
+  const bytes = createHash("sha256").update(realMeetingKey).digest();
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.subarray(0, 16).toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+
+// src/logic-functions/data/create-call-recording.util.ts
+var import_guards7 = __toESM(require_build());
+var createCallRecording = async (client, {
+  id,
+  data
+}) => {
+  const mutationResult = await client.mutation({
+    createCallRecording: {
+      __args: {
+        data: { id, ...data }
+      },
+      id: true
+    }
+  });
+  const createdCallRecordingId = mutationResult.createCallRecording?.id;
+  if ((0, import_guards7.isUndefined)(createdCallRecordingId)) {
+    throw new Error(
+      "createCallRecording mutation did not return a call recording id"
+    );
+  }
+  return createdCallRecordingId;
+};
+
+// src/logic-functions/flows/ensure-call-recorder.util.ts
+var import_guards14 = __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/milliseconds-per-minute.ts
+var MILLISECONDS_PER_MINUTE = 6e4;
+
+// 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_guards9 = __toESM(require_build());
+
+// src/logic-functions/constants/twenty-page-size.ts
+var TWENTY_PAGE_SIZE = 100;
+
+// src/logic-functions/data/fetch-all-nodes.util.ts
+var import_guards8 = __toESM(require_build());
+var fetchAllNodes = async (fetchPage) => {
+  const nodes = [];
+  let hasNextPage = true;
+  let afterCursor;
+  while (hasNextPage) {
+    const connection = await fetchPage(afterCursor);
+    if ((0, import_guards8.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_guards8.isString)(endCursor)) {
+      throw new Error(
+        "Inconsistent pagination state: hasNextPage is true without an endCursor"
+      );
+    }
+    afterCursor = (0, import_guards8.isString)(endCursor) ? endCursor : void 0;
+  }
+  return nodes;
+};
+
+// src/logic-functions/data/find-call-recordings-by-filter.util.ts
+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_guards9.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_guards11 = __toESM(require_build());
+
+// src/logic-functions/utils/as-record.util.ts
+var import_guards10 = __toESM(require_build());
+var asRecord = (value) => (0, import_guards10.isObject)(value) && !(0, import_guards10.isArray)(value) ? value : void 0;
+
+// src/logic-functions/utils/get-string.util.ts
+var getString = (value) => isNonEmptyString(value) ? value : void 0;
+
+// src/logic-functions/data/get-current-workspace-id.util.ts
+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_guards11.isUndefined)(accessToken)) {
+    return void 0;
+  }
+  return getWorkspaceIdFromAccessToken(accessToken);
+};
+var getWorkspaceIdFromAccessToken = (accessToken) => {
+  const encodedPayload = accessToken.split(".")[1];
+  if ((0, import_guards11.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_guards13 = __toESM(require_build());
+
+// src/logic-functions/constants/recall-bot-automatic-leave.ts
+var import_guards12 = __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_guards12.isUndefined)(waitingRoomTimeoutSeconds)) {
+    automaticLeave.waiting_room_timeout = waitingRoomTimeoutSeconds;
+  }
+  if (!(0, import_guards12.isUndefined)(nooneJoinedTimeoutSeconds)) {
+    automaticLeave.noone_joined_timeout = nooneJoinedTimeoutSeconds;
+  }
+  if (!(0, import_guards12.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_guards12.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_guards13.isUndefined)(automaticLeave) ? {} : { automatic_leave: automaticLeave },
+      recording_config: getRecallBotRecordingConfig(),
+      metadata
+    }
+  });
+  if (!result.ok) {
+    return result;
+  }
+  const externalBotId = extractRecallBotId(result.data);
+  if ((0, import_guards13.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_guards14.isUndefined)(meetingUrl) || (0, import_guards14.isUndefined)(meetingStartsAt)) {
+    return false;
+  }
+  const joinAt = computeRecallBotJoinAt(meetingStartsAt);
+  const freshCallRecording = (await findCallRecordingsByIds(client, [callRecording.id]))[0];
+  if ((0, import_guards14.isUndefined)(freshCallRecording) || freshCallRecording.recordingRequestStatus !== "REQUESTED" /* REQUESTED */ || !(0, import_guards14.isUndefined)(freshCallRecording.externalBotId)) {
+    return false;
+  }
+  const workspaceId = getCurrentWorkspaceId();
+  if ((0, import_guards14.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_guards15 = __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_guards15.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_guards15.isString)(calendarEvent.callRecorderPreference) ? calendarEvent.callRecorderPreference : void 0
+  }));
+};
+
+// 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/fetch-calendar-events-by-starts-at-values.util.ts
+var fetchCalendarEventsByStartsAtValues = async (client, startsAtValues) => {
+  const uniqueStartsAtValues = [...new Set(startsAtValues)].sort();
+  if (uniqueStartsAtValues.length === 0) {
+    return [];
+  }
+  return fetchCalendarEventsByFilter(client, {
+    startsAt: { in: uniqueStartsAtValues }
+  });
+};
+
+// src/logic-functions/data/find-call-recordings-by-calendar-event-ids.util.ts
+var findCallRecordingsByCalendarEventIds = async (client, calendarEventIds) => {
+  if (calendarEventIds.length === 0) {
+    return [];
+  }
+  return findCallRecordingsByFilter(client, {
+    calendarEventId: { in: calendarEventIds }
+  });
+};
+
+// src/logic-functions/flows/reschedule-call-recording-bot.util.ts
+var import_guards17 = __toESM(require_build());
+
+// src/logic-functions/recall-api/reschedule-recall-bot.util.ts
+var import_guards16 = __toESM(require_build());
+var rescheduleRecallBot = async ({
+  externalBotId,
+  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/${externalBotId}/`,
+    method: "PATCH",
+    body: {
+      meeting_url: meetingUrl,
+      join_at: joinAt,
+      bot_name: configResult.config.botName,
+      ...(0, import_guards16.isUndefined)(automaticLeave) ? {} : { automatic_leave: automaticLeave },
+      recording_config: getRecallBotRecordingConfig(),
+      metadata
+    }
+  });
+  if (!result.ok) {
+    return result;
+  }
+  return {
+    ok: true,
+    externalBotId: extractRecallBotId(result.data) ?? externalBotId
+  };
+};
+
+// src/logic-functions/flows/reschedule-call-recording-bot.util.ts
+var RECALL_BOT_NOT_FOUND_STATUS = 404;
+var rescheduleCallRecordingBot = async (client, { callRecording, calendarEvent }) => {
+  const externalBotId = callRecording.externalBotId;
+  if ((0, import_guards17.isUndefined)(externalBotId)) {
+    return;
+  }
+  const meetingUrl = calendarEvent.conferenceLinkUrl;
+  const meetingStartsAt = calendarEvent.startsAt;
+  if ((0, import_guards17.isUndefined)(meetingUrl) || (0, import_guards17.isUndefined)(meetingStartsAt)) {
+    return;
+  }
+  const joinAt = computeRecallBotJoinAt(meetingStartsAt);
+  const workspaceId = getCurrentWorkspaceId();
+  if ((0, import_guards17.isUndefined)(workspaceId)) {
+    console.warn(
+      `[call-recorder] cannot reschedule Recall bot for callRecording ${callRecording.id}: workspace id unavailable`
+    );
+    return;
+  }
+  const rescheduleResult = await rescheduleRecallBot({
+    externalBotId,
+    meetingUrl,
+    joinAt,
+    metadata: buildRecallRoutingMetadata({
+      callRecordingId: callRecording.id,
+      workspaceId
+    })
+  });
+  if (rescheduleResult.ok) {
+    return;
+  }
+  if (rescheduleResult.status === RECALL_BOT_NOT_FOUND_STATUS) {
+    await updateCallRecording(client, {
+      id: callRecording.id,
+      data: { externalBotId: null }
+    });
+    return;
+  }
+  console.warn(
+    `[call-recorder] failed to update Recall bot for callRecording ${callRecording.id}: ${rescheduleResult.errorMessage}`
+  );
+};
+
+// src/logic-functions/flows/reconcile-call-recorder.util.ts
+var reconcileCallRecorderForCalendarEventIds = async ({
+  client,
+  calendarEventIds,
+  removedOccurrences = [],
+  now = /* @__PURE__ */ new Date()
+}) => {
+  const meetingPolicyResults = await resolveCallRecorderPolicyResultsForMeetings({
+    client,
+    calendarEventIds,
+    removedOccurrences,
+    now
+  });
+  return reconcileCallRecorderForMeetingOccurrences({
+    client,
+    meetingPolicyResults,
+    removedOccurrences
+  });
+};
+var resolveCallRecorderPolicyResultsForMeetings = async ({
+  client,
+  calendarEventIds,
+  removedOccurrences = [],
+  now = /* @__PURE__ */ new Date()
+}) => {
+  const changedCalendarEvents = await fetchCalendarEventsByIds(
+    client,
+    getUniqueSortedIds(calendarEventIds)
+  );
+  const affectedMeetingKeys = /* @__PURE__ */ new Set();
+  const occurrenceStartsAtAnchors = /* @__PURE__ */ new Set();
+  const changedCalendarEventPolicyResults = changedCalendarEvents.map(
+    (calendarEvent) => buildCallRecorderPolicyResult(calendarEvent, now)
+  );
+  for (const policyResult of changedCalendarEventPolicyResults) {
+    affectedMeetingKeys.add(policyResult.realMeetingKey);
+  }
+  for (const calendarEvent of changedCalendarEvents) {
+    if (!(0, import_guards18.isUndefined)(calendarEvent.startsAt)) {
+      occurrenceStartsAtAnchors.add(calendarEvent.startsAt);
+    }
+  }
+  for (const removedOccurrence of removedOccurrences) {
+    affectedMeetingKeys.add(removedOccurrence.realMeetingKey);
+    if (!(0, import_guards18.isUndefined)(removedOccurrence.startsAt)) {
+      occurrenceStartsAtAnchors.add(removedOccurrence.startsAt);
+    }
+  }
+  if (affectedMeetingKeys.size === 0) {
+    return [];
+  }
+  const occurrenceSiblingEvents = await fetchCalendarEventsByStartsAtValues(
+    client,
+    [...occurrenceStartsAtAnchors]
+  );
+  const policyResultsByCalendarEventId = new Map(
+    changedCalendarEventPolicyResults.map((policyResult) => [
+      policyResult.calendarEventId,
+      policyResult
+    ])
+  );
+  for (const calendarEvent of occurrenceSiblingEvents) {
+    if (policyResultsByCalendarEventId.has(calendarEvent.id)) {
+      continue;
+    }
+    policyResultsByCalendarEventId.set(
+      calendarEvent.id,
+      buildCallRecorderPolicyResult(calendarEvent, now)
+    );
+  }
+  const perCalendarEventPolicyResults = [
+    ...policyResultsByCalendarEventId.values()
+  ].filter(
+    (policyResult) => affectedMeetingKeys.has(policyResult.realMeetingKey)
+  ).map((policyResult) => ({
+    calendarEventId: policyResult.calendarEventId,
+    realMeetingKey: policyResult.realMeetingKey,
+    shouldRequestBot: policyResult.shouldRequestBot
+  }));
+  const meetingPolicyResults = aggregateCallRecorderPolicyResultsByMeeting(
+    perCalendarEventPolicyResults
+  );
+  const meetingKeysWithPolicyResult = new Set(
+    meetingPolicyResults.map(
+      (meetingPolicyResult) => meetingPolicyResult.realMeetingKey
+    )
+  );
+  for (const meetingKey of [...affectedMeetingKeys].sort()) {
+    if (meetingKeysWithPolicyResult.has(meetingKey)) {
+      continue;
+    }
+    meetingPolicyResults.push({
+      realMeetingKey: meetingKey,
+      shouldRequestBot: false,
+      calendarEventIds: [],
+      requestingCalendarEventIds: []
+    });
+  }
+  return meetingPolicyResults;
+};
+var reconcileCallRecorderForMeetingOccurrences = async ({
+  client,
+  meetingPolicyResults,
+  removedOccurrences = []
+}) => {
+  const removedCalendarEventIdsByMeetingKey = buildRemovedCalendarEventIdsByMeetingKey(removedOccurrences);
+  const reconciliationResults = [];
+  const orderedMeetingPolicyResults = [
+    ...meetingPolicyResults.filter(
+      (meetingPolicyResult) => !meetingPolicyResult.shouldRequestBot
+    ),
+    ...meetingPolicyResults.filter(
+      (meetingPolicyResult) => meetingPolicyResult.shouldRequestBot
+    )
+  ];
+  for (const meetingPolicyResult of orderedMeetingPolicyResults) {
+    const removedCalendarEventIds = removedCalendarEventIdsByMeetingKey.get(
+      meetingPolicyResult.realMeetingKey
+    ) ?? [];
+    try {
+      reconciliationResults.push(
+        meetingPolicyResult.shouldRequestBot ? await reconcileActiveMeeting({
+          client,
+          meetingPolicyResult,
+          removedCalendarEventIds
+        }) : await reconcileCanceledMeeting({
+          client,
+          meetingPolicyResult,
+          removedCalendarEventIds
+        })
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(
+        `[call-recorder] reconciliation failed for meeting ${meetingPolicyResult.realMeetingKey}: ${errorMessage}`
+      );
+      reconciliationResults.push({
+        action: "FAILED",
+        realMeetingKey: meetingPolicyResult.realMeetingKey,
+        errorMessage
+      });
+    }
+  }
+  return reconciliationResults;
+};
+var reconcileActiveMeeting = async ({
+  client,
+  meetingPolicyResult,
+  removedCalendarEventIds
+}) => {
+  const representativeCalendarEventId = getUniqueSortedIds(
+    meetingPolicyResult.requestingCalendarEventIds
+  )[0];
+  if ((0, import_guards18.isUndefined)(representativeCalendarEventId)) {
+    return buildSkippedResult(meetingPolicyResult.realMeetingKey);
+  }
+  const representativeCalendarEvent = (await fetchCalendarEventsByIds(client, [representativeCalendarEventId]))[0];
+  if ((0, import_guards18.isUndefined)(representativeCalendarEvent)) {
+    return buildSkippedResult(meetingPolicyResult.realMeetingKey);
+  }
+  const callRecordingId = computeCallRecordingIdForMeeting(
+    meetingPolicyResult.realMeetingKey
+  );
+  const existingCallRecording = (await findCallRecordingsByIds(client, [callRecordingId]))[0];
+  if (!(0, import_guards18.isUndefined)(existingCallRecording)) {
+    return updatePolicyManagedCallRecording({
+      client,
+      existingCallRecording,
+      representativeCalendarEvent,
+      realMeetingKey: meetingPolicyResult.realMeetingKey
+    });
+  }
+  const manualOpenCallRecording = await findManualOpenCallRecording({
+    client,
+    meetingPolicyResult,
+    removedCalendarEventIds
+  });
+  if (!(0, import_guards18.isUndefined)(manualOpenCallRecording)) {
+    return {
+      action: "SKIPPED",
+      realMeetingKey: meetingPolicyResult.realMeetingKey,
+      callRecordingId: manualOpenCallRecording.id
+    };
+  }
+  return createPolicyManagedCallRecording({
+    client,
+    callRecordingId,
+    representativeCalendarEvent,
+    realMeetingKey: meetingPolicyResult.realMeetingKey
+  });
+};
+var updatePolicyManagedCallRecording = async ({
+  client,
+  existingCallRecording,
+  representativeCalendarEvent,
+  realMeetingKey
+}) => {
+  await updateCallRecording(client, {
+    id: existingCallRecording.id,
+    data: buildPolicyManagedCallRecordingUpdateFields({
+      existingCallRecording,
+      calendarEvent: representativeCalendarEvent
+    })
+  });
+  await rescheduleCallRecordingBot(client, {
+    callRecording: existingCallRecording,
+    calendarEvent: representativeCalendarEvent
+  });
+  return {
+    action: "UPDATED",
+    realMeetingKey,
+    callRecordingId: existingCallRecording.id
+  };
+};
+var createPolicyManagedCallRecording = async ({
+  client,
+  callRecordingId,
+  representativeCalendarEvent,
+  realMeetingKey
+}) => {
+  const scheduledFields = buildScheduledCallRecordingFields(
+    representativeCalendarEvent
+  );
+  try {
+    await createCallRecording(client, {
+      id: callRecordingId,
+      data: scheduledFields
+    });
+  } catch (error) {
+    const concurrentlyCreatedCallRecording = (await findCallRecordingsByIds(client, [callRecordingId]))[0];
+    if ((0, import_guards18.isUndefined)(concurrentlyCreatedCallRecording)) {
+      throw error;
+    }
+    return updatePolicyManagedCallRecording({
+      client,
+      existingCallRecording: concurrentlyCreatedCallRecording,
+      representativeCalendarEvent,
+      realMeetingKey
+    });
+  }
+  await ensureCallRecorder(client, {
+    callRecording: {
+      id: callRecordingId,
+      ...scheduledFields,
+      title: scheduledFields.title ?? void 0
+    },
+    calendarEvent: representativeCalendarEvent
+  });
+  return {
+    action: "CREATED",
+    realMeetingKey,
+    callRecordingId
+  };
+};
+var findManualOpenCallRecording = async ({
+  client,
+  meetingPolicyResult,
+  removedCalendarEventIds
+}) => {
+  const calendarEventIds = getUniqueSortedIds([
+    ...meetingPolicyResult.calendarEventIds,
+    ...meetingPolicyResult.requestingCalendarEventIds,
+    ...removedCalendarEventIds
+  ]);
+  const callRecordings = await findCallRecordingsByCalendarEventIds(
+    client,
+    calendarEventIds
+  );
+  return [...callRecordings].sort(
+    (firstCallRecording, secondCallRecording) => firstCallRecording.id.localeCompare(secondCallRecording.id)
+  ).find(
+    (callRecording) => callRecording.status !== "COMPLETED" /* COMPLETED */ && (0, import_guards18.isUndefined)(callRecording.recordingRequestStatus)
+  );
+};
+var reconcileCanceledMeeting = async ({
+  client,
+  meetingPolicyResult,
+  removedCalendarEventIds
+}) => {
+  const calendarEventIds = getUniqueSortedIds([
+    ...meetingPolicyResult.calendarEventIds,
+    ...removedCalendarEventIds
+  ]);
+  const cancellableCallRecordings = (await findCallRecordingsByCalendarEventIds(client, calendarEventIds)).filter(
+    (callRecording) => callRecording.status === "SCHEDULED" /* SCHEDULED */ && callRecording.recordingRequestStatus === "REQUESTED" /* REQUESTED */
+  );
+  if (cancellableCallRecordings.length === 0) {
+    return buildSkippedResult(meetingPolicyResult.realMeetingKey);
+  }
+  for (const callRecording of cancellableCallRecordings) {
+    await cancelCallRecordingRequest({
+      client,
+      callRecording
+    });
+  }
+  return {
+    action: "CANCELED",
+    realMeetingKey: meetingPolicyResult.realMeetingKey,
+    callRecordingId: cancellableCallRecordings[0].id
+  };
+};
+var buildCalendarDrivenCallRecordingFields = (calendarEvent) => ({
+  // Wire null clears a stale title when the calendar title is gone or restricted.
+  title: calendarEvent.title ?? null,
+  recordingRequestStatus: "REQUESTED" /* REQUESTED */,
+  calendarEventId: calendarEvent.id
+});
+var buildScheduledCallRecordingFields = (calendarEvent) => ({
+  ...buildCalendarDrivenCallRecordingFields(calendarEvent),
+  status: "SCHEDULED" /* SCHEDULED */
+});
+var buildPolicyManagedCallRecordingUpdateFields = ({
+  existingCallRecording,
+  calendarEvent
+}) => canResetCallRecordingStatusToScheduled(existingCallRecording.status) ? {
+  ...buildScheduledCallRecordingFields(calendarEvent),
+  ...(0, import_guards18.isUndefined)(existingCallRecording.callRecorderFailureReason) ? {} : { callRecorderFailureReason: null }
+} : buildCalendarDrivenCallRecordingFields(calendarEvent);
+var canResetCallRecordingStatusToScheduled = (status) => status === "SCHEDULED" /* SCHEDULED */ || status === "FAILED" /* FAILED */;
+var buildRemovedCalendarEventIdsByMeetingKey = (removedOccurrences) => {
+  const calendarEventIdsByMeetingKey = /* @__PURE__ */ new Map();
+  for (const removedOccurrence of removedOccurrences) {
+    calendarEventIdsByMeetingKey.set(removedOccurrence.realMeetingKey, [
+      ...calendarEventIdsByMeetingKey.get(removedOccurrence.realMeetingKey) ?? [],
+      removedOccurrence.calendarEventId
+    ]);
+  }
+  return calendarEventIdsByMeetingKey;
+};
+var buildSkippedResult = (realMeetingKey) => ({
+  action: "SKIPPED",
+  realMeetingKey,
+  callRecordingId: null
+});
+
+// src/logic-functions/reconcile-call-recorder-calendar-event.ts
+var CALENDAR_EVENT_OBJECT_NAME = "calendarEvent";
+var CALL_RECORDER_RELEVANT_CALENDAR_EVENT_FIELDS = [
+  "title",
+  "callRecorderPreference",
+  "conferenceLink",
+  "startsAt",
+  "endsAt",
+  "isCanceled",
+  "iCalUid"
+];
+var CALL_RECORDER_KEY_CALENDAR_EVENT_FIELDS = [
+  "conferenceLink",
+  "startsAt",
+  "iCalUid"
+];
+var handler = async (event) => {
+  const [objectName, action] = event.name.split(".");
+  if (objectName !== CALENDAR_EVENT_OBJECT_NAME) {
+    return { skipped: true, reason: "not a calendar event" };
+  }
+  const reconciliationPayload = buildCalendarEventReconciliationPayload({
+    event,
+    action
+  });
+  if (reconciliationPayload.calendarEventIds.length === 0 && reconciliationPayload.removedOccurrences.length === 0) {
+    return { skipped: true, reason: "no relevant calendar event change" };
+  }
+  const client = new CoreApiClient();
+  const reconciliationResults = await reconcileCallRecorderForCalendarEventIds({
+    client,
+    calendarEventIds: reconciliationPayload.calendarEventIds,
+    removedOccurrences: reconciliationPayload.removedOccurrences
+  });
+  return {
+    reconciled: true,
+    calendarEventIds: reconciliationPayload.calendarEventIds,
+    removedOccurrenceCount: reconciliationPayload.removedOccurrences.length,
+    reconciliationResults
+  };
+};
+var buildCalendarEventReconciliationPayload = ({
+  event,
+  action
+}) => {
+  if (action === "created") {
+    return {
+      calendarEventIds: getUniqueSortedIds([
+        event.recordId,
+        event.properties.after?.id
+      ]),
+      removedOccurrences: []
+    };
+  }
+  if (action === "updated") {
+    const updatedFields = event.properties.updatedFields ?? [];
+    if (!hasRelevantFieldChange(updatedFields)) {
+      return { calendarEventIds: [], removedOccurrences: [] };
+    }
+    const removedOccurrence = hasKeyFieldChange(updatedFields) ? buildRemovedOccurrence(event.properties.before) : void 0;
+    return {
+      calendarEventIds: getUniqueSortedIds([
+        event.recordId,
+        event.properties.after?.id
+      ]),
+      removedOccurrences: (0, import_guards19.isUndefined)(removedOccurrence) ? [] : [removedOccurrence]
+    };
+  }
+  if (action === "deleted" || action === "destroyed") {
+    const removedOccurrence = buildRemovedOccurrence(event.properties.before);
+    return {
+      calendarEventIds: [],
+      removedOccurrences: (0, import_guards19.isUndefined)(removedOccurrence) ? [] : [removedOccurrence]
+    };
+  }
+  return { calendarEventIds: [], removedOccurrences: [] };
+};
+var hasRelevantFieldChange = (updatedFields) => updatedFields.some(
+  (updatedField) => CALL_RECORDER_RELEVANT_CALENDAR_EVENT_FIELDS.includes(updatedField)
+);
+var hasKeyFieldChange = (updatedFields) => updatedFields.some(
+  (updatedField) => CALL_RECORDER_KEY_CALENDAR_EVENT_FIELDS.includes(updatedField)
+);
+var buildRemovedOccurrence = (calendarEvent) => {
+  if ((0, import_guards19.isUndefined)(calendarEvent)) {
+    return void 0;
+  }
+  return {
+    calendarEventId: calendarEvent.id,
+    realMeetingKey: computeRealMeetingKey({
+      calendarEventId: calendarEvent.id,
+      conferenceLinkUrl: calendarEvent.conferenceLink?.primaryLinkUrl,
+      iCalUid: calendarEvent.iCalUid ?? void 0,
+      startsAt: calendarEvent.startsAt ?? void 0
+    }),
+    startsAt: calendarEvent.startsAt ?? void 0
+  };
+};
+var reconcile_call_recorder_calendar_event_default = defineLogicFunction({
+  universalIdentifier: CALENDAR_EVENT_RECONCILIATION_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+  name: "reconcile-call-recorder-calendar-event",
+  description: "Reconciles app-managed Recall bot recording requests when calendar events change.",
+  timeoutSeconds: 60,
+  handler,
+  databaseEventTriggerSettings: {
+    eventName: `${CALENDAR_EVENT_OBJECT_NAME}.*`
+  }
+});
+export {
+  reconcile_call_recorder_calendar_event_default as default
+};
+//# sourceMappingURL=reconcile-call-recorder-calendar-event.mjs.map