@dxos/echo 0.8.4-main.3a94e84 → 0.8.4-main.3c1ae3b

package/dist/lib/node-esm/chunk-W5AQXKVF.mjs

@@ -0,0 +1,38 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  DescriptionAnnotation,
+  FormInputAnnotation,
+  GeneratorAnnotation,
+  LabelAnnotation,
+  SystemTypeAnnotation,
+  TypeAnnotation,
+  getDescription,
+  getLabel,
+  getTypeAnnotation,
+  setDescription,
+  setLabel
+} from "./chunk-6OTQZKHX.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Annotation.ts
+var Annotation_exports = {};
+__export(Annotation_exports, {
+  DescriptionAnnotation: () => DescriptionAnnotation,
+  FormInputAnnotation: () => FormInputAnnotation,
+  GeneratorAnnotation: () => GeneratorAnnotation,
+  LabelAnnotation: () => LabelAnnotation,
+  SystemTypeAnnotation: () => SystemTypeAnnotation,
+  TypeAnnotation: () => TypeAnnotation,
+  getDescription: () => getDescription,
+  getLabel: () => getLabel,
+  getTypeAnnotation: () => getTypeAnnotation,
+  setDescription: () => setDescription,
+  setLabel: () => setLabel
+});
+
+export {
+  Annotation_exports
+};
+//# sourceMappingURL=chunk-W5AQXKVF.mjs.map

package/dist/lib/node-esm/chunk-W5AQXKVF.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Annotation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport {\n  DescriptionAnnotation,\n  FormInputAnnotation,\n  GeneratorAnnotation,\n  LabelAnnotation,\n  SystemTypeAnnotation,\n  TypeAnnotation,\n  getDescription,\n  getLabel,\n  getTypeAnnotation,\n  setDescription,\n  setLabel,\n} from './internal/annotations';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;",
+  "names": []
+}

package/dist/lib/node-esm/chunk-YNBFXTDG.mjs

@@ -0,0 +1,24 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  JsonSchemaType,
+  toEffectSchema,
+  toJsonSchema
+} from "./chunk-DJX53IQ3.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.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-YNBFXTDG.mjs.map

package/dist/lib/node-esm/chunk-YNBFXTDG.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"]
+}

package/dist/lib/node-esm/chunk-Z53QIBP2.mjs

@@ -0,0 +1,151 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  is,
+  props,
+  type
+} from "./chunk-LDXRA5TC.mjs";
+import {
+  getTypeDXNFromSpecifier
+} from "./chunk-6OTQZKHX.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Query.ts
+var Query_exports = {};
+__export(Query_exports, {
+  all: () => all,
+  fromAst: () => fromAst,
+  is: () => is2,
+  select: () => select,
+  type: () => type2,
+  without: () => without
+});
+var QueryClass = class _QueryClass {
+  ast;
+  static variance = {};
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Query" = _QueryClass.variance;
+  select(filter) {
+    if (is(filter)) {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: filter.ast
+      });
+    } else {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: props(filter).ast
+      });
+    }
+  }
+  reference(key) {
+    return new _QueryClass({
+      type: "reference-traversal",
+      anchor: this.ast,
+      property: key
+    });
+  }
+  referencedBy(target, key) {
+    const dxn = getTypeDXNFromSpecifier(target);
+    return new _QueryClass({
+      type: "incoming-references",
+      anchor: this.ast,
+      property: key,
+      typename: dxn.toString()
+    });
+  }
+  sourceOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "outgoing",
+      filter: type(relation, predicates).ast
+    });
+  }
+  targetOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "incoming",
+      filter: type(relation, predicates).ast
+    });
+  }
+  source() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "source"
+    });
+  }
+  target() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "target"
+    });
+  }
+  orderBy(...order) {
+    return new _QueryClass({
+      type: "order",
+      query: this.ast,
+      order: order.map((o) => o.ast)
+    });
+  }
+  options(options) {
+    return new _QueryClass({
+      type: "options",
+      query: this.ast,
+      options
+    });
+  }
+};
+var is2 = (value) => {
+  return typeof value === "object" && value !== null && "~Query" in value;
+};
+var fromAst = (ast) => {
+  return new QueryClass(ast);
+};
+var select = (filter) => {
+  return new QueryClass({
+    type: "select",
+    filter: filter.ast
+  });
+};
+var type2 = (schema, predicates) => {
+  return new QueryClass({
+    type: "select",
+    filter: type(schema, predicates).ast
+  });
+};
+var all = (...queries) => {
+  if (queries.length === 0) {
+    throw new TypeError("Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())");
+  }
+  return new QueryClass({
+    type: "union",
+    queries: queries.map((q) => q.ast)
+  });
+};
+var without = (source, exclude) => {
+  return new QueryClass({
+    type: "set-difference",
+    source: source.ast,
+    exclude: exclude.ast
+  });
+};
+
+export {
+  is2 as is,
+  fromAst,
+  select,
+  type2 as type,
+  all,
+  without,
+  Query_exports
+};
+//# sourceMappingURL=chunk-Z53QIBP2.mjs.map

