@dxos/echo 0.8.4-main.ef1bc66f44 → 0.8.4-main.effb148878

package/dist/lib/neutral/{chunk-KB7RIVLK.mjs → chunk-A5HDDVKS.mjs}

@@ -1,18 +1,40 @@
-// src/internal/types/entity.ts
+// src/internal/common/types/entity.ts
 import * as Schema from "effect/Schema";
 var KindId = "~@dxos/echo/Kind";
 var SchemaKindId = "~@dxos/echo/SchemaKind";
 var SnapshotKindId = "~@dxos/echo/SnapshotKind";
+var StaticTypeSchemaSlot = "~@dxos/echo/Type.StaticSchema";
+var getStaticTypeSchema = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[StaticTypeSchemaSlot];
+};
+var getSchemaKind = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[SchemaKindId];
+};
+var getEntityKindBrand = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[KindId];
+};
+var InstancePhantomId = "~@dxos/echo/Type.Instance";
+var UnknownTypeSchemaBrandId = "~@dxos/echo/UnknownTypeSchemaBrand";
 var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
   EntityKind2["Object"] = "object";
   EntityKind2["Relation"] = "relation";
+  EntityKind2["Type"] = "type";
   return EntityKind2;
 })({});
 var EntityKindSchema = Schema.Enums(EntityKind);
-var ANY_OBJECT_TYPENAME = "dxos.org/schema/AnyObject";
+var ANY_OBJECT_TYPENAME = "org.dxos.schema.anyObject";
 var ANY_OBJECT_VERSION = "0.0.0";
 
-// src/internal/annotations/util.ts
+// src/internal/Annotation/util.ts
 import * as SchemaAST from "effect/SchemaAST";
 import { assertArgument } from "@dxos/invariant";
 import { DXN } from "@dxos/keys";
@@ -35,8 +57,7 @@ var makeTypeJsonSchemaAnnotation = (options) => {
   assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), "relationSource");
   assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), "relationTarget");
   const obj = {
-    // TODO(dmaretskyi): Should this include the version?
-    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),
+    $id: options.identifier ?? DXN.make(options.typename, options.version),
     entityKind: options.kind,
     version: options.version,
     typename: options.typename
