@cosmicdrift/kumiko-framework 0.387.0 → 0.388.0

package/dist/engine/feature-ast/pattern-change-schema.d.ts

@@ -7,6 +7,7 @@ import type { RelationDefinition } from "../types/relations.ts";
 import type { ScreenDefinition } from "../types/screen.ts";
 import type { TreeActionDef } from "../types/tree-node.ts";
 import type { WorkspaceDefinition } from "../types/workspace.ts";
+import type { RawRefSentinel } from "./extractors/shared.ts";
 import type { PatternChange } from "./patch.ts";
 import type { SourceLocation } from "./source-location.ts";
 export type PatternChangeIssue = {
@@ -26,6 +27,7 @@ export declare const PATTERN_SCHEMAS_BY_KIND: {
         source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
         entityName: z.ZodString;
         definition: z.ZodType<EntityDefinition, unknown, z.core.$ZodTypeInternals<EntityDefinition, unknown>>;
+        backingTable: z.ZodOptional<z.ZodType<RawRefSentinel, unknown, z.core.$ZodTypeInternals<RawRefSentinel, unknown>>>;
     }, z.core.$strict>;
     relation: z.ZodObject<{
         kind: z.ZodLiteral<"relation">;
@@ -648,6 +650,7 @@ export declare const patternSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;
     entityName: z.ZodString;
     definition: z.ZodType<EntityDefinition, unknown, z.core.$ZodTypeInternals<EntityDefinition, unknown>>;
+    backingTable: z.ZodOptional<z.ZodType<RawRefSentinel, unknown, z.core.$ZodTypeInternals<RawRefSentinel, unknown>>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"relation">;
     source: z.ZodType<SourceLocation, unknown, z.core.$ZodTypeInternals<SourceLocation, unknown>>;

package/dist/engine/feature-ast/pattern-change-schema.js

@@ -332,6 +332,7 @@ const entitySchema = z
     source: sourceFieldSchema,
     entityName: z.string(),
     definition: entityDefinitionSchema,
+    backingTable: passthroughSchema().optional(),
 })
     .strict();
 const relationSchema = z

package/dist/engine/feature-ast/pattern-id-matchers.d.ts

@@ -0,0 +1,7 @@
+import { type CallExpression } from "ts-morph";
+import type { PatternId } from "./patch.ts";
+import type { MembersByKind } from "./patterns.ts";
+type PatternIdKind = PatternId["kind"];
+type PatternIdOfKind = MembersByKind<PatternId>;
+export declare function callMatchesId<K extends PatternIdKind>(call: CallExpression, kind: K, id: PatternIdOfKind[K]): boolean;
+export {};

package/dist/engine/feature-ast/pattern-id-matchers.js

