@dxos/echo 0.8.4-main.d05673bc65 → 0.8.4-main.dfabb4ec29

package/dist/lib/neutral/Type.mjs

@@ -10,16 +10,16 @@ import {
   isRelationSchema,
   object,
   relation
-} from "./chunk-RMLF7JOZ.mjs";
-import "./chunk-TQQZLKB7.mjs";
-import "./chunk-YWXWXIE5.mjs";
-import "./chunk-BOZZPUXE.mjs";
-import "./chunk-B5OXLWZL.mjs";
-import "./chunk-43Y5DOS6.mjs";
-import "./chunk-NEGC54NE.mjs";
-import "./chunk-SEMVAGBM.mjs";
-import "./chunk-WYOKA6AE.mjs";
-import "./chunk-UBEZSGXY.mjs";
+} from "./chunk-FZHVQEHN.mjs";
+import "./chunk-SJKBWMJY.mjs";
+import "./chunk-6VIJV543.mjs";
+import "./chunk-O5LRY6CO.mjs";
+import "./chunk-TRPZU2HV.mjs";
+import "./chunk-MPAI2MHO.mjs";
+import "./chunk-FHYIM4RD.mjs";
+import "./chunk-TNBK56IN.mjs";
+import "./chunk-N4B7FHQT.mjs";
+import "./chunk-ZISMEVKD.mjs";
 import "./chunk-J5LGTIGS.mjs";
 export {
   PersistentType,

package/dist/lib/neutral/{chunk-FZO7LQO7.mjs → chunk-44HT3MEC.mjs}

@@ -28,7 +28,7 @@ import {
   getOptionsAnnotation,
   getTypeEnum,
   typeToFormat
-} from "./chunk-B5OXLWZL.mjs";
+} from "./chunk-TRPZU2HV.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -70,4 +70,4 @@ __export(Format_exports, {
 export {
   Format_exports
 };
-//# sourceMappingURL=chunk-FZO7LQO7.mjs.map
+//# sourceMappingURL=chunk-44HT3MEC.mjs.map

package/dist/lib/neutral/{chunk-OENWMTE6.mjs → chunk-5SL5LDLD.mjs}

