@dxos/react-ui-form 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/components/ObjectPicker/ObjectPicker.tsx

@@ -0,0 +1,202 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as Schema from 'effect/Schema';
+import React, { type KeyboardEvent, forwardRef, useCallback, useState } from 'react';
+
+import { type Palette, Popover, type ThemedClassName, useTranslation } from '@dxos/react-ui';
+import { Combobox } from '@dxos/react-ui-list';
+import { useSearchListResults } from '@dxos/react-ui-search';
+
+import { translationKey } from '#translations';
+
+import { Form } from '../Form';
+import { type FormFieldMap } from '../Form/FormFieldComponent';
+
+export type RefOption = {
+  id: string;
+  label: string;
+  hue?: Palette;
+};
+
+export type ObjectPickerContentProps = ThemedClassName<{
+  options: RefOption[];
+  selectedIds?: string[];
+  createOptionLabel?: [string, { ns: string | readonly string[] }];
+  createOptionIcon?: string;
+  createSchema?: Schema.Schema.AnyNoContext;
+  createInitialValuePath?: string;
+  createFieldMap?: FormFieldMap;
+  /**
+   * Persist a newly-created object given the form values. May be async (e.g.
+   * to write to a database). The Promise is awaited before the inline create
+   * form is collapsed back to the picker list, so consumers can complete
+   * follow-up work (assign the new ref to a parent slot, close the popover)
+   * before the picker UI re-renders.
+   */
+  onCreate?: (values: any) => unknown | Promise<unknown>;
+  onSelect: (id: string) => void;
+}>;
+
+const ObjectPickerContent = forwardRef<HTMLDivElement, ObjectPickerContentProps>(
+  (
+    {
+      options,
+      selectedIds,
+      createSchema,
+      createOptionLabel,
+      createOptionIcon,
+      createInitialValuePath,
+      createFieldMap,
+      onSelect,
+      onCreate,
+      ...props
+    },
+    forwardedRef,
+  ) => {
+    const { t } = useTranslation(translationKey);
+    const [showForm, setShowForm] = useState(false);
+    const [formInitialValue, setFormInitialValue] = useState<string>('');
+
+    const { results, query, handleSearch } = useSearchListResults({
+      items: options,
+    });
+
+    const handleFormSave = useCallback(
+      async (values: any) => {
+        await onCreate?.(values);
+        setShowForm(false);
+        setFormInitialValue('');
+      },
+      [onCreate],
+    );
+
+    const handleFormCancel = useCallback(() => {
+      setShowForm(false);
+      setFormInitialValue('');
+    }, []);
+
+    const handleKeyDown = useCallback(
+      (event: KeyboardEvent) => {
+        if (
+          event.key === 'Enter' &&
+          createSchema &&
+          (event.currentTarget as HTMLElement).querySelector(
+            '[role="option"][aria-selected="true"][data-value="__create__"]',
+          )
+        ) {
+          event.stopPropagation();
+          event.preventDefault();
+          // Get the current query from the input element
+          const input = (event.currentTarget as HTMLElement).querySelector('input[type="text"]') as HTMLInputElement;
+          const currentQuery = input?.value || '';
+          setFormInitialValue(currentQuery);
+          setShowForm(true);
+        }
+      },
+      [createSchema],
+    );
+
+    if (showForm && createSchema) {
+      return (
+        <Combobox.Content {...props} onKeyDownCapture={handleKeyDown} ref={forwardedRef}>
+          <Popover.Viewport>
+            <Form.Root
+              testId='create-referenced-object-form'
+              schema={createSchema}
+              defaultValues={createInitialValuePath ? { [createInitialValuePath]: formInitialValue } : {}}
+              fieldMap={createFieldMap}
+              onSave={handleFormSave}
+              onCancel={handleFormCancel}
+            >
+              <Form.Viewport>
+                <Form.Content>
+                  <Form.FieldSet />
+                  <Form.Actions />
+                </Form.Content>
+              </Form.Viewport>
+            </Form.Root>
+          </Popover.Viewport>
+          <Combobox.Arrow />
+        </Combobox.Content>
+      );
+    }
+
+    return (
+      <Combobox.Content {...props} onKeyDownCapture={handleKeyDown} ref={forwardedRef}>
+        <Combobox.Input
+          placeholder={t('ref-field-combobox-input.placeholder')}
+          autoFocus
+          value={query}
+          onValueChange={handleSearch}
+        />
+        <Combobox.List>
+          {results.map((option) => (
+            <Combobox.Item
+              key={option.id}
+              value={option.id}
+              label={option.label}
+              checked={selectedIds?.includes(option.id)}
+              onSelect={() => onSelect(option.id)}
+              classNames='flex items-center gap-2'
+            />
+          ))}
+          {createSchema && onCreate && (
+            <CreateItem
+              query={query}
+              createOptionLabel={createOptionLabel}
+              createOptionIcon={createOptionIcon ?? 'ph--plus--regular'}
+              onCreateItemSelect={(currentQuery: string) => {
+                setFormInitialValue(currentQuery);
+                setShowForm(true);
+              }}
+            />
+          )}
+        </Combobox.List>
+        <Combobox.Arrow />
+      </Combobox.Content>
+    );
+  },
+);
+
+const CreateItem = ({
+  query,
+  createOptionLabel,
+  createOptionIcon,
+  onCreateItemSelect,
+}: {
+  query: string;
+  createOptionLabel?: [string, { ns: string | readonly string[] }];
+  createOptionIcon: string;
+  onCreateItemSelect: (query: string) => void;
+}) => {
+  const { t } = useTranslation(translationKey);
+
+  const label = createOptionLabel
+    ? t(createOptionLabel[0], { ns: createOptionLabel[1].ns, text: query })
+    : t('create-option.label');
+
+  return (
+    <Combobox.Item
+      value='__create__'
+      label={label}
+      icon={createOptionIcon}
+      classNames='flex items-center gap-2'
+      closeOnSelect={false}
+      onSelect={() => {
+        onCreateItemSelect(query);
+      }}
+    />
+  );
+};
+
+ObjectPickerContent.displayName = 'ObjectPicker.Content';
+
+export const ObjectPicker = {
+  Root: Combobox.Root,
+  Portal: Combobox.Portal,
+  Trigger: Combobox.Trigger,
+  VirtualTrigger: Combobox.VirtualTrigger,
+  Content: ObjectPickerContent,
+};