@@ -56,6 +77,12 @@ export {
   KindId,
   SchemaKindId,
   SnapshotKindId,
+  StaticTypeSchemaSlot,
+  getStaticTypeSchema,
+  getSchemaKind,
+  getEntityKindBrand,
+  InstancePhantomId,
+  UnknownTypeSchemaBrandId,
   EntityKind,
   EntityKindSchema,
   ANY_OBJECT_TYPENAME,
@@ -64,4 +91,4 @@ export {
   unwrapOptional,
   makeTypeJsonSchemaAnnotation
 };
-//# sourceMappingURL=chunk-KB7RIVLK.mjs.map
+//# sourceMappingURL=chunk-A5HDDVKS.mjs.map

package/dist/lib/neutral/chunk-A5HDDVKS.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/common/types/entity.ts", "../../../src/internal/Annotation/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.\n//   Unique symbols cause TS4023 \"cannot be named\" errors when external packages\n//   try to export types that reference this key (e.g., `export const Graph = ...`).\n//   TypeScript cannot emit declaration files that reference unique symbols from\n//   external modules. Using a string literal allows the type to be inlined in\n//   declaration files, making the API portable across package boundaries.\n\n/**\n * String key used to identify the kind of an entity instance (object or relation).\n */\nexport const KindId = '~@dxos/echo/Kind' as const;\nexport type KindId = typeof KindId;\n\n/**\n * String key used to identify the kind of a schema (object schema or relation schema).\n * Parallels KindId which identifies instance kinds.\n */\nexport const SchemaKindId = '~@dxos/echo/SchemaKind' as const;\nexport type SchemaKindId = typeof SchemaKindId;\n\n/**\n * String key used to brand snapshot types.\n * Snapshots have SnapshotKindId instead of KindId, making them\n * distinguishable from reactive objects at the type level.\n */\nexport const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;\nexport type SnapshotKindId = typeof SnapshotKindId;\n\n/**\n * Hidden slot on a static `Type.Type` entity that holds the source Effect\n * Schema. `Type.getSchema(...)` reads this for static types; persisted types\n * rebuild from `jsonSchema` instead. Stored as a string key for declaration\n * portability (see KindId comment above).\n */\nexport const StaticTypeSchemaSlot = '~@dxos/echo/Type.StaticSchema' as const;\nexport type StaticTypeSchemaSlot = typeof StaticTypeSchemaSlot;\n\n/**\n * Read the hidden `StaticTypeSchemaSlot` off any value that may carry one.\n * Returns `undefined` for raw schemas (no slot) and non-object inputs.\n * Single point-of-cast for the slot lookup.\n */\nexport const getStaticTypeSchema = (value: unknown): Schema.Schema.AnyNoContext | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [StaticTypeSchemaSlot]?: Schema.Schema.AnyNoContext })[StaticTypeSchemaSlot];\n};\n\n/**\n * Read the `[SchemaKindId]` brand off a value. Returns `undefined` for raw\n * schemas (which don't carry the brand on their static type) and non-object\n * inputs. Single point-of-cast for the brand lookup.\n */\nexport const getSchemaKind = (value: unknown): EntityKind | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [SchemaKindId]?: EntityKind })[SchemaKindId];\n};\n\n/**\n * Read the `[KindId]` brand off a value. Returns `undefined` for raw schemas\n * and non-object inputs. Companion to {@link getSchemaKind}.\n */\nexport const getEntityKindBrand = (value: unknown): EntityKind | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [KindId]?: EntityKind })[KindId];\n};\n\n/**\n * Phantom string key on `Type<A>` entities that carries the instance type `A`.\n * Lets internal helpers (`makeObject`, `createObject`, etc.) pattern-match the\n * instance type from an entity input without importing from the top-level\n * `Type` module. Mirrors `Type.InstancePhantomId` (declared in `Type.ts`).\n *\n * Stored as a string key so declarations remain portable across packages\n * (see KindId comment above).\n */\nexport const InstancePhantomId = '~@dxos/echo/Type.Instance' as const;\nexport type InstancePhantomId = typeof InstancePhantomId;\n\n/**\n * Nominal brand carried by the well-known \"any object\" / \"any relation\"\n * schemas (`Obj.Unknown`, `Relation.Unknown`). The brand lets `Ref.Ref`,\n * `Filter.type`, and `Query.type` accept these schemas in addition to\n * `Type.Type` entities, without opening the door to arbitrary raw schemas.\n *\n * Stored as a string key so declarations remain portable across packages\n * (see KindId comment above).\n */\nexport const UnknownTypeSchemaBrandId = '~@dxos/echo/UnknownTypeSchemaBrand' as const;\nexport type UnknownTypeSchemaBrandId = typeof UnknownTypeSchemaBrandId;\n\n/**\n * Schema-side companion to `Type.Type` entities for the \"any object\" /\n * \"any relation\" cases. Branded so `Ref.Ref` / `Filter.type` / `Query.type`\n * can pattern-match on it; arbitrary `Schema.Schema` values do not satisfy\n * this shape.\n */\nexport interface UnknownTypeSchema<A, K extends EntityKind> extends Schema.Schema<A, any, never> {\n  readonly [UnknownTypeSchemaBrandId]: K;\n}\n\n/**\n * Kinds of entities stored in ECHO: objects, relations, and types.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\n  Type = 'type',\n}\n\nexport const EntityKindSchema = Schema.Enums(EntityKind);\n\n/**\n * Typename for generic object references (Type.Obj / Ref.Ref(Obj.Unknown)).\n * Used when referencing any object without a specific schema.\n */\nexport const ANY_OBJECT_TYPENAME = 'org.dxos.schema.anyObject';\n\n/**\n * Version for generic object references.\n */\nexport const ANY_OBJECT_VERSION = '0.0.0';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { EntityKind } from '../common/types';\n\nexport interface AnnotationHelper<T> {\n  /**\n   * Get the annotation value from an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — to read an annotation off a `Type.Type`\n   * entity, unwrap it first with `Type.getSchema(entity)`. This keeps the\n   * annotation pipeline single-shaped and forces annotations to live on the\n   * source schema, not on the post-construction Type entity.\n   */\n  get: (schema: Schema.Schema.Any) => Option.Option<T>;\n  /**\n   * Get the annotation value from the AST.\n   */\n  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;\n  /**\n   * Set the annotation on an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — annotations must be applied to the\n   * source schema BEFORE wrapping it with `Type.makeObject` / `Type.makeRelation`.\n   * In a pipe, place every `Annotation.X.set(...)` before the `Type.make...` step.\n   */\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\n/**\n * Note: only for system annotations.\n */\n// TODO(dmaretskyi): Rename to createSystemAnnotationHelper.\nexport const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {\n  return {\n    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),\n    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),\n    set:\n      (value) =>\n      <S extends Schema.Schema.Any>(schema: S): S =>\n        schema.annotations({ [id]: value }) as S,\n  };\n};\n\n/**\n * If property is optional returns the nested property, otherwise returns the property.\n */\n// TODO(wittjosiah): Is there a way to do this as a generic?\nexport const unwrapOptional = (property: SchemaAST.PropertySignature) => {\n  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {\n    return property;\n  }\n\n  return property.type.types[0];\n};\n\n/**\n * @see JSONSchemaAnnotationId\n * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.\n */\n// TODO(burdon): Required type.\nexport const makeTypeJsonSchemaAnnotation = (options: {\n  identifier?: string;\n  kind: EntityKind;\n  typename: string;\n  version: string;\n  relationSource?: string;\n  relationTarget?: string;\n}) => {\n  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');\n  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');\n\n  const obj: Record<string, unknown> = {\n    $id: options.identifier ?? DXN.make(options.typename, options.version),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  };\n  if (options.kind === EntityKind.Relation) {\n    obj.relationSource = { $ref: options.relationSource };\n    obj.relationTarget = { $ref: options.relationTarget };\n  }\n\n  return obj;\n};\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAYjB,IAAMC,SAAS;AAOf,IAAMC,eAAe;AAQrB,IAAMC,iBAAiB;AASvB,IAAMC,uBAAuB;AAQ7B,IAAMC,sBAAsB,CAACC,UAAAA;AAClC,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAAkEF,oBAAAA;AAC5E;AAOO,IAAMI,gBAAgB,CAACF,UAAAA;AAC5B,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAA0CJ,YAAAA;AACpD;AAMO,IAAMO,qBAAqB,CAACH,UAAAA;AACjC,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAAoCL,MAAAA;AAC9C;AAWO,IAAMS,oBAAoB;AAY1B,IAAMC,2BAA2B;AAgBjC,IAAKC,aAAAA,0BAAAA,aAAAA;;;;SAAAA;;AAML,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC9HlC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAgCb,IAAMC,yBAAyB,CAAIC,OAAAA;AACxC,SAAO;IACLC,KAAK,CAACC,WAAqBC,wBAAcD,OAAOE,KAAKJ,EAAAA;IACrDK,YAAY,CAACD,QAAkBD,wBAAcC,KAAKJ,EAAAA;IAClDM,KACE,CAACC,UACD,CAA8BL,WAC5BA,OAAOM,YAAY;MAAE,CAACR,EAAAA,GAAKO;IAAM,CAAA;EACvC;AACF;AAMO,IAAME,iBAAiB,CAACC,aAAAA;AAC7B,MAAI,CAACA,SAASC,cAAc,CAAWC,kBAAQF,SAASG,IAAI,GAAG;AAC7D,WAAOH;EACT;AAEA,SAAOA,SAASG,KAAKC,MAAM,CAAA;AAC7B;AAOO,IAAMC,+BAA+B,CAACC,YAAAA;AAQ3CC,iBAAe,CAAC,CAACD,QAAQE,oBAAoBF,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AACpFJ,iBAAe,CAAC,CAACD,QAAQM,oBAAoBN,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AAEpF,QAAME,MAA+B;IACnCC,KAAKR,QAAQS,cAAcC,IAAIC,KAAKX,QAAQY,UAAUZ,QAAQa,OAAO;IACrEC,YAAYd,QAAQG;IACpBU,SAASb,QAAQa;IACjBD,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEa,MAAMf,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAES,MAAMf,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
+  "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "StaticTypeSchemaSlot", "getStaticTypeSchema", "value", "undefined", "getSchemaKind", "getEntityKindBrand", "InstancePhantomId", "UnknownTypeSchemaBrandId", "EntityKind", "EntityKindSchema", "Enums", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "SchemaAST", "assertArgument", "DXN", "createAnnotationHelper", "id", "get", "schema", "getAnnotation", "ast", "getFromAst", "set", "value", "annotations", "unwrapOptional", "property", "isOptional", "isUnion", "type", "types", "makeTypeJsonSchemaAnnotation", "options", "assertArgument", "relationSource", "kind", "EntityKind", "Relation", "relationTarget", "obj", "$id", "identifier", "DXN", "make", "typename", "version", "entityKind", "$ref"]
+}

