@company-semantics/contracts 98.0.0 → 99.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@company-semantics/contracts",
-  "version": "98.0.0",
+  "version": "99.1.0",
   "private": false,
   "repository": {
     "type": "git",

package/src/api/generated-spec-hash.ts

@@ -1,3 +1,3 @@
 // AUTO-GENERATED — do not edit. Run pnpm generate:spec-hash to regenerate.
-export const SPEC_HASH = '51e9ee445972' as const;
-export const SPEC_HASH_FULL = '51e9ee445972ebf381cd85489343494ecdd81453574bbec8696a038ef4fd327f' as const;
+export const SPEC_HASH = '935ee995d53d' as const;
+export const SPEC_HASH_FULL = '935ee995d53d56538f0566bb3c1372041d5cb1def41f3b28db02716ad4d8c591' as const;

package/src/api/generated.ts

@@ -421,6 +421,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/chats/{id}/branch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Make one version of a turn the active branch */
+        post: operations["selectChatBranch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/chats/{id}/pin": {
         parameters: {
             query?: never;
@@ -5719,6 +5736,10 @@ export interface components {
             title: string;
             isAutoGenerated: boolean;
         };
+        ChatBranchSelectRequest: {
+            /** Format: uuid */
+            messageId: string;
+        };
         ChatSseEvent: {
             /** @constant */
             v: 1;
@@ -5987,14 +6008,16 @@ export interface components {
         ChatMessageFeedbackResponse: {
             /** @enum {string} */
             rating: "up" | "down";
-            reason: string | null;
+            reason: ("incorrect" | "didnt_follow_instructions" | "not_helpful" | "missing_context" | "tool_or_workflow_issue" | "other") | null;
             /** Format: date-time */
             updatedAt: string;
         };
         PutChatMessageFeedbackRequest: {
             /** @enum {string} */
             rating: "up" | "down";
-            reason?: string;
+            /** @enum {string} */
+            reason?: "incorrect" | "didnt_follow_instructions" | "not_helpful" | "missing_context" | "tool_or_workflow_issue" | "other";
+            comment?: string;
         };
         WorkspaceAccessResponse: {
             hasAccess: boolean;
@@ -12463,6 +12486,32 @@ export interface operations {
             };
         };
     };
+    selectChatBranch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ChatBranchSelectRequest"];
+            };
+        };
+        responses: {
+            /** @description The chat with its new active branch */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetChatResponse"];
+                };
+            };
+        };
+    };
     pinChat: {
         parameters: {
             query?: never;

package/src/chat/__tests__/runtime-profile.test.ts

@@ -81,13 +81,31 @@ function backendAgenticModelDefault(): string {
   );
 }
 
-/** The chat model the factory declares to the provider resolver. */
+/**
+ * The chat model the factory declares to the provider resolver. The factory's
+ * CHAT_DEFAULT_MODEL reads `modelFor('chat.default')`, so the id lives on the
+ * `chat.default` entry of the backend's model use-site registry.
+ *
+ * Until backend PRD-01163 lands on its origin/main, the resolved backend (a
+ * detached checkout such as the PR gate reads origin/main) has no registry and
+ * still declares the literal in factory.ts. Read whichever declaration the
+ * resolved backend actually has — parity is asserted either way. Drop the
+ * factory.ts branch once the registry is on backend main.
+ */
 function backendChatModelDefault(): string {
+  if (!backend!.exists("src/runtimes/models/use-sites.ts")) {
+    return extractDeclaration(
+      readBackendSource("src", "chat", "orchestrator", "factory.ts"),
+      /CHAT_DEFAULT_MODEL\s*=\s*['"]([^'"]+)['"]/,
+      "CHAT_DEFAULT_MODEL",
+      "src/chat/orchestrator/factory.ts",
+    );
+  }
   return extractDeclaration(
-    readBackendSource("src", "chat", "orchestrator", "factory.ts"),
-    /CHAT_DEFAULT_MODEL\s*=\s*['"]([^'"]+)['"]/,
-    "CHAT_DEFAULT_MODEL",
-    "src/chat/orchestrator/factory.ts",
+    readBackendSource("src", "runtimes", "models", "use-sites.ts"),
+    /['"]chat\.default['"]\s*:\s*\{\s*modelId:\s*['"]([^'"]+)['"]/,
+    "the 'chat.default' use-site modelId",
+    "src/runtimes/models/use-sites.ts",
   );
 }
 

package/src/generated/openapi-routes.ts

@@ -28,6 +28,7 @@ export const openApiRoutes = {
   '/api/chats/proactive/{eventId}': ['GET'],
   '/api/chats/resolve-launch': ['POST'],
   '/api/chats/{id}': ['DELETE', 'GET', 'PATCH'],
+  '/api/chats/{id}/branch': ['POST'],
   '/api/chats/{id}/generate-title': ['POST'],
   '/api/chats/{id}/messages': ['POST'],
   '/api/chats/{id}/messages/{messageId}': ['DELETE'],

package/src/index.ts

@@ -324,7 +324,10 @@ export * from "./product-intake/index";
 // for one target document; the wire carries facts and a count, never content.
 // See ./source-sync/vocabulary.ts and ./source-sync/schemas.ts.
 export * from "./source-sync/index";
-
 // Quality control plane vocabulary (PRD-01088 / quality-control-plane)
 // Closed evaluation/decision sets plus QualityRunReportSchema — ids, scores and failure kinds only. See ./quality/index.ts.
 export * from "./quality/index";
+// Scheduled-execution vocabulary (PRD-01175 / schedule-execution-wire-types)
+// Schedule definitions, slot-derived execution identity, lifecycle, the pure
+// UTC cron evaluator and the schedule route responses. See ./schedules/README.md.
+export * from "./schedules";

package/src/ingestion/README.md

@@ -1,49 +1,79 @@
 # ingestion/
 
-Shared vocabulary for the document-ingestion accept-set.
+Shared vocabulary for the one ingestion pipeline: formats, surfaces, providers.
 
 ## Purpose
 
-The single source of truth for which file formats the platform accepts for
-upload — their MIME types, filename extensions, human label groups, and
-per-format byte caps. The backend normalizer joins these entries with its
-private dispatch table; the app upload UI derives its file-input `accept`
-attribute and supported-formats copy from the same data.
+The single source of truth for which files the platform ingests and what each
+surface does with them. The format registry names every accepted format — its
+MIME type, filename extensions, family, class, human label group and byte cap.
+The surface declarations say, per consuming surface (company-md, org-chart,
+chat, profile-image), which treatment each admitted family gets and the byte
+ceiling. The provider vocabulary names the native types an external source
+(Google Drive) hands the pipeline and the registry format each exports to. The
+backend normalizer, discovery and the app upload UI derive everything they need
+from these three declarations.
 
 ## Invariants
 
 - `INGESTION_FORMATS` is the canonical list; `mime` is unique across entries.
-- Entries are ordered text → documents → images/diagrams → audio/video. The
+  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** from the registry, never
-  hand-maintained — adding a format updates both automatically.
+- Every format carries a `family` and a required `class` (`FormatClass`:
+  `docs | slides | sheets | pdf | text | image | diagram | audio | video`). No
+  consumer keeps its own extension → class table.
+- A surface (`INGESTION_SURFACES`) declares `treatments` — family →
+  `text | vision | transcript | store` — and a required `maxBytes`.
+  `familiesOf`, `formatsFor`, `surfaceAdmits`, `treatmentFor`, `acceptFor`,
+  `supportedLabelFor` and `maxBytesFor` are **derived** from that declaration.
+  Treatments are per family, never per format.
+- `vision` means the richest native form: images as images, a PDF as a binary
+  document, text-native formats as text.
+- A provider (`INGESTION_PROVIDERS`) declares its native types, their export
+  targets and labels, and its container MIMEs. `providerFormatsFor`,
+  `classOfMime`, `inventoryClassesFor` and `labelOfMime` are **derived**.
+- `acceptFor` emits extensions and MIMEs (".png,image/png,…"), so a
+  MIME-only matcher can use the same string as a file-input `accept`.
+- Nothing outside this domain names a MIME, an extension or a provider-native
+  type; consumers ask these helpers (ADR slug `single-ingestion-pipeline`).
 - No normalizer-routing fields here (`canonicalKind`, `normalizerKey` are
-  backend-only). This package stays pure vocabulary.
-- Every entry carries a `family`; `INGESTION_SURFACES` declares which families
-  each upload surface admits, and `formatsFor` / `acceptFor` /
-  `supportedLabelFor` / `maxBytesFor` are **derived** from that declaration
-  (ADR-CONTRACTS-159). A surface never re-spells a MIME.
+  backend-only). This package stays pure vocabulary
+  (ADR slug `ingestion-surface-treatments-and-providers`).
 
 <!-- BEGIN GENERATED: readme-public-api — derived from code by `pnpm readme-api`. Do not edit. -->
 
 ## Public API
 
+- `FORMAT_CLASSES` — The coarse, provider-agnostic kind of a format, used wherever the system classes a file without reading it…
+- `FormatClass` _(type)_
 - `INGESTION_FORMATS` — The canonical public format registry.
-- `INGESTION_SURFACES` — The canonical surface declarations. - `company-md`: context-bank and goals extraction.
-- `INGEST_ACCEPT` — Comma-joined extension string for a file input's `accept` attribute.
+- `INGESTION_PROVIDERS` — Every provider's native types and container MIMEs, keyed by provider.
+- `INGESTION_SURFACES` — The canonical surface declarations. - `company-md`: context bank, goals extraction, Source Sync landing.
 - `IngestionFamily` _(type)_ — The semantic family a format belongs to.
 - `IngestionFormat` _(type)_ — One accepted upload format, keyed by its canonical MIME type.
-- `IngestionSurface` _(type)_ — What one upload surface consumes: the families it admits and, optionally, a byte ceiling tighter than the…
-- `IngestionSurfaceKey` _(type)_ — The upload surfaces that consume the registry.
-- `SUPPORTED_LABEL` — Human-readable supported-formats summary, derived from {@link humanLabels}.
+- `IngestionProvider` _(type)_ — One provider: its native types and the structural container MIMEs it lists.
+- `IngestionProviderKey` _(type)_ — External sources that hand the pipeline provider-native files.
+- `IngestionSurface` _(type)_ — One surface: the treatment it applies per admitted family, and its byte ceiling.
+- `IngestionSurfaceKey` _(type)_ — The surfaces that consume the registry.
+- `InventoryClass` _(type)_ — A Source Sync inventory class: a format class, or a provider shortcut row.
+- `ProviderFormat` _(type)_ — One MIME a provider can hand the pipeline, with the registry format it lands as.
+- `ProviderNativeFormat` _(type)_ — A provider-native type that is exported to a registry format before ingestion.
+- `TREATMENTS` — What a surface does with an admitted family.
+- `Treatment` _(type)_
 - `acceptExtensions` — All accepted filename extensions, in registry order.
-- `acceptFor` — Comma-joined extension string for the surface's file input `accept`.
+- `acceptFor` — The `<input accept>` value for a surface: per format, its extensions then its MIME…
 - `byMime` — Look up the entry for a canonical MIME; undefined means unsupported.
+- `classOfMime` — The class of a provider-listed MIME; null for containers and unknown types.
+- `familiesOf` — The families a surface admits, in canonical family order.
 - `formatsFor` — The registry formats a surface admits, in registry order.
 - `humanLabels` — Unique group labels for human display, in registry order.
-- `maxBytesFor` — The transport byte ceiling for a surface: the largest registry cap among its admitted formats, tightened to…
+- `inventoryClassesFor` — The inventory classes discovery can record for a provider feeding a surface, in canonical class order, plus…
+- `labelOfMime` — Display label for a MIME (provider-native first when a provider is given); null if unknown.
+- `maxBytesFor` — The transport byte ceiling: the largest registry cap among admitted formats, tightened to the (required)…
+- `providerFormatsFor` — Every MIME the provider can hand a surface (natives first, then registry order).
 - `supportedLabelFor` — "Supported: …" copy naming every label group the surface admits.
 - `surfaceAdmits` — True when the surface admits this registry format.
+- `treatmentFor` — What the surface does with this format; null = the surface refuses it.
 
 <!-- END GENERATED: readme-public-api -->
 

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

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import {
+  INGESTION_PROVIDERS,
+  providerFormatsFor,
+  classOfMime,
+  inventoryClassesFor,
+  labelOfMime,
+} from "../providers";
+import { byMime } from "../registry";
+
+describe("ingestion providers", () => {
+  it("every Drive native type exports to a registry format", () => {
+    for (const n of INGESTION_PROVIDERS["google-drive"].nativeFormats) {
+      expect(byMime(n.exportsTo)).toBeDefined();
+    }
+  });
+
+  it("the company-md Drive net is the three Workspace types plus the company-md formats", () => {
+    const net = providerFormatsFor("google-drive", "company-md");
+    expect(net.slice(0, 3).map((pf) => pf.mime)).toEqual([
+      "application/vnd.google-apps.document",
+      "application/vnd.google-apps.presentation",
+      "application/vnd.google-apps.spreadsheet",
+    ]);
+    expect(net.map((pf) => pf.mime)).toContain("application/pdf");
+    expect(net.map((pf) => pf.mime)).not.toContain("image/png");
+    expect(new Set(net.map((pf) => pf.mime)).size).toBe(net.length);
+  });
+
+  it("pins the company-md inventory classes the DB CHECK carries today", () => {
+    expect(inventoryClassesFor("google-drive", "company-md")).toEqual([
+      "docs",
+      "slides",
+      "sheets",
+      "pdf",
+      "text",
+      "shortcut",
+    ]);
+  });
+
+  it("classes native, downloaded and container MIMEs", () => {
+    expect(
+      classOfMime("google-drive", "application/vnd.google-apps.spreadsheet"),
+    ).toBe("sheets");
+    expect(classOfMime("google-drive", "text/csv")).toBe("sheets");
+    expect(classOfMime("google-drive", "image/png")).toBe("image");
+    expect(
+      classOfMime("google-drive", "application/vnd.google-apps.folder"),
+    ).toBeNull();
+  });
+
+  it("labels native and registry MIMEs", () => {
+    expect(
+      labelOfMime("application/vnd.google-apps.document", "google-drive"),
+    ).toBe("Google Doc");
+    expect(labelOfMime("application/pdf")).toBe("PDF");
+    expect(labelOfMime("application/x-unknown")).toBeNull();
+  });
+});

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";