@@ -3,6 +3,7 @@ import {
   FormInputAnnotation,
   GeneratorAnnotation,
   IconAnnotation,
+  IconFromRefAnnotation,
   LabelAnnotation,
   ReferenceAnnotation,
   SystemTypeAnnotation,
@@ -13,7 +14,7 @@ import {
   makeUserAnnotation,
   setDescriptionWithSchema,
   setLabelWithSchema
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -25,6 +26,7 @@ __export(Annotation_exports, {
   FormInputAnnotation: () => FormInputAnnotation,
   GeneratorAnnotation: () => GeneratorAnnotation,
   IconAnnotation: () => IconAnnotation,
+  IconFromRefAnnotation: () => IconFromRefAnnotation,
   LabelAnnotation: () => LabelAnnotation,
   ReferenceAnnotation: () => ReferenceAnnotation,
   SystemTypeAnnotation: () => SystemTypeAnnotation,
@@ -42,4 +44,4 @@ export {
   make,
   Annotation_exports
 };
-//# sourceMappingURL=chunk-OENWMTE6.mjs.map
+//# sourceMappingURL=chunk-5SL5LDLD.mjs.map

package/dist/lib/neutral/chunk-5SL5LDLD.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Annotation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nexport {\n  DescriptionAnnotation,\n  FormInputAnnotation,\n  GeneratorAnnotation,\n  LabelAnnotation,\n  ReferenceAnnotation,\n  SystemTypeAnnotation,\n  TypeAnnotation,\n  getDescriptionWithSchema,\n  getLabelWithSchema,\n  getTypeAnnotation,\n  setDescriptionWithSchema,\n  setLabelWithSchema,\n  IconAnnotation,\n  IconFromRefAnnotation,\n} from './internal/Annotation';\n\nimport type * as Schema from 'effect/Schema';\n\nimport * as internalAnnotations from './internal/Annotation';\n\ninterface MakeProps<T> {\n  id: string;\n  schema: Schema.Schema<T, any, never>;\n}\n\n/**\n * Create a new schema annotation.\n * Annotation can be assigned both to fields and to the schema itself.\n * Annotation is serialized with the schema.\n *\n * @example\n * ```ts\n * const ColorAnnotation = Annotation.make({\n *   id: 'org.dxos.annotation.color',\n *   schema: Schema.String,\n * });\n *\n * const schema = Schema.String.annotations(ColorAnnotation.set('red'));\n * ```\n */\nexport const make: <T>(props: MakeProps<T>) => internalAnnotations.AnnotationHelper<T> =\n  internalAnnotations.makeUserAnnotation;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;AA+CO,IAAMA,OACSC;",
+  "names": ["make", "makeUserAnnotation"]
+}

package/dist/lib/neutral/{chunk-YWXWXIE5.mjs → chunk-6VIJV543.mjs}

@@ -1,6 +1,6 @@
 import {
   Ref
-} from "./chunk-43Y5DOS6.mjs";
+} from "./chunk-MPAI2MHO.mjs";
 
 // src/internal/Ref/ref-array.ts
 import { isNonNullable } from "@dxos/util";
@@ -31,4 +31,4 @@ var RefArray = Object.freeze({
 export {
   RefArray
 };
-//# sourceMappingURL=chunk-YWXWXIE5.mjs.map
+//# sourceMappingURL=chunk-6VIJV543.mjs.map

package/dist/lib/neutral/{chunk-YWXWXIE5.mjs.map → chunk-6VIJV543.mjs.map}

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/Ref/ref-array.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { type ObjectId } from '@dxos/keys';\nimport { isNonNullable } from '@dxos/util';\n\nimport { type AnyEntity } from '../common/types';\n\nimport { Ref } from './ref';\n\n/**\n * Helper functions for working with arrays of refs.\n */\nexport const RefArray = Object.freeze({\n  /**\n   * @returns all resolved targets.\n   */\n  targets: <T extends AnyEntity>(refs: readonly Ref<T>[]): T[] => {\n    return refs.map((ref) => ref.target).filter(isNonNullable);\n  },\n\n  /**\n   * Load all referenced objects.\n   */\n  loadAll: <T extends AnyEntity>(refs: readonly Ref<T>[]): Promise<T[]> => {\n    return Promise.all(refs.map((ref) => ref.load()));\n  },\n\n  /**\n   * Removes the ref with the given id.\n   */\n  removeById: (refs: Ref<AnyEntity>[], id: ObjectId) => {\n    const index = refs.findIndex(Ref.hasObjectId(id));\n    if (index >= 0) {\n      refs.splice(index, 1);\n    }\n  },\n});\n"],
-  "mappings": ";;;;;AAKA,SAASA,qBAAqB;AASvB,IAAMC,WAAWC,OAAOC,OAAO;;;;EAIpCC,SAAS,CAAsBC,SAAAA;AAC7B,WAAOA,KAAKC,IAAI,CAACC,QAAQA,IAAIC,MAAM,EAAEC,OAAOC,aAAAA;EAC9C;;;;EAKAC,SAAS,CAAsBN,SAAAA;AAC7B,WAAOO,QAAQC,IAAIR,KAAKC,IAAI,CAACC,QAAQA,IAAIO,KAAI,CAAA,CAAA;EAC/C;;;;EAKAC,YAAY,CAACV,MAAwBW,OAAAA;AACnC,UAAMC,QAAQZ,KAAKa,UAAUC,IAAIC,YAAYJ,EAAAA,CAAAA;AAC7C,QAAIC,SAAS,GAAG;AACdZ,WAAKgB,OAAOJ,OAAO,CAAA;IACrB;EACF;AACF,CAAA;",
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { type ObjectId } from '@dxos/keys';\nimport { isNonNullable } from '@dxos/util';\n\nimport { type AnyEntity } from '../common/types';\nimport { Ref } from './ref';\n\n/**\n * Helper functions for working with arrays of refs.\n */\nexport const RefArray = Object.freeze({\n  /**\n   * @returns all resolved targets.\n   */\n  targets: <T extends AnyEntity>(refs: readonly Ref<T>[]): T[] => {\n    return refs.map((ref) => ref.target).filter(isNonNullable);\n  },\n\n  /**\n   * Load all referenced objects.\n   */\n  loadAll: <T extends AnyEntity>(refs: readonly Ref<T>[]): Promise<T[]> => {\n    return Promise.all(refs.map((ref) => ref.load()));\n  },\n\n  /**\n   * Removes the ref with the given id.\n   */\n  removeById: (refs: Ref<AnyEntity>[], id: ObjectId) => {\n    const index = refs.findIndex(Ref.hasObjectId(id));\n    if (index >= 0) {\n      refs.splice(index, 1);\n    }\n  },\n});\n"],
+  "mappings": ";;;;;AAKA,SAASA,qBAAqB;AAQvB,IAAMC,WAAWC,OAAOC,OAAO;;;;EAIpCC,SAAS,CAAsBC,SAAAA;AAC7B,WAAOA,KAAKC,IAAI,CAACC,QAAQA,IAAIC,MAAM,EAAEC,OAAOC,aAAAA;EAC9C;;;;EAKAC,SAAS,CAAsBN,SAAAA;AAC7B,WAAOO,QAAQC,IAAIR,KAAKC,IAAI,CAACC,QAAQA,IAAIO,KAAI,CAAA,CAAA;EAC/C;;;;EAKAC,YAAY,CAACV,MAAwBW,OAAAA;AACnC,UAAMC,QAAQZ,KAAKa,UAAUC,IAAIC,YAAYJ,EAAAA,CAAAA;AAC7C,QAAIC,SAAS,GAAG;AACdZ,WAAKgB,OAAOJ,OAAO,CAAA;IACrB;EACF;AACF,CAAA;",
   "names": ["isNonNullable", "RefArray", "Object", "freeze", "targets", "refs", "map", "ref", "target", "filter", "isNonNullable", "loadAll", "Promise", "all", "load", "removeById", "id", "index", "findIndex", "Ref", "hasObjectId", "splice"]
 }

package/dist/lib/neutral/{chunk-ANHVGJI4.mjs → chunk-7RVZT53K.mjs}

@@ -18,4 +18,4 @@ export {
   SpaceId,
   ObjectId
 };
-//# sourceMappingURL=chunk-ANHVGJI4.mjs.map
+//# sourceMappingURL=chunk-7RVZT53K.mjs.map

package/dist/lib/neutral/{chunk-BNCCGLJN.mjs → chunk-BICZKPQG.mjs}

@@ -4,4 +4,4 @@ var SchemaRegistry_exports = {};
 export {
   SchemaRegistry_exports
 };
-//# sourceMappingURL=chunk-BNCCGLJN.mjs.map
+//# sourceMappingURL=chunk-BICZKPQG.mjs.map

package/dist/lib/neutral/{chunk-NEGC54NE.mjs → chunk-FHYIM4RD.mjs}

@@ -1,9 +1,9 @@
 import {
   isInstanceOf
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   ObjectNotFoundError
-} from "./chunk-UBEZSGXY.mjs";
+} from "./chunk-ZISMEVKD.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -23,9 +23,11 @@ __export(Database_exports, {
   makeService: () => makeService,
   notAvailable: () => notAvailable,
   query: () => query,
+  registerSchema: () => registerSchema,
   remove: () => remove,
   resolve: () => resolve,
   runQuery: () => runQuery,
+  runQueryFirst: () => runQueryFirst,
   runSchemaQuery: () => runSchemaQuery,
   schemaQuery: () => schemaQuery,
   spaceId: () => spaceId
@@ -76,33 +78,27 @@ var resolve = (ref, schema) => Effect.gen(function* () {
   if (!object) {
     return yield* Effect.fail(new ObjectNotFoundError(dxn));
   }
-  invariant(!schema || isInstanceOf(schema, object), "Object type mismatch.", {
-    F: __dxlog_file,
-    L: 230,
-    S: this,
-    A: [
-      "!schema || isInstanceOf(schema, object)",
-      "'Object type mismatch.'"
-    ]
-  });
+  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;
-});
-var load = Effect.fn(function* (ref) {
+}).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(function* (ref) {
+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)));
-var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj)));
-var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));
+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())));
+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())));
 
