@dxos/echo 0.8.4-main.69d29f4 → 0.8.4-main.6fa680abb7

package/src/internal/Obj/snapshot.ts

@@ -0,0 +1,105 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { assertArgument } from '@dxos/invariant';
+import { deepMapValues } from '@dxos/util';
+
+import {
+  KindId,
+  MetaId,
+  ObjectDatabaseId,
+  ObjectDeletedId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  SchemaId,
+  SelfDXNId,
+  SnapshotKindId,
+  TypeId,
+} from '../common/types';
+
+/**
+ * Copy a Symbol-keyed property from source to target if it has a defined value.
+ * Handles both plain objects (symbol in source) and proxies where get returns a value
+ * but has/in returns false (e.g. ObjectDatabaseId on echo-db proxies).
+ * Optional transform clones or mutates the value before assignment (e.g. for MetaId).
+ */
+const copySymbolProperty = (
+  source: any,
+  target: any,
+  symbol: symbol,
+  transform?: (value: unknown) => unknown,
+): void => {
+  let value: unknown;
+  // Echo-db proxy getters (e.g. RelationSourceId, RelationTargetId) can throw in certain states.
+  try {
+    value = source[symbol];
+  } catch {
+    return;
+  }
+  if (value !== undefined) {
+    const finalValue = transform ? transform(value) : value;
+    Object.defineProperty(target, symbol, {
+      value: finalValue,
+      writable: false,
+      enumerable: false,
+      configurable: false,
+    });
+  }
+};
+
+/**
+ * Returns an immutable snapshot of the reactive object.
+ * The snapshot is branded with SnapshotKindId (not KindId).
+ */
+export const getSnapshot = <T extends object>(obj: T): T => {
+  assertArgument(typeof obj === 'object' && obj !== null && KindId in obj, 'obj', 'must be an entity');
+
+  const snapshot = deepMapValues(obj, (value, recurse) => {
+    // Do not recurse on references (but do recurse on arrays).
+    if (
+      typeof value === 'object' &&
+      value !== null &&
+      Object.getPrototypeOf(value) !== Object.prototype &&
+      !Array.isArray(value)
+    ) {
+      return value;
+    }
+
+    return recurse(value);
+  }) as any;
+
+  // Add SnapshotKindId brand based on original KindId.
+  if (obj != null && typeof obj === 'object' && KindId in obj) {
+    snapshot[SnapshotKindId] = (obj as any)[KindId];
+  }
+
+  // Preserve Symbol-keyed properties that are important for type introspection.
+  // These are not copied by deepMapValues since Object.keys() doesn't include symbols.
+  const source = obj as any;
+
+  // Type introspection symbols.
+  copySymbolProperty(source, snapshot, TypeId);
+  copySymbolProperty(source, snapshot, SchemaId);
+  copySymbolProperty(source, snapshot, SelfDXNId);
+
+  // Database reference (required for Obj.getDatabase to work on snapshots).
+  copySymbolProperty(source, snapshot, ObjectDatabaseId);
+  copySymbolProperty(source, snapshot, ObjectDeletedId);
+
+  // Metadata symbol. Copy arrays so the snapshot is not affected by mutations to the live meta's keys/tags.
+  copySymbolProperty(source, snapshot, MetaId, (meta: any) => ({
+    keys: [...(meta?.keys ?? [])],
+    tags: [...(meta?.tags ?? [])],
+  }));
+
+  // Relation endpoint symbols.
+  copySymbolProperty(source, snapshot, RelationSourceDXNId);
+  copySymbolProperty(source, snapshot, RelationTargetDXNId);
+  copySymbolProperty(source, snapshot, RelationSourceId);
+  copySymbolProperty(source, snapshot, RelationTargetId);
+
+  return Object.freeze(snapshot) as T;
+};

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

@@ -6,13 +6,13 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { describe, expect, test } from 'vitest';
 
-import { EchoObjectSchema } from '../entities';
+import { EchoObjectSchema } from '../Entity';
 
 const Organization = Schema.Struct({
   name: Schema.String,
 }).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Organization',
+    typename: 'com.example.type.organization',
     version: '0.1.0',
   }),
 );
