@dxos/echo 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

package/dist/lib/node-esm/chunk-6OTQZKHX.mjs

@@ -0,0 +1,303 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  EntityKind,
+  createAnnotationHelper
+} from "./chunk-NHYOREKX.mjs";
+
+// src/internal/types/typename.ts
+var ATTR_TYPE = "@type";
+var TypeId = Symbol.for("@dxos/echo/Type");
+var SchemaId = Symbol.for("@dxos/echo/Schema");
+var getSchema = (obj) => {
+  if (obj) {
+    return obj[SchemaId];
+  }
+};
+var setSchema = (obj, schema) => {
+  Object.defineProperty(obj, SchemaId, {
+    value: schema,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+
+// src/internal/annotations/annotations.ts
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { raise } from "@dxos/debug";
+import { Reference } from "@dxos/echo-protocol";
+import { getField } from "@dxos/effect";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/annotations/annotations.ts";
+var FIELD_PATH_ANNOTATION = "path";
+var FieldPath = (path) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
+var TypeIdentifierAnnotationId = Symbol.for("@dxos/schema/annotation/TypeIdentifier");
+var getTypeIdentifierAnnotation = (schema) => Function.flow(SchemaAST.getAnnotation(TypeIdentifierAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+var getSchemaDXN = (schema) => {
+  assertArgument(Schema.isSchema(schema), "schema", "invalid schema");
+  const id = getTypeIdentifierAnnotation(schema);
+  if (id) {
+    return DXN.parse(id);
+  }
+  const objectAnnotation = getTypeAnnotation(schema);
+  if (!objectAnnotation) {
+    return void 0;
+  }
+  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);
+};
+var getTypeReference = (schema) => {
+  if (!schema) {
+    return void 0;
+  }
+  const schemaDXN = getSchemaDXN(schema);
+  if (!schemaDXN) {
+    return void 0;
+  }
+  return Reference.fromDXN(schemaDXN);
+};
+var requireTypeReference = (schema) => {
+  const typeReference = getTypeReference(schema);
+  if (typeReference == null) {
+    throw new Error("Schema must be defined via TypedObject.");
+  }
+  return typeReference;
+};
+var getTypeDXNFromSpecifier = (input) => {
+  if (Schema.isSchema(input)) {
+    return getTypeReference(input)?.toDXN() ?? raise(new TypeError("Schema has no DXN"));
+  } else {
+    assertArgument(typeof input === "string", "input");
+    assertArgument(!input.startsWith("dxn:"), "input");
+    return DXN.fromTypename(input);
+  }
+};
+var TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\w+\.[a-zA-Z]\w{1,}\/[\w/_-]+$/)).annotations({
+  description: "Fully qualified globally unique typename",
+  example: "dxos.org/type/Message"
+});
+var VersionSchema = Schema.String.pipe(Schema.pattern(/^\d+.\d+.\d+$/)).annotations({
+  description: "Semantic version format: `major.minor.patch`",
+  example: "1.0.0"
+});
+var TypeMeta = Schema.Struct({
+  typename: TypenameSchema,
+  version: VersionSchema
+});
+var TypeAnnotationId = Symbol.for("@dxos/schema/annotation/Type");
+var TypeAnnotation = Schema.extend(TypeMeta, Schema.Struct({
+  kind: Schema.Enums(EntityKind),
+  /**
+   * If this is a relation, the schema of the source object.
+   * Must be present if entity kind is {@link EntityKind.Relation}.
+   */
+  sourceSchema: Schema.optional(DXN.Schema),
+  /**
+   * If this is a relation, the schema of the target object.
+   * Must be present if entity kind is {@link EntityKind.Relation}.
+   */
+  targetSchema: Schema.optional(DXN.Schema)
+}));
+var getTypeAnnotation = (schema) => {
+  assertArgument(schema != null && schema.ast != null, "schema", "invalid schema");
+  return Function.flow(SchemaAST.getAnnotation(TypeAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+};
+var getEntityKind = (schema) => getTypeAnnotation(schema)?.kind;
+var getSchemaTypename = (schema) => getTypeAnnotation(schema)?.typename;
+var getSchemaVersion = (schema) => getTypeAnnotation(schema)?.version;
+var getTypename = (obj) => {
+  const schema = getSchema(obj);
+  if (schema != null) {
+    return getSchemaTypename(schema);
+  } else {
+    const type = getTypeDXN(obj);
+    return type?.asTypeDXN()?.type;
+  }
+};
+var setTypename = (obj, typename) => {
+  invariant(typename instanceof DXN, "Invalid type.", {
+    F: __dxlog_file,
+    L: 231,
+    S: void 0,
+    A: [
+      "typename instanceof DXN",
+      "'Invalid type.'"
+    ]
+  });
+  Object.defineProperty(obj, TypeId, {
+    value: typename,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+var getTypeDXN = (obj) => {
+  if (!obj) {
+    return void 0;
+  }
+  const type = obj[TypeId];
+  if (!type) {
+    return void 0;
+  }
+  invariant(type instanceof DXN, "Invalid object.", {
+    F: __dxlog_file,
+    L: 258,
+    S: void 0,
+    A: [
+      "type instanceof DXN",
+      "'Invalid object.'"
+    ]
+  });
+  return type;
+};
+var isInstanceOf = (schema, object) => {
+  if (object == null) {
+    return false;
+  }
+  const schemaDXN = getSchemaDXN(schema);
+  if (!schemaDXN) {
+    throw new Error("Schema must have an object annotation.");
+  }
+  const type = getTypeDXN(object);
+  if (type && DXN.equals(type, schemaDXN)) {
+    return true;
+  }
+  const typename = getTypename(object);
+  if (!typename) {
+    return false;
+  }
+  const typeDXN = schemaDXN.asTypeDXN();
+  if (!typeDXN) {
+    return false;
+  }
+  return typeDXN.type === typename;
+};
+var PropertyMetaAnnotationId = Symbol.for("@dxos/schema/annotation/PropertyMeta");
+var PropertyMeta = (name, value) => {
+  return (self) => {
+    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId];
+    return self.annotations({
+      [PropertyMetaAnnotationId]: {
+        ...existingMeta,
+        [name]: value
+      }
+    });
+  };
+};
+var getPropertyMetaAnnotation = (prop, name) => Function.pipe(SchemaAST.getAnnotation(PropertyMetaAnnotationId)(prop.type), Option.map((meta) => meta[name]), Option.getOrElse(() => void 0));
+var ReferenceAnnotationId = Symbol.for("@dxos/schema/annotation/Reference");
+var getReferenceAnnotation = (schema) => Function.pipe(SchemaAST.getAnnotation(ReferenceAnnotationId)(schema.ast), Option.getOrElse(() => void 0));
+var SchemaMetaSymbol = Symbol.for("@dxos/schema/SchemaMeta");
+var SystemTypeAnnotationId = Symbol.for("@dxos/schema/annotation/SystemType");
+var SystemTypeAnnotation = createAnnotationHelper(SystemTypeAnnotationId);
+var LabelAnnotationId = Symbol.for("@dxos/schema/annotation/Label");
+var LabelAnnotation = createAnnotationHelper(LabelAnnotationId);
+var getLabel = (schema, object) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => [
+    "name"
+  ]));
+  for (const accessor of annotation) {
+    assertArgument(typeof accessor === "string", "accessor", "Label annotation must be a string or an array of strings");
+    const value = getField(object, accessor);
+    switch (typeof value) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "bigint":
+      case "symbol":
+        return value.toString();
+      case "undefined":
+      case "object":
+      case "function":
+        continue;
+    }
+  }
+  return void 0;
+};
+var setLabel = (schema, object, label) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option.map((field) => field[0]), Option.getOrElse(() => "name"));
+  object[annotation] = label;
+};
+var DescriptionAnnotationId = Symbol.for("@dxos/schema/annotation/Description");
+var DescriptionAnnotation = createAnnotationHelper(DescriptionAnnotationId);
+var getDescription = (schema, object) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => "description"));
+  assertArgument(typeof accessor === "string", "accessor", "Description annotation must be a string");
+  const value = getField(object, accessor);
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return value.toString();
+    case "undefined":
+    case "object":
+    case "function":
+    default:
+      return void 0;
+  }
+};
+var setDescription = (schema, object, description) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => "description"));
+  object[accessor] = description;
+};
+var FormInputAnnotationId = Symbol.for("@dxos/schema/annotation/FormInput");
+var FormInputAnnotation = createAnnotationHelper(FormInputAnnotationId);
+var FieldLookupAnnotationId = Symbol.for("@dxos/schema/annotation/FieldLookup");
+var GeneratorAnnotationId = Symbol.for("@dxos/schema/annotation/Generator");
+var GeneratorAnnotation = createAnnotationHelper(GeneratorAnnotationId);
+
+export {
+  ATTR_TYPE,
+  TypeId,
+  SchemaId,
+  getSchema,
+  setSchema,
+  FIELD_PATH_ANNOTATION,
+  FieldPath,
+  TypeIdentifierAnnotationId,
+  getTypeIdentifierAnnotation,
+  getSchemaDXN,
+  getTypeReference,
+  requireTypeReference,
+  getTypeDXNFromSpecifier,
+  TypenameSchema,
+  VersionSchema,
+  TypeMeta,
+  TypeAnnotationId,
+  TypeAnnotation,
+  getTypeAnnotation,
+  getEntityKind,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypename,
+  setTypename,
+  getTypeDXN,
+  isInstanceOf,
+  PropertyMetaAnnotationId,
+  PropertyMeta,
+  getPropertyMetaAnnotation,
+  ReferenceAnnotationId,
+  getReferenceAnnotation,
+  SchemaMetaSymbol,
+  SystemTypeAnnotationId,
+  SystemTypeAnnotation,
+  LabelAnnotationId,
+  LabelAnnotation,
+  getLabel,
+  setLabel,
+  DescriptionAnnotationId,
+  DescriptionAnnotation,
+  getDescription,
+  setDescription,
+  FormInputAnnotationId,
+  FormInputAnnotation,
+  FieldLookupAnnotationId,
+  GeneratorAnnotationId,
+  GeneratorAnnotation
+};
+//# sourceMappingURL=chunk-6OTQZKHX.mjs.map

