@dxos/echo 0.10.0 → 0.11.1

package/dist/lib/chunk-json-schema.mjs

@@ -0,0 +1,660 @@
+import { a as ANY_OBJECT_VERSION, g as getStaticTypeSchema, i as ANY_OBJECT_TYPENAME, n as makeTypeJsonSchemaAnnotation, o as EntityKind, s as EntityKindSchema } from "./chunk-util.mjs";
+import { Q as PropertyMetaAnnotationId, W as GeneratorAnnotationId, X as LabelAnnotationId, it as TypeIdentifierAnnotationId, rt as TypeAnnotationId } from "./chunk-Database.mjs";
+import { o as createEchoReferenceSchema } from "./chunk-ref.mjs";
+import { c as FormatAnnotationId, m as TypeFormat, n as CurrencyAnnotationId, s as FormatAnnotation } from "./chunk-number.mjs";
+import { DXN, EID, EntityId } from "@dxos/keys";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { SchemaEx } from "@dxos/effect";
+import { clearUndefined, orderKeys, removeProperties } from "@dxos/util";
+import { raise } from "@dxos/debug";
+import * as Array from "effect/Array";
+import * as JSONSchema from "effect/JSONSchema";
+import { log } from "@dxos/log";
+//#region src/internal/JsonSchema/annotations.ts
+/**
+* List of annotations for JSON encoding/decoding.
+* Omits default effect-schema annotations since they are encoded with default serializer.
+*/
+var CustomAnnotations = {
+	format: FormatAnnotationId,
+	currency: CurrencyAnnotationId
+};
+/**
+* List of annotations for JSON decoding only.
+* Includes default effect annotations.
+*/
+var DecodedAnnotations = {
+	title: SchemaAST.TitleAnnotationId,
+	description: SchemaAST.DescriptionAnnotationId
+};
+/**
+* Annotations that go into ECHO namespace in json-schema.
+*/
+var EchoAnnotations = {
+	meta: PropertyMetaAnnotationId,
+	generator: GeneratorAnnotationId,
+	labelProp: LabelAnnotationId
+};
+//#endregion
+//#region src/internal/JsonSchema/json-schema-type.ts
+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);
+/**
+* Go under the `annotations` property.
+*/
+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}; mirrors `GeneratorAnnotationValue`, whose object
+	* form (`{ generator, args }`) is used by schemas like `Task` — a narrower contract here makes
+	* those schemas unserializable (`Operation.serialize` fails on any operation referencing them).
+	*/
+	generator: Schema.optional(Schema.Union(Schema.String, Schema.Tuple(Schema.String, Schema.Number), Schema.Struct({
+		generator: Schema.String,
+		args: Schema.optional(Schema.Array(Schema.Any)),
+		probability: Schema.optional(Schema.Number)
+	}))),
+	/**
+	* {@link PropertyMeta} annotations get serialized here.
+	*/
+	meta: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Any
+	})),
+	/**
+	* @deprecated
+	*/
+	type: Schema.optional(Schema.Struct({
+		typename: Schema.String,
+		version: Schema.String,
+		schemaId: Schema.optional(Schema.String)
+	})),
+	/**
+	* @deprecated Superseded by `meta`.
+	*/
+	annotations: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Any
+	}))
+});
+/**
+* Describes a schema for the JSON-schema objects stored in ECHO.
+* Contains extensions for ECHO (e.g., references).
+* Ref: https://json-schema.org/draft-07/schema
+*/
+var _JsonSchemaType = Schema.Struct({
+	/**
+	* Identifier for this schema.
+	* This schema might be referenced by $ref clause in other schemas.
+	*/
+	$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))),
+	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),
+	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),
+	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)),
+	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)
+	})),
+	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.
+	*/
+	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;
+};
+/**
+* @internal
+*/
+var ECHO_ANNOTATIONS_NS_DEPRECATED_KEY = "echo";
+/**
+* @internal
+*/
+var ECHO_ANNOTATIONS_NS_KEY = "annotations";
+/**
+* @internal
+* @returns ECHO annotations namespace object in its normalized form.
+*
+* `meta` holds PropertyMeta annotations.
+* `annotations` holds other annotations.
+*/
+var getNormalizedEchoAnnotations = (obj) => {
+	if (obj["annotations"] != null && obj["echo"] != null) return normalizeEchoAnnotations({
+		...obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY],
+		...obj[ECHO_ANNOTATIONS_NS_KEY]
+	});
+	else if (obj["annotations"] != null) return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_KEY]);
+	else if (obj["echo"] != null) return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY]);
+	else return;
+};
+var normalizeEchoAnnotations = (obj) => {
+	if (!obj.annotations) return obj;
+	else {
+		const res = {
+			...obj,
+			meta: {
+				...obj.annotations,
+				...obj.meta ?? {}
+			}
+		};
+		delete res.annotations;
+		return res;
+	}
+};
+//#endregion
+//#region src/internal/JsonSchema/json-schema.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/JsonSchema/json-schema.ts";
+var PropType = /* @__PURE__ */ function(PropType) {
+	PropType[PropType["NONE"] = 0] = "NONE";
+	PropType[PropType["STRING"] = 1] = "STRING";
+	PropType[PropType["NUMBER"] = 2] = "NUMBER";
+	PropType[PropType["BOOLEAN"] = 3] = "BOOLEAN";
+	PropType[PropType["DATE"] = 4] = "DATE";
+	PropType[PropType["REF"] = 5] = "REF";
+	PropType[PropType["RECORD"] = 6] = "RECORD";
+	PropType[PropType["ENUM"] = 7] = "ENUM";
+	return PropType;
+}({});
+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#";
+/**
+* Convert effect schema to JSON Schema.
+* NOTE: This handles custom annotations.
+* @param schema
+*/
+var toJsonSchema = (schema, options = {}) => {
+	const slot = getStaticTypeSchema(schema);
+	if (slot != null) schema = slot;
+	else if (!Schema.isSchema(schema)) {
+		const entityJsonSchema = schema.jsonSchema;
+		if (entityJsonSchema != null) return entityJsonSchema;
+	}
+	assertArgument(Schema.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, inProgress = /* @__PURE__ */ new Set()) => {
+	const withRefinements = withEchoRefinements(ast, "#", /* @__PURE__ */ new Map(), inProgress);
+	return normalizeJsonSchema(JSONSchema.fromAST(withRefinements, { definitions: {} }));
+};
+var withEchoRefinements = (ast, path, suspendCache = /* @__PURE__ */ new Map(), inProgress = /* @__PURE__ */ new Set()) => {
+	if (path) suspendCache.set(ast, path);
+	let recursiveResult;
+	if (SchemaAST.isSuspend(ast)) {
+		const suspendedAst = ast.f();
+		const cachedPath = suspendCache.get(suspendedAst);
+		if (cachedPath) recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache, inProgress), { [SchemaAST.JSONSchemaAnnotationId]: { $ref: cachedPath } });
+		else if (inProgress.has(suspendedAst)) recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache, inProgress), { [SchemaAST.JSONSchemaAnnotationId]: {
+			$id: "/schemas/any",
+			type: [
+				"string",
+				"number",
+				"boolean",
+				"object",
+				"array",
+				"null"
+			]
+		} });
+		else {
+			inProgress.add(suspendedAst);
+			const jsonSchema = _toJsonSchemaAST(suspendedAst, inProgress);
+			inProgress.delete(suspendedAst);
+			recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache, inProgress), { [SchemaAST.JSONSchemaAnnotationId]: jsonSchema });
+		}
+	} else if (SchemaAST.isTypeLiteral(ast)) {
+		recursiveResult = SchemaEx.mapAst(ast, (ast, key) => withEchoRefinements(ast, path && typeof key === "string" ? `${path}/${key}` : void 0, suspendCache, inProgress));
+		recursiveResult = addJsonSchemaFields(recursiveResult, { propertyOrder: [...ast.propertySignatures.map((p) => p.name)] });
+	} else if (SchemaAST.isUndefinedKeyword(ast)) return ast;
+	else recursiveResult = SchemaEx.mapAst(ast, (ast, key) => withEchoRefinements(ast, path && (typeof key === "string" || typeof key === "number") ? `${path}/${key}` : void 0, suspendCache, inProgress));
+	const annotationFields = annotations_toJsonSchemaFields(ast.annotations);
+	if (Object.keys(annotationFields).length === 0) return recursiveResult;
+	else return addJsonSchemaFields(recursiveResult, annotationFields);
+};
+/**
+* Convert JSON schema to effect schema.
+* @param root
+* @param definitions
+*/
+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 = Schema.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 = Schema.Unknown;
+			break;
+		case "/schemas/{}":
+		case "/schemas/object":
+			result = Schema.Struct({});
+			break;
+		case "/schemas/echo/ref":
+			result = refToEffectSchema(root);
+			break;
+	}
+	else if ("enum" in root) result = Schema.Union(...root.enum.map((e) => Schema.Literal(e)));
+	else if ("oneOf" in root) result = Schema.Union(...root.oneOf.map((v) => toEffectSchema(v, defs)));
+	else if ("anyOf" in root) result = Schema.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: 264,
+			S: void 0
+		});
+		result = Schema.Unknown;
+	}
+	else if ("type" in root) switch (root.type) {
+		case "string":
+			result = Schema.String;
+			if (root.pattern) result = result.pipe(Schema.pattern(new RegExp(root.pattern)));
+			break;
+		case "number":
+			result = Schema.Number;
+			break;
+		case "integer":
+			result = Schema.Number.pipe(Schema.int());
+			break;
+		case "boolean":
+			result = Schema.Boolean;
+			break;
+		case "array":
+			if (Array.isArray(root.items)) {
+				const [required, optional] = Function.pipe(root.items, Array.map((v) => toEffectSchema(v, defs)), Array.splitAt(root.minItems ?? root.items.length));
+				result = Schema.Tuple(...required, ...optional.map(Schema.optionalElement));
+			} else {
+				invariant(root.items, void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file,
+					L: 297,
+					S: void 0,
+					A: ["root.items", ""]
+				});
+				const items = root.items;
+				result = Array.isArray(items) ? Schema.Tuple(...items.map((v) => toEffectSchema(v, defs))) : Schema.Array(toEffectSchema(items, defs));
+			}
+			break;
+		case "null":
+			result = Schema.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: 313,
+			S: void 0,
+			A: ["jsonSchema", "`missing definition for ${root.$ref}`"]
+		});
+		result = toEffectSchema(jsonSchema, defs).pipe(Schema.annotations({ identifier: refSegments[refSegments.length - 1] }));
+	}
+	const annotations = jsonSchemaFieldsToAnnotations(root);
+	result = result.annotations(annotations);
+	return result;
+};
+var objectToEffectSchema = (root, defs) => {
+	invariant("type" in root && root.type === "object", `not an object: ${root}`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 328,
+		S: void 0,
+		A: ["'type' in root && root.type === 'object'", "`not an object: ${root}`"]
+	});
+	const isEchoObject = root["echo"] != 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) : Schema.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: 354,
+			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: 355,
+			S: void 0,
+			A: ["Object.keys(root.patternProperties).length === 1 && Object.keys(root.patternProperties)[0] === ''", "'only one pattern property is supported'"]
+		});
+		schema = Schema.Record({
+			key: Schema.String,
+			value: toEffectSchema(root.patternProperties[""], defs)
+		});
+	} else if (typeof root.additionalProperties !== "object") schema = Schema.Struct(fields);
+	else {
+		const indexValue = toEffectSchema(root.additionalProperties, defs);
+		if (propertyList.length > 0) schema = Schema.Struct(fields, {
+			key: Schema.String,
+			value: indexValue
+		});
+		else schema = Schema.Record({
+			key: Schema.String,
+			value: indexValue
+		});
+	}
+	if (immutableIdField) schema = Schema.extend(schema, Schema.Struct({ id: immutableIdField }));
+	const annotations = jsonSchemaFieldsToAnnotations(root);
+	return schema.annotations(annotations);
+};
+var anyToEffectSchema = (root) => {
+	const echoRefinement = root[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];
+	if (echoRefinement?.reference != null) return createEchoReferenceSchema(root.$id.startsWith("echo:") ? root.$id : void 0, echoRefinement.reference.typename, echoRefinement.reference.version);
+	return Schema.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: 409,
+		S: void 0,
+		A: ["targetSchemaDXN", "`Expected a type DXN, got: ${ref}`"]
+	});
+	return createEchoReferenceSchema(ref, DXN.getName(targetSchemaDXN), reference.schemaVersion);
+};
+var annotations_toJsonSchemaFields = (annotations) => {
+	const schemaFields = {};
+	const echoAnnotations = {};
+	for (const [key, annotationId] of Object.entries(EchoAnnotations)) if (annotations[annotationId] != null) echoAnnotations[key] = annotations[annotationId];
+	if (Object.keys(echoAnnotations).length > 0) schemaFields[ECHO_ANNOTATIONS_NS_KEY] = echoAnnotations;
+	const echoIdentifier = annotations[TypeIdentifierAnnotationId];
+	if (echoIdentifier) schemaFields.$id = echoIdentifier;
+	for (const [key, annotationId] of Object.entries(CustomAnnotations)) {
+		const value = annotations[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;
+};
+var decodeTypeAnnotation = (schema) => {
+	if (schema.typename) {
+		const annotation = {
+			kind: schema.entityKind ? Schema.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(/* @__PURE__ */ new Error("Relation source not set"));
+			const target = schema.relationTarget?.$ref ?? raise(/* @__PURE__ */ new Error("Relation target not set"));
+			annotation.sourceSchema = DXN.tryMake(source) ?? raise(/* @__PURE__ */ new Error(`Invalid relation source: ${source}`));
+			annotation.targetSchema = DXN.tryMake(target) ?? raise(/* @__PURE__ */ 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
+	};
+};
+var jsonSchemaFieldsToAnnotations = (schema) => {
+	const annotations = {};
+	const echoAnnotations = getNormalizedEchoAnnotations(schema) ?? {};
+	if (echoAnnotations) {
+		for (const [key, annotationId] of Object.entries(EchoAnnotations)) if (echoAnnotations[key]) annotations[annotationId] = echoAnnotations[key];
+	}
+	annotations[TypeIdentifierAnnotationId] = decodeTypeIdentifierAnnotation(schema);
+	const typeAnnotation = decodeTypeAnnotation(schema);
+	if (typeAnnotation) {
+		annotations[TypeAnnotationId] = typeAnnotation;
+		annotations[SchemaAST.JSONSchemaAnnotationId] = makeTypeJsonSchemaAnnotation({
+			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) annotations[annotationId] = schema[key];
+	return clearUndefined(annotations);
+};
+var makeAnnotatedRefinement = (ast, annotations) => {
+	return new SchemaAST.Refinement(ast, () => Option.none(), annotations);
+};
+var addJsonSchemaFields = (ast, schema) => makeAnnotatedRefinement(ast, { [SchemaAST.JSONSchemaAnnotationId]: schema });
+/**
+* Fixes field order.
+* Sets `$schema` prop.
+*/
+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;
+};
+//#endregion
+export { ECHO_ANNOTATIONS_NS_DEPRECATED_KEY as a, JsonSchemaFields as c, getSchemaProperty as d, setSchemaProperty as f, EchoAnnotations as h, toPropType as i, JsonSchemaType as l, DecodedAnnotations as m, toEffectSchema as n, ECHO_ANNOTATIONS_NS_KEY as o, CustomAnnotations as p, toJsonSchema as r, JsonSchemaEchoAnnotations as s, PropType as t, getNormalizedEchoAnnotations as u };
+
+//# sourceMappingURL=chunk-json-schema.mjs.map