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

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

@@ -0,0 +1,130 @@
+import {
+  isInstanceOf
+} from "./chunk-RIMHNJ3E.mjs";
+import {
+  ObjectNotFoundError
+} from "./chunk-RPB6V4BE.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,
+  remove: () => remove,
+  resolve: () => resolve,
+  runQuery: () => runQuery,
+  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 = 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.", {
+    F: __dxlog_file,
+    L: 266,
+    S: this,
+    A: [
+      "!schema || isInstanceOf(schema, object)",
+      "'Object type mismatch.'"
+    ]
+  });
+  return object;
+});
+var load = Effect.fn(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) {
+  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 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 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,
+  schemaQuery,
+  runSchemaQuery,
+  Database_exports
+};
+//# sourceMappingURL=chunk-LKFNEFHF.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Database.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { type QueryAST } from '@dxos/echo-protocol';\nimport { promiseWithCauseCapture } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { DXN, type PublicKey, type SpaceId } from '@dxos/keys';\nimport { type QueryOptions as QueryOptionsProto } from '@dxos/protocols/proto/dxos/echo/filter';\n\nimport type * as Entity from './Entity';\nimport * as Err from './Err';\nimport type * as Filter from './Filter';\nimport type * as Hypergraph from './Hypergraph';\nimport { isInstanceOf } from './internal/annotations';\nimport type { Ref } from './internal/ref/ref';\nimport { type AnyProperties } from './internal/types';\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 * @deprecated Use `QueryAST.QueryOptions` instead.\n */\nexport type QueryOptions = {\n  /**\n   * @deprecated Use `spaceIds` instead.\n   */\n  spaces?: PublicKey[];\n\n  /**\n   * Query only in specific spaces.\n   */\n  // TODO(dmaretskyi): Change this to SpaceId.\n  spaceIds?: string[];\n\n  /**\n   * Return only the first `limit` results.\n   */\n  limit?: number;\n\n  /**\n   * Query only local spaces, or remote on agent.\n   * @default `QueryOptions.DataLocation.LOCAL`\n   *\n   * Options:\n   *   - proto3_optional = true\n   */\n  // TODO(burdon): Remove?\n  dataLocation?: QueryOptionsProto.DataLocation;\n};\n\n/**\n * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\n// TODO(dmaretskyi): Remove query options.\nexport interface QueryFn {\n  <Q extends Query.Any>(\n    query: Q,\n    options?: (QueryAST.QueryOptions & QueryOptions) | undefined,\n  ): QueryResult.QueryResult<Query.Type<Q>>;\n\n  <F extends Filter.Any>(\n    filter: F,\n    options?: (QueryAST.QueryOptions & QueryOptions) | undefined,\n  ): QueryResult.QueryResult<Filter.Type<F>>;\n}\n\n/**\n * Common interface for Database and Queue.\n */\nexport interface Queryable {\n  query: QueryFn;\n}\n\nexport type GetObjectByIdOptions = {\n  deleted?: boolean;\n};\n\nexport type ObjectPlacement = 'root-doc' | 'linked-doc';\n\nexport type AddOptions = {\n  /**\n   * Where to place the object in the Automerge document tree.\n   * Root document is always loaded with the space.\n   * Linked documents are loaded lazily.\n   * Placing large number of objects in the root document may slow down the initial load.\n   *\n   * @default 'linked-doc'\n   */\n  placeIn?: ObjectPlacement;\n};\n\nexport type FlushOptions = {\n  /**\n   * Write any pending changes to disk.\n   * @default true\n   */\n  disk?: boolean;\n\n  /**\n   * Wait for pending index updates.\n   * @default false\n   */\n  indexes?: boolean;\n\n  /**\n   * Flush pending updates to objects and queries.\n   * @default false\n   */\n  updates?: boolean;\n};\n\n/**\n * 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.Obj<AnyProperties>>(id: string, opts?: GetObjectByIdOptions): 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.Entity.Any>(\n    ref: DXN | Ref<any>,\n    schema: S,\n  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;\n} = (<S extends Type.Entity.Any>(\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  })) 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(function* (ref) {\n  const object = yield* promiseWithCauseCapture(() => ref.tryLoad());\n  if (!object) {\n    return yield* Effect.fail(new Err.ObjectNotFoundError(ref.dxn));\n  }\n  return object;\n});\n\n/**\n * Loads an object reference option.\n */\n// TODO(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(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)));\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)));\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))));\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(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));\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": "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",
+  "names": ["Context", "Effect", "Layer", "Option", "Schema", "promiseWithCauseCapture", "invariant", "DXN", "TypeId", "Symbol", "for", "isDatabase", "obj", "Database", "Any", "pipe", "filter", "space", "Service", "Tag", "notAvailable", "succeed", "db", "Error", "makeService", "layer", "spaceId", "gen", "resolve", "ref", "schema", "dxn", "DXN", "object", "promiseWithCauseCapture", "graph", "createRefResolver", "context", "fail", "ObjectNotFoundError", "invariant", "isInstanceOf", "load", "fn", "tryLoad", "loadOption", "catchTag", "undefined", "fromNullable", "add", "map", "remove", "flush", "opts", "flatMap", "query", "queryOrFilter", "withSpan", "runQuery", "queryResult", "run", "schemaQuery", "schemaQueryOptions", "schemaRegistry", "runSchemaQuery"]
+}

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