@@ -0,0 +1,210 @@
+import { SyntaxKind } from "ts-morph";
+import { readNameLiteral, readNameOrRef, resolveSameFileObjectLiteral, } from "./extractors/shared.js";
+const PATTERN_ID_MATCHERS = {
+    requires: matchSingletonCall,
+    optionalRequires: matchSingletonCall,
+    readsConfig: matchSingletonCall,
+    systemScope: matchSingletonCall,
+    toggleable: matchSingletonCall,
+    describe: matchSingletonCall,
+    uiHints: matchSingletonCall,
+    config: matchSingletonCall,
+    translations: matchSingletonCall,
+    authClaims: matchSingletonCall,
+    treeActions: matchSingletonCall,
+    entity: matchEntityCall,
+    relation: matchRelationCall,
+    nav: matchIdPropertyCall,
+    workspace: matchIdPropertyCall,
+    screen: matchIdPropertyCall,
+    writeHandler: matchHandlerCall,
+    queryHandler: matchHandlerCall,
+    streamHandler: matchHandlerCall,
+    hook: matchHookCall,
+    metric: matchShortNameCall,
+    secret: matchShortNameCall,
+    secretNamespace: matchShortNameCall,
+    claimKey: matchShortNameCall,
+    referenceData: matchReferenceDataCall,
+    useExtension: matchUseExtensionCall,
+    job: matchJobCall,
+    notification: matchNotificationCall,
+    httpRoute: matchHttpRouteCall,
+    projection: matchProjectionCall,
+    multiStreamProjection: matchProjectionCall,
+    defineEvent: matchDefineEventCall,
+    extendsRegistrar: matchExtendsRegistrarCall,
+    "ai.generate": matchAiStepCall,
+    "ai.extract": matchAiStepCall,
+    "ai.classify": matchAiStepCall,
+};
+export function callMatchesId(call, kind, id) {
+    return PATTERN_ID_MATCHERS[kind](call, id);
+}
+// Singletons: kind alone identifies the call.
+function matchSingletonCall() {
+    return true;
+}
+function matchEntityCall(call, id) {
+    return (matchFirstArgString(call, id.entityName) || matchObjectProperty(call, "name", id.entityName));
+}
+// Positional: r.relation(entity, name, def) | Object: { entity, name, ... }
+function matchRelationCall(call, id) {
+    if (matchFirstArgString(call, id.entityName)) {
+        return matchArgString(call, 1, id.relationName);
+    }
+    return (matchObjectProperty(call, "entity", id.entityName) &&
+        matchObjectProperty(call, "name", id.relationName));
+}
+function matchIdPropertyCall(call, id) {
+    return matchObjectProperty(call, "id", id.id);
+}
+function matchHandlerCall(call, id) {
+    return (matchFirstArgString(call, id.handlerName) || matchObjectProperty(call, "name", id.handlerName));
+}
+// Positional: r.hook(type, target, fn) | Object: { type, target }
+function matchHookCall(call, id) {
+    if (typeof id.target === "object") {
+        return matchHookAllOfCall(call, id.hookType, id.target.allOf);
+    }
+    if (matchFirstArgString(call, id.hookType)) {
+        return matchArgNameOrRef(call, 1, id.target);
+    }
+    return (matchObjectProperty(call, "type", id.hookType) && matchObjectProperty(call, "target", id.target));
+}
+// 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.
+function matchHookAllOfCall(call, hookType, allOfEntity) {
+    if (matchFirstArgString(call, hookType)) {
+        return matchAllOfArg(call.getArguments()[1], allOfEntity);
+    }
+    return (matchObjectProperty(call, "type", hookType) &&
+        matchObjectAllOfProperty(call, "target", allOfEntity));
+}
+function matchShortNameCall(call, id) {
+    return matchFirstArgString(call, id.shortName) || matchObjectProperty(call, "name", id.shortName);
+}
+function matchReferenceDataCall(call, id) {
+    return (matchFirstArgString(call, id.entityName) || matchObjectProperty(call, "entity", id.entityName));
+}
+// Positional: r.useExtension(name, entity) | Object: { name, entity }
+function matchUseExtensionCall(call, id) {
+    if (matchFirstArgString(call, id.extensionName)) {
+        return matchArgNameOrRef(call, 1, id.entityName);
+    }
+    return (matchObjectProperty(call, "name", id.extensionName) &&
+        matchObjectProperty(call, "entity", id.entityName));
+}
+function matchJobCall(call, id) {
+    return matchFirstArgString(call, id.jobName) || matchObjectProperty(call, "name", id.jobName);
+}
+function matchNotificationCall(call, id) {
+    return (matchFirstArgString(call, id.notificationName) ||
+        matchObjectProperty(call, "name", id.notificationName));
+}
+// Object form only; positional doesn't apply.
+function matchHttpRouteCall(call, id) {
+    return (matchObjectProperty(call, "method", id.method) && matchObjectProperty(call, "path", id.path));
+}
+function matchProjectionCall(call, id) {
+    return matchObjectProperty(call, "name", id.name);
+}
+function matchDefineEventCall(call, id) {
+    return matchFirstArgString(call, id.eventName) || matchObjectProperty(call, "name", id.eventName);
+}
+function matchExtendsRegistrarCall(call, id) {
+    return matchFirstArgString(call, id.extensionName);
+}
+function matchAiStepCall(call, id) {
+    return readAiStepKey(call) === id.stepKey;
+}
+function readAiStepKey(call) {
+    const arg = call.getArguments()[0];
+    if (!arg)
+        return undefined;
+    const obj = resolveSameFileObjectLiteral(arg);
+    if (!obj)
+        return undefined;
+    const prop = obj.getProperty("stepKey");
+    if (!prop)
+        return undefined;
+    const assign = prop.asKind(SyntaxKind.PropertyAssignment);
+    if (assign) {
+        const init = assign.getInitializer();
+        if (!init)
+            return undefined;
+        return readNameLiteral(init);
+    }
+    const shorthand = prop.asKind(SyntaxKind.ShorthandPropertyAssignment);
+    if (shorthand)
+        return readNameLiteral(shorthand.getNameNode());
+    return undefined;
+}
+// Resolves an argument the same way the extractors do (readNameLiteral):
+// a string literal directly, or a bare identifier following its
+// declaration (same-file or imported) to a string-literal initializer —
+// the dominant naming style in the framework's own bundled-features
+// (`r.entity(ENTITY, ...)`, `r.useExtension(EXT_X, ...)`).
+//
+// Narrow on purpose: every kind's arg-0 (and relation's arg-1) is parsed
+// via readNameLiteral, never readNameOrRef (see round2.ts/round3.ts) —
+// widening this shared helper to readNameOrRef would let an object-form
+// call's first argument (an ObjectLiteralExpression) match here too,
+// short-circuiting the object-form branch in callMatchesId. Positions
+// where the parser itself accepts an inline `{ name: "..." }` ref use
+// `matchArgNameOrRef` below instead.
+function matchArgString(call, index, expected) {
+    const arg = call.getArguments()[index];
+    if (!arg)
+        return false;
+    return readNameLiteral(arg) === expected;
+}
+// @wrapper-known semantic-alias
+function matchFirstArgString(call, expected) {
+    return matchArgString(call, 0, expected);
+}
+// Like matchArgString, but via readNameOrRef — for the specific positional
+// slots where the parser accepts an inline `{ name: "..." }` object ref in
+// addition to a literal/identifier (useExtension's entity arg, hook's
+// target arg; see round3.ts:445 / hooks.ts:75). Not a drop-in replacement
+// for matchArgString: applying it to an arg-0 position would match an
+// object-form call's first (and only) argument, see the comment above.
+function matchArgNameOrRef(call, index, expected) {
+    const arg = call.getArguments()[index];
+    if (!arg)
+        return false;
+    return readNameOrRef(arg) === expected;
+}
+// Object-form property values are resolved via readNameOrRef, not the
+// narrower readNameLiteral — some properties (useExtension's `entity`,
+// hook's `target`/`allOf`) accept an inline `{ name: "..." }` ref in the
+// parser (see extractors/round3.ts, extractors/hooks.ts), not just a
+// literal or identifier. readNameOrRef is a superset of readNameLiteral,
+// so this is safe for every other property too.
+function matchObjectProperty(call, propName, expected) {
+    const obj = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (!obj)
+        return false;
+    const init = obj.getProperty(propName)?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
+    if (!init)
+        return false;
+    return readNameOrRef(init) === 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, expectedEntity) {
+    const obj = node?.asKind(SyntaxKind.ObjectLiteralExpression);
+    const init = obj?.getProperty("allOf")?.asKind(SyntaxKind.PropertyAssignment)?.getInitializer();
+    if (!init)
+        return false;
+    return readNameOrRef(init) === expectedEntity;
+}
+function matchObjectAllOfProperty(call, propName, expectedEntity) {
+    const obj = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
+    const propInit = obj
+        ?.getProperty(propName)
+        ?.asKind(SyntaxKind.PropertyAssignment)
+        ?.getInitializer();
+    return matchAllOfArg(propInit, expectedEntity);
+}

