@company-semantics/contracts 97.0.0 → 99.0.0

package/src/ingestion/__tests__/registry.test.ts

@@ -1,12 +1,6 @@
 import { describe, it, expect } from "vitest";
-import {
-  INGESTION_FORMATS,
-  byMime,
-  acceptExtensions,
-  humanLabels,
-  INGEST_ACCEPT,
-  SUPPORTED_LABEL,
-} from "../registry";
+import { INGESTION_FORMATS, byMime, acceptExtensions } from "../registry";
+import { FORMAT_CLASSES } from "../types";
 
 describe("ingestion registry", () => {
   it("has a unique MIME per entry", () => {
@@ -28,17 +22,23 @@ describe("ingestion registry", () => {
     expect(byMime("application/x-unknown")).toBeUndefined();
   });
 
-  it("derives INGEST_ACCEPT from every extension in registry order", () => {
-    expect(INGEST_ACCEPT).toBe(acceptExtensions().join(","));
-    expect(INGEST_ACCEPT).toBe(
-      ".txt,.md,.html,.htm,.csv,.rtf,.docx,.doc,.pptx,.ppt,.xlsx,.xls,.odt,.ods,.odp,.epub,.pdf,.png,.jpg,.jpeg,.webp,.gif,.heic,.svg,.drawio,.mp3,.m4a,.wav,.aac,.mp4,.m4v,.mov",
-    );
+  it("every format carries a known class", () => {
+    for (const entry of INGESTION_FORMATS)
+      expect(FORMAT_CLASSES).toContain(entry.class);
   });
 
-  it("derives SUPPORTED_LABEL from the unique group labels", () => {
-    expect(SUPPORTED_LABEL).toBe(`Supported: ${humanLabels().join(", ")}`);
-    expect(SUPPORTED_LABEL).toBe(
-      "Supported: Text, Markdown, HTML, CSV, RTF, Word, PowerPoint, Excel, OpenDocument, EPUB, PDF, Image, Diagram, Audio, Video",
-    );
+  it("classes documents the way discovery does", () => {
+    expect(byMime("text/csv")!.class).toBe("sheets");
+    expect(byMime("application/epub+zip")!.class).toBe("docs");
+    expect(byMime("application/vnd.ms-powerpoint")!.class).toBe("slides");
+    expect(byMime("application/pdf")!.class).toBe("pdf");
+    expect(byMime("text/markdown")!.class).toBe("text");
+    expect(byMime("image/svg+xml")!.class).toBe("diagram");
+  });
+
+  it("admits HEIF and no longer lists drawio", () => {
+    expect(byMime("image/heif")?.family).toBe("image");
+    expect(byMime("application/vnd.jgraph.mxfile")).toBeUndefined();
+    expect(acceptExtensions()).not.toContain(".drawio");
   });
 });

package/src/ingestion/__tests__/surfaces.test.ts

@@ -1,64 +1,92 @@
 import { describe, it, expect } from "vitest";
-import { INGESTION_FORMATS, byMime } from "../registry";
+import { byMime } from "../registry";
+import { TREATMENTS } from "../types";
+import type { IngestionSurfaceKey } from "../types";
 import {
   INGESTION_SURFACES,
+  familiesOf,
+  treatmentFor,
   formatsFor,
-  surfaceAdmits,
   acceptFor,
-  supportedLabelFor,
   maxBytesFor,
 } from "../surfaces";
 
 describe("ingestion surfaces", () => {
-  it("every registry entry carries a family", () => {
-    for (const entry of INGESTION_FORMATS) {
-      expect(entry.family).toMatch(
-        /^(text|document|image|diagram|audio|video)$/,
-      );
+  it("every surface declares treatments only for real families and a positive ceiling", () => {
+    for (const key of Object.keys(
+      INGESTION_SURFACES,
+    ) as IngestionSurfaceKey[]) {
+      const s = INGESTION_SURFACES[key];
+      expect(s.key).toBe(key);
+      expect(s.maxBytes).toBeGreaterThan(0);
+      for (const [family, treatment] of Object.entries(s.treatments)) {
+        expect([
+          "text",
+          "document",
+          "image",
+          "diagram",
+          "audio",
+          "video",
+        ]).toContain(family);
+        expect(TREATMENTS).toContain(treatment);
+      }
+      expect(familiesOf(key).length).toBeGreaterThan(0);
     }
   });
 
-  it("every surface admits at least one format, in registry order", () => {
-    for (const key of Object.keys(INGESTION_SURFACES) as Array<
-      keyof typeof INGESTION_SURFACES
-    >) {
-      const formats = formatsFor(key);
-      expect(formats.length).toBeGreaterThan(0);
-      const order = formats.map((f) => INGESTION_FORMATS.indexOf(f));
-      expect(order).toEqual([...order].sort((a, b) => a - b));
-    }
+  it("company-md turns text and documents into text and refuses images and media", () => {
+    expect(treatmentFor("company-md", byMime("application/pdf")!)).toBe("text");
+    expect(treatmentFor("company-md", byMime("text/csv")!)).toBe("text");
+    expect(treatmentFor("company-md", byMime("image/png")!)).toBeNull();
+    expect(treatmentFor("company-md", byMime("audio/mpeg")!)).toBeNull();
+    expect(maxBytesFor("company-md")).toBe(50_000_000);
   });
 
-  it("company-md admits text and documents only", () => {
-    expect(surfaceAdmits("company-md", byMime("application/pdf")!)).toBe(true);
-    expect(surfaceAdmits("company-md", byMime("text/csv")!)).toBe(true);
-    expect(surfaceAdmits("company-md", byMime("image/png")!)).toBe(false);
-    expect(surfaceAdmits("company-md", byMime("audio/mpeg")!)).toBe(false);
-    expect(acceptFor("company-md")).toBe(
-      ".txt,.md,.html,.htm,.csv,.rtf,.docx,.doc,.pptx,.ppt,.xlsx,.xls,.odt,.ods,.odp,.epub,.pdf",
-    );
-    expect(supportedLabelFor("company-md")).toBe(
-      "Supported: Text, Markdown, HTML, CSV, RTF, Word, PowerPoint, Excel, OpenDocument, EPUB, PDF",
+  it("org-chart hands documents, images and diagrams to vision", () => {
+    expect(treatmentFor("org-chart", byMime("application/pdf")!)).toBe(
+      "vision",
     );
+    expect(treatmentFor("org-chart", byMime("image/heic")!)).toBe("vision");
+    expect(treatmentFor("org-chart", byMime("image/svg+xml")!)).toBe("vision");
+    expect(treatmentFor("org-chart", byMime("video/mp4")!)).toBeNull();
+    expect(maxBytesFor("org-chart")).toBe(10 * 1024 * 1024);
+  });
+
+  it("chat admits text, documents and images but never media", () => {
+    expect(treatmentFor("chat", byMime("text/markdown")!)).toBe("text");
+    expect(treatmentFor("chat", byMime("application/pdf")!)).toBe("vision");
+    expect(treatmentFor("chat", byMime("image/png")!)).toBe("vision");
+    expect(treatmentFor("chat", byMime("audio/mpeg")!)).toBeNull();
+    expect(maxBytesFor("chat")).toBe(5 * 1024 * 1024);
+  });
+
+  it("chat caps files per turn and only chat declares a per-turn count", () => {
+    expect(INGESTION_SURFACES.chat.maxFilesPerTurn).toBe(8);
+    for (const key of ["company-md", "org-chart", "profile-image"] as const) {
+      expect(INGESTION_SURFACES[key].maxFilesPerTurn).toBeUndefined();
+    }
   });
 
-  it("org-chart adds images and diagrams but never media", () => {
-    expect(surfaceAdmits("org-chart", byMime("image/heic")!)).toBe(true);
-    expect(surfaceAdmits("org-chart", byMime("image/svg+xml")!)).toBe(true);
-    expect(surfaceAdmits("org-chart", byMime("video/mp4")!)).toBe(false);
-    expect(acceptFor("org-chart")).toBe(
-      ".txt,.md,.html,.htm,.csv,.rtf,.docx,.doc,.pptx,.ppt,.xlsx,.xls,.odt,.ods,.odp,.epub,.pdf,.png,.jpg,.jpeg,.webp,.gif,.heic,.svg,.drawio",
+  it("profile-image stores images only", () => {
+    expect(familiesOf("profile-image")).toEqual(["image"]);
+    expect(treatmentFor("profile-image", byMime("image/heif")!)).toBe("store");
+    expect(acceptFor("profile-image")).toBe(
+      ".png,image/png,.jpg,.jpeg,image/jpeg,.webp,image/webp,.gif,image/gif,.heic,image/heic,.heif,image/heif",
     );
+    expect(maxBytesFor("profile-image")).toBe(5 * 1024 * 1024);
   });
 
-  it("derives the byte ceiling from the admitted formats and the surface cap", () => {
-    expect(maxBytesFor("company-md")).toBe(50_000_000);
-    expect(maxBytesFor("org-chart")).toBe(10 * 1024 * 1024);
-    for (const key of ["company-md", "org-chart"] as const) {
-      const ceiling = INGESTION_SURFACES[key].maxBytes ?? Infinity;
-      expect(maxBytesFor(key)).toBeLessThanOrEqual(ceiling);
+  it("acceptFor lists every admitted extension and MIME, in registry order", () => {
+    for (const key of Object.keys(
+      INGESTION_SURFACES,
+    ) as IngestionSurfaceKey[]) {
+      const tokens = acceptFor(key).split(",");
+      for (const f of formatsFor(key)) {
+        expect(tokens).toContain(f.mime);
+        for (const ext of f.extensions) expect(tokens).toContain(ext);
+      }
       expect(maxBytesFor(key)).toBeLessThanOrEqual(
-        Math.max(...formatsFor(key).map((f) => f.maxBytes)),
+        INGESTION_SURFACES[key].maxBytes,
       );
     }
   });

package/src/ingestion/index.ts

@@ -13,22 +13,40 @@ export type {
   IngestionFormat,
   IngestionSurface,
   IngestionSurfaceKey,
+  FormatClass,
+  InventoryClass,
+  Treatment,
+  IngestionProvider,
+  IngestionProviderKey,
+  ProviderNativeFormat,
 } from "./types";
 
+export { FORMAT_CLASSES, TREATMENTS } from "./types";
+
 export {
   INGESTION_FORMATS,
   byMime,
   acceptExtensions,
   humanLabels,
-  INGEST_ACCEPT,
-  SUPPORTED_LABEL,
 } from "./registry";
 
 export {
   INGESTION_SURFACES,
+  familiesOf,
+  treatmentFor,
   formatsFor,
   surfaceAdmits,
   acceptFor,
   supportedLabelFor,
   maxBytesFor,
 } from "./surfaces";
+
+export type { ProviderFormat } from "./providers";
+
+export {
+  INGESTION_PROVIDERS,
+  providerFormatsFor,
+  classOfMime,
+  inventoryClassesFor,
+  labelOfMime,
+} from "./providers";

package/src/ingestion/providers.ts

@@ -0,0 +1,141 @@
+/**
+ * Ingestion Providers
+ *
+ * Provider vocabulary: the native types an external source hands us (exported
+ * to a registry format before ingestion) and its structural container MIMEs.
+ * Discovery's net, the Drive picker filter, inventory classes and display
+ * labels all derive from this plus the surface declarations — no backend or
+ * app module keeps its own Workspace MIME table.
+ */
+import { INGESTION_FORMATS, byMime } from "./registry";
+import { surfaceAdmits } from "./surfaces";
+import {
+  FORMAT_CLASSES,
+  type FormatClass,
+  type IngestionFormat,
+  type IngestionProvider,
+  type IngestionProviderKey,
+  type IngestionSurfaceKey,
+  type InventoryClass,
+  type ProviderNativeFormat,
+} from "./types";
+
+/** Every provider's native types and container MIMEs, keyed by provider. */
+export const INGESTION_PROVIDERS: Readonly<
+  Record<IngestionProviderKey, IngestionProvider>
+> = {
+  "google-drive": {
+    key: "google-drive",
+    nativeFormats: [
+      {
+        mime: "application/vnd.google-apps.document",
+        label: "Google Doc",
+        exportsTo:
+          "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      },
+      {
+        mime: "application/vnd.google-apps.presentation",
+        label: "Google Slides",
+        exportsTo:
+          "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      },
+      {
+        mime: "application/vnd.google-apps.spreadsheet",
+        label: "Google Sheet",
+        exportsTo:
+          "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      },
+    ],
+    containerMimes: {
+      folder: "application/vnd.google-apps.folder",
+      shortcut: "application/vnd.google-apps.shortcut",
+    },
+  },
+};
+
+/** One MIME a provider can hand the pipeline, with the registry format it lands as. */
+export interface ProviderFormat {
+  /** The MIME as the provider lists it (native or a registry MIME). */
+  mime: string;
+  /** True for a provider-native type that is exported before ingestion. */
+  native: boolean;
+  /** The registry format the bytes arrive as (the export target for natives). */
+  format: IngestionFormat;
+  /** Display label: the native label, else the registry label. */
+  label: string;
+}
+
+function exportTarget(native: ProviderNativeFormat): IngestionFormat {
+  const target = byMime(native.exportsTo);
+  if (!target) {
+    throw new Error(
+      `ingestion provider: ${native.mime} exports to ${native.exportsTo}, which is not in INGESTION_FORMATS`,
+    );
+  }
+  return target;
+}
+
+/** Every MIME the provider can hand a surface (natives first, then registry order). */
+export function providerFormatsFor(
+  provider: IngestionProviderKey,
+  surface: IngestionSurfaceKey,
+): ProviderFormat[] {
+  const natives: ProviderFormat[] = INGESTION_PROVIDERS[
+    provider
+  ].nativeFormats.map((native) => ({
+    mime: native.mime,
+    native: true,
+    format: exportTarget(native),
+    label: native.label,
+  }));
+  const downloads: ProviderFormat[] = INGESTION_FORMATS.map((format) => ({
+    mime: format.mime,
+    native: false,
+    format,
+    label: format.label,
+  }));
+  return [...natives, ...downloads].filter((pf) =>
+    surfaceAdmits(surface, pf.format),
+  );
+}
+
+/** The class of a provider-listed MIME; null for containers and unknown types. */
+export function classOfMime(
+  provider: IngestionProviderKey,
+  mime: string,
+): FormatClass | null {
+  const native = INGESTION_PROVIDERS[provider].nativeFormats.find(
+    (n) => n.mime === mime,
+  );
+  if (native) return exportTarget(native).class;
+  return byMime(mime)?.class ?? null;
+}
+
+/**
+ * The inventory classes discovery can record for a provider feeding a surface,
+ * in canonical class order, plus "shortcut". The DB CHECK on
+ * source_inventory_items.mime_class is pinned to this.
+ */
+export function inventoryClassesFor(
+  provider: IngestionProviderKey,
+  surface: IngestionSurfaceKey,
+): InventoryClass[] {
+  const present = new Set(
+    providerFormatsFor(provider, surface).map((pf) => pf.format.class),
+  );
+  return [...FORMAT_CLASSES.filter((c) => present.has(c)), "shortcut"];
+}
+
+/** Display label for a MIME (provider-native first when a provider is given); null if unknown. */
+export function labelOfMime(
+  mime: string,
+  provider?: IngestionProviderKey,
+): string | null {
+  if (provider) {
+    const native = INGESTION_PROVIDERS[provider].nativeFormats.find(
+      (n) => n.mime === mime,
+    );
+    if (native) return native.label;
+  }
+  return byMime(mime)?.label ?? null;
+}

package/src/ingestion/registry.ts

@@ -2,15 +2,18 @@
  * Ingestion Format Registry
  *
  * THE single source of truth for the public document-ingestion accept-set. The
- * backend normalizer joins these entries with its private dispatch table; the
- * app derives its file-input `accept` attribute and supported-formats copy from
- * the helpers below. Neither side re-spells the extension or label list.
+ * backend normalizer joins these entries with its private dispatch table; each
+ * upload surface derives its file-input `accept` attribute and supported-formats
+ * copy from the surface helpers. Neither side re-spells the extension, label or
+ * class list.
  *
  * Invariants:
  * - Entries are ordered text → documents → images/diagrams → audio/video; the
  *   backend's MIME-order test and the derived UI strings depend on this order.
- * - `INGEST_ACCEPT` and `SUPPORTED_LABEL` are DERIVED, never hand-maintained —
- *   adding a format here updates both automatically.
+ * - Every entry declares its `class` (one of `FORMAT_CLASSES`); no consumer
+ *   keeps its own extension → class table.
+ * - `.drawio` is not listed: no normalizer can rasterize a raw `<mxfile>`, so
+ *   admitting it would be a lie. It returns when a rasterizer exists.
  *
  * @see ADR-CONT-075 for design rationale
  */
@@ -22,6 +25,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "text/plain",
     family: "text",
+    class: "text",
     extensions: [".txt"],
     label: "Text",
     maxBytes: 10_000_000,
@@ -29,6 +33,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "text/markdown",
     family: "text",
+    class: "text",
     extensions: [".md"],
     label: "Markdown",
     maxBytes: 10_000_000,
@@ -36,6 +41,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "text/html",
     family: "text",
+    class: "text",
     extensions: [".html", ".htm"],
     label: "HTML",
     maxBytes: 10_000_000,
@@ -43,6 +49,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "text/csv",
     family: "text",
+    class: "sheets",
     extensions: [".csv"],
     label: "CSV",
     maxBytes: 25_000_000,
@@ -50,6 +57,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/rtf",
     family: "document",
+    class: "docs",
     extensions: [".rtf"],
     label: "RTF",
     maxBytes: 25_000_000,
@@ -57,6 +65,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
     family: "document",
+    class: "docs",
     extensions: [".docx"],
     label: "Word",
     maxBytes: 25_000_000,
@@ -64,6 +73,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/msword",
     family: "document",
+    class: "docs",
     extensions: [".doc"],
     label: "Word",
     maxBytes: 25_000_000,
@@ -71,6 +81,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
     family: "document",
+    class: "slides",
     extensions: [".pptx"],
     label: "PowerPoint",
     maxBytes: 50_000_000,
@@ -78,6 +89,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/vnd.ms-powerpoint",
     family: "document",
+    class: "slides",
     extensions: [".ppt"],
     label: "PowerPoint",
     maxBytes: 50_000_000,
@@ -85,6 +97,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
     family: "document",
+    class: "sheets",
     extensions: [".xlsx"],
     label: "Excel",
     maxBytes: 50_000_000,
@@ -92,6 +105,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/vnd.ms-excel",
     family: "document",
+    class: "sheets",
     extensions: [".xls"],
     label: "Excel",
     maxBytes: 50_000_000,
@@ -99,6 +113,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/vnd.oasis.opendocument.text",
     family: "document",
+    class: "docs",
     extensions: [".odt"],
     label: "OpenDocument",
     maxBytes: 25_000_000,
@@ -106,6 +121,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/vnd.oasis.opendocument.spreadsheet",
     family: "document",
+    class: "sheets",
     extensions: [".ods"],
     label: "OpenDocument",
     maxBytes: 50_000_000,
@@ -113,6 +129,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/vnd.oasis.opendocument.presentation",
     family: "document",
+    class: "slides",
     extensions: [".odp"],
     label: "OpenDocument",
     maxBytes: 50_000_000,
@@ -120,6 +137,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/epub+zip",
     family: "document",
+    class: "docs",
     extensions: [".epub"],
     label: "EPUB",
     maxBytes: 25_000_000,
@@ -127,6 +145,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "application/pdf",
     family: "document",
+    class: "pdf",
     extensions: [".pdf"],
     label: "PDF",
     maxBytes: 50_000_000,
@@ -134,6 +153,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "image/png",
     family: "image",
+    class: "image",
     extensions: [".png"],
     label: "Image",
     maxBytes: 25_000_000,
@@ -141,6 +161,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "image/jpeg",
     family: "image",
+    class: "image",
     extensions: [".jpg", ".jpeg"],
     label: "Image",
     maxBytes: 25_000_000,
@@ -148,6 +169,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "image/webp",
     family: "image",
+    class: "image",
     extensions: [".webp"],
     label: "Image",
     maxBytes: 25_000_000,
@@ -155,6 +177,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "image/gif",
     family: "image",
+    class: "image",
     extensions: [".gif"],
     label: "Image",
     maxBytes: 25_000_000,
@@ -162,27 +185,31 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "image/heic",
     family: "image",
+    class: "image",
     extensions: [".heic"],
     label: "Image",
     maxBytes: 25_000_000,
   },
   {
-    mime: "image/svg+xml",
-    family: "diagram",
-    extensions: [".svg"],
-    label: "Diagram",
-    maxBytes: 10_000_000,
+    mime: "image/heif",
+    family: "image",
+    class: "image",
+    extensions: [".heif"],
+    label: "Image",
+    maxBytes: 25_000_000,
   },
   {
-    mime: "application/vnd.jgraph.mxfile",
+    mime: "image/svg+xml",
     family: "diagram",
-    extensions: [".drawio"],
+    class: "diagram",
+    extensions: [".svg"],
     label: "Diagram",
     maxBytes: 10_000_000,
   },
   {
     mime: "audio/mpeg",
     family: "audio",
+    class: "audio",
     extensions: [".mp3"],
     label: "Audio",
     maxBytes: 500_000_000,
@@ -190,6 +217,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "audio/x-m4a",
     family: "audio",
+    class: "audio",
     extensions: [".m4a"],
     label: "Audio",
     maxBytes: 500_000_000,
@@ -197,6 +225,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "audio/wav",
     family: "audio",
+    class: "audio",
     extensions: [".wav"],
     label: "Audio",
     maxBytes: 500_000_000,
@@ -204,6 +233,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "audio/aac",
     family: "audio",
+    class: "audio",
     extensions: [".aac"],
     label: "Audio",
     maxBytes: 500_000_000,
@@ -211,6 +241,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "video/mp4",
     family: "video",
+    class: "video",
     extensions: [".mp4", ".m4v"],
     label: "Video",
     maxBytes: 500_000_000,
@@ -218,6 +249,7 @@ export const INGESTION_FORMATS: readonly IngestionFormat[] = [
   {
     mime: "video/quicktime",
     family: "video",
+    class: "video",
     extensions: [".mov"],
     label: "Video",
     maxBytes: 500_000_000,
@@ -238,16 +270,3 @@ export function acceptExtensions(): string[] {
 export function humanLabels(): string[] {
   return [...new Set(INGESTION_FORMATS.map((entry) => entry.label))];
 }
-
-/**
- * Comma-joined extension string for a file input's `accept` attribute.
- * Derived from {@link acceptExtensions} — never hand-maintained.
- */
-export const INGEST_ACCEPT: string = acceptExtensions().join(",");
-
-/**
- * Human-readable supported-formats summary, derived from {@link humanLabels}.
- * Names every accepted group (in registry order) so the copy can't undersell
- * what actually works.
- */
-export const SUPPORTED_LABEL: string = `Supported: ${humanLabels().join(", ")}`;