@cosmicdrift/kumiko-bundled-features 0.98.0 → 0.100.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-bundled-features",
-  "version": "0.98.0",
+  "version": "0.100.0",
   "description": "Built-in features — tenant, user, auth, delivery. The stuff you'd rewrite anyway, already typed.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -91,11 +91,11 @@
     "./step-dispatcher": "./src/step-dispatcher/index.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.98.0",
-    "@cosmicdrift/kumiko-framework": "0.98.0",
-    "@cosmicdrift/kumiko-headless": "0.98.0",
-    "@cosmicdrift/kumiko-renderer": "0.98.0",
-    "@cosmicdrift/kumiko-renderer-web": "0.98.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.100.0",
+    "@cosmicdrift/kumiko-framework": "0.100.0",
+    "@cosmicdrift/kumiko-headless": "0.100.0",
+    "@cosmicdrift/kumiko-renderer": "0.100.0",
+    "@cosmicdrift/kumiko-renderer-web": "0.100.0",
     "@mollie/api-client": "^4.5.0",
     "@node-rs/argon2": "^2.0.2",
     "@types/nodemailer": "^8.0.0",

package/src/file-foundation/feature.ts

@@ -1,103 +1,44 @@
 // kumiko-feature-version: 1
 //
-// file-foundation as a Kumiko bundled feature — plugin-API shape.
+// file-foundation as a Kumiko bundled feature — declares the `fileProvider`
+// extension point + the per-tenant `provider` config key. Provider RESOLUTION
+// (createFileProviderForTenant) + the plugin types now live in the framework
+// (packages/framework/src/files/provider-resolver.ts) so the upload routes,
+// `ctx.files` and the GDPR jobs resolve through ONE path — uploads, export and
+// erasure hit the same store by construction. This feature re-exports the moved
+// symbols unchanged so existing imports keep working.
 //
-// **Pattern-Vorbild:** identisch zu `mail-foundation`. Foundation
-// deklariert extension-point `fileProvider`, Provider-Features (file-
-// provider-s3, später file-provider-azure-blob, file-provider-gcs)
-// registrieren sich namentlich. Tenant wählt zur Runtime via config-
-// key `provider`.
+// **Pattern-Vorbild:** identisch zu `mail-foundation`. Foundation deklariert
+// extension-point `fileProvider`, Provider-Features (file-provider-s3, -inmemory,
+// -s3-env, später -gcs/-azure-blob) registrieren sich namentlich. Tenant wählt
+// zur Runtime via config-key `provider`.
 //
-// **Was diese Foundation NICHT mehr macht:**
-//   - Keine S3-spezifischen Config-Keys mehr (bucket/region/endpoint/
-//     forcePathStyle/accessKeyId) — die leben im Provider-Plugin.
-//   - Kein direkter Import von `createS3Provider`. Foundation kennt
-//     nur das `FileStorageProvider`-Interface (Type-Import, kein
-//     runtime-coupling).
-//
-// **Standalone:** Foundation ist ohne tier-engine nutzbar. Existing
-// `files-provider-s3` (App-wide-Library) bleibt unangetastet.
-//
-// **Boot-Dependencies:** config (für provider-selector). Kein secrets,
-// weil Foundation selbst keine Secrets hält.
+// **Boot-Dependencies:** config (für provider-selector). Kein secrets, weil
+// Foundation selbst keine Secrets hält.
 
-import { requireDefined } from "@cosmicdrift/kumiko-bundled-features/foundation-shared";
 import {
   access,
-  type ConfigAccessor,
   createTenantConfig,
   defineFeature,
-  type Registry,
+  EXT_FILE_PROVIDER,
 } from "@cosmicdrift/kumiko-framework/engine";