@@ -25,7 +25,7 @@ describe('EchoObjectSchema DSL', () => {
   });
 
   test('static typename accessor', async () => {
-    expect(Organization.typename).to.eq('example.com/type/Organization');
+    expect(Organization.typename).to.eq('com.example.type.organization');
   });
 
   test('expect schema', async () => {

package/src/internal/{object → Obj}/typed-object.ts

@@ -4,8 +4,8 @@
 
 import type * as Schema from 'effect/Schema';
 
-import { type TypeMeta } from '../annotations';
-import { type AnyEntity } from '../types';
+import { type TypeMeta } from '../Annotation';
+import { type AnyEntity } from '../common/types';
 
 /**
  * Definition for an object type that can be stored in an ECHO database.
@@ -14,7 +14,7 @@ import { type AnyEntity } from '../types';
  *
  * In contrast to {@link EchoSchema} this definition is not recorded in the database.
  *
- * @deprecated Use `Type.Obj.Any` from `@dxos/echo` instead.
+ * @deprecated Use `Type.AnyObj` from `@dxos/echo` instead.
  */
 export interface TypedObject<A = any, I = any> extends TypeMeta, Schema.Schema<A, I> {}
 
@@ -22,7 +22,7 @@ export interface TypedObject<A = any, I = any> extends TypeMeta, Schema.Schema<A
  * Typed object that could be used as a prototype in class definitions.
  * This is an internal API type.
  *
- * @deprecated Use `Type.Obj.Any` from `@dxos/echo` instead.
+ * @deprecated Use `Type.AnyObj` from `@dxos/echo` instead.
  */
 export interface TypedObjectPrototype<A = any, I = any> extends TypedObject<A, I> {
   /** Type constructor. */

package/src/internal/{ref → Ref}/ref-array.ts

@@ -5,7 +5,7 @@
 import { type ObjectId } from '@dxos/keys';
 import { isNonNullable } from '@dxos/util';
 
-import { type AnyEntity } from '../types';
+import { type AnyEntity } from '../common/types';
 
 import { Ref } from './ref';
 

package/src/internal/{ref → Ref}/ref.test.ts

@@ -7,8 +7,8 @@ import { describe, expect, test } from 'vitest';
 
 import { DXN, ObjectId } from '@dxos/keys';
 
-import { EchoObjectSchema, getObjectDXN } from '../entities';
-import { createObject } from '../object';
+import { EchoObjectSchema, getObjectDXN } from '../Entity';
+import { createObject } from '../Obj';
 
 import { Ref, getReferenceAst } from './ref';
 
@@ -16,7 +16,7 @@ const Task = Schema.Struct({
   title: Schema.optional(Schema.String),
 }).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Task',
+    typename: 'com.example.type.task',
     version: '0.1.0',
   }),
 );
@@ -29,7 +29,7 @@ const Contact = Schema.Struct({
   tasks: Schema.Array(Ref(Task)),
 }).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Person',
+    typename: 'com.example.type.person',
     version: '0.1.0',
   }),
 );

package/src/internal/{ref → Ref}/ref.ts

@@ -3,8 +3,11 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Equal from 'effect/Equal';
+import * as Hash from 'effect/Hash';
 import * as Option from 'effect/Option';
 import * as ParseResult from 'effect/ParseResult';
+import * as Pipeable from 'effect/Pipeable';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import type * as Types from 'effect/Types';
@@ -16,9 +19,9 @@ import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
 
 import * as Database from '../../Database';
-import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../annotations';
-import { type JsonSchemaType } from '../json-schema';
-import type { AnyEntity, AnyProperties } from '../types';
+import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../Annotation';
+import { type JsonSchemaType } from '../JsonSchema';
+import type { AnyEntity, AnyProperties } from '../common/types';
 
 /**
  * The `$id` and `$ref` fields for an ECHO reference schema.
@@ -130,7 +133,7 @@ export const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Sc
  * Represents materialized reference to a target.
  * This is the data type for the fields marked as ref.
  */
