@dxos/echo 0.8.4-main.ead640a → 0.8.4-main.effb148878

package/src/testing/test-data.ts

@@ -0,0 +1,189 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { DatabaseDirectory, ObjectStructure } from '@dxos/echo-protocol';
+import { EchoURI, ObjectId, PublicKey } from '@dxos/keys';
+
+import { Type } from '../index';
+import { TestSchema } from './test-schema';
+
+// 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 = {
+  get alice(): DatabaseDirectory {
+    if (cachedPeopleAlice === undefined) {
+      cachedPeopleAlice = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getURI(TestSchema.Person)!,
+            data: {
+              name: 'Alice',
+            },
+          }),
+        },
+      });
+    }
+    return cachedPeopleAlice;
+  },
+
+  get bob(): DatabaseDirectory {
+    if (cachedPeopleBob === undefined) {
+      cachedPeopleBob = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getURI(TestSchema.Person)!,
+            data: {
+              name: 'Bob',
+            },
+          }),
+        },
+      });
+    }
+    return cachedPeopleBob;
+  },
+};
+
+export const ORGS = {
+  get dxos(): DatabaseDirectory {
+    if (cachedOrgsDxos === undefined) {
+      cachedOrgsDxos = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getURI(TestSchema.Organization)!,
+            data: {
+              name: 'DXOS',
+              founded: '2023',
+            },
+          }),
+        },
+      });
+    }
+    return cachedOrgsDxos;
+  },
+
+  get cyberdyne(): DatabaseDirectory {
+    if (cachedOrgsCyberdyne === undefined) {
+      cachedOrgsCyberdyne = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getURI(TestSchema.Organization)!,
+            data: {
+              name: 'Cyberdyne Systems',
+              founded: '1984',
+            },
+          }),
+        },
+      });
+    }
+    return cachedOrgsCyberdyne;
+  },
+};
+
+export const WORKS_FOR = {
+  get fredWorksForCyberdyne(): DatabaseDirectory {
+    if (cachedWorksFredCyberdyne === undefined) {
+      cachedWorksFredCyberdyne = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeRelation({
+            type: Type.getURI(TestSchema.EmployedBy)!,
+            source: { '/': EchoURI.make({ objectId: Object.keys(PEOPLE.bob.objects!)[0] }) },
+            target: { '/': EchoURI.make({ objectId: Object.keys(ORGS.cyberdyne.objects!)[0] }) },
+            data: {
+              since: '2020',
+              position: 'Engineer',
+            },
+          }),
+        },
+      });
+    }
+    return cachedWorksFredCyberdyne;
+  },
+
+  get aliceWorksForAperture(): DatabaseDirectory {
+    if (cachedWorksAliceAperture === undefined) {
+      cachedWorksAliceAperture = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeRelation({
+            type: Type.getURI(TestSchema.EmployedBy)!,
+            source: { '/': EchoURI.make({ objectId: Object.keys(PEOPLE.alice.objects!)[0] }) },
+            target: { '/': EchoURI.make({ objectId: Object.keys(ORGS.dxos.objects!)[0] }) },
+            data: {
+              since: '2018',
+              position: 'Research Scientist',
+            },
+          }),
+        },
+      });
+    }
+    return cachedWorksAliceAperture;
+  },
+};
+
+export const TASKS = {
+  get task1(): DatabaseDirectory {
+    if (cachedTasksTask1 === undefined) {
+      cachedTasksTask1 = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.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: { '/': EchoURI.make({ objectId: Object.keys(PEOPLE.bob.objects!)[0] }) },
+            },
+          }),
+        },
+      });
+    }
+    return cachedTasksTask1;
+  },
+
+  get task2(): DatabaseDirectory {
+    if (cachedTasksTask2 === undefined) {
+      cachedTasksTask2 = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.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: { '/': EchoURI.make({ objectId: Object.keys(PEOPLE.alice.objects!)[0] }) },
+            },
+          }),
+        },
+      });
+    }
+    return cachedTasksTask2;
+  },
+};

