@useupup/core 3.3.0

package/dist/index.js

@@ -0,0 +1,1589 @@
+import { EventEmitter, PluginManager, FileManager, IndexedDBStorage, CrashRecoveryManager, UploadManager, validateFileRestrictions, isUploadActive } from './chunk-PMBR3OUW.js';
+export { ACCEPT_PRESETS, BoxPlugin, DropboxPlugin, GoogleDrivePlugin, OneDrivePlugin, PopupOAuthPlugin, resolveAccept } from './chunk-PMBR3OUW.js';
+import { PipelineEngine } from './chunk-FYQQRULL.js';
+import { abortPersistedMultipartSessions, ServerCredentials, MultipartUpload } from './chunk-MHYXDLZR.js';
+import { loadSession, fileFingerprint, TokenEndpointCredentials, DirectUpload } from './chunk-OOPDEOTM.js';
+import { TusUpload } from './chunk-TRCP5FUR.js';
+import { FileSource, UploadStatus } from './chunk-ZMS2HXLB.js';
+export { FileSource, NON_S3_STORAGE_PROVIDERS, StorageProvider, UploadStatus } from './chunk-ZMS2HXLB.js';
+import { UpupError, UpupConfigError } from './chunk-GE4LIVXP.js';
+export { UpupAuthError, UpupConfigError, UpupError, UpupErrorCode, UpupNetworkError, UpupQuotaError, UpupStorageError, UpupValidationError, uploadErrorFromResponse } from './chunk-GE4LIVXP.js';
+import { createTranslator, resolveLocaleBundle, enUS } from './chunk-UXNPM54W.js';
+export { LOCALE_CODES, LOCALE_META, LOCALE_REGISTRY, arSA, createTranslator, deDE, enUS, errorCodeToMessageKey, esES, flattenTranslatorToUiTranslations, formatUiMessage, frFR, jaJP, koKR, normalizeBcp47, pluralUiMessage, zhCN, zhTW } from './chunk-UXNPM54W.js';
+export { UPUP_VAR_PREFIX, darkPreset, flattenSlotsToClassNames, lightPreset, resolveTheme, tokensToVars } from './chunk-VV6QCQLL.js';
+
+// src/pipeline/build-auto-pipeline.ts
+async function buildAutoPipeline(options) {
+  const steps = [];
+  if (options.heicConversion) {
+    const { heicStep } = await import('./steps/heic.js');
+    steps.push(heicStep());
+  }
+  if (options.stripExifData) {
+    const { exifStep } = await import('./steps/exif.js');
+    steps.push(exifStep());
+  }
+  if (options.imageCompression) {
+    const { compressStep } = await import('./steps/compress.js');
+    const opts = typeof options.imageCompression === "object" ? options.imageCompression : {};
+    steps.push(compressStep(opts));
+  }
+  if (options.thumbnailGenerator) {
+    const { thumbnailStep } = await import('./steps/thumbnail.js');
+    const opts = typeof options.thumbnailGenerator === "object" ? options.thumbnailGenerator : {};
+    steps.push(thumbnailStep(opts));
+  }
+  if (options.checksumVerification) {
+    const { hashStep } = await import('./steps/hash.js');
+    steps.push(hashStep());
+  }
+  return steps;
+}
+
+// src/resolve-upload-config.ts
+function resolveUploadConfig(options) {
+  const tusOptions = options.resumable?.protocol === "tus" ? options.resumable : null;
+  const configuredTargetCount = [
+    options.uploadEndpoint,
+    options.serverUrl,
+    tusOptions?.endpoint
+  ].filter(Boolean).length;
+  if (configuredTargetCount > 1) {
+    throw new UpupConfigError(
+      'Configure exactly one upload target: uploadEndpoint, serverUrl, or resumable.protocol="tus" with endpoint.',
+      "AMBIGUOUS_UPLOAD_TARGET"
+    );
+  }
+  const credentials = options.serverUrl ? new ServerCredentials({
+    serverUrl: options.serverUrl
+  }) : options.uploadEndpoint ? new TokenEndpointCredentials({
+    url: options.uploadEndpoint
+  }) : {
+    getPresignedUrl: () => {
+      throw new UpupConfigError(
+        "Tus uploads do not use presigned upload URLs."
+      );
+    }
+  };
+  const directUpload = new DirectUpload();
+  const tusUpload = tusOptions ? new TusUpload(tusOptions) : null;
+  const multipartUpload = options.resumable?.protocol === "multipart" ? new MultipartUpload({
+    credentials,
+    chunkSizeBytes: options.resumable.chunkSizeBytes,
+    // Cross-reload resume is ON by default: an interrupted
+    // multipart upload keeps its server-side parts so the next
+    // attempt continues instead of restarting. Integrators who
+    // want the old auto-abort behavior set persist: false (and
+    // should set an S3 AbortIncompleteMultipartUpload lifecycle
+    // rule either way).
+    persist: options.resumable.persist ?? true,
+    sessionScope: options.serverUrl,
+    retryDelays: options.resumable.retryDelays,
+    partTimeoutMs: options.resumable.partTimeoutMs,
+    maxConcurrentParts: options.resumable.maxConcurrentParts
+  }) : null;
+  const multipartThreshold = options.resumable?.protocol === "multipart" ? options.resumable.thresholdBytes ?? 5 * 1024 * 1024 : Number.POSITIVE_INFINITY;
+  return {
+    credentials,
+    uploadStrategy: directUpload,
+    resolveUploadStrategy: (file) => {
+      if (tusUpload) {
+        return { uploadStrategy: tusUpload, presign: false };
+      }
+      if (multipartUpload && file.size >= multipartThreshold) {
+        return { uploadStrategy: multipartUpload, presign: false };
+      }
+      return { uploadStrategy: directUpload, presign: true };
+    },
+    maxConcurrentUploads: options.maxConcurrentUploads ?? 3,
+    ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {},
+    ...options.fastAbortThreshold !== void 0 ? { fastAbortThreshold: options.fastAbortThreshold } : {},
+    ...options.isSuccessfulCall !== void 0 ? { isSuccessfulCall: options.isSuccessfulCall } : {}
+  };
+}
+
+// src/crash-recovery-serializer.ts
+function toCrashRecoveryFileSnapshot(id, file) {
+  const snapshot = {
+    file,
+    id: file.id,
+    name: file.name,
+    type: file.type,
+    lastModified: file.lastModified,
+    source: file.source,
+    status: file.status,
+    metadata: file.metadata
+  };
+  if (file.url && !file.url.startsWith("blob:")) {
+    snapshot.url = file.url;
+  }
+  for (const key of [
+    "relativePath",
+    "key",
+    "etag",
+    "fileHash",
+    "checksumSHA256"
+  ]) {
+    if (file[key] !== void 0) {
+      Object.assign(snapshot, { [key]: file[key] });
+    }
+  }
+  const legacyThumbnail = file.thumbnail;
+  if (legacyThumbnail) {
+    snapshot.thumbnail = legacyThumbnail;
+  }
+  return snapshot;
+}
+function serializeCrashRecovery(files, status) {
+  return {
+    files: [...files.entries()].map(([id, file]) => [
+      id,
+      toCrashRecoveryFileSnapshot(id, file)
+    ]),
+    status
+  };
+}
+function reviveCrashRecoverySnapshot(snapshot) {
+  if (!isRecord(snapshot) || !Array.isArray(snapshot.files)) {
+    return null;
+  }
+  const status = isUploadStatus(snapshot.status) ? snapshot.status : "IDLE" /* IDLE */;
+  const files = snapshot.files.map((entry, index) => {
+    if (!Array.isArray(entry) || entry.length < 2) return null;
+    const id = typeof entry[0] === "string" ? entry[0] : `recovered-${index}`;
+    const file = reviveCrashRecoveryFile(id, entry[1], status);
+    return file ? [id, file] : null;
+  }).filter((entry) => entry != null);
+  return { files, status };
+}
+function reviveCrashRecoveryFile(id, value, fallbackStatus) {
+  const isFileLike = typeof File !== "undefined" && value instanceof File;
+  const wrappedBlob = isRecord(value) && typeof Blob !== "undefined" && value.file instanceof Blob ? value.file : null;
+  const props = isRecord(value) && wrappedBlob ? value : isRecord(value) ? value : {};
+  const nameFromProps = typeof props.name === "string" && props.name.trim() !== "" ? props.name : void 0;
+  const file = wrappedBlob ? toRecoverableFile(wrappedBlob, nameFromProps ?? id, props) : isFileLike ? value : null;
+  if (!file) return null;
+  const metadata = isRecord(props.metadata) ? props.metadata : {};
+  const uploadStatus = isUploadStatus(props.status) ? props.status : fallbackStatus;
+  const source = Object.values(FileSource).includes(
+    props.source
+  ) ? props.source : "local" /* LOCAL */;
+  const uploadFile = Object.assign(file, {
+    id: typeof props.id === "string" ? props.id : id,
+    source,
+    status: uploadStatus,
+    metadata
+  });
+  const url = typeof props.url === "string" && !props.url.startsWith("blob:") ? props.url : createObjectUrl(file);
+  if (url) {
+    uploadFile.url = url;
+  }
+  for (const key of [
+    "relativePath",
+    "key",
+    "etag",
+    "fileHash",
+    "checksumSHA256"
+  ]) {
+    if (typeof props[key] === "string") {
+      Object.assign(uploadFile, { [key]: props[key] });
+    }
+  }
+  if (isRecord(props.thumbnail)) {
+    const uploadFileRecord = uploadFile;
+    uploadFileRecord.thumbnail = props.thumbnail;
+  }
+  return uploadFile;
+}
+function createObjectUrl(file) {
+  return typeof URL !== "undefined" && typeof URL.createObjectURL === "function" ? URL.createObjectURL(file) : void 0;
+}
+function toRecoverableFile(blob, name, props) {
+  if (typeof File === "undefined") return null;
+  if (blob instanceof File && blob.name) {
+    return blob;
+  }
+  const type = typeof props.type === "string" ? props.type : blob.type;
+  const lastModified = typeof props.lastModified === "number" ? props.lastModified : Date.now();
+  return new File([blob], name, { type, lastModified });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isUploadStatus(value) {
+  return Object.values(UploadStatus).includes(value);
+}
+
+// src/core.ts
+var UpupCore = class {
+  constructor(options) {
+    this.emitter = new EventEmitter();
+    this.pluginManager = new PluginManager();
+    this.pipelineEngine = null;
+    this.uploadManager = null;
+    this._status = "IDLE" /* IDLE */;
+    this._error = null;
+    this.crashRecovery = null;
+    // Only set when WE created the IndexedDBStorage (not user-supplied
+    // storage, whose lifecycle belongs to the caller) so destroy() can
+    // release its cached IndexedDB connection.
+    this.crashRecoveryStorage = null;
+    this.crashRecoveryUnsubscribe = null;
+    /** Every crash-recovery storage write flows through this one promise chain.
+     *  Blob snapshots of large files make IndexedDB puts slow; fire-and-forget
+     *  save/clear calls complete out of order, so a save started before
+     *  completion can land after the completion clear and resurrect a finished
+     *  upload as a resumable one. FIFO ordering makes the last requested op the
+     *  last applied op. */
+    this.crashRecoveryChain = Promise.resolve();
+    /** True while a snapshot sync is queued but not yet run. Progress ticks
+     *  arrive far faster than a large snapshot writes; coalescing them into the
+     *  one queued sync (which reads state at write time) keeps it to at most
+     *  one write in flight plus one pending, instead of N stacked blob puts. */
+    this.crashRecoverySyncQueued = false;
+    this.fileOverrides = /* @__PURE__ */ new Map();
+    this.pauseRequested = false;
+    this.cancelRequested = false;
+    this.destroyed = false;
+    /** True only while the CURRENT pause was made by the offline handler —
+     *  the one case `online` may resume. A pause the user chose stays theirs. */
+    this.offlinePausedRun = false;
+    this.detachNetworkListeners = null;
+    this.activeRun = null;
+    this.workerProvider = null;
+    this.options = { ...options };
+    this.fileManager = new FileManager(this.fileManagerOptions());
+    if (options.pipeline) {
+      this.pipelineEngine = new PipelineEngine(options.pipeline);
+    }
+    if (options.plugins) {
+      for (const plugin of options.plugins) {
+        this.use(plugin);
+      }
+    }
+    this.configureCrashRecovery(options.crashRecovery);
+    this.installNetworkAwareness();
+  }
+  /** Connectivity reactions (`networkAware`, default on): `offline` pauses
+   *  an active run — with `persist` on, that keeps the multipart session
+   *  alive instead of burning whole-run retries against a dead network —
+   *  and `online` resumes it, but ONLY when this handler made the pause.
+   *  SSR/node-safe: without a window this installs nothing. */
+  installNetworkAwareness() {
+    if (this.options.networkAware === false) return;
+    if (typeof window === "undefined" || typeof window.addEventListener !== "function") {
+      return;
+    }
+    const onOffline = () => {
+      if (this.destroyed || !isUploadActive(this._status)) return;
+      this.pause();
+      this.offlinePausedRun = true;
+    };
+    const onOnline = () => {
+      if (!this.offlinePausedRun) return;
+      setTimeout(() => {
+        if (!this.offlinePausedRun || this.destroyed) return;
+        const onLine = typeof navigator === "undefined" ? void 0 : navigator.onLine;
+        if (onLine === false) {
+          return;
+        }
+        this.offlinePausedRun = false;
+        if (this._status !== "PAUSED" /* PAUSED */) return;
+        this.resume();
+      }, 0);
+    };
+    window.addEventListener("offline", onOffline);
+    window.addEventListener("online", onOnline);
+    this.detachNetworkListeners = () => {
+      window.removeEventListener("offline", onOffline);
+      window.removeEventListener("online", onOnline);
+    };
+  }
+  /** The one projection of CoreOptions the FileManager consumes — construction
+   *  and updateOptions() must stay in lockstep, so both call this. */
+  fileManagerOptions() {
+    return {
+      allowedFileTypes: this.options.allowedFileTypes,
+      limit: this.options.limit,
+      maxFileSize: this.options.maxFileSize,
+      minFileSize: this.options.minFileSize,
+      maxTotalFileSize: this.options.maxTotalFileSize,
+      contentDeduplication: this.options.contentDeduplication,
+      onBeforeFileAdded: this.options.onBeforeFileAdded
+    };
+  }
+  get files() {
+    return this.fileManager.getFiles();
+  }
+  get status() {
+    return this._status;
+  }
+  get error() {
+    return this._error;
+  }
+  get progress() {
+    const files = [...this.files.values()];
+    const total = files.length;
+    const completed = files.filter((f) => f.key != null).length;
+    return {
+      totalFiles: total,
+      completedFiles: completed,
+      percentage: total > 0 ? Math.round(completed / total * 100) : 0
+    };
+  }
+  /**
+   * Crash-recovery persistence is best-effort by design — a failed save/clear
+   * must never break an upload. But full silence hides a dead durability
+   * opt-in (F-734): surface failures dev-only, matching the worker-fallback
+   * convention in maybeCreateWorkerProvider().
+   */
+  warnCrashRecoveryFailure(op) {
+    return (err) => {
+      if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+        console.warn(`[upup] crash-recovery ${op} failed`, err);
+      }
+    };
+  }
+  configureCrashRecovery(crashRecovery) {
+    if (!crashRecovery || this.crashRecovery) return;
+    const crashOptions = typeof crashRecovery === "object" ? crashRecovery : {};
+    let storage = crashOptions.storage;
+    if (!storage) {
+      this.crashRecoveryStorage = new IndexedDBStorage();
+      storage = this.crashRecoveryStorage;
+    }
+    this.crashRecovery = new CrashRecoveryManager(storage);
+    this.crashRecoveryUnsubscribe = this.on("state-change", () => {
+      if (this.destroyed || this.files.size === 0) return;
+      this.queueCrashRecoverySync();
+    });
+  }
+  /** Queue a snapshot write that reads files/status at WRITE time, not at
+   *  event time — so the write that runs last always reflects the state that
+   *  came last, and a completion observed while a save is queued turns that
+   *  queued write into the clear instead of racing it. */
+  queueCrashRecoverySync() {
+    if (this.crashRecoverySyncQueued) return;
+    this.crashRecoverySyncQueued = true;
+    void this.enqueueCrashRecoveryOp(async () => {
+      this.crashRecoverySyncQueued = false;
+      const manager = this.crashRecovery;
+      if (!manager || this.destroyed || this.files.size === 0) return;
+      if (this._status === "SUCCESSFUL" /* SUCCESSFUL */) {
+        await manager.clear().catch(this.warnCrashRecoveryFailure("clear"));
+        return;
+      }
+      await manager.save(serializeCrashRecovery(this.files, this._status)).catch(this.warnCrashRecoveryFailure("save"));
+    });
+  }
+  /** Queue an unconditional clear behind any in-flight snapshot write. The
+   *  default manager is captured at call time so a clear requested before
+   *  disable/destroy still applies after the field is nulled. */
+  queueCrashRecoveryClear(manager = this.crashRecovery) {
+    if (!manager) return Promise.resolve();
+    return this.enqueueCrashRecoveryOp(() => manager.clear());
+  }
+  enqueueCrashRecoveryOp(op) {
+    const run = this.crashRecoveryChain.then(op);
+    this.crashRecoveryChain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  disableCrashRecovery() {
+    const manager = this.crashRecovery;
+    this.crashRecoveryUnsubscribe?.();
+    this.crashRecoveryUnsubscribe = null;
+    this.crashRecovery = null;
+    this.queueCrashRecoveryClear(manager).catch(
+      this.warnCrashRecoveryFailure("clear")
+    );
+  }
+  use(plugin) {
+    this.pluginManager.register(plugin);
+    plugin.init?.(this.emitter);
+    this.emitter.emit("plugin-registered", { name: plugin.name });
+    return this;
+  }
+  registerExtension(name, methods) {
+    this.pluginManager.registerExtension(name, methods);
+  }
+  getPlugin(name) {
+    return this.pluginManager.getPlugin(name);
+  }
+  getExtension(name) {
+    return this.pluginManager.getExtension(name);
+  }
+  get ext() {
+    return this.pluginManager.getExtensions();
+  }
+  async addFiles(files, overrides) {
+    if (this.destroyed)
+      throw new UpupError(
+        "UpupCore: addFiles() after destroy()",
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    try {
+      const added = await this.fileManager.addFiles(files);
+      if (added.length > 0) {
+        if (overrides) {
+          for (const file of added) {
+            this.fileOverrides.set(file.id, overrides);
+          }
+        }
+        this.emitter.emit("files-added", added);
+        const wasTerminal = this._status === "SUCCESSFUL" /* SUCCESSFUL */ || this._status === "FAILED" /* FAILED */;
+        if (wasTerminal && added.some((f) => f.key == null)) {
+          this._status = "IDLE" /* IDLE */;
+          this._error = null;
+          this.emitter.emit("state-change", {
+            files: this.files,
+            status: this._status
+          });
+        } else {
+          this.emitter.emit("state-change", { files: this.files });
+        }
+      }
+      const rejectedCount = files.length - added.length;
+      if (rejectedCount > 0) {
+        this.emitter.emit("file-rejected", { count: rejectedCount });
+      }
+    } catch (error) {
+      this.emitter.emit("restriction-failed", { error });
+      throw error;
+    }
+  }
+  /**
+   * Discard the persisted multipart sessions of files the user just threw
+   * away (cancel / removeFile / removeAll), aborting them server-side on the
+   * way out. With `resumable.persist` on, a failed or cancelled upload
+   * deliberately keeps its server-side parts alive for a later resume — so
+   * an explicit discard is the ONE place that has to say "no, really, drop
+   * it", or the user pays storage for parts nothing will ever finish.
+   *
+   * Fire-and-forget and fully swallowed: cancelling must never throw or wait.
+   */
+  discardPersistedMultipartSessions(files) {
+    const resumable = this.options.resumable;
+    if (resumable?.protocol !== "multipart") return;
+    if (resumable.persist === false) return;
+    const pending = files.filter((file) => file.key == null);
+    if (pending.length === 0) return;
+    try {
+      const { credentials } = resolveUploadConfig(this.options);
+      abortPersistedMultipartSessions(pending, credentials);
+    } catch {
+    }
+  }
+  removeFile(id) {
+    const file = this.fileManager.removeFile(id);
+    if (file) {
+      this.discardPersistedMultipartSessions([file]);
+      this.fileOverrides.delete(id);
+      this.emitter.emit("file-removed", file);
+      this.emitter.emit("state-change", { files: this.files });
+    }
+  }
+  removeAll() {
+    this.discardPersistedMultipartSessions([...this.files.values()]);
+    this.fileManager.removeAll();
+    this.fileOverrides.clear();
+    this.queueCrashRecoveryClear().catch(
+      this.warnCrashRecoveryFailure("clear")
+    );
+    this.emitter.emit("state-change", { files: this.files });
+    this.emitter.emit("files-cleared", {});
+  }
+  async setFiles(files) {
+    if (this.destroyed)
+      throw new UpupError(
+        "UpupCore: setFiles() after destroy()",
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    await this.fileManager.setFiles(files);
+    this.emitter.emit("state-change", { files: this.files });
+    this.emitter.emit("files-set", { count: this.files.size });
+  }
+  /** Update options after construction (e.g. when React props change). */
+  updateOptions(partial) {
+    const hadCrashRecovery = this.crashRecovery != null;
+    const PIPELINE_FLAGS = [
+      "heicConversion",
+      "stripExifData",
+      "imageCompression",
+      "thumbnailGenerator",
+      "checksumVerification"
+    ];
+    const pipelineFlagChanged = PIPELINE_FLAGS.some((k) => k in partial);
+    Object.assign(this.options, partial);
+    this.fileManager.updateOptions(this.fileManagerOptions());
+    if (pipelineFlagChanged && !this.options.pipeline) {
+      this.pipelineEngine = null;
+    }
+    if ("crashRecovery" in partial) {
+      if (partial.crashRecovery) {
+        this.configureCrashRecovery(partial.crashRecovery);
+      } else if (hadCrashRecovery) {
+        this.disableCrashRecovery();
+      }
+    }
+    this.emitter.emit("options-updated", { partial });
+  }
+  reorderFiles(fileIds) {
+    this.fileManager.reorderFiles(fileIds);
+    this.emitter.emit("state-change", { files: this.files });
+    this.emitter.emit("files-reordered", { fileIds });
+  }
+  async maybeCreateWorkerProvider(stepCount) {
+    const { isWorkerEligible } = await import('./eligibility-ULFC3E4G.js');
+    if (!isWorkerEligible(
+      this.options,
+      typeof Worker !== "undefined",
+      stepCount
+    ))
+      return null;
+    try {
+      const [{ createWorkerProvider }, { BrowserRuntime }] = await Promise.all([
+        import('./create-worker-provider-AA5SRII6.js'),
+        import('./browser-WD6T5ABJ.js')
+      ]);
+      return createWorkerProvider(
+        BrowserRuntime,
+        this.options.workerTimeoutMs !== void 0 ? { timeoutMs: this.options.workerTimeoutMs } : {}
+      );
+    } catch (err) {
+      if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+        console.warn(
+          "[upup] worker offload unavailable, falling back to main thread",
+          err
+        );
+      }
+      return null;
+    }
+  }
+  hasUploadTarget() {
+    return Boolean(
+      this.options.uploadEndpoint || this.options.serverUrl || this.options.resumable?.protocol === "tus"
+    );
+  }
+  createUploadManager() {
+    const config = resolveUploadConfig(this.options);
+    return new UploadManager({
+      ...config,
+      onFileStart: (file) => {
+        const uploading = this.fileManager.updateFile(file.id, {
+          status: "UPLOADING" /* UPLOADING */
+        });
+        if (!uploading) return;
+        this.emitter.emit("file-upload-start", { file: uploading });
+        this.emitter.emit("state-change", { files: this.files });
+      },
+      onProgress: (fileId, loaded, total) => {
+        this.emitter.emit("upload-progress", { fileId, loaded, total });
+        this.emitter.emit("state-change", { progress: this.progress });
+      },
+      onFileComplete: (file, result) => {
+        if (this.pauseRequested || this.cancelRequested || this.destroyed)
+          return;
+        const updated = this.fileManager.updateFile(file.id, {
+          key: result.key,
+          status: "SUCCESSFUL" /* SUCCESSFUL */
+        });
+        if (!updated) return;
+        this.emitter.emit("upload-success", { file: updated, result });
+        this.emitter.emit("state-change", { files: this.files });
+      },
+      onFileError: (file, error) => {
+        if (this.pauseRequested || this.cancelRequested || this.destroyed)
+          return;
+        const failed = this.fileManager.updateFile(file.id, {
+          status: "FAILED" /* FAILED */
+        });
+        if (!failed) return;
+        this.emitter.emit("upload-error", { file: failed, error });
+        this.emitter.emit("state-change", { files: this.files });
+      }
+    });
+  }
+  markFilesReady(files) {
+    return files.map((file) => {
+      const overrides = this.fileOverrides.get(file.id);
+      return this.fileManager.updateFile(file.id, {
+        status: "READY" /* READY */,
+        metadata: {
+          ...file.metadata,
+          ...this.options.metadata,
+          ...overrides?.metadata
+        }
+      });
+    }).filter((file) => file !== void 0);
+  }
+  updatePendingFileStatuses(status) {
+    for (const file of [...this.files.values()]) {
+      if (file.key == null && (file.status === "READY" /* READY */ || file.status === "UPLOADING" /* UPLOADING */ || file.status === "PROCESSING" /* PROCESSING */ || file.status === "PAUSED" /* PAUSED */)) {
+        this.fileManager.updateFile(file.id, { status });
+      }
+    }
+  }
+  markUnsuccessfulFilesFailed() {
+    for (const file of [...this.files.values()]) {
+      if (file.key == null && file.status !== "SUCCESSFUL" /* SUCCESSFUL */) {
+        this.fileManager.updateFile(file.id, {
+          status: "FAILED" /* FAILED */
+        });
+      }
+    }
+  }
+  async uploadFiles(files) {
+    const targetFiles = this.markFilesReady(files);
+    this.emitter.emit("state-change", { files: this.files });
+    if (!this.hasUploadTarget()) {
+      throw new UpupConfigError(
+        "No upload target configured. Use selected files directly for local-only flows, or configure uploadEndpoint, serverUrl, or an external Tus endpoint before calling upload()."
+      );
+    }
+    this.uploadManager = this.createUploadManager();
+    await this.uploadManager.uploadAll(targetFiles);
+    this.uploadManager = null;
+    return [...this.files.values()];
+  }
+  validateFiles(files) {
+    return Promise.resolve(
+      files.map((file) => {
+        const errors = validateFileRestrictions(file, this.options);
+        return { file, valid: errors.length === 0, errors };
+      })
+    );
+  }
+  async upload() {
+    if (this.destroyed)
+      throw new UpupError(
+        "UpupCore: upload() after destroy()",
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    if (this.activeRun) return this.activeRun;
+    this.activeRun = this.runUpload();
+    try {
+      return await this.activeRun;
+    } finally {
+      this.activeRun = null;
+    }
+  }
+  resetRunFlags() {
+    this.pauseRequested = false;
+    this.cancelRequested = false;
+  }
+  async runUpload() {
+    this.resetRunFlags();
+    this._status = "PROCESSING" /* PROCESSING */;
+    this.emitter.emit("upload-start", {});
+    this.emitter.emit("state-change", { status: this._status });
+    try {
+      if (!this.pipelineEngine) {
+        const autoSteps = await buildAutoPipeline(this.options);
+        if (autoSteps.length > 0) {
+          this.pipelineEngine = new PipelineEngine(autoSteps);
+        }
+      }
+      if (this.pipelineEngine) {
+        const translator = createTranslator({
+          bundle: resolveLocaleBundle(this.options.locale) ?? enUS,
+          fallback: enUS
+        });
+        const provider = await this.maybeCreateWorkerProvider(
+          this.pipelineEngine.stepCount
+        );
+        this.workerProvider = provider;
+        try {
+          const context = {
+            files: this.files,
+            options: this.options,
+            emit: (event, data) => {
+              this.emitter.emit(event, data);
+            },
+            t: (key, vars) => translator(
+              key,
+              vars
+            ),
+            worker: provider ? {
+              execute: (task) => provider.execute(task)
+            } : void 0
+          };
+          const processed = await this.pipelineEngine.processAll(
+            [...this.files.values()].filter((f) => f.key == null),
+            context
+          );
+          this.fileManager.applyProcessed(processed);
+        } finally {
+          provider?.terminate();
+          this.workerProvider = null;
+        }
+      }
+      if (this.destroyed || this.cancelRequested) {
+        this._status = "IDLE" /* IDLE */;
+        this._error = null;
+        this.emitter.emit("state-change", { status: this._status });
+        return [...this.files.values()];
+      }
+      if (this.pauseRequested) {
+        this._status = "PAUSED" /* PAUSED */;
+        this.emitter.emit("state-change", { status: this._status });
+        return [...this.files.values()];
+      }
+      this._status = "UPLOADING" /* UPLOADING */;
+      this.emitter.emit("state-change", { status: this._status });
+      await this.uploadFiles(
+        [...this.files.values()].filter((f) => f.key == null)
+      );
+      this._status = "SUCCESSFUL" /* SUCCESSFUL */;
+      this._error = null;
+      this.emitter.emit("upload-all-complete", [...this.files.values()]);
+      this.emitter.emit("state-change", { status: this._status });
+      this.queueCrashRecoveryClear().catch(
+        this.warnCrashRecoveryFailure("clear")
+      );
+      return [...this.files.values()];
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.uploadManager = null;
+      if (this.pauseRequested) {
+        this._status = "PAUSED" /* PAUSED */;
+        this._error = null;
+        this.emitter.emit("state-change", { status: this._status });
+        return [...this.files.values()];
+      }
+      if (this.cancelRequested || this.destroyed) {
+        this._status = "IDLE" /* IDLE */;
+        this._error = null;
+        this.emitter.emit("state-change", { status: this._status });
+        return [...this.files.values()];
+      }
+      this.terminalRunFailure(err);
+      throw err;
+    }
+  }
+  /**
+   * The single terminal-failure path shared by all three run flavors
+   * (runUpload / runRetry / resume). They previously diverged (F-729): only
+   * runUpload marked leftover files FAILED, and resume never invoked
+   * options.onError — a retry/resume failure looked different to consumers
+   * than the identical first-run failure for no reason.
+   */
+  terminalRunFailure(err) {
+    this.uploadManager = null;
+    this._status = "FAILED" /* FAILED */;
+    this._error = err;
+    this.markUnsuccessfulFilesFailed();
+    this.options.onError?.(err);
+    this.emitter.emit("upload-error", { error: err });
+    this.emitter.emit("state-change", {
+      status: this._status,
+      error: err,
+      files: this.files
+    });
+  }
+  replaceFile(id, file) {
+    const next = this.fileManager.replaceFile(id, file);
+    this.emitter.emit("file-replaced", { file: next });
+    this.emitter.emit("state-change", { files: this.files });
+  }
+  /**
+   * Pause in-flight uploads by aborting the current abort controller.
+   * Note: This cancels active HTTP requests. Resume will re-upload
+   * files that were in progress — true pause/resume of partial uploads
+   * requires multipart upload support.
+   */
+  pause() {
+    this.offlinePausedRun = false;
+    this.pauseRequested = true;
+    if (this.uploadManager) {
+      this.uploadManager.abort();
+      this.uploadManager = null;
+    }
+    this.updatePendingFileStatuses("PAUSED" /* PAUSED */);
+    this._status = "PAUSED" /* PAUSED */;
+    this.emitter.emit("upload-pause", {});
+    this.emitter.emit("state-change", { status: this._status });
+  }
+  /**
+   * Resume uploads after a pause. Re-uploads files that did not
+   * complete successfully (those without a `key` set).
+   */
+  resume() {
+    if (this.destroyed)
+      throw new UpupError(
+        "UpupCore: resume() after destroy()",
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    if (this.activeRun) return;
+    this.pauseRequested = false;
+    this.offlinePausedRun = false;
+    this._status = "UPLOADING" /* UPLOADING */;
+    this.emitter.emit("upload-resume", {});
+    this.emitter.emit("state-change", { status: this._status });
+    const incomplete = [...this.files.values()].filter((f) => f.key == null);
+    if (incomplete.length > 0 && this.hasUploadTarget()) {
+      const run = this.uploadFiles(incomplete);
+      this.activeRun = run;
+      run.then(() => {
+        const allComplete = [...this.files.values()].every(
+          (file) => file.key != null
+        );
+        this._status = allComplete ? "SUCCESSFUL" /* SUCCESSFUL */ : "IDLE" /* IDLE */;
+        this.emitter.emit("state-change", { status: this._status });
+      }).catch((err) => {
+        if (this.pauseRequested || this.cancelRequested || this.destroyed)
+          return;
+        this.terminalRunFailure(
+          err instanceof Error ? err : new Error(String(err))
+        );
+      }).finally(() => {
+        this.activeRun = null;
+      });
+      return;
+    }
+    if (incomplete.length === 0 && this.files.size > 0) {
+      const allComplete = [...this.files.values()].every(
+        (file) => file.key != null
+      );
+      this._status = allComplete ? "SUCCESSFUL" /* SUCCESSFUL */ : "IDLE" /* IDLE */;
+      if (allComplete) {
+        this.emitter.emit("upload-all-complete", [
+          ...this.files.values()
+        ]);
+        this.queueCrashRecoveryClear().catch(
+          this.warnCrashRecoveryFailure("clear")
+        );
+      }
+      this.emitter.emit("state-change", { status: this._status });
+    }
+  }
+  cancel() {
+    this.offlinePausedRun = false;
+    this.cancelRequested = true;
+    if (this.uploadManager) {
+      this.uploadManager.abort();
+      this.uploadManager = null;
+    }
+    this.discardPersistedMultipartSessions([...this.files.values()]);
+    this.updatePendingFileStatuses("IDLE" /* IDLE */);
+    this._status = "IDLE" /* IDLE */;
+    this._error = null;
+    this.emitter.emit("upload-cancel", {});
+    this.emitter.emit("state-change", { status: this._status });
+  }
+  async retry(fileId) {
+    if (this.destroyed)
+      throw new UpupError(
+        "UpupCore: retry() after destroy()",
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    if (this.activeRun) return this.activeRun;
+    this.activeRun = this.runRetry(fileId);
+    try {
+      return await this.activeRun;
+    } finally {
+      this.activeRun = null;
+    }
+  }
+  async runRetry(fileId) {
+    this.emitter.emit("retry", { fileId });
+    const target = fileId ? this.files.get(fileId) : void 0;
+    const files = fileId ? target ? [target] : [] : [...this.files.values()].filter(
+      (file) => file.key == null || file.status === "FAILED" /* FAILED */
+    );
+    if (files.length === 0) {
+      return [...this.files.values()];
+    }
+    this._status = "UPLOADING" /* UPLOADING */;
+    this._error = null;
+    this.emitter.emit("upload-start", { retry: true, fileId });
+    this.emitter.emit("state-change", { status: this._status });
+    try {
+      const uploaded = await this.uploadFiles(files);
+      const allComplete = [...this.files.values()].every(
+        (file) => file.key != null
+      );
+      this._status = allComplete ? "SUCCESSFUL" /* SUCCESSFUL */ : "IDLE" /* IDLE */;
+      if (allComplete) {
+        this.emitter.emit("upload-all-complete", [
+          ...this.files.values()
+        ]);
+        this.queueCrashRecoveryClear().catch(
+          this.warnCrashRecoveryFailure("clear")
+        );
+      }
+      this.emitter.emit("state-change", { status: this._status });
+      return uploaded;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.terminalRunFailure(err);
+      throw err;
+    }
+  }
+  on(event, handler) {
+    return this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  emit(event, data) {
+    this.emitter.emit(event, data);
+  }
+  getSnapshot() {
+    return {
+      files: [...this.files.entries()],
+      status: this._status
+    };
+  }
+  restore(snapshot) {
+    this.fileManager.restore(snapshot.files);
+    this._status = snapshot.status;
+    this.emitter.emit("state-change", {
+      files: this.files,
+      status: this._status
+    });
+    this.emitter.emit("snapshot-restored", {
+      count: snapshot.files.length,
+      status: snapshot.status
+    });
+  }
+  async restoreFromCrashRecovery() {
+    if (!this.crashRecovery) return false;
+    const snapshot = await this.crashRecovery.restore();
+    const restored = reviveCrashRecoverySnapshot(snapshot);
+    if (restored && restored.files.length > 0) {
+      const wasActive = restored.status === "PROCESSING" /* PROCESSING */ || restored.status === "UPLOADING" /* UPLOADING */;
+      const liveFiles = restored.files.filter(
+        ([, file]) => !this.isStaleMultipartRestore(file)
+      );
+      if (liveFiles.length === 0) {
+        this.queueCrashRecoveryClear().catch(
+          this.warnCrashRecoveryFailure("clear")
+        );
+        return false;
+      }
+      const normalized = {
+        files: liveFiles.map(([id, file]) => {
+          if (wasActive && file.key == null && (file.status === "PROCESSING" /* PROCESSING */ || file.status === "UPLOADING" /* UPLOADING */ || file.status === "READY" /* READY */ || file.status === "IDLE" /* IDLE */)) {
+            return [
+              id,
+              Object.assign(file, {
+                status: "PAUSED" /* PAUSED */
+              })
+            ];
+          }
+          return [id, file];
+        }),
+        status: wasActive ? "PAUSED" /* PAUSED */ : restored.status
+      };
+      this.restore(normalized);
+      this.seedRestoredProgress(normalized.files);
+      this.emitter.emit("crash-recovery-restored", {});
+      this.maybeScheduleAutoResume(normalized.status);
+      return true;
+    }
+    return false;
+  }
+  /** `resumable.autoResume` continues a crash-restored upload without the
+   *  explicit Resume click. Off by default on purpose: closing a tab is an
+   *  ambiguous signal — as often "cancel" as "oops" — so silently resuming
+   *  a transfer the user may have meant to kill is an integrator's call,
+   *  never the library's. Deferred a tick so the host finishes mounting
+   *  (the same guard autoUpload's timer carries, F-148), and re-checked at
+   *  fire time: the user may have discarded the restore in between. */
+  maybeScheduleAutoResume(restoredStatus) {
+    const resumable = this.options.resumable;
+    if (resumable?.protocol !== "multipart" || !resumable.autoResume) {
+      return;
+    }
+    if (restoredStatus !== "PAUSED" /* PAUSED */) return;
+    setTimeout(() => {
+      if (this.destroyed) return;
+      if (this._status !== "PAUSED" /* PAUSED */) return;
+      this.resume();
+    }, 0);
+  }
+  /** A restored PAUSED file rendered "0 B of N" even when most of it was
+   *  already in storage — the persisted multipart session knows the real
+   *  offset, but nothing replayed it into the progress pipeline until the
+   *  user actually hit resume. Emit it here so the restored UI opens at the
+   *  byte count the resume will continue from. Same session gates as
+   *  tryResume (scope), minus the server round-trip: this is display-only
+   *  and must not spend a request; the authoritative recheck still happens
+   *  on resume. */
+  /** A finished multipart upload can die in the window between its
+   *  synchronous session removal and the asynchronous IndexedDB snapshot
+   *  clear — the next visit then restores a file the server already
+   *  assembled, offering a Resume that would re-upload all of it. The
+   *  session store is the tiebreaker: init writes the session synchronously
+   *  before the first byte moves and completion removes it synchronously,
+   *  so an UPLOADING-status file of multipart size with no session is a
+   *  stale snapshot, not a crashed upload. PROCESSING files never had a
+   *  session and stay restorable; so does everything below the multipart
+   *  threshold or outside persist mode. */
+  isStaleMultipartRestore(file) {
+    const resumable = this.options.resumable;
+    if (resumable?.protocol !== "multipart") return false;
+    if (!(resumable.persist ?? true)) return false;
+    if (!(file instanceof File)) return false;
+    if (file.status !== "UPLOADING" /* UPLOADING */) return false;
+    if (file.key != null) return false;
+    if (file.size < (resumable.thresholdBytes ?? 5 * 1024 * 1024)) {
+      return false;
+    }
+    return loadSession(fileFingerprint(file)) == null;
+  }
+  seedRestoredProgress(restored) {
+    for (const [, file] of restored) {
+      if (file.status !== "PAUSED" /* PAUSED */) continue;
+      if (!(file instanceof File)) continue;
+      const session = loadSession(fileFingerprint(file));
+      if (!session || session.scope !== this.options.serverUrl) continue;
+      const loaded = Math.min(session.uploadedBytes ?? 0, file.size);
+      if (loaded <= 0) continue;
+      this.emitter.emit("upload-progress", {
+        fileId: file.id,
+        loaded,
+        total: file.size
+      });
+    }
+  }
+  async clearCrashRecovery() {
+    await this.queueCrashRecoveryClear();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.detachNetworkListeners?.();
+    this.detachNetworkListeners = null;
+    this.uploadManager?.abort();
+    this.uploadManager = null;
+    this.workerProvider?.terminate();
+    this.workerProvider = null;
+    this.emitter.emit("destroyed", {});
+    this.crashRecoveryUnsubscribe?.();
+    this.crashRecoveryUnsubscribe = null;
+    this.crashRecoveryStorage?.close();
+    this.crashRecoveryStorage = null;
+    this.crashRecovery = null;
+    this.pipelineEngine = null;
+    this.fileOverrides.clear();
+    this.emitter.removeAllListeners();
+    this.pluginManager.destroy();
+    this.fileManager.removeAll();
+    this._status = "IDLE" /* IDLE */;
+    this._error = null;
+  }
+};
+
+// src/drives/drive-browser-descriptors.ts
+var GOOGLE_DRIVE_DESCRIPTOR = {
+  pluginId: "google-drive",
+  eventPrefix: "google-drive",
+  rootFolderName: "Drive",
+  rootFolderId: "root",
+  folderKey: "id",
+  loadFilesRootArg: void 0,
+  folderIdField: "folderId",
+  auth: "gis",
+  selectFolder: "cached-children"
+};
+var ONE_DRIVE_DESCRIPTOR = {
+  pluginId: "one-drive",
+  eventPrefix: "one-drive",
+  rootFolderName: "OneDrive",
+  rootFolderId: "root",
+  folderKey: "id",
+  loadFilesRootArg: void 0,
+  folderIdField: "folderId",
+  auth: "popup",
+  selectFolder: "load-all",
+  loadAllRootArg: "root"
+};
+var DROPBOX_DESCRIPTOR = {
+  pluginId: "dropbox",
+  eventPrefix: "dropbox",
+  rootFolderName: "Dropbox",
+  rootFolderId: "root",
+  folderKey: "path",
+  loadFilesRootArg: "",
+  folderIdField: "path",
+  auth: "popup",
+  selectFolder: "load-all",
+  loadAllRootArg: ""
+};
+var BOX_DESCRIPTOR = {
+  pluginId: "box",
+  eventPrefix: "box",
+  rootFolderName: "Box",
+  rootFolderId: "0",
+  folderKey: "id",
+  loadFilesRootArg: "0",
+  folderIdField: "folderId",
+  auth: "popup",
+  selectFolder: "load-all",
+  loadAllRootArg: "0"
+};
+
+// src/icons/file-type-icons.ts
+var FT_STROKE = {
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "2",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round"
+};
+var FILE_TYPE_EXTENSIONS = [
+  "bmp",
+  "css",
+  "csv",
+  "docx",
+  "html",
+  "jpg",
+  "js",
+  "jsx",
+  "pdf",
+  "png",
+  "php",
+  "ppt",
+  "rs",
+  "sql",
+  "svg",
+  "ts",
+  "tsx",
+  "txt",
+  "vue",
+  "xls",
+  "xml",
+  "zip"
+];
+var FILE_TYPE_ICONS = {
+  "file-bmp": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M18 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M4 21h1.5a1.5 1.5 0 0 0 0 -3h-1.5h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6z"></path><path d="M10 21v-6l2.5 3l2.5 -3v6"></path>`
+  },
+  "file-css": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M8 16.5a1.5 1.5 0 0 0 -3 0v3a1.5 1.5 0 0 0 3 0"></path><path d="M11 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M17 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path>`
+  },
+  "file-csv": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M7 16.5a1.5 1.5 0 0 0 -3 0v3a1.5 1.5 0 0 0 3 0"></path><path d="M10 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M16 15l2 6l2 -6"></path>`
+  },
+  "file-docx": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M2 15v6h1a2 2 0 0 0 2 -2v-2a2 2 0 0 0 -2 -2h-1z"></path><path d="M17 16.5a1.5 1.5 0 0 0 -3 0v3a1.5 1.5 0 0 0 3 0"></path><path d="M9.5 15a1.5 1.5 0 0 1 1.5 1.5v3a1.5 1.5 0 0 1 -3 0v-3a1.5 1.5 0 0 1 1.5 -1.5z"></path><path d="M19.5 15l3 6"></path><path d="M19.5 21l3 -6"></path>`
+  },
+  "file-html": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M2 21v-6"></path><path d="M5 15v6"></path><path d="M2 18h3"></path><path d="M20 15v6h2"></path><path d="M13 21v-6l2 3l2 -3v6"></path><path d="M7.5 15h3"></path><path d="M9 15v6"></path>`
+  },
+  "file-jpg": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M11 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M20 15h-1a2 2 0 0 0 -2 2v2a2 2 0 0 0 2 2h1v-3"></path><path d="M5 15h3v4.5a1.5 1.5 0 0 1 -3 0"></path>`
+  },
+  "file-js": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M3 15h3v4.5a1.5 1.5 0 0 1 -3 0"></path><path d="M9 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v11a2 2 0 0 1 -2 2h-1"></path>`
+  },
+  "file-jsx": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M4 15h3v4.5a1.5 1.5 0 0 1 -3 0"></path><path d="M10 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M16 15l4 6"></path><path d="M16 21l4 -6"></path>`
+  },
+  "file-pdf": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M5 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M17 18h2"></path><path d="M20 15h-3v6"></path><path d="M11 15v6h1a2 2 0 0 0 2 -2v-2a2 2 0 0 0 -2 -2h-1z"></path>`
+  },
+  "file-png": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M20 15h-1a2 2 0 0 0 -2 2v2a2 2 0 0 0 2 2h1v-3"></path><path d="M5 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M11 21v-6l3 6v-6"></path>`
+  },
+  "file-php": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M5 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M17 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M11 21v-6"></path><path d="M14 15v6"></path><path d="M11 18h3"></path>`
+  },
+  "file-ppt": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M11 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M16.5 15h3"></path><path d="M18 15v6"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path>`
+  },
+  "file-rs": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M9 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v11a2 2 0 0 1 -2 2h-1"></path><path d="M3 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6m3 0l-2 -3"></path>`
+  },
+  "file-sql": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M18 15v6h2"></path><path d="M13 15a2 2 0 0 1 2 2v2a2 2 0 1 1 -4 0v-2a2 2 0 0 1 2 -2z"></path><path d="M14 20l1.5 1.5"></path>`
+  },
+  "file-svg": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M4 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M10 15l2 6l2 -6"></path><path d="M20 15h-1a2 2 0 0 0 -2 2v2a2 2 0 0 0 2 2h1v-3"></path>`
+  },
+  "file-ts": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v11a2 2 0 0 1 -2 2h-1"></path><path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M9 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M3.5 15h3"></path><path d="M5 15v6"></path>`
+  },
+  "file-tsx": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M16 15l4 6"></path><path d="M16 21l4 -6"></path><path d="M10 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M4.5 15h3"></path><path d="M6 15v6"></path>`
+  },
+  "file-txt": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M16.5 15h3"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M4.5 15h3"></path><path d="M6 15v6"></path><path d="M18 15v6"></path><path d="M10 15l4 6"></path><path d="M10 21l4 -6"></path>`
+  },
+  "file-vue": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M4 15l2 6l2 -6"></path><path d="M11 15v4.5a1.5 1.5 0 0 0 3 0v-4.5"></path><path d="M20 15h-3v6h3"></path><path d="M17 18h2"></path>`
+  },
+  "file-xls": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M4 15l4 6"></path><path d="M4 21l4 -6"></path><path d="M17 20.25c0 .414 .336 .75 .75 .75h1.25a1 1 0 0 0 1 -1v-1a1 1 0 0 0 -1 -1h-1a1 1 0 0 1 -1 -1v-1a1 1 0 0 1 1 -1h1.25a.75 .75 0 0 1 .75 .75"></path><path d="M11 15v6h3"></path>`
+  },
+  "file-xml": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M4 15l4 6"></path><path d="M4 21l4 -6"></path><path d="M19 15v6h3"></path><path d="M11 21v-6l2.5 3l2.5 -3v6"></path>`
+  },
+  "file-zip": {
+    viewBox: "0 0 24 24",
+    defaultSize: 48,
+    attrs: { ...FT_STROKE },
+    inner: `<path d="M14 3v4a1 1 0 0 0 1 1h4"></path><path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4"></path><path d="M16 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6"></path><path d="M12 15v6"></path><path d="M5 15h3l-3 6h3"></path>`
+  }
+};
+
+// src/icons/registry.ts
+var STROKE_ATTRS = {
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "2",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round"
+};
+var FILLED_ATTRS = { fill: "currentColor", stroke: "none" };
+var BRAND_FILLRULE = { fill: "none", "fill-rule": "nonzero" };
+var ICONS = {
+  // ── Brand/source (viewBox 0 0 32 32) ──
+  "my-device": {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    className: "upup-text-[#0ea5e9]",
+    inner: `
+  <path d="M8.45 22.087l-1.305-6.674h17.678l-1.572 6.674H8.45zm4.975-12.412l1.083 1.765a.823.823 0 00.715.386h7.951V13.5H8.587V9.675h4.838zM26.043 13.5h-1.195v-2.598c0-.463-.336-.75-.798-.75h-8.356l-1.082-1.766A.823.823 0 0013.897 8H7.728c-.462 0-.815.256-.815.718V13.5h-.956a.97.97 0 00-.746.37.972.972 0 00-.19.81l1.724 8.565c.095.44.484.755.933.755H24c.44 0 .824-.3.929-.727l2.043-8.568a.972.972 0 00-.176-.825.967.967 0 00-.753-.38z" fill="currentcolor" fill-rule="evenodd" />
+`
+  },
+  box: {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    className: "upup-text-[#0061d5]",
+    inner: `
+  <g fill="currentcolor" fill-rule="nonzero">
+    <path d="m16.4 13.5c-1.6 0-3 0.9-3.7 2.2-0.7-1.3-2.1-2.2-3.7-2.2-1 0-1.8 0.3-2.5 0.8v-3.6c-0.1-0.3-0.5-0.7-1-0.7s-0.8 0.4-0.8 0.8v7c0 2.3 1.9 4.2 4.2 4.2 1.6 0 3-0.9 3.7-2.2 0.7 1.3 2.1 2.2 3.7 2.2 2.3 0 4.2-1.9 4.2-4.2 0.1-2.4-1.8-4.3-4.1-4.3m-7.5 6.8c-1.4 0-2.5-1.1-2.5-2.5s1.1-2.5 2.5-2.5 2.5 1.1 2.5 2.5-1.1 2.5-2.5 2.5m7.5 0c-1.4 0-2.5-1.1-2.5-2.5s1.1-2.5 2.5-2.5 2.5 1.1 2.5 2.5-1.1 2.5-2.5 2.5" />
+    <path d="m27.2 20.6l-2.3-2.8 2.3-2.8c0.3-0.4 0.2-0.9-0.2-1.2s-1-0.2-1.3 0.2l-2 2.4-2-2.4c-0.3-0.4-0.9-0.4-1.3-0.2-0.4 0.3-0.5 0.8-0.2 1.2l2.3 2.8-2.3 2.8c-0.3 0.4-0.2 0.9 0.2 1.2s1 0.2 1.3-0.2l2-2.4 2 2.4c0.3 0.4 0.9 0.4 1.3 0.2 0.4-0.3 0.4-0.8 0.2-1.2" />
+  </g>
+`
+  },
+  dropbox: {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    className: "upup-text-[#0061fe]",
+    inner: `
+  <path d="M10.5 7.5L5 10.955l5.5 3.454 5.5-3.454 5.5 3.454 5.5-3.454L21.5 7.5 16 10.955zM10.5 21.319L5 17.864l5.5-3.455 5.5 3.455zM16 17.864l5.5-3.455 5.5 3.455-5.5 3.455zM16 25.925l-5.5-3.455 5.5-3.454 5.5 3.454z" fill="currentcolor" fill-rule="nonzero" />
+`
+  },
+  "google-drive": {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    attrs: { ...BRAND_FILLRULE },
+    inner: `
+  <g fill-rule="nonzero" fill="none">
+    <path d="M6.663 22.284l.97 1.62c.202.34.492.609.832.804l3.465-5.798H5c0 .378.1.755.302 1.096l1.361 2.278z" fill="#0066DA" />
+    <path d="M16 12.09l-3.465-5.798c-.34.195-.63.463-.832.804l-6.4 10.718A2.15 2.15 0 005 18.91h6.93L16 12.09z" fill="#00AC47" />
+    <path d="M23.535 24.708c.34-.195.63-.463.832-.804l.403-.67 1.928-3.228c.201-.34.302-.718.302-1.096h-6.93l1.474 2.802 1.991 2.996z" fill="#EA4335" />
+    <path d="M16 12.09l3.465-5.798A2.274 2.274 0 0018.331 6h-4.662c-.403 0-.794.11-1.134.292L16 12.09z" fill="#00832D" />
+    <path d="M20.07 18.91h-8.14l-3.465 5.798c.34.195.73.292 1.134.292h12.802c.403 0 .794-.11 1.134-.292L20.07 18.91z" fill="#2684FC" />
+    <path d="M23.497 12.455l-3.2-5.359a2.252 2.252 0 00-.832-.804L16 12.09l4.07 6.82h6.917c0-.377-.1-.755-.302-1.096l-3.188-5.359z" fill="#FFBA00" />
+  </g>
+`
+  },
+  "one-drive": {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    attrs: { ...BRAND_FILLRULE },
+    inner: `
+  <g fill="none" fill-rule="nonzero">
+    <path d="M13.39 12.888l4.618 2.747 2.752-1.15a4.478 4.478 0 012.073-.352 6.858 6.858 0 00-5.527-5.04 6.895 6.895 0 00-6.876 2.982l.07-.002a5.5 5.5 0 012.89.815z" fill="#0364B8" />
+    <path d="M13.39 12.887v.001a5.5 5.5 0 00-2.89-.815l-.07.002a5.502 5.502 0 00-4.822 2.964 5.43 5.43 0 00.38 5.62l4.073-1.702 1.81-.757 4.032-1.685 2.105-.88-4.619-2.748z" fill="#0078D4" />
+    <path d="M22.833 14.133a4.479 4.479 0 00-2.073.352l-2.752 1.15.798.475 2.616 1.556 1.141.68 3.902 2.321a4.413 4.413 0 00-.022-4.25 4.471 4.471 0 00-3.61-2.284z" fill="#1490DF" />
+    <path d="M22.563 18.346l-1.141-.68-2.616-1.556-.798-.475-2.105.88L11.87 18.2l-1.81.757-4.073 1.702A5.503 5.503 0 0010.5 23h12.031a4.472 4.472 0 003.934-2.333l-3.902-2.321z" fill="#28A8EA" />
+  </g>
+`
+  },
+  link: {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    inner: `<path d="M23.637 15.312l-2.474 2.464a3.582 3.582 0 01-.577.491c-.907.657-1.897.986-2.968.986a4.925 4.925 0 01-3.959-1.971c-.248-.329-.164-.902.165-1.149.33-.247.907-.164 1.155.164 1.072 1.478 3.133 1.724 4.618.656a.642.642 0 00.33-.328l2.473-2.463c1.238-1.313 1.238-3.366-.082-4.597a3.348 3.348 0 00-4.618 0l-1.402 1.395a.799.799 0 01-1.154 0 .79.79 0 010-1.15l1.402-1.394a4.843 4.843 0 016.843 0c2.062 1.805 2.144 5.007.248 6.896zm-8.081 5.664l-1.402 1.395a3.348 3.348 0 01-4.618 0c-1.319-1.23-1.319-3.365-.082-4.596l2.475-2.464.328-.328c.743-.492 1.567-.739 2.475-.657.906.165 1.648.574 2.143 1.314.248.329.825.411 1.155.165.33-.248.412-.822.165-1.15-.825-1.068-1.98-1.724-3.216-1.888-1.238-.247-2.556.082-3.628.902l-.495.493-2.474 2.464c-1.897 1.969-1.814 5.09.083 6.977.99.904 2.226 1.396 3.463 1.396s2.473-.492 3.463-1.395l1.402-1.396a.79.79 0 000-1.15c-.33-.328-.908-.41-1.237-.082z" fill="#FF753E" fill-rule="nonzero" />`
+  },
+  camera: {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    inner: `
+  <path d="M23.5 9.5c1.417 0 2.5 1.083 2.5 2.5v9.167c0 1.416-1.083 2.5-2.5 2.5h-15c-1.417 0-2.5-1.084-2.5-2.5V12c0-1.417 1.083-2.5 2.5-2.5h2.917l1.416-2.167C13 7.167 13.25 7 13.5 7h5c.25 0 .5.167.667.333L20.583 9.5H23.5zM16 11.417a4.706 4.706 0 00-4.75 4.75 4.704 4.704 0 004.75 4.75 4.703 4.703 0 004.75-4.75c0-2.663-2.09-4.75-4.75-4.75zm0 7.825c-1.744 0-3.076-1.332-3.076-3.074 0-1.745 1.333-3.077 3.076-3.077 1.744 0 3.074 1.333 3.074 3.076s-1.33 3.075-3.074 3.075z" fill="#02B383" fill-rule="nonzero" />
+`
+  },
+  audio: {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    className: "upup-text-[#8030a3]",
+    inner: `
+  <path d="M21.143 12.297c.473 0 .857.383.857.857v2.572c0 3.016-2.24 5.513-5.143 5.931v2.64h2.572a.857.857 0 110 1.714H12.57a.857.857 0 110-1.714h2.572v-2.64C12.24 21.24 10 18.742 10 15.726v-2.572a.857.857 0 111.714 0v2.572A4.29 4.29 0 0016 20.01a4.29 4.29 0 004.286-4.285v-2.572c0-.474.384-.857.857-.857zM16 6.5a3 3 0 013 3v6a3 3 0 01-6 0v-6a3 3 0 013-3z" fill="currentcolor" fill-rule="nonzero" />
+`
+  },
+  "screen-capture": {
+    viewBox: "0 0 32 32",
+    defaultSize: 32,
+    className: "upup-text-[#2c3e50]",
+    inner: `
+  <g fill="currentcolor" fill-rule="evenodd">
+    <path d="M24.182 9H7.818C6.81 9 6 9.742 6 10.667v10c0 .916.81 1.666 1.818 1.666h4.546V24h7.272v-1.667h4.546c1 0 1.809-.75 1.809-1.666l.009-10C26 9.742 25.182 9 24.182 9zM24 21H8V11h16v10z" />
+    <circle cx="16" cy="16" r="2" />
+  </g>
+`
+  },
+  // ── Stroke UI (viewBox 0 0 24 24) ──
+  upload: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M4 17v2a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-2" />
+    <polyline points="7 9 12 4 17 9" />
+    <line x1="12" y1="4" x2="12" y2="16" />
+  `
+  },
+  loader: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <line x1="12" y1="2" x2="12" y2="6" /><line x1="12" y1="18" x2="12" y2="22" />
+    <line x1="4.93" y1="4.93" x2="7.76" y2="7.76" /><line x1="16.24" y1="16.24" x2="19.07" y2="19.07" />
+    <line x1="2" y1="12" x2="6" y2="12" /><line x1="18" y1="12" x2="22" y2="12" />
+    <line x1="4.93" y1="19.07" x2="7.76" y2="16.24" /><line x1="16.24" y1="7.76" x2="19.07" y2="4.93" />
+  `
+  },
+  x: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <line x1="18" y1="6" x2="6" y2="18" />
+    <line x1="6" y1="6" x2="18" y2="18" />
+  `
+  },
+  // Tabler 'chevron-left' — drive-browser "go back one folder" affordance.
+  "chevron-left": {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M15 6l-6 6l6 6" />
+  `
+  },
+  // Tabler 'trash' (matches react-icons/tb TbTrash exactly) — default for icons.FileDeleteIcon.
+  trash: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M4 7l16 0" />
+    <path d="M10 11l0 6" />
+    <path d="M14 11l0 6" />
+    <path d="M5 7l1 12a2 2 0 0 0 2 2h8a2 2 0 0 0 2 -2l1 -12" />
+    <path d="M9 7v-3a1 1 0 0 1 1 -1h4a1 1 0 0 1 1 1v3" />
+  `
+  },
+  // Tabler 'camera-rotate' (matches react-icons/tb TbCameraRotate exactly) — default for icons.CameraRotateIcon.
+  "camera-rotate": {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M5 7h1a2 2 0 0 0 2 -2a1 1 0 0 1 1 -1h6a1 1 0 0 1 1 1a2 2 0 0 0 2 2h1a2 2 0 0 1 2 2v9a2 2 0 0 1 -2 2h-14a2 2 0 0 1 -2 -2v-9a2 2 0 0 1 2 -2" />
+    <path d="M11.245 15.904a3 3 0 0 0 3.755 -2.904m-2.25 -2.905a3 3 0 0 0 -3.75 2.905" />
+    <path d="M14 13h2v2" />
+    <path d="M10 13h-2v-2" />
+  `
+  },
+  // Tabler 'capture' (matches react-icons/tb TbCapture exactly) — default for icons.CameraCaptureIcon.
+  capture: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M4 8v-2a2 2 0 0 1 2 -2h2" />
+    <path d="M4 16v2a2 2 0 0 0 2 2h2" />
+    <path d="M16 4h2a2 2 0 0 1 2 2v2" />
+    <path d="M16 20h2a2 2 0 0 0 2 -2v-2" />
+    <path d="M12 12m-3 0a3 3 0 1 0 6 0a3 3 0 1 0 -6 0" />
+  `
+  },
+  // Tabler 'plus' (matches react-icons/tb TbPlus exactly) — default for icons.ContainerAddMoreIcon.
+  plus: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M12 5l0 14" />
+    <path d="M5 12l14 0" />
+  `
+  },
+  "layout-grid": {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <rect x="4" y="4" width="6" height="6" rx="1" /><rect x="14" y="4" width="6" height="6" rx="1" />
+    <rect x="4" y="14" width="6" height="6" rx="1" /><rect x="14" y="14" width="6" height="6" rx="1" />
+  `
+  },
+  "layout-list": {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <rect x="4" y="4" width="16" height="6" rx="1" /><rect x="4" y="14" width="16" height="6" rx="1" />
+  `
+  },
+  folder: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M5 4h4l3 3h7a2 2 0 0 1 2 2v8a2 2 0 0 1 -2 2h-14a2 2 0 0 1 -2 -2v-11a2 2 0 0 1 2 -2" />
+  `
+  },
+  // Tabler 'folder-filled' — solid folder glyph for the drive browser, tinted
+  // amber at the call site so folders read unmistakably as folders.
+  "folder-filled": {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...FILLED_ATTRS },
+    inner: `
+    <path d="M9 3a1 1 0 0 1 .608 .206l.1 .087l2.706 2.707h6.586a3 3 0 0 1 2.995 2.824l.005 .176v8a3 3 0 0 1 -2.824 2.995l-.176 .005h-14a3 3 0 0 1 -2.995 -2.824l-.005 -.176v-11a3 3 0 0 1 2.824 -2.995l.176 -.005h4z" />
+  `
+  },
+  search: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <circle cx="10" cy="10" r="7" /><line x1="21" y1="21" x2="15" y2="15" />
+  `
+  },
+  user: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M12 7m-4 0a4 4 0 1 0 8 0a4 4 0 1 0 -8 0" /><path d="M6 21v-2a4 4 0 0 1 4 -4h4a4 4 0 0 1 4 4v2" />
+  `
+  },
+  file: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" /><polyline points="14 2 14 8 20 8" />
+  `
+  },
+  // Tabler 'files' — stacked pages, used for the "N files max" limit caption.
+  "stacked-files": {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <path d="M15 3v4a1 1 0 0 0 1 1h4" />
+    <path d="M18 17h-7a2 2 0 0 1 -2 -2v-10a2 2 0 0 1 2 -2h4l5 5v7a2 2 0 0 1 -2 2z" />
+    <path d="M16 17v2a2 2 0 0 1 -2 2h-7a2 2 0 0 1 -2 -2v-10a2 2 0 0 1 2 -2h2" />
+  `
+  },
+  // Tabler 'database' — storage cylinder, used for the "SIZE each" limit caption
+  // (a drive/storage glyph — deliberately NOT a speedometer).
+  storage: {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...STROKE_ATTRS },
+    inner: `
+    <ellipse cx="12" cy="6" rx="8" ry="3" />
+    <path d="M4 6v6a8 3 0 0 0 16 0v-6" />
+    <path d="M4 12v6a8 3 0 0 0 16 0v-6" />
+  `
+  },
+  // ── Filled UI (viewBox 0 0 24 24) ──
+  "player-play": {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...FILLED_ATTRS },
+    inner: `<path d="M6 4l15 8-15 8z" />`
+  },
+  "player-pause": {
+    viewBox: "0 0 24 24",
+    defaultSize: 24,
+    attrs: { ...FILLED_ATTRS },
+    inner: `
+    <rect x="6" y="4" width="4" height="16" rx="1" /><rect x="14" y="4" width="4" height="16" rx="1" />
+  `
+  },
+  // ── File-type typed glyphs (Tabler TbFileType*) ──
+  ...FILE_TYPE_ICONS
+};
+
+// src/icons/file-type-icon.ts
+function fileTypeIconName(extension) {
+  const key = `file-${extension.toLowerCase()}`;
+  return key in ICONS ? key : "file";
+}
+
+export { BOX_DESCRIPTOR, DROPBOX_DESCRIPTOR, FILE_TYPE_EXTENSIONS, GOOGLE_DRIVE_DESCRIPTOR, ICONS, ONE_DRIVE_DESCRIPTOR, UpupCore, fileTypeIconName };