@dxos/echo 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Filter.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Function from 'effect/Function';\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 { EID, EntityId, type URI } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport * as internal from './internal';\nimport type * as Obj from './Obj';\nimport * as Ref from './Ref';\n// eslint-disable-next-line @dxos/rules/import-as-namespace\nimport type * as Type$ from './Type';\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 EntityId.\n */\nexport const id = (...ids: EntityId[]): Any => {\n  assertArgument(\n    ids.every((id) => EntityId.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 *\n * Accepts a `Type.Type` entity (the value produced by `Type.makeObject` /\n * `Type.makeRelation`), a `Schema.Union` of such entities (for filtering across a\n * union of ECHO types), or a fully-qualified type URI — an `echo:` EID (stored schema)\n * or a `dxn:` DXN (static schema). To filter by a bare typename, wrap it: `DXN.make(typename)`.\n */\nexport const type: {\n  <T extends Type$.AnyEntity>(type: T, props?: Props<Type$.InstanceType<T>>): Filter<Type$.InstanceType<T>>;\n  // Schema-side overload restricted to the well-known unknown schemas and to\n  // `Schema.Union(...)` of `Type.Type` entities (for filtering across a union\n  // of ECHO types). Other raw schemas are rejected.\n  <S extends internal.UnknownTypeSchema<any, any>>(\n    schema: S,\n    props?: Props<Schema.Schema.Type<S>>,\n  ): Filter<Schema.Schema.Type<S>>;\n  <S extends Schema.Union<readonly Schema.Schema.AnyNoContext[]>>(\n    union: S,\n    props?: Props<Schema.Schema.Type<S>>,\n  ): Filter<Schema.Schema.Type<S>>;\n  (uri: URI.URI, props?: Props<unknown>): Filter<any>;\n  // Passthrough overload for callers that hold a `Type.AnyEntity | URI.URI` union\n  // (e.g. Query.type / Query.sourceOf / Query.targetOf impls). Listed last so the\n  // typed overloads above still win for monomorphic inputs.\n  (input: Type$.AnyEntity | URI.URI, props?: Props<unknown>): Filter<unknown>;\n} = (input: Type$.AnyEntity | Schema.Schema.AnyNoContext | URI.URI, props?: Props<unknown>): any => {\n  if (Schema.isSchema(input) && SchemaAST.isUnion(input.ast)) {\n    const typenames = input.ast.types.map((t) => internal.getTypeURIFromSpecifier(Schema.make(t)));\n    return new FilterClass({\n      type: 'or',\n      filters: typenames.map((typename) => ({\n        type: 'object',\n        typename,\n        props: {},\n      })),\n    });\n  }\n\n  const uri = internal.getTypeURIFromSpecifier(input);\n  return new FilterClass({\n    type: 'object',\n    typename: uri,\n    ...propsFilterToAst(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 Type$.AnyEntity | URI.URI>(\n  schema: S,\n  keys: ForeignKey[],\n): Filter<S extends Type$.AnyEntity ? Type$.InstanceType<S> : unknown> => {\n  const uri = internal.getTypeURIFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: uri,\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.getURI}.\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 EID.parse(item.uri);\n    }\n    return EID.parse(internal.getUri(item));\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 EntityId[] | 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(EntityId).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\n/**\n * Create a predicate from a filter.\n */\nexport const toPredicate: {\n  <T extends Entity.Unknown>(filter: Filter<T>): (entity: Entity.Unknown) => entity is T;\n  <T extends Entity.Unknown>(entity: Entity.Unknown, filter: Filter<T>): entity is T;\n} = Function.dual<\n  <T extends Entity.Unknown>(filter: Filter<T>) => (entity: Entity.Unknown) => entity is T,\n  <T extends Entity.Unknown>(entity: Entity.Unknown, filter: Filter<T>) => entity is T\n>(2, <T extends Entity.Unknown>(entity: Entity.Unknown, filter: Filter<T>): entity is T =>\n  internal.filterMatchEntity(filter.ast, entity),\n);\n"],
+  "mappings": "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",
+  "names": ["Function", "Match", "Schema", "SchemaAST", "assertArgument", "EID", "EntityId", "FilterClass", "ast", "variance", "is", "value", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "id", "ids", "assertArgument", "every", "EntityId", "isValid", "length", "input", "isSchema", "isUnion", "typenames", "types", "map", "t", "getTypeURIFromSpecifier", "make", "filters", "uri", "propsFilterToAst", "tag", "key", "options", "metaKey", "metaVersion", "version", "text", "searchKind", "foreignKeys", "schema", "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", "EID", "parse", "uri", "getUri", "transitive", "not", "filter", "ast", "f", "or", "propsFilterToAst", "predicates", "idFilter", "assertArgument", "id", "Schema", "EntityId", "pipe", "validateSync", "props", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "is", "_predicate", "Error", "nestedProps", "key", "typename", "orElse", "eq", "pretty", "prettyFilter", "toPredicate", "dual", "entity", "filterMatchEntity"]
+}

package/dist/lib/neutral/{chunk-BBFJWWAV.mjs → chunk-TOCVVFK2.mjs}

@@ -7,7 +7,9 @@ var Err_exports = {};
 __export(Err_exports, {
   EntityNotFoundError: () => EntityNotFoundError,
   GetReactiveError: () => GetReactiveError,
-  SchemaNotFoundError: () => SchemaNotFoundError
+  SchemaNotFoundError: () => SchemaNotFoundError,
+  TextEditNotFoundError: () => TextEditNotFoundError,
+  TextNotSupportedError: () => TextNotSupportedError
 });
 import { BaseError } from "@dxos/errors";
 var SchemaNotFoundError = class extends BaseError.extend("SchemaNotFoundError", "Schema not found") {
@@ -30,6 +32,26 @@ var EntityNotFoundError = class extends BaseError.extend("EntityNotFoundError",
     });
   }
 };
