@dxos/echo 0.8.4-main.fffef41 → 0.8.4-staging.ac66bdf99f

package/src/internal/Entity/version.ts

@@ -0,0 +1,96 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { assertArgument } from '@dxos/invariant';
+
+import { type AnyEntity, VersionTypeId } from '../common/types';
+import { ObjectVersionId } from './model';
+
+/**
+ * Represent entity version.
+ * May be backed by Automerge.
+ * Entities with no history are not versioned.
+ * Named EntityVersion to avoid conflict with types/version.ts.
+ */
+export interface EntityVersion {
+  [VersionTypeId]: {};
+
+  /**
+   * Whether the entity is versioned.
+   */
+  versioned: boolean;
+
+  /**
+   * Automerge heads.
+   */
+  automergeHeads?: string[];
+}
+
+const unversioned: EntityVersion = {
+  [VersionTypeId]: {},
+  versioned: false,
+};
+
+/**
+ * Checks that `obj` is a version object.
+ */
+export const isVersion = (entity: unknown): entity is EntityVersion => {
+  return entity != null && typeof entity === 'object' && VersionTypeId in entity;
+};
+
+/**
+ * Returns the version of an entity.
+ * Accepts both reactive entities and snapshots.
+ */
+export const version = (entity: AnyEntity): EntityVersion => {
+  const ver = (entity as any)[ObjectVersionId];
+  if (ver === undefined) {
+    return unversioned;
+  }
+  return ver;
+};
+
+/**
+ * Checks that `version` is a valid version object.
+ */
+export const versionValid = (ver: EntityVersion): boolean => {
+  assertArgument(isVersion(ver), 'version', 'Invalid version object');
+  return !!ver.versioned;
+};
+
+export type VersionCompareResult = 'unversioned' | 'equal' | 'different';
+
+/**
+ * Compares two versions.
+ * @param version1
+ * @param version2
+ * @returns 'unversioned' if either entity is unversioned, 'equal' if the versions are equal, 'different' if the versions are different.
+ */
+export const compareVersions = (version1: EntityVersion, version2: EntityVersion): VersionCompareResult => {
+  assertArgument(isVersion(version1), 'version1', 'Invalid version object');
+  assertArgument(isVersion(version2), 'version2', 'Invalid version object');
+
+  if (!versionValid(version1) || !versionValid(version2)) {
+    return 'unversioned';
+  }
+
+  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
+    return 'different';
+  }
+  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
+    return 'different';
+  }
+
+  return 'equal';
+};
+
+export const encodeVersion = (ver: EntityVersion): string => {
+  return JSON.stringify(ver);
+};
+
+export const decodeVersion = (ver: string): EntityVersion => {
+  const parsed = JSON.parse(ver);
+  parsed[VersionTypeId] = {};
+  return parsed;
+};

package/src/internal/{formats → Format}/date.test.ts

@@ -7,8 +7,7 @@ import { describe, expect, test } from 'vitest';
 
 import { log } from '@dxos/log';
 
-import { toJsonSchema } from '../json';
-
+import { toJsonSchema } from '../JsonSchema';
 import {
   DateOnly,
   DateTime,

package/src/internal/{formats → Format}/date.ts

@@ -5,7 +5,7 @@
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 /**
  * Datetime values should be stored as ISO strings or unix numbers (ms) in UTC.
@@ -102,7 +102,7 @@ export const DateOnly = /* Schema.transformOrFail(Schema.String, SimpleDate, {
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Date),
+  FormatAnnotation.set(TypeFormat.Date),
   Schema.annotations({
     title: 'Date',
     description: 'Valid date in ISO format',
@@ -132,7 +132,7 @@ export const TimeOnly = /* Schema.transformOrFail(Schema.String, SimpleTime, {
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Time),
+  FormatAnnotation.set(TypeFormat.Time),
   Schema.annotations({
     title: 'Time',
     description: 'Valid time in ISO format',
@@ -177,7 +177,7 @@ export const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime,
     );
   },
 }) */ Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.DateTime),
