@dxos/echo 0.8.4-main.9735255 → 0.8.4-main.9be5663bfe

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

@@ -0,0 +1,120 @@
+import {
+  object
+} from "./chunk-UPWIIW2V.mjs";
+import {
+  getDXN,
+  make
+} from "./chunk-ZGVZNBBJ.mjs";
+import {
+  FormInputAnnotation,
+  IconAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-6URFBQJH.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Feed.ts
+var Feed_exports = {};
+__export(Feed_exports, {
+  Feed: () => Feed,
+  FeedService: () => FeedService,
+  Service: () => Service,
+  append: () => append,
+  cursor: () => cursor,
+  getQueueDxn: () => getQueueDxn,
+  make: () => make2,
+  next: () => next,
+  nextOption: () => nextOption,
+  notAvailable: () => notAvailable,
+  query: () => query,
+  remove: () => remove,
+  runQuery: () => runQuery,
+  setRetention: () => setRetention
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { DXN } from "@dxos/keys";
+var Feed = Schema.Struct({
+  /** User-facing display name. */
+  name: Schema.String.pipe(Schema.optional),
+  /** Identifier for the feed's kind (e.g., plugin id). */
+  kind: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),
+  /**
+  * Feed namespace.
+  * Controls how feed data is stored and replicated.
+  * - `data`: Data feed (default).
+  * - `trace`: Trace feed.
+  */
+  namespace: Schema.optional(Schema.Literal("data", "trace"))
+}).pipe(object({
+  typename: "org.dxos.type.feed",
+  version: "0.1.0"
+}), SystemTypeAnnotation.set(true), IconAnnotation.set({
+  icon: "ph--rows--regular",
+  hue: "yellow"
+}));
+var make2 = (props = {}) => make(Feed, props);
+var getQueueDxn = (feed) => {
+  const self = getDXN(feed).asEchoDXN();
+  if (!self || !self.spaceId) {
+    return void 0;
+  }
+  return new DXN(DXN.kind.QUEUE, [
+    feed.namespace ?? "data",
+    self.spaceId,
+    self.echoId
+  ]);
+};
+var FeedService = class extends Context.Tag("@dxos/echo/Feed/FeedService")() {
+};
+var Service = FeedService;
+var notAvailable = Layer.succeed(FeedService, {
+  append: () => {
+    throw new Error("Feed.FeedService not available");
+  },
+  remove: () => {
+    throw new Error("Feed.FeedService not available");
+  },
+  query: () => {
+    throw new Error("Feed.FeedService not available");
+  }
+});
+var append = (feed, items) => Effect.gen(function* () {
+  const service = yield* FeedService;
+  yield* Effect.promise(() => service.append(feed, items));
+});
+var remove = (feed, items) => Effect.gen(function* () {
+  const service = yield* FeedService;
+  const ids = items.map((item) => item.id);
+  yield* Effect.promise(() => service.remove(feed, ids));
+});
+var query = (feed, queryOrFilter) => FeedService.pipe(Effect.map((service) => service.query(feed, queryOrFilter)));
+var runQuery = (feed, queryOrFilter) => query(feed, queryOrFilter).pipe(Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())));
+var cursor = (_feed) => Effect.succeed({
+  _tag: "Cursor"
+});
+var next = (_cursor) => Effect.die("Feed.next is not yet implemented");
+var nextOption = (_cursor) => Effect.die("Feed.nextOption is not yet implemented");
+var setRetention = (_feed, _options) => Effect.void;
+
+export {
+  Feed,
+  make2 as make,
+  getQueueDxn,
+  FeedService,
+  Service,
+  notAvailable,
+  append,
+  remove,
+  query,
+  runQuery,
+  cursor,
+  next,
+  nextOption,
+  setRetention,
+  Feed_exports
+};
+//# sourceMappingURL=chunk-HBJ7JT5A.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Feed.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 type * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\n\nimport { DXN } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport type * as Entity from './Entity';\nimport type * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport * as Type from './Type';\n\n/**\n * Runtime schema for a Feed object.\n *\n * @example\n * ```ts\n * const feed = Obj.make(Feed.Feed, { name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });\n * ```\n */\nexport const Feed = Schema.Struct({\n  /** User-facing display name. */\n  name: Schema.String.pipe(Schema.optional),\n  /** Identifier for the feed's kind (e.g., plugin id). */\n  kind: Schema.String.pipe(internal.FormInputAnnotation.set(false), Schema.optional),\n\n  /**\n   * Feed namespace.\n   * Controls how feed data is stored and replicated.\n   * - `data`: Data feed (default).\n   * - `trace`: Trace feed.\n   */\n  namespace: Schema.optional(Schema.Literal('data', 'trace')),\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.feed',\n    version: '0.1.0',\n  }),\n  internal.SystemTypeAnnotation.set(true),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--rows--regular',\n    hue: 'yellow',\n  }),\n);\n\n/**\n * TypeScript instance type for a Feed object.\n */\nexport interface Feed extends Schema.Schema.Type<typeof Feed> {}\n\n//\n// Types\n//\n\n/**\n * Opaque cursor for iterating over feed items.\n */\n// TODO(dmaretskyi): T needs to be referenced in the type structure for typescript to respect it during inference and type-checking.\nexport interface Cursor<T = Obj.Snapshot> {\n  readonly _tag: 'Cursor';\n}\n\n/**\n * Retention options for a feed.\n */\nexport interface RetentionOptions {\n  /** Retain items after this cursor position. */\n  // TODO(wittjosiah): Use FeedCursor from @dxos/feed?\n  cursor?: string;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates a new feed object.\n *\n * @example\n * ```ts\n * const feed = Feed.make({ name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });\n * ```\n */\n// TODO(wittjosiah): How to control the feed namespace (data/trace)? Why do feeds have namespaces?\nexport const make = (props: Obj.MakeProps<typeof Feed> = {}): Feed => Obj.make(Feed, props);\n\n/**\n * Derives the queue DXN from the feed object's DXN.\n * Returns `undefined` when the feed is not stored in a space yet.\n *\n * Used internally by the feed service layer.\n */\nexport const getQueueDxn = (feed: Feed): DXN | undefined => {\n  const self = Obj.getDXN(feed).asEchoDXN();\n  if (!self || !self.spaceId) {\n    return undefined;\n  }\n  return new DXN(DXN.kind.QUEUE, [feed.namespace ?? 'data', self.spaceId, self.echoId]);\n};\n\n//\n// Service\n//\n\n/**\n * Effect service for feed operations.\n * Provides the bridge to the underlying storage implementation.\n * Must be provided by the application layer (e.g., echo-db).\n */\nexport class FeedService extends Context.Tag('@dxos/echo/Feed/FeedService')<\n  FeedService,\n  {\n    /**\n     * Appends items to a feed.\n     */\n    append(feed: Feed, items: Entity.Unknown[]): Promise<void>;\n\n    /**\n     * Removes items from a feed by ID.\n     */\n    // TODO(dmaretskyi): Change type to ObjectId.\n    remove(feed: Feed, ids: string[]): Promise<void>;\n\n    /**\n     * Queries items in a feed.\n     */\n    query: {\n      <Q extends Query.Any>(feed: Feed, query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n      <F extends Filter.Any>(feed: Feed, filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n    };\n  }\n>() {}\n\n/**\n * @deprecated Use `FeedService` instead.\n */\nexport type Service = FeedService;\n\n/**\n * @deprecated Use `FeedService` instead.\n */\nexport const Service = FeedService;\n\n/**\n * Layer that provides a Feed service that throws when accessed.\n * Useful as a default layer when no feed service is available.\n */\nexport const notAvailable: Layer.Layer<FeedService> = Layer.succeed(FeedService, {\n  append: () => {\n    throw new Error('Feed.FeedService not available');\n  },\n  remove: () => {\n    throw new Error('Feed.FeedService not available');\n  },\n  query: () => {\n    throw new Error('Feed.FeedService not available');\n  },\n} as Context.Tag.Service<FeedService>);\n\n//\n// Operations\n//\n\n/**\n * Appends items to a feed.\n *\n * @example\n * ```ts\n * yield* Feed.append(feed, [Obj.make(Notification, { title: 'Hello' })]);\n * ```\n */\nexport const append = (feed: Feed, items: Entity.Unknown[]): Effect.Effect<void, never, FeedService> =>\n  Effect.gen(function* () {\n    const service = yield* FeedService;\n    yield* Effect.promise(() => service.append(feed, items));\n  });\n\n/**\n * Removes items from a feed.\n *\n * @example\n * ```ts\n * yield* Feed.remove(feed, [item]);\n * ```\n */\n// TODO(dmaretskyi): Should we allow snapshots here? - what does it mean to remove a snapshot?\nexport const remove = (feed: Feed, items: (Entity.Unknown | Obj.Snapshot)[]): Effect.Effect<void, never, FeedService> =>\n  Effect.gen(function* () {\n    const service = yield* FeedService;\n    const ids = items.map((item) => item.id);\n    yield* Effect.promise(() => service.remove(feed, ids));\n  });\n\n/**\n * Creates a reactive query over items in a feed.\n *\n * @example\n * ```ts\n * const result = yield* Feed.query(feed, Filter.type(Person));\n * ```\n */\n// TODO(dmaretskyi): Suport chained queries:\n//                   const result = yield* feed.pipe(Feed.query(Filter.type(Person))); result.subscribe(...)\n//                   const objects = yield* feed.pipe(Feed.query(Filter.type(Person))).run;\n//                   const object = yield* feed.pipe(Feed.query(Filter.type(Person))).first;\n// ... unify for Database and schema queries.\nexport const query: {\n  <Q extends Query.Any>(\n    feed: Feed,\n    query: Q,\n  ): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, FeedService>;\n  <F extends Filter.Any>(\n    feed: Feed,\n    filter: F,\n  ): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, FeedService>;\n} = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>\n  FeedService.pipe(Effect.map((service) => service.query(feed, queryOrFilter as any) as QueryResult.QueryResult<any>));\n\n/**\n * Executes a feed query once and returns the results.\n *\n * @example\n * ```ts\n * const items = yield* Feed.runQuery(feed, Filter.type(Person));\n * ```\n */\nexport const runQuery: {\n  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<Query.Type<Q>[], never, FeedService>;\n  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<Filter.Type<F>[], never, FeedService>;\n} = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>\n  query(feed, queryOrFilter as any).pipe(Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())));\n\n/**\n * Creates a cursor for iterating over feed items.\n * Currently stubbed — cursor operations are not yet implemented.\n *\n * @example\n * ```ts\n * const cursor = yield* Feed.cursor<Person>(feed);\n * const item = yield* Feed.next(cursor);\n * ```\n */\n// TODO(wittjosiah): Implement cursor operations. Use Effect streams?\nexport const cursor = <T = Obj.Snapshot>(_feed: Feed): Effect.Effect<Cursor<T>, never, FeedService> =>\n  Effect.succeed({ _tag: 'Cursor' } as Cursor<T>);\n\n/**\n * Returns the next item from a feed cursor.\n * Currently stubbed — cursor operations are not yet implemented.\n */\nexport const next = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<T, never, FeedService> =>\n  Effect.die('Feed.next is not yet implemented');\n\n/**\n * Returns the next item from a feed cursor as an Option.\n * Currently stubbed — cursor operations are not yet implemented.\n */\nexport const nextOption = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<Option.Option<T>, never, FeedService> =>\n  Effect.die('Feed.nextOption is not yet implemented');\n\n/**\n * Sets the local retention policy for a feed.\n * Currently stubbed — queues do not yet support retention.\n *\n * @example\n * ```ts\n * yield* Feed.setRetention(feed, { count: 1000 });\n * ```\n */\n// TODO(feed): Implement when queue retention is supported.\nexport const setRetention = (_feed: Feed, _options: RetentionOptions): Effect.Effect<void, never, FeedService> =>\n  Effect.void;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;;;;;;;;cAAAA;EAAA;;;;;;;;AAMA,YAAYC,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AAEvB,YAAYC,YAAY;AAExB,SAASC,WAAW;AAmBb,IAAMC,OAAcC,cAAO;;EAEhCC,MAAaC,cAAOC,KAAYC,eAAQ;;EAExCC,MAAaH,cAAOC,KAAcG,oBAAoBC,IAAI,KAAA,GAAeH,eAAQ;;;;;;;EAQjFI,WAAkBJ,gBAAgBK,eAAQ,QAAQ,OAAA,CAAA;AACpD,CAAA,EAAGN,KACIO,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACSC,qBAAqBN,IAAI,IAAA,GACvBO,eAAeP,IAAI;EAC5BQ,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AA0CK,IAAMC,QAAO,CAACC,QAAoC,CAAC,MAAgBD,KAAKlB,MAAMmB,KAAAA;AAQ9E,IAAMC,cAAc,CAACC,SAAAA;AAC1B,QAAMC,OAAWC,OAAOF,IAAAA,EAAMG,UAAS;AACvC,MAAI,CAACF,QAAQ,CAACA,KAAKG,SAAS;AAC1B,WAAOC;EACT;AACA,SAAO,IAAIC,IAAIA,IAAIrB,KAAKsB,OAAO;IAACP,KAAKZ,aAAa;IAAQa,KAAKG;IAASH,KAAKO;GAAO;AACtF;AAWO,IAAMC,cAAN,cAAkCC,YAAI,6BAAA,EAAA,EAAA;AAsBxC;AAUE,IAAMC,UAAUF;AAMhB,IAAMG,eAA+CC,cAAQJ,aAAa;EAC/EK,QAAQ,MAAA;AACN,UAAM,IAAIC,MAAM,gCAAA;EAClB;EACAC,QAAQ,MAAA;AACN,UAAM,IAAID,MAAM,gCAAA;EAClB;EACAE,OAAO,MAAA;AACL,UAAM,IAAIF,MAAM,gCAAA;EAClB;AACF,CAAA;AAcO,IAAMD,SAAS,CAACd,MAAYkB,UAC1BC,WAAI,aAAA;AACT,QAAMC,UAAU,OAAOX;AACvB,SAAcY,eAAQ,MAAMD,QAAQN,OAAOd,MAAMkB,KAAAA,CAAAA;AACnD,CAAA;AAWK,IAAMF,SAAS,CAAChB,MAAYkB,UAC1BC,WAAI,aAAA;AACT,QAAMC,UAAU,OAAOX;AACvB,QAAMa,MAAMJ,MAAMK,IAAI,CAACC,SAASA,KAAKC,EAAE;AACvC,SAAcJ,eAAQ,MAAMD,QAAQJ,OAAOhB,MAAMsB,GAAAA,CAAAA;AACnD,CAAA;AAeK,IAAML,QAST,CAACjB,MAAY0B,kBACfjB,YAAY1B,KAAYwC,WAAI,CAACH,YAAYA,QAAQH,MAAMjB,MAAM0B,aAAAA,CAAAA,CAAAA;AAUxD,IAAMC,WAGT,CAAC3B,MAAY0B,kBACfT,MAAMjB,MAAM0B,aAAAA,EAAsB3C,KAAY6C,eAAQ,CAACC,gBAAuBR,eAAQ,MAAMQ,YAAYC,IAAG,CAAA,CAAA,CAAA;AAatG,IAAMC,SAAS,CAAmBC,UAChCnB,eAAQ;EAAEoB,MAAM;AAAS,CAAA;AAM3B,IAAMC,OAAO,CAAmBC,YAC9BC,WAAI,kCAAA;AAMN,IAAMC,aAAa,CAAmBF,YACpCC,WAAI,wCAAA;AAYN,IAAME,eAAe,CAACN,OAAaO,aACjCC;",
+  "names": ["make", "Context", "Effect", "Layer", "Schema", "DXN", "Feed", "Struct", "name", "String", "pipe", "optional", "kind", "FormInputAnnotation", "set", "namespace", "Literal", "object", "typename", "version", "SystemTypeAnnotation", "IconAnnotation", "icon", "hue", "make", "props", "getQueueDxn", "feed", "self", "getDXN", "asEchoDXN", "spaceId", "undefined", "DXN", "QUEUE", "echoId", "FeedService", "Tag", "Service", "notAvailable", "succeed", "append", "Error", "remove", "query", "items", "gen", "service", "promise", "ids", "map", "item", "id", "queryOrFilter", "runQuery", "flatMap", "queryResult", "run", "cursor", "_feed", "_tag", "next", "_cursor", "die", "nextOption", "setRetention", "_options", "void"]
+}

