@dxos/echo 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

package/dist/lib/browser/chunk-F4YF6C3O.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Obj.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Schema from 'effect/Schema';\n\nimport { type ForeignKey } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { type DXN, ObjectId } from '@dxos/keys';\nimport { getSnapshot as getSnapshot$ } from '@dxos/live-object';\nimport { assumeType, deepMapValues } from '@dxos/util';\n\nimport * as Entity from './Entity';\nimport {\n  type AnyEchoObject,\n  type AnyProperties,\n  type InternalObjectProps,\n  MetaId,\n  type ObjectJSON,\n  type ObjectMeta,\n  ObjectVersionId,\n  VersionTypeId,\n  getDescription as getDescription$,\n  getLabel as getLabel$,\n  getMeta as getMeta$,\n  getObjectDXN,\n  getSchema as getSchema$,\n  getSchemaTypename,\n  getTypeAnnotation,\n  getTypeDXN as getTypeDXN$,\n  isDeleted as isDeleted$,\n  isInstanceOf,\n  makeObject,\n  objectFromJSON,\n  objectToJSON,\n  setDescription as setDescription$,\n  setLabel as setLabel$,\n} from './internal';\nimport * as Ref from './Ref';\nimport * as Type from './Type';\n\n/**\n * Base type for all ECHO objects.\n * @private\n */\ninterface BaseObj extends AnyEchoObject, Entity.OfKind<typeof Entity.Kind.Object> {}\n\n/**\n * Base type for all Obj objects.\n */\nexport interface Any extends BaseObj {}\n\nexport const Any = Schema.Struct({}).pipe(\n  Type.Obj({\n    typename: 'dxos.org/type/Any',\n    version: '0.1.0',\n  }),\n);\n\n/**\n * Object type with specific properties.\n */\nexport type Obj<Props> = BaseObj & Props;\n\n/**\n * Object with arbitrary properties.\n *\n * NOTE: Due to how typescript works, this type is not assignable to a specific schema type.\n * In that case, use `Obj.instanceOf` to check if an object is of a specific type.\n */\nexport interface AnyProps extends BaseObj, AnyProperties {}\n\nconst defaultMeta: ObjectMeta = {\n  keys: [],\n};\n\ntype Props<T = any> = {\n  id?: ObjectId;\n  [Meta]?: Partial<ObjectMeta>;\n} & Type.Properties<T>;\n\n// TODO(burdon): Should we allow the caller to set the id?\nexport type MakeProps<T extends Schema.Schema.AnyNoContext> = {\n  id?: ObjectId;\n  [Meta]?: Partial<ObjectMeta>;\n} & NoInfer<Props<Schema.Schema.Type<T>>>;\n\n/**\n * Creates a new object of the given types.\n * @param schema - Object schema.\n * @param props - Object properties.\n * @param meta - Object metadata (deprecated) -- pass with Obj.Meta.\n *\n * Meta can be passed as a symbol in `props`.\n *\n * Example:\n * ```ts\n * const obj = Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' });\n * ```\n */\nexport const make = <S extends Schema.Schema.AnyNoContext>(\n  schema: S,\n  props: MakeProps<S>,\n  meta?: Partial<ObjectMeta>,\n): Obj<Schema.Schema.Type<S>> => {\n  assertArgument(getTypeAnnotation(schema)?.kind === Entity.Kind.Object, 'schema', 'Expected an object schema');\n\n  // Set default fields on meta on creation.\n  if (props[MetaId] != null) {\n    meta = { ...structuredClone(defaultMeta), ...props[MetaId] };\n    delete props[MetaId];\n  }\n\n  // Filter undefined values.\n  const filterUndefined = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== undefined));\n\n  return makeObject<Schema.Schema.Type<S>>(schema, filterUndefined as any, {\n    ...defaultMeta,\n    ...meta,\n  });\n};\n\n/**\n * Determine if object is an ECHO object.\n */\nexport const isObject = (obj: unknown): obj is Any => {\n  assumeType<InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && obj[Entity.KindId] === Entity.Kind.Object;\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of an object.\n */\nexport const getSnapshot: <T extends Any>(obj: Obj<T>) => T = getSnapshot$;\n\nexport type CloneOptions = {\n  /**\n   * Retain the original object's ID.\n   * @default false\n   */\n  retainId?: boolean;\n};\n\n/**\n * Clones an object or relation.\n * This does not clone referenced objects, only the properties in the object.\n * @returns A new object with the same schema and properties.\n */\nexport const clone = <T extends Any>(obj: T, opts?: CloneOptions): T => {\n  const { id, ...data } = obj;\n  const schema = getSchema$(obj);\n  invariant(schema != null, 'Object should have a schema');\n  const props: any = deepMapValues(data, (value, recurse) => {\n    if (Ref.isRef(value)) {\n      return value;\n    }\n    return recurse(value);\n  });\n\n  if (opts?.retainId) {\n    props.id = id;\n  }\n  const meta = getMeta(obj);\n  props[MetaId] = deepMapValues(meta, (value, recurse) => {\n    if (Ref.isRef(value)) {\n      return value;\n    }\n    return recurse(value);\n  });\n\n  return make(schema as Type.Obj.Any, props);\n};\n\n//\n// Type\n//\n\n// TODO(burdon): To discuss: prefer over ObjectId or Key.ObjectId or Type.ID?\nexport const ID = ObjectId;\nexport type ID = ObjectId;\n\n/**\n * Test if object or relation is an instance of a schema.\n * @example\n * ```ts\n * const john = Obj.make(Person, { name: 'John' });\n * const isPerson = Obj.instanceOf(Person);\n * if (isPerson(john)) {\n *   // john is Person\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.Entity.Any>(schema: S): (value: unknown) => value is Schema.Schema.Type<S>;\n  <S extends Type.Entity.Any>(schema: S, value: unknown): value is Schema.Schema.Type<S>;\n} = ((...args: [schema: Type.Entity.Any, value: unknown] | [schema: Type.Entity.Any]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => isInstanceOf(args[0], entity);\n  }\n\n  return isInstanceOf(args[0], args[1]);\n}) as any;\n\n// TODO(dmaretskyi): Allow returning undefined.\nexport const getDXN = (entity: Entity.Unknown): DXN => {\n  assertArgument(!Schema.isSchema(entity), 'obj', 'Object should not be a schema.');\n  const dxn = getObjectDXN(entity);\n  invariant(dxn != null, 'Invalid object.');\n  return dxn;\n};\n\n/**\n * @returns The DXN of the object's type.\n * @example dxn:example.com/type/Person:1.0.0\n */\n// TODO(burdon): Must define and return type for expando.\nexport const getTypeDXN = getTypeDXN$;\n\n/**\n * Get the schema of the object.\n */\nexport const getSchema = getSchema$;\n\n/**\n * @returns The typename of the object's type.\n * @example `example.com/type/Person`\n */\nexport const getTypename = (entity: Entity.Unknown): string | undefined => {\n  const schema = getSchema$(entity);\n  if (schema == null) {\n    // Try to extract typename from DXN.\n    return getTypeDXN$(entity)?.asTypeDXN()?.type;\n  }\n\n  return getSchemaTypename(schema);\n};\n\n//\n// Meta\n//\n\nexport const Meta: unique symbol = MetaId as any;\n\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): Allow returning undefined.\nexport const getMeta = (entity: AnyProperties): ObjectMeta => {\n  const meta = getMeta$(entity);\n  invariant(meta != null, 'Invalid object.');\n  return meta;\n};\n\n/**\n * @returns Foreign keys for the object from the specified source.\n */\nexport const getKeys: {\n  (entity: Entity.Unknown, source: string): ForeignKey[];\n  (source: string): (entity: Entity.Unknown) => ForeignKey[];\n} = Function.dual(2, (entity: Entity.Unknown, source?: string): ForeignKey[] => {\n  const meta = getMeta(entity);\n  invariant(meta != null, 'Invalid object.');\n  return meta.keys.filter((key) => key.source === source);\n});\n\n/**\n * Delete all keys from the object for the specified source.\n * @param entity\n * @param source\n */\nexport const deleteKeys = (entity: Entity.Unknown, source: string) => {\n  const meta = getMeta(entity);\n  for (let i = 0; i < meta.keys.length; i++) {\n    if (meta.keys[i].source === source) {\n      meta.keys.splice(i, 1);\n      i--;\n    }\n  }\n};\n\nexport const addTag = (entity: Entity.Unknown, tag: string) => {\n  const meta = getMeta(entity);\n  meta.tags ??= [];\n  meta.tags.push(tag);\n};\n\nexport const removeTag = (entity: Entity.Unknown, tag: string) => {\n  const meta = getMeta(entity);\n  if (!meta.tags) {\n    return;\n  }\n  for (let i = 0; i < meta.tags.length; i++) {\n    if (meta.tags[i] === tag) {\n      meta.tags.splice(i, 1);\n      i--;\n    }\n  }\n};\n\n// TODO(dmaretskyi): Default to `false`.\nexport const isDeleted = (entity: Entity.Unknown): boolean => {\n  const deleted = isDeleted$(entity);\n  invariant(typeof deleted === 'boolean', 'Invalid object.');\n  return deleted;\n};\n\n//\n// Annotations\n//\n\nexport const getLabel = (entity: Entity.Unknown): string | undefined => {\n  const schema = getSchema$(entity);\n  if (schema != null) {\n    return getLabel$(schema, entity);\n  }\n};\n\nexport const setLabel = (entity: Entity.Unknown, label: string) => {\n  const schema = getSchema$(entity);\n  if (schema != null) {\n    setLabel$(schema, entity, label);\n  }\n};\n\nexport const getDescription = (entity: Entity.Unknown): string | undefined => {\n  const schema = getSchema$(entity);\n  if (schema != null) {\n    return getDescription$(schema, entity);\n  }\n};\n\nexport const setDescription = (entity: Entity.Unknown, description: string) => {\n  const schema = getSchema$(entity);\n  if (schema != null) {\n    setDescription$(schema, entity, description);\n  }\n};\n\n//\n// JSON\n//\n\n/**\n * JSON representation of an object.\n */\nexport type JSON = ObjectJSON;\n\n/**\n * Converts object to its JSON representation.\n *\n * The same algorithm is used when calling the standard `JSON.stringify(obj)` function.\n */\nexport const toJSON = (entity: Entity.Unknown): JSON => objectToJSON(entity);\n\n/**\n * Creates an object from its json representation, performing schema validation.\n * References and schemas will be resolvable if the `refResolver` is provided.\n *\n * The function must be async to support resolving the schema as well as the relation endpoints.\n *\n * @param options.refResolver - Resolver for references. Produces hydrated references that can be resolved.\n * @param options.dxn - Override object DXN. Changes the result of `Obj.getDXN`.\n */\nexport const fromJSON: (json: unknown, options?: { refResolver?: Ref.Resolver; dxn?: DXN }) => Promise<Any> =\n  objectFromJSON as any;\n\n//\n// Sorting\n//\n\nconst compare = (a?: string, b?: string) => {\n  if (a == null) {\n    return b == null ? 0 : 1;\n  }\n\n  if (b == null) {\n    return -1;\n  }\n\n  return a.localeCompare(b);\n};\n\nexport type Comparator = (a: Entity.Unknown, b: Entity.Unknown) => number;\n\nexport const sortByLabel: Comparator = (a: Entity.Unknown, b: Entity.Unknown) => compare(getLabel(a), getLabel(b));\nexport const sortByTypename: Comparator = (a: Entity.Unknown, b: Entity.Unknown) =>\n  compare(getTypename(a), getTypename(b));\nexport const sort = (...comparators: Comparator[]): Comparator => {\n  return (a: Entity.Unknown, b: Entity.Unknown) => {\n    for (const comparator of comparators) {\n      const result = comparator(a, b);\n      if (result !== 0) {\n        return result;\n      }\n    }\n\n    return 0;\n  };\n};\n\n//\n// Version\n//\n\n/**\n * Unique symbol for version type identification.\n */\nexport { VersionTypeId };\n\n/**\n * Represent object version.\n * May be backed by Automerge.\n * Objects with no history are not versioned.\n */\nexport interface Version {\n  [VersionTypeId]: {};\n\n  /**\n   * Whether the object is versioned.\n   */\n  versioned: boolean;\n\n  /**\n   * Automerge heads.\n   */\n  automergeHeads?: string[];\n}\n\nconst unversioned: Version = {\n  [VersionTypeId]: {},\n  versioned: false,\n};\n\n/**\n * Checks that `obj` is a version object.\n */\nexport const isVersion = (entity: unknown): entity is Version => {\n  return entity != null && typeof entity === 'object' && VersionTypeId in entity;\n};\n\n/**\n * Returns the version of the object.\n */\nexport const version = (entity: Entity.Unknown): Version => {\n  const version = (entity as any)[ObjectVersionId];\n  if (version === undefined) {\n    return unversioned;\n  }\n\n  return version;\n};\n\n/**\n * Checks that `version` is a valid version object.\n */\nexport const versionValid = (version: Version): boolean => {\n  assertArgument(isVersion(version), 'version', 'Invalid version object');\n  return !!version.versioned;\n};\n\nexport type VersionCompareResult = 'unversioned' | 'equal' | 'different';\n\n/**\n * Compares two versions.\n * @param version1\n * @param version2\n * @returns 'unversioned' if either object is unversioned, 'equal' if the versions are equal, 'different' if the versions are different.\n */\nexport const compareVersions = (version1: Version, version2: Version): VersionCompareResult => {\n  assertArgument(isVersion(version1), 'version1', 'Invalid version object');\n  assertArgument(isVersion(version2), 'version2', 'Invalid version object');\n\n  if (!versionValid(version1) || !versionValid(version2)) {\n    return 'unversioned';\n  }\n\n  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {\n    return 'different';\n  }\n  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {\n    return 'different';\n  }\n\n  return 'equal';\n};\n\nexport const encodeVersion = (version: Version): string => {\n  return JSON.stringify(version);\n};\n\nexport const decodeVersion = (version: string): Version => {\n  const parsed = JSON.parse(version);\n  parsed[VersionTypeId] = {};\n  return parsed;\n};\n"],
+  "mappings": "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",
+  "names": ["getDescription", "getLabel", "getMeta", "getSchema", "getTypeDXN", "isDeleted", "setDescription", "setLabel", "Function", "Schema", "assertArgument", "invariant", "ObjectId", "getSnapshot", "getSnapshot$", "assumeType", "deepMapValues", "Any", "Struct", "pipe", "Obj", "typename", "version", "defaultMeta", "keys", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "Kind", "Object", "MetaId", "structuredClone", "filterUndefined", "fromEntries", "entries", "filter", "_", "v", "undefined", "makeObject", "isObject", "obj", "assumeType", "KindId", "getSnapshot", "getSnapshot$", "clone", "opts", "id", "data", "getSchema$", "invariant", "deepMapValues", "value", "recurse", "isRef", "retainId", "getMeta", "ID", "ObjectId", "instanceOf", "args", "length", "entity", "isInstanceOf", "getDXN", "isSchema", "dxn", "getObjectDXN", "getTypeDXN", "getTypeDXN$", "getSchema", "getTypename", "asTypeDXN", "type", "getSchemaTypename", "Meta", "getMeta$", "getKeys", "dual", "source", "key", "deleteKeys", "i", "splice", "addTag", "tag", "tags", "push", "removeTag", "isDeleted", "deleted", "isDeleted$", "getLabel", "getLabel$", "setLabel", "label", "setLabel$", "getDescription", "getDescription$", "setDescription", "description", "setDescription$", "toJSON", "objectToJSON", "fromJSON", "objectFromJSON", "compare", "a", "b", "localeCompare", "sortByLabel", "sortByTypename", "sort", "comparators", "comparator", "result", "unversioned", "VersionTypeId", "versioned", "isVersion", "entity", "version", "ObjectVersionId", "undefined", "versionValid", "assertArgument", "compareVersions", "version1", "version2", "automergeHeads", "length", "some", "head", "includes", "encodeVersion", "JSON", "stringify", "decodeVersion", "parsed", "parse"]
+}

