@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

package/src/testing/api.test.ts

@@ -13,16 +13,22 @@ import { TestSchema } from './test-schema';
 describe('Experimental API review', () => {
   test('type checks', ({ expect }) => {
     const contact = Obj.make(TestSchema.Person, { name: 'Test' });
-    const schema = Obj.getSchema(contact) ?? raise(new Error('No schema found'));
-
-    expect(Type.getDXN(schema)?.typename).to.eq(TestSchema.Person.typename);
-    expect(Type.getTypename(schema)).to.eq('com.example.type.person');
-    expect(Type.getVersion(schema)).to.eq('0.1.0');
-    expect(Type.getMeta(schema)).to.deep.eq({
-      kind: Entity.Kind.Object,
-      typename: 'com.example.type.person',
+    const type = Obj.getType(contact) ?? raise(new Error('No type found'));
+
+    expect(Type.getTypename(type)).to.eq(Type.getTypename(TestSchema.Person));
+    expect(Type.getTypename(type)).to.eq('com.example.type.person');
+    expect(Type.getVersion(type)).to.eq('0.1.0');
+    // `Type.getMeta` returns `EntityMeta` (`{ keys, tags?, key?, version? }`) —
+    // the same shape `Obj.getMeta` and `Relation.getMeta` return. The
+    // schema-kind brand lives on `[SchemaKindId]`, not in meta.
+    expect(Type.getMeta(type)).to.deep.eq({
+      keys: [],
+      tags: [],
+      annotations: {},
+      key: 'com.example.type.person',
       version: '0.1.0',
     });
+    expect(Type.isObject(type)).to.be.true;
   });
 
   test('instance checks', ({ expect }) => {
@@ -32,7 +38,7 @@ describe('Experimental API review', () => {
       employer: Ref.make(organization),
     });
 
-    expect(Schema.is(TestSchema.Person)(contact)).to.be.true;
+    expect(Schema.is(Type.getSchema(TestSchema.Person))(contact)).to.be.true;
     expect(Obj.instanceOf(TestSchema.Person, contact)).to.be.true;
     expect(Obj.instanceOf(TestSchema.Organization, organization)).to.be.true;
 

package/src/testing/index.ts

@@ -2,6 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './registry';
 export * from './test-data';
 export * from './test-schema';
 export * from './util';

package/src/testing/registry.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Atom from '@effect-atom/atom/Atom';
+import * as Layer from 'effect/Layer';
+
+import { Event } from '@dxos/async';
+
+import * as Registry from '../Registry';
+
+/**
+ * Noop `Registry.Service` layer for testing — always returns empty query results.
+ * Use this in test layer stacks that require `Registry.Service` but don't need
+ * actual registry contents.
+ */
+export const registryLayerNoop: Layer.Layer<Registry.Service> = Layer.succeed(Registry.Service, {
+  [Registry.TypeId]: Registry.TypeId,
+  id: 'noop-registry',
+  changed: new Event<void>(),
+  local: [],
+  add: () => {},
+  remove: () => false,
+  clear: () => {},
+  get: () => undefined,
+  getByURI: () => undefined,
+  list: () => [],
+  // QueryFn is an overloaded interface — a single generic function cannot satisfy both overload
+  // signatures without a cast. This is the intentional type-system boundary.
+  query: ((_queryOrFilter: unknown) => ({
+    results: [],
+    entries: [],
+    run: async () => [],
+    runEntries: async () => [],
+    runSync: () => [],
+    runSyncEntries: () => [],
+    first: async (): Promise<never> => {
+      throw new Error('registryLayerNoop: registry is empty');
+    },
+    firstOrUndefined: async () => undefined,
+    subscribe: () => () => {},
+    atom: Atom.make((): never[] => []),
+  })) as Registry.Registry['query'],
+} satisfies Registry.Registry);

package/src/testing/test-data.ts

@@ -2,128 +2,188 @@
 // Copyright 2025 DXOS.org
 //
 
-import { DatabaseDirectory, ObjectStructure } from '@dxos/echo-protocol';
-import { DXN, ObjectId, PublicKey } from '@dxos/keys';
+import { DatabaseDirectory, EntityStructure } from '@dxos/echo-protocol';
+import { EID, EntityId, PublicKey } from '@dxos/keys';
 
 import { Type } from '../index';
 import { TestSchema } from './test-schema';
 
-const spaceKey = PublicKey.random();
+// Lazy init: Cloudflare workers disallow non-determinism at module scope (e.g. random keys).
+let cachedSpaceKeyHex: string | undefined;
+const getSpaceKeyHex = (): string => {
+  if (cachedSpaceKeyHex === undefined) {
+    cachedSpaceKeyHex = PublicKey.random().toHex();
+  }
+  return cachedSpaceKeyHex;
+};
+
+let cachedPeopleAlice: DatabaseDirectory | undefined;
+let cachedPeopleBob: DatabaseDirectory | undefined;
+let cachedOrgsDxos: DatabaseDirectory | undefined;
+let cachedOrgsCyberdyne: DatabaseDirectory | undefined;
+let cachedWorksFredCyberdyne: DatabaseDirectory | undefined;
+let cachedWorksAliceAperture: DatabaseDirectory | undefined;
+let cachedTasksTask1: DatabaseDirectory | undefined;
+let cachedTasksTask2: DatabaseDirectory | undefined;
 
 // TODO(burdon): Use Obj.make.
 
 export const PEOPLE = {
-  alice: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Person)!.toString(),
-        data: {
-          name: 'Alice',
+  get alice(): DatabaseDirectory {
+    if (cachedPeopleAlice === undefined) {
+      cachedPeopleAlice = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Person)!,
+            data: {
+              name: 'Alice',
+            },
+          }),
         },
-      }),
-    },
-  }),
-  bob: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Person)!.toString(),
-        data: {
-          name: 'Bob',
+      });
+    }
+    return cachedPeopleAlice;
+  },
+
+  get bob(): DatabaseDirectory {
+    if (cachedPeopleBob === undefined) {
+      cachedPeopleBob = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Person)!,
+            data: {
+              name: 'Bob',
+            },
+          }),
         },
