@dxos/echo 0.8.4-main.c4373fc → 0.8.4-main.cb12b3f963

package/dist/lib/neutral/chunk-44HT3MEC.mjs

@@ -0,0 +1,73 @@
+import {
+  Currency,
+  CurrencyAnnotationId,
+  DecimalPrecision,
+  Email,
+  Format,
+  FormatAnnotation,
+  FormatAnnotationId,
+  FormatEnums,
+  Formula,
+  GeoLocation,
+  GeoPoint,
+  Hostname,
+  JSON,
+  Markdown,
+  OptionsAnnotation,
+  OptionsAnnotationId,
+  PropertyKind,
+  Regex,
+  SelectOption,
+  Text,
+  TypeEnum,
+  TypeFormat,
+  URL,
+  UUID,
+  formatToType,
+  getFormatAnnotation,
+  getOptionsAnnotation,
+  getTypeEnum,
+  typeToFormat
+} from "./chunk-TRPZU2HV.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Format.ts
+var Format_exports = {};
+__export(Format_exports, {
+  Currency: () => Currency,
+  CurrencyAnnotationId: () => CurrencyAnnotationId,
+  DecimalPrecision: () => DecimalPrecision,
+  Email: () => Email,
+  Format: () => Format,
+  FormatAnnotation: () => FormatAnnotation,
+  FormatAnnotationId: () => FormatAnnotationId,
+  FormatEnums: () => FormatEnums,
+  Formula: () => Formula,
+  GeoLocation: () => GeoLocation,
+  GeoPoint: () => GeoPoint,
+  Hostname: () => Hostname,
+  JSON: () => JSON,
+  Markdown: () => Markdown,
+  OptionsAnnotation: () => OptionsAnnotation,
+  OptionsAnnotationId: () => OptionsAnnotationId,
+  PropertyKind: () => PropertyKind,
+  Regex: () => Regex,
+  SelectOption: () => SelectOption,
+  Text: () => Text,
+  TypeEnum: () => TypeEnum,
+  TypeFormat: () => TypeFormat,
+  URL: () => URL,
+  UUID: () => UUID,
+  formatToType: () => formatToType,
+  getFormatAnnotation: () => getFormatAnnotation,
+  getOptionsAnnotation: () => getOptionsAnnotation,
+  getTypeEnum: () => getTypeEnum,
+  typeToFormat: () => typeToFormat
+});
+
+export {
+  Format_exports
+};
+//# sourceMappingURL=chunk-44HT3MEC.mjs.map

package/dist/lib/neutral/chunk-44HT3MEC.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Format.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as internal from './internal';\n\nexport * from './internal/Format';\n\nexport type Format = internal.TypeFormat;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+  "names": []
+}

package/dist/lib/neutral/chunk-4VTRFJV3.mjs