package/dist/lib/browser/chunk-FGFQWIZE.mjs

@@ -0,0 +1,9 @@
+import "@dxos/node-std/globals";
+
+// src/SchemaRegistry.ts
+var SchemaRegistry_exports = {};
+
+export {
+  SchemaRegistry_exports
+};
+//# sourceMappingURL=chunk-FGFQWIZE.mjs.map

package/dist/lib/browser/chunk-FGFQWIZE.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/SchemaRegistry.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Types from 'effect/Types';\n\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Key from './Key';\nimport type * as QueryResult from './QueryResult';\nimport type * as Type from './Type';\n\n// TODO(wittjosiah): Replace w/ Query.Query.\nexport type Query = {\n  /**\n   * Filter by schema ID.\n   * Schema id is a DXN with `echo` or `type` kind.\n   */\n  id?: string | string[];\n\n  /**\n   * Id of the backing ECHO object.\n   */\n  backingObjectId?: Key.ObjectId | Key.ObjectId[];\n\n  /**\n   * One or more typenames to filter by.\n   */\n  typename?: string | string[];\n\n  /**\n   * [Semver Range](https://docs.npmjs.com/cli/v6/using-npm/semver#ranges) for the schema version.\n   */\n  version?: string;\n\n  /**\n   * Where to look for the schema.\n   *\n   * Database schema are stored in the database of the current space.\n   * Runtime schema are registered in the runtime.\n   *\n   * @default ['database']\n   */\n  location?: ('database' | 'runtime')[];\n\n  /**\n   * Include system schemas.\n   * @default false\n   *\n   * The system schema include but are not limited to:\n   *  - dxos.org/type/Schema\n   */\n  includeSystem?: boolean;\n};\n\n/**\n * Input for schema registration.\n * The typename, version and schema mutability metadata is read from the schema annotations.\n */\nexport type RegisterSchemaInput =\n  | Type.Entity.Any\n  | {\n      typename: string;\n      version: string;\n      jsonSchema: JsonSchema.JsonSchema;\n      /**\n       * Display name of the schema.\n       */\n      name?: string;\n    };\n\nexport type ExtractQueryResult<Query> = Query extends { location: ('database' | 'runtime')[] }\n  ? Type.Entity.Any\n  : Type.RuntimeType;\n\nexport interface SchemaRegistry {\n  /**\n   * Registers the provided schema.\n   *\n   * @returns Mutable runtime instances of schemas that were registered.\n   *\n   * The behavior of this method depends on the state of the database.\n   * The general principle is that the schema will be upserted into the space.\n   * If an equivalent schema with the same name and version already exists, the method does nothing.\n   * If a different schema with the same name and version exists, the method throws an error.\n   * If no schema with the same name and version exists, a new schema will be inserted based on semantic versioning rules.\n   */\n  register(input: RegisterSchemaInput[]): Promise<Type.RuntimeType[]>;\n\n  query<Q extends Types.NoExcessProperties<Query, Q>>(\n    query?: Q & Query,\n  ): QueryResult.QueryResult<ExtractQueryResult<Q>>;\n}\n"],
+  "mappings": ";;;AAAA;",
+  "names": []
+}