+var TextNotSupportedError = class extends BaseError.extend("TextNotSupportedError", "Text operation is not supported for this object") {
+  constructor(operation, options) {
+    super({
+      context: {
+        operation
+      },
+      ...options
+    });
+  }
+};
+var TextEditNotFoundError = class extends BaseError.extend("TextEditNotFoundError", "Edit text not found") {
+  constructor(oldString, options) {
+    super({
+      context: {
+        oldString
+      },
+      ...options
+    });
+  }
+};
 var GetReactiveError = class extends BaseError.extend("GetReactiveError", "Failed to get reactive object from snapshot") {
   constructor(options) {
     super({
@@ -45,7 +67,9 @@ var GetReactiveError = class extends BaseError.extend("GetReactiveError", "Faile
 export {
   SchemaNotFoundError,
   EntityNotFoundError,
+  TextNotSupportedError,
+  TextEditNotFoundError,
   GetReactiveError,
   Err_exports
 };
-//# sourceMappingURL=chunk-BBFJWWAV.mjs.map
+//# sourceMappingURL=chunk-TOCVVFK2.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Err.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\nimport { type URI } from '@dxos/keys';\n\nexport class SchemaNotFoundError extends BaseError.extend('SchemaNotFoundError', 'Schema not found') {\n  constructor(schema: string, options?: BaseErrorOptions) {\n    super({ context: { schema }, ...options });\n  }\n}\n\nexport class EntityNotFoundError extends BaseError.extend('EntityNotFoundError', 'Entity not found') {\n  constructor(uri: URI.URI, options?: BaseErrorOptions) {\n    super({ context: { uri }, ...options });\n  }\n}\n\n/**\n * Thrown when a `Text` mutation is attempted on an object whose reactive handler does not implement\n * string CRDT editing (e.g. a snapshot or a non-reactive value).\n */\nexport class TextNotSupportedError extends BaseError.extend(\n  'TextNotSupportedError',\n  'Text operation is not supported for this object',\n) {\n  constructor(operation: string, options?: BaseErrorOptions) {\n    super({ context: { operation }, ...options });\n  }\n}\n\n/**\n * Thrown by `Text.apply` when a non-`replaceAll` edit's `oldString` is not found in the text.\n */\nexport class TextEditNotFoundError extends BaseError.extend('TextEditNotFoundError', 'Edit text not found') {\n  constructor(oldString: string, options?: BaseErrorOptions) {\n    super({ context: { oldString }, ...options });\n  }\n}\n\n/**\n * Reason why getting a reactive object from a snapshot failed.\n * - `no-database`: The snapshot is not associated with a database.\n * - `object-not-found`: The object was removed or does not exist in the database.\n */\nexport type GetReactiveErrorReason = 'no-database' | 'object-not-found';\n\n/**\n * Error thrown when a reactive object cannot be resolved from a snapshot.\n * Extends `BaseError` with a `reason` and optional `snapshotId` in its context.\n */\nexport class GetReactiveError extends BaseError.extend(\n  'GetReactiveError',\n  'Failed to get reactive object from snapshot',\n) {\n  constructor(options: { reason: GetReactiveErrorReason; snapshotId?: string } & BaseErrorOptions) {\n    super({ context: { reason: options.reason, snapshotId: options.snapshotId }, ...options });\n  }\n}\n"],
+  "mappings": ";;;;;AAAA;;;;;;;;AAMA,SAASA,iBAAwC;AAG1C,IAAMC,sBAAN,cAAkCD,UAAUE,OAAO,uBAAuB,kBAAA,EAAA;EAC/E,YAAYC,QAAgBC,SAA4B;AACtD,UAAM;MAAEC,SAAS;QAAEF;MAAO;MAAG,GAAGC;IAAQ,CAAA;EAC1C;AACF;AAEO,IAAME,sBAAN,cAAkCN,UAAUE,OAAO,uBAAuB,kBAAA,EAAA;EAC/E,YAAYK,KAAcH,SAA4B;AACpD,UAAM;MAAEC,SAAS;QAAEE;MAAI;MAAG,GAAGH;IAAQ,CAAA;EACvC;AACF;AAMO,IAAMI,wBAAN,cAAoCR,UAAUE,OACnD,yBACA,iDAAA,EAAA;EAEA,YAAYO,WAAmBL,SAA4B;AACzD,UAAM;MAAEC,SAAS;QAAEI;MAAU;MAAG,GAAGL;IAAQ,CAAA;EAC7C;AACF;AAKO,IAAMM,wBAAN,cAAoCV,UAAUE,OAAO,yBAAyB,qBAAA,EAAA;EACnF,YAAYS,WAAmBP,SAA4B;AACzD,UAAM;MAAEC,SAAS;QAAEM;MAAU;MAAG,GAAGP;IAAQ,CAAA;EAC7C;AACF;AAaO,IAAMQ,mBAAN,cAA+BZ,UAAUE,OAC9C,oBACA,6CAAA,EAAA;EAEA,YAAYE,SAAqF;AAC/F,UAAM;MAAEC,SAAS;QAAEQ,QAAQT,QAAQS;QAAQC,YAAYV,QAAQU;MAAW;MAAG,GAAGV;IAAQ,CAAA;EAC1F;AACF;",
+  "names": ["BaseError", "SchemaNotFoundError", "extend", "schema", "options", "context", "EntityNotFoundError", "uri", "TextNotSupportedError", "operation", "TextEditNotFoundError", "oldString", "GetReactiveError", "reason", "snapshotId"]
+}

package/dist/lib/neutral/{chunk-A53NTBHE.mjs → chunk-U53LSQQA.mjs}

@@ -1,9 +1,9 @@
 import {
   getSchema
-} from "./chunk-HGWQR5KH.mjs";
+} from "./chunk-XB6ISRAO.mjs";
 import {
   getSchemaURI
-} from "./chunk-WZ32BF53.mjs";
+} from "./chunk-3TN2VMI4.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -38,4 +38,4 @@ export {
   define,
   Migration_exports
 };
-//# sourceMappingURL=chunk-A53NTBHE.mjs.map
+//# sourceMappingURL=chunk-U53LSQQA.mjs.map

package/dist/lib/neutral/{chunk-A53NTBHE.mjs.map → chunk-U53LSQQA.mjs.map}

@@ -1,7 +1,7 @@
 {
   "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 URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport { MetaId, type EntityMeta, getSchemaURI } from './internal';\nimport * as Type from './Type';\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 */\ntype MigrationSchemaInput = Type.AnyEntity;\n\ntype MigrationInstanceType<S> = S extends Type.AnyEntity\n  ? Type.InstanceType<S>\n  : S extends Schema.Schema.AnyNoContext\n    ? Schema.Schema.Type<S>\n    : never;\n\nexport type TransformResult<To> = Omit<MigrationInstanceType<To>, 'id' | Entity.KindId> & {\n  [MetaId]?: Partial<EntityMeta>;\n};\n\ntype DefineObjectMigrationOptions<From extends MigrationSchemaInput, To extends MigrationSchemaInput> = {\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: MigrationInstanceType<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, To> = {\n  before: MigrationInstanceType<From>;\n  object: MigrationInstanceType<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: URI.URI;\n  toType: URI.URI;\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 MigrationSchemaInput, To extends MigrationSchemaInput>(\n  options: DefineObjectMigrationOptions<From, To>,\n): ObjectMigration => {\n  const fromSchema = Type.getSchema(options.from);\n  const toSchema = Type.getSchema(options.to);\n  const fromType = getSchemaURI(fromSchema);\n  if (!fromType) {\n    throw new Error('Invalid from schema');\n  }\n  const toType = getSchemaURI(toSchema);\n  if (!toType) {\n    throw new Error('Invalid to schema');\n  }\n\n  return {\n    fromType,\n    toType,\n    fromSchema,\n    toSchema,\n    transform: options.transform as any,\n    onMigration: options.onMigration as any,\n  };\n};\n"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport { type EntityMeta, MetaId, getSchemaURI } from './internal';\nimport * as Type from './Type';\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 */\ntype MigrationSchemaInput = Type.AnyEntity;\n\ntype MigrationInstanceType<S> = S extends Type.AnyEntity\n  ? Type.InstanceType<S>\n  : S extends Schema.Schema.AnyNoContext\n    ? Schema.Schema.Type<S>\n    : never;\n\nexport type TransformResult<To> = Omit<MigrationInstanceType<To>, 'id' | Entity.KindId> & {\n  [MetaId]?: Partial<EntityMeta>;\n};\n\ntype DefineObjectMigrationOptions<From extends MigrationSchemaInput, To extends MigrationSchemaInput> = {\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: MigrationInstanceType<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, To> = {\n  before: MigrationInstanceType<From>;\n  object: MigrationInstanceType<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: URI.URI;\n  toType: URI.URI;\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 MigrationSchemaInput, To extends MigrationSchemaInput>(\n  options: DefineObjectMigrationOptions<From, To>,\n): ObjectMigration => {\n  const fromSchema = Type.getSchema(options.from);\n  const toSchema = Type.getSchema(options.to);\n  const fromType = getSchemaURI(fromSchema);\n  if (!fromType) {\n    throw new Error('Invalid from schema');\n  }\n  const toType = getSchemaURI(toSchema);\n  if (!toType) {\n    throw new Error('Invalid to schema');\n  }\n\n  return {\n    fromType,\n    toType,\n    fromSchema,\n    toSchema,\n    transform: options.transform as any,\n    onMigration: options.onMigration as any,\n  };\n};\n"],
   "mappings": ";;;;;;;;;;;AAAA;;;;AA2FO,IAAMA,SAAS,CACpBC,YAAAA;AAEA,QAAMC,aAAkBC,UAAUF,QAAQG,IAAI;AAC9C,QAAMC,WAAgBF,UAAUF,QAAQK,EAAE;AAC1C,QAAMC,WAAWC,aAAaN,UAAAA;AAC9B,MAAI,CAACK,UAAU;AACb,UAAM,IAAIE,MAAM,qBAAA;EAClB;AACA,QAAMC,SAASF,aAAaH,QAAAA;AAC5B,MAAI,CAACK,QAAQ;AACX,UAAM,IAAID,MAAM,mBAAA;EAClB;AAEA,SAAO;IACLF;IACAG;IACAR;IACAG;IACAM,WAAWV,QAAQU;IACnBC,aAAaX,QAAQW;EACvB;AACF;",
   "names": ["define", "options", "fromSchema", "getSchema", "from", "toSchema", "to", "fromType", "getSchemaURI", "Error", "toType", "transform", "onMigration"]
 }

package/dist/lib/neutral/{chunk-PLDMJJJC.mjs → chunk-UGFFV2FR.mjs}

@@ -2,7 +2,7 @@ import {
   JsonSchemaType,
   toEffectSchema,
   toJsonSchema
-} from "./chunk-K3S7D5PR.mjs";
+} from "./chunk-4A2NWKRJ.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -24,4 +24,4 @@ export {
   JsonSchema,
   JsonSchema_exports
 };
-//# sourceMappingURL=chunk-PLDMJJJC.mjs.map
+//# sourceMappingURL=chunk-UGFFV2FR.mjs.map

package/dist/lib/neutral/{chunk-35INCYOE.mjs → chunk-UWLP4RFM.mjs}

@@ -4,4 +4,4 @@ var QueryResult_exports = {};
 export {
   QueryResult_exports
 };
-//# sourceMappingURL=chunk-35INCYOE.mjs.map
+//# sourceMappingURL=chunk-UWLP4RFM.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/QueryResult.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Atom from '@effect-atom/atom/Atom';\nimport type * as Effect from 'effect/Effect';\nimport type * as Option from 'effect/Option';\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\n// TODO(burdon): Should T be constrained to Entity.Any?\nexport interface QueryResult<T> {\n  /**\n   * Currently available results along with their match metadata.\n   */\n  readonly entries: Entry<T>[];\n\n  /**\n   * Currently available results.\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  /**\n   * Self-updating atom. Updates automatically when query results change.\n   *\n   * Memoized per QueryResult instance — repeated accesses on the same instance return the same\n   * Atom. Safe only when the QueryResult is itself held stable across re-renders (e.g. behind a\n   * `useMemo`). It must NOT be used in graph-builder connectors/actions or other atom computes,\n   * where `db.query(...)` is called fresh on each re-evaluation: every run constructs a new\n   * QueryResult and so a new atom + subscription, leaking the previous ones. Use the memoized\n   * {@link atom} family there instead.\n   */\n  readonly atom: Atom.Atom<T[]>;\n}\n\n/**\n * Effect that returns a QueryResult when evaluated, but also has shorthand methods for running the query or getting the first result.\n */\nexport interface QueryResultEffect<T, E, R> extends Effect.Effect<QueryResult<T>, E, R> {\n  run: Effect.Effect<T[], E, R>;\n  first: Effect.Effect<Option.Option<T>, E, R>;\n\n  // TODO(dmaretskyi): Considering adding `atom`, but since `Database.query` is used in imperative code only, I dont think it will be useful.\n}\n"],
+  "mappings": ";AAAA;",
+  "names": []
+}

