@cosmicdrift/kumiko-framework 0.133.0 → 0.135.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.133.0",
+  "version": "0.135.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -189,7 +189,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-dispatcher-live": "0.133.0",
+    "@cosmicdrift/kumiko-dispatcher-live": "0.135.0",
     "bun-types": "^1.3.13",
     "pino-pretty": "^13.1.3"
   },

package/src/engine/__tests__/boot-validator-dashboard.test.ts

@@ -12,15 +12,25 @@ const STAT_PANEL = {
   valueField: "count",
 } as const;
 
-function dashboardFeature(panels: DashboardScreenDefinition["panels"]) {
+function dashboardFeature(
+  panels: DashboardScreenDefinition["panels"],
+  filter?: DashboardScreenDefinition["filter"],
+) {
   return defineFeature("demo", (r) => {
-    r.screen({ id: "overview", type: "dashboard", panels });
+    r.screen({
+      id: "overview",
+      type: "dashboard",
+      panels,
+      ...(filter !== undefined && { filter }),
+    });
     r.translations({
       keys: {
         "screen:overview.title": { de: "Übersicht", en: "Overview" },
         "demo:dashboard:panel:open-incidents": { de: "Offene Vorfälle", en: "Open incidents" },
         "demo:dashboard:panel:latest": { de: "Neueste", en: "Latest" },
         "demo:dashboard:col:name": { de: "Name", en: "Name" },
+        "demo:dashboard:group:net-worth": { de: "Net Worth", en: "Net Worth" },
+        "demo:dashboard:filter:region": { de: "Region", en: "Region" },
       },
     });
   });
@@ -90,4 +100,128 @@ describe("validateBoot — dashboard screens", () => {
     expect(keys).toContain("demo:dashboard:panel:latest");
     expect(keys).toContain("demo:dashboard:col:name");
   });
+
+  test("accepts a stat-group, feed, progress-list and custom panel", () => {
+    const feature = dashboardFeature(
+      [
+        {
+          kind: "stat-group",
+          id: "net-worth",
+          label: "demo:dashboard:group:net-worth",
+          stats: [STAT_PANEL],
+        },
+        {
+          kind: "feed",
+          id: "upcoming",
+          label: "demo:dashboard:panel:latest",
+          query: "demo:query:incident:latest",
+        },
+        {
+          kind: "progress-list",
+          id: "progress",
+          label: "demo:dashboard:panel:latest",
+          query: "demo:query:incident:latest",
+        },
+        {
+          kind: "custom",
+          id: "custom-panel",
+          component: { react: { __component: "demo-custom" } },
+        },
+      ],
+      {
+        id: "region",
+        label: "demo:dashboard:filter:region",
+        kind: "select",
+        options: [{ value: "eu", label: "demo:dashboard:filter:region" }],
+      },
+    );
+    expect(() => validateBoot([feature])).not.toThrow();
+  });
+
+  test("rejects a stat-group with an empty stats list", () => {
+    const feature = dashboardFeature([
+      { kind: "stat-group", id: "net-worth", label: "demo:dashboard:group:net-worth", stats: [] },
+    ]);
+    expect(() => validateBoot([feature])).toThrow(/empty stats list/);
+  });
+
+  test("rejects a duplicate id nested inside a stat-group", () => {
+    const feature = dashboardFeature([
+      STAT_PANEL,
+      {
+        kind: "stat-group",
+        id: "net-worth",
+        label: "demo:dashboard:group:net-worth",
+        stats: [STAT_PANEL],
+      },
+    ]);
+    expect(() => validateBoot([feature])).toThrow(/duplicate panel id/);
+  });
+
+  test("rejects a custom panel without a react/native component", () => {
+    const feature = dashboardFeature([{ kind: "custom", id: "custom-panel", component: {} }]);
+    expect(() => validateBoot([feature])).toThrow(/has no component/);
+  });
+
+  test("rejects a filter that sets neither options nor optionsQuery", () => {
+    const feature = dashboardFeature([STAT_PANEL], {
+      id: "region",
+      label: "demo:dashboard:filter:region",
+      kind: "select",
+    });
+    expect(() => validateBoot([feature])).toThrow(/exactly one of/);
+  });
+
+  test("rejects a filter that sets both options and optionsQuery", () => {
+    const feature = dashboardFeature([STAT_PANEL], {
+      id: "region",
+      label: "demo:dashboard:filter:region",
+      kind: "select",
+      options: [{ value: "eu", label: "demo:dashboard:filter:region" }],
+      optionsQuery: "demo:query:folder:list",
+    });
+    expect(() => validateBoot([feature])).toThrow(/exactly one of/);
+  });
+
+  test("rejects a filter with an empty options list", () => {
+    const feature = dashboardFeature([STAT_PANEL], {
+      id: "region",
+      label: "demo:dashboard:filter:region",
+      kind: "select",
+      options: [],
+    });
+    expect(() => validateBoot([feature])).toThrow(/filter.options is empty/);
+  });
+
+  test("requiredKeysFromScreen sammelt stat-group-Kinder- und Filter-Labels, aber keine custom-Panel-Keys", () => {
+    const screen: DashboardScreenDefinition = {
+      id: "overview",
+      type: "dashboard",
+      filter: {
+        id: "region",
+        label: "demo:dashboard:filter:region",
+        kind: "select",
+        options: [{ value: "eu", label: "demo:dashboard:col:name" }],
+      },
+      panels: [
+        {
+          kind: "stat-group",
+          id: "net-worth",
+          label: "demo:dashboard:group:net-worth",
+          stats: [STAT_PANEL],
+        },
+        {
+          kind: "custom",
+          id: "custom-panel",
+          component: { react: { __component: "demo-custom" } },
+        },
+      ],
+    };
+    const keys = requiredKeysFromScreen("demo", screen);
+    expect(keys).toContain("demo:dashboard:group:net-worth");
+    expect(keys).toContain("demo:dashboard:panel:open-incidents");
+    expect(keys).toContain("demo:dashboard:filter:region");
+    expect(keys).toContain("demo:dashboard:col:name");
+    expect(keys).not.toContain("custom-panel");
+  });
 });

