@dxos/echo 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

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

@@ -0,0 +1,205 @@
+import {
+  select
+} from "./chunk-QQIYS74I.mjs";
+import {
+  Feed
+} from "./chunk-ZGNNFYHS.mjs";
+import {
+  nothing
+} from "./chunk-6YDI3J37.mjs";
+import {
+  Unknown,
+  instanceOf,
+  make
+} from "./chunk-TYGKCRMK.mjs";
+import {
+  Ref
+} from "./chunk-MZ7K3MLL.mjs";
+import {
+  getSchema,
+  makeObject
+} from "./chunk-T6E37YIP.mjs";
+import {
+  JsonSchemaType
+} from "./chunk-7PI7C4EF.mjs";
+import {
+  FormInputAnnotation,
+  HiddenAnnotation,
+  IconAnnotation
+} from "./chunk-R5W6DXR4.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/index.ts
+import { QueryAST as QueryAST2 } from "@dxos/echo-protocol";
+import { DXN as DXN3, EID as EID2, URI } from "@dxos/keys";
+
+// src/Hypergraph.ts
+var Hypergraph_exports = {};
+
+// src/Json.ts
+var Json_exports = {};
+__export(Json_exports, {
+  createRefReplacer: () => createRefReplacer
+});
+import { EID } from "@dxos/keys";
+var isEncodedRef = (value) => typeof value === "object" && value !== null && Object.keys(value).length === 1 && typeof value["/"] === "string";
+var toJson = (obj) => typeof obj.toJSON === "function" ? obj.toJSON() : obj;
+var createRefReplacer = ({ db, depth = 1 }) => {
+  const hops = /* @__PURE__ */ new WeakMap();
+  return function(key, value) {
+    const parentHops = this && typeof this === "object" ? hops.get(this) ?? 0 : 0;
+    if (isEncodedRef(value)) {
+      if (parentHops >= depth) {
+        return value;
+      }
+      const dxnString = value["/"];
+      if (!dxnString.startsWith("dxn:") && !dxnString.startsWith("echo:")) {
+        return value;
+      }
+      let echoUri;
+      try {
+        const parsed = EID.tryParse(dxnString);
+        echoUri = parsed ? EID.getEntityId(parsed) : void 0;
+      } catch {
+        return value;
+      }
+      if (!echoUri) {
+        return value;
+      }
+      const target = db.getObjectById(echoUri);
+      if (!target) {
+        return value;
+      }
+      const encoded = toJson(target);
+      if (encoded != null && typeof encoded === "object") {
+        hops.set(encoded, parentHops + 1);
+      }
+      return encoded;
+    }
+    if (value != null && typeof value === "object") {
+      hops.set(value, parentHops);
+    }
+    return value;
+  };
+};
+
+// src/Collection.ts
+var Collection_exports = {};
+__export(Collection_exports, {
+  Collection: () => Collection,
+  isCollection: () => isCollection,
+  make: () => make2
+});
+import * as Schema from "effect/Schema";
+import { DXN } from "@dxos/keys";
+var Collection = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  objects: Schema.Array(Ref(Unknown)).pipe(FormInputAnnotation.set(false))
+}).pipe(IconAnnotation.set({
+  icon: "ph--folder--regular",
+  hue: "amber"
+}), makeObject(DXN.make("org.dxos.type.collection", "0.1.0")));
+var make2 = (props = {}) => make(Collection, {
+  objects: [],
+  ...props
+});
+var isCollection = instanceOf(Collection);
+
+// src/View.ts
+var View_exports = {};
+__export(View_exports, {
+  FieldSchema: () => FieldSchema,
+  KeyValueProps: () => KeyValueProps,
+  Projection: () => Projection,
+  View: () => View,
+  createFieldId: () => createFieldId,
+  make: () => make3
+});
+import * as Schema2 from "effect/Schema";
+import { QueryAST } from "@dxos/echo-protocol";
+import { SchemaEx } from "@dxos/effect";
+import { DXN as DXN2, PublicKey } from "@dxos/keys";
+var FieldSchema = Schema2.Struct({
+  id: Schema2.String,
+  path: SchemaEx.JsonPath,
+  visible: Schema2.optional(Schema2.Boolean),
+  // TODO(wittjosiah): Presentation-specific?
+  referencePath: Schema2.optional(SchemaEx.JsonPath)
+});
+var KeyValueProps = Schema2.Record({
+  key: Schema2.String,
+  value: Schema2.Any
+});
+var createFieldId = () => PublicKey.random().truncate();
+var Projection = Schema2.Struct({
+  /**
+  * Optional schema override used to customize the underlying schema.
+  */
+  schema: JsonSchemaType.pipe(Schema2.optional),
+  /**
+  * UX metadata associated with displayed fields (in table, form, etc.)
+  */
+  // TODO(wittjosiah): Should this just be an array of SchemaEx.JsonPath?
+  fields: Schema2.Array(FieldSchema),
+  /**
+  * The id for the field used to pivot the view.
+  * E.g., the field to use for kanban columns or the field to use for map coordinates.
+  */
+  pivotFieldId: Schema2.String.pipe(Schema2.optional)
+});
+var ViewSchema = Schema2.Struct({
+  /**
+  * Query used to retrieve data.
+  * Can be a user-provided query grammar string or a query AST.
+  */
+  query: Schema2.Struct({
+    raw: Schema2.optional(Schema2.String),
+    ast: QueryAST.Query
+  }),
+  /**
+  * Projection of the data returned from the query.
+  */
+  projection: Projection
+}).pipe(HiddenAnnotation.set(true), IconAnnotation.set({
+  icon: "ph--funnel--regular",
+  hue: "green"
+}), makeObject(DXN2.make("org.dxos.type.view", "0.1.0")));
+var View = ViewSchema;
+var make3 = (props) => {
+  return make(View, {
+    query: {
+      ast: select(nothing()).ast
+    },
+    projection: {
+      fields: []
+    },
+    ...props
+  });
+};
+
+// src/Dataset.ts
+var Dataset_exports = {};
+__export(Dataset_exports, {
+  Dataset: () => Dataset,
+  isDataset: () => isDataset
+});
+import { pipe } from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as Schema3 from "effect/Schema";
+var Dataset = Schema3.Union(getSchema(Feed), getSchema(Collection), getSchema(View));
+var isDataset = pipe(instanceOf(Feed), Predicate.or(instanceOf(Collection)), Predicate.or(instanceOf(View)));
+
+export {
+  Hypergraph_exports,
+  Json_exports,
+  Collection_exports,
+  View_exports,
+  Dataset_exports,
+  QueryAST2 as QueryAST,
+  DXN3 as DXN,
+  EID2 as EID,
+  URI
+};
+//# sourceMappingURL=chunk-UUP46KUQ.mjs.map

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-WTQJHC75.mjs