package/dist/lib/neutral/{chunk-SZ5WB6HF.mjs → chunk-UZHCQ6NI.mjs}

@@ -2,33 +2,35 @@ import {
   Kind,
   KindId,
   SnapshotKindId
-} from "./chunk-Z3WMRRAZ.mjs";
+} from "./chunk-BEFR7LEA.mjs";
 import {
   getSchema
-} from "./chunk-HGWQR5KH.mjs";
+} from "./chunk-XB6ISRAO.mjs";
 import {
   VersionTypeId,
-  change,
   getSnapshot,
   isDeleted,
   isVersion,
-  makeObject,
   makeRelation,
   objectToJSON,
   setValue,
   sort,
   sortByLabel,
   sortByTypename,
-  subscribe,
   version
-} from "./chunk-VQYL2OQF.mjs";
+} from "./chunk-ACFAOTKJ.mjs";
 import {
   addTag,
   deleteKeys,
   getKeys,
   getMetaChecked,
+  makeObject,
   removeTag
-} from "./chunk-X3NUUON4.mjs";
+} from "./chunk-2HKGAQM4.mjs";
+import {
+  change,
+  subscribe
+} from "./chunk-L3E5IXAE.mjs";
 import {
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
@@ -51,12 +53,12 @@ import {
   isInstanceOf,
   setDescription,
   setLabel
-} from "./chunk-WZ32BF53.mjs";
+} from "./chunk-3TN2VMI4.mjs";
 import {
   ANY_OBJECT_TYPENAME,
   ANY_OBJECT_VERSION,
   EntityKind
-} from "./chunk-O6BH7EPN.mjs";
+} from "./chunk-2ZHECXUR.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -109,7 +111,7 @@ import * as Schema from "effect/Schema";
 import { raise } from "@dxos/debug";
 import { SchemaEx } from "@dxos/effect";
 import { assertArgument, invariant } from "@dxos/invariant";
