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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Type.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema$ from 'effect/Schema';\n\nimport { type EncodedReference } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { type DXN } from '@dxos/keys';\nimport { type ToMutable } from '@dxos/util';\n\nimport type * as Entity$ from './Entity';\nimport {\n  type ATTR_RELATION_SOURCE,\n  type ATTR_RELATION_TARGET,\n  EchoObjectSchema,\n  EchoRelationSchema,\n  type EchoRelationSchemaOptions,\n  EchoSchema,\n  Expando as Expando$,\n  type ExpandoEncoded,\n  PersistentSchema,\n  type PersistentSchemaEncoded,\n  Ref as Ref$,\n  type RefFn,\n  type RefSchema,\n  type TypeAnnotation,\n  type TypeMeta,\n  getSchemaDXN,\n  getSchemaTypename,\n  getSchemaVersion,\n  getTypeAnnotation,\n  isMutable as isMutable$,\n  toEffectSchema,\n  toJsonSchema,\n} from './internal';\nimport type * as Relation$ from './Relation';\n\n// TODO(burdon): Remove toEffectSchema, toJsonSchema (moved to JsonSchema export).\nexport { toEffectSchema, toJsonSchema };\n\n/**\n * Returns all properties of an object or relation except for the id and kind.\n */\nexport type Properties<T = any> = Omit<T, 'id' | Entity$.KindId | Relation$.Source | Relation$.Target>;\n\n//\n// Entity\n//\n\nexport namespace Entity {\n  /**\n   * Type.Obj.Any | Type.Relation.Any.\n   */\n  export type Any = Obj.Any | Relation.Any;\n}\n\n//\n// Obj\n//\n\ninterface ObjJsonProps {\n  id: string;\n}\n\n/**\n * Return type of the `Obj` schema constructor.\n *\n * This typedef avoids `TS4023` error (name from external module cannot be used named).\n * See Effect's note on interface types.\n */\nexport interface obj<Self extends Schema$.Schema.Any>\n  extends TypeMeta,\n    Schema$.AnnotableClass<\n      obj<Self>,\n      Entity$.OfKind<typeof Entity$.Kind.Object> & ToMutable<Schema$.Schema.Type<Self>>,\n      Schema$.Simplify<ObjJsonProps & ToMutable<Schema$.Schema.Encoded<Self>>>,\n      Schema$.Schema.Context<Self>\n    > {}\n\n/**\n * Object schema.\n */\nexport const Obj: {\n  (opts: TypeMeta): <Self extends Schema$.Schema.Any>(self: Self) => obj<Self>;\n} = EchoObjectSchema as any;\n\n/**\n * Object schema type definitions.\n */\nexport declare namespace Obj {\n  /**\n   * Type that represents an arbitrary schema type of an object.\n   * NOTE: This is not an instance type.\n   */\n  // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.\n  // TODO(burdon): This erases the ECHO type info (e.g., id, typename).\n  export type Any = obj<Schema$.Schema.AnyNoContext>;\n}\n\n//\n// Expando\n//\n\nexport const Expando: obj<Schema$.Schema<Expando$, ExpandoEncoded>> = Expando$ as any;\nexport type Expando = obj<Schema$.Schema<Expando$, ExpandoEncoded>>;\n\n//\n// Schema\n//\n\nexport const PersistentType: obj<Schema$.Schema<PersistentSchema, PersistentSchemaEncoded>> = PersistentSchema as any;\nexport type PersistentType = obj<Schema$.Schema<PersistentSchema, PersistentSchemaEncoded>>;\n\nexport { EchoSchema as RuntimeType };\n\n//\n// Relation\n//\n\ninterface RelationJsonProps {\n  id: string;\n  [ATTR_RELATION_SOURCE]: string;\n  [ATTR_RELATION_TARGET]: string;\n}\n\n/**\n * Return type of the `Relation` schema constructor.\n *\n * This typedef avoids `TS4023` error (name from external module cannot be used named).\n * See Effect's note on interface types.\n */\nexport interface relation<\n  Self extends Schema$.Schema.Any,\n  SourceSchema extends Schema$.Schema.Any,\n  TargetSchema extends Schema$.Schema.Any,\n> extends TypeMeta,\n    Schema$.AnnotableClass<\n      relation<Self, SourceSchema, TargetSchema>,\n      Entity$.OfKind<typeof Entity$.Kind.Relation> &\n        Relation.Endpoints<Schema$.Schema.Type<SourceSchema>, Schema$.Schema.Type<TargetSchema>> &\n        ToMutable<Schema$.Schema.Type<Self>>,\n      Schema$.Simplify<RelationJsonProps & ToMutable<Schema$.Schema.Encoded<Self>>>,\n      Schema$.Schema.Context<Self>\n    > {}\n\n/**\n * Relation schema.\n */\n// TODO(dmaretskyi): I have to redefine the type here so that the definition uses symbols from @dxos/echo/Relation.\n// TODO(burdon): Remove?\nexport const Relation: {\n  <Source extends Schema$.Schema.AnyNoContext, Target extends Schema$.Schema.AnyNoContext>(\n    opts: EchoRelationSchemaOptions<Source, Target>,\n  ): <Self extends Schema$.Schema.Any>(self: Self) => relation<Self, Source, Target>;\n} = EchoRelationSchema as any;\n\n/**\n * Relation schema type definitions.\n */\nexport namespace Relation {\n  /**\n   * Type that represents an arbitrary schema type of a relation.\n   * NOTE: This is not an instance type.\n   */\n  // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.\n  export type Any = Schema$.Schema.AnyNoContext;\n\n  /**\n   * Get relation source type.\n   */\n  export type Source<A> = A extends Relation.Endpoints<infer S, infer _T> ? S : never;\n\n  /**\n   * Get relation target type.\n   */\n  export type Target<A> = A extends Relation.Endpoints<infer _S, infer T> ? T : never;\n\n  export type Endpoints<Source, Target> = {\n    [Relation$.Source]: Source;\n    [Relation$.Target]: Target;\n  };\n}\n\n//\n// Ref\n// TODO(burdon): Reconcile Type.Ref with Ref.Ref.\n//\n\n/**\n * Return type of the `Ref` schema constructor.\n *\n * This typedef avoids `TS4023` error (name from external module cannot be used named).\n * See Effect's note on interface types.\n */\nexport interface ref<TargetSchema extends Schema$.Schema.Any> extends RefSchema<Schema$.Schema.Type<TargetSchema>> {}\n\n/**\n * Ref schema.\n */\nexport const Ref: RefFn = Ref$;\n\nexport interface Ref<T> extends Schema$.SchemaClass<Ref$<T>, EncodedReference> {}\n\nexport namespace Ref {\n  /**\n   * Type that represents an arbitrary schema type of a reference.\n   * NOTE: This is not an instance type.\n   */\n  export type Any = Schema$.Schema<Ref$<any>, EncodedReference>;\n}\n\n/**\n * Gets the full DXN of the schema.\n * Will include the version if it's a `type` DXN.\n * @example \"dxn:example.com/type/Person:0.1.0\"\n * @example \"dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX\"\n */\nexport const getDXN = (schema: Entity.Any): DXN | undefined => {\n  return getSchemaDXN(schema);\n};\n\n/**\n * @param schema - Schema to get the typename from.\n * @returns The typename of the schema. Example: `example.com/type/Person`.\n */\nexport const getTypename = (schema: Entity.Any): string => {\n  const typename = getSchemaTypename(schema);\n  invariant(typeof typename === 'string' && !typename.startsWith('dxn:'), 'Invalid typename');\n  return typename;\n};\n\n/**\n * Gets the version of the schema.\n * @example 0.1.0\n */\nexport const getVersion = (schema: Entity.Any): string => {\n  const version = getSchemaVersion(schema);\n  invariant(typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/), 'Invalid version');\n  return version;\n};\n\n/**\n * @returns True if the schema is mutable.\n */\nexport const isMutable = isMutable$;\n\n/**\n * ECHO type metadata.\n */\nexport type Meta = TypeAnnotation;\n\n/**\n * Gets the meta data of the schema.\n */\nexport const getMeta = (schema: Entity.Any): Meta | undefined => {\n  return getTypeAnnotation(schema);\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;;iBAAAA;EAAA;;aAAAC;EAAA;;;;;;mBAAAC;EAAA;;;AAOA,SAASC,iBAAiB;A;AA4EnB,IAAMC,MAETC;AAmBG,IAAMC,WAAyDC;AAO/D,IAAMC,iBAAiFC;AAwCvF,IAAMC,WAITC;AA6CG,IAAMC,OAAaC;AAkBnB,IAAMC,SAAS,CAACC,WAAAA;AACrB,SAAOC,aAAaD,MAAAA;AACtB;AAMO,IAAME,cAAc,CAACF,WAAAA;AAC1B,QAAMG,WAAWC,kBAAkBJ,MAAAA;AACnCK,YAAU,OAAOF,aAAa,YAAY,CAACA,SAASG,WAAW,MAAA,GAAS,oBAAA;;;;;;;;;AACxE,SAAOH;AACT;AAMO,IAAMI,aAAa,CAACP,WAAAA;AACzB,QAAMQ,UAAUC,iBAAiBT,MAAAA;AACjCK,YAAU,OAAOG,YAAY,YAAYA,QAAQE,MAAM,iBAAA,GAAoB,mBAAA;;;;;;;;;AAC3E,SAAOF;AACT;AAKO,IAAMG,aAAYC;AAUlB,IAAMC,UAAU,CAACb,WAAAA;AACtB,SAAOc,kBAAkBd,MAAAA;AAC3B;",
+  "names": ["Expando", "Ref", "isMutable", "invariant", "Obj", "EchoObjectSchema", "Expando", "Expando$", "PersistentType", "PersistentSchema", "Relation", "EchoRelationSchema", "Ref", "Ref$", "getDXN", "schema", "getSchemaDXN", "getTypename", "typename", "getSchemaTypename", "invariant", "startsWith", "getVersion", "version", "getSchemaVersion", "match", "isMutable", "isMutable$", "getMeta", "getTypeAnnotation"]
+}

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