package/src/engine/__tests__/boot-validator-located-timestamps.test.ts

@@ -7,25 +7,9 @@
 import { describe, expect, test } from "bun:test";
 import { validateBoot } from "../boot-validator";
 import { defineFeature } from "../define-feature";
-import { createEntity, createTimestampField, createTzField, locatedTimestamp } from "../factories";
+import { createEntity, createTimestampField, createTzField } from "../factories";
 
 describe("validateBoot — locatedBy markers", () => {
-  test("locatedTimestamp(name) Helper-Pair passiert validiert (positive case)", () => {
-    const feature = defineFeature("test", (r) => {
-      r.entity(
-        "order",
-        createEntity({
-          fields: {
-            ...locatedTimestamp("pickup"),
-            ...locatedTimestamp("delivery"),
-          },
-        }),
-      );
-    });
-
-    expect(() => validateBoot([feature])).not.toThrow();
-  });
-
   test("manuelle Konstruktion mit korrektem Pair passiert (positive case)", () => {
     const feature = defineFeature("test", (r) => {
       r.entity(
@@ -75,7 +59,7 @@ describe("validateBoot — locatedBy markers", () => {
     expect(() => validateBoot([feature])).toThrow(/expected "tz"/);
   });
 
-  test("Fehlermeldung verweist auf locatedTimestamp-Helper als Fix", () => {
+  test("Fehlermeldung verweist auf createLocatedTimestampField als Fix", () => {
     const feature = defineFeature("test", (r) => {
       r.entity(
         "order",
@@ -87,7 +71,7 @@ describe("validateBoot — locatedBy markers", () => {
       );
     });
 
-    expect(() => validateBoot([feature])).toThrow(/locatedTimestamp\("pickup"\)/);
+    expect(() => validateBoot([feature])).toThrow(/createLocatedTimestampField/);
   });
 
   test("Timestamp ohne locatedBy ist OK (reiner UTC-Instant)", () => {

package/src/engine/__tests__/factories-time.test.ts

@@ -1,17 +1,12 @@
 // Unit-Tests für die neuen Time-Field-Factories
-// (createTimestampField, createTzField, locatedTimestamp).
+// (createTimestampField, createTzField, createLocatedTimestampField).
 //
 // Test-Fokus: korrektes Field-Shape + locatedBy-Marker-Verdrahtung. Die
 // echte TZ-Konvertierung (Wall-Clock ↔ UTC) testen wir später beim
 // DB-Wrapper-Schritt.
 
 import { describe, expect, test } from "bun:test";
-import {
-  createLocatedTimestampField,
-  createTimestampField,
-  createTzField,
-  locatedTimestamp,
-} from "../factories";
+import { createLocatedTimestampField, createTimestampField, createTzField } from "../factories";
 
 describe("createTimestampField", () => {
   test("default-Form ist nicht-required UTC-Instant ohne locatedBy", () => {
@@ -57,65 +52,6 @@ describe("createTzField", () => {
   });
 });
 
-describe("locatedTimestamp(name) Helper", () => {
-  test("erzeugt korrektes Pair aus <name>At + <name>Tz mit locatedBy-Verdrahtung", () => {
-    const fields = locatedTimestamp("pickup");
-    expect(fields).toEqual({
-      pickupAt: { type: "timestamp", locatedBy: "pickupTz" },
-      pickupTz: { type: "tz" },
-    });
-  });
-
-  test("required-Override propagiert auf BEIDE Felder", () => {
-    const fields = locatedTimestamp("delivery", { required: true });
-    expect(fields).toEqual({
-      deliveryAt: { type: "timestamp", locatedBy: "deliveryTz", required: true },
-      deliveryTz: { type: "tz", required: true },
-    });
-  });
-
-  test("access-Override propagiert auf BEIDE Felder (Field-Level Read-Access)", () => {
-    const fields = locatedTimestamp("internal", {
-      access: { read: ["Dispatcher"] },
-    });
-    expect(fields).toEqual({
-      internalAt: {
-        type: "timestamp",
-        locatedBy: "internalTz",
-        access: { read: ["Dispatcher"] },
-      },
-      internalTz: { type: "tz", access: { read: ["Dispatcher"] } },
-    });
-  });
-
-  test("locatedBy-Marker zeigt immer auf das EIGENE Tz-Feld (nicht auf einen anderen Namen)", () => {
-    // Das ist der Kern des Patterns — wenn die zwei Felder nicht
-    // konsistent verdrahtet sind, fliegt der Boot-Validator (kommt in
-    // späterer Iteration). Hier prüfen wir die Helper-Garantie.
-    for (const name of ["a", "x_y", "long_field_name"]) {
-      const fields = locatedTimestamp(name);
-      const at = fields[`${name}At`];
-      if (at?.type !== "timestamp") throw new Error("at field missing");
-      expect(at.locatedBy).toBe(`${name}Tz`);
-    }
-  });
-
-  test("Spread in createEntity-fields Kompositions-tauglich", () => {
-    // Realer Use-Case: pickup + delivery in einer Entity, plus normale Felder.
-    const entityFields = {
-      ...locatedTimestamp("pickup"),
-      ...locatedTimestamp("delivery"),
-      // Kein Konflikt zwischen den beiden Pairs.
-    };
-    expect(Object.keys(entityFields).sort()).toEqual([
-      "deliveryAt",
-      "deliveryTz",
-      "pickupAt",
-      "pickupTz",
-    ]);
-  });
-});
-
 describe("createLocatedTimestampField (Phase A — atomarer Field-Type)", () => {
   test("default-Form ist nicht-required mit type 'locatedTimestamp'", () => {
     expect(createLocatedTimestampField()).toEqual({

package/src/engine/__tests__/{visual-tree-patterns.test.ts → tree-actions-patterns.test.ts}

@@ -1,15 +1,5 @@
 import { describe, expect, test } from "bun:test";
 import { buildTarget, createRegistry, defineFeature } from "../index";
-import type { TreeChildrenSubscribe, TreeNode } from "../types/tree-node";
-
-// Stub-Provider für Tests. Form: (ctx) => (emit) => unsubscribe.
-// Emittet einmal initial, kein Cleanup nötig (no-op unsubscribe).
-function makeStubProvider(nodes: readonly TreeNode[]): TreeChildrenSubscribe {
-  return () => (emit) => {
-    emit(nodes);
-    return () => {};
-  };
-}
 
 describe("r.treeActions — registrar slot", () => {
   test("feature without r.treeActions leaves the slot undefined", () => {
@@ -63,80 +53,12 @@ describe("r.treeActions — registrar slot", () => {
   });
 });
 
-describe("r.tree — registrar slot", () => {
-  test("feature without r.tree leaves the slot undefined", () => {
-    const feature = defineFeature("empty", () => {});
-    expect(feature.treeProvider).toBeUndefined();
-  });
-
-  test("single r.tree call stores the provider function on the FeatureDefinition", () => {
-    const provider = makeStubProvider([{ label: "Marketing" }]);
-    const feature = defineFeature("text-content", (r) => {
-      r.tree(provider);
-    });
-    expect(feature.treeProvider).toBe(provider);
-  });
-
-  test("second r.tree call throws — only-once-guard", () => {
-    expect(() =>
-      defineFeature("dupe", (r) => {
-        r.tree(makeStubProvider([]));
-        r.tree(makeStubProvider([]));
-      }),
-    ).toThrow(/r\.tree\(\) already called/);
-  });
-
-  test("treeActions and tree are independent slots — can declare one without the other", () => {
-    const onlyActions = defineFeature("a", (r) => {
-      r.treeActions({ list: {} });
-    });
-    expect(onlyActions.treeActions).toBeDefined();
-    expect(onlyActions.treeProvider).toBeUndefined();
-
-    const onlyProvider = defineFeature("b", (r) => {
-      r.tree(makeStubProvider([]));
-    });
-    expect(onlyProvider.treeActions).toBeUndefined();
-    expect(onlyProvider.treeProvider).toBeDefined();
-  });
-});
-
-describe("Registry.getTreeProviders + getTreeActions", () => {
-  test("empty registry returns empty providers map and undefined actions", () => {
+describe("Registry.getTreeActions", () => {
+  test("empty registry returns undefined actions", () => {
     const reg = createRegistry([]);
-    expect(reg.getTreeProviders().size).toBe(0);
     expect(reg.getTreeActions("nonexistent")).toBeUndefined();
   });
 
-  test("aggregates providers from multiple features keyed by feature name", () => {
-    const providerA = makeStubProvider([{ label: "A-root" }]);
-    const providerB = makeStubProvider([{ label: "B-root" }]);
-    const featureA = defineFeature("text-content", (r) => {
-      r.tree(providerA);
-    });
-    const featureB = defineFeature("legal-pages", (r) => {
-      r.tree(providerB);
-    });
-    const reg = createRegistry([featureA, featureB]);
-
-    const providers = reg.getTreeProviders();
-    expect(providers.size).toBe(2);
-    expect(providers.get("text-content")).toBe(providerA);
-    expect(providers.get("legal-pages")).toBe(providerB);
-  });
-
-  test("features without r.tree are absent from the providers map (Zero-Whitelist-Filter)", () => {
-    const featureWithProvider = defineFeature("text-content", (r) => {
-      r.tree(makeStubProvider([]));
-    });
-    const featureWithoutProvider = defineFeature("schema-editor", () => {});
-    const reg = createRegistry([featureWithProvider, featureWithoutProvider]);
-
-    const providers = reg.getTreeProviders();
-    expect(providers.has("text-content")).toBe(true);
-    expect(providers.has("schema-editor")).toBe(false);
-  });
-
   test("getTreeActions returns the erased map for a feature that declared r.treeActions", () => {
     const feature = defineFeature("text-content", (r) => {
       r.treeActions({
@@ -153,9 +75,7 @@ describe("Registry.getTreeProviders + getTreeActions", () => {
   });
 
   test("getTreeActions returns undefined for a feature without r.treeActions", () => {
-    const feature = defineFeature("no-actions", (r) => {
-      r.tree(makeStubProvider([]));
-    });
+    const feature = defineFeature("no-actions", () => {});
     const reg = createRegistry([feature]);
 
     expect(reg.getTreeActions("no-actions")).toBeUndefined();
@@ -169,7 +89,7 @@ describe("Registry.getTreeProviders + getTreeActions", () => {
 // returnt einen typed Handle, der via setup-export durch FeatureDefinition
 // fließt und compile-time-typisiert vom Schicht-1-buildTarget konsumiert
 // wird. Ohne diese Tests würde ein Type-Drift in einer der zwei Schichten
-// erst in V.1.1 sichtbar — siehe advisor-Verdict + Memory `[EventDef-
+// erst spät sichtbar — siehe advisor-Verdict + Memory `[EventDef-
 // Exports-Pattern]`.
 // =============================================================================
 

package/src/engine/boot-validator/entity-handler.ts

@@ -178,8 +178,9 @@ export function validateMultiStreamProjections(feature: FeatureDefinition): void
 //
 // Die häufigste Quelle von Konflikten ist Hand-Konstruktion:
 //   { foo: { type: "timestamp", locatedBy: "fooTz" } }
-// ohne das `fooTz`-Feld zu deklarieren. Der `locatedTimestamp(name)` Helper
-// macht das Pair atomar — wer ihn nutzt, fliegt nicht durch diesen Validator.
+// ohne das `fooTz`-Feld zu deklarieren. `createLocatedTimestampField()`
+// erzeugt stattdessen EIN Feld vom Typ "locatedTimestamp" — wer den nutzt,
+// fliegt nicht durch diesen Validator.
 export function validateLocatedTimestamps(feature: FeatureDefinition): void {
   for (const [entityName, entity] of Object.entries(feature.entities ?? {})) {
     const fields = entity.fields;
@@ -190,8 +191,8 @@ export function validateLocatedTimestamps(feature: FeatureDefinition): void {
         throw new Error(
           `Feature "${feature.name}", entity "${entityName}": field "${fieldName}" has ` +
             `locatedBy: "${field.locatedBy}" but no field with that name exists in the entity. ` +
-            `Either declare the tz-field, or use the locatedTimestamp("${fieldName.replace(/At$/, "")}") helper ` +
-            `to create the pair atomically.`,
+            `Either declare the tz-field, or use createLocatedTimestampField() ` +
+            `to create a single located-timestamp field instead.`,
         );
       }
       if (referenced.type !== "tz") {

package/src/engine/boot-validator/screens-nav.ts

@@ -4,7 +4,11 @@ import { qualifyEntityName } from "../qualified-name";
 import { getAllowedFilterOps, isFieldFilterable } from "../screen-filter-ops";
 import type { FeatureDefinition, NavDefinition, WorkspaceDefinition } from "../types";
 import type {
+  DashboardCustomPanel,
+  DashboardFilterDefinition,
+  DashboardPanelDefinition,
   DashboardScreenDefinition,
+  DashboardStatGroupPanel,
   FieldCondition,
   RowAction,
   RowFieldExtractor,
@@ -655,36 +659,128 @@ function validateDashboardScreen(
     );
   }
   const panelIds = new Set<string>();
+  const addPanelId = (id: string, context: string): void => {
+    if (panelIds.has(id)) {
+      throw new Error(
+        `[Feature ${featureName}] Screen "${screenId}" (dashboard) has duplicate panel id "${id}" (${context}).`,
+      );
+    }
+    panelIds.add(id);
+  };
+
   for (const panel of screen.panels) {
-    if (panelIds.has(panel.id)) {
+    addPanelId(panel.id, panel.kind);
+    if (panel.kind === "stat-group") {
+      validateDashboardStatGroupPanel(featureName, screenId, panel, addPanelId);
+    } else if (panel.kind === "custom") {
+      validateDashboardCustomPanel(featureName, screenId, panel);
+    } else {
+      validateDashboardQueryPanel(featureName, screenId, panel);
+    }
+  }
+
+  if (screen.filter !== undefined) {
+    validateDashboardFilterDefinition(featureName, screenId, screen.filter);
+  }
+}
+
+function validateDashboardStatGroupPanel(
+  featureName: string,
+  screenId: string,
+  panel: DashboardStatGroupPanel,
+  addPanelId: (id: string, context: string) => void,
+): void {
+  if (panel.stats.length === 0) {
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-group "${panel.id}" has an empty stats list.`,
+    );
+  }
+  for (const stat of panel.stats) {
+    addPanelId(stat.id, "stat-group child");
+    if (!stat.query || typeof stat.query !== "string") {
       throw new Error(
-        `[Feature ${featureName}] Screen "${screenId}" (dashboard) has duplicate panel id "${panel.id}".`,
+        `[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-group "${panel.id}" child "${stat.id}" has empty or non-string query.`,
       );
     }
-    panelIds.add(panel.id);
-    if (!panel.query || typeof panel.query !== "string") {
+    if (stat.valueField.length === 0) {
       throw new Error(
-        `[Feature ${featureName}] Screen "${screenId}" (dashboard) panel "${panel.id}" has empty or non-string query.`,
+        `[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-group "${panel.id}" child "${stat.id}" has empty valueField.`,
       );
     }
-    if (panel.kind === "stat" && panel.valueField.length === 0) {
+  }
+}
+
+function validateDashboardCustomPanel(
+  featureName: string,
+  screenId: string,
+  panel: DashboardCustomPanel,
+): void {
+  if (panel.component.react === undefined && panel.component.native === undefined) {
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (dashboard) custom-panel "${panel.id}" has no component — ` +
+        `declare a react/native component marker.`,
+    );
+  }
+}
+
+function validateDashboardQueryPanel(
+  featureName: string,
+  screenId: string,
+  panel: Exclude<DashboardPanelDefinition, DashboardStatGroupPanel | DashboardCustomPanel>,
+): void {
+  if (!panel.query || typeof panel.query !== "string") {
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (dashboard) panel "${panel.id}" has empty or non-string query.`,
+    );
+  }
+  if (panel.kind === "stat" && panel.valueField.length === 0) {
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-panel "${panel.id}" has empty valueField.`,
+    );
+  }
+  if (panel.kind === "list") {
+    if (panel.columns.length === 0) {
       throw new Error(
-        `[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-panel "${panel.id}" has empty valueField.`,
+        `[Feature ${featureName}] Screen "${screenId}" (dashboard) list-panel "${panel.id}" has an empty columns list.`,
       );
     }
-    if (panel.kind === "list") {
-      if (panel.columns.length === 0) {
-        throw new Error(
-          `[Feature ${featureName}] Screen "${screenId}" (dashboard) list-panel "${panel.id}" has an empty columns list.`,
-        );
-      }
-      for (const col of panel.columns) {
-        validateColumnRendererForm(featureName, screenId, normalizeListColumn(col));
-      }
+    for (const col of panel.columns) {
+      validateColumnRendererForm(featureName, screenId, normalizeListColumn(col));
     }
   }
 }
 
+function validateDashboardFilterDefinition(
+  featureName: string,
+  screenId: string,
+  filter: DashboardFilterDefinition,
+): void {
+  if (filter.id.length === 0) {
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (dashboard) filter has an empty id.`,
+    );
+  }
+  if (filter.label.length === 0) {
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (dashboard) filter has an empty label.`,
+    );
+  }
+  const hasOptions = filter.options !== undefined;
+  const hasOptionsQuery = filter.optionsQuery !== undefined;
+  if (hasOptions === hasOptionsQuery) {
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (dashboard) filter must set exactly one of ` +
+        `options/optionsQuery.`,
+    );
+  }
+  if (hasOptions && (filter.options?.length ?? 0) === 0) {
+    throw new Error(
+      `[Feature ${featureName}] Screen "${screenId}" (dashboard) filter.options is empty — ` +
+        `declare at least one option or use optionsQuery instead.`,
+    );
+  }
+}
+
 // Form-check für ListColumn-Renderer in der PlatformComponent-Form
 // (`{ react: { __component: "Name" } }`). Der Server kennt die client-
 // seitige columnRenderers-Map nicht — also nur prüfen ob die Struktur

package/src/engine/define-feature.ts

@@ -64,7 +64,6 @@ import type {
   TranslationsDef,
   TreeActionDef,
   TreeActionsHandle,
-  TreeChildrenSubscribe,
   UiHints,
   UnmanagedTableEntry,
   UnmanagedTableOptions,
@@ -163,14 +162,13 @@ export function defineFeature<const TName extends string, TExports = undefined>(
   let toggleableDefault: boolean | undefined;
   let description: string | undefined;
   let uiHints: UiHints | undefined;
-  // Visual-Tree-Slots — at-most-one per feature, only-once-guard im
-  // registrar (siehe r.treeActions / r.tree). Undefined wenn das Feature
-  // keinen Visual-Tree-Beitrag liefert (Zero-Whitelist-Filter).
+  // Tree-Action-Slot — at-most-one per feature, only-once-guard im
+  // registrar (siehe r.treeActions). Undefined wenn das Feature keine
+  // Tree-Actions liefert (Zero-Whitelist-Filter).
   // Name-Collision-Sicherheit: object-literal-method-Names im registrar
   // sind keine bindings im closure-scope, daher kollidiert die `treeActions`
   // closure-let-var nicht mit der `treeActions(...)` registrar-Methode.
   let treeActions: Readonly<Record<string, TreeActionDef>> | undefined;
-  let treeProvider: TreeChildrenSubscribe | undefined;
   // Optional Zod-schema for env-vars this feature reads at runtime,
   // declared via r.envSchema(). At-most-one per feature.
   let envSchema: z.ZodObject<z.ZodRawShape> | undefined;
@@ -969,17 +967,6 @@ export function defineFeature<const TName extends string, TExports = undefined>(
         treeActions: actions,
       });
     },
-
-    tree(provider: TreeChildrenSubscribe): void {
-      // Only-once-guard analog zu r.treeActions.
-      if (treeProvider !== undefined) {
-        throw new Error(
-          `[Feature ${name}] r.tree() already called. ` +
-            `Each feature may declare a single tree-provider.`,
-        );
-      }
-      treeProvider = provider;
-    },
   };
 
   const exports = setup(registrar) as TExports; // @cast-boundary engine-bridge
@@ -1049,7 +1036,6 @@ export function defineFeature<const TName extends string, TExports = undefined>(
     rawTables,
     unmanagedTables,
     ...(treeActions !== undefined && { treeActions }),
-    ...(treeProvider !== undefined && { treeProvider }),
     ...(envSchema !== undefined && { envSchema }),
   };
 }