@cratis/scene.components 3.3.1 → 3.5.0

package/data/for_SceneDataTable/when_forwarding_query_arguments.tsx

@@ -0,0 +1,104 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { act, cleanup, render, screen } from '@testing-library/react';
+import { vi } from 'vitest';
+import { externalComponent } from '../../given';
+
+let InvoicesForProject: typeof import('../../bindings/for_requireArcProxy/NativeProxies').Snapshot;
+let AnotherQuery: typeof InvoicesForProject;
+
+// Load a fresh adapter so its lazy component cannot leak the peer double into other specs.
+describe('when forwarding query arguments', () => {
+    const suppliedId = 'project-with-an-explicit-id';
+    const received = vi.fn<(properties: Record<string, unknown>) => void>();
+    let SceneDataTable: typeof import('../SceneDataTable').SceneDataTable;
+    let bindings: typeof import('../../bindings');
+
+    beforeEach(async () => {
+        vi.resetModules();
+        received.mockClear();
+        vi.doMock('@cratis/components/DataTables', () => ({
+            DataTableForQuery: (properties: Record<string, unknown>) => {
+                received(properties);
+                return <div data-testid='query-table' />;
+            },
+        }));
+        ({ Snapshot: InvoicesForProject } = await import('../../bindings/for_requireArcProxy/NativeProxies'));
+        AnotherQuery = InvoicesForProject;
+        bindings = await import('../../bindings');
+        bindings.clearBindings();
+        bindings.registerQuery('InvoicesForProject', InvoicesForProject);
+        bindings.registerQuery('AnotherQuery', AnotherQuery);
+        ({ SceneDataTable } = await import('../SceneDataTable'));
+    });
+
+    afterEach(() => {
+        cleanup();
+        bindings.clearBindings();
+        vi.doUnmock('@cratis/components/DataTables');
+        vi.resetModules();
+    });
+
+    async function renderTable(properties: Record<string, unknown>) {
+        const element = externalComponent('Cratis.Components:dataTable', properties);
+        await act(async () => {
+            render(<SceneDataTable element={element} slots={{}} />);
+        });
+    }
+
+    it('should pass the exact registered constructor and explicit projectId object through the runtime boundary', async () => {
+        const queryArguments = { projectId: suppliedId };
+        await renderTable({ query: 'InvoicesForProject', queryArguments });
+        await screen.findByTestId('query-table');
+        const properties = received.mock.lastCall![0];
+        (properties.query === InvoicesForProject).should.equal(true);
+        (properties.queryArguments === queryArguments).should.equal(true);
+        properties.should.have.property('queryArguments').that.deep.equals({ projectId: suppliedId });
+    });
+
+    it('should preserve all supplied keys and values without normalization or defaults', async () => {
+        const queryArguments = { projectId: suppliedId, ProjectID: 'distinct', limit: 0, enabled: false, optional: null, filter: { names: ['one'] } };
+        await renderTable({ query: 'InvoicesForProject', queryArguments });
+        await screen.findByTestId('query-table');
+        (received.mock.lastCall![0].queryArguments === queryArguments).should.equal(true);
+    });
+
+    it('should leave omitted arguments absent from the underlying component props', async () => {
+        await renderTable({ query: 'InvoicesForProject' });
+        await screen.findByTestId('query-table');
+        Object.prototype.hasOwnProperty.call(received.mock.lastCall![0], 'queryArguments').should.equal(false);
+        (received.mock.lastCall![0].query === InvoicesForProject).should.equal(true);
+    });
+
+    it('should treat undefined arguments as omitted like the existing property readers', async () => {
+        await renderTable({ query: 'InvoicesForProject', queryArguments: undefined });
+        await screen.findByTestId('query-table');
+        Object.prototype.hasOwnProperty.call(received.mock.lastCall![0], 'queryArguments').should.equal(false);
+    });
+
+    it('should pass an explicitly empty argument object unchanged', async () => {
+        const queryArguments = {};
+        await renderTable({ query: 'InvoicesForProject', queryArguments });
+        await screen.findByTestId('query-table');
+        (received.mock.lastCall![0].queryArguments === queryArguments).should.equal(true);
+    });
+
+    for (const queryArguments of [[], ['project'], 'project', '{"projectId":"project"}', 42, false, null]) {
+        it(`should visibly reject ${JSON.stringify(queryArguments)} without mounting a query table`, async () => {
+            await renderTable({ query: 'InvoicesForProject', queryArguments });
+            (screen.getByText("Invalid queryArguments: expected an object on Cratis.Components:dataTable") !== null).should.equal(true);
+            received.mock.calls.should.have.lengthOf(0);
+            (screen.queryByTestId('query-table') === null).should.equal(true);
+        });
+    }
+
+    for (const queryArguments of [{ projectId: suppliedId }, null, []]) {
+        it(`should retain MissingBinding precedence and never choose another registered query with ${JSON.stringify(queryArguments)}`, async () => {
+            await renderTable({ query: 'UnregisteredQuery', queryArguments });
+            (screen.getByText("Unresolved query binding 'UnregisteredQuery' on Cratis.Components:dataTable") !== null).should.equal(true);
+            received.mock.calls.should.have.lengthOf(0);
+            (screen.queryByText(/Invalid queryArguments/) === null).should.equal(true);
+        });
+    }
+});

