@happyvertical/smrt-fields 0.40.60 → 0.40.62

package/dist/svelte/__tests__/ObjectForm.test.js

@@ -0,0 +1,687 @@
+// @vitest-environment jsdom
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { field, ObjectRegistry, SmrtObject, smrt, } from '@happyvertical/smrt-core';
+import { expectNoA11yViolations, fireEvent, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { tick } from 'svelte';
+import { describe, expect, it, vi } from 'vitest';
+import FieldInput from '../components/FieldInput.svelte';
+import { policyToVisibleColumnIds } from '../data-table.js';
+import { ObjectFormSourceRegistry, } from '../index.js';
+import { FieldInputRegistry } from '../input-registry.js';
+import { resolveObjectFormFields } from '../object-form.js';
+import ObjectFormActionsFixture from './fixtures/ObjectFormActionsFixture.svelte';
+import ObjectFormFixture from './fixtures/ObjectFormFixture.svelte';
+import ObjectFormRegistryFixture from './fixtures/ObjectFormRegistryFixture.svelte';
+import ObjectFormSnippetFixture from './fixtures/ObjectFormSnippetFixture.svelte';
+import ObjectFormSourceFixture from './fixtures/ObjectFormSourceFixture.svelte';
+import ObjectFormSourceSnippetFixture from './fixtures/ObjectFormSourceSnippetFixture.svelte';
+import PolicyDataTableFixture from './fixtures/PolicyDataTableFixture.svelte';
+let AcceptanceProduct = class AcceptanceProduct extends SmrtObject {
+    name = '';
+    price = 0;
+    published = false;
+};
+__decorate([
+    field({ required: true })
+], AcceptanceProduct.prototype, "name", void 0);
+__decorate([
+    field({ type: 'decimal' })
+], AcceptanceProduct.prototype, "price", void 0);
+__decorate([
+    field({ type: 'boolean', default: false })
+], AcceptanceProduct.prototype, "published", void 0);
+AcceptanceProduct = __decorate([
+    smrt({
+        packageName: '@test/smrt-fields-object-form',
+        visibility: 'internal',
+        api: { include: ['list', 'get', 'create', 'update'] },
+        cli: false,
+        mcp: false,
+    })
+], AcceptanceProduct);
+let AcceptanceEvent = class AcceptanceEvent extends SmrtObject {
+    title = '';
+    startsAt = '';
+    metadata = {};
+};
+__decorate([
+    field({ required: true })
+], AcceptanceEvent.prototype, "title", void 0);
+__decorate([
+    field({ type: 'datetime' })
+], AcceptanceEvent.prototype, "startsAt", void 0);
+__decorate([
+    field({ type: 'json' })
+], AcceptanceEvent.prototype, "metadata", void 0);
+AcceptanceEvent = __decorate([
+    smrt({
+        packageName: '@test/smrt-fields-object-form',
+        visibility: 'internal',
+        api: { include: ['list', 'get', 'create', 'update'] },
+        cli: false,
+        mcp: false,
+    })
+], AcceptanceEvent);
+function objectRef(ctor) {
+    const registered = ObjectRegistry.getClassByConstructor(ctor);
+    if (!registered?.qualifiedName)
+        throw new Error('acceptance fixture did not register');
+    return registered.qualifiedName;
+}
+function sourcePolicy(objectRef, definitions, defaults = {}) {
+    return {
+        objectRef,
+        fields: Object.fromEntries(Object.entries(definitions).map(([fieldName, definition], index) => [
+            fieldName,
+            {
+                fieldName,
+                hasDefault: fieldName in defaults,
+                defaultValue: defaults[fieldName],
+                visibility: 'basic',
+                help: definition.description ?? null,
+                label: fieldName
+                    .replace(/([A-Z])/g, ' $1')
+                    .replace(/^./, (letter) => letter.toUpperCase()),
+                order: index,
+                group: null,
+                locked: false,
+                required: definition.required === true,
+            },
+        ])),
+    };
+}
+const fields = {
+    name: { type: 'text', required: true },
+    price: { type: 'decimal', ui: { group: 'Pricing', order: 2 } },
+    published: { type: 'boolean' },
+    metadata: { type: 'json' },
+    id: { type: 'text' },
+};
+const policy = {
+    objectRef: '@test:Product',
+    fields: {
+        name: {
+            fieldName: 'name',
+            hasDefault: false,
+            defaultValue: undefined,
+            visibility: 'basic',
+            help: 'Public display name',
+            label: 'Name',
+            order: 1,
+            group: null,
+            locked: false,
+            required: true,
+        },
+        price: {
+            fieldName: 'price',
+            hasDefault: false,
+            defaultValue: undefined,
+            visibility: 'advanced',
+            help: null,
+            label: 'Price',
+            order: 2,
+            group: 'Pricing',
+            locked: false,
+            required: false,
+        },
+        published: {
+            fieldName: 'published',
+            hasDefault: true,
+            defaultValue: false,
+            visibility: 'hidden',
+            help: null,
+            label: 'Published',
+            order: 3,
+            group: null,
+            locked: false,
+            required: false,
+        },
+        metadata: {
+            fieldName: 'metadata',
+            hasDefault: false,
+            defaultValue: undefined,
+            visibility: 'basic',
+            help: null,
+            label: 'Metadata',
+            order: 4,
+            group: null,
+            locked: false,
+            required: false,
+        },
+        serverOnly: {
+            fieldName: 'serverOnly',
+            hasDefault: false,
+            defaultValue: undefined,
+            visibility: 'basic',
+            help: null,
+            label: 'Server only',
+            order: 5,
+            group: null,
+            locked: false,
+            required: false,
+        },
+    },
+};
+describe('ObjectForm selection and adapters', () => {
+    it('uses only the safe web definition × policy intersection, ordered by policy', () => {
+        expect(resolveObjectFormFields(fields, policy).map((field) => field.name)).toEqual(['name', 'price', 'published', 'metadata']);
+    });
+    it('keeps unmapped/action columns while filtering policy-hidden and static hidden columns', () => {
+        expect([
+            ...policyToVisibleColumnIds(policy, [
+                { id: 'name' },
+                { id: 'published' },
+                { id: 'computed' },
+                { id: 'actions' },
+                { id: 'metadata', hidden: true },
+            ]),
+        ]).toEqual(['name', 'computed', 'actions']);
+    });
+    it('prefers field overrides to type overrides and keeps registries isolated per app', () => {
+        const registry = new FieldInputRegistry();
+        const text = (() => ({}));
+        const field = (() => ({}));
+        registry.registerType('text', text);
+        registry.registerField('@test:Product', 'name', field);
+        expect(registry.resolve('@test:Product', 'name', 'text')).toBe(field);
+        expect(registry.resolve('@test:Product', 'other', 'text')).toBe(text);
+        expect(new FieldInputRegistry().resolve('@test:Product', 'name', 'text')).toBeUndefined();
+    });
+});
+describe('ObjectForm component', () => {
+    it('renders basic fields, omits hidden and non-formable fields, and reveals advanced groups', async () => {
+        render(ObjectFormFixture, { props: { fields, policy } });
+        expect(screen.getByRole('textbox', { name: 'Name' })).toBeInTheDocument();
+        expect(screen.getByRole('textbox', { name: 'Metadata' })).toBeInTheDocument();
+        expect(screen.queryByRole('checkbox', { name: 'Published' })).not.toBeInTheDocument();
+        expect(screen.queryByRole('spinbutton', { name: 'Price' })).not.toBeInTheDocument();
+        expect(screen.queryByRole('group', { name: 'Pricing' })).not.toBeInTheDocument();
+        expect(screen.queryByText('Server only')).not.toBeInTheDocument();
+        await userEvent.click(screen.getByRole('radio', { name: /Advanced/ }));
+        expect(screen.getByRole('group', { name: 'Pricing' })).toBeInTheDocument();
+        expect(screen.getByRole('spinbutton', { name: 'Price' })).toBeInTheDocument();
+    });
+    it('updates the bound create record through built-in text and decimal adapters', async () => {
+        render(ObjectFormFixture, { props: { fields, policy } });
+        const name = screen.getByRole('textbox', { name: 'Name' });
+        await userEvent.type(name, 'Deluxe');
+        expect(screen.getByTestId('record')).toHaveTextContent('Deluxe');
+        await userEvent.click(screen.getByRole('radio', { name: /Advanced/ }));
+        await userEvent.type(screen.getByRole('spinbutton', { name: 'Price' }), '19.5');
+        expect(screen.getByTestId('record')).toHaveTextContent('19.5');
+    });
+    it('seeds policy defaults into create records, including hidden fields', async () => {
+        render(ObjectFormFixture, { props: { fields, policy } });
+        await tick();
+        expect(screen.getByTestId('record')).toHaveTextContent('"published":false');
+    });
+    it('reapplies defaults after a host resets the bound record for a second create session', async () => {
+        render(ObjectFormFixture, { props: { fields, policy } });
+        await userEvent.type(screen.getByRole('textbox', { name: 'Name' }), 'First');
+        await userEvent.click(screen.getByRole('button', { name: 'Start another record' }));
+        await tick();
+        expect(screen.getByTestId('record')).toHaveTextContent('{"published":false}');
+    });
+    it('uses an app registry field override ahead of the built-in type adapter', () => {
+        render(ObjectFormRegistryFixture, { props: { fields, policy } });
+        expect(screen.getByRole('textbox', { name: 'Registry name' })).toBeInTheDocument();
+    });
+    it('allows a per-field snippet renderer to replace the resolved input', async () => {
+        render(ObjectFormSnippetFixture, { props: { fields, policy } });
+        const custom = screen.getByRole('textbox', { name: 'Custom product name' });
+        await userEvent.type(custom, 'Custom');
+        expect(screen.getByTestId('record')).toHaveTextContent('Custom');
+        expect(screen.queryByRole('textbox', { name: 'Name' })).not.toBeInTheDocument();
+    });
+    it('renders host actions inside the form and keeps submit validation and callbacks intact', async () => {
+        const onsubmit = vi.fn();
+        render(ObjectFormActionsFixture, { props: { fields, policy, onsubmit } });
+        const submit = screen.getByRole('button', { name: 'Save product' });
+        expect(submit).toHaveAttribute('type', 'submit');
+        await userEvent.type(screen.getByRole('textbox', { name: 'Name' }), 'Deluxe');
+        await userEvent.click(submit);
+        expect(onsubmit).toHaveBeenCalledTimes(1);
+        const metadata = screen.getByRole('textbox', {
+            name: 'Metadata',
+        });
+        metadata.value = '{not json}';
+        await fireEvent.input(metadata);
+        await userEvent.click(submit);
+        expect(onsubmit).toHaveBeenCalledTimes(1);
+    });
+    it('reports only after a synchronous host persistence acknowledgement', async () => {
+        const onsubmit = vi.fn(() => true);
+        const reportUsage = vi.fn(() => {
+            throw new Error('metrics unavailable');
+        });
+        render(ObjectFormActionsFixture, {
+            props: { fields, policy, onsubmit, usageReporter: { reportUsage } },
+        });
+        await userEvent.type(screen.getByRole('textbox', { name: 'Name' }), 'Deluxe');
+        await userEvent.click(screen.getByRole('button', { name: 'Save product' }));
+        expect(onsubmit).toHaveBeenCalledTimes(1);
+        expect(reportUsage).toHaveBeenCalledWith({
+            entries: [{ objectRef: '@test:Product', fieldName: 'name' }],
+        });
+        const metadata = screen.getByRole('textbox', {
+            name: 'Metadata',
+        });
+        metadata.value = '{not json}';
+        await fireEvent.input(metadata);
+        await userEvent.click(screen.getByRole('button', { name: 'Save product' }));
+        expect(reportUsage).toHaveBeenCalledTimes(1);
+    });
+    it('reports after an asynchronous host persistence acknowledgement', async () => {
+        const onsubmit = vi.fn(async () => true);
+        const reportUsage = vi.fn();
+        render(ObjectFormActionsFixture, {
+            props: { fields, policy, onsubmit, usageReporter: { reportUsage } },
+        });
+        await userEvent.type(screen.getByRole('textbox', { name: 'Name' }), 'Deluxe');
+        await userEvent.click(screen.getByRole('button', { name: 'Save product' }));
+        await vi.waitFor(() => expect(reportUsage).toHaveBeenCalledTimes(1));
+    });
+    it('reports the submitted values when a successful create clears its bound record', async () => {
+        const reportUsage = vi.fn();
+        render(ObjectFormActionsFixture, {
+            props: {
+                fields,
+                policy,
+                onsubmit: async () => true,
+                usageReporter: { reportUsage },
+                resetAfterSuccessfulSubmit: true,
+            },
+        });
+        await userEvent.type(screen.getByRole('textbox', { name: 'Name' }), 'Deluxe');
+        await userEvent.click(screen.getByRole('button', { name: 'Save product' }));
+        await vi.waitFor(() => expect(reportUsage).toHaveBeenCalledWith({
+            entries: [{ objectRef: '@test:Product', fieldName: 'name' }],
+        }));
+    });
+    it('keeps named void and Promise<void> persistence handlers compatible without treating either as success', async () => {
+        function legacyVoidHandler(_event) { }
+        async function legacyAsyncVoidHandler(_event) { }
+        const handlers = [
+            legacyVoidHandler,
+            legacyAsyncVoidHandler,
+        ];
+        for (const onsubmit of handlers) {
+            const reportUsage = vi.fn();
+            const view = render(ObjectFormActionsFixture, {
+                props: { fields, policy, onsubmit, usageReporter: { reportUsage } },
+            });
+            await userEvent.type(screen.getByRole('textbox', { name: 'Name' }), 'Deluxe');
+            await userEvent.click(screen.getByRole('button', { name: 'Save product' }));
+            await Promise.resolve();
+            expect(reportUsage).not.toHaveBeenCalled();
+            view.unmount();
+        }
+    });
+    it('marks a count-only text default as matched after persistence', async () => {
+        const policyWithTextDefault = {
+            ...policy,
+            fields: {
+                ...policy.fields,
+                name: {
+                    ...policy.fields.name,
+                    hasDefault: true,
+                    defaultValue: 'Default product name',
+                },
+            },
+        };
+        const reportUsage = vi.fn();
+        render(ObjectFormActionsFixture, {
+            props: {
+                fields,
+                policy: policyWithTextDefault,
+                onsubmit: () => true,
+                usageReporter: { reportUsage },
+            },
+        });
+        await tick();
+        await userEvent.click(screen.getByRole('button', { name: 'Save product' }));
+        expect(reportUsage).toHaveBeenCalledWith({
+            entries: [
+                {
+                    objectRef: '@test:Product',
+                    fieldName: 'name',
+                    matchedDefault: true,
+                },
+            ],
+        });
+    });
+    it('does not report when the host cancels, omits success, rejects, or local validation fails', async () => {
+        let attempt = 0;
+        const onsubmit = vi.fn(async () => {
+            attempt++;
+            if (attempt === 1)
+                return undefined;
+            if (attempt === 2)
+                return false;
+            throw new Error('persistence failed');
+        });
+        const reportUsage = vi.fn();
+        render(ObjectFormActionsFixture, {
+            props: { fields, policy, onsubmit, usageReporter: { reportUsage } },
+        });
+        await userEvent.type(screen.getByRole('textbox', { name: 'Name' }), 'Deluxe');
+        const submit = screen.getByRole('button', { name: 'Save product' });
+        await userEvent.click(submit);
+        await userEvent.click(submit);
+        await userEvent.click(submit);
+        await vi.waitFor(() => expect(onsubmit).toHaveBeenCalledTimes(3));
+        expect(reportUsage).not.toHaveBeenCalled();
+        const metadata = screen.getByRole('textbox', {
+            name: 'Metadata',
+        });
+        metadata.value = '{not json}';
+        await fireEvent.input(metadata);
+        await userEvent.click(submit);
+        expect(onsubmit).toHaveBeenCalledTimes(3);
+        expect(reportUsage).not.toHaveBeenCalled();
+    });
+    it('is axe-clean for its generated basic form', async () => {
+        const { container } = render(ObjectFormFixture, {
+            props: { fields, policy },
+        });
+        await expectNoA11yViolations(container);
+    });
+    it('gives separately mounted forms distinct control and help ids', () => {
+        render(ObjectFormFixture, { props: { fields, policy } });
+        render(ObjectFormFixture, { props: { fields, policy } });
+        const names = screen.getAllByRole('textbox', { name: 'Name' });
+        expect(names[0].id).not.toBe(names[1].id);
+        expect(names[0].getAttribute('aria-describedby')).not.toBe(names[1].getAttribute('aria-describedby'));
+    });
+    it('surfaces invalid JSON without emitting the stale parsed value', async () => {
+        const values = [];
+        const validity = [];
+        render(FieldInput, {
+            props: {
+                id: 'payload',
+                name: 'payload',
+                field: {
+                    name: 'payload',
+                    definition: { type: 'json' },
+                    group: null,
+                    order: null,
+                },
+                value: { ok: true },
+                required: false,
+                disabled: false,
+                onvaluechange: (value) => values.push(value),
+                onvaliditychange: (valid) => validity.push(valid),
+            },
+        });
+        const input = screen.getByRole('textbox');
+        input.value = '{bad';
+        await fireEvent.input(input);
+        expect(input).toHaveAttribute('aria-invalid', 'true');
+        expect(screen.getByRole('alert')).toHaveTextContent(/valid JSON/i);
+        expect(values).toEqual([]);
+        expect(validity.at(-1)).toBe(false);
+    });
+    it('treats an empty optional JSON input as valid and emits undefined', async () => {
+        const values = [];
+        const validity = [];
+        render(FieldInput, {
+            props: {
+                id: 'payload-empty',
+                name: 'payload',
+                field: {
+                    name: 'payload',
+                    definition: { type: 'json' },
+                    group: null,
+                    order: null,
+                },
+                value: { ok: true },
+                required: false,
+                disabled: false,
+                onvaluechange: (value) => values.push(value),
+                onvaliditychange: (valid) => validity.push(valid),
+            },
+        });
+        const input = screen.getByRole('textbox');
+        input.value = '';
+        await fireEvent.input(input);
+        expect(input).not.toHaveAttribute('aria-invalid');
+        expect(values.at(-1)).toBeUndefined();
+        expect(validity.at(-1)).toBe(true);
+    });
+    it('does not emit NaN while a numeric control holds an invalid intermediate value', async () => {
+        const values = [];
+        render(FieldInput, {
+            props: {
+                id: 'price',
+                name: 'price',
+                field: {
+                    name: 'price',
+                    definition: { type: 'decimal' },
+                    group: null,
+                    order: null,
+                },
+                value: 12.5,
+                required: false,
+                disabled: false,
+                onvaluechange: (value) => values.push(value),
+            },
+        });
+        const input = screen.getByRole('spinbutton');
+        let raw = '1e';
+        Object.defineProperty(input, 'value', {
+            configurable: true,
+            get: () => raw,
+            set: (next) => {
+                raw = next;
+            },
+        });
+        await fireEvent.input(input);
+        expect(values).toEqual([]);
+    });
+    it('does not treat a browser badInput empty number value as a deliberate clear', async () => {
+        const values = [];
+        render(FieldInput, {
+            props: {
+                id: 'quantity',
+                name: 'quantity',
+                field: {
+                    name: 'quantity',
+                    definition: { type: 'integer' },
+                    group: null,
+                    order: null,
+                },
+                value: 3,
+                required: false,
+                disabled: false,
+                onvaluechange: (value) => values.push(value),
+            },
+        });
+        const input = screen.getByRole('spinbutton');
+        let raw = '';
+        Object.defineProperty(input, 'value', {
+            configurable: true,
+            get: () => raw,
+            set: (next) => {
+                raw = next;
+            },
+        });
+        Object.defineProperty(input, 'validity', {
+            configurable: true,
+            value: { badInput: true },
+        });
+        await fireEvent.input(input);
+        expect(values).toEqual([]);
+    });
+    it('converts ISO datetimes for datetime-local editing and emits an ISO DTO', async () => {
+        const values = [];
+        render(FieldInput, {
+            props: {
+                id: 'starts-at',
+                name: 'startsAt',
+                field: {
+                    name: 'startsAt',
+                    definition: { type: 'datetime' },
+                    group: null,
+                    order: null,
+                },
+                value: '2025-01-02T03:04:00.000Z',
+                required: false,
+                disabled: false,
+                onvaluechange: (value) => values.push(value),
+            },
+        });
+        const input = document.querySelector('#starts-at');
+        if (!input)
+            throw new Error('datetime input missing');
+        input.value = '2025-01-03T04:05';
+        await fireEvent.input(input);
+        expect(values.at(-1)).toMatch(/Z$/);
+    });
+    it('uses the resolved display label for generated boolean toggle accessibility', () => {
+        render(FieldInput, {
+            props: {
+                id: 'is-published',
+                name: 'isPublished',
+                label: 'Published publicly',
+                field: {
+                    name: 'isPublished',
+                    definition: { type: 'boolean' },
+                    group: null,
+                    order: null,
+                },
+                value: false,
+                required: false,
+                disabled: false,
+                onvaluechange: () => undefined,
+            },
+        });
+        expect(screen.getByRole('checkbox', { name: 'Published publicly' })).toBeInTheDocument();
+    });
+    it('humanizes a generated boolean name when policy has no display label', () => {
+        const booleanFields = { isPublished: { type: 'boolean' } };
+        const booleanPolicy = {
+            objectRef: '@test:Boolean',
+            fields: {
+                isPublished: {
+                    fieldName: 'isPublished',
+                    hasDefault: false,
+                    defaultValue: undefined,
+                    visibility: 'basic',
+                    help: null,
+                    label: null,
+                    order: 1,
+                    group: null,
+                    locked: false,
+                    required: false,
+                },
+            },
+        };
+        render(ObjectFormFixture, {
+            props: { fields: booleanFields, policy: booleanPolicy },
+        });
+        expect(screen.getByRole('checkbox', { name: 'Is Published' })).toBeInTheDocument();
+    });
+});
+describe('ObjectForm generated source acceptance', () => {
+    const productRef = objectRef(AcceptanceProduct);
+    const eventRef = objectRef(AcceptanceEvent);
+    const productFields = {
+        name: { type: 'text', required: true },
+        price: { type: 'decimal' },
+        published: { type: 'boolean' },
+    };
+    const eventFields = {
+        title: { type: 'text', required: true },
+        startsAt: { type: 'datetime' },
+        metadata: { type: 'json' },
+    };
+    const definitions = [
+        { objectRef: productRef, fields: productFields },
+        { objectRef: eventRef, fields: eventFields },
+    ];
+    const policies = {
+        [productRef]: sourcePolicy(productRef, productFields, { published: false }),
+        [eventRef]: sourcePolicy(eventRef, eventFields),
+    };
+    function createSource(response = { policies }) {
+        const source = new ObjectFormSourceRegistry({
+            resolveBatch: vi.fn(async () => response),
+        });
+        for (const definition of definitions)
+            source.register(definition);
+        return source;
+    }
+    it('drives two REST-exposed decorated objects through one source, including create and edit semantics', async () => {
+        const productRegistration = ObjectRegistry.getClassByConstructor(AcceptanceProduct);
+        const eventRegistration = ObjectRegistry.getClassByConstructor(AcceptanceEvent);
+        expect(productRegistration?.config.api).toEqual(expect.objectContaining({
+            include: expect.arrayContaining(['create', 'update']),
+        }));
+        expect(eventRegistration?.config.api).toEqual(expect.objectContaining({
+            include: expect.arrayContaining(['create', 'update']),
+        }));
+        expect(ObjectRegistry.getFields(productRef).get('price')?.type).toBe('decimal');
+        expect(ObjectRegistry.getFields(eventRef).get('metadata')?.type).toBe('json');
+        const createView = render(ObjectFormSourceSnippetFixture, {
+            props: { source: createSource(), objectRef: productRef },
+        });
+        await vi.waitFor(() => expect(screen.getByRole('textbox', { name: 'Custom generated name' })).toBeInTheDocument());
+        expect(screen.getByTestId('record')).toHaveTextContent('"published":false');
+        await userEvent.type(screen.getByRole('textbox', { name: 'Custom generated name' }), 'deluxe');
+        expect(screen.getByTestId('record')).toHaveTextContent('"DELUXE"');
+        await expectNoA11yViolations(createView.container);
+        createView.unmount();
+        render(ObjectFormSourceFixture, {
+            props: {
+                source: createSource(),
+                objectRef: eventRef,
+                isNewRecord: false,
+                initialValue: {
+                    title: 'Existing event',
+                    startsAt: '2026-08-08T10:00',
+                    metadata: { venue: 'Hall A' },
+                },
+            },
+        });
+        await vi.waitFor(() => expect(screen.getByRole('textbox', { name: 'Title' })).toHaveValue('Existing event'));
+        expect(screen.getByRole('textbox', { name: 'Metadata' })
+            .value).toContain('Hall A');
+        await userEvent.clear(screen.getByRole('textbox', { name: 'Title' }));
+        await userEvent.type(screen.getByRole('textbox', { name: 'Title' }), 'Updated event');
+        expect(screen.getByTestId('record')).toHaveTextContent('Updated event');
+    });
+    it('fails closed with an accessible error for malformed generated action responses', async () => {
+        render(ObjectFormSourceFixture, {
+            props: {
+                source: createSource({
+                    policies: { [productRef]: { objectRef: eventRef } },
+                }),
+                objectRef: productRef,
+            },
+        });
+        await vi.waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent(/Invalid ObjectForm source response/));
+        expect(screen.queryByRole('textbox')).not.toBeInTheDocument();
+    });
+    it('fails closed with an accessible error for an unregistered objectRef', async () => {
+        render(ObjectFormSourceFixture, {
+            props: { source: createSource(), objectRef: '@test/missing:Missing' },
+        });
+        await vi.waitFor(() => expect(screen.getByRole('alert')).toHaveTextContent(/has no definition/));
+        expect(screen.queryByRole('textbox')).not.toBeInTheDocument();
+    });
+});
+describe('DataTable policy consumer acceptance', () => {
+    it('uses the real DataTable visible-column API without reviving static-hidden columns', () => {
+        render(PolicyDataTableFixture, { props: { policy } });
+        expect(screen.getByRole('columnheader', { name: 'Name' })).toBeInTheDocument();
+        expect(screen.queryByRole('columnheader', { name: 'Published' })).not.toBeInTheDocument();
+        expect(screen.queryByRole('columnheader', { name: 'Metadata' })).not.toBeInTheDocument();
+        expect(screen.getByRole('columnheader', { name: 'Computed' })).toBeInTheDocument();
+        expect(screen.getByRole('columnheader', { name: 'Actions' })).toBeInTheDocument();
+    });
+});