@ai-matrx/media 0.7.16 → 0.8.0

package/dist/files.js

@@ -0,0 +1,1275 @@
+// src/files/ref-types.ts
+function toVisibility(raw) {
+  if (raw === "public") return "public";
+  if (raw === "link") return "link";
+  if (raw === "internal") return "internal";
+  return "personal";
+}
+function fileIdToMediaRef(fileId, mimeType) {
+  const ref = { file_id: fileId };
+  if (mimeType) ref.mime_type = mimeType;
+  return ref;
+}
+function urlToMediaRef(url, mimeType) {
+  const ref = { url };
+  if (mimeType) ref.mime_type = mimeType;
+  return ref;
+}
+
+// src/files/blocks/types.ts
+function parseGenerationMetadata(metadata) {
+  if (!metadata) return null;
+  const raw = metadata.generation;
+  if (!raw || typeof raw !== "object") return null;
+  const w = raw;
+  if (typeof w.kind !== "string") return null;
+  if (typeof w.provider !== "string") return null;
+  if (typeof w.model !== "string") return null;
+  if (typeof w.prompt !== "string") return null;
+  return {
+    kind: w.kind,
+    provider: w.provider,
+    model: w.model,
+    prompt: w.prompt,
+    negativePrompt: w.negative_prompt ?? null,
+    revisedPrompt: w.revised_prompt ?? null,
+    width: w.width ?? null,
+    height: w.height ?? null,
+    aspectRatio: w.aspect_ratio ?? null,
+    durationSeconds: w.duration_seconds ?? null,
+    quality: w.quality ?? null,
+    style: w.style ?? null,
+    seed: w.seed ?? null,
+    steps: w.steps ?? null,
+    cfgScale: w.cfg_scale ?? null,
+    nRequested: w.n_requested ?? 1,
+    nReturned: w.n_returned ?? 1,
+    responseId: w.response_id ?? null,
+    durationMs: w.duration_ms ?? null,
+    costUsd: w.cost_usd ?? null,
+    finishReason: w.finish_reason ?? null,
+    safetyFlagged: w.safety_flagged ?? false,
+    providerExtras: w.provider_extras ?? {}
+  };
+}
+
+// src/files/blocks/guards.ts
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function hasMediaShape(value) {
+  if (!isObject(value)) return false;
+  if (typeof value.kind !== "string") return false;
+  if (value.origin !== "matrx" && value.origin !== "external") return false;
+  return true;
+}
+function isMatrxMediaBlock(value) {
+  if (!hasMediaShape(value)) return false;
+  if (value.origin !== "matrx") return false;
+  return typeof value.fileId === "string";
+}
+function isExternalMediaBlock(value) {
+  if (!hasMediaShape(value)) return false;
+  if (value.origin !== "external") return false;
+  return typeof value.externalUrl === "string";
+}
+function isUnifiedMediaBlock(value) {
+  return isMatrxMediaBlock(value) || isExternalMediaBlock(value);
+}
+function isImageBlock(value) {
+  return isUnifiedMediaBlock(value) && value.kind === "image";
+}
+function isVideoBlock(value) {
+  return isUnifiedMediaBlock(value) && value.kind === "video";
+}
+function isAudioBlock(value) {
+  return isUnifiedMediaBlock(value) && value.kind === "audio";
+}
+function isDocumentBlock(value) {
+  return isUnifiedMediaBlock(value) && value.kind === "document";
+}
+function isYouTubeBlock(value) {
+  return isUnifiedMediaBlock(value) && value.kind === "youtube";
+}
+function isMatrxImageBlock(value) {
+  return isImageBlock(value) && value.origin === "matrx";
+}
+function isExternalImageBlock(value) {
+  return isImageBlock(value) && value.origin === "external";
+}
+
+// src/files/blocks/image/guards.ts
+function isUnifiedImageBlock(value) {
+  return isImageBlock(value);
+}
+
+// src/files/blocks/adapters/from-cx-av-part.ts
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function liftUrls(part) {
+  const metadata = part.metadata ?? null;
+  const cdn = str(metadata?.cdn_url);
+  const download = str(metadata?.download_url);
+  return {
+    // The on-disk `url` is a save-time snapshot; forward it as the fallback
+    // the handler only uses when no identity is available.
+    url: str(part.url) ?? cdn ?? "",
+    file_id: str(part.file_id) ?? str(metadata?.file_id),
+    cdn_url: cdn,
+    download_url: download
+  };
+}
+function fromCxAudioPart(part) {
+  return {
+    type: "audio_output",
+    ...liftUrls(part),
+    mime_type: part.mime_type ?? "audio/*",
+    transcription_result: part.transcription_result ?? null
+  };
+}
+function fromCxVideoPart(part) {
+  return {
+    type: "video_output",
+    ...liftUrls(part),
+    mime_type: part.mime_type ?? "video/*",
+    // A video reference's role (extend / restyle) and its `@name` — carried so
+    // a reload redisplays them (see ReferenceRoleCaption).
+    reference_role: part.role ?? null,
+    reference_name: part.name ?? null
+  };
+}
+
+// src/files/blocks/adapters/from-media-block.ts
+function pickStatus(s) {
+  return s === "streaming" || s === "error" ? s : "complete";
+}
+function pickVisibility(v) {
+  return toVisibility(v);
+}
+function commonFields(wire) {
+  return {
+    status: pickStatus(wire.status),
+    progress: wire.progress ?? null,
+    errorMessage: wire.error_message ?? null,
+    mimeType: wire.mime_type ?? null,
+    fileName: wire.file_name ?? null,
+    sizeBytes: wire.size_bytes ?? null,
+    base64: wire.base64 ?? null,
+    metadata: wire.metadata ?? null
+  };
+}
+function matrxFields(wire) {
+  if (wire.origin !== "matrx") return null;
+  if (!wire.file_id) return null;
+  return {
+    origin: "matrx",
+    fileId: wire.file_id,
+    visibility: pickVisibility(wire.visibility),
+    cdnUrl: wire.cdn_url ?? null,
+    downloadUrl: wire.download_url ?? null,
+    parentFileId: wire.parent_file_id ?? null,
+    derivationKind: wire.derivation_kind ?? null
+  };
+}
+function externalFields(wire) {
+  return {
+    origin: "external",
+    externalUrl: wire.external_url ?? "",
+    sourceLabel: wire.source_label ?? null
+  };
+}
+function liftImage(wire) {
+  const common = commonFields(wire);
+  const matrx = matrxFields(wire);
+  const imageBits = {
+    kind: "image",
+    width: wire.width ?? null,
+    height: wire.height ?? null,
+    visionClass: wire.vision_class ?? null
+  };
+  if (matrx) {
+    const block2 = { ...common, ...matrx, ...imageBits };
+    return block2;
+  }
+  const block = {
+    ...common,
+    ...externalFields(wire),
+    ...imageBits
+  };
+  return block;
+}
+function liftVideo(wire) {
+  const common = commonFields(wire);
+  const matrx = matrxFields(wire);
+  const videoBits = {
+    kind: "video",
+    width: wire.width ?? null,
+    height: wire.height ?? null,
+    durationMs: wire.duration_ms ?? null,
+    posterUrl: wire.poster_url ?? null
+  };
+  if (matrx) {
+    const block2 = { ...common, ...matrx, ...videoBits };
+    return block2;
+  }
+  const block = {
+    ...common,
+    ...externalFields(wire),
+    ...videoBits
+  };
+  return block;
+}
+function liftAudio(wire) {
+  const common = commonFields(wire);
+  const matrx = matrxFields(wire);
+  const audioBits = {
+    kind: "audio",
+    durationMs: wire.duration_ms ?? null,
+    transcript: wire.transcript ?? null
+  };
+  if (matrx) {
+    const block2 = { ...common, ...matrx, ...audioBits };
+    return block2;
+  }
+  const block = {
+    ...common,
+    ...externalFields(wire),
+    ...audioBits
+  };
+  return block;
+}
+function liftDocument(wire) {
+  const common = commonFields(wire);
+  const matrx = matrxFields(wire);
+  const docBits = {
+    kind: "document",
+    pageCount: wire.page_count ?? null,
+    page1Url: wire.page1_url ?? null
+  };
+  if (matrx) {
+    const block2 = { ...common, ...matrx, ...docBits };
+    return block2;
+  }
+  const block = {
+    ...common,
+    ...externalFields(wire),
+    ...docBits
+  };
+  return block;
+}
+function liftYouTube(wire) {
+  const common = commonFields(wire);
+  const block = {
+    ...common,
+    ...externalFields(wire),
+    kind: "youtube",
+    videoId: wire.video_id ?? null
+  };
+  return block;
+}
+function fromMediaBlock(wire) {
+  switch (wire.kind) {
+    case "image":
+      return liftImage(wire);
+    case "video":
+      return liftVideo(wire);
+    case "audio":
+      return liftAudio(wire);
+    case "document":
+      return liftDocument(wire);
+    case "youtube":
+      return liftYouTube(wire);
+    default: {
+      const base = wire;
+      const unknownKind = wire.kind;
+      const fallback = {
+        ...commonFields(base),
+        ...externalFields(base),
+        kind: "image",
+        width: null,
+        height: null,
+        visionClass: null,
+        metadata: {
+          ...base.metadata ?? {},
+          _unknown_media_kind: unknownKind
+        },
+        errorMessage: `Unsupported media kind: ${unknownKind}`,
+        status: "error"
+      };
+      return fallback;
+    }
+  }
+}
+function isMediaBlockData(value) {
+  if (value === null || typeof value !== "object") return false;
+  const v = value;
+  if (v.type !== "media_block") return false;
+  if (!v.block || typeof v.block !== "object") return false;
+  const b = v.block;
+  return typeof b.kind === "string" && typeof b.origin === "string";
+}
+
+// src/files/blocks/adapters/from-media-ref.ts
+function commonBase(ref) {
+  return {
+    status: "complete",
+    progress: null,
+    errorMessage: null,
+    mimeType: ref.mime_type ?? null,
+    fileName: null,
+    sizeBytes: null,
+    base64: null,
+    metadata: null
+  };
+}
+function matrxBase(fileId) {
+  return {
+    origin: "matrx",
+    fileId,
+    visibility: "personal",
+    cdnUrl: null,
+    downloadUrl: null,
+    parentFileId: null,
+    derivationKind: null
+  };
+}
+function externalBase(url) {
+  return {
+    origin: "external",
+    externalUrl: url,
+    sourceLabel: null
+  };
+}
+function imageBlockFromMediaRef(ref) {
+  if (!ref) return null;
+  const common = commonBase(ref);
+  const imageBits = {
+    kind: "image",
+    width: null,
+    height: null,
+    visionClass: null
+  };
+  if (ref.file_id) {
+    const block2 = {
+      ...common,
+      ...matrxBase(ref.file_id),
+      ...imageBits
+    };
+    return block2;
+  }
+  const block = {
+    ...common,
+    ...externalBase(ref.url ?? ""),
+    ...imageBits
+  };
+  return block;
+}
+function videoBlockFromMediaRef(ref) {
+  if (!ref) return null;
+  const common = commonBase(ref);
+  const videoBits = {
+    kind: "video",
+    width: null,
+    height: null,
+    durationMs: null,
+    posterUrl: null
+  };
+  if (ref.file_id) {
+    const block2 = {
+      ...common,
+      ...matrxBase(ref.file_id),
+      ...videoBits
+    };
+    return block2;
+  }
+  const block = {
+    ...common,
+    ...externalBase(ref.url ?? ""),
+    ...videoBits
+  };
+  return block;
+}
+function blockFromMediaRef(ref, kind) {
+  return kind === "video" ? videoBlockFromMediaRef(ref) : imageBlockFromMediaRef(ref);
+}
+
+// src/files/blocks/image/helpers/extract-file-id-from-url.ts
+import { isUuidShape } from "@ai-matrx/kit/uuid";
+function extractFileIdFromUrl(url) {
+  if (!url) return null;
+  try {
+    const parts = new URL(url).pathname.split("/").filter(Boolean);
+    if (parts.length >= 2) {
+      const candidate = parts[1];
+      if (isUuidShape(candidate)) return candidate;
+    }
+    const last = parts[parts.length - 1] ?? "";
+    const stripped = last.replace(/\.[^.]+$/, "");
+    if (isUuidShape(stripped)) return stripped;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/files/blocks/image/helpers/parse-filename-from-url.ts
+var FILENAME_QUERY_KEYS = [
+  "response-content-disposition",
+  "content-disposition"
+];
+function parseFilenameFromUrl(url) {
+  if (!url) return null;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  for (const key of FILENAME_QUERY_KEYS) {
+    const disposition = parsed.searchParams.get(key);
+    if (disposition) {
+      const name = parseContentDisposition(disposition);
+      if (name) return name;
+    }
+  }
+  return null;
+}
+function parseContentDisposition(value) {
+  const extMatch = /filename\*\s*=\s*([A-Za-z0-9_-]+)'(?:[A-Za-z0-9_-]*)'([^;]+)/i.exec(value);
+  if (extMatch) {
+    const charset = extMatch[1];
+    const encoded = extMatch[2].trim();
+    try {
+      const decoded = decodeURIComponent(encoded);
+      if (charset.toLowerCase() === "utf-8") return safeName(decoded);
+      return safeName(decoded);
+    } catch {
+    }
+  }
+  const basicMatch = /filename\s*=\s*(?:"([^"]+)"|([^;]+))/i.exec(value);
+  if (basicMatch) {
+    const raw = (basicMatch[1] ?? basicMatch[2] ?? "").trim();
+    if (raw) return safeName(raw);
+  }
+  return null;
+}
+function safeName(name) {
+  const leaf = name.split(/[/\\]/).pop()?.trim();
+  if (!leaf) return null;
+  if (/[\x00-\x1f]/.test(leaf)) return null;
+  return leaf;
+}
+
+// src/files/blocks/image/adapters/from-image-output-data.ts
+import { isSignedUrl } from "@ai-matrx/data/files";
+function metaString(metadata, key) {
+  if (!metadata) return null;
+  const value = metadata[key];
+  return typeof value === "string" ? value : null;
+}
+function metaNumber(metadata, key) {
+  if (!metadata) return null;
+  const value = metadata[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function metaVisibility(metadata) {
+  const value = metaString(metadata, "visibility");
+  if (value === "public" || value === "personal" || value === "internal" || value === "link")
+    return value;
+  if (value === "shared" || value === "private") return "personal";
+  return "personal";
+}
+function fromImageOutputData(data, carriedMetadata) {
+  const metadata = carriedMetadata ?? null;
+  const cdnUrl = data.cdn_url ?? null;
+  const downloadUrl = data.download_url ?? null;
+  const fallbackUrl = data.url;
+  const fallbackLooksSigned = isSignedUrl(fallbackUrl);
+  const finalCdnUrl = cdnUrl ?? (fallbackLooksSigned ? null : fallbackUrl ?? null);
+  const explicitFileId = data.file_id ?? null;
+  const inferredFileId = explicitFileId ?? extractFileIdFromUrl(finalCdnUrl) ?? extractFileIdFromUrl(fallbackUrl) ?? null;
+  const common = {
+    kind: "image",
+    base64: null,
+    mimeType: data.mime_type ?? null,
+    // Filename priority:
+    //   1. Explicit `file_name` in the event metadata (Python's intent).
+    //   2. The filename baked into the signed URL's
+    //      `response-content-disposition` query param — Python sets this
+    //      to the AI-chosen name on every signed-URL mint, and it's the
+    //      ground truth for "what should the user see on download".
+    //   3. null — fall back to a generic `image.<ext>` at the callsite.
+    fileName: metaString(metadata, "file_name") ?? parseFilenameFromUrl(downloadUrl) ?? parseFilenameFromUrl(finalCdnUrl) ?? null,
+    width: metaNumber(metadata, "width"),
+    height: metaNumber(metadata, "height"),
+    // Phase 0 wire rename: prefer `size_bytes`, accept legacy `file_size`
+    // from in-flight services that haven't redeployed yet.
+    sizeBytes: metaNumber(metadata, "size_bytes") ?? metaNumber(metadata, "file_size"),
+    visionClass: metaString(metadata, "vision_class"),
+    status: "complete",
+    progress: null,
+    errorMessage: null,
+    metadata: metadata ?? null
+  };
+  if (inferredFileId) {
+    const matrx = {
+      ...common,
+      origin: "matrx",
+      fileId: inferredFileId,
+      visibility: metaVisibility(metadata),
+      cdnUrl: finalCdnUrl,
+      downloadUrl,
+      // Phase 1b: thumbnails removed from MatrxImageBlock — the canonical
+      // source is `Asset.variants["thumbnail_url"].url` via GET /assets/{id}.
+      // For top-level listings, `CloudFile.thumbnailUrl` (lifted from
+      // `FileRecord.thumbnail_url`) is the FE-side cache of that resolved URL.
+      parentFileId: metaString(metadata, "parent_file_id"),
+      derivationKind: metaString(metadata, "derivation_kind")
+    };
+    return matrx;
+  }
+  const externalUrl = fallbackUrl ?? finalCdnUrl ?? "";
+  if (!externalUrl) {
+    const broken = {
+      ...common,
+      origin: "external",
+      externalUrl: "",
+      sourceLabel: metaString(metadata, "source_label")
+    };
+    return broken;
+  }
+  const external = {
+    ...common,
+    origin: "external",
+    externalUrl,
+    sourceLabel: metaString(metadata, "source_label")
+  };
+  return external;
+}
+
+// src/files/blocks/image/adapters/from-cx-media-part.ts
+function fromCxMediaPart(part) {
+  const metadata = part.metadata ?? null;
+  const cdnFromMeta = typeof metadata?.cdn_url === "string" ? metadata.cdn_url : null;
+  const downloadFromMeta = typeof metadata?.download_url === "string" ? metadata.download_url : null;
+  const fileId = (typeof part.file_id === "string" ? part.file_id : null) ?? (typeof metadata?.file_id === "string" ? metadata.file_id : null);
+  const fallbackUrl = part.url ?? cdnFromMeta ?? "";
+  const block = fromImageOutputData(
+    {
+      type: "image_output",
+      url: fallbackUrl,
+      mime_type: part.mime_type ?? "image/*",
+      file_id: fileId,
+      cdn_url: cdnFromMeta,
+      download_url: downloadFromMeta
+    },
+    {
+      // Pass through all metadata so the extension fields (visibility,
+      // thumbnail, dimensions, etc.) get lifted by the rich adapter.
+      // Stored parts from before the storage-location eradication may
+      ...metadata ?? {}
+    }
+  );
+  const withRole = {
+    ...block,
+    referenceRole: part.role ?? null,
+    referenceName: part.name ?? null
+  };
+  if (typeof metadata?.base64_data === "string") {
+    return { ...withRole, base64: metadata.base64_data };
+  }
+  return withRole;
+}
+
+// src/files/blocks/image/adapters/from-partial-image-data.ts
+function fromPartialImageData(data, carriedMetadata) {
+  return {
+    kind: "image",
+    origin: "external",
+    base64: data.b64_json,
+    mimeType: data.mime_type ?? "image/png",
+    fileName: null,
+    width: null,
+    height: null,
+    sizeBytes: null,
+    visionClass: null,
+    status: "streaming",
+    progress: data.progress ?? null,
+    errorMessage: null,
+    metadata: carriedMetadata ?? null,
+    externalUrl: "",
+    sourceLabel: "Generating"
+  };
+}
+
+// src/files/blocks/image/adapters/from-render-block.ts
+function fromRenderBlock(block) {
+  const data = block.data ?? {};
+  const src = typeof data.src === "string" ? data.src : "";
+  const mimeType = typeof data.mime_type === "string" ? data.mime_type : "image/*";
+  return fromImageOutputData(
+    {
+      type: "image_output",
+      url: src,
+      mime_type: mimeType
+    },
+    block.metadata ?? null
+  );
+}
+
+// src/files/blocks/image/adapters/to-cx-media-part.ts
+function toCxMediaPart(block) {
+  const visibleUrl = block.origin === "matrx" ? block.cdnUrl ?? void 0 : block.externalUrl || void 0;
+  const callerMetadata = block.metadata ?? {};
+  const packed = {
+    ...callerMetadata,
+    kind: block.kind,
+    origin: block.origin,
+    mime_type: block.mimeType,
+    file_name: block.fileName,
+    width: block.width,
+    height: block.height,
+    size_bytes: block.sizeBytes,
+    vision_class: block.visionClass,
+    status: block.status,
+    progress: block.progress,
+    error_message: block.errorMessage
+  };
+  delete packed.signed_url;
+  delete packed.signed_url_expires_at;
+  if (block.origin === "matrx") {
+    packed.cdn_url = block.cdnUrl;
+    packed.download_url = block.downloadUrl;
+    packed.file_id = block.fileId;
+    packed.visibility = block.visibility;
+    packed.parent_file_id = block.parentFileId;
+    packed.derivation_kind = block.derivationKind;
+  } else {
+    packed.external_url = block.externalUrl;
+    packed.source_label = block.sourceLabel;
+  }
+  if (block.base64) {
+    packed.base64_data = block.base64;
+  }
+  const common = {
+    type: "media",
+    kind: "image",
+    ...block.mimeType !== null ? { mime_type: block.mimeType } : {},
+    ...block.sizeBytes !== null ? { size_bytes: block.sizeBytes } : {},
+    ...block.width !== null ? { width: block.width } : {},
+    ...block.height !== null ? { height: block.height } : {},
+    metadata: packed
+  };
+  if (block.origin === "matrx") {
+    return {
+      ...common,
+      origin: "matrx",
+      file_id: block.fileId,
+      ...visibleUrl ? { url: visibleUrl } : {}
+    };
+  }
+  const externalUrl = visibleUrl ?? (block.base64 ? `data:${block.mimeType ?? "image/*"};base64,${block.base64}` : null);
+  if (!externalUrl) {
+    throw new TypeError(
+      "Cannot project external image into chat.message.content: missing URL and base64 locator"
+    );
+  }
+  return {
+    ...common,
+    origin: "external",
+    url: externalUrl
+  };
+}
+
+// src/files/blocks/image/helpers/derive-viewer-url.ts
+function deriveViewerUrl(block) {
+  if (block.origin === "external") return null;
+  return `/files/f/${block.fileId}`;
+}
+
+// src/react/cn.ts
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(inputs.filter(Boolean).join(" "));
+}
+
+// src/files/media/video-date.ts
+var COMPACT_VIDEO_DATE = new Intl.DateTimeFormat("en-US", {
+  month: "2-digit",
+  day: "2-digit",
+  year: "2-digit",
+  timeZone: "UTC"
+});
+var FULL_VIDEO_DATE = new Intl.DateTimeFormat("en-US", {
+  month: "long",
+  day: "numeric",
+  year: "numeric",
+  timeZone: "UTC"
+});
+function parseVideoDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function formatVideoPublishDate(value) {
+  const date = parseVideoDate(value);
+  return date ? COMPACT_VIDEO_DATE.format(date) : "No Date";
+}
+function formatVideoPublishDateTitle(value) {
+  const date = parseVideoDate(value);
+  return date ? `Published ${FULL_VIDEO_DATE.format(date)}` : "Publish date unavailable";
+}
+var VIDEO_DATE_KEYS = [
+  "published_at",
+  "publishedAt",
+  "publish_date",
+  "publishDate",
+  "uploadDate",
+  "datePublished"
+];
+var VIDEO_METADATA_CONTAINERS = [
+  "video_metadata",
+  "schema_org",
+  "metadata"
+];
+function videoPublishDateFromMetadata(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  for (const key of VIDEO_DATE_KEYS) {
+    const candidate = record[key];
+    if (typeof candidate === "string" && parseVideoDate(candidate)) {
+      return candidate;
+    }
+  }
+  for (const key of VIDEO_METADATA_CONTAINERS) {
+    const nested = videoPublishDateFromMetadata(record[key]);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+// src/files/blocks/video/VideoPublishDate.tsx
+import { jsx } from "react/jsx-runtime";
+function VideoPublishDate({
+  publishedAt,
+  className
+}) {
+  const dateTime = publishedAt && !Number.isNaN(new Date(publishedAt).getTime()) ? publishedAt : void 0;
+  const content = formatVideoPublishDate(publishedAt);
+  const sharedProps = {
+    className: cn(
+      "shrink-0 whitespace-nowrap text-[10px] tabular-nums text-muted-foreground",
+      className
+    ),
+    title: formatVideoPublishDateTitle(publishedAt),
+    "aria-label": formatVideoPublishDateTitle(publishedAt)
+  };
+  return dateTime ? /* @__PURE__ */ jsx("time", { ...sharedProps, dateTime, children: content }) : /* @__PURE__ */ jsx("span", { ...sharedProps, children: content });
+}
+
+// src/files/handler/errors.ts
+var FileHandlerError = class extends Error {
+  code;
+  fileId;
+  cause;
+  constructor(code, message, opts) {
+    super(message);
+    this.name = "FileHandlerError";
+    this.code = code;
+    this.fileId = opts?.fileId;
+    this.cause = opts?.cause;
+  }
+};
+var FileAccessDeniedError = class extends FileHandlerError {
+  constructor(message = "This file isn't available to you.", opts) {
+    super("access_denied", message, opts);
+    this.name = "FileAccessDeniedError";
+  }
+};
+var FileNotFoundError = class extends FileHandlerError {
+  // A 404 from the file server. It proves the server could not retrieve the
+  // file — NOT that the file was deleted (that is `FileDeletedError`, which
+  // has a `deleted_at` to point at) and not that it never existed.
+  constructor(message = "We couldn't retrieve this file.", opts) {
+    super("not_found", message, opts);
+    this.name = "FileNotFoundError";
+  }
+};
+var FileDeletedError = class extends FileHandlerError {
+  constructor(message = "File is in trash", opts) {
+    super("deleted", message, opts);
+    this.name = "FileDeletedError";
+  }
+};
+var ShareLinkInvalidError = class extends FileHandlerError {
+  constructor(message = "Share link is invalid, expired, or revoked") {
+    super("share_link_invalid", message);
+    this.name = "ShareLinkInvalidError";
+  }
+};
+var ExternalFetchError = class extends FileHandlerError {
+  constructor(message = "Failed to fetch external URL", opts) {
+    super("external_fetch_failed", message, opts);
+    this.name = "ExternalFetchError";
+  }
+};
+var FileUploadError = class extends FileHandlerError {
+  constructor(message, opts) {
+    super("upload_failed", message, opts);
+    this.name = "FileUploadError";
+  }
+};
+var UploadCancelledError = class extends FileHandlerError {
+  constructor(message = "Upload cancelled \u2014 no workspace was selected.") {
+    super("upload_cancelled", message);
+    this.name = "UploadCancelledError";
+  }
+};
+function isUploadCancelledError(error) {
+  return error instanceof Error && error.name === "UploadCancelledError";
+}
+
+// src/files/utils/folder-conventions.ts
+var CloudFolders = {
+  // ── Visible / user-managed ────────────────────────────────────────────
+  /** Top-level "Images" drawer. */
+  IMAGES: "Images",
+  /** Images pasted/attached inside a chat. */
+  IMAGES_CHAT: "Images/Chat",
+  /** Screenshots dragged or pasted into the app. */
+  IMAGES_SCREENSHOTS: "Images/Screenshots",
+  /** User avatars / profile images. */
+  IMAGES_AVATARS: "Images/Avatars",
+  /** Images generated by AI tools. */
+  IMAGES_GENERATED: "Images/Generated",
+  /** Screenshots and images flattened with user-authored markup. */
+  IMAGES_ANNOTATED: "Images/Annotated",
+  /** Top-level "Audio" drawer. */
+  AUDIO: "Audio",
+  /** User-initiated audio recordings (voice-to-text, voice pad, etc.). */
+  AUDIO_RECORDINGS: "Audio/Recordings",
+  /** Podcast asset uploads. */
+  AUDIO_PODCASTS: "Audio/Podcasts",
+  /** Top-level "Captures" drawer — everything the in-browser media-capture
+   *  system saves (features/media-capture). User-produced, so visible. */
+  CAPTURES: "Captures",
+  /** Photos taken with the in-app camera (Capture Studio / device fallback). */
+  CAPTURES_PHOTOS: "Captures/Photos",
+  /** Videos recorded with the in-app camera (media-capture Phase 7). */
+  CAPTURES_VIDEOS: "Captures/Videos",
+  /** Audio recorded through the Capture Studio (media-capture Phase 7). */
+  CAPTURES_AUDIO: "Captures/Audio",
+  /** Product-capture staging (features/product-capture) — per-item folders of
+   *  photos/videos/voice notes shot ahead of listing creation. Org-namespaced
+   *  via `folderForProductCaptureItem` (same server one-path-one-org rule as
+   *  Captures). User-produced, so visible. */
+  PRODUCT_CAPTURES: "Product Captures",
+  /** Commerce intake (W4 capture app): per-asset media filed under
+   *  `Commerce Intake/<orgId>/<batchId>/<asset-leaf>` via
+   *  `folderForIntakeAsset` (same server one-path-one-org rule as Captures).
+   *  User-produced, so visible. */
+  COMMERCE_INTAKE: "Commerce Intake",
+  /**
+   * Static app assets (sounds, hero images, model-card thumbnails, demo
+   * data) owned by an admin service account and rendered globally.
+   * Always public — CDN URL is the goal. Source of truth for the
+   * static-asset migration (see scripts/migrate-public-assets-to-cdn.ts).
+   */
+  APP_ASSETS: "App Assets",
+  /** Top-level documents (PDF, DOCX, etc.). */
+  DOCUMENTS: "Documents",
+  /** PDF-specific drawer. */
+  DOCUMENTS_PDFS: "Documents/PDFs",
+  /** Top-level code files (scripts, snippets). */
+  CODE: "Code",
+  /** Code saved via the code-editor window. */
+  CODE_EDITOR: "Code/Editor",
+  /** Generic AI-generated outputs. */
+  GENERATED: "Generated",
+  /** Files attached to agent apps, keyed by app id at runtime. */
+  AGENT_APPS: "Agent Apps",
+  /** Files attached to tasks, keyed by task id at runtime. */
+  TASK_ATTACHMENTS: "Task Attachments",
+  /** Files attached to War Room tiles, keyed by tile id at runtime. */
+  WAR_ROOM: "War Room",
+  /** Files dropped into a chat composer (pre-send or history). */
+  CHAT_ATTACHMENTS: "Chat Attachments",
+  /** Slack-imported files. */
+  SLACK_IMPORTS: "Slack Imports",
+  /** Web-scrape captures (HTML snapshots, exported markdown). */
+  SCRAPED_CONTENT: "Scraped Content",
+  // ── Shared assets / org-scoped public surfaces ─────────────────────────
+  /**
+   * Org-scoped shared assets — logos, hero images, anything an
+   * organization renders on a public surface. Keyed by org id at
+   * runtime (e.g. `Shared Assets/orgs/<org-id>`). Always public —
+   * the CDN URL is the rendering target.
+   */
+  SHARED_ASSETS_ORGS: "Shared Assets/orgs",
+  /** Public screenshot attachments submitted through the feedback window. */
+  FEEDBACK_IMAGES: "Shared Assets/feedback-images",
+  /**
+   * OG / social-preview covers for HTML pages the user publishes.
+   * Lives under Shared Assets so all org/public-surface previews
+   * share one CDN-backed bucket.
+   */
+  HTML_PAGES_OG: "Shared Assets/html-pages",
+  // ── App-asset subfolders ───────────────────────────────────────────────
+  /**
+   * Favicons rendered by prompt-app / agent-app standalone pages.
+   * Always public — favicon requests are anonymous.
+   */
+  PROMPT_APPS_FAVICONS: "App Assets/prompt-apps/favicons",
+  /**
+   * Per-block assets attached to agent blocks (icons, illustrations,
+   * inline media). Keyed by block id at runtime via
+   * `folderForAgentBlock(blockId)`.
+   */
+  AGENT_BLOCKS: "Agent Apps/blocks",
+  // ── Canvas / image-editor ──────────────────────────────────────────────
+  /**
+   * Cover images rendered on canvas social/share surfaces. Public so
+   * the share-card OG image is a stable CDN URL.
+   */
+  CANVAS_COVERS: "Images/Canvas/Covers",
+  /**
+   * Source images the user is editing in the image studio. Private —
+   * these are the user's working files, NOT public render targets.
+   * Outputs that the user explicitly publishes land elsewhere.
+   */
+  IMAGES_EDITED_SOURCES: "Images/Edited/Sources",
+  // ── Hidden / ephemeral ─────────────────────────────────────────────────
+  // All hidden roots live under ".matrx-tmp/" so the tree has a single
+  // ignorable folder rather than many. Callers that use these MUST delete
+  // the file when done.
+  /** Root for all ephemeral cloud-files work. Hidden in the tree. */
+  TMP: ".matrx-tmp",
+  /** Short-lived audio files staged for URL-based transcription. */
+  TMP_TRANSCRIPTS: ".matrx-tmp/transcripts",
+  /** Upload-in-progress staging (future use). */
+  TMP_UPLOADS: ".matrx-tmp/uploads",
+  // ── System / infrastructure ────────────────────────────────────────────
+  // Owned and populated by the Python backend (not the user). These rows
+  // exist in `cld_files` / `cld_folders` so they have asset IDs, but they
+  // must NEVER appear in the user-facing tree.
+  //
+  // The Phase 1b/1c "SOCIAL_BASELINE" backfill (2026-05-16) created
+  // `cld_files` rows under `system-files/variants/<file_id>/<og|thumb|tiny|page1_url>.jpg`
+  // — three to four rows per source file. The cascade was cleaned up
+  // server-side on 2026-05-16 (migrations 012/013); the tree RPCs now
+  // exclude `parent_file_id IS NOT NULL` and `file_path LIKE
+  // 'system-files/%'`. The FE keeps `isSystemPath` as a defensive guard
+  // at every tree boundary (loadUserFileTree, loadFolderContents,
+  // realtime middleware). See common-docs systems/files/file-service/WIRE_CONTRACT.md.
+  /** Root for backend-owned infrastructure files (variants, posters, etc.). */
+  SYSTEM_FILES: "system-files",
+  /** SOCIAL_BASELINE variant storage: og.jpg / thumb.jpg / tiny.jpg / page1_url.jpg. */
+  SYSTEM_VARIANTS: "system-files/variants",
+  /**
+   * Backend "generations" registry root — every AI generation (image,
+   * video, audio/TTS) the server materializes lands under
+   * `generations/<images|video|audio>/...`. Backend-owned; mirrors the
+   * server's `is_system_path()` (which treats `system-files` AND
+   * `generations` as system). Never shown in the user tree.
+   */
+  GENERATIONS: "generations",
+  /**
+   * Recorded audio captured by the Transcripts / voice features. As of
+   * 2026-06-14 the backend relocates every `origin: "transcripts"` upload
+   * here, UNDER the hidden `system-files/` root — one
+   * `recording_<iso>_<rand>.webm` per capture (80+ for an active user).
+   * Because it's under `system-files/`, `isSystemPath` already hides it
+   * from the tree, folder views, AND Recents — no separate predicate
+   * needed. Managed exclusively via the Transcripts UI (by `cld_files.id`).
+   * See docs/files/transcript-recordings-system-relocation.md.
+   */
+  TRANSCRIPT_RECORDINGS: "system-files/transcripts/Recordings",
+  /**
+   * LEGACY user-namespace location for transcript recordings, before the
+   * 2026-06-14 backend relocation to `system-files/transcripts/...`. Kept
+   * ONLY as a defensive Recents guard: the backend relocates every
+   * `origin: "transcripts"` upload, but the presigned/TUS (chunked + large
+   * file) relocation path was genuinely missing and is committed but NOT yet
+   * in prod as of 2026-06-15.
+   *
+   * DO NOT DROP THIS GUARD until that backend fix has DEPLOYED to prod —
+   * dropping it earlier would let a chunked/large recording slip through
+   * unhidden. Sequence: backend deploys → then remove this constant from
+   * `isSystemManagedContentPath` (and delete it). See the FE-response /
+   * "open items" in docs/files/transcript-recordings-system-relocation.md.
+   */
+  TRANSCRIPT_RECORDINGS_LEGACY: "Transcripts/Recordings",
+  // ── System-managed user content (browsable, but NOT in Recents) ─────────
+  // Lives under USER roots (so it stays visible in the Files browser), but
+  // is machine-named, high-volume, and background-produced — so it must
+  // never pollute the Recents stream (your "entire reality" on open).
+  /**
+   * Per-tool generated image variants — `tool-images/<id>/v/<name>.jpg`,
+   * multiple sizes per source. Machine-produced output, excluded from
+   * Recents (see `isSystemManagedContentPath`).
+   */
+  TOOL_IMAGES: "tool-images",
+  /**
+   * FastFire voice-drill recordings — full-session + per-card response clips.
+   * Live under the hidden `system-files/fastfire/...` root (same class as
+   * transcript recordings). Managed via Education / FastFire UI only.
+   */
+  SYSTEM_FASTFIRE: "system-files/fastfire",
+  SYSTEM_FASTFIRE_SESSIONS: "system-files/fastfire/sessions",
+  SYSTEM_FASTFIRE_RESPONSES: "system-files/fastfire/responses",
+  /**
+   * Spoken Practice (oral exam / interview / debate) recordings — full-session
+   * clips + per-prompt spoken-answer clips. Same hidden `system-files/` class as
+   * FastFire (so `isSystemPath` keeps them out of the Files browser + Recents).
+   */
+  SYSTEM_SPOKEN_PRACTICE: "system-files/spoken-practice",
+  SYSTEM_SPOKEN_PRACTICE_SESSIONS: "system-files/spoken-practice/sessions",
+  SYSTEM_SPOKEN_PRACTICE_RESPONSES: "system-files/spoken-practice/responses",
+  /**
+   * Handwritten / image-answer grading — photos of worked problems a learner
+   * submits to the vision grader (assessment written-item photo answers +
+   * the standalone "Grade my handwritten work" surface). Same hidden
+   * `system-files/` class (kept out of the Files browser + Recents).
+   */
+  SYSTEM_IMAGE_GRADE: "system-files/image-grade",
+  SYSTEM_IMAGE_GRADE_RESPONSES: "system-files/image-grade/responses",
+  /**
+   * LEGACY user-namespace FastFire paths (pre-2026-07 relocation). Kept as a
+   * defensive tree + Recents guard until every row is backfilled under
+   * `system-files/fastfire/`.
+   */
+  FASTFIRE_SESSIONS: "FastFire/sessions",
+  FASTFIRE_RESPONSES: "FastFire/responses"
+};
+function folderForTask(taskId) {
+  return `${CloudFolders.TASK_ATTACHMENTS}/${taskId}`;
+}
+function folderForWarRoomThread(threadId) {
+  return `${CloudFolders.WAR_ROOM}/${threadId}`;
+}
+function folderForConversation(conversationId) {
+  return `${CloudFolders.CHAT_ATTACHMENTS}/${conversationId}`;
+}
+function folderForAgentApp(appId) {
+  return `${CloudFolders.AGENT_APPS}/${appId}`;
+}
+function folderForPodcast(podcastId) {
+  return `${CloudFolders.AUDIO_PODCASTS}/${podcastId}`;
+}
+function folderForOrg(orgId) {
+  return `${CloudFolders.SHARED_ASSETS_ORGS}/${orgId}`;
+}
+function folderForAgentBlock(blockId) {
+  return `${CloudFolders.AGENT_BLOCKS}/${blockId}`;
+}
+function folderForCaptures(kind, orgId) {
+  const leaf = kind === "photo" ? "Photos" : kind === "video" ? "Videos" : "Audio";
+  const trimmed = typeof orgId === "string" ? orgId.trim() : "";
+  if (trimmed) {
+    return `${CloudFolders.CAPTURES}/${trimmed}/${leaf}`;
+  }
+  return kind === "photo" ? CloudFolders.CAPTURES_PHOTOS : kind === "video" ? CloudFolders.CAPTURES_VIDEOS : CloudFolders.CAPTURES_AUDIO;
+}
+function folderForProductCaptureItem(orgId, leaf) {
+  const safe = leaf.replace(/[^A-Za-z0-9._@-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${CloudFolders.PRODUCT_CAPTURES}/${orgId.trim()}/${safe}`;
+}
+function folderForIntakeAsset(orgId, batchId, leaf) {
+  const safe = leaf.replace(/[^A-Za-z0-9._@-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${CloudFolders.COMMERCE_INTAKE}/${orgId.trim()}/${batchId.trim()}/${safe || batchId.trim()}`;
+}
+function isHiddenFolder(folderPath) {
+  return folderPath === CloudFolders.TMP || folderPath.startsWith(".matrx-tmp/");
+}
+function isSystemPath(path) {
+  if (!path) return false;
+  return path === CloudFolders.SYSTEM_FILES || path.startsWith(`${CloudFolders.SYSTEM_FILES}/`) || path === CloudFolders.GENERATIONS || path.startsWith(`${CloudFolders.GENERATIONS}/`) || path === CloudFolders.TMP || path.startsWith(`${CloudFolders.TMP}/`);
+}
+function isConventionalFolder(folderPath) {
+  const all = Object.values(CloudFolders);
+  return all.includes(folderPath);
+}
+var CloudFolderDescriptions = {
+  [CloudFolders.IMAGES]: "All your images, organized.",
+  [CloudFolders.IMAGES_CHAT]: "Images shared in chat.",
+  [CloudFolders.IMAGES_SCREENSHOTS]: "Screenshots you pasted or dragged in.",
+  [CloudFolders.IMAGES_AVATARS]: "Profile pictures and avatars.",
+  [CloudFolders.IMAGES_GENERATED]: "AI-generated images.",
+  [CloudFolders.AUDIO]: "Audio files.",
+  [CloudFolders.AUDIO_RECORDINGS]: "Voice recordings.",
+  [CloudFolders.AUDIO_PODCASTS]: "Podcast assets.",
+  [CloudFolders.CAPTURES]: "Photos, videos, and audio captured in the app.",
+  [CloudFolders.CAPTURES_PHOTOS]: "Photos taken with the in-app camera.",
+  [CloudFolders.CAPTURES_VIDEOS]: "Videos recorded with the in-app camera.",
+  [CloudFolders.CAPTURES_AUDIO]: "Audio recorded in the Capture Studio.",
+  [CloudFolders.APP_ASSETS]: "Static app assets shared across the platform.",
+  [CloudFolders.DOCUMENTS]: "Documents and reports.",
+  [CloudFolders.DOCUMENTS_PDFS]: "PDFs.",
+  [CloudFolders.CODE]: "Code files.",
+  [CloudFolders.GENERATED]: "Files produced by AI tools.",
+  [CloudFolders.AGENT_APPS]: "Assets attached to your agent apps.",
+  [CloudFolders.TASK_ATTACHMENTS]: "Files attached to tasks.",
+  [CloudFolders.CHAT_ATTACHMENTS]: "Files shared in conversations.",
+  [CloudFolders.SLACK_IMPORTS]: "Files imported from Slack.",
+  [CloudFolders.SCRAPED_CONTENT]: "Captures from the web scraper.",
+  [CloudFolders.SHARED_ASSETS_ORGS]: "Organization-scoped shared assets.",
+  [CloudFolders.HTML_PAGES_OG]: "OG covers for HTML pages.",
+  [CloudFolders.PROMPT_APPS_FAVICONS]: "Favicons for prompt-app pages.",
+  [CloudFolders.AGENT_BLOCKS]: "Per-block agent app assets.",
+  [CloudFolders.CANVAS_COVERS]: "Canvas social cover images.",
+  [CloudFolders.IMAGES_EDITED_SOURCES]: "Source images for the image studio.",
+  [CloudFolders.TMP]: "Internal temporary workspace (hidden)."
+};
+var DEFAULT_VISIBILITY_RULES = [
+  // Most-specific rules first — longest-prefix wins.
+  { prefix: "Shared Assets/feedback-images", visibility: "public" },
+  { prefix: CloudFolders.SHARED_ASSETS_ORGS, visibility: "public" },
+  { prefix: CloudFolders.HTML_PAGES_OG, visibility: "public" },
+  { prefix: CloudFolders.PROMPT_APPS_FAVICONS, visibility: "public" },
+  { prefix: CloudFolders.AGENT_BLOCKS, visibility: "public" },
+  { prefix: CloudFolders.CANVAS_COVERS, visibility: "public" },
+  { prefix: CloudFolders.APP_ASSETS, visibility: "public" },
+  { prefix: CloudFolders.IMAGES_AVATARS, visibility: "public" },
+  { prefix: CloudFolders.AUDIO_PODCASTS, visibility: "public" },
+  { prefix: CloudFolders.AGENT_APPS, visibility: "public" },
+  { prefix: "Shared Assets", visibility: "public" },
+  // IMAGES_EDITED_SOURCES is private — these are the user's working
+  // source files for the image studio, not public render targets.
+  // Captures are the user's own camera/mic output — never public render
+  // targets. Explicit rule (not just the fallback) so the intent is recorded.
+  { prefix: CloudFolders.CAPTURES, visibility: "personal" },
+  { prefix: CloudFolders.IMAGES_EDITED_SOURCES, visibility: "personal" },
+  { prefix: CloudFolders.IMAGES_GENERATED, visibility: "personal" },
+  { prefix: CloudFolders.CHAT_ATTACHMENTS, visibility: "personal" },
+  { prefix: CloudFolders.TASK_ATTACHMENTS, visibility: "personal" },
+  { prefix: CloudFolders.WAR_ROOM, visibility: "personal" },
+  { prefix: CloudFolders.SLACK_IMPORTS, visibility: "personal" },
+  { prefix: CloudFolders.SCRAPED_CONTENT, visibility: "personal" },
+  { prefix: "Private Assets", visibility: "personal" },
+  { prefix: CloudFolders.TMP, visibility: "personal" }
+];
+function resolveDefaultVisibility(folderPath) {
+  const normalized = folderPath.replace(/^\/+|\/+$/g, "");
+  let best = null;
+  for (const rule of DEFAULT_VISIBILITY_RULES) {
+    if (normalized === rule.prefix || normalized.startsWith(`${rule.prefix}/`)) {
+      if (!best || rule.prefix.length > best.prefix.length) {
+        best = rule;
+      }
+    }
+  }
+  return best?.visibility ?? "personal";
+}
+
+// src/files/handler/utils/upload-folder-path.ts
+var TOP_LEVEL_FOLDERS = {
+  userContent: "My Files",
+  images: CloudFolders.IMAGES,
+  Images: CloudFolders.IMAGES,
+  audio: CloudFolders.AUDIO,
+  Audio: CloudFolders.AUDIO,
+  "audio-recordings": CloudFolders.AUDIO_RECORDINGS,
+  documents: CloudFolders.DOCUMENTS,
+  Documents: CloudFolders.DOCUMENTS,
+  code: CloudFolders.CODE,
+  Code: CloudFolders.CODE,
+  "any-file": "Uploads",
+  attachments: CloudFolders.CHAT_ATTACHMENTS
+};
+function composeUploadFolderPath(root = "Uploads", path) {
+  const top = (TOP_LEVEL_FOLDERS[root] ?? root).replace(/^\/+|\/+$/g, "");
+  const sub = (path ?? "").replace(/^\/+|\/+$/g, "");
+  return sub ? `${top}/${sub}` : top;
+}
+
+// src/files/media/object-url-registry.ts
+var MAX_LIVE = 256;
+var live = /* @__PURE__ */ new Map();
+function createTrackedObjectUrl(blob) {
+  const url = URL.createObjectURL(blob);
+  live.set(url, true);
+  while (live.size > MAX_LIVE) {
+    const oldest = live.keys().next().value;
+    if (!oldest) break;
+    live.delete(oldest);
+    try {
+      URL.revokeObjectURL(oldest);
+    } catch {
+    }
+  }
+  return url;
+}
+function revokeTrackedObjectUrl(url) {
+  if (!url || !live.has(url)) return;
+  live.delete(url);
+  try {
+    URL.revokeObjectURL(url);
+  } catch {
+  }
+}
+export {
+  CloudFolderDescriptions,
+  CloudFolders,
+  ExternalFetchError,
+  FileAccessDeniedError,
+  FileDeletedError,
+  FileHandlerError,
+  FileNotFoundError,
+  FileUploadError,
+  ShareLinkInvalidError,
+  UploadCancelledError,
+  VideoPublishDate,
+  blockFromMediaRef,
+  composeUploadFolderPath,
+  createTrackedObjectUrl,
+  deriveViewerUrl,
+  extractFileIdFromUrl,
+  fileIdToMediaRef,
+  folderForAgentApp,
+  folderForAgentBlock,
+  folderForCaptures,
+  folderForConversation,
+  folderForIntakeAsset,
+  folderForOrg,
+  folderForPodcast,
+  folderForProductCaptureItem,
+  folderForTask,
+  folderForWarRoomThread,
+  formatVideoPublishDate,
+  formatVideoPublishDateTitle,
+  fromCxAudioPart,
+  fromCxMediaPart,
+  fromCxVideoPart,
+  fromImageOutputData,
+  fromMediaBlock,
+  fromPartialImageData,
+  fromRenderBlock,
+  imageBlockFromMediaRef,
+  isAudioBlock,
+  isConventionalFolder,
+  isDocumentBlock,
+  isExternalImageBlock,
+  isExternalMediaBlock,
+  isHiddenFolder,
+  isImageBlock,
+  isMatrxImageBlock,
+  isMatrxMediaBlock,
+  isMediaBlockData,
+  isSystemPath,
+  isUnifiedImageBlock,
+  isUnifiedMediaBlock,
+  isUploadCancelledError,
+  isVideoBlock,
+  isYouTubeBlock,
+  parseFilenameFromUrl,
+  parseGenerationMetadata,
+  resolveDefaultVisibility,
+  revokeTrackedObjectUrl,
+  toCxMediaPart,
+  toVisibility,
+  urlToMediaRef,
+  videoBlockFromMediaRef,
+  videoPublishDateFromMetadata
+};
+//# sourceMappingURL=files.js.map