@dxos/echo 0.8.4-main.69d29f4 → 0.8.4-main.6fa680abb7

package/dist/lib/neutral/chunk-2Z72D23W.mjs

@@ -0,0 +1,787 @@
+import {
+  CurrencyAnnotationId,
+  FormatAnnotation,
+  FormatAnnotationId,
+  TypeFormat
+} from "./chunk-B5OXLWZL.mjs";
+import {
+  createEchoReferenceSchema
+} from "./chunk-35FDO7WH.mjs";
+import {
+  GeneratorAnnotationId,
+  LabelAnnotationId,
+  PropertyMetaAnnotationId,
+  TypeAnnotationId,
+  TypeIdentifierAnnotationId
+} from "./chunk-SEMVAGBM.mjs";
+import {
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  EntityKind,
+  EntityKindSchema,
+  makeTypeJsonSchemaAnnotation
+} from "./chunk-WYOKA6AE.mjs";
+
+// src/internal/JsonSchema/annotations.ts
+import * as SchemaAST from "effect/SchemaAST";
+var CustomAnnotations = {
+  format: FormatAnnotationId,
+  currency: CurrencyAnnotationId
+};
+var DecodedAnnotations = {
+  title: SchemaAST.TitleAnnotationId,
+  description: SchemaAST.DescriptionAnnotationId
+};
+var EchoAnnotations = {
+  // TODO(dmaretskyi): `FieldLookupAnnotationId` might go here, but lets remove it entirely and use LabelAnnotation instead.
+  meta: PropertyMetaAnnotationId,
+  generator: GeneratorAnnotationId,
+  labelProp: LabelAnnotationId
+};
+
+// src/internal/JsonSchema/json-schema-type.ts
+import * as Schema from "effect/Schema";
+import { JsonPath } from "@dxos/effect";
+var SimpleTypes = Schema.Literal("array", "boolean", "integer", "null", "number", "object", "string");
+var NonNegativeInteger = Schema.Number.pipe(Schema.greaterThanOrEqualTo(0));
+var StringArray = Schema.Array(Schema.String);
+var JsonSchemaOrBoolean = Schema.Union(Schema.suspend(() => JsonSchemaType), Schema.Boolean);
+var JsonSchemaEchoAnnotations = Schema.Struct({
+  /**
+  * Label for this schema.
+  * Mapped from {@link LabelAnnotationId}.
+  */
+  labelProp: Schema.optional(Schema.Union(JsonPath, Schema.Array(JsonPath))),
+  /**
+  * Generator function for this schema.
+  * Mapped from {@link GeneratorAnnotationId}.
+  */
+  generator: Schema.optional(Schema.Union(Schema.String, Schema.Tuple(Schema.String, Schema.Number))),
+  /**
+  * {@link PropertyMeta} annotations get serialized here.
+  */
+  meta: Schema.optional(Schema.Record({
+    key: Schema.String,
+    value: Schema.Any
+  })),
+  /**
+  * @deprecated
+  */
+  // TODO(dmaretskyi): We risk old schema not passing validation due to the extra fields. Remove when we are sure this is safe.
+  type: Schema.optional(Schema.Struct({
+    typename: Schema.String,
+    version: Schema.String,
+    // Not used.
+    schemaId: Schema.optional(Schema.String)
+  })),
+  /**
+  * @deprecated Superseded by `meta`.
+  */
+  annotations: Schema.optional(Schema.Record({
+    key: Schema.String,
+    value: Schema.Any
+  }))
+});
+var _JsonSchemaType = Schema.Struct({
+  /**
+  * Identifier for this schema.
+  * This schema might be referenced by $ref clause in other schemas.
+  */
+  // TODO(dmaretskyi): Specify how the ids are generated.
+  // TODO(dmaretskyi): For type dxns, should this include the version?
+  $id: Schema.optional(Schema.String),
+  /**
+  * Schema of this schema.
+  * Set to "https://json-schema.org/draft-07/schema".
+  */
+  $schema: Schema.optional(Schema.String),
+  /**
+  * Reference to another schema.
+  */
+  $ref: Schema.optional(Schema.String),
+  /**
+  * Comments are ignored when interpreting the schema.
+  */
+  $comment: Schema.optional(Schema.String),
+  /**
+  * Defines whether this schema is an object schema or a relation schema.
+  */
+  entityKind: Schema.optional(EntityKindSchema),
+  /**
+  * Typename of this schema.
+  * Only on schema representing an ECHO object.
+  *
+  * @example 'com.example.type.my-type'
+  */
+  typename: Schema.optional(Schema.String),
+  /**
+  * Version of this schema.
+  * Custom dialect for ECHO.
+  */
+  version: Schema.optional(Schema.String),
+  /**
+  * Target of this relation.
+  * Only for relation schemas.
+  * The referenced schema must be an object schema.
+  */
+  relationTarget: Schema.optional(Schema.suspend(() => JsonSchemaType)),
+  /**
+  * Source of this relation.
+  * Only for relation schemas.
+  * The referenced schema must be an object schema.
+  */
+  relationSource: Schema.optional(Schema.suspend(() => JsonSchemaType)),
+  /**
+  * Title of this schema.
+  */
+  title: Schema.optional(Schema.String),
+  /**
+  * Description of this schema.
+  */
+  description: Schema.optional(Schema.String),
+  /**
+  * Whether this schema is read-only.
+  */
+  readOnly: Schema.optional(Schema.Boolean),
+  /**
+  * Whether this schema is write-only.
+  */
+  writeOnly: Schema.optional(Schema.Boolean),
+  /**
+  * Examples of instances of this schema.
+  */
+  examples: Schema.optional(Schema.Array(Schema.Any)),
+  /**
+  * Default value for this schema.
+  */
+  default: Schema.optional(Schema.Any),
+  /**
+  * This schema only matches values that are equal to this value.
+  */
+  const: Schema.optional(Schema.Any),
+  /**
+  * This schema only matches one of the values in this array.
+  */
+  enum: Schema.optional(Schema.Array(Schema.Any)),
+  /**
+  * Base type of the schema.
+  */
+  type: Schema.optional(Schema.Union(SimpleTypes, Schema.Array(SimpleTypes))),
+  //
+  // Numbers.
+  //
+  multipleOf: Schema.optional(Schema.Number.pipe(Schema.greaterThan(0))),
+  maximum: Schema.optional(Schema.Number),
+  exclusiveMaximum: Schema.optional(Schema.Number),
+  minimum: Schema.optional(Schema.Number),
+  exclusiveMinimum: Schema.optional(Schema.Number),
+  //
+  // Strings.
+  //
+  maxLength: Schema.optional(NonNegativeInteger),
+  /**
+  * Regex pattern for strings.
+  */
+  pattern: Schema.optional(Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex))),
+  /**
+  * Serialized from {@link FormatAnnotationId}.
+  */
+  format: Schema.optional(Schema.String),
+  //
+  // Arrays
+  //
+  minLength: Schema.optional(NonNegativeInteger),
+  items: Schema.optional(Schema.Union(Schema.suspend(() => JsonSchemaType), Schema.Array(Schema.suspend(() => JsonSchemaType)))),
+  additionalItems: Schema.optional(Schema.Union(Schema.suspend(() => JsonSchemaType), Schema.Boolean)),
+  maxItems: Schema.optional(NonNegativeInteger),
+  minItems: Schema.optional(NonNegativeInteger),
+  uniqueItems: Schema.optional(Schema.Boolean),
+  contains: Schema.optional(Schema.suspend(() => JsonSchemaType)),
+  //
+  // Objects
+  //
+  maxProperties: Schema.optional(NonNegativeInteger),
+  minProperties: Schema.optional(NonNegativeInteger),
+  required: Schema.optional(StringArray),
+  /**
+  * Non-standard JSON Schema extension.
+  * Defines the order of properties in the object.
+  * The unmentioned properties are placed at the end.
+  *
+  * Related: https://github.com/json-schema/json-schema/issues/119
+  */
+  propertyOrder: Schema.optional(StringArray),
+  additionalProperties: Schema.optional(JsonSchemaOrBoolean),
+  properties: Schema.optional(Schema.Record({
+    key: Schema.String,
+    value: Schema.suspend(() => JsonSchemaType)
+  })),
+  patternProperties: Schema.optional(Schema.Record({
+    key: Schema.String,
+    value: Schema.suspend(() => JsonSchemaType)
+  })),
+  propertyNames: Schema.optional(Schema.suspend(() => JsonSchemaType)),
+  definitions: Schema.optional(Schema.Record({
+    key: Schema.String,
+    value: Schema.suspend(() => JsonSchemaType)
+  })),
+  dependencies: Schema.optional(Schema.Record({
+    key: Schema.String,
+    value: Schema.suspend(() => Schema.Union(Schema.String, StringArray, JsonSchemaType)).annotations({
+      identifier: "dependency",
+      description: "Dependency"
+    })
+  })),
+  contentMediaType: Schema.optional(Schema.String),
+  contentEncoding: Schema.optional(Schema.String),
+  if: Schema.optional(Schema.suspend(() => JsonSchemaType)),
+  then: Schema.optional(Schema.suspend(() => JsonSchemaType)),
+  else: Schema.optional(Schema.suspend(() => JsonSchemaType)),
+  allOf: Schema.optional(Schema.Array(Schema.suspend(() => JsonSchemaType))),
+  anyOf: Schema.optional(Schema.Array(Schema.suspend(() => JsonSchemaType))),
+  oneOf: Schema.optional(Schema.Array(Schema.suspend(() => JsonSchemaType))),
+  not: Schema.optional(Schema.suspend(() => JsonSchemaType)),
+  $defs: Schema.optional(Schema.Record({
+    key: Schema.String,
+    value: Schema.suspend(() => JsonSchemaType)
+  })),
+  //
+  // ECHO extensions.
+  //
+  currency: Schema.optional(Schema.String),
+  reference: Schema.optional(Schema.Struct({
+    schema: Schema.suspend(() => JsonSchemaType),
+    schemaVersion: Schema.optional(Schema.String),
+    schemaObject: Schema.optional(Schema.String)
+  })),
+  /**
+  * ECHO-specific annotations.
+  */
+  // TODO(dmaretskyi): Since we are adding a lot of new extensions to the JSON Schema, it is safer to namespace them here.
+  annotations: Schema.optional(JsonSchemaEchoAnnotations),
+  /**
+  * @deprecated Use `annotations` instead.
+  */
+  echo: Schema.optional(JsonSchemaEchoAnnotations)
+}).annotations({
+  identifier: "jsonSchema",
+  description: "JSON Schema"
+});
+var JsonSchemaFields = Object.keys(_JsonSchemaType.fields);
+var JsonSchemaType = _JsonSchemaType;
+var getSchemaProperty = (schema, property) => {
+  return schema.properties?.[property];
+};
+var setSchemaProperty = (schema, property, value) => {
+  schema.properties ??= {};
+  schema.properties[property] = value;
+  return schema;
+};
+var ECHO_ANNOTATIONS_NS_DEPRECATED_KEY = "echo";
+var ECHO_ANNOTATIONS_NS_KEY = "annotations";
+var getNormalizedEchoAnnotations = (obj) => {
+  if (obj[ECHO_ANNOTATIONS_NS_KEY] != null && obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY] != null) {
+    return normalizeEchoAnnotations({
+      ...obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY],
+      ...obj[ECHO_ANNOTATIONS_NS_KEY]
+    });
+  } else if (obj[ECHO_ANNOTATIONS_NS_KEY] != null) {
+    return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_KEY]);
+  } else if (obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY] != null) {
+    return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY]);
+  } else {
+    return void 0;
+  }
+};
+var normalizeEchoAnnotations = (obj) => {
+  if (!obj.annotations) {
+    return obj;
+  } else {
+    const res = {
+      ...obj,
+      meta: {
+        ...obj.annotations,
+        ...obj.meta ?? {}
+      }
+    };
+    delete res.annotations;
+    return res;
+  }
+};
+
+// src/internal/JsonSchema/json-schema.ts
+import * as Array2 from "effect/Array";
+import * as Function from "effect/Function";
+import * as JSONSchema from "effect/JSONSchema";
+import * as Option from "effect/Option";
+import * as Schema2 from "effect/Schema";
+import * as SchemaAST2 from "effect/SchemaAST";
+import { raise } from "@dxos/debug";
+import { mapAst } from "@dxos/effect";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { DXN, ObjectId } from "@dxos/keys";
+import { log } from "@dxos/log";
+import { clearUndefined, orderKeys, removeProperties } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/JsonSchema/json-schema.ts";
+var PropType = /* @__PURE__ */ (function(PropType2) {
+  PropType2[PropType2["NONE"] = 0] = "NONE";
+  PropType2[PropType2["STRING"] = 1] = "STRING";
+  PropType2[PropType2["NUMBER"] = 2] = "NUMBER";
+  PropType2[PropType2["BOOLEAN"] = 3] = "BOOLEAN";
+  PropType2[PropType2["DATE"] = 4] = "DATE";
+  PropType2[PropType2["REF"] = 5] = "REF";
+  PropType2[PropType2["RECORD"] = 6] = "RECORD";
+  PropType2[PropType2["ENUM"] = 7] = "ENUM";
+  return PropType2;
+})({});
+var toPropType = (type) => {
+  switch (type) {
+    case 1:
+      return "string";
+    case 2:
+      return "number";
+    case 3:
+      return "boolean";
+    case 4:
+      return "date";
+    case 5:
+      return "ref";
+    case 6:
+      return "object";
+    default:
+      throw new Error(`Invalid type: ${type}`);
+  }
+};
+var JSON_SCHEMA_URL = "http://json-schema.org/draft-07/schema#";
+var toJsonSchema = (schema, options = {}) => {
+  assertArgument(Schema2.isSchema(schema), "schema");
+  let jsonSchema = _toJsonSchemaAST(schema.ast);
+  if (options.strict) {
+    jsonSchema = removeProperties(jsonSchema, (key, value) => {
+      if (key === "$id" && value === "/schemas/any") {
+        return true;
+      }
+      if (key === "$ref" && value === "#/$defs/dependency") {
+        return true;
+      }
+      if (key === "$ref" && value === "#/$defs/jsonSchema") {
+        return true;
+      }
+      return false;
+    });
+  }
+  return jsonSchema;
+};
+var _toJsonSchemaAST = (ast) => {
+  const withRefinements = withEchoRefinements(ast, "#");
+  const jsonSchema = JSONSchema.fromAST(withRefinements, {
+    definitions: {}
+  });
+  return normalizeJsonSchema(jsonSchema);
+};
+var withEchoRefinements = (ast, path, suspendCache = /* @__PURE__ */ new Map()) => {
+  if (path) {
+    suspendCache.set(ast, path);
+  }
+  let recursiveResult;
+  if (SchemaAST2.isSuspend(ast)) {
+    const suspendedAst = ast.f();
+    const cachedPath = suspendCache.get(suspendedAst);
+    if (cachedPath) {
+      recursiveResult = new SchemaAST2.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {
+        [SchemaAST2.JSONSchemaAnnotationId]: {
+          $ref: cachedPath
+        }
+      });
+    } else {
+      const jsonSchema = _toJsonSchemaAST(suspendedAst);
+      recursiveResult = new SchemaAST2.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {
+        [SchemaAST2.JSONSchemaAnnotationId]: jsonSchema
+      });
+    }
+  } else if (SchemaAST2.isTypeLiteral(ast)) {
+    recursiveResult = mapAst(ast, (ast2, key) => withEchoRefinements(ast2, path && typeof key === "string" ? `${path}/${key}` : void 0, suspendCache));
+    recursiveResult = addJsonSchemaFields(recursiveResult, {
+      propertyOrder: [
+        ...ast.propertySignatures.map((p) => p.name)
+      ]
+    });
+  } else if (SchemaAST2.isUndefinedKeyword(ast)) {
+    return ast;
+  } else {
+    recursiveResult = mapAst(ast, (ast2, key) => withEchoRefinements(ast2, path && (typeof key === "string" || typeof key === "number") ? `${path}/${key}` : void 0, suspendCache));
+  }
+  const annotationFields = annotations_toJsonSchemaFields(ast.annotations);
+  if (Object.keys(annotationFields).length === 0) {
+    return recursiveResult;
+  } else {
+    return addJsonSchemaFields(recursiveResult, annotationFields);
+  }
+};
+var toEffectSchema = (root, _defs) => {
+  const defs = root.$defs ? {
+    ..._defs,
+    ...root.$defs
+  } : _defs ?? {};
+  if ("type" in root && root.type === "object") {
+    return objectToEffectSchema(root, defs);
+  }
+  let result = Schema2.Unknown;
+  if ("$ref" in root) {
+    switch (root.$ref) {
+      case "/schemas/echo/ref": {
+        result = refToEffectSchema(root);
+        break;
+      }
+    }
+  } else if ("$id" in root) {
+    switch (root.$id) {
+      case "/schemas/any": {
+        result = anyToEffectSchema(root);
+        break;
+      }
+      case "/schemas/unknown": {
+        result = Schema2.Unknown;
+        break;
+      }
+      case "/schemas/{}":
+      case "/schemas/object": {
+        result = Schema2.Object;
+        break;
+      }
+      // Custom ECHO object reference.
+      case "/schemas/echo/ref": {
+        result = refToEffectSchema(root);
+        break;
+      }
+    }
+  } else if ("enum" in root) {
+    result = Schema2.Union(...root.enum.map((e) => Schema2.Literal(e)));
+  } else if ("oneOf" in root) {
+    result = Schema2.Union(...root.oneOf.map((v) => toEffectSchema(v, defs)));
+  } else if ("anyOf" in root) {
+    result = Schema2.Union(...root.anyOf.map((v) => toEffectSchema(v, defs)));
+  } else if ("allOf" in root) {
+    if (root.allOf.length === 1) {
+      result = toEffectSchema(root.allOf[0], defs);
+    } else {
+      log.warn("allOf with multiple schemas is not supported", void 0, {
+        F: __dxlog_file,
+        L: 224,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      result = Schema2.Unknown;
+    }
+  } else if ("type" in root) {
+    switch (root.type) {
+      case "string": {
+        result = Schema2.String;
+        if (root.pattern) {
+          result = result.pipe(Schema2.pattern(new RegExp(root.pattern)));
+        }
+        break;
+      }
+      case "number": {
+        result = Schema2.Number;
+        break;
+      }
+      case "integer": {
+        result = Schema2.Number.pipe(Schema2.int());
+        break;
+      }
+      case "boolean": {
+        result = Schema2.Boolean;
+        break;
+      }
+      case "array": {
+        if (Array2.isArray(root.items)) {
+          const [required, optional3] = Function.pipe(root.items, Array2.map((v) => toEffectSchema(v, defs)), Array2.splitAt(root.minItems ?? root.items.length));
+          result = Schema2.Tuple(...required, ...optional3.map(Schema2.optionalElement));
+        } else {
+          invariant(root.items, void 0, {
+            F: __dxlog_file,
+            L: 257,
+            S: void 0,
+            A: [
+              "root.items",
+              ""
+            ]
+          });
+          const items = root.items;
+          result = Array2.isArray(items) ? Schema2.Tuple(...items.map((v) => toEffectSchema(v, defs))) : Schema2.Array(toEffectSchema(items, defs));
+        }
+        break;
+      }
+      case "null": {
+        result = Schema2.Null;
+        break;
+      }
+    }
+  } else if ("$ref" in root) {
+    const refSegments = root.$ref.split("/");
+    const jsonSchema = defs[refSegments[refSegments.length - 1]];
+    invariant(jsonSchema, `missing definition for ${root.$ref}`, {
+      F: __dxlog_file,
+      L: 273,
+      S: void 0,
+      A: [
+        "jsonSchema",
+        "`missing definition for ${root.$ref}`"
+      ]
+    });
+    result = toEffectSchema(jsonSchema, defs).pipe(Schema2.annotations({
+      identifier: refSegments[refSegments.length - 1]
+    }));
+  }
+  const annotations2 = jsonSchemaFieldsToAnnotations(root);
+  result = result.annotations(annotations2);
+  return result;
+};
+var objectToEffectSchema = (root, defs) => {
+  invariant("type" in root && root.type === "object", `not an object: ${root}`, {
+    F: __dxlog_file,
+    L: 288,
+    S: void 0,
+    A: [
+      "'type' in root && root.type === 'object'",
+      "`not an object: ${root}`"
+    ]
+  });
+  const echoRefinement = root[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];
+  const isEchoObject = echoRefinement != null || "$id" in root && typeof root.$id === "string" && root.$id.startsWith("dxn:");
+  let fields = {};
+  const propertyList = Object.entries(root.properties ?? {});
+  let immutableIdField;
+  for (const [key, value] of propertyList) {
+    if (isEchoObject && key === "id") {
+      immutableIdField = toEffectSchema(value, defs);
+    } else {
+      fields[key] = root.required?.includes(key) ? toEffectSchema(value, defs) : Schema2.optional(toEffectSchema(value, defs));
+    }
+  }
+  if (root.propertyOrder) {
+    fields = orderKeys(fields, root.propertyOrder);
+  }
+  let schema;
+  if (root.patternProperties) {
+    invariant(propertyList.length === 0, "pattern properties mixed with regular properties are not supported", {
+      F: __dxlog_file,
+      L: 314,
+      S: void 0,
+      A: [
+        "propertyList.length === 0",
+        "'pattern properties mixed with regular properties are not supported'"
+      ]
+    });
+    invariant(Object.keys(root.patternProperties).length === 1 && Object.keys(root.patternProperties)[0] === "", "only one pattern property is supported", {
+      F: __dxlog_file,
+      L: 315,
+      S: void 0,
+      A: [
+        "Object.keys(root.patternProperties).length === 1 && Object.keys(root.patternProperties)[0] === ''",
+        "'only one pattern property is supported'"
+      ]
+    });
+    schema = Schema2.Record({
+      key: Schema2.String,
+      value: toEffectSchema(root.patternProperties[""], defs)
+    });
+  } else if (typeof root.additionalProperties !== "object") {
+    schema = Schema2.Struct(fields);
+  } else {
+    const indexValue = toEffectSchema(root.additionalProperties, defs);
+    if (propertyList.length > 0) {
+      schema = Schema2.Struct(fields, {
+        key: Schema2.String,
+        value: indexValue
+      });
+    } else {
+      schema = Schema2.Record({
+        key: Schema2.String,
+        value: indexValue
+      });
+    }
+  }
+  if (immutableIdField) {
+    schema = Schema2.extend(schema, Schema2.Struct({
+      id: immutableIdField
+    }));
+  }
+  const annotations2 = jsonSchemaFieldsToAnnotations(root);
+  return schema.annotations(annotations2);
+};
+var anyToEffectSchema = (root) => {
+  const echoRefinement = root[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];
+  if (echoRefinement?.reference != null) {
+    const echoId = root.$id.startsWith("dxn:echo:") ? root.$id : void 0;
+    return createEchoReferenceSchema(echoId, echoRefinement.reference.typename, echoRefinement.reference.version);
+  }
+  return Schema2.Any;
+};
+var refToEffectSchema = (root) => {
+  if (!("reference" in root)) {
+    return createEchoReferenceSchema(void 0, ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION);
+  }
+  const reference = root.reference;
+  if (typeof reference !== "object") {
+    throw new Error("Invalid reference field in ref schema");
+  }
+  const targetSchemaDXN = DXN.parse(reference.schema.$ref);
+  invariant(targetSchemaDXN.kind === DXN.kind.TYPE, void 0, {
+    F: __dxlog_file,
+    L: 368,
+    S: void 0,
+    A: [
+      "targetSchemaDXN.kind === DXN.kind.TYPE",
+      ""
+    ]
+  });
+  return createEchoReferenceSchema(targetSchemaDXN.toString(), targetSchemaDXN.kind === DXN.kind.TYPE ? targetSchemaDXN.parts[0] : void 0, reference.schemaVersion);
+};
+var annotations_toJsonSchemaFields = (annotations2) => {
+  const schemaFields = {};
+  const echoAnnotations = {};
+  for (const [key, annotationId] of Object.entries(EchoAnnotations)) {
+    if (annotations2[annotationId] != null) {
+      echoAnnotations[key] = annotations2[annotationId];
+    }
+  }
+  if (Object.keys(echoAnnotations).length > 0) {
+    schemaFields[ECHO_ANNOTATIONS_NS_KEY] = echoAnnotations;
+  }
+  const echoIdentifier = annotations2[TypeIdentifierAnnotationId];
+  if (echoIdentifier) {
+    schemaFields[ECHO_ANNOTATIONS_NS_KEY] ??= {};
+    schemaFields[ECHO_ANNOTATIONS_NS_KEY].schemaId = echoIdentifier;
+  }
+  for (const [key, annotationId] of Object.entries(CustomAnnotations)) {
+    const value = annotations2[annotationId];
+    if (value != null) {
+      schemaFields[key] = value;
+    }
+  }
+  return schemaFields;
+};
+var decodeTypeIdentifierAnnotation = (schema) => {
+  if (schema.$id && schema.$id.startsWith("dxn:echo:")) {
+    return schema.$id;
+  } else if (schema.$id && schema.$id.startsWith("dxn:type:") && schema?.echo?.type?.schemaId) {
+    const id = schema?.echo?.type?.schemaId;
+    if (ObjectId.isValid(id)) {
+      return DXN.fromLocalObjectId(id).toString();
+    }
+  }
+  return void 0;
+};
+var decodeTypeAnnotation = (schema) => {
+  if (schema.typename) {
+    const annotation = {
+      // TODO(dmaretskyi): Decoding default.
+      kind: schema.entityKind ? Schema2.decodeSync(EntityKindSchema)(schema.entityKind) : EntityKind.Object,
+      typename: schema.typename,
+      version: schema.version ?? "0.1.0"
+    };
+    if (annotation.kind === EntityKind.Relation) {
+      const source = schema.relationSource?.$ref ?? raise(new Error("Relation source not set"));
+      const target = schema.relationTarget?.$ref ?? raise(new Error("Relation target not set"));
+      annotation.sourceSchema = DXN.parse(source).toString();
+      annotation.targetSchema = DXN.parse(target).toString();
+    }
+    return annotation;
+  }
+  if (!schema.typename && schema?.echo?.type) {
+    return {
+      kind: EntityKind.Object,
+      typename: schema.echo.type.typename,
+      version: schema.echo.type.version
+    };
+  }
+  return void 0;
+};
+var jsonSchemaFieldsToAnnotations = (schema) => {
+  const annotations2 = {};
+  const echoAnnotations = getNormalizedEchoAnnotations(schema) ?? {};
+  if (echoAnnotations) {
+    for (const [key, annotationId] of Object.entries(EchoAnnotations)) {
+      if (echoAnnotations[key]) {
+        annotations2[annotationId] = echoAnnotations[key];
+      }
+    }
+  }
+  const typeIdentifier = decodeTypeIdentifierAnnotation(schema);
+  annotations2[TypeIdentifierAnnotationId] = typeIdentifier;
+  const typeAnnotation = decodeTypeAnnotation(schema);
+  if (typeAnnotation) {
+    annotations2[TypeAnnotationId] = typeAnnotation;
+    annotations2[SchemaAST2.JSONSchemaAnnotationId] = makeTypeJsonSchemaAnnotation({
+      identifier: typeIdentifier,
+      kind: typeAnnotation.kind,
+      typename: typeAnnotation.typename,
+      version: typeAnnotation.version,
+      relationSource: typeAnnotation.sourceSchema,
+      relationTarget: typeAnnotation.targetSchema
+    });
+  }
+  for (const [key, annotationId] of Object.entries({
+    ...CustomAnnotations,
+    ...DecodedAnnotations
+  })) {
+    if (key in schema) {
+      annotations2[annotationId] = schema[key];
+    }
+  }
+  return clearUndefined(annotations2);
+};
+var makeAnnotatedRefinement = (ast, annotations2) => {
+  return new SchemaAST2.Refinement(ast, () => Option.none(), annotations2);
+};
+var addJsonSchemaFields = (ast, schema) => makeAnnotatedRefinement(ast, {
+  [SchemaAST2.JSONSchemaAnnotationId]: schema
+});
+var normalizeJsonSchema = (jsonSchema) => {
+  if (jsonSchema.properties && "id" in jsonSchema.properties) {
+    jsonSchema.properties = orderKeys(jsonSchema.properties, [
+      "id"
+    ]);
+  }
+  jsonSchema.$schema = JSON_SCHEMA_URL;
+  jsonSchema = orderKeys(jsonSchema, [
+    "$schema",
+    "$id",
+    "entityKind",
+    "typename",
+    "version",
+    "relationTarget",
+    "relationSource",
+    "type",
+    "enum",
+    "properties",
+    "required",
+    "propertyOrder",
+    "items",
+    "additionalProperties",
+    "anyOf",
+    "oneOf"
+  ]);
+  return jsonSchema;
+};
+
+export {
+  CustomAnnotations,
+  DecodedAnnotations,
+  EchoAnnotations,
+  JsonSchemaEchoAnnotations,
+  JsonSchemaFields,
+  JsonSchemaType,
+  getSchemaProperty,
+  setSchemaProperty,
+  ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,
+  ECHO_ANNOTATIONS_NS_KEY,
+  getNormalizedEchoAnnotations,
+  PropType,
+  toPropType,
+  toJsonSchema,
+  toEffectSchema
+};
+//# sourceMappingURL=chunk-2Z72D23W.mjs.map