@@ -0,0 +1,251 @@
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  MetaId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  VersionTypeId,
+  addTag,
+  change,
+  deleteKeys,
+  getDXN,
+  getDatabase,
+  getDescription,
+  getKeys,
+  getLabel,
+  getMetaChecked,
+  getObjectDXN,
+  getSnapshot,
+  isDeleted,
+  isVersion,
+  makeObject,
+  objectToJSON,
+  removeTag,
+  setDescription,
+  setLabel,
+  setValue,
+  sort,
+  sortByLabel,
+  sortByTypename,
+  subscribe,
+  version
+} from "./chunk-TLGNKUUG.mjs";
+import {
+  ParentId,
+  getSchema,
+  getTypeAnnotation,
+  getTypeDXN,
+  getTypename
+} from "./chunk-RIMHNJ3E.mjs";
+import {
+  EntityKind,
+  KindId,
+  SnapshotKindId
+} from "./chunk-KB7RIVLK.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Relation.ts
+var Relation_exports = {};
+__export(Relation_exports, {
+  Source: () => Source,
+  Target: () => Target,
+  VersionTypeId: () => VersionTypeId,
+  addTag: () => addTag2,
+  change: () => change2,
+  deleteKeys: () => deleteKeys2,
+  getDXN: () => getDXN2,
+  getDatabase: () => getDatabase2,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys2,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta,
+  getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot2,
+  getSource: () => getSource,
+  getSourceDXN: () => getSourceDXN,
+  getTarget: () => getTarget,
+  getTargetDXN: () => getTargetDXN,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename2,
+  getValue: () => getValue,
+  isDeleted: () => isDeleted2,
+  isRelation: () => isRelation,
+  isVersion: () => isVersion,
+  make: () => make,
+  removeTag: () => removeTag2,
+  setDescription: () => setDescription2,
+  setLabel: () => setLabel2,
+  setValue: () => setValue2,
+  sort: () => sort2,
+  sortByLabel: () => sortByLabel2,
+  sortByTypename: () => sortByTypename2,
+  subscribe: () => subscribe2,
+  toJSON: () => toJSON,
+  version: () => version2
+});
+import { raise } from "@dxos/debug";
+import { createJsonPath, getValue as getValue$ } from "@dxos/effect";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+import { assumeType } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
+var Source = RelationSourceId;
+var Target = RelationTargetId;
+var make = (schema, props, meta) => {
+  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, "schema", "Expected a relation schema");
+  assertArgument(props[ParentId] === void 0, "props", "Parent is not allowed for relations");
+  if (props[MetaId] != null) {
+    meta = props[MetaId];
+    delete props[MetaId];
+  }
+  const sourceDXN = getObjectDXN(props[Source]) ?? raise(new Error("Unresolved relation source"));
+  const targetDXN = getObjectDXN(props[Target]) ?? raise(new Error("Unresolved relation target"));
+  props[RelationSourceDXNId] = sourceDXN;
+  props[RelationTargetDXNId] = targetDXN;
+  return makeObject(schema, props, meta);
+};
+var isRelation = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (ATTR_RELATION_SOURCE in value || ATTR_RELATION_TARGET in value) {
+    return true;
+  }
+  const kind = value[KindId] ?? value[SnapshotKindId];
+  return kind === EntityKind.Relation;
+};
+var getSourceDXN = (value) => {
+  assertArgument(isRelation(value), "Expected a relation");
+  assumeType(value);
+  const dxn = value[RelationSourceDXNId];
+  invariant(dxn instanceof DXN, void 0, {
+    F: __dxlog_file,
+    L: 190,
+    S: void 0,
+    A: [
+      "dxn instanceof DXN",
+      ""
+    ]
+  });
+  return dxn;
+};
+var getTargetDXN = (value) => {
+  assertArgument(isRelation(value), "Expected a relation");
+  assumeType(value);
+  const dxn = value[RelationTargetDXNId];
+  invariant(dxn instanceof DXN, void 0, {
+    F: __dxlog_file,
+    L: 203,
+    S: void 0,
+    A: [
+      "dxn instanceof DXN",
+      ""
+    ]
+  });
+  return dxn;
+};
+var getSource = (relation) => {
+  assertArgument(isRelation(relation), "Expected a relation");
+  assumeType(relation);
+  const obj = relation[RelationSourceId];
+  invariant(obj !== void 0, `Invalid source: ${relation.id}`, {
+    F: __dxlog_file,
+    L: 216,
+    S: void 0,
+    A: [
+      "obj !== undefined",
+      "`Invalid source: ${relation.id}`"
+    ]
+  });
+  return obj;
+};
+var getTarget = (relation) => {
+  assertArgument(isRelation(relation), "Expected a relation");
+  assumeType(relation);
+  const obj = relation[RelationTargetId];
+  invariant(obj !== void 0, `Invalid target: ${relation.id}`, {
+    F: __dxlog_file,
+    L: 229,
+    S: void 0,
+    A: [
+      "obj !== undefined",
+      "`Invalid target: ${relation.id}`"
+    ]
+  });
+  return obj;
+};
+var change2 = (relation, callback) => {
+  change(relation, callback);
+};
+var getSnapshot2 = getSnapshot;
+var subscribe2 = (rel, callback) => {
+  return subscribe(rel, callback);
+};
+var getValue = (rel, path) => {
+  return getValue$(rel, createJsonPath(path));
+};
+var setValue2 = setValue;
+var getDXN2 = (entity) => getDXN(entity);
+var getTypeDXN2 = getTypeDXN;
+var getSchema2 = getSchema;
+var getTypename2 = (entity) => getTypename(entity);
+var getDatabase2 = (entity) => getDatabase(entity);
+function getMeta(entity) {
+  return getMetaChecked(entity);
+}
+var getKeys2 = (entity, source) => getKeys(entity, source);
+var deleteKeys2 = (entity, source) => deleteKeys(entity, source);
+var addTag2 = (entity, tag) => addTag(entity, tag);
+var removeTag2 = (entity, tag) => removeTag(entity, tag);
+var isDeleted2 = (entity) => isDeleted(entity);
+var getLabel2 = (entity) => getLabel(entity);
+var setLabel2 = (entity, label) => setLabel(entity, label);
+var getDescription2 = (entity) => getDescription(entity);
+var setDescription2 = (entity, description) => setDescription(entity, description);
+var toJSON = (entity) => objectToJSON(entity);
+var sortByLabel2 = sortByLabel;
+var sortByTypename2 = sortByTypename;
+var sort2 = (...comparators) => sort(...comparators);
+var version2 = (entity) => version(entity);
+
+export {
+  Source,
+  Target,
+  make,
+  isRelation,
+  getSourceDXN,
+  getTargetDXN,
+  getSource,
+  getTarget,
+  change2 as change,
+  getSnapshot2 as getSnapshot,
+  subscribe2 as subscribe,
+  getValue,
+  setValue2 as setValue,
+  getDXN2 as getDXN,
+  getTypeDXN2 as getTypeDXN,
+  getSchema2 as getSchema,
+  getTypename2 as getTypename,
+  getDatabase2 as getDatabase,
+  getMeta,
+  getKeys2 as getKeys,
+  deleteKeys2 as deleteKeys,
+  addTag2 as addTag,
+  removeTag2 as removeTag,
+  isDeleted2 as isDeleted,
+  getLabel2 as getLabel,
+  setLabel2 as setLabel,
+  getDescription2 as getDescription,
+  setDescription2 as setDescription,
+  toJSON,
+  sortByLabel2 as sortByLabel,
+  sortByTypename2 as sortByTypename,
+  sort2 as sort,
+  version2 as version,
+  Relation_exports
+};
+//# sourceMappingURL=chunk-MTEHHY62.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Relation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath, getValue as getValue$ } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, type ObjectId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport {\n  type ObjectJSON as APIJSON,\n  ATTR_RELATION_SOURCE,\n  ATTR_RELATION_TARGET,\n  type AnyEntity,\n  type Comparator as ApiComparator,\n  type Meta as ApiMeta,\n  type ReadonlyMeta as ApiReadonlyMeta,\n  type EntityVersion as ApiVersion,\n  type ChangeCallback,\n  EntityKind,\n  type InternalObjectProps,\n  type KindId,\n  MetaId,\n  type Mutable,\n  type ObjectMeta,\n  ParentId,\n  RelationSourceDXNId,\n  RelationSourceId,\n  RelationTargetDXNId,\n  RelationTargetId,\n  SnapshotKindId,\n  VersionTypeId,\n  addTag as addTag$,\n  change as change$,\n  deleteKeys as deleteKeys$,\n  getDXN as getDXN$,\n  getDatabase as getDatabase$,\n  getDescription as getDescription$,\n  getKeys as getKeys$,\n  getLabel as getLabel$,\n  getMetaChecked as getMeta$,\n  getObjectDXN,\n  getSchema as getSchema$,\n  getSnapshot as getSnapshot$,\n  getTypeAnnotation,\n  getTypeDXN as getTypeDXN$,\n  getTypename as getTypename$,\n  isDeleted as isDeleted$,\n  isVersion,\n  makeObject,\n  removeTag as removeTag$,\n  setDescription as setDescription$,\n  setLabel as setLabel$,\n  setValue as setValue$,\n  sort as sort$,\n  sortByLabel as sortByLabel$,\n  sortByTypename as sortByTypename$,\n  subscribe as subscribe$,\n  objectToJSON as toJSON$,\n  version as version$,\n} from './internal';\nimport type * as Obj from './Obj';\nimport type * as Type from './Type';\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends AnyEntity,\n    Type.Relation.Endpoints<Source, Target>,\n    Entity.OfKind<EntityKind.Relation> {}\n\n/**\n * Relation with no known properties beyond id, kind, source, and target.\n * Use this when the relation's schema/properties are not known.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO relation, use `Relation.isRelation`.\n */\nexport interface Unknown extends BaseRelation<Obj.Unknown, Obj.Unknown> {}\n\n/**\n * Relation type with specific source and target types.\n */\nexport type Relation<Source extends Obj.Unknown, Target extends Obj.Unknown, Props> = BaseRelation<Source, Target> &\n  Props;\n\n/**\n * Base type for snapshot relations (has SnapshotKindId instead of KindId).\n */\ninterface BaseRelationSnapshot<Source, Target> extends AnyEntity, Type.Relation.Endpoints<Source, Target> {\n  readonly [SnapshotKindId]: EntityKind.Relation;\n  readonly id: ObjectId;\n}\n\n/**\n * Immutable snapshot of an ECHO relation.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, KindId> & BaseRelationSnapshot<Obj.Unknown, Obj.Unknown>;\n\nexport const Source: unique symbol = RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = RelationTargetId as any;\nexport type Target = typeof Target;\n\n/**\n * Internal props type for relation instance creation.\n */\ntype RelationMakeProps<T extends Unknown> = {\n  id?: ObjectId;\n  [MetaId]?: ObjectMeta;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Type.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema.\n * Takes a schema type (created with Type.Relation) and extracts the props type.\n */\nexport type MakeProps<S extends Type.Relation.Any> = RelationMakeProps<Schema.Schema.Type<S>>;\n\n/**\n * Creates new relation.\n * @param schema - Relation schema.\n * @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.\n * @param meta - Relation metadata. (deprecated; use [Obj.Meta] instead)\n * @returns\n */\n// NOTE: Writing the definition this way (with generic over schema) makes typescript perfer to infer the type from the first param (this schema) rather than the second param (the props).\n// TODO(dmaretskyi): Move meta into props.\nexport const make = <S extends Type.Relation.Any>(\n  schema: S,\n  props: NoInfer<RelationMakeProps<Schema.Schema.Type<S>>>,\n  meta?: ObjectMeta,\n): Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation> => {\n  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, 'schema', 'Expected a relation schema');\n  assertArgument(props[ParentId] === undefined, 'props', 'Parent is not allowed for relations');\n\n  if (props[MetaId] != null) {\n    meta = props[MetaId] as any;\n    delete props[MetaId];\n  }\n\n  const sourceDXN = getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[RelationSourceDXNId] = sourceDXN;\n  (props as any)[RelationTargetDXNId] = targetDXN;\n\n  return makeObject<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (ATTR_RELATION_SOURCE in value || ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  // Check for reactive relation (KindId) or snapshot (SnapshotKindId).\n  const kind = (value as any)[Entity.KindId] ?? (value as any)[SnapshotKindId];\n  return kind === EntityKind.Relation;\n};\n\n/**\n * @returns Relation source DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<InternalObjectProps>(value);\n  const dxn = (value as InternalObjectProps)[RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<InternalObjectProps>(value);\n  const dxn = (value as InternalObjectProps)[RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): Type.Relation.Source<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<InternalObjectProps>(relation);\n  const obj = (relation as InternalObjectProps)[RelationSourceId];\n  invariant(obj !== undefined, `Invalid source: ${relation.id}`);\n  return obj as Type.Relation.Source<T>;\n};\n\n/**\n * @returns Relation target.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Unknown | Snapshot>(relation: T): Type.Relation.Target<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<InternalObjectProps>(relation);\n  const obj = (relation as InternalObjectProps)[RelationTargetId];\n  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\n  return obj as Type.Relation.Target<T>;\n};\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of a relation within `Relation.change`.\n */\nexport type { Mutable };\n\n/**\n * Perform mutations on an echo relation within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Relation.change` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.change` for objects.\n * @param callback - The callback that performs mutations on the relation.\n *\n * @example\n * ```ts\n * const worksFor = Relation.make(EmployedBy, {\n *   [Relation.Source]: person,\n *   [Relation.Target]: company,\n *   role: 'Engineer',\n * });\n *\n * // Mutate within Relation.change\n * Relation.change(worksFor, (r) => {\n *   r.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.change` for objects.\n */\nexport const change = <T extends Unknown>(relation: T, callback: ChangeCallback<T>): void => {\n  change$(relation, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of a relation.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive relation at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(rel: T) => Snapshot<T> = getSnapshot$ as any;\n\n//\n// Subscribe\n//\n\n/**\n * Subscribe to relation updates.\n * The callback is called synchronously when the relation is modified.\n * Only accepts reactive relations (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (rel: Unknown, callback: () => void): (() => void) => {\n  return subscribe$(rel, callback);\n};\n\n//\n// Property Access\n//\n\n/**\n * Get a deeply nested property from a relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getValue = (rel: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return getValue$(rel, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on a relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setValue: (rel: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  setValue$ as any;\n\n//\n// Type\n//\n\n/**\n * Get the DXN of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => getDXN$(entity);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeDXN = getTypeDXN$;\n\n/**\n * Get the schema of the relation.\n * Returns the branded ECHO schema used to create the relation.\n */\nexport const getSchema: (rel: unknown | undefined) => Type.Entity.Any | undefined = getSchema$ as any;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => getTypename$(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the relation belongs to.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): Database.Database | undefined => getDatabase$(entity);\n\n//\n// Meta\n//\n\n/**\n * Deeply read-only version of ObjectMeta.\n */\nexport type ReadonlyMeta = ApiReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.change` callback.\n */\nexport type Meta = ApiMeta;\n\n/**\n * Get the metadata for a relation.\n * Returns mutable meta when passed a mutable relation (inside `Relation.change` callback).\n * Returns read-only meta when passed a regular relation 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>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return getMeta$(entity);\n}\n\n/**\n * @returns Foreign keys for the relation from the specified source.\n * Accepts both reactive relations and snapshots.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => getKeys$(entity, source);\n\n/**\n * Delete all keys from the relation for the specified source.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => deleteKeys$(entity, source);\n\n/**\n * Add a tag to the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => addTag$(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => removeTag$(entity, tag);\n\n/**\n * Check if the relation is deleted.\n * Accepts both reactive relations and snapshots.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => isDeleted$(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => getLabel$(entity);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => setLabel$(entity, label);\n\n/**\n * Get the description of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => getDescription$(entity);\n\n/**\n * Set the description of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  setDescription$(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of a relation.\n */\nexport type JSON = APIJSON;\n\n/**\n * Converts relation to its JSON representation.\n * Accepts both reactive relations and snapshots.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => toJSON$(entity);\n\n//\n// Sorting\n//\n\n/**\n * Comparator function type for sorting relations.\n * Accepts both reactive relations and snapshots.\n */\nexport type Comparator = ApiComparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = sortByLabel$ as Comparator;\nexport const sortByTypename: Comparator = sortByTypename$ as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => sort$(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport { VersionTypeId, isVersion };\n\n/**\n * Represent relation version.\n */\nexport type Version = ApiVersion;\n\n/**\n * Returns the version of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => version$(entity);\n"],
+  "mappings": "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",
+  "names": ["addTag", "change", "deleteKeys", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "raise", "createJsonPath", "getValue", "getValue$", "assertArgument", "invariant", "DXN", "assumeType", "Source", "RelationSourceId", "Target", "RelationTargetId", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "Relation", "ParentId", "undefined", "MetaId", "sourceDXN", "getObjectDXN", "raise", "Error", "targetDXN", "RelationSourceDXNId", "RelationTargetDXNId", "makeObject", "isRelation", "value", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "KindId", "SnapshotKindId", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "id", "getTarget", "change", "callback", "change$", "getSnapshot", "getSnapshot$", "subscribe", "rel", "subscribe$", "getValue", "path", "getValue$", "createJsonPath", "setValue", "setValue$", "getDXN", "entity", "getDXN$", "getTypeDXN", "getTypeDXN$", "getSchema", "getSchema$", "getTypename", "getTypename$", "getDatabase", "getDatabase$", "getMeta", "getMeta$", "getKeys", "source", "getKeys$", "deleteKeys", "deleteKeys$", "addTag", "tag", "addTag$", "removeTag", "removeTag$", "isDeleted", "isDeleted$", "getLabel", "getLabel$", "setLabel", "label", "setLabel$", "getDescription", "getDescription$", "setDescription", "description", "setDescription$", "toJSON", "toJSON$", "sortByLabel", "sortByLabel$", "sortByTypename", "sortByTypename$", "sort", "comparators", "sort$", "version", "entity", "version$"]
+}