package/data/for_SceneSingleResult/when_executing_a_native_query.tsx

@@ -0,0 +1,290 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react';
+import { expect, vi } from 'vitest';
+import { StrictMode } from 'react';
+import { ArcContext, type ArcConfiguration } from '@cratis/arc.react';
+import { QueryFor, QueryHttpMethod, QueryValidator } from '@cratis/arc/queries';
+import { clearBindings, registerQuery } from '../../bindings';
+import { externalComponent } from '../../given';
+import { SceneSingleResult } from '../SceneSingleResult';
+
+class ProjectName extends QueryFor<object | undefined, { projectId: string }> {
+    readonly route = '/projects/{projectId}/name';
+    readonly parameterDescriptors = [];
+    readonly requiredRequestParameters = ['projectId'];
+    defaultValue = undefined;
+
+    constructor() {
+        super(Object, false);
+        this.setHttpMethod(QueryHttpMethod.Get);
+    }
+}
+
+class ProjectNames extends QueryFor<object[]> {
+    readonly route = '/projects';
+    readonly parameterDescriptors = [];
+    readonly requiredRequestParameters = [];
+    defaultValue = [];
+
+    constructor() { super(Object, true); }
+}
+
+class ProjectArgumentsValidator extends QueryValidator<{ projectId: string }> {
+    static received: unknown;
+
+    constructor() {
+        super();
+        this.ruleFor(args => {
+            ProjectArgumentsValidator.received = args;
+            return args.projectId;
+        }).minLength(2);
+    }
+}
+
+class ValidatedProjectName extends ProjectName {
+    readonly validation = new ProjectArgumentsValidator();
+}
+
+function envelope(data: unknown, overrides: Record<string, unknown> = {}) {
+    return {
+        data, isSuccess: true, isAuthorized: true, isValid: true, hasExceptions: false,
+        validationResults: [], exceptionMessages: [], exceptionStackTrace: '',
+        paging: { page: 0, size: 0, totalItems: 0, totalPages: 0 }, ...overrides,
+    };
+}
+
+function response(data: unknown, overrides: Record<string, unknown> = {}) {
+    return { ok: true, status: 200, json: async () => envelope(data, overrides) } as Response;
+}
+
+function deferred() {
+    let resolve!: (value: Response) => void;
+    let reject!: (error: unknown) => void;
+    const promise = new Promise<Response>((yes, no) => { resolve = yes; reject = no; });
+    return { promise, resolve, reject };
+}
+
+describe('when executing an optional single result with native Arc 22.16.1', () => {
+    const headers = () => ({ 'x-host': 'one' });
+    const context: ArcConfiguration = { microservice: 'projects', origin: 'https://example.test', apiBasePath: '/backend', httpHeadersCallback: headers };
+    const fetch = vi.fn<typeof globalThis.fetch>();
+
+    function view(queryArguments: unknown = { projectId: 'A' }, arc = context, properties: Record<string, unknown> = {}) {
+        return <ArcContext.Provider value={arc}>
+            <SceneSingleResult element={externalComponent('Cratis.Components:singleResult', {
+                query: 'ProjectName', queryArguments, enabled: true, resultField: 'name', ...properties,
+            })} slots={{}} />
+        </ArcContext.Provider>;
+    }
+
+    beforeEach(() => {
+        clearBindings();
+        registerQuery('ProjectName', ProjectName);
+        registerQuery('ProjectNames', ProjectNames);
+        registerQuery('ValidatedProjectName', ValidatedProjectName);
+        fetch.mockReset();
+        vi.stubGlobal('fetch', fetch);
+    });
+
+    afterEach(() => {
+        cleanup();
+        clearBindings();
+        vi.unstubAllGlobals();
+    });
+
+    it('uses the native URL, arguments and context headers without changing the host object', async () => {
+        const args = Object.freeze({ projectId: 'AA', locale: 'en' });
+        fetch.mockResolvedValue(response({ name: '<b>Project A</b>' }));
+        await act(async () => { render(view(args, context, { query: 'ValidatedProjectName' })); });
+        expect(await screen.findByText('<b>Project A</b>')).not.toBeNull();
+        expect(document.querySelector('b')).toBeNull();
+        expect(fetch).toHaveBeenCalledTimes(1);
+        const [url, init] = fetch.mock.calls[0];
+        expect(String(url)).toBe('https://example.test/backend/projects/AA/name?locale=en');
+        expect(ProjectArgumentsValidator.received).toBe(args);
+        expect(new Headers(init?.headers).get('x-host')).toBe('one');
+        expect(new Headers(init?.headers).get('x-cratis-microservice')).toBe('projects');
+        expect(args).toEqual({ projectId: 'AA', locale: 'en' });
+    });
+
+    for (const value of [false, 0, '']) {
+        it(`renders scalar own-field ${JSON.stringify(value)} as present`, async () => {
+            fetch.mockResolvedValue(response({ name: value }));
+            await act(async () => { render(view()); });
+            await waitFor(() => expect(screen.getByRole('status').getAttribute('data-scene-single-result')).toBe('success'));
+            expect(screen.getByRole('status').textContent).toBe(String(value));
+        });
+    }
+
+    for (const data of [null, undefined]) {
+        it(`shows not found for successful ${String(data)}`, async () => {
+            fetch.mockResolvedValue(response(data));
+            await act(async () => { render(view()); });
+            expect(await screen.findByText('Not found')).not.toBeNull();
+        });
+    }
+
+    for (const failure of [{ isSuccess: false }, { isAuthorized: false }, { isValid: false }, { hasExceptions: true }]) {
+        it(`prioritizes failure over missing data: ${JSON.stringify(failure)}`, async () => {
+            fetch.mockResolvedValue(response(null, { ...failure, exceptionMessages: ['secret'], exceptionStackTrace: 'server stack' }));
+            await act(async () => { render(view()); });
+            expect(await screen.findByRole('alert')).toHaveProperty('textContent', 'Unable to load result');
+            expect(screen.queryByText('Not found')).toBeNull();
+            expect(document.body.textContent).not.toMatch(/secret|server stack/);
+        });
+    }
+
+    for (const args of [{}, { projectId: '' }, { projectId: null }, [], null, 'A', undefined]) {
+        it(`does not send invalid or missing arguments: ${JSON.stringify(args)}`, async () => {
+            await act(async () => { render(view(args, context, { queryArguments: args })); });
+            expect(await screen.findByRole('alert')).not.toBeNull();
+            expect(fetch).not.toHaveBeenCalled();
+        });
+    }
+
+    it('lets the native proxy validator reject arguments without HTTP', async () => {
+        await act(async () => { render(view({ projectId: 'A' }, context, { query: 'ValidatedProjectName' })); });
+        expect(await screen.findByRole('alert')).not.toBeNull();
+        expect(fetch).not.toHaveBeenCalled();
+    });
+
+    for (const enabled of [false, undefined, 'true']) {
+        it(`is idle unless explicitly enabled: ${String(enabled)}`, async () => {
+            await act(async () => { render(view({ projectId: 'A' }, context, { enabled })); });
+            expect(screen.getByText('Idle')).not.toBeNull();
+            expect(fetch).not.toHaveBeenCalled();
+        });
+    }
+
+    it('never chooses another query when the binding is missing', async () => {
+        await act(async () => { render(view({}, context, { query: 'Missing' })); });
+        expect(screen.getByText(/Unresolved query binding 'Missing'/)).not.toBeNull();
+        expect(fetch).not.toHaveBeenCalled();
+    });
+
+    it('aborts A and ignores reverse completion when the transport ignores abort', async () => {
+        const a = deferred();
+        const b = deferred();
+        fetch.mockReturnValueOnce(a.promise).mockReturnValueOnce(b.promise);
+        let mounted!: ReturnType<typeof render>;
+        await act(async () => { mounted = render(view()); });
+        expect(screen.getByText('Loading')).not.toBeNull();
+        const signal = fetch.mock.calls[0][1]?.signal;
+        await act(async () => { mounted.rerender(view({ projectId: 'B' })); });
+        expect(signal?.aborted).toBe(true);
+        await act(async () => { b.resolve(response({ name: 'B' })); });
+        expect(screen.getByText('B')).not.toBeNull();
+        await act(async () => { a.resolve(response({ name: 'A' })); });
+        expect(screen.queryByText('A')).toBeNull();
+        expect(screen.getByText('B')).not.toBeNull();
+    });
+
+    it('hides a settled A immediately on B and aborts B on disposal', async () => {
+        const b = deferred();
+        fetch.mockResolvedValueOnce(response({ name: 'A' })).mockReturnValueOnce(b.promise);
+        let mounted!: ReturnType<typeof render>;
+        await act(async () => { mounted = render(view()); });
+        expect(screen.getByText('A')).not.toBeNull();
+        await act(async () => { mounted.rerender(view({ projectId: 'B' })); });
+        expect(screen.queryByText('A')).toBeNull();
+        expect(screen.getByText('Loading')).not.toBeNull();
+        mounted.unmount();
+        expect(fetch.mock.calls[1][1]?.signal?.aborted).toBe(true);
+        await act(async () => { b.reject(new DOMException('Aborted', 'AbortError')); });
+    });
+
+    it('reexecutes for header-only context changes and ignores the old response', async () => {
+        const a = deferred();
+        const b = deferred();
+        const args = { projectId: 'A' };
+        fetch.mockReturnValueOnce(a.promise).mockReturnValueOnce(b.promise);
+        let mounted!: ReturnType<typeof render>;
+        await act(async () => { mounted = render(view(args)); });
+        await act(async () => { mounted.rerender(view(args, { ...context, httpHeadersCallback: () => ({ 'x-host': 'two' }) })); });
+        expect(fetch.mock.calls[0][1]?.signal?.aborted).toBe(true);
+        expect(new Headers(fetch.mock.calls[1][1]?.headers).get('x-host')).toBe('two');
+        await act(async () => { b.resolve(response({ name: 'New context' })); a.resolve(response({ name: 'Old context' })); });
+        expect(screen.getByText('New context')).not.toBeNull();
+        expect(screen.queryByText('Old context')).toBeNull();
+    });
+
+    it('rejects enumerable proxies before HTTP rather than adapting them to a single model', async () => {
+        await act(async () => { render(view({}, context, { query: 'ProjectNames' })); });
+        expect(await screen.findByRole('alert')).not.toBeNull();
+        expect(fetch).not.toHaveBeenCalled();
+    });
+
+    it('handles StrictMode disposal without an unhandled abort promise', async () => {
+        const a = deferred();
+        const b = deferred();
+        fetch.mockReturnValueOnce(a.promise).mockReturnValueOnce(b.promise);
+        await act(async () => { render(<StrictMode>{view()}</StrictMode>); });
+        expect(fetch).toHaveBeenCalledTimes(2);
+        expect(fetch.mock.calls[0][1]?.signal?.aborted).toBe(true);
+        await act(async () => {
+            a.reject(new DOMException('Aborted', 'AbortError'));
+            b.resolve(response({ name: 'Current generation' }));
+        });
+        expect(screen.getByText('Current generation')).not.toBeNull();
+    });
+
+    it('ignores successful completion after unmount even if HTTP ignores abort', async () => {
+        const pending = deferred();
+        fetch.mockReturnValueOnce(pending.promise);
+        let mounted!: ReturnType<typeof render>;
+        await act(async () => { mounted = render(view()); });
+        mounted.unmount();
+        expect(fetch.mock.calls[0][1]?.signal?.aborted).toBe(true);
+        await act(async () => { pending.resolve(response({ name: 'Disposed' })); });
+        expect(screen.queryByText('Disposed')).toBeNull();
+    });
+
+    it('turns transport rejection and malformed envelopes into safe failure', async () => {
+        fetch.mockRejectedValueOnce(new Error('private network detail'));
+        let mounted!: ReturnType<typeof render>;
+        await act(async () => { mounted = render(view()); });
+        expect(await screen.findByRole('alert')).toHaveProperty('textContent', 'Unable to load result');
+        fetch.mockResolvedValueOnce({ ok: false, status: 500, json: async () => ({}) } as Response);
+        await act(async () => { mounted.rerender(view({ projectId: 'B' })); });
+        expect(await screen.findByRole('alert')).toHaveProperty('textContent', 'Unable to load result');
+        expect(document.body.textContent).not.toContain('private network detail');
+    });
+
+    it('aborts and clears a pending request when disabled', async () => {
+        const pending = deferred();
+        fetch.mockReturnValueOnce(pending.promise);
+        let mounted!: ReturnType<typeof render>;
+        await act(async () => { mounted = render(view()); });
+        await act(async () => { mounted.rerender(view({ projectId: 'A' }, context, { enabled: false })); });
+        expect(fetch.mock.calls[0][1]?.signal?.aborted).toBe(true);
+        await act(async () => { pending.resolve(response({ name: 'Obsolete' })); });
+        expect(screen.getByText('Idle')).not.toBeNull();
+        expect(screen.queryByText('Obsolete')).toBeNull();
+    });
+
+    for (const change of [{ origin: 'https://other.test' }, { apiBasePath: '/v2' }, { microservice: 'other' }, { queryVersion: 1 }]) {
+        it(`invalidates a settled result after context changes: ${JSON.stringify(change)}`, async () => {
+            const pending = deferred();
+            const args = { projectId: 'A' };
+            fetch.mockResolvedValueOnce(response({ name: 'Old' })).mockReturnValueOnce(pending.promise);
+            let mounted!: ReturnType<typeof render>;
+            await act(async () => { mounted = render(view(args)); });
+            await act(async () => { mounted.rerender(view(args, { ...context, ...change })); });
+            expect(screen.queryByText('Old')).toBeNull();
+            expect(screen.getByText('Loading')).not.toBeNull();
+            expect(fetch).toHaveBeenCalledTimes(2);
+            await act(async () => { pending.resolve(response({ name: 'New' })); });
+            expect(screen.getByText('New')).not.toBeNull();
+        });
+    }
+
+    for (const data of [{ name: {} }, { name: [] }, {}, Object.create({ name: 'Inherited' }), [{ name: 'A' }]]) {
+        it(`rejects non-scalar or absent own fields: ${JSON.stringify(data)}`, async () => {
+            fetch.mockResolvedValue(response(data));
+            await act(async () => { render(view()); });
+            expect(await screen.findByRole('alert')).not.toBeNull();
+        });
+    }
+});

