@dxos/echo-protocol 0.8.3 → 0.8.4-main.05e74ebcff

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,825 @@
+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";
+import { DXN, LOCAL_SPACE_TAG } from "@dxos/keys";
+var Reference = class _Reference {
+  _objectId;
+  _protocol;
+  _host;
+  _dxn;
+  /**
+  * Protocol references to runtime registered types.
+  * @deprecated
+  */
+  static TYPE_PROTOCOL = "protobuf";
+  static fromDXN(dxn) {
+    switch (dxn.kind) {
+      case DXN.kind.TYPE:
+        return new _Reference(dxn.parts[0], _Reference.TYPE_PROTOCOL, "dxos.org", dxn);
+      case DXN.kind.ECHO:
+        if (dxn.parts[0] === LOCAL_SPACE_TAG) {
+          return new _Reference(dxn.parts[1], void 0, void 0, dxn);
+        } else {
+          return new _Reference(dxn.parts[1], void 0, dxn.parts[0], dxn);
+        }
+      default:
+        return new _Reference(dxn.parts[0], void 0, dxn.parts[0], dxn);
+    }
+  }
+  static fromValue(value2) {
+    return new _Reference(value2.objectId, value2.protocol, value2.host);
+  }
+  /**
+  * Reference an object in the local space.
+  */
+  static localObjectReference(objectId) {
+    return new _Reference(objectId);
+  }
+  /**
+  * @deprecated
+  */
+  // TODO(dmaretskyi): Remove.
+  static fromLegacyTypename(type) {
+    return new _Reference(type, _Reference.TYPE_PROTOCOL, "dxos.org");
+  }
+  /**
+  * @deprecated
+  */
+  // TODO(dmaretskyi): Remove
+  static fromObjectIdAndSpaceKey(objectId, spaceKey) {
+    return new _Reference(objectId, void 0, spaceKey.toHex());
+  }
+  // prettier-ignore
+  constructor(_objectId, _protocol, _host, _dxn) {
+    this._objectId = _objectId;
+    this._protocol = _protocol;
+    this._host = _host;
+    this._dxn = _dxn;
+  }
+  get dxn() {
+    return this._dxn;
+  }
+  /**
+  * @deprecated
+  */
+  // TODO(dmaretskyi): Remove.
+  get objectId() {
+    return this._objectId;
+  }
+  /**
+  * @deprecated
+  */
+  // TODO(dmaretskyi): Remove.
+  get protocol() {
+    return this._protocol;
+  }
+  /**
+  * @deprecated
+  */
+  // TODO(dmaretskyi): Remove.
+  get host() {
+    return this._host;
+  }
+  encode() {
+    return {
+      objectId: this.objectId,
+      host: this.host,
+      protocol: this.protocol
+    };
+  }
+  // TODO(dmaretskyi): Remove in favor of `reference.dxn`.
+  toDXN() {
+    if (this._dxn) {
+      return this._dxn;
+    }
+    if (this.protocol === _Reference.TYPE_PROTOCOL) {
+      return new DXN(DXN.kind.TYPE, [
+        this.objectId
+      ]);
+    } else {
+      if (this.host) {
+        return new DXN(DXN.kind.ECHO, [
+          this.host,
+          this.objectId
+        ]);
+      } else {
+        return new DXN(DXN.kind.ECHO, [
+          LOCAL_SPACE_TAG,
+          this.objectId
+        ]);
+      }
+    }
+  }
+};
+var REFERENCE_TYPE_TAG = "dxos.echo.model.document.Reference";
+var encodeReference = (reference) => ({
+  "/": reference.toDXN().toString()
+});
+var decodeReference = (value2) => {
+  if (typeof value2 !== "object" || value2 === null || typeof value2["/"] !== "string") {
+    throw new Error("Invalid reference");
+  }
+  const dxnString = value2["/"];
+  if (dxnString.length % 2 === 0 && dxnString.slice(0, dxnString.length / 2) === dxnString.slice(dxnString.length / 2) && dxnString.includes("dxn:echo")) {
+    throw new Error("Automerge bug detected!");
+  }
+  return Reference.fromDXN(DXN.parse(dxnString));
+};
+var isEncodedReference = (value2) => typeof value2 === "object" && value2 !== null && Object.keys(value2).length === 1 && typeof value2["/"] === "string";
+var EncodedReference = Object.freeze({
+  isEncodedReference,
+  getReferenceString: (value2) => {
+    assertArgument(isEncodedReference(value2), "value", "invalid reference");
+    return value2["/"];
+  },
+  toDXN: (value2) => {
+    return DXN.parse(EncodedReference.getReferenceString(value2));
+  },
+  fromDXN: (dxn) => {
+    return {
+      "/": dxn.toString()
+    };
+  },
+  fromLegacyTypename: (typename) => {
+    return {
+      "/": DXN.fromTypename(typename).toString()
+    };
+  }
+});
+
+// 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 ObjectStructure = 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", "Invalid kind", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 45, S: void 0, A: ["kind === 'object' || kind === 'relation'", "'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 ?? {}
+    };
+  }
+});
+var PROPERTY_ID = "id";
+var DATA_NAMESPACE = "data";
+
+// 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, {
+  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,
+  Scope: () => Scope,
+  fold: () => fold,
+  map: () => map,
+  visit: () => visit
+});
+import * as Match from "effect/Match";
+import * as Schema2 from "effect/Schema";
+import { DXN as DXN2, ObjectId } from "@dxos/keys";
+var TypenameSpecifier = Schema2.Union(DXN2.Schema, Schema2.Null).annotations({
+  description: "DXN or null; null matches any type"
+});
+var FilterObject_ = Schema2.Struct({
+  type: Schema2.Literal("object"),
+  typename: TypenameSpecifier,
+  id: Schema2.optional(Schema2.Array(ObjectId)),
+  /**
+  * 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(DXN2.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
+}));
+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", {
+    scope: 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 Scope = Schema2.Struct({
+  /**
+  * The nested select statemets will select from the given spaces.
+  *
+  * NOTE: Spaces and feeds are unioned together if both are specified.
+  */
+  spaceIds: Schema2.optional(Schema2.Array(Schema2.String)),
+  /**
+  * If true, the nested select statements will select from all feeds in the spaces specified by `spaceIds`.
+  */
+  allFeedsFromSpaces: Schema2.optional(Schema2.Boolean),
+  /**
+  * The nested select statemets will select from the given feeds (by underlying queue DXN).
+  *
+  * NOTE: Spaces and feeds are unioned together if both are specified.
+  */
+  feeds: Schema2.optional(Schema2.Array(DXN2.Schema))
+});
+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,
+  ForeignKey,
+  ObjectStructure,
+  PROPERTY_ID,
+  ast_exports as QueryAST,
+  REFERENCE_TYPE_TAG,
+  Reference,
+  SpaceDocVersion,
+  createIdFromSpaceKey,
+  decodeReference,
+  encodeReference,
+  isEncodedReference
+};
+//# sourceMappingURL=index.mjs.map