@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts", "../../../src/Hypergraph.ts", "../../../src/Json.ts", "../../../src/Collection.ts", "../../../src/View.ts", "../../../src/Dataset.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport { QueryAST } from '@dxos/echo-protocol';\nexport { DXN, EID, URI } from '@dxos/keys';\n\nexport * as Annotation from './Annotation';\nexport * as Database from './Database';\nexport * as Entity from './Entity';\n// TODO(burdon): Rename to Error (less problematic than Obj/Object).\nexport * as Err from './Err';\nexport * as Feed from './Feed';\nexport * as Filter from './Filter';\nexport * as Format from './Format';\nexport * as Hypergraph from './Hypergraph';\nexport * as Json from './Json';\nexport * as JsonSchema from './JsonSchema';\nexport * as Key from './Key';\nexport * as Migration from './Migration';\nexport * as Obj from './Obj';\nexport * as Order from './Order';\nexport * as Query from './Query';\nexport * as QueryResult from './QueryResult';\nexport * as Ref from './Ref';\nexport * as Registry from './Registry';\nexport * as Relation from './Relation';\nexport * as Scope from './Scope';\nexport * as Tag from './Tag';\nexport * as Type from './Type';\nexport * as Collection from './Collection';\nexport * as View from './View';\nexport * as Dataset from './Dataset';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport type * as internal from './internal';\nimport type * as Key from './Key';\nimport type * as Ref from './Ref';\nimport type * as Registry from './Registry';\n\n/**\n * Resolution context.\n * Affects how non-absolute DXNs are resolved.\n */\nexport interface RefResolutionContext {\n  /**\n   * Space that the resolution is happening from.\n   */\n  space?: Key.SpaceId;\n\n  /**\n   * Feed that the resolution is happening from.\n   * This feed will be searched first, and then the space it belongs to.\n   */\n  feed?: URI.URI;\n}\n\nexport interface RefResolverOptions {\n  /**\n   * Resolution context.\n   * Affects how non-absolute DXNs are resolved.\n   */\n  context?: RefResolutionContext;\n\n  /**\n   * Middleware to change the resolved object before returning it.\n   * @deprecated On track to be removed.\n   */\n  middleware?: (obj: internal.AnyProperties) => internal.AnyProperties;\n}\n\n/**\n * Manages cross-space database interactions.\n */\nexport interface Hypergraph extends Database.Queryable {\n  /**\n   * In-process registry of keyed objects and static schema types.\n   * Populated at startup via `registry.add(objects)` / `registry.add(schemas)`.\n   * Queries that include no explicit from() clause will fan out to this registry automatically.\n   */\n  get registry(): Registry.Registry;\n\n  /**\n   * Query objects.\n   */\n  query: Database.QueryFn;\n\n  /**\n   * Creates a reference to an existing object in the database.\n   *\n   * NOTE: The reference may be dangling if the object is not present in the database.\n   * NOTE: Difference from `Ref.fromURI`\n   * `Ref.fromURI(dxn)` returns an unhydrated reference. The `.load` and `.target` APIs will not work.\n   * `db.makeRef(dxn)` is preferable in cases with access to the database.\n   */\n  makeRef<T extends Entity.Unknown = Entity.Unknown>(uri: URI.URI): Ref.Ref<T>;\n\n  /**\n   * @param hostDb Host database for reference resolution.\n   * @param middleware Called with the loaded object. The caller may change the object.\n   * @returns Result of `onLoad`.\n   */\n  // TODO(dmaretskyi): Restructure API: Remove middleware.\n  createRefResolver(options: RefResolverOptions): Ref.Resolver;\n\n  /**\n   * Get a database by space ID.\n   * @returns The database for the given space ID, or undefined if not found.\n   */\n  getDatabase(spaceId: Key.SpaceId): Database.Database | undefined;\n}\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { EID } from '@dxos/keys';\n\nimport * as Database from './Database';\nimport * as Obj from './Obj';\n\n/**\n * `JSON.stringify` replacer signature.\n *\n * Defined here (rather than re-imported from a UI package) so other ECHO-aware utilities can\n * share a stable signature without creating a dependency edge into the UI tree.\n */\nexport type JsonReplacer = (key: string, value: any) => any;\n\nexport type CreateRefReplacerOptions = {\n  db: Database.Database;\n  /** How many ref hops to follow. `0` leaves all refs as-is. Default: `1`. */\n  depth?: number;\n};\n\nconst isEncodedRef = (value: unknown): value is { '/': string } =>\n  typeof value === 'object' &&\n  value !== null &&\n  Object.keys(value as object).length === 1 &&\n  typeof (value as { '/': unknown })['/'] === 'string';\n\nconst toJson = (obj: Obj.Any): unknown => (typeof (obj as any).toJSON === 'function' ? (obj as any).toJSON() : obj);\n\n/**\n * Returns a {@link JsonReplacer} that inlines ECHO ref objects (`{ \"/\": \"echo:...\" }`) up to\n * `depth` ref hops. Beyond that depth refs are left in their encoded form.\n *\n * Implemented as a per-call `JSON.stringify` replacer (not a one-shot tree walk at root) so it\n * composes with wrappers like `safeStringify` that intercept the root call. JSON.stringify\n * already drives the recursion; we only need to (a) detect a ref at the current callback,\n * (b) resolve and return the target if hop budget remains, and (c) tag the returned object\n * with its hop count so children know how far in they are.\n *\n * The hop count is tracked per-object via a `WeakMap`: a ref-resolved target's children inherit\n * `parentHops + 1`; a regular intermediate object's children inherit `parentHops`. This makes the\n * budget count *ref hops*, not tree depth — a ref deep in a tree still resolves once when\n * `depth >= 1`.\n *\n * Note: ECHO objects' `toJSON` runs before the replacer is invoked, so by the time we see a\n * value refs are already encoded as `{ \"/\": \"dxn:...\" }`.\n */\nexport const createRefReplacer = ({ db, depth = 1 }: CreateRefReplacerOptions): JsonReplacer => {\n  // Per-object hop count. Set when we return an object (via ref resolution or pass-through) so\n  // the child callbacks (which carry that object as `this`) can read it.\n  const hops = new WeakMap<object, number>();\n\n  return function (this: any, key: string, value: any) {\n    // Hop count for this call: hops at the parent, or 0 for the root.\n    const parentHops = this && typeof this === 'object' ? (hops.get(this) ?? 0) : 0;\n    if (isEncodedRef(value)) {\n      if (parentHops >= depth) {\n        return value;\n      }\n\n      // The `{ '/': string }` shape is shared with non-DXN IPLD-style refs (e.g. CIDs);\n      // an unparseable string would otherwise crash the whole `JSON.stringify`.\n      // Treat any parse miss as \"leave as-is\" rather than propagating.\n      const dxnString = value['/'];\n      if (!dxnString.startsWith('dxn:') && !dxnString.startsWith('echo:')) {\n        return value;\n      }\n\n      let echoUri: string | undefined;\n      try {\n        const parsed = EID.tryParse(dxnString);\n        echoUri = parsed ? EID.getEntityId(parsed) : undefined;\n      } catch {\n        return value;\n      }\n\n      if (!echoUri) {\n        return value;\n      }\n      const target = db.getObjectById(echoUri);\n      if (!target) {\n        return value;\n      }\n\n      const encoded = toJson(target);\n      if (encoded != null && typeof encoded === 'object') {\n        // Children of the resolved target are one hop deeper.\n        hops.set(encoded as object, parentHops + 1);\n      }\n      return encoded;\n    }\n\n    // Pass-through object: children inherit the parent's hop count (this branch doesn't burn\n    // budget).\n    if (value != null && typeof value === 'object') {\n      hops.set(value, parentHops);\n    }\n\n    return value;\n  };\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { DXN } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Ref from './Ref';\nimport * as Type from './Type';\n\n/**\n * A an ordered set of objects.\n */\nexport const Collection = Schema.Struct({\n  name: Schema.String.pipe(Schema.optional),\n  objects: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(internal.FormInputAnnotation.set(false)),\n}).pipe(\n  Annotation.IconAnnotation.set({ icon: 'ph--folder--regular', hue: 'amber' }),\n  Type.makeObject(DXN.make('org.dxos.type.collection', '0.1.0')),\n);\n\nexport type Collection = Type.InstanceType<typeof Collection>;\n\nexport const make = (props: Partial<Obj.MakeProps<typeof Collection>> = {}): Collection =>\n  Obj.make(Collection, { objects: [], ...props });\n\nexport const isCollection: (value: unknown) => value is Collection = Obj.instanceOf(Collection);\n", "//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { QueryAST } from '@dxos/echo-protocol';\nimport { SchemaEx } from '@dxos/effect';\nimport { DXN, PublicKey } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Query from './Query';\nimport * as Type from './Type';\n\n/**\n * Stored field metadata (e.g., for UX).\n */\nexport const FieldSchema = Schema.Struct({\n  id: Schema.String,\n  path: SchemaEx.JsonPath,\n  visible: Schema.optional(Schema.Boolean),\n\n  // TODO(wittjosiah): Presentation-specific?\n  referencePath: Schema.optional(SchemaEx.JsonPath),\n});\n\nexport type FieldType = Schema.Schema.Type<typeof FieldSchema>;\n\nexport const KeyValueProps = Schema.Record({ key: Schema.String, value: Schema.Any });\n\nexport const createFieldId = () => PublicKey.random().truncate();\n\nexport const Projection = Schema.Struct({\n  /**\n   * Optional schema override used to customize the underlying schema.\n   */\n  schema: internal.JsonSchemaType.pipe(Schema.optional),\n\n  /**\n   * UX metadata associated with displayed fields (in table, form, etc.)\n   */\n  // TODO(wittjosiah): Should this just be an array of SchemaEx.JsonPath?\n  fields: Schema.Array(FieldSchema),\n\n  /**\n   * The id for the field used to pivot the view.\n   * E.g., the field to use for kanban columns or the field to use for map coordinates.\n   */\n  pivotFieldId: Schema.String.pipe(Schema.optional),\n});\n\nexport type Projection = Schema.Schema.Type<typeof Projection>;\n\n/**\n * Views are generated or user-defined projections of a schema's properties.\n * They are used to configure the visual representation of the data.\n */\nconst ViewSchema = Schema.Struct({\n  /**\n   * Query used to retrieve data.\n   * Can be a user-provided query grammar string or a query AST.\n   */\n  query: Schema.Struct({\n    raw: Schema.optional(Schema.String),\n    ast: QueryAST.Query,\n  }),\n\n  /**\n   * Projection of the data returned from the query.\n   */\n  projection: Projection,\n}).pipe(\n  internal.HiddenAnnotation.set(true),\n  Annotation.IconAnnotation.set({ icon: 'ph--funnel--regular', hue: 'green' }),\n  Type.makeObject(DXN.make('org.dxos.type.view', '0.1.0')),\n);\n\n// NOTE: Declared as a named interface and the `View` const is annotated `Type.Obj<View>` so\n//   downstream consumers see a named `View` type instead of the inlined `QueryAST.Query` union.\n//   Without the named interface, embedding `Type.getSchema(View.View)` in a downstream\n//   `Schema.Struct` triggers TS2742 portability errors (e.g. plugin-kanban, plugin-table).\n// TODO(wittjosiah): Find a better solution that doesn't require manually keeping the interface in sync.\nexport interface View extends Type.InstanceType<typeof ViewSchema> {}\n\nexport const View: Type.Obj<View> = ViewSchema as any;\n\nexport const make = (props: Partial<Obj.MakeProps<typeof View>>): View => {\n  return Obj.make(View, {\n    query: { ast: Query.select(Filter.nothing()).ast },\n    projection: { fields: [] },\n    ...props,\n  });\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { pipe } from 'effect/Function';\nimport * as Predicate from 'effect/Predicate';\nimport * as Schema from 'effect/Schema';\n\nimport * as Collection from './Collection';\nimport * as Feed from './Feed';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\nimport * as View from './View';\n\n/**\n * Abstract set of objects, represented by a view, feed, or collection.\n * Schema-level union of the underlying type entities (rebuilt via\n * `Type.getSchema`) so this can still be consumed by Schema-side APIs such\n * as `Filter.type(...)` on a union.\n */\nexport type Dataset = Feed.Feed | Collection.Collection | View.View;\nexport const Dataset = Schema.Union(\n  Type.getSchema(Feed.Feed),\n  Type.getSchema(Collection.Collection),\n  Type.getSchema(View.View),\n);\n\nexport const isDataset: (value: unknown) => value is Dataset = pipe(\n  Obj.instanceOf(Feed.Feed),\n  Predicate.or(Obj.instanceOf(Collection.Collection)),\n  Predicate.or(Obj.instanceOf(View.View)),\n);\n"],
+  "mappings": "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",
+  "names": ["QueryAST", "DXN", "EID", "URI", "EID", "isEncodedRef", "value", "Object", "keys", "length", "toJson", "obj", "toJSON", "createRefReplacer", "db", "depth", "hops", "WeakMap", "key", "parentHops", "get", "dxnString", "startsWith", "echoUri", "parsed", "tryParse", "getEntityId", "undefined", "target", "getObjectById", "encoded", "set", "make", "Schema", "DXN", "Collection", "Struct", "name", "String", "pipe", "optional", "objects", "Array", "Ref", "Unknown", "FormInputAnnotation", "set", "IconAnnotation", "icon", "hue", "makeObject", "DXN", "make", "props", "isCollection", "instanceOf", "make", "Schema", "QueryAST", "SchemaEx", "DXN", "PublicKey", "FieldSchema", "Struct", "id", "String", "path", "SchemaEx", "JsonPath", "visible", "optional", "Boolean", "referencePath", "KeyValueProps", "Record", "key", "value", "Any", "createFieldId", "PublicKey", "random", "truncate", "Projection", "schema", "JsonSchemaType", "pipe", "fields", "Array", "pivotFieldId", "ViewSchema", "query", "raw", "ast", "QueryAST", "Query", "projection", "HiddenAnnotation", "set", "IconAnnotation", "icon", "hue", "makeObject", "DXN", "make", "View", "props", "select", "nothing", "pipe", "Predicate", "Schema", "Dataset", "Union", "getSchema", "Feed", "Collection", "View", "isDataset", "pipe", "instanceOf", "or"]
+}

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

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Scope.ts
+var Scope_exports = {};
+__export(Scope_exports, {
+  feed: () => feed,
+  registry: () => registry,
+  space: () => space
+});
+var space = (options) => ({
+  _tag: "space",
+  ...options?.id !== void 0 ? {
+    spaceId: options.id
+  } : {},
+  ...options?.includeAllFeeds ? {
+    includeAllFeeds: true
+  } : {}
+});
+var registry = (location = "local") => ({
+  _tag: "registry",
+  location
+});
+var feed = (feedUri) => ({
+  _tag: "feed",
+  feedUri
+});
+
+export {
+  space,
+  registry,
+  feed,
+  Scope_exports
+};
+//# sourceMappingURL=chunk-WISOH2XH.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Scope.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\n/**\n * Scope targeting a space's automerge documents.\n *\n * With no `spaceId`, targets the owning space — i.e. the space of whichever database\n * executes the query — so callers can reference \"this space\" without looking up its id.\n *\n * @example\n * ```ts\n * db.query(Filter.type(Person).from(Scope.space()));            // owning space\n * db.query(Filter.type(Person).from(Scope.space({ id: otherSpaceId }))); // a specific space\n * ```\n */\nexport const space = (options?: { id?: string; includeAllFeeds?: boolean }): QueryAST.SpaceScope => ({\n  _tag: 'space',\n  ...(options?.id !== undefined ? { spaceId: options.id } : {}),\n  ...(options?.includeAllFeeds ? { includeAllFeeds: true } : {}),\n});\n\n/**\n * Scope targeting a code-shipped object/type registry.\n *\n * - `'local'`  — the in-process registry attached to the hypergraph (default).\n * - `'remote'` — a remote registry service (not yet implemented).\n *\n * @example\n * ```ts\n * // Discover all types — persisted in the space and code-shipped in the registry.\n * db.query(Filter.type(Type.Type).from(Scope.space(), Scope.registry()));\n * ```\n */\nexport const registry = (location: 'local' | 'remote' = 'local'): QueryAST.RegistryScope => ({\n  _tag: 'registry',\n  location,\n});\n\n/**\n * Scope targeting a specific feed (by its underlying queue EID).\n */\nexport const feed = (feedUri: string): QueryAST.FeedScope => ({\n  _tag: 'feed',\n  feedUri,\n});\n"],
+  "mappings": ";;;;;AAAA;;;;;;AAoBO,IAAMA,QAAQ,CAACC,aAA+E;EACnGC,MAAM;EACN,GAAID,SAASE,OAAOC,SAAY;IAAEC,SAASJ,QAAQE;EAAG,IAAI,CAAC;EAC3D,GAAIF,SAASK,kBAAkB;IAAEA,iBAAiB;EAAK,IAAI,CAAC;AAC9D;AAcO,IAAMC,WAAW,CAACC,WAA+B,aAAqC;EAC3FN,MAAM;EACNM;AACF;AAKO,IAAMC,OAAO,CAACC,aAAyC;EAC5DR,MAAM;EACNQ;AACF;",
+  "names": ["space", "options", "_tag", "id", "undefined", "spaceId", "includeAllFeeds", "registry", "location", "feed", "feedUri"]
+}