-      }),
-    },
-  }),
+      });
+    }
+    return cachedPeopleBob;
+  },
 };
 
 export const ORGS = {
-  dxos: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Organization)!.toString(),
-        data: {
-          name: 'DXOS',
-          founded: '2023',
+  get dxos(): DatabaseDirectory {
+    if (cachedOrgsDxos === undefined) {
+      cachedOrgsDxos = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Organization)!,
+            data: {
+              name: 'DXOS',
+              founded: '2023',
+            },
+          }),
         },
-      }),
-    },
-  }),
-  cyberdyne: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Organization)!.toString(),
-        data: {
-          name: 'Cyberdyne Systems',
-          founded: '1984',
+      });
+    }
+    return cachedOrgsDxos;
+  },
+
+  get cyberdyne(): DatabaseDirectory {
+    if (cachedOrgsCyberdyne === undefined) {
+      cachedOrgsCyberdyne = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Organization)!,
+            data: {
+              name: 'Cyberdyne Systems',
+              founded: '1984',
+            },
+          }),
         },
-      }),
-    },
-  }),
+      });
+    }
+    return cachedOrgsCyberdyne;
+  },
 };
 
 export const WORKS_FOR = {
-  fredWorksForCyberdyne: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeRelation({
-        type: Type.getDXN(TestSchema.EmployedBy)!.toString(),
-        source: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects!)[0]).toString() },
-        target: { '/': DXN.fromLocalObjectId(Object.keys(ORGS.cyberdyne.objects!)[0]).toString() },
-        data: {
-          since: '2020',
-          position: 'Engineer',
+  get fredWorksForCyberdyne(): DatabaseDirectory {
+    if (cachedWorksFredCyberdyne === undefined) {
+      cachedWorksFredCyberdyne = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeRelation({
+            type: Type.getURI(TestSchema.EmployedBy)!,
+            source: { '/': EID.make({ entityId: Object.keys(PEOPLE.bob.objects!)[0] }) },
+            target: { '/': EID.make({ entityId: Object.keys(ORGS.cyberdyne.objects!)[0] }) },
+            data: {
+              since: '2020',
+              position: 'Engineer',
+            },
+          }),
         },
-      }),
-    },
-  }),
-  aliceWorksForAperture: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeRelation({
-        type: Type.getDXN(TestSchema.EmployedBy)!.toString(),
-        source: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects!)[0]).toString() },
-        target: { '/': DXN.fromLocalObjectId(Object.keys(ORGS.dxos.objects!)[0]).toString() },
-        data: {
-          since: '2018',
-          position: 'Research Scientist',
+      });
+    }
+    return cachedWorksFredCyberdyne;
+  },
+
+  get aliceWorksForAperture(): DatabaseDirectory {
+    if (cachedWorksAliceAperture === undefined) {
+      cachedWorksAliceAperture = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeRelation({
+            type: Type.getURI(TestSchema.EmployedBy)!,
+            source: { '/': EID.make({ entityId: Object.keys(PEOPLE.alice.objects!)[0] }) },
+            target: { '/': EID.make({ entityId: Object.keys(ORGS.dxos.objects!)[0] }) },
+            data: {
+              since: '2018',
+              position: 'Research Scientist',
+            },
+          }),
         },
-      }),
-    },
-  }),
+      });
+    }
+    return cachedWorksAliceAperture;
+  },
 };
 
 export const TASKS = {
-  task1: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Task)!.toString(),
-        data: {
-          title: 'Complete project documentation',
-          description: 'Write comprehensive documentation for the new system',
-          status: 'in-progress',
-          dueDate: '2023-12-31',
-          assignee: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects!)[0]).toString() },
+  get task1(): DatabaseDirectory {
+    if (cachedTasksTask1 === undefined) {
+      cachedTasksTask1 = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Task)!,
+            data: {
+              title: 'Complete project documentation',
+              description: 'Write comprehensive documentation for the new system',
+              status: 'in-progress',
+              dueDate: '2023-12-31',
+              assignee: { '/': EID.make({ entityId: Object.keys(PEOPLE.bob.objects!)[0] }) },
+            },
+          }),
         },
