@dxos/echo 0.8.4-main.bc674ce → 0.8.4-main.bd9b33e6c8

package/src/internal/{schema → Type}/manipulation.ts

@@ -8,7 +8,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { invariant } from '@dxos/invariant';
 import { DXN } from '@dxos/keys';
 
-import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../annotations';
+import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../Annotation';
 
 // TODO(ZaymonFC): Do this one at a time. This might be dangerous.
 export const addFieldsToSchema = (

package/src/internal/{schema → Type}/persistent-schema.ts

@@ -4,9 +4,10 @@
 
 import * as Schema from 'effect/Schema';
 
-import { TypenameSchema, VersionSchema } from '../annotations';
-import { EchoObjectSchema } from '../entities';
-import { JsonSchemaType } from '../json-schema';
+import { IconAnnotation } from '../Annotation';
+import { LabelAnnotation, TypenameSchema, VersionSchema } from '../Annotation';
+import { EchoObjectSchema } from '../Entity';
+import { JsonSchemaType } from '../JsonSchema';
 
 /**
  * Persistent representation of a schema.
@@ -19,9 +20,14 @@ export const PersistentSchema = Schema.Struct({
   jsonSchema: JsonSchemaType,
 }).pipe(
   EchoObjectSchema({
-    typename: 'dxos.org/type/Schema',
+    typename: 'org.dxos.type.schema',
     version: '0.1.0',
   }),
+  LabelAnnotation.set(['name']),
+  IconAnnotation.set({
+    icon: 'ph--database--regular',
+    hue: 'green',
+  }),
 );
 
 export interface PersistentSchema extends Schema.Schema.Type<typeof PersistentSchema> {}

package/src/internal/{README.md → common/README.md}

@@ -30,7 +30,7 @@
 
 - [x] QueryResult namespace
 - [x] SchemaRegistry interface
-- [x] Schema registry should return Type.Entity.Any instead of Schema.Schema.AnyNoContext.
+- [x] Schema registry should return Type.AnyEntity instead of Schema.Schema.AnyNoContext.
 - [x] Hypergraph interface
 - [x] Obj.getDatabase
 - [x] SpaceAction.AddObject target should be a db not a space.

package/src/internal/{api → common/api}/index.ts

@@ -12,8 +12,4 @@
  * and prevent external packages from using internals directly.
  */
 
-export * from './annotations';
-export * from './entity';
 export * from './meta';
-export * from './sorting';
-export * from './version';

package/src/internal/common/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './api';
+export * from './proxy';
+export * from './types';

package/src/internal/{proxy → common/proxy}/change.test.ts

@@ -4,9 +4,9 @@
 
 import { describe, test } from 'vitest';
 
-import * as Obj from '../../Obj';
-import * as Relation from '../../Relation';
-import { TestSchema } from '../../testing';
+import * as Obj from '../../../Obj';
+import * as Relation from '../../../Relation';
+import { TestSchema } from '../../../testing';
 
 /**
  * Tests for Obj.change context enforcement and mutator type safety.
@@ -122,8 +122,8 @@ describe('Obj.change enforcement', () => {
       // Person schema uses 'name' as label field.
       expect(Obj.getLabel(obj)).toBe('John');
 
-      Obj.change(obj, (o) => {
-        Obj.setLabel(o, 'Jane');
+      Obj.change(obj, (obj) => {
+        Obj.setLabel(obj, 'Jane');
       });
 
       // setLabel updates the name field.
@@ -140,8 +140,8 @@ describe('Obj.change enforcement', () => {
 
       // setDescription only works if schema has description annotation.
       // For schemas without it, this is a no-op.
-      Obj.change(obj, (o) => {
-        Obj.setDescription(o, 'My Description');
+      Obj.change(obj, (obj) => {
+        Obj.setDescription(obj, 'My Description');
       });
 
       // Verify setDescription doesn't throw.
@@ -153,15 +153,15 @@ describe('Obj.change enforcement', () => {
 
       expect(Obj.getMeta(obj).tags).toBeUndefined();
 
-      Obj.change(obj, (o) => {
-        Obj.addTag(o, 'tag-1');
-        Obj.addTag(o, 'tag-2');
+      Obj.change(obj, (obj) => {
+        Obj.addTag(obj, 'tag-1');
+        Obj.addTag(obj, 'tag-2');
       });
 
       expect(Obj.getMeta(obj).tags).toEqual(['tag-1', 'tag-2']);
 
-      Obj.change(obj, (o) => {
-        Obj.removeTag(o, 'tag-1');
+      Obj.change(obj, (obj) => {
+        Obj.removeTag(obj, 'tag-1');
       });
 
       expect(Obj.getMeta(obj).tags).toEqual(['tag-2']);
@@ -170,8 +170,8 @@ describe('Obj.change enforcement', () => {
     test('deleteKeys removes foreign keys by source', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (o) => {
-        const meta = Obj.getMeta(o);
+      Obj.change(obj, (obj) => {
+        const meta = Obj.getMeta(obj);
         meta.keys.push({ source: 'source-a', id: '1' });
         meta.keys.push({ source: 'source-a', id: '2' });
         meta.keys.push({ source: 'source-b', id: '3' });
@@ -179,8 +179,8 @@ describe('Obj.change enforcement', () => {
 
       expect(Obj.getMeta(obj).keys).toHaveLength(3);
 
-      Obj.change(obj, (o) => {
-        Obj.deleteKeys(o, 'source-a');
+      Obj.change(obj, (obj) => {
+        Obj.deleteKeys(obj, 'source-a');
       });
 
       expect(Obj.getMeta(obj).keys).toHaveLength(1);
@@ -190,8 +190,8 @@ describe('Obj.change enforcement', () => {
     test('setValue sets nested properties', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (o) => {
-        Obj.setValue(o, ['name'], 'Updated Name');
+      Obj.change(obj, (obj) => {
+        Obj.setValue(obj, ['name'], 'Updated Name');
       });
 
       expect(obj.name).toBe('Updated Name');
@@ -200,8 +200,8 @@ describe('Obj.change enforcement', () => {
     test('getMeta is mutable inside change and changes persist', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (o) => {
-        const meta = Obj.getMeta(o);
+      Obj.change(obj, (obj) => {
+        const meta = Obj.getMeta(obj);
         meta.tags = ['tag-1', 'tag-2'];
         meta.keys.push({ source: 'external', id: '123' });
       });
@@ -214,12 +214,12 @@ describe('Obj.change enforcement', () => {
     test('multiple mutations in single change all persist', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      Obj.change(obj, (o) => {
-        o.name = 'Name 1';
-        o.name = 'Name 2';
-        o.name = 'Name 3';
-        Obj.addTag(o, 'tag-1');
-        Obj.addTag(o, 'tag-2');
+      Obj.change(obj, (obj) => {
+        obj.name = 'Name 1';
+        obj.name = 'Name 2';
+        obj.name = 'Name 3';
+        Obj.addTag(obj, 'tag-1');
+        Obj.addTag(obj, 'tag-2');
       });
 
       // All mutations should persist.
@@ -237,9 +237,9 @@ describe('Obj.change enforcement', () => {
         notificationCount++;
       });
 
-      Obj.change(obj, (p) => {
-        p.name = 'Jane';
-        p.age = 30;
+      Obj.change(obj, (obj) => {
+        obj.name = 'Jane';
+        obj.age = 30;
       });
 
       // Should only fire one notification for all changes.
@@ -256,8 +256,8 @@ describe('Obj.change enforcement', () => {
         address: { city: 'NYC', coordinates: {} },
       });
 
-      Obj.change(obj, (p) => {
-        p.address!.state = 'NY';
+      Obj.change(obj, (obj) => {
+        obj.address!.state = 'NY';
       });
 
       expect(obj.address?.state).toBe('NY');
@@ -270,9 +270,9 @@ describe('Obj.change enforcement', () => {
         address: { city: 'NYC', coordinates: { lat: 40.7128, lng: -74.006 } },
       });
 
-      Obj.change(obj, (p) => {
-        p.address!.coordinates!.lat = 51.5074;
-        p.address!.coordinates!.lng = -0.1278;
+      Obj.change(obj, (obj) => {
+        obj.address!.coordinates!.lat = 51.5074;
+        obj.address!.coordinates!.lng = -0.1278;
       });
 
       expect(obj.address?.coordinates?.lat).toBe(51.5074);
@@ -306,8 +306,8 @@ describe('Obj.change enforcement', () => {
     test('nested Obj.change calls work correctly', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'John' });
 
-      Obj.change(obj, (p) => {
-        p.name = 'Jane';
+      Obj.change(obj, (obj) => {
+        obj.name = 'Jane';
 
         // Nested change should work (already in change context).
         Obj.change(obj, (p2) => {
@@ -323,8 +323,8 @@ describe('Obj.change enforcement', () => {
       const obj = Obj.make(TestSchema.Person, { name: 'John' });
 
       expect(() => {
-        Obj.change(obj, (p) => {
-          p.name = 'Jane';
+        Obj.change(obj, (obj) => {
+          obj.name = 'Jane';
           throw new Error('Test error');
         });
       }).toThrow('Test error');
@@ -344,8 +344,8 @@ describe('Obj.change enforcement', () => {
         fields: [{ label: 'tag1', value: 'val1' }],
       });
 
-      Obj.change(obj, (p) => {
-        p.fields!.push({ label: 'tag2', value: 'val2' });
+      Obj.change(obj, (obj) => {
+        obj.fields!.push({ label: 'tag2', value: 'val2' });
       });
 
       expect(obj.fields).toHaveLength(2);
@@ -362,8 +362,8 @@ describe('Obj.change enforcement', () => {
       });
 
       let popped: any;
-      Obj.change(obj, (p) => {
-        popped = p.fields!.pop();
+      Obj.change(obj, (obj) => {
+        popped = obj.fields!.pop();
       });
 
       expect(popped.label).toBe('b');
@@ -380,8 +380,8 @@ describe('Obj.change enforcement', () => {
         ],
       });
 
-      Obj.change(obj, (p) => {
-        p.fields!.splice(1, 1, { label: 'x', value: 'x' });
+      Obj.change(obj, (obj) => {
+        obj.fields!.splice(1, 1, { label: 'x', value: 'x' });
       });
 
       expect(obj.fields).toHaveLength(3);
@@ -429,8 +429,8 @@ describe('Obj.change enforcement', () => {
     test('delete property within Obj.change', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'John', age: 25 });
 
-      Obj.change(obj, (p) => {
-        delete p.age;
+      Obj.change(obj, (obj) => {
+        delete obj.age;
       });
 
       expect(obj.age).toBeUndefined();
@@ -455,8 +455,8 @@ describe('Obj.change enforcement', () => {
         [Relation.Target]: target,
       });
 
-      Relation.change(rel, (r) => {
-        const meta = Relation.getMeta(r);
+      Relation.change(rel, (obj) => {
+        const meta = Relation.getMeta(obj);
         meta.tags = ['rel-tag'];
         meta.keys.push({ source: 'rel-source', id: 'rel-key' });
       });
@@ -473,14 +473,14 @@ describe('Obj.change enforcement', () => {
         [Relation.Target]: target,
       });
 
-      Relation.change(rel, (r) => {
-        Relation.addTag(r, 'important');
+      Relation.change(rel, (obj) => {
+        Relation.addTag(obj, 'important');
       });
 
       expect(Relation.getMeta(rel).tags).toContain('important');
 
-      Relation.change(rel, (r) => {
-        Relation.removeTag(r, 'important');
+      Relation.change(rel, (obj) => {
+        Relation.removeTag(obj, 'important');
       });
 
       expect(Relation.getMeta(rel).tags).not.toContain('important');
@@ -494,8 +494,8 @@ describe('Obj.change enforcement', () => {
 
       // Direct assignment of root ECHO objects (created with Obj.make) is not allowed.
       expect(() => {
-        Obj.change(obj, (o) => {
-          o.other = other;
+        Obj.change(obj, (obj) => {
+          obj.other = other;
         });
       }).toThrow(/Object references must be wrapped with `Ref\.make`/);
     });
@@ -504,14 +504,14 @@ describe('Obj.change enforcement', () => {
       const obj = Obj.make(TestSchema.Expando, {});
 
       // Assign a plain object (not created with Obj.make).
-      Obj.change(obj, (o) => {
-        o.nested = { value: 'initial' };
+      Obj.change(obj, (obj) => {
+        obj.nested = { value: 'initial' };
       });
       expect(obj.nested.value).toBe('initial');
 
       // Modify plain nested object through parent's change context.
-      Obj.change(obj, (o) => {
-        o.nested.value = 'modified';
+      Obj.change(obj, (obj) => {
+        obj.nested.value = 'modified';
       });
       expect(obj.nested.value).toBe('modified');
     });

package/src/internal/{proxy → common/proxy}/handler.test.ts

@@ -8,8 +8,8 @@ import { describe, expect, test } from 'vitest';
 
 import { isNode } from '@dxos/util';
 
-import { TestSchema, updateCounter } from '../../testing';
-import { createObject } from '../object';
+import { TestSchema, updateCounter } from '../../../testing';
+import { createObject } from '../../Obj';
 import { ATTR_META } from '../types';
 
 import { makeObject } from './make-object';

package/src/internal/{proxy → common/proxy}/json-serializer.ts

@@ -7,16 +7,19 @@ import { invariant } from '@dxos/invariant';
 import { DXN } from '@dxos/keys';
 import { deepMapValues } from '@dxos/util';
 
+import { Ref } from '../../Ref';
 import {
+  ATTR_META,
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
   ATTR_SELF_DXN,
+  ATTR_TYPE,
+  MetaId,
   RelationSourceDXNId,
   RelationTargetDXNId,
   SelfDXNId,
-} from '../entities';
-import { Ref } from '../ref';
-import { ATTR_META, ATTR_TYPE, MetaId, TypeId } from '../types';
+  TypeId,
+} from '../types';
 
 /**
  * Attaches a toJSON method to the object for typed serialization.

package/src/internal/{proxy → common/proxy}/make-object.ts

@@ -6,8 +6,8 @@ import type * as Schema from 'effect/Schema';
 
 import { ObjectId } from '@dxos/keys';
 
-import { getTypeAnnotation } from '../annotations';
-import { type AnyProperties, KindId, MetaId, type ObjectMeta, ObjectMetaSchema } from '../types';
+import { getTypeAnnotation } from '../../Annotation';
+import { type AnyProperties, KindId, MetaId, type ObjectMeta, ObjectMetaSchema, ParentId } from '../types';
 
 import { defineHiddenProperty } from './define-hidden-property';
 import { attachTypedJsonSerializer } from './json-serializer';
@@ -35,7 +35,8 @@ export const makeObject: {
     meta?: ObjectMeta,
   ): T;
 } = <T extends AnyProperties>(schema: Schema.Schema<T, any>, obj: MakeObjectProps<T>, meta?: ObjectMeta): T => {
-  return createReactiveObject<T>({ ...obj } as T, meta, schema);
+  // Use Object.assign to copy symbol properties (like ParentId) that spread operator doesn't copy.
+  return createReactiveObject<T>(Object.assign({}, obj) as T, meta, schema);
 };
 
 const createReactiveObject = <T extends AnyProperties>(obj: T, meta?: ObjectMeta, schema?: Schema.Schema<T>): T => {
@@ -47,12 +48,21 @@ const createReactiveObject = <T extends AnyProperties>(obj: T, meta?: ObjectMeta
     throw new Error('Schema is required for reactive objects. Use Atom for untyped reactive state.');
   }
 
+  // Extract parent from props (can be set via [Obj.Parent]).
+  const parent = (obj as any)[ParentId];
+  if (parent !== undefined) {
+    delete (obj as any)[ParentId];
+  }
+
   const annotation = getTypeAnnotation(schema);
   if (annotation) {
     setIdOnTarget(obj);
     defineHiddenProperty(obj, KindId, annotation.kind);
   }
   initMeta(obj, meta);
+  if (parent !== undefined) {
+    defineHiddenProperty(obj, ParentId, parent);
+  }
   prepareTypedTarget(obj, schema);
   attachTypedJsonSerializer(obj);
   const proxy = createProxy<T>(obj, TypedReactiveHandler.instance);

package/src/internal/{proxy → common/proxy}/reactive.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type RefTypeId } from '../ref/ref';
+import { type RefTypeId } from '../../Ref/ref';
 
 import { getProxyTarget } from './proxy-utils';
 import { ChangeId, EventId } from './symbols';

package/src/internal/{proxy → common/proxy}/schema.test.ts

@@ -6,14 +6,14 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { describe, expect, test } from 'vitest';
 
-import { createEchoSchema } from '../../testing';
-import { PropertyMeta, getPropertyMetaAnnotation, getTypeAnnotation } from '../annotations';
-import { EchoObjectSchema } from '../entities';
+import { createEchoSchema } from '../../../testing';
+import { PropertyMeta, getPropertyMetaAnnotation, getTypeAnnotation } from '../../Annotation';
+import { EchoObjectSchema } from '../../Entity';
 
 // TODO(dmaretskyi): Comment.
 const EmptySchemaType = Schema.Struct({}).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Empty',
+    typename: 'com.example.type.empty',
     version: '0.1.0',
   }),
 );
@@ -27,7 +27,7 @@ describe('dynamic schema', () => {
       field2: Schema.Boolean,
     }).pipe(
       EchoObjectSchema({
-        typename: 'example.com/type/Test',
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -44,7 +44,7 @@ describe('dynamic schema', () => {
       field1: Schema.String,
     }).pipe(
       EchoObjectSchema({
-        typename: 'example.com/type/Test',
+        typename: 'com.example.type.test',
         version: '0.1.0',
       }),
     );
@@ -95,7 +95,7 @@ describe('dynamic schema', () => {
     registered.updateFields({ field3: Schema.Boolean });
     registered.removeFields(['field2']);
     expect(getTypeAnnotation(registered)).to.deep.contain({
-      typename: 'example.com/type/Empty',
+      typename: 'com.example.type.empty',
       version: '0.1.0',
     });
     expect(getPropertyMetaAnnotation(registered.getProperties()[0], metaNamespace)).to.deep.eq(metaInfo);
@@ -111,7 +111,7 @@ describe('dynamic schema', () => {
     });
 
     // First update.
-    const newTypename1 = 'example.com/type/Individual';
+    const newTypename1 = 'com.example.type.individual';
     registered.updateTypename(newTypename1);
 
     // Basic typename update checks.
@@ -132,13 +132,13 @@ describe('dynamic schema', () => {
     expect(nameMeta).toEqual({ maxLength: 10 });
 
     // Second update to ensure multiple updates work.
-    const newTypename2 = 'example.com/type/Person';
+    const newTypename2 = 'com.example.type.person';
     registered.updateTypename(newTypename2);
     expect(registered.typename).toBe(newTypename2);
     expect(registered.jsonSchema.$id).toBe(`dxn:type:${newTypename2}`);
     expect(registered.jsonSchema.typename).toBe(newTypename2);
     expect(getTypeAnnotation(registered)).to.deep.contain({
-      typename: 'example.com/type/Person',
+      typename: 'com.example.type.person',
       version: '0.1.0',
     });
   });

package/src/internal/{proxy → common/proxy}/typed-handler.test.ts

@@ -5,10 +5,10 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { TestSchema } from '../../testing';
-import { EchoObjectSchema } from '../entities';
-import { setValue } from '../object';
-import { Ref } from '../ref';
+import { TestSchema } from '../../../testing';
+import { EchoObjectSchema } from '../../Entity';
+import { setValue } from '../../Obj';
+import { Ref } from '../../Ref';
 import { foreignKey, getMeta } from '../types';
 
 import { makeObject } from './make-object';
@@ -40,10 +40,10 @@ describe('complex schema validations', () => {
 
   test('references', () => {
     const Foo = Schema.Struct({ field: Schema.String }).pipe(
-      EchoObjectSchema({ typename: 'example.com/type/Foo', version: '0.1.0' }),
+      EchoObjectSchema({ typename: 'com.example.type.foo', version: '0.1.0' }),
     );
     const Bar = Schema.Struct({ fooRef: Ref(Foo) }).pipe(
-      EchoObjectSchema({ typename: 'example.com/type/Bar', version: '0.1.0' }),
+      EchoObjectSchema({ typename: 'com.example.type.bar', version: '0.1.0' }),
     );
     const field = 'hello';
     expect(() => makeObject(Bar, { fooRef: { id: '1', field } as any })).to.throw();

package/src/internal/{proxy → common/proxy}/typed-handler.ts

@@ -11,9 +11,8 @@ import { Event } from '@dxos/async';
 import { inspectCustom } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 
-import { getSchemaDXN } from '../annotations';
-import { ObjectDeletedId } from '../entities';
-import { SchemaId, TypeId } from '../types';
+import { getSchemaDXN } from '../../Annotation';
+import { ObjectDeletedId, ParentId, SchemaId, TypeId } from '../types';
 
 import { executeChange, isInChangeContext, queueNotification } from './change-context';
 import { defineHiddenProperty } from './define-hidden-property';
@@ -47,6 +46,7 @@ type ProxyTarget = {
    * Schema for the root.
    */
   [SchemaId]: Schema.Schema.AnyNoContext;
+  [ParentId]?: any;
 
   /**
    * For modifications.
@@ -320,6 +320,10 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
   ): { echoRoot: object; preparedValue: any } {
     const echoRoot = getEchoRoot(target);
 
+    if (prop === ParentId) {
+      return { echoRoot, preparedValue: value }; // Short-circuit for parent assignment.
+    }
+
     // Check for cycles before assignment.
     if (isValidProxyTarget(value) || isProxy(value)) {
       if (wouldCreateCycle(echoRoot, value)) {
@@ -363,6 +367,9 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
   }
 
   private _validateValue(target: any, prop: string | symbol, value: any) {
+    if (prop === ParentId) {
+      return value;
+    }
     const schema = SchemaValidator.getTargetPropertySchema(target, prop);
     const _ = Schema.asserts(schema)(value);
     if (isValidProxyTarget(value)) {

package/src/internal/{proxy → common/proxy}/typed-object.test.ts

@@ -6,7 +6,7 @@ import * as Schema from 'effect/Schema';
 import type * as Types from 'effect/Types';
 import { describe, expect, test } from 'vitest';
 
-import { EchoObjectSchema } from '../entities';
+import { EchoObjectSchema } from '../../Entity';
 import { getSchema } from '../types';
 
 import { makeObject } from './make-object';
@@ -16,7 +16,7 @@ const Organization = Schema.Struct({
   name: Schema.String,
 }).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Organization',
+    typename: 'com.example.type.organization',
     version: '0.1.0',
   }),
 );
@@ -34,7 +34,7 @@ const Contact = Schema.Struct(
 ).pipe(
   Schema.partial,
   EchoObjectSchema({
-    typename: 'example.com/type/Person',
+    typename: 'com.example.type.person',
     version: '0.1.0',
   }),
 );
@@ -101,7 +101,7 @@ describe('EchoObjectSchema class DSL', () => {
         meta: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
       }).pipe(
         EchoObjectSchema({
-          typename: 'dxos.org/type/FunctionTrigger',
+          typename: 'org.dxos.type.function-trigger',
           version: '0.1.0',
         }),
       );

package/src/internal/{types → common/types}/base.ts

@@ -14,12 +14,12 @@ import { type ATTR_META, type ObjectMeta } from './meta';
  * NOTE: This describes the base type for all database objects.
  * It is stricter than `T extends {}` or `T extends object`.
  */
-// TODO(burdon): Make internal.
 // TODO(burdon): Prefer Record<string, unknown>.
 export type AnyProperties = Record<string, any>;
 
 /**
  * Canonical type for all ECHO entities (objects and relations).
+ * @depreacted Remove, use Entity.Unknown instead.
  */
 // TODO(wittjosiah): Remove. Prefer higher level types (e.g. Entity.Unknown).
 export interface AnyEntity {

package/src/internal/{types → common/types}/entity.ts

@@ -43,10 +43,10 @@ export enum EntityKind {
 export const EntityKindSchema = Schema.Enums(EntityKind);
 
 /**
- * Typename for generic object references (Type.Obj / Type.Ref(Type.Obj)).
+ * Typename for generic object references (Type.Obj / Ref.Ref(Obj.Unknown)).
  * Used when referencing any object without a specific schema.
  */
-export const ANY_OBJECT_TYPENAME = 'dxos.org/schema/AnyObject';
+export const ANY_OBJECT_TYPENAME = 'org.dxos.schema.any-object';
 
 /**
  * Version for generic object references.

package/src/internal/{types → common/types}/index.ts

@@ -5,5 +5,6 @@
 export * from './base';
 export * from './entity';
 export * from './meta';
+export * from './model-symbols';
 export * from './typename';
 export * from './version';