@dxos/echo 0.8.4-main.ead640a → 0.8.4-main.f466a3d56e

package/dist/lib/neutral/chunk-I2DARWPX.mjs

@@ -0,0 +1,128 @@
+import {
+  isInstanceOf
+} from "./chunk-TNBK56IN.mjs";
+import {
+  ObjectNotFoundError
+} from "./chunk-ZISMEVKD.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Database.ts
+var Database_exports = {};
+__export(Database_exports, {
+  Database: () => Database,
+  Service: () => Service,
+  TypeId: () => TypeId,
+  add: () => add,
+  flush: () => flush,
+  isDatabase: () => isDatabase,
+  layer: () => layer,
+  load: () => load,
+  loadOption: () => loadOption,
+  makeService: () => makeService,
+  notAvailable: () => notAvailable,
+  query: () => query,
+  registerSchema: () => registerSchema,
+  remove: () => remove,
+  resolve: () => resolve,
+  runQuery: () => runQuery,
+  runQueryFirst: () => runQueryFirst,
+  runSchemaQuery: () => runSchemaQuery,
+  schemaQuery: () => schemaQuery,
+  spaceId: () => spaceId
+});
+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 = /* @__PURE__ */ 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 extends Context.Tag("@dxos/echo/Database/Service")() {
+};
+var notAvailable = Layer.succeed(Service, {
+  get db() {
+    throw new Error("Database not available");
+  }
+});
+var makeService = (db) => {
+  return {
+    get db() {
+      return db;
+    }
+  };
+};
+var layer = (db) => {
+  return Layer.succeed(Service, makeService(db));
+};
+var spaceId = Effect.gen(function* () {
+  const { db } = yield* Service;
+  return db.spaceId;
+});
+var 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.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 67, S: this, A: ["!schema || isInstanceOf(schema, object)", "'Object type mismatch.'"] });
+  return object;
+}).pipe(Effect.withSpan("Database.resolve"));
+var load = Effect.fn("Database.load")(function* (ref) {
+  const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
+  if (!object) {
+    return yield* Effect.fail(new ObjectNotFoundError(ref.dxn));
+  }
+  return object;
+});
+var loadOption = Effect.fn("Database.loadOption")(function* (ref) {
+  const object = yield* load(ref).pipe(Effect.catchTag("ObjectNotFoundError", () => Effect.succeed(void 0)));
+  return Option.fromNullable(object);
+});
+var add = (obj) => Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan("Database.add"));
+var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan("Database.remove"));
+var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))).pipe(Effect.withSpan("Database.flush"));
+var query = (queryOrFilter) => Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Database.query"));
+var runQuery = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())), Effect.withSpan("Database.runQuery"));
+var runQueryFirst = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined()))), Effect.withSpan("Database.runQueryFirst"));
+var registerSchema = (input) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.schemaRegistry.register(input))), Effect.withSpan("Database.registerSchema"));
+var schemaQuery = (schemaQueryOptions) => Service.pipe(Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)), Effect.withSpan("Database.schemaQuery"));
+var runSchemaQuery = (schemaQueryOptions) => schemaQuery(schemaQueryOptions).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
+
+export {
+  TypeId,
+  isDatabase,
+  Database,
+  Service,
+  notAvailable,
+  makeService,
+  layer,
+  spaceId,
+  resolve,
+  load,
+  loadOption,
+  add,
+  remove,
+  flush,
+  query,
+  runQuery,
+  runQueryFirst,
+  registerSchema,
+  schemaQuery,
+  runSchemaQuery,
+  Database_exports
+};
+//# sourceMappingURL=chunk-I2DARWPX.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Database.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\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 { promiseWithCauseCapture } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { DXN, type SpaceId } from '@dxos/keys';\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/Annotation';\nimport { type AnyProperties } from './internal/common/types';\nimport type { Ref } from './internal/Ref/ref';\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 * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\nexport interface QueryFn {\n  <Q extends Query.Any>(query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n  <F extends Filter.Any>(filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n}\n\n/**\n * Common interface for Database, Feed, and Hypergraph.\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 true\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.OfShape<AnyProperties>>(\n    id: string,\n    opts?: GetObjectByIdOptions,\n  ): 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\n/**\n * Effect service tag for Database dependency injection.\n */\nexport class Service extends Context.Tag('@dxos/echo/Database/Service')<\n  Service,\n  {\n    readonly db: Database;\n  }\n>() {}\n\n/**\n * Layer that provides a Database service that throws when accessed.\n * Useful as a default layer when no database is available.\n */\nexport const notAvailable = Layer.succeed(Service, {\n  get db(): Database {\n    throw new Error('Database not available');\n  },\n});\n\n/**\n * Creates a Database service instance from a Database.\n */\nexport const makeService = (db: Database): Context.Tag.Service<Service> => {\n  return {\n    get db() {\n      return db;\n    },\n  };\n};\n\n/**\n * Creates a Layer that provides the Database service.\n */\nexport const layer = (db: Database): Layer.Layer<Service> => {\n  return Layer.succeed(Service, makeService(db));\n};\n\n/**\n * Returns the space ID of the database.\n */\nexport const spaceId = Effect.gen(function* () {\n  const { db } = yield* Service;\n  return db.spaceId;\n});\n\n/**\n * Resolves an object by its DXN.\n */\nexport const resolve: {\n  // No type check.\n  (ref: DXN | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;\n  // Check matches schema.\n  <S extends Type.AnyEntity>(\n    ref: DXN | Ref<any>,\n    schema: S,\n  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;\n} = (<S extends Type.AnyEntity>(\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  }).pipe(Effect.withSpan('Database.resolve'))) as any;\n\n/**\n * Loads an object reference.\n */\nexport const load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.ObjectNotFoundError, never> = Effect.fn('Database.load')(\n  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/**\n * Loads an object reference option.\n */\n// TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.\nexport const loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(\n  'Database.loadOption',\n)(function* (ref) {\n  const object = yield* load(ref).pipe(Effect.catchTag('ObjectNotFoundError', () => Effect.succeed(undefined)));\n\n  return Option.fromNullable(object);\n});\n\n/**\n * Adds an object to the database.\n * @see {@link Database.add}\n */\nexport const add = <T extends Entity.Unknown>(obj: T): Effect.Effect<T, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan('Database.add'));\n\n/**\n * Removes an object from the database.\n * @see {@link Database.remove}\n */\nexport const remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan('Database.remove'));\n\n/**\n * Flushes pending changes to disk.\n * @see {@link Database.flush}\n */\nexport const flush = (opts?: FlushOptions) =>\n  Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))).pipe(\n    Effect.withSpan('Database.flush'),\n  );\n\n/**\n * Creates a `QueryResult` object that can be subscribed to.\n */\nexport const 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('Database.query'),\n  );\n\n/**\n * Executes the query once and returns the results.\n */\nexport const 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  query(queryOrFilter as any).pipe(\n    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n    Effect.withSpan('Database.runQuery'),\n  );\n\n/**\n * Executes the query once and returns the first result as or None.\n */\nexport const runQueryFirst: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Option.Option<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Option.Option<Filter.Type<F>>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  query(queryOrFilter as any).pipe(\n    Effect.flatMap((queryResult) =>\n      promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined())),\n    ),\n    Effect.withSpan('Database.runQueryFirst'),\n  );\n\n/**\n * Persists schemas in the database so they replicate to other clients.\n * @see {@link SchemaRegistry.SchemaRegistry.register}\n */\nexport const registerSchema = (\n  input: SchemaRegistry.RegisterSchemaInput[],\n): Effect.Effect<Type.RuntimeType[], never, Service> =>\n  Service.pipe(\n    Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.schemaRegistry.register(input))),\n    Effect.withSpan('Database.registerSchema'),\n  );\n\n/**\n * Creates a schema query result that can be subscribed to.\n */\n// TODO(dmaretskyi): Change API to `yield* Database.querySchema(...).first` and `yield* Database.querySchema(...).schema`.\nexport const schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<QueryResult.QueryResult<SchemaRegistry.ExtractQueryResult<Q>>, never, Service> =>\n  Service.pipe(\n    Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)),\n    Effect.withSpan('Database.schemaQuery'),\n  );\n\n/**\n * Executes a schema query once and returns the results.\n */\nexport const runSchemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<SchemaRegistry.ExtractQueryResult<Q>[], never, Service> =>\n  schemaQuery(schemaQueryOptions).pipe(\n    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n  );\n"],
+  "mappings": ";;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAMA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,YAAY;AAGxB,SAASC,+BAA+B;AACxC,SAASC,iBAAiB;AAC1B,SAASC,WAAyB;AAqElC,IAAA,eAAA;AA+DSC,IAAM,SAAOA,uBAAQ,IAAA,qBAAsBA;AAClD,IAAA,aAAA,CAAA,QAAA;AAEF,SAAO,MAAMC,OAAoCC,QAAOC,YAASD,UAAc,OAACE,IAAUC,MAAAA,MAAWD,SAAS;AAE9G;;AAUA,IAAA,UAAA,cAAA,YAAA,6BAAA,EAAA,EAAA;;AAMI,IAAM,eAAU,cAAA,SAAA;EAClB,IAAA,KAAA;AACC,UAAA,IAAA,MAAA,wBAAA;EAEH;;AAKI,IAAIE,cAAK,CAAA,OAAA;;IAET,IAAA,KAAA;AACF,aAAA;IACA;EAEF;;AAKE,IAAA,QAAA,CAAA,OAAA;AAEF,SAAA,cAAA,SAAA,YAAA,EAAA,CAAA;;AAKSA,IAAGC,UAAO,WAAA,aAAA;AAChB,QAAA,EAAA,GAAA,IAAA,OAAA;AAEH,SAAA,GAAA;;AAiBI,IAAMC,UAAMC,CAAAA,KAAAA,WAA2BA,WAAID,aAAG;AAC9C,QAAME,EAAAA,GAAAA,IAAS,OAAOC;cAGhBC,eAAS,MAAA,MAAA,IAAA;iBACPR,OAAUG,wBAAO,MAAA,GAAA,MAAA,kBAAA;IACnB,SAAA;MAEDM,OAAQL,GAAAA;IAGRE;EACH,CAAA,EAAA,QAAO,GAAOI,CAAAA;AAChB,MAAA,CAAA,QAAA;AACAC,WAAWC,OAAUC,YAAAA,IAAaD,oBAAiB,GAAA,CAAA;EACnD;AACCE,YAAKJ,CAAOK,UAAS,aAAA,QAA6B,MAAA,GAAA,yBAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,MAAA,GAAA,CAAA,2CAAA,yBAAA,EAAA,CAAA;AAEvD,SAAA;;AAMST,IAAQ,OAAA,UAAA,eAAA,EAAA,WAAA,KAAA;QACX,SAAO,OAAOI,wBAAoBM,MAAAA,IAAAA,QAAwBZ,CAAAA;AAC5D,MAAA,CAAA,QAAA;AACA,WAAOE,OAAAA,YAAAA,IAAAA,oBAAAA,IAAAA,GAAAA,CAAAA;EAET;AAEF,SAAA;;AASE,IAAOW,aAAoBX,UAAAA,qBAAAA,EAAAA,WAAAA,KAAAA;AAC1B,QAAA,SAAA,OAAA,KAAA,GAAA,EAAA,KAAA,gBAAA,uBAAA,MAAA,eAAA,MAAA,CAAA,CAAA;AAEH,SAAA,oBAAA,MAAA;;;;;;;;;;;",
+  "names": ["Context", "Effect", "Layer", "Option", "Schema", "promiseWithCauseCapture", "invariant", "DXN", "obj", "Database", "Schema", "Any", "space", "isDatabase", "db", "spaceId", "dxn", "ref", "object", "promiseWithCauseCapture", "context", "resolve", "Effect", "invariant", "schema", "isInstanceOf", "pipe", "withSpan", "ObjectNotFoundError", "Option"]
+}