package/dist/lib/neutral/chunk-N2QNHMT5.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-7WE7SBA2.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-N2QNHMT5.mjs.map

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

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

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

@@ -0,0 +1,7 @@
+// src/QueryResult.ts
+var QueryResult_exports = {};
+
+export {
+  QueryResult_exports
+};
+//# sourceMappingURL=chunk-OMUPQMLR.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/QueryResult.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type CleanupFn } from '@dxos/async';\n\nimport type * as Entity from './Entity';\n\n/**\n * Individual query result entry.\n */\nexport type Entry<T> = {\n  id: string;\n\n  /**\n   * May not be present for remote results.\n   */\n  result?: T;\n\n  match?: {\n    // TODO(dmaretskyi): text positional info.\n\n    /**\n     * Higher means better match.\n     */\n    rank: number;\n  };\n\n  /**\n   * Query resolution metadata.\n   */\n  // TODO(dmaretskyi): Rename to meta?\n  resolution?: {\n    // TODO(dmaretskyi): Make this more generic.\n    source: 'remote' | 'local' | 'index';\n\n    /**\n     * Query resolution time in milliseconds.\n     */\n    time: number;\n  };\n};\n\n/**\n * Invidual query result entry for a database Entity.\n */\nexport type EntityEntry<T extends Entity.Unknown = Entity.Unknown> = Entry<T>;\n\nexport type RunOptions = {\n  timeout?: number;\n};\n\nexport type SubscriptionOptions = {\n  /**\n   * Fire the callback immediately.\n   */\n  fire?: boolean;\n};\n\n// TODO(burdon): Should T be constrained to Entity.Any?\nexport interface QueryResult<T> {\n  /**\n   * Currently available results along with their match metadata.\n   */\n  readonly entries: Entry<T>[];\n\n  /**\n   * Currently available results.\n   */\n  readonly results: T[];\n\n  /**\n   * Returns all known results.\n   */\n  run(opts?: RunOptions): Promise<T[]>;\n\n  /**\n   * Returns all known results along with their match metadata.\n   */\n  runEntries(opts?: RunOptions): Promise<Entry<T>[]>;\n\n  /**\n   * Returns currently available results synchronously.\n   */\n  runSync(): T[];\n\n  /**\n   * Returns currently available results synchronously along with their match metadata.\n   */\n  runSyncEntries(): Entry<T>[];\n\n  /**\n   * Returns first result.\n   */\n  first(opts?: RunOptions): Promise<T>;\n\n  /**\n   * Returns first result if there is one.\n   */\n  firstOrUndefined(opts?: RunOptions): Promise<T | undefined>;\n\n  /**\n   * Subscribes to changes in query results.\n   */\n  subscribe(callback?: (query: QueryResult<T>) => void, opts?: SubscriptionOptions): CleanupFn;\n}\n"],
+  "mappings": ";AAAA;",
+  "names": []
+}

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

@@ -0,0 +1,23 @@
+import {
+  JsonSchemaType,
+  toEffectSchema,
+  toJsonSchema
+} from "./chunk-TLGNKUUG.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/JsonSchema.ts
+var JsonSchema_exports = {};
+__export(JsonSchema_exports, {
+  JsonSchema: () => JsonSchema,
+  toEffectSchema: () => toEffectSchema,
+  toJsonSchema: () => toJsonSchema
+});
+var JsonSchema = JsonSchemaType;
+
+export {
+  JsonSchema,
+  JsonSchema_exports
+};
+//# sourceMappingURL=chunk-QARLJVDB.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/JsonSchema.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\nimport { JsonSchemaType } from './internal';\n\nexport { toEffectSchema, toJsonSchema } from './internal';\n\n/**\n * Serializable JsonSchema type definition.\n */\nexport type JsonSchema = JsonSchemaType;\n\nexport const JsonSchema: Schema.Schema<JsonSchemaType> = JsonSchemaType;\n"],
+  "mappings": ";;;;;;;;;;AAAA;;;;;;AAeO,IAAMA,aAA4CC;",
+  "names": ["JsonSchema", "JsonSchemaType"]
+}