package/dist/lib/browser/chunk-INHXFXY5.mjs

@@ -0,0 +1,22 @@
+import "@dxos/node-std/globals";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
+
+// src/Key.ts
+var Key_exports = {};
+__export(Key_exports, {
+  ForeignKey: () => ForeignKey,
+  ObjectId: () => ObjectId,
+  SpaceId: () => SpaceId
+});
+import { ForeignKey } from "@dxos/echo-protocol";
+import { SpaceId, ObjectId } from "@dxos/keys";
+
+export {
+  Key_exports,
+  ForeignKey,
+  SpaceId,
+  ObjectId
+};
+//# sourceMappingURL=chunk-INHXFXY5.mjs.map

package/dist/lib/browser/chunk-INHXFXY5.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Key.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// TODO(wittjosiah): Should this be a subset of Type?\n\nexport { ForeignKey } from '@dxos/echo-protocol';\nexport { SpaceId, ObjectId } from '@dxos/keys';\n"],
+  "mappings": ";;;;;;AAAA;;;;;;AAMA,SAASA,kBAAkB;AAC3B,SAASC,SAASC,gBAAgB;",
+  "names": ["ForeignKey", "SpaceId", "ObjectId"]
+}

package/dist/lib/browser/chunk-JG4GH6LN.mjs