-export interface Ref<T> {
+export interface Ref<T> extends Pipeable.Pipeable {
   /**
    * Target object DXN.
    */
@@ -459,6 +462,21 @@ export class RefImpl<T> implements Ref<T> {
 
   [RefTypeId] = refVariance;
 
+  /**
+   * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)
+   * to deduplicate Ref instances that point to the same object.
+   * ECHO proxies return new RefImpl instances on every property access,
+   * so without this, each access would create a separate cache entry.
+   */
+  [Hash.symbol](): number {
+    return Hash.hash(this.#dxn.toString());
+  }
+
+  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */
+  [Equal.symbol](that: Equal.Equal): boolean {
+    return that instanceof RefImpl && this.#dxn.toString() === that.dxn.toString();
+  }
+
   /**
    * Internal method to set the resolver.
    *
@@ -474,6 +492,11 @@ export class RefImpl<T> implements Ref<T> {
   _getSavedTarget(): T | undefined {
     return this.#target;
   }
+
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return Pipeable.pipeArguments(this, arguments);
+  }
 }
 
 /**

package/src/internal/{schema → Type}/compose.test.ts

@@ -5,10 +5,10 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { FieldPath } from '../annotations';
-import { EchoObjectSchema } from '../entities';
-import { FormatAnnotation, TypeFormat } from '../formats';
-import { ECHO_ANNOTATIONS_NS_KEY, toJsonSchema } from '../json-schema';
+import { FieldPath } from '../Annotation';
+import { EchoObjectSchema } from '../Entity';
+import { FormatAnnotation, TypeFormat } from '../Format';
+import { ECHO_ANNOTATIONS_NS_KEY, toJsonSchema } from '../JsonSchema';
 
 import { composeSchema } from './compose';
 
@@ -17,7 +17,7 @@ describe('schema composition', () => {
     const BaseType = Schema.Struct({
       name: Schema.String,
       email: Schema.String,
-    }).pipe(EchoObjectSchema({ typename: 'example.com/Person', version: '0.1.0' }));
+    }).pipe(EchoObjectSchema({ typename: 'com.example.person', version: '0.1.0' }));
 
     const OverlaySchema = Schema.Struct({
       email: Schema.String.pipe(FieldPath('$.email'), FormatAnnotation.set(TypeFormat.Email)),

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

@@ -6,7 +6,7 @@ import type * as Types from 'effect/Types';
 
 import { invariant } from '@dxos/invariant';
 
-import { type JsonSchemaType } from '../json-schema';
+import { type JsonSchemaType } from '../JsonSchema';
 
 /**
  * Creates a composite schema from the source and projection schemas.

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

@@ -8,11 +8,12 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { invariant } from '@dxos/invariant';
 import { type ObjectId } from '@dxos/keys';
 
-import { type SchemaMeta, SchemaMetaSymbol, type TypeAnnotation, getTypeAnnotation } from '../annotations';
-import { type JsonSchemaType, toEffectSchema, toJsonSchema } from '../json-schema';
-import { type TypedObject, type TypedObjectPrototype, getSnapshot } from '../object';
-import { ChangeId } from '../proxy';
-import { EntityKind, SchemaKindId } from '../types';
+import type * as Type from '../../Type';
+import { type SchemaMeta, SchemaMetaSymbol, type TypeAnnotation, getTypeAnnotation } from '../Annotation';
+import { type JsonSchemaType, toEffectSchema, toJsonSchema } from '../JsonSchema';
+import { type TypedObject, type TypedObjectPrototype, getSnapshot } from '../Obj';
+import { ChangeId } from '../common/proxy';
+import { EntityKind, SchemaKindId } from '../common/types';
 
 import {
   addFieldsToSchema,
@@ -177,7 +178,7 @@ const schemaVariance = {
  *
  * @example
  * ```ts
- * export class TableType extends Schema.Struct({...}).pipe(Type.object({ typename: 'example.org/type/Table', version: '0.1.0' })){
+ * export class TableType extends Schema.Struct({...}).pipe(Type.object({ typename: 'com.example.type.table', version: '0.1.0' })){
  *   title: Schema.String,
  *   schema: Schema.optional(ref(EchoSchema)),
  *   props: Schema.mutable(S.Array(TablePropSchema)),
@@ -192,7 +193,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
 
   /**
    * Schema kind key that marks this as an ECHO schema.
-   * Makes EchoSchema satisfy the Type.Obj.Any type.
+   * Makes EchoSchema satisfy the Type.AnyObj type.
    */
   readonly [SchemaKindId]: EntityKind.Object = EntityKind.Object;
 
@@ -304,8 +305,8 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
   /**
    * Reference to the underlying persistent schema object.
    */
-  public get persistentSchema(): PersistentSchema {
-    return this._persistentSchema;
+  public get persistentSchema(): Type.PersistentType {
+    return this._persistentSchema as Type.PersistentType;
   }
 
   public getProperties(): SchemaAST.PropertySignature[] {
@@ -399,7 +400,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   _rebuild(): void {
     if (this._isDirty || this._schema == null) {
-      this._schema = toEffectSchema(getSnapshot(this._persistentSchema.jsonSchema));
+      this._schema = toEffectSchema(getSnapshot(this._persistentSchema).jsonSchema);
       this._isDirty = false;
     }
   }

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--brackets-curly--regular',
+    hue: 'blue',
+  }),
 );
 
 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.

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();