package/dist/lib/neutral/{chunk-G3IQMKF7.mjs → chunk-WTQJHC75.mjs}

@@ -1,12 +1,13 @@
-import {
-  Service
-} from "./chunk-PHU22NLC.mjs";
 import {
   ReferenceAnnotationId,
-  getSchemaDXN,
+  Service,
+  getSchemaURI,
   getTypeAnnotation,
   getTypeIdentifierAnnotation
-} from "./chunk-2KHZ36F5.mjs";
+} from "./chunk-R5W6DXR4.mjs";
+import {
+  getStaticTypeSchema
+} from "./chunk-O6BH7EPN.mjs";
 
 // src/internal/Ref/ref.ts
 import * as Effect from "effect/Effect";
@@ -21,15 +22,49 @@ import { Event } from "@dxos/async";
 import { inspectCustom } from "@dxos/debug";
 import { EncodedReference } from "@dxos/echo-protocol";
 import { assertArgument, invariant } from "@dxos/invariant";
-import { DXN, ObjectId } from "@dxos/keys";
+import { DXN, EID, EntityId } from "@dxos/keys";
+
+// src/internal/Ref/atoms.ts
+import * as Atom from "@effect-atom/atom/Atom";
+
+// src/internal/Ref/utils.ts
+var loadRefTarget = (ref, get, onTargetAvailable) => {
+  const currentTarget = ref.target;
+  if (currentTarget) {
+    return onTargetAvailable(currentTarget);
+  }
+  const unsubscribe = ref.onResolved(() => {
+    const target = ref.target;
+    if (target) {
+      get.setSelf(onTargetAvailable(target));
+    }
+  });
+  get.addFinalizer(unsubscribe);
+  void ref.load().then((loadedTarget) => {
+    get.setSelf(onTargetAvailable(loadedTarget));
+  }).catch(() => {
+  });
+  return void 0;
+};
+
+// src/internal/Ref/atoms.ts
+var refSimpleFamily = Atom.family((ref) => {
+  return Atom.make((get) => {
+    return loadRefTarget(ref, get, (target) => target);
+  });
+});
+
+// src/internal/Ref/ref.ts
 var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Ref/ref.ts";
 var JSON_SCHEMA_ECHO_REF_ID = "/schemas/echo/ref";
 var getSchemaReference = (property) => {
   const { $id, reference: { schema: { $ref } = {} } = {} } = property;
   if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {
-    return {
-      typename: DXN.parse($ref).typename
-    };
+    const parsed = DXN.tryMake($ref);
+    const typename = parsed ? DXN.getName(parsed) : void 0;
+    return typename ? {
+      typename
+    } : void 0;
   }
 };
 var createSchemaReference = (typename) => {
@@ -37,7 +72,7 @@ var createSchemaReference = (typename) => {
     $id: JSON_SCHEMA_ECHO_REF_ID,
     reference: {
       schema: {
-        $ref: DXN.fromTypename(typename).toString()
+        $ref: DXN.make(typename)
       }
     }
   };
@@ -52,7 +87,8 @@ var getReferenceAst = (ast) => {
   };
 };
 var RefTypeId = /* @__PURE__ */ Symbol("@dxos/echo/internal/Ref");
