@cosmicdrift/kumiko-framework 0.365.1 → 0.366.0

package/dist/engine/feature-config-events-jobs.js

@@ -217,6 +217,9 @@ export function buildConfigEventsJobsMethods(state, name) {
                 ...(resolvedDefinition.localizedTemplate !== undefined
                     ? { localizedTemplate: resolvedDefinition.localizedTemplate }
                     : {}),
+                ...(resolvedDefinition.renamedFrom !== undefined
+                    ? { renamedFrom: resolvedDefinition.renamedFrom }
+                    : {}),
             };
         },
         translations(def) {

package/dist/engine/feature-entity-handlers.d.ts

@@ -3,34 +3,15 @@ import type { ZodType } from "zod";
 import { type QueryHandlerDefinition, type StreamHandlerDefinition, type WriteHandlerDefinition } from "./define-handler.js";
 import type { RegisterEntityCrudOptions } from "./entity-handlers.js";
 import type { FeatureBuilderState } from "./feature-builder-state.js";
-import type { AccessRule, AgentHandlerHints, EntityDefinition, EntityRef, EscapeHatchDeclaration, HandlerRef, KumikoEventTypeMap, NameOrRef, PayloadRateLimitOption, QueryHandlerFn, RateLimitDeclaration, RelationDefinition, StreamHandlerFn, WriteHandlerFn } from "./types/index.js";
+import type { AccessRule, EntityDefinition, EntityObjectDefinition, EntityRef, EscapeHatchDeclaration, HandlerRef, KumikoEventTypeMap, NameOrRef, RateLimitDeclaration, RelationDefinition, StreamHandlerFn } from "./types/index.js";
 export declare function buildEntityHandlerMethods<TName extends string>(state: FeatureBuilderState, name: TName): {
-    entity(nameOrDefinition: string | ({
-        readonly name: string;
-    } & EntityDefinition), definition?: EntityDefinition, options?: {
-        readonly table?: unknown;
-    }): EntityRef;
+    entity(definition: EntityObjectDefinition): EntityRef;
     relation(entityRefOrDefinition: NameOrRef | ({
         readonly entity: NameOrRef;
         readonly name: string;
     } & RelationDefinition), relationName?: string, definition?: RelationDefinition): void;
-    writeHandler<TName_1 extends string, TSchema extends ZodType, TPrepared = undefined>(nameOrDef: string | WriteHandlerDefinition<TName_1, TSchema, unknown, KumikoEventTypeMap, TPrepared>, schema?: TSchema, handler?: WriteHandlerFn<z.infer<TSchema>>, options?: {
-        access: AccessRule;
-        rateLimit?: RateLimitDeclaration;
-        additionalRateLimits?: readonly PayloadRateLimitOption[];
-        description?: string;
-        agent?: AgentHandlerHints;
-        escapeHatch?: EscapeHatchDeclaration;
-    }): HandlerRef;
-    queryHandler<TName_1 extends string, TSchema extends ZodType>(nameOrDef: string | QueryHandlerDefinition<TName_1, TSchema>, schema?: TSchema, handler?: QueryHandlerFn<z.infer<TSchema>>, options?: {
-        access: AccessRule;
-        rateLimit?: RateLimitDeclaration;
-        outputSchema?: ZodType;
-        liveEntities?: readonly string[];
-        description?: string;
-        agent?: AgentHandlerHints;
-        escapeHatch?: EscapeHatchDeclaration;
-    }): HandlerRef;
+    writeHandler<TName_1 extends string, TSchema extends ZodType, TPrepared = undefined>(def: WriteHandlerDefinition<TName_1, TSchema, unknown, KumikoEventTypeMap, TPrepared>): HandlerRef;
+    queryHandler<TName_1 extends string, TSchema extends ZodType>(def: QueryHandlerDefinition<TName_1, TSchema>): HandlerRef;
     streamHandler<TName_1 extends string, TSchema extends ZodType>(nameOrDef: string | StreamHandlerDefinition<TName_1, TSchema>, schema?: TSchema, handler?: StreamHandlerFn<z.infer<TSchema>>, options?: {
         access: AccessRule;
         rateLimit?: RateLimitDeclaration;

package/dist/engine/feature-entity-handlers.js

@@ -1,9 +1,9 @@
 import { ENTITY_CONVENTION_QUERY_BRAND } from "@cosmicdrift/kumiko-types/handlers";
 import { toTableName } from "../db/table-builder.js";
 import { isEntityConventionQueryHandler, isPagedQueryHandler, PAGED_QUERY_HANDLER_BRAND, } from "./define-handler.js";
-import { registerEntityCrud } from "./entity-handlers.js";
+import { registerCrudHandlers } from "./entity-handlers.js";
 import { resolveName } from "./handler-helpers.js";
-import { splitNamedDefinition } from "./object-form.js";
+import { isObjectArgument, throwPositionalFormRemoved } from "./object-form.js";
 const CRUD_VERBS = new Set(["create", "update", "delete"]);
 const CRUD_REGISTERED_VERBS = new Set([...CRUD_VERBS, "restore", "list", "detail"]);
 // A silent overwrite would drop framework behaviour that rides on the r.crud
@@ -65,6 +65,13 @@ function transactionPhaseSlots(def) {
         ...(def.transaction && { transaction: def.transaction }),
     };
 }
+// Typed callers cannot omit `access`; untyped ones (JS, designer output) must not get a
+// handler that silently falls through to the boot-time default-deny.
+function assertHandlerHasAccess(featureName, method, handlerName, access) {
+    if (access === undefined || access === null) {
+        throw new Error(`[Feature ${featureName}] r.${method}({ name: "${handlerName}" }) requires an access rule (access: { roles: [...] } or { openToAll: { reason } })`);
+    }
+}
 function requireInlineHandlerArgs(kind, schema, handler, options) {
     if (!schema || !handler || !options?.access) {
         throw new Error(`${kind} inline form requires schema + handler + options.access`);
@@ -75,13 +82,13 @@ function requireInlineHandlerArgs(kind, schema, handler, options) {
 // methods that create or reference entities.
 export function buildEntityHandlerMethods(state, name) {
     const methods = {
-        entity(nameOrDefinition, definition, options) {
-            const [entityName, entityDefinition] = typeof nameOrDefinition === "string"
-                ? [nameOrDefinition, definition]
-                : splitNamedDefinition(nameOrDefinition);
+        entity(definition) {
+            if (!isObjectArgument(definition))
+                throwPositionalFormRemoved(name, "entity");
+            const { name: entityName, backingTable, ...entityDefinition } = definition;
             state.entities[entityName] = entityDefinition;
-            if (options?.table !== undefined)
-                state.entityTables[entityName] = options.table;
+            if (backingTable !== undefined)
+                state.entityTables[entityName] = backingTable;
             return { name: entityName, table: entityDefinition.table ?? toTableName(entityName) };
         },
         relation(entityRefOrDefinition, relationName, definition) {
@@ -96,105 +103,75 @@ export function buildEntityHandlerMethods(state, name) {
                 state.relations[entityName] = {};
             state.relations[entityName][resolvedRelationName] = resolvedDefinition;
         },
-        writeHandler(nameOrDef, schema, handler, options) {
-            if (typeof nameOrDef === "object") {
-                const def = nameOrDef;
-                assertHandlerNameFree(state, name, "write", def.name);
-                state.writeHandlers[def.name] = {
-                    name: def.name,
-                    schema: def.schema,
-                    // @cast-boundary engine-bridge — typed Dev-API's handler is
-                    // generic over the schema's parsed payload (`WriteEvent<output<TSchema>>`),
-                    // the storage form WriteHandlerFn carries `WriteEvent<unknown>`.
-                    // Function-arg variance: TS sees the typed handler as stricter
-                    // than the loose storage shape and rejects direct assignment.
-                    // The runtime value is identical — the cast crosses that boundary.
-                    // `satisfies` does not work here (it asserts assignability, which
-                    // is what fails). Explicit cast is the right tool.
-                    handler: def.handler,
-                    access: def.access,
-                    ...agentSlots(def),
-                    ...(def.excludedFields && { excludedFields: def.excludedFields }),
-                    ...(def.unsafeSkipTransitionGuard && { unsafeSkipTransitionGuard: true }),
-                    ...(def.rateLimit && { rateLimit: def.rateLimit }),
-                    ...(def.additionalRateLimits && { additionalRateLimits: def.additionalRateLimits }),
-                    ...(def.escapeHatch && { escapeHatch: def.escapeHatch }),
-                    ...transactionPhaseSlots(def),
-                    ...(def.tenantlessAnonymous && { tenantlessAnonymous: true }),
-                    // Forward the pipeline-build closure so boot-validators and
-                    // Designer/AI tooling can inspect the step list. Absent on
-                    // free-form handlers — defineWriteHandler only sets `perform`
-                    // when the author used the pipeline form. Variance cast
-                    // mirrors the handler-cast above: PipelineDef<output<TSchema>>
-                    // is stricter than PipelineDef<unknown> for the same reason.
-                    ...(def.perform !== undefined && {
-                        perform: def.perform,
-                    }),
-                };
-                tryMapEntity(state, name, def.name);
-                return { name: def.name };
-            }
-            const inline = requireInlineHandlerArgs("writeHandler", schema, handler, options);
-            assertHandlerNameFree(state, name, "write", nameOrDef);
-            state.writeHandlers[nameOrDef] = {
-                name: nameOrDef,
-                schema: inline.schema,
-                handler: inline.handler, // @cast-boundary engine-bridge
-                access: inline.options.access,
-                ...agentSlots(inline.options),
-                ...(inline.options.rateLimit && { rateLimit: inline.options.rateLimit }),
-                ...(inline.options.additionalRateLimits && {
-                    additionalRateLimits: inline.options.additionalRateLimits,
+        writeHandler(def) {
+            if (!isObjectArgument(def))
+                throwPositionalFormRemoved(name, "writeHandler");
+            assertHandlerHasAccess(name, "writeHandler", def.name, def.access);
+            assertHandlerNameFree(state, name, "write", def.name);
+            state.writeHandlers[def.name] = {
+                name: def.name,
+                schema: def.schema,
+                // @cast-boundary engine-bridge — typed Dev-API's handler is
+                // generic over the schema's parsed payload (`WriteEvent<output<TSchema>>`),
+                // the storage form WriteHandlerFn carries `WriteEvent<unknown>`.
+                // Function-arg variance: TS sees the typed handler as stricter
+                // than the loose storage shape and rejects direct assignment.
+                // The runtime value is identical — the cast crosses that boundary.
+                // `satisfies` does not work here (it asserts assignability, which
+                // is what fails). Explicit cast is the right tool.
+                handler: def.handler,
+                access: def.access,
+                ...agentSlots(def),
+                ...(def.excludedFields && { excludedFields: def.excludedFields }),
+                ...(def.unsafeSkipTransitionGuard && { unsafeSkipTransitionGuard: true }),
+                ...(def.rateLimit && { rateLimit: def.rateLimit }),
+                ...(def.additionalRateLimits && { additionalRateLimits: def.additionalRateLimits }),
+                ...(def.escapeHatch && { escapeHatch: def.escapeHatch }),
+                ...transactionPhaseSlots(def),
+                ...(def.tenantlessAnonymous && { tenantlessAnonymous: true }),
+                // Forward the pipeline-build closure so boot-validators and
+                // Designer/AI tooling can inspect the step list. Absent on
+                // free-form handlers — defineWriteHandler only sets `perform`
+                // when the author used the pipeline form. Variance cast
+                // mirrors the handler-cast above: PipelineDef<output<TSchema>>
+                // is stricter than PipelineDef<unknown> for the same reason.
+                ...(def.perform !== undefined && {
+                    perform: def.perform,
                 }),
-                ...(inline.options.escapeHatch && { escapeHatch: inline.options.escapeHatch }),
             };
-            tryMapEntity(state, name, nameOrDef);
-            return { name: nameOrDef };
+            tryMapEntity(state, name, def.name);
+            return { name: def.name };
         },
-        queryHandler(nameOrDef, schema, handler, options) {
-            if (typeof nameOrDef === "object") {
-                const def = nameOrDef;
-                assertHandlerNameFree(state, name, "query", def.name);
-                state.queryHandlers[def.name] = {
-                    name: def.name,
-                    schema: def.schema,
-                    // @cast-boundary engine-bridge — typed Dev-API → erased internal storage
-                    handler: def.handler, // @cast-boundary engine-bridge
-                    access: def.access,
-                    ...agentSlots(def),
-                    ...(def.rateLimit && { rateLimit: def.rateLimit }),
-                    ...(def.outputSchema && { outputSchema: def.outputSchema }),
-                    ...(def.liveEntities && { liveEntities: def.liveEntities }),
-                    ...(def.escapeHatch && { escapeHatch: def.escapeHatch }),
-                    // Carry the definePagedQueryHandler brand through — this rebuild
-                    // drops any field not explicitly listed.
-                    ...(isPagedQueryHandler(def) && { [PAGED_QUERY_HANDLER_BRAND]: true }),
-                    ...(isEntityConventionQueryHandler(def) && {
-                        [ENTITY_CONVENTION_QUERY_BRAND]: true,
-                    }),
-                };
-                tryMapEntity(state, name, def.name);
-                return { name: def.name };
-            }
-            const inline = requireInlineHandlerArgs("queryHandler", schema, handler, options);
-            assertHandlerNameFree(state, name, "query", nameOrDef);
-            state.queryHandlers[nameOrDef] = {
-                name: nameOrDef,
-                schema: inline.schema,
-                handler: inline.handler, // @cast-boundary engine-bridge
-                access: inline.options.access,
-                ...agentSlots(inline.options),
-                ...(inline.options.rateLimit && { rateLimit: inline.options.rateLimit }),
-                ...(inline.options.outputSchema && { outputSchema: inline.options.outputSchema }),
-                ...(inline.options.liveEntities && { liveEntities: inline.options.liveEntities }),
-                ...(inline.options.escapeHatch && { escapeHatch: inline.options.escapeHatch }),
+        queryHandler(def) {
+            if (!isObjectArgument(def))
+                throwPositionalFormRemoved(name, "queryHandler");
+            assertHandlerHasAccess(name, "queryHandler", def.name, def.access);
+            assertHandlerNameFree(state, name, "query", def.name);
+            state.queryHandlers[def.name] = {
+                name: def.name,
+                schema: def.schema,
+                // @cast-boundary engine-bridge — typed Dev-API → erased internal storage
+                handler: def.handler, // @cast-boundary engine-bridge
+                access: def.access,
+                ...agentSlots(def),
+                ...(def.rateLimit && { rateLimit: def.rateLimit }),
+                ...(def.outputSchema && { outputSchema: def.outputSchema }),
+                ...(def.liveEntities && { liveEntities: def.liveEntities }),
+                ...(def.escapeHatch && { escapeHatch: def.escapeHatch }),
+                // Carry the definePagedQueryHandler brand through — this rebuild
+                // drops any field not explicitly listed.
+                ...(isPagedQueryHandler(def) && { [PAGED_QUERY_HANDLER_BRAND]: true }),
+                ...(isEntityConventionQueryHandler(def) && {
+                    [ENTITY_CONVENTION_QUERY_BRAND]: true,
+                }),
             };
-            tryMapEntity(state, name, nameOrDef);
-            return { name: nameOrDef };
+            tryMapEntity(state, name, def.name);
+            return { name: def.name };
         },
         streamHandler(nameOrDef, schema, handler, options) {
             if (typeof nameOrDef === "object") {
                 const def = nameOrDef;
+                assertHandlerHasAccess(name, "streamHandler", def.name, def.access);
                 state.streamHandlers[def.name] = {
                     name: def.name,
                     schema: def.schema,
@@ -221,7 +198,7 @@ export function buildEntityHandlerMethods(state, name) {
     return {
         ...methods,
         crud(entityName, entity, options) {
-            registerEntityCrud(methods, entityName, entity, options);
+            registerCrudHandlers(methods, entityName, entity, options);
         },
     };
 }

package/dist/engine/feature-ui-extensions.d.ts

@@ -2,17 +2,12 @@ import { type WebSocketRouteDefinition } from "@cosmicdrift/kumiko-types/websock
 import type { EntityTableMeta } from "../db/entity-table-meta.js";
 import type { FeatureBuilderState } from "./feature-builder-state.js";
 import type { HttpRouteDefinition } from "./types/http-route.js";
-import type { BootCheckFn, EntityProjectionExtension, EscapeHatchDeclaration, ExtensionSelectorPanel, HookPhase, LifecycleHookFn, LifecycleHookType, MultiStreamProjectionDefinition, NameOrRef, ProjectionDefinition, RegistrarExtensionDef, SearchPayloadContributorFn, StoreTableOptions, TreeActionDef, TreeActionsHandle, ValidationHookFn } from "./types/index.js";
+import type { BootCheckFn, EntityProjectionExtension, ExtensionSelectorPanel, HookDefinition, MultiStreamProjectionDefinition, NameOrRef, ProjectionDefinition, RegistrarExtensionDef, SearchPayloadContributorFn, StoreTableOptions, TreeActionDef, TreeActionsHandle } from "./types/index.js";
 import type { ContentCollectionDefinition, NavDefinition } from "./types/nav.js";
 import type { ScreenDefinition } from "./types/screen.js";
 import type { WorkspaceDefinition } from "./types/workspace.js";
 export declare function buildUiExtensionsMethods<TName extends string>(state: FeatureBuilderState, name: TName): {
-    hook(type: LifecycleHookType | "validation", target: NameOrRef | readonly NameOrRef[] | {
-        readonly allOf: NameOrRef;
-    }, fn: LifecycleHookFn | ValidationHookFn, options?: {
-        phase?: HookPhase;
-        escapeHatch?: EscapeHatchDeclaration;
-    }): void;
+    hook(definition: HookDefinition): void;
     searchPayloadExtension(entityRef: NameOrRef, fn: SearchPayloadContributorFn): void;
     extendsRegistrar(extensionName: string, def: RegistrarExtensionDef): void;
     useExtension(extensionNameOrDefinition: string | ({
@@ -25,20 +20,20 @@ export declare function buildUiExtensionsMethods<TName extends string>(state: Fe
         readonly panels?: readonly ExtensionSelectorPanel[];
     }): void;
     /**
-     * Marker-Deklaration: dieses Feature stellt eine Cross-Feature-API
-     * unter dem genannten Namen bereit. Die eigentliche Implementation
-     * wird separat als Query- oder Write-Handler unter dem QN-Pattern
-     * registriert; r.exposesApi ist reine Boot-Check-Surface.
+     * Marker declaration: this feature provides a cross-feature API under
+     * the given name. The implementation is registered separately as a query
+     * or write handler under the QN pattern; r.exposesApi only feeds the
+     * boot check.
      *
-     * Beispiel:
+     * Example:
      *   defineFeature("compliance-profiles", (r) => {
      *     r.exposesApi("compliance.forTenant");
      *     r.queryHandler({ name: "compliance:query:for-tenant", ... });
      *   });
      *   defineFeature("user-data-rights", (r) => {
-     *     r.requires("compliance-profiles");
+     *     r.requires({ features: ["compliance-profiles"] });
      *     r.usesApi("compliance.forTenant");
-     *     // ruft im Handler: ctx.callQuery("compliance:query:for-tenant", ...)
+     *     // in a handler: ctx.callQuery("compliance:query:for-tenant", ...)
      *   });
      */
     exposesApi(apiName: string): void;

package/dist/engine/feature-ui-extensions.js

@@ -4,6 +4,7 @@ import { WEBSOCKET_MAX_CONNECTIONS_PER_USER_LIMIT, WEBSOCKET_MAX_PAYLOAD_BYTES,
 import { bindHookEscapeHatchGrant } from "../pipeline/system-identity-switch.js";
 import { LifecycleHookTypes } from "./constants.js";
 import { resolveName } from "./handler-helpers.js";
+import { isObjectArgument, throwPositionalFormRemoved } from "./object-form.js";
 import { isKebabSegment, isValidQn, qualifyEntityName, toKebab } from "./qualified-name.js";
 import { HookPhases } from "./types/index.js";
 // Builds hooks/extensions/projections/screens/nav/workspace/tables/tree-actions
@@ -43,8 +44,8 @@ function isEntityWideHookType(type) {
         type === LifecycleHookTypes.postDelete ||
         type === LifecycleHookTypes.postQuery);
 }
-// r.hook(type, { allOf: entity }, fn) — "all write/query handlers of this
-// entity", replacing the old r.entityHook(type, entity, fn). Hook-fn casts
+// r.hook({ type, target: { allOf: entity }, handler }) — "all write/query handlers of
+// this entity". Hook-fn casts
 // below: @cast-boundary engine-bridge — typed Dev-API (LifecycleHookFn) →
 // erased Map<entityName, fn>.
 function registerEntityWideHook(state, featureName, type, entityName, fn, options) {
@@ -107,21 +108,28 @@ export function buildUiExtensionsMethods(state, name) {
         state.navs[navDefinition.id] = Object.fromEntries(Object.entries(navDefinition).filter(([, value]) => value !== undefined));
     }
     return {
-        hook(type, target, fn, options) {
+        hook(definition) {
+            if (!isObjectArgument(definition))
+                throwPositionalFormRemoved(name, "hook");
+            const { type, target, handler: fn } = definition;
+            const options = {
+                ...(definition.phase !== undefined && { phase: definition.phase }),
+                ...(definition.escapeHatch !== undefined && { escapeHatch: definition.escapeHatch }),
+            };
             if (type === "validation") {
                 if (options?.escapeHatch !== undefined) {
-                    throw new Error(`[Feature ${name}] r.hook("validation", ...) does not accept { escapeHatch } — ` +
+                    throw new Error(`[Feature ${name}] r.hook({ type: "validation", … }) does not accept escapeHatch — ` +
                         "validation hooks receive no context to switch identity with.");
                 }
             }
             else if (options?.escapeHatch !== undefined &&
                 options.escapeHatch.reason.trim().length === 0) {
-                throw new Error(`[Feature ${name}] r.hook("${type}", ...) declares { escapeHatch: { reason: "" } } — ` +
+                throw new Error(`[Feature ${name}] r.hook({ type: "${type}", … }) declares escapeHatch: { reason: "" } — ` +
                     "the reason must be a non-empty string explaining why this hook switches identity to SYSTEM.");
             }
             const hookGrantsProblem = options?.escapeHatch && escapeHatchGrantsProblem(options.escapeHatch);
             if (hookGrantsProblem) {
-                throw new Error(`[Feature ${name}] r.hook("${type}", ...) declares an invalid escapeHatch — ${hookGrantsProblem}`);
+                throw new Error(`[Feature ${name}] r.hook({ type: "${type}", … }) declares an invalid escapeHatch — ${hookGrantsProblem}`);
             }
             // Wrapped once for both branches below; validation hooks stay unwrapped (no context).
             const hookLabel = `${type} hook of feature "${name}"`;
@@ -135,7 +143,7 @@ export function buildUiExtensionsMethods(state, name) {
                 !Array.isArray(target) &&
                 "allOf" in target) {
                 if (!isEntityWideHookType(type)) {
-                    throw new Error(`[Feature ${name}] r.hook("${type}", { allOf }, ...) only supports ` +
+                    throw new Error(`[Feature ${name}] r.hook({ type: "${type}", target: { allOf }, … }) only supports ` +
                         `postSave/preDelete/postDelete/postQuery, not "${type}".`);
                 }
                 registerEntityWideHook(state, name, type, resolveName(target.allOf), wrapped, // @cast-boundary engine-bridge
@@ -241,20 +249,20 @@ export function buildUiExtensionsMethods(state, name) {
             });
         },
         /**
-         * Marker-Deklaration: dieses Feature stellt eine Cross-Feature-API
-         * unter dem genannten Namen bereit. Die eigentliche Implementation
-         * wird separat als Query- oder Write-Handler unter dem QN-Pattern
-         * registriert; r.exposesApi ist reine Boot-Check-Surface.
+         * Marker declaration: this feature provides a cross-feature API under
+         * the given name. The implementation is registered separately as a query
+         * or write handler under the QN pattern; r.exposesApi only feeds the
+         * boot check.
          *
-         * Beispiel:
+         * Example:
          *   defineFeature("compliance-profiles", (r) => {
          *     r.exposesApi("compliance.forTenant");
          *     r.queryHandler({ name: "compliance:query:for-tenant", ... });
          *   });
          *   defineFeature("user-data-rights", (r) => {
-         *     r.requires("compliance-profiles");
+         *     r.requires({ features: ["compliance-profiles"] });
          *     r.usesApi("compliance.forTenant");
-         *     // ruft im Handler: ctx.callQuery("compliance:query:for-tenant", ...)
+         *     // in a handler: ctx.callQuery("compliance:query:for-tenant", ...)
          *   });
          */
         exposesApi(apiName) {

package/dist/engine/handler-field-references.d.ts

@@ -18,5 +18,30 @@ export type HandlerFieldReferenceReading = {
     readonly kind: "ok";
     readonly reference: HandlerFieldReference;
 };
+export type HandlerFieldPathSegment = {
+    readonly kind: "field";
+    readonly name: string;
+} | {
+    readonly kind: "element";
+} | {
+    readonly kind: "recordKey";
+} | {
+    readonly kind: "recordValue";
+};
+export type HandlerFieldReferenceAtPath = {
+    readonly path: string;
+    readonly segments: readonly HandlerFieldPathSegment[];
+    readonly reading: Exclude<HandlerFieldReferenceReading, {
+        kind: "none";
+    }>;
+};
 export declare function readHandlerFieldReference(schema: z.ZodType, field: string): HandlerFieldReferenceReading;
+/** All reference metas of a handler input schema, including fields nested in arrays,
+ *  objects and records. `z.lazy()` is not followed. */
+export declare function readHandlerFieldReferences(schema: z.ZodType): readonly HandlerFieldReferenceAtPath[];
+export declare function handlerFieldReferences(schema: z.ZodType): readonly {
+    readonly path: string;
+    readonly segments: readonly HandlerFieldPathSegment[];
+    readonly reference: HandlerFieldReference;
+}[];
 export declare function handlerFieldReference(schema: z.ZodType, field: string): HandlerFieldReference | undefined;

package/dist/engine/handler-field-references.js

@@ -1,7 +1,8 @@
 import * as z from "zod";
-import { zodDef, zodMeta, zodShapeField } from "../env/_zod-introspect.js";
+import { zodDef, zodMeta, zodShape, zodShapeField } from "../env/_zod-introspect.js";
 export const HANDLER_FIELD_REFERENCES_META_KEY = "references";
 const MAX_WRAPPER_DEPTH = 8;
+const MAX_NESTING_DEPTH = 8;
 const referenceMetaSchema = z.union([
     z.string().min(1),
     z.object({ entity: z.string().min(1), by: z.string().min(1).optional() }),
@@ -42,11 +43,7 @@ function isArrayField(field) {
     }
     return false;
 }
-export function readHandlerFieldReference(schema, field) {
-    const objectSchema = unwrapObjectSchema(schema);
-    const fieldSchema = objectSchema && zodShapeField(objectSchema, field);
-    if (fieldSchema === undefined)
-        return { kind: "none" };
+function readFieldReference(fieldSchema) {
     const raw = findRawReferenceMeta(fieldSchema);
     if (raw === undefined)
         return { kind: "none" };
@@ -63,6 +60,83 @@ export function readHandlerFieldReference(schema, field) {
         },
     };
 }
+export function readHandlerFieldReference(schema, field) {
+    const objectSchema = unwrapObjectSchema(schema);
+    const fieldSchema = objectSchema && zodShapeField(objectSchema, field);
+    if (fieldSchema === undefined)
+        return { kind: "none" };
+    return readFieldReference(fieldSchema);
+}
+function pathOf(segments) {
+    let path = "";
+    for (const segment of segments) {
+        if (segment.kind === "field")
+            path += path === "" ? segment.name : `.${segment.name}`;
+        else if (segment.kind === "element")
+            path += "[]";
+        else if (segment.kind === "recordKey")
+            path += "{key}";
+        else
+            path += "{}";
+    }
+    return path;
+}
+function collectAt(schema, segments, out) {
+    const reading = readFieldReference(schema);
+    if (reading.kind !== "none")
+        out.push({ path: pathOf(segments), segments, reading });
+}
+function walkNested(schema, segments, depth, out) {
+    // skip: schemas nested deeper than MAX_NESTING_DEPTH are not inspected
+    if (depth > MAX_NESTING_DEPTH)
+        return;
+    let current = schema;
+    let currentSegments = segments;
+    for (let layer = 0; layer < MAX_WRAPPER_DEPTH && current !== undefined; layer++) {
+        if (current instanceof z.ZodObject) {
+            walkObject(current, currentSegments, depth, out);
+            break;
+        }
+        if (current instanceof z.ZodRecord) {
+            const { keyType, valueType } = current;
+            if (keyType instanceof z.ZodType) {
+                collectAt(keyType, [...currentSegments, { kind: "recordKey" }], out);
+            }
+            if (valueType instanceof z.ZodType) {
+                const valueSegments = [...currentSegments, { kind: "recordValue" }];
+                collectAt(valueType, valueSegments, out);
+                walkNested(valueType, valueSegments, depth + 1, out);
+            }
+            break;
+        }
+        if (current instanceof z.ZodArray) {
+            currentSegments = [...currentSegments, { kind: "element" }];
+            current = zodDef(current)?.element;
+            continue;
+        }
+        current = zodDef(current)?.innerType;
+    }
+}
+function walkObject(objectSchema, segments, depth, out) {
+    for (const [name, fieldSchema] of Object.entries(zodShape(objectSchema))) {
+        const fieldSegments = [...segments, { kind: "field", name }];
+        collectAt(fieldSchema, fieldSegments, out);
+        walkNested(fieldSchema, fieldSegments, depth + 1, out);
+    }
+}
+/** All reference metas of a handler input schema, including fields nested in arrays,
+ *  objects and records. `z.lazy()` is not followed. */
+export function readHandlerFieldReferences(schema) {
+    const objectSchema = unwrapObjectSchema(schema);
+    if (objectSchema === undefined)
+        return [];
+    const out = [];
+    walkObject(objectSchema, [], 0, out);
+    return out;
+}
+export function handlerFieldReferences(schema) {
+    return readHandlerFieldReferences(schema).flatMap(({ path, segments, reading }) => reading.kind === "ok" ? [{ path, segments, reference: reading.reference }] : []);
+}
 export function handlerFieldReference(schema, field) {
     const reading = readHandlerFieldReference(schema, field);
     return reading.kind === "ok" ? reading.reference : undefined;

package/dist/engine/index.d.ts

@@ -25,7 +25,7 @@ export type { WorkflowDefinition, WorkflowInput, WorkflowTrigger } from "./defin
 export { computeDefinitionFingerprint, defineWorkflow } from "./define-workflow.js";
 export type { ToggleReader } from "./effective-features.js";
 export { computeEffectiveFeatures, isToggleableFeature } from "./effective-features.js";
-export { createEntityExecutor, defineEntityCreateHandler, defineEntityDeleteHandler, defineEntityDetailHandler, defineEntityListHandler, defineEntityQueryHandler, defineEntityRestoreHandler, defineEntityUpdateHandler, defineEntityWriteHandler, defineProjectionQueryHandler, type EntityCrudRegistrar, entityListSchema, MAX_LIST_LIMIT, type RegisterEntityCrudOptions, registerEntityCrud, } from "./entity-handlers.js";
+export { createEntityExecutor, defineEntityCreateHandler, defineEntityDeleteHandler, defineEntityDetailHandler, defineEntityListHandler, defineEntityQueryHandler, defineEntityRestoreHandler, defineEntityUpdateHandler, defineEntityWriteHandler, defineProjectionQueryHandler, type EntityCrudRegistrar, entityListSchema, MAX_LIST_LIMIT, type RegisterEntityCrudOptions, } from "./entity-handlers.js";
 export { declareEscapeHatch } from "./escape-hatch-declaration.js";
 export type { EmitCtx } from "./event-helpers.js";
 export { emitEvent, typedPayload } from "./event-helpers.js";
@@ -43,7 +43,7 @@ export { addPattern, applyChanges, createFeaturePatcher, getPatternSchema, group
 export { type ChangelogEntry, type ChangelogType, compareVersions, type FeatureChangelog, filterEntriesAfter, parseFeatureChangelog, sortEntries, validateChangelog, } from "./feature-changelog.js";
 export { type BuildManifestOptions, buildManifestFromRegistry, type FeatureManifest, type ManifestConfigKey, type ManifestExtension, type ManifestFeature, type ManifestSecret, type ManifestSystemEvent, serializeManifest, } from "./feature-manifest.js";
 export { checkWriteFieldOwnership, checkWriteFieldRoles, filterReadFields, maskWriteOnlyFields, } from "./field-access.js";
-export { HANDLER_FIELD_REFERENCES_META_KEY, type HandlerFieldReference, type HandlerFieldReferenceMeta, handlerFieldReference, } from "./handler-field-references.js";
+export { HANDLER_FIELD_REFERENCES_META_KEY, type HandlerFieldPathSegment, type HandlerFieldReference, type HandlerFieldReferenceAtPath, type HandlerFieldReferenceMeta, handlerFieldReference, handlerFieldReferences, readHandlerFieldReferences, } from "./handler-field-references.js";
 export { resolveName, withResponseData } from "./handler-helpers.js";
 export { i18nKey } from "./i18n-key.js";
 export { buildSessionRoles, findForbiddenMembershipRole, isForbiddenMembershipRole, stripForbiddenMembershipRoles, } from "./membership-roles.js";
@@ -81,7 +81,7 @@ export { assertNotificationVariables, templateVariable, templateVariablesToZod,
 export { type EffectiveFeaturesResolver, findTierResolverUsage, isTierResolverPlugin, requireTierResolverPlugin, TENANT_TIER_RESOLVER_EXT, type TierResolverPlugin, type TrialGate, } from "./tier-resolver-extension.js";
 export { findOverDeepTransferChain, resolveTransferAdjacency as resolveEntityTransferAdjacency, type TransferAdjacency, type TransferEdge, type TransferEdgeLink, } from "./transfer-adjacency.js";
 export { isSystemTenant, isUuid, parseTenantId, SYSTEM_TENANT_ID } from "./types/identifiers.js";
-export type { AccessRule, ActionFormScreenDefinition, ActiveMembership, ActiveMembershipRejection, ActiveMembershipResult, AgentExposure, AgentHandlerHints, AgentRisk, AppContext, AppendEventArgs, AppendEventFn, AuthClaimsContext, AuthClaimsFn, AuthClaimsHookDef, BeforeTransactionPhase, BeforeTransactionResult, BelongsToRelation, BigIntFieldDef, BooleanFieldDef, CamelToKebab, ChatSendFailureCode, ClaimKeyDefinition, ClaimKeyHandle, ClaimKeyJsType, ClaimKeyType, ConcurrencyMode, ConfigAccessor, ConfigAccessorFactory, ConfigBacking, ConfigCascade, ConfigCascadeLevel, ConfigDefinition, ConfigEditScreenDefinition, ConfigKeyAccess, ConfigKeyDefinition, ConfigKeyHandle, ConfigKeyType, ConfigMask, ConfigResolver, ConfigScope, ConfigSecretsReader, ConfigSeedDef, ConfigStoredRow, ConfigStoredRowWithSource, ConfigValidateContext, ConfigValidateFn, ConfigValue, ConfigValueSource, ConfigValueWithSource, ContentCollectionDefinition, CreateSeedOptions, CreateTenantSeedOptions, CreateUserSeedOptions, CustomScreenDefinition, CustomScreenRoute, DashboardChartPanel, DashboardCustomPanel, DashboardDateParam, DashboardFeedPanel, DashboardFilterDefinition, DashboardI18nText, DashboardListPanel, DashboardMoneyParam, DashboardPanelDefinition, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, DashboardText, DashboardTextParam, DashboardValueFormat, DateFieldDef, DecimalFieldDef, DeleteContext, DeliveryErrorCode, DeliveryFailureCode, DeliverySkipReason, DeriveContext, DerivedFieldDef, DerivedFieldsMap, DerivedValueType, EditExtensionSection, EditFieldPrefill, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EmbeddedListEditSpec, EntityDefinition, EntityEditAction, EntityEditActionPlacement, EntityEditScreenDefinition, EntityId, EntityListExpandableRow, EntityListScreenDefinition, EntityRef, EntityRelations, EscapeHatchAuditSink, EscapeHatchDeclaration, EscapeHatchKind, EscapeHatchReporter, EscapeHatchTarget, EscapeHatchUseEvent, EventDef, ExtensionOptionsArgs, ExtensionOptionsFor, FeatureDefinition, FeatureRegistrar, FieldAccess, FieldCondition, FieldDefinition, FieldFormatRegistry, FieldIconKey, FieldRenderer, FileFieldDef, FilesFieldDef, Findability, FormatSpec, FormWidth, HandlerContext, HasManyRelation, HookMap, ImageFieldDef, ImagesFieldDef, JobBackoff, JobBackoffStrategy, JobContext, JobDefinition, JobHandlerFn, JobTrigger, JobTriggerEvent, JsonbFieldDef, KumikoEntityTypeMap, KumikoEventTypeMap, KumikoExtensionOptionsMap, KumikoHandlerPayloadMap, KumikoHandlerResultMap, LifecycleHookType, ListColumnSpec, ListFacetSpec, ListPaginationMode, ListSortDir, ListSortSpec, LongTextFindability, ManyToManyRelation, MaxPerTenantOptions, MemberReader, MetricNavigate, MetricSpec, MspErrorMode, MspErrorPolicy, MultiSelectFieldDef, MultiStreamApplyFn, MultiStreamProjectionDefinition, NameOrRef, NavDefinition, NavIconKey, NotificationDataFn, NotificationDefinition, NotificationLocalizedTemplate, NotificationRecipientFn, NotificationRecordMapping, NotificationTemplateBody, NotificationTemplateFn, NotificationTemplateMeta, NotifyDeferred, NotifyDelivery, NotifyDeliveryStatus, NotifyDispatched, NotifyFactory, NotifyFn, NotifyJobDispatcher, NotifyOptions, NotifyPriority, NotifyResult, NumberFieldDef, OnDeleteStrategy, OpenToAllAccessRule, OpenToAllDeclaration, OpenToAllPersonalData, ParentRefDef, PersonalAnnotations, PersonalAnnotationsLongText, PersonalAnnotationsNoFind, PersonalSubject, PlatformComponent, PluralForms, PostDeleteHookFn, PostSaveHookFn, PreDeleteHookFn, PreparedWriteEvent, PreQueryHookFn, PreSaveHookFn, ProjectionDefinition, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, ProjectionTable, QualifiedEventName, QueryEvent, QueryHandlerDef, QueryHandlerFn, RateLimitPer, RecordHeaderSpec, RecordHeaderSubtitlePart, ReferenceDataDef, Registry, RelationDefinition, ResolvedPiiFlags, RetentionDef, RoleAccessPersonalData, RoleAccessRule, RowAction, RowActionNavigate, RowActionNavigateBase, RowActionWriteHandler, RowFieldExtractor, SaveContext, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenNavSugar, ScreenSlots, SecretKeyDefinition, SecretKeyHandle, SecretMintConfirmStep, SecretMintScreenDefinition, SecretNamespaceDefinition, SecretNamespaceHandle, SecretNamespaceOptions, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, SelectFieldDef, SessionUser, SessionUserOrigin, StreamHandlerDef, StreamHandlerFn, Subscribe, TargetRef, TemplateListVariableDef, TemplateScalarVariableDef, TemplateVariableDef, TemplateVariables, TenantId, TenantWriteTarget, TextFieldDef, ToolbarAction, TranslationEntry, TranslationKeys, TranslationsDef, TranslationValue, TreeAction, TreeActionDef, TreeActionsHandle, TreeChildrenSubscribe, TreeNode, TreeNodeState, UnitKey, UnsafeAppendEventFn, ValidationError, ValidationHookFn, WorkspaceDefinition, WriteEvent, WriteHandlerDef, WriteHandlerFn, WriteResult, } from "./types/index.js";
+export type { AccessRule, ActionFormScreenDefinition, ActiveMembership, ActiveMembershipRejection, ActiveMembershipResult, AgentExposure, AgentHandlerHints, AgentRisk, AppContext, AppendEventArgs, AppendEventFn, AuthClaimsContext, AuthClaimsFn, AuthClaimsHookDef, BeforeTransactionPhase, BeforeTransactionResult, BelongsToRelation, BigIntFieldDef, BooleanFieldDef, CamelToKebab, ChatSendFailureCode, ClaimKeyDefinition, ClaimKeyHandle, ClaimKeyJsType, ClaimKeyType, ConcurrencyMode, ConfigAccessor, ConfigAccessorFactory, ConfigBacking, ConfigCascade, ConfigCascadeLevel, ConfigDefinition, ConfigEditScreenDefinition, ConfigKeyAccess, ConfigKeyDefinition, ConfigKeyHandle, ConfigKeyType, ConfigMask, ConfigResolver, ConfigScope, ConfigSecretsReader, ConfigSeedDef, ConfigStoredRow, ConfigStoredRowWithSource, ConfigValidateContext, ConfigValidateFn, ConfigValue, ConfigValueSource, ConfigValueWithSource, ContentCollectionDefinition, CreateSeedOptions, CreateTenantSeedOptions, CreateUserSeedOptions, CustomScreenDefinition, CustomScreenRoute, DashboardChartPanel, DashboardCustomPanel, DashboardDateParam, DashboardFeedPanel, DashboardFilterDefinition, DashboardI18nText, DashboardListPanel, DashboardMoneyParam, DashboardPanelDefinition, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, DashboardText, DashboardTextParam, DashboardValueFormat, DateFieldDef, DecimalFieldDef, DeleteContext, DeliveryErrorCode, DeliveryFailureCode, DeliverySkipReason, DeriveContext, DerivedFieldDef, DerivedFieldsMap, DerivedValueType, EditExtensionSection, EditFieldPrefill, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EmbeddedListEditSpec, EntityDefinition, EntityEditAction, EntityEditActionPlacement, EntityEditScreenDefinition, EntityId, EntityListExpandableRow, EntityListScreenDefinition, EntityObjectDefinition, EntityRef, EntityRelations, EscapeHatchAuditSink, EscapeHatchDeclaration, EscapeHatchKind, EscapeHatchReporter, EscapeHatchTarget, EscapeHatchUseEvent, EventDef, ExtensionOptionsArgs, ExtensionOptionsFor, FeatureDefinition, FeatureRegistrar, FieldAccess, FieldCondition, FieldDefinition, FieldFormatRegistry, FieldIconKey, FieldRenderer, FileFieldDef, FilesFieldDef, Findability, FormatSpec, FormWidth, HandlerContext, HasManyRelation, HookDefinition, HookMap, ImageFieldDef, ImagesFieldDef, JobBackoff, JobBackoffStrategy, JobContext, JobDefinition, JobHandlerFn, JobTrigger, JobTriggerEvent, JsonbFieldDef, KumikoEntityTypeMap, KumikoEventTypeMap, KumikoExtensionOptionsMap, KumikoHandlerPayloadMap, KumikoHandlerResultMap, LifecycleHookType, ListColumnSpec, ListFacetSpec, ListPaginationMode, ListSortDir, ListSortSpec, LongTextFindability, ManyToManyRelation, MaxPerTenantOptions, MemberReader, MetricNavigate, MetricSpec, MspErrorMode, MspErrorPolicy, MultiSelectFieldDef, MultiStreamApplyFn, MultiStreamProjectionDefinition, NameOrRef, NavDefinition, NavIconKey, NotificationDataFn, NotificationDefinition, NotificationLocalizedTemplate, NotificationRecipientFn, NotificationRecordMapping, NotificationTemplateBody, NotificationTemplateFn, NotificationTemplateMeta, NotifyDeferred, NotifyDelivery, NotifyDeliveryStatus, NotifyDispatched, NotifyFactory, NotifyFn, NotifyJobDispatcher, NotifyOptions, NotifyPriority, NotifyResult, NumberFieldDef, OnDeleteStrategy, OpenToAllAccessRule, OpenToAllDeclaration, OpenToAllPersonalData, ParentRefDef, PersonalAnnotations, PersonalAnnotationsLongText, PersonalAnnotationsNoFind, PersonalSubject, PlatformComponent, PluralForms, PostDeleteHookFn, PostSaveHookFn, PreDeleteHookFn, PreparedWriteEvent, PreQueryHookFn, PreSaveHookFn, ProjectionDefinition, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, ProjectionTable, QualifiedEventName, QueryEvent, QueryHandlerDef, QueryHandlerFn, RateLimitPer, RecordHeaderSpec, RecordHeaderSubtitlePart, ReferenceDataDef, Registry, RelationDefinition, ResolvedPiiFlags, RetentionDef, RoleAccessPersonalData, RoleAccessRule, RowAction, RowActionNavigate, RowActionNavigateBase, RowActionWriteHandler, RowFieldExtractor, SaveContext, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenNavSugar, ScreenSlots, SecretKeyDefinition, SecretKeyHandle, SecretMintConfirmStep, SecretMintScreenDefinition, SecretNamespaceDefinition, SecretNamespaceHandle, SecretNamespaceOptions, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, SelectFieldDef, SessionUser, SessionUserOrigin, StreamHandlerDef, StreamHandlerFn, Subscribe, TargetRef, TemplateListVariableDef, TemplateScalarVariableDef, TemplateVariableDef, TemplateVariables, TenantId, TenantWriteTarget, TextFieldDef, ToolbarAction, TranslationEntry, TranslationKeys, TranslationsDef, TranslationValue, TreeAction, TreeActionDef, TreeActionsHandle, TreeChildrenSubscribe, TreeNode, TreeNodeState, UnitKey, UnsafeAppendEventFn, ValidationError, ValidationHookFn, WorkspaceDefinition, WriteEvent, WriteHandlerDef, WriteHandlerFn, WriteResult, } from "./types/index.js";
 export { DEFAULT_CURRENCIES, DEFAULT_LOCALES, DELIVERY_FAILURE_CODES, DELIVERY_SKIP_REASONS, HookPhases, HTTP_ERROR_CODE_PATTERN, isAgentVisibleScreen, isDeliveryErrorCode, isOpenToAllGranted, resolveAgentExposure, } from "./types/index.js";
 export type { AwaitedEventType, PipelineBuildCtx, PipelineCtx, PipelineDef, StepBuilder, StepDef, StepFailureStrategy, StepInstance, StepKind, StepNamespace, StepResolver, } from "./types/step.js";
 export { runValidation } from "./validation.js";

package/dist/engine/index.js

@@ -25,7 +25,7 @@ export { createEntityExecutor, defineEntityCreateHandler, defineEntityDeleteHand
 // Apps nehmen die verb-spezifischen Wrapper oben. Existierende
 // Caller (Integration-Tests, alte bundled-features) bleiben so
 // unverändert lauffähig.
-defineEntityQueryHandler, defineEntityRestoreHandler, defineEntityUpdateHandler, defineEntityWriteHandler, defineProjectionQueryHandler, entityListSchema, MAX_LIST_LIMIT, registerEntityCrud, } from "./entity-handlers.js";
+defineEntityQueryHandler, defineEntityRestoreHandler, defineEntityUpdateHandler, defineEntityWriteHandler, defineProjectionQueryHandler, entityListSchema, MAX_LIST_LIMIT, } from "./entity-handlers.js";
 export { declareEscapeHatch } from "./escape-hatch-declaration.js";
 export { emitEvent, typedPayload } from "./event-helpers.js";
 export { EXT_ASSIGNABLE_ROLE, EXT_DERIVATIVE_OVERLAY_RESOLVER, EXT_DERIVATIVE_PUBLIC_PREDICATE, EXT_DERIVATIVE_RENDERER, EXT_EXTERNAL_RESOURCE, EXT_FILE_PROVIDER, EXT_INFRA_RESOURCE, EXT_PRINCIPAL_STATUS, EXT_SEARCH_ADAPTER, EXT_STORAGE_PROVIDER, EXT_TENANT_DATA, EXT_TENANT_LIFECYCLE_STATUS, EXT_USER_DATA, EXT_USER_DATA_ORDER, FILE_PROVIDER_CONFIG_KEY, FILE_STORAGE_PROVIDER_BOOT_SENTINEL, FILE_STORAGE_PROVIDER_ENV, TENANT_MEMBERSHIPS_QUERY, } from "./extension-names.js";
@@ -38,7 +38,7 @@ export { addPattern, applyChanges, createFeaturePatcher, getPatternSchema, group
 export { compareVersions, filterEntriesAfter, parseFeatureChangelog, sortEntries, validateChangelog, } from "./feature-changelog.js";
 export { buildManifestFromRegistry, serializeManifest, } from "./feature-manifest.js";
 export { checkWriteFieldOwnership, checkWriteFieldRoles, filterReadFields, maskWriteOnlyFields, } from "./field-access.js";
-export { HANDLER_FIELD_REFERENCES_META_KEY, handlerFieldReference, } from "./handler-field-references.js";
+export { HANDLER_FIELD_REFERENCES_META_KEY, handlerFieldReference, handlerFieldReferences, readHandlerFieldReferences, } from "./handler-field-references.js";
 export { resolveName, withResponseData } from "./handler-helpers.js";
 export { i18nKey } from "./i18n-key.js";
 // findForbiddenMembershipRole/isForbiddenMembershipRole/