@@ -0,0 +1,9 @@
+import "@dxos/node-std/globals";
+
+// src/QueryResult.ts
+var QueryResult_exports = {};
+
+export {
+  QueryResult_exports
+};
+//# sourceMappingURL=chunk-JG4GH6LN.mjs.map

package/dist/lib/browser/chunk-JG4GH6LN.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/QueryResult.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type CleanupFn } from '@dxos/async';\n\nimport type * as Entity from './Entity';\n\n/**\n * Individual query result entry.\n */\nexport type Entry<T> = {\n  id: string;\n\n  /**\n   * May not be present for remote results.\n   */\n  result?: T;\n\n  match?: {\n    // TODO(dmaretskyi): text positional info.\n\n    /**\n     * Higher means better match.\n     */\n    rank: number;\n  };\n\n  /**\n   * Query resolution metadata.\n   */\n  // TODO(dmaretskyi): Rename to meta?\n  resolution?: {\n    // TODO(dmaretskyi): Make this more generic.\n    source: 'remote' | 'local' | 'index';\n\n    /**\n     * Query resolution time in milliseconds.\n     */\n    time: number;\n  };\n};\n\n/**\n * Invidual query result entry for a database Entity.\n */\nexport type EntityEntry<T extends Entity.Unknown = Entity.Unknown> = Entry<T>;\n\nexport type RunOptions = {\n  timeout?: number;\n};\n\nexport type SubscriptionOptions = {\n  /**\n   * Fire the callback immediately.\n   */\n  fire?: boolean;\n};\n\nexport interface QueryResult<T> {\n  /**\n   * Currently available results along with their match metadata.\n   *\n   * @reactive\n   */\n  readonly entries: Entry<T>[];\n\n  /**\n   * Currently available results.\n   *\n   * @reactive\n   */\n  readonly results: T[];\n\n  /**\n   * Returns all known results.\n   */\n  run(opts?: RunOptions): Promise<T[]>;\n\n  /**\n   * Returns all known results along with their match metadata.\n   */\n  runEntries(opts?: RunOptions): Promise<Entry<T>[]>;\n\n  /**\n   * Returns currently available results synchronously.\n   */\n  runSync(): T[];\n\n  /**\n   * Returns currently available results synchronously along with their match metadata.\n   */\n  runSyncEntries(): Entry<T>[];\n\n  /**\n   * Returns first result.\n   */\n  first(opts?: RunOptions): Promise<T>;\n\n  /**\n   * Returns first result if there is one.\n   */\n  firstOrUndefined(opts?: RunOptions): Promise<T | undefined>;\n\n  /**\n   * Subscribes to changes in query results.\n   */\n  subscribe(callback?: (query: QueryResult<T>) => void, opts?: SubscriptionOptions): CleanupFn;\n}\n"],
+  "mappings": ";;;AAAA;",
+  "names": []
+}

package/dist/lib/browser/chunk-MYCCGG2T.mjs

@@ -0,0 +1,15 @@
+import "@dxos/node-std/globals";
+
+// src/index.ts
+import { QueryAST } from "@dxos/echo-protocol";
+import { DXN } from "@dxos/keys";
+
+// src/Hypergraph.ts
+var Hypergraph_exports = {};
+
+export {
+  Hypergraph_exports,
+  QueryAST,
+  DXN
+};
+//# sourceMappingURL=chunk-MYCCGG2T.mjs.map

package/dist/lib/browser/chunk-MYCCGG2T.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts", "../../../src/Hypergraph.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport { QueryAST } from '@dxos/echo-protocol';\n// TODO(wittjosiah): Refactor DXN to not use statics similar to Query.\nexport { DXN } from '@dxos/keys';\n\nexport * as Annotation from './Annotation';\nexport * as Database from './Database';\nexport * as Entity from './Entity';\nexport * as Err from './Err';\nexport * as Filter from './Filter';\nexport * as Format from './Format';\nexport * as Hypergraph from './Hypergraph';\nexport * as JsonSchema from './JsonSchema';\nexport * as Key from './Key';\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 Relation from './Relation';\nexport * as SchemaRegistry from './SchemaRegistry';\nexport * as Tag from './Tag';\nexport * as Type from './Type';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type DXN } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport { type AnyProperties } from './internal';\nimport type * as Key from './Key';\nimport type * as Ref from './Ref';\nimport type * as SchemaRegistry from './SchemaRegistry';\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   * Queue that the resolution is happening from.\n   * This queue will be searched first, and then the space it belongs to.\n   */\n  queue?: DXN;\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: AnyProperties) => AnyProperties;\n}\n\n/**\n *\n */\n// TODO(burdon): Comment required.\nexport interface Hypergraph extends Database.Queryable {\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\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.fromDXN`\n   * `Ref.fromDXN(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>(dxn: DXN): 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"],
+  "mappings": ";;;AAIA,SAASA,gBAAgB;AAEzB,SAASC,WAAW;;;ACNpB;",
+  "names": ["QueryAST", "DXN"]
+}