@@ -0,0 +1,113 @@
+import "@dxos/node-std/globals";
+import {
+  isInstanceOf
+} from "./chunk-WABSVOOX.mjs";
+import {
+  ObjectNotFoundError
+} from "./chunk-XRHHSMHJ.mjs";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
+
+// src/Database.ts
+var Database_exports = {};
+__export(Database_exports, {
+  Service: () => Service
+});
+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 { promiseWithCauseCapture } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
+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));
+  };
+  /**
+  * Resolves an object by its DXN.
+  */
+  static resolve = (dxn, schema) => Effect.gen(function* () {
+    const { db } = yield* _Service;
+    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: 226,
+      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(burdon): Option?
+  static loadOption = Effect.fn(function* (ref) {
+    const object = yield* _Service.load(ref).pipe(Effect.catchTag("OBJECT_NOT_FOUND", () => Effect.succeed(void 0)));
+    return Option.fromNullable(object);
+  });
+  // TODO(burdon): Can we create a proxy for the following methods on Database? Use @inheritDoc?
+  // TODO(burdon): Figure out how to chain query().run();
+  /**
+  * @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 {
+  Service,
+  Database_exports
+};
+//# sourceMappingURL=chunk-BD6MRI4M.mjs.map

package/dist/lib/browser/chunk-BD6MRI4M.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 type * 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 { type DXN, type PublicKey, type SpaceId } from '@dxos/keys';\nimport { type Live } from '@dxos/live-object';\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';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport type * as Ref from './Ref';\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 * ECHO Database interface.\n */\nexport interface Database extends Queryable {\n  get spaceId(): SpaceId;\n\n  // TODO(burdon): Can we move this into graph?\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\n\n  /**\n   *\n   */\n  // TODO(burdon): Comment required.\n  get graph(): Hypergraph.Hypergraph;\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.Ref<T>;\n\n  /**\n   * Adds object to the database.\n   */\n  // TODO(burdon): Add batch.\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 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  /**\n   * Resolves an object by its DXN.\n   */\n  static resolve: {\n    // No type check.\n    (dxn: DXN): Effect.Effect<Entity.Unknown, never, Service>;\n    // Check matches schema.\n    <S extends Type.Entity.Any>(\n      dxn: DXN,\n      schema: S,\n    ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;\n  } = (<S extends Type.Entity.Any>(\n    dxn: DXN,\n    schema?: S,\n  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service> =>\n    Effect.gen(function* () {\n      const { db } = yield* Service;\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.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(burdon): Option?\n  static loadOption: <T>(ref: Ref.Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(function* (ref) {\n    const object = yield* Service.load(ref).pipe(Effect.catchTag('OBJECT_NOT_FOUND', () => Effect.succeed(undefined)));\n    return Option.fromNullable(object);\n  });\n\n  // TODO(burdon): Can we create a proxy for the following methods on Database? Use @inheritDoc?\n  // TODO(burdon): Figure out how to chain query().run();\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<Live<Query.Type<Q>>>, never, Service>;\n    <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult.QueryResult<Live<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<Live<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<Live<Query.Type<Q>>[], never, Service>;\n    <F extends Filter.Any>(filter: F): Effect.Effect<Live<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": "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",
+  "names": ["Context", "Effect", "Layer", "Option", "promiseWithCauseCapture", "invariant", "Service", "Tag", "notAvailable", "succeed", "db", "Error", "make", "layer", "resolve", "dxn", "schema", "gen", "object", "promiseWithCauseCapture", "graph", "createRefResolver", "context", "space", "spaceId", "fail", "ObjectNotFoundError", "invariant", "isInstanceOf", "load", "fn", "ref", "tryLoad", "loadOption", "pipe", "catchTag", "undefined", "fromNullable", "add", "obj", "map", "remove", "flush", "opts", "flatMap", "query", "queryOrFilter", "withSpan", "runQuery", "queryResult", "run", "schemaQuery", "schemaRegistry", "runSchemaQuery"]
+}

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

@@ -0,0 +1,11 @@
+import "@dxos/node-std/globals";
+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-CGS2ULMK.mjs.map

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

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

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

@@ -0,0 +1,32 @@
+import "@dxos/node-std/globals";
+import {
+  getEntityKind
+} from "./chunk-WABSVOOX.mjs";
+import {
+  EntityKind,
+  EntityKindSchema,
+  KindId
+} from "./chunk-QU7PWSZD.mjs";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
+
+// src/Entity.ts
+var Entity_exports = {};
+__export(Entity_exports, {
+  Kind: () => Kind,
+  KindId: () => KindId,
+  KindSchema: () => KindSchema,
+  getKind: () => getKind
+});
+var Kind = EntityKind;
+var KindSchema = EntityKindSchema;
+var getKind = getEntityKind;
+
+export {
+  Kind,
+  KindSchema,
+  getKind,
+  Entity_exports
+};
+//# sourceMappingURL=chunk-DOPKE2FQ.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Entity.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type { ObjectId } from '@dxos/keys';\n\nimport { EntityKind, EntityKindSchema, KindId, getEntityKind } from './internal';\n\nexport { KindId };\n\n// NOTE: Relation does not extend Obj so that, for example, we can prevent Relations from being used as source and target objects.\n//  However, we generally refer to Obj and Relation instances as \"objects\",\n//  and many API methods accept both Obj.Any and Relation.Any (i.e., Entity.Unknown) instances.\n\nexport const Kind = EntityKind;\nexport type Kind = EntityKind;\nexport const KindSchema = EntityKindSchema;\n\n/**\n * Assigns a kind to an Object or Relation instance.\n */\n// NOTE: Needed to make `isRelation` and `isObject` checks work.\nexport interface OfKind<K extends Kind> {\n  readonly [KindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Obj or Relation with a specific set of properties.\n */\nexport type Entity<Props> = OfKind<Kind> & Props;\n\n/**\n * Unknown Obj or Relation.\n */\nexport interface Unknown extends OfKind<Kind> {}\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 * This type is very permissive and allows accessing any property on the object.\n * We should move to Obj.Any that is not permissive and requires explicit instanceof checks..\n */\nexport interface Any extends OfKind<Kind> {\n  [key: string]: unknown;\n}\n\nexport const getKind = getEntityKind;\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;;;;;;;AAcO,IAAMA,OAAOC;AAEb,IAAMC,aAAaC;AAkCnB,IAAMC,UAAUC;",
+  "names": ["Kind", "EntityKind", "KindSchema", "EntityKindSchema", "getKind", "getEntityKind"]
+}

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

@@ -0,0 +1,41 @@
+import "@dxos/node-std/globals";
+import {
+  Ref,
+  RefArray,
+  getSchemaReference
+} from "./chunk-6XVZF5VJ.mjs";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
+
+// src/Ref.ts
+var Ref_exports = {};
+__export(Ref_exports, {
+  Array: () => Array,
+  fromDXN: () => fromDXN,
+  isRef: () => isRef,
+  isRefType: () => isRefType,
+  make: () => make
+});
+import * as Option from "effect/Option";
+import * as SchemaAST from "effect/SchemaAST";
+var Array = RefArray;
+var isRef = Ref.isRef;
+var make = Ref.make;
+var fromDXN = Ref.fromDXN;
+var isRefType = (ast) => {
+  return SchemaAST.getAnnotation(ast, SchemaAST.JSONSchemaAnnotationId).pipe(Option.flatMap((jsonSchema) => "$id" in jsonSchema ? Option.some(jsonSchema) : Option.none()), Option.flatMap((jsonSchema) => {
+    const { typename } = getSchemaReference(jsonSchema) ?? {};
+    return typename ? Option.some(true) : Option.some(false);
+  }), Option.getOrElse(() => false));
+};
+
+export {
+  Array,
+  isRef,
+  make,
+  fromDXN,
+  isRefType,
+  Ref_exports
+};
+//# sourceMappingURL=chunk-ESLW4N7S.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Ref.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { Ref as Ref$, RefArray, type RefResolver } from './internal';\nimport { getSchemaReference } from './internal';\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Obj from './Obj';\n\nexport type Ref<T> = Ref$<T>;\nexport type Any = Ref$<Obj.Any>;\n\nexport const Array = RefArray;\n\n/**\n * Extract reference target.\n */\nexport type Target<R extends Any> = R extends Ref$<infer T> ? T : never;\n\n/**\n * Reference resolver.\n */\nexport type Resolver = RefResolver;\n\nexport const isRef: (value: unknown) => value is Any = Ref$.isRef;\n\nexport const make = Ref$.make;\n\n// TODO(dmaretskyi): Consider just allowing `make` to accept DXN.\nexport const fromDXN = Ref$.fromDXN;\n\n// TODO(wittjosiah): Factor out?\nexport const isRefType = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation<JsonSchema.JsonSchema>(ast, SchemaAST.JSONSchemaAnnotationId).pipe(\n    Option.flatMap((jsonSchema) => ('$id' in jsonSchema ? Option.some(jsonSchema) : Option.none())),\n    Option.flatMap((jsonSchema) => {\n      const { typename } = getSchemaReference(jsonSchema) ?? {};\n      return typename ? Option.some(true) : Option.some(false);\n    }),\n    Option.getOrElse(() => false),\n  );\n};\n"],
+  "mappings": ";;;;;;;;;;;AAAA;;;;;;;;AAIA,YAAYA,YAAY;AACxB,YAAYC,eAAe;AAUpB,IAAMC,QAAQC;AAYd,IAAMC,QAA0CC,IAAKD;AAErD,IAAME,OAAOD,IAAKC;AAGlB,IAAMC,UAAUF,IAAKE;AAGrB,IAAMC,YAAY,CAACC,QAAAA;AACxB,SAAiBC,wBAAqCD,KAAeE,gCAAsB,EAAEC,KACpFC,eAAQ,CAACC,eAAgB,SAASA,aAAoBC,YAAKD,UAAAA,IAAqBE,YAAI,CAAA,GACpFH,eAAQ,CAACC,eAAAA;AACd,UAAM,EAAEG,SAAQ,IAAKC,mBAAmBJ,UAAAA,KAAe,CAAC;AACxD,WAAOG,WAAkBF,YAAK,IAAA,IAAeA,YAAK,KAAA;EACpD,CAAA,GACOI,iBAAU,MAAM,KAAA,CAAA;AAE3B;",
+  "names": ["Option", "SchemaAST", "Array", "RefArray", "isRef", "Ref$", "make", "fromDXN", "isRefType", "ast", "getAnnotation", "JSONSchemaAnnotationId", "pipe", "flatMap", "jsonSchema", "some", "none", "typename", "getSchemaReference", "getOrElse"]
+}

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