package/data/for_SceneSingleResult/when_gating_the_lazy_runtime.tsx

@@ -0,0 +1,60 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { act, cleanup, render, screen } from '@testing-library/react';
+import { expect, vi } from 'vitest';
+import { externalComponent } from '../../given';
+
+class RegisteredQuery {}
+
+describe('when gating the single result lazy runtime', () => {
+    const loaded = vi.fn();
+    let SceneSingleResult: typeof import('../SceneSingleResult').SceneSingleResult;
+    let bindings: typeof import('../../bindings');
+
+    beforeEach(async () => {
+        vi.resetModules();
+        loaded.mockClear();
+        vi.doMock('../SingleResultRuntime', () => {
+            loaded();
+            return { default: () => <span>Runtime mounted</span> };
+        });
+        bindings = await import('../../bindings');
+        bindings.clearBindings();
+        bindings.registerQuery('Registered', RegisteredQuery);
+        ({ SceneSingleResult } = await import('../SceneSingleResult'));
+    });
+
+    afterEach(() => {
+        cleanup();
+        bindings.clearBindings();
+        vi.doUnmock('../SingleResultRuntime');
+        vi.resetModules();
+    });
+
+    for (const properties of [
+        { query: 'Missing', enabled: true, queryArguments: {}, resultField: 'name' },
+        { query: 'Registered', queryArguments: {}, resultField: 'name' },
+        { query: 'Registered', enabled: true, queryArguments: [], resultField: 'name' },
+        { query: 'Registered', enabled: true, queryArguments: {}, resultField: '' },
+    ]) {
+        it(`does not import Arc-bound code for ${JSON.stringify(properties)}`, async () => {
+            await act(async () => {
+                render(<SceneSingleResult element={externalComponent('Cratis.Components:singleResult', properties)} slots={{}} />);
+            });
+            expect(loaded).not.toHaveBeenCalled();
+            expect(screen.queryByText('Runtime mounted')).toBeNull();
+            expect(document.body.textContent).toMatch(/Unresolved query binding|Idle|Unable to load result/);
+        });
+    }
+
+    it('loads only the explicitly bound and enabled view', async () => {
+        await act(async () => {
+            render(<SceneSingleResult element={externalComponent('Cratis.Components:singleResult', {
+                query: 'Registered', enabled: true, queryArguments: {}, resultField: 'name',
+            })} slots={{}} />);
+        });
+        expect(await screen.findByText('Runtime mounted')).not.toBeNull();
+        expect(loaded).toHaveBeenCalledTimes(1);
+    });
+});

