@dxos/echo 0.8.4-main.84f28bd → 0.8.4-main.937b3ca

package/dist/lib/node-esm/chunk-DMR7OAFK.mjs

@@ -0,0 +1,57 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  object
+} from "./chunk-NRN3ZW2T.mjs";
+import {
+  make
+} from "./chunk-ILMLLM4R.mjs";
+import {
+  LabelAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-YOLH5KS4.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.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(object({
+  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-DMR7OAFK.mjs.map

package/dist/lib/node-esm/chunk-DMR7OAFK.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.object({\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,OAAO;EACVC,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", "object", "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/node-esm/chunk-FWTSPIFF.mjs

@@ -0,0 +1,133 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  isInstanceOf
+} from "./chunk-YOLH5KS4.mjs";
+import {
+  ObjectNotFoundError
+} from "./chunk-YQ2NWGL5.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Database.ts
+var Database_exports = {};
+__export(Database_exports, {
+  Database: () => Database,
+  Service: () => Service,
+  TypeId: () => TypeId,
+  isDatabase: () => isDatabase
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { promiseWithCauseCapture } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
+var TypeId = Symbol.for("@dxos/echo/Database");
+var isDatabase = (obj) => {
+  return obj ? typeof obj === "object" && TypeId in obj && obj[TypeId] === TypeId : false;
+};
+var Database = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));
+var Service = class _Service extends Context.Tag("@dxos/echo/Database/Service")() {
+  static notAvailable = Layer.succeed(_Service, {
+    get db() {
+      throw new Error("Database not available");
+    }
+  });
+  static make = (db) => {
+    return {
+      get db() {
+        return db;
+      }
+    };
+  };
+  static layer = (db) => {
+    return Layer.succeed(_Service, _Service.make(db));
+  };
+  // TODO(dmaretskyi): Move all those to the top-level API of Database.ts module.
+  /**
+  * Returns the space ID of the database.
+  */
+  static spaceId = Effect.gen(function* () {
+    const { db } = yield* _Service;
+    return db.spaceId;
+  });
+  /**
+  * Resolves an object by its DXN.
+  */
+  static resolve = (ref, schema) => Effect.gen(function* () {
+    const { db } = yield* _Service;
+    const dxn = ref instanceof DXN ? ref : ref.dxn;
+    const object = yield* promiseWithCauseCapture(() => db.graph.createRefResolver({
+      context: {
+        space: db.spaceId
+      }
+    }).resolve(dxn));
+    if (!object) {
+      return yield* Effect.fail(new ObjectNotFoundError(dxn));
+    }
+    invariant(!schema || isInstanceOf(schema, object), "Object type mismatch.", {
+      F: __dxlog_file,
+      L: 254,
+      S: this,
+      A: [
+        "!schema || isInstanceOf(schema, object)",
+        "'Object type mismatch.'"
+      ]
+    });
+    return object;
+  });
+  /**
+  * Loads an object reference.
+  */
+  static load = Effect.fn(function* (ref) {
+    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
+    if (!object) {
+      return yield* Effect.fail(new ObjectNotFoundError(ref.dxn));
+    }
+    return object;
+  });
+  /**
+  * Loads an object reference option.
+  */
+  // TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.
+  static loadOption = Effect.fn(function* (ref) {
+    const object = yield* _Service.load(ref).pipe(Effect.catchTag("ObjectNotFoundError", () => Effect.succeed(void 0)));
+    return Option.fromNullable(object);
+  });
+  /**
+  * @link EchoDatabase.add
+  */
+  static add = (obj) => _Service.pipe(Effect.map(({ db }) => db.add(obj)));
+  /**
+  * @link EchoDatabase.remove
+  */
+  static remove = (obj) => _Service.pipe(Effect.map(({ db }) => db.remove(obj)));
+  /**
+  * @link EchoDatabase.flush
+  */
+  static flush = (opts) => _Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));
+  /**
+  * Creates a `QueryResult` object that can be subscribed to.
+  */
+  static query = (queryOrFilter) => _Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Service.query"));
+  /**
+  * Executes the query once and returns the results.
+  */
+  static runQuery = (queryOrFilter) => _Service.query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
+  // TODO(dmaretskyi): Change API to `yield* Service.querySchema(...).first` and `yield* Service.querySchema(...).schema`.
+  static schemaQuery = (query) => _Service.pipe(Effect.map(({ db }) => db.schemaRegistry.query(query)), Effect.withSpan("Service.schemaQuery"));
+  static runSchemaQuery = (query) => _Service.schemaQuery(query).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
+};
+
+export {
+  TypeId,
+  isDatabase,
+  Database,
+  Service,
+  Database_exports
+};
+//# sourceMappingURL=chunk-FWTSPIFF.mjs.map

package/dist/lib/node-esm/chunk-FWTSPIFF.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Database.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { type QueryAST } from '@dxos/echo-protocol';\nimport { promiseWithCauseCapture } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { DXN, type PublicKey, type SpaceId } from '@dxos/keys';\nimport { type QueryOptions as QueryOptionsProto } from '@dxos/protocols/proto/dxos/echo/filter';\n\nimport type * as Entity from './Entity';\nimport * as Err from './Err';\nimport type * as Filter from './Filter';\nimport type * as Hypergraph from './Hypergraph';\nimport { isInstanceOf } from './internal/annotations';\nimport type { Ref } from './internal/ref/ref';\nimport { type AnyProperties } from './internal/types';\nimport type * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport type * as SchemaRegistry from './SchemaRegistry';\nimport type * as Type from './Type';\n\n/**\n * @deprecated Use `QueryAST.QueryOptions` instead.\n */\nexport type QueryOptions = {\n  /**\n   * @deprecated Use `spaceIds` instead.\n   */\n  spaces?: PublicKey[];\n\n  /**\n   * Query only in specific spaces.\n   */\n  // TODO(dmaretskyi): Change this to SpaceId.\n  spaceIds?: string[];\n\n  /**\n   * Return only the first `limit` results.\n   */\n  limit?: number;\n\n  /**\n   * Query only local spaces, or remote on agent.\n   * @default `QueryOptions.DataLocation.LOCAL`\n   *\n   * Options:\n   *   - proto3_optional = true\n   */\n  // TODO(burdon): Remove?\n  dataLocation?: QueryOptionsProto.DataLocation;\n};\n\n/**\n * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\n// TODO(dmaretskyi): Remove query options.\nexport interface QueryFn {\n  <Q extends Query.Any>(\n    query: Q,\n    options?: (QueryAST.QueryOptions & QueryOptions) | undefined,\n  ): QueryResult.QueryResult<Query.Type<Q>>;\n\n  <F extends Filter.Any>(\n    filter: F,\n    options?: (QueryAST.QueryOptions & QueryOptions) | undefined,\n  ): QueryResult.QueryResult<Filter.Type<F>>;\n}\n\n/**\n * Common interface for Database and Queue.\n */\nexport interface Queryable {\n  query: QueryFn;\n}\n\nexport type GetObjectByIdOptions = {\n  deleted?: boolean;\n};\n\nexport type ObjectPlacement = 'root-doc' | 'linked-doc';\n\nexport type AddOptions = {\n  /**\n   * Where to place the object in the Automerge document tree.\n   * Root document is always loaded with the space.\n   * Linked documents are loaded lazily.\n   * Placing large number of objects in the root document may slow down the initial load.\n   *\n   * @default 'linked-doc'\n   */\n  placeIn?: ObjectPlacement;\n};\n\nexport type FlushOptions = {\n  /**\n   * Write any pending changes to disk.\n   * @default true\n   */\n  disk?: boolean;\n\n  /**\n   * Wait for pending index updates.\n   * @default false\n   */\n  indexes?: boolean;\n\n  /**\n   * Flush pending updates to objects and queries.\n   * @default false\n   */\n  updates?: boolean;\n};\n\n/**\n * Identifier denoting an ECHO Database.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Database');\nexport type TypeId = typeof TypeId;\n\n/**\n * ECHO Database interface.\n */\nexport interface Database extends Queryable {\n  readonly [TypeId]: TypeId;\n\n  get spaceId(): SpaceId;\n\n  // TODO(burdon): Can we move this into graph?\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\n\n  get graph(): Hypergraph.Hypergraph;\n\n  toJSON(): object;\n\n  /**\n   * Return object by local ID.\n   */\n  getObjectById<T extends Obj.Unknown = Obj.Obj<AnyProperties>>(id: string, opts?: GetObjectByIdOptions): T | undefined;\n\n  /**\n   * Query objects.\n   */\n  query: 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<T>;\n\n  /**\n   * Adds object to the database.\n   */\n  add<T extends Entity.Unknown = Entity.Unknown>(obj: T, opts?: AddOptions): T;\n\n  /**\n   * Removes object from the database.\n   */\n  // TODO(burdon): Return true if removed (currently throws if not present).\n  remove(obj: Entity.Unknown): void;\n\n  /**\n   * Wait for all pending changes to be saved to disk.\n   * Optionaly waits for changes to be propagated to indexes and event handlers.\n   */\n  flush(opts?: FlushOptions): Promise<void>;\n}\n\nexport const isDatabase = (obj: unknown): obj is Database => {\n  return obj ? typeof obj === 'object' && TypeId in obj && obj[TypeId] === TypeId : false;\n};\n\nexport const Database: Schema.Schema<Database> = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));\n\nexport class Service extends Context.Tag('@dxos/echo/Database/Service')<\n  Service,\n  {\n    readonly db: Database;\n  }\n>() {\n  static notAvailable = Layer.succeed(Service, {\n    get db(): Database {\n      throw new Error('Database not available');\n    },\n  });\n\n  static make = (db: Database): Context.Tag.Service<Service> => {\n    return {\n      get db() {\n        return db;\n      },\n    };\n  };\n\n  static layer = (db: Database): Layer.Layer<Service> => {\n    return Layer.succeed(Service, Service.make(db));\n  };\n\n  // TODO(dmaretskyi): Move all those to the top-level API of Database.ts module.\n\n  /**\n   * Returns the space ID of the database.\n   */\n  static spaceId = Effect.gen(function* () {\n    const { db } = yield* Service;\n    return db.spaceId;\n  });\n\n  /**\n   * Resolves an object by its DXN.\n   */\n  static resolve: {\n    // No type check.\n    (ref: DXN | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;\n    // Check matches schema.\n    <S extends Type.Entity.Any>(\n      ref: DXN | Ref<any>,\n      schema: S,\n    ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;\n  } = (<S extends Type.Entity.Any>(\n    ref: DXN | Ref<any>,\n    schema?: S,\n  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service> =>\n    Effect.gen(function* () {\n      const { db } = yield* Service;\n      const dxn = ref instanceof DXN ? ref : ref.dxn;\n      const object = yield* promiseWithCauseCapture(() =>\n        db.graph\n          .createRefResolver({\n            context: {\n              space: db.spaceId,\n            },\n          })\n          .resolve(dxn),\n      );\n\n      if (!object) {\n        return yield* Effect.fail(new Err.ObjectNotFoundError(dxn));\n      }\n      invariant(!schema || isInstanceOf(schema, object), 'Object type mismatch.');\n      return object as any;\n    })) as any;\n\n  /**\n   * Loads an object reference.\n   */\n  static load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.ObjectNotFoundError, never> = Effect.fn(function* (ref) {\n    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());\n    if (!object) {\n      return yield* Effect.fail(new Err.ObjectNotFoundError(ref.dxn));\n    }\n    return object;\n  });\n\n  /**\n   * Loads an object reference option.\n   */\n  // TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.\n  static loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(function* (ref) {\n    const object = yield* Service.load(ref).pipe(\n      Effect.catchTag('ObjectNotFoundError', () => Effect.succeed(undefined)),\n    );\n\n    return Option.fromNullable(object);\n  });\n\n  /**\n   * @link EchoDatabase.add\n   */\n  static add = <T extends Entity.Unknown>(obj: T): Effect.Effect<T, never, Service> =>\n    Service.pipe(Effect.map(({ db }) => db.add(obj)));\n\n  /**\n   * @link EchoDatabase.remove\n   */\n  static remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>\n    Service.pipe(Effect.map(({ db }) => db.remove(obj)));\n\n  /**\n   * @link EchoDatabase.flush\n   */\n  static flush = (opts?: FlushOptions) =>\n    Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));\n\n  /**\n   * Creates a `QueryResult` object that can be subscribed to.\n   */\n  static query: {\n    <Q extends Query.Any>(query: Q): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, Service>;\n    <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, Service>;\n  } = (queryOrFilter: Query.Any | Filter.Any) =>\n    Service.pipe(\n      Effect.map(({ db }) => db.query(queryOrFilter as any) as QueryResult.QueryResult<any>),\n      Effect.withSpan('Service.query'),\n    );\n\n  /**\n   * Executes the query once and returns the results.\n   */\n  static runQuery: {\n    <Q extends Query.Any>(query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n    <F extends Filter.Any>(filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n  } = (queryOrFilter: Query.Any | Filter.Any) =>\n    Service.query(queryOrFilter as any).pipe(\n      Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n    );\n\n  // TODO(dmaretskyi): Change API to `yield* Service.querySchema(...).first` and `yield* Service.querySchema(...).schema`.\n\n  static schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n    query?: Q & SchemaRegistry.Query,\n  ): Effect.Effect<QueryResult.QueryResult<SchemaRegistry.ExtractQueryResult<Q>>, never, Service> =>\n    Service.pipe(\n      Effect.map(({ db }) => db.schemaRegistry.query(query)),\n      Effect.withSpan('Service.schemaQuery'),\n    );\n\n  static runSchemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n    query?: Q & SchemaRegistry.Query,\n  ): Effect.Effect<SchemaRegistry.ExtractQueryResult<Q>[], never, Service> =>\n    Service.schemaQuery(query).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));\n}\n"],
+  "mappings": ";;;;;;;;;;;;AAAA;;;;;;;AAIA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,YAAY;AAIxB,SAASC,+BAA+B;AACxC,SAASC,iBAAiB;AAC1B,SAASC,WAAyC;;AAgH3C,IAAMC,SAASC,OAAOC,IAAI,qBAAA;AAwD1B,IAAMC,aAAa,CAACC,QAAAA;AACzB,SAAOA,MAAM,OAAOA,QAAQ,YAAYJ,UAAUI,OAAOA,IAAIJ,MAAAA,MAAYA,SAAS;AACpF;AAEO,IAAMK,WAA2CC,WAAIC,KAAYC,cAAO,CAACC,UAAUN,WAAWM,KAAAA,CAAAA,CAAAA;AAE9F,IAAMC,UAAN,MAAMA,iBAAwBC,YAAI,6BAAA,EAAA,EAAA;EAMvC,OAAOC,eAAqBC,cAAQH,UAAS;IAC3C,IAAII,KAAe;AACjB,YAAM,IAAIC,MAAM,wBAAA;IAClB;EACF,CAAA;EAEA,OAAOC,OAAO,CAACF,OAAAA;AACb,WAAO;MACL,IAAIA,KAAK;AACP,eAAOA;MACT;IACF;EACF;EAEA,OAAOG,QAAQ,CAACH,OAAAA;AACd,WAAaD,cAAQH,UAASA,SAAQM,KAAKF,EAAAA,CAAAA;EAC7C;;;;;EAOA,OAAOI,UAAiBC,WAAI,aAAA;AAC1B,UAAM,EAAEL,GAAE,IAAK,OAAOJ;AACtB,WAAOI,GAAGI;EACZ,CAAA;;;;EAKA,OAAOE,UAQF,CACHC,KACAC,WAEOH,WAAI,aAAA;AACT,UAAM,EAAEL,GAAE,IAAK,OAAOJ;AACtB,UAAMa,MAAMF,eAAeG,MAAMH,MAAMA,IAAIE;AAC3C,UAAME,SAAS,OAAOC,wBAAwB,MAC5CZ,GAAGa,MACAC,kBAAkB;MACjBC,SAAS;QACPpB,OAAOK,GAAGI;MACZ;IACF,CAAA,EACCE,QAAQG,GAAAA,CAAAA;AAGb,QAAI,CAACE,QAAQ;AACX,aAAO,OAAcK,YAAK,IAAQC,oBAAoBR,GAAAA,CAAAA;IACxD;AACAS,cAAU,CAACV,UAAUW,aAAaX,QAAQG,MAAAA,GAAS,yBAAA;;;;;;;;;AACnD,WAAOA;EACT,CAAA;;;;EAKF,OAAOS,OAAoFC,UAAG,WAAWd,KAAG;AAC1G,UAAMI,SAAS,OAAOC,wBAAwB,MAAML,IAAIe,QAAO,CAAA;AAC/D,QAAI,CAACX,QAAQ;AACX,aAAO,OAAcK,YAAK,IAAQC,oBAAoBV,IAAIE,GAAG,CAAA;IAC/D;AACA,WAAOE;EACT,CAAA;;;;;EAMA,OAAOY,aAAuFF,UAAG,WAAWd,KAAG;AAC7G,UAAMI,SAAS,OAAOf,SAAQwB,KAAKb,GAAAA,EAAKd,KAC/B+B,gBAAS,uBAAuB,MAAazB,eAAQ0B,MAAAA,CAAAA,CAAAA;AAG9D,WAAcC,oBAAaf,MAAAA;EAC7B,CAAA;;;;EAKA,OAAOgB,MAAM,CAA2BrC,QACtCM,SAAQH,KAAYmC,WAAI,CAAC,EAAE5B,GAAE,MAAOA,GAAG2B,IAAIrC,GAAAA,CAAAA,CAAAA;;;;EAK7C,OAAOuC,SAAS,CAA2BvC,QACzCM,SAAQH,KAAYmC,WAAI,CAAC,EAAE5B,GAAE,MAAOA,GAAG6B,OAAOvC,GAAAA,CAAAA,CAAAA;;;;EAKhD,OAAOwC,QAAQ,CAACC,SACdnC,SAAQH,KAAYuC,eAAQ,CAAC,EAAEhC,GAAE,MAAOY,wBAAwB,MAAMZ,GAAG8B,MAAMC,IAAAA,CAAAA,CAAAA,CAAAA;;;;EAKjF,OAAOE,QAGH,CAACC,kBACHtC,SAAQH,KACCmC,WAAI,CAAC,EAAE5B,GAAE,MAAOA,GAAGiC,MAAMC,aAAAA,CAAAA,GACzBC,gBAAS,eAAA,CAAA;;;;EAMpB,OAAOC,WAGH,CAACF,kBACHtC,SAAQqC,MAAMC,aAAAA,EAAsBzC,KAC3BuC,eAAQ,CAACK,gBAAgBzB,wBAAwB,MAAMyB,YAAYC,IAAG,CAAA,CAAA,CAAA;;EAKjF,OAAOC,cAAc,CACnBN,UAEArC,SAAQH,KACCmC,WAAI,CAAC,EAAE5B,GAAE,MAAOA,GAAGwC,eAAeP,MAAMA,KAAAA,CAAAA,GACxCE,gBAAS,qBAAA,CAAA;EAGpB,OAAOM,iBAAiB,CACtBR,UAEArC,SAAQ2C,YAAYN,KAAAA,EAAOxC,KAAYuC,eAAQ,CAACK,gBAAgBzB,wBAAwB,MAAMyB,YAAYC,IAAG,CAAA,CAAA,CAAA;AACjH;",
+  "names": ["Context", "Effect", "Layer", "Option", "Schema", "promiseWithCauseCapture", "invariant", "DXN", "TypeId", "Symbol", "for", "isDatabase", "obj", "Database", "Any", "pipe", "filter", "space", "Service", "Tag", "notAvailable", "succeed", "db", "Error", "make", "layer", "spaceId", "gen", "resolve", "ref", "schema", "dxn", "DXN", "object", "promiseWithCauseCapture", "graph", "createRefResolver", "context", "fail", "ObjectNotFoundError", "invariant", "isInstanceOf", "load", "fn", "tryLoad", "loadOption", "catchTag", "undefined", "fromNullable", "add", "map", "remove", "flush", "opts", "flatMap", "query", "queryOrFilter", "withSpan", "runQuery", "queryResult", "run", "schemaQuery", "schemaRegistry", "runSchemaQuery"]
+}

package/dist/lib/node-esm/chunk-HSLMI22Q.mjs

@@ -0,0 +1,11 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-HSLMI22Q.mjs.map

package/dist/lib/node-esm/chunk-HSLMI22Q.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/node-esm/chunk-ILMLLM4R.mjs

@@ -0,0 +1,204 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Kind
+} from "./chunk-ANLVLWME.mjs";
+import {
+  MetaId,
+  VersionTypeId,
+  addTag,
+  change,
+  clone,
+  compareVersions,
+  decodeVersion,
+  deleteKeys,
+  encodeVersion,
+  getDXN,
+  getDatabase,
+  getDescription,
+  getKeys,
+  getLabel,
+  getMetaChecked,
+  getSnapshot,
+  isDeleted,
+  isVersion,
+  makeObject,
+  objectFromJSON,
+  objectToJSON,
+  removeTag,
+  setDescription,
+  setLabel,
+  setValue,
+  sort,
+  sortByLabel,
+  sortByTypename,
+  subscribe,
+  version,
+  versionValid
+} from "./chunk-LT3H4JOX.mjs";
+import {
+  getSchema,
+  getTypeAnnotation,
+  getTypeDXN,
+  getTypename,
+  isInstanceOf
+} from "./chunk-YOLH5KS4.mjs";
+import {
+  KindId
+} from "./chunk-XHJRMQZD.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Obj.ts
+var Obj_exports = {};
+__export(Obj_exports, {
+  ID: () => ID,
+  Meta: () => Meta,
+  VersionTypeId: () => VersionTypeId,
+  addTag: () => addTag2,
+  change: () => change2,
+  clone: () => clone2,
+  compareVersions: () => compareVersions,
+  decodeVersion: () => decodeVersion,
+  deleteKeys: () => deleteKeys2,
+  encodeVersion: () => encodeVersion,
+  fromJSON: () => fromJSON,
+  getDXN: () => getDXN2,
+  getDatabase: () => getDatabase2,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys2,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta,
+  getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot2,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename2,
+  getValue: () => getValue,
+  instanceOf: () => instanceOf,
+  isDeleted: () => isDeleted2,
+  isObject: () => isObject,
+  isVersion: () => isVersion,
+  make: () => make,
+  removeTag: () => removeTag2,
+  setDescription: () => setDescription2,
+  setLabel: () => setLabel2,
+  setValue: () => setValue2,
+  sort: () => sort2,
+  sortByLabel: () => sortByLabel2,
+  sortByTypename: () => sortByTypename2,
+  subscribe: () => subscribe2,
+  toJSON: () => toJSON,
+  version: () => version2,
+  versionValid: () => versionValid
+});
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+import { createJsonPath, getValue as getValue$ } from "@dxos/effect";
+import { assertArgument } from "@dxos/invariant";
+import { ObjectId } from "@dxos/keys";
+import { assumeType } from "@dxos/util";
+var defaultMeta = {
+  keys: []
+};
+var make = (schema, props, meta) => {
+  assertArgument(getTypeAnnotation(schema)?.kind === Kind.Object, "schema", "Expected an object schema");
+  if (props[MetaId] != null) {
+    meta = {
+      ...structuredClone(defaultMeta),
+      ...props[MetaId]
+    };
+    delete props[MetaId];
+  }
+  const filterUndefined = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== void 0));
+  return makeObject(schema, filterUndefined, {
+    ...defaultMeta,
+    ...meta
+  });
+};
+var isObject = (obj) => {
+  assumeType(obj);
+  return typeof obj === "object" && obj !== null && obj[KindId] === Kind.Object;
+};
+var subscribe2 = (obj, callback) => {
+  return subscribe(obj, callback);
+};
+var getSnapshot2 = getSnapshot;
+var clone2 = clone;
+var change2 = (obj, callback) => {
+  change(obj, callback);
+};
+var getValue = (obj, path) => {
+  return getValue$(obj, createJsonPath(path));
+};
+var setValue2 = setValue;
+var ID = ObjectId;
+var instanceOf = (...args) => {
+  if (args.length === 1) {
+    return (entity) => isInstanceOf(args[0], entity);
+  }
+  return isInstanceOf(args[0], args[1]);
+};
+var getDXN2 = (entity) => {
+  assertArgument(!Schema.isSchema(entity), "obj", "Object should not be a schema.");
+  return getDXN(entity);
+};
+var getTypeDXN2 = getTypeDXN;
+var getSchema2 = getSchema;
+var getTypename2 = (entity) => getTypename(entity);
+var getDatabase2 = (entity) => getDatabase(entity);
+var Meta = MetaId;
+function getMeta(entity) {
+  return getMetaChecked(entity);
+}
+var getKeys2 = Function.dual(2, (entity, source) => getKeys(entity, source));
+var deleteKeys2 = (entity, source) => deleteKeys(entity, source);
+var addTag2 = (entity, tag) => addTag(entity, tag);
+var removeTag2 = (entity, tag) => removeTag(entity, tag);
+var isDeleted2 = (entity) => isDeleted(entity);
+var getLabel2 = (entity) => getLabel(entity);
+var setLabel2 = (entity, label) => setLabel(entity, label);
+var getDescription2 = (entity) => getDescription(entity);
+var setDescription2 = (entity, description) => setDescription(entity, description);
+var toJSON = (entity) => objectToJSON(entity);
+var fromJSON = objectFromJSON;
+var sortByLabel2 = sortByLabel;
+var sortByTypename2 = sortByTypename;
+var sort2 = (...comparators) => sort(...comparators);
+var version2 = (entity) => version(entity);
+
+export {
+  make,
+  isObject,
+  subscribe2 as subscribe,
+  getSnapshot2 as getSnapshot,
+  clone2 as clone,
+  change2 as change,
+  getValue,
+  setValue2 as setValue,
+  ID,
+  instanceOf,
+  getDXN2 as getDXN,
+  getTypeDXN2 as getTypeDXN,
+  getSchema2 as getSchema,
+  getTypename2 as getTypename,
+  getDatabase2 as getDatabase,
+  Meta,
+  getMeta,
+  getKeys2 as getKeys,
+  deleteKeys2 as deleteKeys,
+  addTag2 as addTag,
+  removeTag2 as removeTag,
+  isDeleted2 as isDeleted,
+  getLabel2 as getLabel,
+  setLabel2 as setLabel,
+  getDescription2 as getDescription,
+  setDescription2 as setDescription,
+  toJSON,
+  fromJSON,
+  sortByLabel2 as sortByLabel,
+  sortByTypename2 as sortByTypename,
+  sort2 as sort,
+  version2 as version,
+  Obj_exports
+};
+//# sourceMappingURL=chunk-ILMLLM4R.mjs.map

