@dxos/echo 0.8.4-main.66e292d → 0.8.4-main.69d29f4

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

@@ -0,0 +1,69 @@
+import "@dxos/node-std/globals";
+
+// src/internal/types/entity.ts
+import * as Schema from "effect/Schema";
+var KindId = "~@dxos/echo/Kind";
+var SchemaKindId = "~@dxos/echo/SchemaKind";
+var SnapshotKindId = "~@dxos/echo/SnapshotKind";
+var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
+  EntityKind2["Object"] = "object";
+  EntityKind2["Relation"] = "relation";
+  return EntityKind2;
+})({});
+var EntityKindSchema = Schema.Enums(EntityKind);
+var ANY_OBJECT_TYPENAME = "dxos.org/schema/AnyObject";
+var ANY_OBJECT_VERSION = "0.0.0";
+
+// src/internal/annotations/util.ts
+import * as SchemaAST from "effect/SchemaAST";
+import { assertArgument } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var createAnnotationHelper = (id) => {
+  return {
+    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),
+    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),
+    set: (value) => (schema) => schema.annotations({
+      [id]: value
+    })
+  };
+};
+var unwrapOptional = (property) => {
+  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {
+    return property;
+  }
+  return property.type.types[0];
+};
+var makeTypeJsonSchemaAnnotation = (options) => {
+  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), "relationSource");
+  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), "relationTarget");
+  const obj = {
+    // TODO(dmaretskyi): Should this include the version?
+    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),
+    entityKind: options.kind,
+    version: options.version,
+    typename: options.typename
+  };
+  if (options.kind === EntityKind.Relation) {
+    obj.relationSource = {
+      $ref: options.relationSource
+    };
+    obj.relationTarget = {
+      $ref: options.relationTarget
+    };
+  }
+  return obj;
+};
+
+export {
+  KindId,
+  SchemaKindId,
+  SnapshotKindId,
+  EntityKind,
+  EntityKindSchema,
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  createAnnotationHelper,
+  unwrapOptional,
+  makeTypeJsonSchemaAnnotation
+};
+//# sourceMappingURL=chunk-YKTSSMDS.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/types/entity.ts", "../../../src/internal/annotations/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.\n//   Unique symbols cause TS4023 \"cannot be named\" errors when external packages\n//   try to export types that reference this key (e.g., `export const Graph = ...`).\n//   TypeScript cannot emit declaration files that reference unique symbols from\n//   external modules. Using a string literal allows the type to be inlined in\n//   declaration files, making the API portable across package boundaries.\n\n/**\n * String key used to identify the kind of an entity instance (object or relation).\n */\nexport const KindId = '~@dxos/echo/Kind' as const;\nexport type KindId = typeof KindId;\n\n/**\n * String key used to identify the kind of a schema (object schema or relation schema).\n * Parallels KindId which identifies instance kinds.\n */\nexport const SchemaKindId = '~@dxos/echo/SchemaKind' as const;\nexport type SchemaKindId = typeof SchemaKindId;\n\n/**\n * String key used to brand snapshot types.\n * Snapshots have SnapshotKindId instead of KindId, making them\n * distinguishable from reactive objects at the type level.\n */\nexport const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;\nexport type SnapshotKindId = typeof SnapshotKindId;\n\n/**\n * Kinds of entities stored in ECHO: objects and relations.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\n}\n\nexport const EntityKindSchema = Schema.Enums(EntityKind);\n\n/**\n * Typename for generic object references (Type.Obj / Type.Ref(Type.Obj)).\n * Used when referencing any object without a specific schema.\n */\nexport const ANY_OBJECT_TYPENAME = 'dxos.org/schema/AnyObject';\n\n/**\n * Version for generic object references.\n */\nexport const ANY_OBJECT_VERSION = '0.0.0';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { EntityKind } from '../types';\n\nexport interface AnnotationHelper<T> {\n  get: (schema: Schema.Schema.Any) => Option.Option<T>;\n  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\nexport const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {\n  return {\n    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),\n    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),\n    set:\n      (value) =>\n      <S extends Schema.Schema.Any>(schema: S) =>\n        schema.annotations({ [id]: value }) as S,\n  };\n};\n\n/**\n * If property is optional returns the nested property, otherwise returns the property.\n */\n// TODO(wittjosiah): Is there a way to do this as a generic?\nexport const unwrapOptional = (property: SchemaAST.PropertySignature) => {\n  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {\n    return property;\n  }\n\n  return property.type.types[0];\n};\n\n/**\n * @see JSONSchemaAnnotationId\n * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.\n */\n// TODO(burdon): Required type.\nexport const makeTypeJsonSchemaAnnotation = (options: {\n  identifier?: string;\n  kind: EntityKind;\n  typename: string;\n  version: string;\n  relationSource?: string;\n  relationTarget?: string;\n}) => {\n  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');\n  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');\n\n  const obj = {\n    // TODO(dmaretskyi): Should this include the version?\n    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  } as any;\n  if (options.kind === EntityKind.Relation) {\n    obj.relationSource = { $ref: options.relationSource };\n    obj.relationTarget = { $ref: options.relationTarget };\n  }\n\n  return obj;\n};\n"],
+  "mappings": ";;;AAIA,YAAYA,YAAY;AAYjB,IAAMC,SAAS;AAOf,IAAMC,eAAe;AAQrB,IAAMC,iBAAiB;AAMvB,IAAKC,aAAAA,0BAAAA,aAAAA;;;SAAAA;;AAKL,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC/ClC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAUb,IAAMC,yBAAyB,CAAIC,OAAAA;AACxC,SAAO;IACLC,KAAK,CAACC,WAAqBC,wBAAcD,OAAOE,KAAKJ,EAAAA;IACrDK,YAAY,CAACD,QAAkBD,wBAAcC,KAAKJ,EAAAA;IAClDM,KACE,CAACC,UACD,CAA8BL,WAC5BA,OAAOM,YAAY;MAAE,CAACR,EAAAA,GAAKO;IAAM,CAAA;EACvC;AACF;AAMO,IAAME,iBAAiB,CAACC,aAAAA;AAC7B,MAAI,CAACA,SAASC,cAAc,CAAWC,kBAAQF,SAASG,IAAI,GAAG;AAC7D,WAAOH;EACT;AAEA,SAAOA,SAASG,KAAKC,MAAM,CAAA;AAC7B;AAOO,IAAMC,+BAA+B,CAACC,YAAAA;AAQ3CC,iBAAe,CAAC,CAACD,QAAQE,oBAAoBF,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AACpFJ,iBAAe,CAAC,CAACD,QAAQM,oBAAoBN,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AAEpF,QAAME,MAAM;;IAEVC,KAAKR,QAAQS,cAAcC,IAAIC,aAAaX,QAAQY,QAAQ,EAAEC,SAAQ;IACtEC,YAAYd,QAAQG;IACpBY,SAASf,QAAQe;IACjBH,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEc,MAAMhB,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAEU,MAAMhB,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
+  "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "EntityKind", "EntityKindSchema", "Enums", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "SchemaAST", "assertArgument", "DXN", "createAnnotationHelper", "id", "get", "schema", "getAnnotation", "ast", "getFromAst", "set", "value", "annotations", "unwrapOptional", "property", "isOptional", "isUnion", "type", "types", "makeTypeJsonSchemaAnnotation", "options", "assertArgument", "relationSource", "kind", "EntityKind", "Relation", "relationTarget", "obj", "$id", "identifier", "DXN", "fromTypename", "typename", "toString", "entityKind", "version", "$ref"]
+}

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