package/dist/lib/node-esm/chunk-Z53QIBP2.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Query.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as EffectArray from 'effect/Array';\nimport type * as Schema from 'effect/Schema';\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nimport * as Filter from './Filter';\nimport { getTypeDXNFromSpecifier } from './internal';\nimport type * as Order from './Order';\nimport type * as Ref from './Ref';\nimport type * as Type$ from './Type';\n\n// TODO(dmaretskyi): Split up into interfaces for objects and relations so they can have separate verbs.\n// TODO(dmaretskyi): Undirected relation traversals.\n// TODO(wittjosiah): Make Filter & Query pipeable.\n\n/**\n * All property paths inside T that are references.\n */\n// TODO(dmaretskyi): Filter only properties that are references (or optional references, or unions that include references).\ntype RefPropKey<T> = keyof T & string;\n\n// TODO(burdon): Narrow T to Entity.Unknown?\nexport interface Query<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Query': { value: T };\n\n  ast: QueryAST.Query;\n\n  /**\n   * Filter the current selection based on a filter.\n   * @param filter - Filter to select the objects.\n   * @returns Query for the selected objects.\n   */\n  select(filter: Filter.Filter<T>): Query<T>;\n  select(props: Filter.Props<T>): Query<T>;\n\n  /**\n   * Traverse an outgoing reference.\n   * @param key - Property path inside T that is a reference or optional reference.\n   * @returns Query for the target of the reference.\n   */\n  reference<K extends RefPropKey<T>>(\n    key: K,\n  ): Query<\n    T[K] extends Ref.Any\n      ? Ref.Target<T[K]>\n      : T[K] extends Ref.Any | undefined\n        ? Ref.Target<Exclude<T[K], undefined>>\n        : never\n  >;\n\n  /**\n   * Find objects referencing this object.\n   * @param target - Schema of the referencing object.\n   * @param key - Property path inside the referencing object that is a reference.\n   * @returns Query for the referencing objects.\n   */\n  // TODO(dmaretskyi): any way to enforce `Ref.Target<Schema.Schema.Type<S>[key]> == T`?\n  // TODO(dmaretskyi): Ability to go through arrays of references.\n  referencedBy<S extends Schema.Schema.All>(\n    target: S | string,\n    key: RefPropKey<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * Find relations where this object is the source.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  sourceOf<S extends Schema.Schema.All>(\n    relation: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * Find relations where this object is the target.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  targetOf<S extends Schema.Schema.All>(\n    relation: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * For a query for relations, get the source objects.\n   * @returns Query for the source objects.\n   */\n  source(): Query<Type$.Relation.Source<T>>;\n\n  /**\n   * For a query for relations, get the target objects.\n   * @returns Query for the target objects.\n   */\n  target(): Query<Type$.Relation.Target<T>>;\n\n  /**\n   * Order the query results.\n   * Orders are specified in priority order. The first order will be applied first, etc.\n   * @param order - Order to sort the results.\n   * @returns Query for the ordered results.\n   */\n  orderBy(...order: EffectArray.NonEmptyArray<Order.Order<T>>): Query<T>;\n\n  /**\n   * Add options to a query.\n   */\n  options(options: QueryAST.QueryOptions): Query<T>;\n}\n\nexport type Any = Query<any>;\n\nexport type Type<Q extends Any> = Q extends Query<infer T> ? T : never;\n\nclass QueryClass implements Any {\n  private static variance: Any['~Query'] = {} as Any['~Query'];\n\n  constructor(public readonly ast: QueryAST.Query) {}\n\n  '~Query' = QueryClass.variance;\n\n  select(filter: Filter.Any | Filter.Props<any>): Any {\n    if (Filter.is(filter)) {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: filter.ast,\n      });\n    } else {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: Filter.props(filter).ast,\n      });\n    }\n  }\n\n  reference(key: string): Any {\n    return new QueryClass({\n      type: 'reference-traversal',\n      anchor: this.ast,\n      property: key,\n    });\n  }\n\n  referencedBy(target: Schema.Schema.All | string, key: string): Any {\n    const dxn = getTypeDXNFromSpecifier(target);\n    return new QueryClass({\n      type: 'incoming-references',\n      anchor: this.ast,\n      property: key,\n      typename: dxn.toString(),\n    });\n  }\n\n  sourceOf(relation: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'outgoing',\n      filter: Filter.type(relation, predicates).ast,\n    });\n  }\n\n  targetOf(relation: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'incoming',\n      filter: Filter.type(relation, predicates).ast,\n    });\n  }\n\n  source(): Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'source',\n    });\n  }\n\n  target(): Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'target',\n    });\n  }\n\n  orderBy(...order: Order.Order<any>[]): Any {\n    return new QueryClass({\n      type: 'order',\n      query: this.ast,\n      order: order.map((o) => o.ast),\n    });\n  }\n\n  options(options: QueryAST.QueryOptions): Any {\n    return new QueryClass({\n      type: 'options',\n      query: this.ast,\n      options,\n    });\n  }\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Query' in value;\n};\n\n/** Construct a query from an ast. */\nexport const fromAst = (ast: QueryAST.Query): Any => {\n  return new QueryClass(ast);\n};\n\n/**\n * Select objects based on a filter.\n * @param filter - Filter to select the objects.\n * @returns Query for the selected objects.\n */\nexport const select = <F extends Filter.Any>(filter: F): Query<Filter.Type<F>> => {\n  return new QueryClass({\n    type: 'select',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Query for objects of a given schema.\n * @param schema - Schema of the objects.\n * @param predicates - Predicates to filter the objects.\n * @returns Query for the objects.\n *\n * Shorthand for: `Query.select(Filter.type(schema, predicates))`.\n */\nexport const type = (schema: Schema.Schema.All | string, predicates?: Filter.Props<unknown>): Any => {\n  return new QueryClass({\n    type: 'select',\n    filter: Filter.type(schema, predicates).ast,\n  });\n};\n\n/**\n * Combine results of multiple queries.\n * @param queries - Queries to combine.\n * @returns Query for the combined results.\n */\n// TODO(dmaretskyi): Rename to `combine` or `union`.\nexport const all = (...queries: Any[]): Any => {\n  if (queries.length === 0) {\n    throw new TypeError(\n      'Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())',\n    );\n  }\n  return new QueryClass({\n    type: 'union',\n    queries: queries.map((q) => q.ast),\n  });\n};\n\n/**\n * Subtract one query from another.\n * @param source - Query to subtract from.\n * @param exclude - Query to subtract.\n * @returns Query for the results of the source query minus the results of the exclude query.\n */\nexport const without = <T>(source: Query<T>, exclude: Query<T>): Query<T> => {\n  return new QueryClass({\n    type: 'set-difference',\n    source: source.ast,\n    exclude: exclude.ast,\n  });\n};\n"],
+  "mappings": "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",
+  "names": ["is", "type", "QueryClass", "variance", "ast", "select", "filter", "is", "type", "selection", "props", "reference", "key", "anchor", "property", "referencedBy", "target", "dxn", "getTypeDXNFromSpecifier", "typename", "toString", "sourceOf", "relation", "predicates", "direction", "targetOf", "source", "orderBy", "order", "query", "map", "o", "options", "value", "fromAst", "schema", "all", "queries", "length", "TypeError", "q", "without", "exclude"]
+}