-import type { FileStorageProvider } from "@cosmicdrift/kumiko-framework/files";
-
-const FEATURE_NAME = "file-foundation";
-
-// =============================================================================
-// Plugin-Interface — what a Provider-Plugin must implement
-// =============================================================================
-
-/**
- * Schmaler Surface-Type fuer Provider-Plugins. HandlerContext ist zu
- * fett (haelt tx, actor, signal etc.) — Provider sollen sich auf die
- * read-Felder beschraenken die fuer Tenant-Config + Secret-Lookup
- * gebraucht werden.
- *
- * **Warum nicht voller HandlerContext?** Im Worker-Pfad (r.job) gibt
- * es keinen request-bezogenen `tx`/`actor`/`signal`. Wenn ein Provider
- * `ctx.tx` lesen wuerde, wuerde der ganze Worker-Pfad zur Runtime
- * brechen — und das wuerde NUR mit S3 und nur in production auffallen.
- * Die schmale Surface zwingt Provider zur expliziten Erweiterung
- * (extra-arg) statt silent ctx-feld-ausnutzen.
- *
- * **Felder:**
- *   config  — fuer tenant-config-reads (bucket/region/endpoint/...)
- *   registry — fuer extension-Lookup in der Factory (nicht Plugin-intern)
- *   secrets — fuer tenant-secret-reads (s3.secretAccessKey)
- *   _userId — Audit-Identity fuer secret-reads. Im Handler-Pfad setzt
- *             der dispatcher das auf die Caller-User-ID; im Worker-Pfad
- *             muss der r.job-Wrap das explizit auf eine System-Identity
- *             setzen (z.B. "system:user-data-rights:run-export-jobs").
- */
-export type FileProviderContext = {
-  readonly config?: ConfigAccessor;
-  readonly registry?: Registry;
-  readonly secrets?: import("@cosmicdrift/kumiko-framework/secrets").SecretsContext;
-  readonly _userId?: string | undefined;
-};
-
-/**
- * File-Storage-Plugin contract. Each provider-feature (file-provider-s3,
- * file-provider-azure-blob, ...) registers an implementation via
- * `r.useExtension("fileProvider", "<name>", { build })`.
- *
- * **Plugin-Author-Warnung:** `ctx` ist EXPLIZIT ein FileProviderContext,
- * nicht ein voller HandlerContext. Felder ausserhalb der schmalen
- * Surface (z.B. `ctx.tx`, `ctx.actor`, `ctx.signal`, `ctx.notify`) sind
- * im Worker-Pfad (r.job-getriggerte Provider-Builds) NICHT vorhanden.
- * Cast `ctx as unknown as HandlerContext` macht den Compiler happy aber
- * fliegt zur Runtime im Worker — und der Crash kommt erst in production
- * mit dem ersten S3-Tenant. Wenn ein Plugin Felder braucht die nicht in
- * FileProviderContext sind: lieber FileProviderContext explizit erweitern
- * (sichtbarer breaking change) als ctx-cast.
- */
-export type FileProviderPlugin = {
-  readonly build: (ctx: FileProviderContext, tenantId: string) => Promise<FileStorageProvider>;
-};
 
-// extension-usage `options` is engine-payload (unknown) — structurally validate
-// instead of casting blind.
-export function isFileProviderPlugin(o: unknown): o is FileProviderPlugin {
-  return typeof o === "object" && o !== null && "build" in o && typeof o.build === "function";
-}
+export type {
+  FileProviderContext,
+  FileProviderPlugin,
+} from "@cosmicdrift/kumiko-framework/files";
+// Moved into the framework — re-exported here so `@cosmicdrift/kumiko-bundled-
+// features/file-foundation` consumers (user-data-rights, app code) keep working.
+export {
+  createFileProviderForTenant,
+  isFileProviderPlugin,
+} from "@cosmicdrift/kumiko-framework/files";
 
