@dxos/echo-protocol 0.10.0 → 0.11.0

package/dist/lib/index.mjs

@@ -0,0 +1,722 @@
+import { assertArgument, invariant } from "@dxos/invariant";
+import { EID, EntityId, PublicKey, SpaceId, URI } from "@dxos/keys";
+import { ComplexMap, compositeKey, visitValues } from "@dxos/util";
+import { subtleCrypto } from "@dxos/crypto";
+import { EdgeService, FeedProtocol } from "@dxos/protocols";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import * as Match from "effect/Match";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/reference.ts
+var REFERENCE_TYPE_TAG = "dxos.echo.model.document.Reference";
+var isEncodedReference = (value) => typeof value === "object" && value !== null && Object.keys(value).length === 1 && typeof value["/"] === "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: (value) => {
+		assertArgument(isEncodedReference(value), "value", "invalid reference");
+		return value["/"];
+	},
+	/**
+	* Creates an encoded reference from an opaque URI.
+	*/
+	fromURI: (uri) => {
+		return { "/": uri };
+	}
+});
+//#endregion
+//#region src/space-id.ts
+var SPACE_IDS_CACHE = new ComplexMap(PublicKey.hash);
+/**
+* Space keys are generated by creating a keypair, and then taking the first 20 bytes of the SHA-256 hash of the public key and encoding them to multibase RFC4648 base-32 format (prefixed with B, see Multibase Table).
+* Inspired by how ethereum addresses are derived.
+*/
+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;
+};
+//#endregion
+//#region src/document-structure.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo-protocol/src/document-structure.ts";
+var DatabaseDirectory = Object.freeze({
+	/**
+	* @returns ID of the space that owns the document.
+	* Coalesces `access.spaceId` with the deprecated space key fields (`access.spaceKey`,
+	* `experimental_spaceKey`), deriving the id from the key for documents that predate `spaceId`.
+	*/
+	getSpaceId: async (doc) => {
+		if (doc.access?.spaceId != null) {
+			invariant(SpaceId.isValid(doc.access.spaceId), "Invalid space ID", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 111,
+				S: void 0,
+				A: ["SpaceId.isValid(doc.access.spaceId)", "'Invalid space ID'"]
+			});
+			return doc.access.spaceId;
+		}
+		const spaceKeyHex = DatabaseDirectory.getSpaceKey(doc);
+		if (spaceKeyHex == null) return null;
+		return createIdFromSpaceKey(PublicKey.fromHex(spaceKeyHex));
+	},
+	/**
+	* @deprecated Use {@link DatabaseDirectory.getSpaceId}. Only paths that require the space
+	* public key (which cannot be derived from the space id) should read the key.
+	*
+	* @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: 137,
+			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();
+	},
+	/**
+	* @returns The branch registry for a subtree-root object, or undefined if it has no branches.
+	*/
+	getBranches: (doc, rootObjectId) => {
+		return doc.branches?.[rootObjectId];
+	},
+	/**
+	* @returns All branch document urls referenced anywhere in the registry. Used by the host to
+	* decide which documents to replicate (branch docs are NOT object links).
+	*/
+	getAllBranchDocUrls: (doc) => {
+		const urls = [];
+		for (const byName of Object.values(doc.branches ?? {})) for (const record of Object.values(byName)) for (const url of Object.values(record.members ?? {})) urls.push(url.toString());
+		return urls;
+	},
+	make: ({ spaceId, spaceKey, objects, links }) => ({
+		access: {
+			...spaceId != null ? { spaceId } : {},
+			...spaceKey != null ? { 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: 224,
+			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 visit = (path, value) => {
+			if (isEncodedReference(value)) references.push({
+				path,
+				reference: value
+			});
+			else visitValues(value, (value, key) => visit([...path, String(key)], value));
+		};
+		visitValues(object.data, (value, key) => visit([String(key)], value));
+		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 ?? {}
+		};
+	}
+});
+/**
+* Id property name.
+*/
+var PROPERTY_ID = "id";
+/**
+* Data namespace.
+* The key on {@link EntityStructure} that contains the user-defined data.
+*/
+var DATA_NAMESPACE = "data";
+//#endregion
+//#region src/edge-peer.ts
+/**
+* Returns true if the given peerId belongs to an EDGE replicator (Automerge or Subduction).
+*
+* When `spaceId` is provided, the match is scoped to that space (peerId must start with
+* `<service>:<spaceId>`). When omitted, only the leading service segment is checked
+* (peerId must start with `<service>:`), which is useful when the caller doesn't have a
+* spaceId on hand or wants to match any edge replicator regardless of space.
+*/
+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);
+};
+//#endregion
+//#region src/echo-feed-codec.ts
+/** Property name for meta when object is serialized to JSON. Matches @dxos/echo/internal ATTR_META. */
+var ATTR_META = "@meta";
+/**
+* Codec for ECHO objects in feed block payload: JSON object ↔ UTF-8 bytes.
+* Encodes with queue position stripped; decodes with optional position injection.
+*/
+var EchoFeedCodec = class EchoFeedCodec {
+	static #encoder = new TextEncoder();
+	static #decoder = new TextDecoder();
+	/**
+	* Feed blocks are always whole-object snapshots; the index collapses entries by id to the latest
+	* block. TODO(wittjosiah): Follow-up — a partial-object update block format with field-level
+	* last-write-wins merge at the index (see EntityMetaIndex.update).
+	*/
+	static encode(value) {
+		const prepared = EchoFeedCodec.stripQueuePosition(value);
+		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;
+	}
+	/**
+	* Strips the queue-position foreign key from an object's metadata, producing a canonical form
+	* comparable across a local snapshot and an inbound feed block (positions differ per-append).
+	*/
+	static stripQueuePosition(value) {
+		if (typeof value !== "object" || value === null) return value;
+		const obj = structuredClone(value);
+		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()
+		});
+	}
+};
+/**
+* Foreign-key source for the global position a feed block was assigned.
+* Re-exported so `@dxos/echo` can read it without depending on `@dxos/protocols`.
+*/
+var KEY_QUEUE_POSITION = FeedProtocol.KEY_QUEUE_POSITION;
+/**
+* Reference to an object in a foreign database.
+*/
+var ForeignKey = Schema.Struct({
+	/**
+	* Name of the foreign database/system.
+	* E.g., `github.com`.
+	*/
+	source: Schema.String,
+	/**
+	* Id within the foreign database.
+	*/
+	id: Schema.String.annotations({ [SchemaAST.IdentifierAnnotationId]: "false" })
+});
+//#endregion
+//#region src/query/ast.ts
+var ast_exports = /* @__PURE__ */ __exportAll({
+	FeedScope: () => FeedScope,
+	Filter: () => Filter,
+	FilterAnd: () => FilterAnd,
+	FilterChildOf: () => FilterChildOf,
+	FilterCompare: () => FilterCompare,
+	FilterContains: () => FilterContains,
+	FilterIn: () => FilterIn,
+	FilterInQuery: () => FilterInQuery,
+	FilterNot: () => FilterNot,
+	FilterObject: () => FilterObject,
+	FilterOr: () => FilterOr,
+	FilterRange: () => FilterRange,
+	FilterTag: () => FilterTag,
+	FilterTextSearch: () => FilterTextSearch,
+	FilterTimestamp: () => FilterTimestamp,
+	GroupAggregate: () => GroupAggregate,
+	Order: () => Order,
+	OrderDirection: () => OrderDirection,
+	Query: () => Query,
+	QueryAggregateClause: () => QueryAggregateClause,
+	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,
+	QuerySkipClause: () => QuerySkipClause,
+	QueryUnionClause: () => QueryUnionClause,
+	RegistryScope: () => RegistryScope,
+	Scope: () => Scope,
+	SpaceScope: () => SpaceScope,
+	fold: () => fold,
+	map: () => map,
+	visit: () => visit
+});
+var TypenameSpecifier = Schema.Union(URI.Schema, Schema.Null);
+var FilterObject = Schema.Struct({
+	type: Schema.Literal("object"),
+	typename: TypenameSpecifier,
+	id: Schema.optional(Schema.Array(EntityId)),
+	/**
+	* Filter by property.
+	* Must not include object ID.
+	*/
+	props: Schema.Record({
+		key: Schema.String.annotations({ description: "Property name" }),
+		value: Schema.suspend(() => Filter)
+	}),
+	/**
+	* Objects that have any of the given foreign keys.
+	*/
+	foreignKeys: Schema.optional(Schema.Array(ForeignKey)),
+	/**
+	* Match objects whose meta `key` equals this fully-qualified registry key (FQN format).
+	*/
+	metaKey: Schema.optional(Schema.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: Schema.optional(Schema.String)
+});
+var FilterCompare = Schema.Struct({
+	type: Schema.Literal("compare"),
+	operator: Schema.Literal("eq", "neq", "gt", "gte", "lt", "lte"),
+	value: Schema.Unknown
+});
+var FilterIn = Schema.Struct({
+	type: Schema.Literal("in"),
+	values: Schema.Array(Schema.Any)
+});
+var FilterInQuery = Schema.Struct({
+	type: Schema.Literal("in-query"),
+	subquery: Schema.suspend(() => Query),
+	property: Schema.String
+});
+/**
+* Predicate for an array property to contain the provided value.
+* Nested objects are matched using strict structural matching.
+*/
+var FilterContains = Schema.Struct({
+	type: Schema.Literal("contains"),
+	value: Schema.Any
+});
+var FilterTag = Schema.Struct({
+	type: Schema.Literal("tag"),
+	tag: Schema.String
+});
+var FilterRange = Schema.Struct({
+	type: Schema.Literal("range"),
+	from: Schema.Any,
+	to: Schema.Any
+});
+var FilterTimestamp = Schema.Struct({
+	type: Schema.Literal("timestamp"),
+	field: Schema.Literal("createdAt", "updatedAt"),
+	operator: Schema.Literal("gt", "gte", "lt", "lte"),
+	value: Schema.Number
+});
+var FilterTextSearch = Schema.Struct({
+	type: Schema.Literal("text-search"),
+	text: Schema.String,
+	searchKind: Schema.optional(Schema.Literal("full-text", "vector"))
+});
+var FilterNot = Schema.Struct({
+	type: Schema.Literal("not"),
+	filter: Schema.suspend(() => Filter)
+});
+var FilterAnd = Schema.Struct({
+	type: Schema.Literal("and"),
+	filters: Schema.Array(Schema.suspend(() => Filter))
+});
+var FilterOr = Schema.Struct({
+	type: Schema.Literal("or"),
+	filters: Schema.Array(Schema.suspend(() => Filter))
+});
+var FilterChildOf = Schema.Struct({
+	type: Schema.Literal("child-of"),
+	/** Parent DXNs to match children of. */
+	parents: Schema.Array(EID.Schema),
+	/** Whether to match transitively (grandchildren, etc.). Defaults to true. */
+	transitive: Schema.Boolean
+});
+/**
+* Union of filters.
+*/
+var Filter = Schema.Union(FilterObject, FilterCompare, FilterIn, FilterInQuery, FilterContains, FilterTag, FilterRange, FilterTimestamp, FilterTextSearch, FilterChildOf, FilterNot, FilterAnd, FilterOr).annotations({ identifier: "org.dxos.schema.filter" });
+var QuerySelectClause = Schema.Struct({
+	type: Schema.Literal("select"),
+	filter: Schema.suspend(() => Filter)
+});
+var QueryFilterClause = Schema.Struct({
+	type: Schema.Literal("filter"),
+	selection: Schema.suspend(() => Query),
+	filter: Schema.suspend(() => Filter)
+});
+var QueryReferenceTraversalClause = Schema.Struct({
+	type: Schema.Literal("reference-traversal"),
+	anchor: Schema.suspend(() => Query),
+	property: Schema.String
+});
+var QueryIncomingReferencesClause = Schema.Struct({
+	type: Schema.Literal("incoming-references"),
+	anchor: Schema.suspend(() => Query),
+	/**
+	* Property path where the reference is located.
+	* If null, matches references from any property.
+	*/
+	property: Schema.NullOr(Schema.String),
+	typename: TypenameSpecifier
+});
+var QueryRelationClause = Schema.Struct({
+	type: Schema.Literal("relation"),
+	anchor: Schema.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: Schema.Literal("outgoing", "incoming", "both"),
+	filter: Schema.optional(Schema.suspend(() => Filter))
+});
+var QueryRelationTraversalClause = Schema.Struct({
+	type: Schema.Literal("relation-traversal"),
+	anchor: Schema.suspend(() => Query),
+	direction: Schema.Literal("source", "target", "both")
+});
+var QueryHierarchyTraversalClause = Schema.Struct({
+	type: Schema.Literal("hierarchy-traversal"),
+	anchor: Schema.suspend(() => Query),
+	/**
+	* to-parent: traverse from child to parent.
+	* to-children: traverse from parent to children.
+	*/
+	direction: Schema.Literal("to-parent", "to-children")
+});
+var QueryUnionClause = Schema.Struct({
+	type: Schema.Literal("union"),
+	queries: Schema.Array(Schema.suspend(() => Query))
+});
+var QuerySetDifferenceClause = Schema.Struct({
+	type: Schema.Literal("set-difference"),
+	source: Schema.suspend(() => Query),
+	exclude: Schema.suspend(() => Query)
+});
+var OrderDirection = Schema.Literal("asc", "desc");
+var Order = Schema.Union(Schema.Struct({
+	kind: Schema.Literal("natural"),
+	direction: OrderDirection
+}), Schema.Struct({
+	kind: Schema.Literal("property"),
+	property: Schema.String,
+	direction: OrderDirection
+}), Schema.Struct({
+	kind: Schema.Literal("rank"),
+	direction: OrderDirection
+}), Schema.Struct({
+	kind: Schema.Literal("timestamp"),
+	field: Schema.Literal("createdAt", "updatedAt"),
+	direction: OrderDirection
+}));
+var QueryOrderClause = Schema.Struct({
+	type: Schema.Literal("order"),
+	query: Schema.suspend(() => Query),
+	order: Schema.Array(Order)
+});
+var QueryOptionsClause = Schema.Struct({
+	type: Schema.Literal("options"),
+	query: Schema.suspend(() => Query),
+	options: Schema.suspend(() => QueryOptions)
+});
+var QueryLimitClause = Schema.Struct({
+	type: Schema.Literal("limit"),
+	query: Schema.suspend(() => Query),
+	limit: Schema.Number
+});
+var QuerySkipClause = Schema.Struct({
+	type: Schema.Literal("skip"),
+	query: Schema.suspend(() => Query),
+	skip: Schema.Number
+});
+/**
+* A named aggregate computed per group over its members, exposed as a top-level field on the flat
+* result record (`row[name]`) and orderable via a following `orderBy(Order.property(name))`. A
+* tagged union per kind — `property`/`limit`/`order` are present exactly when the kind uses them,
+* so read sites narrow by `kind` instead of guarding an unused optional field.
+* - `group` partitions members by a scalar `property`; its coerced key value is the field's value.
+*   Composite keys are formed from multiple `group` entries. A query with no `group` entries
+*   aggregates its entire input into a single row.
+* - `max`/`min` reduce a scalar member `property`.
+* - `items` collects the group's members, optionally ordered by `order` and capped to `limit`.
+*   Opt-in — a row carries no members otherwise. `order` is this aggregate's own per-group
+*   ordering, independent of any `orderBy` clause elsewhere in the query (which orders the whole
+*   input stream / the resulting groups, not this aggregate's member selection).
+* - `count` yields the member count. Opt-in — a row carries no count otherwise.
+*/
+var GroupAggregateGroup_ = Schema.Struct({
+	name: Schema.String,
+	kind: Schema.Literal("group"),
+	property: Schema.String
+});
+var GroupAggregateMax_ = Schema.Struct({
+	name: Schema.String,
+	kind: Schema.Literal("max"),
+	property: Schema.String
+});
+var GroupAggregateMin_ = Schema.Struct({
+	name: Schema.String,
+	kind: Schema.Literal("min"),
+	property: Schema.String
+});
+var GroupAggregateItems_ = Schema.Struct({
+	name: Schema.String,
+	kind: Schema.Literal("items"),
+	limit: Schema.optional(Schema.Number),
+	order: Schema.optional(Schema.Array(Order))
+});
+var GroupAggregateCount_ = Schema.Struct({
+	name: Schema.String,
+	kind: Schema.Literal("count")
+});
+var GroupAggregate = Schema.Union(GroupAggregateGroup_, GroupAggregateMax_, GroupAggregateMin_, GroupAggregateItems_, GroupAggregateCount_);
+var QueryAggregateClause = Schema.Struct({
+	type: Schema.Literal("aggregate"),
+	query: Schema.suspend(() => Query),
+	aggregates: Schema.Array(GroupAggregate)
+});
+var QueryFromClause_ = Schema.Struct({
+	type: Schema.Literal("from"),
+	query: Schema.suspend(() => Query),
+	from: Schema.Union(Schema.TaggedStruct("scope", { scopes: Schema.Array(Schema.suspend(() => Scope)) }), Schema.TaggedStruct("query", { query: Schema.suspend(() => Query) }))
+});
+var QueryFromClause = QueryFromClause_;
+var Query = Schema.Union(QuerySelectClause, QueryFilterClause, QueryReferenceTraversalClause, QueryIncomingReferencesClause, QueryRelationClause, QueryRelationTraversalClause, QueryHierarchyTraversalClause, QueryUnionClause, QuerySetDifferenceClause, QueryOrderClause, QueryOptionsClause, QueryLimitClause, QuerySkipClause, QueryAggregateClause, QueryFromClause).annotations({ identifier: "org.dxos.schema.query" });
+var QueryOptions = Schema.Struct({
+	/**
+	* Nested select statements will use this option to filter deleted objects.
+	*/
+	deleted: Schema.optional(Schema.Literal("include", "exclude", "only")),
+	/**
+	* Diagnostics-only label for logs / tooling (not used by execution semantics).
+	*/
+	debugLabel: Schema.optional(Schema.String)
+});
+/**
+* Selects from a space (automerge documents).
+* When `spaceId` is omitted, targets the owning space — i.e. the space of whichever
+* database executes the query. This lets callers reference "this space" without
+* having to look up its id.
+* When `includeAllFeeds` is true, also selects from all feeds belonging to that space.
+*/
+var SpaceScope = Schema.TaggedStruct("space", {
+	spaceId: Schema.optional(Schema.String),
+	includeAllFeeds: Schema.optional(Schema.Boolean)
+});
+/**
+* Selects from a specific feed (by its underlying queue DXN).
+*/
+var FeedScope = Schema.TaggedStruct("feed", { feedUri: Schema.String });
+/**
+* Selects from a code-shipped object registry.
+*
+* - `'local'`  — the in-process registry attached to the hypergraph.
+* - `'remote'` — a future remote registry service (not yet implemented).
+*
+* To include both, add two separate `RegistryScope` entries to the `scopes` array.
+*/
+var RegistryScope = Schema.TaggedStruct("registry", { location: Schema.Literal("local", "remote") });
+/**
+* Specifies the scope of the data to query from.
+* A `from` clause may carry multiple scopes; results are unioned across them.
+*/
+var Scope = Schema.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 }) => visit(query, 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 }) => visit(query, visitor)), Match.when({ type: "limit" }, ({ query }) => visit(query, visitor)), Match.when({ type: "skip" }, ({ query }) => visit(query, visitor)), Match.when({ type: "aggregate" }, ({ query }) => visit(query, 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);
+};
+/**
+* Recursively transforms a query tree bottom-up.
+* The mapper receives each node with its children already transformed.
+*/
+var map = (query, mapper) => {
+	return mapper(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: "skip" }, (node) => ({
+		...node,
+		query: map(node.query, mapper)
+	})), Match.when({ type: "aggregate" }, (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));
+};
+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 }) => fold(query, 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 }) => fold(query, reducer)), Match.when({ type: "limit" }, ({ query }) => fold(query, reducer)), Match.when({ type: "skip" }, ({ query }) => fold(query, reducer)), Match.when({ type: "aggregate" }, ({ query }) => fold(query, 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);
+};
+//#endregion
+//#region src/space-doc-version.ts
+var SpaceDocVersion = Object.freeze({
+	/**
+	* For the documents created before the versioning was introduced.
+	*/
+	LEGACY: 0,
+	/**
+	* Current version.
+	*/
+	CURRENT: 1
+});
+//#endregion
+export { DATA_NAMESPACE, DatabaseDirectory, EchoFeedCodec, EncodedReference, EntityStructure, ForeignKey, KEY_QUEUE_POSITION, PROPERTY_ID, ast_exports as QueryAST, REFERENCE_TYPE_TAG, SpaceDocVersion, createIdFromSpaceKey, isEdgePeerId, isEncodedReference };
+
+//# sourceMappingURL=index.mjs.map