@dxos/echo 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/src/testing/test-data.ts

@@ -2,8 +2,8 @@
 // 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';
@@ -34,8 +34,8 @@ export const PEOPLE = {
       cachedPeopleAlice = DatabaseDirectory.make({
         spaceKey: getSpaceKeyHex(),
         objects: {
-          [ObjectId.random()]: ObjectStructure.makeObject({
-            type: Type.getDXN(TestSchema.Person)!.toString(),
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Person)!,
             data: {
               name: 'Alice',
             },
@@ -51,8 +51,8 @@ export const PEOPLE = {
       cachedPeopleBob = DatabaseDirectory.make({
         spaceKey: getSpaceKeyHex(),
         objects: {
-          [ObjectId.random()]: ObjectStructure.makeObject({
-            type: Type.getDXN(TestSchema.Person)!.toString(),
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Person)!,
             data: {
               name: 'Bob',
             },
@@ -70,8 +70,8 @@ export const ORGS = {
       cachedOrgsDxos = DatabaseDirectory.make({
         spaceKey: getSpaceKeyHex(),
         objects: {
-          [ObjectId.random()]: ObjectStructure.makeObject({
-            type: Type.getDXN(TestSchema.Organization)!.toString(),
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Organization)!,
             data: {
               name: 'DXOS',
               founded: '2023',
@@ -88,8 +88,8 @@ export const ORGS = {
       cachedOrgsCyberdyne = DatabaseDirectory.make({
         spaceKey: getSpaceKeyHex(),
         objects: {
-          [ObjectId.random()]: ObjectStructure.makeObject({
-            type: Type.getDXN(TestSchema.Organization)!.toString(),
+          [EntityId.random()]: EntityStructure.makeObject({
+            type: Type.getURI(TestSchema.Organization)!,
             data: {
               name: 'Cyberdyne Systems',
               founded: '1984',
@@ -108,10 +108,10 @@ export const WORKS_FOR = {
       cachedWorksFredCyberdyne = DatabaseDirectory.make({
         spaceKey: getSpaceKeyHex(),
         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() },
+          [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',
@@ -128,10 +128,10 @@ export const WORKS_FOR = {
       cachedWorksAliceAperture = DatabaseDirectory.make({
         spaceKey: getSpaceKeyHex(),
         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() },
+          [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',
@@ -150,14 +150,14 @@ export const TASKS = {
       cachedTasksTask1 = DatabaseDirectory.make({
         spaceKey: getSpaceKeyHex(),
         objects: {
-          [ObjectId.random()]: ObjectStructure.makeObject({
-            type: Type.getDXN(TestSchema.Task)!.toString(),
+          [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: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects!)[0]).toString() },
+              assignee: { '/': EID.make({ entityId: Object.keys(PEOPLE.bob.objects!)[0] }) },
             },
           }),
         },
@@ -171,14 +171,14 @@ export const TASKS = {
       cachedTasksTask2 = DatabaseDirectory.make({
         spaceKey: getSpaceKeyHex(),
         objects: {
-          [ObjectId.random()]: ObjectStructure.makeObject({
-            type: Type.getDXN(TestSchema.Task)!.toString(),
+          [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: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects!)[0]).toString() },
+              assignee: { '/': EID.make({ entityId: Object.keys(PEOPLE.alice.objects!)[0] }) },
             },
           }),
         },

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-GWFFC34K.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-BICZKPQG.mjs";
-//# sourceMappingURL=SchemaRegistry.mjs.map

package/dist/lib/neutral/chunk-5SL5LDLD.mjs

@@ -1,47 +0,0 @@
-import {
-  DescriptionAnnotation,
-  FormInputAnnotation,
-  GeneratorAnnotation,
-  IconAnnotation,
-  IconFromRefAnnotation,
-  LabelAnnotation,
-  ReferenceAnnotation,
-  SystemTypeAnnotation,
-  TypeAnnotation,
-  getDescriptionWithSchema,
-  getLabelWithSchema,
-  getTypeAnnotation,
-  makeUserAnnotation,
-  setDescriptionWithSchema,
-  setLabelWithSchema
-} from "./chunk-TNBK56IN.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/Annotation.ts
-var Annotation_exports = {};
-__export(Annotation_exports, {
-  DescriptionAnnotation: () => DescriptionAnnotation,
-  FormInputAnnotation: () => FormInputAnnotation,
-  GeneratorAnnotation: () => GeneratorAnnotation,
-  IconAnnotation: () => IconAnnotation,
-  IconFromRefAnnotation: () => IconFromRefAnnotation,
-  LabelAnnotation: () => LabelAnnotation,
-  ReferenceAnnotation: () => ReferenceAnnotation,
-  SystemTypeAnnotation: () => SystemTypeAnnotation,
-  TypeAnnotation: () => TypeAnnotation,
-  getDescriptionWithSchema: () => getDescriptionWithSchema,
-  getLabelWithSchema: () => getLabelWithSchema,
-  getTypeAnnotation: () => getTypeAnnotation,
-  make: () => make,
-  setDescriptionWithSchema: () => setDescriptionWithSchema,
-  setLabelWithSchema: () => setLabelWithSchema
-});
-var make = makeUserAnnotation;
-
-export {
-  make,
-  Annotation_exports
-};
-//# sourceMappingURL=chunk-5SL5LDLD.mjs.map

package/dist/lib/neutral/chunk-5SL5LDLD.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Annotation.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nexport {\n  DescriptionAnnotation,\n  FormInputAnnotation,\n  GeneratorAnnotation,\n  LabelAnnotation,\n  ReferenceAnnotation,\n  SystemTypeAnnotation,\n  TypeAnnotation,\n  getDescriptionWithSchema,\n  getLabelWithSchema,\n  getTypeAnnotation,\n  setDescriptionWithSchema,\n  setLabelWithSchema,\n  IconAnnotation,\n  IconFromRefAnnotation,\n} from './internal/Annotation';\n\nimport type * as Schema from 'effect/Schema';\n\nimport * as internalAnnotations from './internal/Annotation';\n\ninterface MakeProps<T> {\n  id: string;\n  schema: Schema.Schema<T, any, never>;\n}\n\n/**\n * Create a new schema annotation.\n * Annotation can be assigned both to fields and to the schema itself.\n * Annotation is serialized with the schema.\n *\n * @example\n * ```ts\n * const ColorAnnotation = Annotation.make({\n *   id: 'org.dxos.annotation.color',\n *   schema: Schema.String,\n * });\n *\n * const schema = Schema.String.annotations(ColorAnnotation.set('red'));\n * ```\n */\nexport const make: <T>(props: MakeProps<T>) => internalAnnotations.AnnotationHelper<T> =\n  internalAnnotations.makeUserAnnotation;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;AA+CO,IAAMA,OACSC;",
-  "names": ["make", "makeUserAnnotation"]
-}

package/dist/lib/neutral/chunk-7RVZT53K.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Key.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// TODO(wittjosiah): Should this be a subset of Type?\n\nexport { ForeignKey } from '@dxos/echo-protocol';\nexport { SpaceId, ObjectId } from '@dxos/keys';\n"],
-  "mappings": ";;;;;AAAA;;;;;;AAMA,SAASA,kBAAkB;AAC3B,SAASC,SAASC,gBAAgB;",
-  "names": ["ForeignKey", "SpaceId", "ObjectId"]
-}

package/dist/lib/neutral/chunk-APJKDGFL.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Filter.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport * as internal from './internal';\nimport type * as Obj from './Obj';\nimport * as Ref from './Ref';\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Filter': { value: Types.Covariant<T> };\n\n  ast: QueryAST.Filter;\n}\n\nexport type Props<T> = {\n  // Predicate or a value as a shorthand for `eq`.\n  [K in keyof T & string]?: Filter<T[K]> | T[K];\n};\n\nexport type Any = Filter<any>;\n\nexport type Type<F extends Any> = F extends Filter<infer T> ? T : never;\n\nclass FilterClass implements Any {\n  private static 'variance': Any['~Filter'] = {} as Any['~Filter'];\n\n  constructor(public readonly ast: QueryAST.Filter) {}\n\n  '~Filter' = FilterClass.variance;\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Filter' in value;\n};\n\n/** Construct a filter from an ast. */\nexport const fromAst = (ast: QueryAST.Filter): Any => {\n  return new FilterClass(ast);\n};\n\n/**\n * Filter that matches all objects.\n */\n// TODO(dmaretskyi): `Entity.Any` would be more type-safe, but causes annoying errors in existing code\nexport const everything = (): FilterClass => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n  });\n};\n\n/**\n * Filter that matches no objects.\n */\nexport const nothing = (): FilterClass => {\n  return new FilterClass({\n    type: 'not',\n    filter: {\n      type: 'object',\n      typename: null,\n      props: {},\n    },\n  });\n};\n\n/*\n * Filter by ObjectId.\n */\nexport const id = (...ids: ObjectId[]): Any => {\n  assertArgument(\n    ids.every((id) => ObjectId.isValid(id)),\n    'ids',\n    'ids must be valid',\n  );\n\n  if (ids.length === 0) {\n    return nothing();\n  }\n\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    id: ids,\n    props: {},\n  });\n};\n\n/**\n * Filter by type.\n */\nexport const type = <S extends Schema.Schema.All>(\n  schema: S | string,\n  props?: Props<Schema.Schema.Type<S>>,\n): Filter<Schema.Schema.Type<S>> => {\n  if (Schema.isSchema(schema) && SchemaAST.isUnion(schema.ast)) {\n    const typenames = schema.ast.types.map((type) => internal.getTypeDXNFromSpecifier(Schema.make(type)));\n    return new FilterClass({\n      type: 'or',\n      filters: typenames.map((typename) => ({\n        type: 'object',\n        typename: typename.toString(),\n        props: {},\n      })),\n    });\n  }\n\n  const dxn = internal.getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    ...propsFilterToAst(props ?? {}),\n  });\n};\n\n/**\n * Filter by non-qualified typename.\n */\nexport const typename = (typename: string): Any => {\n  assertArgument(!typename.startsWith('dxn:'), 'typename', 'Typename must no be qualified');\n  return new FilterClass({\n    type: 'object',\n    typename: DXN.fromTypename(typename).toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by fully qualified type DXN.\n */\nexport const typeDXN = (dxn: DXN): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by tag.\n */\nexport const tag = (tag: string): Any => {\n  return new FilterClass({\n    type: 'tag',\n    tag,\n  });\n};\n\n/**\n * Options for {@link key} filter.\n */\nexport type KeyFilterOptions = {\n  /**\n   * Optional semver range expression (e.g. `^1.2.3`, `~2.0.0`, `>=1.0.0 <2.0.0`).\n   * Matches the object's meta `version` field against the range.\n   * If omitted, matches any version (including objects with no version).\n   */\n  version?: string;\n};\n\n/**\n * Filter by registry key stored in object meta.\n *\n * @example\n * ```ts\n * Filter.key('org.example.type.foo');\n * Filter.key('org.example.type.foo', { version: '^1.2.3' });\n * ```\n */\nexport const key = (key: string, options?: KeyFilterOptions): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n    metaKey: key,\n    metaVersion: options?.version,\n  });\n};\n\n/**\n * Filter by properties.\n */\nexport const props = <T>(props: Props<T>): Filter<T> => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    ...propsFilterToAst(props),\n  });\n};\n\nexport type TextSearchOptions = {\n  // TODO(dmaretskyi): Hybrid search.\n  type?: 'full-text' | 'vector';\n};\n\n/**\n * Full-text or vector search.\n */\nexport const text = (\n  // TODO(dmaretskyi): Consider passing a vector here, but really the embedding should be done on the query-executor side.\n  text: string,\n  options?: TextSearchOptions,\n): Any => {\n  return new FilterClass({\n    type: 'text-search',\n    text,\n    searchKind: options?.type,\n  });\n};\n\n/**\n * Filter by foreign keys.\n */\nexport const foreignKeys = <S extends Schema.Schema.All>(\n  schema: S | string,\n  keys: ForeignKey[],\n): Filter<Schema.Schema.Type<S>> => {\n  const dxn = internal.getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n    foreignKeys: keys,\n  });\n};\n\n/**\n * Predicate for property to be equal to the provided value.\n */\nexport const eq = <T>(value: T): Filter<T | undefined> => {\n  if (!Ref.isRef(value) && typeof value === 'object' && value !== null) {\n    throw new TypeError('Cannot use object as a value for eq filter');\n  }\n\n  return new FilterClass({\n    type: 'compare',\n    operator: 'eq',\n    value: Ref.isRef(value) ? value.noInline().encode() : value,\n  });\n};\n\n/**\n * Predicate for property to be not equal to the provided value.\n */\nexport const neq = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'neq',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than the provided value.\n */\nexport const gt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than or equal to the provided value.\n */\nexport const gte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than the provided value.\n */\nexport const lt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than or equal to the provided value.\n */\nexport const lte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided array.\n * @param values - Values to check against.\n */\nconst in$ = <T>(...values: T[]): Filter<T> => {\n  return new FilterClass({\n    type: 'in',\n    values,\n  });\n};\nexport { in$ as in };\n\n/**\n * Predicate for an array property to contain the provided value.\n * @param value - Value to check against.\n */\nexport const contains = <T>(value: T): Filter<readonly T[] | undefined> => {\n  return new FilterClass({\n    type: 'contains',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided range.\n * @param from - Start of the range (inclusive).\n * @param to - End of the range (exclusive).\n */\nexport const between = <T>(from: T, to: T): Filter<T> => {\n  return new FilterClass({\n    type: 'range',\n    from,\n    to,\n  });\n};\n\ntype TimeRange = { after?: Date | number; before?: Date | number };\n\nconst _toUnixMs = (date: Date | number): number => (typeof date === 'number' ? date : date.getTime());\n\nconst _timeRangeFilter = (field: 'updatedAt' | 'createdAt', range: TimeRange): Any => {\n  const filters: Any[] = [];\n  if (range.after != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'gte', value: _toUnixMs(range.after) }));\n  }\n  if (range.before != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'lte', value: _toUnixMs(range.before) }));\n  }\n  if (filters.length === 0) {\n    return everything();\n  }\n  return filters.length === 1 ? filters[0] : and(...filters);\n};\n\n/**\n * Filter objects by updatedAt timestamp.\n */\nexport const updated = (range: TimeRange): Any => _timeRangeFilter('updatedAt', range);\n\n/**\n * Filter objects by createdAt timestamp.\n */\nexport const created = (range: TimeRange): Any => _timeRangeFilter('createdAt', range);\n\nexport type ChildOfOptions = {\n  /** Whether to match transitively (grandchildren, etc.). Defaults to true. */\n  transitive?: boolean;\n};\n\n/**\n * Filter objects that are children of the specified parent(s).\n * Accepts ECHO objects, Refs, or arrays of either.\n * Refs are resolved to DXNs without loading; objects use {@link Obj.getDXN}.\n * With transitive=true (default), also matches grandchildren and beyond.\n */\nexport const childOf = (\n  parents: Obj.Unknown | Ref.Unknown | readonly (Obj.Unknown | Ref.Unknown)[],\n  options?: ChildOfOptions,\n): Any => {\n  const items = Array.isArray(parents) ? parents : [parents];\n  const dxns = items.map((item) => {\n    if (Ref.isRef(item)) {\n      return item.dxn.toString();\n    }\n    return internal.getDXN(item).toString();\n  });\n  return new FilterClass({\n    type: 'child-of',\n    parents: dxns,\n    transitive: options?.transitive ?? true,\n  });\n};\n\n/**\n * Negate the filter.\n */\nexport const not = <F extends Any>(filter: F): Filter<Type<F>> => {\n  return new FilterClass({\n    type: 'not',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Combine filters with a logical AND.\n */\nexport const and = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'and',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n/**\n * Combine filters with a logical OR.\n */\nexport const or = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'or',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n// TODO(dmaretskyi): Add `Filter.match` to support pattern matching on string props.\n\nconst propsFilterToAst = (predicates: Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {\n  let idFilter: readonly ObjectId[] | undefined;\n  if ('id' in predicates) {\n    assertArgument(\n      typeof predicates.id === 'string' || Array.isArray(predicates.id),\n      'predicates.id',\n      'invalid id filter',\n    );\n    idFilter = typeof predicates.id === 'string' ? [predicates.id] : predicates.id;\n    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);\n  }\n\n  return {\n    id: idFilter,\n    props: Object.fromEntries(\n      Object.entries(predicates)\n        .filter(([prop, _value]) => prop !== 'id')\n        .map(([prop, predicate]) => [prop, processPredicate(predicate)]),\n    ) as Record<string, QueryAST.Filter>,\n  };\n};\n\nconst processPredicate = (predicate: any): QueryAST.Filter => {\n  return Match.value(predicate).pipe(\n    Match.withReturnType<QueryAST.Filter>(),\n    Match.when(is, (predicate) => predicate.ast),\n    // TODO(wittjosiah): Add support for array predicates.\n    Match.when(Array.isArray, (_predicate) => {\n      throw new Error('Array predicates are not yet supported.');\n    }),\n    Match.when(\n      (predicate: any) => !Ref.isRef(predicate) && typeof predicate === 'object' && predicate !== null,\n      (predicate) => {\n        const nestedProps = Object.fromEntries(\n          Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)]),\n        );\n\n        return {\n          type: 'object',\n          typename: null,\n          props: nestedProps,\n        };\n      },\n    ),\n    Match.orElse((value) => eq(value).ast),\n  );\n};\n\n/**\n * Returns a human-readable string representation of a Filter AST.\n */\nexport const pretty = (filter: Any): string => internal.prettyFilter(filter.ast);\n"],
-  "mappings": "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",
-  "names": ["Match", "Schema", "SchemaAST", "assertArgument", "DXN", "ObjectId", "FilterClass", "ast", "variance", "is", "value", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "id", "ids", "assertArgument", "every", "ObjectId", "isValid", "length", "schema", "isSchema", "isUnion", "typenames", "types", "map", "getTypeDXNFromSpecifier", "make", "filters", "toString", "dxn", "propsFilterToAst", "startsWith", "DXN", "fromTypename", "typeDXN", "tag", "key", "options", "metaKey", "metaVersion", "version", "text", "searchKind", "foreignKeys", "keys", "eq", "isRef", "TypeError", "operator", "noInline", "encode", "neq", "gt", "gte", "lt", "lte", "in$", "values", "contains", "value", "FilterClass", "type", "between", "from", "to", "_toUnixMs", "date", "getTime", "_timeRangeFilter", "field", "range", "filters", "after", "push", "operator", "before", "length", "everything", "and", "updated", "created", "childOf", "parents", "options", "items", "Array", "isArray", "dxns", "map", "item", "isRef", "dxn", "toString", "getDXN", "transitive", "not", "filter", "ast", "f", "or", "propsFilterToAst", "predicates", "idFilter", "assertArgument", "id", "Schema", "ObjectId", "pipe", "validateSync", "props", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "is", "_predicate", "Error", "nestedProps", "key", "typename", "orElse", "eq", "pretty", "prettyFilter"]
-}

package/dist/lib/neutral/chunk-BICZKPQG.mjs

@@ -1,7 +0,0 @@
-// src/SchemaRegistry.ts
-var SchemaRegistry_exports = {};
-
-export {
-  SchemaRegistry_exports
-};
-//# sourceMappingURL=chunk-BICZKPQG.mjs.map

package/dist/lib/neutral/chunk-BICZKPQG.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/SchemaRegistry.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Types from 'effect/Types';\n\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Key from './Key';\nimport type * as QueryResult from './QueryResult';\nimport type * as Type from './Type';\n\n// TODO(wittjosiah): Replace w/ Query.Query.\nexport type Query = {\n  /**\n   * Filter by schema ID.\n   * Schema id is a DXN with `echo` or `type` kind.\n   */\n  id?: string | string[];\n\n  /**\n   * Id of the backing ECHO object.\n   */\n  backingObjectId?: Key.ObjectId | Key.ObjectId[];\n\n  /**\n   * One or more typenames to filter by.\n   */\n  typename?: string | string[];\n\n  /**\n   * [Semver Range](https://docs.npmjs.com/cli/v6/using-npm/semver#ranges) for the schema version.\n   */\n  version?: string;\n\n  /**\n   * Where to look for the schema.\n   *\n   * Database schema are stored in the database of the current space.\n   * Runtime schema are registered in the runtime.\n   *\n   * @default ['database']\n   */\n  location?: ('database' | 'runtime')[];\n\n  /**\n   * Include system schemas.\n   * @default false\n   *\n   * The system schema include but are not limited to:\n   *  - org.dxos.type.schema\n   */\n  includeSystem?: boolean;\n};\n\n/**\n * Input for schema registration.\n * The typename, version and schema mutability metadata is read from the schema annotations.\n *\n * Accepts:\n * - Branded ECHO schemas created with Type.Obj() or Type.Relation()\n * - JSON schema with typename and version\n */\nexport type RegisterSchemaInput =\n  | Type.AnyEntity\n  | {\n      typename: string;\n      version: string;\n      jsonSchema: JsonSchema.JsonSchema;\n      /**\n       * Display name of the schema.\n       */\n      name?: string;\n    };\n\nexport type ExtractQueryResult<Query> = Query extends { location: ('database' | 'runtime')[] }\n  ? Type.AnyEntity\n  : Type.RuntimeType;\n\n// TODO(dmaretskyi): Rename TypeRegistry\nexport interface SchemaRegistry {\n  /**\n   * Checks if the provided schema is registered.\n   */\n  // TODO(burdon): Type?\n  hasSchema(schema: Type.AnyEntity): boolean;\n\n  /**\n   * Registers the provided schema.\n   *\n   * @returns Mutable runtime instances of schemas that were registered.\n   *\n   * The behavior of this method depends on the state of the database.\n   * The general principle is that the schema will be upserted into the space.\n   * If an equivalent schema with the same name and version already exists, the method does nothing.\n   * If a different schema with the same name and version exists, the method throws an error.\n   * If no schema with the same name and version exists, a new schema will be inserted based on semantic versioning rules.\n   */\n  register(input: RegisterSchemaInput[]): Promise<Type.RuntimeType[]>;\n\n  /**\n   *\n   */\n  query<Q extends Types.NoExcessProperties<Query, Q>>(\n    query?: Q & Query,\n  ): QueryResult.QueryResult<ExtractQueryResult<Q>>;\n}\n"],
-  "mappings": ";AAAA;",
-  "names": []
-}

package/dist/lib/neutral/chunk-BMB7IHGB.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/internal/Ref/ref.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as Hash from 'effect/Hash';\nimport * as Option from 'effect/Option';\nimport * as ParseResult from 'effect/ParseResult';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { Event } from '@dxos/async';\nimport { type CustomInspectFunction, inspectCustom } from '@dxos/debug';\nimport { EncodedReference } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport * as Database from '../../Database';\nimport { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../Annotation';\nimport type { AnyEntity, AnyProperties } from '../common/types';\nimport { type JsonSchemaType } from '../JsonSchema';\n\n/**\n * The `$id` and `$ref` fields for an ECHO reference schema.\n */\nexport const JSON_SCHEMA_ECHO_REF_ID = '/schemas/echo/ref';\n\nexport const getSchemaReference = (property: JsonSchemaType): { typename: string } | undefined => {\n  const { $id, reference: { schema: { $ref } = {} } = {} } = property;\n  if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {\n    return { typename: DXN.parse($ref).typename };\n  }\n};\n\nexport const createSchemaReference = (typename: string): Types.DeepMutable<JsonSchemaType> => {\n  return {\n    $id: JSON_SCHEMA_ECHO_REF_ID,\n    reference: {\n      schema: {\n        $ref: DXN.fromTypename(typename).toString(),\n      },\n    },\n  };\n};\n\n/**\n * Runtime type-info for a reference extracted from effect AST.\n */\nexport type RefereneAST = {\n  /**\n   * Typename of linked schema.\n   */\n  typename: string;\n\n  /**\n   * Version of linked schema.\n   */\n  version: string;\n};\n\nexport const getReferenceAst = (ast: SchemaAST.AST): RefereneAST | undefined => {\n  if (ast._tag !== 'Declaration' || !ast.annotations[ReferenceAnnotationId]) {\n    return undefined;\n  }\n  return {\n    typename: (ast.annotations[ReferenceAnnotationId] as any).typename,\n    version: (ast.annotations[ReferenceAnnotationId] as any).version,\n  };\n};\n\nexport const RefTypeId: unique symbol = Symbol('@dxos/echo/internal/Ref');\n\n/**\n * Reference Schema.\n */\nexport interface RefSchema<T extends AnyEntity> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}\n\n/**\n * Type of the `Ref` function and extra methods attached to it.\n */\nexport interface RefFn {\n  <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>>;\n\n  /**\n   * @returns True if the object is a reference.\n   */\n  isRef: (obj: unknown) => obj is Ref<any>;\n\n  /**\n   * @returns True if the reference points to the given object id.\n   */\n  hasObjectId: (id: ObjectId) => (ref: Ref<any>) => boolean;\n\n  /**\n   * @returns True if the schema is a reference schema.\n   */\n  isRefSchema: (schema: Schema.Schema<any, any>) => schema is RefSchema<any>;\n\n  /**\n   * @returns True if the schema AST is a reference schema.\n   */\n  isRefSchemaAST: (ast: SchemaAST.AST) => boolean;\n\n  /**\n   * Constructs a reference that points to the given object.\n   */\n  // TODO(burdon): Narrow to Obj.Unknown?\n  make: <T extends AnyEntity>(object: T) => Ref<T>;\n\n  /**\n   * Constructs a reference that points to the object specified by the provided DXN.\n   */\n  fromDXN: (dxn: DXN) => Ref<any>;\n}\n\n/**\n * Schema builder for references.\n */\nexport const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>> => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'Must call with an instance of effect-schema');\n  const annotation = getTypeAnnotation(schema);\n  if (annotation == null) {\n    throw new Error('Reference target must be an ECHO schema.');\n  }\n\n  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version);\n};\n\n/**\n * Represents materialized reference to a target.\n * This is the data type for the fields marked as ref.\n */\nexport interface Ref<T> extends Pipeable.Pipeable {\n  /**\n   * Target object DXN.\n   */\n  get dxn(): DXN;\n\n  /**\n   * Returns true if the reference has a target available (inlined or resolver set).\n   */\n  get isAvailable(): boolean;\n\n  /**\n   * @returns The reference target.\n   * May return `undefined` if the object is not loaded in the working set.\n   * Accessing this property, even if it returns `undefined` will trigger the object to be loaded to the working set.\n   */\n  get target(): T | undefined;\n\n  /**\n   * @returns Promise that will resolves with the target object.\n   * Will load the object from disk if it is not present in the working set.\n   * @throws If the object is not available locally.\n   */\n  load(): Promise<T>;\n\n  /**\n   * @returns Promise that will resolves with the target object or undefined if the object is not loaded locally.\n   */\n\n  tryLoad(): Promise<T | undefined>;\n\n  /**\n   * Subscribe to the ref's resolution event.\n   * The callback fires when the target object becomes available in the working set\n   * (e.g. when its document is loaded after sibling-client mutation).\n   * Note: the resolver only schedules a notification when the target is requested\n   * via {@link target} while it is not yet loaded.\n   * @returns Function that unsubscribes the callback.\n   */\n  onResolved(callback: () => void): () => void;\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   *\n   * When serialized with toJSON, the difference is between:\n   * `{ \"/\": \"dxn:...\" }`\n   * and\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   *\n   * Clones the reference object.\n   */\n  noInline(): Ref<T>;\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   *\n   * Examples:\n   * `{ \"/\": \"dxn:...\" }`\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   */\n  encode(): EncodedReference;\n\n  [RefTypeId]: {\n    _T: T;\n  };\n}\n\nexport declare namespace Ref {\n  /**\n   * Target of the reference.\n   */\n  export type Target<R> = R extends Ref<infer U> ? U : never;\n}\n\nRef.isRef = (obj: any): obj is Ref<any> => {\n  return obj && typeof obj === 'object' && RefTypeId in obj;\n};\n\nRef.hasObjectId = (id: ObjectId) => (ref: Ref<any>) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;\n\nRef.isRefSchema = (schema: Schema.Schema<any, any>): schema is RefSchema<any> => {\n  return Ref.isRefSchemaAST(schema.ast);\n};\n\nRef.isRefSchemaAST = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);\n};\n\nRef.make = <T extends AnyProperties>(obj: T): Ref<T> => {\n  if (typeof obj !== 'object' || obj === null) {\n    throw new TypeError('Expected: ECHO object.');\n  }\n\n  // TODO(dmaretskyi): Extract to `getObjectDXN` function.\n  const id = obj.id;\n  invariant(ObjectId.isValid(id), 'Invalid object ID');\n  const dxn = DXN.fromLocalObjectId(id);\n  return new RefImpl(dxn, obj);\n};\n\nRef.fromDXN = (dxn: DXN): Ref<any> => {\n  assertArgument(dxn instanceof DXN, 'dxn', 'Expected DXN');\n  return new RefImpl(dxn);\n};\n\n/**\n * `reference` field on the schema object.\n */\nexport type JsonSchemaReferenceInfo = {\n  schema: { $ref: string };\n  schemaVersion?: string;\n};\n\n/**\n * @internal\n */\n// TODO(burdon): Move to json schema and make private?\nexport const createEchoReferenceSchema = (\n  echoId: string | undefined,\n  typename: string | undefined,\n  version: string | undefined,\n): Schema.SchemaClass<Ref<any>, EncodedReference> => {\n  if (!echoId && !typename) {\n    throw new TypeError('Either echoId or typename must be provided.');\n  }\n\n  const referenceInfo: JsonSchemaReferenceInfo = {\n    schema: {\n      // TODO(dmaretskyi): Include version?\n      $ref: echoId ?? DXN.fromTypename(typename!).toString(),\n    },\n    schemaVersion: version,\n  };\n\n  // TODO(dmaretskyi): Add name and description.\n  const refSchema = Schema.declare<Ref<any>, EncodedReference, []>(\n    [],\n    {\n      encode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            if (Ref.isRef(value)) {\n              return EncodedReference.fromDXN((value as Ref<any>).dxn);\n            } else if (EncodedReference.isEncodedReference(value)) {\n              return value;\n            }\n            throw new Error('Invalid reference');\n          });\n      },\n      decode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            const dbService = yield* Effect.serviceOption(Database.Service);\n\n            // TODO(dmaretskyi): This branch seems to be taken by Schema.is\n            if (Ref.isRef(value)) {\n              if (Option.isSome(dbService)) {\n                return dbService.value.db.makeRef(value.dxn);\n              } else {\n                return value;\n              }\n            }\n\n            if (!EncodedReference.isEncodedReference(value)) {\n              return yield* Effect.fail(new ParseResult.Unexpected(value, 'reference'));\n            }\n            if (Option.isSome(dbService)) {\n              return dbService.value.db.makeRef(EncodedReference.toDXN(value));\n            } else {\n              return Ref.fromDXN(EncodedReference.toDXN(value));\n            }\n          });\n      },\n    },\n    {\n      jsonSchema: {\n        // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.\n        $id: JSON_SCHEMA_ECHO_REF_ID,\n        $ref: JSON_SCHEMA_ECHO_REF_ID,\n        reference: referenceInfo,\n      },\n      [ReferenceAnnotationId]: {\n        typename: typename ?? '',\n        version,\n      },\n    },\n  );\n\n  return refSchema;\n};\n\nconst getSchemaExpectedName = (ast: SchemaAST.Annotated): string | undefined => {\n  return SchemaAST.getIdentifierAnnotation(ast).pipe(\n    Option.orElse(() => SchemaAST.getTitleAnnotation(ast)),\n    Option.orElse(() => SchemaAST.getDescriptionAnnotation(ast)),\n    Option.getOrElse(() => undefined),\n  );\n};\n\nexport interface RefResolver {\n  /**\n   * Resolve ref synchronously from the objects in the working set.\n   *\n   * @param dxn\n   * @param load If true the resolver should attempt to load the object from disk.\n   * @param onLoad Callback to call when the object is loaded.\n   */\n  resolveSync(dxn: DXN, load: boolean, onLoad?: () => void): AnyProperties | undefined;\n\n  /**\n   * Resolver ref asynchronously.\n   */\n  resolve(dxn: DXN): Promise<AnyProperties | undefined>;\n\n  // TODO(dmaretskyi): Combine with `resolve`.\n  resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined>;\n}\n\nexport class RefImpl<T> implements Ref<T> {\n  #dxn: DXN;\n  #resolver?: RefResolver = undefined;\n  #resolved = new Event<void>();\n\n  /**\n   * Target is set when the reference is created from a specific object.\n   * In this case, the target might not be in the database.\n   */\n  #target: T | undefined = undefined;\n\n  /**\n   * Callback to issue a reactive notification when object is resolved.\n   */\n  #resolverCallback = () => {\n    this.#resolved.emit();\n  };\n\n  constructor(dxn: DXN, target?: T) {\n    this.#dxn = dxn;\n    this.#target = target;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get dxn(): DXN {\n    return this.#dxn;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get isAvailable(): boolean {\n    return this.#target !== undefined || this.#resolver !== undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get target(): T | undefined {\n    if (this.#target) {\n      return this.#target;\n    }\n\n    invariant(this.#resolver, 'Resolver is not set');\n    return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback) as T | undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async load(): Promise<T> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    const obj = await this.#resolver.resolve(this.#dxn);\n    if (obj == null) {\n      throw new Error('Object not found');\n    }\n    return obj as T;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async tryLoad(): Promise<T | undefined> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    return (await this.#resolver.resolve(this.#dxn)) as T | undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  onResolved(callback: () => void): () => void {\n    return this.#resolved.on(callback);\n  }\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   * Clones the reference object.\n   */\n  noInline(): RefImpl<T> {\n    const ref = new RefImpl<T>(this.#dxn, undefined);\n    ref.#resolver = this.#resolver;\n    return ref;\n  }\n\n  encode(): EncodedReference {\n    return {\n      '/': this.#dxn.toString(),\n      ...(this.#target ? { target: this.#target } : {}),\n    };\n  }\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   */\n  toJSON(): EncodedReference {\n    return this.encode();\n  }\n\n  toString(): string {\n    if (this.#target) {\n      return `Ref(${this.#target.toString()})`;\n    }\n\n    return `Ref(${this.#dxn.toString()})`;\n  }\n\n  [inspectCustom]: CustomInspectFunction = (depth, options, inspect) => {\n    return this.toString();\n  };\n\n  [RefTypeId] = refVariance;\n\n  /**\n   * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)\n   * to deduplicate Ref instances that point to the same object.\n   * ECHO proxies return new RefImpl instances on every property access,\n   * so without this, each access would create a separate cache entry.\n   */\n  [Hash.symbol](): number {\n    return Hash.hash(this.#dxn.toString());\n  }\n\n  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */\n  [Equal.symbol](that: Equal.Equal): boolean {\n    return that instanceof RefImpl && this.#dxn.toString() === that.dxn.toString();\n  }\n\n  /**\n   * Internal method to set the resolver.\n   *\n   * @internal\n   */\n  _setResolver(resolver: RefResolver): void {\n    this.#resolver = resolver;\n  }\n\n  /**\n   * @internal\n   */\n  _getSavedTarget(): T | undefined {\n    return this.#target;\n  }\n\n  pipe() {\n    // eslint-disable-next-line prefer-rest-params\n    return Pipeable.pipeArguments(this, arguments);\n  }\n}\n\n/**\n * Internal API for setting the reference resolver.\n */\nexport const setRefResolver = (ref: Ref<any>, resolver: RefResolver) => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  ref._setResolver(resolver);\n};\n\n/**\n * Internal API for getting the saved target on a reference.\n */\nexport const getRefSavedTarget = (ref: Ref<any>): AnyProperties | undefined => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  return ref._getSavedTarget();\n};\n\n// Used to validate reference target type.\nconst refVariance: Ref<any>[typeof RefTypeId] = {\n  _T: null as any,\n};\n\nexport const refFromEncodedReference = (encodedReference: EncodedReference, resolver?: RefResolver): Ref<any> => {\n  const dxn = DXN.parse(encodedReference['/']);\n  const ref = new RefImpl(dxn);\n\n  // TODO(dmaretskyi): Handle inline target in the encoded reference.\n\n  if (resolver) {\n    setRefResolver(ref, resolver);\n  }\n  return ref;\n};\n\nexport class StaticRefResolver implements RefResolver {\n  public objects = new Map<ObjectId, AnyProperties>();\n  public schemas = new Map<DXN.String, Schema.Schema.AnyNoContext>();\n\n  addObject(obj: AnyProperties): this {\n    this.objects.set(obj.id, obj);\n    return this;\n  }\n\n  addSchema(schema: Schema.Schema.AnyNoContext): this {\n    const dxn = getSchemaDXN(schema);\n    invariant(dxn, 'Schema has no DXN');\n    this.schemas.set(dxn.toString(), schema);\n    return this;\n  }\n\n  resolveSync(dxn: DXN, _load: boolean, _onLoad?: () => void): AnyProperties | undefined {\n    const id = dxn?.asEchoDXN()?.echoId;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolve(dxn: DXN): Promise<AnyProperties | undefined> {\n    const id = dxn?.asEchoDXN()?.echoId;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined> {\n    return this.schemas.get(dxn.toString());\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["Effect", "Equal", "Hash", "Option", "ParseResult", "Pipeable", "Schema", "SchemaAST", "Event", "inspectCustom", "EncodedReference", "assertArgument", "invariant", "DXN", "ObjectId", "reference", "$ref", "$id", "JSON_SCHEMA_ECHO_REF_ID", "typename", "schema", "undefined", "version", "annotation", "getTypeAnnotation", "Error", "createEchoReferenceSchema", "isRef", "obj", "hasObjectId", "ref", "isLocalObjectId", "Ref", "isRefSchemaAST", "ast", "make", "TypeError", "dxn", "DXN", "fromDXN", "RefImpl", "referenceInfo", "schemaVersion", "Effect", "gen", "EncodedReference", "value", "dbService", "Option", "isSome", "jsonSchema", "ReferenceAnnotationId", "getSchemaExpectedName", "undefined", "target", "invariant", "obj", "Error", "ref", "encode", "toString", "inspectCustom", "depth", "options", "inspect", "RefTypeId", "refVariance", "pipe", "_setResolver", "resolver", "_getSavedTarget", "dxn", "schemas", "addObject", "objects", "set", "addSchema", "schema", "resolveSync", "id", "resolve", "resolveSchema"]
-}

package/dist/lib/neutral/chunk-FIWO2FZK.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Migration.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type DXN } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport { MetaId, type ObjectMeta, getSchemaDXN } from './internal';\n\n/**\n * Result returned by a migration's `transform` callback.\n * The data shape matches the target schema; the optional `[Obj.Meta]` symbol key lets the\n * transform update the object's meta (e.g. `key` / `version`) atomically with the data swap.\n */\nexport type TransformResult<To extends Schema.Schema.AnyNoContext> = Omit<\n  Schema.Schema.Type<To>,\n  'id' | Entity.KindId\n> & {\n  [MetaId]?: Partial<ObjectMeta>;\n};\n\ntype DefineObjectMigrationOptions<From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext> = {\n  from: From;\n  to: To;\n  /**\n   * Pure function that converts the old object data to the new object data.\n   *\n   * The returned object may include an optional `[Obj.Meta]` entry to update the object's meta\n   * (e.g. registry `key` / `version`) atomically with the data swap.\n   */\n  // TODO(dmaretskyi): `id` should not be a part of the schema.\n  transform: (from: Schema.Schema.Type<From>, context: ObjectMigrationContext) => Promise<TransformResult<To>>;\n\n  /**\n   * Callback that is called after the object is migrated. Called for every object that is migrated.\n   *\n   * NOTE: Database mutations performed in this callback are not guaranteed to be idempotent.\n   *       If multiple peers run the migration separately, the effects may be applied multiple times.\n   */\n  onMigration?: (params: OnMigrateProps<From, To>) => Promise<void>;\n};\n\n/**\n * Context passed to object migration callbacks.\n */\nexport type ObjectMigrationContext = {\n  db: Database.Database;\n};\n\ntype OnMigrateProps<From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext> = {\n  before: Schema.Schema.Type<From>;\n  object: Schema.Schema.Type<To>;\n  db: Database.Database;\n};\n\n/**\n * Definition of a migration from one object schema version to another.\n */\nexport type ObjectMigration = {\n  fromType: DXN;\n  toType: DXN;\n  fromSchema: Schema.Schema.AnyNoContext;\n  toSchema: Schema.Schema.AnyNoContext;\n  transform: (from: unknown, context: ObjectMigrationContext) => Promise<unknown>;\n  onMigration?: (params: OnMigrateProps<any, any>) => Promise<void>;\n};\n\n/**\n * Define a migration between two object schemas.\n *\n * @example\n * ```ts\n * const migration = Migration.define({\n *   from: ContactV1,\n *   to: ContactV2,\n *   transform: async (from) => ({ name: `${from.firstName} ${from.lastName}` }),\n *   onMigration: async () => {},\n * });\n * ```\n */\nexport const define = <From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext>(\n  options: DefineObjectMigrationOptions<From, To>,\n): ObjectMigration => {\n  const fromType = getSchemaDXN(options.from);\n  if (!fromType) {\n    throw new Error('Invalid from schema');\n  }\n  const toType = getSchemaDXN(options.to);\n  if (!toType) {\n    throw new Error('Invalid to schema');\n  }\n\n  return {\n    fromType,\n    toType,\n    fromSchema: options.from,\n    toSchema: options.to,\n    transform: options.transform as any,\n    onMigration: options.onMigration as any,\n  };\n};\n"],
-  "mappings": ";;;;;;;;AAAA;;;;AAqFO,IAAMA,SAAS,CACpBC,YAAAA;AAEA,QAAMC,WAAWC,aAAaF,QAAQG,IAAI;AAC1C,MAAI,CAACF,UAAU;AACb,UAAM,IAAIG,MAAM,qBAAA;EAClB;AACA,QAAMC,SAASH,aAAaF,QAAQM,EAAE;AACtC,MAAI,CAACD,QAAQ;AACX,UAAM,IAAID,MAAM,mBAAA;EAClB;AAEA,SAAO;IACLH;IACAI;IACAE,YAAYP,QAAQG;IACpBK,UAAUR,QAAQM;IAClBG,WAAWT,QAAQS;IACnBC,aAAaV,QAAQU;EACvB;AACF;",
-  "names": ["define", "options", "fromType", "getSchemaDXN", "from", "Error", "toType", "to", "fromSchema", "toSchema", "transform", "onMigration"]
-}