@cosmicdrift/kumiko-framework 0.154.1 → 0.155.0

package/src/engine/feature-ast/__tests__/render-roundtrip.test.ts

@@ -9,7 +9,8 @@
 // up at canonical positions). We compare every other field.
 
 import { describe, expect, test } from "bun:test";
-import { Project } from "ts-morph";
+import * as path from "node:path";
+import { Project, ts } from "ts-morph";
 import { parseSourceFile } from "../parse";
 import type { FeaturePattern } from "../patterns";
 import { renderFeatureFile, renderPattern } from "../render";
@@ -29,10 +30,10 @@ defineFeature("inventory", (r) => {
     },
   });
 
-  r.relation("item", "supplier", { kind: "belongsTo", to: "user" });
+  r.relation("item", "supplier", { type: "belongsTo", target: "user", foreignKey: "supplierId" });
 
   r.metric("created", { type: "counter" });
-  r.secret("apiKey", { description: "Stripe key" });
+  r.secret("apiKey", { label: { en: "Stripe API Key" }, scope: "tenant" });
   r.claimKey("teamId", { type: "string" });
 
   r.referenceData(
@@ -44,7 +45,16 @@ defineFeature("inventory", (r) => {
     { upsertKey: "id" },
   );
 
-  r.config({ keys: { maxRows: { type: "number", default: 50 } } });
+  r.config({
+    keys: {
+      maxRows: {
+        type: "number",
+        default: 50,
+        scope: "tenant",
+        access: { read: ["user"], write: ["admin"] },
+      },
+    },
+  });
 });
 `;
 
@@ -359,6 +369,41 @@ describe("renderPattern — single-pattern shape", () => {
   });
 });
 
+// Regression guard for the class of bug the r.exposesApi/r.usesApi fold
+// hit: a registrar-shape change must survive the Designer's parse→render→
+// parse cycle, not just a TS compile of the framework itself. r.hook()'s
+// `{ allOf: entity }` target (replacing r.entityHook) reuses HookPattern's
+// already-generic target field, so this is the cheap case — but proving it
+// beats assuming it.
+const HOOK_ALL_OF_FEATURE = `
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+defineFeature("shop", (r) => {
+  r.entity("product", { fields: { name: { type: "text" } } });
+  r.hook("postSave", { allOf: "product" }, async (result) => {
+    console.log(result);
+  });
+});
+`;
+
+describe("render → parse roundtrip — r.hook({ allOf }) entity-wide target", () => {
+  test("allOf target survives parse → render → parse unchanged", () => {
+    const initial = parse(HOOK_ALL_OF_FEATURE);
+    const rendered = renderFeatureFile({
+      featureName: initial.featureName ?? "",
+      patterns: initial.patterns,
+    });
+    const reparsed = parse(rendered);
+    expect(reparsed.patterns.map(stripLocations)).toEqual(initial.patterns.map(stripLocations));
+
+    const hookPattern = reparsed.patterns.find((p) => p.kind === "hook");
+    expect(hookPattern?.kind).toBe("hook");
+    if (hookPattern?.kind === "hook") {
+      expect(hookPattern.target).toEqual({ allOf: "product" });
+    }
+  });
+});
+
 // Regression guard for the class of bug the r.exposesApi/r.usesApi fold
 // hit: a registrar-shape change (there, removing a method; here, adding a
 // nested optional field) must survive the Designer's parse→render→parse
@@ -436,3 +481,164 @@ describe("render → parse roundtrip — r.defineEvent({ migrations }) fold", ()
     }
   });
 });
+
+// --- Real-compile check ---------------------------------------------------
+//
+// Everything above proves parse(render(patterns)) is structurally faithful.
+// It does NOT prove the rendered code actually compiles against the real
+// FeatureRegistrar type — parse() runs against a bare in-memory Project with
+// no lib/module resolution, so a rendered call can be well-formed AST and
+// still be a type error against the real registrar (e.g. a removed method).
+// That gap let the r.usesApi removal (folded into r.requires({apis})) pass
+// the full 4960-test suite silently; only the visual Designer would have hit
+// the broken shape.
+//
+// This Project resolves `@cosmicdrift/kumiko-framework/*` against the real
+// framework source (unlike parse()'s Project, dependency resolution is NOT
+// skipped), so `r` in a compiled fixture is the real FeatureRegistrar, not a
+// structural stand-in.
+const FRAMEWORK_TSCONFIG_PATH = path.join(import.meta.dir, "../../../../tsconfig.json");
+
+const compileProject = new Project({
+  tsConfigFilePath: FRAMEWORK_TSCONFIG_PATH,
+  skipAddingFilesFromTsConfig: true,
+});
+
+let compileCheckCounter = 0;
+
+function compileAgainstRegistrar(source: string): readonly string[] {
+  compileCheckCounter += 1;
+  const filePath = path.join(
+    import.meta.dir,
+    `__generated__/compile-check-${compileCheckCounter}.gen.ts`,
+  );
+  const sourceFile = compileProject.createSourceFile(filePath, source, { overwrite: true });
+  const diagnostics = sourceFile.getPreEmitDiagnostics().map((d) => {
+    const text = ts.flattenDiagnosticMessageText(d.compilerObject.messageText, "\n");
+    return `${d.getLineNumber()}: ${text}`;
+  });
+  sourceFile.forget();
+  return diagnostics;
+}
+
+function renderAndCompile(source: string): readonly string[] {
+  const { featureName, patterns } = parse(source);
+  const rendered = renderFeatureFile({ featureName: featureName ?? "", patterns });
+  return compileAgainstRegistrar(rendered);
+}
+
+describe("render → compiles against the real FeatureRegistrar type", () => {
+  test("compile check has teeth: an unknown registrar method is reported", () => {
+    const diagnostics = compileAgainstRegistrar(`
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+defineFeature("teeth-check", (r) => {
+  r.methodThatDoesNotExist({ nope: true });
+});
+`);
+    expect(diagnostics.length).toBeGreaterThan(0);
+    expect(diagnostics.join("\n")).toContain("methodThatDoesNotExist");
+  }, 20_000);
+
+  test("positive control: a minimal always-matched-the-real-shape fixture compiles clean", () => {
+    const diagnostics = compileAgainstRegistrar(`
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+defineFeature("teeth-check-positive", (r) => {
+  r.systemScope();
+  r.describe("Minimal fixture proving the harness returns [] on real success.");
+  r.toggleable({ default: true });
+});
+`);
+    expect(diagnostics).toEqual([]);
+  }, 20_000);
+
+  test("STATIC_FEATURE's rendered header-data patterns compile clean", () => {
+    expect(renderAndCompile(STATIC_FEATURE)).toEqual([]);
+  }, 20_000);
+});
+
+// One self-contained, compile-clean fixture per remaining pattern kind not
+// already exercised above (STATIC_FEATURE / MIXED_FEATURE / HOOK_ALL_OF /
+// SCREEN_WITH_NAV / DEFINE_EVENT_WITH_MIGRATIONS). Deliberately separate
+// from the parse-roundtrip fixtures above: those were written to test
+// parse/render symmetry, not to be type-correct (e.g. DEFINE_EVENT_WITH_
+// MIGRATIONS_FEATURE uses `z` without importing it) — reusing them here
+// would produce diagnostics unrelated to the registrar shape and defeat the
+// point of an exact-match assertion.
+//
+// RAW_REF_FEATURE and the "unknown" pattern kind are excluded on purpose:
+// raw-ref sentinels reference symbols that don't exist by design, and
+// "unknown" is the parser's catch-all bucket for unrecognized r.calls, not
+// a real user-authored pattern.
+const MANIFEST_AND_CONFIG_FEATURE = `
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+import { z } from "zod";
+
+defineFeature("catalog", (r) => {
+  r.systemScope();
+  r.describe("Product catalog and pricing.");
+  r.optionalRequires("promotions");
+  r.uiHints({ displayLabel: "Catalog", category: "Commerce", recommended: true });
+  r.readsConfig("auth.smtpHost");
+  r.translations({ keys: { en: { title: "Catalog" } } });
+  r.useExtension("audit-log", "item");
+  r.extendsRegistrar("audit-log", {});
+  r.envSchema(z.object({ CATALOG_API_KEY: z.string() }));
+  r.usesApi("compliance.forTenant");
+  r.exposesApi("catalog.pricingFor");
+});
+`;
+
+// r.projection is deliberately excluded here: its `table` field (a Drizzle
+// table reference) is dropped by the feature-ast renderer independent of
+// the object-form/positional-form issue this fixture targets — a
+// pre-existing, separately tracked gap (public-api-registrar-consolidation
+// plan doc, kumiko-platform). multiStreamProjection below covers the
+// `apply`-map shape without hitting it (its `table` is optional).
+const INTEGRATION_FEATURE = `
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+defineFeature("fulfillment", (r) => {
+  r.job("reconcile-counts", { trigger: { manual: true } }, async (payload, context) => {
+    console.log(payload, context);
+  });
+
+  r.notification("itemLowStock", {
+    trigger: { on: "item:lowStock" },
+    recipient: () => null,
+    data: () => ({}),
+  });
+
+  r.authClaims(async () => ({}));
+
+  r.httpRoute({
+    method: "GET",
+    path: "/fulfillment/feed.xml",
+    handler: (c) => c.text("ok"),
+  });
+
+  r.multiStreamProjection({
+    name: "item-audit",
+    apply: {
+      "item.created": async (event, tx, ctx) => {
+        console.log(event, tx, ctx);
+      },
+    },
+  });
+
+  r.workspace({ id: "ops", label: "fulfillment:workspace.ops" });
+
+  r.treeActions({ list: {} });
+});
+`;
+
+describe("render → compiles against the real FeatureRegistrar type — full pattern-kind coverage", () => {
+  test("manifest/config-only patterns compile clean", () => {
+    expect(renderAndCompile(MANIFEST_AND_CONFIG_FEATURE)).toEqual([]);
+  }, 20_000);
+
+  test("job/notification/httpRoute/projection/workspace patterns compile clean", () => {
+    expect(renderAndCompile(INTEGRATION_FEATURE)).toEqual([]);
+  }, 20_000);
+});

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

@@ -29,7 +29,6 @@ export {
   collectScreenOpaqueProps,
   extractAuthClaims,
   extractDefineEvent,
-  extractEntityHook,
   extractHook,
   extractHttpRoute,
   extractJob,
@@ -39,7 +38,6 @@ export {
   extractQueryHandler,
   extractScreen,
   extractWriteHandler,
-  isEntityHookType,
   isHookType,
   isHttpRouteMethod,
   type ParsedHandlerCall,

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

@@ -10,7 +10,6 @@ import type { ScreenDefinition } from "../../types/screen";
 import type {
   AuthClaimsPattern,
   DefineEventPattern,
-  EntityHookPattern,
   HookPattern,
   HttpRoutePattern,
   JobPattern,
@@ -90,6 +89,25 @@ export function readOptionalRateLimit(value: unknown): RateLimitOption | undefin
   return value as unknown as RateLimitOption;
 }
 
+// r.hook's target: a NameOrRef, a list of them, or an entity-wide
+// `{ allOf: entityRef }` (replaces the old r.entityHook(type, entity, fn)).
+// Checked first so a malformed `{ allOf }` doesn't silently fall through
+// to being read as some other object shape.
+function readHookTarget(
+  node: Node,
+): string | readonly string[] | { readonly allOf: string } | undefined {
+  const obj = node.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (obj) {
+    const allOfProp = obj.getProperty("allOf")?.asKind(SyntaxKind.PropertyAssignment);
+    if (allOfProp) {
+      const initializer = allOfProp.getInitializer();
+      const entityName = initializer && readNameOrRef(initializer);
+      return entityName ? { allOf: entityName } : undefined;
+    }
+  }
+  return readNameOrRefOrList(node);
+}
+
 export function extractHook(
   call: CallExpression,
   sourceFile: SourceFile,
@@ -133,7 +151,7 @@ export function extractHook(
         "object form requires a `target` property",
       );
     }
-    const target = readNameOrRefOrList(targetInit);
+    const target = readHookTarget(targetInit);
     if (!target) {
       return fail(
         "hook",
@@ -195,7 +213,7 @@ export function extractHook(
       "expected a target (NameOrRef or array) as second argument",
     );
   }
-  const target = readNameOrRefOrList(targetArg);
+  const target = readHookTarget(targetArg);
   if (!target) {
     return fail(
       "hook",
@@ -230,154 +248,6 @@ export function extractHook(
   });
 }
 
-export function isEntityHookType(value: string): value is "postSave" | "preDelete" | "postDelete" {
-  return value === "postSave" || value === "preDelete" || value === "postDelete";
-}
-
-export function extractEntityHook(
-  call: CallExpression,
-  sourceFile: SourceFile,
-): ExtractOutput<EntityHookPattern> {
-  const args = call.getArguments();
-  const first = args[0];
-  if (!first) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "expected at least one argument",
-    );
-  }
-
-  const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-  if (obj && args.length === 1) {
-    const typeInit = obj
-      .getProperty("type")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer()
-      ?.asKind(SyntaxKind.StringLiteral);
-    if (!typeInit) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires a string-literal `type` property",
-      );
-    }
-    const hookType = typeInit.getLiteralValue();
-    if (!isEntityHookType(hookType)) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        `entity hook type must be postSave, preDelete, or postDelete (got "${hookType}")`,
-      );
-    }
-    const entityInit = obj
-      .getProperty("entity")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer();
-    if (!entityInit) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires an `entity` property",
-      );
-    }
-    const entityName = readNameOrRef(entityInit);
-    if (!entityName) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "`entity` must be a string literal or inline { name } object",
-      );
-    }
-    const handlerInit = obj
-      .getProperty("handler")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer();
-    if (!handlerInit) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires a `handler` property",
-      );
-    }
-    const fn = findFunctionLiteral(handlerInit);
-    if (!fn) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "handler must be an inline arrow function or function expression",
-      );
-    }
-    const phase = readOptionalPhase(obj);
-    return ok({
-      kind: "entityHook",
-      source: sourceLocationFromNode(call, sourceFile),
-      hookType,
-      entityName,
-      fnBody: sourceLocationFromNode(fn, sourceFile),
-      ...(phase !== undefined && { phase }),
-    });
-  }
-
-  const typeArg = first.asKind(SyntaxKind.StringLiteral);
-  if (!typeArg) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "first argument must be a string literal hook type (or use the object form)",
-    );
-  }
-  const hookType = typeArg.getLiteralValue();
-  if (!isEntityHookType(hookType)) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      `entity hook type must be postSave, preDelete, or postDelete (got "${hookType}")`,
-    );
-  }
-  const entityArg = args[1];
-  if (!entityArg) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "expected an entity reference as second argument",
-    );
-  }
-  const entityName = readNameOrRef(entityArg);
-  if (!entityName) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "second argument must be a string literal or inline { name } object",
-    );
-  }
-  const fnArg = args[2];
-  if (!fnArg) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "expected a hook function as third argument",
-    );
-  }
-  const fn = findFunctionLiteral(fnArg);
-  if (!fn) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "third argument must be an inline arrow function or function expression",
-    );
-  }
-  const phase = readOptionalPhase(args[3]);
-  return ok({
-    kind: "entityHook",
-    source: sourceLocationFromNode(call, sourceFile),
-    hookType,
-    entityName,
-    fnBody: sourceLocationFromNode(fn, sourceFile),
-    ...(phase !== undefined && { phase }),
-  });
-}
-
 // guard:dup-ok — intentionale Parallele zu extractTree (round6); verschiedene Feature-AST-Extraktoren by design
 export function extractAuthClaims(
   call: CallExpression,

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

@@ -27,7 +27,6 @@ export type {
   AddConfigArgs,
   AddDefineEventArgs,
   AddEntityArgs,
-  AddEntityHookArgs,
   AddHookArgs,
   AddHttpRouteArgs,
   AddJobArgs,
@@ -58,7 +57,6 @@ export type {
   ConfigPattern,
   DefineEventPattern,
   Editability,
-  EntityHookPattern,
   // Static patterns
   EntityPattern,
   ExtendsRegistrarPattern,

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

@@ -38,7 +38,6 @@ import {
   extractDefineEvent,
   extractDescribe,
   extractEntity,
-  extractEntityHook,
   extractEnvSchema,
   extractExposesApi,
   extractExtendsRegistrar,
@@ -442,8 +441,6 @@ function dispatchExtractor(
     // Round 4 — mixed (header + body) patterns
     case "hook":
       return extractHook(call, sourceFile);
-    case "entityHook":
-      return extractEntityHook(call, sourceFile);
     case "authClaims":
       return extractAuthClaims(call, sourceFile);
     case "writeHandler":

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

@@ -53,8 +53,11 @@ export type PatternId =
   | { readonly kind: "screen"; readonly id: string }
   | { readonly kind: "writeHandler"; readonly handlerName: string }
   | { readonly kind: "queryHandler"; readonly handlerName: string }
-  | { readonly kind: "hook"; readonly hookType: string; readonly target: string }
-  | { readonly kind: "entityHook"; readonly hookType: string; readonly entityName: string }
+  | {
+      readonly kind: "hook";
+      readonly hookType: string;
+      readonly target: string | { readonly allOf: string };
+    }
   | { readonly kind: "metric"; readonly shortName: string }
   | { readonly kind: "secret"; readonly shortName: string }
   | { readonly kind: "claimKey"; readonly shortName: string }
@@ -356,6 +359,18 @@ function callMatchesId(call: CallExpression, id: PatternId): boolean {
       );
     case "hook":
       // Positional: r.hook(type, target, fn) | Object: { type, target }
+      if (typeof id.target === "object") {
+        // Entity-wide { allOf } target — only ever appears as the object
+        // literal { allOf: entity } (positional or nested in the object
+        // form), never as a bare string, so check both call shapes.
+        if (matchFirstArgString(call, id.hookType)) {
+          return matchAllOfArg(call.getArguments()[1], id.target.allOf);
+        }
+        return (
+          matchObjectProperty(call, "type", id.hookType) &&
+          matchObjectAllOfProperty(call, "target", id.target.allOf)
+        );
+      }
       if (matchFirstArgString(call, id.hookType)) {
         const target = call.getArguments()[1]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
         return target === id.target;
@@ -364,15 +379,6 @@ function callMatchesId(call: CallExpression, id: PatternId): boolean {
         matchObjectProperty(call, "type", id.hookType) &&
         matchObjectProperty(call, "target", id.target)
       );
-    case "entityHook":
-      if (matchFirstArgString(call, id.hookType)) {
-        const ent = call.getArguments()[1]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
-        return ent === id.entityName;
-      }
-      return (
-        matchObjectProperty(call, "type", id.hookType) &&
-        matchObjectProperty(call, "entity", id.entityName)
-      );
     case "metric":
     case "secret":
     case "claimKey":
@@ -439,6 +445,31 @@ function matchObjectProperty(call: CallExpression, propName: string, expected: s
   return init?.getLiteralValue() === expected;
 }
 
+// Matches an r.hook `{ allOf: entity }` target — as the arg node directly
+// (positional call form) or as a nested object property (object call form).
+function matchAllOfArg(node: Node | undefined, expectedEntity: string): boolean {
+  const obj = node?.asKind(SyntaxKind.ObjectLiteralExpression);
+  const init = obj
+    ?.getProperty("allOf")
+    ?.asKind(SyntaxKind.PropertyAssignment)
+    ?.getInitializer()
+    ?.asKind(SyntaxKind.StringLiteral);
+  return init?.getLiteralValue() === expectedEntity;
+}
+
+function matchObjectAllOfProperty(
+  call: CallExpression,
+  propName: string,
+  expectedEntity: string,
+): boolean {
+  const obj = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
+  const propInit = obj
+    ?.getProperty(propName)
+    ?.asKind(SyntaxKind.PropertyAssignment)
+    ?.getInitializer();
+  return matchAllOfArg(propInit, expectedEntity);
+}
+
 // =============================================================================
 // Format helpers — line boundaries / blank-line collapse
 // (indent / PATTERN_INDENT live in render.ts and are imported above.)

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

@@ -106,19 +106,15 @@ export type AddQueryHandlerArgs = {
 
 export type AddHookArgs = {
   readonly type: LifecycleHookType | "validation";
-  readonly target: string | readonly string[];
+  // `{ allOf: entity }` — entity-wide target, fires for every write/query
+  // handler of that entity; replaces the old addEntityHook(). Only valid
+  // for postSave/preDelete/postDelete/postQuery, same as r.hook() itself.
+  readonly target: string | readonly string[] | { readonly allOf: string };
   /** Source text of the closure, e.g. `"async (event, ctx) => { ... }"`. */
   readonly handlerSource: string;
   readonly phase?: HookPhase;
 };
 