package/dist/lib/browser/chunk-NFH3POTD.mjs

@@ -0,0 +1,37 @@
+import "@dxos/node-std/globals";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
+
+// src/Order.ts
+var Order_exports = {};
+__export(Order_exports, {
+  natural: () => natural,
+  property: () => property
+});
+var OrderClass = class _OrderClass {
+  ast;
+  static variance = {};
+  static is(value) {
+    return typeof value === "object" && value !== null && "~Order" in value;
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Order" = _OrderClass.variance;
+};
+var natural = new OrderClass({
+  kind: "natural"
+});
+var property = (property2, direction) => new OrderClass({
+  kind: "property",
+  property: property2,
+  direction
+});
+
+export {
+  natural,
+  property,
+  Order_exports
+};
+//# sourceMappingURL=chunk-NFH3POTD.mjs.map

package/dist/lib/browser/chunk-NFH3POTD.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Order.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nexport interface Order<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Order': { value: T };\n\n  ast: QueryAST.Order;\n}\n\nexport type Any = Order<any>;\n\nclass OrderClass implements Order<any> {\n  private static variance: Order<any>['~Order'] = {} as Order<any>['~Order'];\n\n  static is(value: unknown): value is Order<any> {\n    return typeof value === 'object' && value !== null && '~Order' in value;\n  }\n\n  constructor(public readonly ast: QueryAST.Order) {}\n\n  '~Order' = OrderClass.variance;\n}\n\nexport const natural: Order<any> = new OrderClass({ kind: 'natural' });\nexport const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Order<T> =>\n  new OrderClass({\n    kind: 'property',\n    property,\n    direction,\n  });\n"],
+  "mappings": ";;;;;;AAAA;;;;;AAeA,IAAMA,aAAN,MAAMA,YAAAA;;EACJ,OAAeC,WAAiC,CAAC;EAEjD,OAAOC,GAAGC,OAAqC;AAC7C,WAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,YAAYA;EACpE;EAEA,YAA4BC,KAAqB;SAArBA,MAAAA;EAAsB;EAElD,WAAWJ,YAAWC;AACxB;AAEO,IAAMI,UAAsB,IAAIL,WAAW;EAAEM,MAAM;AAAU,CAAA;AAC7D,IAAMC,WAAW,CAAIA,WAA4BC,cACtD,IAAIR,WAAW;EACbM,MAAM;EACNC,UAAAA;EACAC;AACF,CAAA;",
+  "names": ["OrderClass", "variance", "is", "value", "ast", "natural", "kind", "property", "direction"]
+}

package/dist/lib/browser/chunk-O6FOICWT.mjs

@@ -0,0 +1,57 @@
+import "@dxos/node-std/globals";
+import {
+  make
+} from "./chunk-F4YF6C3O.mjs";
+import {
+  Obj
+} from "./chunk-AGOWBKY6.mjs";
+import {
+  LabelAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-WABSVOOX.mjs";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
+
+// src/Tag.ts
+var Tag_exports = {};
+__export(Tag_exports, {
+  Tag: () => Tag,
+  createTagList: () => createTagList,
+  findTagByLabel: () => findTagByLabel,
+  make: () => make2,
+  sortTags: () => sortTags
+});
+import * as Schema from "effect/Schema";
+var Tag = Schema.Struct({
+  label: Schema.String,
+  hue: Schema.optional(Schema.String)
+}).pipe(Obj({
+  typename: "dxos.org/type/Tag",
+  version: "0.1.0"
+}), LabelAnnotation.set([
+  "label"
+]), SystemTypeAnnotation.set(true));
+var make2 = (props) => make(Tag, props);
+var sortTags = ({ label: a }, { label: b }) => a.localeCompare(b);
+var createTagList = (tags) => Object.entries(tags).map(([id, tag]) => ({
+  ...tag,
+  id
+})).sort(sortTags);
+var findTagByLabel = (tags, name) => {
+  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());
+  return entry ? {
+    ...entry[1],
+    id: entry[0]
+  } : void 0;
+};
+
+export {
+  Tag,
+  make2 as make,
+  sortTags,
+  createTagList,
+  findTagByLabel,
+  Tag_exports
+};
+//# sourceMappingURL=chunk-O6FOICWT.mjs.map