@@ -123,8 +119,10 @@ export {
   flush,
   query,
   runQuery,
+  runQueryFirst,
+  registerSchema,
   schemaQuery,
   runSchemaQuery,
   Database_exports
 };
-//# sourceMappingURL=chunk-NEGC54NE.mjs.map
+//# sourceMappingURL=chunk-FHYIM4RD.mjs.map

package/dist/lib/neutral/chunk-FHYIM4RD.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 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 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-RMLF7JOZ.mjs → chunk-FZHVQEHN.mjs}

@@ -4,17 +4,17 @@ import {
   EchoSchema,
   PersistentSchema,
   isMutable
-} from "./chunk-TQQZLKB7.mjs";
+} from "./chunk-SJKBWMJY.mjs";
 import {
   getSchemaDXN,
   getSchemaTypename,
   getSchemaVersion,
   getTypeAnnotation
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   EntityKind,
   SchemaKindId
-} from "./chunk-WYOKA6AE.mjs";
+} from "./chunk-N4B7FHQT.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -51,28 +51,12 @@ var getDXN = (schema) => {
 };
 var getTypename = (schema) => {
   const typename = getSchemaTypename(schema);
-  invariant(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", {
-    F: __dxlog_file,
-    L: 230,
-    S: void 0,
-    A: [
-      "typeof typename === 'string' && !typename.startsWith('dxn:')",
-      "'Invalid typename'"
-    ]
-  });
+  invariant(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 70, S: void 0, A: ["typeof typename === 'string' && !typename.startsWith('dxn:')", "'Invalid typename'"] });
   return typename;
 };
 var getVersion = (schema) => {
   const version = getSchemaVersion(schema);
-  invariant(typeof version === "string" && version.match(/^\d+\.\d+\.\d+$/), "Invalid version", {
-    F: __dxlog_file,
-    L: 240,
-    S: void 0,
-    A: [
-      "typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)",
-      "'Invalid version'"
-    ]
-  });
+  invariant(typeof version === "string" && version.match(/^\d+\.\d+\.\d+$/), "Invalid version", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 78, S: void 0, A: ["typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)", "'Invalid version'"] });
   return version;
 };
 var isMutable2 = isMutable;
@@ -94,4 +78,4 @@ export {
   getMeta,
   Type_exports
 };
-//# sourceMappingURL=chunk-RMLF7JOZ.mjs.map
+//# sourceMappingURL=chunk-FZHVQEHN.mjs.map