@@ -0,0 +1,395 @@
+import {
+  ReferenceAnnotationId,
+  Service,
+  getSchemaURI,
+  getTypeAnnotation,
+  getTypeIdentifierAnnotation
+} from "./chunk-R5W6DXR4.mjs";
+import {
+  getStaticTypeSchema
+} from "./chunk-O6BH7EPN.mjs";
+
+// src/internal/Ref/ref.ts
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import * as Option from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
+import * as Pipeable from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { Event } from "@dxos/async";
+import { inspectCustom } from "@dxos/debug";
+import { EncodedReference } from "@dxos/echo-protocol";
+import { assertArgument, invariant } from "@dxos/invariant";
+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) {
+    const parsed = DXN.tryMake($ref);
+    const typename = parsed ? DXN.getName(parsed) : void 0;
+    return typename ? {
+      typename
+    } : void 0;
+  }
+};
+var createSchemaReference = (typename) => {
+  return {
+    $id: JSON_SCHEMA_ECHO_REF_ID,
+    reference: {
+      schema: {
+        $ref: DXN.make(typename)
+      }
+    }
+  };
+};
+var getReferenceAst = (ast) => {
+  if (ast._tag !== "Declaration" || !ast.annotations[ReferenceAnnotationId]) {
+    return void 0;
+  }
+  return {
+    typename: ast.annotations[ReferenceAnnotationId].typename,
+    version: ast.annotations[ReferenceAnnotationId].version
+  };
+};
+var RefTypeId = /* @__PURE__ */ Symbol("@dxos/echo/internal/Ref");
+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) {
+    throw new Error("Reference target must be an ECHO schema.");
+  }
+  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version);
+};
+Ref.isRef = (obj) => {
+  return obj && typeof obj === "object" && RefTypeId in obj;
+};
+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);
+};
+Ref.isRefSchemaAST = (ast) => {
+  return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);
+};
+Ref.make = (obj) => {
+  if (typeof obj !== "object" || obj === null) {
+    throw new TypeError("Expected: ECHO object.");
+  }
+  const id = obj.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
+  });
+  return new RefImpl(uri, obj);
+};
+Ref.fromURI = (uri) => {
+  assertArgument(typeof uri === "string", "uri", "Expected URI string");
+  return new RefImpl(uri);
+};
+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: echoUri ?? DXN.make(typename)
+    },
+    schemaVersion: version
+  };
+  const refSchema = Schema.declare([], {
+    encode: () => {
+      return (value) => Effect.gen(function* () {
+        if (Ref.isRef(value)) {
+          return EncodedReference.fromURI(value.uri);
+        } else if (EncodedReference.isEncodedReference(value)) {
+          return value;
+        }
+        throw new Error("Invalid reference");
+      });
+    },
+    decode: () => {
+      return (value) => Effect.gen(function* () {
+        const dbService = yield* Effect.serviceOption(Service);
+        if (Ref.isRef(value)) {
+          if (Option.isSome(dbService)) {
+            return dbService.value.db.makeRef(value.uri);
+          } else {
+            return value;
+          }
+        }
+        if (!EncodedReference.isEncodedReference(value)) {
+          return yield* Effect.fail(new ParseResult.Unexpected(value, "reference"));
+        }
+        if (Option.isSome(dbService)) {
+          return dbService.value.db.makeRef(EncodedReference.toURI(value));
+        } else {
+          return Ref.fromURI(EncodedReference.toURI(value));
+        }
+      });
+    }
+  }, {
+    jsonSchema: {
+      // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.
+      $id: JSON_SCHEMA_ECHO_REF_ID,
+      $ref: JSON_SCHEMA_ECHO_REF_ID,
+      reference: referenceInfo
+    },
+    [ReferenceAnnotationId]: {
+      typename: typename ?? "",
+      version
+    }
+  });
+  return refSchema;
+};
+var RefImpl = class _RefImpl {
+  #uri;
+  #resolver = void 0;
+  #resolved = new Event();
+  /**
+  * Target is set when the reference is created from a specific object.
+  * In this case, the target might not be in the database.
+  */
+  #target = void 0;
+  /**
+  * Callback to issue a reactive notification when object is resolved.
+  */
+  #resolverCallback = () => {
+    this.#resolved.emit();
+  };
+  constructor(uri, target) {
+    this.#uri = uri;
+    this.#target = target;
+  }
+  /**
+  * @inheritdoc
+  */
+  get uri() {
+    return this.#uri;
+  }
+  /**
+  * @inheritdoc
+  */
+  get isAvailable() {
+    return this.#target !== void 0 || this.#resolver !== void 0;
+  }
+  /**
+  * @inheritdoc
+  */
+  get target() {
+    if (this.#target) {
+      return this.#target;
+    }
+    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
+  */
+  async load() {
+    if (this.#target) {
+      return this.#target;
+    }
+    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");
+    }
+    return obj;
+  }
+  /**
+  * @inheritdoc
+  */
+  async tryLoad() {
+    if (this.#target) {
+      return this.#target;
+    }
+    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.
+  * Makes .target unavailable unless the reference is connected to a database context.
+  * Clones the reference object.
+  */
+  noInline() {
+    const ref = new _RefImpl(this.#uri, void 0);
+    ref.#resolver = this.#resolver;
+    return ref;
+  }
+  encode() {
+    return {
+      "/": this.#uri,
+      ...this.#target ? {
+        target: this.#target
+      } : {}
+    };
+  }
+  /**
+  * Serializes the reference to a JSON object.
+  * The serialization format is compatible with the IPLD-style encoded references.
+  * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),
+  * the target is included in the serialized object.
+  */
+  toJSON() {
+    return this.encode();
+  }
+  toString() {
+    if (this.#target) {
+      return `Ref(${this.#target.toString()})`;
+    }
+    return `Ref(${this.#uri.toString()})`;
+  }
+  [inspectCustom] = (depth, options, inspect) => {
+    return this.toString();
+  };
+  [RefTypeId] = refVariance;
+  /**
+  * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)
+  * to deduplicate Ref instances that point to the same object.
+  * ECHO proxies return new RefImpl instances on every property access,
+  * so without this, each access would create a separate cache entry.
+  */
+  [Hash.symbol]() {
+    return Hash.hash(this.#uri.toString());
+  }
+  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */
+  [Equal.symbol](that) {
+    return that instanceof _RefImpl && this.#uri === that.uri;
+  }
+  get atom() {
+    return refSimpleFamily(this);
+  }
+  /**
+  * Internal method to set the resolver.
+  *
+  * @internal
+  */
+  _setResolver(resolver) {
+    this.#resolver = resolver;
+  }
+  /**
+  * @internal
+  */
+  _getSavedTarget() {
+    return this.#target;
+  }
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  }
+};
+var setRefResolver = (ref, resolver) => {
+  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", { "~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 uri = EncodedReference.toURI(encodedReference);
+  const ref = new RefImpl(uri);
+  if (resolver) {
+    setRefResolver(ref, resolver);
+  }
+  return ref;
+};
+var StaticRefResolver = class {
+  objects = /* @__PURE__ */ new Map();
+  schemas = /* @__PURE__ */ new Map();
+  addObject(obj) {
+    this.objects.set(obj.id, obj);
+    return this;
+  }
+  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(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(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(uri) {
+    return this.schemas.get(uri);
+  }
+};
+
+export {
+  loadRefTarget,
+  JSON_SCHEMA_ECHO_REF_ID,
+  getSchemaReference,
+  createSchemaReference,
+  getReferenceAst,
+  RefTypeId,
+  Ref,
+  createEchoReferenceSchema,
+  RefImpl,
+  setRefResolver,
+  getRefSavedTarget,
+  refFromEncodedReference,
+  StaticRefResolver
+};
+//# sourceMappingURL=chunk-WTQJHC75.mjs.map