package/dist/lib/neutral/chunk-J54QMAKF.mjs

@@ -0,0 +1,421 @@
+import {
+  isRef
+} from "./chunk-N7VOEPSV.mjs";
+import {
+  Kind,
+  KindId,
+  SnapshotKindId
+} from "./chunk-SCPFDS2E.mjs";
+import {
+  EchoObjectSchema,
+  MetaId,
+  VersionTypeId,
+  addTag,
+  change,
+  clone,
+  compareVersions,
+  decodeVersion,
+  deleteKeys,
+  encodeVersion,
+  getDXN,
+  getDatabase,
+  getKeys,
+  getMetaChecked,
+  getProxyTarget,
+  getSnapshot,
+  getValue,
+  isDeleted,
+  isProxy,
+  isVersion,
+  makeObject,
+  objectFromJSON,
+  objectToJSON,
+  removeTag,
+  setValue,
+  sort,
+  sortByLabel,
+  sortByTypename,
+  subscribe,
+  version,
+  versionValid
+} from "./chunk-G54OX4IX.mjs";
+import {
+  ParentId,
+  getDescription,
+  getLabel,
+  getSchema,
+  getTypeAnnotation,
+  getTypeDXN,
+  getTypename,
+  isInstanceOf,
+  setDescription,
+  setLabel
+} from "./chunk-TNBK56IN.mjs";
+import {
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  SchemaKindId
+} from "./chunk-N4B7FHQT.mjs";
+import {
+  GetReactiveError
+} from "./chunk-ZISMEVKD.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Obj.ts
+var Obj_exports = {};
+__export(Obj_exports, {
+  ID: () => ID,
+  Meta: () => Meta,
+  Parent: () => Parent,
+  Unknown: () => Unknown2,
+  VersionTypeId: () => VersionTypeId2,
+  addTag: () => addTag2,
+  clone: () => clone2,
+  compareVersions: () => compareVersions2,
+  decodeVersion: () => decodeVersion2,
+  deleteKeys: () => deleteKeys2,
+  encodeVersion: () => encodeVersion2,
+  fromJSON: () => fromJSON,
+  getDXN: () => getDXN2,
+  getDatabase: () => getDatabase2,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys2,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta,
+  getParent: () => getParent,
+  getReactive: () => getReactive,
+  getReactiveOption: () => getReactiveOption,
+  getReactiveOrThrow: () => getReactiveOrThrow,
+  getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot2,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename2,
+  getValue: () => getValue2,
+  instanceOf: () => instanceOf,
+  isDeleted: () => isDeleted2,
+  isObject: () => isObject,
+  isSnapshot: () => isSnapshot,
+  isVersion: () => isVersion2,
+  make: () => make,
+  removeTag: () => removeTag2,
+  setDescription: () => setDescription2,
+  setLabel: () => setLabel2,
+  setParent: () => setParent,
+  setValue: () => setValue2,
+  snapshotOf: () => snapshotOf,
+  sort: () => sort2,
+  sortByLabel: () => sortByLabel2,
+  sortByTypename: () => sortByTypename2,
+  subscribe: () => subscribe2,
+  toJSON: () => toJSON,
+  update: () => update,
+  updateFrom: () => updateFrom,
+  version: () => version2,
+  versionValid: () => versionValid2
+});
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Utils from "effect/Utils";
+import { createJsonPath } from "@dxos/effect";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { ObjectId } from "@dxos/keys";
+import { assumeType, deepMapValues } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
+var Unknown2 = Schema.Struct({
+  id: Schema.String
+}).pipe(
+  Schema.extend(Schema.Record({
+    key: Schema.String,
+    value: Schema.Unknown
+  })),
+  // TODO(dmaretskyi): Clean this up.
+  // NOTE: The EchoObjectSchema annotation is required for Ref.Ref(Obj.Unknown) to work.
+  //   The typename/version only satisfy ECHO schema machinery for reference targets.
+  EchoObjectSchema({
+    typename: ANY_OBJECT_TYPENAME,
+    version: ANY_OBJECT_VERSION
+  }),
+  (schema) => Object.assign(schema, {
+    [SchemaKindId]: schema[SchemaKindId]
+  })
+);
+var defaultMeta = {
+  keys: []
+};
+var make = (schema, props) => {
+  assertArgument(getTypeAnnotation(schema)?.kind === Kind.Object, "schema", "Expected an object schema");
+  let meta = void 0;
+  if (props[MetaId] != null) {
+    meta = {
+      ...structuredClone(defaultMeta),
+      ...props[MetaId]
+    };
+    delete props[MetaId];
+  }
+  const filterUndefined = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== void 0));
+  for (const sym of Object.getOwnPropertySymbols(props)) {
+    const value = props[sym];
+    if (value !== void 0) {
+      filterUndefined[sym] = value;
+    }
+  }
+  return makeObject(schema, filterUndefined, {
+    ...defaultMeta,
+    ...meta
+  });
+};
+var isObject = (obj) => {
+  assumeType(obj);
+  return typeof obj === "object" && obj !== null && obj[KindId] === Kind.Object;
+};
+var isSnapshot = (obj) => {
+  assumeType(obj);
+  return typeof obj === "object" && obj !== null && obj[SnapshotKindId] === Kind.Object;
+};
+var subscribe2 = (obj, callback) => {
+  return subscribe(obj, callback);
+};
+var getSnapshot2 = getSnapshot;
+var getReactive = (snapshot) => Effect.gen(function* () {
+  const db = getDatabase(snapshot);
+  if (!db) {
+    return yield* Effect.fail(new GetReactiveError({
+      reason: "no-database",
+      snapshotId: snapshot.id
+    }));
+  }
+  const obj = db.getObjectById(snapshot.id);
+  if (!obj) {
+    return yield* Effect.fail(new GetReactiveError({
+      reason: "object-not-found",
+      snapshotId: snapshot.id
+    }));
+  }
+  return obj;
+});
+var getReactiveOption = (snapshot) => getReactive(snapshot).pipe(Effect.map(Option.some), Effect.catchAll(() => Effect.succeed(Option.none())));
+var getReactiveOrThrow = (snapshot) => Effect.runSync(getReactive(snapshot));
+var clone2 = clone;
+var update = (obj, callback) => {
+  change(obj, callback);
+};
+var getValue2 = (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 snapshotOf = (...args) => {
+  const check = (entity) => entity != null && typeof entity === "object" && SnapshotKindId in entity && isInstanceOf(args[0], entity);
+  if (args.length === 1) {
+    return (entity) => check(entity);
+  }
+  return check(args[1]);
+};
+var getDXN2 = (entity) => {
+  assertArgument(!Schema.isSchema(entity), "obj", "Object should not be a schema.");
+  return getDXN(entity);
+};
+var getTypeDXN2 = (obj) => {
+  const type = getTypeDXN(obj);
+  invariant(type != null, "Corrupted object: missing type.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 315, S: void 0, A: ["type != null", "'Corrupted object: missing type.'"] });
+  return type;
+};
+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 Parent = ParentId;
+var getParent = (entity) => {
+  assertArgument(isObject(entity), "Expected an object");
+  assumeType(entity);
+  return entity[ParentId];
+};
+var setParent = (entity, parent) => {
+  assertArgument(isObject(entity), "Expected an object");
+  assertArgument(parent === void 0 || isObject(parent), "Expected an object");
+  assumeType(entity);
+  assumeType(parent);
+  entity[ParentId] = parent;
+  return entity;
+};
+var valuesEqual = (left, right) => {
+  if (left === right) {
+    return true;
+  }
+  if (left === null || right === null) {
+    return left === right;
+  }
+  if (typeof left !== "object" || typeof right !== "object") {
+    return Utils.structuralRegion(() => Equal.equals(left, right));
+  }
+  if (isRef(left) && isRef(right)) {
+    return left.dxn.toString() === right.dxn.toString();
+  }
+  if (isRef(left) || isRef(right)) {
+    return false;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    for (let index = 0; index < left.length; index++) {
+      if (!valuesEqual(left[index], right[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(leftRecord).filter((key) => key !== "id"),
+    ...Object.keys(rightRecord).filter((key) => key !== "id")
+  ]);
+  for (const key of keys) {
+    const leftHas = Object.hasOwn(leftRecord, key);
+    const rightHas = Object.hasOwn(rightRecord, key);
+    const leftValue = leftHas ? leftRecord[key] : void 0;
+    const rightValue = rightHas ? rightRecord[key] : void 0;
+    if (!valuesEqual(leftValue, rightValue)) {
+      return false;
+    }
+  }
+  return true;
+};
+var prepareAssignValue = (value) => deepMapValues(value, (nested, recurse) => {
+  if (nested === null || typeof nested !== "object") {
+    return nested;
+  }
+  if (isRef(nested)) {
+    return nested;
+  }
+  if (Array.isArray(nested)) {
+    return recurse(nested);
+  }
+  if (isProxy(nested)) {
+    return recurse({
+      ...getProxyTarget(nested)
+    });
+  }
+  return recurse(nested);
+});
+var updateFrom = (target, source, options) => {
+  assertArgument(isObject(target), "Expected an echo object target.");
+  assertArgument(isObject(source), "Expected an echo object source.");
+  let keys = Object.keys(source).filter((key) => key !== "id");
+  if (options?.include !== void 0) {
+    const include = new Set(options.include.map((key) => String(key)));
+    keys = keys.filter((key) => include.has(key));
+  }
+  if (options?.exclude !== void 0) {
+    const exclude = new Set(options.exclude.map((key) => String(key)));
+    keys = keys.filter((key) => !exclude.has(key));
+  }
+  let updated = false;
+  const sourceRecord = source;
+  const targetRecord = target;
+  for (const key of keys) {
+    if (!Object.hasOwn(sourceRecord, key)) {
+      continue;
+    }
+    const nextValue = sourceRecord[key];
+    const prevValue = Object.hasOwn(targetRecord, key) ? targetRecord[key] : void 0;
+    if (valuesEqual(prevValue, nextValue)) {
+      continue;
+    }
+    targetRecord[key] = prepareAssignValue(nextValue);
+    updated = true;
+  }
+  return updated;
+};
+var toJSON = (entity) => objectToJSON(entity);
+var fromJSON = objectFromJSON;
+var sortByLabel2 = sortByLabel;
+var sortByTypename2 = sortByTypename;
+var sort2 = (...comparators) => sort(...comparators);
+var VersionTypeId2 = VersionTypeId;
+var isVersion2 = isVersion;
+var versionValid2 = versionValid;
+var compareVersions2 = compareVersions;
+var encodeVersion2 = encodeVersion;
+var decodeVersion2 = decodeVersion;
+var version2 = (entity) => version(entity);
+
+export {
+  Unknown2 as Unknown,
+  make,
+  isObject,
+  isSnapshot,
+  subscribe2 as subscribe,
+  getSnapshot2 as getSnapshot,
+  getReactive,
+  getReactiveOption,
+  getReactiveOrThrow,
+  clone2 as clone,
+  update,
+  getValue2 as getValue,
+  setValue2 as setValue,
+  ID,
+  instanceOf,
+  snapshotOf,
+  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,
+  Parent,
+  getParent,
+  setParent,
+  updateFrom,
+  toJSON,
+  fromJSON,
+  sortByLabel2 as sortByLabel,
+  sortByTypename2 as sortByTypename,
+  sort2 as sort,
+  VersionTypeId2 as VersionTypeId,
+  isVersion2 as isVersion,
+  versionValid2 as versionValid,
+  compareVersions2 as compareVersions,
+  encodeVersion2 as encodeVersion,
+  decodeVersion2 as decodeVersion,
+  version2 as version,
+  Obj_exports
+};
+//# sourceMappingURL=chunk-J54QMAKF.mjs.map