@dxos/echo 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@dxos/echo",
-  "version": "0.8.4-main.fffef41",
+  "version": "0.8.4-staging.60fe92afc8",
   "description": "ECHO API",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
   "sideEffects": false,
   "type": "module",
@@ -12,70 +16,117 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     },
-    "./Type": {
-      "source": "./src/Type.ts",
-      "types": "./dist/types/src/Type.d.ts",
-      "browser": "./dist/lib/browser/Type.mjs",
-      "node": "./dist/lib/node-esm/Type.mjs"
+    "./internal": {
+      "source": "./src/internal/index.ts",
+      "types": "./dist/types/src/internal/index.d.ts",
+      "default": "./dist/lib/neutral/internal/index.mjs"
+    },
+    "./testing": {
+      "source": "./src/testing/index.ts",
+      "types": "./dist/types/src/testing/index.d.ts",
+      "default": "./dist/lib/neutral/testing/index.mjs"
+    },
+    "./Annotation": {
+      "source": "./src/Annotation.ts",
+      "types": "./dist/types/src/Annotation.d.ts",
+      "default": "./dist/lib/neutral/Annotation.mjs"
+    },
+    "./Database": {
+      "source": "./src/Database.ts",
+      "types": "./dist/types/src/Database.d.ts",
+      "default": "./dist/lib/neutral/Database.mjs"
+    },
+    "./Entity": {
+      "source": "./src/Entity.ts",
+      "types": "./dist/types/src/Entity.d.ts",
+      "default": "./dist/lib/neutral/Entity.mjs"
+    },
+    "./Err": {
+      "source": "./src/Err.ts",
+      "types": "./dist/types/src/Err.d.ts",
+      "default": "./dist/lib/neutral/Err.mjs"
+    },
+    "./Feed": {
+      "source": "./src/Feed.ts",
+      "types": "./dist/types/src/Feed.d.ts",
+      "default": "./dist/lib/neutral/Feed.mjs"
+    },
+    "./Filter": {
+      "source": "./src/Filter.ts",
+      "types": "./dist/types/src/Filter.d.ts",
+      "default": "./dist/lib/neutral/Filter.mjs"
+    },
+    "./Format": {
+      "source": "./src/Format.ts",
+      "types": "./dist/types/src/Format.d.ts",
+      "default": "./dist/lib/neutral/Format.mjs"
+    },
+    "./JsonSchema": {
+      "source": "./src/JsonSchema.ts",
+      "types": "./dist/types/src/JsonSchema.d.ts",
+      "default": "./dist/lib/neutral/JsonSchema.mjs"
+    },
+    "./Key": {
+      "source": "./src/Key.ts",
+      "types": "./dist/types/src/Key.d.ts",
+      "default": "./dist/lib/neutral/Key.mjs"
+    },
+    "./Migration": {
+      "source": "./src/Migration.ts",
+      "types": "./dist/types/src/Migration.d.ts",
+      "default": "./dist/lib/neutral/Migration.mjs"
     },
     "./Obj": {
       "source": "./src/Obj.ts",
       "types": "./dist/types/src/Obj.d.ts",
-      "browser": "./dist/lib/browser/Obj.mjs",
-      "node": "./dist/lib/node-esm/Obj.mjs"
+      "default": "./dist/lib/neutral/Obj.mjs"
     },
-    "./Relation": {
-      "source": "./src/Relation.ts",
-      "types": "./dist/types/src/Relation.d.ts",
-      "browser": "./dist/lib/browser/Relation.mjs",
-      "node": "./dist/lib/node-esm/Relation.mjs"
+    "./Order": {
+      "source": "./src/Order.ts",
+      "types": "./dist/types/src/Order.d.ts",
+      "default": "./dist/lib/neutral/Order.mjs"
+    },
+    "./Query": {
+      "source": "./src/Query.ts",
+      "types": "./dist/types/src/Query.d.ts",
+      "default": "./dist/lib/neutral/Query.mjs"
+    },
+    "./QueryResult": {
+      "source": "./src/QueryResult.ts",
+      "types": "./dist/types/src/QueryResult.d.ts",
+      "default": "./dist/lib/neutral/QueryResult.mjs"
     },
     "./Ref": {
       "source": "./src/Ref.ts",
       "types": "./dist/types/src/Ref.d.ts",
-      "browser": "./dist/lib/browser/Ref.mjs",
-      "node": "./dist/lib/node-esm/Ref.mjs"
+      "default": "./dist/lib/neutral/Ref.mjs"
     },
-    "./internal": {
-      "source": "./src/internal/index.ts",
-      "types": "./dist/types/src/internal/index.d.ts",
-      "browser": "./dist/lib/browser/internal/index.mjs",
-      "node": "./dist/lib/node-esm/internal/index.mjs"
+    "./Registry": {
+      "source": "./src/Registry.ts",
+      "types": "./dist/types/src/Registry.d.ts",
+      "default": "./dist/lib/neutral/Registry.mjs"
     },
-    "./query": {
-      "source": "./src/query/index.ts",
-      "types": "./dist/types/src/query/index.d.ts",
-      "browser": "./dist/lib/browser/query/index.mjs",
-      "node": "./dist/lib/node-esm/query/index.mjs"
+    "./Relation": {
+      "source": "./src/Relation.ts",
+      "types": "./dist/types/src/Relation.d.ts",
+      "default": "./dist/lib/neutral/Relation.mjs"
     },
-    "./testing": {
-      "source": "./src/testing/index.ts",
-      "types": "./dist/types/src/testing/index.d.ts",
-      "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/index.mjs"
-    }
-  },
-  "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "Type": [
-        "dist/types/src/Type.d.ts"
-      ],
-      "Obj": [
-        "dist/types/src/Obj.d.ts"
-      ],
-      "Relation": [
-        "dist/types/src/Relation.d.ts"
-      ],
-      "Ref": [
-        "dist/types/src/Ref.d.ts"
-      ],
-      "testing": [
-        "dist/types/src/testing/index.d.ts"
-      ]
+    "./Scope": {
+      "source": "./src/Scope.ts",
+      "types": "./dist/types/src/Scope.d.ts",
+      "default": "./dist/lib/neutral/Scope.mjs"
+    },
+    "./Tag": {
+      "source": "./src/Tag.ts",
+      "types": "./dist/types/src/Tag.d.ts",
+      "default": "./dist/lib/neutral/Tag.mjs"
+    },
+    "./Type": {
+      "source": "./src/Type.ts",
+      "types": "./dist/types/src/Type.d.ts",
+      "default": "./dist/lib/neutral/Type.mjs"
     }
   },
   "files": [
@@ -83,19 +134,21 @@
     "src"
   ],
   "dependencies": {
-    "@preact/signals-core": "^1.12.1",
-    "effect": "3.18.3",
-    "@dxos/debug": "0.8.4-main.fffef41",
-    "@dxos/echo-signals": "0.8.4-main.fffef41",
-    "@dxos/echo-protocol": "0.8.4-main.fffef41",
-    "@dxos/errors": "0.8.4-main.fffef41",
-    "@dxos/invariant": "0.8.4-main.fffef41",
-    "@dxos/keys": "0.8.4-main.fffef41",
-    "@dxos/effect": "0.8.4-main.fffef41",
-    "@dxos/log": "0.8.4-main.fffef41",
-    "@dxos/live-object": "0.8.4-main.fffef41",
-    "@dxos/node-std": "0.8.4-main.fffef41",
-    "@dxos/util": "0.8.4-main.fffef41"
+    "@effect-atom/atom": "^0.5.3",
+    "effect": "3.21.3",
+    "@dxos/async": "0.8.4-staging.60fe92afc8",
+    "@dxos/debug": "0.8.4-staging.60fe92afc8",
+    "@dxos/echo-protocol": "0.8.4-staging.60fe92afc8",
+    "@dxos/invariant": "0.8.4-staging.60fe92afc8",
+    "@dxos/errors": "0.8.4-staging.60fe92afc8",
+    "@dxos/keys": "0.8.4-staging.60fe92afc8",
+    "@dxos/effect": "0.8.4-staging.60fe92afc8",
+    "@dxos/node-std": "0.8.4-staging.60fe92afc8",
+    "@dxos/log": "0.8.4-staging.60fe92afc8",
+    "@dxos/util": "0.8.4-staging.60fe92afc8"
+  },
+  "devDependencies": {
+    "@types/node": "22.10.2"
   },
   "publishConfig": {
     "access": "public"

package/src/Annotation.test.ts

@@ -0,0 +1,439 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { describe, test } from 'vitest';
+
+import { DXN } from '@dxos/keys';
+
+import * as Annotation from './Annotation';
+import * as Obj from './Obj';
+import * as Type from './Type';
+
+describe('Annotation', () => {
+  describe('make', () => {
+    test('creates an annotation with a string schema', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+
+      expect(ColorAnnotation.key).toBe('org.dxos.annotation.color');
+      expect(ColorAnnotation.schema).toBe(Schema.String);
+      expect(ColorAnnotation[Annotation.TypeId]).toBeDefined();
+    });
+
+    test('creates an annotation with a number schema', ({ expect }) => {
+      const PriorityAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.priority',
+        schema: Schema.Number,
+      });
+
+      expect(PriorityAnnotation.key).toBe('org.dxos.annotation.priority');
+      expect(PriorityAnnotation.schema).toBe(Schema.Number);
+    });
+
+    test('creates an annotation with a complex schema', ({ expect }) => {
+      const MetadataSchema = Schema.Struct({
+        author: Schema.String,
+        version: Schema.Number,
+        tags: Schema.Array(Schema.String),
+      });
+      const MetadataAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.metadata',
+        schema: MetadataSchema,
+      });
+
+      expect(MetadataAnnotation.key).toBe('org.dxos.annotation.metadata');
+      expect(MetadataAnnotation.schema).toBe(MetadataSchema);
+    });
+  });
+
+  describe('getDictionary and setDictionary', () => {
+    test('set and get a string value', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+      const values: Annotation.Dictionary = {};
+
+      Annotation.setDictionary(values, ColorAnnotation, 'red');
+      const result = Annotation.getDictionary(values, ColorAnnotation);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('red');
+    });
+
+    test('set and get a number value', ({ expect }) => {
+      const PriorityAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.priority',
+        schema: Schema.Number,
+      });
+      const values: Annotation.Dictionary = {};
+
+      Annotation.setDictionary(values, PriorityAnnotation, 42);
+      const result = Annotation.getDictionary(values, PriorityAnnotation);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe(42);
+    });
+
+    test('set and get a boolean value', ({ expect }) => {
+      const EnabledAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.enabled',
+        schema: Schema.Boolean,
+      });
+      const values: Annotation.Dictionary = {};
+
+      Annotation.setDictionary(values, EnabledAnnotation, true);
+      const result = Annotation.getDictionary(values, EnabledAnnotation);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe(true);
+    });
+
+    test('set and get a complex object value', ({ expect }) => {
+      const ConfigSchema = Schema.Struct({
+        theme: Schema.String,
+        fontSize: Schema.Number,
+        darkMode: Schema.Boolean,
+      });
+      const ConfigAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.config',
+        schema: ConfigSchema,
+      });
+      const values: Annotation.Dictionary = {};
+
+      const config = { theme: 'modern', fontSize: 14, darkMode: true };
+      Annotation.setDictionary(values, ConfigAnnotation, config);
+      const result = Annotation.getDictionary(values, ConfigAnnotation);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toEqual(config);
+    });
+
+    test('set and get an array value', ({ expect }) => {
+      const TagsAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.tags',
+        schema: Schema.Array(Schema.String),
+      });
+      const values: Annotation.Dictionary = {};
+
+      const tags = ['important', 'urgent', 'review'];
+      Annotation.setDictionary(values, TagsAnnotation, tags);
+      const result = Annotation.getDictionary(values, TagsAnnotation);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toEqual(tags);
+    });
+
+    test('get returns None for missing annotation', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+      const values: Annotation.Dictionary = {};
+
+      const result = Annotation.getDictionary(values, ColorAnnotation);
+
+      expect(Option.isNone(result)).toBe(true);
+    });
+
+    test('overwriting an annotation value', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+      const values: Annotation.Dictionary = {};
+
+      Annotation.setDictionary(values, ColorAnnotation, 'red');
+      Annotation.setDictionary(values, ColorAnnotation, 'blue');
+      const result = Annotation.getDictionary(values, ColorAnnotation);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('blue');
+    });
+
+    test('multiple annotations on the same dictionary', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+      const PriorityAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.priority',
+        schema: Schema.Number,
+      });
+      const EnabledAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.enabled',
+        schema: Schema.Boolean,
+      });
+      const values: Annotation.Dictionary = {};
+
+      Annotation.setDictionary(values, ColorAnnotation, 'green');
+      Annotation.setDictionary(values, PriorityAnnotation, 5);
+      Annotation.setDictionary(values, EnabledAnnotation, false);
+
+      expect(Option.getOrThrow(Annotation.getDictionary(values, ColorAnnotation))).toBe('green');
+      expect(Option.getOrThrow(Annotation.getDictionary(values, PriorityAnnotation))).toBe(5);
+      expect(Option.getOrThrow(Annotation.getDictionary(values, EnabledAnnotation))).toBe(false);
+    });
+  });
+
+  describe('curried forms', () => {
+    test('getDictionary curried form', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+      const values: Annotation.Dictionary = {};
+      Annotation.setDictionary(values, ColorAnnotation, 'purple');
+
+      const getColor = Annotation.getDictionary(ColorAnnotation);
+      const result = getColor(values);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('purple');
+    });
+
+    test('setDictionary curried form', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+      const values: Annotation.Dictionary = {};
+
+      const setOrange = Annotation.setDictionary(ColorAnnotation, 'orange');
+      setOrange(values);
+      const result = Annotation.getDictionary(values, ColorAnnotation);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('orange');
+    });
+
+    test('curried forms work in pipelines', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+      const values: Annotation.Dictionary = {};
+
+      Annotation.setDictionary(ColorAnnotation, 'cyan')(values);
+      const result = Annotation.getDictionary(ColorAnnotation)(values);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('cyan');
+    });
+  });
+
+  describe('Key', () => {
+    test('Key.make creates a branded key', ({ expect }) => {
+      const key = Annotation.Key.make('org.dxos.annotation.my-annotation');
+
+      expect(key).toBe('org.dxos.annotation.my-annotation');
+      expect(typeof key).toBe('string');
+    });
+  });
+
+  describe('Dictionary schema', () => {
+    test('Dictionary can be used as a schema', ({ expect }) => {
+      const PersonWithAnnotations = Schema.Struct({
+        name: Schema.String,
+        extensions: Annotation.Dictionary,
+      });
+
+      const person = Schema.decodeUnknownSync(PersonWithAnnotations)({
+        name: 'Alice',
+        extensions: {},
+      });
+
+      expect(person.name).toBe('Alice');
+      expect(person.extensions).toEqual({});
+    });
+
+    test('Dictionary schema accepts annotation data', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+      const values: Annotation.Dictionary = {};
+      Annotation.setDictionary(values, ColorAnnotation, 'red');
+
+      const PersonWithAnnotations = Schema.Struct({
+        name: Schema.String,
+        extensions: Annotation.Dictionary,
+      });
+
+      const person = Schema.decodeUnknownSync(PersonWithAnnotations)({
+        name: 'Bob',
+        extensions: values,
+      });
+
+      expect(person.name).toBe('Bob');
+      const color = Annotation.getDictionary(person.extensions, ColorAnnotation);
+      expect(Option.getOrThrow(color)).toBe('red');
+    });
+  });
+
+  describe('TypeId', () => {
+    test('TypeId is a unique symbol-like string', ({ expect }) => {
+      expect(Annotation.TypeId).toBe('~@dxos/echo/Annotation');
+    });
+
+    test('annotations have TypeId property', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+
+      expect(Annotation.TypeId in ColorAnnotation).toBe(true);
+    });
+  });
+
+  describe('schema', () => {
+    test('set and get on a struct schema', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+
+      const PersonSchema = Schema.Struct({
+        name: Schema.String,
+      }).pipe(ColorAnnotation.set('crimson'));
+
+      const result = ColorAnnotation.get(PersonSchema);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('crimson');
+    });
+
+    test('get returns None when annotation is not on schema', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+
+      const PersonSchema = Schema.Struct({
+        name: Schema.String,
+      });
+
+      expect(Option.isNone(ColorAnnotation.get(PersonSchema))).toBe(true);
+    });
+
+    test('set and get on a property schema', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+
+      const PersonSchema = Schema.Struct({
+        name: Schema.String.pipe(ColorAnnotation.set('navy')),
+      });
+
+      const nameProperty = SchemaAST.getPropertySignatures(PersonSchema.ast).find((prop) => prop.name === 'name');
+      expect(nameProperty).toBeDefined();
+
+      const result = ColorAnnotation.getFromAst(nameProperty!.type);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('navy');
+    });
+
+    test('annotation survives Type.makeObject and is readable from Type.getSchema', ({ expect }) => {
+      const ColorAnnotation = Annotation.make({
+        id: 'org.dxos.annotation.color',
+        schema: Schema.String,
+      });
+
+      const TaggedPerson = Schema.Struct({
+        name: Schema.String,
+      })
+        .pipe(ColorAnnotation.set('teal'))
+        .pipe(Type.makeObject(DXN.make('com.example.type.taggedperson', '0.1.0')));
+
+      const schema = Type.getSchema(TaggedPerson);
+      const result = ColorAnnotation.get(schema);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('teal');
+    });
+  });
+
+  describe('object', () => {
+    const ColorAnnotation = Annotation.make({
+      id: 'org.dxos.annotation.color',
+      schema: Schema.String,
+    });
+    const Person = Schema.Struct({
+      name: Schema.String,
+    })
+      .pipe(ColorAnnotation.set('schema-teal'))
+      .pipe(Type.makeObject(DXN.make('com.example.type.taggedperson', '0.1.0')));
+
+    test('set and get on Obj.make instance', ({ expect }) => {
+      const person = Obj.make(Person, { name: 'Alice' });
+
+      Obj.update(person, (person) => {
+        Annotation.set(person, ColorAnnotation, 'instance-red');
+      });
+      const result = Annotation.get(person, ColorAnnotation);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('instance-red');
+    });
+
+    test('get returns None when instance has no annotation value', ({ expect }) => {
+      const person = Obj.make(Person, { name: 'Bob' });
+
+      expect(Option.isNone(Annotation.get(person, ColorAnnotation))).toBe(true);
+    });
+
+    test('instance annotation is independent of schema default', ({ expect }) => {
+      const person = Obj.make(Person, { name: 'Carol' });
+
+      expect(Option.getOrThrow(ColorAnnotation.get(Type.getSchema(Person)))).toBe('schema-teal');
+      expect(Option.isNone(Annotation.get(person, ColorAnnotation))).toBe(true);
+
+      Obj.update(person, (person) => {
+        Annotation.set(person, ColorAnnotation, 'instance-blue');
+      });
+
+      expect(Option.getOrThrow(Annotation.get(person, ColorAnnotation))).toBe('instance-blue');
+      expect(Option.getOrThrow(ColorAnnotation.get(Type.getSchema(Person)))).toBe('schema-teal');
+    });
+
+    test('set and get inside Obj.update', ({ expect }) => {
+      const person = Obj.make(Person, { name: 'Dana' });
+
+      Obj.update(person, (person) => {
+        Annotation.set(person, ColorAnnotation, 'updated');
+      });
+
+      expect(Option.getOrThrow(Annotation.get(person, ColorAnnotation))).toBe('updated');
+    });
+
+    test('curried get and set on instances', ({ expect }) => {
+      const person = Obj.make(Person, { name: 'Eve' });
+
+      Obj.update(person, (person) => {
+        Annotation.set(ColorAnnotation, 'curried')(person);
+      });
+      const result = Annotation.get(ColorAnnotation)(person);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('curried');
+    });
+
+    test('get reads annotation from a snapshot', ({ expect }) => {
+      const person = Obj.make(Person, { name: 'Frank' });
+      Obj.update(person, (person) => {
+        Annotation.set(person, ColorAnnotation, 'snapshot-color');
+      });
+
+      const snapshot = Obj.getSnapshot(person);
+      expect(Option.getOrThrow(Annotation.get(snapshot, ColorAnnotation))).toBe('snapshot-color');
+    });
+  });
+});