-      }),
-    },
-  }),
-  task2: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Task)!.toString(),
-        data: {
-          title: 'Run experiments',
-          description: 'Conduct series of experiments on the portal device',
-          status: 'pending',
-          dueDate: '2023-11-15',
-          assignee: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects!)[0]).toString() },
+      });
+    }
+    return cachedTasksTask1;
+  },
+
+  get task2(): DatabaseDirectory {
+    if (cachedTasksTask2 === undefined) {
+      cachedTasksTask2 = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Task)!,
+            data: {
+              title: 'Run experiments',
+              description: 'Conduct series of experiments on the portal device',
+              status: 'pending',
+              dueDate: '2023-11-15',
+              assignee: { '/': EID.make({ entityId: Object.keys(PEOPLE.alice.objects!)[0] }) },
+            },
+          }),
         },
-      }),
-    },
-  }),
+      });
+    }
+    return cachedTasksTask2;
+  },
 };

package/src/testing/test-schema.ts

@@ -4,6 +4,8 @@
 
 import * as Schema from 'effect/Schema';
 
+import { DXN } from '@dxos/keys';
+
 import * as Obj from '../Obj';
 import * as Ref from '../Ref';
 import * as Type from '../Type';
@@ -18,13 +20,10 @@ export namespace TestSchema {
    * This is the test variant with example.com namespace.
    */
   export const Expando = Schema.Struct({}, { key: Schema.String, value: Schema.Any }).pipe(
-    Type.object({
-      typename: 'com.example.type.expando',
-      version: '0.1.0',
-    }),
+    Type.makeObject(DXN.make('com.example.type.expando', '0.1.0')),
   );
 
-  export interface Expando extends Schema.Schema.Type<typeof Expando> {}
+  export type Expando = Type.InstanceType<typeof Expando>;
 
   //
   // Example
@@ -63,15 +62,10 @@ export namespace TestSchema {
   export interface ExampleSchema extends Schema.Schema.Type<typeof ExampleSchema> {}
 
   /** @deprecated Use another test schema or create a specific local test schema. */
-  export const Example = ExampleSchema.pipe(
-    Type.object({
-      typename: 'com.example.type.example',
-      version: '0.1.0',
-    }),
-  );
+  export const Example = ExampleSchema.pipe(Type.makeObject(DXN.make('com.example.type.example', '0.1.0')));
 
   /** @deprecated Use another test schema or create a specific local test schema. */
-  export interface Example extends Schema.Schema.Type<typeof Example> {}
+  export interface Example extends Type.InstanceType<typeof Example> {}
 
   //
   // Message
@@ -87,14 +81,9 @@ export namespace TestSchema {
     ),
   });
 