package/dist/lib/neutral/{chunk-RMLF7JOZ.mjs.map → chunk-FZHVQEHN.mjs.map}

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/Type.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\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 * as typeInternal from './internal/Type';\nimport * as internal from './internal';\nimport type * as ObjModule from './Obj';\nimport type * as RelationModule from './Relation';\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport const RuntimeType = typeInternal.EchoSchema;\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport type RuntimeType = typeInternal.EchoSchema;\n\n//\n// Internal types (not exported)\n//\n\n/**\n * Type that marks a schema as an ECHO schema.\n * The value indicates the entity kind (Object or Relation).\n */\ntype EchoSchemaKind<K extends internal.EntityKind = internal.EntityKind> = {\n  readonly [internal.SchemaKindId]: K;\n};\n\n//\n// Obj - Runtime schema for any ECHO object\n//\n\n/**\n * TypeScript type for an ECHO object schema.\n * `T` is the instance type produced by the schema.\n * `Fields` is the optional struct fields type for introspection.\n *\n * @example\n * ```ts\n * const PersonSchema: Type.Obj<Person> = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'Person', version: '0.1.0' }));\n *\n * // Access fields for introspection:\n * Object.keys(PersonSchema.fields); // ['name']\n * ```\n */\nexport interface Obj<T, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Object>,\n    Schema.AnnotableClass<\n      Obj<T, Fields>,\n      Entity.OfKind<typeof Entity.Kind.Object> & T,\n      Schema.Simplify<ObjModule.BaseObjJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO object schema.\n * Accepts both static schemas (created with Type.object()) and EchoSchema.\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isObjectSchema() for runtime type guards.\n */\ntype ObjectSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO object schema.\n * Accepts both static schemas (Type.object()) and mutable schemas (EchoSchema).\n */\nexport type AnyObj = ObjectSchemaBase;\n\n/**\n * Factory function to create an ECHO object schema.\n * Adds object metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'com.example.type.person', version: '0.1.0' }));\n * ```\n */\nexport const object: {\n  (opts: internal.TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => Obj<Schema.Schema.Type<Self>>;\n} = internal.EchoObjectSchema as any;\n\n//\n// PersistentType (Schema stored in database)\n//\n\nexport const PersistentType: Obj<typeInternal.PersistentSchema> = typeInternal.PersistentSchema as any;\n\nexport interface PersistentType extends Schema.Schema.Type<typeof PersistentType> {}\n\n/**\n * TypeScript type for an ECHO relation schema.\n * `T` is the instance type produced by the schema (excluding source/target).\n * `Source` and `Target` are the endpoint types.\n * `Fields` is the optional struct fields type for introspection.\n */\nexport interface Relation<T, Source, Target, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Relation>,\n    Schema.AnnotableClass<\n      Relation<T, Source, Target, Fields>,\n      Entity.OfKind<typeof Entity.Kind.Relation> & RelationModule.Endpoints<Source, Target> & T,\n      Schema.Simplify<RelationModule.BaseRelationJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO relation schema.\n * Accepts static schemas (created with Type.relation()).\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isRelationSchema() for runtime type guards.\n */\ntype RelationSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO relation schema.\n * Accepts static schemas (Type.relation()).\n */\nexport type AnyRelation = RelationSchemaBase;\n\n/**\n * Factory function to create an ECHO relation schema.\n * Adds relation metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const WorksFor = Schema.Struct({\n *   role: Schema.String,\n * }).pipe(Type.relation({\n *   typename: 'com.example.type.works-for',\n *   version: '0.1.0',\n *   source: Person,\n *   target: Company,\n * }));\n * ```\n */\nexport const relation: {\n  <SourceSchema extends Schema.Schema.AnyNoContext, TargetSchema extends Schema.Schema.AnyNoContext>(\n    opts: internal.EchoRelationSchemaOptions<SourceSchema, TargetSchema>,\n  ): <Self extends Schema.Schema.Any>(\n    self: Self,\n  ) => Relation<Schema.Schema.Type<Self>, Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>>;\n} = internal.EchoRelationSchema as any;\n\n/**\n * Type alias for any ECHO entity schema (object or relation).\n * Use this in type annotations for schema parameters.\n */\nexport type AnyEntity = AnyObj | AnyRelation;\n\n/**\n * Type guard to check if a schema is an object schema.\n * NOTE: This checks SCHEMAS, not instances. Use Obj.isObject for instances.\n */\nexport const isObjectSchema = (schema: AnyEntity): schema is AnyObj => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Object;\n};\n\n/**\n * Type guard to check if a schema is a relation schema.\n * NOTE: This checks SCHEMAS, not instances. Use Relation.isRelation for instances.\n */\nexport const isRelationSchema = (schema: AnyEntity): schema is AnyRelation => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * Type that represents any Ref schema (with unknown target type).\n * This is a schema type, not an instance type.\n */\nexport type AnyRef = Schema.Schema<internal.Ref<any>, EncodedReference>;\n\n//\n// Schema utility functions\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:com.example.type.person:0.1.0\"\n * @example \"dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX\"\n */\nexport const getDXN = (schema: AnyEntity): DXN | undefined => {\n  return internal.getSchemaDXN(schema);\n};\n\n/**\n * @param schema - Schema to get the typename from.\n * @returns The typename of the schema. Example: `com.example.type.person`.\n */\nexport const getTypename = (schema: AnyEntity): string => {\n  const typename = internal.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: AnyEntity): string => {\n  const version = internal.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 = typeInternal.isMutable;\n\n/**\n * ECHO type metadata.\n */\nexport type Meta = internal.TypeAnnotation;\n\n/**\n * Gets the meta data of the schema.\n */\nexport const getMeta = (schema: AnyEntity): Meta | undefined => {\n  return internal.getTypeAnnotation(schema);\n};\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;mBAAAA;EAAA;;;;;AASA,SAASC,iBAAiB;;AAanB,IAAMC,cAA2BC;AAmFjC,IAAMC,SAEAC;AAMN,IAAMC,iBAAkEC;AA4DxE,IAAMC,WAMAC;AAYN,IAAMC,iBAAiB,CAACC,WAAAA;AAC7B,SAAQA,OAAwBC,YAAY,MAAeC,WAAWC;AACxE;AAMO,IAAMC,mBAAmB,CAACJ,WAAAA;AAC/B,SAAQA,OAAwBC,YAAY,MAAeC,WAAWG;AACxE;AAkBO,IAAMC,SAAS,CAACN,WAAAA;AACrB,SAAgBO,aAAaP,MAAAA;AAC/B;AAMO,IAAMQ,cAAc,CAACR,WAAAA;AAC1B,QAAMS,WAAoBC,kBAAkBV,MAAAA;AAC5CW,YAAU,OAAOF,aAAa,YAAY,CAACA,SAASG,WAAW,MAAA,GAAS,oBAAA;;;;;;;;;AACxE,SAAOH;AACT;AAMO,IAAMI,aAAa,CAACb,WAAAA;AACzB,QAAMc,UAAmBC,iBAAiBf,MAAAA;AAC1CW,YAAU,OAAOG,YAAY,YAAYA,QAAQE,MAAM,iBAAA,GAAoB,mBAAA;;;;;;;;;AAC3E,SAAOF;AACT;AAKO,IAAMG,aAAyBA;AAU/B,IAAMC,UAAU,CAAClB,WAAAA;AACtB,SAAgBmB,kBAAkBnB,MAAAA;AACpC;",
-  "names": ["isMutable", "invariant", "RuntimeType", "EchoSchema", "object", "EchoObjectSchema", "PersistentType", "PersistentSchema", "relation", "EchoRelationSchema", "isObjectSchema", "schema", "SchemaKindId", "EntityKind", "Object", "isRelationSchema", "Relation", "getDXN", "getSchemaDXN", "getTypename", "typename", "getSchemaTypename", "invariant", "startsWith", "getVersion", "version", "getSchemaVersion", "match", "isMutable", "getMeta", "getTypeAnnotation"]
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\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 * as internal from './internal';\nimport * as typeInternal from './internal/Type';\nimport type * as ObjModule from './Obj';\nimport type * as RelationModule from './Relation';\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport const RuntimeType = typeInternal.EchoSchema;\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport type RuntimeType = typeInternal.EchoSchema;\n\n//\n// Internal types (not exported)\n//\n\n/**\n * Type that marks a schema as an ECHO schema.\n * The value indicates the entity kind (Object or Relation).\n */\ntype EchoSchemaKind<K extends internal.EntityKind = internal.EntityKind> = {\n  readonly [internal.SchemaKindId]: K;\n};\n\n//\n// Obj - Runtime schema for any ECHO object\n//\n\n/**\n * TypeScript type for an ECHO object schema.\n * `T` is the instance type produced by the schema.\n * `Fields` is the optional struct fields type for introspection.\n *\n * @example\n * ```ts\n * const PersonSchema: Type.Obj<Person> = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'Person', version: '0.1.0' }));\n *\n * // Access fields for introspection:\n * Object.keys(PersonSchema.fields); // ['name']\n * ```\n */\nexport interface Obj<T, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Object>,\n    Schema.AnnotableClass<\n      Obj<T, Fields>,\n      Entity.OfKind<typeof Entity.Kind.Object> & T,\n      Schema.Simplify<ObjModule.BaseObjJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO object schema.\n * Accepts both static schemas (created with Type.object()) and EchoSchema.\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isObjectSchema() for runtime type guards.\n */\ntype ObjectSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO object schema.\n * Accepts both static schemas (Type.object()) and mutable schemas (EchoSchema).\n */\nexport type AnyObj = ObjectSchemaBase;\n\n/**\n * Factory function to create an ECHO object schema.\n * Adds object metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'com.example.type.person', version: '0.1.0' }));\n * ```\n */\nexport const object: {\n  (opts: internal.TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => Obj<Schema.Schema.Type<Self>>;\n} = internal.EchoObjectSchema as any;\n\n//\n// PersistentType (Schema stored in database)\n//\n\nexport const PersistentType: Obj<typeInternal.PersistentSchema> = typeInternal.PersistentSchema as any;\n\nexport interface PersistentType extends Schema.Schema.Type<typeof PersistentType> {}\n\n/**\n * TypeScript type for an ECHO relation schema.\n * `T` is the instance type produced by the schema (excluding source/target).\n * `Source` and `Target` are the endpoint types.\n * `Fields` is the optional struct fields type for introspection.\n */\nexport interface Relation<T, Source, Target, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Relation>,\n    Schema.AnnotableClass<\n      Relation<T, Source, Target, Fields>,\n      Entity.OfKind<typeof Entity.Kind.Relation> & RelationModule.Endpoints<Source, Target> & T,\n      Schema.Simplify<RelationModule.BaseRelationJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO relation schema.\n * Accepts static schemas (created with Type.relation()).\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isRelationSchema() for runtime type guards.\n */\ntype RelationSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO relation schema.\n * Accepts static schemas (Type.relation()).\n */\nexport type AnyRelation = RelationSchemaBase;\n\n/**\n * Factory function to create an ECHO relation schema.\n * Adds relation metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const WorksFor = Schema.Struct({\n *   role: Schema.String,\n * }).pipe(Type.relation({\n *   typename: 'com.example.type.works-for',\n *   version: '0.1.0',\n *   source: Person,\n *   target: Company,\n * }));\n * ```\n */\nexport const relation: {\n  <SourceSchema extends Schema.Schema.AnyNoContext, TargetSchema extends Schema.Schema.AnyNoContext>(\n    opts: internal.EchoRelationSchemaOptions<SourceSchema, TargetSchema>,\n  ): <Self extends Schema.Schema.Any>(\n    self: Self,\n  ) => Relation<Schema.Schema.Type<Self>, Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>>;\n} = internal.EchoRelationSchema as any;\n\n/**\n * Type alias for any ECHO entity schema (object or relation).\n * Use this in type annotations for schema parameters.\n */\nexport type AnyEntity = AnyObj | AnyRelation;\n\n/**\n * Type guard to check if a schema is an object schema.\n * NOTE: This checks SCHEMAS, not instances. Use Obj.isObject for instances.\n */\nexport const isObjectSchema = (schema: AnyEntity): schema is AnyObj => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Object;\n};\n\n/**\n * Type guard to check if a schema is a relation schema.\n * NOTE: This checks SCHEMAS, not instances. Use Relation.isRelation for instances.\n */\nexport const isRelationSchema = (schema: AnyEntity): schema is AnyRelation => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * Type that represents any Ref schema (with unknown target type).\n * This is a schema type, not an instance type.\n */\nexport type AnyRef = Schema.Schema<internal.Ref<any>, EncodedReference>;\n\n//\n// Schema utility functions\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:com.example.type.person:0.1.0\"\n * @example \"dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX\"\n */\nexport const getDXN = (schema: AnyEntity): DXN | undefined => {\n  return internal.getSchemaDXN(schema);\n};\n\n/**\n * @param schema - Schema to get the typename from.\n * @returns The typename of the schema. Example: `com.example.type.person`.\n */\nexport const getTypename = (schema: AnyEntity): string => {\n  const typename = internal.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: AnyEntity): string => {\n  const version = internal.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 = typeInternal.isMutable;\n\n/**\n * ECHO type metadata.\n */\nexport type Meta = internal.TypeAnnotation;\n\n/**\n * Gets the meta data of the schema.\n */\nexport const getMeta = (schema: AnyEntity): Meta | undefined => {\n  return internal.getTypeAnnotation(schema);\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;mBAAAA;EAAA;;;;;AASA,SAASC,iBAAiB;AAU1B,IAAA,eAAA;;AA2FA,IAAA,SAAA;;;AAmFE,IAAA,iBAAA,CAAA,WAAA;AAEF,SAAA,OAAA,YAAA,MAAA,WAAA;;AAME,IAAA,mBAAA,CAAA,WAAA;AAQA,SAAA,OAAA,YAAA,MAAA,WAAA;AACF;AAWE,IAAA,SAAA,CAAA,WAAA;AAEF,SAAA,aAAA,MAAA;;AAMEC,IAAU,cAAOC,CAAAA,WAAa;AAC9B,QAAA,WAAOA,kBAAAA,MAAAA;AACP,YAAA,OAAA,aAAA,YAAA,CAAA,SAAA,WAAA,MAAA,GAAA,oBAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,QAAA,GAAA,CAAA,gEAAA,oBAAA,EAAA,CAAA;AAEF,SAAA;;AAMED,IAAU,aAAOE,CAAAA,WAAY;AAC7B,QAAA,UAAOA,iBAAAA,MAAAA;AACP,YAAA,OAAA,YAAA,YAAA,QAAA,MAAA,iBAAA,GAAA,mBAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,QAAA,GAAA,CAAA,wEAAA,mBAAA,EAAA,CAAA;AAEF,SAAA;;;AAeE,IAAA,UAAA,CAAA,WAAA;;;",
+  "names": ["isMutable", "invariant", "invariant", "typename", "version"]
 }

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

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Extension.ts
+var Extension_exports = {};
+__export(Extension_exports, {
+  Key: () => Key,
+  TypeId: () => TypeId,
+  Values: () => Values,
+  get: () => get,
+  make: () => make,
+  set: () => set
+});
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+var TypeId = "~@dxos/echo/Extension";
+var make = (key, valueSchema) => {
+  return {
+    [TypeId]: {},
+    key: Key.make(key),
+    valueSchema
+  };
+};
+var Key = Schema.String.pipe(Schema.brand("~@dxos/echo/ExtensionKey"));
+var Values = Schema.Record({
+  key: Key,
+  value: Schema.Unknown
+});
+var get = Function.dual(2, (values, extension) => {
+  if (!(extension.key in values)) {
+    return Option.none();
+  }
+  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);
+});
+var set = Function.dual(3, (values, extension, value) => {
+  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);
+});
+
+export {
+  TypeId,
+  make,
+  Key,
+  Values,
+  get,
+  set,
+  Extension_exports
+};
+//# sourceMappingURL=chunk-GWFFC34K.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Extension.ts"],
+  "sourcesContent": ["// @import-as-namespace\n//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\n// @import-as-namespace\n\n/**\n * Extensions allow objects to contain typed properties that are not part of the schema.\n */\n\nexport const TypeId = '~@dxos/echo/Extension' as const;\nexport type TypeId = typeof TypeId;\n\nexport interface Extension<T> extends Record<\n  TypeId,\n  {\n    _Type: T;\n  }\n> {\n  readonly [TypeId]: {\n    _Type: T;\n  };\n\n  readonly key: Key;\n  readonly valueSchema: Schema.Schema<T>;\n}\n\n/**\n * Create a new typed extension.\n *\n * ```ts\n * const ColorExtension = Extension.make('color', Schema.String);\n *\n * const obj = Obj.make(Person, {\n *   [Obj.Meta]: { keys: [{ source: 'external', id: '123' }] },\n *   name: 'John',\n *   email: 'john@example.com',\n * });\n *\n * Obj.update(obj, (obj) => {\n *   Extension.set(obj.extensions, ColorExtension, 'red');\n * });\n *\n * console.log(Extension.get(obj.extensions, ColorExtension)); // 'red'\n * ```\n */\nexport const make = <S extends Schema.Schema.AnyNoContext>(\n  key: string,\n  valueSchema: S,\n): Extension<Schema.Schema.Type<S>> => {\n  return {\n    [TypeId]: {} as any,\n    key: Key.make(key),\n    valueSchema,\n  };\n};\n\n/**\n * Unique identifier for an extension.\n */\n// TODO(dmaretskyi): filter to be fully qualified: (e.g., org.dxos.extension.color)\nexport const Key = Schema.String.pipe(Schema.brand('~@dxos/echo/ExtensionKey'));\nexport type Key = Schema.Schema.Type<typeof Key>;\n\n/**\n * Set of extension values.\n *\n * Can be used inside an object/relation schema:\n *\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n *   extensions: Extension.Values,\n * });\n * ```\n */\nexport const Values = Schema.Record({ key: Key, value: Schema.Unknown });\nexport interface Values extends Schema.Schema.Type<typeof Values> {}\n\n/**\n * Get the value of an extension from a set of values.\n */\nexport const get: {\n  <T>(extension: Extension<T>): (values: Values) => Option.Option<T>;\n  <T>(values: Values, extension: Extension<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(extension: Extension<T>) => (values: Values) => Option.Option<T>,\n  <T>(values: Values, extension: Extension<T>) => Option.Option<T>\n>(2, (values, extension) => {\n  if (!(extension.key in values)) {\n    return Option.none();\n  }\n\n  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);\n});\n\n/**\n * Set the value of an extension in a set of values.\n *\n * Can also be used within Obj.update callback:\n *\n * ```ts\n * Obj.update(obj, (obj) => {\n *   Extension.set(obj.extensions, ColorExtension, 'red');\n * });\n * ```\n */\nexport const set: {\n  <T>(extension: Extension<T>, value: T): (values: Values) => void;\n  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T): void;\n} = Function.dual<\n  <T>(extension: Extension<T>, value: T) => (values: Values) => void,\n  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T) => void\n>(3, (values, extension, value) => {\n  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);\n});\n"],
+  "mappings": ";;;;;AAAA;;;;;;;;;AAKA,YAAYA,cAAc;AAC1B,YAAYC,YAAY;AACxB,YAAYC,YAAY;AASjB,IAAMC,SAAS;AAoCf,IAAMC,OAAO,CAClBC,KACAC,gBAAAA;AAEA,SAAO;IACL,CAACH,MAAAA,GAAS,CAAC;IACXE,KAAKE,IAAIH,KAAKC,GAAAA;IACdC;EACF;AACF;AAMO,IAAMC,MAAaC,cAAOC,KAAYC,aAAM,0BAAA,CAAA;AAe5C,IAAMC,SAAgBC,cAAO;EAAEP,KAAKE;EAAKM,OAAcC;AAAQ,CAAA;AAM/D,IAAMC,MAGAC,cAGX,GAAG,CAACC,QAAQC,cAAAA;AACZ,MAAI,EAAEA,UAAUb,OAAOY,SAAS;AAC9B,WAAcE,YAAI;EACpB;AAEA,SAAgBV,cAAKQ,OAAOC,UAAUb,GAAG,GAAUe,yBAAkBF,UAAUZ,WAAW,GAAUe,WAAI;AAC1G,CAAA;AAaO,IAAMC,MAGAN,cAGX,GAAG,CAACC,QAAQC,WAAWL,UAAAA;AACvBI,SAAOC,UAAUb,GAAG,IAAWkB,kBAAWL,UAAUZ,WAAW,EAAEO,KAAAA;AACnE,CAAA;",
+  "names": ["Function", "Option", "Schema", "TypeId", "make", "key", "valueSchema", "Key", "String", "pipe", "brand", "Values", "Record", "value", "Unknown", "get", "dual", "values", "extension", "none", "decodeUnknownSync", "some", "set", "encodeSync"]
+}