+  FormatAnnotation.set(TypeFormat.DateTime),
   Schema.annotations({
     title: 'DateTime',
     description: 'Valid date and time in ISO format',
@@ -189,7 +189,7 @@ export const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime,
  */
 // TODO(burdon): Define duration type.
 export const Duration = Schema.String.pipe(
-  FormatAnnotation.set(FormatEnum.Duration),
+  FormatAnnotation.set(TypeFormat.Duration),
   Schema.annotations({
     title: 'Duration',
     description: 'Duration in ISO 8601 format',

package/src/internal/{formats → Format}/format.test.ts

@@ -5,10 +5,9 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { toJsonSchema } from '../json';
-
+import { toJsonSchema } from '../JsonSchema';
 import { Format } from './format';
-import { FormatEnum, TypeEnum, getTypeEnum } from './types';
+import { TypeEnum, TypeFormat, getTypeEnum } from './types';
 
 describe('formats', () => {
   test('annotations', ({ expect }) => {
@@ -20,7 +19,7 @@ describe('formats', () => {
       birthday: Schema.optional(Format.Date),
       started: Schema.optional(Format.DateTime),
       active: Schema.optional(Schema.Boolean),
-    }).pipe(Schema.mutable);
+    });
 
     type TestType = Schema.Schema.Type<typeof TestSchema>;
 
@@ -48,7 +47,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.String);
       expect(prop).includes({
         type: TypeEnum.String,
-        format: FormatEnum.Email,
+        format: TypeFormat.Email,
         title: 'Email',
       });
     }
@@ -58,7 +57,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.Number);
       expect(prop).includes({
         type: TypeEnum.Number,
-        format: FormatEnum.Currency,
+        format: TypeFormat.Currency,
         title: 'Currency',
         multipleOf: 0.01,
         currency: 'USD',
@@ -70,7 +69,7 @@ describe('formats', () => {
       expect(getTypeEnum(prop)).to.eq(TypeEnum.String);
       expect(prop).includes({
         type: TypeEnum.String,
-        format: FormatEnum.Date,
+        format: TypeFormat.Date,
       });
     }
   });

package/src/internal/{formats → Format}/format.ts

@@ -10,10 +10,10 @@ import * as DateUtil from './date';
 import * as NumberUtil from './number';
 import * as ObjectUtil from './object';
 import * as StringUtil from './string';
+import { TypeFormat as TypeFormat$ } from './types';
 
-// TODO(burdon): Consider factoring out to separate `@dxos/json-schema`
 // TODO(burdon): Media encoding.
-//  - https://json-schema.org/understanding-json-schema/reference/non_json_data
+// - https://json-schema.org/understanding-json-schema/reference/non_json_data
 
 /**
  * Formats.
@@ -22,7 +22,9 @@ import * as StringUtil from './string';
  */
 // TODO(burdon): Add fields for `examples`, `message`, etc.
 export namespace Format {
-  // Strings
+  export import TypeFormat = TypeFormat$;
+
+  // String
   export const DXN = Keys.DXN.Schema;
   export const Email = StringUtil.Email;
   export const Formula = StringUtil.Formula;
@@ -41,12 +43,12 @@ export namespace Format {
   export const Timestamp = NumberUtil.Timestamp;
 
   // Dates and times
-  export const DateTime = DateUtil.DateTime;
   export const Date = DateUtil.DateOnly;
-  export const Time = DateUtil.TimeOnly;
+  export const DateTime = DateUtil.DateTime;
   export const Duration = DateUtil.Duration;
+  export const Time = DateUtil.TimeOnly;
 
   // Objects
   export const GeoPoint = ObjectUtil.GeoPoint;
-  export type GeoPoint = ObjectUtil.GeoPoint;
+  export type GeoPoint = ObjectUtil.GeoPoint; // TODO(burdon): Export types.
 }

package/src/internal/{formats → Format}/number.ts

@@ -4,7 +4,7 @@
 
 import * as Schema from 'effect/Schema';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 const encodeMultipleOf = (divisor: number) => 1 / Math.pow(10, divisor);
 
@@ -37,7 +37,7 @@ export type CurrencyAnnotation = {
 export const Currency = ({ decimals, code }: CurrencyAnnotation = { decimals: 2 }) =>
   Schema.Number.pipe(
     encodeMultiple(decimals),
-    FormatAnnotation.set(FormatEnum.Currency),
+    FormatAnnotation.set(TypeFormat.Currency),
     Schema.annotations({
       title: 'Currency',
       description: 'Currency value',
@@ -55,7 +55,7 @@ export type PercentAnnotation = {
 export const Integer = () =>
   Schema.Number.pipe(
     Schema.int(),
-    FormatAnnotation.set(FormatEnum.Integer),
+    FormatAnnotation.set(TypeFormat.Integer),
     Schema.annotations({
       title: 'Integer',
       description: 'Integer value',
@@ -69,7 +69,7 @@ export const Integer = () =>
 export const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>
   Schema.Number.pipe(
     encodeMultiple(decimals),
-    FormatAnnotation.set(FormatEnum.Percent),
+    FormatAnnotation.set(TypeFormat.Percent),
     Schema.annotations({
       title: 'Percent',
       description: 'Percentage value',
@@ -81,7 +81,7 @@ export const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>
  * https://en.wikipedia.org/wiki/Unix_time
  */
 export const Timestamp = Schema.Number.pipe(
-  FormatAnnotation.set(FormatEnum.Timestamp),
+  FormatAnnotation.set(TypeFormat.Timestamp),
   Schema.annotations({
     title: 'Timestamp',
     description: 'Unix timestamp',

package/src/internal/{formats → Format}/object.ts

@@ -6,7 +6,7 @@ import * as Schema from 'effect/Schema';
 
 import { clamp } from '@dxos/util';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 /**
  * GeoJSON Format
@@ -21,13 +21,13 @@ import { FormatAnnotation, FormatEnum } from './types';
  * Note: optional third element for altitude.
  */
 export const GeoPoint = Schema.Tuple(
-  Schema.Number.pipe(Schema.annotations({ title: 'Longitude' }), Schema.clamp(-180, 180), Schema.multipleOf(0.00001)),
-  Schema.Number.pipe(Schema.annotations({ title: 'Latitude' }), Schema.clamp(-90, 90), Schema.multipleOf(0.00001)),
+  Schema.Number.pipe(Schema.annotations({ title: 'Longitude' }), Schema.clamp(-180, 180), Schema.multipleOf(0.000001)),
+  Schema.Number.pipe(Schema.annotations({ title: 'Latitude' }), Schema.clamp(-90, 90), Schema.multipleOf(0.000001)),
   Schema.optionalElement(Schema.Number).annotations({
     title: 'Height ASL (m)',
   }),
 ).pipe(
-  FormatAnnotation.set(FormatEnum.GeoPoint),
+  FormatAnnotation.set(TypeFormat.GeoPoint),
   Schema.annotations({
     title: 'GeoPoint',
     description: 'GeoJSON Position',

package/src/internal/{formats → Format}/select.ts

@@ -4,13 +4,15 @@
 
 import * as Schema from 'effect/Schema';
 
-/** Schema for a single select option. Used to define choices in a {single|multi}-select field. */
-export const SelectOptionSchema = Schema.Struct({
+/**
+ * Schema for a single select option. Used to define choices in a {single|multi}-select field.
+ */
+export const SelectOption = Schema.Struct({
   /** Stable identifier for the option. */
   id: Schema.NonEmptyString,
   title: Schema.String,
   /** Color palette used for visual styling. */
   color: Schema.String,
-}).pipe(Schema.mutable);
+});
 
-export type SelectOption = Schema.Schema.Type<typeof SelectOptionSchema>;
+export type SelectOption = Schema.Schema.Type<typeof SelectOption>;

package/src/internal/{formats → Format}/string.ts

@@ -5,7 +5,7 @@
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 /**
  * Email address (RFC 5321)
@@ -13,7 +13,7 @@ import { FormatAnnotation, FormatEnum } from './types';
  */
 export const Email = Schema.String.pipe(
   Schema.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/),
-  FormatAnnotation.set(FormatEnum.Email),
+  FormatAnnotation.set(TypeFormat.Email),
   Schema.annotations({
     title: 'Email',
     description: 'Email address',
@@ -24,25 +24,25 @@ export const Email = Schema.String.pipe(
  *
  */
 // TODO(burdon): Implement.
-export const Formula = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Formula));
+export const Formula = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Formula));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const Hostname = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Hostname));
+export const Hostname = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const JSON = Schema.String.pipe(FormatAnnotation.set(FormatEnum.JSON));
+export const JSON = Schema.String.pipe(FormatAnnotation.set(TypeFormat.JSON));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const Markdown = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Markdown));
+export const Markdown = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));
 
 /**
  * Regex
@@ -50,14 +50,19 @@ export const Markdown = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Markd
  * https://ecma-international.org/publications-and-standards/standards/ecma-262
  */
 // TODO(burdon): Implement.
-export const Regex = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Regex));
+export const Regex = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex));
+
+/**
+ * Multi-line text.
+ */
+export const Text = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Text));
 
 /**
  * https://datatracker.ietf.org/doc/html/rfc3986#section-1.1.3
  */
 export const URL = Schema.String.pipe(
   Schema.pattern(/^(\w+?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/i),
-  FormatAnnotation.set(FormatEnum.URL),
+  FormatAnnotation.set(TypeFormat.URL),
   Schema.annotations({
     title: 'URL',
     description: 'URL',
@@ -69,7 +74,7 @@ export const URL = Schema.String.pipe(
  * https://datatracker.ietf.org/doc/html/rfc4122
  */
 export const UUID = Schema.UUID.pipe(
-  FormatAnnotation.set(FormatEnum.UUID),
+  FormatAnnotation.set(TypeFormat.UUID),
   Schema.annotations({
     [SchemaAST.ExamplesAnnotationId]: ['3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a'],
   }),

package/src/internal/{formats → Format}/types.ts

@@ -7,8 +7,8 @@ import type * as JSONSchema from 'effect/JSONSchema';
 import * as Option from 'effect/Option';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { createAnnotationHelper } from '../ast';
-import { type JsonSchemaType } from '../json-schema';
+import { createAnnotationHelper } from '../Annotation';
+import { type JsonSchemaType } from '../JsonSchema';
 
 // TODO(burdon): Rename PropertyType.
 export type ScalarType =
@@ -53,14 +53,20 @@ export const getTypeEnum = (property: JsonSchemaType): TypeEnum | undefined => {
  */
 export const FormatAnnotationId = Symbol.for('@dxos/schema/annotation/Format');
 
-export const FormatAnnotation = createAnnotationHelper<FormatEnum>(FormatAnnotationId);
+export const FormatAnnotation = createAnnotationHelper<TypeFormat>(FormatAnnotationId);
 
-export const getFormatAnnotation = (node: SchemaAST.AST): FormatEnum | undefined =>
-  Function.pipe(SchemaAST.getAnnotation<FormatEnum>(FormatAnnotationId)(node), Option.getOrUndefined);
+/** @deprecated */
+export const getFormatAnnotation = (node: SchemaAST.AST): TypeFormat | undefined =>
+  Function.pipe(SchemaAST.getAnnotation<TypeFormat>(FormatAnnotationId)(node), Option.getOrUndefined);
 
-// TODO(burdon): Rename to FormatType and change to discriminated union.
-export enum FormatEnum {
+// TODO(burdon): Rename Format; Change to discriminated union?
+export enum TypeFormat {
   None = 'none',
+
+  //
+  // Scalar
+  //
+
   String = 'string',
   Number = 'number',
   Boolean = 'boolean',
@@ -79,6 +85,7 @@ export enum FormatEnum {
   Markdown = 'markdown',
   Regex = 'regex',
   SingleSelect = 'single-select',
+  Text = 'text',
   MultiSelect = 'multi-select',
   URL = 'url',
   UUID = 'uuid',
@@ -108,60 +115,61 @@ export enum FormatEnum {
   GeoPoint = 'lnglat',
 }
 
-export const FormatEnums = Object.values(FormatEnum).sort();
+export const FormatEnums = Object.values(TypeFormat).sort();
 
 export const PropertyKind = {
   type: TypeEnum,
-  format: FormatEnum,
+  format: TypeFormat,
 };
 
 /**
  * Default formats
  */
-export const typeToFormat: Partial<Record<TypeEnum, FormatEnum>> = {
-  [TypeEnum.String]: FormatEnum.String,
-  [TypeEnum.Number]: FormatEnum.Number,
-  [TypeEnum.Boolean]: FormatEnum.Boolean,
+export const typeToFormat: Partial<Record<TypeEnum, TypeFormat>> = {
+  [TypeEnum.String]: TypeFormat.String,
+  [TypeEnum.Number]: TypeFormat.Number,
+  [TypeEnum.Boolean]: TypeFormat.Boolean,
 };
 
 /**
  * Map of format to type.
  */
-export const formatToType: Record<FormatEnum, TypeEnum> = {
-  [FormatEnum.None]: undefined as any,
-  [FormatEnum.String]: TypeEnum.String,
-  [FormatEnum.Number]: TypeEnum.Number,
-  [FormatEnum.Boolean]: TypeEnum.Boolean,
-  [FormatEnum.Ref]: TypeEnum.Ref,
+export const formatToType: Record<TypeFormat, TypeEnum> = {
+  [TypeFormat.None]: TypeEnum.String,
+  [TypeFormat.String]: TypeEnum.String,
+  [TypeFormat.Number]: TypeEnum.Number,
+  [TypeFormat.Boolean]: TypeEnum.Boolean,
+  [TypeFormat.Ref]: TypeEnum.Ref,
 
   // Strings
-  [FormatEnum.DID]: TypeEnum.String,
-  [FormatEnum.DXN]: TypeEnum.String,
-  [FormatEnum.Email]: TypeEnum.String,
-  [FormatEnum.Formula]: TypeEnum.String,
-  [FormatEnum.Hostname]: TypeEnum.String,
-  [FormatEnum.JSON]: TypeEnum.String,
-  [FormatEnum.Markdown]: TypeEnum.String,
-  [FormatEnum.Regex]: TypeEnum.String,
-  [FormatEnum.URL]: TypeEnum.String,
-  [FormatEnum.UUID]: TypeEnum.String,
-  [FormatEnum.SingleSelect]: TypeEnum.String,
-  [FormatEnum.MultiSelect]: TypeEnum.Object,
+  [TypeFormat.DID]: TypeEnum.String,
+  [TypeFormat.DXN]: TypeEnum.String,
+  [TypeFormat.Email]: TypeEnum.String,
+  [TypeFormat.Formula]: TypeEnum.String,
+  [TypeFormat.Hostname]: TypeEnum.String,
+  [TypeFormat.JSON]: TypeEnum.String,
+  [TypeFormat.Markdown]: TypeEnum.String,
+  [TypeFormat.Regex]: TypeEnum.String,
+  [TypeFormat.URL]: TypeEnum.String,
+  [TypeFormat.UUID]: TypeEnum.String,
+  [TypeFormat.SingleSelect]: TypeEnum.String,
+  [TypeFormat.Text]: TypeEnum.String,
+  [TypeFormat.MultiSelect]: TypeEnum.Object,
 
   // Dates
-  [FormatEnum.Date]: TypeEnum.String,
-  [FormatEnum.DateTime]: TypeEnum.String,
-  [FormatEnum.Duration]: TypeEnum.String,
-  [FormatEnum.Time]: TypeEnum.String,
+  [TypeFormat.Date]: TypeEnum.String,
+  [TypeFormat.DateTime]: TypeEnum.String,
+  [TypeFormat.Duration]: TypeEnum.String,
+  [TypeFormat.Time]: TypeEnum.String,
 
   // Numbers
-  [FormatEnum.Currency]: TypeEnum.Number,
-  [FormatEnum.Integer]: TypeEnum.Number,
-  [FormatEnum.Percent]: TypeEnum.Number,
-  [FormatEnum.Timestamp]: TypeEnum.Number,
+  [TypeFormat.Currency]: TypeEnum.Number,
+  [TypeFormat.Integer]: TypeEnum.Number,
+  [TypeFormat.Percent]: TypeEnum.Number,
+  [TypeFormat.Timestamp]: TypeEnum.Number,
 
   // Objects
-  [FormatEnum.GeoPoint]: TypeEnum.Array,
+  [TypeFormat.GeoPoint]: TypeEnum.Array,
 };
 
 /**
@@ -169,7 +177,10 @@ export const formatToType: Record<FormatEnum, TypeEnum> = {
  */
 export const OptionsAnnotationId = Symbol.for('@dxos/schema/annotation/Options');
 
-export const getOptionsAnnotation = (node: SchemaAST.AST): OptionsAnnotationType[] | undefined =>
-  Function.pipe(SchemaAST.getAnnotation<OptionsAnnotationType[]>(OptionsAnnotationId)(node), Option.getOrUndefined);
+// TODO(wittjosiah): Reconcile with `SelectOption`.
+export type Options = string | number;
+export const OptionsAnnotation = createAnnotationHelper<Options[]>(OptionsAnnotationId);
 
-export type OptionsAnnotationType = string | number;
+/** @deprecated */
+export const getOptionsAnnotation = (node: SchemaAST.AST): Options[] | undefined =>
+  Function.pipe(SchemaAST.getAnnotation<Options[]>(OptionsAnnotationId)(node), Option.getOrUndefined);

package/src/internal/{json → JsonSchema}/annotations.ts

@@ -4,9 +4,9 @@
 
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { GeneratorAnnotationId, LabelAnnotationId, PropertyMetaAnnotationId } from '../ast';
-import { CurrencyAnnotationId, FormatAnnotationId } from '../formats';
-import { type JsonSchemaEchoAnnotations, type JsonSchemaType } from '../json-schema';
+import { GeneratorAnnotationId, LabelAnnotationId, PropertyMetaAnnotationId } from '../Annotation';
+import { CurrencyAnnotationId, FormatAnnotationId } from '../Format';
+import { type JsonSchemaEchoAnnotations, type JsonSchemaType } from '../JsonSchema';
 
 //
 // This file configures annotations for JSON encoding/decoding.

package/src/internal/{json-schema → JsonSchema}/index.ts

@@ -2,5 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './annotations';
 export * from './json-schema-normalize';
 export * from './json-schema-type';
+export * from './json-schema';

package/src/internal/{json-schema → JsonSchema}/json-schema-normalize.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+import type * as Types from 'effect/Types';
+
 import { JsonSchemaFields, type JsonSchemaType } from './json-schema-type';
 
 /**
@@ -9,12 +11,12 @@ import { JsonSchemaFields, type JsonSchemaType } from './json-schema-type';
  * Note: the input type does not necessarily match the {@link JsonSchemaType} type.
  */
 export const normalizeSchema = (schema: JsonSchemaType): JsonSchemaType => {
-  const copy = structuredClone(schema);
+  const copy = structuredClone(schema) as Types.DeepMutable<JsonSchemaType>;
   go(copy);
   return copy;
 };
 
-const go = (schema: JsonSchemaType) => {
+const go = (schema: Types.DeepMutable<JsonSchemaType>) => {
   if (typeof schema !== 'object' || schema === null) {
     return;
   }