package/dist/lib/node-esm/chunk-ILMLLM4R.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 { createJsonPath, getValue as getValue$ } from '@dxos/effect';\nimport { assertArgument } from '@dxos/invariant';\nimport { type DXN, ObjectId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport {\n  type ObjectJSON as APIJSON,\n  type AnyEntity,\n  type AnyProperties,\n  type Comparator as ApiComparator,\n  type Meta as ApiMeta,\n  type ReadonlyMeta as ApiReadonlyMeta,\n  type EntityVersion as ApiVersion,\n  type ChangeCallback,\n  type InternalObjectProps,\n  type KindId,\n  MetaId,\n  type Mutable,\n  type ObjectMeta,\n  type SnapshotKindId,\n  type VersionCompareResult,\n  VersionTypeId,\n  addTag as addTag$,\n  change as change$,\n  clone as clone$,\n  compareVersions,\n  decodeVersion,\n  deleteKeys as deleteKeys$,\n  encodeVersion,\n  getDXN as getDXN$,\n  getDatabase as getDatabase$,\n  getDescription as getDescription$,\n  getKeys as getKeys$,\n  getLabel as getLabel$,\n  getMetaChecked as getMeta$,\n  getSchema as getSchema$,\n  getSnapshot as getSnapshot$,\n  getTypeAnnotation,\n  getTypeDXN as getTypeDXN$,\n  getTypename as getTypename$,\n  isDeleted as isDeleted$,\n  isInstanceOf,\n  isVersion,\n  makeObject,\n  objectFromJSON,\n  removeTag as removeTag$,\n  setDescription as setDescription$,\n  setLabel as setLabel$,\n  setValue as setValue$,\n  sort as sort$,\n  sortByLabel as sortByLabel$,\n  sortByTypename as sortByTypename$,\n  subscribe as subscribe$,\n  objectToJSON as toJSON$,\n  version as version$,\n  versionValid,\n} from './internal';\nimport type * as Ref from './Ref';\nimport type * as Type from './Type';\n\n/**\n * Base type for all ECHO objects.\n */\ninterface BaseObj extends AnyEntity, Entity.OfKind<typeof Entity.Kind.Object> {}\n\n/**\n * Object type with specific properties.\n */\nexport type Obj<Props> = BaseObj & Props;\n\n/**\n * Object with no known properties beyond id and kind.\n * Use this when the object's schema/properties are not known.\n * For objects with arbitrary properties, use `Obj.AnyProps`.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO object, use `Schema.is(Type.Obj)`.\n */\nexport interface Unknown extends BaseObj {}\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 *\n * Prefer using `Obj.Unknown` when you don't need to access arbitrary properties.\n */\nexport interface Any extends BaseObj, AnyProperties {}\n\n/**\n * Base type for snapshot objects (has SnapshotKindId instead of KindId).\n */\ninterface BaseSnapshot extends AnyEntity {\n  readonly [SnapshotKindId]: typeof Entity.Kind.Object;\n  readonly id: ObjectId;\n}\n\n/**\n * Immutable snapshot of an ECHO object.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks like useObject().\n *\n * Snapshots are structurally identical to reactive objects but have a different brand,\n * making them distinguishable at the TypeScript level. Neither is assignable to the other.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, KindId> & BaseSnapshot;\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?\n/**\n * Props type for object creation with a given schema.\n */\nexport type MakeProps<S extends Schema.Schema.AnyNoContext> = {\n  id?: ObjectId;\n  [Meta]?: Partial<ObjectMeta>;\n} & NoInfer<Props<Schema.Schema.Type<S>>>;\n\n/**\n * Creates a new echo object of the given schema.\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 *\n * Note: Only accepts object schemas, not relation schemas. Use `Relation.make` for relations.\n */\nexport const make: {\n  <S extends Type.Obj.Any>(schema: S, props: MakeProps<S>): Obj<Schema.Schema.Type<S>>;\n  /**\n   * @deprecated Pass meta as in the example: `Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' })`.\n   */\n  <S extends Type.Obj.Any>(schema: S, props: MakeProps<S>, meta: Partial<ObjectMeta>): Obj<Schema.Schema.Type<S>>;\n} = <S extends Type.Obj.Any>(\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 Unknown => {\n  assumeType<InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && obj[Entity.KindId] === Entity.Kind.Object;\n};\n\n/**\n * Subscribe to object updates.\n * The callback is called synchronously when the object is modified.\n * Only accepts reactive objects (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (obj: Unknown, callback: () => void): (() => void) => {\n  return subscribe$(obj, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of an object.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive object at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(obj: T) => Snapshot<T> = getSnapshot$ as any;\n\nexport type CloneOptions = {\n  /**\n   * Retain the original object's ID.\n   * @default false\n   */\n  retainId?: boolean;\n\n  /**\n   * Recursively clone referenced objects.\n   * @default false\n   */\n  deep?: 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 Unknown>(obj: T, opts?: CloneOptions) => T = clone$;\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of an object within `Obj.change`.\n */\nexport type { Mutable };\n\n/**\n * Perform mutations on an echo object within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Obj.change` will throw\n * an error for echo objects.\n *\n * This function also works with nested objects within echo objects (e.g., Template structs)\n * that are reactive at runtime.\n *\n * @param obj - The echo object to mutate. Use `Relation.change` for relations.\n * @param callback - The callback that performs mutations on the object.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, { name: 'John', age: 25 });\n *\n * // Mutate within Obj.change\n * Obj.change(person, (p) => {\n *   p.name = 'Jane';\n *   p.age = 30;\n * });\n * // ONE notification fires here\n *\n * // Direct mutation throws\n * person.name = 'Bob'; // Error: Cannot modify outside Obj.change()\n * ```\n *\n * Note: Only accepts objects. Use `Relation.change` for relations.\n */\nexport const change = <T extends Unknown>(obj: T, callback: ChangeCallback<T>): void => {\n  change$(obj, callback);\n};\n\n/**\n * Get a deeply nested property from an object.\n *\n * Similar to lodash.get and getDeep from @dxos/util.\n * This is the complementary function to setValue.\n * Accepts both reactive objects and snapshots.\n *\n * @param obj - The ECHO object to get the property from.\n * @param path - Path to the property (array of keys).\n * @returns The value at the path, or undefined if not found.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, {\n *   name: 'John',\n *   addresses: [{ street: '123 Main St' }]\n * });\n *\n * Obj.getValue(person, ['addresses', 0, 'street']); // '123 Main St'\n * Obj.getValue(person, ['addresses', 1, 'street']); // undefined\n * ```\n */\nexport const getValue = (obj: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return getValue$(obj, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on an object, using the object's schema to determine\n * whether to initialize nested data as an empty object or array.\n *\n * Similar to lodash.set and setDeep from @dxos/util, but schema-aware.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n *\n * @param obj - The mutable ECHO object to set the property on.\n * @param path - Path to the property (array of keys).\n * @param value - Value to set.\n * @returns The value that was set.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, { name: 'John' });\n * // Person schema has: addresses: Schema.mutable(Schema.Array(Address))\n * Obj.change(person, (p) => {\n *   Obj.setValue(p, ['addresses', 0, 'street'], '123 Main St');\n * });\n * // Creates: person.addresses = [{ street: '123 Main St' }]\n * ```\n */\n// TODO(wittjosiah): Compute possible path values + type value based on generic object type.\nexport const setValue: (obj: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  setValue$ as any;\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.\n/**\n * Get the DXN of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => {\n  assertArgument(!Schema.isSchema(entity), 'obj', 'Object should not be a schema.');\n  return getDXN$(entity);\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(wittjosiah): Narrow types.\nexport const getTypeDXN: (obj: unknown | undefined) => DXN | undefined = getTypeDXN$ as any;\n\n/**\n * Get the schema of the object.\n * Returns the branded ECHO schema used to create the object.\n */\n// TODO(wittjosiah): Narrow types.\nexport const getSchema: (obj: unknown | undefined) => Type.Entity.Any | undefined = getSchema$ as any;\n\n/**\n * @returns The typename of the object's type.\n * Accepts both reactive objects and snapshots.\n * @example `example.com/type/Person`\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => getTypename$(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the object belongs to.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): Database.Database | undefined => getDatabase$(entity);\n\n//\n// Meta\n//\n\nexport const Meta: unique symbol = MetaId as any;\n\n/**\n * Deeply read-only version of ObjectMeta.\n * Prevents mutation at all nesting levels (e.g., `meta.keys.push()` is a TypeScript error).\n */\nexport type ReadonlyMeta = ApiReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Obj.getMeta` inside an `Obj.change` callback.\n */\nexport type Meta = ApiMeta;\n\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): Allow returning undefined.\n/**\n * Get the metadata for an object.\n * Returns mutable meta when passed a mutable object (inside `Obj.change` callback).\n * Returns read-only meta when passed a regular object or snapshot.\n *\n * @example\n * ```ts\n * // Read-only access outside change callback\n * const meta = Obj.getMeta(person);  // ReadonlyMeta\n *\n * // Mutable access inside change callback\n * Obj.change(person, (p) => {\n *   const meta = Obj.getMeta(p);     // ObjectMeta (mutable)\n *   meta.tags ??= [];\n *   meta.tags.push('important');\n * });\n * ```\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): ObjectMeta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): ObjectMeta | ReadonlyMeta {\n  return getMeta$(entity);\n}\n\n/**\n * @returns Foreign keys for the object from the specified source.\n * Accepts both reactive objects and snapshots.\n */\nexport const getKeys: {\n  (entity: Unknown | Snapshot, source: string): ForeignKey[];\n  (source: string): (entity: Unknown | Snapshot) => ForeignKey[];\n} = Function.dual(2, (entity: Unknown | Snapshot, source?: string): ForeignKey[] => getKeys$(entity, source!));\n\n/**\n * Delete all keys from the object for the specified source.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => deleteKeys$(entity, source);\n\n/**\n * Add a tag to the object.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => addTag$(entity, tag);\n\n/**\n * Remove a tag from the object.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => removeTag$(entity, tag);\n\n/**\n * Check if the object is deleted.\n * Accepts both reactive objects and snapshots.\n */\n// TODO(dmaretskyi): Default to `false`.\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => isDeleted$(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => getLabel$(entity);\n\n/**\n * Set the label of the object.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => setLabel$(entity, label);\n\n/**\n * Get the description of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => getDescription$(entity);\n\n/**\n * Set the description of the object.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  setDescription$(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of an object.\n */\nexport type JSON = APIJSON;\n\n/**\n * Converts object to its JSON representation.\n * Accepts both reactive objects and snapshots.\n *\n * The same algorithm is used when calling the standard `JSON.stringify(obj)` function.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => toJSON$(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<Unknown> =\n  objectFromJSON as any;\n\n//\n// Sorting\n//\n\n/**\n * Comparator function type for sorting objects.\n * Accepts both reactive objects and snapshots.\n */\nexport type Comparator = ApiComparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = sortByLabel$ as Comparator;\nexport const sortByTypename: Comparator = sortByTypename$ as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => sort$(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport { VersionTypeId };\nexport type { VersionCompareResult };\n\n/**\n * Represent object version.\n * May be backed by Automerge.\n * Objects with no history are not versioned.\n */\nexport type Version = ApiVersion;\n\nexport { isVersion, versionValid, compareVersions, encodeVersion, decodeVersion };\n\n/**\n * Returns the version of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => version$(entity);\n"],
+  "mappings": "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",
+  "names": ["addTag", "change", "clone", "deleteKeys", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Function", "Schema", "createJsonPath", "getValue", "getValue$", "assertArgument", "ObjectId", "assumeType", "defaultMeta", "keys", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "Kind", "Object", "MetaId", "structuredClone", "filterUndefined", "fromEntries", "entries", "filter", "_", "v", "undefined", "makeObject", "isObject", "obj", "assumeType", "KindId", "subscribe", "callback", "subscribe$", "getSnapshot", "getSnapshot$", "clone", "clone$", "change", "change$", "getValue", "path", "getValue$", "createJsonPath", "setValue", "setValue$", "ID", "ObjectId", "instanceOf", "args", "length", "entity", "isInstanceOf", "getDXN", "isSchema", "getDXN$", "getTypeDXN", "getTypeDXN$", "getSchema", "getSchema$", "getTypename", "getTypename$", "getDatabase", "getDatabase$", "Meta", "getMeta", "getMeta$", "getKeys", "dual", "source", "getKeys$", "deleteKeys", "deleteKeys$", "addTag", "tag", "addTag$", "removeTag", "removeTag$", "isDeleted", "isDeleted$", "getLabel", "getLabel$", "setLabel", "label", "setLabel$", "getDescription", "getDescription$", "setDescription", "description", "setDescription$", "toJSON", "toJSON$", "fromJSON", "objectFromJSON", "sortByLabel", "sortByLabel$", "sortByTypename", "sortByTypename$", "sort", "comparators", "sort$", "version", "entity", "version$"]
+}

package/dist/lib/node-esm/chunk-K37NA7PO.mjs

@@ -0,0 +1,43 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Order.ts
+var Order_exports = {};
+__export(Order_exports, {
+  natural: () => natural,
+  property: () => property,
+  rank: () => rank
+});
+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
+});
+var rank = (direction = "desc") => new OrderClass({
+  kind: "rank",
+  direction
+});
+
+export {
+  natural,
+  property,
+  rank,
+  Order_exports
+};
+//# sourceMappingURL=chunk-K37NA7PO.mjs.map

package/dist/lib/node-esm/chunk-K37NA7PO.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\n/**\n * Order by relevance rank (for FTS/vector search results).\n * Higher rank = better match. Default direction is 'desc' (best matches first).\n */\nexport const rank = <T>(direction: QueryAST.OrderDirection = 'desc'): Order<T> =>\n  new OrderClass({\n    kind: 'rank',\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;AAMK,IAAMC,OAAO,CAAID,YAAqC,WAC3D,IAAIR,WAAW;EACbM,MAAM;EACNE;AACF,CAAA;",
+  "names": ["OrderClass", "variance", "is", "value", "ast", "natural", "kind", "property", "direction", "rank"]
+}