package/dist/lib/neutral/{chunk-724GQYEN.mjs → chunk-HPNQTEEQ.mjs}

@@ -1,13 +1,13 @@
 import {
   object
-} from "./chunk-RMLF7JOZ.mjs";
+} from "./chunk-FZHVQEHN.mjs";
 import {
   make
-} from "./chunk-NQRLRYJM.mjs";
+} from "./chunk-SW5CUSBY.mjs";
 import {
   LabelAnnotation,
   SystemTypeAnnotation
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -53,4 +53,4 @@ export {
   findTagByLabel,
   Tag_exports
 };
-//# sourceMappingURL=chunk-724GQYEN.mjs.map
+//# sourceMappingURL=chunk-HPNQTEEQ.mjs.map

package/dist/lib/neutral/{chunk-UFDK26FO.mjs → chunk-LVGOVFDV.mjs}

@@ -10,20 +10,21 @@ import {
   objectToJSON,
   removeTag,
   subscribe
-} from "./chunk-TQQZLKB7.mjs";
+} from "./chunk-SJKBWMJY.mjs";
 import {
   getDescription,
   getEntityKind,
   getLabel,
+  getSchema,
   getTypeDXN,
   getTypename
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   EntityKind,
   EntityKindSchema,
   KindId,
   SnapshotKindId
-} from "./chunk-WYOKA6AE.mjs";
+} from "./chunk-N4B7FHQT.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -37,7 +38,6 @@ __export(Entity_exports, {
   Meta: () => Meta,
   SnapshotKindId: () => SnapshotKindId2,
   addTag: () => addTag2,