-import { EID, DXN } from "@dxos/keys";
+import { DXN, EID } from "@dxos/keys";
 import { assumeType } from "@dxos/util";
 var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
 var Unknown2 = Schema.Struct({
@@ -278,4 +280,4 @@ export {
   atom,
   Relation_exports
 };
-//# sourceMappingURL=chunk-SZ5WB6HF.mjs.map
+//# sourceMappingURL=chunk-UZHCQ6NI.mjs.map

package/dist/lib/neutral/{chunk-SZ5WB6HF.mjs.map → chunk-UZHCQ6NI.mjs.map}

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/Relation.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { SchemaEx } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { EID, type EntityId, type URI, DXN } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as internal from './internal';\nimport * as entityInternal from './internal/Entity';\nimport * as objInternal from './internal/Obj';\nimport * as Obj from './Obj';\nimport type * as Ref from './Ref';\nimport type * as Tag from './Tag';\nimport * as Type from './Type';\n\nexport type Endpoints<Source, Target> = {\n  [Source]: Source;\n  [Target]: Target;\n};\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends internal.AnyEntity, Endpoints<Source, Target>, Entity.OfKind<internal.EntityKind.Relation> {}\n\n/**\n * Relation with no known properties beyond id, kind, source, and target.\n * Use this when the relation's schema/properties are not known.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO relation, use `Relation.isRelation`.\n */\nexport interface Unknown extends BaseRelation<Obj.Unknown, Obj.Unknown> {}\n\n/**\n * Runtime Effect schema for any ECHO relation.\n * Use for validation, parsing, or as a reference target for collections.\n * A relation has `id`, source, and target fields plus any additional properties.\n *\n * NOTE: `Schema.is(Type.Relation)` does STRUCTURAL validation only (checks for `id` field).\n * Use `Relation.isRelation()` for proper ECHO instance type guards that check the KindId brand.\n *\n * @example\n * ```ts\n * // Structural type guard (accepts any object with id field)\n * if (Schema.is(Type.Relation)(unknownValue)) { ... }\n *\n * // ECHO instance type guard (checks KindId brand)\n * if (Relation.isRelation(unknownValue)) { ... }\n * ```\n */\n// TODO(dmaretskyi): Change ObjModule.Any to ObjModule.Unknown to have stricter types.\nexport const Unknown: internal.UnknownTypeSchema<Unknown, typeof Entity.Kind.Relation> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  Schema.annotations({\n    [internal.TypeAnnotationId]: {\n      kind: Entity.Kind.Relation,\n      typename: 'org.dxos.schema.anyRelation',\n      version: '0.0.0',\n      sourceSchema: DXN.make(internal.ANY_OBJECT_TYPENAME, internal.ANY_OBJECT_VERSION),\n      targetSchema: DXN.make(internal.ANY_OBJECT_TYPENAME, internal.ANY_OBJECT_VERSION),\n    },\n  }),\n) as unknown as internal.UnknownTypeSchema<Unknown, typeof Entity.Kind.Relation>;\n\n/**\n * Relation type with specific source and target types.\n */\nexport type OfShape<Source extends Obj.Unknown, Target extends Obj.Unknown, Props> = BaseRelation<Source, Target> &\n  Props;\n\n/**\n * Base type for snapshot relations (has SnapshotKindId instead of KindId).\n */\ninterface BaseRelationSnapshot<Source, Target> extends internal.AnyEntity, Endpoints<Source, Target> {\n  readonly [Entity.SnapshotKindId]: internal.EntityKind.Relation;\n  readonly id: EntityId;\n}\n\n/**\n * JSON-encoded properties for relations.\n */\nexport interface BaseRelationJson {\n  id: string;\n  [internal.ATTR_RELATION_SOURCE]: string;\n  [internal.ATTR_RELATION_TARGET]: string;\n}\n\n/**\n * Immutable snapshot of an ECHO relation.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> &\n  BaseRelationSnapshot<Obj.Unknown, Obj.Unknown>;\n\nexport const Source: unique symbol = entityInternal.RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = entityInternal.RelationTargetId as any;\nexport type Target = typeof Target;\n\n/**\n * Get relation source type.\n */\nexport type SourceOf<A> = A extends Endpoints<infer S, infer _T> ? S : never;\n\n/**\n * Get relation target type.\n */\nexport type TargetOf<A> = A extends Endpoints<infer _S, infer T> ? T : never;\n\n/**\n * Internal props type for relation instance creation.\n */\ntype MakePropsInternal<T extends Endpoints<any, any>> = {\n  id?: EntityId;\n  [Meta]?: Partial<internal.EntityMeta>;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Entity.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema. Accepts a `Type.AnyRelation`\n * entity (created with `Type.makeRelation`) and derives the props shape via\n * `Type.InstanceType`. Object-kind entities are rejected at the type level —\n * use `Obj.MakeProps` for those.\n */\nexport type MakeProps<S extends Type.AnyRelation> = MakePropsInternal<Type.InstanceType<S>>;\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. (deprecated; use [Obj.Meta] instead)\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 = <T extends Type.AnyRelation>(\n  type: T,\n  props: NoInfer<MakeProps<T>>,\n): Type.InstanceType<T> & Entity.OfKind<typeof Entity.Kind.Relation> => {\n  const schema = Type.getSchema(type);\n  assertArgument(\n    internal.getTypeAnnotation(schema)?.kind === internal.EntityKind.Relation,\n    'schema',\n    'Expected a relation schema',\n  );\n  assertArgument(props[internal.ParentId] === undefined, 'props', 'Parent is not allowed for relations');\n\n  let meta: internal.EntityMeta | undefined = undefined;\n\n  if (props[internal.MetaId] != null) {\n    meta = props[internal.MetaId] as any;\n    delete props[internal.MetaId];\n  }\n\n  const sourceDXN = internal.getObjectEchoUri(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = internal.getObjectEchoUri(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[internal.RelationSourceDXNId] = sourceDXN;\n  (props as any)[internal.RelationTargetDXNId] = targetDXN;\n\n  // Pass the type entity through as `typeSource` so the resulting instance\n  // carries a back-reference resolvable via `Relation.getType` / `Entity.getType`.\n  return internal.makeObject(schema as any, props as any, meta, type as any) as any;\n};\n\n/**\n * Test if a value is an instance of a given relation type.\n *\n * Mirrors `Obj.instanceOf` but only accepts `Type.AnyRelation` — use\n * `Obj.instanceOf` for objects and `Type.isType` for `Type.Type` entities.\n *\n * @example\n * ```ts\n * const isEmployedBy = Relation.instanceOf(EmployedBy);\n * if (isEmployedBy(relation)) {\n *   // relation is EmployedBy\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.AnyRelation>(schema: S): (value: unknown) => value is Type.InstanceType<S>;\n  <S extends Type.AnyRelation>(schema: S, value: unknown): value is Type.InstanceType<S>;\n} = ((...args: [schema: Type.AnyRelation, value?: unknown]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => internal.isInstanceOf(args[0], entity);\n  }\n  return internal.isInstanceOf(args[0], args[1]);\n}) as any;\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (internal.ATTR_RELATION_SOURCE in value || internal.ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  // Check for reactive relation (KindId) or snapshot (SnapshotKindId).\n  const kind = (value as any)[Entity.KindId] ?? (value as any)[Entity.SnapshotKindId];\n  return kind === internal.EntityKind.Relation;\n};\n\nexport const isSnapshot = (value: unknown): value is Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[Entity.SnapshotKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * @returns Relation source URI.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceURI = (value: Unknown | Snapshot): EID.EID => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const uri = (value as internal.InternalObjectProps)[internal.RelationSourceDXNId];\n  invariant(EID.isEID(uri));\n  return uri;\n};\n\n/**\n * @returns Relation target URI.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetURI = (value: Unknown | Snapshot): EID.EID => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const uri = (value as internal.InternalObjectProps)[internal.RelationTargetDXNId];\n  invariant(EID.isEID(uri));\n  return uri;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): SourceOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationSourceId];\n  if (obj === undefined) {\n    throw new Error(`Relation source could not be resolved.`);\n  }\n  return obj as SourceOf<T>;\n};\n\n/**\n * @returns Relation target.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Unknown | Snapshot>(relation: T): TargetOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationTargetId];\n  if (obj === undefined) {\n    throw new Error(`Relation target could not be resolved.`);\n  }\n  return obj as TargetOf<T>;\n};\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of a relation within `Relation.update`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an echo relation within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Relation.update` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.update` for objects.\n * @param callback - The callback that performs mutations on the relation.\n *\n * @example\n * ```ts\n * const worksFor = Relation.make(EmployedBy, {\n *   [Relation.Source]: person,\n *   [Relation.Target]: company,\n *   role: 'Engineer',\n * });\n *\n * // Mutate within Relation.update\n * Relation.update(worksFor, (obj) => {\n *   obj.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.update` for objects.\n */\nexport const update = <T extends Unknown>(relation: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(relation, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of a relation.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive relation at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(rel: T) => Snapshot<T> = internal.getSnapshot as any;\n\n//\n// Subscribe\n//\n\n/**\n * Subscribe to relation updates.\n * The callback is called synchronously when the relation is modified.\n * Only accepts reactive relations (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (rel: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(rel, callback);\n};\n\n//\n// Property Access\n//\n\n/**\n * Get a deeply nested property from a relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getValue = (rel: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return SchemaEx.getValue(rel, SchemaEx.createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on a relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setValue: (rel: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  internal.setValue as any;\n\n//\n// Type\n//\n\n/**\n * Get the canonical URI of the relation. Returns `URI.URI` — today always an EID,\n * but future entity kinds may surface other URI schemes; narrow with `EID.parse(uri)`\n * or `DXN.tryMake(uri)` at the point of use. Accepts both reactive relations and snapshots.\n *\n * @param options.prefer - Controls the URI form (see {@link internal.GetURIOptions}).\n */\nexport const getURI = (entity: Unknown | Snapshot, options?: internal.GetURIOptions): URI.URI =>\n  internal.getUri(entity, options);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeURI: (obj: internal.AnyProperties) => URI.URI | undefined = internal.getTypeURI;\n\n/**\n * Get the type entity (`Type.AnyRelation`) the relation was created from.\n *\n * Returns `undefined` when the relation's type isn't registered in this\n * runtime (e.g. a freshly deserialized snapshot whose type entity hasn't been\n * wired up yet, or a relation loaded from storage before its schema is known).\n * To get the Effect Schema from the returned entity, use `Type.getSchema(...)`.\n */\nexport const getType = (relation: Unknown | Snapshot): Type.AnyRelation | undefined =>\n  internal.getType(relation) as Type.AnyRelation | undefined;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the relation belongs to.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): Database.Database | undefined => internal.getDatabase(entity);\n\n//\n// Meta\n//\n\n/**\n * Property that accesses metadata for an entity.\n *\n * Alias for `Entity.Meta`.\n */\nexport const Meta = internal.MetaId;\n\n/**\n * Deeply read-only version of EntityMeta.\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.update` callback.\n */\nexport type Meta = internal.Meta;\n\n/**\n * Get the metadata for a relation.\n * Returns mutable meta when passed a mutable relation (inside `Relation.update` callback).\n * Returns read-only meta when passed a regular relation or snapshot.\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * @returns Foreign keys for the relation from the specified source.\n * Accepts both reactive relations and snapshots.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Delete all keys from the relation for the specified source.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => internal.deleteKeys(entity, source);\n\n/**\n * Add a tag to the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: Ref.Ref<Tag.Tag>): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: Ref.Ref<Tag.Tag>): void => internal.removeTag(entity, tag);\n\n/**\n * Check if the relation is deleted.\n * Accepts both reactive relations and snapshots.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the relation.\n * Accepts both reactive relations and snapshots.\n *\n * @param options.fallback `'typename'` returns the relation's typename when no\n *   label is set (e.g. `org.dxos.type.table`).\n */\nexport const getLabel = (entity: Unknown | Snapshot, options?: internal.GetLabelOptions): string | undefined =>\n  internal.getLabel(entity, options);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);\n\n/**\n * Get the description of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Set the description of the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  internal.setDescription(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of a relation.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Converts relation to its JSON representation.\n * Accepts both reactive relations and snapshots.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n//\n// Sorting\n//\n\n/**\n * Comparator function type for sorting relations.\n * Accepts both reactive relations and snapshots.\n */\nexport type Comparator = internal.Comparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = internal.sortByLabel as Comparator;\nexport const sortByTypename: Comparator = internal.sortByTypename as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => internal.sort(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport const VersionTypeId = internal.VersionTypeId;\nexport const isVersion = internal.isVersion;\n\n/**\n * Represent relation version.\n */\nexport type Version = internal.EntityVersion;\n\n/**\n * Returns the version of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => internal.version(entity);\n\n//\n// Atoms\n//\n\nexport const atom = objInternal.makeRelation;\n"],
-  "mappings": "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",
-  "names": ["Unknown", "VersionTypeId", "addTag", "deleteKeys", "getDatabase", "getDescription", "getKeys", "getLabel", "getSnapshot", "getType", "getTypeURI", "getTypename", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "SchemaEx", "assertArgument", "invariant", "EID", "DXN", "assumeType", "Schema", "Record", "key", "annotations", "TypeAnnotationId", "kind", "Kind", "typename", "version", "sourceSchema", "targetSchema", "assertArgument", "internal", "getTypeAnnotation", "ParentId", "undefined", "meta", "props", "MetaId", "sourceDXN", "getObjectEchoUri", "RelationSourceDXNId", "RelationTargetDXNId", "targetDXN", "entity", "isInstanceOf", "args", "value", "assumeType", "invariant", "EID", "isEID", "uri", "relation", "RelationSourceId", "obj", "RelationTargetId", "getSnapshot", "subscribe", "setValue", "getTypename", "getDatabase", "getMetaChecked", "isDeleted", "sortByTypename", "sort", "comparators", "VersionTypeId"]
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { SchemaEx } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, EID, type EntityId, type URI } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as internal from './internal';\nimport * as entityInternal from './internal/Entity';\nimport * as objInternal from './internal/Obj';\nimport * as Obj from './Obj';\nimport type * as Ref from './Ref';\nimport type * as Tag from './Tag';\nimport * as Type from './Type';\n\nexport type Endpoints<Source, Target> = {\n  [Source]: Source;\n  [Target]: Target;\n};\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends internal.AnyEntity, Endpoints<Source, Target>, Entity.OfKind<internal.EntityKind.Relation> {}\n\n/**\n * Relation with no known properties beyond id, kind, source, and target.\n * Use this when the relation's schema/properties are not known.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO relation, use `Relation.isRelation`.\n */\nexport interface Unknown extends BaseRelation<Obj.Unknown, Obj.Unknown> {}\n\n/**\n * Runtime Effect schema for any ECHO relation.\n * Use for validation, parsing, or as a reference target for collections.\n * A relation has `id`, source, and target fields plus any additional properties.\n *\n * NOTE: `Schema.is(Type.Relation)` does STRUCTURAL validation only (checks for `id` field).\n * Use `Relation.isRelation()` for proper ECHO instance type guards that check the KindId brand.\n *\n * @example\n * ```ts\n * // Structural type guard (accepts any object with id field)\n * if (Schema.is(Type.Relation)(unknownValue)) { ... }\n *\n * // ECHO instance type guard (checks KindId brand)\n * if (Relation.isRelation(unknownValue)) { ... }\n * ```\n */\n// TODO(dmaretskyi): Change ObjModule.Any to ObjModule.Unknown to have stricter types.\nexport const Unknown: internal.UnknownTypeSchema<Unknown, typeof Entity.Kind.Relation> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  Schema.annotations({\n    [internal.TypeAnnotationId]: {\n      kind: Entity.Kind.Relation,\n      typename: 'org.dxos.schema.anyRelation',\n      version: '0.0.0',\n      sourceSchema: DXN.make(internal.ANY_OBJECT_TYPENAME, internal.ANY_OBJECT_VERSION),\n      targetSchema: DXN.make(internal.ANY_OBJECT_TYPENAME, internal.ANY_OBJECT_VERSION),\n    },\n  }),\n) as unknown as internal.UnknownTypeSchema<Unknown, typeof Entity.Kind.Relation>;\n\n/**\n * Relation type with specific source and target types.\n */\nexport type OfShape<Source extends Obj.Unknown, Target extends Obj.Unknown, Props> = BaseRelation<Source, Target> &\n  Props;\n\n/**\n * Base type for snapshot relations (has SnapshotKindId instead of KindId).\n */\ninterface BaseRelationSnapshot<Source, Target> extends internal.AnyEntity, Endpoints<Source, Target> {\n  readonly [Entity.SnapshotKindId]: internal.EntityKind.Relation;\n  readonly id: EntityId;\n}\n\n/**\n * JSON-encoded properties for relations.\n */\nexport interface BaseRelationJson {\n  id: string;\n  [internal.ATTR_RELATION_SOURCE]: string;\n  [internal.ATTR_RELATION_TARGET]: string;\n}\n\n/**\n * Immutable snapshot of an ECHO relation.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> &\n  BaseRelationSnapshot<Obj.Unknown, Obj.Unknown>;\n\nexport const Source: unique symbol = entityInternal.RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = entityInternal.RelationTargetId as any;\nexport type Target = typeof Target;\n\n/**\n * Get relation source type.\n */\nexport type SourceOf<A> = A extends Endpoints<infer S, infer _T> ? S : never;\n\n/**\n * Get relation target type.\n */\nexport type TargetOf<A> = A extends Endpoints<infer _S, infer T> ? T : never;\n\n/**\n * Internal props type for relation instance creation.\n */\ntype MakePropsInternal<T extends Endpoints<any, any>> = {\n  id?: EntityId;\n  [Meta]?: Partial<internal.EntityMeta>;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Entity.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema. Accepts a `Type.AnyRelation`\n * entity (created with `Type.makeRelation`) and derives the props shape via\n * `Type.InstanceType`. Object-kind entities are rejected at the type level —\n * use `Obj.MakeProps` for those.\n */\nexport type MakeProps<S extends Type.AnyRelation> = MakePropsInternal<Type.InstanceType<S>>;\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. (deprecated; use [Obj.Meta] instead)\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 = <T extends Type.AnyRelation>(\n  type: T,\n  props: NoInfer<MakeProps<T>>,\n): Type.InstanceType<T> & Entity.OfKind<typeof Entity.Kind.Relation> => {\n  const schema = Type.getSchema(type);\n  assertArgument(\n    internal.getTypeAnnotation(schema)?.kind === internal.EntityKind.Relation,\n    'schema',\n    'Expected a relation schema',\n  );\n  assertArgument(props[internal.ParentId] === undefined, 'props', 'Parent is not allowed for relations');\n\n  let meta: internal.EntityMeta | undefined = undefined;\n\n  if (props[internal.MetaId] != null) {\n    meta = props[internal.MetaId] as any;\n    delete props[internal.MetaId];\n  }\n\n  const sourceDXN = internal.getObjectEchoUri(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = internal.getObjectEchoUri(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[internal.RelationSourceDXNId] = sourceDXN;\n  (props as any)[internal.RelationTargetDXNId] = targetDXN;\n\n  // Pass the type entity through as `typeSource` so the resulting instance\n  // carries a back-reference resolvable via `Relation.getType` / `Entity.getType`.\n  return internal.makeObject(schema as any, props as any, meta, type as any) as any;\n};\n\n/**\n * Test if a value is an instance of a given relation type.\n *\n * Mirrors `Obj.instanceOf` but only accepts `Type.AnyRelation` — use\n * `Obj.instanceOf` for objects and `Type.isType` for `Type.Type` entities.\n *\n * @example\n * ```ts\n * const isEmployedBy = Relation.instanceOf(EmployedBy);\n * if (isEmployedBy(relation)) {\n *   // relation is EmployedBy\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.AnyRelation>(schema: S): (value: unknown) => value is Type.InstanceType<S>;\n  <S extends Type.AnyRelation>(schema: S, value: unknown): value is Type.InstanceType<S>;\n} = ((...args: [schema: Type.AnyRelation, value?: unknown]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => internal.isInstanceOf(args[0], entity);\n  }\n  return internal.isInstanceOf(args[0], args[1]);\n}) as any;\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (internal.ATTR_RELATION_SOURCE in value || internal.ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  // Check for reactive relation (KindId) or snapshot (SnapshotKindId).\n  const kind = (value as any)[Entity.KindId] ?? (value as any)[Entity.SnapshotKindId];\n  return kind === internal.EntityKind.Relation;\n};\n\nexport const isSnapshot = (value: unknown): value is Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[Entity.SnapshotKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * @returns Relation source URI.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceURI = (value: Unknown | Snapshot): EID.EID => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const uri = (value as internal.InternalObjectProps)[internal.RelationSourceDXNId];\n  invariant(EID.isEID(uri));\n  return uri;\n};\n\n/**\n * @returns Relation target URI.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetURI = (value: Unknown | Snapshot): EID.EID => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const uri = (value as internal.InternalObjectProps)[internal.RelationTargetDXNId];\n  invariant(EID.isEID(uri));\n  return uri;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): SourceOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationSourceId];\n  if (obj === undefined) {\n    throw new Error(`Relation source could not be resolved.`);\n  }\n  return obj as SourceOf<T>;\n};\n\n/**\n * @returns Relation target.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Unknown | Snapshot>(relation: T): TargetOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationTargetId];\n  if (obj === undefined) {\n    throw new Error(`Relation target could not be resolved.`);\n  }\n  return obj as TargetOf<T>;\n};\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of a relation within `Relation.update`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an echo relation within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Relation.update` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.update` for objects.\n * @param callback - The callback that performs mutations on the relation.\n *\n * @example\n * ```ts\n * const worksFor = Relation.make(EmployedBy, {\n *   [Relation.Source]: person,\n *   [Relation.Target]: company,\n *   role: 'Engineer',\n * });\n *\n * // Mutate within Relation.update\n * Relation.update(worksFor, (obj) => {\n *   obj.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.update` for objects.\n */\nexport const update = <T extends Unknown>(relation: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(relation, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of a relation.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive relation at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(rel: T) => Snapshot<T> = internal.getSnapshot as any;\n\n//\n// Subscribe\n//\n\n/**\n * Subscribe to relation updates.\n * The callback is called synchronously when the relation is modified.\n * Only accepts reactive relations (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (rel: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(rel, callback);\n};\n\n//\n// Property Access\n//\n\n/**\n * Get a deeply nested property from a relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getValue = (rel: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return SchemaEx.getValue(rel, SchemaEx.createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on a relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setValue: (rel: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  internal.setValue as any;\n\n//\n// Type\n//\n\n/**\n * Get the canonical URI of the relation. Returns `URI.URI` — today always an EID,\n * but future entity kinds may surface other URI schemes; narrow with `EID.parse(uri)`\n * or `DXN.tryMake(uri)` at the point of use. Accepts both reactive relations and snapshots.\n *\n * @param options.prefer - Controls the URI form (see {@link internal.GetURIOptions}).\n */\nexport const getURI = (entity: Unknown | Snapshot, options?: internal.GetURIOptions): URI.URI =>\n  internal.getUri(entity, options);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeURI: (obj: internal.AnyProperties) => URI.URI | undefined = internal.getTypeURI;\n\n/**\n * Get the type entity (`Type.AnyRelation`) the relation was created from.\n *\n * Returns `undefined` when the relation's type isn't registered in this\n * runtime (e.g. a freshly deserialized snapshot whose type entity hasn't been\n * wired up yet, or a relation loaded from storage before its schema is known).\n * To get the Effect Schema from the returned entity, use `Type.getSchema(...)`.\n */\nexport const getType = (relation: Unknown | Snapshot): Type.AnyRelation | undefined =>\n  internal.getType(relation) as Type.AnyRelation | undefined;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the relation belongs to.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): Database.Database | undefined => internal.getDatabase(entity);\n\n//\n// Meta\n//\n\n/**\n * Property that accesses metadata for an entity.\n *\n * Alias for `Entity.Meta`.\n */\nexport const Meta = internal.MetaId;\n\n/**\n * Deeply read-only version of EntityMeta.\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.update` callback.\n */\nexport type Meta = internal.Meta;\n\n/**\n * Get the metadata for a relation.\n * Returns mutable meta when passed a mutable relation (inside `Relation.update` callback).\n * Returns read-only meta when passed a regular relation or snapshot.\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * @returns Foreign keys for the relation from the specified source.\n * Accepts both reactive relations and snapshots.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Delete all keys from the relation for the specified source.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => internal.deleteKeys(entity, source);\n\n/**\n * Add a tag to the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: Ref.Ref<Tag.Tag>): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: Ref.Ref<Tag.Tag>): void => internal.removeTag(entity, tag);\n\n/**\n * Check if the relation is deleted.\n * Accepts both reactive relations and snapshots.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the relation.\n * Accepts both reactive relations and snapshots.\n *\n * @param options.fallback `'typename'` returns the relation's typename when no\n *   label is set (e.g. `org.dxos.type.table`).\n */\nexport const getLabel = (entity: Unknown | Snapshot, options?: internal.GetLabelOptions): string | undefined =>\n  internal.getLabel(entity, options);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);\n\n/**\n * Get the description of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Set the description of the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  internal.setDescription(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of a relation.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Converts relation to its JSON representation.\n * Accepts both reactive relations and snapshots.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n//\n// Sorting\n//\n\n/**\n * Comparator function type for sorting relations.\n * Accepts both reactive relations and snapshots.\n */\nexport type Comparator = internal.Comparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = internal.sortByLabel as Comparator;\nexport const sortByTypename: Comparator = internal.sortByTypename as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => internal.sort(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport const VersionTypeId = internal.VersionTypeId;\nexport const isVersion = internal.isVersion;\n\n/**\n * Represent relation version.\n */\nexport type Version = internal.EntityVersion;\n\n/**\n * Returns the version of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => internal.version(entity);\n\n//\n// Atoms\n//\n\nexport const atom = objInternal.makeRelation;\n"],
+  "mappings": "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",
+  "names": ["Unknown", "VersionTypeId", "addTag", "deleteKeys", "getDatabase", "getDescription", "getKeys", "getLabel", "getSnapshot", "getType", "getTypeURI", "getTypename", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "SchemaEx", "assertArgument", "invariant", "DXN", "EID", "assumeType", "Schema", "Record", "key", "annotations", "TypeAnnotationId", "kind", "Kind", "typename", "version", "sourceSchema", "targetSchema", "assertArgument", "internal", "getTypeAnnotation", "ParentId", "undefined", "meta", "props", "MetaId", "sourceDXN", "getObjectEchoUri", "RelationSourceDXNId", "RelationTargetDXNId", "targetDXN", "entity", "isInstanceOf", "args", "value", "assumeType", "invariant", "EID", "isEID", "uri", "relation", "RelationSourceId", "obj", "RelationTargetId", "getSnapshot", "subscribe", "setValue", "getTypename", "getDatabase", "getMetaChecked", "isDeleted", "sortByTypename", "sort", "comparators", "VersionTypeId"]
 }