package/data/index.ts

@@ -1,5 +1,6 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+export * from './SceneSingleResult';
 export * from './SceneDataTable';
 export * from './SceneObservableDataTable';

package/dialogs/SceneCommandDialog.tsx

@@ -6,7 +6,7 @@ import { RegisteredComponentProps } from '@cratis/scene.react';
 import { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding } from '../bindings';
 import { booleanProperty, stringProperty } from '../properties';
 
-const CommandDialog = lazy(async () => ({ default: (await import('@cratis/components/CommandDialog')).CommandDialog }));
+const CommandDialog = lazy(async () => ({ default: (await import('../bindings/ArcBoundComponents')).BoundCommandDialog }));
 
 /**
  * The `Cratis.Components:commandDialog` component - `CommandDialog` from `@cratis/components/CommandDialog`.

package/dialogs/SceneStepperCommandDialog.tsx

@@ -7,7 +7,7 @@ import { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding
 import { booleanProperty, stringProperty, unionProperty } from '../properties';
 
 const StepperCommandDialog = lazy(async () => ({
-    default: (await import('@cratis/components/CommandDialog')).StepperCommandDialog,
+    default: (await import('../bindings/ArcBoundComponents')).BoundStepperCommandDialog,
 }));
 
 /** Whether the step headers run across the top or down the side. */