-var Ref = (schema) => {
+var Ref = (input) => {
+  const schema = getStaticTypeSchema(input) ?? input;
   assertArgument(Schema.isSchema(schema), "schema", "Must call with an instance of effect-schema");
   const annotation = getTypeAnnotation(schema);
   if (annotation == null) {
@@ -63,7 +99,10 @@ var Ref = (schema) => {
 Ref.isRef = (obj) => {
   return obj && typeof obj === "object" && RefTypeId in obj;
 };
-Ref.hasObjectId = (id) => (ref) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;
+Ref.hasEntityId = (id) => (ref) => {
+  const uri = EID.tryParse(ref.uri);
+  return uri !== void 0 && EID.isLocal(uri) && EID.getEntityId(uri) === id;
+};
 Ref.isRefSchema = (schema) => {
   return Ref.isRefSchemaAST(schema.ast);
 };
@@ -75,30 +114,24 @@ Ref.make = (obj) => {
     throw new TypeError("Expected: ECHO object.");
   }
   const id = obj.id;
-  invariant(ObjectId.isValid(id), "Invalid object ID", {
-    F: __dxlog_file,
-    L: 225,
-    S: void 0,
-    A: [
-      "ObjectId.isValid(id)",
-      "'Invalid object ID'"
-    ]
+  invariant(EntityId.isValid(id), "Invalid object ID", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 86, S: void 0, A: ["EntityId.isValid(id)", "'Invalid object ID'"] });
+  const uri = EID.make({
+    entityId: id
   });
-  const dxn = DXN.fromLocalObjectId(id);
-  return new RefImpl(dxn, obj);
+  return new RefImpl(uri, obj);
 };
-Ref.fromDXN = (dxn) => {
-  assertArgument(dxn instanceof DXN, "dxn", "Expected DXN");
-  return new RefImpl(dxn);
+Ref.fromURI = (uri) => {
+  assertArgument(typeof uri === "string", "uri", "Expected URI string");
+  return new RefImpl(uri);
 };
-var createEchoReferenceSchema = (echoId, typename, version) => {
-  if (!echoId && !typename) {
-    throw new TypeError("Either echoId or typename must be provided.");
+var createEchoReferenceSchema = (echoUri, typename, version) => {
+  if (!echoUri && !typename) {
+    throw new TypeError("Either echoUri or typename must be provided.");
   }
   const referenceInfo = {
     schema: {
       // TODO(dmaretskyi): Include version?
-      $ref: echoId ?? DXN.fromTypename(typename).toString()
+      $ref: echoUri ?? DXN.make(typename)
     },
     schemaVersion: version
   };
@@ -106,7 +139,7 @@ var createEchoReferenceSchema = (echoId, typename, version) => {
     encode: () => {
       return (value) => Effect.gen(function* () {
         if (Ref.isRef(value)) {
-          return EncodedReference.fromDXN(value.dxn);
+          return EncodedReference.fromURI(value.uri);
         } else if (EncodedReference.isEncodedReference(value)) {
           return value;
         }
@@ -118,7 +151,7 @@ var createEchoReferenceSchema = (echoId, typename, version) => {
         const dbService = yield* Effect.serviceOption(Service);
         if (Ref.isRef(value)) {
           if (Option.isSome(dbService)) {
-            return dbService.value.db.makeRef(value.dxn);
+            return dbService.value.db.makeRef(value.uri);
           } else {
             return value;
           }
@@ -127,9 +160,9 @@ var createEchoReferenceSchema = (echoId, typename, version) => {
           return yield* Effect.fail(new ParseResult.Unexpected(value, "reference"));
         }
         if (Option.isSome(dbService)) {
-          return dbService.value.db.makeRef(EncodedReference.toDXN(value));
+          return dbService.value.db.makeRef(EncodedReference.toURI(value));
         } else {
-          return Ref.fromDXN(EncodedReference.toDXN(value));
+          return Ref.fromURI(EncodedReference.toURI(value));
         }
       });
     }
@@ -148,7 +181,7 @@ var createEchoReferenceSchema = (echoId, typename, version) => {
   return refSchema;
 };
 var RefImpl = class _RefImpl {
-  #dxn;
+  #uri;
   #resolver = void 0;
   #resolved = new Event();
   /**
@@ -162,15 +195,15 @@ var RefImpl = class _RefImpl {
   #resolverCallback = () => {
     this.#resolved.emit();
   };
-  constructor(dxn, target) {
-    this.#dxn = dxn;
+  constructor(uri, target) {
+    this.#uri = uri;
     this.#target = target;
   }
   /**
   * @inheritdoc
   */
-  get dxn() {
-    return this.#dxn;
+  get uri() {
+    return this.#uri;
   }
   /**
   * @inheritdoc
@@ -185,16 +218,8 @@ var RefImpl = class _RefImpl {
     if (this.#target) {
       return this.#target;
     }
-    invariant(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file,
-      L: 393,
-      S: this,
-      A: [
-        "this.#resolver",
-        "'Resolver is not set'"
-      ]
-    });
-    return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback);
+    invariant(this.#resolver, "Resolver is not set", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 193, S: this, A: ["this.#resolver", "'Resolver is not set'"] });
+    return this.#resolver.resolveSync(this.#uri, true, this.#resolverCallback);
   }
   /**
   * @inheritdoc
@@ -203,16 +228,8 @@ var RefImpl = class _RefImpl {
     if (this.#target) {
       return this.#target;
     }
-    invariant(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file,
-      L: 404,
-      S: this,
-      A: [
-        "this.#resolver",
-        "'Resolver is not set'"
-      ]
-    });
-    const obj = await this.#resolver.resolve(this.#dxn);
+    invariant(this.#resolver, "Resolver is not set", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 202, S: this, A: ["this.#resolver", "'Resolver is not set'"] });
+    const obj = await this.#resolver.resolve(this.#uri);
     if (obj == null) {
       throw new Error("Object not found");
     }
@@ -225,16 +242,14 @@ var RefImpl = class _RefImpl {
     if (this.#target) {
       return this.#target;
     }
-    invariant(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file,
-      L: 419,
-      S: this,
-      A: [
-        "this.#resolver",
-        "'Resolver is not set'"
-      ]
-    });
-    return await this.#resolver.resolve(this.#dxn);
+    invariant(this.#resolver, "Resolver is not set", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 215, S: this, A: ["this.#resolver", "'Resolver is not set'"] });
+    return await this.#resolver.resolve(this.#uri);
+  }
+  /**
+  * @inheritdoc
+  */
+  onResolved(callback) {
+    return this.#resolved.on(callback);
   }
   /**
   * Do not inline the target object in the reference.
@@ -242,13 +257,13 @@ var RefImpl = class _RefImpl {
   * Clones the reference object.
   */
   noInline() {
-    const ref = new _RefImpl(this.#dxn, void 0);
+    const ref = new _RefImpl(this.#uri, void 0);
     ref.#resolver = this.#resolver;
     return ref;
   }
   encode() {
     return {
-      "/": this.#dxn.toString(),
+      "/": this.#uri,
       ...this.#target ? {
         target: this.#target
       } : {}
@@ -267,7 +282,7 @@ var RefImpl = class _RefImpl {
     if (this.#target) {
       return `Ref(${this.#target.toString()})`;
     }
-    return `Ref(${this.#dxn.toString()})`;
+    return `Ref(${this.#uri.toString()})`;
   }
   [inspectCustom] = (depth, options, inspect) => {
     return this.toString();
@@ -280,11 +295,14 @@ var RefImpl = class _RefImpl {
   * so without this, each access would create a separate cache entry.
   */
   [Hash.symbol]() {
-    return Hash.hash(this.#dxn.toString());
+    return Hash.hash(this.#uri.toString());
   }
   /** Effect Equal trait. See {@link Hash.symbol} for rationale. */
   [Equal.symbol](that) {
-    return that instanceof _RefImpl && this.#dxn.toString() === that.dxn.toString();
+    return that instanceof _RefImpl && this.#uri === that.uri;
+  }
+  get atom() {
+    return refSimpleFamily(this);
   }
   /**
   * Internal method to set the resolver.
@@ -305,35 +323,19 @@ var RefImpl = class _RefImpl {
   }
 };
 var setRefResolver = (ref, resolver) => {
-  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
-    F: __dxlog_file,
-    L: 506,
-    S: void 0,
-    A: [
-      "ref instanceof RefImpl",
-      "'Ref is not an instance of RefImpl'"
-    ]
-  });
+  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 292, S: void 0, A: ["ref instanceof RefImpl", "'Ref is not an instance of RefImpl'"] });
   ref._setResolver(resolver);
 };
 var getRefSavedTarget = (ref) => {
-  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
-    F: __dxlog_file,
-    L: 514,
-    S: void 0,
-    A: [
-      "ref instanceof RefImpl",
-      "'Ref is not an instance of RefImpl'"
-    ]
-  });
+  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 298, S: void 0, A: ["ref instanceof RefImpl", "'Ref is not an instance of RefImpl'"] });
   return ref._getSavedTarget();
 };
 var refVariance = {
   _T: null
 };
 var refFromEncodedReference = (encodedReference, resolver) => {
-  const dxn = DXN.parse(encodedReference["/"]);
-  const ref = new RefImpl(dxn);
+  const uri = EncodedReference.toURI(encodedReference);
+  const ref = new RefImpl(uri);
   if (resolver) {
     setRefResolver(ref, resolver);
   }
@@ -346,40 +348,37 @@ var StaticRefResolver = class {
     this.objects.set(obj.id, obj);
     return this;
   }
-  addSchema(schema) {
-    const dxn = getSchemaDXN(schema);
-    invariant(dxn, "Schema has no DXN", {
-      F: __dxlog_file,
-      L: 546,
-      S: this,
-      A: [
-        "dxn",
-        "'Schema has no DXN'"
-      ]
-    });
-    this.schemas.set(dxn.toString(), schema);
+  addSchema(input) {
+    const schema = getStaticTypeSchema(input);
+    invariant(schema, "Type entity is missing its source schema", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 323, S: this, A: ["schema", "'Type entity is missing its source schema'"] });
+    const uri = getSchemaURI(schema);
+    invariant(uri, "Schema has no URI", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 325, S: this, A: ["uri", "'Schema has no URI'"] });
+    this.schemas.set(uri, schema);
     return this;
   }
-  resolveSync(dxn, _load, _onLoad) {
-    const id = dxn?.asEchoDXN()?.echoId;
+  resolveSync(uri, _load, _onLoad) {
+    const echoUri = EID.tryParse(uri);
+    const id = echoUri ? EID.getEntityId(echoUri) : void 0;
     if (id == null) {
       return void 0;
     }
     return this.objects.get(id);
   }
-  async resolve(dxn) {
-    const id = dxn?.asEchoDXN()?.echoId;
+  async resolve(uri) {
+    const echoUri = EID.tryParse(uri);
+    const id = echoUri ? EID.getEntityId(echoUri) : void 0;
     if (id == null) {
       return void 0;
     }
     return this.objects.get(id);
   }
-  async resolveSchema(dxn) {
-    return this.schemas.get(dxn.toString());
+  async resolveSchema(uri) {
+    return this.schemas.get(uri);
   }
 };
 
 export {
+  loadRefTarget,
   JSON_SCHEMA_ECHO_REF_ID,
   getSchemaReference,
   createSchemaReference,
@@ -393,4 +392,4 @@ export {
   refFromEncodedReference,
   StaticRefResolver
 };
-//# sourceMappingURL=chunk-G3IQMKF7.mjs.map
+//# sourceMappingURL=chunk-WTQJHC75.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Ref/ref.ts", "../../../src/internal/Ref/atoms.ts", "../../../src/internal/Ref/utils.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport type * as Atom from '@effect-atom/atom/Atom';\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as Hash from 'effect/Hash';\nimport * as Option from 'effect/Option';\nimport * as ParseResult from 'effect/ParseResult';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { Event } from '@dxos/async';\nimport { type CustomInspectFunction, inspectCustom } from '@dxos/debug';\nimport { EncodedReference } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, EID, EntityId, type URI } from '@dxos/keys';\n\nimport * as Database from '../../Database';\nimport type * as Type from '../../Type';\nimport {\n  ReferenceAnnotationId,\n  getSchemaURI,\n  getTypeAnnotation,\n  getTypeIdentifierAnnotation,\n} from '../Annotation/annotations';\nimport { type AnyEntity, type AnyProperties, type UnknownTypeSchema, getStaticTypeSchema } from '../common/types';\nimport { type JsonSchemaType } from '../JsonSchema';\nimport * as RefAtoms from './atoms';\n\n/**\n * The `$id` and `$ref` fields for an ECHO reference schema.\n */\nexport const JSON_SCHEMA_ECHO_REF_ID = '/schemas/echo/ref';\n\nexport const getSchemaReference = (property: JsonSchemaType): { typename: string } | undefined => {\n  const { $id, reference: { schema: { $ref } = {} } = {} } = property;\n  if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {\n    const parsed = DXN.tryMake($ref);\n    const typename = parsed ? DXN.getName(parsed) : undefined;\n    return typename ? { typename } : undefined;\n  }\n};\n\nexport const createSchemaReference = (typename: string): Types.DeepMutable<JsonSchemaType> => {\n  return {\n    $id: JSON_SCHEMA_ECHO_REF_ID,\n    reference: {\n      schema: {\n        $ref: DXN.make(typename),\n      },\n    },\n  };\n};\n\n/**\n * Runtime type-info for a reference extracted from effect AST.\n */\nexport type RefereneAST = {\n  /**\n   * Typename of linked schema.\n   */\n  typename: string;\n\n  /**\n   * Version of linked schema.\n   */\n  version: string;\n};\n\nexport const getReferenceAst = (ast: SchemaAST.AST): RefereneAST | undefined => {\n  if (ast._tag !== 'Declaration' || !ast.annotations[ReferenceAnnotationId]) {\n    return undefined;\n  }\n  return {\n    typename: (ast.annotations[ReferenceAnnotationId] as any).typename,\n    version: (ast.annotations[ReferenceAnnotationId] as any).version,\n  };\n};\n\nexport const RefTypeId: unique symbol = Symbol('@dxos/echo/internal/Ref');\n\n/**\n * Reference Schema.\n */\nexport interface RefSchema<T extends AnyEntity> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}\n\n/**\n * Type of the `Ref` function and extra methods attached to it.\n */\nexport interface RefFn {\n  // A reference target is a `Type.AnyEntity` entity (the canonical Option B\n  // input) or one of the well-known \"any object\" / \"any relation\" branded\n  // schemas (`Obj.Unknown` / `Relation.Unknown`). Arbitrary raw schemas are\n  // rejected.\n  //\n  // Referencing a type-kind entity (a meta-schema, e.g. `Type.Type`) yields a\n  // reference to a stored schema record; its loaded target is any registered\n  // entity (`Type.AnyEntity`), since a stored object/relation schema is itself a\n  // `Type.Type` record. Referencing an object/relation type yields a reference\n  // to an instance of that type.\n  <S extends Type.AnyEntity | UnknownTypeSchema<any, any> = Type.AnyEntity>(\n    schema: S,\n  ): RefSchema<\n    S extends Type.AnyType\n      ? Type.AnyEntity\n      : S extends Type.AnyObj | Type.AnyRelation\n        ? Type.InstanceType<S>\n        : S extends UnknownTypeSchema<infer A, any>\n          ? A\n          : never\n  >;\n\n  /**\n   * @returns True if the object is a reference.\n   */\n  isRef: (obj: unknown) => obj is Ref<any>;\n\n  /**\n   * @returns True if the reference points to the given object id.\n   */\n  hasEntityId: (id: EntityId) => (ref: Ref<any>) => boolean;\n\n  /**\n   * @returns True if the schema is a reference schema.\n   */\n  isRefSchema: (schema: Schema.Schema<any, any>) => schema is RefSchema<any>;\n\n  /**\n   * @returns True if the schema AST is a reference schema.\n   */\n  isRefSchemaAST: (ast: SchemaAST.AST) => boolean;\n\n  /**\n   * Constructs a reference that points to the given object.\n   */\n  // TODO(burdon): Narrow to Obj.Unknown?\n  make: <T extends AnyEntity>(object: T) => Ref<T>;\n\n  /**\n   * Constructs a reference that points to the object specified by the provided URI\n   * (either an `echo:` EID for an object reference or a `dxn:` DXN for a type reference).\n   */\n  fromURI: (uri: URI.URI) => Ref<any>;\n}\n\n/**\n * Schema builder for references.\n */\nexport const Ref: RefFn = (input: any): RefSchema<any> => {\n  // `Type.Type` entities carry their source schema on the hidden slot; the\n  // branded `Obj.Unknown` / `Relation.Unknown` schemas are used directly.\n  const schema = getStaticTypeSchema(input) ?? input;\n  assertArgument(Schema.isSchema(schema), 'schema', 'Must call with an instance of effect-schema');\n  const annotation = getTypeAnnotation(schema);\n  if (annotation == null) {\n    throw new Error('Reference target must be an ECHO schema.');\n  }\n\n  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version);\n};\n\n/**\n * Represents materialized reference to a target.\n * This is the data type for the fields marked as ref.\n */\nexport interface Ref<T> extends Pipeable.Pipeable {\n  /**\n   * Target URI (either an `echo:` EID for an object reference or a `dxn:` DXN for a type reference).\n   */\n  get uri(): URI.URI;\n\n  /**\n   * Returns true if the reference has a target available (inlined or resolver set).\n   */\n  get isAvailable(): boolean;\n\n  /**\n   * @returns The reference target.\n   * May return `undefined` if the object is not loaded in the working set.\n   * Accessing this property, even if it returns `undefined` will trigger the object to be loaded to the working set.\n   */\n  get target(): T | undefined;\n\n  /**\n   * @returns Promise that will resolves with the target object.\n   * Will load the object from disk if it is not present in the working set.\n   * @throws If the object is not available locally.\n   */\n  load(): Promise<T>;\n\n  /**\n   * @returns Promise that will resolves with the target object or undefined if the object is not loaded locally.\n   */\n\n  tryLoad(): Promise<T | undefined>;\n\n  /**\n   * Subscribe to the ref's resolution event.\n   * The callback fires when the target object becomes available in the working set\n   * (e.g. when its document is loaded after sibling-client mutation).\n   * Note: the resolver only schedules a notification when the target is requested\n   * via {@link target} while it is not yet loaded.\n   * @returns Function that unsubscribes the callback.\n   */\n  onResolved(callback: () => void): () => void;\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   *\n   * When serialized with toJSON, the difference is between:\n   * `{ \"/\": \"dxn:...\" }`\n   * and\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   *\n   * Clones the reference object.\n   */\n  noInline(): Ref<T>;\n\n  /**\n   * Read-only atom for the ref target.\n   * Resolves once when the target loads; does NOT subscribe to target object mutations.\n   * Use `Obj.atom(ref)` if you need reactive snapshots that update on every object mutation.\n   */\n  get atom(): Atom.Atom<T | undefined>;\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   *\n   * Examples:\n   * `{ \"/\": \"dxn:...\" }`\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   */\n  encode(): EncodedReference;\n\n  [RefTypeId]: {\n    _T: T;\n  };\n}\n\nexport declare namespace Ref {\n  /**\n   * Target of the reference.\n   */\n  export type Target<R> = R extends Ref<infer U> ? U : never;\n}\n\nRef.isRef = (obj: any): obj is Ref<any> => {\n  return obj && typeof obj === 'object' && RefTypeId in obj;\n};\n\nRef.hasEntityId = (id: EntityId) => (ref: Ref<any>) => {\n  const uri = EID.tryParse(ref.uri);\n  return uri !== undefined && EID.isLocal(uri) && EID.getEntityId(uri) === id;\n};\n\nRef.isRefSchema = (schema: Schema.Schema<any, any>): schema is RefSchema<any> => {\n  return Ref.isRefSchemaAST(schema.ast);\n};\n\nRef.isRefSchemaAST = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);\n};\n\nRef.make = <T extends AnyProperties>(obj: T): Ref<T> => {\n  if (typeof obj !== 'object' || obj === null) {\n    throw new TypeError('Expected: ECHO object.');\n  }\n\n  // TODO(dmaretskyi): Extract to `getObjectEchoUri` function.\n  const id = obj.id;\n  invariant(EntityId.isValid(id), 'Invalid object ID');\n  const uri = EID.make({ entityId: id });\n  return new RefImpl(uri, obj);\n};\n\nRef.fromURI = (uri: URI.URI): Ref<any> => {\n  assertArgument(typeof uri === 'string', 'uri', 'Expected URI string');\n  return new RefImpl(uri);\n};\n\n/**\n * `reference` field on the schema object.\n */\nexport type JsonSchemaReferenceInfo = {\n  schema: { $ref: string };\n  schemaVersion?: string;\n};\n\n/**\n * @internal\n */\n// TODO(burdon): Move to json schema and make private?\nexport const createEchoReferenceSchema = (\n  echoUri: string | undefined,\n  typename: string | undefined,\n  version: string | undefined,\n): Schema.SchemaClass<Ref<any>, EncodedReference> => {\n  if (!echoUri && !typename) {\n    throw new TypeError('Either echoUri or typename must be provided.');\n  }\n\n  const referenceInfo: JsonSchemaReferenceInfo = {\n    schema: {\n      // TODO(dmaretskyi): Include version?\n      $ref: echoUri ?? DXN.make(typename!),\n    },\n    schemaVersion: version,\n  };\n\n  // TODO(dmaretskyi): Add name and description.\n  const refSchema = Schema.declare<Ref<any>, EncodedReference, []>(\n    [],\n    {\n      encode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            if (Ref.isRef(value)) {\n              return EncodedReference.fromURI((value as Ref<any>).uri);\n            } else if (EncodedReference.isEncodedReference(value)) {\n              return value;\n            }\n            throw new Error('Invalid reference');\n          });\n      },\n      decode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            const dbService = yield* Effect.serviceOption(Database.Service);\n\n            // TODO(dmaretskyi): This branch seems to be taken by Schema.is\n            if (Ref.isRef(value)) {\n              if (Option.isSome(dbService)) {\n                return dbService.value.db.makeRef(value.uri);\n              } else {\n                return value;\n              }\n            }\n\n            if (!EncodedReference.isEncodedReference(value)) {\n              return yield* Effect.fail(new ParseResult.Unexpected(value, 'reference'));\n            }\n            if (Option.isSome(dbService)) {\n              return dbService.value.db.makeRef(EncodedReference.toURI(value));\n            } else {\n              return Ref.fromURI(EncodedReference.toURI(value));\n            }\n          });\n      },\n    },\n    {\n      jsonSchema: {\n        // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.\n        $id: JSON_SCHEMA_ECHO_REF_ID,\n        $ref: JSON_SCHEMA_ECHO_REF_ID,\n        reference: referenceInfo,\n      },\n      [ReferenceAnnotationId]: {\n        typename: typename ?? '',\n        version,\n      },\n    },\n  );\n\n  return refSchema;\n};\n\nconst getSchemaExpectedName = (ast: SchemaAST.Annotated): string | undefined => {\n  return SchemaAST.getIdentifierAnnotation(ast).pipe(\n    Option.orElse(() => SchemaAST.getTitleAnnotation(ast)),\n    Option.orElse(() => SchemaAST.getDescriptionAnnotation(ast)),\n    Option.getOrElse(() => undefined),\n  );\n};\n\nexport interface RefResolver {\n  /**\n   * Resolve ref synchronously from the objects in the working set.\n   *\n   * @param uri\n   * @param load If true the resolver should attempt to load the object from disk.\n   * @param onLoad Callback to call when the object is loaded.\n   */\n  resolveSync(uri: URI.URI, load: boolean, onLoad?: () => void): AnyProperties | undefined;\n\n  /**\n   * Resolver ref asynchronously.\n   */\n  resolve(uri: URI.URI): Promise<AnyProperties | undefined>;\n\n  // TODO(dmaretskyi): Combine with `resolve`.\n  resolveSchema(uri: URI.URI): Promise<Schema.Schema.AnyNoContext | undefined>;\n\n  /**\n   * Resolve the source `Type.AnyEntity` entity for a type URI. Used by\n   * deserialization paths (`Obj.fromJSON`) to set the back-reference accessed\n   * via `Obj.getType` / `Entity.getType`. Optional — resolvers that only\n   * carry raw schemas may leave this unimplemented; the deserializer falls\n   * back to leaving the type entity unset.\n   */\n  resolveType?(uri: URI.URI): Promise<unknown | undefined>;\n}\n\nexport class RefImpl<T> implements Ref<T> {\n  #uri: URI.URI;\n  #resolver?: RefResolver = undefined;\n  #resolved = new Event<void>();\n\n  /**\n   * Target is set when the reference is created from a specific object.\n   * In this case, the target might not be in the database.\n   */\n  #target: T | undefined = undefined;\n\n  /**\n   * Callback to issue a reactive notification when object is resolved.\n   */\n  #resolverCallback = () => {\n    this.#resolved.emit();\n  };\n\n  constructor(uri: URI.URI, target?: T) {\n    this.#uri = uri;\n    this.#target = target;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get uri(): URI.URI {\n    return this.#uri;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get isAvailable(): boolean {\n    return this.#target !== undefined || this.#resolver !== undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get target(): T | undefined {\n    if (this.#target) {\n      return this.#target;\n    }\n\n    invariant(this.#resolver, 'Resolver is not set');\n    return this.#resolver.resolveSync(this.#uri, true, this.#resolverCallback) as T | undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async load(): Promise<T> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    const obj = await this.#resolver.resolve(this.#uri);\n    if (obj == null) {\n      throw new Error('Object not found');\n    }\n    return obj as T;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async tryLoad(): Promise<T | undefined> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    return (await this.#resolver.resolve(this.#uri)) as T | undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  onResolved(callback: () => void): () => void {\n    return this.#resolved.on(callback);\n  }\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   * Clones the reference object.\n   */\n  noInline(): RefImpl<T> {\n    const ref = new RefImpl<T>(this.#uri, undefined);\n    ref.#resolver = this.#resolver;\n    return ref;\n  }\n\n  encode(): EncodedReference {\n    return {\n      '/': this.#uri,\n      ...(this.#target ? { target: this.#target } : {}),\n    };\n  }\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   */\n  toJSON(): EncodedReference {\n    return this.encode();\n  }\n\n  toString(): string {\n    if (this.#target) {\n      return `Ref(${this.#target.toString()})`;\n    }\n\n    return `Ref(${this.#uri.toString()})`;\n  }\n\n  [inspectCustom]: CustomInspectFunction = (depth, options, inspect) => {\n    return this.toString();\n  };\n\n  [RefTypeId] = refVariance;\n\n  /**\n   * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)\n   * to deduplicate Ref instances that point to the same object.\n   * ECHO proxies return new RefImpl instances on every property access,\n   * so without this, each access would create a separate cache entry.\n   */\n  [Hash.symbol](): number {\n    return Hash.hash(this.#uri.toString());\n  }\n\n  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */\n  [Equal.symbol](that: Equal.Equal): boolean {\n    return that instanceof RefImpl && this.#uri === that.uri;\n  }\n\n  get atom(): Atom.Atom<T | undefined> {\n    return RefAtoms.refSimpleFamily(this);\n  }\n\n  /**\n   * Internal method to set the resolver.\n   *\n   * @internal\n   */\n  _setResolver(resolver: RefResolver): void {\n    this.#resolver = resolver;\n  }\n\n  /**\n   * @internal\n   */\n  _getSavedTarget(): T | undefined {\n    return this.#target;\n  }\n\n  pipe() {\n    // eslint-disable-next-line prefer-rest-params\n    return Pipeable.pipeArguments(this, arguments);\n  }\n}\n\n/**\n * Internal API for setting the reference resolver.\n */\nexport const setRefResolver = (ref: Ref<any>, resolver: RefResolver) => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  ref._setResolver(resolver);\n};\n\n/**\n * Internal API for getting the saved target on a reference.\n */\nexport const getRefSavedTarget = (ref: Ref<any>): AnyProperties | undefined => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  return ref._getSavedTarget();\n};\n\n// Used to validate reference target type.\nconst refVariance: Ref<any>[typeof RefTypeId] = {\n  _T: null as any,\n};\n\nexport const refFromEncodedReference = (encodedReference: EncodedReference, resolver?: RefResolver): Ref<any> => {\n  const uri = EncodedReference.toURI(encodedReference);\n  const ref = new RefImpl(uri);\n\n  // TODO(dmaretskyi): Handle inline target in the encoded reference.\n\n  if (resolver) {\n    setRefResolver(ref, resolver);\n  }\n  return ref;\n};\n\nexport class StaticRefResolver implements RefResolver {\n  public objects = new Map<EntityId, AnyProperties>();\n  public schemas = new Map<URI.URI, Schema.Schema.AnyNoContext>();\n\n  addObject(obj: AnyProperties): this {\n    this.objects.set(obj.id, obj);\n    return this;\n  }\n\n  addSchema(input: Type.AnyEntity): this {\n    const schema = getStaticTypeSchema(input);\n    invariant(schema, 'Type entity is missing its source schema');\n    const uri = getSchemaURI(schema);\n    invariant(uri, 'Schema has no URI');\n    this.schemas.set(uri, schema);\n    return this;\n  }\n\n  resolveSync(uri: URI.URI, _load: boolean, _onLoad?: () => void): AnyProperties | undefined {\n    const echoUri = EID.tryParse(uri);\n    const id = echoUri ? EID.getEntityId(echoUri) : undefined;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolve(uri: URI.URI): Promise<AnyProperties | undefined> {\n    const echoUri = EID.tryParse(uri);\n    const id = echoUri ? EID.getEntityId(echoUri) : undefined;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolveSchema(uri: URI.URI): Promise<Schema.Schema.AnyNoContext | undefined> {\n    return this.schemas.get(uri);\n  }\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Atom from '@effect-atom/atom/Atom';\n\nimport type { Ref } from './ref';\nimport { loadRefTarget } from './utils';\n\n/**\n * Atom family for ECHO refs.\n * Uses ref reference as key — same ref returns same atom.\n * This atom only updates once when the ref loads — it does not subscribe to target object changes.\n * Use `Obj.atom(ref)` if you need reactive snapshots of ECHO objects via a ref.\n */\nexport const refSimpleFamily = Atom.family(<T>(ref: Ref<T>): Atom.Atom<T | undefined> => {\n  return Atom.make<T | undefined>((get) => {\n    return loadRefTarget(ref, get, (target) => target);\n  });\n});\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Atom from '@effect-atom/atom/Atom';\n\nimport type { Ref } from './ref';\n\n/**\n * Internal helper for loading ref targets in atoms.\n * Handles the common pattern of checking for loaded target and triggering async load.\n */\nexport const loadRefTarget = <T, R>(\n  ref: Ref<T>,\n  get: Atom.Context,\n  onTargetAvailable: (target: T) => R,\n): R | undefined => {\n  // Accessing `ref.target` registers a resolution callback when the target is\n  // not yet loaded, so resolution can be observed via `ref.onResolved` below.\n  const currentTarget = ref.target;\n  if (currentTarget) {\n    return onTargetAvailable(currentTarget);\n  }\n\n  // Subscribe to the ref's resolution event in case the target loads later.\n  const unsubscribe = ref.onResolved(() => {\n    const target = ref.target;\n    if (target) {\n      get.setSelf(onTargetAvailable(target));\n    }\n  });\n  get.addFinalizer(unsubscribe);\n\n  // Also try async load (e.g. for objects that need disk loading).\n  void ref\n    .load()\n    .then((loadedTarget) => {\n      get.setSelf(onTargetAvailable(loadedTarget));\n    })\n    .catch(() => {\n      // Loading failed; the resolution subscription above will pick up cross-client updates.\n    });\n\n  return undefined;\n};\n"],
+  "mappings": "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",
+  "names": ["Effect", "Equal", "Hash", "Option", "ParseResult", "Pipeable", "Schema", "SchemaAST", "Event", "inspectCustom", "EncodedReference", "assertArgument", "invariant", "DXN", "EID", "EntityId", "Atom", "loadRefTarget", "ref", "get", "onTargetAvailable", "currentTarget", "target", "unsubscribe", "onResolved", "setSelf", "addFinalizer", "load", "then", "loadedTarget", "catch", "undefined", "refSimpleFamily", "family", "ref", "make", "get", "loadRefTarget", "target", "reference", "$ref", "$id", "JSON_SCHEMA_ECHO_REF_ID", "parsed", "tryMake", "typename", "getName", "undefined", "schema", "version", "annotation", "getTypeAnnotation", "Error", "createEchoReferenceSchema", "isRef", "obj", "hasEntityId", "ref", "uri", "isRefSchema", "isRefSchemaAST", "ast", "make", "TypeError", "EID", "entityId", "id", "RefImpl", "fromURI", "referenceInfo", "schemaVersion", "Effect", "gen", "EncodedReference", "value", "Ref", "dbService", "Option", "isSome", "jsonSchema", "ReferenceAnnotationId", "getSchemaExpectedName", "undefined", "target", "invariant", "obj", "Error", "ref", "encode", "toString", "inspectCustom", "depth", "options", "inspect", "RefTypeId", "refVariance", "atom", "pipe", "_setResolver", "resolver", "_getSavedTarget", "uri", "schemas", "addObject", "objects", "set", "addSchema", "input", "schema", "getSchemaURI", "resolveSync", "id", "echoUri", "getEntityId", "resolve", "resolveSchema"]
+}

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

@@ -0,0 +1,31 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Registry.ts
+var Registry_exports = {};
+__export(Registry_exports, {
+  Service: () => Service,
+  TypeId: () => TypeId,
+  isRegistry: () => isRegistry,
+  runQuery: () => runQuery
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+var TypeId = /* @__PURE__ */ Symbol.for("@dxos/echo/Registry");
+var isRegistry = (obj) => obj != null && typeof obj === "object" && TypeId in obj && obj[TypeId] === TypeId;
+var Service = class extends Context.Tag("@dxos/echo/Registry/Service")() {
+};
+var runQuery = (queryOrFilter) => Effect.gen(function* () {
+  const registry = yield* Service;
+  return yield* Effect.promise(() => registry.query(queryOrFilter).run());
+});
+
+export {
+  TypeId,
+  isRegistry,
+  Service,
+  runQuery,
+  Registry_exports
+};
+//# sourceMappingURL=chunk-WU3GIANS.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Registry.ts"],
+  "sourcesContent": ["// Copyright 2026 DXOS.org\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\n\nimport { type ReadOnlyEvent } from '@dxos/async';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport type * as Filter from './Filter';\nimport type * as Query from './Query';\n\n/**\n * Identifier denoting an ECHO Registry.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Registry');\nexport type TypeId = typeof TypeId;\n\n/**\n * Composable, in-memory registry of keyed ECHO entities.\n *\n * Entities are stored by id and queried via the standard ECHO Query API.\n * A registry may delegate to an optional upstream registry: results from the local\n * registry take precedence and upstream results fill in anything not found locally.\n *\n * Intended use cases include caches of schemas, operations, blueprints, routines, plugins,\n * etc., sourced from 3rd-party plugins, local code, or local space objects.\n *\n * Types (schema-definition entities produced by `Type.makeObject` / `Type.makeRelation`) are\n * stored the same way as any other entity — via `add()`. Use `list().filter(Type.isType)` to\n * retrieve them.\n *\n * Scope: a Registry is independent of any ECHO space or Hypergraph — it is a process-local,\n * in-memory cache. Wire one per space (e.g. as a Layer scoped to the space's Effect runtime)\n * or share a single instance across spaces depending on the use case.\n *\n * The concrete implementation (and the `makeRegistry` / `registryLayer` factories) lives in\n * `@dxos/echo-client`; this module declares only the interface so that the `@dxos/echo` API surface\n * stays free of query-matching dependencies.\n */\nexport interface Registry {\n  readonly [TypeId]: TypeId;\n\n  /**\n   * Stable per-instance identifier. Used to key process-local resources (e.g. memoized\n   * reactive atoms) to a specific registry instance, analogous to {@link Database.spaceId}.\n   */\n  readonly id: string;\n\n  /**\n   * Fires whenever local registry contents change (add, remove, or clear).\n   */\n  readonly changed: ReadOnlyEvent<void>;\n\n  /**\n   * All locally-stored entities.\n   * Does not include upstream entities — use {@link list} for that.\n   */\n  readonly local: readonly Entity.Unknown[];\n\n  /**\n   * Add or replace one or more entities in the local registry.\n   * Existing entries with the same id are replaced.\n   * Also indexes type entities by DXN for fast lookup.\n   */\n  add(entities: readonly Entity.Unknown[]): void;\n\n  /**\n   * Remove an entity by id from the local registry.\n   * @returns true if an entity was removed, false if it was not found.\n   */\n  remove(id: string): boolean;\n\n  /**\n   * Remove all locally-stored entities.\n   * Does not affect the upstream registry.\n   */\n  clear(): void;\n\n  /**\n   * Get an entity by id.\n   * Searches the local registry first, then falls back to the upstream registry.\n   */\n  get(id: string): Entity.Unknown | undefined;\n\n  /**\n   * Get an entity by one of its addressing URIs — a type entity by its typename DXN (or, when\n   * persisted, its identifier EID), a keyed entity by its `dxn:<key>[:<version>]`. Accepts legacy\n   * DXN forms (normalized internally). Searches the local registry first, then falls back to the\n   * upstream registry. Narrow the result with `Type.isType` when a type entity is required.\n   */\n  getByURI(uri: string): Entity.Unknown | undefined;\n\n  /**\n   * List all entities.\n   * Local entities take precedence over upstream entities with the same id.\n   */\n  list(): Entity.Unknown[];\n\n  /**\n   * Run an ECHO query against the registry's entities (implements {@link Database.Queryable}).\n   *\n   * Matching happens in-memory over {@link list}. Scope (`from`) clauses are unwrapped and\n   * ignored — a direct registry query always targets the registry's own entities. The primary\n   * way to query registry contents is still through the database (`db.query(...).from(Scope.registry())`),\n   * which fans the database and registry together; this method is for querying a registry directly.\n   *\n   * Only locally-evaluable AST nodes are supported: `select`, `filter`, `limit`, `from`, `options`,\n   * and boolean combinators. Server-side concerns (order, traversal, text/timestamp filters) throw.\n   */\n  query: Database.QueryFn;\n}\n\n/**\n * Type guard for {@link Registry}.\n */\nexport const isRegistry = (obj: unknown): obj is Registry =>\n  obj != null && typeof obj === 'object' && TypeId in obj && (obj as { [TypeId]?: unknown })[TypeId] === TypeId;\n\n/**\n * Options for the registry factory (`makeRegistry` in `@dxos/echo-client`).\n */\nexport type Options = {\n  /**\n   * Optional upstream registry. Queries fall back to upstream when an entity\n   * is not present in the local registry.\n   */\n  upstream?: Registry;\n\n  /**\n   * Initial set of entities to seed the local registry with.\n   */\n  initial?: readonly Entity.Unknown[];\n};\n\n/**\n * Effect Context tag for {@link Registry}.\n * Use this to inject a registry into Effect-based code.\n */\nexport class Service extends Context.Tag('@dxos/echo/Registry/Service')<Service, Registry>() {}\n\n/**\n * Executes a query against the registry and returns the results.\n * Analogous to {@link Database.query} `.run` for the in-process registry.\n */\nexport const runQuery: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  Effect.gen(function* () {\n    const registry = yield* Service;\n    return (yield* Effect.promise(() => registry.query(queryOrFilter as any).run())) as any;\n  });\n"],
+  "mappings": ";;;;;AAAA;;;;;;;AAIA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AAYjB,IAAMC,SAASC,uBAAOC,IAAI,qBAAA;AAqG1B,IAAMC,aAAa,CAACC,QACzBA,OAAO,QAAQ,OAAOA,QAAQ,YAAYJ,UAAUI,OAAQA,IAA+BJ,MAAAA,MAAYA;AAsBlG,IAAMK,UAAN,cAA8BC,YAAI,6BAAA,EAAA,EAAA;AAAqD;AAMvF,IAAMC,WAGT,CAACC,kBACIC,WAAI,aAAA;AACT,QAAMC,WAAW,OAAOL;AACxB,SAAQ,OAAcM,eAAQ,MAAMD,SAASE,MAAMJ,aAAAA,EAAsBK,IAAG,CAAA;AAC9E,CAAA;",
+  "names": ["Context", "Effect", "TypeId", "Symbol", "for", "isRegistry", "obj", "Service", "Tag", "runQuery", "queryOrFilter", "gen", "registry", "promise", "query", "run"]
+}