package/dist/lib/neutral/{chunk-DLPC7DHQ.mjs → chunk-EZ4XJFHJ.mjs}

@@ -1,13 +1,13 @@
-import {
-  object
-} from "./chunk-TQT6WTIJ.mjs";
 import {
   make
-} from "./chunk-EBUAT5ID.mjs";
+} from "./chunk-FFCN66OF.mjs";
+import {
+  makeObject
+} from "./chunk-UQAMAXDU.mjs";
 import {
   LabelAnnotation,
   SystemTypeAnnotation
-} from "./chunk-RIMHNJ3E.mjs";
+} from "./chunk-KHRAQDYX.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -22,15 +22,13 @@ __export(Tag_exports, {
   sortTags: () => sortTags
 });
 import * as Schema from "effect/Schema";
+import { DXN } from "@dxos/keys";
 var Tag = Schema.Struct({
   label: Schema.String,
   hue: Schema.optional(Schema.String)
-}).pipe(object({
-  typename: "dxos.org/type/Tag",
-  version: "0.1.0"
-}), LabelAnnotation.set([
+}).pipe(LabelAnnotation.set([
   "label"
-]), SystemTypeAnnotation.set(true));
+]), SystemTypeAnnotation.set(true), makeObject(DXN.make("org.dxos.type.tag", "0.1.0")));
 var make2 = (props) => make(Tag, props);
 var sortTags = ({ label: a }, { label: b }) => a.localeCompare(b);
 var createTagList = (tags) => Object.entries(tags).map(([id, tag]) => ({
@@ -53,4 +51,4 @@ export {
   findTagByLabel,
   Tag_exports
 };
-//# sourceMappingURL=chunk-DLPC7DHQ.mjs.map
+//# sourceMappingURL=chunk-EZ4XJFHJ.mjs.map

package/dist/lib/neutral/chunk-EZ4XJFHJ.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Tag.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { DXN } from '@dxos/keys';\n\nimport * as internal 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  internal.LabelAnnotation.set(['label']),\n  internal.SystemTypeAnnotation.set(true),\n  Type.makeObject(DXN.make('org.dxos.type.tag', '0.1.0')),\n);\n\nexport type Tag = Type.InstanceType<typeof Tag>;\n\nexport const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);\n\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;;AAMA,YAAYC,YAAY;AAExB,SAASC,WAAW;AAMb,IAAMC,MAAaC,cAAO;EAC/BC,OAAcC;EACdC,KAAYC,gBAAgBF,aAAM;AACpC,CAAA,EAAGG,KACQC,gBAAgBC,IAAI;EAAC;CAAQ,GAC7BC,qBAAqBD,IAAI,IAAA,GAC7BE,WAAWC,IAAIC,KAAK,qBAAqB,OAAA,CAAA,CAAA;AAKzC,IAAMA,QAAO,CAACC,UAAyCD,KAAKZ,KAAKa,KAAAA;AAIjE,IAAMC,WAAW,CAAC,EAAEZ,OAAOa,EAAC,GAAS,EAAEb,OAAOc,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,IAAItB,MAAM6B,YAAW,MAAOJ,KAAKI,YAAW,CAAA;AACxG,SAAOH,QAAQ;IAAE,GAAGA,MAAM,CAAA;IAAIL,IAAIK,MAAM,CAAA;EAAG,IAAII;AACjD;",
+  "names": ["make", "Schema", "DXN", "Tag", "Struct", "label", "String", "hue", "optional", "pipe", "LabelAnnotation", "set", "SystemTypeAnnotation", "makeObject", "DXN", "make", "props", "sortTags", "a", "b", "localeCompare", "createTagList", "tags", "Object", "entries", "map", "id", "tag", "sort", "findTagByLabel", "name", "entry", "find", "_", "toLowerCase", "undefined"]
+}