package/dist/lib/node-esm/chunk-6OTQZKHX.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/types/typename.ts", "../../../src/internal/annotations/annotations.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\n/**\n * Property name for typename when object is serialized to JSON.\n */\nexport const ATTR_TYPE = '@type';\n\n/**\n * DXN to the object type.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Type');\n\n/**\n * Reference to the object schema.\n */\nexport const SchemaId = Symbol.for('@dxos/echo/Schema');\n\n/**\n * Returns the schema for the given object if one is defined.\n *\n * @internal (Use Obj.getSchema)\n */\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): For echo objects, this always returns the root schema.\nexport const getSchema = (obj: unknown | undefined): Schema.Schema.AnyNoContext | undefined => {\n  if (obj) {\n    return (obj as any)[SchemaId];\n  }\n};\n\n/**\n * @internal\n */\nexport const setSchema = (obj: any, schema: Schema.Schema.AnyNoContext): void => {\n  Object.defineProperty(obj, SchemaId, {\n    value: schema,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  });\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { raise } from '@dxos/debug';\nimport { Reference } from '@dxos/echo-protocol';\nimport { type JsonPath, getField } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Primitive } from '@dxos/util';\n\nimport { type AnyProperties, EntityKind, TypeId, getSchema } from '../types';\n\nimport { createAnnotationHelper } from './util';\n\n/**\n * @internal\n */\nexport const FIELD_PATH_ANNOTATION = 'path';\n\n/**\n * Sets the path for the field.\n * @param path Data source path in the json path format. This is the field path in the source object.\n */\n// TODO(burdon): Field, vs. path vs. property.\nexport const FieldPath = (path: string) => PropertyMeta(FIELD_PATH_ANNOTATION, path);\n\n//\n// Type\n//\n\n/**\n * ECHO identifier (for a stored schema).\n * Must be a `dxn:echo:` URI.\n */\nexport const TypeIdentifierAnnotationId = Symbol.for('@dxos/schema/annotation/TypeIdentifier');\n\nexport const getTypeIdentifierAnnotation = (schema: Schema.Schema.All) =>\n  Function.flow(\n    SchemaAST.getAnnotation<string>(TypeIdentifierAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n\n/**\n * @returns DXN of the schema.\n *\n * For non-stored schema returns `dxn:type:`.\n * For stored schema returns `dxn:echo:`.\n */\nexport const getSchemaDXN = (schema: Schema.Schema.All): DXN | undefined => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');\n  const id = getTypeIdentifierAnnotation(schema);\n  if (id) {\n    return DXN.parse(id);\n  }\n\n  // TODO(dmaretskyi): Add support for dynamic schema.\n  const objectAnnotation = getTypeAnnotation(schema);\n  if (!objectAnnotation) {\n    return undefined;\n  }\n\n  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);\n};\n\n/**\n * Returns a reference that will be used to point to a schema.\n * @deprecated Use {@link getSchemaDXN} instead.\n */\nexport const getTypeReference = (schema: Schema.Schema.All | undefined): Reference | undefined => {\n  if (!schema) {\n    return undefined;\n  }\n\n  const schemaDXN = getSchemaDXN(schema);\n  if (!schemaDXN) {\n    return undefined;\n  }\n  return Reference.fromDXN(schemaDXN);\n};\n\n/**\n * Returns a reference that will be used to point to a schema.\n * @throws If it is not possible to reference this schema.\n *\n * @deprecated Use {@link getSchemaDXN} instead.\n */\nexport const requireTypeReference = (schema: Schema.Schema.AnyNoContext): Reference => {\n  const typeReference = getTypeReference(schema);\n  if (typeReference == null) {\n    // TODO(burdon): Catalog user-facing errors (this is too verbose).\n    throw new Error('Schema must be defined via TypedObject.');\n  }\n\n  return typeReference;\n};\n\n/**\n * @param input schema or a typename string\n * @return type DXN\n */\nexport const getTypeDXNFromSpecifier = (input: Schema.Schema.All | string): DXN => {\n  if (Schema.isSchema(input)) {\n    return getTypeReference(input)?.toDXN() ?? raise(new TypeError('Schema has no DXN'));\n  } else {\n    assertArgument(typeof input === 'string', 'input');\n    assertArgument(!input.startsWith('dxn:'), 'input');\n    return DXN.fromTypename(input);\n  }\n};\n\n//\n// TypeAnnotation\n//\n\n/**\n * Fully qualified globally unique typename.\n * Example: `dxos.org/type/Message`\n */\n// TODO(burdon): Reconcile with short DXN format.\n// TODO(burdon): Change \"/type\" => \"/schema\" throughout.\nexport const TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\\w+\\.[a-zA-Z]\\w{1,}\\/[\\w/_-]+$/)).annotations(\n  {\n    description: 'Fully qualified globally unique typename',\n    example: 'dxos.org/type/Message',\n  },\n);\n\n/**\n * Semantic version format: `major.minor.patch`\n * Example: `1.0.0`\n */\nexport const VersionSchema = Schema.String.pipe(Schema.pattern(/^\\d+.\\d+.\\d+$/)).annotations({\n  description: 'Semantic version format: `major.minor.patch`',\n  example: '1.0.0',\n});\n\nexport const TypeMeta = Schema.Struct({\n  typename: TypenameSchema,\n  version: VersionSchema,\n});\n\nexport interface TypeMeta extends Schema.Schema.Type<typeof TypeMeta> {}\n\n/**\n * Entity type.\n */\nexport const TypeAnnotationId = Symbol.for('@dxos/schema/annotation/Type');\n\n/**\n * Payload stored under {@link TypeAnnotationId}.\n */\nexport const TypeAnnotation = Schema.extend(\n  TypeMeta,\n  Schema.Struct({\n    kind: Schema.Enums(EntityKind),\n\n    /**\n     * If this is a relation, the schema of the source object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    sourceSchema: Schema.optional(DXN.Schema),\n\n    /**\n     * If this is a relation, the schema of the target object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    targetSchema: Schema.optional(DXN.Schema),\n  }),\n);\n\nexport interface TypeAnnotation extends Schema.Schema.Type<typeof TypeAnnotation> {}\n\n/**\n * @returns {@link TypeAnnotation} from a schema.\n * Schema must have been created with {@link TypedObject} or {@link TypedLink} or manually assigned an appropriate annotation.\n */\nexport const getTypeAnnotation = (schema: Schema.Schema.All): TypeAnnotation | undefined => {\n  assertArgument(schema != null && schema.ast != null, 'schema', 'invalid schema');\n  return Function.flow(\n    SchemaAST.getAnnotation<TypeAnnotation>(TypeAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n};\n\n/**\n * @returns {@link EntityKind} from a schema.\n */\nexport const getEntityKind = (schema: Schema.Schema.All): EntityKind | undefined => getTypeAnnotation(schema)?.kind;\n\n/**\n * @internal\n * @returns Schema typename (without dxn: prefix or version number).\n */\nexport const getSchemaTypename = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.typename;\n\n/**\n * @internal\n * @returns Schema version in semver format.\n */\nexport const getSchemaVersion = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.version;\n\n/**\n * Gets the typename of the object without the version.\n * Returns only the name portion, not the DXN.\n * @example \"example.org/type/Contact\"\n *\n * @internal (use Obj.getTypename)\n */\nexport const getTypename = (obj: AnyProperties): string | undefined => {\n  const schema = getSchema(obj);\n  if (schema != null) {\n    // Try to extract typename from DXN.\n    return getSchemaTypename(schema);\n  } else {\n    const type = getTypeDXN(obj);\n    return type?.asTypeDXN()?.type;\n  }\n};\n\n/**\n * @internal (use Type.setTypename)\n */\n// TODO(dmaretskyi): Rename setTypeDXN.\nexport const setTypename = (obj: any, typename: DXN): void => {\n  invariant(typename instanceof DXN, 'Invalid type.');\n  Object.defineProperty(obj, TypeId, {\n    value: typename,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  });\n};\n\n/**\n * @returns Object type as {@link DXN}.\n * @returns undefined if the object doesn't have a type.\n * @example `dxn:example.com/type/Person:1.0.0`\n *\n * @internal (use Obj.getTypeDXN)\n */\n// TODO(burdon): Narrow type.\nexport const getTypeDXN = (obj: AnyProperties): DXN | undefined => {\n  if (!obj) {\n    return undefined;\n  }\n\n  const type = (obj as any)[TypeId];\n  if (!type) {\n    return undefined;\n  }\n\n  invariant(type instanceof DXN, 'Invalid object.');\n  return type;\n};\n\n/**\n * Checks if the object is an instance of the schema.\n * Only typename is compared, the schema version is ignored.\n *\n * The following cases are considered to mean that the object is an instance of the schema:\n *  - Object was created with this exact schema.\n *  - Object was created with a different version of this schema.\n *  - Object was created with a different schema (maybe dynamic) that has the same typename.\n */\n// TODO(burdon): Can we use `Schema.is`?\nexport const isInstanceOf = <Schema extends Schema.Schema.AnyNoContext>(\n  schema: Schema,\n  object: any,\n): object is Schema.Schema.Type<Schema> => {\n  if (object == null) {\n    return false;\n  }\n\n  const schemaDXN = getSchemaDXN(schema);\n  if (!schemaDXN) {\n    throw new Error('Schema must have an object annotation.');\n  }\n\n  const type = getTypeDXN(object);\n  if (type && DXN.equals(type, schemaDXN)) {\n    return true;\n  }\n\n  const typename = getTypename(object);\n  if (!typename) {\n    return false;\n  }\n\n  const typeDXN = schemaDXN.asTypeDXN();\n  if (!typeDXN) {\n    return false;\n  }\n\n  return typeDXN.type === typename;\n};\n\n//\n// PropertyMeta\n//\n\n/**\n * PropertyMeta (metadata for dynamic schema properties).\n * For user-defined annotations.\n */\nexport const PropertyMetaAnnotationId = Symbol.for('@dxos/schema/annotation/PropertyMeta');\n\nexport type PropertyMetaValue = Primitive | Record<string, Primitive> | Primitive[];\n\nexport type PropertyMetaAnnotation = {\n  [name: string]: PropertyMetaValue;\n};\n\n// TODO(wittjosiah): Align with other annotations.\n// TODO(wittjosiah): Why is this separate from FormatAnnotation?\nexport const PropertyMeta = (name: string, value: PropertyMetaValue) => {\n  return <A, I, R>(self: Schema.Schema<A, I, R>): Schema.Schema<A, I, R> => {\n    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId] as PropertyMetaAnnotation;\n    return self.annotations({\n      [PropertyMetaAnnotationId]: {\n        ...existingMeta,\n        [name]: value,\n      },\n    });\n  };\n};\n\nexport const getPropertyMetaAnnotation = <T>(prop: SchemaAST.PropertySignature, name: string) =>\n  Function.pipe(\n    SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(prop.type),\n    Option.map((meta) => meta[name] as T),\n    Option.getOrElse(() => undefined),\n  );\n\n//\n// Reference\n//\n\n/**\n * Schema reference.\n */\nexport const ReferenceAnnotationId = Symbol.for('@dxos/schema/annotation/Reference');\n\nexport type ReferenceAnnotationValue = TypeAnnotation;\n\nexport const getReferenceAnnotation = (schema: Schema.Schema.AnyNoContext) =>\n  Function.pipe(\n    SchemaAST.getAnnotation<ReferenceAnnotationValue>(ReferenceAnnotationId)(schema.ast),\n    Option.getOrElse(() => undefined),\n  );\n\n/**\n * SchemaMeta.\n */\nexport const SchemaMetaSymbol = Symbol.for('@dxos/schema/SchemaMeta');\nexport type SchemaMeta = TypeMeta & { id: string };\n\n/**\n * Identifies a schema as a schema for a hidden system type.\n */\nexport const SystemTypeAnnotationId = Symbol.for('@dxos/schema/annotation/SystemType');\nexport const SystemTypeAnnotation = createAnnotationHelper<boolean>(SystemTypeAnnotationId);\n\n/**\n * Identifies label property or JSON path expression.\n * Either a string or an array of strings representing field accessors each matched in priority order.\n */\nexport const LabelAnnotationId = Symbol.for('@dxos/schema/annotation/Label');\nexport const LabelAnnotation = createAnnotationHelper<string[]>(LabelAnnotationId);\n\n/**\n * Returns the label for a given object based on {@link LabelAnnotationId}.\n */\n// TODO(burdon): Convert to JsonPath?\nexport const getLabel = <S extends Schema.Schema.Any>(schema: S, object: Schema.Schema.Type<S>): string | undefined => {\n  const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => ['name']));\n  for (const accessor of annotation) {\n    assertArgument(\n      typeof accessor === 'string',\n      'accessor',\n      'Label annotation must be a string or an array of strings',\n    );\n    const value = getField(object, accessor as JsonPath);\n    switch (typeof value) {\n      case 'string':\n      case 'number':\n      case 'boolean':\n      case 'bigint':\n      case 'symbol':\n        return value.toString();\n      case 'undefined':\n      case 'object':\n      case 'function':\n        continue;\n    }\n  }\n\n  return undefined;\n};\n\n/**\n * Sets the label for a given object based on {@link LabelAnnotationId}.\n */\nexport const setLabel = <S extends Schema.Schema.Any>(schema: S, object: Schema.Schema.Type<S>, label: string) => {\n  const annotation = LabelAnnotation.get(schema).pipe(\n    Option.map((field) => field[0]),\n    Option.getOrElse(() => 'name'),\n  );\n  object[annotation] = label;\n};\n\n/**\n * Identifies description property or JSON path expression.\n * A string representing field accessor.\n */\nexport const DescriptionAnnotationId = Symbol.for('@dxos/schema/annotation/Description');\nexport const DescriptionAnnotation = createAnnotationHelper<string>(DescriptionAnnotationId);\n\n/**\n * Returns the label for a given object based on {@link LabelAnnotationId}.\n */\n// TODO(burdon): Convert to JsonPath?\nexport const getDescription = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n): string | undefined => {\n  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));\n  assertArgument(typeof accessor === 'string', 'accessor', 'Description annotation must be a string');\n  const value = getField(object, accessor as JsonPath);\n  switch (typeof value) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'bigint':\n    case 'symbol':\n      return value.toString();\n    case 'undefined':\n    case 'object':\n    case 'function':\n    default:\n      return undefined;\n  }\n};\n\n/**\n * Sets the description for a given object based on {@link DescriptionAnnotationId}.\n */\nexport const setDescription = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n  description: string,\n) => {\n  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));\n  object[accessor] = description;\n};\n\n/**\n * Identifies if a property should be included in a form or not.\n * By default, all properties are included in forms, so this is opt-out.\n */\n// TODO(burdon): UI concern.\nexport const FormInputAnnotationId = Symbol.for('@dxos/schema/annotation/FormInput');\nexport const FormInputAnnotation = createAnnotationHelper<boolean>(FormInputAnnotationId);\n\n/**\n * Default field to be used on referenced schema to lookup the value.\n */\nexport const FieldLookupAnnotationId = Symbol.for('@dxos/schema/annotation/FieldLookup');\n\n/**\n * Generate test data.\n */\nexport const GeneratorAnnotationId = Symbol.for('@dxos/schema/annotation/Generator');\n\nexport type GeneratorAnnotationValue =\n  | string\n  | {\n      generator: string;\n      args?: any[];\n      probability?: number;\n    };\n\nexport const GeneratorAnnotation = createAnnotationHelper<GeneratorAnnotationValue>(GeneratorAnnotationId);\n"],
+  "mappings": ";;;;;;;AASO,IAAMA,YAAY;AAKlB,IAAMC,SAASC,OAAOC,IAAI,iBAAA;AAK1B,IAAMC,WAAWF,OAAOC,IAAI,mBAAA;AAS5B,IAAME,YAAY,CAACC,QAAAA;AACxB,MAAIA,KAAK;AACP,WAAQA,IAAYF,QAAAA;EACtB;AACF;AAKO,IAAMG,YAAY,CAACD,KAAUE,WAAAA;AAClCC,SAAOC,eAAeJ,KAAKF,UAAU;IACnCO,OAAOH;IACPI,UAAU;IACVC,YAAY;IACZC,cAAc;EAChB,CAAA;AACF;;;ACxCA,YAAYC,cAAc;AAC1B,YAAYC,YAAY;AACxB,YAAYC,YAAY;AACxB,YAAYC,eAAe;AAE3B,SAASC,aAAa;AACtB,SAASC,iBAAiB;AAC1B,SAAwBC,gBAAgB;AACxC,SAASC,gBAAgBC,iBAAiB;AAC1C,SAASC,WAAW;;AAUb,IAAMC,wBAAwB;AAO9B,IAAMC,YAAY,CAACC,SAAiBC,aAAaH,uBAAuBE,IAAAA;AAUxE,IAAME,6BAA6BC,OAAOC,IAAI,wCAAA;AAE9C,IAAMC,8BAA8B,CAACC,WACjCC,cACGC,wBAAsBN,0BAAAA,GACzBO,iBAAU,MAAMC,MAAAA,CAAAA,EACvBJ,OAAOK,GAAG;AAQP,IAAMC,eAAe,CAACN,WAAAA;AAC3BO,iBAAsBC,gBAASR,MAAAA,GAAS,UAAU,gBAAA;AAClD,QAAMS,KAAKV,4BAA4BC,MAAAA;AACvC,MAAIS,IAAI;AACN,WAAOC,IAAIC,MAAMF,EAAAA;EACnB;AAGA,QAAMG,mBAAmBC,kBAAkBb,MAAAA;AAC3C,MAAI,CAACY,kBAAkB;AACrB,WAAOR;EACT;AAEA,SAAOM,IAAII,uBAAuBF,iBAAiBG,UAAUH,iBAAiBI,OAAO;AACvF;AAMO,IAAMC,mBAAmB,CAACjB,WAAAA;AAC/B,MAAI,CAACA,QAAQ;AACX,WAAOI;EACT;AAEA,QAAMc,YAAYZ,aAAaN,MAAAA;AAC/B,MAAI,CAACkB,WAAW;AACd,WAAOd;EACT;AACA,SAAOe,UAAUC,QAAQF,SAAAA;AAC3B;AAQO,IAAMG,uBAAuB,CAACrB,WAAAA;AACnC,QAAMsB,gBAAgBL,iBAAiBjB,MAAAA;AACvC,MAAIsB,iBAAiB,MAAM;AAEzB,UAAM,IAAIC,MAAM,yCAAA;EAClB;AAEA,SAAOD;AACT;AAMO,IAAME,0BAA0B,CAACC,UAAAA;AACtC,MAAWjB,gBAASiB,KAAAA,GAAQ;AAC1B,WAAOR,iBAAiBQ,KAAAA,GAAQC,MAAAA,KAAWC,MAAM,IAAIC,UAAU,mBAAA,CAAA;EACjE,OAAO;AACLrB,mBAAe,OAAOkB,UAAU,UAAU,OAAA;AAC1ClB,mBAAe,CAACkB,MAAMI,WAAW,MAAA,GAAS,OAAA;AAC1C,WAAOnB,IAAIoB,aAAaL,KAAAA;EAC1B;AACF;AAYO,IAAMM,iBAAwBC,cAAOC,KAAYC,eAAQ,yCAAA,CAAA,EAA4CC,YAC1G;EACEC,aAAa;EACbC,SAAS;AACX,CAAA;AAOK,IAAMC,gBAAuBN,cAAOC,KAAYC,eAAQ,eAAA,CAAA,EAAkBC,YAAY;EAC3FC,aAAa;EACbC,SAAS;AACX,CAAA;AAEO,IAAME,WAAkBC,cAAO;EACpCzB,UAAUgB;EACVf,SAASsB;AACX,CAAA;AAOO,IAAMG,mBAAmB5C,OAAOC,IAAI,8BAAA;AAKpC,IAAM4C,iBAAwBC,cACnCJ,UACOC,cAAO;EACZI,MAAaC,aAAMC,UAAAA;;;;;EAMnBC,cAAqBC,gBAAStC,IAAIuC,MAAM;;;;;EAMxCC,cAAqBF,gBAAStC,IAAIuC,MAAM;AAC1C,CAAA,CAAA;AASK,IAAMpC,oBAAoB,CAACb,WAAAA;AAChCO,iBAAeP,UAAU,QAAQA,OAAOK,OAAO,MAAM,UAAU,gBAAA;AAC/D,SAAgBJ,cACJC,wBAA8BuC,gBAAAA,GACjCtC,iBAAU,MAAMC,MAAAA,CAAAA,EACvBJ,OAAOK,GAAG;AACd;AAKO,IAAM8C,gBAAgB,CAACnD,WAAsDa,kBAAkBb,MAAAA,GAAS4C;AAMxG,IAAMQ,oBAAoB,CAACpD,WAAkDa,kBAAkBb,MAAAA,GAASe;AAMxG,IAAMsC,mBAAmB,CAACrD,WAAkDa,kBAAkBb,MAAAA,GAASgB;AASvG,IAAMsC,cAAc,CAACC,QAAAA;AAC1B,QAAMvD,SAASwD,UAAUD,GAAAA;AACzB,MAAIvD,UAAU,MAAM;AAElB,WAAOoD,kBAAkBpD,MAAAA;EAC3B,OAAO;AACL,UAAMyD,OAAOC,WAAWH,GAAAA;AACxB,WAAOE,MAAME,UAAAA,GAAaF;EAC5B;AACF;AAMO,IAAMG,cAAc,CAACL,KAAUxC,aAAAA;AACpC8C,YAAU9C,oBAAoBL,KAAK,iBAAA;;;;;;;;;AACnCoD,SAAOC,eAAeR,KAAKS,QAAQ;IACjCC,OAAOlD;IACPmD,UAAU;IACVC,YAAY;IACZC,cAAc;EAChB,CAAA;AACF;AAUO,IAAMV,aAAa,CAACH,QAAAA;AACzB,MAAI,CAACA,KAAK;AACR,WAAOnD;EACT;AAEA,QAAMqD,OAAQF,IAAYS,MAAAA;AAC1B,MAAI,CAACP,MAAM;AACT,WAAOrD;EACT;AAEAyD,YAAUJ,gBAAgB/C,KAAK,mBAAA;;;;;;;;;AAC/B,SAAO+C;AACT;AAYO,IAAMY,eAAe,CAC1BrE,QACAsE,WAAAA;AAEA,MAAIA,UAAU,MAAM;AAClB,WAAO;EACT;AAEA,QAAMpD,YAAYZ,aAAaN,MAAAA;AAC/B,MAAI,CAACkB,WAAW;AACd,UAAM,IAAIK,MAAM,wCAAA;EAClB;AAEA,QAAMkC,OAAOC,WAAWY,MAAAA;AACxB,MAAIb,QAAQ/C,IAAI6D,OAAOd,MAAMvC,SAAAA,GAAY;AACvC,WAAO;EACT;AAEA,QAAMH,WAAWuC,YAAYgB,MAAAA;AAC7B,MAAI,CAACvD,UAAU;AACb,WAAO;EACT;AAEA,QAAMyD,UAAUtD,UAAUyC,UAAS;AACnC,MAAI,CAACa,SAAS;AACZ,WAAO;EACT;AAEA,SAAOA,QAAQf,SAAS1C;AAC1B;AAUO,IAAM0D,2BAA2B5E,OAAOC,IAAI,sCAAA;AAU5C,IAAMH,eAAe,CAAC+E,MAAcT,UAAAA;AACzC,SAAO,CAAUU,SAAAA;AACf,UAAMC,eAAeD,KAAKtE,IAAI8B,YAAYsC,wBAAAA;AAC1C,WAAOE,KAAKxC,YAAY;MACtB,CAACsC,wBAAAA,GAA2B;QAC1B,GAAGG;QACH,CAACF,IAAAA,GAAOT;MACV;IACF,CAAA;EACF;AACF;AAEO,IAAMY,4BAA4B,CAAIC,MAAmCJ,SACrEzC,cACG/B,wBAAsCuE,wBAAAA,EAA0BK,KAAKrB,IAAI,GAC5EsB,WAAI,CAACC,SAASA,KAAKN,IAAAA,CAAK,GACxBvE,iBAAU,MAAMC,MAAAA,CAAAA;AAUpB,IAAM6E,wBAAwBpF,OAAOC,IAAI,mCAAA;AAIzC,IAAMoF,yBAAyB,CAAClF,WAC5BiC,cACG/B,wBAAwC+E,qBAAAA,EAAuBjF,OAAOK,GAAG,GAC5EF,iBAAU,MAAMC,MAAAA,CAAAA;AAMpB,IAAM+E,mBAAmBtF,OAAOC,IAAI,yBAAA;AAMpC,IAAMsF,yBAAyBvF,OAAOC,IAAI,oCAAA;AAC1C,IAAMuF,uBAAuBC,uBAAgCF,sBAAAA;AAM7D,IAAMG,oBAAoB1F,OAAOC,IAAI,+BAAA;AACrC,IAAM0F,kBAAkBF,uBAAiCC,iBAAAA;AAMzD,IAAME,WAAW,CAA8BzF,QAAWsE,WAAAA;AAC/D,QAAMoB,aAAaF,gBAAgBG,IAAI3F,MAAAA,EAAQiC,KAAY9B,iBAAU,MAAM;IAAC;GAAO,CAAA;AACnF,aAAWyF,YAAYF,YAAY;AACjCnF,mBACE,OAAOqF,aAAa,UACpB,YACA,0DAAA;AAEF,UAAM3B,QAAQ4B,SAASvB,QAAQsB,QAAAA;AAC/B,YAAQ,OAAO3B,OAAAA;MACb,KAAK;MACL,KAAK;MACL,KAAK;MACL,KAAK;MACL,KAAK;AACH,eAAOA,MAAM6B,SAAQ;MACvB,KAAK;MACL,KAAK;MACL,KAAK;AACH;IACJ;EACF;AAEA,SAAO1F;AACT;AAKO,IAAM2F,WAAW,CAA8B/F,QAAWsE,QAA+B0B,UAAAA;AAC9F,QAAMN,aAAaF,gBAAgBG,IAAI3F,MAAAA,EAAQiC,KACtC8C,WAAI,CAACkB,UAAUA,MAAM,CAAA,CAAE,GACvB9F,iBAAU,MAAM,MAAA,CAAA;AAEzBmE,SAAOoB,UAAAA,IAAcM;AACvB;AAMO,IAAME,0BAA0BrG,OAAOC,IAAI,qCAAA;AAC3C,IAAMqG,wBAAwBb,uBAA+BY,uBAAAA;AAM7D,IAAME,iBAAiB,CAC5BpG,QACAsE,WAAAA;AAEA,QAAMsB,WAAWO,sBAAsBR,IAAI3F,MAAAA,EAAQiC,KAAY9B,iBAAU,MAAM,aAAA,CAAA;AAC/EI,iBAAe,OAAOqF,aAAa,UAAU,YAAY,yCAAA;AACzD,QAAM3B,QAAQ4B,SAASvB,QAAQsB,QAAAA;AAC/B,UAAQ,OAAO3B,OAAAA;IACb,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;AACH,aAAOA,MAAM6B,SAAQ;IACvB,KAAK;IACL,KAAK;IACL,KAAK;IACL;AACE,aAAO1F;EACX;AACF;AAKO,IAAMiG,iBAAiB,CAC5BrG,QACAsE,QACAlC,gBAAAA;AAEA,QAAMwD,WAAWO,sBAAsBR,IAAI3F,MAAAA,EAAQiC,KAAY9B,iBAAU,MAAM,aAAA,CAAA;AAC/EmE,SAAOsB,QAAAA,IAAYxD;AACrB;AAOO,IAAMkE,wBAAwBzG,OAAOC,IAAI,mCAAA;AACzC,IAAMyG,sBAAsBjB,uBAAgCgB,qBAAAA;AAK5D,IAAME,0BAA0B3G,OAAOC,IAAI,qCAAA;AAK3C,IAAM2G,wBAAwB5G,OAAOC,IAAI,mCAAA;AAUzC,IAAM4G,sBAAsBpB,uBAAiDmB,qBAAAA;",
+  "names": ["ATTR_TYPE", "TypeId", "Symbol", "for", "SchemaId", "getSchema", "obj", "setSchema", "schema", "Object", "defineProperty", "value", "writable", "enumerable", "configurable", "Function", "Option", "Schema", "SchemaAST", "raise", "Reference", "getField", "assertArgument", "invariant", "DXN", "FIELD_PATH_ANNOTATION", "FieldPath", "path", "PropertyMeta", "TypeIdentifierAnnotationId", "Symbol", "for", "getTypeIdentifierAnnotation", "schema", "flow", "getAnnotation", "getOrElse", "undefined", "ast", "getSchemaDXN", "assertArgument", "isSchema", "id", "DXN", "parse", "objectAnnotation", "getTypeAnnotation", "fromTypenameAndVersion", "typename", "version", "getTypeReference", "schemaDXN", "Reference", "fromDXN", "requireTypeReference", "typeReference", "Error", "getTypeDXNFromSpecifier", "input", "toDXN", "raise", "TypeError", "startsWith", "fromTypename", "TypenameSchema", "String", "pipe", "pattern", "annotations", "description", "example", "VersionSchema", "TypeMeta", "Struct", "TypeAnnotationId", "TypeAnnotation", "extend", "kind", "Enums", "EntityKind", "sourceSchema", "optional", "Schema", "targetSchema", "getEntityKind", "getSchemaTypename", "getSchemaVersion", "getTypename", "obj", "getSchema", "type", "getTypeDXN", "asTypeDXN", "setTypename", "invariant", "Object", "defineProperty", "TypeId", "value", "writable", "enumerable", "configurable", "isInstanceOf", "object", "equals", "typeDXN", "PropertyMetaAnnotationId", "name", "self", "existingMeta", "getPropertyMetaAnnotation", "prop", "map", "meta", "ReferenceAnnotationId", "getReferenceAnnotation", "SchemaMetaSymbol", "SystemTypeAnnotationId", "SystemTypeAnnotation", "createAnnotationHelper", "LabelAnnotationId", "LabelAnnotation", "getLabel", "annotation", "get", "accessor", "getField", "toString", "setLabel", "label", "field", "DescriptionAnnotationId", "DescriptionAnnotation", "getDescription", "setDescription", "FormInputAnnotationId", "FormInputAnnotation", "FieldLookupAnnotationId", "GeneratorAnnotationId", "GeneratorAnnotation"]
+}