package/dist/lib/node-esm/index.mjs

@@ -1,22 +1,85 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
   DXN,
-  Filter,
-  Key_exports,
-  Obj_exports,
-  Query,
-  Ref_exports,
-  Relation_exports,
+  Hypergraph_exports,
+  QueryAST
+} from "./chunk-MOWUEW5P.mjs";
+import {
+  Tag_exports
+} from "./chunk-KUX5JEL2.mjs";
+import {
+  Order_exports
+} from "./chunk-BYL2NPEA.mjs";
+import {
+  Key_exports
+} from "./chunk-AJEMYSIR.mjs";
+import {
+  Format_exports
+} from "./chunk-CCMFPJUT.mjs";
+import {
+  Relation_exports
+} from "./chunk-76LEDWHO.mjs";
+import {
+  JsonSchema_exports
+} from "./chunk-YNBFXTDG.mjs";
+import {
+  QueryResult_exports
+} from "./chunk-AGHZH33D.mjs";
+import {
+  Query_exports
+} from "./chunk-Z53QIBP2.mjs";
+import {
+  Filter_exports
+} from "./chunk-LDXRA5TC.mjs";
+import {
+  SchemaRegistry_exports
+} from "./chunk-QVZZHCDS.mjs";
+import {
+  Obj_exports
+} from "./chunk-BJACR7QG.mjs";
+import {
   Type_exports
-} from "./chunk-IV6BWGHK.mjs";
+} from "./chunk-FWTPV5QD.mjs";
+import {
+  Ref_exports
+} from "./chunk-W3OLV7MG.mjs";
+import {
+  Entity_exports
+} from "./chunk-5M5P2DCR.mjs";
+import {
+  Annotation_exports
+} from "./chunk-W5AQXKVF.mjs";
+import {
+  Database_exports
+} from "./chunk-JYZSF62S.mjs";
+import "./chunk-DJX53IQ3.mjs";
+import "./chunk-HLUDHPFO.mjs";
+import "./chunk-6OTQZKHX.mjs";
+import "./chunk-NHYOREKX.mjs";
+import {
+  Err_exports
+} from "./chunk-D5BW7KHR.mjs";
+import "./chunk-HSLMI22Q.mjs";
 export {
+  Annotation_exports as Annotation,
   DXN,
-  Filter,
+  Database_exports as Database,
+  Entity_exports as Entity,
+  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,
-  Query,
+  Order_exports as Order,
+  Query_exports as Query,
+  QueryAST,
+  QueryResult_exports as QueryResult,
   Ref_exports as Ref,
   Relation_exports as Relation,
+  SchemaRegistry_exports as SchemaRegistry,
+  Tag_exports as Tag,
   Type_exports as Type
 };
 //# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/internal/index.mjs

