nolo-cli 0.148.0-alpha.1 → 0.151.0-alpha.2

package/{localRuntimeAuthority-5W6IJRAD.js → chunk-2IXDJNZI.js}

@@ -2,7 +2,7 @@ import {
   resolveCliAuthorityBrokerEndpoint,
   resolveCliAuthorityBrokerHealthPath,
   resolveCliAuthorityBrokerMetadataPath
-} from "./chunk-BFU6C242.js";
+} from "./chunk-NMFV26UG.js";
 import {
   createCliAuthorityBrokerClient,
   createCliAuthorityBrokerSocketInvoker,
@@ -10,19 +10,15 @@ import {
 } from "./chunk-EXAJ6DCR.js";
 import {
   createLegacyServerDb,
-  createLevelAuthorityStore
-} from "./chunk-CIF4X6ZM.js";
-import {
+  createLevelAuthorityStore,
   isLevelLockError
-} from "./chunk-URMS4XY2.js";
-import "./chunk-UV6VISQJ.js";
-import {
-  resolveNoloHome
-} from "./chunk-GLKOYSRU.js";
+} from "./chunk-AWVFQMOV.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
-import "./chunk-4VNS5WPM.js";
+import {
+  resolveNoloHome
+} from "./chunk-GLKOYSRU.js";
 
 // packages/cli/localRuntimeAuthority.ts
 import fs2 from "node:fs";
@@ -33,6 +29,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { createServer } from "node:net";
 var brokerRegistry = /* @__PURE__ */ new Map();