@@ -0,0 +1,9 @@
+import "@dxos/node-std/globals";
+
+// src/SchemaRegistry.ts
+var SchemaRegistry_exports = {};
+
+export {
+  SchemaRegistry_exports
+};
+//# sourceMappingURL=chunk-ZHXZGIXD.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/SchemaRegistry.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Types from 'effect/Types';\n\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Key from './Key';\nimport type * as QueryResult from './QueryResult';\nimport type * as Type from './Type';\n\n// TODO(wittjosiah): Replace w/ Query.Query.\nexport type Query = {\n  /**\n   * Filter by schema ID.\n   * Schema id is a DXN with `echo` or `type` kind.\n   */\n  id?: string | string[];\n\n  /**\n   * Id of the backing ECHO object.\n   */\n  backingObjectId?: Key.ObjectId | Key.ObjectId[];\n\n  /**\n   * One or more typenames to filter by.\n   */\n  typename?: string | string[];\n\n  /**\n   * [Semver Range](https://docs.npmjs.com/cli/v6/using-npm/semver#ranges) for the schema version.\n   */\n  version?: string;\n\n  /**\n   * Where to look for the schema.\n   *\n   * Database schema are stored in the database of the current space.\n   * Runtime schema are registered in the runtime.\n   *\n   * @default ['database']\n   */\n  location?: ('database' | 'runtime')[];\n\n  /**\n   * Include system schemas.\n   * @default false\n   *\n   * The system schema include but are not limited to:\n   *  - dxos.org/type/Schema\n   */\n  includeSystem?: boolean;\n};\n\n/**\n * Input for schema registration.\n * The typename, version and schema mutability metadata is read from the schema annotations.\n *\n * Accepts:\n * - Branded ECHO schemas created with Type.Obj() or Type.Relation()\n * - JSON schema with typename and version\n */\nexport type RegisterSchemaInput =\n  | Type.Entity.Any\n  | {\n      typename: string;\n      version: string;\n      jsonSchema: JsonSchema.JsonSchema;\n      /**\n       * Display name of the schema.\n       */\n      name?: string;\n    };\n\nexport type ExtractQueryResult<Query> = Query extends { location: ('database' | 'runtime')[] }\n  ? Type.Entity.Any\n  : Type.RuntimeType;\n\nexport interface SchemaRegistry {\n  /**\n   * Checks if the provided schema is registered.\n   */\n  // TODO(burdon): Type?\n  hasSchema(schema: Type.Entity.Any): boolean;\n\n  /**\n   * Registers the provided schema.\n   *\n   * @returns Mutable runtime instances of schemas that were registered.\n   *\n   * The behavior of this method depends on the state of the database.\n   * The general principle is that the schema will be upserted into the space.\n   * If an equivalent schema with the same name and version already exists, the method does nothing.\n   * If a different schema with the same name and version exists, the method throws an error.\n   * If no schema with the same name and version exists, a new schema will be inserted based on semantic versioning rules.\n   */\n  register(input: RegisterSchemaInput[]): Promise<Type.RuntimeType[]>;\n\n  /**\n   *\n   */\n  query<Q extends Types.NoExcessProperties<Query, Q>>(\n    query?: Q & Query,\n  ): QueryResult.QueryResult<ExtractQueryResult<Q>>;\n}\n"],
+  "mappings": ";;;AAAA;",
+  "names": []
+}

