@dxos/echo 0.10.0 → 0.11.0

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

@@ -1,747 +0,0 @@
-import {
-  CurrencyAnnotationId,
-  FormatAnnotation,
-  FormatAnnotationId,
-  TypeFormat
-} from "./chunk-KCBW4BR6.mjs";
-import {
-  createEchoReferenceSchema
-} from "./chunk-L3E5IXAE.mjs";
-import {
-  GeneratorAnnotationId,
-  LabelAnnotationId,
-  PropertyMetaAnnotationId,
-  TypeAnnotationId,
-  TypeIdentifierAnnotationId
-} from "./chunk-3TN2VMI4.mjs";
-import {
-  ANY_OBJECT_TYPENAME,
-  ANY_OBJECT_VERSION,
-  EntityKind,
-  EntityKindSchema,
-  getStaticTypeSchema,
-  makeTypeJsonSchemaAnnotation
-} from "./chunk-2ZHECXUR.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 { SchemaEx } 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(SchemaEx.JsonPath, Schema.Array(SchemaEx.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 { SchemaEx as SchemaEx2 } from "@dxos/effect";
-import { assertArgument, invariant } from "@dxos/invariant";
-import { DXN, EID, EntityId } 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 = {}) => {
-  const slot = getStaticTypeSchema(schema);
-  if (slot != null) {
-    schema = slot;
-  } else if (!Schema2.isSchema(schema)) {
-    const entityJsonSchema = schema.jsonSchema;
-    if (entityJsonSchema != null) {
-      return entityJsonSchema;
-    }
-  }
-  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 = SchemaEx2.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 = SchemaEx2.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 (decodeURIComponent(root.$id)) {
-      case "/schemas/any": {
-        result = anyToEffectSchema(root);
-        break;
-      }
-      case "/schemas/unknown": {
-        result = Schema2.Unknown;
-        break;
-      }
-      case "/schemas/{}":
-      case "/schemas/object": {
-        result = Schema2.Struct({});
-        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, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 197, S: void 0 });
-      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, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 231, 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}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 246, 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}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 257, 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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 276, 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", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 277, 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 echoUri = root.$id.startsWith("echo:") ? root.$id : void 0;
-    return createEchoReferenceSchema(echoUri, 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 ref = reference.schema.$ref;
-  const targetSchemaDXN = DXN.tryMake(ref);
-  invariant(targetSchemaDXN, `Expected a type DXN, got: ${ref}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 327, S: void 0, A: ["targetSchemaDXN", "`Expected a type DXN, got: ${ref}`"] });
-  return createEchoReferenceSchema(ref, DXN.getName(targetSchemaDXN), 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.$id = 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("echo:")) {
-    return schema.$id;
-  }
-  const legacySchemaId = schema.echo?.type?.schemaId;
-  if (legacySchemaId) {
-    return EntityId.isValid(legacySchemaId) ? EID.make({
-      entityId: legacySchemaId
-    }) : legacySchemaId;
-  }
-  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.tryMake(source) ?? raise(new Error(`Invalid relation source: ${source}`));
-      annotation.targetSchema = DXN.tryMake(target) ?? raise(new Error(`Invalid relation target: ${target}`));
-    }
-    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({
-      // $id is the typename DXN — the schema's type identity. The storage EID (if any)
-      // is preserved separately on TypeIdentifierAnnotation / echo.schemaId.
-      identifier: DXN.make(typeAnnotation.typename, typeAnnotation.version),
-      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-4A2NWKRJ.mjs.map