+var databaseOwners = /* @__PURE__ */ new Map();
 var DEFAULT_ITERATOR_LIMIT = 200;
 function resolveBrokerListenTarget(endpoint) {
   if (endpoint.startsWith("unix://")) {
@@ -118,7 +115,6 @@ async function dispatchCliAuthorityBrokerRequest(store, request) {
         await store.open();
         return { ok: true, result: { type: "open" } };
       case "close":
-        await store.close();
         return { ok: true, result: { type: "close" } };
       case "get":
         return { ok: true, result: { type: "get", value: await store.get(request.key) } };
@@ -146,77 +142,100 @@ async function dispatchCliAuthorityBrokerRequest(store, request) {
 }
 async function createBrokerHandle(options) {
   const target = resolveBrokerListenTarget(options.endpoint);
-  if (target.kind === "unix") {
-    ensureParentDir(target.path);
-    removeFileIfPresent(target.path);
-  }
-  const store = await options.createStore();
-  await store.open();
+  const socketMode = (options.transportMode ?? "socket") === "socket";
+  let store;
+  const sockets = /* @__PURE__ */ new Set();
   const server = createServer((socket) => {
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
+    socket.on("error", () => {
+    });
+    if (!storeReady || !store) {
+      socket.once("data", () => {
+        socket.end(`${JSON.stringify({ ok: false, error: { code: "BROKER_UNAVAILABLE", message: "CLI authority broker is starting", retryable: true } })}
+`);
+      });
+      return;
+    }
     bindSocketRequestHandler({ socket, store });
   });
-  if ((options.transportMode ?? "socket") === "socket") {
-    try {
+  let storeReady = false;
+  try {
+    if (socketMode) {
+      if (target.kind === "unix") ensureParentDir(target.path);
       await new Promise((resolve, reject) => {
         server.once("error", reject);
-        if (target.kind === "unix") {
-          server.listen(target.path, () => {
-            server.off("error", reject);
-            resolve();
-          });
-          return;
-        }
-        server.listen(target.port, target.host, () => {
+        const onListening = () => {
           server.off("error", reject);
           resolve();
-        });
+        };
+        if (target.kind === "unix") server.listen(target.path, onListening);
+        else server.listen(target.port, target.host, onListening);
       });
       server.unref();
-    } catch (error) {
-      await store.close().catch(() => {
-      });
-      throw error;
     }
-  }
-  const now = options.now ?? Date.now;
-  const listeningEndpoint = (options.transportMode ?? "socket") === "socket" ? buildListeningEndpoint(server, target) : options.endpoint;
-  writeJsonFile(options.metadataPath, {
-    pid: process.pid,
-    endpoint: listeningEndpoint,
-    location: store.location ?? listeningEndpoint,
-    startedAt: new Date(now()).toISOString()
-  });
-  writeJsonFile(options.healthPath, {
-    ok: true,
-    pid: process.pid,
-    endpoint: listeningEndpoint,
-    checkedAt: new Date(now()).toISOString()
-  });
-  let closed = false;
-  return {
-    endpoint: options.endpoint,
-    listeningEndpoint,
-    authorityStore: store,
-    request(request) {
-      return dispatchCliAuthorityBrokerRequest(store, request);
-    },
-    async close() {
-      if (closed) return;
-      closed = true;
-      brokerRegistry.delete(options.endpoint);
-      if ((options.transportMode ?? "socket") === "socket") {
-        await new Promise((resolve, reject) => {
-          server.close((error) => error ? reject(error) : resolve());
+    store = await options.createStore();
+    await store.open();
+    storeReady = true;
+    const readyStore = store;
+    const now = options.now ?? Date.now;
+    const listeningEndpoint = (options.transportMode ?? "socket") === "socket" ? buildListeningEndpoint(server, target) : options.endpoint;
+    writeJsonFile(options.metadataPath, {
+      pid: process.pid,
+      endpoint: listeningEndpoint,
+      location: readyStore.location ?? listeningEndpoint,
+      startedAt: new Date(now()).toISOString()
+    });
+    writeJsonFile(options.healthPath, {
+      ok: true,
+      pid: process.pid,
+      endpoint: listeningEndpoint,
+      checkedAt: new Date(now()).toISOString()
+    });
+    let closing;
+    return {
+      endpoint: options.endpoint,
+      listeningEndpoint,
+      authorityStore: readyStore,
+      request(request) {
+        return dispatchCliAuthorityBrokerRequest(readyStore, request);
+      },
+      async close() {
+        closing ??= (async () => {
+          storeReady = false;
+          for (const socket of sockets) socket.destroy();
+          if (server.listening) {
+            await new Promise((resolve, reject) => {
+              server.close((error) => error ? reject(error) : resolve());
+            });
+          }
+          await readyStore.close();
+          brokerRegistry.delete(options.endpoint);
+          releaseDatabaseOwnership(options);
+          removeFileIfPresent(options.metadataPath);
+          removeFileIfPresent(options.healthPath);
+        })().catch((error) => {
+          closing = void 0;
+          throw error;
         });
+        return closing;
       }
-      await store.close();
-      if (target.kind === "unix") {
-        removeFileIfPresent(target.path);
+    };
+  } catch (error) {
+    storeReady = false;
+    for (const socket of sockets) socket.destroy();
+    if (server.listening) {
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+    if (store) {
+      try {
+        await store.close();
+      } catch (closeError) {
+        throw Object.assign(new AggregateError([error, closeError], "Broker startup failed and the native authority store could not close"), { retainAuthorityOwnership: true });
       }
-      removeFileIfPresent(options.metadataPath);
-      removeFileIfPresent(options.healthPath);
     }
-  };
+    throw error;
+  }
 }
 function bindSocketRequestHandler(args) {
   let buffer = "";
@@ -239,10 +258,41 @@ function bindSocketRequestHandler(args) {
 `);
   });
 }
+function canonicalDatabasePath(dbPath) {
+  const absolute = path.resolve(dbPath);
+  try {
+    return fs.realpathSync(absolute);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    const parent = path.dirname(absolute);
+    if (parent === absolute) throw error;
+    return path.join(canonicalDatabasePath(parent), path.basename(absolute));
+  }
+}
+function releaseDatabaseOwnership(options) {
+  if (!options.dbPath) return;
+  const identity = options.dbPath;
+  if (databaseOwners.get(identity) === options.endpoint) databaseOwners.delete(identity);
+}
 function getOrCreateCliAuthorityBrokerServer(options) {
+  options = { ...options, dbPath: options.dbPath ? canonicalDatabasePath(options.dbPath) : void 0 };
   const existing = brokerRegistry.get(options.endpoint);
-  if (existing) return existing;
+  if (existing) {
+    if (options.dbPath && databaseOwners.get(options.dbPath) !== options.endpoint) {
+      return Promise.reject(new Error(`CLI authority endpoint ${options.endpoint} already owns another database`));
+    }
+    return existing;
+  }
+  if (options.dbPath) {
+    const identity = canonicalDatabasePath(options.dbPath);
+    const owner = databaseOwners.get(identity);
+    if (owner) {
+      return Promise.reject(Object.assign(new Error(`CLI authority database already owned by ${owner}`), { code: "LEVEL_LOCKED" }));
+    }
+    databaseOwners.set(identity, options.endpoint);
+  }
   const pending = createBrokerHandle(options).catch((error) => {
+    if (!error?.retainAuthorityOwnership) releaseDatabaseOwnership(options);
     brokerRegistry.delete(options.endpoint);
     throw error;
   });
@@ -254,10 +304,33 @@ function getOrCreateCliAuthorityBrokerServer(options) {
 function ensureDbParentDir(dbPath) {
   fs2.mkdirSync(path2.dirname(dbPath), { recursive: true });
 }
+function findCliAuthorityCorruption(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    if (current.code === "LEVEL_CORRUPTION" || /Corruption:|missing files/i.test(toErrorMessage(current))) return current;
+    current = current.cause;
+  }
+  return void 0;
+}
+function throwCliAuthorityStartupError(error) {
+  const corruption = findCliAuthorityCorruption(error);
+  if (corruption) {
+    throw new Error(`Local authority database corruption: ${toErrorMessage(corruption)}`, { cause: error });
+  }
+  throw error;
+}
 function isCliAuthorityLockError(error) {
-  if (isLevelLockError(error)) return true;
-  const message = toErrorMessage(error);
-  return /Database failed to open|EADDRINUSE|Failed to listen/i.test(message);
+  if (findCliAuthorityCorruption(error)) return false;
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    if (isLevelLockError(current)) return true;
+    current = current.cause;
+  }
+  return /EADDRINUSE|Failed to listen/i.test(toErrorMessage(error));
 }
 async function sleep(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
@@ -313,12 +386,13 @@ async function connectCliAuthorityBroker(args) {
         endpoint: args.endpoint,
         metadataPath: args.metadataPath,
         healthPath: args.healthPath,
+        dbPath: args.dbPath,
         createStore: () => createLevelAuthorityStore(args.dbPath)
       });
       await client2.open();
       return client2;
     } catch (error) {
-      if (!isCliAuthorityLockError(error)) throw error;
+      if (!isCliAuthorityLockError(error)) throwCliAuthorityStartupError(error);
       if (await attachToExistingBroker(5)) {
         return client2;
       }
@@ -330,6 +404,7 @@ async function connectCliAuthorityBroker(args) {
             endpoint: args.endpoint,
             metadataPath: args.metadataPath,
             healthPath: args.healthPath,
+            dbPath: args.dbPath,
             createStore: () => createLevelAuthorityStore(args.dbPath)
           });
           await client2.open();
@@ -345,10 +420,13 @@ async function connectCliAuthorityBroker(args) {
           if (isCliAuthorityBrokerUnavailableError(retryError)) {
             continue;
           }
-          throw retryError;
+          throwCliAuthorityStartupError(retryError);
         }
       }
-      throw new Error(`CLI authority broker could not attach or take ownership for ${args.endpoint}`, {
+      const lastMessage = toErrorMessage(lastError);
+      const portInUse = lastError !== null && typeof lastError === "object" && "code" in lastError && lastError.code === "EADDRINUSE" || /EADDRINUSE/i.test(lastMessage);
+      const detail = portInUse ? `: EADDRINUSE (${lastMessage}). The broker endpoint is already in use; check the process using it or set NOLO_CLI_AUTHORITY_BROKER_PORT to a free port for all local CLI processes` : "";
+      throw new Error(`CLI authority broker could not attach or take ownership for ${args.endpoint}${detail}`, {
         cause: lastError
       });
     }
@@ -481,6 +559,7 @@ async function getDefaultCliLocalRuntimeDb(options = {}) {
   const authorityStore = await getDefaultCliLocalRuntimeAuthority(options);
   return createLegacyServerDb(authorityStore);
 }
+
 export {
   connectCliAuthorityBroker,
   getDefaultCliLocalRuntimeAuthority,

package/{chunk-IVZJWTDI.js → chunk-36OMEXXR.js}

@@ -1,15 +1,34 @@
+import {
+  _appendRetiredStateBatch,
+  loadMemoryVNextCatalog
+} from "./chunk-TY3TIUJK.js";
 import {
   resolveMachineId
-} from "./chunk-ESHYE7WU.js";
+} from "./chunk-S73EPYNC.js";
+import {
+  createMemoryKey,
+  createMemoryOwnerIndexKey,
+  createMemorySubjectKindIndexKey,
+  memoryOwnerRange
+} from "./chunk-5EMSBTQ6.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
 import {
   getDefaultCliLocalRuntimeDb
-} from "./chunk-ZOVKKMF6.js";
+} from "./chunk-FY4SDK2E.js";
 import {
   resolveAuthTokenFromEnv
 } from "./chunk-A7GB5UGH.js";
 import {
   DEFAULT_NOLO_SERVER_URL
 } from "./chunk-OLZBQWZU.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
 import {
   buildCliRuntimeEnv,
   clearProfileAuthToken,
@@ -19,19 +38,6 @@ import {
   loadProfileConfig,
   saveDefaultProfile
 } from "./chunk-TNIX77YM.js";
-import {
-  asTrimmedNonEmptyStringArray,
-  createMemoryKey,
-  createMemoryOwnerIndexKey,
-  createMemorySubjectKindIndexKey,
-  memoryOwnerRange
-} from "./chunk-3AH7LNUB.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
-import {
-  normalizeServerOrigin
-} from "./chunk-CF7PE763.js";
 
 // packages/cli/authCommands.ts
 import { createInterface } from "node:readline/promises";
@@ -39,6 +45,29 @@ import { stdin as input, stdout as output } from "node:process";
 import { spawn } from "node:child_process";
 
 // packages/ai/memory/delete.ts
+var VNEXT_STATE_ID_PREFIX = "vnext-state-";
+var toVNextMemoryItem = (state, owner) => ({
+  id: `${VNEXT_STATE_ID_PREFIX}${state.id}`,
+  ownerType: owner.ownerType,
+  ownerId: owner.ownerId,
+  visibility: "private",
+  subjectType: "user",
+  subjectId: owner.ownerId,
+  kind: "semantic",
+  content: state.text.trim(),
+  createdAt: state.createdAt,
+  lastActivatedAt: state.createdAt,
+  activationCount: 1,
+  importance: 0.9,
+  confidence: 0.9,
+  resident: state.facet === "preference" || state.facet === "style"
+});
+var matchesVNextFilters = (state, idSet, contentSub) => {
+  if (!idSet && !contentSub) return false;
+  if (idSet && !idSet.has(`${VNEXT_STATE_ID_PREFIX}${state.id}`)) return false;
+  if (contentSub && !state.text.toLowerCase().includes(contentSub)) return false;
+  return true;
+};
 function hasExplicitDeleteFilters(filters) {
   return Boolean(
     filters.ids && filters.ids.length > 0 || typeof filters.contentSubstring === "string" && filters.contentSubstring.trim().length > 0 || filters.tags && filters.tags.length > 0 || typeof filters.sourceDialogId === "string" && filters.sourceDialogId.trim().length > 0 || typeof filters.patternKeyPrefix === "string" && filters.patternKeyPrefix.trim().length > 0 || filters.facets && filters.facets.length > 0 || typeof filters.subjectId === "string" && filters.subjectId.trim().length > 0
@@ -127,8 +156,32 @@ var deleteMemoriesForOwnerFromDb = async (db, owner, filters = {}) => {
     matchedItems.push(item);
     if (matchedItems.length >= limit) break;
   }
+  const idSet = normalizeSet(filters.ids);
+  const contentSub = asTrimmedString(filters.contentSubstring).toLowerCase();
+  const vnextStateIdsToRetire = [];
+  const vnextStatesToRetire = [];
+  const vnextMatchedItems = [];
+  let vnextPrincipalId = null;
+  const hasScopingFilters = Boolean(
+    normalizeSet(filters.kinds) || normalizeSet(filters.facets) || normalizeSet(filters.tags) || asTrimmedString(filters.subjectType) || asTrimmedString(filters.subjectId) || asTrimmedString(filters.patternKeyPrefix) || asTrimmedString(filters.sourceDialogId)
+  );
+  const canMatchVNext = !hasScopingFilters && (contentSub.length > 0 || idSet !== null && [...idSet].some((id) => id.startsWith(VNEXT_STATE_ID_PREFIX)));
+  if (canMatchVNext) {
+    vnextPrincipalId = `${owner.ownerType}:${encodeURIComponent(owner.ownerId)}`;
+    const catalog = await loadMemoryVNextCatalog(db, vnextPrincipalId);
+    for (const state of catalog.states) {
+      if (matchedItems.length >= limit) break;
+      if (state.retiredAt) continue;
+      if (!matchesVNextFilters(state, idSet, contentSub)) continue;
+      vnextStateIdsToRetire.push(state.id);
+      vnextStatesToRetire.push(state);
+      const projected = toVNextMemoryItem(state, owner);
+      vnextMatchedItems.push(projected);
+      matchedItems.push(projected);
+    }
+  }
   if (matchedItems.length === 0) {
-    return { deletedCount: 0, deletedIds: [], matchedItems: [] };
+    return { deletedCount: 0, deletedIds: [], retiredIds: [], matchedItems: [] };
   }
   const token = generateMemoryDeletionToken(
     owner.ownerId,
@@ -138,23 +191,38 @@ var deleteMemoriesForOwnerFromDb = async (db, owner, filters = {}) => {
     return {
       deletedCount: 0,
       deletedIds: [],
+      retiredIds: [],
       matchedItems,
       deletionToken: token
     };
   }
   if (filters.deletionToken && filters.deletionToken !== token) {
     throw new Error(
-      "deletionToken mismatch: memory dataset changed since preview; please rerun dry-run preview before confirming."
+      "deletionToken mismatch: target set differs from preview; preview exact intended targets again."
     );
   }
-  const batch = db.batch();
-  for (const item of matchedItems) {
-    deleteMemoryItemWithIndexesInBatch(batch, item);
+  const vnextMatchedIdSet = new Set(
+    vnextStateIdsToRetire.map((stateId) => `${VNEXT_STATE_ID_PREFIX}${stateId}`)
+  );
+  const legacyItems = matchedItems.filter((item) => !vnextMatchedIdSet.has(item.id));
+  const shouldRetireVNext = vnextStatesToRetire.length > 0;
+  if (legacyItems.length > 0 || shouldRetireVNext) {
+    const batch = db.batch();
+    for (const item of legacyItems) {
+      deleteMemoryItemWithIndexesInBatch(batch, item);
+    }
+    if (shouldRetireVNext) {
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      for (const state of vnextStatesToRetire) {
+        _appendRetiredStateBatch(batch, { ...state, retiredAt: nowIso });
+      }
+    }
+    await batch.write();
   }
-  await batch.write();
   return {
     deletedCount: matchedItems.length,
     deletedIds: matchedItems.map((item) => item.id),
+    retiredIds: vnextMatchedItems.map((item) => item.id),
     matchedItems,
     deletionToken: token
   };

package/{chunk-H6A6X4EK.js → chunk-3MZAGMYY.js}

@@ -78,6 +78,20 @@ function clampCooldownDeadline(at, now) {
   const max = now + MAX_COOLDOWN_MS;
   return Math.min(Math.max(at, min), max);
 }
+function shouldClearCooldownFromQuota(entry, quota, now) {
+  if (!(typeof entry.nextAvailableAt === "number" && entry.nextAvailableAt > now)) return false;
+  if (typeof entry.markedAt !== "number" || !Number.isFinite(entry.markedAt)) return false;
+  if (!quota || !(quota.observedAt > entry.markedAt)) return false;
+  const subscriptionWindows = quota.windows.filter((window) => window.scope === "5h" || window.scope === "7d");
+  if (subscriptionWindows.length === 0) return false;
+  if (quota.windows.some((window) => window.scope !== "5h" && window.scope !== "7d" && (window.remaining === 0 || typeof window.utilization === "number" && window.utilization >= 0.95))) return false;
+  return subscriptionWindows.every((window) => {
+    const hasUtilization = typeof window.utilization === "number";
+    const hasRemaining = typeof window.remaining === "number";
+    if (!hasUtilization && !hasRemaining) return false;
+    return (!hasUtilization || window.utilization < 0.95) && (!hasRemaining || window.remaining > 0);
+  });
+}
 function isAgentUnavailableNow(agent, now = Date.now()) {
   const at = agent?.nextAvailableAt;
   return typeof at === "number" && Number.isFinite(at) && at > now;
@@ -214,10 +228,12 @@ function resolveCredentialKeyWithFallback(agent) {
 export {
   QUOTA_ERROR_PATTERNS,
   isQuotaExhaustedError,
+  shouldClearCooldownFromQuota,
   isAgentUnavailableNow,
   isQuotaLimited403Body,
   resolveAvailabilityAction,
   mergeAvailabilityDeadline,
+  PROBE_INTERVAL_MS,
   resolveCooldownGate,
   resolveCredentialKeyWithFallback
 };

package/chunk-3PVYUPXK.js

@@ -0,0 +1,40 @@
+// packages/app/utils/fileUtils.ts
+var fileConstructor = typeof globalThis !== "undefined" && typeof globalThis.File === "function" ? globalThis.File : void 0;
+var isImageMimeType = (value) => typeof value === "string" && value.toLowerCase().startsWith("image/");
+var IMAGE_FILE_NAME_RE = /\.(avif|bmp|gif|heic|heif|ico|jpe?g|png|svg|tiff?|webp)$/i;
+var VIDEO_FILE_NAME_RE = /\.(avi|m4v|mkv|mov|mp4|mpeg|mpg|webm)$/i;
+var AUDIO_FILE_NAME_RE = /\.(aac|flac|m4a|mp3|ogg|wav|weba)$/i;
+var DOCUMENT_FILE_NAME_RE = /\.(csv|doc|docx|md|odt|pdf|ppt|pptx|rtf|txt|xls|xlsx)$/i;
+var isImageFileName = (value) => typeof value === "string" && IMAGE_FILE_NAME_RE.test(value.trim());
+var isVideoMimeType = (value) => typeof value === "string" && value.toLowerCase().startsWith("video/");
+var isAudioMimeType = (value) => typeof value === "string" && value.toLowerCase().startsWith("audio/");
+var isPdfMimeType = (value) => typeof value === "string" && value.toLowerCase() === "application/pdf";
+var isDocumentMimeType = (value) => {
+  if (typeof value !== "string") return false;
+  const normalized = value.toLowerCase();
+  return isPdfMimeType(normalized) || normalized === "text/plain" || normalized === "text/markdown" || normalized === "text/csv" || normalized === "application/msword" || normalized === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || normalized === "application/vnd.ms-powerpoint" || normalized === "application/vnd.openxmlformats-officedocument.presentationml.presentation" || normalized === "application/vnd.ms-excel" || normalized === "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" || normalized === "application/rtf" || normalized === "application/vnd.oasis.opendocument.text";
+};
+var resolveFileCategory = ({
+  mimeType,
+  fileName
+}) => {
+  if (isImageMimeType(mimeType) || isImageFileName(fileName)) return "image";
+  if (isVideoMimeType(mimeType) || typeof fileName === "string" && VIDEO_FILE_NAME_RE.test(fileName.trim())) {
+    return "video";
+  }
+  if (isAudioMimeType(mimeType) || typeof fileName === "string" && AUDIO_FILE_NAME_RE.test(fileName.trim())) {
+    return "audio";
+  }
+  if (isDocumentMimeType(mimeType) || typeof fileName === "string" && DOCUMENT_FILE_NAME_RE.test(fileName.trim())) {
+    return "document";
+  }
+  return "other";
+};
+var MEDIA_EXTENSION_RE = /\.(aac|avi|flac|m4a|m4v|mkv|mov|mp3|mp4|mpeg|mpg|ogg|wav|weba|webm)$/i;
+var isMediaFile = (file) => file.type.toLowerCase().startsWith("audio/") || file.type.toLowerCase().startsWith("video/") || MEDIA_EXTENSION_RE.test(file.name.trim());
+var MAX_MEDIA_FILE_SIZE = 120 * 1024 * 1024;
+
+export {
+  resolveFileCategory,
+  isMediaFile
+};