package/dist/lib/neutral/{chunk-IP2GHXWA.mjs → chunk-OLFCVPOO.mjs}

@@ -1,13 +1,13 @@
 import {
   object
-} from "./chunk-XMIDBDE6.mjs";
+} from "./chunk-UPWIIW2V.mjs";
 import {
   make
-} from "./chunk-2MTHJ5UW.mjs";
+} from "./chunk-ZGVZNBBJ.mjs";
 import {
   LabelAnnotation,
   SystemTypeAnnotation
-} from "./chunk-CUDIBUM4.mjs";
+} from "./chunk-6URFBQJH.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -26,7 +26,7 @@ var Tag = Schema.Struct({
   label: Schema.String,
   hue: Schema.optional(Schema.String)
 }).pipe(object({
-  typename: "dxos.org/type/Tag",
+  typename: "org.dxos.type.tag",
   version: "0.1.0"
 }), LabelAnnotation.set([
   "label"
@@ -53,4 +53,4 @@ export {
   findTagByLabel,
   Tag_exports
 };
-//# sourceMappingURL=chunk-IP2GHXWA.mjs.map
+//# sourceMappingURL=chunk-OLFCVPOO.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Tag.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\nexport const Tag = Schema.Struct({\n  label: Schema.String,\n  hue: Schema.optional(Schema.String), // TODO(burdon): Color name?\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.tag',\n    version: '0.1.0',\n  }),\n  internal.LabelAnnotation.set(['label']),\n  internal.SystemTypeAnnotation.set(true),\n);\n\nexport type Tag = Schema.Schema.Type<typeof Tag>;\n\nexport const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);\n\nexport type Map = Record<string, Tag>;\n\nexport const sortTags = ({ label: a }: Tag, { label: b }: Tag) => a.localeCompare(b);\n\nexport const createTagList = (tags: Map): Tag[] =>\n  Object.entries(tags)\n    .map(([id, tag]) => ({ ...tag, id }))\n    .sort(sortTags);\n\nexport const findTagByLabel = (tags: Map | undefined, name: string): Tag | undefined => {\n  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());\n  return entry ? { ...entry[1], id: entry[0] } : undefined;\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;cAAAA;EAAA;;AAMA,YAAYC,YAAY;AAMjB,IAAMC,MAAaC,cAAO;EAC/BC,OAAcC;EACdC,KAAYC,gBAAgBF,aAAM;AACpC,CAAA,EAAGG,KACIC,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACSC,gBAAgBC,IAAI;EAAC;CAAQ,GAC7BC,qBAAqBD,IAAI,IAAA,CAAA;AAK7B,IAAME,QAAO,CAACC,UAAyCD,KAAKb,KAAKc,KAAAA;AAIjE,IAAMC,WAAW,CAAC,EAAEb,OAAOc,EAAC,GAAS,EAAEd,OAAOe,EAAC,MAAYD,EAAEE,cAAcD,CAAAA;AAE3E,IAAME,gBAAgB,CAACC,SAC5BC,OAAOC,QAAQF,IAAAA,EACZG,IAAI,CAAC,CAACC,IAAIC,GAAAA,OAAU;EAAE,GAAGA;EAAKD;AAAG,EAAA,EACjCE,KAAKX,QAAAA;AAEH,IAAMY,iBAAiB,CAACP,MAAuBQ,SAAAA;AACpD,QAAMC,QAAQR,OAAOC,QAAQF,QAAQ,CAAC,CAAA,EAAGU,KAAK,CAAC,CAACC,GAAGN,GAAAA,MAASA,IAAIvB,MAAM8B,YAAW,MAAOJ,KAAKI,YAAW,CAAA;AACxG,SAAOH,QAAQ;IAAE,GAAGA,MAAM,CAAA;IAAIL,IAAIK,MAAM,CAAA;EAAG,IAAII;AACjD;",
+  "names": ["make", "Schema", "Tag", "Struct", "label", "String", "hue", "optional", "pipe", "object", "typename", "version", "LabelAnnotation", "set", "SystemTypeAnnotation", "make", "props", "sortTags", "a", "b", "localeCompare", "createTagList", "tags", "Object", "entries", "map", "id", "tag", "sort", "findTagByLabel", "name", "entry", "find", "_", "toLowerCase", "undefined"]
+}

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

@@ -0,0 +1,396 @@
+import {
+  Service
+} from "./chunk-EBVB5NOH.mjs";
+import {
+  ReferenceAnnotationId,
+  getSchemaDXN,
+  getTypeAnnotation,
+  getTypeIdentifierAnnotation
+} from "./chunk-6URFBQJH.mjs";
+
+// src/internal/Ref/ref.ts
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import * as Option from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
+import * as Pipeable from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { Event } from "@dxos/async";
+import { inspectCustom } from "@dxos/debug";
+import { EncodedReference } from "@dxos/echo-protocol";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { DXN, ObjectId } from "@dxos/keys";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Ref/ref.ts";
+var JSON_SCHEMA_ECHO_REF_ID = "/schemas/echo/ref";
+var getSchemaReference = (property) => {
+  const { $id, reference: { schema: { $ref } = {} } = {} } = property;
+  if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {
+    return {
+      typename: DXN.parse($ref).typename
+    };
+  }
+};
+var createSchemaReference = (typename) => {
+  return {
+    $id: JSON_SCHEMA_ECHO_REF_ID,
+    reference: {
+      schema: {
+        $ref: DXN.fromTypename(typename).toString()
+      }
+    }
+  };
+};
+var getReferenceAst = (ast) => {
+  if (ast._tag !== "Declaration" || !ast.annotations[ReferenceAnnotationId]) {
+    return void 0;
+  }
+  return {
+    typename: ast.annotations[ReferenceAnnotationId].typename,
+    version: ast.annotations[ReferenceAnnotationId].version
+  };
+};
+var RefTypeId = /* @__PURE__ */ Symbol("@dxos/echo/internal/Ref");
+var Ref = (schema) => {
+  assertArgument(Schema.isSchema(schema), "schema", "Must call with an instance of effect-schema");
+  const annotation = getTypeAnnotation(schema);
+  if (annotation == null) {
+    throw new Error("Reference target must be an ECHO schema.");
+  }
+  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version);
+};
+Ref.isRef = (obj) => {
+  return obj && typeof obj === "object" && RefTypeId in obj;
+};
+Ref.hasObjectId = (id) => (ref) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;
+Ref.isRefSchema = (schema) => {
+  return Ref.isRefSchemaAST(schema.ast);
+};
+Ref.isRefSchemaAST = (ast) => {
+  return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);
+};
+Ref.make = (obj) => {
+  if (typeof obj !== "object" || obj === null) {
+    throw new TypeError("Expected: ECHO object.");
+  }
+  const id = obj.id;
+  invariant(ObjectId.isValid(id), "Invalid object ID", {
+    F: __dxlog_file,
+    L: 225,
+    S: void 0,
+    A: [
+      "ObjectId.isValid(id)",
+      "'Invalid object ID'"
+    ]
+  });
+  const dxn = DXN.fromLocalObjectId(id);
+  return new RefImpl(dxn, obj);
+};
+Ref.fromDXN = (dxn) => {
+  assertArgument(dxn instanceof DXN, "dxn", "Expected DXN");
+  return new RefImpl(dxn);
+};
+var createEchoReferenceSchema = (echoId, typename, version) => {
+  if (!echoId && !typename) {
+    throw new TypeError("Either echoId or typename must be provided.");
+  }
+  const referenceInfo = {
+    schema: {
+      // TODO(dmaretskyi): Include version?
+      $ref: echoId ?? DXN.fromTypename(typename).toString()
+    },
+    schemaVersion: version
+  };
+  const refSchema = Schema.declare([], {
+    encode: () => {
+      return (value) => Effect.gen(function* () {
+        if (Ref.isRef(value)) {
+          return EncodedReference.fromDXN(value.dxn);
+        } else if (EncodedReference.isEncodedReference(value)) {
+          return value;
+        }
+        throw new Error("Invalid reference");
+      });
+    },
+    decode: () => {
+      return (value) => Effect.gen(function* () {
+        const dbService = yield* Effect.serviceOption(Service);
+        if (Ref.isRef(value)) {
+          if (Option.isSome(dbService)) {
+            return dbService.value.db.makeRef(value.dxn);
+          } else {
+            return value;
+          }
+        }
+        if (!EncodedReference.isEncodedReference(value)) {
+          return yield* Effect.fail(new ParseResult.Unexpected(value, "reference"));
+        }
+        if (Option.isSome(dbService)) {
+          return dbService.value.db.makeRef(EncodedReference.toDXN(value));
+        } else {
+          return Ref.fromDXN(EncodedReference.toDXN(value));
+        }
+      });
+    }
+  }, {
+    jsonSchema: {
+      // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.
+      $id: JSON_SCHEMA_ECHO_REF_ID,
+      $ref: JSON_SCHEMA_ECHO_REF_ID,
+      reference: referenceInfo
+    },
+    [ReferenceAnnotationId]: {
+      typename: typename ?? "",
+      version
+    }
+  });
+  return refSchema;
+};
+var RefImpl = class _RefImpl {
+  #dxn;
+  #resolver = void 0;
+  #resolved = new Event();
+  /**
+  * Target is set when the reference is created from a specific object.
+  * In this case, the target might not be in the database.
+  */
+  #target = void 0;
+  /**
+  * Callback to issue a reactive notification when object is resolved.
+  */
+  #resolverCallback = () => {
+    this.#resolved.emit();
+  };
+  constructor(dxn, target) {
+    this.#dxn = dxn;
+    this.#target = target;
+  }
+  /**
+  * @inheritdoc
+  */
+  get dxn() {
+    return this.#dxn;
+  }
+  /**
+  * @inheritdoc
+  */
+  get isAvailable() {
+    return this.#target !== void 0 || this.#resolver !== void 0;
+  }
+  /**
+  * @inheritdoc
+  */
+  get target() {
+    if (this.#target) {
+      return this.#target;
+    }
+    invariant(this.#resolver, "Resolver is not set", {
+      F: __dxlog_file,
+      L: 393,
+      S: this,
+      A: [
+        "this.#resolver",
+        "'Resolver is not set'"
+      ]
+    });
+    return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback);
+  }
+  /**
+  * @inheritdoc
+  */
+  async load() {
+    if (this.#target) {
+      return this.#target;
+    }
+    invariant(this.#resolver, "Resolver is not set", {
+      F: __dxlog_file,
+      L: 404,
+      S: this,
+      A: [
+        "this.#resolver",
+        "'Resolver is not set'"
+      ]
+    });
+    const obj = await this.#resolver.resolve(this.#dxn);
+    if (obj == null) {
+      throw new Error("Object not found");
+    }
+    return obj;
+  }
+  /**
+  * @inheritdoc
+  */
+  async tryLoad() {
+    if (this.#target) {
+      return this.#target;
+    }
+    invariant(this.#resolver, "Resolver is not set", {
+      F: __dxlog_file,
+      L: 419,
+      S: this,
+      A: [
+        "this.#resolver",
+        "'Resolver is not set'"
+      ]
+    });
+    return await this.#resolver.resolve(this.#dxn);
+  }
+  /**
+  * Do not inline the target object in the reference.
+  * Makes .target unavailable unless the reference is connected to a database context.
+  * Clones the reference object.
+  */
+  noInline() {
+    const ref = new _RefImpl(this.#dxn, void 0);
+    ref.#resolver = this.#resolver;
+    return ref;
+  }
+  encode() {
+    return {
+      "/": this.#dxn.toString(),
+      ...this.#target ? {
+        target: this.#target
+      } : {}
+    };
+  }
+  /**
+  * Serializes the reference to a JSON object.
+  * The serialization format is compatible with the IPLD-style encoded references.
+  * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),
+  * the target is included in the serialized object.
+  */
+  toJSON() {
+    return this.encode();
+  }
+  toString() {
+    if (this.#target) {
+      return `Ref(${this.#target.toString()})`;
+    }
+    return `Ref(${this.#dxn.toString()})`;
+  }
+  [inspectCustom] = (depth, options, inspect) => {
+    return this.toString();
+  };
+  [RefTypeId] = refVariance;
+  /**
+  * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)
+  * to deduplicate Ref instances that point to the same object.
+  * ECHO proxies return new RefImpl instances on every property access,
+  * so without this, each access would create a separate cache entry.
+  */
+  [Hash.symbol]() {
+    return Hash.hash(this.#dxn.toString());
+  }
+  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */
+  [Equal.symbol](that) {
+    return that instanceof _RefImpl && this.#dxn.toString() === that.dxn.toString();
+  }
+  /**
+  * Internal method to set the resolver.
+  *
+  * @internal
+  */
+  _setResolver(resolver) {
+    this.#resolver = resolver;
+  }
+  /**
+  * @internal
+  */
+  _getSavedTarget() {
+    return this.#target;
+  }
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  }
+};
+var setRefResolver = (ref, resolver) => {
+  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
+    F: __dxlog_file,
+    L: 506,
+    S: void 0,
+    A: [
+      "ref instanceof RefImpl",
+      "'Ref is not an instance of RefImpl'"
+    ]
+  });
+  ref._setResolver(resolver);
+};
+var getRefSavedTarget = (ref) => {
+  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
+    F: __dxlog_file,
+    L: 514,
+    S: void 0,
+    A: [
+      "ref instanceof RefImpl",
+      "'Ref is not an instance of RefImpl'"
+    ]
+  });
+  return ref._getSavedTarget();
+};
+var refVariance = {
+  _T: null
+};
+var refFromEncodedReference = (encodedReference, resolver) => {
+  const dxn = DXN.parse(encodedReference["/"]);
+  const ref = new RefImpl(dxn);
+  if (resolver) {
+    setRefResolver(ref, resolver);
+  }
+  return ref;
+};
+var StaticRefResolver = class {
+  objects = /* @__PURE__ */ new Map();
+  schemas = /* @__PURE__ */ new Map();
+  addObject(obj) {
+    this.objects.set(obj.id, obj);
+    return this;
+  }
+  addSchema(schema) {
+    const dxn = getSchemaDXN(schema);
+    invariant(dxn, "Schema has no DXN", {
+      F: __dxlog_file,
+      L: 546,
+      S: this,
+      A: [
+        "dxn",
+        "'Schema has no DXN'"
+      ]
+    });
+    this.schemas.set(dxn.toString(), schema);
+    return this;
+  }
+  resolveSync(dxn, _load, _onLoad) {
+    const id = dxn?.asEchoDXN()?.echoId;
+    if (id == null) {
+      return void 0;
+    }
+    return this.objects.get(id);
+  }
+  async resolve(dxn) {
+    const id = dxn?.asEchoDXN()?.echoId;
+    if (id == null) {
+      return void 0;
+    }
+    return this.objects.get(id);
+  }
+  async resolveSchema(dxn) {
+    return this.schemas.get(dxn.toString());
+  }
+};
+
+export {
+  JSON_SCHEMA_ECHO_REF_ID,
+  getSchemaReference,
+  createSchemaReference,
+  getReferenceAst,
+  RefTypeId,
+  Ref,
+  createEchoReferenceSchema,
+  RefImpl,
+  setRefResolver,
+  getRefSavedTarget,
+  refFromEncodedReference,
+  StaticRefResolver
+};
+//# sourceMappingURL=chunk-QWAOTFCY.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Ref/ref.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as Hash from 'effect/Hash';\nimport * as Option from 'effect/Option';\nimport * as ParseResult from 'effect/ParseResult';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { Event } from '@dxos/async';\nimport { type CustomInspectFunction, inspectCustom } from '@dxos/debug';\nimport { EncodedReference } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport * as Database from '../../Database';\nimport { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../Annotation';\nimport type { AnyEntity, AnyProperties } from '../common/types';\nimport { type JsonSchemaType } from '../JsonSchema';\n\n/**\n * The `$id` and `$ref` fields for an ECHO reference schema.\n */\nexport const JSON_SCHEMA_ECHO_REF_ID = '/schemas/echo/ref';\n\nexport const getSchemaReference = (property: JsonSchemaType): { typename: string } | undefined => {\n  const { $id, reference: { schema: { $ref } = {} } = {} } = property;\n  if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {\n    return { typename: DXN.parse($ref).typename };\n  }\n};\n\nexport const createSchemaReference = (typename: string): Types.DeepMutable<JsonSchemaType> => {\n  return {\n    $id: JSON_SCHEMA_ECHO_REF_ID,\n    reference: {\n      schema: {\n        $ref: DXN.fromTypename(typename).toString(),\n      },\n    },\n  };\n};\n\n/**\n * Runtime type-info for a reference extracted from effect AST.\n */\nexport type RefereneAST = {\n  /**\n   * Typename of linked schema.\n   */\n  typename: string;\n\n  /**\n   * Version of linked schema.\n   */\n  version: string;\n};\n\nexport const getReferenceAst = (ast: SchemaAST.AST): RefereneAST | undefined => {\n  if (ast._tag !== 'Declaration' || !ast.annotations[ReferenceAnnotationId]) {\n    return undefined;\n  }\n  return {\n    typename: (ast.annotations[ReferenceAnnotationId] as any).typename,\n    version: (ast.annotations[ReferenceAnnotationId] as any).version,\n  };\n};\n\nexport const RefTypeId: unique symbol = Symbol('@dxos/echo/internal/Ref');\n\n/**\n * Reference Schema.\n */\nexport interface RefSchema<T extends AnyEntity> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}\n\n/**\n * Type of the `Ref` function and extra methods attached to it.\n */\nexport interface RefFn {\n  <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>>;\n\n  /**\n   * @returns True if the object is a reference.\n   */\n  isRef: (obj: unknown) => obj is Ref<any>;\n\n  /**\n   * @returns True if the reference points to the given object id.\n   */\n  hasObjectId: (id: ObjectId) => (ref: Ref<any>) => boolean;\n\n  /**\n   * @returns True if the schema is a reference schema.\n   */\n  isRefSchema: (schema: Schema.Schema<any, any>) => schema is RefSchema<any>;\n\n  /**\n   * @returns True if the schema AST is a reference schema.\n   */\n  isRefSchemaAST: (ast: SchemaAST.AST) => boolean;\n\n  /**\n   * Constructs a reference that points to the given object.\n   */\n  // TODO(burdon): Narrow to Obj.Unknown?\n  make: <T extends AnyEntity>(object: T) => Ref<T>;\n\n  /**\n   * Constructs a reference that points to the object specified by the provided DXN.\n   */\n  fromDXN: (dxn: DXN) => Ref<any>;\n}\n\n/**\n * Schema builder for references.\n */\nexport const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>> => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'Must call with an instance of effect-schema');\n  const annotation = getTypeAnnotation(schema);\n  if (annotation == null) {\n    throw new Error('Reference target must be an ECHO schema.');\n  }\n\n  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version);\n};\n\n/**\n * Represents materialized reference to a target.\n * This is the data type for the fields marked as ref.\n */\nexport interface Ref<T> extends Pipeable.Pipeable {\n  /**\n   * Target object DXN.\n   */\n  get dxn(): DXN;\n\n  /**\n   * Returns true if the reference has a target available (inlined or resolver set).\n   */\n  get isAvailable(): boolean;\n\n  /**\n   * @returns The reference target.\n   * May return `undefined` if the object is not loaded in the working set.\n   * Accessing this property, even if it returns `undefined` will trigger the object to be loaded to the working set.\n   */\n  get target(): T | undefined;\n\n  /**\n   * @returns Promise that will resolves with the target object.\n   * Will load the object from disk if it is not present in the working set.\n   * @throws If the object is not available locally.\n   */\n  load(): Promise<T>;\n\n  /**\n   * @returns Promise that will resolves with the target object or undefined if the object is not loaded locally.\n   */\n\n  tryLoad(): Promise<T | undefined>;\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   *\n   * When serialized with toJSON, the difference is between:\n   * `{ \"/\": \"dxn:...\" }`\n   * and\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   *\n   * Clones the reference object.\n   */\n  noInline(): Ref<T>;\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   *\n   * Examples:\n   * `{ \"/\": \"dxn:...\" }`\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   */\n  encode(): EncodedReference;\n\n  [RefTypeId]: {\n    _T: T;\n  };\n}\n\nexport declare namespace Ref {\n  /**\n   * Target of the reference.\n   */\n  export type Target<R> = R extends Ref<infer U> ? U : never;\n}\n\nRef.isRef = (obj: any): obj is Ref<any> => {\n  return obj && typeof obj === 'object' && RefTypeId in obj;\n};\n\nRef.hasObjectId = (id: ObjectId) => (ref: Ref<any>) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;\n\nRef.isRefSchema = (schema: Schema.Schema<any, any>): schema is RefSchema<any> => {\n  return Ref.isRefSchemaAST(schema.ast);\n};\n\nRef.isRefSchemaAST = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);\n};\n\nRef.make = <T extends AnyProperties>(obj: T): Ref<T> => {\n  if (typeof obj !== 'object' || obj === null) {\n    throw new TypeError('Expected: ECHO object.');\n  }\n\n  // TODO(dmaretskyi): Extract to `getObjectDXN` function.\n  const id = obj.id;\n  invariant(ObjectId.isValid(id), 'Invalid object ID');\n  const dxn = DXN.fromLocalObjectId(id);\n  return new RefImpl(dxn, obj);\n};\n\nRef.fromDXN = (dxn: DXN): Ref<any> => {\n  assertArgument(dxn instanceof DXN, 'dxn', 'Expected DXN');\n  return new RefImpl(dxn);\n};\n\n/**\n * `reference` field on the schema object.\n */\nexport type JsonSchemaReferenceInfo = {\n  schema: { $ref: string };\n  schemaVersion?: string;\n};\n\n/**\n * @internal\n */\n// TODO(burdon): Move to json schema and make private?\nexport const createEchoReferenceSchema = (\n  echoId: string | undefined,\n  typename: string | undefined,\n  version: string | undefined,\n): Schema.SchemaClass<Ref<any>, EncodedReference> => {\n  if (!echoId && !typename) {\n    throw new TypeError('Either echoId or typename must be provided.');\n  }\n\n  const referenceInfo: JsonSchemaReferenceInfo = {\n    schema: {\n      // TODO(dmaretskyi): Include version?\n      $ref: echoId ?? DXN.fromTypename(typename!).toString(),\n    },\n    schemaVersion: version,\n  };\n\n  // TODO(dmaretskyi): Add name and description.\n  const refSchema = Schema.declare<Ref<any>, EncodedReference, []>(\n    [],\n    {\n      encode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            if (Ref.isRef(value)) {\n              return EncodedReference.fromDXN((value as Ref<any>).dxn);\n            } else if (EncodedReference.isEncodedReference(value)) {\n              return value;\n            }\n            throw new Error('Invalid reference');\n          });\n      },\n      decode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            const dbService = yield* Effect.serviceOption(Database.Service);\n\n            // TODO(dmaretskyi): This branch seems to be taken by Schema.is\n            if (Ref.isRef(value)) {\n              if (Option.isSome(dbService)) {\n                return dbService.value.db.makeRef(value.dxn);\n              } else {\n                return value;\n              }\n            }\n\n            if (!EncodedReference.isEncodedReference(value)) {\n              return yield* Effect.fail(new ParseResult.Unexpected(value, 'reference'));\n            }\n            if (Option.isSome(dbService)) {\n              return dbService.value.db.makeRef(EncodedReference.toDXN(value));\n            } else {\n              return Ref.fromDXN(EncodedReference.toDXN(value));\n            }\n          });\n      },\n    },\n    {\n      jsonSchema: {\n        // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.\n        $id: JSON_SCHEMA_ECHO_REF_ID,\n        $ref: JSON_SCHEMA_ECHO_REF_ID,\n        reference: referenceInfo,\n      },\n      [ReferenceAnnotationId]: {\n        typename: typename ?? '',\n        version,\n      },\n    },\n  );\n\n  return refSchema;\n};\n\nconst getSchemaExpectedName = (ast: SchemaAST.Annotated): string | undefined => {\n  return SchemaAST.getIdentifierAnnotation(ast).pipe(\n    Option.orElse(() => SchemaAST.getTitleAnnotation(ast)),\n    Option.orElse(() => SchemaAST.getDescriptionAnnotation(ast)),\n    Option.getOrElse(() => undefined),\n  );\n};\n\nexport interface RefResolver {\n  /**\n   * Resolve ref synchronously from the objects in the working set.\n   *\n   * @param dxn\n   * @param load If true the resolver should attempt to load the object from disk.\n   * @param onLoad Callback to call when the object is loaded.\n   */\n  resolveSync(dxn: DXN, load: boolean, onLoad?: () => void): AnyProperties | undefined;\n\n  /**\n   * Resolver ref asynchronously.\n   */\n  resolve(dxn: DXN): Promise<AnyProperties | undefined>;\n\n  // TODO(dmaretskyi): Combine with `resolve`.\n  resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined>;\n}\n\nexport class RefImpl<T> implements Ref<T> {\n  #dxn: DXN;\n  #resolver?: RefResolver = undefined;\n  #resolved = new Event<void>();\n\n  /**\n   * Target is set when the reference is created from a specific object.\n   * In this case, the target might not be in the database.\n   */\n  #target: T | undefined = undefined;\n\n  /**\n   * Callback to issue a reactive notification when object is resolved.\n   */\n  #resolverCallback = () => {\n    this.#resolved.emit();\n  };\n\n  constructor(dxn: DXN, target?: T) {\n    this.#dxn = dxn;\n    this.#target = target;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get dxn(): DXN {\n    return this.#dxn;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get isAvailable(): boolean {\n    return this.#target !== undefined || this.#resolver !== undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get target(): T | undefined {\n    if (this.#target) {\n      return this.#target;\n    }\n\n    invariant(this.#resolver, 'Resolver is not set');\n    return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback) as T | undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async load(): Promise<T> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    const obj = await this.#resolver.resolve(this.#dxn);\n    if (obj == null) {\n      throw new Error('Object not found');\n    }\n    return obj as T;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async tryLoad(): Promise<T | undefined> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    return (await this.#resolver.resolve(this.#dxn)) as T | undefined;\n  }\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   * Clones the reference object.\n   */\n  noInline(): RefImpl<T> {\n    const ref = new RefImpl<T>(this.#dxn, undefined);\n    ref.#resolver = this.#resolver;\n    return ref;\n  }\n\n  encode(): EncodedReference {\n    return {\n      '/': this.#dxn.toString(),\n      ...(this.#target ? { target: this.#target } : {}),\n    };\n  }\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   */\n  toJSON(): EncodedReference {\n    return this.encode();\n  }\n\n  toString(): string {\n    if (this.#target) {\n      return `Ref(${this.#target.toString()})`;\n    }\n\n    return `Ref(${this.#dxn.toString()})`;\n  }\n\n  [inspectCustom]: CustomInspectFunction = (depth, options, inspect) => {\n    return this.toString();\n  };\n\n  [RefTypeId] = refVariance;\n\n  /**\n   * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)\n   * to deduplicate Ref instances that point to the same object.\n   * ECHO proxies return new RefImpl instances on every property access,\n   * so without this, each access would create a separate cache entry.\n   */\n  [Hash.symbol](): number {\n    return Hash.hash(this.#dxn.toString());\n  }\n\n  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */\n  [Equal.symbol](that: Equal.Equal): boolean {\n    return that instanceof RefImpl && this.#dxn.toString() === that.dxn.toString();\n  }\n\n  /**\n   * Internal method to set the resolver.\n   *\n   * @internal\n   */\n  _setResolver(resolver: RefResolver): void {\n    this.#resolver = resolver;\n  }\n\n  /**\n   * @internal\n   */\n  _getSavedTarget(): T | undefined {\n    return this.#target;\n  }\n\n  pipe() {\n    // eslint-disable-next-line prefer-rest-params\n    return Pipeable.pipeArguments(this, arguments);\n  }\n}\n\n/**\n * Internal API for setting the reference resolver.\n */\nexport const setRefResolver = (ref: Ref<any>, resolver: RefResolver) => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  ref._setResolver(resolver);\n};\n\n/**\n * Internal API for getting the saved target on a reference.\n */\nexport const getRefSavedTarget = (ref: Ref<any>): AnyProperties | undefined => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  return ref._getSavedTarget();\n};\n\n// Used to validate reference target type.\nconst refVariance: Ref<any>[typeof RefTypeId] = {\n  _T: null as any,\n};\n\nexport const refFromEncodedReference = (encodedReference: EncodedReference, resolver?: RefResolver): Ref<any> => {\n  const dxn = DXN.parse(encodedReference['/']);\n  const ref = new RefImpl(dxn);\n\n  // TODO(dmaretskyi): Handle inline target in the encoded reference.\n\n  if (resolver) {\n    setRefResolver(ref, resolver);\n  }\n  return ref;\n};\n\nexport class StaticRefResolver implements RefResolver {\n  public objects = new Map<ObjectId, AnyProperties>();\n  public schemas = new Map<DXN.String, Schema.Schema.AnyNoContext>();\n\n  addObject(obj: AnyProperties): this {\n    this.objects.set(obj.id, obj);\n    return this;\n  }\n\n  addSchema(schema: Schema.Schema.AnyNoContext): this {\n    const dxn = getSchemaDXN(schema);\n    invariant(dxn, 'Schema has no DXN');\n    this.schemas.set(dxn.toString(), schema);\n    return this;\n  }\n\n  resolveSync(dxn: DXN, _load: boolean, _onLoad?: () => void): AnyProperties | undefined {\n    const id = dxn?.asEchoDXN()?.echoId;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolve(dxn: DXN): Promise<AnyProperties | undefined> {\n    const id = dxn?.asEchoDXN()?.echoId;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined> {\n    return this.schemas.get(dxn.toString());\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["Effect", "Equal", "Hash", "Option", "ParseResult", "Pipeable", "Schema", "SchemaAST", "Event", "inspectCustom", "EncodedReference", "assertArgument", "invariant", "DXN", "ObjectId", "JSON_SCHEMA_ECHO_REF_ID", "getSchemaReference", "property", "$id", "reference", "schema", "$ref", "typename", "DXN", "parse", "createSchemaReference", "fromTypename", "toString", "getReferenceAst", "ast", "_tag", "annotations", "ReferenceAnnotationId", "undefined", "version", "RefTypeId", "Symbol", "Ref", "assertArgument", "isSchema", "annotation", "getTypeAnnotation", "Error", "createEchoReferenceSchema", "getTypeIdentifierAnnotation", "isRef", "obj", "hasObjectId", "id", "ref", "dxn", "isLocalObjectId", "parts", "isRefSchema", "isRefSchemaAST", "getAnnotation", "pipe", "isSome", "make", "TypeError", "invariant", "ObjectId", "isValid", "fromLocalObjectId", "RefImpl", "fromDXN", "echoId", "referenceInfo", "schemaVersion", "refSchema", "declare", "encode", "value", "gen", "EncodedReference", "isEncodedReference", "decode", "dbService", "serviceOption", "Service", "db", "makeRef", "fail", "Unexpected", "toDXN", "jsonSchema", "RefImpl", "undefined", "Event", "emit", "dxn", "target", "isAvailable", "invariant", "resolveSync", "load", "obj", "resolve", "Error", "tryLoad", "noInline", "ref", "encode", "toString", "toJSON", "inspectCustom", "depth", "options", "inspect", "RefTypeId", "refVariance", "symbol", "hash", "that", "_setResolver", "resolver", "_getSavedTarget", "pipe", "pipeArguments", "arguments", "setRefResolver", "getRefSavedTarget", "_T", "refFromEncodedReference", "encodedReference", "DXN", "parse", "StaticRefResolver", "objects", "Map", "schemas", "addObject", "set", "id", "addSchema", "schema", "getSchemaDXN", "_load", "_onLoad", "asEchoDXN", "echoId", "get", "resolveSchema"]
+}