@dxos/react-ui-table 0.8.4-main.d05673bc65 → 0.8.4-main.d9fc60f731

package/src/components/TableCellEditor/TableCellEditor.tsx

@@ -25,16 +25,9 @@ import {
 import { type FieldProjection } from '@dxos/schema';
 
 import { type ModalController, type TableModel } from '../../model';
-
 import { CellValidationMessage } from './CellValidationMessage';
 import { FormCellEditor, type OnCreateHandler } from './FormCellEditor';
 
-const editorSlots = {
-  scroll: {
-    className: '!py-(--dx-grid-cell-editor-padding-block)',
-  },
-};
-
 /**
  * Option to create new object/value.
  */
@@ -250,7 +243,16 @@ export const TableCellEditor = ({
   return (
     <>
       <CellValidationMessage validationError={validationError} variant={validationVariant} __gridScope={__gridScope} />
-      <GridCellEditor extensions={extensions} getCellContent={getCellContent} onBlur={handleBlur} slots={editorSlots} />
+      <GridCellEditor
+        extensions={extensions}
+        slots={{
+          content: {
+            className: '!py-(--dx-grid-cell-editor-padding-block)',
+          },
+        }}
+        getCellContent={getCellContent}
+        onBlur={handleBlur}
+      />
     </>
   );
 };

package/src/components/index.ts

@@ -3,4 +3,3 @@
 //
 
 export * from './Table';
-export * from './TableToolbar';

package/src/components/testing.ts

@@ -6,10 +6,10 @@ import { Atom } from '@effect-atom/atom-react';
 import * as Schema from 'effect/Schema';
 import { useEffect } from 'react';
 
-import { Format, Type } from '@dxos/echo';
+import { DXN, Format, Type } from '@dxos/echo';
 import { TypeEnum } from '@dxos/echo/internal';
 import { setValue } from '@dxos/effect';
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 import { type ProjectionModel } from '@dxos/schema';
 
 export const TestSchema = Schema.Struct({
@@ -17,12 +17,7 @@ export const TestSchema = Schema.Struct({
   age: Schema.optional(Schema.Number),
   active: Schema.optional(Schema.Boolean),
   netWorth: Schema.optional(Schema.Number),
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test',
-    version: '0.1.0',
-  }),
-);
+}).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
 export type TestItem = {
   name: string;
@@ -37,10 +32,10 @@ export type TestItem = {
 export const createItemsAtom = (n: number) => {
   return Atom.make<{ data: TestItem[] }>({
     data: Array.from({ length: n }, () => ({
-      name: faker.person.fullName(),
-      age: faker.number.int({ min: 20, max: 70 }),
-      active: faker.datatype.boolean(),
-      netWorth: faker.number.int(),
+      name: random.person.fullName(),
+      age: random.number.int({ min: 20, max: 70 }),
+      active: random.datatype.boolean(),
+      netWorth: random.number.int(),
     })),
   }).pipe(Atom.keepAlive);
 };
@@ -50,10 +45,10 @@ export const createItemsAtom = (n: number) => {
  */
 export const createItems = (n: number): TestItem[] => {
   return Array.from({ length: n }, () => ({
-    name: faker.person.fullName(),
-    age: faker.number.int({ min: 20, max: 70 }),
-    active: faker.datatype.boolean(),
-    netWorth: faker.number.int(),
+    name: random.person.fullName(),
+    age: random.number.int({ min: 20, max: 70 }),
+    active: random.datatype.boolean(),
+    netWorth: random.number.int(),
   }));
 };
 

package/src/hooks/useProjectionModel.ts

@@ -5,7 +5,7 @@
 import { type Registry } from '@effect-atom/atom-react';
 import { useState } from 'react';
 
-import { JsonSchema, Type } from '@dxos/echo';
+import { Type } from '@dxos/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 import { ProjectionModel, createEchoChangeCallback } from '@dxos/schema';
 
@@ -21,13 +21,12 @@ export const useProjectionModel = <S extends Type.AnyEntity>(
   useAsyncEffect(async () => {
     if (schema && table) {
       const view = await table.view.load();
-      // For mutable schemas (EchoSchema), use the live jsonSchema reference for reactivity.
-      // For immutable schemas, create a snapshot.
-      const jsonSchema = Type.isMutable(schema) ? schema.jsonSchema : JsonSchema.toJsonSchema(schema);
+      // Use the live jsonSchema reference for reactivity.
+      const jsonSchema = schema.jsonSchema;
 
       // Always use createEchoChangeCallback since the view is ECHO-backed.
-      // Pass schema only when mutable to allow schema mutations.
-      const change = createEchoChangeCallback(view, Type.isMutable(schema) ? schema : undefined);
+      // Pass the type entity only when stored, to allow schema mutations.
+      const change = createEchoChangeCallback(view, Type.getDatabase(schema) != null ? schema : undefined);
 
       const projection = new ProjectionModel({ registry, view, baseSchema: jsonSchema, change });
       projection.normalizeView();

package/src/hooks/useTableModel.ts

@@ -44,7 +44,7 @@ export const useTableModel = <T extends TableRow = TableRow>({
   ...props
 }: UseTableModelProps<T>): TableModel<T> | undefined => {
   const registry = useContext(RegistryContext);
-  const selected = useSelected(object && Obj.getDXN(object).toString(), 'multi');
+  const selected = useSelected(object && Obj.getURI(object), 'multi');
   const initialSelection = useMemo(() => selected, [object]);
 
   const [model, setModel] = useState<TableModel<T>>();

package/src/index.ts

@@ -2,11 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { translations } from './translations';
-
 export * from './components';
 export * from './hooks';
 export * from './model';
 export * from './util';
-
-export { translations };

package/src/model/table-model.test.ts

@@ -6,12 +6,11 @@ import { Registry } from '@effect-atom/atom-react';
 import * as Schema from 'effect/Schema';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Filter, JsonSchema, Query, Type } from '@dxos/echo';
+import { DXN, Filter, JsonSchema, Query, Type } from '@dxos/echo';
 import { createEchoSchema } from '@dxos/echo/testing';
 import { ProjectionModel, ViewModel, createDirectChangeCallback } from '@dxos/schema';
 
 import { Table } from '../types';
-
 import {
   TableModel,
   type TableModelProps,
@@ -119,15 +118,10 @@ describe('TableModel', () => {
 const Test = Schema.Struct({
   title: Schema.String,
   completed: Schema.Boolean,
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test',
-    version: '0.1.0',
-  }),
-);
+}).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
 const createTableModel = (registry: Registry.Registry, props: Partial<TableModelProps> = {}): TableModel => {
-  const schema = createEchoSchema(Test);
+  const schema = createEchoSchema(Type.getSchema(Test));
   const view = ViewModel.make({
     query: Query.select(Filter.type(schema)),
     jsonSchema: schema.jsonSchema,
@@ -137,7 +131,7 @@ const createTableModel = (registry: Registry.Registry, props: Partial<TableModel
     registry,
     view,
     baseSchema: schema.jsonSchema,
-    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(schema)),
+    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(Type.getSchema(schema))),
   });
   projection.normalizeView();
   return new TableModel({

package/src/model/table-model.ts

@@ -5,13 +5,12 @@
 import { Atom, type Registry } from '@effect-atom/atom-react';
 
 import { Resource } from '@dxos/context';
-import { type Database, Format, Obj, Order, Query, type QueryAST, Ref } from '@dxos/echo';
-import { type View } from '@dxos/echo';
+import { type Database, Format, Obj, Order, Query, type QueryAST, Ref, Type, type View } from '@dxos/echo';
 import { type JsonProp, type JsonSchemaType, type Mutable, toEffectSchema } from '@dxos/echo/internal';
 import { getSnapshot } from '@dxos/echo/internal';
 import { getValue, setValue } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
-import { ObjectId } from '@dxos/keys';
+import { EntityId } from '@dxos/keys';
 import { type Label } from '@dxos/react-ui';
 import { formatForEditing, parseValue } from '@dxos/react-ui-form';
 import {
@@ -38,7 +37,7 @@ export type FieldSortType = {
 import { type SelectionMode, SelectionModel } from './selection-model';
 
 /**
- * Callback type for wrapping mutations in Obj.change().
+ * Callback type for wrapping mutations in Obj.update().
  * Contains separate callbacks for table object and row mutations.
  */
 export type TableChangeCallback<T extends TableRow> = {
@@ -53,10 +52,10 @@ export type TableChangeCallback<T extends TableRow> = {
  * Use this when the table and rows are stored in the ECHO database.
  */
 export const createEchoChangeCallback = <T extends TableRow>(table: Table.Table): TableChangeCallback<T> => ({
-  table: (mutate) => Obj.change(table, (mutableTable) => mutate(mutableTable as unknown as Table.Table)),
+  table: (mutate) => Obj.update(table, (table) => mutate(table as unknown as Table.Table)),
   row: (row, mutate) => {
     if (Obj.isObject(row)) {
-      Obj.change(row, (mutableRow) => mutate(mutableRow as T));
+      Obj.update(row, (row) => mutate(row as T));
     } else {
       mutate(row);
     }
@@ -112,7 +111,7 @@ export type TableModelProps<T extends TableRow = TableRow> = {
   projection: ProjectionModel;
   db?: Database.Database;
   /**
-   * Callbacks to wrap mutations in Obj.change().
+   * Callbacks to wrap mutations in Obj.update().
    * Use createEchoChangeCallback() for ECHO-backed objects or createDirectChangeCallback() for plain objects.
    */
   change?: TableChangeCallback<T>;
@@ -300,7 +299,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
   }
 
   public get id(): string {
-    return Obj.getDXN(this._object).toString();
+    return Obj.getURI(this._object);
   }
 
   public get view(): View.View {
@@ -524,7 +523,7 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
     }
 
     // NOTE(ZaymonFC): This is initialized with id because it's required in all schemata?
-    const draftData = { id: ObjectId.random() } as any as T;
+    const draftData = { id: EntityId.random() } as any as T;
     const validationErrors = this.validateDraftRowData(draftData);
 
     const draftRow: DraftRow<T> = {
@@ -695,8 +694,9 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
       const snapshot = { ...getSnapshot(currentRow) };
       setValue(snapshot, field.path, transformedValue);
 
-      const schema = Obj.getSchema(currentRow);
-      invariant(schema);
+      const type = Obj.getType(currentRow as unknown as Obj.Unknown);
+      invariant(type);
+      const schema = Type.getSchema(type);
 
       const validationResult = validateSchema(schema, snapshot);
       if (validationResult && validationResult.length > 0) {
@@ -894,14 +894,14 @@ export class TableModel<T extends TableRow = TableRow> extends Resource {
       if (field) {
         // Persist sort to view.query.ast
         const newQuery = baseQuery.orderBy(Order.property<any>(field.path as string, inMemorySort.direction));
-        Obj.change(view, (v) => {
-          v.query.ast = newQuery.ast as Mutable<typeof newQuery.ast>;
+        Obj.update(view, (view) => {
+          view.query.ast = newQuery.ast as Mutable<typeof newQuery.ast>;
         });
       }
     } else {
       // Clear sort from view.query.ast
-      Obj.change(view, (v) => {
-        v.query.ast = baseQuery.ast as Mutable<typeof baseQuery.ast>;
+      Obj.update(view, (view) => {
+        view.query.ast = baseQuery.ast as Mutable<typeof baseQuery.ast>;
       });
     }
 

package/src/model/table-presentation.test.ts

@@ -6,12 +6,11 @@ import { Registry } from '@effect-atom/atom-react';
 import * as Schema from 'effect/Schema';
 import { beforeEach, describe, expect, it } from 'vitest';
 
-import { Filter, JsonSchema, Query, Type } from '@dxos/echo';
+import { DXN, Filter, JsonSchema, Query, Type } from '@dxos/echo';
 import { createEchoSchema } from '@dxos/echo/testing';
 import { ProjectionModel, ViewModel, createDirectChangeCallback } from '@dxos/schema';
 
 import { Table } from '../types';
-
 import { TableModel, type TableModelProps } from './table-model';
 import { TablePresentation } from './table-presentation';
 
@@ -90,15 +89,10 @@ describe('TablePresentation', () => {
 const Test = Schema.Struct({
   title: Schema.String,
   count: Schema.Number,
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test',
-    version: '0.1.0',
-  }),
-);
+}).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
 const createTableModel = (registry: Registry.Registry, props: Partial<TableModelProps> = {}): TableModel => {
-  const schema = createEchoSchema(Test);
+  const schema = createEchoSchema(Type.getSchema(Test));
   const view = ViewModel.make({
     query: Query.select(Filter.type(schema)),
     jsonSchema: schema.jsonSchema,
@@ -108,7 +102,7 @@ const createTableModel = (registry: Registry.Registry, props: Partial<TableModel
     registry,
     view,
     baseSchema: schema.jsonSchema,
-    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(schema)),
+    change: createDirectChangeCallback(view.projection, JsonSchema.toJsonSchema(Type.getSchema(schema))),
   });
   projection.normalizeView();
   return new TableModel({ registry, object, projection, ...props });

package/src/model/table-presentation.ts

@@ -5,8 +5,7 @@
 import { Atom, type Registry } from '@effect-atom/atom-react';
 import * as Predicate from 'effect/Predicate';
 
-import { Obj } from '@dxos/echo';
-import { type View } from '@dxos/echo';
+import { Obj, type View } from '@dxos/echo';
 import { Format, TypeEnum, getValue } from '@dxos/echo/internal';
 import { cellClassesForFieldType, formatForDisplay } from '@dxos/react-ui-form';
 import {
@@ -20,7 +19,6 @@ import { VIEW_FIELD_LIMIT } from '@dxos/schema';
 import { mx } from '@dxos/ui-theme';
 
 import { tableButtons, tableControls } from '../util';
-
 import { type SelectionMode } from './selection-model';
 import { type TableModel, type TableRow } from './table-model';
 
@@ -210,8 +208,8 @@ export class TablePresentation<T extends TableRow = TableRow> {
     if (props.format === Format.TypeFormat.Ref && props.referenceSchema) {
       const targetObj = getValue(obj, field.path)?.target;
       if (targetObj) {
-        const dxn = Obj.getDXN(targetObj)?.toString();
-        cell.accessoryHtml = `<div role="none" class="absolute end-0 inset-y-0 p-(--dx-grid-cell-content-padding-block)"><dx-anchor dxn=${dxn} class="dx-button w-6 aspect-square min-h-0" data-dx-grid-action="accessory"><dx-icon icon="ph--link-simple--regular"/></dx-anchor></div>`;
+        const uri = Obj.getURI(targetObj);
+        cell.accessoryHtml = `<div role="none" class="absolute end-0 inset-y-0 p-(--dx-grid-cell-content-padding-block)"><dx-anchor uri=${uri} class="dx-button w-6 aspect-square min-h-0" data-dx-grid-action="accessory"><dx-icon icon="ph--link-simple--regular"/></dx-anchor></div>`;
       }
     }
 
@@ -474,8 +472,8 @@ export const cellClassesForRowSelection = (selected: boolean, selectionMode: Sel
 
   switch (selectionMode) {
     case 'single':
-      return ['dx-grid__cell--no-focus-unfurl !bg-current-surface hover:bg-hover-surface cursor-pointer!'];
+      return ['dx-grid__cell--no-focus-unfurl bg-current-surface! hover:bg-hover-surface cursor-pointer!'];
     case 'multiple':
-      return ['!bg-grid-cell-selected'];
+      return ['bg-grid-cell-selected!'];
   }
 };

package/src/playwright/smoke.spec.ts

@@ -5,7 +5,7 @@
 import { expect, test } from '@playwright/test';
 
 import { type DxGrid } from '@dxos/lit-grid';
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 import { setupPage, storybookUrl } from '@dxos/test-utils/playwright';
 
 import { TableManager } from './TableManager';
@@ -13,7 +13,7 @@ import { TableManager } from './TableManager';
 const storyUrl = storybookUrl('ui-react-ui-table-table--default', 9004);
 const relationsStoryUrl = storybookUrl('ui-react-ui-table-relations--default', 9004);
 
-// NOTE(ZaymonFC): This test suite relies on the faker seed being set to 0 in the story.
+// NOTE(ZaymonFC): This test suite relies on the random seed being set to 0 in the story.
 test.describe('Table', () => {
   test('Loads', async ({ browser, browserName }) => {
     test.skip(browserName === 'webkit');
@@ -310,7 +310,7 @@ test.describe('Table', () => {
       dxGridElement.scrollToColumn(6);
     });
 
-    const nonRefContent = faker.lorem.words(3);
+    const nonRefContent = random.lorem.words(3);
     const nonRefCell = dxGrid.locator('[data-dx-grid-plane="grid"] [aria-rowindex="0"][aria-colindex="6"]');
     await nonRefCell.click();
     await page.keyboard.press('Enter');

package/src/testing/useTestTableModel.ts

@@ -5,12 +5,11 @@
 import { RegistryContext } from '@effect-atom/atom-react';
 import { type RefObject, useCallback, useContext, useMemo, useRef } from 'react';
 
-import { type Database, type Type } from '@dxos/echo';
-import { isMutable } from '@dxos/echo/internal';
-import { faker } from '@dxos/random';
-import { Filter, useQuery, useSchema } from '@dxos/react-client/echo';
+import { type Database, Filter, Type } from '@dxos/echo';
+import { random } from '@dxos/random';
+import { useQuery, useType } from '@dxos/react-client/echo';
 import { useClientStory } from '@dxos/react-client/testing';
-import { useGlobalFilteredObjects } from '@dxos/react-ui-searchlist';
+import { useGlobalFilteredObjects } from '@dxos/react-ui-search';
 import { type ProjectionModel, getTypenameFromQuery } from '@dxos/schema';
 
 import { type TableController } from '../components';
@@ -18,7 +17,7 @@ import { useAddRow, useProjectionModel, useTableModel } from '../hooks';
 import { type TableModel, TablePresentation } from '../model';
 import { Table } from '../types';
 
-faker.seed(0); // NOTE(ZaymonFC): Required for smoke tests.
+random.seed(0); // NOTE(ZaymonFC): Required for smoke tests.
 
 export type TestTableModel<T extends Type.AnyObj = Type.AnyObj> = {
   schema: T | undefined;
@@ -46,14 +45,14 @@ export const useTestTableModel = <T extends Type.AnyObj = Type.AnyObj>(): TestTa
   const tables = useQuery(space?.db, Filter.type(Table.Table));
   const table = tables.at(0);
   const typename = table?.view.target?.query ? getTypenameFromQuery(table.view.target.query.ast) : undefined;
-  const schema = useSchema<T>(space?.db, typename);
+  const schema = useType<T>(space?.db, typename);
   const projection = useProjectionModel(schema, table, registry);
 
   const features = useMemo(
     () => ({
       selection: { enabled: true, mode: 'multiple' as const },
       dataEditable: true,
-      schemaEditable: schema && isMutable(schema),
+      schemaEditable: schema != null && Type.getDatabase(schema) != null,
     }),
     [schema],
   );

package/src/translations.ts

@@ -10,27 +10,25 @@ export const translations = [
   {
     'en-US': {
       [translationKey]: {
-        'object placeholder': 'New table',
-        'create object label': 'Create table',
-        'table name placeholder': 'Table name',
-        'settings title': 'Table settings',
-        'table schema label': 'Type',
-        'new schema': 'New type',
-        'continue label': 'Continue',
-        'create stack section label': 'Create table',
-        'add row label': 'Add row',
-        'create comment': 'Create thread',
-        'column action sort descending': 'Sort Descending',
-        'column action sort ascending': 'Sort Ascending',
-        'column action clear sorting': 'Clear Sorting',
-        'column action settings': 'Column Settings',
-        'column action delete': 'Delete Column',
-        'delete row label': 'Delete row',
-        'bulk delete row label': 'Delete selected rows',
-        'column deleted label': 'Column deleted',
-        'new column button label': 'Create column',
-        'create new object label': 'Create new object “{{text}}”',
-        'save view label': 'Save changes to view',
+        'object.placeholder': 'New table',
+        'create-object.label': 'Create table',
+        'table-name.placeholder': 'Table name',
+        'settings.title': 'Table settings',
+        'table-schema.label': 'Type',
+        'continue.label': 'Continue',
+        'create-stack-section.label': 'Create table',
+        'add-row.label': 'Add row',
+        'column-action-sort-descending.menu': 'Sort Descending',
+        'column-action-sort-ascending.menu': 'Sort Ascending',
+        'column-action-clear-sorting.menu': 'Clear Sorting',
+        'column-action-settings.menu': 'Column Settings',
+        'column-action-delete.menu': 'Delete Column',
+        'delete-row.label': 'Delete row',
+        'bulk-delete-row.label': 'Delete selected rows',
+        'column-deleted.label': 'Column deleted',
+        'new-column-button.label': 'Create column',
+        'create-new-object.label': 'Create new object “{{text}}”',
+        'save-view.label': 'Save changes to view',
       },
     },
   },

package/src/types/Table.ts

@@ -6,12 +6,15 @@ import * as Match from 'effect/Match';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { Annotation, JsonSchema, Obj, Ref, Type } from '@dxos/echo';
-import { View } from '@dxos/echo';
+// QueryAST is referenced indirectly through `Type.InstanceType<typeof TableSchema>`
+// (Ref.Ref(View.View) → View.View → QueryAST.Query) in the emitted .d.ts; the
+// namespace import keeps the inferred types portable.
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { DXN, Annotation, JsonSchema, Obj, QueryAST, Ref, Type, View } from '@dxos/echo';
 import { FormInputAnnotation, type JsonPath, type JsonSchemaType, LabelAnnotation } from '@dxos/echo/internal';
 import { ViewAnnotation } from '@dxos/schema';
 
-export const Table = Schema.Struct({
+const TableSchema = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
 
   view: Ref.Ref(View.View).pipe(FormInputAnnotation.set(false)),
@@ -22,19 +25,15 @@ export const Table = Schema.Struct({
     value: Schema.Number,
   }).pipe(Schema.mutable, FormInputAnnotation.set(false)),
 }).pipe(
-  Type.object({
-    typename: 'org.dxos.type.table',
-    version: '0.1.0',
-  }),
   LabelAnnotation.set(['name']),
-  ViewAnnotation.set(true),
-  Annotation.IconAnnotation.set({
-    icon: 'ph--table--regular',
-    hue: 'green',
-  }),
+  ViewAnnotation.set(['view']),
+  Annotation.IconAnnotation.set({ icon: 'ph--table--regular', hue: 'green' }),
+  Type.makeObject(DXN.make('org.dxos.type.table', '0.1.0')),
 );
 
-export interface Table extends Schema.Schema.Type<typeof Table> {}
+// TODO(wittjosiah): Try to clean up this type inference.
+export interface Table extends Type.InstanceType<typeof TableSchema> {}
+export const Table = TableSchema;
 
 type MakeProps = {
   name?: string;

package/src/util/dynamic-table.test.ts

@@ -11,13 +11,14 @@ import { type TablePropertyDefinition, getBaseSchema, makeDynamicTable } from '.
 
 describe('makeDynamicTable', () => {
   /**
-   * Base case: plain jsonSchema (not from Echo / JsonSchema.toJsonSchema). Does not exercise the path
-   * where projection or schema are reactive, so this does not reproduce the Obj.change regression.
-   * Confirms makeDynamicTable + setProperties (title) works with plain objects.
+   * Builds the Type entity from a JSON schema, then makes the table.
+   * Confirms makeDynamicTable + setProperties (title) works for the jsonSchema path.
    */
-  test('makeDynamicTable with plain jsonSchema and properties with title does not throw', () => {
+  test('makeDynamicTable from a jsonSchema with properties with title does not throw', () => {
     const registry = Registry.make();
     const jsonSchema = {
+      typename: 'com.example.type.dynamicTablePlain',
+      version: '0.1.0',
       type: 'object' as const,
       properties: {
         id: { type: 'string' as const },
@@ -31,11 +32,8 @@ describe('makeDynamicTable', () => {
     ];
 
     expect(() => {
-      const { projection, object } = makeDynamicTable({
-        registry,
-        jsonSchema,
-        properties,
-      });
+      const { type } = getBaseSchema({ jsonSchema });
+      const { projection, object } = makeDynamicTable({ registry, type, properties });
       expect(projection).toBeDefined();
       expect(object).toBeDefined();
       expect(projection.getFields().length).toBeGreaterThan(0);
@@ -43,25 +41,20 @@ describe('makeDynamicTable', () => {
   });
 
   /**
-   * Regression test for the path where jsonSchema comes from getBaseSchema(typename, properties).
-   * That path uses Echo (ViewModel.make, JsonSchema.toJsonSchema); mutations must run inside Obj.change and on a
-   * cloned schema. This test ensures that flow does not throw.
+   * Builds the Type entity from property definitions, then makes the table.
+   * Confirms makeDynamicTable + setProperties (title) works for the property-definitions path.
    */
-  test('makeDynamicTable with jsonSchema from getBaseSchema(typename, properties) and properties with title does not throw', () => {
+  test('makeDynamicTable from getBaseSchema(typename, properties) with properties with title does not throw', () => {
     const registry = Registry.make();
-    const typename = 'com.example.type.dynamic-table-test';
+    const typename = 'com.example.type.dynamicTableTest';
     const properties: TablePropertyDefinition[] = [
       { name: 'id', format: Format.TypeFormat.String },
       { name: 'name', format: Format.TypeFormat.String, title: 'Name' },
     ];
-    const { jsonSchema } = getBaseSchema({ typename, properties });
 
     expect(() => {
-      const { projection, object } = makeDynamicTable({
-        registry,
-        jsonSchema,
-        properties,
-      });
+      const { type } = getBaseSchema({ typename, properties });
+      const { projection, object } = makeDynamicTable({ registry, type, properties });
       expect(projection).toBeDefined();
       expect(object).toBeDefined();
       expect(projection.getFields().length).toBeGreaterThan(0);