-  export const Message = MessageStruct.pipe(
-    Type.object({
-      typename: 'com.example.type.message',
-      version: '0.1.0',
-    }),
-  );
+  export const Message = MessageStruct.pipe(Type.makeObject(DXN.make('com.example.type.message', '0.1.0')));
 
-  export interface Message extends Schema.Schema.Type<typeof Message> {}
+  export type Message = Type.InstanceType<typeof Message>;
 
   //
   // Organization
@@ -108,14 +97,9 @@ export namespace TestSchema {
         value: Schema.String,
       }),
     ),
-  }).pipe(
-    Type.object({
-      typename: 'com.example.type.organization',
-      version: '0.1.0',
-    }),
-  );
+  }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
 
-  export interface Organization extends Schema.Schema.Type<typeof Organization> {}
+  export type Organization = Type.InstanceType<typeof Organization>;
 
   //
   // Person
@@ -141,15 +125,9 @@ export namespace TestSchema {
       label: Schema.String,
       value: Schema.String,
     }).pipe(Schema.Array, Schema.optional),
-  }).pipe(
-    Schema.partial,
-    Type.object({
-      typename: 'com.example.type.person',
-      version: '0.1.0',
-    }),
-  );
+  }).pipe(Schema.partial, Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
 
-  export interface Person extends Schema.Schema.Type<typeof Person> {}
+  export interface Person extends Type.InstanceType<typeof Person> {}
 
   //
   // Task
@@ -163,30 +141,23 @@ export namespace TestSchema {
     previous: Schema.optional(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task))),
     subTasks: Schema.optional(Schema.Array(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task)))),
     description: Schema.optional(Schema.String),
-  }).pipe(
-    Schema.partial,
-    Type.object({
-      typename: 'com.example.type.task',
-      version: '0.1.0',
-    }),
-  );
+  }).pipe(Schema.partial, Type.makeObject(DXN.make('com.example.type.task', '0.1.0')));
 