package/dist/lib/neutral/{chunk-ZAHWXGK4.mjs → chunk-F625JEZB.mjs}

@@ -1,9 +1,13 @@
 import {
   isRef
-} from "./chunk-K5K3Z62A.mjs";
+} from "./chunk-4SYHDOQA.mjs";
 import {
-  getTypeDXNFromSpecifier
-} from "./chunk-RIMHNJ3E.mjs";
+  prettyFilter
+} from "./chunk-LNZIPZX6.mjs";
+import {
+  getTypeURIFromSpecifier,
+  getUri
+} from "./chunk-ZII2BGPM.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -13,7 +17,9 @@ var Filter_exports = {};
 __export(Filter_exports, {
   and: () => and,
   between: () => between,
+  childOf: () => childOf,
   contains: () => contains,
+  created: () => created,
   eq: () => eq,
   everything: () => everything,
   foreignKeys: () => foreignKeys,
@@ -23,26 +29,30 @@ __export(Filter_exports, {
   id: () => id,
   in: () => in$,
   is: () => is,
+  key: () => key,
   lt: () => lt,
   lte: () => lte,
   neq: () => neq,
   not: () => not,
   nothing: () => nothing,
   or: () => or,
+  pretty: () => pretty,
   props: () => props,
   tag: () => tag,
   text: () => text,
   type: () => type,
-  typeDXN: () => typeDXN,
-  typename: () => typename
+  typeURI: () => typeURI,
+  typename: () => typename,
+  updated: () => updated
 });
 import * as Match from "effect/Match";
 import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
 import { assertArgument } from "@dxos/invariant";
-import { DXN, ObjectId } from "@dxos/keys";
+import { DXN, EchoURI, ObjectId } from "@dxos/keys";
 var FilterClass = class _FilterClass {
   ast;
-  static variance = {};
+  static "variance" = {};
   constructor(ast) {
     this.ast = ast;
   }
@@ -83,11 +93,22 @@ var id = (...ids) => {
     props: {}
   });
 };
-var type = (schema, props2) => {
-  const dxn = getTypeDXNFromSpecifier(schema);
+var type = (input, props2) => {
+  if (Schema.isSchema(input) && SchemaAST.isUnion(input.ast)) {
+    const typenames = input.ast.types.map((t) => getTypeURIFromSpecifier(Schema.make(t)));
+    return new FilterClass({
+      type: "or",
+      filters: typenames.map((typename2) => ({
+        type: "object",
+        typename: typename2,
+        props: {}
+      }))
+    });
+  }
+  const uri = getTypeURIFromSpecifier(input);
   return new FilterClass({
     type: "object",
-    typename: dxn.toString(),
+    typename: uri,
     ...propsFilterToAst(props2 ?? {})
   });
 };
@@ -95,14 +116,14 @@ var typename = (typename2) => {
   assertArgument(!typename2.startsWith("dxn:"), "typename", "Typename must no be qualified");
   return new FilterClass({
     type: "object",
-    typename: DXN.fromTypename(typename2).toString(),
+    typename: DXN.make(typename2),
     props: {}
   });
 };
-var typeDXN = (dxn) => {
+var typeURI = (uri) => {
   return new FilterClass({
     type: "object",
-    typename: dxn.toString(),
+    typename: uri,
     props: {}
   });
 };
@@ -112,6 +133,15 @@ var tag = (tag2) => {
     tag: tag2
   });
 };
+var key = (key2, options) => {
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    props: {},
+    metaKey: key2,
+    metaVersion: options?.version
+  });
+};
 var props = (props2) => {
   return new FilterClass({
     type: "object",
@@ -127,10 +157,10 @@ var text = (text2, options) => {
   });
 };
 var foreignKeys = (schema, keys) => {
-  const dxn = getTypeDXNFromSpecifier(schema);
+  const uri = getTypeURIFromSpecifier(schema);
   return new FilterClass({
     type: "object",
-    typename: dxn.toString(),
+    typename: uri,
     props: {},
     foreignKeys: keys
   });
@@ -199,6 +229,48 @@ var between = (from, to) => {
     to
   });
 };
