@dxos/react-ui-form 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/src/components/Form/fields/TupleField.tsx

@@ -17,6 +17,7 @@ export const TupleField = ({
   type,
   readonly,
   label,
+  jsonPath,
   getStatus,
   getValue,
   onValueChange,
@@ -31,7 +32,7 @@ export const TupleField = ({
 
   return (
     <Input.Root validationValence={status}>
-      <FormFieldLabel error={error} readonly={readonly} label={label} />
+      <FormFieldLabel error={error} readonly={readonly} label={label} path={jsonPath} />
       <div className={mx('grid gap-form-gap', gridCols[binding.length - 1])}>
         {binding.map((prop) => (
           <Input.TextInput

package/src/components/Form/fields/index.ts

@@ -4,7 +4,9 @@
 
 export * from './ArrayField';
 export * from './BooleanField';
+export * from './DateField';
 export * from './GeoPointField';
+export * from './InlineRefField';
 export * from './MarkdownField';
 export * from './NumberField';
 export * from './RefField';

package/src/components/Form/index.ts

@@ -6,3 +6,6 @@ export * from './fields';
 
 export * from './Form';
 export * from './FormFieldComponent';
+export * from './FormTooltipsContext';
+export * from './meta-tags';
+export * from './Layout';

package/src/components/Form/meta-tags.test.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { describe, test } from 'vitest';
+
+import { Obj, Ref, Tag } from '@dxos/echo';
+
+import { META_TAGS_KEY, withMetaTags } from './meta-tags';
+
+// A feed-host schema whose own `tags` field is a `TagIndex` record (tagId -> objectId[]), not an
+// array — mirrors plugin-commerce `Search`, plugin-inbox `Mailbox`, plugin-feed `Subscription`.
+const TagIndexHost = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  tags: Schema.Record({ key: Schema.String, value: Schema.Array(Obj.ID) }).pipe(Schema.optional),
+});
+
+const propertyNames = (schema: Schema.Schema.AnyNoContext): string[] =>
+  SchemaAST.getPropertySignatures(schema.ast).map((property) => property.name.toString());
+
+describe('withMetaTags', () => {
+  test('keying meta-tags as `tags` collides with a schema-declared `tags` record (regression)', ({ expect }) => {
+    // The pre-fix shape: splice a `tags: Array<Ref<Tag>>` onto a schema that already declares `tags`.
+    // `Schema.extend` cannot merge an array with a record at the same key, hence the companion crash:
+    // "overlapping types at path: [\"tags\"]".
+    expect(() =>
+      Schema.Struct({ tags: Schema.Array(Ref.Ref(Tag.Tag)).pipe(Schema.optional) }).pipe(Schema.extend(TagIndexHost)),
+    ).toThrow(/tags/i);
+  });
+
+  test('splices meta-tags under `_tags` without colliding with a schema-declared `tags`', ({ expect }) => {
+    const schema = withMetaTags(TagIndexHost);
+    const names = propertyNames(schema);
+    expect(names).toContain(META_TAGS_KEY);
+    expect(names).toContain('tags');
+    expect(names).not.toContain('id');
+  });
+
+  test('still splices meta-tags onto a schema with no `tags` field', ({ expect }) => {
+    const Plain = Schema.Struct({ name: Schema.String });
+    const names = propertyNames(withMetaTags(Plain));
+    expect(names).toContain(META_TAGS_KEY);
+    expect(names).toContain('name');
+  });
+});

package/src/components/Form/meta-tags.ts

@@ -0,0 +1,33 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Ref, Tag } from '@dxos/echo';
+
+import { omitId } from './Form';
+
+/**
+ * Form-field key for the synthetic meta-tags array spliced into property/create forms.
+ *
+ * An object's tags live in `Obj.getMeta(obj).tags` (off-schema), so the form surfaces them as an
+ * extra field rather than reading the schema. The key is underscore-prefixed so it never collides
+ * with a `tags` field an object schema declares itself — e.g. a `TagIndex` record on a feed host,
+ * whose `tags` is `Record<tagId, objectId[]>`, not an array. Extending such a schema with a `tags`
+ * array threw "overlapping types at path: [\"tags\"]"; the disjoint `_tags` key avoids it. The
+ * human-facing label is restored via the `title` annotation on {@link withMetaTags}.
+ */
+export const META_TAGS_KEY = '_tags';
+
+/**
+ * Splices the synthetic meta-tags array (an object's `meta.tags`, surfaced as {@link Tag} refs) onto
+ * a schema for editing and drops `id`. Keyed by {@link META_TAGS_KEY} so it never collides with a
+ * `tags` field the schema declares itself.
+ */
+export const withMetaTags = (schema: Schema.Schema.AnyNoContext) =>
+  omitId(
+    Schema.Struct({
+      [META_TAGS_KEY]: Schema.Array(Ref.Ref(Tag.Tag)).pipe(Schema.annotations({ title: 'Tags' }), Schema.optional),
+    }).pipe(Schema.extend(schema)),
+  );

package/src/components/ObjectForm/ObjectForm.tsx

@@ -2,21 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Schema from 'effect/Schema';
 import React, { useCallback, useMemo } from 'react';
 
-import { DXN, Obj, Ref, Tag, Type } from '@dxos/echo';
+import { Obj, Ref, Tag, Type } from '@dxos/echo';
 import { type JsonPath, splitJsonPath } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
 import { HuePicker } from '@dxos/react-ui-pickers';
-import { isNonNullable } from '@dxos/util';
 
 import { translationKey } from '#translations';
 
-import { Form, type FormFieldMap, omitId } from '../Form';
+import { Form, type FormFieldMap, META_TAGS_KEY, withMetaTags } from '../Form';
 
 export type ObjectFormProps = {
-  schema: Schema.Schema.AnyNoContext;
+  type: Type.AnyEntity;
   object: Obj.Unknown;
 };
 
@@ -33,51 +31,48 @@ const createFieldMap: FormFieldMap = {
   },
 };
 
-export const ObjectForm = ({ object, schema }: ObjectFormProps) => {
+export const ObjectForm = ({ object, type }: ObjectFormProps) => {
   const db = Obj.getDatabase(object);
   const meta = Obj.getMeta(object);
-  const tags = (meta.tags ?? []).map((tag) => db?.makeRef(DXN.parse(tag))).filter(isNonNullable);
-  const values = useMemo(() => ({ tags, ...object }), [object, tags]);
-  const formSchema = useMemo(
-    () =>
-      omitId(
-        Schema.Struct({
-          tags: Schema.Array(Ref.Ref(Tag.Tag)).pipe(Schema.optional),
-        }).pipe(Schema.extend(schema)),
-      ),
-    [schema],
-  );
+  // `meta.tags` already holds `Ref<Tag>`s (materialized by the database handler).
+  const tags = [...meta.tags];
+  const values = useMemo(() => ({ [META_TAGS_KEY]: tags, ...object }), [object, tags]);
+  const formSchema = useMemo(() => withMetaTags(Type.getSchema(type)), [type]);
 
-  const handleCreate = useCallback((schema: Type.AnyEntity, values: any) => {
+  const handleCreate = useCallback((type: Type.AnyEntity, values: any) => {
     invariant(db);
-    invariant(Type.isObjectSchema(schema));
-    const newObject = db.add(Obj.make(schema, values));
+    invariant(Type.isObject(type));
+    const newObject = db.add(Obj.make(type, values));
     if (Obj.instanceOf(Tag.Tag, newObject)) {
       Obj.update(object, (object) => {
-        Obj.getMeta(object).tags = [...(Obj.getMeta(object).tags ?? []), Obj.getDXN(newObject).toString()];
+        Obj.getMeta(object).tags = [...Obj.getMeta(object).tags, Ref.make(newObject)];
       });
     }
   }, []);
 
   // TODO(wittjosiah): Use FormRootProps type.
   const handleChange = useCallback(
-    ({ tags, ...values }: any, { isValid, changed }: { isValid: boolean; changed: Record<JsonPath, boolean> }) => {
+    (
+      { [META_TAGS_KEY]: metaTags, ...values }: any,
+      { isValid, changed }: { isValid: boolean; changed: Record<JsonPath, boolean> },
+    ) => {
       if (!isValid) {
         return;
       }
 
       const changedPaths = Object.keys(changed).filter((path) => changed[path as JsonPath]) as JsonPath[];
 
-      // Handle tags separately using Obj.update.
-      const hasTagsChange = changedPaths.some((path) => splitJsonPath(path)[0] === 'tags');
+      // Handle meta-tags separately using Obj.update.
+      const hasTagsChange = changedPaths.some((path) => splitJsonPath(path)[0] === META_TAGS_KEY);
       if (hasTagsChange) {
         Obj.update(object, (object) => {
-          Obj.getMeta(object).tags = tags?.map((tag: Ref.Ref<Tag.Tag>) => tag.dxn.toString()) ?? [];
+          // Copy so later in-place form mutations don't bypass the `Obj.update` boundary.
+          Obj.getMeta(object).tags = Array.isArray(metaTags) ? [...(metaTags as Ref.Ref<Tag.Tag>[])] : [];
         });
       }
 
       // Handle other property changes.
-      const nonTagPaths = changedPaths.filter((path) => splitJsonPath(path)[0] !== 'tags');
+      const nonTagPaths = changedPaths.filter((path) => splitJsonPath(path)[0] !== META_TAGS_KEY);
       if (nonTagPaths.length > 0) {
         Obj.update(object, () => {
           for (const path of nonTagPaths) {

package/src/components/ObjectPicker/ObjectPicker.stories.tsx

@@ -7,7 +7,7 @@ import * as Schema from 'effect/Schema';
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { expect, fn, userEvent, within } from 'storybook/test';
 
-import { Filter, Obj } from '@dxos/echo';
+import { Filter, Obj, Type } from '@dxos/echo';
 import { random } from '@dxos/random';
 import { useQuery } from '@dxos/react-client/echo';
 import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
@@ -28,7 +28,7 @@ const createPerson = () =>
   });
 
 const omitId = Schema.omit<any, any, ['id']>('id');
-const personSchema = omitId(Person.Person);
+const personSchema = omitId(Type.getSchema(Person.Person));
 
 // Mock functions for testing
 const mockHandleSelect = fn();

package/src/components/ObjectPicker/ObjectPicker.tsx

@@ -23,7 +23,7 @@ export type RefOption = {
 export type ObjectPickerContentProps = ThemedClassName<{
   options: RefOption[];
   selectedIds?: string[];
-  createOptionLabel?: [string, { ns: string }];
+  createOptionLabel?: [string, { ns: string | readonly string[] }];
   createOptionIcon?: string;
   createSchema?: Schema.Schema.AnyNoContext;
   createInitialValuePath?: string;
@@ -167,7 +167,7 @@ const CreateItem = ({
   onCreateItemSelect,
 }: {
   query: string;
-  createOptionLabel?: [string, { ns: string }];
+  createOptionLabel?: [string, { ns: string | readonly string[] }];
   createOptionIcon: string;
   onCreateItemSelect: (query: string) => void;
 }) => {

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

@@ -7,7 +7,7 @@ import * as Schema from 'effect/Schema';
 import React, { useEffect } from 'react';
 import { expect, userEvent, within } from 'storybook/test';
 
-import { Annotation, Filter, Obj, Ref, Tag, Type } from '@dxos/echo';
+import { DXN, Annotation, Filter, Obj, Ref, Tag, Type } from '@dxos/echo';
 import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';
 import { useQuery } from '@dxos/react-client/echo';
 import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
@@ -30,27 +30,21 @@ import { ObjectProperties } from './ObjectProperties';
 const Author = Schema.Struct({
   name: Schema.String,
 }).pipe(
-  Type.object({
-    typename: 'org.dxos.test.author',
-    version: '0.1.0',
-  }),
   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 = Schema.Schema.Type<typeof Author>;
+type Author = Type.InstanceType<typeof Author>;
 
 const Article = Schema.Struct({
   title: Schema.String.pipe(Schema.optional),
   authors: Schema.Array(Ref.Ref(Author)),
 }).pipe(
-  Type.object({
-    typename: 'org.dxos.test.article',
-    version: '0.1.0',
-  }),
   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 = Schema.Schema.Type<typeof Article>;
+type Article = Type.InstanceType<typeof Article>;
 
 //
 // `Note` mirrors the `Subscription.Feed` shape: a required `Ref` field
@@ -60,37 +54,31 @@ type Article = Schema.Schema.Type<typeof Article>;
 // 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.object({ typename: 'org.dxos.test.note-backing', version: '0.1.0' }));
-type NoteBacking = Schema.Schema.Type<typeof NoteBacking>;
+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(
-  Type.object({
-    typename: 'org.dxos.test.note',
-    version: '0.1.0',
-  }),
   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 = Schema.Schema.Type<typeof Note>;
+type Note = Type.InstanceType<typeof Note>;
 
 const Notebook = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
   notes: Schema.Array(Ref.Ref(Note)),
 }).pipe(
-  Type.object({
-    typename: 'org.dxos.test.notebook',
-    version: '0.1.0',
-  }),
   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 = Schema.Schema.Type<typeof Notebook>;
+type Notebook = Type.InstanceType<typeof Notebook>;
 
 //
 // Stories.
@@ -288,9 +276,9 @@ export const CreateRefArrayPlay: Story = {
     const canvas = within(canvasElement);
     const body = within(document.body);
 
-    // ObjectProperties extends Article with the BaseSchema's `tags` array, so
-    // the form has two "Add item" buttons (Tags + Authors). Pick the last one
-    // — Authors comes after Tags in the rendered order.
+    // 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));

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

@@ -3,10 +3,11 @@
 //
 
 import { composeStories } from '@storybook/react';
-import { cleanup } from '@testing-library/react';
+import { act, cleanup } from '@testing-library/react';
 import { afterEach, describe, expect, test } from 'vitest';
 
 import { Filter, Obj, Tag } from '@dxos/echo';
+import { EID } from '@dxos/keys';
 
 import { OBJECT_PROPERTIES_DEBUG_SYMBOL } from '../testing';
 import * as stories from './ObjectProperties.stories';
@@ -20,8 +21,20 @@ const getDebug = (): ObjectPropertiesDebug => {
   return debug!;
 };
 
+/**
+ * Refs may be stored as legacy (`dxn:echo:@:<id>`, `dxn:echo:<space>:<id>`) or
+ * new (`echo:/<id>`, `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(() => {
+  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];
   });
@@ -35,13 +48,11 @@ describe('ObjectProperties — inline create flow', () => {
     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 DXN that resolves to that tag.
-    // Compare by the DXN's object-id tail since refs may be stored as relative
-    // (`dxn:echo:@:<id>`) or absolute (`dxn:echo:<spaceId>:<id>`) forms.
+    // 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((dxn) => dxn.endsWith(`:${createdId}`));
-    expect(matched, "meta.tags should contain a DXN ending with the new tag's id").toBe(true);
+    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 () => {
@@ -58,10 +69,9 @@ describe('ObjectProperties — inline create flow', () => {
     // 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);
-    // Compare by DXN tail to be agnostic to relative vs absolute Ref form.
     const createdId = (created as any).id as string;
     expect(
-      article.authors[0]?.dxn?.toString().endsWith(`:${createdId}`),
+      refTargetsObject(article.authors[0]?.uri ?? '', createdId),
       'article.authors[0] should reference the newly-created Author',
     ).toBe(true);
   });
@@ -87,7 +97,7 @@ describe('ObjectProperties — inline create flow', () => {
       expect(notebook.notes ?? [], 'notebook.notes should contain a single Ref').toHaveLength(1);
       const createdId = (created as any).id as string;
       expect(
-        notebook.notes[0]?.dxn?.toString().endsWith(`:${createdId}`),
+        refTargetsObject(notebook.notes[0]?.uri ?? '', createdId),
         'notebook.notes[0] should reference the newly-created Note',
       ).toBe(true);
 

package/src/components/ObjectProperties/ObjectProperties.tsx

@@ -4,21 +4,19 @@
 
 import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
 import React, { type PropsWithChildren, useCallback, useMemo } from 'react';
 
-import { DXN, Obj, Ref, Tag, Type } from '@dxos/echo';
-import { useSchema } from '@dxos/echo-react';
+import { Obj, Ref, Tag, Type } from '@dxos/echo';
+import { useType } from '@dxos/echo-react';
 import { type JsonPath, splitJsonPath } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
+import { composable, composableProps } from '@dxos/react-ui';
 import { HuePicker } from '@dxos/react-ui-pickers';
 import { FactoryAnnotation } from '@dxos/schema';
-import { composable, composableProps } from '@dxos/ui-theme';
-import { isNonNullable } from '@dxos/util';
 
 import { translationKey } from '#translations';
 
-import { Form, type FormFieldMap, omitId } from '../Form';
+import { Form, type FormFieldMap, META_TAGS_KEY, withMetaTags } from '../Form';
 
 export type ObjectPropertiesProps = PropsWithChildren<{ object: Obj.Unknown }>;
 
@@ -27,27 +25,29 @@ export const ObjectProperties = composable<HTMLDivElement, ObjectPropertiesProps
   ({ children, object, ...props }, forwardedRef) => {
     const db = Obj.getDatabase(object);
     const meta = Obj.getMeta(object);
-    const tags = (meta.tags ?? []).map((tag) => db?.makeRef(DXN.parse(tag))).filter(isNonNullable);
-    const values = useMemo(() => ({ tags, ...object }), [object, tags]);
+    // `meta.tags` already holds `Ref<Tag>`s (materialized by the database handler).
+    const tags = [...meta.tags];
+    const values = useMemo(() => ({ [META_TAGS_KEY]: tags, ...object }), [object, tags]);
 
-    // Obj.getSchema fails for database-registered (dynamic) schemas due to DXN mismatch;
-    // useSchema queries by typename which correctly resolves both static and dynamic schemas.
+    // Obj.getType fails for database-registered (dynamic) schemas due to DXN mismatch;
+    // useType queries by typename which correctly resolves both static and dynamic schemas.
     const typename = Obj.getTypename(object) ?? undefined;
-    const schemaFromRegistry = useSchema(db, typename);
-    const rawSchema = Obj.getSchema(object) ?? schemaFromRegistry;
+    const typeFromRegistry = useType(db, typename);
+    const type = Obj.getType(object) ?? typeFromRegistry;
 
     const formSchema = useMemo(() => {
       return Function.pipe(
-        rawSchema,
+        type,
         Option.fromNullable,
-        Option.map((schema) => omitId(BaseSchema.pipe(Schema.extend(schema)))),
+        Option.map((type) => Type.getSchema(type)),
+        Option.map((schema) => withMetaTags(schema)),
         Option.getOrUndefined,
       );
-    }, [rawSchema]);
+    }, [type]);
 
     // Persist a newly-created object referenced by one of the form's ref
     // fields and return it. The calling RefField wires the new Ref into its
-    // own slot's form value; for the BaseSchema `tags` array, the resulting
+    // own slot's form value; for the synthetic `_tags` array, the resulting
     // form change is then synced back to `Obj.getMeta(object).tags` by
     // `handleChange` below — so Tag.Tag follows the same generic path as any
     // other ref-array field, no type-specific branching required here.
@@ -56,11 +56,11 @@ export const ObjectProperties = composable<HTMLDivElement, ObjectPropertiesProps
     // values)` alone (e.g. types with a required ref to a backing object) can
     // declare a `FactoryAnnotation` to take over construction.
     const handleCreate = useCallback(
-      (schema: Type.AnyEntity, values: any): Obj.Unknown => {
+      (type: Type.AnyEntity, values: any): Obj.Unknown => {
         invariant(db);
-        invariant(Type.isObjectSchema(schema));
-        const factory = Option.getOrUndefined(FactoryAnnotation.get(schema));
-        const newObject = factory ? (factory(values) as Obj.Unknown) : Obj.make(schema, values);
+        invariant(Type.isObject(type));
+        const factory = Option.getOrUndefined(FactoryAnnotation.get(Type.getSchema(type)));
+        const newObject = factory ? (factory(values) as Obj.Unknown) : Obj.make(type, values);
         return db.add(newObject) as Obj.Unknown;
       },
       [db],
@@ -69,7 +69,7 @@ export const ObjectProperties = composable<HTMLDivElement, ObjectPropertiesProps
     // TODO(wittjosiah): Use FormRootProps type.
     const handleChange = useCallback(
       (
-        { tags, ...values }: Schema.Schema.Type<typeof formSchema>,
+        { [META_TAGS_KEY]: metaTags, ...values }: any,
         { isValid, changed }: { isValid: boolean; changed: Record<JsonPath, boolean> },
       ) => {
         if (!isValid) {
@@ -78,16 +78,17 @@ export const ObjectProperties = composable<HTMLDivElement, ObjectPropertiesProps
 
         const changedPaths = Object.keys(changed).filter((path) => changed[path as JsonPath]) as JsonPath[];
 
-        // Handle tags separately using Obj.update.
-        const hasTagsChange = changedPaths.some((path) => splitJsonPath(path)[0] === 'tags');
+        // Handle meta-tags separately using Obj.update.
+        const hasTagsChange = changedPaths.some((path) => splitJsonPath(path)[0] === META_TAGS_KEY);
         if (hasTagsChange) {
           Obj.update(object, (object) => {
-            Obj.getMeta(object).tags = tags?.map((tag: Ref.Ref<Tag.Tag>) => tag.dxn.toString()) ?? [];
+            // Copy so later in-place form mutations don't bypass the `Obj.update` boundary.
+            Obj.getMeta(object).tags = Array.isArray(metaTags) ? [...(metaTags as Ref.Ref<Tag.Tag>[])] : [];
           });
         }
 
         // Handle other property changes.
-        const nonTagPaths = changedPaths.filter((path) => splitJsonPath(path)[0] !== 'tags');
+        const nonTagPaths = changedPaths.filter((path) => splitJsonPath(path)[0] !== META_TAGS_KEY);
         if (nonTagPaths.length > 0) {
           Obj.update(object, () => {
             for (const path of nonTagPaths) {
@@ -141,8 +142,3 @@ const createFieldMap: FormFieldMap = {
     );
   },
 };
-
-// TODO(wittjosiah): Would be nice to control order when extending so this isn't always first/last.
-const BaseSchema = Schema.Struct({
-  tags: Schema.Array(Ref.Ref(Tag.Tag)).pipe(Schema.optional),
-});