package/dist/lib/browser/chunk-O6FOICWT.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Tag.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { LabelAnnotation, SystemTypeAnnotation } from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\nexport const Tag = Schema.Struct({\n  label: Schema.String,\n  hue: Schema.optional(Schema.String), // TODO(burdon): Color name?\n}).pipe(\n  Type.Obj({\n    typename: 'dxos.org/type/Tag',\n    version: '0.1.0',\n  }),\n  LabelAnnotation.set(['label']),\n  SystemTypeAnnotation.set(true),\n);\n\nexport type Tag = Schema.Schema.Type<typeof Tag>;\n\nexport const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);\n\n// TODO(burdon): Rename Map.\nexport type Map = Record<string, Tag>;\n\nexport const sortTags = ({ label: a }: Tag, { label: b }: Tag) => a.localeCompare(b);\n\nexport const createTagList = (tags: Map): Tag[] =>\n  Object.entries(tags)\n    .map(([id, tag]) => ({ ...tag, id }))\n    .sort(sortTags);\n\nexport const findTagByLabel = (tags: Map | undefined, name: string): Tag | undefined => {\n  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());\n  return entry ? { ...entry[1], id: entry[0] } : undefined;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAAA;;;;;cAAAA;EAAA;;AAIA,YAAYC,YAAY;AAMjB,IAAMC,MAAaC,cAAO;EAC/BC,OAAcC;EACdC,KAAYC,gBAAgBF,aAAM;AACpC,CAAA,EAAGG,KACIC,IAAI;EACPC,UAAU;EACVC,SAAS;AACX,CAAA,GACAC,gBAAgBC,IAAI;EAAC;CAAQ,GAC7BC,qBAAqBD,IAAI,IAAA,CAAA;AAKpB,IAAME,QAAO,CAACC,UAAyCD,KAAKb,KAAKc,KAAAA;AAKjE,IAAMC,WAAW,CAAC,EAAEb,OAAOc,EAAC,GAAS,EAAEd,OAAOe,EAAC,MAAYD,EAAEE,cAAcD,CAAAA;AAE3E,IAAME,gBAAgB,CAACC,SAC5BC,OAAOC,QAAQF,IAAAA,EACZG,IAAI,CAAC,CAACC,IAAIC,GAAAA,OAAU;EAAE,GAAGA;EAAKD;AAAG,EAAA,EACjCE,KAAKX,QAAAA;AAEH,IAAMY,iBAAiB,CAACP,MAAuBQ,SAAAA;AACpD,QAAMC,QAAQR,OAAOC,QAAQF,QAAQ,CAAC,CAAA,EAAGU,KAAK,CAAC,CAACC,GAAGN,GAAAA,MAASA,IAAIvB,MAAM8B,YAAW,MAAOJ,KAAKI,YAAW,CAAA;AACxG,SAAOH,QAAQ;IAAE,GAAGA,MAAM,CAAA;IAAIL,IAAIK,MAAM,CAAA;EAAG,IAAII;AACjD;",
+  "names": ["make", "Schema", "Tag", "Struct", "label", "String", "hue", "optional", "pipe", "Obj", "typename", "version", "LabelAnnotation", "set", "SystemTypeAnnotation", "make", "props", "sortTags", "a", "b", "localeCompare", "createTagList", "tags", "Object", "entries", "map", "id", "tag", "sort", "findTagByLabel", "name", "entry", "find", "_", "toLowerCase", "undefined"]
+}

package/dist/lib/browser/chunk-P2B4BASR.mjs

@@ -0,0 +1,288 @@
+import "@dxos/node-std/globals";
+import {
+  isRef
+} from "./chunk-ESLW4N7S.mjs";
+import {
+  getTypeDXNFromSpecifier
+} from "./chunk-WABSVOOX.mjs";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
+
+// src/Filter.ts
+var Filter_exports = {};
+__export(Filter_exports, {
+  and: () => and,
+  between: () => between,
+  contains: () => contains,
+  eq: () => eq,
+  everything: () => everything,
+  foreignKeys: () => foreignKeys,
+  fromAst: () => fromAst,
+  gt: () => gt,
+  gte: () => gte,
+  id: () => id,
+  in: () => in$,
+  is: () => is,
+  lt: () => lt,
+  lte: () => lte,
+  neq: () => neq,
+  not: () => not,
+  nothing: () => nothing,
+  or: () => or,
+  props: () => props,
+  tag: () => tag,
+  text: () => text,
+  type: () => type,
+  typeDXN: () => typeDXN,
+  typename: () => typename
+});
+import * as Match from "effect/Match";
+import * as Schema from "effect/Schema";
+import { assertArgument } from "@dxos/invariant";
+import { DXN, ObjectId } from "@dxos/keys";
+var FilterClass = class _FilterClass {
+  ast;
+  static variance = {};
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Filter" = _FilterClass.variance;
+};
+var is = (value2) => {
+  return typeof value2 === "object" && value2 !== null && "~Filter" in value2;
+};
+var fromAst = (ast) => {
+  return new FilterClass(ast);
+};
+var everything = () => {
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    props: {}
+  });
+};
+var nothing = () => {
+  return new FilterClass({
+    type: "not",
+    filter: {
+      type: "object",
+      typename: null,
+      props: {}
+    }
+  });
+};
+var id = (...ids) => {
+  assertArgument(ids.every((id2) => ObjectId.isValid(id2)), "ids", "ids must be valid");
+  if (ids.length === 0) {
+    return nothing();
+  }
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    id: ids,
+    props: {}
+  });
+};
+var type = (schema, props2) => {
+  const dxn = getTypeDXNFromSpecifier(schema);
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    ...propsFilterToAst(props2 ?? {})
+  });
+};
+var typename = (typename2) => {
+  assertArgument(!typename2.startsWith("dxn:"), "typename", "Typename must no be qualified");
+  return new FilterClass({
+    type: "object",
+    typename: DXN.fromTypename(typename2).toString(),
+    props: {}
+  });
+};
+var typeDXN = (dxn) => {
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    props: {}
+  });
+};
+var tag = (tag2) => {
+  return new FilterClass({
+    type: "tag",
+    tag: tag2
+  });
+};
+var props = (props2) => {
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    ...propsFilterToAst(props2)
+  });
+};
+var text = (text2, options) => {
+  return new FilterClass({
+    type: "text-search",
+    text: text2,
+    searchKind: options?.type
+  });
+};
+var foreignKeys = (schema, keys) => {
+  const dxn = getTypeDXNFromSpecifier(schema);
+  return new FilterClass({
+    type: "object",
+    typename: dxn.toString(),
+    props: {},
+    foreignKeys: keys
+  });
+};
+var eq = (value2) => {
+  if (!isRef(value2) && typeof value2 === "object" && value2 !== null) {
+    throw new TypeError("Cannot use object as a value for eq filter");
+  }
+  return new FilterClass({
+    type: "compare",
+    operator: "eq",
+    value: isRef(value2) ? value2.noInline().encode() : value2
+  });
+};
+var neq = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "neq",
+    value: value2
+  });
+};
+var gt = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "gt",
+    value: value2
+  });
+};
+var gte = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "gte",
+    value: value2
+  });
+};
+var lt = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "lt",
+    value: value2
+  });
+};
+var lte = (value2) => {
+  return new FilterClass({
+    type: "compare",
+    operator: "lte",
+    value: value2
+  });
+};
+var in$ = (...values) => {
+  return new FilterClass({
+    type: "in",
+    values
+  });
+};
+var contains = (value2) => {
+  return new FilterClass({
+    type: "contains",
+    value: value2
+  });
+};
+var between = (from, to) => {
+  return new FilterClass({
+    type: "range",
+    from,
+    to
+  });
+};
+var not = (filter) => {
+  return new FilterClass({
+    type: "not",
+    filter: filter.ast
+  });
+};
+var and = (...filters) => {
+  return new FilterClass({
+    type: "and",
+    filters: filters.map((f) => f.ast)
+  });
+};
+var or = (...filters) => {
+  return new FilterClass({
+    type: "or",
+    filters: filters.map((f) => f.ast)
+  });
+};
+var propsFilterToAst = (predicates) => {
+  let idFilter;
+  if ("id" in predicates) {
+    assertArgument(typeof predicates.id === "string" || Array.isArray(predicates.id), "predicates.id", "invalid id filter");
+    idFilter = typeof predicates.id === "string" ? [
+      predicates.id
+    ] : predicates.id;
+    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);
+  }
+  return {
+    id: idFilter,
+    props: Object.fromEntries(Object.entries(predicates).filter(([prop, _value]) => prop !== "id").map(([prop, predicate]) => [
+      prop,
+      processPredicate(predicate)
+    ]))
+  };
+};
+var processPredicate = (predicate) => {
+  return Match.value(predicate).pipe(
+    Match.withReturnType(),
+    Match.when(is, (predicate2) => predicate2.ast),
+    // TODO(wittjosiah): Add support for array predicates.
+    Match.when(Array.isArray, (_predicate) => {
+      throw new Error("Array predicates are not yet supported.");
+    }),
+    Match.when((predicate2) => !isRef(predicate2) && typeof predicate2 === "object" && predicate2 !== null, (predicate2) => {
+      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key, value2]) => [
+        key,
+        processPredicate(value2)
+      ]));
+      return {
+        type: "object",
+        typename: null,
+        props: nestedProps
+      };
+    }),
+    Match.orElse((value2) => eq(value2).ast)
+  );
+};
+
+export {
+  is,
+  fromAst,
+  everything,
+  nothing,
+  id,
+  type,
+  typename,
+  typeDXN,
+  tag,
+  props,
+  text,
+  foreignKeys,
+  eq,
+  neq,
+  gt,
+  gte,
+  lt,
+  lte,
+  in$,
+  contains,
+  between,
+  not,
+  and,
+  or,
+  Filter_exports
+};
+//# sourceMappingURL=chunk-P2B4BASR.mjs.map

