@cosmicdrift/kumiko-framework 0.132.0 → 0.134.0

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/deep-link.ts

@@ -0,0 +1,23 @@
+// Deep-Link-URL-Builder für Notification-Templates (#449, Lazy-Scope: nur
+// Notification→Screen, kein Permalink-Sharing-Layer). Server-seitig nutzbar
+// (kein React) — der Renderer hat mit `formatPath`
+// (packages/renderer/src/app/nav.tsx) dasselbe Pfad-Format fürs Client-Routing,
+// hier bewusst dupliziert statt importiert: `renderer` zieht React als
+// Dependency, Notification-Data-Fns laufen server-seitig im Write-Handler.
+//
+// baseUrl kommt vom App-Autor (analog `AuthMailOptions.baseUrl` /
+// magic-link-mail.ts appendToken) — kein Auto-Detect, kein Env-Var-Read hier.
+
+export type DeepLinkTarget = {
+  readonly screenId: string;
+  readonly entityId?: string;
+  readonly workspaceId?: string;
+};
+
+export function buildDeepLinkUrl(baseUrl: string, target: DeepLinkTarget): string {
+  const segments: string[] = [];
+  if (target.workspaceId !== undefined) segments.push(target.workspaceId);
+  segments.push(target.screenId);
+  if (target.entityId !== undefined) segments.push(target.entityId);
+  return `${baseUrl.replace(/\/+$/, "")}/${segments.join("/")}`;
+}

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 }),
   };
 }

package/src/engine/factories.ts