package/dist/lib/neutral/{chunk-L3OBWBV2.mjs → chunk-WKIT2YY5.mjs}

@@ -1,6 +1,6 @@
 import {
   Ref
-} from "./chunk-4TPQZPLY.mjs";
+} from "./chunk-L3E5IXAE.mjs";
 
 // src/internal/Ref/ref-array.ts
 import { isNonNullable } from "@dxos/util";
@@ -31,4 +31,4 @@ var RefArray = Object.freeze({
 export {
   RefArray
 };
-//# sourceMappingURL=chunk-L3OBWBV2.mjs.map
+//# sourceMappingURL=chunk-WKIT2YY5.mjs.map

package/dist/lib/neutral/{chunk-HGWQR5KH.mjs → chunk-XB6ISRAO.mjs}

@@ -1,36 +1,38 @@
 import {
-  EchoObjectSchema,
-  EchoRelationSchema,
   TypeSchema,
   addFieldsToSchema,
-  change,
-  makeObject,
+  makeObjectType,
+  makeRelationType,
   removeFieldsFromSchema,
   updateFieldNameInSchema,
   updateFieldsInSchema,
   version
-} from "./chunk-VQYL2OQF.mjs";
+} from "./chunk-ACFAOTKJ.mjs";
+import {
+  getMetaChecked,
+  makeObject
+} from "./chunk-2HKGAQM4.mjs";
 import {
   toEffectSchema,
   toJsonSchema
-} from "./chunk-K3S7D5PR.mjs";
+} from "./chunk-4A2NWKRJ.mjs";
 import {
-  getMetaChecked
-} from "./chunk-X3NUUON4.mjs";
+  change
+} from "./chunk-L3E5IXAE.mjs";
 import {
   TypeIdentifierAnnotationId,
   getDatabase,
   getLabel,
   getSchemaURI,
   getTypeURIFromSpecifier
-} from "./chunk-WZ32BF53.mjs";
+} from "./chunk-3TN2VMI4.mjs";
 import {
   EntityKind,
   InstancePhantomId,
   getEntityKindBrand,
   getSchemaKind,
   getStaticTypeSchema
-} from "./chunk-O6BH7EPN.mjs";
+} from "./chunk-2ZHECXUR.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -68,7 +70,7 @@ import { raise } from "@dxos/debug";
 import { assertArgument, invariant } from "@dxos/invariant";
 import { DXN, EID } from "@dxos/keys";
 var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Type.ts";