+var _toUnixMs = (date) => typeof date === "number" ? date : date.getTime();
+var _timeRangeFilter = (field, range) => {
+  const filters = [];
+  if (range.after != null) {
+    filters.push(new FilterClass({
+      type: "timestamp",
+      field,
+      operator: "gte",
+      value: _toUnixMs(range.after)
+    }));
+  }
+  if (range.before != null) {
+    filters.push(new FilterClass({
+      type: "timestamp",
+      field,
+      operator: "lte",
+      value: _toUnixMs(range.before)
+    }));
+  }
+  if (filters.length === 0) {
+    return everything();
+  }
+  return filters.length === 1 ? filters[0] : and(...filters);
+};
+var updated = (range) => _timeRangeFilter("updatedAt", range);
+var created = (range) => _timeRangeFilter("createdAt", range);
+var childOf = (parents, options) => {
+  const items = Array.isArray(parents) ? parents : [
+    parents
+  ];
+  const dxns = items.map((item) => {
+    if (isRef(item)) {
+      return EchoURI.parse(item.uri);
+    }
+    return getUri(item);
+  });
+  return new FilterClass({
+    type: "child-of",
+    parents: dxns,
+    transitive: options?.transitive ?? true
+  });
+};
 var not = (filter) => {
   return new FilterClass({
     type: "not",
@@ -243,8 +315,8 @@ var processPredicate = (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,
+      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key2, value2]) => [
+        key2,
         processPredicate(value2)
       ]));
       return {
@@ -256,6 +328,7 @@ var processPredicate = (predicate) => {
     Match.orElse((value2) => eq(value2).ast)
   );
 };