-export type AddEntityHookArgs = {
-  readonly type: "postSave" | "preDelete" | "postDelete";
-  readonly entity: string;
-  readonly handlerSource: string;
-  readonly phase?: HookPhase;
-};
-
 export type AddJobArgs = {
   readonly name: string;
   readonly options: Omit<JobDefinition, "name" | "handler">;
@@ -238,7 +234,6 @@ export type FeaturePatcher = {
   readonly addWriteHandler: (args: AddWriteHandlerArgs) => void;
   readonly addQueryHandler: (args: AddQueryHandlerArgs) => void;
   readonly addHook: (args: AddHookArgs) => void;
-  readonly addEntityHook: (args: AddEntityHookArgs) => void;
   readonly addJob: (args: AddJobArgs) => void;
   readonly addNotification: (args: AddNotificationArgs) => void;
   readonly addAuthClaims: (args: AddAuthClaimsArgs) => void;
@@ -408,17 +403,6 @@ export function createFeaturePatcher(sourceFile: SourceFile): FeaturePatcher {
       });
     },
 
-    addEntityHook({ type, entity, handlerSource, phase }) {
-      add({
-        kind: "entityHook",
-        source: SYNTHETIC_LOC,
-        hookType: type,
-        entityName: entity,
-        fnBody: rawLoc(handlerSource),
-        ...(phase !== undefined && { phase }),
-      });
-    },
-
     addJob({ name, options, handlerSource }) {
       add({
         kind: "job",

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

@@ -376,30 +376,20 @@ export type QueryHandlerPattern = {
 
 // `r.hook(type, target, fn, options?)` — attaches a lifecycle hook
 // (`validation`, `preSave`, `postSave`, `preDelete`, `postDelete`,
-// `preQuery`, `postQuery`) to one or more target handlers. Post-hooks
-// accept a `phase` option; `preDelete` always runs in-transaction — it
-// guards the delete. The hook body is an opaque code span.
+// `preQuery`, `postQuery`) to one or more target handlers, or — for
+// postSave/preDelete/postDelete/postQuery — to `{ allOf: entityRef }`
+// ("every write/query handler of this entity", replacing the old
+// `r.entityHook(type, entity, fn)`). Post-hooks accept a `phase` option;
+// `preDelete` always runs in-transaction — it guards the delete. The hook
+// body is an opaque code span.
 export type HookPattern = {
   readonly kind: "hook";
   readonly source: SourceLocation;
   readonly hookType: LifecycleHookType | "validation";
-  // r.hook accepts a single target or a list; we keep both shapes so
-  // the Designer can render the original author intent.
-  readonly target: string | readonly string[];
-  readonly fnBody: SourceLocation;
-  readonly phase?: HookPhase;
-};
-
-// `r.entityHook(type, entity, fn, options?)` — like `r.hook`, but bound to
-// an entity instead of individual handlers: `postSave`, `preDelete`, and
-// `postDelete` fire on every matching write. The runtime API additionally
-// accepts `postQuery` (fires for all query-handlers of the entity), but
-// this pattern type only represents the three write-side hooks.
-export type EntityHookPattern = {
-  readonly kind: "entityHook";
-  readonly source: SourceLocation;
-  readonly hookType: "postSave" | "preDelete" | "postDelete";
-  readonly entityName: string;
+  // r.hook accepts a single target, a list, or an entity-wide { allOf }
+  // target; we keep all three shapes so the Designer can render the
+  // original author intent.
+  readonly target: string | readonly string[] | { readonly allOf: string };
   readonly fnBody: SourceLocation;
   readonly phase?: HookPhase;
 };
@@ -603,7 +593,6 @@ export type FeaturePattern =
   | WriteHandlerPattern
   | QueryHandlerPattern
   | HookPattern
-  | EntityHookPattern
   | JobPattern
   | NotificationPattern
   | AuthClaimsPattern
@@ -659,7 +648,6 @@ export function getEditability(pattern: FeaturePattern): Editability {
     case "writeHandler":
     case "queryHandler":
     case "hook":
-    case "entityHook":
     case "job":
     case "notification":
     case "httpRoute":