@@ -230,8 +230,8 @@ export function createDateField<R extends true | false = false>(
  * (createdAt, loginAt, actualPickupAt). Temporal.Instant intern.
  *
  * Mit `locatedBy: "<name>Tz"` wird das Feld zum Wall-Clock-Pair eines
- * Termins an einem Ort — bevorzuge dafür den `locatedTimestamp(name)`
- * Helper, der Pair + Marker atomar erzeugt.
+ * Termins an einem Ort — bevorzuge dafür `createLocatedTimestampField()`,
+ * das EIN atomares Feld statt eines lose verdrahteten Pairs erzeugt.
  */
 export function createTimestampField<R extends true | false = false>(
   overrides?: Partial<Omit<TimestampFieldDef, "type" | "required">> & { required?: R },
@@ -300,53 +300,6 @@ export function createLocatedTimestampField<R extends true | false = false>(
   } as LocatedTimestampFieldDef & { required: R }; // @cast-boundary engine-payload
 }
 
-/**
- * @deprecated Verwende stattdessen `createLocatedTimestampField()` —
- * EIN Field-Type statt zwei lose Pair-Felder. Migration: ersetze
- * `...locatedTimestamp("pickup")` durch `pickup: createLocatedTimestampField()`.
- *
- * Wall-Clock-Termin an einem Ort — Helper der ZWEI verbundene Felder
- * erzeugt. Bevorzugte Form für jeden Date-Wert mit Location-Bezug
- * (Pickup, Delivery, Meeting, Schedule).
- *
- * ```ts
- * r.entity("order", {
- *   fields: {
- *     ...locatedTimestamp("pickup"),    // → pickupAt + pickupTz
- *     ...locatedTimestamp("delivery"),  // → deliveryAt + deliveryTz
- *   },
- * });
- * ```
- *
- * Zur Laufzeit wird:
- * - DB: `<name>_at TIMESTAMPTZ` (UTC) + `<name>_tz TEXT` (IANA-Name)
- * - JSON: `{ <name>At: "2026-04-03T10:00:00", <name>Tz: "Europe/Lisbon" }`
- *   (Wall-Clock OHNE Offset, plus IANA-Name — zwei getrennte Felder)
- * - Reducer/Apply: kann mit Temporal.ZonedDateTime arbeiten
- *
- * Optionen pro Feld (z.B. `required` auf den At-Teil) per zweitem Argument.
- */
-export function locatedTimestamp(
-  name: string,
-  overrides?: { readonly required?: boolean; readonly access?: TimestampFieldDef["access"] },
-): Readonly<Record<string, TimestampFieldDef | TzFieldDef>> {
-  const atName = `${name}At`;
-  const tzName = `${name}Tz`;
-  return {
-    [atName]: {
-      type: "timestamp",
-      locatedBy: tzName,
-      required: overrides?.required,
-      access: overrides?.access,
-    },
-    [tzName]: {
-      type: "tz",
-      required: overrides?.required,
-      access: overrides?.access,
-    },
-  };
-}
-
 export function createFileField(overrides?: Partial<Omit<FileFieldDef, "type">>): FileFieldDef {
   return { type: "file", ...overrides };
 }

package/src/engine/feature-ast/extractors/index.ts

@@ -58,10 +58,7 @@ export {
   extractUnmanagedTable,
   extractUsesApi,
 } from "./round5";
-export {
-  extractTree,
-  extractTreeActions,
-} from "./round6";
+export { extractTreeActions } from "./round6";
 export type { ExtractOutput } from "./shared";
 export {
   fail,

package/src/engine/feature-ast/extractors/round6.ts

@@ -1,15 +1,8 @@
 import type { CallExpression, SourceFile } from "ts-morph";
 import type { TreeActionDef } from "../../types/tree-node";
-import type { TreeActionsPattern, TreePattern } from "../patterns";
+import type { TreeActionsPattern } from "../patterns";
 import { sourceLocationFromNode } from "../source-location";
-import {
-  type ExtractOutput,
-  fail,
-  findFunctionLiteral,
-  isPlainObject,
-  ok,
-  readDataLiteralNode,
-} from "./shared";
+import { type ExtractOutput, fail, isPlainObject, ok, readDataLiteralNode } from "./shared";
 
 export function extractTreeActions(
   call: CallExpression,
@@ -37,30 +30,3 @@ export function extractTreeActions(
     definitions: definitions as Readonly<Record<string, TreeActionDef>>,
   });
 }
-
-export function extractTree(
-  call: CallExpression,
-  sourceFile: SourceFile,
-): ExtractOutput<TreePattern> {
-  const arg = call.getArguments()[0];
-  if (!arg) {
-    return fail(
-      "tree",
-      sourceLocationFromNode(call, sourceFile),
-      "expected a tree-provider function as first argument",
-    );
-  }
-  const fn = findFunctionLiteral(arg);
-  if (!fn) {
-    return fail(
-      "tree",
-      sourceLocationFromNode(call, sourceFile),
-      "first argument must be an inline arrow function or function expression",
-    );
-  }
-  return ok({
-    kind: "tree",
-    source: sourceLocationFromNode(call, sourceFile),
-    providerBody: sourceLocationFromNode(fn, sourceFile),
-  });
-}

package/src/engine/feature-ast/parse.ts

@@ -56,7 +56,6 @@ import {
   extractSystemScope,
   extractToggleable,
   extractTranslations,
-  extractTree,
   extractTreeActions,
   extractUiHints,
   extractUnmanagedTable,
@@ -364,11 +363,9 @@ function dispatchExtractor(
       return extractExposesApi(call, sourceFile);
     case "unmanagedTable":
       return extractUnmanagedTable(call, sourceFile);
-    // Round 6 — Visual-Tree patterns
+    // Round 6 — Tree-Actions pattern
     case "treeActions":
       return extractTreeActions(call, sourceFile);
-    case "tree":
-      return extractTree(call, sourceFile);
     // Round 7 — env-schema contract (opaque, Zod-expression argument)
     case "envSchema":
       return extractEnvSchema(call, sourceFile);

package/src/engine/feature-ast/patch.ts

@@ -84,8 +84,7 @@ export type PatternId =
   | { readonly kind: "config" }
   | { readonly kind: "translations" }
   | { readonly kind: "authClaims" }
-  | { readonly kind: "treeActions" }
-  | { readonly kind: "tree" };
+  | { readonly kind: "treeActions" };
 
 // =============================================================================
 // Change ops — generic apply API
@@ -277,10 +276,9 @@ export const SINGLETON_KINDS: ReadonlySet<PatternId["kind"]> = new Set([
   "config",
   "translations",
   "authClaims",
-  // Visual-Tree slots — at-most-one per feature, mirrors the registrar's
+  // Tree-Actions slot — at-most-one per feature, mirrors the registrar's
   // only-once-guard in define-feature.ts.
   "treeActions",
-  "tree",
 ]);
 
 /**
@@ -336,7 +334,6 @@ function callMatchesId(call: CallExpression, id: PatternId): boolean {
     case "translations":
     case "authClaims":
     case "treeActions":
-    case "tree":
       return true;
 
     case "entity":

package/src/engine/feature-ast/patterns.ts

@@ -445,18 +445,6 @@ export type AuthClaimsPattern = {
   readonly fnBody: SourceLocation;
 };
 
-// `r.tree(provider)` — the feature's top-level tree provider: a subscribe
-// function (emit-fn in, unsubscribe-fn out) that feeds workspaces with
-// `navigation: "tree"`. Features without `r.tree()` are invisible there —
-// provider presence IS the filter, there is no workspace mapping.
-// Closure-only, no header form: the Designer renders a read-only code
-// block, the AI patcher overwrites the span verbatim.
-export type TreePattern = {
-  readonly kind: "tree";
-  readonly source: SourceLocation;
-  readonly providerBody: SourceLocation;
-};
-
 // `r.httpRoute(definition)` — mounts an HTTP route owned by the feature,
 // outside the dispatcher pipeline (not under `/api/write|query|batch`) —
 // for RSS/Atom feeds, OG images, OpenAPI specs and similar. Duplicate
@@ -625,7 +613,6 @@ export type FeaturePattern =
   | DefineEventPattern
   | EventMigrationPattern
   | ExtendsRegistrarPattern
-  | TreePattern
   | EnvSchemaPattern
   // Catch-all
   | UnknownPattern;
@@ -684,7 +671,6 @@ export function getEditability(pattern: FeaturePattern): Editability {
       return "mixed";
     case "authClaims":
     case "extendsRegistrar":
-    case "tree":
     case "envSchema":
     case "uiHints":
     case "unknown":

package/src/engine/feature-ast/render.ts

@@ -49,7 +49,6 @@ import type {
   ToggleablePattern,
   TranslationsPattern,
   TreeActionsPattern,
-  TreePattern,
   UiHintsPattern,
   UnknownPattern,
   UseExtensionPattern,
@@ -139,8 +138,6 @@ export function renderPattern(pattern: FeaturePattern): string {
       return renderExposesApi(pattern);
     case "treeActions":
       return renderTreeActions(pattern);
-    case "tree":
-      return renderTree(pattern);
     case "envSchema":
       return renderEnvSchema(pattern);
     case "unknown":
@@ -433,16 +430,11 @@ function renderAuthClaims(p: AuthClaimsPattern): string {
   return `r.authClaims(${p.fnBody.raw});`;
 }
 
-// Visual-Tree patterns. treeActions is a static object-literal (mirrors
-// renderWorkspace), tree is opaque-only (mirrors renderAuthClaims).
+// treeActions is a static object-literal (mirrors renderWorkspace).
 function renderTreeActions(p: TreeActionsPattern): string {
   return `r.treeActions(${renderValue(p.definitions)});`;
 }
 
-function renderTree(p: TreePattern): string {
-  return `r.tree(${p.providerBody.raw});`;
-}
-
 function renderHttpRoute(p: HttpRoutePattern): string {
   const lines: string[] = ["r.httpRoute({"];
   lines.push(`  method: ${JSON.stringify(p.method)},`);

package/src/engine/index.ts

@@ -38,6 +38,8 @@ export {
 export type { App, AppConfig } from "./create-app";
 export { createApp } from "./create-app";
 export { crossTenantOverrideDenied } from "./cross-tenant";
+export type { DeepLinkTarget } from "./deep-link";
+export { buildDeepLinkUrl } from "./deep-link";
 export { defineFeature } from "./define-feature";
 export type {
   QueryHandlerDefinition,
@@ -121,7 +123,6 @@ export {
   createTextField,
   createTimestampField,
   createTzField,
-  locatedTimestamp,
 } from "./factories";
 // AST inspection + patching pipeline — used by the CLI scaffolder, the
 // Designer (C5/C6), and the AI-Builder (L2). See feature-ast/index.ts

package/src/engine/pattern-library/__tests__/library.test.ts

@@ -60,7 +60,6 @@ const ALL_KINDS: FeaturePatternKind[] = [
   "usesApi",
   "exposesApi",
   "treeActions",
-  "tree",
   "envSchema",
   "unknown",
 ];
@@ -351,8 +350,6 @@ function makePlaceholderPattern(kind: FeaturePatternKind): FeaturePattern {
       };
     case "treeActions":
       return { kind, source: PLACEHOLDER_LOC, definitions: {} };
-    case "tree":
-      return { kind, source: PLACEHOLDER_LOC, providerBody: PLACEHOLDER_BODY_LOC };
     case "envSchema":
       return { kind, source: PLACEHOLDER_LOC, schemaBody: PLACEHOLDER_BODY_LOC };
     case "unknown":

package/src/engine/pattern-library/library.ts

@@ -1102,24 +1102,6 @@ const treeActionsSchema: PatternFormSchema = {
   ],
 };
 
-const treeSchema: PatternFormSchema = {
-  kind: "tree",
-  label: { en: "Tree provider", de: "Tree-Provider" },
-  summary: { en: "Subscribe-Function emitting top-level Visual-Tree nodes." },
-  category: "ui",
-  editability: "opaque",
-  singleton: true,
-  fields: [
-    {
-      path: "providerBody",
-      label: { en: "Provider body (source)", de: "Provider-Body (Source)" },
-      input: "code-block",
-      language: "typescript",
-      readOnly: true,
-    },
-  ],
-};
-
 const envSchemaSchema: PatternFormSchema = {
   kind: "envSchema",
   label: { en: "Env schema", de: "Env-Schema" },
@@ -1200,7 +1182,6 @@ export const PATTERN_LIBRARY: Readonly<Record<FeaturePatternKind, PatternFormSch
   usesApi: usesApiSchema,
   exposesApi: exposesApiSchema,
   treeActions: treeActionsSchema,
-  tree: treeSchema,
   envSchema: envSchemaSchema,
   unknown: unknownSchema,
 } satisfies Readonly<Record<FeaturePatternKind, PatternFormSchema>>;

package/src/engine/registry.ts

@@ -57,7 +57,6 @@ import type {
   SecretKeyDefinition,
   TranslationKeys,
   TreeActionDef,
-  TreeChildrenSubscribe,
   UnmanagedTableDef,
   WorkspaceDefinition,
   WriteHandlerDef,
@@ -291,12 +290,10 @@ export function createRegistry(features: readonly FeatureDefinition[]): Registry
   const navsByWorkspace = new Map<string, string[]>();
   let defaultWorkspace: WorkspaceDefinition | undefined;
 
-  // Visual-Tree-Provider — keyed by declaring feature name (NOT qualified;
-  // ein Feature liefert genau einen Provider). Visual-Tree-Component
-  // iteriert die Map zur Mount-Zeit. Tree-Actions parallel — featureName
-  // → erased Action-Map (compile-time-typed Variante geht über
-  // setup-export-handle, siehe FeatureRegistrar.treeActions docs).
-  const treeProvidersMap = new Map<string, TreeChildrenSubscribe>();
+  // Tree-Actions — keyed by declaring feature name (NOT qualified; ein
+  // Feature liefert genau eine erased Action-Map (compile-time-typed
+  // Variante geht über setup-export-handle, siehe
+  // FeatureRegistrar.treeActions docs).
   const treeActionsMap = new Map<string, Readonly<Record<string, TreeActionDef>>>();
 
   // Local alias for readability — `qualifyEntityName` is the shared helper
@@ -786,12 +783,9 @@ export function createRegistry(features: readonly FeatureDefinition[]): Registry
       }
     }
 
-    // Visual-Tree slots — at-most-one per feature (only-once-guard im
-    // registrar). Erased Maps für Runtime-Lookup; compile-time-typed
+    // Tree-Actions slot — at-most-one per feature (only-once-guard im
+    // registrar). Erased Map für Runtime-Lookup; compile-time-typed
     // Surface läuft über FeatureDefinition.exports (TreeActionsHandle).
-    if (feature.treeProvider !== undefined) {
-      treeProvidersMap.set(feature.name, feature.treeProvider);
-    }
     if (feature.treeActions !== undefined) {
       treeActionsMap.set(feature.name, feature.treeActions);
     }
@@ -1693,10 +1687,6 @@ export function createRegistry(features: readonly FeatureDefinition[]): Registry
       return defaultWorkspace;
     },
 
-    getTreeProviders(): ReadonlyMap<string, TreeChildrenSubscribe> {
-      return treeProvidersMap;
-    },
-
     getTreeActions(featureName: string): Readonly<Record<string, TreeActionDef>> | undefined {
       return treeActionsMap.get(featureName);
     },