-  export interface Task extends Schema.Schema.Type<typeof Task> {}
+  export interface Task extends Type.InstanceType<typeof Task> {}
 
   //
   // HasManager
   //
 
   export const HasManager = Schema.Struct({}).pipe(
-    Type.relation({
-      typename: 'com.example.type.has-manager',
-      version: '0.1.0',
+    Type.makeRelation({
+      dxn: DXN.make('com.example.type.hasManager', '0.1.0'),
       source: Person,
       target: Person,
     }),
   );
 
-  export interface HasManager extends Schema.Schema.Type<typeof HasManager> {}
+  export type HasManager = Type.InstanceType<typeof HasManager>;
 
   //
   // EmployedBy
@@ -196,15 +167,14 @@ export namespace TestSchema {
     role: Schema.String,
     since: Schema.optional(Schema.String),
   }).pipe(
-    Type.relation({
-      typename: 'com.example.type.employed-by',
-      version: '0.1.0',
+    Type.makeRelation({
+      dxn: DXN.make('com.example.type.employedBy', '0.1.0'),
       source: Person,
       target: Organization,
     }),
   );
 
-  export interface EmployedBy extends Schema.Schema.Type<typeof EmployedBy> {}
+  export type EmployedBy = Type.InstanceType<typeof EmployedBy>;
 
   //
   // RecordType
@@ -228,13 +198,7 @@ export namespace TestSchema {
         }),
       ),
     ),
-  }).pipe(
-    Schema.partial,
-    Type.object({
-      typename: 'com.example.type.container',
-      version: '0.1.0',
-    }),
-  );
+  }).pipe(Schema.partial, Type.makeObject(DXN.make('com.example.type.container', '0.1.0')));
 
-  export interface Container extends Schema.Schema.Type<typeof Container> {}
+  export type Container = Type.InstanceType<typeof Container>;
 }

package/src/testing/util.ts

@@ -8,24 +8,27 @@ import type * as SchemaAST from 'effect/SchemaAST';
 import { assertArgument } from '@dxos/invariant';
 import { deepMapValues } from '@dxos/util';
 
-import { EchoSchema, PersistentSchema, getSchemaTypename, makeObject, subscribe, toJsonSchema } from '../internal';
+import { TypeSchema, getSchemaTypename, getStaticTypeSchema, makeObject, subscribe, toJsonSchema } from '../internal';
+import type * as Type from '../Type';
 
 /**
- * Create a reactive mutable schema that updates when the JSON schema is updated.
+ * Create an in-memory `Type.Type` entity (a `TypeSchema` object) for tests.
+ * Accepts a raw Effect Schema. Pass `Type.getSchema(entity)` to convert a
+ * `Type.Type` entity to its underlying source schema first.
  */
 // TODO(dmaretskyi): Should be replaced by registration of typed object.
-export const createEchoSchema = (schema: Schema.Schema.AnyNoContext, version = '0.1.0'): EchoSchema => {
+export const createEchoSchema = (schema: Schema.Schema.AnyNoContext, version = '0.1.0'): Type.Type => {
   const jsonSchema = toJsonSchema(schema);
   const typename = getSchemaTypename(schema);
   assertArgument(typename, 'typename', 'Schema does not have a typename.');
-  const echoSchema = new EchoSchema(makeObject(PersistentSchema, { typename, version, jsonSchema }));
-
-  // TODO(burdon): Unsubscribe is never called.
-  subscribe(echoSchema.persistentSchema, () => {
-    echoSchema._invalidate();
-  });
-
-  return echoSchema;
+  // typename/version are routed via EntityMeta (the canonical registry-provenance
+  // pair); they're no longer data fields on `TypeSchema`.
+  return makeObject(
+    getStaticTypeSchema(TypeSchema) as any,
+    { jsonSchema },
+    { keys: [], key: typename, version },
+    TypeSchema,
+  ) as unknown as Type.Type;
 };
 
 /**

package/dist/lib/neutral/Extension.mjs

@@ -1,18 +0,0 @@
-import {
-  Key,
-  TypeId,
-  Values,
-  get,
-  make,
-  set
-} from "./chunk-YS6Q3XAD.mjs";
-import "./chunk-J5LGTIGS.mjs";
-export {
-  Key,
-  TypeId,
-  Values,
-  get,
-  make,
-  set
-};
-//# sourceMappingURL=Extension.mjs.map

package/dist/lib/neutral/SchemaRegistry.mjs

@@ -1,2 +0,0 @@
-import "./chunk-BNCCGLJN.mjs";
-//# sourceMappingURL=SchemaRegistry.mjs.map