package/dist/lib/browser/index.mjs

@@ -1,44 +1,84 @@
 import "@dxos/node-std/globals";
 import {
-  Annotation_exports,
   DXN,
-  Database_exports,
-  Entity_exports,
-  Filter,
-  FilterClass,
-  Format_exports,
-  JsonSchema_exports,
-  Key_exports,
-  Obj_exports,
-  ObjectNotFoundError,
-  Order,
-  Query,
-  QueryAST,
-  Ref_exports,
-  Relation_exports,
-  SchemaNotFoundError,
-  Tag_exports,
+  Hypergraph_exports,
+  QueryAST
+} from "./chunk-MYCCGG2T.mjs";
+import {
+  Tag_exports
+} from "./chunk-AFGYYVVQ.mjs";
+import {
+  Order_exports
+} from "./chunk-JMKVF2YQ.mjs";
+import {
+  Key_exports
+} from "./chunk-INHXFXY5.mjs";
+import {
   Type_exports
-} from "./chunk-E4UTVJNF.mjs";
-import "./chunk-7GH6RXJ3.mjs";
+} from "./chunk-L4RXUJHJ.mjs";
+import {
+  Format_exports
+} from "./chunk-5RDNDPMX.mjs";
+import {
+  Relation_exports
+} from "./chunk-2RMVRVOB.mjs";
+import {
+  JsonSchema_exports
+} from "./chunk-BC6R4CAF.mjs";
+import {
+  QueryResult_exports
+} from "./chunk-IXVWLTG7.mjs";
+import {
+  Query_exports
+} from "./chunk-BPYFLHWO.mjs";
+import {
+  Filter_exports
+} from "./chunk-TPIL3G6Y.mjs";
+import {
+  Ref_exports
+} from "./chunk-QIWDIPLR.mjs";
+import {
+  SchemaRegistry_exports
+} from "./chunk-ZHXZGIXD.mjs";
+import {
+  Obj_exports
+} from "./chunk-CBPFF3ZO.mjs";
+import {
+  Entity_exports
+} from "./chunk-73M2G455.mjs";
+import "./chunk-PAM4KEXE.mjs";
+import "./chunk-R3S54KRI.mjs";
+import {
+  Annotation_exports
+} from "./chunk-FPOISFQK.mjs";
+import {
+  Database_exports
+} from "./chunk-7STIBCP7.mjs";
+import "./chunk-RK4Z4JUZ.mjs";
+import "./chunk-YKTSSMDS.mjs";
+import {
+  Err_exports
+} from "./chunk-CJ5YELTO.mjs";
+import "./chunk-CGS2ULMK.mjs";
 export {
   Annotation_exports as Annotation,
   DXN,
   Database_exports as Database,
   Entity_exports as Entity,
-  Filter,
-  FilterClass,
+  Err_exports as Err,
+  Filter_exports as Filter,
   Format_exports as Format,
+  Hypergraph_exports as Hypergraph,
   JsonSchema_exports as JsonSchema,
   Key_exports as Key,
   Obj_exports as Obj,
-  ObjectNotFoundError,
-  Order,
-  Query,
+  Order_exports as Order,
+  Query_exports as Query,
   QueryAST,
+  QueryResult_exports as QueryResult,
   Ref_exports as Ref,
   Relation_exports as Relation,
-  SchemaNotFoundError,
+  SchemaRegistry_exports as SchemaRegistry,
   Tag_exports as Tag,
   Type_exports as Type
 };