@marimo-team/islands 0.19.7-dev33 → 0.19.7-dev34

package/dist/main.js

@@ -34867,7 +34867,7 @@ ${c.sqlString}
       let e2 = r === "validate" ? "default" : "validate";
       e2 === "default" && clearAllSqlValidationErrors(), c(e2);
     }, e[0] = c, e[1] = r, e[2] = d) : d = e[2];
-    let f = d, _ = _temp4$12, v = _temp5$8, y;
+    let f = d, _ = _temp4$11, v = _temp5$8, y;
     e[3] === r ? y = e[4] : (y = v(r), e[3] = r, e[4] = y);
     let S;
     e[5] === r ? S = e[6] : (S = _(r), e[5] = r, e[6] = S);
@@ -34931,7 +34931,7 @@ ${c.sqlString}
   function _temp3$20(e) {
     return e = e.filter(_temp$39), e.map(_temp2$27);
   }
-  function _temp4$12(e) {
+  function _temp4$11(e) {
     return e === "validate" ? (0, import_jsx_runtime.jsx)(SearchCheck, {
       className: "h-3 w-3"
     }) : (0, import_jsx_runtime.jsx)(DatabaseBackup, {
@@ -51487,7 +51487,7 @@ Database schema: ${c}`), (_a3 = r2.aiFix) == null ? void 0 : _a3.setAiCompletion
     if (c.some(_temp$36)) v = "Interrupted";
     else if (c.some(_temp2$25)) v = "An internal error occurred";
     else if (c.some(_temp3$18)) v = "Ancestor prevented from running", y = "default", S = "text-secondary-foreground";
-    else if (c.some(_temp4$11)) v = "Ancestor stopped", y = "default", S = "text-secondary-foreground";
+    else if (c.some(_temp4$10)) v = "Ancestor stopped", y = "default", S = "text-secondary-foreground";
     else if (c.some(_temp5$7)) v = "SQL error";
     else {
       let e2;
@@ -51860,7 +51860,7 @@ Database schema: ${c}`), (_a3 = r2.aiFix) == null ? void 0 : _a3.setAiCompletion
   function _temp3$18(e) {
     return e.type === "ancestor-prevented";
   }
-  function _temp4$11(e) {
+  function _temp4$10(e) {
     return e.type === "ancestor-stopped";
   }
   function _temp5$7(e) {
@@ -52191,6 +52191,85 @@ Database schema: ${c}`), (_a3 = r2.aiFix) == null ? void 0 : _a3.setAiCompletion
   function isOutputEmpty(e) {
     return e == null || e.data == null || e.data === "";
   }
+  function createMimeConfig(e) {
+    let r = /* @__PURE__ */ new Map();
+    for (let c2 = 0; c2 < e.precedence.length; c2++) r.set(e.precedence[c2], c2);
+    let c = /* @__PURE__ */ new Map();
+    for (let [r2, d] of Object.entries(e.hidingRules)) c.set(r2, new Set(d));
+    return {
+      precedence: r,
+      hidingRules: c
+    };
+  }
+  const getDefaultMimeConfig = once(() => {
+    let e = [
+      "image/png",
+      "image/jpeg",
+      "image/gif"
+    ];
+    return createMimeConfig({
+      precedence: [
+        "text/html",
+        "application/vnd.vegalite.v6+json",
+        "application/vnd.vegalite.v5+json",
+        "application/vnd.vega.v6+json",
+        "application/vnd.vega.v5+json",
+        "image/svg+xml",
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "text/markdown",
+        "text/latex",
+        "text/csv",
+        "application/json",
+        "text/plain",
+        "video/mp4",
+        "video/mpeg"
+      ],
+      hidingRules: {
+        "text/html": [
+          ...e,
+          "image/avif",
+          "image/bmp",
+          "image/tiff"
+        ],
+        "application/vnd.vegalite.v6+json": e,
+        "application/vnd.vegalite.v5+json": e,
+        "application/vnd.vega.v6+json": e,
+        "application/vnd.vega.v5+json": e
+      }
+    });
+  });
+  function applyHidingRules(e, r) {
+    let c = /* @__PURE__ */ new Set();
+    for (let d2 of e) {
+      let f = r.get(d2);
+      if (f) for (let r2 of f) e.has(r2) && c.add(r2);
+    }
+    let d = /* @__PURE__ */ new Set();
+    for (let r2 of e) c.has(r2) || d.add(r2);
+    return {
+      visible: d,
+      hidden: c
+    };
+  }
+  function sortByPrecedence(e, r) {
+    let c = r.size;
+    return [
+      ...e
+    ].sort((e2, d) => (r.get(e2[0]) ?? c) - (r.get(d[0]) ?? c));
+  }
+  function processMimeBundle(e, r = getDefaultMimeConfig()) {
+    if (e.length === 0) return {
+      entries: [],
+      hidden: []
+    };
+    let { visible: c, hidden: d } = applyHidingRules(new Set(e.map(([e2]) => e2)), r.hidingRules);
+    return {
+      entries: sortByPrecedence(e.filter(([e2]) => c.has(e2)), r.precedence),
+      hidden: Array.from(d)
+    };
+  }
   const LazyVegaEmbed = import_react.lazy(() => import("./react-vega-DgHpnZ04.js").then((e) => ({
     default: e.VegaEmbed
   })));
@@ -62832,7 +62911,7 @@ ${O}`,
     if (r[0] !== y || r[1] !== f || r[2] !== d || r[3] !== S || r[4] !== _) {
       q = /* @__PURE__ */ Symbol.for("react.early_return_sentinel");
       bb0: {
-        let e2 = Objects.entries(_).filter(_temp$33).map(_temp2$24), c2 = (_a2 = e2[0]) == null ? void 0 : _a2[0];
+        let { entries: e2 } = processMimeBundle(Objects.entries(_).filter(_temp$33).map(_temp2$24)), c2 = (_a2 = e2[0]) == null ? void 0 : _a2[0];
         if (!c2) {
           q = null;
           break bb0;
@@ -62842,18 +62921,18 @@ ${O}`,
             cellId: f,
             message: {
               channel: d,
-              data: _[c2],
+              data: e2[0][1],
               mimetype: c2
             },
             metadata: S == null ? void 0 : S[c2]
           });
           break bb0;
         }
-        e2.sort(_temp3$17), w = Tabs, z = c2, G = "vertical", M = "flex";
+        w = Tabs, z = c2, G = "vertical", M = "flex";
         let v2 = y && "mt-4", IY2;
         r[13] === v2 ? IY2 = r[14] : (IY2 = cn("self-start max-h-none flex flex-col gap-2 mr-3 shrink-0", v2), r[13] = v2, r[14] = IY2), I = (0, import_jsx_runtime.jsx)(TabsList, {
           className: IY2,
-          children: e2.map(_temp4$10)
+          children: e2.map(_temp3$17)
         }), E = "flex-1 w-full";
         let LY2;
         r[15] !== f || r[16] !== d || r[17] !== S ? (LY2 = (e3) => {
@@ -63040,11 +63119,7 @@ ${O}`,
       c
     ];
   }
-  function _temp3$17(e, r) {
-    let [c] = e;
-    return c === "text/html" ? -1 : 0;
-  }
-  function _temp4$10(e) {
+  function _temp3$17(e) {
     let [r] = e;
     return (0, import_jsx_runtime.jsx)(TabsTrigger, {
       value: r,
@@ -73083,7 +73158,7 @@ Image URL: ${r.imageUrl}`)), contextToXml({
       return Logger.warn("Failed to get version from mount config"), null;
     }
   }
-  const marimoVersionAtom = atom(getVersionFromMountConfig() || "0.19.7-dev33"), showCodeInRunModeAtom = atom(true);
+  const marimoVersionAtom = atom(getVersionFromMountConfig() || "0.19.7-dev34"), showCodeInRunModeAtom = atom(true);
   atom(null);
   var import_compiler_runtime$88 = require_compiler_runtime();
   function useKeydownOnElement(e, r) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.19.7-dev33",
+  "version": "0.19.7-dev34",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/components/editor/Output.tsx

@@ -36,6 +36,7 @@ import type { TopLevelFacetedUnitSpec } from "@/plugins/impl/data-explorer/queri
 import { useTheme } from "@/theme/useTheme";
 import { Events } from "@/utils/events";
 import { invariant } from "@/utils/invariant";
+import { processMimeBundle } from "@/utils/mime-types";
 import { Objects } from "@/utils/objects";
 import { LazyVegaEmbed } from "../charts/lazy";
 import { ChartLoadingState } from "../data-table/charts/components/chart-states";
@@ -268,10 +269,13 @@ const MimeBundleOutputRenderer: React.FC<{
   const metadata = mimebundle[METADATA_KEY];
 
   // Filter out metadata from the mime entries and type narrow
-  const mimeEntries = Objects.entries(mimebundle as Record<string, unknown>)
+  const rawEntries = Objects.entries(mimebundle as Record<string, unknown>)
     .filter(([key]) => key !== METADATA_KEY)
     .map(([mime, data]) => [mime, data] as [MimeType, CellOutput["data"]]);
 
+  // Apply precedence ordering and hiding rules
+  const { entries: mimeEntries } = processMimeBundle(rawEntries);
+
   // If there is none, return null
   const first = mimeEntries[0]?.[0];
   if (!first) {
@@ -285,7 +289,7 @@ const MimeBundleOutputRenderer: React.FC<{
         cellId={cellId}
         message={{
           channel: channel,
-          data: mimebundle[first],
+          data: mimeEntries[0][1],
           mimetype: first,
         }}
         metadata={metadata?.[first]}
@@ -293,14 +297,6 @@ const MimeBundleOutputRenderer: React.FC<{
     );
   }
 
-  // Sort HTML first
-  mimeEntries.sort(([mimeA], [_mimeB]) => {
-    if (mimeA === "text/html") {
-      return -1;
-    }
-    return 0;
-  });
-
   return (
     <Tabs defaultValue={first} orientation="vertical">
       <div className="flex">

package/src/utils/__tests__/mime-types.test.ts

@@ -0,0 +1,326 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import type { MimeType } from "@/components/editor/Output";
+import {
+  applyHidingRules,
+  createMimeConfig,
+  getDefaultMimeConfig,
+  processMimeBundle,
+  sortByPrecedence,
+} from "../mime-types";
+
+/** Helper to build a hiding rules Map inline */
+function hidingRules(
+  rules: Record<string, MimeType[]>,
+): ReadonlyMap<MimeType, ReadonlySet<MimeType>> {
+  const map = new Map<MimeType, ReadonlySet<MimeType>>();
+  for (const [trigger, toHide] of Object.entries(rules)) {
+    map.set(trigger as MimeType, new Set(toHide));
+  }
+  return map;
+}
+
+/** Helper to build a precedence Map inline */
+function precedenceMap(types: MimeType[]): ReadonlyMap<MimeType, number> {
+  const map = new Map<MimeType, number>();
+  types.forEach((mime, i) => map.set(mime, i));
+  return map;
+}
+
+describe("mime-types", () => {
+  describe("applyHidingRules", () => {
+    it("should return all visible when no rules match", () => {
+      const mimeTypes = new Set<MimeType>(["text/plain", "text/markdown"]);
+      const rules = hidingRules({ "text/html": ["image/png"] });
+
+      const result = applyHidingRules(mimeTypes, rules);
+
+      expect(result.visible).toEqual(new Set(["text/plain", "text/markdown"]));
+      expect(result.hidden.size).toBe(0);
+    });
+
+    it("should hide mime types when trigger is present", () => {
+      const mimeTypes = new Set<MimeType>([
+        "text/html",
+        "image/png",
+        "text/plain",
+      ]);
+      const rules = hidingRules({ "text/html": ["image/png"] });
+
+      const result = applyHidingRules(mimeTypes, rules);
+
+      expect(result.visible).toEqual(new Set(["text/html", "text/plain"]));
+      expect(result.hidden).toEqual(new Set(["image/png"]));
+    });
+
+    it("should not hide markdown when html is present (per requirements)", () => {
+      const mimeTypes = new Set<MimeType>([
+        "text/html",
+        "text/markdown",
+        "image/png",
+      ]);
+      const rules = hidingRules({ "text/html": ["image/png"] });
+
+      const result = applyHidingRules(mimeTypes, rules);
+
+      expect(result.visible.has("text/markdown")).toBe(true);
+      expect(result.visible.has("text/html")).toBe(true);
+      expect(result.hidden.has("image/png")).toBe(true);
+    });
+
+    it("should handle multiple matching rules", () => {
+      const mimeTypes = new Set<MimeType>([
+        "text/html",
+        "application/vnd.vegalite.v5+json",
+        "image/png",
+        "image/jpeg",
+      ]);
+      const rules = hidingRules({
+        "text/html": ["image/png"],
+        "application/vnd.vegalite.v5+json": ["image/jpeg"],
+      });
+
+      const result = applyHidingRules(mimeTypes, rules);
+
+      expect(result.hidden).toEqual(new Set(["image/png", "image/jpeg"]));
+      expect(result.visible).toEqual(
+        new Set(["text/html", "application/vnd.vegalite.v5+json"]),
+      );
+    });
+
+    it("should handle empty mime types", () => {
+      const mimeTypes = new Set<MimeType>();
+      const rules = hidingRules({ "text/html": ["image/png"] });
+
+      const result = applyHidingRules(mimeTypes, rules);
+
+      expect(result.visible.size).toBe(0);
+      expect(result.hidden.size).toBe(0);
+    });
+
+    it("should handle empty rules", () => {
+      const mimeTypes = new Set<MimeType>(["text/html", "image/png"]);
+      const rules = hidingRules({});
+
+      const result = applyHidingRules(mimeTypes, rules);
+
+      expect(result.visible).toEqual(mimeTypes);
+      expect(result.hidden.size).toBe(0);
+    });
+
+    it("should hide a type that is also a trigger if configured", () => {
+      const mimeTypes = new Set<MimeType>(["text/html", "text/plain"]);
+      const rules = hidingRules({ "text/html": ["text/html"] });
+
+      const result = applyHidingRules(mimeTypes, rules);
+
+      expect(result.hidden.has("text/html")).toBe(true);
+    });
+
+    it("should not hide types that are not present", () => {
+      const mimeTypes = new Set<MimeType>(["text/html"]);
+      const rules = hidingRules({
+        "text/html": ["image/png", "image/jpeg"],
+      });
+
+      const result = applyHidingRules(mimeTypes, rules);
+
+      expect(result.hidden.size).toBe(0);
+      expect(result.visible).toEqual(new Set(["text/html"]));
+    });
+  });
+
+  describe("sortByPrecedence", () => {
+    it("should sort entries by precedence order", () => {
+      const entries: Array<[MimeType, string]> = [
+        ["text/plain", "plain"],
+        ["text/html", "html"],
+        ["image/png", "png"],
+      ];
+
+      const result = sortByPrecedence(
+        entries,
+        precedenceMap(["text/html", "image/png", "text/plain"]),
+      );
+
+      expect(result.map(([m]) => m)).toEqual([
+        "text/html",
+        "image/png",
+        "text/plain",
+      ]);
+    });
+
+    it("should place unknown mime types at the end", () => {
+      const entries: Array<[MimeType, string]> = [
+        ["text/plain", "plain"],
+        ["text/html", "html"],
+        ["application/json", "json"],
+      ];
+
+      const result = sortByPrecedence(entries, precedenceMap(["text/html"]));
+
+      expect(result[0][0]).toBe("text/html");
+      expect(result.slice(1).map(([m]) => m)).toEqual([
+        "text/plain",
+        "application/json",
+      ]);
+    });
+
+    it("should handle empty entries", () => {
+      const result = sortByPrecedence([], precedenceMap(["text/html"]));
+
+      expect(result).toEqual([]);
+    });
+
+    it("should handle empty precedence", () => {
+      const entries: Array<[MimeType, string]> = [
+        ["text/plain", "plain"],
+        ["text/html", "html"],
+      ];
+
+      const result = sortByPrecedence(entries, precedenceMap([]));
+
+      expect(result.map(([m]) => m)).toEqual(["text/plain", "text/html"]);
+    });
+
+    it("should not mutate original array", () => {
+      const entries: Array<[MimeType, string]> = [
+        ["text/plain", "plain"],
+        ["text/html", "html"],
+      ];
+      const original = [...entries];
+
+      sortByPrecedence(entries, precedenceMap(["text/html", "text/plain"]));
+
+      expect(entries).toEqual(original);
+    });
+  });
+
+  describe("processMimeBundle", () => {
+    it("should filter and sort mime entries", () => {
+      const entries: Array<[MimeType, string]> = [
+        ["text/plain", "plain"],
+        ["text/html", "html"],
+        ["image/png", "png"],
+      ];
+
+      const config = createMimeConfig({
+        precedence: ["text/html", "text/plain"],
+        hidingRules: { "text/html": ["image/png"] },
+      });
+
+      const result = processMimeBundle(entries, config);
+
+      expect(result.entries.map(([m]) => m)).toEqual([
+        "text/html",
+        "text/plain",
+      ]);
+      expect(result.hidden).toEqual(["image/png"]);
+    });
+
+    it("should handle empty entries", () => {
+      const result = processMimeBundle([]);
+
+      expect(result.entries).toEqual([]);
+      expect(result.hidden).toEqual([]);
+    });
+
+    it("should use default config when not provided", () => {
+      const entries: Array<[MimeType, string]> = [
+        ["text/html", "html"],
+        ["image/png", "png"],
+        ["text/markdown", "md"],
+      ];
+
+      const result = processMimeBundle(entries);
+
+      expect(result.entries.map(([m]) => m)).not.toContain("image/png");
+      expect(result.entries.map(([m]) => m)).toContain("text/markdown");
+    });
+
+    it("should preserve data associated with mime types", () => {
+      const htmlData = { content: "<h1>Hello</h1>" };
+      const entries: Array<[MimeType, typeof htmlData]> = [
+        ["text/html", htmlData],
+      ];
+
+      const result = processMimeBundle(entries);
+
+      expect(result.entries[0][1]).toBe(htmlData);
+    });
+
+    it("should sort by precedence after filtering", () => {
+      const entries: Array<[MimeType, string]> = [
+        ["text/plain", "plain"],
+        ["text/markdown", "md"],
+        ["text/html", "html"],
+      ];
+
+      const result = processMimeBundle(entries);
+
+      expect(result.entries[0][0]).toBe("text/html");
+    });
+  });
+
+  describe("getDefaultMimeConfig", () => {
+    const config = getDefaultMimeConfig();
+
+    it("should have text/html as highest precedence", () => {
+      expect(config.precedence.get("text/html")).toBe(0);
+    });
+
+    it("should hide image types when html is present", () => {
+      const htmlHides = config.hidingRules.get("text/html");
+
+      expect(htmlHides).toBeDefined();
+      expect(htmlHides?.has("image/png")).toBe(true);
+      expect(htmlHides?.has("image/jpeg")).toBe(true);
+    });
+
+    it("should NOT hide markdown when html is present", () => {
+      const htmlHides = config.hidingRules.get("text/html");
+
+      expect(htmlHides?.has("text/markdown")).toBeFalsy();
+    });
+
+    it("should hide images when vega charts are present", () => {
+      const vegaHides = config.hidingRules.get(
+        "application/vnd.vegalite.v5+json",
+      );
+
+      expect(vegaHides).toBeDefined();
+      expect(vegaHides?.has("image/png")).toBe(true);
+    });
+
+    it("should return the same instance on repeated calls", () => {
+      expect(getDefaultMimeConfig()).toBe(config);
+    });
+  });
+
+  describe("createMimeConfig", () => {
+    it("should compile precedence array into a Map", () => {
+      const config = createMimeConfig({
+        precedence: ["text/html", "image/png"],
+        hidingRules: {},
+      });
+
+      expect(config.precedence.get("text/html")).toBe(0);
+      expect(config.precedence.get("image/png")).toBe(1);
+      expect(config.precedence.has("text/plain")).toBe(false);
+    });
+
+    it("should compile hiding rules into Map<MimeType, Set>", () => {
+      const config = createMimeConfig({
+        precedence: [],
+        hidingRules: {
+          "text/html": ["image/png", "image/jpeg"],
+        },
+      });
+
+      const htmlHides = config.hidingRules.get("text/html");
+      expect(htmlHides).toBeInstanceOf(Set);
+      expect(htmlHides?.has("image/png")).toBe(true);
+      expect(htmlHides?.has("image/jpeg")).toBe(true);
+    });
+  });
+});

package/src/utils/mime-types.ts

@@ -0,0 +1,181 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { MimeType } from "@/components/editor/Output";
+import { once } from "./once";
+
+/**
+ * Configuration for mime type precedence and filtering.
+ * Uses Map/Set for O(1) lookups at runtime.
+ */
+export interface MimeTypeConfig {
+  /**
+   * Pre-computed precedence map: mime type -> sort index.
+   * Lower index = higher priority. Types not in the map are placed at the end.
+   */
+  precedence: ReadonlyMap<MimeType, number>;
+
+  /**
+   * Hiding rules: trigger mime type -> set of mime types to hide.
+   * When the key mime type is present, all mime types in the value set are hidden.
+   */
+  hidingRules: ReadonlyMap<MimeType, ReadonlySet<MimeType>>;
+}
+
+/**
+ * Result of processing mime types through the filtering and sorting pipeline.
+ */
+export interface ProcessedMimeTypes<T> {
+  /** The filtered and sorted mime entries */
+  entries: Array<[MimeType, T]>;
+  /** Mime types that were hidden by rules */
+  hidden: MimeType[];
+}
+
+/**
+ * Creates a compiled MimeTypeConfig from readable arrays.
+ *
+ * @example
+ * ```ts
+ * const config = createMimeConfig({
+ *   precedence: ["text/html", "image/png", "text/plain"],
+ *   hidingRules: {
+ *     "text/html": ["image/png", "image/jpeg"],
+ *   },
+ * });
+ * ```
+ */
+export function createMimeConfig(input: {
+  precedence: MimeType[];
+  hidingRules: Record<string, MimeType[]>;
+}): MimeTypeConfig {
+  const precedence = new Map<MimeType, number>();
+  for (let i = 0; i < input.precedence.length; i++) {
+    precedence.set(input.precedence[i], i);
+  }
+
+  const hidingRules = new Map<MimeType, ReadonlySet<MimeType>>();
+  for (const [trigger, toHide] of Object.entries(input.hidingRules)) {
+    hidingRules.set(trigger as MimeType, new Set(toHide));
+  }
+
+  return { precedence, hidingRules };
+}
+
+/**
+ * Default configuration for mime type handling.
+ * Lazily compiled on first access.
+ *
+ * Design rationale:
+ * - text/html typically contains rich rendered output and should take precedence
+ * - When text/html is present, image fallbacks (png, jpeg, etc.) are often redundant
+ *   static renders and should be hidden to reduce UI clutter
+ * - text/markdown should NOT be hidden by text/html as they serve different purposes
+ * - Vega charts should remain visible as they provide interactivity
+ */
+export const getDefaultMimeConfig = once((): MimeTypeConfig => {
+  const IMAGE_FALLBACKS: MimeType[] = ["image/png", "image/jpeg", "image/gif"];
+
+  return createMimeConfig({
+    precedence: [
+      "text/html",
+      "application/vnd.vegalite.v6+json",
+      "application/vnd.vegalite.v5+json",
+      "application/vnd.vega.v6+json",
+      "application/vnd.vega.v5+json",
+      "image/svg+xml",
+      "image/png",
+      "image/jpeg",
+      "image/gif",
+      "text/markdown",
+      "text/latex",
+      "text/csv",
+      "application/json",
+      "text/plain",
+      "video/mp4",
+      "video/mpeg",
+    ],
+    hidingRules: {
+      // When HTML is present, hide static image fallbacks
+      "text/html": [
+        ...IMAGE_FALLBACKS,
+        "image/avif",
+        "image/bmp",
+        "image/tiff",
+      ],
+      // When Vega charts are present, hide image fallbacks
+      "application/vnd.vegalite.v6+json": IMAGE_FALLBACKS,
+      "application/vnd.vegalite.v5+json": IMAGE_FALLBACKS,
+      "application/vnd.vega.v6+json": IMAGE_FALLBACKS,
+      "application/vnd.vega.v5+json": IMAGE_FALLBACKS,
+    },
+  });
+});
+
+/**
+ * Filters mime types based on hiding rules.
+ */
+export function applyHidingRules(
+  mimeTypes: ReadonlySet<MimeType>,
+  rules: ReadonlyMap<MimeType, ReadonlySet<MimeType>>,
+): { visible: Set<MimeType>; hidden: Set<MimeType> } {
+  const hidden = new Set<MimeType>();
+
+  for (const mime of mimeTypes) {
+    const toHide = rules.get(mime);
+    if (toHide) {
+      for (const hideType of toHide) {
+        if (mimeTypes.has(hideType)) {
+          hidden.add(hideType);
+        }
+      }
+    }
+  }
+
+  const visible = new Set<MimeType>();
+  for (const mime of mimeTypes) {
+    if (!hidden.has(mime)) {
+      visible.add(mime);
+    }
+  }
+
+  return { visible, hidden };
+}
+
+/**
+ * Sorts mime entries according to a precedence map.
+ * Mime types not in the map are placed at the end, preserving their original order.
+ */
+export function sortByPrecedence<T>(
+  entries: Array<[MimeType, T]>,
+  precedence: ReadonlyMap<MimeType, number>,
+): Array<[MimeType, T]> {
+  const unknownPrecedence = precedence.size;
+
+  return [...entries].sort((a, b) => {
+    const indexA = precedence.get(a[0]) ?? unknownPrecedence;
+    const indexB = precedence.get(b[0]) ?? unknownPrecedence;
+    return indexA - indexB;
+  });
+}
+
+/**
+ * Main entry point: processes mime entries by applying hiding rules and sorting.
+ */
+export function processMimeBundle<T>(
+  entries: Array<[MimeType, T]>,
+  config: MimeTypeConfig = getDefaultMimeConfig(),
+): ProcessedMimeTypes<T> {
+  if (entries.length === 0) {
+    return { entries: [], hidden: [] };
+  }
+
+  const mimeTypes = new Set(entries.map(([mime]) => mime));
+  const { visible, hidden } = applyHidingRules(mimeTypes, config.hidingRules);
+  const filteredEntries = entries.filter(([mime]) => visible.has(mime));
+  const sortedEntries = sortByPrecedence(filteredEntries, config.precedence);
+
+  return {
+    entries: sortedEntries,
+    hidden: Array.from(hidden),
+  };
+}