@@ -0,0 +1,347 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ATTR_DELETED,
+  ATTR_META,
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  ATTR_SELF_DXN,
+  CustomAnnotations,
+  DecodedAnnotations,
+  ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,
+  ECHO_ANNOTATIONS_NS_KEY,
+  EXPANDO_TYPENAME,
+  EchoAnnotations,
+  EchoObjectSchema,
+  EchoRelationSchema,
+  EchoSchema,
+  Expando,
+  ImmutableSchema,
+  JSON_SCHEMA_ECHO_REF_ID,
+  JsonPath,
+  JsonProp,
+  JsonSchemaEchoAnnotations,
+  JsonSchemaFields,
+  JsonSchemaType,
+  MetaId,
+  ObjectDeletedId,
+  ObjectMetaSchema,
+  ObjectVersionId,
+  PersistentSchema,
+  PropType,
+  RawObject,
+  Ref,
+  RefArray,
+  RefImpl,
+  RefTypeId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  SchemaValidator,
+  SelfDXNId,
+  StaticRefResolver,
+  TypedObject,
+  TypedReactiveHandler,
+  VersionTypeId,
+  addFieldsToSchema,
+  assertObjectModel,
+  attachTypedJsonSerializer,
+  checkIdNotPresentOnSchema,
+  compareForeignKeys,
+  createEchoReferenceSchema,
+  createObject,
+  createQueueDXN,
+  createSchemaReference,
+  foreignKey,
+  foreignKeyEquals,
+  getMeta,
+  getNormalizedEchoAnnotations,
+  getObjectDXN,
+  getRefSavedTarget,
+  getReferenceAst,
+  getSchemaProperty,
+  getSchemaReference,
+  getSnapshot,
+  getValue,
+  isDeleted,
+  isMutable,
+  makeObject,
+  makeTypedEntityClass,
+  normalizeSchema,
+  objectFromJSON,
+  objectToJSON,
+  prepareTypedTarget,
+  refFromEncodedReference,
+  removeFieldsFromSchema,
+  setRefResolver,
+  setRefResolverOnData,
+  setSchemaProperty,
+  setTypenameInSchema,
+  setValue,
+  splitJsonPath,
+  splitMeta,
+  toEffectSchema,
+  toJsonSchema,
+  toPropType,
+  updateFieldNameInSchema,
+  updateFieldsInSchema
+} from "../chunk-DJX53IQ3.mjs";
+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-HLUDHPFO.mjs";
+import {
+  ATTR_TYPE,
+  DescriptionAnnotation,
+  DescriptionAnnotationId,
+  FIELD_PATH_ANNOTATION,
+  FieldLookupAnnotationId,
+  FieldPath,
+  FormInputAnnotation,
+  FormInputAnnotationId,
+  GeneratorAnnotation,
+  GeneratorAnnotationId,
+  LabelAnnotation,
+  LabelAnnotationId,
+  PropertyMeta,
+  PropertyMetaAnnotationId,
+  ReferenceAnnotationId,
+  SchemaId,
+  SchemaMetaSymbol,
+  SystemTypeAnnotation,
+  SystemTypeAnnotationId,
+  TypeAnnotation,
+  TypeAnnotationId,
+  TypeId,
+  TypeIdentifierAnnotationId,
+  TypeMeta,
+  TypenameSchema,
+  VersionSchema,
+  getDescription,
+  getEntityKind,
+  getLabel,
+  getPropertyMetaAnnotation,
+  getReferenceAnnotation,
+  getSchema,
+  getSchemaDXN,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypeAnnotation,
+  getTypeDXN,
+  getTypeDXNFromSpecifier,
+  getTypeIdentifierAnnotation,
+  getTypeReference,
+  getTypename,
+  isInstanceOf,
+  requireTypeReference,
+  setDescription,
+  setLabel,
+  setSchema,
+  setTypename
+} from "../chunk-6OTQZKHX.mjs";
+import {
+  EntityKind,
+  EntityKindSchema,
+  KindId,
+  createAnnotationHelper,
+  makeTypeJsonSchemaAnnotation,
+  unwrapOptional
+} from "../chunk-NHYOREKX.mjs";
+import "../chunk-HSLMI22Q.mjs";
+export {
+  ATTR_DELETED,
+  ATTR_META,
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  ATTR_SELF_DXN,
+  ATTR_TYPE,
+  Currency,
+  CurrencyAnnotationId,
+  CustomAnnotations,
+  DecimalPrecision,
+  DecodedAnnotations,
+  DescriptionAnnotation,
+  DescriptionAnnotationId,
+  ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,
+  ECHO_ANNOTATIONS_NS_KEY,
+  EXPANDO_TYPENAME,
+  EchoAnnotations,
+  EchoObjectSchema,
+  EchoRelationSchema,
+  EchoSchema,
+  Email,
+  EntityKind,
+  EntityKindSchema,
+  Expando,
+  FIELD_PATH_ANNOTATION,
+  FieldLookupAnnotationId,
+  FieldPath,
+  FormInputAnnotation,
+  FormInputAnnotationId,
+  Format,
+  FormatAnnotation,
+  FormatAnnotationId,
+  FormatEnums,
+  Formula,
+  GeneratorAnnotation,
+  GeneratorAnnotationId,
+  GeoLocation,
+  GeoPoint,
+  Hostname,
+  ImmutableSchema,
+  JSON,
+  JSON_SCHEMA_ECHO_REF_ID,
+  JsonPath,
+  JsonProp,
+  JsonSchemaEchoAnnotations,
+  JsonSchemaFields,
+  JsonSchemaType,
+  KindId,
+  LabelAnnotation,
+  LabelAnnotationId,
+  Markdown,
+  MetaId,
+  ObjectDeletedId,
+  ObjectMetaSchema,
+  ObjectVersionId,
+  OptionsAnnotation,
+  OptionsAnnotationId,
+  PersistentSchema,
+  PropType,
+  PropertyKind,
+  PropertyMeta,
+  PropertyMetaAnnotationId,
+  RawObject,
+  Ref,
+  RefArray,
+  RefImpl,
+  RefTypeId,
+  ReferenceAnnotationId,
+  Regex,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  SchemaId,
+  SchemaMetaSymbol,
+  SchemaValidator,
+  SelectOption,
+  SelfDXNId,
+  StaticRefResolver,
+  SystemTypeAnnotation,
+  SystemTypeAnnotationId,
+  Text,
+  TypeAnnotation,
+  TypeAnnotationId,
+  TypeEnum,
+  TypeFormat,
+  TypeId,
+  TypeIdentifierAnnotationId,
+  TypeMeta,
+  TypedObject,
+  TypedReactiveHandler,
+  TypenameSchema,
+  URL,
+  UUID,
+  VersionSchema,
+  VersionTypeId,
+  addFieldsToSchema,
+  assertObjectModel,
+  attachTypedJsonSerializer,
+  checkIdNotPresentOnSchema,
+  compareForeignKeys,
+  createAnnotationHelper,
+  createEchoReferenceSchema,
+  createObject,
+  createQueueDXN,
+  createSchemaReference,
+  foreignKey,
+  foreignKeyEquals,
+  formatToType,
+  getDescription,
+  getEntityKind,
+  getFormatAnnotation,
+  getLabel,
+  getMeta,
+  getNormalizedEchoAnnotations,
+  getObjectDXN,
+  getOptionsAnnotation,
+  getPropertyMetaAnnotation,
+  getRefSavedTarget,
+  getReferenceAnnotation,
+  getReferenceAst,
+  getSchema,
+  getSchemaDXN,
+  getSchemaProperty,
+  getSchemaReference,
+  getSchemaTypename,
+  getSchemaVersion,
+  getSnapshot,
+  getTypeAnnotation,
+  getTypeDXN,
+  getTypeDXNFromSpecifier,
+  getTypeEnum,
+  getTypeIdentifierAnnotation,
+  getTypeReference,
+  getTypename,
+  getValue,
+  isDeleted,
+  isInstanceOf,
+  isMutable,
+  makeObject,
+  makeTypeJsonSchemaAnnotation,
+  makeTypedEntityClass,
+  normalizeSchema,
+  objectFromJSON,
+  objectToJSON,
+  prepareTypedTarget,
+  refFromEncodedReference,
+  removeFieldsFromSchema,
+  requireTypeReference,
+  setDescription,
+  setLabel,
+  setRefResolver,
+  setRefResolverOnData,
+  setSchema,
+  setSchemaProperty,
+  setTypename,
+  setTypenameInSchema,
+  setValue,
+  splitJsonPath,
+  splitMeta,
+  toEffectSchema,
+  toJsonSchema,
+  toPropType,
+  typeToFormat,
+  unwrapOptional,
+  updateFieldNameInSchema,
+  updateFieldsInSchema
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/internal/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}