package/dist/lib/node-esm/chunk-76LEDWHO.mjs

@@ -0,0 +1,152 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Any
+} from "./chunk-BJACR7QG.mjs";
+import {
+  Relation
+} from "./chunk-FWTPV5QD.mjs";
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  MetaId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  getObjectDXN,
+  makeObject
+} from "./chunk-DJX53IQ3.mjs";
+import {
+  getTypeAnnotation
+} from "./chunk-6OTQZKHX.mjs";
+import {
+  EntityKind,
+  KindId
+} from "./chunk-NHYOREKX.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// 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/type/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 makeObject(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[KindId];
+  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: 124,
+    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: 136,
+    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: 148,
+    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: 160,
+    S: void 0,
+    A: [
+      "obj !== undefined",
+      "`Invalid target: ${relation.id}`"
+    ]
+  });
+  return obj;
+};
+
+export {
+  Any2 as Any,
+  Source,
+  Target,
+  make,
+  isRelation,
+  getSourceDXN,
+  getTargetDXN,
+  getSource,
+  getTarget,
+  Relation_exports
+};
+//# sourceMappingURL=chunk-76LEDWHO.mjs.map

package/dist/lib/node-esm/chunk-76LEDWHO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Relation.ts"],
+  "sourcesContent": ["//\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, type ObjectId } from '@dxos/keys';\nimport { type Live } from '@dxos/live-object';\nimport { assumeType } from '@dxos/util';\n\nimport * as Entity from './Entity';\nimport {\n  ATTR_RELATION_SOURCE,\n  ATTR_RELATION_TARGET,\n  type AnyEchoObject,\n  EntityKind,\n  type InternalObjectProps,\n  MetaId,\n  type ObjectMeta,\n  RelationSourceDXNId,\n  RelationSourceId,\n  RelationTargetDXNId,\n  RelationTargetId,\n  getObjectDXN,\n  getTypeAnnotation,\n  makeObject,\n} from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends AnyEchoObject,\n    Type.Relation.Endpoints<Source, Target>,\n    Entity.OfKind<EntityKind.Relation> {}\n\n/**\n * Base type for all Relations objects.\n */\nexport interface Any extends BaseRelation<Obj.Any, Obj.Any> {}\n\nexport const Any = Schema.Struct({}).pipe(\n  Type.Relation({\n    typename: 'dxos.org/type/Any',\n    version: '0.1.0',\n    source: Obj.Any,\n    target: Obj.Any,\n  }),\n);\n\n/**\n * Relation type with specific source and target types.\n */\nexport type Relation<Source extends Obj.Any, Target extends Obj.Any, Props> = BaseRelation<Source, Target> & Props;\n\nexport const Source: unique symbol = RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = RelationTargetId as any;\nexport type Target = typeof Target;\n\ntype MakeProps<T extends Any> = {\n  id?: ObjectId;\n  [MetaId]?: ObjectMeta;\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?: ObjectMeta,\n): Live<Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation>> => {\n  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, 'schema', 'Expected a relation schema');\n\n  if (props[MetaId] != null) {\n    meta = props[MetaId] as any;\n    delete props[MetaId];\n  }\n\n  const sourceDXN = getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[RelationSourceDXNId] = sourceDXN;\n  (props as any)[RelationTargetDXNId] = targetDXN;\n\n  return makeObject<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 (ATTR_RELATION_SOURCE in value || ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  const kind = (value as any)[Entity.KindId];\n  return kind === 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<InternalObjectProps>(value);\n  const dxn = (value as InternalObjectProps)[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<InternalObjectProps>(value);\n  const dxn = (value as InternalObjectProps)[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<InternalObjectProps>(relation);\n  const obj = (relation as InternalObjectProps)[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<InternalObjectProps>(relation);\n  const obj = (relation as InternalObjectProps)[RelationTargetId];\n  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\n  return obj as Type.Relation.Target<T>;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;aAAAA;EAAA;;;;;;;;;AAIA,YAAYC,YAAY;AAExB,SAASC,aAAa;AACtB,SAASC,gBAAgBC,iBAAiB;AAC1C,SAASC,WAA0B;AAEnC,SAASC,kBAAkB;;AAoCpB,IAAMC,OAAaC,cAAO,CAAC,CAAA,EAAGC,KAC9BC,SAAS;EACZC,UAAU;EACVC,SAAS;EACTC,QAAYN;EACZO,QAAYP;AACd,CAAA,CAAA;AAQK,IAAMQ,SAAwBC;AAG9B,IAAMC,SAAwBC;AAmB9B,IAAMC,OAAO,CAClBC,QACAC,OACAC,SAAAA;AAEAC,iBAAeC,kBAAkBJ,MAAAA,GAASK,SAASC,WAAWhB,UAAU,UAAU,4BAAA;AAElF,MAAIW,MAAMM,MAAAA,KAAW,MAAM;AACzBL,WAAOD,MAAMM,MAAAA;AACb,WAAON,MAAMM,MAAAA;EACf;AAEA,QAAMC,YAAYC,aAAaR,MAAMN,MAAAA,CAAO,KAAKe,MAAM,IAAIC,MAAM,4BAAA,CAAA;AACjE,QAAMC,YAAYH,aAAaR,MAAMJ,MAAAA,CAAO,KAAKa,MAAM,IAAIC,MAAM,4BAAA,CAAA;AAEhEV,QAAcY,mBAAAA,IAAuBL;AACrCP,QAAca,mBAAAA,IAAuBF;AAEtC,SAAOG,WAAkCf,QAAQC,OAAcC,IAAAA;AACjE;AAEO,IAAMc,aAAa,CAACC,UAAAA;AACzB,MAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;AAC/C,WAAO;EACT;AACA,MAAIC,wBAAwBD,SAASE,wBAAwBF,OAAO;AAClE,WAAO;EACT;AAEA,QAAMZ,OAAQY,MAAqBG,MAAM;AACzC,SAAOf,SAASC,WAAWhB;AAC7B;AAMO,IAAM+B,eAAe,CAACJ,UAAAA;AAC3Bd,iBAAea,WAAWC,KAAAA,GAAQ,qBAAA;AAClCK,aAAgCL,KAAAA;AAChC,QAAMM,MAAON,MAA8BJ,mBAAAA;AAC3CW,YAAUD,eAAeE,KAAAA,QAAAA;;;;;;;;;AACzB,SAAOF;AACT;AAMO,IAAMG,eAAe,CAACT,UAAAA;AAC3Bd,iBAAea,WAAWC,KAAAA,GAAQ,qBAAA;AAClCK,aAAgCL,KAAAA;AAChC,QAAMM,MAAON,MAA8BH,mBAAAA;AAC3CU,YAAUD,eAAeE,KAAAA,QAAAA;;;;;;;;;AACzB,SAAOF;AACT;AAMO,IAAMI,YAAY,CAAgBC,aAAAA;AACvCzB,iBAAea,WAAWY,QAAAA,GAAW,qBAAA;AACrCN,aAAgCM,QAAAA;AAChC,QAAMC,MAAOD,SAAiChC,gBAAAA;AAC9C4B,YAAUK,QAAQC,QAAW,mBAAmBF,SAASG,EAAE,IAAE;;;;;;;;;AAC7D,SAAOF;AACT;AAMO,IAAMG,YAAY,CAAgBJ,aAAAA;AACvCzB,iBAAea,WAAWY,QAAAA,GAAW,qBAAA;AACrCN,aAAgCM,QAAAA;AAChC,QAAMC,MAAOD,SAAiC9B,gBAAAA;AAC9C0B,YAAUK,QAAQC,QAAW,mBAAmBF,SAASG,EAAE,IAAE;;;;;;;;;AAC7D,SAAOF;AACT;",
+  "names": ["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", "makeObject", "isRelation", "value", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "KindId", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "undefined", "id", "getTarget"]
+}