package/src/components/ObjectPicker/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './ObjectPicker';

package/src/components/ObjectProperties/ObjectProperties.stories.tsx

@@ -0,0 +1,350 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Schema from 'effect/Schema';
+import React, { useEffect } from 'react';
+import { expect, userEvent, within } from 'storybook/test';
+
+import { DXN, Annotation, Filter, Obj, Ref, Tag, Type } from '@dxos/echo';
+import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/Annotation';
+import { useQuery } from '@dxos/react-client/echo';
+import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
+import { Panel } from '@dxos/react-ui';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { FactoryAnnotation, type FactoryFn } from '@dxos/schema';
+import { Pipeline } from '@dxos/types';
+
+import { translations } from '#translations';
+
+import { OBJECT_PROPERTIES_DEBUG_SYMBOL } from '../testing';
+import { ObjectProperties } from './ObjectProperties';
+
+//
+// Test-only schemas exercising a non-Tag ref-array. `Article.authors` is the
+// case the generic create flow currently fails on: the picker creates an
+// Author in the DB but never wires the new Ref into the array slot.
+//
+
+const Author = Schema.Struct({
+  name: Schema.String,
+}).pipe(
+  LabelAnnotation.set(['name']),
+  Annotation.IconAnnotation.set({ icon: 'ph--user--regular', hue: 'blue' }),
+  Type.makeObject(DXN.make('org.dxos.test.author', '0.1.0')),
+);
+type Author = Type.InstanceType<typeof Author>;
+
+const Article = Schema.Struct({
+  title: Schema.String.pipe(Schema.optional),
+  authors: Schema.Array(Ref.Ref(Author)),
+}).pipe(
+  LabelAnnotation.set(['title']),
+  Annotation.IconAnnotation.set({ icon: 'ph--article--regular', hue: 'green' }),
+  Type.makeObject(DXN.make('org.dxos.test.article', '0.1.0')),
+);
+type Article = Type.InstanceType<typeof Article>;
+
+//
+// `Note` mirrors the `Subscription.Feed` shape: a required `Ref` field
+// (`backing`) is hidden from the form via `FormInputAnnotation.set(false)`,
+// so `Obj.make(Note, values)` from the picker would reject because the form
+// values can't satisfy the schema. A `FactoryAnnotation` constructs the
+// backing object and links it at create time. `cursor` is an optional hidden
+// field included to exercise the same path for non-required hidden fields.
+//
+const NoteBacking = Schema.Struct({}).pipe(Type.makeObject(DXN.make('org.dxos.test.noteBacking', '0.1.0')));
+type NoteBacking = Type.InstanceType<typeof NoteBacking>;
+
+const Note = Schema.Struct({
+  title: Schema.String,
+  cursor: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),
+  backing: Ref.Ref(NoteBacking).pipe(FormInputAnnotation.set(false)),
+}).pipe(
+  LabelAnnotation.set(['title']),
+  Annotation.IconAnnotation.set({ icon: 'ph--note--regular', hue: 'amber' }),
+  FactoryAnnotation.set(((values: any) =>
+    Obj.make(Note, { ...values, backing: Ref.make(Obj.make(NoteBacking, {})) })) as FactoryFn),
+  Type.makeObject(DXN.make('org.dxos.test.note', '0.1.0')),
+);
+type Note = Type.InstanceType<typeof Note>;
+
+const Notebook = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  notes: Schema.Array(Ref.Ref(Note)),
+}).pipe(
+  LabelAnnotation.set(['name']),
+  Annotation.IconAnnotation.set({ icon: 'ph--notebook--regular', hue: 'amber' }),
+  Type.makeObject(DXN.make('org.dxos.test.notebook', '0.1.0')),
+);
+type Notebook = Type.InstanceType<typeof Notebook>;
+
+//
+// Stories.
+//
+
+export type ObjectPropertiesDebug = {
+  /** Live database the story is rendering against. */
+  db: ReturnType<typeof useClientStory>['space'] extends infer S ? (S extends { db: infer D } ? D : never) : never;
+  /** Object whose properties are being edited. */
+  object: Obj.Unknown;
+};
+
+const PipelineStory = () => {
+  const { space } = useClientStory();
+  const [object] = useQuery(space?.db, Filter.type(Pipeline.Pipeline));
+
+  useEffect(() => {
+    if (typeof window !== 'undefined' && space?.db && object) {
+      (window as any)[OBJECT_PROPERTIES_DEBUG_SYMBOL] = { db: space.db, object } satisfies ObjectPropertiesDebug;
+    }
+  }, [space, object]);
+
+  if (!object) {
+    return <Loading />;
+  }
+  return (
+    <Panel.Root>
+      <Panel.Content asChild>
+        <ObjectProperties object={object} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const ArticleStory = () => {
+  const { space } = useClientStory();
+  const [object] = useQuery(space?.db, Filter.type(Article));
+
+  useEffect(() => {
+    if (typeof window !== 'undefined' && space?.db && object) {
+      (window as any)[OBJECT_PROPERTIES_DEBUG_SYMBOL] = { db: space.db, object } satisfies ObjectPropertiesDebug;
+    }
+  }, [space, object]);
+
+  if (!object) {
+    return <Loading />;
+  }
+  return (
+    <Panel.Root>
+      <Panel.Content asChild>
+        <ObjectProperties object={object} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const meta = {
+  title: 'ui/react-ui-form/ObjectProperties',
+  component: ObjectProperties as any,
+  decorators: [withTheme(), withLayout({ layout: 'column' })],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<typeof PipelineStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+const pipelineDecorators = [
+  withClientProvider({
+    createIdentity: true,
+    createSpace: true,
+    types: [Pipeline.Pipeline, Tag.Tag],
+    onCreateSpace: async ({ space }) => {
+      space.db.add(Pipeline.make());
+      space.db.add(Tag.make({ label: 'Tag 1' }));
+      space.db.add(Tag.make({ label: 'Tag 2' }));
+      space.db.add(Tag.make({ label: 'Tag 3' }));
+    },
+  }),
+];
+
+const articleDecorators = [
+  withClientProvider({
+    createIdentity: true,
+    createSpace: true,
+    types: [Article, Author, Tag.Tag],
+    onCreateSpace: async ({ space }) => {
+      space.db.add(Obj.make(Article, { title: 'Untitled article', authors: [] }));
+    },
+  }),
+];
+
+const NotebookStory = () => {
+  const { space } = useClientStory();
+  const [object] = useQuery(space?.db, Filter.type(Notebook));
+
+  useEffect(() => {
+    if (typeof window !== 'undefined' && space?.db && object) {
+      (window as any)[OBJECT_PROPERTIES_DEBUG_SYMBOL] = { db: space.db, object } satisfies ObjectPropertiesDebug;
+    }
+  }, [space, object]);
+
+  if (!object) {
+    return <Loading />;
+  }
+  return (
+    <Panel.Root>
+      <Panel.Content asChild>
+        <ObjectProperties object={object} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const notebookDecorators = [
+  withClientProvider({
+    createIdentity: true,
+    createSpace: true,
+    types: [Notebook, Note, NoteBacking, Tag.Tag],
+    onCreateSpace: async ({ space }) => {
+      space.db.add(Obj.make(Notebook, { name: 'Untitled notebook', notes: [] }));
+    },
+  }),
+];
+
+/**
+ * Default Pipeline form — manual exploration. Includes the Tags picker (which
+ * is the only ref-array path that currently works end-to-end, by virtue of
+ * `Tag.Tag` being special-cased in `ObjectProperties.handleCreate`).
+ */
+export const Default: Story = {
+  render: PipelineStory,
+  decorators: pipelineDecorators,
+};
+
+/**
+ * Tag-creation play. Walks the inline create flow against the Tags picker and
+ * leaves the magazine in the post-Save state for assertions to inspect via
+ * `OBJECT_PROPERTIES_DEBUG_SYMBOL`.
+ *
+ * Expected end-state (currently passes):
+ *   - new Tag.Tag exists in the DB with `label === "PinnedTag"`
+ *   - `Obj.getMeta(object).tags` includes its DXN.
+ */
+export const CreateTagPlay: Story = {
+  render: PipelineStory,
+  decorators: pipelineDecorators,
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    const body = within(document.body);
+
+    // Tags is `Schema.Array(Ref.Ref(Tag.Tag))` and starts empty, so it renders
+    // as an "Add item" button — same shape as any other ref-array. Click it
+    // to materialise an empty slot, then open the slot's picker.
+    const addButton = await canvas.findByRole('button', { name: /add/i }, { timeout: 10_000 });
+    await userEvent.click(addButton);
+    await new Promise((resolve) => setTimeout(resolve, 250));
+
+    const comboboxes = await canvas.findAllByRole('combobox', undefined, { timeout: 10_000 });
+    await expect(comboboxes.length).toBeGreaterThan(0);
+    await userEvent.click(comboboxes[0]);
+
+    const search = await body.findByPlaceholderText(/search/i, undefined, { timeout: 5000 });
+    await userEvent.type(search, 'PinnedTag');
+
+    // The Tag picker localises the create option as "Add tag" (no text suffix
+    // — the translation has no `{{text}}` placeholder), so match on /add/.
+    const createOption = await body.findByRole('option', { name: /add/i }, { timeout: 3000 });
+    await userEvent.click(createOption);
+
+    const form = await body.findByTestId('create-referenced-object-form', undefined, { timeout: 5000 });
+    const labelInput = await within(form).findByLabelText(/^label$/i);
+    await userEvent.clear(labelInput);
+    await userEvent.type(labelInput, 'PinnedTag');
+    await userEvent.click(await within(form).findByTestId('save-button'));
+
+    // Allow async state updates to flush before the test asserts.
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  },
+};
+
+/**
+ * Ref-array creation play. Walks Add → Open → Create → Save against
+ * `Article.authors`. After the fix, the new Author should be persisted AND
+ * wired into `article.authors[0]`. Today it persists to the DB but the array
+ * slot stays empty.
+ */
+export const CreateRefArrayPlay: Story = {
+  render: ArticleStory,
+  decorators: articleDecorators,
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    const body = within(document.body);
+
+    // ObjectProperties extends Article with the synthetic `_tags` meta-tags
+    // array (labelled "Tags"), so the form has two "Add item" buttons (Tags +
+    // Authors). Pick the last one — Authors comes after Tags in rendered order.
+    const addButtons = await canvas.findAllByRole('button', { name: /add/i }, { timeout: 10_000 });
+    await userEvent.click(addButtons[addButtons.length - 1]);
+    await new Promise((resolve) => setTimeout(resolve, 250));
+
+    // Open the empty slot's combobox.
+    const comboboxes = await canvas.findAllByRole('combobox', undefined, { timeout: 10_000 });
+    await expect(comboboxes.length).toBeGreaterThan(0);
+    await userEvent.click(comboboxes[0]);
+
+    const search = await body.findByPlaceholderText(/search/i, undefined, { timeout: 5000 });
+    await userEvent.type(search, 'Ada Lovelace');
+
+    // Author has no `createOptionLabel` → option falls back to "Create".
+    const createOption = await body.findByRole('option', { name: /create/i }, { timeout: 3000 });
+    await userEvent.click(createOption);
+
+    const form = await body.findByTestId('create-referenced-object-form', undefined, { timeout: 5000 });
+    const nameInput = await within(form).findByLabelText(/^name$/i);
+    await userEvent.clear(nameInput);
+    await userEvent.type(nameInput, 'Ada Lovelace');
+    await userEvent.click(await within(form).findByTestId('save-button'));
+
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  },
+};
+
+/**
+ * Ref-array creation against a schema with a hidden required field. `Note`
+ * mirrors the shape of `Subscription.Feed`: the form omits `backing` (a
+ * required `Ref` annotated `FormInputAnnotation.set(false)`) but the schema
+ * requires it. Without `omitHiddenFormFields` + `FactoryAnnotation`, the
+ * form's validator would reject Save and the popover would never close.
+ *
+ * Expected end-state after the fix:
+ *   - new Note exists in DB with a synthesised `backing` ref
+ *   - `notebook.notes[0]` references the new Note
+ *   - the create form is gone
+ */
+export const CreateHiddenFieldPlay: Story = {
+  render: NotebookStory,
+  decorators: notebookDecorators,
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    const body = within(document.body);
+
+    // Two "Add item" buttons (Tags + Notes) — Notes comes second.
+    const addButtons = await canvas.findAllByRole('button', { name: /add/i }, { timeout: 10_000 });
+    await userEvent.click(addButtons[addButtons.length - 1]);
+    await new Promise((resolve) => setTimeout(resolve, 250));
+
+    const comboboxes = await canvas.findAllByRole('combobox', undefined, { timeout: 10_000 });
+    await expect(comboboxes.length).toBeGreaterThan(0);
+    await userEvent.click(comboboxes[0]);
+
+    const search = await body.findByPlaceholderText(/search/i, undefined, { timeout: 5000 });
+    await userEvent.type(search, 'Ideas');
+
+    const createOption = await body.findByRole('option', { name: /create/i }, { timeout: 3000 });
+    await userEvent.click(createOption);
+
+    const form = await body.findByTestId('create-referenced-object-form', undefined, { timeout: 5000 });
+    const titleInput = await within(form).findByLabelText(/^title$/i);
+    await userEvent.clear(titleInput);
+    await userEvent.type(titleInput, 'Ideas');
+    await userEvent.click(await within(form).findByTestId('save-button'));
+
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  },
+};

package/src/components/ObjectProperties/ObjectProperties.test.tsx

@@ -0,0 +1,111 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { composeStories } from '@storybook/react';
+import { act, cleanup } from '@testing-library/react';
+import { afterEach, describe, expect, test } from 'vitest';
+
+import { Filter, Obj, Tag } from '@dxos/echo';
+import { DXN, EID } from '@dxos/keys';
+
+import { OBJECT_PROPERTIES_DEBUG_SYMBOL } from '../testing';
+import * as stories from './ObjectProperties.stories';
+import { type ObjectPropertiesDebug } from './ObjectProperties.stories';
+
+const { CreateTagPlay, CreateRefArrayPlay, CreateHiddenFieldPlay } = composeStories(stories);
+
+const getDebug = (): ObjectPropertiesDebug => {
+  const debug = (window as any)[OBJECT_PROPERTIES_DEBUG_SYMBOL] as ObjectPropertiesDebug | undefined;
+  expect(debug).toBeDefined();
+  return debug!;
+};
+
+/**
+ * Refs may be stored in local (`echo:/<id>`) or qualified (`echo://<space>/<id>`) form —
+ * extract and compare object id.
+ */
+const refTargetsObject = (uri: string, objectId: string): boolean => {
+  const parsed = EID.tryParse(uri);
+  return parsed !== undefined && EID.getEntityId(parsed) === objectId;
+};
+
+describe('ObjectProperties — inline create flow', () => {
+  afterEach(async () => {
+    // Flush pending React scheduler work before teardown to prevent
+    // "window is not defined" errors from setImmediate callbacks firing after happy-dom cleanup.
+    await act(async () => {});
+    cleanup();
+    delete (window as any)[OBJECT_PROPERTIES_DEBUG_SYMBOL];
+  });
+
+  test('Tag.Tag: Create + Save persists tag and assigns it to the object', { timeout: 30_000 }, async () => {
+    await CreateTagPlay.run();
+    const { db, object } = getDebug();
+
+    // The new Tag should exist in the DB.
+    const tags = (await db.query(Filter.type(Tag.Tag)).run()) as Tag.Tag[];
+    const created = tags.find((tag) => tag.label === 'PinnedTag');
+    expect(created, 'new Tag.Tag with label "PinnedTag" should be in the database').toBeDefined();
+
+    // And `object.meta.tags` should contain a ref that resolves to that tag.
+    const meta = Obj.getMeta(object);
+    const createdId = (created as any).id as string;
+    const matched = meta.tags.some((ref) => refTargetsObject(ref.uri, createdId));
+    expect(matched, "meta.tags should contain a ref targeting the new tag's id").toBe(true);
+  });
+
+  test('non-Tag ref-array: Create + Save assigns the new ref to the array slot', { timeout: 30_000 }, async () => {
+    await CreateRefArrayPlay.run();
+    const { db, object } = getDebug();
+
+    // The new Author should exist in the DB.
+    const authors = (await db.query(Filter.type(DXN.make('org.dxos.test.author'))).run()) as any[];
+    const created = authors.find((author: any) => author.name === 'Ada Lovelace');
+    expect(created, 'new Author with name "Ada Lovelace" should be in the database').toBeDefined();
+
+    // And the article's authors array should contain a Ref to it. This is the
+    // assertion that fails before the fix — handleCreate persists the object
+    // but never wires the new ref into the array slot.
+    const article = object as any;
+    expect(article.authors ?? [], 'article.authors should contain a single Ref').toHaveLength(1);
+    const createdId = (created as any).id as string;
+    expect(
+      refTargetsObject(article.authors[0]?.uri ?? '', createdId),
+      'article.authors[0] should reference the newly-created Author',
+    ).toBe(true);
+  });
+
+  test(
+    'hidden required field via FactoryAnnotation: Create + Save closes form and assigns ref',
+    { timeout: 30_000 },
+    async () => {
+      await CreateHiddenFieldPlay.run();
+      const { db, object } = getDebug();
+
+      // The new Note should exist in the DB with the synthesised backing ref.
+      const notes = (await db.query(Filter.type(DXN.make('org.dxos.test.note'))).run()) as any[];
+      const created = notes.find((note: any) => note.title === 'Ideas');
+      expect(created, 'new Note with title "Ideas" should be in the database').toBeDefined();
+      expect(
+        (created as any).backing,
+        'FactoryAnnotation should have populated the hidden `backing` ref',
+      ).toBeDefined();
+
+      // The notebook's notes array should reference the new Note.
+      const notebook = object as any;
+      expect(notebook.notes ?? [], 'notebook.notes should contain a single Ref').toHaveLength(1);
+      const createdId = (created as any).id as string;
+      expect(
+        refTargetsObject(notebook.notes[0]?.uri ?? '', createdId),
+        'notebook.notes[0] should reference the newly-created Note',
+      ).toBe(true);
+
+      // The picker's create form should be gone.
+      expect(
+        document.querySelector('[data-testid="create-referenced-object-form"]'),
+        'create form should be dismissed after a successful save',
+      ).toBeNull();
+    },
+  );
+});