package/dist/cjs/bindings/ArcBoundComponents.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var queries = require('@cratis/arc/queries');
+var commands = require('@cratis/arc/commands');
+var DataTables = require('@cratis/components/DataTables');
+var DataPage = require('@cratis/components/DataPage');
+var CommandDialog = require('@cratis/components/CommandDialog');
+var requireArcProxy = require('./requireArcProxy.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+// Runtime-only module: import dynamically beneath ArcRuntimeBoundary, never through the barrel.
+// Scene carries property names and argument objects, not compile-time row schemas. These adapters
+// support generated object/collection queries, as required by the Components public prop contracts.
+function BoundDataTable({ query, ...props }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(DataTables.DataTableForQuery, {
+        ...props,
+        query: requireArcProxy.requireArcProxy(query, queries.QueryFor, 'query')
+    });
+}
+function BoundObservableDataTable({ query, ...props }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(DataTables.DataTableForObservableQuery, {
+        ...props,
+        query: requireArcProxy.requireArcProxy(query, queries.ObservableQueryFor, 'observable query')
+    });
+}
+function BoundDataPage({ query, ...props }) {
+    const base = query.prototype instanceof queries.ObservableQueryFor ? queries.ObservableQueryFor : queries.QueryFor;
+    // This chooses only the kind of the supplied constructor, never another registered binding.
+    const proxy = requireArcProxy.requireArcProxy(query, base, 'query');
+    return /*#__PURE__*/ jsxRuntime.jsx(DataPage.DataPage, {
+        ...props,
+        query: proxy
+    });
+}
+function BoundCommandDialog({ command, ...props }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(CommandDialog.CommandDialog, {
+        ...props,
+        command: requireArcProxy.requireArcProxy(command, commands.Command, 'command')
+    });
+}
+function BoundStepperCommandDialog({ command, ...props }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(CommandDialog.StepperCommandDialog, {
+        ...props,
+        command: requireArcProxy.requireArcProxy(command, commands.Command, 'command')
+    });
+}
+
+exports.BoundCommandDialog = BoundCommandDialog;
+exports.BoundDataPage = BoundDataPage;
+exports.BoundDataTable = BoundDataTable;
+exports.BoundObservableDataTable = BoundObservableDataTable;
+exports.BoundStepperCommandDialog = BoundStepperCommandDialog;
+//# sourceMappingURL=ArcBoundComponents.js.map

package/dist/cjs/bindings/ArcBoundComponents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArcBoundComponents.js","sources":["../../../bindings/ArcBoundComponents.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n// Runtime-only module: import dynamically beneath ArcRuntimeBoundary, never through the barrel.\nimport type { ComponentProps } from 'react';\nimport { QueryFor, ObservableQueryFor } from '@cratis/arc/queries';\nimport { Command } from '@cratis/arc/commands';\nimport { DataTableForQuery, DataTableForObservableQuery } from '@cratis/components/DataTables';\nimport { DataPage } from '@cratis/components/DataPage';\nimport { CommandDialog, StepperCommandDialog } from '@cratis/components/CommandDialog';\nimport type { BoundConstructor } from './BoundConstructor';\nimport { requireArcProxy } from './requireArcProxy';\n\ntype QueryProps<T> = Omit<T, 'query'> & { query: BoundConstructor };\ntype CommandProps<T> = Omit<T, 'command'> & { command: BoundConstructor };\n\n// Scene carries property names and argument objects, not compile-time row schemas. These adapters\n// support generated object/collection queries, as required by the Components public prop contracts.\nexport function BoundDataTable({ query, ...props }: QueryProps<ComponentProps<typeof DataTableForQuery>>) {\n    return <DataTableForQuery {...props} query={requireArcProxy(query, QueryFor<object, object>, 'query')} />;\n}\n\nexport function BoundObservableDataTable({ query, ...props }: QueryProps<ComponentProps<typeof DataTableForObservableQuery>>) {\n    return <DataTableForObservableQuery {...props} query={requireArcProxy(query, ObservableQueryFor<object, object>, 'observable query')} />;\n}\n\nexport function BoundDataPage({ query, ...props }: QueryProps<ComponentProps<typeof DataPage>>) {\n    const base = query.prototype instanceof ObservableQueryFor ? ObservableQueryFor<object, object> : QueryFor<object, object>;\n    // This chooses only the kind of the supplied constructor, never another registered binding.\n    const proxy = requireArcProxy<QueryFor<object, object> | ObservableQueryFor<object, object>>(query, base, 'query');\n    return <DataPage {...props} query={proxy} />;\n}\n\nexport function BoundCommandDialog({ command, ...props }: CommandProps<ComponentProps<typeof CommandDialog>>) {\n    return <CommandDialog {...props} command={requireArcProxy(command, Command<object, object>, 'command')} />;\n}\n\nexport function BoundStepperCommandDialog({ command, ...props }: CommandProps<ComponentProps<typeof StepperCommandDialog>>) {\n    return <StepperCommandDialog {...props} command={requireArcProxy(command, Command<object, object>, 'command')} />;\n}\n"],"names":["BoundDataTable","query","props","_jsx","DataTableForQuery","requireArcProxy","QueryFor","BoundObservableDataTable","DataTableForObservableQuery","ObservableQueryFor","BoundDataPage","base","prototype","proxy","DataPage","BoundCommandDialog","command","CommandDialog","Command","BoundStepperCommandDialog","StepperCommandDialog"],"mappings":";;;;;;;;;;AAAA;AACA;AAEA;AAaA;AACA;AACO,SAASA,cAAAA,CAAe,EAAEC,KAAK,EAAE,GAAGC,KAAAA,EAA6D,EAAA;AACpG,IAAA,qBAAOC,cAAA,CAACC,4BAAAA,EAAAA;AAAmB,QAAA,GAAGF,KAAK;QAAED,KAAAA,EAAOI,+BAAAA,CAAgBJ,OAAOK,gBAAAA,EAA0B,OAAA;;AACjG;AAEO,SAASC,wBAAAA,CAAyB,EAAEN,KAAK,EAAE,GAAGC,KAAAA,EAAuE,EAAA;AACxH,IAAA,qBAAOC,cAAA,CAACK,sCAAAA,EAAAA;AAA6B,QAAA,GAAGN,KAAK;QAAED,KAAAA,EAAOI,+BAAAA,CAAgBJ,OAAOQ,0BAAAA,EAAoC,kBAAA;;AACrH;AAEO,SAASC,aAAAA,CAAc,EAAET,KAAK,EAAE,GAAGC,KAAAA,EAAoD,EAAA;AAC1F,IAAA,MAAMS,IAAAA,GAAOV,KAAAA,CAAMW,SAAS,YAAYH,6BAAqBA,0BAAAA,GAAqCH,gBAAAA;;IAElG,MAAMO,KAAAA,GAAQR,+BAAAA,CAA+EJ,KAAAA,EAAOU,IAAAA,EAAM,OAAA,CAAA;AAC1G,IAAA,qBAAOR,cAAA,CAACW,iBAAAA,EAAAA;AAAU,QAAA,GAAGZ,KAAK;QAAED,KAAAA,EAAOY;;AACvC;AAEO,SAASE,kBAAAA,CAAmB,EAAEC,OAAO,EAAE,GAAGd,KAAAA,EAA2D,EAAA;AACxG,IAAA,qBAAOC,cAAA,CAACc,2BAAAA,EAAAA;AAAe,QAAA,GAAGf,KAAK;QAAEc,OAAAA,EAASX,+BAAAA,CAAgBW,SAASE,gBAAAA,EAAyB,SAAA;;AAChG;AAEO,SAASC,yBAAAA,CAA0B,EAAEH,OAAO,EAAE,GAAGd,KAAAA,EAAkE,EAAA;AACtH,IAAA,qBAAOC,cAAA,CAACiB,kCAAAA,EAAAA;AAAsB,QAAA,GAAGlB,KAAK;QAAEc,OAAAA,EAASX,+BAAAA,CAAgBW,SAASE,gBAAAA,EAAyB,SAAA;;AACvG;;;;;;"}

package/dist/cjs/bindings/requireArcProxy.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Bridge for the generated, zero-argument Arc proxies consumed by Components. The registry remains
+ * open to arbitrary constructors; only mounting an Arc adapter requires this narrower contract.
+ * Check inheritance without constructing a proxy (constructors can have side effects).
+ *
+ * This is not structural interface validation: the host still owns the generated subclass's data,
+ * argument and implementation correctness. Prototype identity deliberately rejects duck-typed proxies
+ * and proxies from a second Arc installation. The arity check enforces the generated convention,
+ * not general JavaScript constructor safety (defaults/rest parameters can hide requirements).
+ * The single assertion bridges the registry under that host-owned generated-proxy contract; it is
+ * not a proof of arbitrary subclass behavior or of erased row/argument types.
+ */ function requireArcProxy(target, base, kind) {
+    const prototype = target.prototype;
+    if (target.length !== 0 || typeof prototype !== 'object' || prototype === null || !Object.prototype.isPrototypeOf.call(base.prototype, prototype)) {
+        throw new Error(`Invalid ${kind} binding '${target.name}': expected a zero-argument Arc ${kind} proxy`);
+    }
+    return target;
+}
+
+exports.requireArcProxy = requireArcProxy;
+//# sourceMappingURL=requireArcProxy.js.map

package/dist/cjs/bindings/requireArcProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireArcProxy.js","sources":["../../../bindings/requireArcProxy.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport type { BoundConstructor } from './BoundConstructor';\n\n/**\n * Bridge for the generated, zero-argument Arc proxies consumed by Components. The registry remains\n * open to arbitrary constructors; only mounting an Arc adapter requires this narrower contract.\n * Check inheritance without constructing a proxy (constructors can have side effects).\n *\n * This is not structural interface validation: the host still owns the generated subclass's data,\n * argument and implementation correctness. Prototype identity deliberately rejects duck-typed proxies\n * and proxies from a second Arc installation. The arity check enforces the generated convention,\n * not general JavaScript constructor safety (defaults/rest parameters can hide requirements).\n * The single assertion bridges the registry under that host-owned generated-proxy contract; it is\n * not a proof of arbitrary subclass behavior or of erased row/argument types.\n */\nexport function requireArcProxy<T extends object>(target: BoundConstructor, base: { prototype: T }, kind: string): new () => T {\n    const prototype: unknown = target.prototype;\n    if (target.length !== 0 || typeof prototype !== 'object' || prototype === null || !Object.prototype.isPrototypeOf.call(base.prototype, prototype)) {\n        throw new Error(`Invalid ${kind} binding '${target.name}': expected a zero-argument Arc ${kind} proxy`);\n    }\n    return target as new () => T;\n}\n"],"names":["requireArcProxy","target","base","kind","prototype","length","Object","isPrototypeOf","call","Error","name"],"mappings":";;AAAA;AACA;AAIA;;;;;;;;;;;AAWC,IACM,SAASA,eAAAA,CAAkCC,MAAwB,EAAEC,IAAsB,EAAEC,IAAY,EAAA;IAC5G,MAAMC,SAAAA,GAAqBH,OAAOG,SAAS;IAC3C,IAAIH,MAAAA,CAAOI,MAAM,KAAK,CAAA,IAAK,OAAOD,SAAAA,KAAc,QAAA,IAAYA,cAAc,IAAA,IAAQ,CAACE,OAAOF,SAAS,CAACG,aAAa,CAACC,IAAI,CAACN,IAAAA,CAAKE,SAAS,EAAEA,SAAAA,CAAAA,EAAY;AAC/I,QAAA,MAAM,IAAIK,KAAAA,CAAM,CAAC,QAAQ,EAAEN,IAAAA,CAAK,UAAU,EAAEF,MAAAA,CAAOS,IAAI,CAAC,gCAAgC,EAAEP,IAAAA,CAAK,MAAM,CAAC,CAAA;AAC1G,IAAA;IACA,OAAOF,MAAAA;AACX;;"}

package/dist/cjs/cratisComponents.js

@@ -4,6 +4,7 @@ var scene_react = require('@cratis/scene.react');
 var ScenePage = require('./pages/ScenePage.js');
 var SceneDataPage = require('./pages/SceneDataPage.js');
 var SceneFormElement = require('./pages/SceneFormElement.js');
+var SceneSingleResult = require('./data/SceneSingleResult.js');
 var SceneDataTable = require('./data/SceneDataTable.js');
 var SceneObservableDataTable = require('./data/SceneObservableDataTable.js');
 var SceneCommandForm = require('./forms/SceneCommandForm.js');
@@ -65,6 +66,7 @@ var SceneToolbarSeparator = require('./toolbar/SceneToolbarSeparator.js');
     [scene_react.componentRegistryKey(cratisComponentsPackageName, 'page')]: ScenePage.ScenePage,
     [scene_react.componentRegistryKey(cratisComponentsPackageName, 'dataPage')]: SceneDataPage.SceneDataPage,
     [scene_react.componentRegistryKey(cratisComponentsPackageName, 'formElement')]: SceneFormElement.SceneFormElement,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'singleResult')]: SceneSingleResult.SceneSingleResult,
     [scene_react.componentRegistryKey(cratisComponentsPackageName, 'dataTable')]: SceneDataTable.SceneDataTable,
     [scene_react.componentRegistryKey(cratisComponentsPackageName, 'table')]: SceneDataTable.SceneDataTable,
     [scene_react.componentRegistryKey(cratisComponentsPackageName, 'observableDataTable')]: SceneObservableDataTable.SceneObservableDataTable,