package/dist/lib/browser/chunk-P2B4BASR.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Filter.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport { getTypeDXNFromSpecifier } from './internal';\nimport * as Ref from './Ref';\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Filter': { value: Types.Contravariant<T> };\n\n  ast: QueryAST.Filter;\n}\n\nexport type Props<T> = {\n  // Predicate or a value as a shorthand for `eq`.\n  [K in keyof T & string]?: Filter<T[K]> | T[K];\n};\n\nexport type Any = Filter<any>;\n\nexport type Type<F extends Any> = F extends Filter<infer T> ? T : never;\n\nclass FilterClass implements Any {\n  private static variance: Any['~Filter'] = {} as Any['~Filter'];\n\n  constructor(public readonly ast: QueryAST.Filter) {}\n\n  '~Filter' = FilterClass.variance;\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Filter' in value;\n};\n\n/** Construct a filter from an ast. */\nexport const fromAst = (ast: QueryAST.Filter): Any => {\n  return new FilterClass(ast);\n};\n\n/**\n * Filter that matches all objects.\n */\n// TODO(dmaretskyi): `Entity.Any` would be more type-safe, but causes annoying errors in existing code\nexport const everything = (): FilterClass => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n  });\n};\n\n/**\n * Filter that matches no objects.\n */\nexport const nothing = (): FilterClass => {\n  return new FilterClass({\n    type: 'not',\n    filter: {\n      type: 'object',\n      typename: null,\n      props: {},\n    },\n  });\n};\n\n/*\n * Filter by ObjectId.\n */\nexport const id = (...ids: ObjectId[]): Any => {\n  assertArgument(\n    ids.every((id) => ObjectId.isValid(id)),\n    'ids',\n    'ids must be valid',\n  );\n\n  if (ids.length === 0) {\n    return nothing();\n  }\n\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    id: ids,\n    props: {},\n  });\n};\n\n/**\n * Filter by type.\n */\nexport const type = <S extends Schema.Schema.All>(\n  schema: S | string,\n  props?: Props<Schema.Schema.Type<S>>,\n): Filter<Schema.Schema.Type<S>> => {\n  const dxn = getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    ...propsFilterToAst(props ?? {}),\n  });\n};\n\n/**\n * Filter by non-qualified typename.\n */\nexport const typename = (typename: string): Any => {\n  assertArgument(!typename.startsWith('dxn:'), 'typename', 'Typename must no be qualified');\n  return new FilterClass({\n    type: 'object',\n    typename: DXN.fromTypename(typename).toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by fully qualified type DXN.\n */\nexport const typeDXN = (dxn: DXN): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by tag.\n */\nexport const tag = (tag: string): Any => {\n  return new FilterClass({\n    type: 'tag',\n    tag,\n  });\n};\n\n/**\n * Filter by properties.\n */\nexport const props = <T>(props: Props<T>): Filter<T> => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    ...propsFilterToAst(props),\n  });\n};\n\nexport type TextSearchOptions = {\n  // TODO(dmaretskyi): Hybrid search.\n  type?: 'full-text' | 'vector';\n};\n\n/**\n * Full-text or vector search.\n */\nexport const text = (\n  // TODO(dmaretskyi): Consider passing a vector here, but really the embedding should be done on the query-executor side.\n  text: string,\n  options?: TextSearchOptions,\n): Any => {\n  return new FilterClass({\n    type: 'text-search',\n    text,\n    searchKind: options?.type,\n  });\n};\n\n/**\n * Filter by foreign keys.\n */\nexport const foreignKeys = <S extends Schema.Schema.All>(\n  schema: S | string,\n  keys: ForeignKey[],\n): Filter<Schema.Schema.Type<S>> => {\n  const dxn = getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n    foreignKeys: keys,\n  });\n};\n\n/**\n * Predicate for property to be equal to the provided value.\n */\nexport const eq = <T>(value: T): Filter<T | undefined> => {\n  if (!Ref.isRef(value) && typeof value === 'object' && value !== null) {\n    throw new TypeError('Cannot use object as a value for eq filter');\n  }\n\n  return new FilterClass({\n    type: 'compare',\n    operator: 'eq',\n    value: Ref.isRef(value) ? value.noInline().encode() : value,\n  });\n};\n\n/**\n * Predicate for property to be not equal to the provided value.\n */\nexport const neq = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'neq',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than the provided value.\n */\nexport const gt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than or equal to the provided value.\n */\nexport const gte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than the provided value.\n */\nexport const lt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than or equal to the provided value.\n */\nexport const lte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided array.\n * @param values - Values to check against.\n */\nconst in$ = <T>(...values: T[]): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'in',\n    values,\n  });\n};\nexport { in$ as in };\n\n/**\n * Predicate for an array property to contain the provided value.\n * @param value - Value to check against.\n */\nexport const contains = <T>(value: T): Filter<readonly T[] | undefined> => {\n  return new FilterClass({\n    type: 'contains',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided range.\n * @param from - Start of the range (inclusive).\n * @param to - End of the range (exclusive).\n */\nexport const between = <T>(from: T, to: T): Filter<unknown> => {\n  return new FilterClass({\n    type: 'range',\n    from,\n    to,\n  });\n};\n\n/**\n * Negate the filter.\n */\nexport const not = <F extends Any>(filter: F): Filter<Type<F>> => {\n  return new FilterClass({\n    type: 'not',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Combine filters with a logical AND.\n */\nexport const and = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'and',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n/**\n * Combine filters with a logical OR.\n */\nexport const or = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'or',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n// TODO(dmaretskyi): Add `Filter.match` to support pattern matching on string props.\n\nconst propsFilterToAst = (predicates: Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {\n  let idFilter: readonly ObjectId[] | undefined;\n  if ('id' in predicates) {\n    assertArgument(\n      typeof predicates.id === 'string' || Array.isArray(predicates.id),\n      'predicates.id',\n      'invalid id filter',\n    );\n    idFilter = typeof predicates.id === 'string' ? [predicates.id] : predicates.id;\n    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);\n  }\n\n  return {\n    id: idFilter,\n    props: Object.fromEntries(\n      Object.entries(predicates)\n        .filter(([prop, _value]) => prop !== 'id')\n        .map(([prop, predicate]) => [prop, processPredicate(predicate)]),\n    ) as Record<string, QueryAST.Filter>,\n  };\n};\n\nconst processPredicate = (predicate: any): QueryAST.Filter => {\n  return Match.value(predicate).pipe(\n    Match.withReturnType<QueryAST.Filter>(),\n    Match.when(is, (predicate) => predicate.ast),\n    // TODO(wittjosiah): Add support for array predicates.\n    Match.when(Array.isArray, (_predicate) => {\n      throw new Error('Array predicates are not yet supported.');\n    }),\n    Match.when(\n      (predicate: any) => !Ref.isRef(predicate) && typeof predicate === 'object' && predicate !== null,\n      (predicate) => {\n        const nestedProps = Object.fromEntries(\n          Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)]),\n        );\n\n        return {\n          type: 'object',\n          typename: null,\n          props: nestedProps,\n        };\n      },\n    ),\n    Match.orElse((value) => eq(value).ast),\n  );\n};\n"],
+  "mappings": "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",
+  "names": ["Match", "Schema", "assertArgument", "DXN", "ObjectId", "FilterClass", "variance", "ast", "is", "value", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "id", "ids", "assertArgument", "every", "ObjectId", "isValid", "length", "schema", "dxn", "getTypeDXNFromSpecifier", "toString", "propsFilterToAst", "startsWith", "DXN", "fromTypename", "typeDXN", "tag", "text", "options", "searchKind", "foreignKeys", "keys", "eq", "isRef", "TypeError", "operator", "noInline", "encode", "neq", "gt", "gte", "lt", "lte", "in$", "values", "contains", "value", "FilterClass", "type", "between", "from", "to", "not", "filter", "ast", "and", "filters", "map", "f", "or", "propsFilterToAst", "predicates", "idFilter", "assertArgument", "id", "Array", "isArray", "Schema", "ObjectId", "pipe", "validateSync", "props", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "is", "_predicate", "Error", "isRef", "nestedProps", "key", "typename", "orElse", "eq"]
+}