-// =============================================================================
-// Feature-definition
-// =============================================================================
+const FEATURE_NAME = "file-foundation";
 
 export const fileFoundationFeature = defineFeature(FEATURE_NAME, (r) => {
   r.describe(
-    "Defines the `fileProvider` extension point and a per-tenant `provider` config key that selects which registered storage plugin to use at runtime. Call `createFileProviderForTenant(ctx, tenantId)` to get a `FileStorageProvider` \u2014 use this feature together with at least one `file-provider-*` feature; the `files` feature builds on top of it for tracked `FileRef` entities with GDPR hooks.",
+    "Defines the `fileProvider` extension point and a per-tenant `provider` config key that selects which registered storage plugin to use at runtime. Call `createFileProviderForTenant(ctx, tenantId)` to get a `FileStorageProvider` — use this feature together with at least one `file-provider-*` feature; the `files` feature builds on top of it for tracked `FileRef` entities with GDPR hooks.",
   );
   r.uiHints({
     displayLabel: "File Provider Foundation",
@@ -106,7 +47,7 @@ export const fileFoundationFeature = defineFeature(FEATURE_NAME, (r) => {
   });
   r.requires("config");
 
-  r.extendsRegistrar("fileProvider", {
+  r.extendsRegistrar(EXT_FILE_PROVIDER, {
     onRegister: () => {
       // No side-effects at register-time — registry stores the usage,
       // factory looks it up at request-time.
@@ -124,61 +65,7 @@ export const fileFoundationFeature = defineFeature(FEATURE_NAME, (r) => {
   });
   // Readiness gating: provider-plugins' required keys/secrets count only
   // while their plugin is the one this key selects.
-  r.extensionSelector("fileProvider", configKeys.provider);
+  r.extensionSelector(EXT_FILE_PROVIDER, configKeys.provider);
 
   return { configKeys };
 });
-
-// =============================================================================
-// Provider-factory — looks up the registered plugin + delegates
-// =============================================================================
-
-export async function createFileProviderForTenant(
-  ctx: FileProviderContext,
-  tenantId: string,
-  handlerName = "file-foundation:provider-factory",
-): Promise<FileStorageProvider> {
-  const ctxConfig = ctx.config;
-  if (!ctxConfig) {
-    throw new Error(
-      `${handlerName}: ctx.config is missing — feature requires the config-feature mounted in the registry`,
-    );
-  }
-  if (!ctx.registry) {
-    throw new Error(
-      `${handlerName}: ctx.registry is missing — required to look up registered file-provider plugins`,
-    );
-  }
-
-  const provider = requireDefined(
-    await ctxConfig(fileFoundationFeature.exports.configKeys.provider),
-    FEATURE_NAME,
-    "provider",
-  ) as string; // @cast-boundary engine-payload
-  if (provider.length === 0) {
-    const usages = ctx.registry.getExtensionUsages("fileProvider");
-    const known = usages.map((u) => u.entityName).join(", ") || "<none>";
-    throw new Error(
-      `${FEATURE_NAME}: no provider selected — set the 'provider' config-key to one of: ${known}. ` +
-        `Mount a file-provider-* feature first if no plugins are registered.`,
-    );
-  }
-
-  const usages = ctx.registry.getExtensionUsages("fileProvider");
-  const usage = usages.find((u) => u.entityName === provider);
-  if (!usage) {
-    const known = usages.map((u) => u.entityName).join(", ") || "<none>";
-    throw new Error(
-      `${FEATURE_NAME}: provider "${provider}" not registered. Known: ${known}. ` +
-        `Mount the matching file-provider-${provider} feature.`,
-    );
-  }
-
-  if (!isFileProviderPlugin(usage.options)) {
-    throw new Error(
-      `${FEATURE_NAME}: provider "${provider}" registered without a build() — ` +
-        `extension options must be a FileProviderPlugin.`,
-    );
-  }
-  return usage.options.build(ctx, tenantId);
-}

package/src/tags/constants.ts

@@ -19,6 +19,12 @@ export const TAGS_SECTION_EXTENSION_NAME = "TagSection";
 // after mounting tagsClient(); the renderer passes it the list's screenId.
 export const TAGS_FILTER_EXTENSION_NAME = "TagFilter";
 
+// Registry name for the <TagsCell> column renderer. A host entityList shows an
+// entity's tags inline by declaring a labeled virtual column:
+// `{ field: "tags", label: "Tags", renderer: { react: { __component: TAGS_COLUMN_RENDERER_NAME } } }`
+// after mounting tagsClient() (which registers it under clientFeatures.columnRenderers).
+export const TAGS_COLUMN_RENDERER_NAME = "TagsCell";
+
 // Screen-id of the standalone Tags management screen (custom screen rendering
 // TagManager). Qualified = "tags:screen:tag-list"; the app places it via r.nav.
 export const TAGS_SCREEN_ID = "tag-list";

package/src/tags/index.ts

@@ -2,6 +2,7 @@ export { tagAssignmentAggregateId } from "./aggregate-id";
 export {
   DEFAULT_TAG_ACCESS,
   DEFAULT_TAG_ROLES,
+  TAGS_COLUMN_RENDERER_NAME,
   TAGS_FEATURE_NAME,
   TAGS_FILTER_EXTENSION_NAME,
   TAGS_SCREEN_ID,

package/src/tags/web/__tests__/tag-filter.test.tsx

@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  createStaticLocaleResolver,
+  LocaleProvider,
+  PrimitivesProvider,
+} from "@cosmicdrift/kumiko-renderer";
+import { defaultPrimitives } from "@cosmicdrift/kumiko-renderer-web";
+import { fireEvent, render, screen } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { TagsQueries } from "../../constants";
+import { defaultTranslations } from "../i18n";
+import { TagFilter } from "../tag-filter";
+
+type TagRow = { id: string; name: string; color?: string };
+type AssignmentRow = { tagId: string; entityType: string; entityId: string };
+
+let catalogRows: readonly TagRow[] = [];
+let assignmentRows: readonly AssignmentRow[] = [];
+const setFilterSpy = mock((_field: string, _values: readonly string[]) => {});
+
+beforeEach(() => {
+  catalogRows = [
+    { id: "t1", name: "urgent", color: "#ef4444" },
+    { id: "t2", name: "backend", color: "#3b82f6" },
+  ];
+  assignmentRows = [
+    { tagId: "t1", entityType: "note", entityId: "n1" },
+    { tagId: "t2", entityType: "note", entityId: "n2" },
+  ];
+  setFilterSpy.mockClear();
+});
+
+const useQuerySpy = mock((type: string) => ({
+  data: type === TagsQueries.tagList ? { rows: catalogRows } : { rows: assignmentRows },
+  loading: false,
+  error: null,
+  refetch: mock(async () => {}),
+}));
+
+const actual_renderer = await import("@cosmicdrift/kumiko-renderer");
+mock.module("@cosmicdrift/kumiko-renderer", () => ({
+  ...actual_renderer,
+  useQuery: useQuerySpy,
+  useListUrlState: () => ({
+    sort: null,
+    q: "",
+    page: 1,
+    filters: {},
+    setSort: mock(() => {}),
+    setQ: mock(() => {}),
+    setPage: mock(() => {}),
+    setFilter: setFilterSpy,
+    clearFilters: mock(() => {}),
+  }),
+}));
+
+// Headless picker stub: a button that reports a tag selection back through the
+// real onChange contract — no Dialog/cmdk popover to drive.
+const StubPicker = ({
+  onChange,
+}: {
+  readonly value: readonly string[];
+  readonly onChange: (next: readonly string[]) => void;
+  readonly entityType: string;
+  readonly open: boolean;
+  readonly onOpenChange: (open: boolean) => void;
+}): ReactNode => (
+  <button type="button" data-testid="picker-pick-t1" onClick={() => onChange(["t1"])}>
+    pick urgent
+  </button>
+);
+mock.module("../tag-picker", () => ({ TagPicker: StubPicker }));
+
+function Wrapper({ children }: { readonly children: ReactNode }): ReactNode {
+  return (
+    <LocaleProvider resolver={createStaticLocaleResolver()} fallbackBundles={[defaultTranslations]}>
+      <PrimitivesProvider value={defaultPrimitives}>{children}</PrimitivesProvider>
+    </LocaleProvider>
+  );
+}
+
+describe("TagFilter", () => {
+  test("idle → just the filter button, no chips, no clear", () => {
+    render(
+      <Wrapper>
+        <TagFilter entityName="note" screenId="note-list" />
+      </Wrapper>,
+    );
+    expect(screen.getByTestId("tag-filter-open")).toBeTruthy();
+    expect(screen.queryByTestId("tag-chip")).toBeNull();
+    expect(screen.queryByTestId("tag-filter-clear")).toBeNull();
+  });
+
+  test("picking a tag → narrows the list to its entity ids + shows the selected chip + clear", () => {
+    render(
+      <Wrapper>
+        <TagFilter entityName="note" screenId="note-list" />
+      </Wrapper>,
+    );
+
+    fireEvent.click(screen.getByTestId("picker-pick-t1"));
+
+    // urgent (t1) is assigned to n1 → list narrows to that id set
+    expect(setFilterSpy).toHaveBeenCalledWith("id", ["n1"]);
+    // the active selection is visible as a chip + a clear affordance
+    expect(screen.getByText("urgent")).toBeTruthy();
+    expect(screen.getByTestId("tag-filter-clear")).toBeTruthy();
+  });
+
+  test("clear → drops the filter and the chip", () => {
+    render(
+      <Wrapper>
+        <TagFilter entityName="note" screenId="note-list" />
+      </Wrapper>,
+    );
+    fireEvent.click(screen.getByTestId("picker-pick-t1"));
+    setFilterSpy.mockClear();
+
+    fireEvent.click(screen.getByTestId("tag-filter-clear"));
+
+    expect(setFilterSpy).toHaveBeenCalledWith("id", []);
+    expect(screen.queryByText("urgent")).toBeNull();
+  });
+});

package/src/tags/web/__tests__/tags-cell.test.tsx

@@ -0,0 +1,94 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  createStaticLocaleResolver,
+  LocaleProvider,
+  PrimitivesProvider,
+} from "@cosmicdrift/kumiko-renderer";
+import { defaultPrimitives } from "@cosmicdrift/kumiko-renderer-web";
+import { render, screen } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { TagsQueries } from "../../constants";
+import { defaultTranslations } from "../i18n";
+import { TagsCell } from "../tags-cell";
+
+type TagRow = { id: string; name: string; color?: string };
+type AssignmentRow = { tagId: string; entityType: string; entityId: string };
+
+let catalogRows: readonly TagRow[] = [];
+let assignmentRows: readonly AssignmentRow[] = [];
+
+beforeEach(() => {
+  catalogRows = [];
+  assignmentRows = [];
+});
+
+const useQuerySpy = mock((type: string) => ({
+  data: type === TagsQueries.tagList ? { rows: catalogRows } : { rows: assignmentRows },
+  loading: false,
+  error: null,
+  refetch: mock(async () => {}),
+}));
+
+const actual_renderer = await import("@cosmicdrift/kumiko-renderer");
+mock.module("@cosmicdrift/kumiko-renderer", () => ({
+  ...actual_renderer,
+  useQuery: useQuerySpy,
+}));
+
+function Wrapper({ children }: { readonly children: ReactNode }): ReactNode {
+  return (
+    <LocaleProvider resolver={createStaticLocaleResolver()} fallbackBundles={[defaultTranslations]}>
+      <PrimitivesProvider value={defaultPrimitives}>{children}</PrimitivesProvider>
+    </LocaleProvider>
+  );
+}
+
+function renderCell(rowId: string): void {
+  render(
+    <Wrapper>
+      <TagsCell value={rowId} row={{ id: rowId }} column={{ field: "tags" }} />
+    </Wrapper>,
+  );
+}
+
+describe("TagsCell", () => {
+  test("renders a chip per tag assigned to the row's id, joined to the catalog", () => {
+    catalogRows = [
+      { id: "t1", name: "important", color: "#ef4444" },
+      { id: "t2", name: "project-x", color: "#3b82f6" },
+    ];
+    assignmentRows = [
+      { tagId: "t1", entityType: "note", entityId: "n1" },
+      { tagId: "t2", entityType: "note", entityId: "n1" },
+      { tagId: "t1", entityType: "note", entityId: "n2" }, // a different row
+    ];
+
+    renderCell("n1");
+
+    expect(screen.getByTestId("tags-cell")).toBeTruthy();
+    expect(screen.getByText("important")).toBeTruthy();
+    expect(screen.getByText("project-x")).toBeTruthy();
+  });
+
+  test("renders nothing when the row has no assigned tags", () => {
+    catalogRows = [{ id: "t1", name: "important" }];
+    assignmentRows = [{ tagId: "t1", entityType: "note", entityId: "other-row" }];
+
+    renderCell("n1");
+
+    expect(screen.queryByTestId("tags-cell")).toBeNull();
+  });
+
+  test("renders nothing for an empty row id", () => {
+    catalogRows = [{ id: "t1", name: "important" }];
+    assignmentRows = [{ tagId: "t1", entityType: "note", entityId: "n1" }];
+
+    render(
+      <Wrapper>
+        <TagsCell value="" row={{}} column={{ field: "tags" }} />
+      </Wrapper>,
+    );
+
+    expect(screen.queryByTestId("tags-cell")).toBeNull();
+  });
+});

package/src/tags/web/client-plugin.tsx

@@ -2,6 +2,7 @@
 
 import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer-web";
 import {
+  TAGS_COLUMN_RENDERER_NAME,
   TAGS_FEATURE_NAME,
   TAGS_FILTER_EXTENSION_NAME,
   TAGS_SCREEN_ID,
@@ -11,6 +12,7 @@ import { defaultTranslations } from "./i18n";
 import { TagFilter } from "./tag-filter";
 import { TagManager } from "./tag-manager";
 import { TagSection } from "./tag-section";
+import { TagsCell } from "./tags-cell";
 
 export function tagsClient(): ClientFeatureDefinition {
   return {
@@ -20,6 +22,10 @@ export function tagsClient(): ClientFeatureDefinition {
       // Header-slot tag filter for any entityList toolbar.
       [TAGS_FILTER_EXTENSION_NAME]: TagFilter,
     },
+    // Inline tag chips on any entityList row, via a labeled virtual column.
+    columnRenderers: {
+      [TAGS_COLUMN_RENDERER_NAME]: TagsCell,
+    },
     // Standalone Tags management screen (custom screen → TagManager).
     components: {
       [TAGS_SCREEN_ID]: TagManager,

package/src/tags/web/i18n.ts

@@ -30,7 +30,7 @@ export const defaultTranslations: TranslationsByLocale = {
     "tags.picker.title": "Tags",
     "tags.picker.done": "Fertig",
     "tags.filter.label": "Nach Tag filtern",
-    "tags.filter.active": "Tags: {count}",
+    "tags.filter.clear": "Filter zurücksetzen",
   },
   en: {
     "tags.section.createMode": "Save the entity first to add tags.",
@@ -55,6 +55,6 @@ export const defaultTranslations: TranslationsByLocale = {
     "tags.picker.title": "Tags",
     "tags.picker.done": "Done",
     "tags.filter.label": "Filter by tag",
-    "tags.filter.active": "Tags: {count}",
+    "tags.filter.clear": "Clear",
   },
 };

package/src/tags/web/index.ts

@@ -1,5 +1,6 @@
 // @runtime client
 export {
+  TAGS_COLUMN_RENDERER_NAME,
   TAGS_FILTER_EXTENSION_NAME,
   TAGS_SCREEN_ID,
   TAGS_SECTION_EXTENSION_NAME,
@@ -13,3 +14,4 @@ export { TagFilter } from "./tag-filter";
 export { TagManager } from "./tag-manager";
 export { TagPicker } from "./tag-picker";
 export { TagSection } from "./tag-section";
+export { TagsCell } from "./tags-cell";

package/src/tags/web/tag-filter.tsx

@@ -1,10 +1,13 @@
 // @runtime client
 // TagFilter — a drop-in tag filter for ANY entityList toolbar. Register it as
-// the list's header slot (`screen.slots.header`) and mark `id` filterable is NOT
-// needed — the renderer passes this control the list's screenId, and picking
-// tags resolves the matching row ids and narrows the list via an id-set URL
-// filter (`<screenId>.f.id=…`, applied as `{ field: "id", op: "in" }`). No host
-// schema change: any list gets tag-filtering by mounting this in its header.
+// the list's header slot (`screen.slots.header`); the renderer passes it the
+// list's screenId, and picking tags resolves the matching row ids and narrows
+// the list via an id-set URL filter (`<screenId>.f.id=…`, applied as
+// `{ field: "id", op: "in" }`). No host schema change: any list gets
+// tag-filtering by mounting this in its header.
+//
+// The active selection is shown inline as colored chips next to the button, with
+// a clear affordance — so the filter is visible, not hidden behind a count.
 //
 // ponytail: resolves ids from the assignment list (first 500 rows) + an id-IN
 // URL filter — fine for typical tag volumes. For huge assignment sets add a
@@ -18,6 +21,7 @@ import {
 } from "@cosmicdrift/kumiko-renderer";
 import { type ReactNode, useState } from "react";
 import { TagsQueries } from "../constants";
+import { TagChip } from "./tag-chip";
 import { TagPicker } from "./tag-picker";
 
 // Tags chosen but zero matching entities → filter to a value that matches no row
@@ -29,6 +33,7 @@ type AssignmentRow = {
   readonly entityType: string;
   readonly entityId: string;
 };
+type TagRow = { readonly id: string; readonly name: string; readonly color?: string | null };
 
 export function TagFilter({
   entityName,
@@ -42,6 +47,7 @@ export function TagFilter({
   const t = useTranslation();
   const [open, setOpen] = useState(false);
   const [selected, setSelected] = useState<readonly string[]>([]);
+  const catalog = useQuery<{ rows: readonly TagRow[] }>(TagsQueries.tagList, {});
   const assignments = useQuery<{ rows: readonly AssignmentRow[] }>(TagsQueries.assignmentList, {
     limit: 500,
   });
@@ -66,16 +72,22 @@ export function TagFilter({
     urlState.setFilter("id", ids.length > 0 ? ids : [NO_MATCH]);
   };
 
-  const label =
-    selected.length > 0
-      ? t("tags.filter.active", { count: selected.length })
-      : t("tags.filter.label");
+  const byId = new Map((catalog.data?.rows ?? []).map((tg) => [tg.id, tg]));
 
   return (
-    <>
+    <div className="flex flex-wrap items-center gap-1">
       <Button variant="secondary" onClick={() => setOpen(true)} testId="tag-filter-open">
-        {label}
+        {t("tags.filter.label")}
       </Button>
+      {selected.map((id) => {
+        const tag = byId.get(id);
+        return <TagChip key={id} name={tag?.name ?? id} color={tag?.color} />;
+      })}
+      {selected.length > 0 && (
+        <Button variant="secondary" onClick={() => applyFilter([])} testId="tag-filter-clear">
+          {t("tags.filter.clear")}
+        </Button>
+      )}
       <TagPicker
         entityType={entityName}
         value={selected}
@@ -83,6 +95,6 @@ export function TagFilter({
         open={open}
         onOpenChange={setOpen}
       />
-    </>
+    </div>
   );
 }

package/src/tags/web/tags-cell.tsx

@@ -0,0 +1,46 @@
+// @runtime client
+// TagsCell — a reusable columnRenderer that shows an entity's tags as colored
+// chips inline in a list row. Drop it into ANY entityList by declaring a labeled
+// virtual column (no host-schema change), after mounting tagsClient():
+//   columns: [
+//     "title",
+//     { field: "tags", label: "Tags",
+//       renderer: { react: { __component: TAGS_COLUMN_RENDERER_NAME } } },
+//   ]
+// It reads the row's id (entity ids are unique, so entityType is unnecessary)
+// and renders a TagChip per assigned tag; renders nothing when the row has none.
+//
+// ponytail: bulk-loads the assignment list (first 500) + the catalog once and
+// filters per row — kumiko's useQuery dedupes the identical (type, payload)
+// calls, so the whole column shares two queries, not two-per-row. For huge
+// assignment sets add a server-side entitiesByTag query + join filter.
+
+import { type ColumnRendererProps, useQuery } from "@cosmicdrift/kumiko-renderer";
+import type { ReactNode } from "react";
+import { TagsQueries } from "../constants";
+import { TagChip } from "./tag-chip";
+
+type TagRow = { readonly id: string; readonly name: string; readonly color?: string | null };
+type AssignmentRow = { readonly tagId: string; readonly entityId: string };
+
+export function TagsCell({ row }: ColumnRendererProps): ReactNode {
+  const entityId = String(row["id"] ?? "");
+  const catalog = useQuery<{ rows: readonly TagRow[] }>(TagsQueries.tagList, {});
+  const assignments = useQuery<{ rows: readonly AssignmentRow[] }>(TagsQueries.assignmentList, {
+    limit: 500,
+  });
+  if (entityId === "") return null;
+  const byId = new Map((catalog.data?.rows ?? []).map((t) => [t.id, t]));
+  const tagIds = (assignments.data?.rows ?? [])
+    .filter((a) => a.entityId === entityId)
+    .map((a) => a.tagId);
+  if (tagIds.length === 0) return null;
+  return (
+    <div className="flex flex-wrap gap-1" data-testid="tags-cell">
+      {tagIds.map((id) => {
+        const tag = byId.get(id);
+        return <TagChip key={id} name={tag?.name ?? id} color={tag?.color} />;
+      })}
+    </div>
+  );
+}

package/src/user-data-rights/__tests__/file-binary-forget-cleanup.integration.test.ts

@@ -80,7 +80,6 @@ beforeAll(async () => {
       createUserDataRightsFeature(),
       createUserDataRightsDefaultsFeature(),
     ],
-    files: { storageProvider: provider },
     extraContext: ({ registry }) => ({
       configResolver: resolver,
       _configAccessorFactory: createConfigAccessorFactory(registry, resolver),

package/src/user-data-rights/__tests__/file-binary-forget-failure.integration.test.ts

@@ -90,7 +90,6 @@ beforeAll(async () => {
       createUserDataRightsFeature(),
       createUserDataRightsDefaultsFeature(),
     ],
-    files: { storageProvider: flakyProvider },
     extraContext: ({ registry }) => ({
       configResolver: resolver,
       _configAccessorFactory: createConfigAccessorFactory(registry, resolver),

package/src/user-data-rights/__tests__/file-storage-unification.integration.test.ts

@@ -0,0 +1,162 @@
+// #608 trap-closed regression: uploads and erasure resolve the file provider
+// through ONE source (file-foundation), end-to-end through the real server.
+//
+// The stack mounts file-foundation + a provider plugin but does NOT inject a
+// resolver (no `files:` option) — so buildServer must build the upload-route
+// resolver itself from the mounted features, exactly as production does. A file
+// uploaded through POST /api/files must land in the SAME store the GDPR forget
+// pipeline deletes from. Before the unification the upload route wrote through a
+// separately-wired provider while erasure deleted through file-foundation — so a
+// regression to a static `storageProvider` makes the `provider.exists(...)`
+// assertion below go red.
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import { type SessionUser, SYSTEM_USER_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  createInMemoryFileProvider,
+  type FileStorageProvider,
+  fileRefsTable,
+  type InMemoryFileProvider,
+} from "@cosmicdrift/kumiko-framework/files";
+import {
+  setupTestStack,
+  type TestStack,
+  unsafeCreateEntityTable,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/stack";
+import {
+  buildMultipartBody,
+  patchFileInstanceofForBunTest,
+  resetTestTables,
+} from "@cosmicdrift/kumiko-framework/testing";
+import { createComplianceProfilesFeature } from "../../compliance-profiles";
+import { createConfigFeature } from "../../config";
+import { createConfigAccessorFactory } from "../../config/feature";
+import { createConfigResolver } from "../../config/resolver";
+import { configValuesTable } from "../../config/table";
+import { createDataRetentionFeature, tenantRetentionOverrideEntity } from "../../data-retention";
+import { fileFoundationFeature } from "../../file-foundation";
+import { createFilesFeature } from "../../files";
+import { createSessionsFeature } from "../../sessions";
+import { createUserFeature, userEntity, userTable } from "../../user";
+import { createUserDataRightsDefaultsFeature } from "../../user-data-rights-defaults";
+import { createUserDataRightsFeature } from "../feature";
+import { makeTenantStorageProviderResolver } from "../lib/storage-provider-resolver";
+import { runForgetCleanup } from "../run-forget-cleanup";
+import {
+  createForgetSeeders,
+  createTestFileProviderFeature,
+  type ForgetSeeders,
+  nowInstant,
+  READ_TENANT_MEMBERSHIPS_DDL,
+  TENANT_SYSTEM,
+} from "./forget-test-helpers";
+
+const FILE_PROVIDER_CONFIG_KEY = "file-foundation:config:provider";
+
+let stack: TestStack;
+let db: DbConnection;
+let provider: InMemoryFileProvider;
+let seed: ForgetSeeders;
+let buildStorageProvider: (tenantId: string) => Promise<FileStorageProvider>;
+
+function uuid(suffix: number): string {
+  return `cccccccc-cccc-4ccc-8ccc-${suffix.toString(16).padStart(12, "0")}`;
+}
+
+async function uploadAs(user: SessionUser, fileName: string, bytes: Uint8Array): Promise<Response> {
+  const token = await stack.jwt.sign(user);
+  const fd = new FormData();
+  fd.append("file", new File([Buffer.from(bytes)], fileName, { type: "application/pdf" }));
+  const { body, contentType } = await buildMultipartBody(fd);
+  return stack.app.request("/api/files", {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+    body,
+  });
+}
+
+beforeAll(async () => {
+  patchFileInstanceofForBunTest();
+  provider = createInMemoryFileProvider();
+  // Select the test plugin app-wide via a config app-override (no admin write).
+  const appOverrides = new Map<string, string>([[FILE_PROVIDER_CONFIG_KEY, "test"]]);
+  const resolver = createConfigResolver({ appOverrides });
+  stack = await setupTestStack({
+    features: [
+      createConfigFeature(),
+      createUserFeature(),
+      createFilesFeature(),
+      fileFoundationFeature,
+      createTestFileProviderFeature(provider, "test"),
+      createDataRetentionFeature(),
+      createComplianceProfilesFeature(),
+      createSessionsFeature(),
+      createUserDataRightsFeature(),
+      createUserDataRightsDefaultsFeature(),
+    ],
+    // No `files:` option on purpose — buildServer must resolve the upload
+    // provider through the mounted file-foundation, like production.
+    extraContext: ({ registry }) => ({
+      configResolver: resolver,
+      _configAccessorFactory: createConfigAccessorFactory(registry, resolver),
+    }),
+  });
+  db = stack.db;
+  seed = createForgetSeeders(db, provider);
+  buildStorageProvider = makeTenantStorageProviderResolver({
+    registry: stack.registry,
+    configResolver: resolver,
+    secrets: undefined,
+    db,
+    userId: SYSTEM_USER_ID,
+    handlerName: "test-608-e2e",
+  });
+
+  await unsafeCreateEntityTable(db, userEntity);
+  await unsafeCreateEntityTable(db, tenantRetentionOverrideEntity);
+  await unsafePushTables(db, { fileRefsTable, configValuesTable });
+  await createEventsTable(db);
+  await asRawClient(db).unsafe(READ_TENANT_MEMBERSHIPS_DDL);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+beforeEach(async () => {
+  provider.clear();
+  await resetTestTables(db, [userTable, "read_tenant_memberships", fileRefsTable]);
+});
+
+describe("#608 unified file-storage :: route upload + GDPR erasure hit one store", () => {
+  test("a file uploaded via /api/files lands in the file-foundation store and forget erases it", async () => {
+    const userId = uuid(1);
+    // The uploader is also the forget subject (DeletionRequested + grace passed).
+    await seed.seedForgetUser(userId);
+    await seed.seedMembership(userId, TENANT_SYSTEM);
+    const uploader: SessionUser = { id: userId, tenantId: TENANT_SYSTEM, roles: ["Member"] };
+
+    const res = await uploadAs(uploader, "secret.pdf", new Uint8Array([10, 20, 30, 40]));
+    expect(res.status).toBe(201);
+    const { storageKey } = (await res.json()) as { storageKey: string };
+
+    // The upload route resolved its provider through file-foundation — the bytes
+    // are in `provider`. A static/separate upload provider would miss here.
+    expect(await provider.exists(storageKey)).toBe(true);
+
+    // Erasure resolves through the SAME source and deletes the very same bytes —
+    // no false "done", no orphaned binary.
+    const result = await runForgetCleanup({
+      db,
+      registry: stack.registry,
+      now: nowInstant(),
+      buildStorageProvider,
+    });
+    expect(result.processedUserIds).toContain(userId);
+    expect(await provider.exists(storageKey)).toBe(false);
+  });
+});