+var pretty = (filter) => prettyFilter(filter.ast);
 
 export {
   is,
@@ -265,8 +338,9 @@ export {
   id,
   type,
   typename,
-  typeDXN,
+  typeURI,
   tag,
+  key,
   props,
   text,
   foreignKeys,
@@ -279,9 +353,13 @@ export {
   in$,
   contains,
   between,
+  updated,
+  created,
+  childOf,
   not,
   and,
   or,
+  pretty,
   Filter_exports
 };
-//# sourceMappingURL=chunk-ZAHWXGK4.mjs.map
+//# sourceMappingURL=chunk-F625JEZB.mjs.map

package/dist/lib/neutral/chunk-F625JEZB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Filter.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, EchoURI, ObjectId, type URI } from '@dxos/keys';\n\nimport * as internal from './internal';\nimport type * as Obj from './Obj';\nimport * as Ref from './Ref';\n// eslint-disable-next-line @dxos/rules/import-as-namespace\nimport type * as Type$ from './Type';\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Filter': { value: Types.Covariant<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 *\n * Accepts a `Type.Type` entity (the value produced by `Type.makeObject` /\n * `Type.makeRelation`), a `Schema.Union` of such entities (for filtering across a\n * union of ECHO types), or a non-qualified typename string.\n */\nexport const type: {\n  <T extends Type$.AnyEntity>(type: T, props?: Props<Type$.InstanceType<T>>): Filter<Type$.InstanceType<T>>;\n  // Schema-side overload restricted to the well-known unknown schemas and to\n  // `Schema.Union(...)` of `Type.Type` entities (for filtering across a union\n  // of ECHO types). Other raw schemas are rejected.\n  <S extends internal.UnknownTypeSchema<any, any>>(\n    schema: S,\n    props?: Props<Schema.Schema.Type<S>>,\n  ): Filter<Schema.Schema.Type<S>>;\n  <S extends Schema.Union<readonly Schema.Schema.AnyNoContext[]>>(\n    union: S,\n    props?: Props<Schema.Schema.Type<S>>,\n  ): Filter<Schema.Schema.Type<S>>;\n  (schema: string, props?: Props<unknown>): Filter<any>;\n  // Passthrough overload for callers that hold a `Type.AnyEntity | string` union\n  // (e.g. Query.type / Query.sourceOf / Query.targetOf impls). Listed last so the\n  // typed overloads above still win for monomorphic inputs.\n  (input: Type$.AnyEntity | string, props?: Props<unknown>): Filter<unknown>;\n} = (input: Type$.AnyEntity | Schema.Schema.AnyNoContext | string, props?: Props<unknown>): any => {\n  if (Schema.isSchema(input) && SchemaAST.isUnion(input.ast)) {\n    const typenames = input.ast.types.map((t) => internal.getTypeURIFromSpecifier(Schema.make(t)));\n    return new FilterClass({\n      type: 'or',\n      filters: typenames.map((typename) => ({\n        type: 'object',\n        typename,\n        props: {},\n      })),\n    });\n  }\n\n  const uri = internal.getTypeURIFromSpecifier(input);\n  return new FilterClass({\n    type: 'object',\n    typename: uri,\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.make(typename),\n    props: {},\n  });\n};\n\n/**\n * Filter by fully qualified type URI — either a typename DXN (for static schemas) or\n * a schema-as-object EchoURI (for stored dynamic schemas). See `getSchemaURI`.\n */\nexport const typeURI = (uri: URI.URI): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: uri,\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 * Options for {@link key} filter.\n */\nexport type KeyFilterOptions = {\n  /**\n   * Optional semver range expression (e.g. `^1.2.3`, `~2.0.0`, `>=1.0.0 <2.0.0`).\n   * Matches the object's meta `version` field against the range.\n   * If omitted, matches any version (including objects with no version).\n   */\n  version?: string;\n};\n\n/**\n * Filter by registry key stored in object meta.\n *\n * @example\n * ```ts\n * Filter.key('org.example.type.foo');\n * Filter.key('org.example.type.foo', { version: '^1.2.3' });\n * ```\n */\nexport const key = (key: string, options?: KeyFilterOptions): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n    metaKey: key,\n    metaVersion: options?.version,\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 Type$.AnyEntity | string>(\n  schema: S,\n  keys: ForeignKey[],\n): Filter<S extends Type$.AnyEntity ? Type$.InstanceType<S> : unknown> => {\n  const uri = internal.getTypeURIFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: uri,\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> => {\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<T> => {\n  return new FilterClass({\n    type: 'range',\n    from,\n    to,\n  });\n};\n\ntype TimeRange = { after?: Date | number; before?: Date | number };\n\nconst _toUnixMs = (date: Date | number): number => (typeof date === 'number' ? date : date.getTime());\n\nconst _timeRangeFilter = (field: 'updatedAt' | 'createdAt', range: TimeRange): Any => {\n  const filters: Any[] = [];\n  if (range.after != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'gte', value: _toUnixMs(range.after) }));\n  }\n  if (range.before != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'lte', value: _toUnixMs(range.before) }));\n  }\n  if (filters.length === 0) {\n    return everything();\n  }\n  return filters.length === 1 ? filters[0] : and(...filters);\n};\n\n/**\n * Filter objects by updatedAt timestamp.\n */\nexport const updated = (range: TimeRange): Any => _timeRangeFilter('updatedAt', range);\n\n/**\n * Filter objects by createdAt timestamp.\n */\nexport const created = (range: TimeRange): Any => _timeRangeFilter('createdAt', range);\n\nexport type ChildOfOptions = {\n  /** Whether to match transitively (grandchildren, etc.). Defaults to true. */\n  transitive?: boolean;\n};\n\n/**\n * Filter objects that are children of the specified parent(s).\n * Accepts ECHO objects, Refs, or arrays of either.\n * Refs are resolved to DXNs without loading; objects use {@link Obj.getURI}.\n * With transitive=true (default), also matches grandchildren and beyond.\n */\nexport const childOf = (\n  parents: Obj.Unknown | Ref.Unknown | readonly (Obj.Unknown | Ref.Unknown)[],\n  options?: ChildOfOptions,\n): Any => {\n  const items = Array.isArray(parents) ? parents : [parents];\n  const dxns = items.map((item) => {\n    if (Ref.isRef(item)) {\n      return EchoURI.parse(item.uri);\n    }\n    return internal.getUri(item);\n  });\n  return new FilterClass({\n    type: 'child-of',\n    parents: dxns,\n    transitive: options?.transitive ?? true,\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\n/**\n * Returns a human-readable string representation of a Filter AST.\n */\nexport const pretty = (filter: Any): string => internal.prettyFilter(filter.ast);\n"],
+  "mappings": "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",
+  "names": ["Match", "Schema", "SchemaAST", "assertArgument", "DXN", "EchoURI", "ObjectId", "FilterClass", "ast", "variance", "is", "value", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "id", "ids", "assertArgument", "every", "ObjectId", "isValid", "length", "input", "isSchema", "isUnion", "typenames", "types", "map", "t", "getTypeURIFromSpecifier", "make", "filters", "uri", "propsFilterToAst", "startsWith", "DXN", "typeURI", "tag", "key", "options", "metaKey", "metaVersion", "version", "text", "searchKind", "foreignKeys", "schema", "keys", "eq", "isRef", "TypeError", "operator", "noInline", "encode", "neq", "gt", "gte", "lt", "lte", "in$", "values", "contains", "value", "FilterClass", "type", "between", "from", "to", "_toUnixMs", "date", "getTime", "_timeRangeFilter", "field", "range", "filters", "after", "push", "operator", "before", "length", "everything", "and", "updated", "created", "childOf", "parents", "options", "items", "Array", "isArray", "dxns", "map", "item", "isRef", "EchoURI", "parse", "uri", "getUri", "transitive", "not", "filter", "ast", "f", "or", "propsFilterToAst", "predicates", "idFilter", "assertArgument", "id", "Schema", "ObjectId", "pipe", "validateSync", "props", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "is", "_predicate", "Error", "nestedProps", "key", "typename", "orElse", "eq", "pretty", "prettyFilter"]
+}