@object-ui/core 17.7.0 → 18.0.0

package/dist/data-scope/ViewDataProvider.js

@@ -9,28 +9,19 @@
  * @object-ui/core - View Data Provider
  *
  * Resolves @objectstack/spec ViewData discriminated union into
- * a unified data access interface. Supports three data modes:
+ * a unified data access interface. Supports two data modes:
  *
  * 1. 'object' — Metadata-driven via ObjectStack API (object name → fields/records)
- * 2. 'api' — Custom REST API endpoints (read/write URLs)
- * 3. 'value' — Static data (pre-loaded items array)
+ * 2. 'value' — Static data (pre-loaded items array)
+ *
+ * The view-level `'api'` mode is retired in `@objectstack/spec`
+ * (objectstack#23082, ADR-0049) and has no arm here (objectui#12325): a
+ * config that still names it resolves as an unknown provider, with an error.
  *
  * @module data-scope
  * @packageDocumentation
  */
 import { collectSavedViews, composeElementDataSource, elementDataSourceRefusedLimitMessage, elementDataSourceViewNotFoundMessage, resolveSavedView, } from './element-data-source.js';
-/** Extract records array from various common API response shapes */
-function extractRecords(data) {
-    if (Array.isArray(data))
-        return data;
-    if (Array.isArray(data?.records))
-        return data.records;
-    if (Array.isArray(data?.data))
-        return data.data;
-    if (Array.isArray(data?.items))
-        return data.items;
-    return [];
-}
 /**
  * Resolves ViewData configuration into actual data via a pluggable fetcher.
  *
@@ -59,8 +50,6 @@ export class ViewDataProvider {
         switch (config.provider) {
             case 'value':
                 return this.resolveValue(config);
-            case 'api':
-                return this.resolveApi(config);
             case 'object':
                 return this.resolveObject(config, options);
             default:
@@ -83,42 +72,6 @@ export class ViewDataProvider {
             loading: false,
         };
     }
-    /** Resolve API-based data */
-    async resolveApi(config) {
-        if (!this.fetcher?.fetchUrl) {
-            return {
-                records: [],
-                total: 0,
-                provider: 'api',
-                loading: false,
-                error: 'No fetchUrl implementation available for API data provider',
-            };
-        }
-        try {
-            const data = await this.fetcher.fetchUrl(config.read.url, {
-                method: config.read.method,
-                headers: config.read.headers,
-            });
-            // Handle common response shapes
-            const records = extractRecords(data);
-            const total = data?.total ?? data?.count ?? records.length;
-            return {
-                records,
-                total,
-                provider: 'api',
-                loading: false,
-            };
-        }
-        catch (error) {
-            return {
-                records: [],
-                total: 0,
-                provider: 'api',
-                loading: false,
-                error: error.message,
-            };
-        }
-    }
     /** Resolve object-based data (metadata-driven) */
     async resolveObject(config, options) {
         if (!this.fetcher) {

package/dist/evaluator/deadlineSettled.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Whether a declared deadline is settled for one row (objectui#11815).
+ *
+ * `@objectstack/spec` declares the deadline semantic on a `date` / `datetime`
+ * field: `dueLike: true` makes it a deadline, and `settledWhen` is a per-record
+ * CEL predicate that, while it holds, settles that deadline for the record —
+ * no overdue wording, no overdue colour. The date cells paint from the field's
+ * declaration alone and cannot evaluate a predicate, so every host that draws
+ * one beside a row asks THIS function and hands the cell its answer as the
+ * `deadlineSettled` prop. One helper, so no host carries its own copy.
+ */
+import { type RowPredicateOptions } from './listConditional.js';
+import type { FieldRulePredicate } from './fieldRules.js';
+/** The two declared keys {@link isDeadlineSettled} reads off a field. */
+export interface DeadlineFieldLike {
+    name?: string;
+    dueLike?: boolean | null;
+    settledWhen?: FieldRulePredicate | null;
+}
+/**
+ * `true` only when the field declares `dueLike: true` AND a `settledWhen`, and
+ * that predicate holds for `row` (bound as `record`, through
+ * {@link evalRowPredicate} — the evaluator, scope and relation collapse the
+ * grid's conditional formatting uses).
+ *
+ * Every other answer is `false`:
+ *  - a field that is not a declared deadline, or declares no `settledWhen`, is
+ *    never settled;
+ *  - a predicate that fails to evaluate is NOT settled. It was judged when it
+ *    was authored, and a quiet "settled" would hide an overdue item; the
+ *    evaluator's own one-time warning names the fault.
+ */
+export declare function isDeadlineSettled(field: DeadlineFieldLike | null | undefined, row: Record<string, unknown> | null | undefined, opts?: Pick<RowPredicateOptions, 'scope' | 'fields'>): boolean;

package/dist/evaluator/deadlineSettled.js

@@ -0,0 +1,45 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Whether a declared deadline is settled for one row (objectui#11815).
+ *
+ * `@objectstack/spec` declares the deadline semantic on a `date` / `datetime`
+ * field: `dueLike: true` makes it a deadline, and `settledWhen` is a per-record
+ * CEL predicate that, while it holds, settles that deadline for the record —
+ * no overdue wording, no overdue colour. The date cells paint from the field's
+ * declaration alone and cannot evaluate a predicate, so every host that draws
+ * one beside a row asks THIS function and hands the cell its answer as the
+ * `deadlineSettled` prop. One helper, so no host carries its own copy.
+ */
+import { evalRowPredicate } from './listConditional.js';
+/**
+ * `true` only when the field declares `dueLike: true` AND a `settledWhen`, and
+ * that predicate holds for `row` (bound as `record`, through
+ * {@link evalRowPredicate} — the evaluator, scope and relation collapse the
+ * grid's conditional formatting uses).
+ *
+ * Every other answer is `false`:
+ *  - a field that is not a declared deadline, or declares no `settledWhen`, is
+ *    never settled;
+ *  - a predicate that fails to evaluate is NOT settled. It was judged when it
+ *    was authored, and a quiet "settled" would hide an overdue item; the
+ *    evaluator's own one-time warning names the fault.
+ */
+export function isDeadlineSettled(field, row, opts = {}) {
+    if (!field || field.dueLike !== true)
+        return false;
+    const settledWhen = field.settledWhen;
+    if (settledWhen == null)
+        return false;
+    return evalRowPredicate(settledWhen, row, {
+        fallback: false,
+        scope: opts.scope,
+        fields: opts.fields,
+        label: `${field.name ?? 'field'}.settledWhen`,
+    });
+}

package/dist/evaluator/fieldRules.js

@@ -74,7 +74,7 @@
  * site as every other fault; the VERDICT is unchanged for every input.
  */
 import { ExpressionEngine } from '@objectstack/formula';
-import { subjectPermissionsOf } from './subjectPermissions.js';
+import { subjectCapabilitiesOf, subjectPermissionsOf } from './subjectPermissions.js';
 import { isBlankPredicateText } from './declaredPredicate.js';
 import { isUnevaluablePredicate, UNEVALUABLE_PREDICATE_REASON } from './unevaluablePredicate.js';
 /** Normalize a predicate into the `Expression` shape the engine expects. */
@@ -226,11 +226,16 @@ export function evalFieldPredicate(pred, record, fallback, previous, scope, diag
             // with none passes none, and `can` then refuses loudly: that fault goes
             // through the caller's `fallback` like any other.
             const permissions = subjectPermissionsOf(scope?.current_user);
+            // objectui#13006 — the subject's held system capabilities, the one input
+            // `current_user.hasCapability(name)` is answered from, carried the same
+            // way and for the same reason; absent stays absent, so the call refuses.
+            const systemPermissions = subjectCapabilitiesOf(scope?.current_user);
             const res = ExpressionEngine.evaluate(expr, {
                 record,
                 previous,
                 ...(scope ? { extra: scope } : {}),
                 ...(permissions !== undefined ? { permissions } : {}),
+                ...(systemPermissions !== undefined ? { systemPermissions } : {}),
             });
             // Parse error, type error, unbound identifier, engine fault … — every
             // not-ok verdict resolves to the fallback, but never silently (objectstack-ai/objectstack#5149).

package/dist/evaluator/index.d.ts

@@ -13,6 +13,7 @@ export * from './fieldRules.js';
 export * from './subjectPermissions.js';
 export * from './rowPredicateCanon.js';
 export * from './listConditional.js';
+export * from './deadlineSettled.js';
 export * from './optionRules.js';
 export * from './optionLint.js';
 export * from './ExpressionCache.js';

package/dist/evaluator/index.js

@@ -13,6 +13,7 @@ export * from './fieldRules.js';
 export * from './subjectPermissions.js';
 export * from './rowPredicateCanon.js';
 export * from './listConditional.js';
+export * from './deadlineSettled.js';
 export * from './optionRules.js';
 export * from './optionLint.js';
 export * from './ExpressionCache.js';

package/dist/evaluator/optionRules.d.ts

@@ -78,7 +78,7 @@ export declare function resolveVisibleOptions<T extends OptionLike>(options: rea
  * This is deliberately NOT the lenient renderer fallback AGENTS.md #0.1
  * forbids. That rule governs metadata the contract REFUSES ("if the metadata
  * is off-spec, fix it at the producer"); an empty label is metadata the
- * contract ACCEPTS. Measured on the installed `@objectstack/spec` 17.6.0,
+ * contract ACCEPTS. Measured on the installed `@objectstack/spec` 18.0.0,
  * `SelectOptionSchema`:
  *
  *   { value: 'low', label: 'Low' } -> ACCEPT   (lit control)

package/dist/evaluator/optionRules.js

@@ -57,7 +57,7 @@ export function resolveVisibleOptions(options, record, scope) {
  * This is deliberately NOT the lenient renderer fallback AGENTS.md #0.1
  * forbids. That rule governs metadata the contract REFUSES ("if the metadata
  * is off-spec, fix it at the producer"); an empty label is metadata the
- * contract ACCEPTS. Measured on the installed `@objectstack/spec` 17.6.0,
+ * contract ACCEPTS. Measured on the installed `@objectstack/spec` 18.0.0,
  * `SelectOptionSchema`:
  *
  *   { value: 'low', label: 'Low' } -> ACCEPT   (lit control)

package/dist/evaluator/subjectPermissions.d.ts

@@ -49,7 +49,7 @@
  * here, because the engine's contract is that an empty map means "holds
  * nothing" and a caller that has no data must not claim it has that answer.
  */
-import type { EvalPermissions } from '@objectstack/formula';
+import type { EvalPermissions, EvalSystemPermissions } from '@objectstack/formula';
 /**
  * The key the subject carries its effective object permissions under.
  *
@@ -74,3 +74,32 @@ export declare function bindSubjectPermissions<T extends object>(subject: T, per
  * carries none (see "Absent is not empty" above).
  */
 export declare function subjectPermissionsOf(subject: unknown): EvalPermissions | undefined;
+/**
+ * The key the subject carries its held system capabilities under — the
+ * `systemPermissions` list of the `/auth/me/permissions` response, the one
+ * input `current_user.hasCapability(name)` is answered from (objectui#13006).
+ *
+ * It rides beside {@link SUBJECT_PERMISSIONS} for the same reasons: the engine
+ * reads it from `EvalContext.systemPermissions`, ⛔ never from a CEL variable,
+ * so it can be neither a scope key (every scope key is a root) nor a string
+ * member of `current_user` (`current_user.systemPermissions` would be a
+ * readable member reaching around the function). A symbol is neither.
+ *
+ * Absent is not empty, exactly as for the permissions map: a subject carrying
+ * no list hands the engine none, and `hasCapability` refuses loudly; an empty
+ * list is a real answer ("holds no capability") and evaluates to `false`.
+ */
+export declare const SUBJECT_CAPABILITIES: unique symbol;
+/**
+ * The subject to publish as `current_user`, carrying `systemPermissions` when
+ * there is a list — the sibling of {@link bindSubjectPermissions}, on the same
+ * terms: a shallow copy (the caller's object is never mutated, and every alias
+ * must be the returned object), and with no list a subject built from one that
+ * had a list is stripped rather than left answering from a stale one.
+ */
+export declare function bindSubjectCapabilities<T extends object>(subject: T, systemPermissions: EvalSystemPermissions | undefined): T;
+/**
+ * The held system capabilities a subject carries, or `undefined` when it
+ * carries none (absent is not empty — see {@link SUBJECT_CAPABILITIES}).
+ */
+export declare function subjectCapabilitiesOf(subject: unknown): EvalSystemPermissions | undefined;

package/dist/evaluator/subjectPermissions.js

@@ -42,3 +42,45 @@ export function subjectPermissionsOf(subject) {
         return undefined;
     return subject[SUBJECT_PERMISSIONS];
 }
+/**
+ * The key the subject carries its held system capabilities under — the
+ * `systemPermissions` list of the `/auth/me/permissions` response, the one
+ * input `current_user.hasCapability(name)` is answered from (objectui#13006).
+ *
+ * It rides beside {@link SUBJECT_PERMISSIONS} for the same reasons: the engine
+ * reads it from `EvalContext.systemPermissions`, ⛔ never from a CEL variable,
+ * so it can be neither a scope key (every scope key is a root) nor a string
+ * member of `current_user` (`current_user.systemPermissions` would be a
+ * readable member reaching around the function). A symbol is neither.
+ *
+ * Absent is not empty, exactly as for the permissions map: a subject carrying
+ * no list hands the engine none, and `hasCapability` refuses loudly; an empty
+ * list is a real answer ("holds no capability") and evaluates to `false`.
+ */
+export const SUBJECT_CAPABILITIES = Symbol.for('@object-ui/core:subject-capabilities');
+/**
+ * The subject to publish as `current_user`, carrying `systemPermissions` when
+ * there is a list — the sibling of {@link bindSubjectPermissions}, on the same
+ * terms: a shallow copy (the caller's object is never mutated, and every alias
+ * must be the returned object), and with no list a subject built from one that
+ * had a list is stripped rather than left answering from a stale one.
+ */
+export function bindSubjectCapabilities(subject, systemPermissions) {
+    if (systemPermissions === undefined) {
+        if (!Object.prototype.hasOwnProperty.call(subject, SUBJECT_CAPABILITIES))
+            return subject;
+        const stripped = { ...subject };
+        delete stripped[SUBJECT_CAPABILITIES];
+        return stripped;
+    }
+    return { ...subject, [SUBJECT_CAPABILITIES]: systemPermissions };
+}
+/**
+ * The held system capabilities a subject carries, or `undefined` when it
+ * carries none (absent is not empty — see {@link SUBJECT_CAPABILITIES}).
+ */
+export function subjectCapabilitiesOf(subject) {
+    if (subject === null || typeof subject !== 'object')
+        return undefined;
+    return subject[SUBJECT_CAPABILITIES];
+}

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export * from './builder/schema-builder.js';
 export * from './utils/dom-props.js';
 export * from './utils/filter-converter.js';
 export * from './utils/managedBy.js';
+export * from './utils/affordanceGrants.js';
 export * from './utils/extract-records.js';
 export * from './utils/non-grid-row-ceiling.js';
 export * from './utils/emptiness.js';

package/dist/index.js

@@ -21,6 +21,9 @@ export * from './builder/schema-builder.js';
 export * from './utils/dom-props.js';
 export * from './utils/filter-converter.js';
 export * from './utils/managedBy.js';
+// The affordance-to-grant map (objectui#12082): every console affordance that
+// offers a write reads the grant it exercises from this one table.
+export * from './utils/affordanceGrants.js';
 export * from './utils/extract-records.js';
 // The non-grid row ceiling (objectui#7210), homed beside the `extractRecords`
 // it wraps by objectui#7508's ruling A′. `@object-ui/react` re-exports three of

package/dist/registry/Registry.d.ts

@@ -136,7 +136,7 @@ export type ComponentDeprecation = {
  * publishing registry mechanics on the general type was the alternative
  * objectui#6067 weighed and rejected.
  *
- * They live in their OWN named type so that `ComponentMeta` below can be
+ * They live in their OWN named type so that `RegistryComponentMeta` below can be
  * DERIVED from the canonical declaration instead of restating it. Until
  * objectui#6067 this file carried a second, thirteen-key structural copy of
  * the name: the nine shared members restated from `@object-ui/types`' `base.ts`,
@@ -238,6 +238,18 @@ export type RegistryComponentMetaExtras = {
  * the two keys the divergence had made unwritable at the very declaration most
  * component registrations import.
  *
+ * ## Its own NAME since objectui#6349 (batch 4)
+ *
+ * This type used to be published as `ComponentMeta` too — the same name as the
+ * canonical declaration it extends, with a different meaning (registration
+ * metadata: the canonical members PLUS the five registry-only keys). A derived
+ * declaration is still a second authority for the name, so the card's rename
+ * branch applies: the registration type is `RegistryComponentMeta` (the name
+ * `PluginScopeImpl.ts` already gave it locally), and `ComponentMeta` from this
+ * package is a plain re-export of `@object-ui/types`' one (just below). The
+ * registry's own doors — `register`, `registerLazy`, `getMeta` — are typed
+ * with this name, so a registration literal keeps accepting the registry keys.
+ *
  * NOTE for anyone pinning this: every member of both halves is OPTIONAL, so
  * `extends` is mutually TRUE between the two shapes even when their key sets
  * differ. Measured on the EMITTED `.d.ts` of both packages immediately before
@@ -248,7 +260,15 @@ export type RegistryComponentMetaExtras = {
  * compares `keyof` sets instead and keeps the assignability check beside it as
  * the labelled control that shows why.
  */
-export type ComponentMeta = CanonicalComponentMeta & RegistryComponentMetaExtras;
+export type RegistryComponentMeta = CanonicalComponentMeta & RegistryComponentMetaExtras;
+/**
+ * The general component metadata — `@object-ui/types`' ONE declaration,
+ * re-exported so an import of `ComponentMeta` from this package resolves to
+ * the same type as one from `@object-ui/types` (objectui#6349, batch 4). It
+ * carries none of the registry-only keys; a registration is typed with
+ * {@link RegistryComponentMeta}.
+ */
+export type { ComponentMeta } from '@object-ui/types';
 /**
  * ONE authority for `ComponentConfig` (objectui#6298) — this package RE-EXPORTS
  * `@object-ui/types`' declaration instead of declaring a second one, the same
@@ -280,8 +300,9 @@ export type ComponentMeta = CanonicalComponentMeta & RegistryComponentMetaExtras
  * counts declarations and ALIASING re-exports, never `export type { X } from …`
  * — which is why this convergence takes `ComponentConfig` off that gate's
  * `KNOWN_COLLISIONS` baseline. Deriving a new declaration here instead would
- * NOT have: `ComponentMeta` was converged that way by PR #6297 and is still a
- * row on that baseline today.
+ * NOT have: `ComponentMeta` was converged that way by PR #6297 and stayed a row
+ * on that baseline until objectui#6349 gave the registry's declaration its own
+ * name, `RegistryComponentMeta`.
  */
 export type { ComponentConfig } from '@object-ui/types';
 /**
@@ -294,7 +315,7 @@ export type { ComponentConfig } from '@object-ui/types';
  * one declaration for the shared members ({@link ComponentConfig}, in
  * `@object-ui/types`), a named extension for the rest
  * ({@link RegistryComponentMetaExtras}) — which is the shape PR #6297 gave
- * {@link ComponentMeta}.
+ * {@link RegistryComponentMeta}.
  *
  * It exists because the extras are NOT optional decoration on a registry entry:
  * {@link Registry.getNamespaceComponents} filters on `config.namespace`, and
@@ -302,7 +323,7 @@ export type { ComponentConfig } from '@object-ui/types';
  * bare re-export as the entry type would have silently dropped them.
  *
  * ⚠️ `ComponentConfig` remains the AUTHORING vocabulary and the general name;
- * registrations are checked against {@link ComponentMeta}, never against this.
+ * registrations are checked against {@link RegistryComponentMeta}, never against this.
  * Nothing writes a `RegistryComponentConfig` literal — the registry builds them.
  */
 export type RegistryComponentConfig<T = any> = ComponentConfig<T> & RegistryComponentMetaExtras;
@@ -322,7 +343,7 @@ export type RegistryComponentConfig<T = any> = ComponentConfig<T> & RegistryComp
  * — the read stamps it, and `manifestFromConfigs` carries it into the manifest
  * so a consumer that means the CURATED vocabulary can filter it out.
  */
-export type PublicComponentConfig<T = any> = Omit<ComponentMeta, 'tier'> & {
+export type PublicComponentConfig<T = any> = Omit<RegistryComponentMeta, 'tier'> & {
     type: string;
     /**
      * The registration's declared tier, or `'html'` for an entry that reaches the
@@ -330,7 +351,7 @@ export type PublicComponentConfig<T = any> = Omit<ComponentMeta, 'tier'> & {
      * curated roster or a `tier: 'public'` opt-in. Absent or `'public'` = the
      * curated JSON-surface vocabulary.
      */
-    tier?: ComponentMeta['tier'] | 'html';
+    tier?: RegistryComponentMeta['tier'] | 'html';
     component?: ComponentRenderer<T>;
     /** True while this entry is a `registerLazy` stub whose loader has not run. */
     lazy?: boolean;
@@ -380,7 +401,7 @@ export type LazyComponentLoader = () => Promise<unknown>;
  * The spliced element is an `InjectedComponentInput` (`@object-ui/types`): a
  * `ComponentInput` plus the framework-set `binding` marker, so it is a plain
  * subtype of the array's element type and the return value type-checks as a
- * `ComponentMeta` with no assertion. This used to read `as ComponentMeta`,
+ * `RegistryComponentMeta` with no assertion. This used to read `as ComponentMeta`,
  * because `ELEMENT_DATA_SOURCE_INPUT` carried a hand-written inline type and
  * `binding` had no declared home — and a cast at the one place the key is
  * written is exactly what would have hidden any later drift between the
@@ -394,7 +415,7 @@ export type LazyComponentLoader = () => Promise<unknown>;
  * pins the positive half, that the local below is ANNOTATED. Keep it typed: if
  * the shape ever stops fitting, that line is where the compiler should say so.
  */
-export declare function withElementDataSourceInput<T>(component: ComponentRenderer<T>, meta?: ComponentMeta): ComponentMeta | undefined;
+export declare function withElementDataSourceInput<T>(component: ComponentRenderer<T>, meta?: RegistryComponentMeta): RegistryComponentMeta | undefined;
 export declare class Registry<T = any> {
     private components;
     private lazyEntries;
@@ -430,7 +451,7 @@ export declare class Registry<T = any> {
      * registry.register('button', ButtonComponent);
      * // Accessible as 'button'
      */
-    register(type: string, component: ComponentRenderer<T>, meta?: ComponentMeta): void;
+    register(type: string, component: ComponentRenderer<T>, meta?: RegistryComponentMeta): void;
     /**
      * Remove a previously registered component. Mirrors {@link register} by
      * clearing both the namespaced key and the bare-name fallback (when the
@@ -473,7 +494,7 @@ export declare class Registry<T = any> {
      * @example
      * ComponentRegistry.registerLazy('object-map', () => import('@object-ui/plugin-map'), { namespace: 'plugin-map' });
      */
-    registerLazy(type: string, loader: LazyComponentLoader, meta?: ComponentMeta): void;
+    registerLazy(type: string, loader: LazyComponentLoader, meta?: RegistryComponentMeta): void;
     /**
      * Returns true if `type` (or its namespaced form) has a registered lazy
      * loader awaiting first use.
@@ -575,7 +596,7 @@ export declare class Registry<T = any> {
      * absent until the chunk loads. Consumers should treat that as "not yet
      * known", not as "declares no props".
      */
-    getMeta(type: string, namespace?: string): ComponentMeta | undefined;
+    getMeta(type: string, namespace?: string): RegistryComponentMeta | undefined;
     /**
      * The deprecation `type` declares FOR `surface` — or `undefined` when it
      * declares none there (objectui#6674).

package/dist/registry/Registry.js

@@ -8,18 +8,6 @@
 import { ELEMENT_DATA_SOURCE_INPUT, isElementDataSourceBlock, } from '../data-scope/element-data-source.js';
 import { PUBLIC_BLOCKS } from './public-blocks.js';
 import { HTML_TIER_INTRINSICS } from './html-tier-intrinsics.js';
-/**
- * The full type a pending lazy stub DECLARES for a bare key.
- *
- * `registerLazy` computes `namespace:type` and stores the stub under both that
- * key and the bare one; nothing on the entry itself records which bare key it
- * claims, so the claim has to be recomputed from the entry's own meta. Spelled
- * once here because both doors' collision guards need it and a second copy
- * would be a second thing to keep in step with `registerLazy`'s own line.
- */
-function lazyStubFullType(type, entry) {
-    return entry.meta?.namespace ? `${entry.meta.namespace}:${type}` : type;
-}
 /**
  * Emit the spec's `dataSource` input for a registration whose renderer wraps
  * `ElementDataSourceGate` (objectui#6678).
@@ -57,7 +45,7 @@ function lazyStubFullType(type, entry) {
  * The spliced element is an `InjectedComponentInput` (`@object-ui/types`): a
  * `ComponentInput` plus the framework-set `binding` marker, so it is a plain
  * subtype of the array's element type and the return value type-checks as a
- * `ComponentMeta` with no assertion. This used to read `as ComponentMeta`,
+ * `RegistryComponentMeta` with no assertion. This used to read `as ComponentMeta`,
  * because `ELEMENT_DATA_SOURCE_INPUT` carried a hand-written inline type and
  * `binding` had no declared home — and a cast at the one place the key is
  * written is exactly what would have hidden any later drift between the
@@ -204,8 +192,7 @@ export class Registry {
                 // owner and the opt-out settles this contest exactly as it does on the
                 // lazy door. Both doors therefore prescribe the same thing now, which
                 // `each door prescribes the remedy that is true for it` pins.
-                const stub = this.lazyEntries.get(type);
-                const stubType = stub ? lazyStubFullType(type, stub) : undefined;
+                const stubType = this.lazyEntries.get(type)?.fullType;
                 if (stubType && stubType !== fullType) {
                     console.warn(`Component "${type}" bare-name fallback is being overwritten by "${fullType}", ` +
                         `which a pending lazy stub already claims for "${stubType}". Which one an ` +
@@ -283,7 +270,7 @@ export class Registry {
         // The same ownership test, on the other table.
         if (namespace) {
             const bareStub = this.lazyEntries.get(type);
-            if (bareStub && lazyStubFullType(type, bareStub) === fullType) {
+            if (bareStub && bareStub.fullType === fullType) {
                 this.lazyEntries.delete(type);
             }
         }
@@ -305,7 +292,7 @@ export class Registry {
      */
     registerLazy(type, loader, meta) {
         const fullType = meta?.namespace ? `${meta.namespace}:${type}` : type;
-        const entry = { loader, meta };
+        const entry = { loader, meta, fullType };
         this.lazyEntries.set(fullType, entry);
         if (meta?.namespace && !meta?.skipFallback) {
             // Collision guard (objectui#9821). This door took the same bare-name
@@ -335,11 +322,7 @@ export class Registry {
             // genuine contest.
             const loaded = this.components.get(type);
             const priorStub = loaded ? undefined : this.lazyEntries.get(type);
-            const claimedBy = loaded
-                ? loaded.type
-                : priorStub
-                    ? lazyStubFullType(type, priorStub)
-                    : undefined;
+            const claimedBy = loaded ? loaded.type : priorStub?.fullType;
             if (claimedBy && claimedBy !== fullType) {
                 console.warn(`Lazy component "${type}" bare-name fallback is being overwritten by "${fullType}", ` +
                     `which ${loaded ? 'a loaded registration' : 'another pending stub'} already claims ` +