package/dist/lib/node-esm/chunk-AGHZH33D.mjs

@@ -0,0 +1,9 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/QueryResult.ts
+var QueryResult_exports = {};
+
+export {
+  QueryResult_exports
+};
+//# sourceMappingURL=chunk-AGHZH33D.mjs.map

package/dist/lib/node-esm/chunk-AGHZH33D.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/QueryResult.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type CleanupFn } from '@dxos/async';\n\nimport type * as Entity from './Entity';\n\n/**\n * Individual query result entry.\n */\nexport type Entry<T> = {\n  id: string;\n\n  /**\n   * May not be present for remote results.\n   */\n  result?: T;\n\n  match?: {\n    // TODO(dmaretskyi): text positional info.\n\n    /**\n     * Higher means better match.\n     */\n    rank: number;\n  };\n\n  /**\n   * Query resolution metadata.\n   */\n  // TODO(dmaretskyi): Rename to meta?\n  resolution?: {\n    // TODO(dmaretskyi): Make this more generic.\n    source: 'remote' | 'local' | 'index';\n\n    /**\n     * Query resolution time in milliseconds.\n     */\n    time: number;\n  };\n};\n\n/**\n * Invidual query result entry for a database Entity.\n */\nexport type EntityEntry<T extends Entity.Unknown = Entity.Unknown> = Entry<T>;\n\nexport type RunOptions = {\n  timeout?: number;\n};\n\nexport type SubscriptionOptions = {\n  /**\n   * Fire the callback immediately.\n   */\n  fire?: boolean;\n};\n\nexport interface QueryResult<T> {\n  /**\n   * Currently available results along with their match metadata.\n   *\n   * @reactive\n   */\n  readonly entries: Entry<T>[];\n\n  /**\n   * Currently available results.\n   *\n   * @reactive\n   */\n  readonly results: T[];\n\n  /**\n   * Returns all known results.\n   */\n  run(opts?: RunOptions): Promise<T[]>;\n\n  /**\n   * Returns all known results along with their match metadata.\n   */\n  runEntries(opts?: RunOptions): Promise<Entry<T>[]>;\n\n  /**\n   * Returns currently available results synchronously.\n   */\n  runSync(): T[];\n\n  /**\n   * Returns currently available results synchronously along with their match metadata.\n   */\n  runSyncEntries(): Entry<T>[];\n\n  /**\n   * Returns first result.\n   */\n  first(opts?: RunOptions): Promise<T>;\n\n  /**\n   * Returns first result if there is one.\n   */\n  firstOrUndefined(opts?: RunOptions): Promise<T | undefined>;\n\n  /**\n   * Subscribes to changes in query results.\n   */\n  subscribe(callback?: (query: QueryResult<T>) => void, opts?: SubscriptionOptions): CleanupFn;\n}\n"],
+  "mappings": ";;;AAAA;",
+  "names": []
+}

package/dist/lib/node-esm/chunk-AJEMYSIR.mjs

@@ -0,0 +1,22 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Key.ts
+var Key_exports = {};
+__export(Key_exports, {
+  ForeignKey: () => ForeignKey,
+  ObjectId: () => ObjectId,
+  SpaceId: () => SpaceId
+});
+import { ForeignKey } from "@dxos/echo-protocol";
+import { SpaceId, ObjectId } from "@dxos/keys";
+
+export {
+  Key_exports,
+  ForeignKey,
+  SpaceId,
+  ObjectId
+};
+//# sourceMappingURL=chunk-AJEMYSIR.mjs.map

package/dist/lib/node-esm/chunk-AJEMYSIR.mjs.map

@@ -0,0 +1,7 @@
+{
+  "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"]
+}