@@ -0,0 +1,128 @@
+import {
+  isInstanceOf
+} from "./chunk-GECFB2UL.mjs";
+import {
+  ObjectNotFoundError
+} from "./chunk-ZISMEVKD.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Database.ts
+var Database_exports = {};
+__export(Database_exports, {
+  Database: () => Database,
+  Service: () => Service,
+  TypeId: () => TypeId,
+  add: () => add,
+  flush: () => flush,
+  isDatabase: () => isDatabase,
+  layer: () => layer,
+  load: () => load,
+  loadOption: () => loadOption,
+  makeService: () => makeService,
+  notAvailable: () => notAvailable,
+  query: () => query,
+  registerSchema: () => registerSchema,
+  remove: () => remove,
+  resolve: () => resolve,
+  runQuery: () => runQuery,
+  runQueryFirst: () => runQueryFirst,
+  runSchemaQuery: () => runSchemaQuery,
+  schemaQuery: () => schemaQuery,
+  spaceId: () => spaceId
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { promiseWithCauseCapture } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
+var TypeId = /* @__PURE__ */ Symbol.for("@dxos/echo/Database");
+var isDatabase = (obj) => {
+  return obj ? typeof obj === "object" && TypeId in obj && obj[TypeId] === TypeId : false;
+};
+var Database = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));
+var Service = class extends Context.Tag("@dxos/echo/Database/Service")() {
+};
+var notAvailable = Layer.succeed(Service, {
+  get db() {
+    throw new Error("Database not available");
+  }
+});
+var makeService = (db) => {
+  return {
+    get db() {
+      return db;
+    }
+  };
+};
+var layer = (db) => {
+  return Layer.succeed(Service, makeService(db));
+};
+var spaceId = Effect.gen(function* () {
+  const { db } = yield* Service;
+  return db.spaceId;
+});
+var resolve = (ref, schema) => Effect.gen(function* () {
+  const { db } = yield* Service;
+  const dxn = ref instanceof DXN ? ref : ref.dxn;
+  const object = yield* promiseWithCauseCapture(() => db.graph.createRefResolver({
+    context: {
+      space: db.spaceId
+    }
+  }).resolve(dxn));
+  if (!object) {
+    return yield* Effect.fail(new ObjectNotFoundError(dxn));
+  }
+  invariant(!schema || isInstanceOf(schema, object), "Object type mismatch.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 67, S: this, A: ["!schema || isInstanceOf(schema, object)", "'Object type mismatch.'"] });
+  return object;
+}).pipe(Effect.withSpan("Database.resolve"));
+var load = Effect.fn("Database.load")(function* (ref) {
+  const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
+  if (!object) {
+    return yield* Effect.fail(new ObjectNotFoundError(ref.dxn));
+  }
+  return object;
+});
+var loadOption = Effect.fn("Database.loadOption")(function* (ref) {
+  const object = yield* load(ref).pipe(Effect.catchTag("ObjectNotFoundError", () => Effect.succeed(void 0)));
+  return Option.fromNullable(object);
+});
+var add = (obj) => Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan("Database.add"));
+var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan("Database.remove"));
+var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))).pipe(Effect.withSpan("Database.flush"));
+var query = (queryOrFilter) => Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Database.query"));
+var runQuery = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())), Effect.withSpan("Database.runQuery"));
+var runQueryFirst = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined()))), Effect.withSpan("Database.runQueryFirst"));
+var registerSchema = (input) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.schemaRegistry.register(input))), Effect.withSpan("Database.registerSchema"));
+var schemaQuery = (schemaQueryOptions) => Service.pipe(Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)), Effect.withSpan("Database.schemaQuery"));
+var runSchemaQuery = (schemaQueryOptions) => schemaQuery(schemaQueryOptions).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
+
+export {
+  TypeId,
+  isDatabase,
+  Database,
+  Service,
+  notAvailable,
+  makeService,
+  layer,
+  spaceId,
+  resolve,
+  load,
+  loadOption,
+  add,
+  remove,
+  flush,
+  query,
+  runQuery,
+  runQueryFirst,
+  registerSchema,
+  schemaQuery,
+  runSchemaQuery,
+  Database_exports
+};
+//# sourceMappingURL=chunk-4VTRFJV3.mjs.map

package/dist/lib/neutral/chunk-4VTRFJV3.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-5NR2KWDU.mjs

@@ -0,0 +1,34 @@
+import {
+  Ref
+} from "./chunk-62RJTYOZ.mjs";
+
+// src/internal/Ref/ref-array.ts
+import { isNonNullable } from "@dxos/util";
+var RefArray = Object.freeze({
+  /**
+  * @returns all resolved targets.
+  */
+  targets: (refs) => {
+    return refs.map((ref) => ref.target).filter(isNonNullable);
+  },
+  /**
+  * Load all referenced objects.
+  */
+  loadAll: (refs) => {
+    return Promise.all(refs.map((ref) => ref.load()));
+  },
+  /**
+  * Removes the ref with the given id.
+  */
+  removeById: (refs, id) => {
+    const index = refs.findIndex(Ref.hasObjectId(id));
+    if (index >= 0) {
+      refs.splice(index, 1);
+    }
+  }
+});
+
+export {
+  RefArray
+};
+//# sourceMappingURL=chunk-5NR2KWDU.mjs.map

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

@@ -0,0 +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';\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-62RJTYOZ.mjs

@@ -0,0 +1,346 @@
+import {
+  Service
+} from "./chunk-4VTRFJV3.mjs";
+import {
+  ReferenceAnnotationId,
+  getSchemaDXN,
+  getTypeAnnotation,
+  getTypeIdentifierAnnotation
+} from "./chunk-GECFB2UL.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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 76, 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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 181, 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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 190, 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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 203, S: this, A: ["this.#resolver", "'Resolver is not set'"] });
+    return await this.#resolver.resolve(this.#dxn);
+  }
+  /**
+  * @inheritdoc
+  */
+  onResolved(callback) {
+    return this.#resolved.on(callback);
+  }
+  /**
+  * 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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 277, 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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 283, 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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 308, 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-62RJTYOZ.mjs.map