package/dist/engine/feature-ast/patterns.d.ts

@@ -18,6 +18,7 @@ export type EntityPattern = {
     readonly source: SourceLocation;
     readonly entityName: string;
     readonly definition: EntityDefinition;
+    readonly backingTable?: RawRefSentinel;
 };
 export type RelationPattern = {
     readonly kind: "relation";
@@ -304,6 +305,14 @@ export type UnknownPattern = {
 };
 export type FeaturePattern = EntityPattern | RelationPattern | NavPattern | WorkspacePattern | ConfigPattern | TranslationsPattern | RequiresPattern | OptionalRequiresPattern | SystemScopePattern | ToggleablePattern | DescribePattern | UiHintsPattern | MetricPattern | SecretPattern | SecretNamespacePattern | ClaimKeyPattern | ReferenceDataPattern | ReadsConfigPattern | UseExtensionPattern | UsesApiPattern | ExposesApiPattern | TreeActionsPattern | ScreenPattern | WriteHandlerPattern | QueryHandlerPattern | StreamHandlerPattern | HookPattern | JobPattern | NotificationPattern | AuthClaimsPattern | HttpRoutePattern | ProjectionPattern | MultiStreamProjectionPattern | DefineEventPattern | ExtendsRegistrarPattern | EnvSchemaPattern | AiGeneratePattern | AiExtractPattern | AiClassifyPattern | UnknownPattern;
 export type FeaturePatternKind = FeaturePattern["kind"];
+export type MembersByKind<U extends {
+    readonly kind: string;
+}> = {
+    readonly [K in U["kind"]]: Extract<U, {
+        readonly kind: K;
+    }>;
+};
+export type FeaturePatternOfKind = MembersByKind<FeaturePattern>;
 export type Editability = "static" | "mixed" | "opaque";
 export declare function getEditability(pattern: FeaturePattern): Editability;
 export {};

package/dist/engine/feature-ast/patterns.js

@@ -59,56 +59,48 @@
 // against this constant to decide "form vs read-only span" — the actual
 // SourceLocation lives at the matching path in `opaqueProps`.
 export const SCREEN_OPAQUE_MARKER = "$opaque";
+const EDITABILITY_BY_KIND = {
+    entity: "static",
+    relation: "static",
+    nav: "static",
+    workspace: "static",
+    config: "static",
+    translations: "static",
+    requires: "static",
+    optionalRequires: "static",
+    systemScope: "static",
+    toggleable: "static",
+    describe: "static",
+    metric: "static",
+    secret: "static",
+    secretNamespace: "static",
+    claimKey: "static",
+    referenceData: "static",
+    readsConfig: "static",
+    useExtension: "static",
+    usesApi: "static",
+    exposesApi: "static",
+    treeActions: "static",
+    screen: "mixed",
+    writeHandler: "mixed",
+    queryHandler: "mixed",
+    streamHandler: "mixed",
+    hook: "mixed",
+    job: "mixed",
+    notification: "mixed",
+    httpRoute: "mixed",
+    projection: "mixed",
+    multiStreamProjection: "mixed",
+    defineEvent: "mixed",
+    "ai.generate": "mixed",
+    "ai.extract": "mixed",
+    "ai.classify": "mixed",
+    authClaims: "opaque",
+    extendsRegistrar: "opaque",
+    envSchema: "opaque",
+    uiHints: "opaque",
+    unknown: "opaque",
+};
 export function getEditability(pattern) {
-    switch (pattern.kind) {
-        case "entity":
-        case "relation":
-        case "nav":
-        case "workspace":
-        case "config":
-        case "translations":
-        case "requires":
-        case "optionalRequires":
-        case "systemScope":
-        case "toggleable":
-        case "describe":
-        case "metric":
-        case "secret":
-        case "secretNamespace":
-        case "claimKey":
-        case "referenceData":
-        case "readsConfig":
-        case "useExtension":
-        case "usesApi":
-        case "exposesApi":
-        case "treeActions":
-            return "static";
-        case "screen":
-        case "writeHandler":
-        case "queryHandler":
-        case "streamHandler":
-        case "hook":
-        case "job":
-        case "notification":
-        case "httpRoute":
-        case "projection":
-        case "multiStreamProjection":
-        case "defineEvent":
-        case "ai.generate":
-        case "ai.extract":
-        case "ai.classify":
-            return "mixed";
-        case "authClaims":
-        case "extendsRegistrar":
-        case "envSchema":
-        case "uiHints":
-        case "unknown":
-            return "opaque";
-        default: {
-            // Exhaustiveness guard — adding a new pattern kind without
-            // updating this switch produces a compile error here.
-            const _exhaustive = pattern;
-            return _exhaustive;
-        }
-    }
+    return EDITABILITY_BY_KIND[pattern.kind];
 }

package/dist/engine/feature-ast/render.js

@@ -30,92 +30,52 @@ export const VERSION_HEADER = `// kumiko-feature-version: ${FEATURE_FILE_VERSION
  * trailing newline; callers compose statements with their own joiner.
  */
 export function renderPattern(pattern) {
-    switch (pattern.kind) {
-        case "requires":
-            return renderRequires(pattern);
-        case "optionalRequires":
-            return renderOptionalRequires(pattern);
-        case "readsConfig":
-            return renderReadsConfig(pattern);
-        case "systemScope":
-            return renderSystemScope(pattern);
-        case "toggleable":
-            return renderToggleable(pattern);
-        case "describe":
-            return renderDescribe(pattern);
-        case "uiHints":
-            return renderUiHints(pattern);
-        case "entity":
-            return renderEntity(pattern);
-        case "relation":
-            return renderRelation(pattern);
-        case "nav":
-            return renderNav(pattern);
-        case "workspace":
-            return renderWorkspace(pattern);
-        case "config":
-            return renderConfig(pattern);
-        case "translations":
-            return renderTranslations(pattern);
-        case "metric":
-            return renderMetric(pattern);
-        case "secret":
-            return renderSecret(pattern);
-        case "secretNamespace":
-            return renderSecretNamespace(pattern);
-        case "claimKey":
-            return renderClaimKey(pattern);
-        case "referenceData":
-            return renderReferenceData(pattern);
-        case "useExtension":
-            return renderUseExtension(pattern);
-        case "screen":
-            return renderScreen(pattern);
-        case "writeHandler":
-            return renderWriteHandler(pattern);
-        case "queryHandler":
-            return renderQueryHandler(pattern);
-        case "streamHandler":
-            return renderStreamHandler(pattern);
-        case "hook":
-            return renderHook(pattern);
-        case "job":
-            return renderJob(pattern);
-        case "notification":
-            return renderNotification(pattern);
-        case "authClaims":
-            return renderAuthClaims(pattern);
-        case "httpRoute":
-            return renderHttpRoute(pattern);
-        case "projection":
-            return renderProjection(pattern);
-        case "multiStreamProjection":
-            return renderMultiStreamProjection(pattern);
-        case "defineEvent":
-            return renderDefineEvent(pattern);
-        case "extendsRegistrar":
-            return renderExtendsRegistrar(pattern);
-        case "usesApi":
-            return renderUsesApi(pattern);
-        case "exposesApi":
-            return renderExposesApi(pattern);
-        case "treeActions":
-            return renderTreeActions(pattern);
-        case "envSchema":
-            return renderEnvSchema(pattern);
-        case "ai.generate":
-            return renderAiGenerate(pattern);
-        case "ai.extract":
-            return renderAiExtract(pattern);
-        case "ai.classify":
-            return renderAiClassify(pattern);
-        case "unknown":
-            return renderUnknown(pattern);
-        default: {
-            const _exhaustive = pattern;
-            return _exhaustive;
-        }
-    }
+    return renderPatternOfKind(pattern.kind, pattern);
+}
+const PATTERN_RENDERERS = {
+    requires: renderRequires,
+    optionalRequires: renderOptionalRequires,
+    readsConfig: renderReadsConfig,
+    systemScope: renderSystemScope,
+    toggleable: renderToggleable,
+    describe: renderDescribe,
+    uiHints: renderUiHints,
+    entity: renderEntity,
+    relation: renderRelation,
+    nav: renderNav,
+    workspace: renderWorkspace,
+    config: renderConfig,
+    translations: renderTranslations,
+    metric: renderMetric,
+    secret: renderSecret,
+    secretNamespace: renderSecretNamespace,
+    claimKey: renderClaimKey,
+    referenceData: renderReferenceData,
+    useExtension: renderUseExtension,
+    screen: renderScreen,
+    writeHandler: renderWriteHandler,
+    queryHandler: renderQueryHandler,
+    streamHandler: renderStreamHandler,
+    hook: renderHook,
+    job: renderJob,
+    notification: renderNotification,
+    authClaims: renderAuthClaims,
+    httpRoute: renderHttpRoute,
+    projection: renderProjection,
+    multiStreamProjection: renderMultiStreamProjection,
+    defineEvent: renderDefineEvent,
+    extendsRegistrar: renderExtendsRegistrar,
+    usesApi: renderUsesApi,
+    exposesApi: renderExposesApi,
+    treeActions: renderTreeActions,
+    envSchema: renderEnvSchema,
+    "ai.generate": renderAiGenerate,
+    "ai.extract": renderAiExtract,
+    "ai.classify": renderAiClassify,
+    unknown: renderUnknown,
+};
+function renderPatternOfKind(kind, pattern) {
+    return PATTERN_RENDERERS[kind](pattern);
 }
 // =============================================================================
 // JSON-Like Value Renderer — emits TypeScript-source-compatible literals.
@@ -206,7 +166,8 @@ function renderEntity(p) {
     // losing `name` to the sentinel shortcut — spread the reference verbatim
     // next to the name instead.
     if (isRawRefSentinel(p.definition)) {
-        return `r.entity({ name: ${JSON.stringify(p.entityName)}, ...${p.definition.__raw} });`;
+        const backingTable = p.backingTable ? `, backingTable: ${p.backingTable.__raw}` : "";
+        return `r.entity({ name: ${JSON.stringify(p.entityName)}, ...${p.definition.__raw}${backingTable} });`;
     }
     const merged = { name: p.entityName, ...p.definition };
     return `r.entity(${renderValue(merged)});`;

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

@@ -130,6 +130,9 @@ export function buildEntityHandlerMethods(state, name) {
                 ...(def.unsafeSkipTransitionGuard && { unsafeSkipTransitionGuard: true }),
                 ...(def.rateLimit && { rateLimit: def.rateLimit }),
                 ...(def.additionalRateLimits && { additionalRateLimits: def.additionalRateLimits }),
+                ...(def.rateLimitCost && {
+                    rateLimitCost: def.rateLimitCost, // @cast-boundary engine-bridge
+                }),
                 ...(def.escapeHatch && { escapeHatch: def.escapeHatch }),
                 ...transactionPhaseSlots(def),
                 ...(def.tenantlessAnonymous && { tenantlessAnonymous: true }),

package/dist/engine/form-derivations.js

@@ -101,17 +101,30 @@ function sumListCell(rows, listField, cell) {
     return sum;
 }
 function targetCurrency(field, current, sourceCurrency) {
+    // The client value is last: it must never override what the field or its sources dictate.
+    if (field.type === "money" && field.currency.kind === "literal")
+        return field.currency.code;
+    if (sourceCurrency !== undefined)
+        return sourceCurrency;
     if (isPlainObject(current) &&
         typeof current["currency"] === "string" &&
         current["currency"] !== "") {
         return current["currency"];
     }
-    if (sourceCurrency !== undefined)
-        return sourceCurrency;
-    if (field.type === "money" && field.currency.kind === "literal")
-        return field.currency.code;
     return undefined;
 }
+function computeOrdinary(derivation, values, fields) {
+    const operands = derivation.from.map((name) => readOperand(values, fields, name));
+    const currencies = new Set(operands.flatMap((operand) => operand.currency ?? []));
+    const sourceCurrency = currencies.values().next().value;
+    // Operands in different currencies have no meaningful sum.
+    if (currencies.size > 1)
+        return { computed: undefined, sourceCurrency };
+    return {
+        computed: computeDerivedCellValue(derivation.op, operands.map((operand) => operand.value)),
+        sourceCurrency,
+    };
+}
 /** Recomputes every derived head field of an action form from its inputs.
  *  Pure and client-safe: the renderer runs it live, the server runs it
  *  again (`withFormDerivations`) and overwrites whatever the client sent.
@@ -148,9 +161,7 @@ export function applyFormDerivations(values, screen) {
             ordinary = derivation;
         }
         if (ordinary !== undefined) {
-            const operands = ordinary.from.map((name) => readOperand(result, screen.fields, name));
-            sourceCurrency = operands.find((operand) => operand.currency !== undefined)?.currency;
-            computed = computeDerivedCellValue(ordinary.op, operands.map((operand) => operand.value));
+            ({ computed, sourceCurrency } = computeOrdinary(ordinary, result, screen.fields));
         }
         if (computed === undefined) {
             delete result[target];

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

@@ -5,7 +5,7 @@ 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() }),
+    z.strictObject({ entity: z.string().min(1), by: z.string().min(1).optional() }),
 ]);
 function rawReferenceMeta(field) {
     const meta = zodMeta(field);

package/dist/engine/project-app-schema-for-roles.d.ts

@@ -1,2 +1,4 @@
 import type { AppSchema } from "../ui-types/app-schema.ts";
+import type { NavDefinition } from "./types/nav.ts";
 export declare function projectAppSchemaForRoles(schema: AppSchema, roles: readonly string[]): AppSchema;
+export declare function isPureGroupingNav(nav: Pick<NavDefinition, "screen" | "target" | "provider">): boolean;

package/dist/engine/project-app-schema-for-roles.js

@@ -27,7 +27,7 @@
 // @cosmicdrift/kumiko-types/handlers) — an unset `access` here means every
 // signed-in user may see the entry, the opposite stance from `hasAccess`.
 //
-// Reference-site coverage (every place boot-validator/screens.ts resolves a
+// Reference-site coverage (every place boot-validator/screens*.ts resolves a
 // screen target is a site this file also projects):
 //   - nav.screen / nav.parent (author-registered AND settings-hub-generated
 //     navs — the latter use short ids relative to the synthetic "config"
@@ -204,16 +204,18 @@ function isNavDeniedOrDead(ctx, screenAccessByQn, keptScreenQns, roles) {
     const effectiveAccess = ctx.nav.access ?? screenAccessByQn.get(ctx.resolvedScreenQn);
     return !isUiAccessGranted(effectiveAccess, roles);
 }
+export function isPureGroupingNav(nav) {
+    return nav.screen === undefined && nav.target === undefined && nav.provider !== true;
+}
 function isDroppedByPropagation(ctx, dropped, childrenByParent) {
     if (ctx.resolvedParentQn !== undefined && dropped.has(ctx.resolvedParentQn))
         return true;
-    const isPureGroupingNode = ctx.nav.screen === undefined && ctx.nav.target === undefined && ctx.nav.provider !== true;
-    if (!isPureGroupingNode)
+    if (!isPureGroupingNav(ctx.nav))
         return false;
     const children = childrenByParent.get(ctx.qn) ?? [];
     return children.length > 0 && children.every((child) => dropped.has(child.qn));
 }
-// --- screen-target resolution helpers (mirror boot-validator/screens.ts) ---
+// --- screen-target resolution helpers (mirror boot-validator/screens*.ts) ---
 function isScreenTargetKept(featureName, target, keptScreenQns) {
     return keptScreenQns.has(resolveScreenTargetQn(featureName, target));
 }

package/dist/engine/registry-ingest.js

@@ -16,7 +16,7 @@ export function populateFeatureCore(state, feature) {
             throw new Error(`Duplicate entity: "${name}" (registered by multiple features)`);
         }
         state.entityMap.set(name, entity);
-        const physical = resolveTableName(name, entity, feature.name);
+        const physical = resolveTableName(name, entity, undefined);
         const clash = state.physicalTableOwners.get(physical);
         if (clash?.kind === "store") {
             throw new Error(`Entity "${name}" (feature "${feature.name}") has physical table "${physical}" which ` +