@cosmicdrift/kumiko-framework 0.154.1 → 0.155.0

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

@@ -23,7 +23,6 @@ import type {
   ConfigPattern,
   DefineEventPattern,
   DescribePattern,
-  EntityHookPattern,
   EntityPattern,
   EnvSchemaPattern,
   ExposesApiPattern,
@@ -112,8 +111,6 @@ export function renderPattern(pattern: FeaturePattern): string {
       return renderQueryHandler(pattern);
     case "hook":
       return renderHook(pattern);
-    case "entityHook":
-      return renderEntityHook(pattern);
     case "job":
       return renderJob(pattern);
     case "notification":
@@ -398,20 +395,16 @@ function renderQueryHandler(p: QueryHandlerPattern): string {
   return lines.join("\n");
 }
 
-function renderHook(p: HookPattern): string {
-  const lines: string[] = ["r.hook({"];
-  lines.push(`  type: ${JSON.stringify(p.hookType)},`);
-  lines.push(`  target: ${renderValue(typeof p.target === "string" ? p.target : [...p.target])},`);
-  lines.push(`  handler: ${reindentBody(p.fnBody.raw, PATTERN_INDENT)},`);
-  if (p.phase !== undefined) lines.push(`  phase: ${JSON.stringify(p.phase)},`);
-  lines.push("});");
-  return lines.join("\n");
+function renderHookTarget(target: HookPattern["target"]): string {
+  if (typeof target === "string") return renderValue(target);
+  if ("allOf" in target) return `{ allOf: ${JSON.stringify(target.allOf)} }`;
+  return renderValue([...target]);
 }
 
-function renderEntityHook(p: EntityHookPattern): string {
-  const lines: string[] = ["r.entityHook({"];
+function renderHook(p: HookPattern): string {
+  const lines: string[] = ["r.hook({"];
   lines.push(`  type: ${JSON.stringify(p.hookType)},`);
-  lines.push(`  entity: ${JSON.stringify(p.entityName)},`);
+  lines.push(`  target: ${renderHookTarget(p.target)},`);
   lines.push(`  handler: ${reindentBody(p.fnBody.raw, PATTERN_INDENT)},`);
   if (p.phase !== undefined) lines.push(`  phase: ${JSON.stringify(p.phase)},`);
   lines.push("});");

package/src/engine/feature-config-events-jobs.ts

@@ -1,5 +1,6 @@
 import { ZodObject, type ZodType, type z } from "zod";
 import type { FeatureBuilderState } from "./feature-builder-state";
+import { splitNamedDefinition } from "./object-form";
 import { QnTypes, qn, toKebab } from "./qualified-name";
 import type {
   AuthClaimsFn,
@@ -154,38 +155,60 @@ export function buildConfigEventsJobsMethods<TName extends string>(
   return {
     config,
     job(
-      jobName: string,
-      options: Omit<JobDefinition, "name" | "handler">,
-      handler: JobHandlerFn,
+      jobNameOrDefinition: string | JobDefinition,
+      options?: Omit<JobDefinition, "name" | "handler">,
+      handler?: JobHandlerFn,
     ): void {
+      const [jobName, jobOptions, jobHandler] =
+        typeof jobNameOrDefinition === "string"
+          ? [
+              jobNameOrDefinition,
+              options as Omit<JobDefinition, "name" | "handler">,
+              handler as JobHandlerFn,
+            ]
+          : (() => {
+              const { name, handler: h, ...rest } = jobNameOrDefinition;
+              return [name, rest, h] as const;
+            })();
       // Resolve NameOrRef(s) in trigger.on. Multi-Trigger-Form: Array
       // wird zu Array von resolved strings, Single bleibt single string —
       // job-runner unterscheidet anhand Array.isArray.
       const trigger =
-        "on" in options.trigger
+        "on" in jobOptions.trigger
           ? {
-              on: Array.isArray(options.trigger.on)
-                ? options.trigger.on.map(resolveName)
-                : resolveName(options.trigger.on as NameOrRef), // @cast-boundary engine-bridge
+              on: Array.isArray(jobOptions.trigger.on)
+                ? jobOptions.trigger.on.map(resolveName)
+                : resolveName(jobOptions.trigger.on as NameOrRef), // @cast-boundary engine-bridge
             }
-          : options.trigger;
-      state.jobs[jobName] = { ...options, trigger, name: jobName, handler };
+          : jobOptions.trigger;
+      state.jobs[jobName] = { ...jobOptions, trigger, name: jobName, handler: jobHandler };
     },
     notification(
-      notificationName: string,
-      definition: {
+      notificationNameOrDefinition:
+        | string
+        | ({ readonly name: string } & {
+            readonly trigger: { readonly on: NameOrRef };
+            readonly recipient: NotificationRecipientFn;
+            readonly data: NotificationDataFn;
+            readonly templates?: Readonly<Record<string, NotificationTemplateFn>>;
+          }),
+      definition?: {
         readonly trigger: { readonly on: NameOrRef };
         readonly recipient: NotificationRecipientFn;
         readonly data: NotificationDataFn;
         readonly templates?: Readonly<Record<string, NotificationTemplateFn>>;
       },
     ): void {
+      const [notificationName, resolvedDefinition] =
+        typeof notificationNameOrDefinition === "string"
+          ? [notificationNameOrDefinition, definition as NonNullable<typeof definition>]
+          : splitNamedDefinition(notificationNameOrDefinition);
       state.notifications[notificationName] = {
         name: notificationName,
-        trigger: { on: resolveName(definition.trigger.on) },
-        recipient: definition.recipient,
-        data: definition.data,
-        templates: definition.templates,
+        trigger: { on: resolveName(resolvedDefinition.trigger.on) },
+        recipient: resolvedDefinition.recipient,
+        data: resolvedDefinition.data,
+        templates: resolvedDefinition.templates,
       };
     },
     translations(def: TranslationsDef): void {
@@ -246,17 +269,29 @@ export function buildConfigEventsJobsMethods<TName extends string>(
       }
       return def;
     },
-    readsConfig(...qualifiedKeys: string[]): void {
+    readsConfig(
+      ...args: readonly [{ readonly keys: readonly string[] }] | readonly string[]
+    ): void {
+      const [first] = args;
+      const qualifiedKeys =
+        typeof first === "object" && first !== null ? first.keys : (args as readonly string[]);
       state.configReads.push(...qualifiedKeys);
     },
-    metric(shortName: string, options: MetricOptions): void {
+    metric(
+      shortNameOrDefinition: string | ({ readonly name: string } & MetricOptions),
+      options?: MetricOptions,
+    ): void {
+      const [shortName, metricOptions] =
+        typeof shortNameOrDefinition === "string"
+          ? [shortNameOrDefinition, options as MetricOptions]
+          : splitNamedDefinition(shortNameOrDefinition);
       if (state.metrics[shortName]) {
         throw new Error(
           `[Feature ${name}] Metric "${shortName}" already registered. ` +
             `Metric names must be unique per feature.`,
         );
       }
-      state.metrics[shortName] = { shortName, ...options };
+      state.metrics[shortName] = { shortName, ...metricOptions };
     },
     envSchema(schema: z.ZodObject<z.ZodRawShape>): void {
       if (state.envSchema !== undefined) {
@@ -266,7 +301,14 @@ export function buildConfigEventsJobsMethods<TName extends string>(
       }
       state.envSchema = schema;
     },
-    secret(shortName: string, options: SecretOptions): SecretKeyHandle {
+    secret(
+      shortNameOrDefinition: string | ({ readonly name: string } & SecretOptions),
+      options?: SecretOptions,
+    ): SecretKeyHandle {
+      const [shortName, secretOptions] =
+        typeof shortNameOrDefinition === "string"
+          ? [shortNameOrDefinition, options as SecretOptions]
+          : splitNamedDefinition(shortNameOrDefinition);
       if (state.secretKeys[shortName]) {
         throw new Error(
           `[Feature ${name}] Secret "${shortName}" already registered. ` +
@@ -282,14 +324,22 @@ export function buildConfigEventsJobsMethods<TName extends string>(
       state.secretKeys[shortName] = {
         shortName,
         qualifiedName,
-        ...options,
+        ...secretOptions,
       };
       return { name: qualifiedName };
     },
     claimKey<T extends ClaimKeyType>(
-      shortName: string,
-      options: { readonly type: T },
+      shortNameOrDefinition: string | { readonly name: string; readonly type: T },
+      options?: { readonly type: T },
     ): ClaimKeyHandle<T> {
+      const shortName =
+        typeof shortNameOrDefinition === "string"
+          ? shortNameOrDefinition
+          : shortNameOrDefinition.name;
+      const claimType: T =
+        typeof shortNameOrDefinition === "string"
+          ? (options as { readonly type: T }).type
+          : shortNameOrDefinition.type;
       if (state.claimKeys[shortName]) {
         throw new Error(
           `[Feature ${name}] Claim key "${shortName}" already declared. ` +
@@ -306,9 +356,9 @@ export function buildConfigEventsJobsMethods<TName extends string>(
       state.claimKeys[shortName] = {
         shortName,
         qualifiedName,
-        type: options.type,
+        type: claimType,
       };
-      return { name: qualifiedName, type: options.type };
+      return { name: qualifiedName, type: claimType };
     },
     authClaims(fn: AuthClaimsFn): void {
       state.authClaimsHooks.push(fn);

package/src/engine/feature-entity-handlers.ts

@@ -1,13 +1,12 @@
 import type { ZodType, z } from "zod";
 import { toTableName } from "../db/table-builder";
 import type { QueryHandlerDefinition, WriteHandlerDefinition } from "./define-handler";
-import { type RegisterEntityCrudOptions, registerEntityCrud } from "./entity-handlers";
 import type { FeatureBuilderState } from "./feature-builder-state";
+import { splitNamedDefinition } from "./object-form";
 import type {
   AccessRule,
   EntityDefinition,
   EntityRef,
-  FeatureRegistrar,
   HandlerRef,
   NameOrRef,
   QueryHandlerFn,
@@ -46,37 +45,43 @@ function tryMapEntity(state: FeatureBuilderState, name: string, handlerName: str
   }
 }
 
-// Builds entity/crud/relation/writeHandler/queryHandler — the registrar
-// methods that create or reference entities. `crud` needs the fully-built
-// registrar (self-reference into registerEntityCrud); getRegistrar is a lazy
-// thunk since the registrar object doesn't exist yet while this is composed.
+// Builds entity/relation/writeHandler/queryHandler — the registrar
+// methods that create or reference entities.
 export function buildEntityHandlerMethods<TName extends string>(
   state: FeatureBuilderState,
   name: TName,
-  getRegistrar: () => FeatureRegistrar<TName>,
 ) {
   return {
     entity(
-      entityName: string,
-      definition: EntityDefinition,
+      nameOrDefinition: string | ({ readonly name: string } & EntityDefinition),
+      definition?: EntityDefinition,
       options?: { readonly table?: unknown },
     ): EntityRef {
-      state.entities[entityName] = definition;
+      const [entityName, entityDefinition] =
+        typeof nameOrDefinition === "string"
+          ? [nameOrDefinition, definition as EntityDefinition]
+          : splitNamedDefinition(nameOrDefinition);
+      state.entities[entityName] = entityDefinition;
       if (options?.table !== undefined) state.entityTables[entityName] = options.table;
-      return { name: entityName, table: definition.table ?? toTableName(entityName) };
+      return { name: entityName, table: entityDefinition.table ?? toTableName(entityName) };
     },
-    crud(
-      entityName: string,
-      definition: EntityDefinition,
-      options?: RegisterEntityCrudOptions,
-    ): EntityRef {
-      registerEntityCrud(getRegistrar(), entityName, definition, options);
-      return { name: entityName, table: definition.table ?? toTableName(entityName) };
-    },
-    relation(entityRef: NameOrRef, relationName: string, definition: RelationDefinition): void {
+    relation(
+      entityRefOrDefinition:
+        | NameOrRef
+        | ({ readonly entity: NameOrRef; readonly name: string } & RelationDefinition),
+      relationName?: string,
+      definition?: RelationDefinition,
+    ): void {
+      const [entityRef, resolvedRelationName, resolvedDefinition] =
+        typeof entityRefOrDefinition === "object" && "entity" in entityRefOrDefinition
+          ? (() => {
+              const { entity, name: innerName, ...rest } = entityRefOrDefinition;
+              return [entity, innerName, rest as RelationDefinition] as const;
+            })()
+          : [entityRefOrDefinition, relationName as string, definition as RelationDefinition];
       const entityName = resolveName(entityRef);
       if (!state.relations[entityName]) state.relations[entityName] = {};
-      state.relations[entityName][relationName] = definition;
+      state.relations[entityName][resolvedRelationName] = resolvedDefinition;
     },
     writeHandler<TName extends string, TSchema extends ZodType>(
       nameOrDef: string | WriteHandlerDefinition<TName, TSchema>,

package/src/engine/feature-ui-extensions.ts

@@ -31,6 +31,61 @@ import type { WorkspaceDefinition } from "./types/workspace";
 
 // Builds hooks/extensions/projections/screens/nav/workspace/tables/tree-actions
 // registrar methods.
+
+type EntityWideHookType = "postSave" | "preDelete" | "postDelete" | "postQuery";
+
+function isEntityWideHookType(type: LifecycleHookType | "validation"): type is EntityWideHookType {
+  return (
+    type === LifecycleHookTypes.postSave ||
+    type === LifecycleHookTypes.preDelete ||
+    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
+// below: @cast-boundary engine-bridge — typed Dev-API (LifecycleHookFn) →
+// erased Map<entityName, fn>.
+function registerEntityWideHook(
+  state: FeatureBuilderState,
+  featureName: string,
+  type: EntityWideHookType,
+  entityName: string,
+  fn: LifecycleHookFn,
+  options?: { phase?: HookPhase },
+): void {
+  if (type === LifecycleHookTypes.postSave) {
+    const phase = options?.phase ?? HookPhases.afterCommit;
+    if (!state.entityPostSave[entityName]) state.entityPostSave[entityName] = [];
+    state.entityPostSave[entityName].push({
+      fn: fn as PostSaveHookFn,
+      phase,
+      featureName,
+    }); // @cast-boundary engine-bridge
+  } else if (type === LifecycleHookTypes.preDelete) {
+    if (!state.entityPreDelete[entityName]) state.entityPreDelete[entityName] = [];
+    state.entityPreDelete[entityName].push({
+      fn: fn as PreDeleteHookFn, // @cast-boundary engine-bridge
+      phase: HookPhases.inTransaction,
+      featureName,
+    });
+  } else if (type === LifecycleHookTypes.postDelete) {
+    const phase = options?.phase ?? HookPhases.afterCommit;
+    if (!state.entityPostDelete[entityName]) state.entityPostDelete[entityName] = [];
+    state.entityPostDelete[entityName].push({
+      fn: fn as PostDeleteHookFn,
+      phase,
+      featureName,
+    }); // @cast-boundary engine-bridge
+  } else {
+    // postQuery is unphased (no inTransaction/afterCommit semantics — fires
+    // synchronously after query-handler-execute, before field-access-filter)
+    if (!state.entityPostQuery[entityName]) state.entityPostQuery[entityName] = [];
+    state.entityPostQuery[entityName].push({ fn: fn as PostQueryHookFn, featureName }); // @cast-boundary engine-bridge
+  }
+}
+
 export function buildUiExtensionsMethods<TName extends string>(
   state: FeatureBuilderState,
   name: TName,
@@ -38,10 +93,36 @@ export function buildUiExtensionsMethods<TName extends string>(
   return {
     hook(
       type: LifecycleHookType | "validation",
-      target: NameOrRef | readonly NameOrRef[],
+      target: NameOrRef | readonly NameOrRef[] | { readonly allOf: NameOrRef },
       fn: LifecycleHookFn | ValidationHookFn,
       options?: { phase?: HookPhase },
     ): void {
+      // Entity-wide target ("all write/query handlers of this entity") —
+      // replaces the old r.entityHook(type, entity, fn).
+      if (
+        typeof target === "object" &&
+        target !== null &&
+        !Array.isArray(target) &&
+        "allOf" in target
+      ) {
+        if (!isEntityWideHookType(type)) {
+          throw new Error(
+            `[Feature ${name}] r.hook("${type}", { allOf }, ...) only supports ` +
+              `postSave/preDelete/postDelete/postQuery, not "${type}".`,
+          );
+        }
+        registerEntityWideHook(
+          state,
+          name,
+          type,
+          resolveName(target.allOf),
+          fn as LifecycleHookFn,
+          options,
+        );
+        // skip: entity-wide target fully handled above, nothing more to do
+        return;
+      }
+
       const targets = Array.isArray(target) ? target : [target];
       const names = targets.map(resolveName);
 
@@ -81,43 +162,6 @@ export function buildUiExtensionsMethods<TName extends string>(
         bucket[n].push({ fn: fn as LifecycleHookFn, phase, featureName: name }); // @cast-boundary engine-bridge
       }
     },
-    entityHook(
-      type: "postSave" | "preDelete" | "postDelete" | "postQuery",
-      entityRef: NameOrRef,
-      fn: LifecycleHookFn,
-      options?: { phase?: HookPhase },
-    ): void {
-      const entityName = resolveName(entityRef);
-      if (type === LifecycleHookTypes.postSave) {
-        const phase = options?.phase ?? HookPhases.afterCommit;
-        if (!state.entityPostSave[entityName]) state.entityPostSave[entityName] = [];
-        state.entityPostSave[entityName].push({
-          fn: fn as PostSaveHookFn,
-          phase,
-          featureName: name,
-        }); // @cast-boundary engine-bridge
-      } else if (type === LifecycleHookTypes.preDelete) {
-        if (!state.entityPreDelete[entityName]) state.entityPreDelete[entityName] = [];
-        state.entityPreDelete[entityName].push({
-          fn: fn as PreDeleteHookFn, // @cast-boundary engine-bridge
-          phase: HookPhases.inTransaction,
-          featureName: name,
-        });
-      } else if (type === LifecycleHookTypes.postDelete) {
-        const phase = options?.phase ?? HookPhases.afterCommit;
-        if (!state.entityPostDelete[entityName]) state.entityPostDelete[entityName] = [];
-        state.entityPostDelete[entityName].push({
-          fn: fn as PostDeleteHookFn,
-          phase,
-          featureName: name,
-        }); // @cast-boundary engine-bridge
-      } else if (type === LifecycleHookTypes.postQuery) {
-        // postQuery is unphased (no inTransaction/afterCommit semantics — fires
-        // synchronously after query-handler-execute, before field-access-filter)
-        if (!state.entityPostQuery[entityName]) state.entityPostQuery[entityName] = [];
-        state.entityPostQuery[entityName].push({ fn: fn as PostQueryHookFn, featureName: name }); // @cast-boundary engine-bridge
-      }
-    },
     searchPayloadExtension(entityRef: NameOrRef, fn: SearchPayloadContributorFn): void {
       const entityName = resolveName(entityRef);
       if (!state.searchPayloadExtensions[entityName])
@@ -128,11 +172,24 @@ export function buildUiExtensionsMethods<TName extends string>(
       state.registrarExtensions[extensionName] = def;
     },
     useExtension(
-      extensionName: string,
-      entityRef: NameOrRef,
+      extensionNameOrDefinition:
+        | string
+        | ({ readonly name: string; readonly entity: NameOrRef } & Record<string, unknown>),
+      entityRef?: NameOrRef,
       options?: Record<string, unknown>,
     ): void {
-      state.extensionUsages.push({ extensionName, entityName: resolveName(entityRef), options });
+      const [extensionName, resolvedEntityRef, resolvedOptions] =
+        typeof extensionNameOrDefinition === "string"
+          ? [extensionNameOrDefinition, entityRef as NameOrRef, options]
+          : (() => {
+              const { name, entity, ...rest } = extensionNameOrDefinition;
+              return [name, entity, rest] as const;
+            })();
+      state.extensionUsages.push({
+        extensionName,
+        entityName: resolveName(resolvedEntityRef),
+        options: resolvedOptions,
+      });
     },
     extensionSelector(extensionName: string, key: { readonly name: string } | string): void {
       if (state.extensionSelectors.some((s) => s.extensionName === extensionName)) {
@@ -232,14 +289,28 @@ export function buildUiExtensionsMethods<TName extends string>(
       state.entityProjectionExtensions[entityName] = list;
     },
     referenceData(
-      entityRef: NameOrRef,
-      data: readonly Record<string, unknown>[],
+      entityRefOrDefinition:
+        | NameOrRef
+        | {
+            readonly entity: NameOrRef;
+            readonly data: readonly Record<string, unknown>[];
+            readonly upsertKey?: string;
+          },
+      data?: readonly Record<string, unknown>[],
       options?: { upsertKey?: string },
     ): void {
+      const [entityRef, resolvedData, upsertKey] =
+        typeof entityRefOrDefinition === "object" && "entity" in entityRefOrDefinition
+          ? [
+              entityRefOrDefinition.entity,
+              entityRefOrDefinition.data,
+              entityRefOrDefinition.upsertKey,
+            ]
+          : [entityRefOrDefinition, data as readonly Record<string, unknown>[], options?.upsertKey];
       state.referenceData.push({
         entityName: resolveName(entityRef),
-        data,
-        upsertKey: options?.upsertKey,
+        data: resolvedData,
+        upsertKey,
       });
     },
     screen(definition: ScreenDefinition): void {

package/src/engine/object-form.ts

@@ -0,0 +1,12 @@
+// Shared helper for registrar methods that accept an Object-Form call
+// (`r.entity({ name: "item", ... })`) alongside the classic positional form
+// (`r.entity("item", { ... })`). Object-Form is the shape the feature-ast
+// renderer emits for Designer/AI-generated code — a single object argument
+// with named fields is easier to generate correctly than positional args
+// whose count/order vary per method.
+export function splitNamedDefinition<T extends { readonly name: string }>(
+  definition: T,
+): [string, Omit<T, "name">] {
+  const { name, ...rest } = definition;
+  return [name, rest];
+}

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

@@ -47,7 +47,6 @@ const ALL_KINDS: FeaturePatternKind[] = [
   "writeHandler",
   "queryHandler",
   "hook",
-  "entityHook",
   "job",
   "notification",
   "authClaims",
@@ -279,14 +278,6 @@ function makePlaceholderPattern(kind: FeaturePatternKind): FeaturePattern {
         target: "x",
         fnBody: PLACEHOLDER_BODY_LOC,
       };
-    case "entityHook":
-      return {
-        kind,
-        source: PLACEHOLDER_LOC,
-        hookType: "postSave",
-        entityName: "x",
-        fnBody: PLACEHOLDER_BODY_LOC,
-      };
     case "job":
       return {
         kind,

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

@@ -17,7 +17,6 @@ import type { FeaturePatternKind } from "../feature-ast/patterns";
 import {
   authClaimsSchema,
   defineEventSchema,
-  entityHookSchema,
   hookSchema,
   httpRouteSchema,
   jobSchema,
@@ -81,7 +80,6 @@ export const PATTERN_LIBRARY: Readonly<Record<FeaturePatternKind, PatternFormSch
   writeHandler: writeHandlerSchema,
   queryHandler: queryHandlerSchema,
   hook: hookSchema,
-  entityHook: entityHookSchema,
   job: jobSchema,
   notification: notificationSchema,
   authClaims: authClaimsSchema,

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

@@ -1,11 +1,6 @@
 // Mixed pattern schemas (header form + opaque body source).
 
-import {
-  accessRuleField,
-  ENTITY_HOOK_TYPE_OPTIONS,
-  HOOK_TYPE_OPTIONS,
-  HTTP_METHOD_OPTIONS,
-} from "./shared-fields";
+import { accessRuleField, HOOK_TYPE_OPTIONS, HTTP_METHOD_OPTIONS } from "./shared-fields";
 import type { PatternFormSchema } from "./types";
 
 // --- Mixed patterns (header form + opaque body source) --------------------
@@ -169,45 +164,6 @@ export const hookSchema: PatternFormSchema = {
   ],
 };
 
-export const entityHookSchema: PatternFormSchema = {
-  kind: "entityHook",
-  label: { en: "Entity hook", de: "Entity-Hook" },
-  summary: { en: "Hook scoped to a single entity (no cross-entity targets)." },
-  category: "behaviour",
-  editability: "mixed",
-  fields: [
-    {
-      path: "hookType",
-      label: { en: "Type", de: "Typ" },
-      input: "select",
-      options: ENTITY_HOOK_TYPE_OPTIONS,
-      required: true,
-    },
-    {
-      path: "entityName",
-      label: { en: "Entity", de: "Entität" },
-      input: "entity-ref",
-      required: true,
-    },
-    {
-      path: "fnBody",
-      label: { en: "Hook body (source)", de: "Hook-Body (Source)" },
-      input: "code-block",
-      language: "typescript",
-      readOnly: true,
-    },
-    {
-      path: "phase",
-      label: { en: "Phase", de: "Phase" },
-      input: "select",
-      options: [
-        { value: "inTransaction", label: { en: "In transaction" } },
-        { value: "afterCommit", label: { en: "After commit" } },
-      ],
-    },
-  ],
-};
-
 export const jobSchema: PatternFormSchema = {
   kind: "job",
   label: { en: "Job", de: "Job" },

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

@@ -11,12 +11,7 @@ export const HOOK_TYPE_OPTIONS = [
   { value: "preDelete", label: { en: "Pre-Delete", de: "Vor Löschen" } },
   { value: "postDelete", label: { en: "Post-Delete", de: "Nach Löschen" } },
   { value: "preQuery", label: { en: "Pre-Query", de: "Vor Abfrage" } },
-] as const;
-
-export const ENTITY_HOOK_TYPE_OPTIONS = [
-  { value: "postSave", label: { en: "Post-Save", de: "Nach Speichern" } },
-  { value: "preDelete", label: { en: "Pre-Delete", de: "Vor Löschen" } },
-  { value: "postDelete", label: { en: "Post-Delete", de: "Nach Löschen" } },
+  { value: "postQuery", label: { en: "Post-Query", de: "Nach Abfrage" } },
 ] as const;
 
 export const HTTP_METHOD_OPTIONS = [

package/src/engine/registry-ingest.ts

@@ -147,9 +147,14 @@ export function populateEvents(state: RegistryState, feature: FeatureDefinition)
 
 // Translations prefixed with featureName: (i18next namespace convention).
 export function populateTranslations(state: RegistryState, feature: FeatureDefinition): void {
-  // Translations prefixed with featureName: (i18next namespace convention)
+  // Translations prefixed with featureName: (i18next namespace convention).
+  // Keys that already carry the feature's own namespace prefix (e.g. a nav
+  // label referencing "cap-counter:nav.cap-list" verbatim) must NOT be
+  // re-prefixed, else server-side t() can never resolve them (#1105).
+  const prefix = `${feature.name}:`;
   for (const [key, value] of Object.entries(feature.translations ?? {})) {
-    state.mergedTranslations[`${feature.name}:${key}`] = value;
+    const qualifiedKey = key.startsWith(prefix) ? key : `${prefix}${key}`;
+    state.mergedTranslations[qualifiedKey] = value;
   }
 }