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

package/src/{query/tag.ts → Tag.ts}

@@ -4,34 +4,37 @@
 
 import * as Schema from 'effect/Schema';
 
-import { LabelAnnotation } from '../internal';
-import * as Obj from '../Obj';
-import * as Type from '../Type';
+import { LabelAnnotation, SystemTypeAnnotation } from './internal';
+import * as Obj from './Obj';
+import * as Type from './Type';
 
 export const Tag = Schema.Struct({
   label: Schema.String,
   hue: Schema.optional(Schema.String), // TODO(burdon): Color name?
 }).pipe(
-  Type.Obj({
+  Type.object({
     typename: 'dxos.org/type/Tag',
     version: '0.1.0',
   }),
   LabelAnnotation.set(['label']),
+  SystemTypeAnnotation.set(true),
 );
+
 export type Tag = Schema.Schema.Type<typeof Tag>;
 
 export const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);
 
-export type TagMap = Record<string, Tag>;
+// TODO(burdon): Rename Map.
+export type Map = Record<string, Tag>;
 
 export const sortTags = ({ label: a }: Tag, { label: b }: Tag) => a.localeCompare(b);
 
-export const createTagList = (tags: TagMap): Tag[] =>
+export const createTagList = (tags: Map): Tag[] =>
   Object.entries(tags)
     .map(([id, tag]) => ({ ...tag, id }))
     .sort(sortTags);
 
-export const findTagByLabel = (tags: TagMap | undefined, name: string): Tag | undefined => {
+export const findTagByLabel = (tags: Map | undefined, name: string): Tag | undefined => {
   const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());
   return entry ? { ...entry[1], id: entry[0] } : undefined;
 };

package/src/Type.test.ts

@@ -0,0 +1,52 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import * as Obj from './Obj';
+import * as Relation from './Relation';
+import { TestSchema } from './testing';
+import * as Type from './Type';
+
+describe('Type', () => {
+  describe('Type.Obj', () => {
+    test('has SchemaKindId for schema type checking', ({ expect }) => {
+      // Type.isObjectSchema uses SchemaKindId to check if a schema is an object schema.
+      expect(Type.isObjectSchema(Type.Obj)).toBe(true);
+      expect(Type.isObjectSchema(TestSchema.Person)).toBe(true);
+      expect(Type.isObjectSchema(Type.Relation)).toBe(false);
+    });
+
+    test('Schema.is validates structural compatibility only', ({ expect }) => {
+      // Schema.is does structural validation (has id field).
+      // It accepts both ECHO objects and plain objects with compatible structure.
+      expect(Schema.is(Type.Obj)({ id: 'plain-object' })).toBe(true);
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+      expect(Schema.is(Type.Obj)(obj)).toBe(true);
+    });
+  });
+
+  describe('Type.Relation', () => {
+    test('has SchemaKindId for schema type checking', ({ expect }) => {
+      // Type.isRelationSchema uses SchemaKindId to check if a schema is a relation schema.
+      expect(Type.isRelationSchema(Type.Relation)).toBe(true);
+      expect(Type.isRelationSchema(TestSchema.HasManager)).toBe(true);
+      expect(Type.isRelationSchema(Type.Obj)).toBe(false);
+    });
+
+    test('Schema.is validates structural compatibility only', ({ expect }) => {
+      // Schema.is does structural validation (has id field).
+      // It accepts both ECHO relations and plain objects with compatible structure.
+      expect(Schema.is(Type.Relation)({ id: 'plain-object' })).toBe(true);
+      const obj1 = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const obj2 = Obj.make(TestSchema.Person, { name: 'Bob' });
+      const rel = Relation.make(TestSchema.HasManager, {
+        [Relation.Source]: obj1,
+        [Relation.Target]: obj2,
+      });
+      expect(Schema.is(Type.Relation)(rel)).toBe(true);
+    });
+  });
+});