@opengeni/documents 0.2.64 → 0.2.69

package/dist/google-drive.js

@@ -0,0 +1,588 @@
+// src/google-drive.ts
+var GOOGLE_DRIVE_PROVIDER_KEY = "google-drive";
+var GOOGLE_DRIVE_FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+var GOOGLE_DRIVE_SHORTCUT_MIME_TYPE = "application/vnd.google-apps.shortcut";
+var GOOGLE_DRIVE_NATIVE_MIME_PREFIX = "application/vnd.google-apps.";
+var GOOGLE_DRIVE_MAX_ID_CHARS = 256;
+var GOOGLE_DRIVE_MAX_NAME_CHARS = 1024;
+var GOOGLE_DRIVE_MAX_MIME_CHARS = 256;
+var GOOGLE_DRIVE_MAX_PAGE_TOKEN_CHARS = 4096;
+var GOOGLE_DRIVE_MAX_PAGE_ITEMS = 100;
+var GOOGLE_DRIVE_MAX_CHECKPOINT_FOLDERS = 2e3;
+var GOOGLE_DRIVE_MAX_CHECKPOINT_BYTES = 2 * 1024 * 1024;
+var GOOGLE_DRIVE_NATIVE_EXPORTS = /* @__PURE__ */ new Map([
+  [
+    "application/vnd.google-apps.document",
+    {
+      contentType: "application/pdf",
+      extension: ".pdf"
+    }
+  ],
+  [
+    "application/vnd.google-apps.spreadsheet",
+    {
+      contentType: "application/pdf",
+      extension: ".pdf"
+    }
+  ],
+  [
+    "application/vnd.google-apps.presentation",
+    {
+      contentType: "application/pdf",
+      extension: ".pdf"
+    }
+  ],
+  ["application/vnd.google-apps.drawing", { contentType: "application/pdf", extension: ".pdf" }]
+]);
+var DEPENDENCY_FREE_ORDINARY_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "application/json",
+  "application/pdf",
+  "application/xml",
+  "application/x-yaml",
+  "application/yaml"
+]);
+var GENERIC_BINARY_CONTENT_TYPES = /* @__PURE__ */ new Set(["application/octet-stream", "binary/octet-stream"]);
+var DEPENDENCY_FREE_EXTENSION_CONTENT_TYPES = /* @__PURE__ */ new Map([
+  [".csv", "text/csv"],
+  [".htm", "text/html"],
+  [".html", "text/html"],
+  [".json", "application/json"],
+  [".markdown", "text/markdown"],
+  [".md", "text/markdown"],
+  [".pdf", "application/pdf"],
+  [".text", "text/plain"],
+  [".tsv", "text/tab-separated-values"],
+  [".txt", "text/plain"],
+  [".xml", "application/xml"],
+  [".yaml", "application/x-yaml"],
+  [".yml", "application/x-yaml"]
+]);
+var GoogleDriveInventoryProviderError = class extends Error {
+  constructor(providerCode) {
+    super(providerCode);
+    this.providerCode = providerCode;
+    this.name = "GoogleDriveInventoryProviderError";
+  }
+};
+function googleDriveKnowledgeScope(targetScope, workspaceId, initiatingSubjectId) {
+  const boundedWorkspaceId = boundedText(workspaceId, "workspaceId", 256);
+  const boundedSubjectId = boundedText(initiatingSubjectId, "initiatingSubjectId", 1024);
+  if (targetScope === "organization") {
+    return { kind: "organization", workspaceId: null, subjectId: null };
+  }
+  if (targetScope === "workspace") {
+    return { kind: "workspace", workspaceId: boundedWorkspaceId, subjectId: null };
+  }
+  return {
+    kind: "personal",
+    workspaceId: boundedWorkspaceId,
+    subjectId: boundedSubjectId
+  };
+}
+function googleDriveKnowledgeSourceIdentity(input) {
+  const sourceId = driveId(input.source.id, "source.id");
+  const externalTenantId = normalizedGooglePermissionId(input.googlePermissionId);
+  const sourceDriveId = nullableDriveId(input.source.driveId, "source.driveId");
+  return {
+    providerKey: GOOGLE_DRIVE_PROVIDER_KEY,
+    externalTenantId,
+    externalSourceId: sourceId,
+    sourceKind: sourceId === "root" ? "google-drive-my-drive" : sourceDriveId === sourceId ? "google-drive-shared-drive" : "google-drive-folder",
+    sourceUri: googleDriveSourceUri(sourceId),
+    scope: googleDriveKnowledgeScope(
+      input.source.targetScope,
+      input.workspaceId,
+      input.initiatingSubjectId
+    )
+  };
+}
+function planGoogleDriveTransfer(item, maxFileBytes) {
+  const normalized = validatedProviderItem(item);
+  const byteLimit = safePositiveInteger(maxFileBytes, "maxFileBytes");
+  if (normalized.trashed) {
+    return { action: "skip", reason: "trashed" };
+  }
+  if (normalized.mimeType === GOOGLE_DRIVE_FOLDER_MIME_TYPE) {
+    return { action: "traverse" };
+  }
+  if (normalized.mimeType === GOOGLE_DRIVE_SHORTCUT_MIME_TYPE) {
+    return { action: "skip", reason: "shortcut_unsupported" };
+  }
+  const nativeExport = GOOGLE_DRIVE_NATIVE_EXPORTS.get(normalized.mimeType);
+  if (nativeExport) {
+    return {
+      action: "export",
+      contentType: nativeExport.contentType,
+      filename: exportedFilename(normalized.name, nativeExport.extension),
+      declaredBytes: null
+    };
+  }
+  if (normalized.mimeType.startsWith(GOOGLE_DRIVE_NATIVE_MIME_PREFIX)) {
+    return { action: "skip", reason: "unsupported_native_type" };
+  }
+  const declaredBytes = fileSize(normalized.size);
+  if (declaredBytes !== null && declaredBytes > BigInt(byteLimit)) {
+    return { action: "skip", reason: "file_too_large" };
+  }
+  const contentType = dependencyFreeOrdinaryContentType(normalized.name, normalized.mimeType);
+  if (!contentType) {
+    return { action: "skip", reason: "unsupported_file_type" };
+  }
+  return {
+    action: "download",
+    contentType,
+    filename: safeFilename(normalized.name),
+    declaredBytes: declaredBytes?.toString() ?? null
+  };
+}
+async function inventoryGoogleDriveSource(input) {
+  const limits = validatedLimits(input.limits);
+  const googlePermissionId = normalizedGooglePermissionId(input.googlePermissionId);
+  const source = googleDriveKnowledgeSourceIdentity({
+    googlePermissionId,
+    source: input.source,
+    workspaceId: input.workspaceId,
+    initiatingSubjectId: input.initiatingSubjectId
+  });
+  const checkpointIdentity = {
+    googlePermissionId,
+    externalTenantId: source.externalTenantId,
+    sourceId: source.externalSourceId,
+    sourceDriveId: nullableDriveId(input.source.driveId, "source.driveId"),
+    scope: source.scope
+  };
+  const now = input.now ?? Date.now;
+  const startedAt = now();
+  const checkpoint = input.checkpoint ? validatedCheckpoint(input.checkpoint, checkpointIdentity, limits) : initialCheckpoint(checkpointIdentity);
+  const initialTotals = cloneTotals(checkpoint.totals);
+  const entries = [];
+  const issues = [];
+  let stopReason = null;
+  while (checkpoint.pendingFolders.length > 0) {
+    if (now() - startedAt >= limits.maxElapsedMs) {
+      stopReason = "elapsed_time_limit";
+      break;
+    }
+    const frame = checkpoint.pendingFolders[0];
+    if (frame.loaded && frame.bufferedItems.length === 0) {
+      if (frame.nextPageToken) {
+        frame.pageToken = frame.nextPageToken;
+        frame.nextPageToken = null;
+        frame.loaded = false;
+      } else {
+        checkpoint.pendingFolders.shift();
+      }
+      continue;
+    }
+    if (checkpoint.totals.itemCount >= limits.maxItems) {
+      stopReason = "item_limit";
+      break;
+    }
+    if (!frame.loaded) {
+      if (checkpoint.totals.apiRequestCount >= limits.maxApiRequests) {
+        stopReason = "api_request_limit";
+        break;
+      }
+      const remainingItems = limits.maxItems - checkpoint.totals.itemCount;
+      const requestedPageSize = Math.min(limits.pageSize, remainingItems);
+      let page;
+      try {
+        page = await input.listChildren({
+          folderId: frame.folderId,
+          driveId: frame.driveId,
+          pageToken: frame.pageToken,
+          pageSize: requestedPageSize
+        });
+      } catch (error) {
+        checkpoint.totals.apiRequestCount += 1;
+        issues.push({
+          code: "provider_error",
+          folderId: frame.folderId,
+          providerCode: providerErrorCode(error)
+        });
+        stopReason = "provider_error";
+        break;
+      }
+      checkpoint.totals.apiRequestCount += 1;
+      if (!validPage(page, requestedPageSize)) {
+        issues.push({ code: "invalid_page", folderId: frame.folderId, providerCode: null });
+        stopReason = "provider_error";
+        break;
+      }
+      if (page.incompleteSearch) {
+        issues.push({ code: "incomplete_search", folderId: frame.folderId, providerCode: null });
+        stopReason = "incomplete_search";
+        break;
+      }
+      frame.loaded = true;
+      frame.bufferedItems = page.items.map(validatedProviderItem);
+      frame.nextPageToken = page.nextPageToken;
+      if (now() - startedAt >= limits.maxElapsedMs) {
+        stopReason = "elapsed_time_limit";
+        break;
+      }
+    }
+    if (frame.bufferedItems.length === 0) {
+      if (frame.nextPageToken) {
+        frame.pageToken = frame.nextPageToken;
+        frame.nextPageToken = null;
+        frame.loaded = false;
+      } else {
+        checkpoint.pendingFolders.shift();
+      }
+      continue;
+    }
+    const item = validatedProviderItem(frame.bufferedItems[0]);
+    let transfer = planGoogleDriveTransfer(item, limits.maxFileBytes);
+    if (transfer.action === "download" && transfer.declaredBytes !== null) {
+      const nextKnownBytes = BigInt(checkpoint.totals.knownBytes) + BigInt(transfer.declaredBytes);
+      if (nextKnownBytes > BigInt(limits.maxKnownBytes)) {
+        stopReason = "known_byte_limit";
+        break;
+      }
+    }
+    frame.bufferedItems.shift();
+    checkpoint.totals.itemCount += 1;
+    const effectiveDriveId = item.driveId ?? frame.driveId;
+    if (transfer.action === "traverse") {
+      if (checkpoint.seenFolderIds.includes(item.id)) {
+        transfer = { action: "skip", reason: "folder_loop" };
+      } else if (checkpoint.seenFolderIds.length >= limits.maxFolders) {
+        transfer = { action: "skip", reason: "folder_limit" };
+      } else {
+        checkpoint.seenFolderIds.push(item.id);
+        checkpoint.totals.folderCount += 1;
+        checkpoint.pendingFolders.push({
+          folderId: item.id,
+          driveId: effectiveDriveId,
+          pageToken: null,
+          loaded: false,
+          bufferedItems: [],
+          nextPageToken: null
+        });
+      }
+    }
+    if (transfer.action === "skip") {
+      checkpoint.totals.skippedItemCount += 1;
+    } else if (transfer.action === "download") {
+      checkpoint.totals.plannedFileCount += 1;
+      checkpoint.totals.downloadFileCount += 1;
+      if (transfer.declaredBytes === null) {
+        checkpoint.totals.unknownSizeFileCount += 1;
+      } else {
+        checkpoint.totals.knownBytes = (BigInt(checkpoint.totals.knownBytes) + BigInt(transfer.declaredBytes)).toString();
+      }
+    } else if (transfer.action === "export") {
+      checkpoint.totals.plannedFileCount += 1;
+      checkpoint.totals.exportFileCount += 1;
+      checkpoint.totals.unknownSizeFileCount += 1;
+    }
+    entries.push({
+      externalObjectId: item.id,
+      externalVersionId: item.version ?? item.md5Checksum ?? item.modifiedTime,
+      sourceId: source.externalSourceId,
+      parentFolderId: frame.folderId,
+      driveId: effectiveDriveId,
+      title: item.name,
+      mimeType: item.mimeType,
+      modifiedTime: item.modifiedTime,
+      createdTime: item.createdTime,
+      sourceUri: item.webViewLink ?? googleDriveFileUri(item.id),
+      transfer
+    });
+  }
+  const elapsedMs = Math.max(0, now() - startedAt);
+  const complete = checkpoint.pendingFolders.length === 0;
+  const outputCheckpoint = complete ? null : cloneCheckpoint(checkpoint);
+  if (outputCheckpoint) assertCheckpointBytes(outputCheckpoint);
+  return {
+    status: complete ? "complete" : "paused",
+    stopReason: complete ? null : stopReason,
+    source,
+    entries,
+    issues,
+    totals: cloneTotals(checkpoint.totals),
+    run: {
+      ...subtractTotals(checkpoint.totals, initialTotals),
+      elapsedMs
+    },
+    checkpoint: outputCheckpoint
+  };
+}
+function initialCheckpoint(identity) {
+  return {
+    version: 2,
+    googlePermissionId: identity.googlePermissionId,
+    externalTenantId: identity.externalTenantId,
+    sourceId: identity.sourceId,
+    sourceDriveId: identity.sourceDriveId,
+    scope: cloneScope(identity.scope),
+    pendingFolders: [
+      {
+        folderId: identity.sourceId,
+        driveId: identity.sourceDriveId,
+        pageToken: null,
+        loaded: false,
+        bufferedItems: [],
+        nextPageToken: null
+      }
+    ],
+    seenFolderIds: [identity.sourceId],
+    totals: emptyTotals()
+  };
+}
+function validatedCheckpoint(value, identity, limits) {
+  if (!value || typeof value !== "object" || value.version !== 2) {
+    throw new Error("unsupported Google Drive inventory checkpoint");
+  }
+  if (value.googlePermissionId !== identity.googlePermissionId || value.externalTenantId !== identity.externalTenantId || value.sourceId !== identity.sourceId || value.sourceDriveId !== identity.sourceDriveId || !sameScope(value.scope, identity.scope)) {
+    throw new Error("Google Drive inventory checkpoint does not match the selected source");
+  }
+  const checkpoint = cloneCheckpoint(value);
+  if (checkpoint.pendingFolders.length === 0) {
+    throw new Error("Google Drive inventory checkpoint is already complete");
+  }
+  if (checkpoint.pendingFolders.length > GOOGLE_DRIVE_MAX_CHECKPOINT_FOLDERS || checkpoint.seenFolderIds.length > GOOGLE_DRIVE_MAX_CHECKPOINT_FOLDERS || checkpoint.seenFolderIds.length > limits.maxFolders) {
+    throw new Error("Google Drive inventory checkpoint exceeds the folder limit");
+  }
+  if (!checkpoint.seenFolderIds.includes(identity.sourceId)) {
+    throw new Error("Google Drive inventory checkpoint lost its source boundary");
+  }
+  if (new Set(checkpoint.seenFolderIds).size !== checkpoint.seenFolderIds.length) {
+    throw new Error("Google Drive inventory checkpoint contains duplicate folder identity");
+  }
+  for (const folderId of checkpoint.seenFolderIds) driveId(folderId, "checkpoint.folderId");
+  const pendingFolderIds = /* @__PURE__ */ new Set();
+  for (const frame of checkpoint.pendingFolders) {
+    driveId(frame.folderId, "checkpoint.pending.folderId");
+    if (!checkpoint.seenFolderIds.includes(frame.folderId) || pendingFolderIds.has(frame.folderId)) {
+      throw new Error("Google Drive inventory checkpoint contains an invalid pending folder");
+    }
+    pendingFolderIds.add(frame.folderId);
+    nullableDriveId(frame.driveId, "checkpoint.pending.driveId");
+    pageToken(frame.pageToken, "checkpoint.pending.pageToken");
+    pageToken(frame.nextPageToken, "checkpoint.pending.nextPageToken");
+    if (typeof frame.loaded !== "boolean" || frame.bufferedItems.length > GOOGLE_DRIVE_MAX_PAGE_ITEMS) {
+      throw new Error("Google Drive inventory checkpoint contains an invalid page frame");
+    }
+    if (!frame.loaded && (frame.bufferedItems.length > 0 || frame.nextPageToken !== null)) {
+      throw new Error("Google Drive inventory checkpoint contains an uncommitted page frame");
+    }
+    frame.bufferedItems = frame.bufferedItems.map(validatedProviderItem);
+  }
+  validatedTotals(checkpoint.totals);
+  if (checkpoint.totals.folderCount !== checkpoint.seenFolderIds.length || checkpoint.totals.plannedFileCount !== checkpoint.totals.exportFileCount + checkpoint.totals.downloadFileCount || checkpoint.totals.unknownSizeFileCount > checkpoint.totals.plannedFileCount || checkpoint.totals.itemCount !== checkpoint.totals.skippedItemCount + checkpoint.totals.plannedFileCount + checkpoint.totals.folderCount - 1) {
+    throw new Error("Google Drive inventory checkpoint totals are inconsistent");
+  }
+  if (checkpoint.totals.itemCount > limits.maxItems || checkpoint.totals.apiRequestCount > limits.maxApiRequests || BigInt(checkpoint.totals.knownBytes) > BigInt(limits.maxKnownBytes)) {
+    throw new Error("Google Drive inventory checkpoint exceeds the supplied limits");
+  }
+  assertCheckpointBytes(checkpoint);
+  return checkpoint;
+}
+function validatedLimits(value) {
+  const limits = {
+    maxItems: safePositiveInteger(value.maxItems, "limits.maxItems"),
+    maxKnownBytes: safePositiveInteger(value.maxKnownBytes, "limits.maxKnownBytes"),
+    maxApiRequests: safePositiveInteger(value.maxApiRequests, "limits.maxApiRequests"),
+    maxElapsedMs: safePositiveInteger(value.maxElapsedMs, "limits.maxElapsedMs"),
+    maxFileBytes: safePositiveInteger(value.maxFileBytes, "limits.maxFileBytes"),
+    maxFolders: safePositiveInteger(value.maxFolders, "limits.maxFolders"),
+    pageSize: safePositiveInteger(value.pageSize, "limits.pageSize")
+  };
+  if (limits.pageSize > GOOGLE_DRIVE_MAX_PAGE_ITEMS) {
+    throw new Error(`limits.pageSize must be <= ${GOOGLE_DRIVE_MAX_PAGE_ITEMS}`);
+  }
+  if (limits.maxFolders > GOOGLE_DRIVE_MAX_CHECKPOINT_FOLDERS) {
+    throw new Error(`limits.maxFolders must be <= ${GOOGLE_DRIVE_MAX_CHECKPOINT_FOLDERS}`);
+  }
+  return limits;
+}
+function validPage(value, expectedMaxItems) {
+  if (!value || !Array.isArray(value.items) || value.items.length > expectedMaxItems || value.items.length > GOOGLE_DRIVE_MAX_PAGE_ITEMS) {
+    return false;
+  }
+  try {
+    pageToken(value.nextPageToken, "page.nextPageToken");
+    value.items.forEach(validatedProviderItem);
+    return typeof value.incompleteSearch === "boolean";
+  } catch {
+    return false;
+  }
+}
+function validatedProviderItem(item) {
+  const id = driveId(item.id, "item.id");
+  const name = boundedText(item.name, "item.name", GOOGLE_DRIVE_MAX_NAME_CHARS);
+  const mimeType = boundedText(item.mimeType, "item.mimeType", GOOGLE_DRIVE_MAX_MIME_CHARS);
+  const parents = Array.isArray(item.parents) ? item.parents.map((parent) => driveId(parent, "item.parent")) : [];
+  if (parents.length > 100) throw new Error("item.parents exceeds the supported bound");
+  return {
+    id,
+    name,
+    mimeType,
+    driveId: nullableDriveId(item.driveId, "item.driveId"),
+    parents,
+    modifiedTime: nullableBoundedText(item.modifiedTime, "item.modifiedTime", 128),
+    createdTime: nullableBoundedText(item.createdTime, "item.createdTime", 128),
+    version: nullableBoundedText(item.version, "item.version", 256),
+    md5Checksum: nullableBoundedText(item.md5Checksum, "item.md5Checksum", 128),
+    size: fileSize(item.size)?.toString() ?? null,
+    webViewLink: nullableHttpsUrl(item.webViewLink, "item.webViewLink"),
+    trashed: item.trashed === true
+  };
+}
+function dependencyFreeOrdinaryContentType(name, mimeType) {
+  const normalizedMime = mimeType.trim().toLowerCase();
+  if (normalizedMime.startsWith("text/")) return normalizedMime;
+  if (DEPENDENCY_FREE_ORDINARY_CONTENT_TYPES.has(normalizedMime)) return normalizedMime;
+  if (!GENERIC_BINARY_CONTENT_TYPES.has(normalizedMime)) return null;
+  const lowerName = name.toLowerCase();
+  for (const [extension, contentType] of DEPENDENCY_FREE_EXTENSION_CONTENT_TYPES) {
+    if (lowerName.endsWith(extension)) return contentType;
+  }
+  return null;
+}
+function exportedFilename(name, extension) {
+  const filename = safeFilename(name);
+  return filename.toLowerCase().endsWith(extension) ? filename : `${filename}${extension}`;
+}
+function safeFilename(value) {
+  const cleaned = value.normalize("NFKC").replace(/[\u0000-\u001f\u007f/\\]/gu, " ").replace(/\s+/gu, " ").trim().slice(0, 512);
+  return cleaned || "untitled";
+}
+function googleDriveSourceUri(id) {
+  return id === "root" ? "https://drive.google.com/drive/my-drive" : `https://drive.google.com/drive/folders/${encodeURIComponent(id)}`;
+}
+function googleDriveFileUri(id) {
+  return `https://drive.google.com/open?id=${encodeURIComponent(id)}`;
+}
+function fileSize(value) {
+  if (value === null) return null;
+  if (!/^\d{1,40}$/u.test(value)) throw new Error("item.size is invalid");
+  return BigInt(value);
+}
+function providerErrorCode(error) {
+  if (!(error instanceof GoogleDriveInventoryProviderError)) return null;
+  const normalized = error.providerCode.trim().toLowerCase();
+  return /^[a-z0-9](?:[a-z0-9._-]{0,126}[a-z0-9])?$/u.test(normalized) ? normalized : null;
+}
+function driveId(value, label) {
+  const candidate = boundedText(value, label, GOOGLE_DRIVE_MAX_ID_CHARS);
+  if (candidate === "root" || /^[A-Za-z0-9_-]+$/u.test(candidate)) return candidate;
+  throw new Error(`${label} is invalid`);
+}
+function normalizedGooglePermissionId(value) {
+  return boundedText(value, "googlePermissionId", GOOGLE_DRIVE_MAX_ID_CHARS);
+}
+function nullableDriveId(value, label) {
+  return value === null ? null : driveId(value, label);
+}
+function pageToken(value, label) {
+  if (value === null) return null;
+  return boundedText(value, label, GOOGLE_DRIVE_MAX_PAGE_TOKEN_CHARS);
+}
+function boundedText(value, label, maxChars) {
+  if (typeof value !== "string") throw new Error(`${label} must be a string`);
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > maxChars || /[\u0000-\u001f\u007f]/u.test(trimmed)) {
+    throw new Error(`${label} is invalid`);
+  }
+  return trimmed;
+}
+function nullableBoundedText(value, label, maxChars) {
+  return value === null ? null : boundedText(value, label, maxChars);
+}
+function nullableHttpsUrl(value, label) {
+  if (value === null) return null;
+  const bounded = boundedText(value, label, 4096);
+  const parsed = new URL(bounded);
+  if (parsed.protocol !== "https:") throw new Error(`${label} must use https`);
+  return parsed.toString();
+}
+function safePositiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${label} must be a positive safe integer`);
+  }
+  return value;
+}
+function validatedTotals(totals) {
+  for (const [key, value] of Object.entries(totals)) {
+    if (key === "knownBytes") continue;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+      throw new Error(`checkpoint.totals.${key} is invalid`);
+    }
+  }
+  if (!/^\d+$/u.test(totals.knownBytes)) {
+    throw new Error("checkpoint.totals.knownBytes is invalid");
+  }
+}
+function emptyTotals() {
+  return {
+    itemCount: 0,
+    folderCount: 1,
+    plannedFileCount: 0,
+    skippedItemCount: 0,
+    exportFileCount: 0,
+    downloadFileCount: 0,
+    unknownSizeFileCount: 0,
+    apiRequestCount: 0,
+    knownBytes: "0"
+  };
+}
+function cloneTotals(value) {
+  return { ...value };
+}
+function subtractTotals(value, initial) {
+  return {
+    itemCount: value.itemCount - initial.itemCount,
+    folderCount: value.folderCount - initial.folderCount,
+    plannedFileCount: value.plannedFileCount - initial.plannedFileCount,
+    skippedItemCount: value.skippedItemCount - initial.skippedItemCount,
+    exportFileCount: value.exportFileCount - initial.exportFileCount,
+    downloadFileCount: value.downloadFileCount - initial.downloadFileCount,
+    unknownSizeFileCount: value.unknownSizeFileCount - initial.unknownSizeFileCount,
+    apiRequestCount: value.apiRequestCount - initial.apiRequestCount,
+    knownBytes: (BigInt(value.knownBytes) - BigInt(initial.knownBytes)).toString()
+  };
+}
+function cloneProviderItem(value) {
+  return { ...value, parents: [...value.parents] };
+}
+function cloneScope(scope) {
+  return { ...scope };
+}
+function cloneCheckpoint(value) {
+  return {
+    version: 2,
+    googlePermissionId: value.googlePermissionId,
+    externalTenantId: value.externalTenantId,
+    sourceId: value.sourceId,
+    sourceDriveId: value.sourceDriveId,
+    scope: cloneScope(value.scope),
+    pendingFolders: value.pendingFolders.map((frame) => ({
+      ...frame,
+      bufferedItems: frame.bufferedItems.map(cloneProviderItem)
+    })),
+    seenFolderIds: [...value.seenFolderIds],
+    totals: cloneTotals(value.totals)
+  };
+}
+function sameScope(left, right) {
+  return !!left && typeof left === "object" && left.kind === right.kind && left.workspaceId === right.workspaceId && left.subjectId === right.subjectId;
+}
+function assertCheckpointBytes(checkpoint) {
+  if (Buffer.byteLength(JSON.stringify(checkpoint), "utf8") > GOOGLE_DRIVE_MAX_CHECKPOINT_BYTES) {
+    throw new Error("Google Drive inventory checkpoint exceeds the serialized byte limit");
+  }
+}
+export {
+  GOOGLE_DRIVE_FOLDER_MIME_TYPE,
+  GOOGLE_DRIVE_PROVIDER_KEY,
+  GOOGLE_DRIVE_SHORTCUT_MIME_TYPE,
+  GoogleDriveInventoryProviderError,
+  googleDriveKnowledgeScope,
+  googleDriveKnowledgeSourceIdentity,
+  inventoryGoogleDriveSource,
+  planGoogleDriveTransfer
+};
+//# sourceMappingURL=google-drive.js.map