package/src/testing/test-schema.ts

@@ -0,0 +1,204 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+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';
+
+export namespace TestSchema {
+  //
+  // Expando
+  //
+
+  /**
+   * Expando object is an object with an arbitrary set of properties.
+   * This is the test variant with example.com namespace.
+   */
+  export const Expando = Schema.Struct({}, { key: Schema.String, value: Schema.Any }).pipe(
+    Type.makeObject(DXN.make('com.example.type.expando', '0.1.0')),
+  );
+
+  export type Expando = Type.InstanceType<typeof Expando>;
+
+  //
+  // Example
+  //
+
+  const Nested = Schema.Struct({
+    field: Schema.String,
+  });
+
+  export class TestClass {
+    field = 'value';
+    toJSON() {
+      return { field: this.field };
+    }
+  }
+
+  /** @deprecated Use another test schema or create a specific local test schema. */
+  export const ExampleSchema = Schema.Struct({
+    string: Schema.String,
+    number: Schema.Number,
+    boolean: Schema.Boolean,
+    null: Schema.Null,
+    undefined: Schema.Undefined,
+    stringArray: Schema.Array(Schema.String),
+    twoDimNumberArray: Schema.Array(Schema.Array(Schema.Number)),
+    nested: Nested,
+    nestedArray: Schema.Array(Nested),
+    nestedNullableArray: Schema.Array(Schema.Union(Nested, Schema.Null)),
+    reference: Schema.suspend((): Ref.RefSchema<Example> => Ref.Ref(Example)),
+    referenceArray: Schema.Array(Schema.suspend((): Ref.RefSchema<Example> => Ref.Ref(Example))),
+    classInstance: Schema.instanceOf(TestClass),
+    other: Schema.Any,
+  }).pipe(Schema.partial);
+
+  /** @deprecated Use another test schema or create a specific local test schema. */
+  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.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 Type.InstanceType<typeof Example> {}
+
+  //
+  // Message
+  //
+
+  // TODO(burdon): Support defaults directly on Type: `make` is erased by `pipe(Type.Obj)`.
+  export const MessageStruct = Schema.Struct({
+    // TODO(burdon): Support S.Date; Custom Timestamp (with defaults).
+    // TODO(burdon): Support defaults (update create and create).
+    timestamp: Schema.String.pipe(
+      Schema.propertySignature,
+      Schema.withConstructorDefault(() => new Date().toISOString()),
+    ),
+  });
+
+  export const Message = MessageStruct.pipe(Type.makeObject(DXN.make('com.example.type.message', '0.1.0')));
+
+  export type Message = Type.InstanceType<typeof Message>;
+
+  //
+  // Organization
+  //
+
+  export const Organization = Schema.Struct({
+    name: Schema.String,
+    properties: Schema.optional(
+      Schema.Record({
+        key: Schema.String,
+        value: Schema.String,
+      }),
+    ),
+  }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
+
+  export type Organization = Type.InstanceType<typeof Organization>;
+
+  //
+  // Person
+  //
+
+  export const Person = Schema.Struct({
+    name: Schema.String,
+    username: Schema.String,
+    email: Schema.String,
+    age: Schema.Number.pipe(Schema.optional),
+    tasks: Schema.Array(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task))),
+    employer: Schema.optional(Ref.Ref(Organization)),
+    address: Schema.Struct({
+      city: Schema.optional(Schema.String),
+      state: Schema.optional(Schema.String),
+      zip: Schema.optional(Schema.String),
+      coordinates: Schema.Struct({
+        lat: Schema.optional(Schema.Number),
+        lng: Schema.optional(Schema.Number),
+      }),
+    }),
+    fields: Schema.Struct({
+      label: Schema.String,
+      value: Schema.String,
+    }).pipe(Schema.Array, Schema.optional),
+  }).pipe(Schema.partial, Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
+
+  export interface Person extends Type.InstanceType<typeof Person> {}
+
+  //
+  // Task
+  //
+
+  export const Task = Schema.Struct({
+    title: Schema.optional(Schema.String),
+    deadline: Schema.optional(Schema.String),
+    completed: Schema.optional(Schema.Boolean),
+    assignee: Schema.optional(Ref.Ref(Person)),
+    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.makeObject(DXN.make('com.example.type.task', '0.1.0')));
+
+  export interface Task extends Type.InstanceType<typeof Task> {}
+
+  //
+  // HasManager
+  //
+
+  export const HasManager = Schema.Struct({}).pipe(
+    Type.makeRelation({
+      dxn: DXN.make('com.example.type.hasManager', '0.1.0'),
+      source: Person,
+      target: Person,
+    }),
+  );
+
+  export type HasManager = Type.InstanceType<typeof HasManager>;
+
+  //
+  // EmployedBy
+  //
+
+  export const EmployedBy = Schema.Struct({
+    role: Schema.String,
+    since: Schema.optional(Schema.String),
+  }).pipe(
+    Type.makeRelation({
+      dxn: DXN.make('com.example.type.employedBy', '0.1.0'),
+      source: Person,
+      target: Organization,
+    }),
+  );
+
+  export type EmployedBy = Type.InstanceType<typeof EmployedBy>;
+
+  //
+  // RecordType
+  //
+
+  export enum RecordType {
+    UNDEFINED = 0,
+    PERSONAL = 1,
+    WORK = 2,
+  }
+
+  export const Container = Schema.Struct({
+    objects: Schema.Array(Ref.Ref(Obj.Unknown)),
+    records: Schema.Array(
+      Schema.partial(
+        Schema.Struct({
+          title: Schema.String,
+          description: Schema.String,
+          contacts: Schema.Array(Ref.Ref(Person)),
+          type: Schema.Enums(RecordType),
+        }),
+      ),
+    ),
+  }).pipe(Schema.partial, Type.makeObject(DXN.make('com.example.type.container', '0.1.0')));
+
+  export type Container = Type.InstanceType<typeof Container>;
+}

package/src/testing/util.ts

@@ -0,0 +1,88 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import type * as Schema from 'effect/Schema';
+import type * as SchemaAST from 'effect/SchemaAST';
+
+import { assertArgument } from '@dxos/invariant';
+import { deepMapValues } from '@dxos/util';
+
+import { TypeSchema, getSchemaTypename, getStaticTypeSchema, makeObject, subscribe, toJsonSchema } from '../internal';
+import type * as Type from '../Type';
+
+/**
+ * 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'): Type.Type => {
+  const jsonSchema = toJsonSchema(schema);
+  const typename = getSchemaTypename(schema);
+  assertArgument(typename, 'typename', 'Schema does not have a typename.');
+  // typename/version are routed via ObjectMeta (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;
+};
+
+/**
+ * Converts AST to a format that can be compared with test matchers.
+ */
+export const prepareAstForCompare = (obj: SchemaAST.AST): any =>
+  deepMapValues(obj, (value: any, recurse: any) => {
+    if (typeof value === 'function') {
+      return null;
+    }
+
+    if (value instanceof RegExp) {
+      return value;
+    }
+
+    // Convert symbols to strings.
+    if (typeof value === 'object') {
+      const clone = { ...value };
+      for (const sym of Object.getOwnPropertySymbols(clone as any)) {
+        clone[sym.toString()] = clone[sym];
+        delete clone[sym];
+      }
+
+      return recurse(clone);
+    }
+
+    return recurse(value);
+  });
+
+/**
+ * Creates an update counter that tracks changes to reactive objects.
+ * @param objects - Reactive objects to subscribe to.
+ * @returns An object with a count property and Symbol.dispose for cleanup.
+ */
+export const updateCounter = (...objects: object[]) => {
+  let updateCount = 0;
+
+  const unsubscribes = objects.map((obj) =>
+    subscribe(obj, () => {
+      updateCount++;
+    }),
+  );
+
+  const unsubscribeAll = () => {
+    for (const unsub of unsubscribes) {
+      unsub();
+    }
+  };
+
+  return {
+    // https://github.com/tc39/proposal-explicit-resource-management
+    [Symbol.dispose]: unsubscribeAll,
+    get count() {
+      return updateCount;
+    },
+  };
+};

package/dist/lib/browser/chunk-HKFCK2GL.mjs

@@ -1,175 +0,0 @@
-import "@dxos/node-std/globals";
-import {
-  Any,
-  Relation
-} from "./chunk-MAAYELT7.mjs";
-import {
-  ATTR_RELATION_SOURCE,
-  ATTR_RELATION_TARGET,
-  EntityKind,
-  EntityKindId,
-  MetaId,
-  RelationSourceDXNId,
-  RelationSourceId,
-  RelationTargetDXNId,
-  RelationTargetId,
-  __export,
-  getObjectDXN,
-  getTypeAnnotation,
-  live
-} from "./chunk-MB6MMNFP.mjs";
-
-// src/errors.ts
-import { BaseError } from "@dxos/errors";
-var SchemaNotFoundError = class extends BaseError.extend("SCHEMA_NOT_FOUND", "Schema not found") {
-  constructor(schema, options) {
-    super({
-      context: {
-        schema
-      },
-      ...options
-    });
-  }
-};
-var ObjectNotFoundError = class extends BaseError.extend("OBJECT_NOT_FOUND", "Object not found") {
-  constructor(dxn, options) {
-    super({
-      context: {
-        dxn
-      },
-      ...options
-    });
-  }
-};
-
-// src/Key.ts
-var Key_exports = {};
-__export(Key_exports, {
-  ObjectId: () => ObjectId,
-  SpaceId: () => SpaceId
-});
-import { SpaceId, ObjectId } from "@dxos/keys";
-
-// src/Relation.ts
-var Relation_exports = {};
-__export(Relation_exports, {
-  Any: () => Any2,
-  Source: () => Source,
-  Target: () => Target,
-  getSource: () => getSource,
-  getSourceDXN: () => getSourceDXN,
-  getTarget: () => getTarget,
-  getTargetDXN: () => getTargetDXN,
-  isRelation: () => isRelation,
-  make: () => make
-});
-import * as Schema from "effect/Schema";
-import { raise } from "@dxos/debug";
-import { assertArgument, invariant } from "@dxos/invariant";
-import { DXN } from "@dxos/keys";
-import { assumeType } from "@dxos/util";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
-var Any2 = Schema.Struct({}).pipe(Relation({
-  typename: "dxos.org/types/Any",
-  version: "0.1.0",
-  source: Any,
-  target: Any
-}));
-var Source = RelationSourceId;
-var Target = RelationTargetId;
-var make = (schema, props, meta) => {
-  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, "schema", "Expected a relation schema");
-  if (props[MetaId] != null) {
-    meta = props[MetaId];
-    delete props[MetaId];
-  }
-  const sourceDXN = getObjectDXN(props[Source]) ?? raise(new Error("Unresolved relation source"));
-  const targetDXN = getObjectDXN(props[Target]) ?? raise(new Error("Unresolved relation target"));
-  props[RelationSourceDXNId] = sourceDXN;
-  props[RelationTargetDXNId] = targetDXN;
-  return live(schema, props, meta);
-};
-var isRelation = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  if (ATTR_RELATION_SOURCE in value || ATTR_RELATION_TARGET in value) {
-    return true;
-  }
-  const kind = value[EntityKindId];
-  return kind === EntityKind.Relation;
-};
-var getSourceDXN = (value) => {
-  assertArgument(isRelation(value), "Expected a relation");
-  assumeType(value);
-  const dxn = value[RelationSourceDXNId];
-  invariant(dxn instanceof DXN, void 0, {
-    F: __dxlog_file,
-    L: 110,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
-  return dxn;
-};
-var getTargetDXN = (value) => {
-  assertArgument(isRelation(value), "Expected a relation");
-  assumeType(value);
-  const dxn = value[RelationTargetDXNId];
-  invariant(dxn instanceof DXN, void 0, {
-    F: __dxlog_file,
-    L: 122,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
-  return dxn;
-};
-var getSource = (relation) => {
-  assertArgument(isRelation(relation), "Expected a relation");
-  assumeType(relation);
-  const obj = relation[RelationSourceId];
-  invariant(obj !== void 0, `Invalid source: ${relation.id}`, {
-    F: __dxlog_file,
-    L: 134,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid source: ${relation.id}`"
-    ]
-  });
-  return obj;
-};
-var getTarget = (relation) => {
-  assertArgument(isRelation(relation), "Expected a relation");
-  assumeType(relation);
-  const obj = relation[RelationTargetId];
-  invariant(obj !== void 0, `Invalid target: ${relation.id}`, {
-    F: __dxlog_file,
-    L: 146,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid target: ${relation.id}`"
-    ]
-  });
-  return obj;
-};
-
-// src/index.ts
-import { QueryAST } from "@dxos/echo-protocol";
-import { DXN as DXN2 } from "@dxos/keys";
-
-export {
-  SchemaNotFoundError,
-  ObjectNotFoundError,
-  Key_exports,
-  Relation_exports,
-  QueryAST,
-  DXN2 as DXN
-};
-//# sourceMappingURL=chunk-HKFCK2GL.mjs.map

package/dist/lib/browser/chunk-HKFCK2GL.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/errors.ts", "../../../src/Key.ts", "../../../src/Relation.ts", "../../../src/index.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\nimport { type DXN } from '@dxos/keys';\n\nexport class SchemaNotFoundError extends BaseError.extend('SCHEMA_NOT_FOUND', 'Schema not found') {\n  constructor(schema: string, options?: BaseErrorOptions) {\n    super({ context: { schema }, ...options });\n  }\n}\n\nexport class ObjectNotFoundError extends BaseError.extend('OBJECT_NOT_FOUND', 'Object not found') {\n  constructor(dxn: DXN, options?: BaseErrorOptions) {\n    super({ context: { dxn }, ...options });\n  }\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nexport { SpaceId, ObjectId } from '@dxos/keys';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Live } from '@dxos/live-object';\nimport { assumeType } from '@dxos/util';\n\nimport { live } from './internal';\nimport * as EchoSchema from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\n/**\n * NOTE: Don't export: Relation.Relation and Relation.Any form the public API.\n */\ninterface BaseRelation<Source, Target>\n  extends EchoSchema.HasId,\n    Type.Relation.Endpoints<Source, Target>,\n    Type.OfKind<EchoSchema.EntityKind.Relation> {}\n\n/**\n * Relation type with specific properties.\n */\nexport type Relation<Source extends Obj.Any, Target extends Obj.Any, Props> = BaseRelation<Source, Target> & Props;\n\n/**\n * Base type for all ECHO relations.\n */\nexport interface Any extends BaseRelation<Obj.Any, Obj.Any> {}\n\nexport const Any = Schema.Struct({}).pipe(\n  Type.Relation({\n    typename: 'dxos.org/types/Any',\n    version: '0.1.0',\n    source: Obj.Any,\n    target: Obj.Any,\n  }),\n);\n\n// TODO(dmaretskyi): Has to be `unique symbol`.\nexport const Source: unique symbol = EchoSchema.RelationSourceId as any;\nexport type Source = typeof Source;\nexport const Target: unique symbol = EchoSchema.RelationTargetId as any;\nexport type Target = typeof Target;\n\ntype MakeProps<T extends Any> = {\n  id?: EchoSchema.ObjectId;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Type.Properties<T>;\n\n/**\n * Creates new relation.\n * @param schema - Relation schema.\n * @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.\n * @param meta - Relation metadata.\n * @returns\n */\n// NOTE: Writing the definition this way (with generic over schema) makes typescript perfer to infer the type from the first param (this schema) rather than the second param (the props).\n// TODO(dmaretskyi): Move meta into props.\nexport const make = <S extends Type.Relation.Any>(\n  schema: S,\n  props: NoInfer<MakeProps<Schema.Schema.Type<S>>>,\n  meta?: EchoSchema.ObjectMeta,\n): Live<Schema.Schema.Type<S> & Type.OfKind<EchoSchema.EntityKind.Relation>> => {\n  assertArgument(\n    EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Relation,\n    'schema',\n    'Expected a relation schema',\n  );\n\n  if (props[EchoSchema.MetaId] != null) {\n    meta = props[EchoSchema.MetaId] as any;\n    delete props[EchoSchema.MetaId];\n  }\n\n  const sourceDXN = EchoSchema.getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = EchoSchema.getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));\n  (props as any)[EchoSchema.RelationSourceDXNId] = sourceDXN;\n  (props as any)[EchoSchema.RelationTargetDXNId] = targetDXN;\n\n  return live<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\n\nexport const isRelation = (value: unknown): value is Any => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (EchoSchema.ATTR_RELATION_SOURCE in value || EchoSchema.ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  const kind = (value as any)[EchoSchema.EntityKindId];\n  return kind === EchoSchema.EntityKind.Relation;\n};\n\n/**\n * @returns Relation source DXN.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Any): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<EchoSchema.InternalObjectProps>(value);\n  const dxn = (value as EchoSchema.InternalObjectProps)[EchoSchema.RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Any): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<EchoSchema.InternalObjectProps>(value);\n  const dxn = (value as EchoSchema.InternalObjectProps)[EchoSchema.RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation source.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Any>(relation: T): Type.Relation.Source<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<EchoSchema.InternalObjectProps>(relation);\n  const obj = (relation as EchoSchema.InternalObjectProps)[EchoSchema.RelationSourceId];\n  invariant(obj !== undefined, `Invalid source: ${relation.id}`);\n  return obj as Type.Relation.Source<T>;\n};\n\n/**\n * @returns Relation target.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Any>(relation: T): Type.Relation.Target<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<EchoSchema.InternalObjectProps>(relation);\n  const obj = (relation as EchoSchema.InternalObjectProps)[EchoSchema.RelationTargetId];\n  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\n  return obj as Type.Relation.Target<T>;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nexport * from './errors';\nexport * from './query';\n\nexport * as Key from './Key';\nexport * as Obj from './Obj';\nexport * as Ref from './Ref';\nexport * as Relation from './Relation';\nexport * as Type from './Type';\n\nexport { QueryAST } from '@dxos/echo-protocol';\nexport { DXN } from '@dxos/keys';\nexport { type Live } from '@dxos/live-object';\n"],
-  "mappings": "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",
-  "names": ["BaseError", "SchemaNotFoundError", "BaseError", "extend", "schema", "options", "context", "ObjectNotFoundError", "dxn", "SpaceId", "ObjectId", "Any", "Schema", "raise", "assertArgument", "invariant", "DXN", "assumeType", "Any", "Struct", "pipe", "Relation", "typename", "version", "source", "target", "Source", "RelationSourceId", "Target", "RelationTargetId", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "MetaId", "sourceDXN", "getObjectDXN", "raise", "Error", "targetDXN", "RelationSourceDXNId", "RelationTargetDXNId", "live", "isRelation", "value", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "EntityKindId", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "undefined", "id", "getTarget", "QueryAST", "DXN"]
-}