-var makeObject2 = EchoObjectSchema;
+var makeObject2 = (dxn, options) => (schema) => makeObjectType(dxn, schema, options);
 var Type = TypeSchema;
 var DRAFT_VERSION = "0.0.0";
 var makeObjectFromJsonSchema = (props) => {
@@ -102,7 +104,17 @@ var makeRelationFromJsonSchema = (props) => {
     version: version2 ?? DRAFT_VERSION
   }, TypeSchema);
 };
-var makeRelation = EchoRelationSchema;
+var makeRelation = (dxn) => (opts) => (schema) => (
+  // Boundary cast: makeRelationType erases generic params since the constructor/prototype
+  // wiring cannot thread them through the type system.
+  makeRelationType({
+    dxn,
+    source: opts.source,
+    target: opts.target,
+    schema,
+    id: opts.id
+  })
+);
 var isObject = (entity) => {
   return getSchemaKind(entity) === EntityKind.Object;
 };
@@ -146,13 +158,13 @@ var getTypename = (input) => {
   }
   typename ??= input.id;
   typename = stripTypenamePrefix(typename);
-  invariant(typeof typename === "string" && typename.length > 0, "Invalid typename", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 219, S: void 0, A: ["typeof typename === 'string' && typename.length > 0", "'Invalid typename'"] });
+  invariant(typeof typename === "string" && typename.length > 0, "Invalid typename", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 228, S: void 0, A: ["typeof typename === 'string' && typename.length > 0", "'Invalid typename'"] });
   return typename;
 };
 var getVersion = (input) => {
   const meta = getMetaChecked(input);
   const semver = meta.version ?? input.jsonSchema?.version ?? DRAFT_VERSION;
-  invariant(typeof semver === "string" && semver.match(/^\d+\.\d+\.\d+$/), "Invalid version", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 240, S: void 0, A: ["typeof semver === 'string' && semver.match(/^\\d+\\.\\d+\\.\\d+$/)", "'Invalid version'"] });
+  invariant(typeof semver === "string" && semver.match(/^\d+\.\d+\.\d+$/), "Invalid version", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 249, S: void 0, A: ["typeof semver === 'string' && semver.match(/^\\d+\\.\\d+\\.\\d+$/)", "'Invalid version'"] });
   const heads = version(input).automergeHeads;
   if (heads != null && heads.length > 0) {
     return `${semver}-${[
@@ -256,4 +268,4 @@ export {
   removeFields,
   Type_exports
 };
-//# sourceMappingURL=chunk-HGWQR5KH.mjs.map
+//# sourceMappingURL=chunk-XB6ISRAO.mjs.map