@@ -0,0 +1,363 @@
+import "@dxos/node-std/globals";
+import {
+  Obj
+} from "./chunk-AGOWBKY6.mjs";
+import {
+  isRef
+} from "./chunk-ESLW4N7S.mjs";
+import {
+  Kind
+} from "./chunk-DOPKE2FQ.mjs";
+import {
+  MetaId,
+  ObjectVersionId,
+  VersionTypeId,
+  getMeta,
+  getObjectDXN,
+  isDeleted,
+  makeObject,
+  objectFromJSON,
+  objectToJSON
+} from "./chunk-6XVZF5VJ.mjs";
+import {
+  getDescription,
+  getLabel,
+  getSchema,
+  getSchemaTypename,
+  getTypeAnnotation,
+  getTypeDXN,
+  isInstanceOf,
+  setDescription,
+  setLabel
+} from "./chunk-WABSVOOX.mjs";
+import {
+  KindId
+} from "./chunk-QU7PWSZD.mjs";
+import {
+  __export
+} from "./chunk-CGS2ULMK.mjs";
+
+// src/Obj.ts
+var Obj_exports = {};
+__export(Obj_exports, {
+  Any: () => Any,
+  ID: () => ID,
+  Meta: () => Meta,
+  VersionTypeId: () => VersionTypeId,
+  addTag: () => addTag,
+  clone: () => clone,
+  compareVersions: () => compareVersions,
+  decodeVersion: () => decodeVersion,
+  deleteKeys: () => deleteKeys,
+  encodeVersion: () => encodeVersion,
+  fromJSON: () => fromJSON,
+  getDXN: () => getDXN,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta2,
+  getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename,
+  instanceOf: () => instanceOf,
+  isDeleted: () => isDeleted2,
+  isObject: () => isObject,
+  isVersion: () => isVersion,
+  make: () => make,
+  removeTag: () => removeTag,
+  setDescription: () => setDescription2,
+  setLabel: () => setLabel2,
+  sort: () => sort,
+  sortByLabel: () => sortByLabel,
+  sortByTypename: () => sortByTypename,
+  toJSON: () => toJSON,
+  version: () => version,
+  versionValid: () => versionValid
+});
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { ObjectId } from "@dxos/keys";
+import { getSnapshot as getSnapshot$ } from "@dxos/live-object";
+import { assumeType, deepMapValues } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
+var Any = Schema.Struct({}).pipe(Obj({
+  typename: "dxos.org/type/Any",
+  version: "0.1.0"
+}));
+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 getSnapshot = getSnapshot$;
+var clone = (obj, opts) => {
+  const { id, ...data } = obj;
+  const schema = getSchema(obj);
+  invariant(schema != null, "Object should have a schema", {
+    F: __dxlog_file,
+    L: 157,
+    S: void 0,
+    A: [
+      "schema != null",
+      "'Object should have a schema'"
+    ]
+  });
+  const props = deepMapValues(data, (value, recurse) => {
+    if (isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = getMeta2(obj);
+  props[MetaId] = deepMapValues(meta, (value, recurse) => {
+    if (isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  return make(schema, props);
+};
+var ID = ObjectId;
+var instanceOf = (...args) => {
+  if (args.length === 1) {
+    return (entity) => isInstanceOf(args[0], entity);
+  }
+  return isInstanceOf(args[0], args[1]);
+};
+var getDXN = (entity) => {
+  assertArgument(!Schema.isSchema(entity), "obj", "Object should not be a schema.");
+  const dxn = getObjectDXN(entity);
+  invariant(dxn != null, "Invalid object.", {
+    F: __dxlog_file,
+    L: 213,
+    S: void 0,
+    A: [
+      "dxn != null",
+      "'Invalid object.'"
+    ]
+  });
+  return dxn;
+};
+var getTypeDXN2 = getTypeDXN;
+var getSchema2 = getSchema;
+var getTypename = (entity) => {
+  const schema = getSchema(entity);
+  if (schema == null) {
+    return getTypeDXN(entity)?.asTypeDXN()?.type;
+  }
+  return getSchemaTypename(schema);
+};
+var Meta = MetaId;
+var getMeta2 = (entity) => {
+  const meta = getMeta(entity);
+  invariant(meta != null, "Invalid object.", {
+    F: __dxlog_file,
+    L: 253,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta;
+};
+var getKeys = Function.dual(2, (entity, source) => {
+  const meta = getMeta2(entity);
+  invariant(meta != null, "Invalid object.", {
+    F: __dxlog_file,
+    L: 265,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta.keys.filter((key) => key.source === source);
+});
+var deleteKeys = (entity, source) => {
+  const meta = getMeta2(entity);
+  for (let i = 0; i < meta.keys.length; i++) {
+    if (meta.keys[i].source === source) {
+      meta.keys.splice(i, 1);
+      i--;
+    }
+  }
+};
+var addTag = (entity, tag) => {
+  const meta = getMeta2(entity);
+  meta.tags ??= [];
+  meta.tags.push(tag);
+};
+var removeTag = (entity, tag) => {
+  const meta = getMeta2(entity);
+  if (!meta.tags) {
+    return;
+  }
+  for (let i = 0; i < meta.tags.length; i++) {
+    if (meta.tags[i] === tag) {
+      meta.tags.splice(i, 1);
+      i--;
+    }
+  }
+};
+var isDeleted2 = (entity) => {
+  const deleted = isDeleted(entity);
+  invariant(typeof deleted === "boolean", "Invalid object.", {
+    F: __dxlog_file,
+    L: 306,
+    S: void 0,
+    A: [
+      "typeof deleted === 'boolean'",
+      "'Invalid object.'"
+    ]
+  });
+  return deleted;
+};
+var getLabel2 = (entity) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getLabel(schema, entity);
+  }
+};
+var setLabel2 = (entity, label) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setLabel(schema, entity, label);
+  }
+};
+var getDescription2 = (entity) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getDescription(schema, entity);
+  }
+};
+var setDescription2 = (entity, description) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setDescription(schema, entity, description);
+  }
+};
+var toJSON = (entity) => objectToJSON(entity);
+var fromJSON = objectFromJSON;
+var compare = (a, b) => {
+  if (a == null) {
+    return b == null ? 0 : 1;
+  }
+  if (b == null) {
+    return -1;
+  }
+  return a.localeCompare(b);
+};
+var sortByLabel = (a, b) => compare(getLabel2(a), getLabel2(b));
+var sortByTypename = (a, b) => compare(getTypename(a), getTypename(b));
+var sort = (...comparators) => {
+  return (a, b) => {
+    for (const comparator of comparators) {
+      const result = comparator(a, b);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  };
+};
+var unversioned = {
+  [VersionTypeId]: {},
+  versioned: false
+};
+var isVersion = (entity) => {
+  return entity != null && typeof entity === "object" && VersionTypeId in entity;
+};
+var version = (entity) => {
+  const version2 = entity[ObjectVersionId];
+  if (version2 === void 0) {
+    return unversioned;
+  }
+  return version2;
+};
+var versionValid = (version2) => {
+  assertArgument(isVersion(version2), "version", "Invalid version object");
+  return !!version2.versioned;
+};
+var compareVersions = (version1, version2) => {
+  assertArgument(isVersion(version1), "version1", "Invalid version object");
+  assertArgument(isVersion(version2), "version2", "Invalid version object");
+  if (!versionValid(version1) || !versionValid(version2)) {
+    return "unversioned";
+  }
+  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
+    return "different";
+  }
+  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
+    return "different";
+  }
+  return "equal";
+};
+var encodeVersion = (version2) => {
+  return JSON.stringify(version2);
+};
+var decodeVersion = (version2) => {
+  const parsed = JSON.parse(version2);
+  parsed[VersionTypeId] = {};
+  return parsed;
+};
+
+export {
+  Any,
+  make,
+  isObject,
+  getSnapshot,
+  clone,
+  ID,
+  instanceOf,
+  getDXN,
+  getTypeDXN2 as getTypeDXN,
+  getSchema2 as getSchema,
+  getTypename,
+  Meta,
+  getMeta2 as getMeta,
+  getKeys,
+  deleteKeys,
+  addTag,
+  removeTag,
+  isDeleted2 as isDeleted,
+  getLabel2 as getLabel,
+  setLabel2 as setLabel,
+  getDescription2 as getDescription,
+  setDescription2 as setDescription,
+  toJSON,
+  fromJSON,
+  sortByLabel,
+  sortByTypename,
+  sort,
+  isVersion,
+  version,
+  versionValid,
+  compareVersions,
+  encodeVersion,
+  decodeVersion,
+  Obj_exports
+};
+//# sourceMappingURL=chunk-F4YF6C3O.mjs.map