-  change: () => change2,
   getDXN: () => getDXN2,
   getDatabase: () => getDatabase2,
   getDescription: () => getDescription2,
@@ -45,6 +45,7 @@ __export(Entity_exports, {
   getKind: () => getKind,
   getLabel: () => getLabel2,
   getMeta: () => getMeta,
+  getSchema: () => getSchema2,
   getTypeDXN: () => getTypeDXN2,
   getTypename: () => getTypename2,
   isDeleted: () => isDeleted2,
@@ -52,7 +53,8 @@ __export(Entity_exports, {
   isSnapshot: () => isSnapshot,
   removeTag: () => removeTag2,
   subscribe: () => subscribe2,
-  toJSON: () => toJSON
+  toJSON: () => toJSON,
+  update: () => update
 });
 var KindId2 = KindId;
 var SnapshotKindId2 = SnapshotKindId;
@@ -74,6 +76,7 @@ var getKind = getEntityKind;
 var Meta = MetaId;
 var getDXN2 = (entity) => getDXN(entity);
 var getTypeDXN2 = getTypeDXN;
+var getSchema2 = getSchema;
 var getTypename2 = (entity) => getTypename(entity);
 var getDatabase2 = (entity) => getDatabase(entity);
 function getMeta(entity) {
@@ -87,7 +90,7 @@ var toJSON = (entity) => objectToJSON(entity);
 var subscribe2 = (entity, callback) => {
   return subscribe(entity, callback);
 };
-var change2 = (entity, callback) => {
+var update = (entity, callback) => {
   change(entity, callback);
 };
 var addTag2 = (entity, tag) => addTag(entity, tag);
@@ -104,6 +107,7 @@ export {
   Meta,
   getDXN2 as getDXN,
   getTypeDXN2 as getTypeDXN,
+  getSchema2 as getSchema,
   getTypename2 as getTypename,
   getDatabase2 as getDatabase,
   getMeta,
@@ -113,9 +117,9 @@ export {
   getDescription2 as getDescription,
   toJSON,
   subscribe2 as subscribe,
-  change2 as change,
+  update,
   addTag2 as addTag,
   removeTag2 as removeTag,
   Entity_exports
 };
-//# sourceMappingURL=chunk-UFDK26FO.mjs.map
+//# sourceMappingURL=chunk-LVGOVFDV.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Entity.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport type { DXN, ObjectId } from '@dxos/keys';\n\nimport * as internal from './internal';\nimport type * as Relation from './Relation';\nimport type * as Type from './Type';\n\n// Re-export KindId and SnapshotKindId from internal.\nexport const KindId = internal.KindId;\nexport type KindId = typeof internal.KindId;\nexport const SnapshotKindId = internal.SnapshotKindId;\nexport type SnapshotKindId = typeof internal.SnapshotKindId;\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.Unknown and Relation.Unknown (i.e., Entity.Unknown) instances.\n\nexport const Kind = internal.EntityKind;\nexport type Kind = internal.EntityKind;\nexport const KindSchema = internal.EntityKindSchema;\n\n/**\n * Assigns a kind to an Object or Relation instance.\n * NOTE: Needed to make `isRelation` and `isObject` checks work.\n */\nexport interface OfKind<K extends Kind> {\n  readonly [KindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Assigns a snapshot kind to an Object or Relation snapshot.\n */\nexport interface SnapshotOfKind<K extends Kind> {\n  readonly [SnapshotKindId]: 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 (reactive).\n */\nexport interface Unknown extends OfKind<Kind> {}\n\n/**\n * Snapshot of an Obj or Relation.\n * Branded with SnapshotKindId instead of KindId.\n */\nexport interface Snapshot extends SnapshotOfKind<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.Unknown that is not permissive and requires explicit instanceof checks..\n */\nexport interface Any extends OfKind<Kind> {\n  [key: string]: unknown;\n}\n\n/**\n * Returns all properties of an object or relation except for the id and kind.\n */\nexport type Properties<T> = Omit<T, 'id' | KindId | Relation.Source | Relation.Target>;\n\n/**\n * Check if a value is an ECHO entity (object or relation).\n * Returns `false` for snapshots.\n */\nexport const isEntity = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[KindId] !== undefined;\n};\n\n/**\n * Check if a value is an ECHO entity snapshot.\n * Returns `false` for entities.\n */\nexport const isSnapshot = (value: unknown): value is Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[SnapshotKindId] !== undefined;\n};\n\n// TODO(dmaretskyi): Type introspection -- move to kind.\nexport const getKind = internal.getEntityKind;\n\n/**\n * Property that accesses metadata for an entity.\n */\nexport const Meta: unique symbol = internal.MetaId as any;\n\n/**\n * Property that accesses metadata for an entity.\n */\nexport type Meta = typeof Meta;\n\n//\n// Entity-level functions that work on any entity (object or relation).\n// Use these when you don't know or care about the specific entity kind.\n// For kind-specific functions, use Obj.* or Relation.*.\n//\n\n/**\n * JSON representation of an entity.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Get the DXN of an entity (object or relation).\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => internal.getDXN(entity);\n\n/**\n * Get the DXN of an entity's type.\n */\nexport const getTypeDXN = internal.getTypeDXN;\n\n/**\n * Get the schema of an entity.\n * Returns the branded ECHO schema used to create the entity.\n */\nexport const getSchema: (entity: Unknown | Snapshot) => Type.AnyEntity | undefined = internal.getSchema as any;\n\n/**\n * Get the typename of an entity's type.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n/**\n * Get the database an entity belongs to.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): any | undefined => internal.getDatabase(entity);\n\n/**\n * Get the metadata for an entity.\n * Returns mutable meta when passed a mutable entity (inside change callback).\n * Returns read-only meta when passed a regular entity or snapshot.\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>): internal.ObjectMeta;\nexport function getMeta(entity: Unknown | Snapshot): internal.ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): internal.ObjectMeta | internal.ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * Get foreign keys for an entity from the specified source.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Check if an entity is deleted.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n/**\n * Get the label of an entity.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Get the description of an entity.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Convert an entity to its JSON representation.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n/**\n * Subscribe to changes on an entity (object or relation).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (entity: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(entity, callback);\n};\n\n//\n// Change\n//\n\n/**\n * Used to provide a mutable view of an entity within `Entity.update`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an entity (object or relation) within a change context.\n *\n * Entities are read-only by default. Mutations are batched and notifications fire\n * when the callback completes. Direct mutations outside of `Entity.update` will throw\n * at runtime.\n *\n * @param entity - The echo entity (object or relation) to mutate.\n * @param callback - Receives a mutable view of the entity. All mutations must occur here.\n *\n * @example\n * ```typescript\n * // Mutate within Entity.update\n * Entity.update(entity, (obj) => {\n *   obj.name = 'Updated';\n *   obj.count = 42;\n * });\n *\n * // Direct mutation throws\n * entity.name = 'Bob'; // Error: Cannot modify outside Entity.update()\n * ```\n *\n * Note: For type-specific operations, prefer `Obj.update` or `Relation.update`.\n */\nexport const update = <T extends Unknown>(entity: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(entity, callback);\n};\n\n/**\n * Add a tag to an entity.\n * Must be called within an `Entity.update`, `Obj.update`, or `Relation.update` callback.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from an entity.\n * Must be called within an `Entity.update`, `Obj.update`, or `Relation.update` callback.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => internal.removeTag(entity, tag);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;gBAAAA;EAAA;;wBAAAC;EAAA,cAAAC;EAAA,cAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,eAAAC;EAAA;kBAAAC;EAAA;mBAAAC;EAAA,kBAAAC;EAAA,mBAAAC;EAAA,iBAAAC;EAAA;;mBAAAC;EAAA,iBAAAC;EAAA;;;AAcO,IAAMC,UAAkBA;AAExB,IAAMC,kBAA0BA;AAOhC,IAAMC,OAAgBC;AAEtB,IAAMC,aAAsBC;AAyD5B,IAAMC,WAAW,CAACC,UAAAA;AACvB,MAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;AAC/C,WAAO;EACT;AACA,SAAQA,MAAcP,OAAAA,MAAYQ;AACpC;AAMO,IAAMC,aAAa,CAACF,UAAAA;AACzB,MAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;AAC/C,WAAO;EACT;AACA,SAAQA,MAAcN,eAAAA,MAAoBO;AAC5C;AAGO,IAAME,UAAmBC;AAKzB,IAAMC,OAA+BC;AAqBrC,IAAMC,UAAS,CAACC,WAA6CD,OAAOC,MAAAA;AAKpE,IAAMC,cAAsBA;AAM5B,IAAMC,aAAiFA;AAKvF,IAAMC,eAAc,CAACH,WAA4DG,YAAYH,MAAAA;AAK7F,IAAMI,eAAc,CAACJ,WAAyDI,YAAYJ,MAAAA;AAU1F,SAASK,QAAQL,QAA6C;AACnE,SAAgBM,eAAeN,MAAAA;AACjC;AAKO,IAAMO,WAAU,CAACP,QAA4BQ,WAA0CD,QAAQP,QAAQQ,MAAAA;AAKvG,IAAMC,aAAY,CAACT,WAAiDS,UAAUT,MAAAA;AAK9E,IAAMU,YAAW,CAACV,WAA4DU,SAASV,MAAAA;AAKvF,IAAMW,kBAAiB,CAACX,WAA4DW,eAAeX,MAAAA;AAKnG,IAAMY,SAAS,CAACZ,WAA8Ca,aAAab,MAAAA;AAM3E,IAAMc,aAAY,CAACd,QAAiBe,aAAAA;AACzC,SAAgBD,UAAUd,QAAQe,QAAAA;AACpC;AAmCO,IAAMC,SAAS,CAAoBhB,QAAWe,aAAAA;AACnDE,EAASC,OAAOlB,QAAQe,QAAAA;AAC1B;AAMO,IAAMI,UAAS,CAACnB,QAA0BoB,QAA+BD,OAAOnB,QAAQoB,GAAAA;AAMxF,IAAMC,aAAY,CAACrB,QAA0BoB,QAA+BC,UAAUrB,QAAQoB,GAAAA;",
+  "names": ["KindId", "SnapshotKindId", "addTag", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "subscribe", "KindId", "SnapshotKindId", "Kind", "EntityKind", "KindSchema", "EntityKindSchema", "isEntity", "value", "undefined", "isSnapshot", "getKind", "getEntityKind", "Meta", "MetaId", "getDXN", "entity", "getTypeDXN", "getSchema", "getTypename", "getDatabase", "getMeta", "getMetaChecked", "getKeys", "source", "isDeleted", "getLabel", "getDescription", "toJSON", "objectToJSON", "subscribe", "callback", "update", "internal", "change", "addTag", "tag", "removeTag"]
+}