{
@@ -37,7 +49,7 @@ const StableWidget: React.FC
= (props) => (
* `content` stays checked once objectui#8347 removes `BaseSchema`'s index
* signature.
*/
-type StableWidgetNode = BaseSchema & { content?: string };
+type StableWidgetNode = BaseSchema & { type: 'stable-widget'; content?: string };
const stableWidget = (schema: StableWidgetNode): StableWidgetNode => schema;
describe('SchemaErrorBoundary', () => {
diff --git a/packages/react/src/__tests__/SchemaRenderer.expressions.test.tsx b/packages/react/src/__tests__/SchemaRenderer.expressions.test.tsx
index a056923291..7d27ccdc2c 100644
--- a/packages/react/src/__tests__/SchemaRenderer.expressions.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.expressions.test.tsx
@@ -34,10 +34,22 @@ import type { PageComponent } from '@objectstack/spec/ui';
* that row. It is checked against this node, not against `BaseSchema`, so the
* key stays checked once objectui#8347 removes `BaseSchema`'s index signature.
*/
-type DeprecatedVisibilityNode = BaseSchema & Pick;
+type DeprecatedVisibilityNode = BaseSchema & Pick & { type: 'test-component' };
const deprecatedVisibilityNode = (schema: DeprecatedVisibilityNode): DeprecatedVisibilityNode => schema;
import { PredicateScopeProvider } from '../hooks/useExpression';
+/**
+ * This file's registered `TestComponent`, typed by its probe node, declared to
+ * `@object-ui/types` the way an application declares a type it registers
+ * (objectui#11466): a node slot and the `schema` prop take the declared node
+ * types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'test-component': DeprecatedVisibilityNode;
+ }
+}
+
/**
* NOTE (objectui#7912): `SchemaRendererProvider.dataSource` — and the context
* it feeds — declare the published `DataSource` adapter contract. The values
diff --git a/packages/react/src/__tests__/SchemaRenderer.hiddenDeclaredGate.test.tsx b/packages/react/src/__tests__/SchemaRenderer.hiddenDeclaredGate.test.tsx
index bd0a11b5f1..b5835db50c 100644
--- a/packages/react/src/__tests__/SchemaRenderer.hiddenDeclaredGate.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.hiddenDeclaredGate.test.tsx
@@ -99,6 +99,17 @@ import { SchemaRendererContext } from '../context/SchemaRendererContext';
import { PredicateScopeProvider } from '../hooks/useExpression';
import { __resetVisibilityPredicateWarnings } from '../utils/visibilityDiagnostic';
+/**
+ * This file's registered probe, declared to `@object-ui/types` the way an
+ * application declares a type it registers (objectui#11466): a node slot and
+ * the `schema` prop take the declared node types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'probe-3955': BaseSchema;
+ }
+}
+
/**
* NOTE (objectui#7912): `SchemaRendererProvider.dataSource` — and the context
* it feeds — declare the published `DataSource` adapter contract. The values
@@ -157,7 +168,7 @@ function renderNode(schema: Record) {
* well. That its verdict is IDENTICAL to the string form's, on all three keys
* and in both polarities, is `SchemaRenderer.predicateEnvelopeDeclared.test.tsx`.
*/
-function renderDeclaredNode(schema: BaseSchema) {
+function renderDeclaredNode(schema: BaseSchema & { type: 'probe-3955' }) {
return render(
diff --git a/packages/react/src/__tests__/SchemaRenderer.hiddenVisibleSynonymy.test.tsx b/packages/react/src/__tests__/SchemaRenderer.hiddenVisibleSynonymy.test.tsx
index 77a56a695c..768a0d9fe7 100644
--- a/packages/react/src/__tests__/SchemaRenderer.hiddenVisibleSynonymy.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.hiddenVisibleSynonymy.test.tsx
@@ -44,6 +44,18 @@ import { render, screen } from '@testing-library/react';
import React from 'react';
import { ComponentRegistry } from '@object-ui/core';
import { SchemaRenderer } from '../SchemaRenderer';
+import type { BaseSchema } from '@object-ui/types';
+
+/**
+ * This file's registered probe, declared to `@object-ui/types` the way an
+ * application declares a type it registers (objectui#11466): a node slot and
+ * the `schema` prop take the declared node types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'probe-7088': BaseSchema;
+ }
+}
const Probe = () => ;
diff --git a/packages/react/src/__tests__/SchemaRenderer.predicateEnvelopeDeclared.test.tsx b/packages/react/src/__tests__/SchemaRenderer.predicateEnvelopeDeclared.test.tsx
index ef942d45ba..b6fc7dac60 100644
--- a/packages/react/src/__tests__/SchemaRenderer.predicateEnvelopeDeclared.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.predicateEnvelopeDeclared.test.tsx
@@ -67,6 +67,17 @@ import { SchemaRenderer } from '../SchemaRenderer';
import { SchemaRendererContext } from '../context/SchemaRendererContext';
import { PredicateScopeProvider } from '../hooks/useExpression';
+/**
+ * This file's registered probe, declared to `@object-ui/types` the way an
+ * application declares a type it registers (objectui#11466): a node slot and
+ * the `schema` prop take the declared node types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'probe-7530': BaseSchema;
+ }
+}
+
/**
* NOTE (objectui#7912): `SchemaRendererProvider.dataSource` — and the context
* it feeds — declare the published `DataSource` adapter contract. The values
@@ -93,7 +104,7 @@ const Probe = (props: { disabled?: unknown }) => (
const DATA = { status: 'draft', published: false };
/** The DECLARED path -- `BaseSchema`, nothing wider, no cast. */
-function mount(schema: BaseSchema) {
+function mount(schema: BaseSchema & { type: 'probe-7530' }) {
return render(
diff --git a/packages/react/src/__tests__/SchemaRenderer.primitiveSchema.test.tsx b/packages/react/src/__tests__/SchemaRenderer.primitiveSchema.test.tsx
index b365e755f4..a3a6c88a50 100644
--- a/packages/react/src/__tests__/SchemaRenderer.primitiveSchema.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.primitiveSchema.test.tsx
@@ -34,6 +34,19 @@ import { render } from '@testing-library/react';
import React from 'react';
import { ComponentRegistry } from '@object-ui/core';
import { SchemaRenderer } from '../SchemaRenderer';
+import { undeclaredNode } from '@object-ui/test-support';
+import type { BaseSchema } from '@object-ui/types';
+
+/**
+ * This file's registered probe, declared to `@object-ui/types` the way an
+ * application declares a type it registers (objectui#11466): a node slot and
+ * the `schema` prop take the declared node types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'test-4548-div': BaseSchema;
+ }
+}
const originalWarn = console.warn;
beforeEach(() => {
@@ -87,7 +100,8 @@ describe('objectui#4548 — non-object schema values', () => {
it('still shows the error box for an OBJECT whose type is unregistered', () => {
// The unknown-component box is correct HERE — an object that names a type
// nothing implements. Only the primitive case stopped producing it.
- const { container } = render();
+ // Deliberately undeclared: the type is the point (objectui#11466).
+ const { container } = render();
expect(container.textContent).toContain('Unknown component type');
expect(container.textContent).toContain('no-such-component-4548');
});
diff --git a/packages/react/src/__tests__/SchemaRenderer.propsResolution.test.ts b/packages/react/src/__tests__/SchemaRenderer.propsResolution.test.ts
index 617e59cd99..5ce00402c5 100644
--- a/packages/react/src/__tests__/SchemaRenderer.propsResolution.test.ts
+++ b/packages/react/src/__tests__/SchemaRenderer.propsResolution.test.ts
@@ -55,7 +55,7 @@
import { describe, it, expect } from 'vitest';
import type { ComponentProps } from 'react';
-import type { AuthoringNode, BaseSchema } from '@object-ui/types';
+import type { BaseSchema, DeclaredNode } from '@object-ui/types';
import { SchemaRenderer, type SchemaRendererProps } from '../SchemaRenderer';
import { toRenderableSchema } from '../schema-input';
@@ -69,10 +69,15 @@ type CallSiteProps = ComponentProps;
// 1. THE assertion. `schema` survives to the call site with its declared type.
// Before the fix this was `any`, so every schema — and any prop typo next to
// it — passed silently. objectui#11364 widened the object member by the
-// referenced `AuthoringNode` types only (no index signature, no `Record`).
+// referenced `AuthoringNode` types only (no index signature, no `Record`);
+// objectui#11466 made it `DeclaredNode`, the union of the declared node
+// types, with no `BaseSchema` (`type: string`) arm.
type _SchemaIsDeclared = Assert<
- Equal
+ Equal
>;
+// 1b. …and `BaseSchema` is no longer an arm of it (objectui#11466): a value typed
+// `BaseSchema` names no declared type, so it does not reach the prop.
+type _BaseSchemaIsNotAnArm = Assert>;
// 2. …and that is not vacuously true because the whole thing is `any`. On the
// pre-fix shape assertion 1 would have "passed" against `any` for any type
diff --git a/packages/react/src/__tests__/SchemaRenderer.scopedStyleSchemaIdentity.test.tsx b/packages/react/src/__tests__/SchemaRenderer.scopedStyleSchemaIdentity.test.tsx
index 47009d389c..a47c66b213 100644
--- a/packages/react/src/__tests__/SchemaRenderer.scopedStyleSchemaIdentity.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.scopedStyleSchemaIdentity.test.tsx
@@ -42,6 +42,19 @@ import { SchemaRenderer } from '../SchemaRenderer';
import { PageVariablesProvider, usePageVariables } from '../hooks/usePageVariables';
import type { BaseSchema } from '@object-ui/types';
import type { PageComponent } from '@objectstack/spec/ui';
+import { undeclaredNode } from '@object-ui/test-support';
+
+/**
+ * This file's registered probes, declared to `@object-ui/types` the way an
+ * application declares a type it registers (objectui#11466): a node slot and
+ * the `schema` prop take the declared node types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'identity-probe': ScopedStyleNode;
+ 'self-updating-probe': ScopedStyleNode;
+ }
+}
/**
* A node authoring `responsiveStyles` inline (objectui#11349), typed by
@@ -51,8 +64,12 @@ import type { PageComponent } from '@objectstack/spec/ui';
* prop accepts, so the key stays checked once objectui#8347 removes
* `BaseSchema`'s index signature.
*/
-type ScopedStyleNode = BaseSchema & Pick;
-const scopedStyleNode = (schema: ScopedStyleNode): ScopedStyleNode => schema;
+type ScopedStyleNode = BaseSchema & Pick & { content?: string };
+/** The registered `IdentityProbe`'s node: every fixture below is one (objectui#11466). */
+type IdentityProbeNode = ScopedStyleNode & { type: 'identity-probe' };
+/** The registered `SelfUpdatingProbe`'s node. */
+type SelfUpdatingProbeNode = ScopedStyleNode & { type: 'self-updating-probe' };
+const scopedStyleNode = (schema: SelfUpdatingProbeNode): SelfUpdatingProbeNode => schema;
/** One capture per probe render: the exact `schema` object it was handed. */
interface Capture {
@@ -89,21 +106,23 @@ const distinctIdentities = (id: string): number =>
// Module-level fixtures: a stable `schema` prop identity is the precondition
// for the `evaluatedSchema` memo to hold, which is what makes this a test of
// the spread branch rather than of the memo above it.
-const PLAIN = { type: 'identity-probe', id: 'plain', content: 'plain' };
-const SCOPED = {
+const PLAIN: IdentityProbeNode = { type: 'identity-probe', id: 'plain', content: 'plain' };
+const SCOPED: IdentityProbeNode = {
type: 'identity-probe',
id: 'scoped',
content: 'scoped',
responsiveStyles: { large: { padding: '8px' } },
};
// The trap fixture: `base` is NOT one of the four sized keys, so this node
-// does not take the scope-class branch at all.
-const BASE_ONLY = {
+// does not take the scope-class branch at all. The spec's `responsiveStyles`
+// declares no `base` either, so the fixture is deliberately undeclared and
+// crosses through the one test helper for that (objectui#11466).
+const BASE_ONLY: IdentityProbeNode = undeclaredNode({
type: 'identity-probe',
id: 'baseonly',
content: 'base-only',
responsiveStyles: { base: { padding: '8px' } },
-};
+});
/**
* A real parent re-render: parent state changes, every child re-renders, and
@@ -294,13 +313,13 @@ describe('SchemaRenderer scoped-style schema identity (objectui#6270)', () => {
describe('delivers a NEW identity when something really changed (anti-staleness)', () => {
it('a changed `className` on a scoped node', () => {
- const before = {
+ const before: IdentityProbeNode = {
type: 'identity-probe',
id: 'scoped',
className: 'text-sm',
responsiveStyles: { large: { padding: '8px' } },
};
- const after = {
+ const after: IdentityProbeNode = {
type: 'identity-probe',
id: 'scoped',
className: 'text-lg',
@@ -318,13 +337,13 @@ describe('SchemaRenderer scoped-style schema identity (objectui#6270)', () => {
});
it('a changed value on a scoped node', () => {
- const before = {
+ const before: IdentityProbeNode = {
type: 'identity-probe',
id: 'scoped',
content: 'first',
responsiveStyles: { large: { padding: '8px' } },
};
- const after = {
+ const after: IdentityProbeNode = {
type: 'identity-probe',
id: 'scoped',
content: 'second',
@@ -342,12 +361,12 @@ describe('SchemaRenderer scoped-style schema identity (objectui#6270)', () => {
});
it('a changed responsiveStyles value re-compiles and re-identifies', () => {
- const before = {
+ const before: IdentityProbeNode = {
type: 'identity-probe',
id: 'scoped',
responsiveStyles: { large: { padding: '8px' } },
};
- const after = {
+ const after: IdentityProbeNode = {
type: 'identity-probe',
id: 'scoped',
responsiveStyles: { large: { padding: '24px' } },
@@ -366,7 +385,7 @@ describe('SchemaRenderer scoped-style schema identity (objectui#6270)', () => {
// The strongest anti-staleness pin: the `schema` PROP identity never
// changes here, so only a genuinely reactive evaluation can move the
// delivered identity. A memo that froze on the prop would go stale.
- const REACTIVE = {
+ const REACTIVE: IdentityProbeNode = {
type: 'identity-probe',
id: 'reactive',
content: '${page.tick}',
diff --git a/packages/react/src/__tests__/SchemaRenderer.unevaluatedExpressionDiagnostic.test.tsx b/packages/react/src/__tests__/SchemaRenderer.unevaluatedExpressionDiagnostic.test.tsx
index be59c65c95..5eb2bb3e21 100644
--- a/packages/react/src/__tests__/SchemaRenderer.unevaluatedExpressionDiagnostic.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.unevaluatedExpressionDiagnostic.test.tsx
@@ -34,6 +34,18 @@ import {
UNEVALUATED_EXPRESSION_PREFIX,
} from '../utils/unevaluatedExpression';
+/**
+ * This file's registered `TextKeyProbe` (namespace `test`), declared to
+ * `@object-ui/types` the way an application declares a type it registers
+ * (objectui#11466): a node slot and the `schema` prop take the declared node
+ * types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'test:probe-4795': TextKeyProbeNode;
+ }
+}
+
const DATA = { n: 99, total: 99, label: 'Widgets' };
/**
@@ -55,7 +67,7 @@ const TextKeyProbe = ({ schema }: any) => (
* the prop accepts, so its keys stay checked once objectui#8347 removes
* `BaseSchema`'s index signature.
*/
-type TextKeyProbeNode = BaseSchema & { value?: string; title?: string };
+type TextKeyProbeNode = BaseSchema & { type: 'test:probe-4795'; value?: string; title?: string };
const textKeyProbeNode = (schema: TextKeyProbeNode): TextKeyProbeNode => schema;
/** Reads only what it is spread, like a plain component. */
@@ -126,7 +138,7 @@ describe('SchemaRenderer — unevaluated `${…}` diagnostic (objectui#4795)', (
});
it('reports once per schema object, however many times it re-renders', () => {
- const schema = { type: 'test:probe-4795', value: '${data.n}' };
+ const schema: TextKeyProbeNode = { type: 'test:probe-4795', value: '${data.n}' };
const { rerender } = renderWithData(schema);
rerender(
diff --git a/packages/react/src/__tests__/SchemaRenderer.unknownTypeCaseSuggestion.test.tsx b/packages/react/src/__tests__/SchemaRenderer.unknownTypeCaseSuggestion.test.tsx
index 697f280263..8018a5b256 100644
--- a/packages/react/src/__tests__/SchemaRenderer.unknownTypeCaseSuggestion.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.unknownTypeCaseSuggestion.test.tsx
@@ -38,6 +38,10 @@ import { render } from '@testing-library/react';
import React from 'react';
import { ComponentRegistry } from '@object-ui/core';
import { SchemaRenderer } from '../SchemaRenderer';
+// Every type below is deliberately one no registration and no declaration names:
+// the suggestion is the point, so each crosses through the one test helper for
+// undeclared input (objectui#11466).
+import { undeclaredNode } from '@object-ui/test-support';
/** Marker text that appears ONLY if the component actually rendered. */
const RENDERED_MARKER = 'the-component-actually-rendered';
@@ -65,7 +69,7 @@ describe('objectui#5247 — case-only miss on the OBJUI-001 panel', () => {
// would make the two assertions below agree about nothing.
expect(ComponentRegistry.getKnownTypes()).toContain('page');
- const { container } = render();
+ const { container } = render();
const text = container.textContent ?? '';
// Half 1 — the ruled behaviour that must NOT change (this passes on a
@@ -80,7 +84,7 @@ describe('objectui#5247 — case-only miss on the OBJUI-001 panel', () => {
});
it('names the namespaced spelling too', () => {
- const { container } = render();
+ const { container } = render();
const text = container.textContent ?? '';
expect(text).not.toContain(RENDERED_MARKER);
@@ -92,7 +96,7 @@ describe('objectui#5247 — case-only miss on the OBJUI-001 panel', () => {
// The counter-probe for the "always suggests" failure mode. On its own it
// is a phantom — it passes on a revert — so it is pinned in the same run as
// the two cases above.
- const { container } = render();
+ const { container } = render();
const text = container.textContent ?? '';
expect(container.querySelector('[role="alert"]')).not.toBeNull();
@@ -103,7 +107,7 @@ describe('objectui#5247 — case-only miss on the OBJUI-001 panel', () => {
it('does not reach for an edit distance — a typo that is not a case typo suggests nothing', () => {
// `pge` is one deletion away from `page`. The ruling granted case, and only
// case; a fuzzy match here would be scope it did not give.
- const { container } = render();
+ const { container } = render();
const text = container.textContent ?? '';
expect(container.querySelector('[role="alert"]')).not.toBeNull();
@@ -117,7 +121,7 @@ describe('objectui#5247 — case-only miss on the OBJUI-001 panel', () => {
ComponentRegistry.unregister('page', 'test5247');
expect(ComponentRegistry.getKnownTypes()).not.toContain('page');
- const { container } = render();
+ const { container } = render();
const text = container.textContent ?? '';
expect(container.querySelector('[role="alert"]')).not.toBeNull();
diff --git a/packages/react/src/__tests__/SchemaRenderer.validation.test.tsx b/packages/react/src/__tests__/SchemaRenderer.validation.test.tsx
index 49bef1f89b..b96a83824a 100644
--- a/packages/react/src/__tests__/SchemaRenderer.validation.test.tsx
+++ b/packages/react/src/__tests__/SchemaRenderer.validation.test.tsx
@@ -12,7 +12,19 @@ import React from 'react';
import { ComponentRegistry } from '@object-ui/core';
import { SchemaRenderer } from '../SchemaRenderer';
import { SchemaRendererProvider } from '../context/SchemaRendererContext';
-import type { DataSource } from '@object-ui/types';
+import type { BaseSchema, DataSource } from '@object-ui/types';
+
+/**
+ * This file's registered hosts, declared to `@object-ui/types` the way an
+ * application declares a type it registers (objectui#11466): a node slot and
+ * the `schema` prop take the declared node types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'valid-host': BaseSchema;
+ 'host-wrap': BaseSchema;
+ }
+}
/**
* NOTE (objectui#7912): `SchemaRendererProvider.dataSource` — and the context
diff --git a/packages/react/src/__tests__/SchemaRendererProvider.smoke.test.tsx b/packages/react/src/__tests__/SchemaRendererProvider.smoke.test.tsx
index f9f16a17e3..b495334ac8 100644
--- a/packages/react/src/__tests__/SchemaRendererProvider.smoke.test.tsx
+++ b/packages/react/src/__tests__/SchemaRendererProvider.smoke.test.tsx
@@ -21,7 +21,19 @@ import React from 'react';
import { ComponentRegistry } from '@object-ui/core';
import { SchemaRenderer } from '../SchemaRenderer';
import { SchemaRendererProvider, useSchemaContext } from '../context/SchemaRendererContext';
-import type { DataSource } from '@object-ui/types';
+import type { BaseSchema, DataSource } from '@object-ui/types';
+import { undeclaredNode } from '@object-ui/test-support';
+
+/**
+ * This file's registered context consumer, declared to `@object-ui/types` the
+ * way an application declares a type it registers (objectui#11466): a node
+ * slot and the `schema` prop take the declared node types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'test-ctx-consumer': BaseSchema;
+ }
+}
/**
* NOTE (objectui#7912): `SchemaRendererProvider.dataSource` — and the context
@@ -170,10 +182,12 @@ describe('Plugin component types render inside provider', () => {
return;
}
- // Render via SchemaRenderer inside provider
+ // Render via SchemaRenderer inside provider. A bare `{ type }` on purpose:
+ // the node carries none of its type's required props, so it crosses
+ // through the one test helper for undeclared input (objectui#11466).
const { container } = render(
-
+
);
diff --git a/packages/react/src/__tests__/schema-input.bridgeFidelity.test.tsx b/packages/react/src/__tests__/schema-input.bridgeFidelity.test.tsx
index 3090679566..d88619aa3f 100644
--- a/packages/react/src/__tests__/schema-input.bridgeFidelity.test.tsx
+++ b/packages/react/src/__tests__/schema-input.bridgeFidelity.test.tsx
@@ -58,11 +58,22 @@
import { describe, it, expect } from 'vitest';
import { render } from '@testing-library/react';
import React from 'react';
-import type { BaseSchema, SchemaNode } from '@object-ui/types';
+import type { BaseSchema, DeclaredNode, SchemaNode } from '@object-ui/types';
import { ComponentRegistry } from '@object-ui/core';
import { SchemaRenderer } from '../SchemaRenderer';
import { toRenderableSchema } from '../schema-input';
+/**
+ * This file's registered probe (`PROBE_TYPE`), declared to `@object-ui/types`
+ * the way an application declares a type it registers (objectui#11466): a node
+ * slot and the `schema` prop take the declared node types only.
+ */
+declare module '@object-ui/types' {
+ interface CustomNodeRegistry {
+ 'test:schema-input-bridge-8908': BaseSchema;
+ }
+}
+
/* The `Assert< … >` alias below IS the assertion — it is deliberately never
* referenced, and a violation is a COMPILE error rather than a use site. */
type Equal = (() => T extends A ? 1 : 2) extends () => T extends B ? 1 : 2 ? true : false;
@@ -72,21 +83,21 @@ const PROBE_TYPE = 'test:schema-input-bridge-8908';
ComponentRegistry.register(PROBE_TYPE, () => probe-node);
/** One arm per member of the `SchemaNode` union, by name. */
-type MemberName = 'BaseSchema' | 'string' | 'number' | 'boolean' | 'null' | 'undefined';
+type MemberName = 'DeclaredNode' | 'string' | 'number' | 'boolean' | 'null' | 'undefined';
/**
* The completeness pin. `MemberName` above is a hand-written list; this ties it
* to the DECLARATION, so the list cannot go stale silently.
*/
type _MembersAreExactlyCovered = Assert<
- Equal
+ Equal
>;
/** `renders` is the text `SchemaRenderer` puts in the DOM for this value. */
type Case = { label: string; value: SchemaNode; renders: string };
const MEMBER_CASES: Record = {
- BaseSchema: [{ label: 'an object node', value: { type: PROBE_TYPE }, renders: 'probe-node' }],
+ DeclaredNode: [{ label: 'an object node', value: { type: PROBE_TYPE }, renders: 'probe-node' }],
string: [
{ label: "'' (empty)", value: '', renders: '' },
{ label: "'txt'", value: 'txt', renders: 'txt' },
@@ -186,7 +197,7 @@ describe('objectui#8908 — the two legs of the mapping, at the bridge itself',
});
it('returns every other member by identity — it converts nothing else', () => {
- const node: BaseSchema = { type: PROBE_TYPE };
+ const node: DeclaredNode = { type: PROBE_TYPE };
expect(toRenderableSchema(node)).toBe(node);
expect(toRenderableSchema('txt')).toBe('txt');
expect(toRenderableSchema('')).toBe('');
diff --git a/packages/react/src/schema-input.ts b/packages/react/src/schema-input.ts
index ae6480ab1c..a49343c08d 100644
--- a/packages/react/src/schema-input.ts
+++ b/packages/react/src/schema-input.ts
@@ -13,8 +13,8 @@ import type { SchemaRendererProps } from './SchemaRenderer.js';
* Narrow a loosely-typed metadata node onto {@link SchemaRendererProps.schema}.
*
* `@object-ui/types` declares `SchemaNode` as
- * `BaseSchema | string | number | boolean | null | undefined`, and a lot of
- * metadata plumbing (page regions, header-bar actions, detail tabs, view
+ * `DeclaredNode | string | number | boolean | null | undefined` (its object
+ * arm the declared-node union, objectui#11466), and a lot of metadata plumbing (page regions, header-bar actions, detail tabs, view
* configs) is typed with it. `SchemaRenderer` deliberately does NOT declare the
* `number` / `boolean` members — nobody should be invited to author them — so
* forwarding such a value needs one honest step in between.
diff --git a/packages/test-support/src/index.ts b/packages/test-support/src/index.ts
index 27b38c9041..98f909a593 100644
--- a/packages/test-support/src/index.ts
+++ b/packages/test-support/src/index.ts
@@ -109,3 +109,10 @@ export type { LocaleCall } from './locale-tripwire';
* one is declared in `exports`, so `tsc` (moduleResolution `bundler`) resolves it
* exactly as it resolves `.`.
*/
+
+/**
+ * The one crossing for deliberately undeclared node input in a test
+ * (objectui#11466): see the module's docblock for what may, and may not, go
+ * through it.
+ */
+export { undeclaredNode } from './undeclared-node';
diff --git a/packages/test-support/src/undeclared-node.ts b/packages/test-support/src/undeclared-node.ts
new file mode 100644
index 0000000000..80f4327175
--- /dev/null
+++ b/packages/test-support/src/undeclared-node.ts
@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+
+/**
+ * THE ONE CROSSING for deliberately undeclared node input in a test
+ * (objectui#11466).
+ *
+ * A node slot and `SchemaRenderer`'s `schema` prop take `DeclaredNode` from
+ * `@object-ui/types`: the union of the declared node types, with no
+ * `type: string` arm. Some tests pin what the RUNTIME does with input that no
+ * declaration covers, on purpose: an unknown or retired `type`, a spelling the
+ * contract refuses, a host value merged into a node. Such a test still has to
+ * hand that input over, and this is the one place it crosses. The return type
+ * is inferred from where the value goes, so a call reads as what it is:
+ *
+ * ```tsx
+ *
+ * ```
+ *
+ * ⛔ Not for a node of a type the test registers with `ComponentRegistry`:
+ * declare that type in `CustomNodeRegistry` (`@object-ui/types`), the way an
+ * application declares its own types. ⛔ Not for a fixture that is a declared
+ * node: annotate it with its declared type. ⛔ Never from source under `src/`
+ * outside a test; this package is never published.
+ *
+ * It takes no `@object-ui/types` import on purpose: that package depends on
+ * this one for its own tests, so the target type comes from the call site.
+ */
+export function undeclaredNode(node: object): Target {
+ return node as unknown as Target;
+}
diff --git a/packages/types/README.md b/packages/types/README.md
index cf76126f90..5069098926 100644
--- a/packages/types/README.md
+++ b/packages/types/README.md
@@ -269,7 +269,9 @@ default.
Foundation types that all components build upon:
- `BaseSchema` - The base interface for all components
-- `SchemaNode` - Union type for schema nodes (objects, strings, numbers, etc.)
+- `SchemaNode` - What a node slot holds: a `DeclaredNode`, or a primitive rendered as text
+- `DeclaredNode` - The discriminated union, keyed by `type`, of every declared node type; every node slot and `SchemaRenderer`'s `schema` prop take it, so an inline child is checked against its own type and an undeclared `type` is refused
+- `CustomNodeRegistry` - The interface an application augments (`declare module '@object-ui/types'`) to declare a node type it registers, which then joins `DeclaredNode`
- `AuthoringNode` - The spec-declared nodes with a typed `properties` bag (see "Authoring the spec's blocks in TypeScript")
- `ComponentMeta` - Metadata for component registration
- `ComponentInput` - Input field definitions for designers/editors
@@ -438,7 +440,7 @@ const sidebar: SidebarSchema = {
const main: ContainerSchema = {
type: 'container',
- children: [{ type: 'data-table', data: [] }]
+ children: [{ type: 'data-table', data: [], columns: [] }]
};
// An authored `flex` node takes its props, the child list included, in its
diff --git a/packages/types/src/__tests__/authoring-nodes-11364.test.ts b/packages/types/src/__tests__/authoring-nodes-11364.test.ts
index 4e007d3c21..a21b3ceb18 100644
--- a/packages/types/src/__tests__/authoring-nodes-11364.test.ts
+++ b/packages/types/src/__tests__/authoring-nodes-11364.test.ts
@@ -28,6 +28,13 @@
* keeps running after the removal lands. `@object-ui/react` pins the prop's
* union exactly (`SchemaRenderer.propsResolution.test.ts`, assertion 1), and
* this file substitutes only its `BaseSchema` member.
+ *
+ * ⚠️ Dated note, 2026-10-02 (objectui#11466): the prop's object member is now
+ * `DeclaredNode`, which has no `BaseSchema` arm, so `PostRemovalSchema` is no
+ * longer the prop with one member substituted. It is kept as the model this
+ * file's assertions were written against: every `AuthoringNode` still fits it,
+ * and its refusals still hold. The current prop and slot are pinned in
+ * `node-slot-union-11466.test.ts`.
*/
import { describe, expect, it } from 'vitest';
diff --git a/packages/types/src/__tests__/node-recursion-point-8344.test.ts b/packages/types/src/__tests__/node-recursion-point-8344.test.ts
index 36da1fdac1..be8ed4eedb 100644
--- a/packages/types/src/__tests__/node-recursion-point-8344.test.ts
+++ b/packages/types/src/__tests__/node-recursion-point-8344.test.ts
@@ -52,6 +52,7 @@
import { describe, it, expect } from 'vitest';
import { AnyComponentSchema, CardSchema, IconSchema, SchemaNodeSchema, safeValidateSchema } from '../zod/index.zod.js';
+import type { RetiredKanbanNodeSchema } from '../zod/complex.zod.js';
import type { SchemaNode } from '../base.js';
import type { z } from 'zod';
@@ -219,13 +220,59 @@ describe('the late-binding wiring, read by IDENTITY on the exported wrapper', ()
* which reads as drift where there is none. The guard answers the empty case first and
* leaves the projection to do exactly what it did before: NAME the arm when there is one.
*/
-type ArmsNotAssignableToSchemaNode =
- [Exclude< z.output< typeof AnyComponentSchema >, SchemaNode >] extends [never]
- ? never
- : Exclude< z.output< typeof AnyComponentSchema >, SchemaNode > extends { type: infer K } ? K : never;
+type ArmsNotAssignableToSchemaNode = Exclude< z.output< typeof AnyComponentSchema >, SchemaNode >;
+
+/**
+ * ⚠️ Dated note, 2026-10-02 (objectui#11466). The bound above was `never` while `SchemaNode`'s
+ * object arm was `BaseSchema`, whose `type: string` and index signature admitted every arm's
+ * output, drifted or not. objectui#11466 made that arm `DeclaredNode`, the union of the
+ * declared node types, so this reads the real exclusion set for the first time. Measured at
+ * that change, nine `type` literals and one arm typed `string`, each a DECLARATION matter
+ * between the two faces that the `BaseSchema` arm hid, ⛔ not a contract:
+ *
+ * - `app`: the zod arm is the app-level document (`AppComponentSchema`'s mirror), while a
+ * node slot's `app` is the page KIND `ComponentRegistry` renders (`DeclaredNode` leaves
+ * the app document out, objectui#11466). Two vocabularies on one token; `./registry.ts`
+ * names them at its `'page'` entry.
+ * - `record`, `home`, `utility`: the zod page-kind arm (objectui#11440) leaves `name` and
+ * `label` optional; the TypeScript `PageDocumentNode` is the spec's `PageSchema` input,
+ * which requires them.
+ * - `page`: `PageNodeSchema`'s `slots` differ between the faces.
+ * - `dashboard`: the widget slot's component arm differs between the faces.
+ * - `detail-section`, `app-schema-renderer`, `cloud:plan-status`: zod arms with no
+ * TypeScript declaration at all, so no node slot admits them.
+ * - the arm typed `string`: the retired `kanban` tombstone (`RetiredKanbanNodeSchema`),
+ * which parses nothing; its output type is not a node.
+ *
+ * Of these, only `detail-section`, `app-schema-renderer` and `cloud:plan-status` got a card of
+ * their own, objectui#11515 (the dated note below). `app`, `record`, `home`, `utility`, `page`
+ * and `dashboard` have none: they are recorded for objectui#8347's family, which reads them
+ * before the signature removal. The list is written out so this stays a
+ * ratchet in BOTH directions: a new arm drifting turns it red, and so does a listed one being
+ * reconciled, which then deletes its name here. ⛔ Do not add a name to make a red go away.
+ * The `[…] extends [never]` guard the paragraph above describes belonged to the
+ * non-distributive projection this replaced: `LiteralArmType` and `WideArm` distribute over
+ * the arms, so an empty exclusion set answers `never` by construction.
+ *
+ * ⚠️ Dated note, 2026-10-03 (objectui#11466, on merging objectui#11515). Reconciled, so their
+ * names left the list below: `detail-section`, `app-schema-renderer` and `cloud:plan-status`.
+ * objectui#11515 gave each its TypeScript twin and joined it to `AnySchema`, so a node slot
+ * admits them and their zod output is assignable. The bullet above that names them is kept as
+ * the reading at objectui#11466's first measurement.
+ */
+type LiteralArmType< Arm > = Arm extends { type: infer K } ? (string extends K ? never : K) : never;
+type WideArm< Arm > = Arm extends { type: infer K } ? (string extends K ? Arm : never) : never;
+type MeasuredArmDrift11466 =
+ | 'app'
+ | 'record'
+ | 'home'
+ | 'utility'
+ | 'page'
+ | 'dashboard';
export type NodeRecursionPointDeclarationDrift = [
- Expect< Equal< ArmsNotAssignableToSchemaNode, never > >,
+ Expect< Equal< LiteralArmType< ArmsNotAssignableToSchemaNode >, MeasuredArmDrift11466 > >,
+ Expect< Equal< WideArm< ArmsNotAssignableToSchemaNode >, z.output< typeof RetiredKanbanNodeSchema > > >,
];
diff --git a/packages/types/src/__tests__/node-slot-union-11466.test.ts b/packages/types/src/__tests__/node-slot-union-11466.test.ts
new file mode 100644
index 0000000000..adafee6843
--- /dev/null
+++ b/packages/types/src/__tests__/node-slot-union-11466.test.ts
@@ -0,0 +1,122 @@
+/**
+ * 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.
+ */
+
+/**
+ * objectui#11466: a node slot and `SchemaRenderer`'s `schema` prop take
+ * `DeclaredNode`, the discriminated union of the declared node types, pinned.
+ *
+ * Most assertions here are TYPE-level: the `Assert` aliases and the
+ * `@ts-expect-error` directives are judged by this package's `type-check` (its
+ * `tsc -p tsconfig.test.json` leg), never by vitest, which strips types. A
+ * directive that stops being needed is TS2578, so each one holds in both
+ * directions.
+ *
+ * ## The compile-fail pin, and why it does not wait for objectui#8347
+ *
+ * Until objectui#8347 removes `BaseSchema`'s index signature, a misspelled key on
+ * a node type that extends `BaseSchema` still compiles: the signature absorbs it
+ * on the type's own arm. What this card changes is the SLOT: it discriminates on
+ * `type`, so an inline child is judged against its own type's arm wherever it is
+ * nested. `ClosedProbeNode` below is a node type declared WITHOUT an index
+ * signature, the shape every arm has once the removal lands, registered through
+ * `CustomNodeRegistry`. Its misspelling is refused at a nested slot today, so the
+ * pin runs in every type-check now and keeps running after the removal. The
+ * spec-derived `AuthoringNode`s carry no signature either and are pinned the
+ * same way.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { AppComponentSchema } from '../app.js';
+import type { AuthoringNode, PageDocumentNode } from '../authoring-nodes.js';
+import type { BaseSchema, CustomNodeRegistry, DeclaredNode, SchemaNode } from '../base.js';
+import type { ListSchema } from '../data-display.js';
+import type { AnySchema, SchemaByType } from '../index.js';
+
+type Assert = T;
+type Equal = (() => T extends A ? 1 : 2) extends () => T extends B ? 1 : 2 ? true : false;
+
+/** A node type with no index signature: the shape every arm takes after objectui#8347. */
+interface ClosedProbeNode {
+ type: 'test:closed-probe-11466';
+ id?: string;
+ label?: string;
+ probeOnly?: string;
+}
+
+/** A LOOSE entry: `BaseSchema` itself, to pin that an entry joins under its key only. */
+type LooseProbeNode = BaseSchema;
+
+declare module '../base.js' {
+ interface CustomNodeRegistry {
+ 'test:closed-probe-11466': ClosedProbeNode;
+ 'test:loose-probe-11466': LooseProbeNode;
+ }
+}
+
+/** What `SchemaRendererProps['schema']` is (`@object-ui/react` pins the prop itself). */
+type PropSchema = DeclaredNode | string | null | undefined;
+
+/** The members a `type === K` check narrows a `DeclaredNode` to. */
+type NarrowOn = T extends { type: infer D } ? (K extends D ? T : never) : never;
+
+// 1. `SchemaNode` is a declared node or a primitive rendered as content.
+type _SchemaNodeShape = Assert>;
+
+// 2. No `type: string` arm: `BaseSchema` is not a member, and no member's `type` is `string`.
+type _BaseSchemaIsNotAnArm = Assert>;
+type WideTyped = U extends { type: infer K } ? (string extends K ? U : never) : never;
+type _NoWideArm = Assert, never>>;
+
+// 3. Every component schema `AnySchema` declares is a member, except its `BaseSchema` arm and
+// the app-level document (`AppComponentSchema`, read structurally and never dispatched).
+type _AnySchemaArmsAreMembers = Assert extends DeclaredNode ? true : false>;
+type _AppDocumentIsNotANode = Assert, never>>;
+// …and every spec-declared `AuthoringNode`.
+type _AuthoringNodesAreMembers = Assert;
+
+// 4. One arm per shared token (H4 of the dispatch). `app` is the page KIND the registry
+// renders; `list` is the `list` node, because a `list` page never reaches `SchemaRenderer`.
+// `SchemaByType` reads `AnySchema` and does not move.
+type _AppNarrowsToThePageKind = Assert, PageDocumentNode>>;
+type _ListNarrowsToTheListNode = Assert, ListSchema>>;
+type _SchemaByTypeApp = Assert, AppComponentSchema>>;
+type _SchemaByTypeList = Assert, ListSchema>>;
+
+// 5. A registry entry joins under its KEY: the arm is the entry intersected with
+// `{ type: KEY }`, so even a loose `BaseSchema` entry adds no `type: string` arm.
+type _LooseEntryJoinsUnderItsKey = Assert<
+ Equal, CustomNodeRegistry['test:loose-probe-11466'] & { type: 'test:loose-probe-11466' }>
+>;
+
+describe('objectui#11466: a node slot takes the declared-node union', () => {
+ it('a nested child is judged against its own type: a misspelled key is refused, the declared spelling compiles', () => {
+ const spelled: SchemaNode = { type: 'card', children: [{ type: 'test:closed-probe-11466', label: 'x' }] };
+ // @ts-expect-error `lable` is not a member of `ClosedProbeNode`, and the slot discriminates on `type`
+ const misspelled: SchemaNode = { type: 'card', children: [{ type: 'test:closed-probe-11466', lable: 'x' }] };
+ // @ts-expect-error the same at a deeper slot
+ const deeper: SchemaNode = { type: 'card', children: [{ type: 'grid', children: [{ type: 'test:closed-probe-11466', lable: 'x' }] }] };
+ // @ts-expect-error a spec-derived node is closed too: `contnt` is not in `element:text`'s bag
+ const bag: SchemaNode = { type: 'card', children: [{ type: 'element:text', properties: { contnt: 'x' } }] };
+ expect([spelled, misspelled, deeper, bag]).toHaveLength(4);
+ });
+
+ it('an undeclared `type` is refused at a slot and at the prop', () => {
+ // @ts-expect-error `txt` names no declared node type and no registry entry
+ const nested: SchemaNode = { type: 'card', children: [{ type: 'txt' }] };
+ // @ts-expect-error the same at `SchemaRenderer`'s prop
+ const atProp: PropSchema = { type: 'txt' };
+ const registered: PropSchema = { type: 'test:closed-probe-11466', label: 'x' };
+ expect([nested, atProp, registered]).toHaveLength(3);
+ });
+
+ it("a registered type's key does not escape onto a declared type", () => {
+ // @ts-expect-error `probeOnly` is `ClosedProbeNode`'s, not `element:text`'s
+ const escaped: SchemaNode = { type: 'card', children: [{ type: 'element:text', probeOnly: 'x', properties: { content: 'y' } }] };
+ expect([escaped]).toHaveLength(1);
+ });
+});
diff --git a/packages/types/src/__tests__/overlay-node-slot-doc-types-7082.test.ts b/packages/types/src/__tests__/overlay-node-slot-doc-types-7082.test.ts
index 3415d8d5b4..77c22c2009 100644
--- a/packages/types/src/__tests__/overlay-node-slot-doc-types-7082.test.ts
+++ b/packages/types/src/__tests__/overlay-node-slot-doc-types-7082.test.ts
@@ -352,9 +352,10 @@ describe('six overlay/feedback pages name node slots at the declared type (objec
// Control: the file is still there and still readable, so the absence above
// is a reading about its CONTENT and not about a failed read.
expect(blocks).toContain('@module blocks');
- // And `SchemaNode` is the slot type these keys actually carry.
+ // And `SchemaNode` is the slot type these keys actually carry. Its object arm
+ // is `DeclaredNode`, the declared-node union, since objectui#11466.
expect(read('packages/types/src/base.ts')).toContain(
- 'export type SchemaNode = BaseSchema | string | number | boolean | null | undefined;',
+ 'export type SchemaNode = DeclaredNode | string | number | boolean | null | undefined;',
);
});
});
diff --git a/packages/types/src/__tests__/overlay-trigger-union-7081.test.ts b/packages/types/src/__tests__/overlay-trigger-union-7081.test.ts
index ce4bfeda8e..4ba16fdde7 100644
--- a/packages/types/src/__tests__/overlay-trigger-union-7081.test.ts
+++ b/packages/types/src/__tests__/overlay-trigger-union-7081.test.ts
@@ -71,7 +71,7 @@ import { fileURLToPath } from 'node:url';
// @ts-expect-error -- plain-JS shared helper, intentionally untyped (`allowJs: false`)
import { stripComments as strip } from '../../../../scripts/js-comment-mask.mjs';
-import type { BaseSchema, SchemaNode } from '../base';
+import type { DeclaredNode, SchemaNode } from '../base';
import type { CollapsibleSchema } from '../disclosure';
import type { ButtonSchema } from '../form';
import type { TextSchema } from '../layout';
@@ -153,10 +153,12 @@ export type _DropdownMenuRequired = Expect>;
export type _ContextMenuTrigger = Expect>;
-// Counter-control: `AdmitsArray` can say `false`, and `SchemaNode` itself did
-// not move -- the widening is per member, not on the node type.
+// Counter-control: `AdmitsArray` can say `false`, and the widening is per member,
+// not on the node type: `SchemaNode` is one node or a primitive, never a list.
+// (Its object arm became `DeclaredNode`, the declared-node union, under
+// objectui#11466; that change is not this widening.)
export type _SchemaNodeUntouched = Expect<
- Equal
+ Equal
>;
interface SingularSlot {
trigger: SchemaNode;
@@ -184,7 +186,8 @@ export const singularStaysSingular: SingularSlot = {
// and so does `shippedCollapsible` below (TS2322).
//
// The redundant `string |` half went with the widening. `_SchemaNodeUntouched`
-// above pins `SchemaNode` as `BaseSchema | string | ...`, and the leg below
+// above pins `SchemaNode` as `DeclaredNode | string | ...` (its object arm was
+// `BaseSchema` until objectui#11466), and the leg below
// spells the consequence out: `string | SchemaNode` denoted `SchemaNode` all
// along, so dropping it moved nothing.
export type _CollapsibleTrigger = Expect>;
diff --git a/packages/types/src/__tests__/page-body-arity-8310.test.ts b/packages/types/src/__tests__/page-body-arity-8310.test.ts
index 1b9e13a445..9e0f045175 100644
--- a/packages/types/src/__tests__/page-body-arity-8310.test.ts
+++ b/packages/types/src/__tests__/page-body-arity-8310.test.ts
@@ -282,14 +282,16 @@ describe('`body` is refused by name on the page node (objectui#6771)', () => {
/* -------------------------------------------------------------------------- */
/**
- * The `const schema = {` object literal inside the README's "Basic Usage"
- * fence, returned as source text. Scanned with brace-depth tracking rather
- * than a regex so a nested `children[]` cannot end the span early.
+ * The `const schema: DeclaredNode = {` object literal inside the README's
+ * "Basic Usage" fence, returned as source text. Scanned with brace-depth
+ * tracking rather than a regex so a nested `children[]` cannot end the span
+ * early. The annotation is part of the anchor since objectui#11466, which
+ * typed the example as the node the `schema` prop takes.
*/
function basicUsageSchemaLiteral(): string {
const heading = README.indexOf('#### Basic Usage');
expect(heading).toBeGreaterThan(-1);
- const start = README.indexOf('const schema = {', heading);
+ const start = README.indexOf('const schema: DeclaredNode = {', heading);
expect(start).toBeGreaterThan(-1);
let depth = 0;
diff --git a/packages/types/src/__tests__/zod-mirror-parity.test.ts b/packages/types/src/__tests__/zod-mirror-parity.test.ts
index 7a3fc6aa23..183e457b47 100644
--- a/packages/types/src/__tests__/zod-mirror-parity.test.ts
+++ b/packages/types/src/__tests__/zod-mirror-parity.test.ts
@@ -635,8 +635,13 @@
* spelled "six" rots exactly as fast as one spelled `6`, it is just harder to
* point a regex at. ⛔ Do not spell a live figure out again, and ⛔ do not
* restate one without checking that the pin's spelling still reaches it.
- * - **4 entries** in `WiderThanDeclared`, **4 keys** across them, and **4 arms**
- * under those keys — split **3** SCHEMA-NODE, **1** CONCRETE, **0** MIXED, **0** unions.
+ * - **6 entries** in `WiderThanDeclared`, **6 keys** across them, and **8 arms**
+ * under those keys — split **3** SCHEMA-NODE, **3** CONCRETE, **0** MIXED, **2** unions.
+ * It read 4 / 4 / 4 — 3 / 1 / 0 / 0 — until objectui#11466 typed `SchemaNode`'s object
+ * arm as the declared-node union: `complex.zod.ts#DashboardWidgetSchema`'s `component`
+ * (two CONCRETE arms, the mirror's `BaseSchema` fallback admitting any `type`) and,
+ * through the element, `complex.zod.ts#DashboardComponentSchema`'s `widgets` (two
+ * CONCRETE arms) ENTERED together.
* It read 3 / 3 / 3 — 2 / 1 / 0 / 0 — until objectui#11515 registered
* `app.zod.ts#AppSchemaRendererNodeSchema`, whose `schema` member IS
* `app.zod.ts#AppComponentSchema`: that pair's own SCHEMA-NODE reading is measured
@@ -3962,6 +3967,25 @@ interface WiderThanDeclared {
* not a separate finding; it leaves when that entry does.
*/
'app.zod.ts#AppSchemaRendererNodeSchema': 'schema';
+ /**
+ * CONCRETE `widgets` (objectui#11466), RE-ENTERED after the history in the comment
+ * below, and inherited through the element: the widget arm's `component` slot, the
+ * `complex.zod.ts#DashboardWidgetSchema` entry next to it. Both arms of the element
+ * state a shape an author writes, so both verdicts are CONCRETE.
+ */
+ 'complex.zod.ts#DashboardComponentSchema': 'widgets';
+ /**
+ * CONCRETE `component` (objectui#11466). A widget's `component` slot is
+ * `DashboardWidgetSlotComponentSchema | SchemaNode` on the declaration, and
+ * `SchemaNode`'s object arm became `DeclaredNode`, the union of the declared node types
+ * with no `type: string` arm. The mirror's slot still ends in the `BaseSchema` fallback
+ * (`z.union([DashboardWidgetSlotComponentSchema, BaseSchema])`), which admits any `type`
+ * string, so it accepts a `component` node the declaration now refuses. That fallback is
+ * objectui#8347's to retire with the index signature, ⛔ not this ledger's: narrowing it
+ * here is the mirror change that card reserves. When it goes, this entry and the
+ * `widgets` one above measure clean and are deleted (clause 4 above).
+ */
+ 'complex.zod.ts#DashboardWidgetSchema': 'component';
// `complex.zod.ts#ChatbotSchema` recorded `body` here (CONCRETE, and DISJOINT rather
// than strictly wider — the pair carried a `KnownDrift` entry for the same key, one of
// the measured cases where each face refuses something the other admits: the mirror
@@ -4192,6 +4216,13 @@ const WIDER_ARMS: Readonly< Record< string, readonly WiderArmClass[] > > = {
// objectui#11515: the one arm is the app document, read wider through the
// annotation the `areas` row above reaches (the ledger entry says so).
'app.zod.ts#AppSchemaRendererNodeSchema::schema': ['SCHEMA-NODE'],
+ // objectui#11466: the element's two arms, the component node and the widget, each a
+ // shape an author writes. The widget arm is the one that reads wider, through its
+ // `component` slot's `BaseSchema` fallback (the next row).
+ 'complex.zod.ts#DashboardComponentSchema::widgets': ['CONCRETE', 'CONCRETE'],
+ // objectui#11466: the slot's two arms, the widget slot's component arm and the
+ // `BaseSchema` fallback, which admits any `type` string.
+ 'complex.zod.ts#DashboardWidgetSchema::component': ['CONCRETE', 'CONCRETE'],
'layout.zod.ts#PageNodeSchema::slots': ['SCHEMA-NODE'],
'objectql.zod.ts#ObjectGridSchema::objectName': ['CONCRETE'],
};
diff --git a/packages/types/src/authoring-nodes.ts b/packages/types/src/authoring-nodes.ts
index ce6c0110ff..1fc6961ad5 100644
--- a/packages/types/src/authoring-nodes.ts
+++ b/packages/types/src/authoring-nodes.ts
@@ -67,23 +67,28 @@
* - {@link PageDocumentNode}: the spec's `PageSchema` input. `PageView`
* hands a stored page to `SchemaRenderer` with its page KIND written into
* `type` (objectui#9642), so `type` is required here, while the spec
- * defaults it. `PageNodeSchema` is the separate `type: 'page'` node, and
- * stays as it is.
+ * defaults it; every kind but the interface-mode `list`, which never
+ * reaches `SchemaRenderer`. `PageNodeSchema` is the separate
+ * `type: 'page'` node, and stays as it is.
*
- * ## What these types do, and what they do NOT do
+ * ## What these types do
*
- * `SchemaRendererProps.schema` (`@object-ui/react`) accepts {@link AuthoringNode}
- * beside `BaseSchema`. In that union, TypeScript discriminates on the literal
- * `type`, so a node of one of these types has its own keys judged: a misspelled
- * key inside an `element:text` bag, or a bag on a node type that declares none,
- * is refused once objectui#8347 lands (`authoring-nodes-11364.test.ts` pins it).
- * The union does not make a member's REQUIRED keys required, because
- * `BaseSchema` (`type: string`) still accepts the same node structurally.
- * Requiredness is the validator's to judge.
+ * {@link AuthoringNode} is one of the three parts of `DeclaredNode`
+ * (`./base.ts`, objectui#11466), beside the component schemas this package
+ * declares and the types an application declares in `CustomNodeRegistry`.
+ * `DeclaredNode` is the object arm of `SchemaNode`, so every node slot takes
+ * these types, and it is what `SchemaRendererProps.schema` (`@object-ui/react`)
+ * takes beside a string. The union has no `type: string` arm, so TypeScript
+ * discriminates on the literal `type`: a node of one of these types has its own
+ * keys judged wherever it is written, nested in a slot or at the prop, and its
+ * required keys are required. A misspelled key inside an `element:text` bag, or
+ * a bag on a node type that declares none, is refused once objectui#8347
+ * removes `BaseSchema`'s index signature (`authoring-nodes-11364.test.ts` and
+ * `node-slot-union-11466.test.ts` pin it).
*
- * ⛔ `SchemaNode` is not widened here. Every reader of a `SchemaNode` that
- * reads an undeclared key compiles today only through `BaseSchema`'s index
- * signature, and a closed member in the union turns that read into TS2339.
+ * Until that removal, the component-schema members that extend `BaseSchema`
+ * still carry its index signature, so a misspelled key on one of THEM still
+ * compiles. These members carry none.
*/
import type { z } from 'zod';
@@ -240,8 +245,19 @@ export type EmbeddableFormBlockNode = ObjectQLPublicBlockNodeOf<'embeddable-form
* ({@link ClosedBag}), because `@objectstack/spec` has no `flex` row
* (objectui#11276). The TypeScript `FlexSchema` (`./layout.ts`) stays the node
* as the `flex` renderer reads it after the hoist.
+ *
+ * ⚠️ An interface, not a type alias, for one reason (objectui#11466). The bag
+ * holds node slots, so `FlexBlockSchema`'s inferred type names
+ * `SchemaNodeSchema`, whose type names `SchemaNode`; and `SchemaNode` names
+ * this type back, through `DeclaredNode` and {@link AuthoringNode}. A type
+ * alias is resolved eagerly when `SchemaNode` is, so that loop is a circular
+ * reference (TS2456 on this type, `AuthoringNode`, `DeclaredNode` and
+ * `SchemaNode`). An interface's members are resolved only when they are read,
+ * so the loop is never walked while `SchemaNode` is being resolved. The
+ * interface declares nothing of its own: every member is the arm's, as above.
*/
-export type FlexBlockNode = ClosedArmInput;
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- an interface on purpose, to break the SchemaNode cycle its docblock names; it declares no member of its own.
+export interface FlexBlockNode extends ClosedArmInput {}
/**
* `element:text_input`: `ComponentPropsMap['element:text_input']`
@@ -271,12 +287,24 @@ type SpecPageInput = z.input;
* input, whose `type` is the page kind (`PageTypeSchema`) and whose `kind` is
* the override mode. `type` is required, because it is the discriminator the
* registry dispatches on.
+ *
+ * ⛔ Every page kind but `list` (objectui#11466). A `list` page is ADR-0047
+ * interface mode: `PageView` (`@object-ui/app-shell`) renders it through
+ * `InterfaceListPage`, never through `SchemaRenderer`, and `ComponentRegistry`'s
+ * `list` key is the `list` node's renderer (`ListSchema`, `./data-display.ts`). A page
+ * document under `type: 'list'` handed to `SchemaRenderer` would be drawn by
+ * that renderer, so this type does not admit one. That also leaves `list` one
+ * arm in `DeclaredNode` (`./base.ts`), where the page kind and the node type
+ * would otherwise share the discriminant and let each other's keys through.
+ * `page-kind-node-type-channel-9642` in `@object-ui/components` re-derives
+ * which kinds reach the registry.
*/
-export type PageDocumentNode = SpecPageInput & { type: NonNullable };
+export type PageDocumentNode = SpecPageInput & { type: Exclude, 'list'> };
/**
- * Every node this module types, so the one place that accepts them all
- * (`SchemaRendererProps.schema`) names one type.
+ * Every node this module types, named as one type for `DeclaredNode`
+ * (`./base.ts`), the union every node slot and `SchemaRendererProps.schema`
+ * take (objectui#11466).
*/
export type AuthoringNode =
| PublicBlockNode
diff --git a/packages/types/src/base.ts b/packages/types/src/base.ts
index ce2bc9e31d..c0d9ad447f 100644
--- a/packages/types/src/base.ts
+++ b/packages/types/src/base.ts
@@ -17,7 +17,9 @@
*/
import type { I18nLabel } from '@objectstack/spec/ui';
+import type { AuthoringNode } from './authoring-nodes.js';
import type { ExpressionWire } from './expression.js';
+import type { AnySchema } from './index.js';
/**
* A KEYED i18n label — a reference INTO a translation bundle (objectui#4581).
@@ -599,9 +601,100 @@ export interface BaseSchema {
}
/**
- * A schema node can be a full schema object or a primitive value.
- * This union type supports both structured components and simple content.
- *
+ * The registry an application augments to declare its OWN node types: the
+ * types it registers with `ComponentRegistry` that this package does not
+ * declare (objectui#11466).
+ *
+ * Each entry's key is the node's `type` string and its value is the node's
+ * schema type. An entry joins {@link DeclaredNode}, so a node of that type is
+ * authorable in every node slot and at `SchemaRenderer`'s `schema` prop:
+ *
+ * ```typescript
+ * interface MyWidgetSchema extends BaseSchema {
+ * type: 'my-widget';
+ * customProp?: string;
+ * }
+ *
+ * declare module '@object-ui/types' {
+ * interface CustomNodeRegistry {
+ * 'my-widget': MyWidgetSchema;
+ * }
+ * }
+ * ```
+ *
+ * ## Why a custom type must be declared here
+ *
+ * A node slot takes the union of the declared node types, discriminated by
+ * the literal `type`, so each inline child is checked against its own type's
+ * keys and a misspelled key is refused where it is written. An undeclared
+ * `type` string has no arm, so it is refused too, the same way the strict zod
+ * face refuses an unregistered type. The entry is what declares it.
+ *
+ * ⛔ An entry is joined under its KEY: the arm is the entry's type intersected
+ * with `{ type: KEY }`. So an entry cannot add a `type: string` arm, which
+ * would make every declared type's literal a candidate for that arm and let
+ * the arm's keys through on every node. An entry whose own `type` is a
+ * different literal than its key intersects to `never` and adds nothing.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- empty by design: applications fill it by declaration merging.
+export interface CustomNodeRegistry {}
+
+/** One arm per {@link CustomNodeRegistry} entry, discriminated by the entry's key. */
+type RegisteredCustomNode = {
+ [K in keyof CustomNodeRegistry & string]: CustomNodeRegistry[K] & { type: K };
+}[keyof CustomNodeRegistry & string];
+
+/**
+ * The arms of a union whose `type` is a literal (or a union of literals). An
+ * arm whose `type` is `string` matches every discriminant, so it is dropped:
+ * from `AnySchema`, that is `BaseSchema` alone, which
+ * `__tests__/node-slot-union-11466.test.ts` pins.
+ */
+type LiteralTypedArm = T extends { type: infer K } ? (string extends K ? never : T) : never;
+
+/**
+ * A node of a declared type: the object arm of {@link SchemaNode}, and what
+ * `SchemaRenderer`'s `schema` prop takes beside a string (objectui#11466).
+ *
+ * It is the discriminated union, keyed by the literal `type`, of
+ *
+ * - every component schema this package declares (`AnySchema` without its
+ * `BaseSchema` arm, whose `type` is `string`, and without the app-level
+ * document, below);
+ * - every spec-declared node `AuthoringNode` types by reference;
+ * - every custom type an application declares in {@link CustomNodeRegistry}.
+ *
+ * Inside the union TypeScript discriminates on `type`, so an inline child
+ * literal is checked against its own type's keys and value types, wherever
+ * it is nested. ⛔ No arm is open: there is no index signature and no
+ * `type: string` arm here. A node built at runtime whose `type` is not known
+ * to the compiler is not a `DeclaredNode`; narrow it to one, or declare its
+ * type in {@link CustomNodeRegistry}.
+ *
+ * ⛔ The app-level document (`./app.ts`, the `app.json` shape: navigation,
+ * areas, the `AnySchema` member whose `type` is `'app'`) is not a node:
+ * `AppSchemaRenderer` (`@object-ui/layout`) reads it structurally and
+ * `ComponentRegistry` never dispatches it. It is left out by that `type`
+ * (`Exclude`), which removes it alone, because
+ * no other `AnySchema` member's `type` is `'app'` (the `'app'` pin in
+ * `__tests__/node-slot-union-11466.test.ts` holds that). The registry's
+ * `app` key serves the page KIND `app`, so as a
+ * node `type: 'app'` is a stored page document, `AuthoringNode`'s
+ * `PageDocumentNode`. Kept out, `app` is one arm here, not two that would let
+ * each other's keys through (`./registry.ts` names the two vocabularies at its
+ * `'page'` entry). The node that renders an app through the registry is
+ * `app-schema-renderer`.
+ */
+export type DeclaredNode =
+ | LiteralTypedArm>
+ | AuthoringNode
+ | RegisteredCustomNode;
+
+/**
+ * A schema node: a node of a declared type, or a primitive rendered as
+ * content. Every node slot (`children`, `trigger`, `content`, a view's
+ * `schema`) takes it, so an inline child is checked against its own type.
+ *
* @example
* ```typescript
* const nodes: SchemaNode[] = [
@@ -611,7 +704,7 @@ export interface BaseSchema {
* ]
* ```
*/
-export type SchemaNode = BaseSchema | string | number | boolean | null | undefined;
+export type SchemaNode = DeclaredNode | string | number | boolean | null | undefined;
/**
* Component renderer function type.
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 77c6a4e8a5..69e06e4f1e 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -109,6 +109,11 @@ export type {
// half of what stops them being mixed up (#4581).
KeyedI18nLabel,
SchemaNode,
+ // The object arm of `SchemaNode`: the discriminated union of the declared
+ // node types, plus the custom types an application declares in
+ // `CustomNodeRegistry` by declaration merging (objectui#11466).
+ DeclaredNode,
+ CustomNodeRegistry,
ComponentRendererProps,
ComponentInput,
// The input the FRAMEWORK injects (`binding: 'object'`, `9e37d9b39`) —
diff --git a/packages/types/src/zod/base.zod.ts b/packages/types/src/zod/base.zod.ts
index fe6c4371c2..899648142d 100644
--- a/packages/types/src/zod/base.zod.ts
+++ b/packages/types/src/zod/base.zod.ts
@@ -191,6 +191,24 @@ export function defineNodeComponentUnion(union: T): T {
return union;
}
+/**
+ * The type of {@link SchemaNodeSchema}, named by a type alias rather than spelled in
+ * the annotation (objectui#11466). `SchemaNode` (`../base.ts`) is the declared-node
+ * union, and resolving it walks back into this module's consts: through
+ * `AuthoringNode`, whose public-block members are the `z.input` of arms built on
+ * `BaseSchema` below. Type arguments spelled in a const's annotation are resolved
+ * eagerly, so they would reference themselves (TS4109); inside a type alias they are
+ * resolved when they are read. Typing only: the schema object does not change.
+ */
+type SchemaNodeZodType = z.ZodType;
+
+/**
+ * The type of {@link NodeSlotSchema}, the single-or-list node slot, written out for
+ * the same reason as {@link SchemaNodeZodType}: inferring it from the `z.union` call
+ * would resolve `SchemaNode` while `SchemaNode` is being resolved.
+ */
+type NodeSlotZodType = z.ZodOptional]>>;
+
/**
* Schema Node — what a child slot holds: a COMPONENT document, or a primitive.
*
@@ -266,9 +284,14 @@ export function defineNodeComponentUnion(union: T): T {
* what this schema accepts at runtime.
*
* ⛔ `SchemaNode` in `../base.ts` did NOT move under #8344 either: the TS face still
- * says `BaseSchema | primitive`, and `BaseSchema` carries an index signature, so the
- * runtime accept set is now NARROWER than the declaration rather than wider. The
- * declaration repair is its own worklist and ⛔ not this const's to make.
+ * said `BaseSchema | primitive`, and `BaseSchema` carries an index signature, so the
+ * runtime accept set was NARROWER than the declaration rather than wider. The
+ * declaration repair was its own worklist and ⛔ not this const's to make.
+ * ⚠️ Dated note, 2026-10-02 (objectui#11466): that repair has landed. `SchemaNode`'s
+ * object arm is `DeclaredNode`, the union of the declared node types with no
+ * `type: string` arm, so an undeclared `type` is refused on the TS face too. The
+ * members that extend `BaseSchema` keep its index signature until objectui#8347
+ * removes it. The two sentences above are kept as the reading at #8344.
*
* ⭐ What #7760 bought: `__tests__/zod-mirror-parity.test.ts` can now compare the
* `z.union([SchemaNodeSchema, z.array(SchemaNodeSchema)])` single-or-list slots that
@@ -285,7 +308,7 @@ export function defineNodeComponentUnion(union: T): T {
* a declaration or narrowing a mirror to make the annotation fit: either is a
* contract change wearing a type-annotation's clothes, and both are ruled elsewhere.
*/
-export const SchemaNodeSchema: z.ZodType = z.lazy(() => {
+export const SchemaNodeSchema: SchemaNodeZodType = z.lazy(() => {
// `z.lazy` memoises this getter, and that is FINE — because what it returns is the
// one live union, whose option slot 0 IS the recursion point and is written by
// {@link defineNodeComponentUnion}. ⛔ Do not move the union's CONSTRUCTION in here:
@@ -294,6 +317,17 @@ export const SchemaNodeSchema: z.ZodType = z.lazy(() =>
return nodeUnion;
});
+/**
+ * `BaseSchemaCore`'s `children` slot: one node or a list of nodes. It is the same
+ * schema it always was, `z.union([SchemaNodeSchema, z.array(SchemaNodeSchema)])`,
+ * held in a const only so its type can be written out ({@link NodeSlotZodType},
+ * objectui#11466). Typing only: the accept set does not change.
+ */
+const NodeSlotSchema: NodeSlotZodType = z
+ .union([SchemaNodeSchema, z.array(SchemaNodeSchema)])
+ .optional()
+ .describe('Child components (React-style)');
+
/**
* Base Schema - Core validation schema that all components extend
*
@@ -388,7 +422,7 @@ const BaseSchemaCore = z.object({
/**
* Child components or content — the one child-list spelling (objectui#6771)
*/
- children: z.union([SchemaNodeSchema, z.array(SchemaNodeSchema)]).optional().describe('Child components (React-style)'),
+ children: NodeSlotSchema,
/**
* Visibility control — a boolean, or the predicate STRING the renderer
@@ -523,7 +557,7 @@ const nodeUnionOptions: [z.ZodType, ...z.ZodType[]] = [
z.undefined(),
];
-const nodeUnion = z.union(nodeUnionOptions) as unknown as z.ZodType;
+const nodeUnion = z.union(nodeUnionOptions) as unknown as SchemaNodeZodType;
/**
* A spec schema's fields, minus the keys objectui declares locally, as an