@cosmicdrift/kumiko-framework 0.146.3 → 0.147.0

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

@@ -47,6 +47,25 @@ export function readBooleanProperty(
   return undefined;
 }
 
+/**
+ * Marks a value the parser could not resolve into a literal (an Identifier
+ * reference, a call expression, ...) while preserving its exact source text.
+ * `renderValue` re-emits `__raw` verbatim instead of re-serializing the
+ * value, so round-tripping a reference like `eventEntity` never expands it
+ * into an inlined object literal.
+ */
+export type RawRefSentinel = { readonly __raw: string };
+
+export function isRawRefSentinel(value: unknown): value is RawRefSentinel {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    "__raw" in value &&
+    typeof (value as { __raw: unknown }).__raw === "string"
+  );
+}
+
 export function readDataLiteralNode(node: Node): unknown {
   const kind = node.getKind();
   switch (kind) {
@@ -103,11 +122,50 @@ export function readDataLiteralNode(node: Node): unknown {
       return readDataLiteralNode(
         node.asKindOrThrow(SyntaxKind.ParenthesizedExpression).getExpression(),
       );
+    case SyntaxKind.Identifier:
+    case SyntaxKind.CallExpression:
+    case SyntaxKind.PropertyAccessExpression:
+      // Unresolvable reference (const identifier, factory call, member access).
+      // Keep the exact source text so renderValue can re-emit it verbatim —
+      // resolving/inlining it would silently rewrite the source on the next
+      // parse->render roundtrip (see readDataLiteralNode doc above).
+      return { __raw: node.getText() } satisfies RawRefSentinel;
     default:
       return undefined;
   }
 }
 
+/**
+ * A node's literal string value, or the raw-ref sentinel when it resolves to
+ * an unresolvable identifier/factory-call/member-access (see
+ * readDataLiteralNode). undefined for anything else (number, boolean, ...).
+ */
+export function readStringOrRaw(node: Node): string | RawRefSentinel | undefined {
+  const value = readDataLiteralNode(node);
+  if (typeof value === "string") return value;
+  if (isRawRefSentinel(value)) return value;
+  return undefined;
+}
+
+/**
+ * Like readStringLiteralArgs, but an argument that resolves to a raw-ref
+ * sentinel is kept as that sentinel instead of failing the whole call. Used
+ * where a value stands in for a single name/key and inlining its resolved
+ * string would corrupt the render roundtrip (e.g. `r.requires(someFeature.name)`
+ * — see #1009).
+ */
+export function readStringOrRawArgs(
+  call: CallExpression,
+): readonly (string | RawRefSentinel)[] | undefined {
+  const out: (string | RawRefSentinel)[] = [];
+  for (const arg of call.getArguments()) {
+    const value = readStringOrRaw(arg);
+    if (value === undefined) return undefined;
+    out.push(value);
+  }
+  return out;
+}
+
 export { isPlainObject } from "../../../utils/is-plain-object";
 
 export function readPropertyKey(propAssign: import("ts-morph").PropertyAssignment): string {
@@ -150,7 +208,7 @@ export function readNameOrRefOrList(node: Node): string | readonly string[] | un
 export function readVarargsOrArrayProp(
   call: CallExpression,
   arrayPropName: "features" | "keys",
-): readonly string[] | undefined {
+): readonly (string | RawRefSentinel)[] | undefined {
   const args = call.getArguments();
   if (args.length === 1) {
     const obj = args[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
@@ -162,15 +220,15 @@ export function readVarargsOrArrayProp(
       if (propInit) {
         const arr = propInit.asKind(SyntaxKind.ArrayLiteralExpression);
         if (!arr) return undefined;
-        const out: string[] = [];
+        const out: (string | RawRefSentinel)[] = [];
         for (const el of arr.getElements()) {
-          const lit = el.asKind(SyntaxKind.StringLiteral);
-          if (!lit) return undefined;
-          out.push(lit.getLiteralValue());
+          const value = readStringOrRaw(el);
+          if (value === undefined) return undefined;
+          out.push(value);
         }
         return out;
       }
     }
   }
-  return readStringLiteralArgs(call);
+  return readStringOrRawArgs(call);
 }

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

@@ -21,7 +21,13 @@
 // Per-pattern extractors fill in iteratively (C1.5) — each round adds
 // one extractor + a focused test.
 
-import type { ArrowFunction, CallExpression, ParameterDeclaration, SourceFile } from "ts-morph";
+import type {
+  ArrowFunction,
+  CallExpression,
+  Node,
+  ParameterDeclaration,
+  SourceFile,
+} from "ts-morph";
 import { Project, SyntaxKind } from "ts-morph";
 
 import {
@@ -63,6 +69,7 @@ import {
   extractUsesApi,
   extractWorkspace,
   extractWriteHandler,
+  findFunctionLiteral,
 } from "./extractors";
 import type { FeaturePattern, UnknownPattern } from "./patterns";
 import { type SourceLocation, sourceLocationFromNode } from "./source-location";
@@ -145,7 +152,7 @@ export function parseSourceFile(sourceFile: SourceFile): ParseResult {
   const patterns: FeaturePattern[] = [];
   const errors: ParseError[] = [];
 
-  walkSetupCallback(setupCallback, registrarParamName, sourceFile, patterns, errors);
+  walkSetupCallback(setupCallback.getBody(), registrarParamName, sourceFile, patterns, errors);
 
   return { featureName, patterns, errors };
 }
@@ -228,25 +235,131 @@ function extractRegistrarParamName(setup: ArrowFunction): string | undefined {
  * structurally impossible.
  */
 function walkSetupCallback(
-  setup: ArrowFunction,
+  body: Node,
   registrarParamName: string,
   sourceFile: SourceFile,
   patterns: FeaturePattern[],
   errors: ParseError[],
+  visitedWrapperDecls: Set<Node> = new Set(),
 ): void {
-  const body = setup.getBody();
   for (const call of body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
     const methodName = extractRegistrarMethodName(call, registrarParamName);
-    if (!methodName) continue; // Not a registrar call — ignore.
-    const result = dispatchExtractor(methodName, call, sourceFile);
-    if (result.kind === "pattern") {
-      patterns.push(result.pattern);
-    } else {
-      errors.push(result.error);
+    if (methodName) {
+      const result = dispatchExtractor(methodName, call, sourceFile);
+      if (result.kind === "pattern") {
+        patterns.push(result.pattern);
+      } else {
+        errors.push(result.error);
+      }
+      continue;
     }
+
+    // Not a direct `<registrarParam>.<method>(...)` call. Check whether it's
+    // a registrar-wrapper call — a function that receives the registrar as
+    // a bare argument, e.g. `registerShowPonyScreens(r)`. Such wrappers are
+    // invisible to a receiver-shape match, so we resolve the callee (same
+    // file, or the declaring file of a named import — #1008) and recurse
+    // into its body with its own parameter name for the registrar slot.
+    const wrapper = resolveRegistrarWrapperCall(call, registrarParamName);
+    if (!wrapper) continue; // Free function call unrelated to the registrar — ignore.
+    if (visitedWrapperDecls.has(wrapper.declNode)) continue; // Cycle guard.
+    visitedWrapperDecls.add(wrapper.declNode);
+    // wrapper.sourceFile, not the outer `sourceFile` param: a cross-file
+    // wrapper's body lives in a different file, and sourceLocationFromNode
+    // uses whichever SourceFile it's given for both the `file` path and
+    // the line/column table — passing the wrong one silently corrupts
+    // both for every pattern found inside the wrapper.
+    walkSetupCallback(
+      wrapper.body,
+      wrapper.paramName,
+      wrapper.sourceFile,
+      patterns,
+      errors,
+      visitedWrapperDecls,
+    );
   }
 }
 
+/**
+ * Resolves a bare call like `registerShowPonyScreens(r)` to the callee's
+ * body + its own parameter name for the registrar slot. The callee may be
+ * declared in the same file (function declaration, or a const initialized
+ * with an arrow/function expression), or imported by name from another
+ * file — resolved via the module specifier's SourceFile (#1008; only
+ * works against a real-filesystem Project, e.g. parseFeatureFile's. The
+ * in-memory Designer Project has no files to resolve against and
+ * getModuleSpecifierSourceFile() returns undefined there, same as any
+ * other unresolvable reference).
+ */
+function resolveRegistrarWrapperCall(
+  call: CallExpression,
+  registrarParamName: string,
+):
+  | {
+      readonly body: Node;
+      readonly paramName: string;
+      readonly declNode: Node;
+      readonly sourceFile: SourceFile;
+    }
+  | undefined {
+  const callee = call.getExpression().asKind(SyntaxKind.Identifier);
+  if (!callee) return undefined;
+
+  const args = call.getArguments();
+  const argIndex = args.findIndex((arg) => arg.getText() === registrarParamName);
+  if (argIndex === -1) return undefined; // Registrar not passed to this call.
+
+  const callSourceFile = call.getSourceFile();
+  const name = callee.getText();
+
+  const local = resolveWrapperDeclarationInFile(callSourceFile, name, argIndex);
+  if (local) return { ...local, sourceFile: callSourceFile };
+
+  const importDecl = callSourceFile
+    .getImportDeclarations()
+    .find((d) =>
+      d.getNamedImports().some((ni) => (ni.getAliasNode()?.getText() ?? ni.getName()) === name),
+    );
+  if (!importDecl) return undefined;
+  const exportedName =
+    importDecl
+      .getNamedImports()
+      .find((ni) => (ni.getAliasNode()?.getText() ?? ni.getName()) === name)
+      ?.getName() ?? name;
+  const targetFile = importDecl.getModuleSpecifierSourceFile();
+  if (!targetFile) return undefined; // Unresolvable: in-memory project, external package, or missing file.
+
+  const imported = resolveWrapperDeclarationInFile(targetFile, exportedName, argIndex);
+  return imported ? { ...imported, sourceFile: targetFile } : undefined;
+}
+
+function resolveWrapperDeclarationInFile(
+  sourceFile: SourceFile,
+  name: string,
+  argIndex: number,
+): { readonly body: Node; readonly paramName: string; readonly declNode: Node } | undefined {
+  const fnDecl = sourceFile.getFunction(name);
+  if (fnDecl) {
+    const param = fnDecl.getParameters()[argIndex];
+    const body = fnDecl.getBody();
+    if (!param || !body) return undefined;
+    return { body, paramName: param.getName(), declNode: fnDecl };
+  }
+
+  const varDecl = sourceFile.getVariableDeclaration(name);
+  const init = varDecl?.getInitializer();
+  const literal = init ? findFunctionLiteral(init) : undefined;
+  const fnLiteral =
+    literal?.asKind(SyntaxKind.ArrowFunction) ?? literal?.asKind(SyntaxKind.FunctionExpression);
+  if (fnLiteral) {
+    const param = fnLiteral.getParameters()[argIndex];
+    if (!param) return undefined;
+    return { body: fnLiteral.getBody(), paramName: param.getName(), declNode: fnLiteral };
+  }
+
+  return undefined;
+}
+
 /**
  * Returns the method name when the call has the form
  * `<registrarParamName>.<method>(...)`, otherwise undefined.

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

@@ -341,14 +341,20 @@ export type ScreenPattern = {
 export type WriteHandlerPattern = {
   readonly kind: "writeHandler";
   readonly source: SourceLocation;
-  readonly handlerName: string;
+  // handlerName/schemaSource/handlerBody are set together, or all left
+  // undefined for a single reference standing in for the whole handler
+  // (`r.writeHandler(handlerRef)`) that couldn't be resolved to an object
+  // literal — see #1007. An opaque pattern re-emits `source.raw` verbatim
+  // and, like UnknownPattern, has no PatternId variant (not individually
+  // patchable).
+  readonly handlerName?: string;
   // schemaSource: the Zod call as source text (e.g. "z.object({...})").
   // We keep it as an opaque block instead of decoding it back to JSON
   // schema — Zod's full surface is too rich for a faithful round-trip.
-  readonly schemaSource: SourceLocation;
+  readonly schemaSource?: SourceLocation;
   // handlerBody: the closure body as source text. Always opaque — AI
   // generates raw TypeScript, no DSL interpretation.
-  readonly handlerBody: SourceLocation;
+  readonly handlerBody?: SourceLocation;
   readonly access?: AccessRule;
   readonly rateLimit?: RateLimitOption;
   readonly unsafeSkipTransitionGuard?: boolean;
@@ -356,13 +362,14 @@ export type WriteHandlerPattern = {
 
 // `r.queryHandler(...)` — registers a read handler: name, Zod input schema,
 // handler closure, plus optional `access` and `rateLimit` rules. Read-side
-// counterpart of `r.writeHandler` with the same header/body split.
+// counterpart of `r.writeHandler` with the same header/body split. Opaque
+// (no handlerName) for the same single-reference case as WriteHandlerPattern.
 export type QueryHandlerPattern = {
   readonly kind: "queryHandler";
   readonly source: SourceLocation;
-  readonly handlerName: string;
-  readonly schemaSource: SourceLocation;
-  readonly handlerBody: SourceLocation;
+  readonly handlerName?: string;
+  readonly schemaSource?: SourceLocation;
+  readonly handlerBody?: SourceLocation;
   readonly access?: AccessRule;
   readonly rateLimit?: RateLimitOption;
 };

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

@@ -16,6 +16,7 @@
 // `// kumiko-feature-version: 1`. Future format bumps run a dedicated
 // migrator over the version comment.
 
+import { isRawRefSentinel } from "./extractors/shared";
 import type {
   AuthClaimsPattern,
   ClaimKeyPattern,
@@ -174,6 +175,7 @@ const SINGLE_LINE_WIDTH = 80;
  * multi-line otherwise — biome-stable in both branches.
  */
 export function renderValue(value: unknown, indent = 0): string {
+  if (isRawRefSentinel(value)) return value.__raw;
   if (value === null) return "null";
   if (typeof value === "string") return JSON.stringify(value);
   if (typeof value === "number" || typeof value === "boolean") return String(value);
@@ -240,6 +242,13 @@ function renderDescribe(p: DescribePattern): string {
 }
 
 function renderEntity(p: EntityPattern): string {
+  // A whole-value raw-ref (`r.entity("x", eventEntity)`) can't be spread
+  // into the merged Object-Form without losing `name` to the sentinel
+  // shortcut in renderValue — fall back to the classic positional form,
+  // which keeps the reference verbatim alongside the name.
+  if (isRawRefSentinel(p.definition)) {
+    return `r.entity(${JSON.stringify(p.entityName)}, ${p.definition.__raw});`;
+  }
   // Inline `name` into the definition object — canonical Object-Form
   // is a single arg with name-as-property.
   const merged = { name: p.entityName, ...p.definition };
@@ -247,6 +256,9 @@ function renderEntity(p: EntityPattern): string {
 }
 
 function renderRelation(p: RelationPattern): string {
+  if (isRawRefSentinel(p.definition)) {
+    return `r.relation(${JSON.stringify(p.entityName)}, ${JSON.stringify(p.relationName)}, ${p.definition.__raw});`;
+  }
   const merged = { entity: p.entityName, name: p.relationName, ...p.definition };
   return `r.relation(${renderValue(merged)});`;
 }
@@ -268,11 +280,17 @@ function renderTranslations(p: TranslationsPattern): string {
 }
 
 function renderMetric(p: MetricPattern): string {
+  if (isRawRefSentinel(p.options)) {
+    return `r.metric(${JSON.stringify(p.shortName)}, ${p.options.__raw});`;
+  }
   const merged = { name: p.shortName, ...p.options };
   return `r.metric(${renderValue(merged)});`;
 }
 
 function renderSecret(p: SecretPattern): string {
+  if (isRawRefSentinel(p.options)) {
+    return `r.secret(${JSON.stringify(p.shortName)}, ${p.options.__raw});`;
+  }
   const merged = { name: p.shortName, ...p.options };
   return `r.secret(${renderValue(merged)});`;
 }
@@ -291,6 +309,9 @@ function renderReferenceData(p: ReferenceDataPattern): string {
 }
 
 function renderUseExtension(p: UseExtensionPattern): string {
+  if (isRawRefSentinel(p.options)) {
+    return `r.useExtension(${JSON.stringify(p.extensionName)}, ${JSON.stringify(p.entityName)}, ${p.options.__raw});`;
+  }
   const merged: Record<string, unknown> = {
     name: p.extensionName,
     entity: p.entityName,
@@ -356,10 +377,11 @@ function reindentBody(raw: string, newIndent: string): string {
 }
 
 function renderWriteHandler(p: WriteHandlerPattern): string {
+  if (p.handlerName === undefined) return p.source.raw;
   const lines: string[] = ["r.writeHandler({"];
   lines.push(`  name: ${JSON.stringify(p.handlerName)},`);
-  lines.push(`  schema: ${reindentBody(p.schemaSource.raw, PATTERN_INDENT)},`);
-  lines.push(`  handler: ${reindentBody(p.handlerBody.raw, PATTERN_INDENT)},`);
+  lines.push(`  schema: ${reindentBody(p.schemaSource?.raw ?? "", PATTERN_INDENT)},`);
+  lines.push(`  handler: ${reindentBody(p.handlerBody?.raw ?? "", PATTERN_INDENT)},`);
   if (p.access !== undefined) lines.push(`  access: ${renderValue(p.access)},`);
   if (p.rateLimit !== undefined) lines.push(`  rateLimit: ${renderValue(p.rateLimit)},`);
   if (p.unsafeSkipTransitionGuard === true) lines.push("  unsafeSkipTransitionGuard: true,");
@@ -368,10 +390,11 @@ function renderWriteHandler(p: WriteHandlerPattern): string {
 }
 
 function renderQueryHandler(p: QueryHandlerPattern): string {
+  if (p.handlerName === undefined) return p.source.raw;
   const lines: string[] = ["r.queryHandler({"];
   lines.push(`  name: ${JSON.stringify(p.handlerName)},`);
-  lines.push(`  schema: ${reindentBody(p.schemaSource.raw, PATTERN_INDENT)},`);
-  lines.push(`  handler: ${reindentBody(p.handlerBody.raw, PATTERN_INDENT)},`);
+  lines.push(`  schema: ${reindentBody(p.schemaSource?.raw ?? "", PATTERN_INDENT)},`);
+  lines.push(`  handler: ${reindentBody(p.handlerBody?.raw ?? "", PATTERN_INDENT)},`);
   if (p.access !== undefined) lines.push(`  access: ${renderValue(p.access)},`);
   if (p.rateLimit !== undefined) lines.push(`  rateLimit: ${renderValue(p.rateLimit)},`);
   lines.push("});");
@@ -563,9 +586,7 @@ function weaveOpaque(
 }
 
 function renderValueWithRawSlots(value: WovenValue, indent: number): string {
-  if (value !== null && typeof value === "object" && !Array.isArray(value) && "__raw" in value) {
-    return (value as { __raw: string }).__raw;
-  }
+  if (isRawRefSentinel(value)) return value.__raw;
   if (Array.isArray(value)) {
     if (value.length === 0) return "[]";
     const inner = value

package/src/engine/feature-builder-state.ts

@@ -0,0 +1,165 @@
+import type { ZodType, z } from "zod";
+import { LifecycleHookTypes } from "./constants";
+import type {
+  AuthClaimsFn,
+  ClaimKeyDefinition,
+  ConfigKeyDefinition,
+  ConfigSeedDef,
+  EntityDefinition,
+  EntityProjectionExtension,
+  EventMigrationDef,
+  ExtensionSelectorDef,
+  FeatureMetricDef,
+  JobDefinition,
+  LifecycleHookFn,
+  MultiStreamProjectionDefinition,
+  NotificationDefinition,
+  OwnedFn,
+  PhasedHook,
+  PostDeleteHookFn,
+  PostQueryHookFn,
+  PostSaveHookFn,
+  PreDeleteHookFn,
+  ProjectionDefinition,
+  QueryHandlerDef,
+  RawTableEntry,
+  ReferenceDataDef,
+  RegistrarExtensionDef,
+  RegistrarExtensionRegistration,
+  RelationDefinition,
+  SearchPayloadContributorFn,
+  SecretKeyDefinition,
+  TranslationKeys,
+  TreeActionDef,
+  UiHints,
+  UnmanagedTableEntry,
+  ValidationHookFn,
+  WriteHandlerDef,
+} from "./types";
+import type { HttpRouteDefinition } from "./types/http-route";
+import type { NavDefinition } from "./types/nav";
+import type { ScreenDefinition } from "./types/screen";
+import type { WorkspaceDefinition } from "./types/workspace";
+
+const LIFECYCLE_TYPES = Object.values(LifecycleHookTypes);
+
+// Bundles every Record/Set/array/scalar defineFeature populates while the
+// registrar's ~40 methods run — hoisted out of defineFeature's closure so a
+// future move-diff (extracting each method into its own module) can thread
+// it explicitly. Every field is held BY REFERENCE — no destructured copies.
+export type FeatureBuilderState = {
+  requires: string[];
+  optionalRequires: string[];
+  requiredProjections: Set<string>;
+  requiredSteps: Set<string>;
+  entities: Record<string, EntityDefinition>;
+  entityTables: Record<string, unknown>;
+  relations: Record<string, Record<string, RelationDefinition>>;
+  writeHandlers: Record<string, WriteHandlerDef>;
+  queryHandlers: Record<string, QueryHandlerDef>;
+  validationHooks: Record<string, ValidationHookFn>;
+  lifecycleHooks: Record<string, Record<string, OwnedFn<LifecycleHookFn>[]>>;
+  phasedLifecycleHooks: Record<
+    "postSave" | "preDelete" | "postDelete",
+    Record<string, PhasedHook<LifecycleHookFn>[]>
+  >;
+  configKeys: Record<string, ConfigKeyDefinition>;
+  configSeeds: ConfigSeedDef[];
+  jobs: Record<string, JobDefinition>;
+  events: Record<string, { name: string; schema: ZodType; version: number }>;
+  eventMigrations: Record<string, EventMigrationDef[]>;
+  configReads: string[];
+  entityPostSave: Record<string, PhasedHook<PostSaveHookFn>[]>;
+  entityPreDelete: Record<string, PhasedHook<PreDeleteHookFn>[]>;
+  entityPostDelete: Record<string, PhasedHook<PostDeleteHookFn>[]>;
+  entityPostQuery: Record<string, OwnedFn<PostQueryHookFn>[]>;
+  searchPayloadExtensions: Record<string, OwnedFn<SearchPayloadContributorFn>[]>;
+  notifications: Record<string, NotificationDefinition>;
+  registrarExtensions: Record<string, RegistrarExtensionDef>;
+  extensionUsages: RegistrarExtensionRegistration[];
+  extensionSelectors: ExtensionSelectorDef[];
+  exposedApis: Set<string>;
+  usedApis: Set<string>;
+  referenceData: ReferenceDataDef[];
+  handlerEntityMappings: Record<string, string>;
+  metrics: Record<string, FeatureMetricDef>;
+  secretKeys: Record<string, SecretKeyDefinition>;
+  projections: Record<string, ProjectionDefinition>;
+  multiStreamProjections: Record<string, MultiStreamProjectionDefinition>;
+  entityProjectionExtensions: Record<string, EntityProjectionExtension[]>;
+  rawTables: Record<string, RawTableEntry>;
+  unmanagedTables: Record<string, UnmanagedTableEntry>;
+  authClaimsHooks: AuthClaimsFn[];
+  claimKeys: Record<string, ClaimKeyDefinition>;
+  screens: Record<string, ScreenDefinition>;
+  navs: Record<string, NavDefinition>;
+  workspaces: Record<string, WorkspaceDefinition>;
+  httpRoutes: Record<string, HttpRouteDefinition>;
+  translations: TranslationKeys;
+  isSystemScoped: boolean;
+  toggleableDefault: boolean | undefined;
+  description: string | undefined;
+  uiHints: UiHints | undefined;
+  treeActions: Readonly<Record<string, TreeActionDef>> | undefined;
+  envSchema: z.ZodObject<z.ZodRawShape> | undefined;
+};
+
+export function createInitialFeatureBuilderState(): FeatureBuilderState {
+  const lifecycleHooks: Record<string, Record<string, OwnedFn<LifecycleHookFn>[]>> = {};
+  for (const t of LIFECYCLE_TYPES) {
+    lifecycleHooks[t] = {};
+  }
+  return {
+    requires: [],
+    optionalRequires: [],
+    requiredProjections: new Set<string>(),
+    requiredSteps: new Set<string>(),
+    entities: {},
+    entityTables: {},
+    relations: {},
+    writeHandlers: {},
+    queryHandlers: {},
+    validationHooks: {},
+    lifecycleHooks,
+    phasedLifecycleHooks: { postSave: {}, preDelete: {}, postDelete: {} },
+    configKeys: {},
+    configSeeds: [],
+    jobs: {},
+    events: {},
+    eventMigrations: {},
+    configReads: [],
+    entityPostSave: {},
+    entityPreDelete: {},
+    entityPostDelete: {},
+    entityPostQuery: {},
+    searchPayloadExtensions: {},
+    notifications: {},
+    registrarExtensions: {},
+    extensionUsages: [],
+    extensionSelectors: [],
+    exposedApis: new Set(),
+    usedApis: new Set(),
+    referenceData: [],
+    handlerEntityMappings: {},
+    metrics: {},
+    secretKeys: {},
+    projections: {},
+    multiStreamProjections: {},
+    entityProjectionExtensions: {},
+    rawTables: {},
+    unmanagedTables: {},
+    authClaimsHooks: [],
+    claimKeys: {},
+    screens: {},
+    navs: {},
+    workspaces: {},
+    httpRoutes: {},
+    translations: {},
+    isSystemScoped: false,
+    toggleableDefault: undefined,
+    description: undefined,
+    uiHints: undefined,
+    treeActions: undefined,
+    envSchema: undefined,
+  };
+}