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

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,721 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/document-structure.ts
+import { invariant } from "@dxos/invariant";
+import { visitValues } from "@dxos/util";
+
+// src/reference.ts
+import { assertArgument } from "@dxos/invariant";
+var REFERENCE_TYPE_TAG = "dxos.echo.model.document.Reference";
+var isEncodedReference = (value2) => typeof value2 === "object" && value2 !== null && Object.keys(value2).length === 1 && typeof value2["/"] === "string";
+var EncodedReference = Object.freeze({
+  isEncodedReference,
+  /**
+  * Returns the opaque URI stored in the encoded reference (any scheme: `echo:` or `dxn:`).
+  * Consumers can narrow with `EID.isEID(uri)` / `DXN.isDXN(uri)`.
+  */
+  toURI: (value2) => {
+    assertArgument(isEncodedReference(value2), "value", "invalid reference");
+    return value2["/"];
+  },
+  /**
+  * Creates an encoded reference from an opaque URI.
+  */
+  fromURI: (uri) => {
+    return {
+      "/": uri
+    };
+  }
+});
+
+// src/document-structure.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo-protocol/src/document-structure.ts";
+var DatabaseDirectory = Object.freeze({
+  /**
+  * @returns Space key in hex of the space that owns the document. In hex format. Without 0x prefix.
+  */
+  getSpaceKey: (doc) => {
+    const rawSpaceKey = doc.access?.spaceKey ?? doc.experimental_spaceKey;
+    if (rawSpaceKey == null) {
+      return null;
+    }
+    const rawKey = String(rawSpaceKey);
+    invariant(!rawKey.startsWith("0x"), "Space key must not start with 0x", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 17, S: void 0, A: ["!rawKey.startsWith('0x')", "'Space key must not start with 0x'"] });
+    return rawKey;
+  },
+  getInlineObject: (doc, id) => {
+    return doc.objects?.[id];
+  },
+  getLink: (doc, id) => {
+    return doc.links?.[id]?.toString();
+  },
+  make: ({ spaceKey, objects, links }) => ({
+    access: {
+      spaceKey
+    },
+    objects: objects ?? {},
+    links: links ?? {}
+  })
+});
+var EntityStructure = Object.freeze({
+  /**
+  * @throws On invalid object structure.
+  */
+  getTypeReference: (object) => {
+    return object.system?.type;
+  },
+  /**
+  * @throws On invalid object structure.
+  */
+  getEntityKind: (object) => {
+    const kind = object.system?.kind ?? "object";
+    invariant(kind === "object" || kind === "relation" || kind === "type", "Invalid kind", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 45, S: void 0, A: ["kind === 'object' || kind === 'relation' || kind === 'type'", "'Invalid kind'"] });
+    return kind;
+  },
+  isDeleted: (object) => {
+    return object.system?.deleted ?? false;
+  },
+  getRelationSource: (object) => {
+    return object.system?.source;
+  },
+  getRelationTarget: (object) => {
+    return object.system?.target;
+  },
+  getParent: (object) => {
+    return object.system?.parent;
+  },
+  /**
+  * @returns All references in the data section of the object.
+  */
+  getAllOutgoingReferences: (object) => {
+    const references = [];
+    const visit2 = (path, value2) => {
+      if (isEncodedReference(value2)) {
+        references.push({
+          path,
+          reference: value2
+        });
+      } else {
+        visitValues(value2, (value3, key) => visit2([
+          ...path,
+          String(key)
+        ], value3));
+      }
+    };
+    visitValues(object.data, (value2, key) => visit2([
+      String(key)
+    ], value2));
+    return references;
+  },
+  getTags: (object) => {
+    return object.meta.tags ?? [];
+  },
+  makeObject: ({ type, data, keys }) => {
+    return {
+      system: {
+        kind: "object",
+        type: {
+          "/": type
+        }
+      },
+      meta: {
+        keys: keys ?? []
+      },
+      data: data ?? {}
+    };
+  },
+  makeRelation: ({ type, source, target, deleted, keys, data }) => {
+    return {
+      system: {
+        kind: "relation",
+        type: {
+          "/": type
+        },
+        source,
+        target,
+        deleted: deleted ?? false
+      },
+      meta: {
+        keys: keys ?? []
+      },
+      data: data ?? {}
+    };
+  },
+  makeType: ({ type, keys, data }) => {
+    return {
+      system: {
+        kind: "type",
+        type: {
+          "/": type
+        }
+      },
+      meta: {
+        keys: keys ?? []
+      },
+      data: data ?? {}
+    };
+  }
+});
+var PROPERTY_ID = "id";
+var DATA_NAMESPACE = "data";
+
+// src/edge-peer.ts
+import { EdgeService } from "@dxos/protocols";
+import { compositeKey } from "@dxos/util";
+var isEdgePeerId = (peerId, spaceId) => {
+  const automergePrefix = spaceId !== void 0 ? compositeKey(EdgeService.AUTOMERGE_REPLICATOR, spaceId) : `${EdgeService.AUTOMERGE_REPLICATOR}:`;
+  const subductionPrefix = spaceId !== void 0 ? compositeKey(EdgeService.SUBDUCTION_REPLICATOR, spaceId) : `${EdgeService.SUBDUCTION_REPLICATOR}:`;
+  return peerId.startsWith(automergePrefix) || peerId.startsWith(subductionPrefix);
+};
+
+// src/echo-feed-codec.ts
+import { FeedProtocol } from "@dxos/protocols";
+var ATTR_META = "@meta";
+var EchoFeedCodec = class _EchoFeedCodec {
+  static #encoder = new TextEncoder();
+  static #decoder = new TextDecoder();
+  /**
+  * Prepares a value for feed storage (strips queue position from metadata) and encodes to bytes.
+  */
+  static encode(value2) {
+    const prepared = _EchoFeedCodec.#stripQueuePosition(value2);
+    return _EchoFeedCodec.#encoder.encode(JSON.stringify(prepared));
+  }
+  /**
+  * Decodes feed block bytes to a JSON value.
+  * If position is provided, injects queue position into the decoded object's metadata.
+  */
+  static decode(data, position) {
+    const decoded = JSON.parse(_EchoFeedCodec.#decoder.decode(data));
+    if (position !== void 0 && typeof decoded === "object" && decoded !== null) {
+      _EchoFeedCodec.#setQueuePosition(decoded, position);
+    }
+    return decoded;
+  }
+  static #stripQueuePosition(value2) {
+    if (typeof value2 !== "object" || value2 === null) {
+      return value2;
+    }
+    const obj = structuredClone(value2);
+    const meta = obj[ATTR_META];
+    if (meta?.keys?.some((key) => key.source === FeedProtocol.KEY_QUEUE_POSITION)) {
+      meta.keys = meta.keys.filter((key) => key.source !== FeedProtocol.KEY_QUEUE_POSITION);
+    }
+    return obj;
+  }
+  static #setQueuePosition(obj, position) {
+    obj[ATTR_META] ??= {
+      keys: []
+    };
+    obj[ATTR_META].keys ??= [];
+    const keys = obj[ATTR_META].keys;
+    for (let i = 0; i < keys.length; i++) {
+      if (keys[i].source === FeedProtocol.KEY_QUEUE_POSITION) {
+        keys.splice(i, 1);
+        i--;
+      }
+    }
+    keys.push({
+      source: FeedProtocol.KEY_QUEUE_POSITION,
+      id: position.toString()
+    });
+  }
+};
+
+// src/foreign-key.ts
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+var ForeignKey_ = Schema.Struct({
+  /**
+  * Name of the foreign database/system.
+  * E.g., `github.com`.
+  */
+  source: Schema.String,
+  /**
+  * Id within the foreign database.
+  */
+  // TODO(wittjosiah): This annotation is currently used to ensure id field shows up in forms.
+  // TODO(dmaretskyi): `false` is not a valid value for the annotation. Use a different annotation.
+  id: Schema.String.annotations({
+    [SchemaAST.IdentifierAnnotationId]: "false"
+  })
+});
+var ForeignKey = ForeignKey_;
+
+// src/query/ast.ts
+var ast_exports = {};
+__export(ast_exports, {
+  FeedScope: () => FeedScope,
+  Filter: () => Filter,
+  FilterAnd: () => FilterAnd,
+  FilterChildOf: () => FilterChildOf,
+  FilterCompare: () => FilterCompare,
+  FilterContains: () => FilterContains,
+  FilterIn: () => FilterIn,
+  FilterNot: () => FilterNot,
+  FilterObject: () => FilterObject,
+  FilterOr: () => FilterOr,
+  FilterRange: () => FilterRange,
+  FilterTag: () => FilterTag,
+  FilterTextSearch: () => FilterTextSearch,
+  FilterTimestamp: () => FilterTimestamp,
+  Order: () => Order,
+  OrderDirection: () => OrderDirection,
+  Query: () => Query,
+  QueryFilterClause: () => QueryFilterClause,
+  QueryFromClause: () => QueryFromClause,
+  QueryFromClause_: () => QueryFromClause_,
+  QueryHierarchyTraversalClause: () => QueryHierarchyTraversalClause,
+  QueryIncomingReferencesClause: () => QueryIncomingReferencesClause,
+  QueryLimitClause: () => QueryLimitClause,
+  QueryOptions: () => QueryOptions,
+  QueryOptionsClause: () => QueryOptionsClause,
+  QueryOrderClause: () => QueryOrderClause,
+  QueryReferenceTraversalClause: () => QueryReferenceTraversalClause,
+  QueryRelationClause: () => QueryRelationClause,
+  QueryRelationTraversalClause: () => QueryRelationTraversalClause,
+  QuerySelectClause: () => QuerySelectClause,
+  QuerySetDifferenceClause: () => QuerySetDifferenceClause,
+  QueryUnionClause: () => QueryUnionClause,
+  RegistryScope: () => RegistryScope,
+  Scope: () => Scope,
+  SpaceScope: () => SpaceScope,
+  fold: () => fold,
+  map: () => map,
+  visit: () => visit
+});
+import * as Match from "effect/Match";
+import * as Schema2 from "effect/Schema";
+import { EID, EntityId, URI } from "@dxos/keys";
+var TypenameSpecifier = Schema2.Union(URI.Schema, Schema2.Null);
+var FilterObject_ = Schema2.Struct({
+  type: Schema2.Literal("object"),
+  typename: TypenameSpecifier,
+  id: Schema2.optional(Schema2.Array(EntityId)),
+  /**
+  * Filter by property.
+  * Must not include object ID.
+  */
+  props: Schema2.Record({
+    key: Schema2.String.annotations({
+      description: "Property name"
+    }),
+    value: Schema2.suspend(() => Filter)
+  }),
+  /**
+  * Objects that have any of the given foreign keys.
+  */
+  foreignKeys: Schema2.optional(Schema2.Array(ForeignKey)),
+  /**
+  * Match objects whose meta `key` equals this fully-qualified registry key (FQN format).
+  */
+  metaKey: Schema2.optional(Schema2.String),
+  /**
+  * Semver range matched against the object's meta `version`.
+  * Only consulted when {@link metaKey} is set. Objects with no `version` do not satisfy a version-constrained filter.
+  */
+  metaVersion: Schema2.optional(Schema2.String)
+});
+var FilterObject = FilterObject_;
+var FilterCompare_ = Schema2.Struct({
+  type: Schema2.Literal("compare"),
+  operator: Schema2.Literal("eq", "neq", "gt", "gte", "lt", "lte"),
+  value: Schema2.Unknown
+});
+var FilterCompare = FilterCompare_;
+var FilterIn_ = Schema2.Struct({
+  type: Schema2.Literal("in"),
+  values: Schema2.Array(Schema2.Any)
+});
+var FilterIn = FilterIn_;
+var FilterContains_ = Schema2.Struct({
+  type: Schema2.Literal("contains"),
+  value: Schema2.Any
+});
+var FilterContains = FilterContains_;
+var FilterTag_ = Schema2.Struct({
+  type: Schema2.Literal("tag"),
+  tag: Schema2.String
+});
+var FilterTag = FilterTag_;
+var FilterRange_ = Schema2.Struct({
+  type: Schema2.Literal("range"),
+  from: Schema2.Any,
+  to: Schema2.Any
+});
+var FilterRange = FilterRange_;
+var FilterTimestamp_ = Schema2.Struct({
+  type: Schema2.Literal("timestamp"),
+  field: Schema2.Literal("createdAt", "updatedAt"),
+  operator: Schema2.Literal("gt", "gte", "lt", "lte"),
+  value: Schema2.Number
+});
+var FilterTimestamp = FilterTimestamp_;
+var FilterTextSearch_ = Schema2.Struct({
+  type: Schema2.Literal("text-search"),
+  text: Schema2.String,
+  searchKind: Schema2.optional(Schema2.Literal("full-text", "vector"))
+});
+var FilterTextSearch = FilterTextSearch_;
+var FilterNot_ = Schema2.Struct({
+  type: Schema2.Literal("not"),
+  filter: Schema2.suspend(() => Filter)
+});
+var FilterNot = FilterNot_;
+var FilterAnd_ = Schema2.Struct({
+  type: Schema2.Literal("and"),
+  filters: Schema2.Array(Schema2.suspend(() => Filter))
+});
+var FilterAnd = FilterAnd_;
+var FilterOr_ = Schema2.Struct({
+  type: Schema2.Literal("or"),
+  filters: Schema2.Array(Schema2.suspend(() => Filter))
+});
+var FilterOr = FilterOr_;
+var FilterChildOf_ = Schema2.Struct({
+  type: Schema2.Literal("child-of"),
+  /** Parent DXNs to match children of. */
+  parents: Schema2.Array(EID.Schema),
+  /** Whether to match transitively (grandchildren, etc.). Defaults to true. */
+  transitive: Schema2.Boolean
+});
+var FilterChildOf = FilterChildOf_;
+var Filter = Schema2.Union(FilterObject, FilterCompare, FilterIn, FilterContains, FilterTag, FilterRange, FilterTimestamp, FilterTextSearch, FilterChildOf, FilterNot, FilterAnd, FilterOr).annotations({
+  identifier: "org.dxos.schema.filter"
+});
+var QuerySelectClause_ = Schema2.Struct({
+  type: Schema2.Literal("select"),
+  filter: Schema2.suspend(() => Filter)
+});
+var QuerySelectClause = QuerySelectClause_;
+var QueryFilterClause_ = Schema2.Struct({
+  type: Schema2.Literal("filter"),
+  selection: Schema2.suspend(() => Query),
+  filter: Schema2.suspend(() => Filter)
+});
+var QueryFilterClause = QueryFilterClause_;
+var QueryReferenceTraversalClause_ = Schema2.Struct({
+  type: Schema2.Literal("reference-traversal"),
+  anchor: Schema2.suspend(() => Query),
+  property: Schema2.String
+});
+var QueryReferenceTraversalClause = QueryReferenceTraversalClause_;
+var QueryIncomingReferencesClause_ = Schema2.Struct({
+  type: Schema2.Literal("incoming-references"),
+  anchor: Schema2.suspend(() => Query),
+  /**
+  * Property path where the reference is located.
+  * If null, matches references from any property.
+  */
+  property: Schema2.NullOr(Schema2.String),
+  typename: TypenameSpecifier
+});
+var QueryIncomingReferencesClause = QueryIncomingReferencesClause_;
+var QueryRelationClause_ = Schema2.Struct({
+  type: Schema2.Literal("relation"),
+  anchor: Schema2.suspend(() => Query),
+  /**
+  * outgoing: anchor is the source of the relation.
+  * incoming: anchor is the target of the relation.
+  * both: anchor is either the source or target of the relation.
+  */
+  direction: Schema2.Literal("outgoing", "incoming", "both"),
+  filter: Schema2.optional(Schema2.suspend(() => Filter))
+});
+var QueryRelationClause = QueryRelationClause_;
+var QueryRelationTraversalClause_ = Schema2.Struct({
+  type: Schema2.Literal("relation-traversal"),
+  anchor: Schema2.suspend(() => Query),
+  direction: Schema2.Literal("source", "target", "both")
+});
+var QueryRelationTraversalClause = QueryRelationTraversalClause_;
+var QueryHierarchyTraversalClause_ = Schema2.Struct({
+  type: Schema2.Literal("hierarchy-traversal"),
+  anchor: Schema2.suspend(() => Query),
+  /**
+  * to-parent: traverse from child to parent.
+  * to-children: traverse from parent to children.
+  */
+  direction: Schema2.Literal("to-parent", "to-children")
+});
+var QueryHierarchyTraversalClause = QueryHierarchyTraversalClause_;
+var QueryUnionClause_ = Schema2.Struct({
+  type: Schema2.Literal("union"),
+  queries: Schema2.Array(Schema2.suspend(() => Query))
+});
+var QueryUnionClause = QueryUnionClause_;
+var QuerySetDifferenceClause_ = Schema2.Struct({
+  type: Schema2.Literal("set-difference"),
+  source: Schema2.suspend(() => Query),
+  exclude: Schema2.suspend(() => Query)
+});
+var QuerySetDifferenceClause = QuerySetDifferenceClause_;
+var OrderDirection = Schema2.Literal("asc", "desc");
+var Order_ = Schema2.Union(Schema2.Struct({
+  // How database wants to order them (in practice - by id).
+  kind: Schema2.Literal("natural")
+}), Schema2.Struct({
+  kind: Schema2.Literal("property"),
+  property: Schema2.String,
+  direction: OrderDirection
+}), Schema2.Struct({
+  // Order by relevance rank (for FTS/vector search results).
+  // Default direction is 'desc' (higher rank = better match first).
+  kind: Schema2.Literal("rank"),
+  direction: OrderDirection
+}), Schema2.Struct({
+  // Order by system timestamp (createdAt / updatedAt) from the object meta index.
+  kind: Schema2.Literal("timestamp"),
+  field: Schema2.Literal("createdAt", "updatedAt"),
+  direction: OrderDirection
+}));
+var Order = Order_;
+var QueryOrderClause_ = Schema2.Struct({
+  type: Schema2.Literal("order"),
+  query: Schema2.suspend(() => Query),
+  order: Schema2.Array(Order)
+});
+var QueryOrderClause = QueryOrderClause_;
+var QueryOptionsClause_ = Schema2.Struct({
+  type: Schema2.Literal("options"),
+  query: Schema2.suspend(() => Query),
+  options: Schema2.suspend(() => QueryOptions)
+});
+var QueryOptionsClause = QueryOptionsClause_;
+var QueryLimitClause_ = Schema2.Struct({
+  type: Schema2.Literal("limit"),
+  query: Schema2.suspend(() => Query),
+  limit: Schema2.Number
+});
+var QueryLimitClause = QueryLimitClause_;
+var QueryFromClause_ = Schema2.Struct({
+  type: Schema2.Literal("from"),
+  query: Schema2.suspend(() => Query),
+  from: Schema2.Union(Schema2.TaggedStruct("scope", {
+    scopes: Schema2.Array(Schema2.suspend(() => Scope))
+  }), Schema2.TaggedStruct("query", {
+    query: Schema2.suspend(() => Query)
+  }))
+});
+var QueryFromClause = QueryFromClause_;
+var Query_ = Schema2.Union(QuerySelectClause, QueryFilterClause, QueryReferenceTraversalClause, QueryIncomingReferencesClause, QueryRelationClause, QueryRelationTraversalClause, QueryHierarchyTraversalClause, QueryUnionClause, QuerySetDifferenceClause, QueryOrderClause, QueryOptionsClause, QueryLimitClause, QueryFromClause).annotations({
+  identifier: "org.dxos.schema.query"
+});
+var Query = Query_;
+var QueryOptions = Schema2.Struct({
+  /**
+  * Nested select statements will use this option to filter deleted objects.
+  */
+  deleted: Schema2.optional(Schema2.Literal("include", "exclude", "only")),
+  /**
+  * Diagnostics-only label for logs / tooling (not used by execution semantics).
+  */
+  debugLabel: Schema2.optional(Schema2.String)
+});
+var SpaceScope = Schema2.TaggedStruct("space", {
+  spaceId: Schema2.optional(Schema2.String),
+  includeAllFeeds: Schema2.optional(Schema2.Boolean)
+});
+var FeedScope = Schema2.TaggedStruct("feed", {
+  feedUri: Schema2.String
+});
+var RegistryScope = Schema2.TaggedStruct("registry", {
+  location: Schema2.Literal("local", "remote")
+});
+var Scope = Schema2.Union(SpaceScope, FeedScope, RegistryScope);
+var visit = (query, visitor) => {
+  visitor(query);
+  Match.value(query).pipe(Match.when({
+    type: "filter"
+  }, ({ selection }) => visit(selection, visitor)), Match.when({
+    type: "reference-traversal"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "incoming-references"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "relation"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "options"
+  }, ({ query: query2 }) => visit(query2, visitor)), Match.when({
+    type: "relation-traversal"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "hierarchy-traversal"
+  }, ({ anchor }) => visit(anchor, visitor)), Match.when({
+    type: "union"
+  }, ({ queries }) => queries.forEach((q) => visit(q, visitor))), Match.when({
+    type: "set-difference"
+  }, ({ source, exclude }) => {
+    visit(source, visitor);
+    visit(exclude, visitor);
+  }), Match.when({
+    type: "order"
+  }, ({ query: query2 }) => visit(query2, visitor)), Match.when({
+    type: "limit"
+  }, ({ query: query2 }) => visit(query2, visitor)), Match.when({
+    type: "from"
+  }, (node) => {
+    visit(node.query, visitor);
+    if (node.from._tag === "query") {
+      visit(node.from.query, visitor);
+    }
+  }), Match.when({
+    type: "select"
+  }, () => {
+  }), Match.exhaustive);
+};
+var map = (query, mapper) => {
+  const mapped = Match.value(query).pipe(Match.when({
+    type: "filter"
+  }, (node) => ({
+    ...node,
+    selection: map(node.selection, mapper)
+  })), Match.when({
+    type: "reference-traversal"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "incoming-references"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "relation"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "relation-traversal"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "hierarchy-traversal"
+  }, (node) => ({
+    ...node,
+    anchor: map(node.anchor, mapper)
+  })), Match.when({
+    type: "options"
+  }, (node) => ({
+    ...node,
+    query: map(node.query, mapper)
+  })), Match.when({
+    type: "order"
+  }, (node) => ({
+    ...node,
+    query: map(node.query, mapper)
+  })), Match.when({
+    type: "limit"
+  }, (node) => ({
+    ...node,
+    query: map(node.query, mapper)
+  })), Match.when({
+    type: "from"
+  }, (node) => ({
+    ...node,
+    query: map(node.query, mapper),
+    ...node.from._tag === "query" ? {
+      from: {
+        _tag: "query",
+        query: map(node.from.query, mapper)
+      }
+    } : {}
+  })), Match.when({
+    type: "union"
+  }, (node) => ({
+    ...node,
+    queries: node.queries.map((q) => map(q, mapper))
+  })), Match.when({
+    type: "set-difference"
+  }, (node) => ({
+    ...node,
+    source: map(node.source, mapper),
+    exclude: map(node.exclude, mapper)
+  })), Match.when({
+    type: "select"
+  }, (node) => node), Match.exhaustive);
+  return mapper(mapped);
+};
+var fold = (query, reducer) => {
+  return Match.value(query).pipe(Match.withReturnType(), Match.when({
+    type: "filter"
+  }, ({ selection }) => fold(selection, reducer)), Match.when({
+    type: "reference-traversal"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "incoming-references"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "relation"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "options"
+  }, ({ query: query2 }) => fold(query2, reducer)), Match.when({
+    type: "relation-traversal"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "hierarchy-traversal"
+  }, ({ anchor }) => fold(anchor, reducer)), Match.when({
+    type: "union"
+  }, ({ queries }) => queries.flatMap((q) => fold(q, reducer))), Match.when({
+    type: "set-difference"
+  }, ({ source, exclude }) => fold(source, reducer).concat(fold(exclude, reducer))), Match.when({
+    type: "order"
+  }, ({ query: query2 }) => fold(query2, reducer)), Match.when({
+    type: "limit"
+  }, ({ query: query2 }) => fold(query2, reducer)), Match.when({
+    type: "from"
+  }, (node) => {
+    const results = fold(node.query, reducer);
+    if (node.from._tag === "query") {
+      return results.concat(fold(node.from.query, reducer));
+    }
+    return results;
+  }), Match.when({
+    type: "select"
+  }, () => []), Match.exhaustive);
+};
+
+// src/space-doc-version.ts
+var SpaceDocVersion = Object.freeze({
+  /**
+  * For the documents created before the versioning was introduced.
+  */
+  LEGACY: 0,
+  /**
+  * Current version.
+  */
+  CURRENT: 1
+});
+
+// src/space-id.ts
+import { subtleCrypto } from "@dxos/crypto";
+import { PublicKey, SpaceId } from "@dxos/keys";
+import { ComplexMap } from "@dxos/util";
+var SPACE_IDS_CACHE = new ComplexMap(PublicKey.hash);
+var createIdFromSpaceKey = async (spaceKey) => {
+  const cachedValue = SPACE_IDS_CACHE.get(spaceKey);
+  if (cachedValue !== void 0) {
+    return cachedValue;
+  }
+  const digest = await subtleCrypto.digest("SHA-256", spaceKey.asUint8Array());
+  const bytes = new Uint8Array(digest).slice(0, SpaceId.byteLength);
+  const spaceId = SpaceId.encode(bytes);
+  SPACE_IDS_CACHE.set(spaceKey, spaceId);
+  return spaceId;
+};
+export {
+  DATA_NAMESPACE,
+  DatabaseDirectory,
+  EchoFeedCodec,
+  EncodedReference,
+  EntityStructure,
+  ForeignKey,
+  PROPERTY_ID,
+  ast_exports as QueryAST,
+  REFERENCE_TYPE_TAG,
+  SpaceDocVersion,
+  createIdFromSpaceKey,
+  isEdgePeerId,
+  isEncodedReference
+};
+//# sourceMappingURL=index.mjs.map