@dxos/echo 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

package/dist/lib/browser/chunk-RP4JV7FD.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/formats/types.ts", "../../../src/internal/formats/number.ts", "../../../src/internal/formats/object.ts", "../../../src/internal/formats/string.ts", "../../../src/internal/formats/format.ts", "../../../src/internal/formats/date.ts", "../../../src/internal/formats/select.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport type * as JSONSchema from 'effect/JSONSchema';\nimport * as Option from 'effect/Option';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { createAnnotationHelper } from '../annotations';\nimport { type JsonSchemaType } from '../json-schema';\n\n// TODO(burdon): Rename PropertyType.\nexport type ScalarType =\n  | JSONSchema.JsonSchema7Object\n  | JSONSchema.JsonSchema7String\n  | JSONSchema.JsonSchema7Number\n  | JSONSchema.JsonSchema7Boolean\n  | JSONSchema.JsonSchema7Ref;\n\n// TODO(burdon): Rename ValueType and change to disciminated union.\n// export type ValueType = 'array' | 'object' | 'string' | 'number' | 'boolean' | 'ref';\nexport enum TypeEnum {\n  Array = 'array', // TODO(burdon): Remove?\n  Object = 'object',\n  String = 'string',\n  Number = 'number',\n  Boolean = 'boolean',\n  Ref = 'ref',\n}\n\n// TODO(burdon): Ref?\nexport const getTypeEnum = (property: JsonSchemaType): TypeEnum | undefined => {\n  switch (property.type) {\n    case 'array':\n      return TypeEnum.Array;\n    case 'object':\n      return TypeEnum.Object;\n    case 'string':\n      return TypeEnum.String;\n    case 'number':\n      return TypeEnum.Number;\n    case 'boolean':\n      return TypeEnum.Boolean;\n    default:\n      return undefined;\n  }\n};\n\n/**\n * https://json-schema.org/understanding-json-schema/reference/schema\n * https://json-schema.org/understanding-json-schema/reference/string#built-in-formats\n */\nexport const FormatAnnotationId = Symbol.for('@dxos/schema/annotation/Format');\n\nexport const FormatAnnotation = createAnnotationHelper<TypeFormat>(FormatAnnotationId);\n\n/** @deprecated */\nexport const getFormatAnnotation = (node: SchemaAST.AST): TypeFormat | undefined =>\n  Function.pipe(SchemaAST.getAnnotation<TypeFormat>(FormatAnnotationId)(node), Option.getOrUndefined);\n\n// TODO(burdon): Rename Format; Change to discriminated union?\nexport enum TypeFormat {\n  None = 'none',\n\n  //\n  // Scalar\n  //\n\n  String = 'string',\n  Number = 'number',\n  Boolean = 'boolean',\n  Ref = 'ref',\n\n  //\n  // { type: 'string' }\n  //\n\n  DID = 'did', // Users, etc.\n  DXN = 'dxn',\n  Email = 'email',\n  Formula = 'formula', // Spreadsheet formula.\n  Hostname = 'hostname',\n  JSON = 'json',\n  Markdown = 'markdown',\n  Regex = 'regex',\n  SingleSelect = 'single-select',\n  Text = 'text',\n  MultiSelect = 'multi-select',\n  URL = 'url',\n  UUID = 'uuid',\n\n  //\n  // { type: 'number' }\n  //\n\n  Currency = 'currency',\n  Integer = 'integer',\n  Percent = 'percent',\n  Timestamp = 'timestamp',\n\n  //\n  // { type: 'date' }\n  //\n\n  DateTime = 'date-time',\n  Date = 'date',\n  Time = 'time',\n  Duration = 'duration',\n\n  //\n  // { type: 'object' }\n  //\n\n  GeoPoint = 'lnglat',\n}\n\nexport const FormatEnums = Object.values(TypeFormat).sort();\n\nexport const PropertyKind = {\n  type: TypeEnum,\n  format: TypeFormat,\n};\n\n/**\n * Default formats\n */\nexport const typeToFormat: Partial<Record<TypeEnum, TypeFormat>> = {\n  [TypeEnum.String]: TypeFormat.String,\n  [TypeEnum.Number]: TypeFormat.Number,\n  [TypeEnum.Boolean]: TypeFormat.Boolean,\n};\n\n/**\n * Map of format to type.\n */\nexport const formatToType: Record<TypeFormat, TypeEnum> = {\n  [TypeFormat.None]: undefined as any,\n  [TypeFormat.String]: TypeEnum.String,\n  [TypeFormat.Number]: TypeEnum.Number,\n  [TypeFormat.Boolean]: TypeEnum.Boolean,\n  [TypeFormat.Ref]: TypeEnum.Ref,\n\n  // Strings\n  [TypeFormat.DID]: TypeEnum.String,\n  [TypeFormat.DXN]: TypeEnum.String,\n  [TypeFormat.Email]: TypeEnum.String,\n  [TypeFormat.Formula]: TypeEnum.String,\n  [TypeFormat.Hostname]: TypeEnum.String,\n  [TypeFormat.JSON]: TypeEnum.String,\n  [TypeFormat.Markdown]: TypeEnum.String,\n  [TypeFormat.Regex]: TypeEnum.String,\n  [TypeFormat.URL]: TypeEnum.String,\n  [TypeFormat.UUID]: TypeEnum.String,\n  [TypeFormat.SingleSelect]: TypeEnum.String,\n  [TypeFormat.Text]: TypeEnum.String,\n  [TypeFormat.MultiSelect]: TypeEnum.Object,\n\n  // Dates\n  [TypeFormat.Date]: TypeEnum.String,\n  [TypeFormat.DateTime]: TypeEnum.String,\n  [TypeFormat.Duration]: TypeEnum.String,\n  [TypeFormat.Time]: TypeEnum.String,\n\n  // Numbers\n  [TypeFormat.Currency]: TypeEnum.Number,\n  [TypeFormat.Integer]: TypeEnum.Number,\n  [TypeFormat.Percent]: TypeEnum.Number,\n  [TypeFormat.Timestamp]: TypeEnum.Number,\n\n  // Objects\n  [TypeFormat.GeoPoint]: TypeEnum.Array,\n};\n\n/**\n * Allowed value options for select.\n */\nexport const OptionsAnnotationId = Symbol.for('@dxos/schema/annotation/Options');\n\n// TODO(wittjosiah): Reconcile with `SelectOption`.\nexport type Options = string | number;\nexport const OptionsAnnotation = createAnnotationHelper<Options[]>(OptionsAnnotationId);\n\n/** @deprecated */\nexport const getOptionsAnnotation = (node: SchemaAST.AST): Options[] | undefined =>\n  Function.pipe(SchemaAST.getAnnotation<Options[]>(OptionsAnnotationId)(node), Option.getOrUndefined);\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\nconst encodeMultipleOf = (divisor: number) => 1 / Math.pow(10, divisor);\n\nconst encodeMultiple =\n  <A extends number>(divisor?: number) =>\n  <I, R>(self: Schema.Schema<A, I, R>) =>\n    divisor === undefined || divisor === 0 ? self : self.pipe(Schema.multipleOf(encodeMultipleOf(divisor)));\n\n/**\n * Convert number of digits to multipleOf annotation.\n */\nexport const DecimalPrecision = Schema.transform(Schema.Number, Schema.Number, {\n  strict: true,\n  encode: (value) => encodeMultipleOf(value),\n  decode: (value) => Math.log10(1 / value),\n}).annotations({\n  title: 'Number of digits',\n});\n\nexport const CurrencyAnnotationId = Symbol.for('@dxos/schema/annotation/Currency');\n\nexport type CurrencyAnnotation = {\n  decimals?: number;\n  code?: string;\n};\n\n/**\n * ISO 4217 currency code.\n */\nexport const Currency = ({ decimals, code }: CurrencyAnnotation = { decimals: 2 }) =>\n  Schema.Number.pipe(\n    encodeMultiple(decimals),\n    FormatAnnotation.set(TypeFormat.Currency),\n    Schema.annotations({\n      title: 'Currency',\n      description: 'Currency value',\n      ...(code ? { [CurrencyAnnotationId]: code.toUpperCase() } : {}),\n    }),\n  );\n\nexport type PercentAnnotation = {\n  decimals?: number;\n};\n\n/**\n * Integer.\n */\nexport const Integer = () =>\n  Schema.Number.pipe(\n    Schema.int(),\n    FormatAnnotation.set(TypeFormat.Integer),\n    Schema.annotations({\n      title: 'Integer',\n      description: 'Integer value',\n    }),\n  );\n\n/**\n * Percent.\n */\n// TODO(burdon): Define min/max (e.g., 0, 1).\nexport const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>\n  Schema.Number.pipe(\n    encodeMultiple(decimals),\n    FormatAnnotation.set(TypeFormat.Percent),\n    Schema.annotations({\n      title: 'Percent',\n      description: 'Percentage value',\n    }),\n  );\n\n/**\n * Unix timestamp.\n * https://en.wikipedia.org/wiki/Unix_time\n */\nexport const Timestamp = Schema.Number.pipe(\n  FormatAnnotation.set(TypeFormat.Timestamp),\n  Schema.annotations({\n    title: 'Timestamp',\n    description: 'Unix timestamp',\n  }),\n);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { clamp } from '@dxos/util';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * GeoJSON Format\n * https://datatracker.ietf.org/doc/html/rfc7946\n * https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.1\n * https://en.wikipedia.org/wiki/Geographic_coordinate_system\n * https://geojson.org\n * {\n *   \"type\": \"Point\",\n *   \"coordinates\": [0, 51.47] // [longitude, latitude]\n * }\n * Note: optional third element for altitude.\n */\nexport const GeoPoint = Schema.Tuple(\n  Schema.Number.pipe(Schema.annotations({ title: 'Longitude' }), Schema.clamp(-180, 180), Schema.multipleOf(0.000001)),\n  Schema.Number.pipe(Schema.annotations({ title: 'Latitude' }), Schema.clamp(-90, 90), Schema.multipleOf(0.000001)),\n  Schema.optionalElement(Schema.Number).annotations({\n    title: 'Height ASL (m)',\n  }),\n).pipe(\n  FormatAnnotation.set(TypeFormat.GeoPoint),\n  Schema.annotations({\n    title: 'GeoPoint',\n    description: 'GeoJSON Position',\n  }),\n);\n\nexport type GeoPoint = Schema.Schema.Type<typeof GeoPoint>;\n\nexport type GeoLocation = {\n  longitude: number;\n  latitude: number;\n  height?: number;\n};\n\n/**\n * Geolocation utilities for working with GeoPoint format.\n */\nexport namespace GeoLocation {\n  /**\n   * Convert latitude and longitude to GeoPoint (GeoJSON format [longitude, latitude, height?]).\n   * Clamps values to valid ranges: latitude [-90, 90], longitude [-180, 180].\n   */\n  export const toGeoPoint = ({ longitude, latitude, height }: GeoLocation): GeoPoint => {\n    // TODO(ZaymonFC): Use schema validation instead of doing this manually.\n    const clampedLongitude = clamp(longitude, -180, 180);\n    const clampedLatitude = clamp(latitude, -90, 90);\n    return height !== undefined ? [clampedLongitude, clampedLatitude, height] : [clampedLongitude, clampedLatitude];\n  };\n\n  /**\n   * Extract latitude and longitude from GeoPoint (GeoJSON format [longitude, latitude, height?]).\n   */\n  export const fromGeoPoint = (geoPoint: GeoPoint | undefined): GeoLocation => {\n    if (!geoPoint) {\n      return { longitude: 0, latitude: 0 };\n    }\n\n    const result: GeoLocation = {\n      longitude: geoPoint[0],\n      latitude: geoPoint[1],\n    };\n\n    // Add height if defined.\n    if (geoPoint[2] !== undefined) {\n      result.height = geoPoint[2];\n    }\n\n    return result;\n  };\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * Email address (RFC 5321)\n * https://datatracker.ietf.org/doc/html/rfc5321#section-4.1.2\n */\nexport const Email = Schema.String.pipe(\n  Schema.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/),\n  FormatAnnotation.set(TypeFormat.Email),\n  Schema.annotations({\n    title: 'Email',\n    description: 'Email address',\n  }),\n);\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Formula = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Formula));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Hostname = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const JSON = Schema.String.pipe(FormatAnnotation.set(TypeFormat.JSON));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Markdown = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));\n\n/**\n * Regex\n * https://json-schema.org/understanding-json-schema/reference/regular_expressions\n * https://ecma-international.org/publications-and-standards/standards/ecma-262\n */\n// TODO(burdon): Implement.\nexport const Regex = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex));\n\n/**\n * Multi-line text.\n */\nexport const Text = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Text));\n\n/**\n * https://datatracker.ietf.org/doc/html/rfc3986#section-1.1.3\n */\nexport const URL = Schema.String.pipe(\n  Schema.pattern(/^(\\w+?:\\/\\/)?([\\da-z.-]+)\\.([a-z.]{2,6})([/\\w .-]*)*\\/?$/i),\n  FormatAnnotation.set(TypeFormat.URL),\n  Schema.annotations({\n    title: 'URL',\n    description: 'URL',\n  }),\n);\n\n/**\n * UUID (RFC 4122)\n * https://datatracker.ietf.org/doc/html/rfc4122\n */\nexport const UUID = Schema.UUID.pipe(\n  FormatAnnotation.set(TypeFormat.UUID),\n  Schema.annotations({\n    [SchemaAST.ExamplesAnnotationId]: ['3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a'],\n  }),\n);\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport * as Keys from '@dxos/keys';\n\nimport * as DateUtil from './date';\nimport * as NumberUtil from './number';\nimport * as ObjectUtil from './object';\nimport * as StringUtil from './string';\nimport { TypeFormat as TypeFormat$ } from './types';\n\n// TODO(burdon): Media encoding.\n// - https://json-schema.org/understanding-json-schema/reference/non_json_data\n\n/**\n * Formats.\n * https://json-schema.org/understanding-json-schema/reference/string#built-in-formats\n * NOTE: A JSON Schema validator will ignore any format type that it does not understand.\n */\n// TODO(burdon): Add fields for `examples`, `message`, etc.\nexport namespace Format {\n  export import TypeFormat = TypeFormat$;\n\n  // String\n  export const DXN = Keys.DXN.Schema;\n  export const Email = StringUtil.Email;\n  export const Formula = StringUtil.Formula;\n  export const Hostname = StringUtil.Hostname;\n  export const JSON = StringUtil.JSON;\n  export const Markdown = StringUtil.Markdown;\n  export const Regex = StringUtil.Regex;\n  export const URL = StringUtil.URL;\n  export const UUID = Schema.UUID;\n\n  // Numbers\n  // TODO(burdon): BigInt.\n  export const Currency = NumberUtil.Currency;\n  export const Integer = NumberUtil.Integer;\n  export const Percent = NumberUtil.Percent;\n  export const Timestamp = NumberUtil.Timestamp;\n\n  // Dates and times\n  export const Date = DateUtil.DateOnly;\n  export const DateTime = DateUtil.DateTime;\n  export const Duration = DateUtil.Duration;\n  export const Time = DateUtil.TimeOnly;\n\n  // Objects\n  export const GeoPoint = ObjectUtil.GeoPoint;\n  export type GeoPoint = ObjectUtil.GeoPoint; // TODO(burdon): Export types.\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * Datetime values should be stored as ISO strings or unix numbers (ms) in UTC.\n *\n * NOTE: HyperFormula uses Excel's time format (null date 1900/01/01)\n * It can be configured to use a different parser via `parseDateTime`.\n * https://hyperformula.handsontable.com/guide/date-and-time-handling.html#date-and-time-handling\n * https://github.com/handsontable/hyperformula/blob/master/src/DateTimeHelper.ts\n */\n\n// TODO(burdon): Annotations not present in JSON.\n// TODO(burdon): Timezone.\n// TODO(burdon): Format for timestamp (Unix UTC or ISO 8601)?\n// TODO(burdon): Refs\n//  - https://www.npmjs.com/package/numfmt\n//  - https://date-fns.org/docs/Getting-Started\n//  - https://github.com/date-fns/tz\n\n/**\n * Simple date compatible with HF.\n */\nexport const SimpleDate = Schema.Struct({\n  year: Schema.Number.pipe(Schema.between(1900, 9999)),\n  month: Schema.Number.pipe(Schema.between(1, 12)),\n  day: Schema.Number.pipe(Schema.between(1, 31)),\n});\n\nexport type SimpleDate = Schema.Schema.Type<typeof SimpleDate>;\n\nexport const toSimpleDate = (date: Date): SimpleDate => ({\n  year: date.getUTCFullYear(),\n  month: date.getUTCMonth() + 1,\n  day: date.getUTCDate(),\n});\n\n/**\n * Simple time compatible with HF.\n */\nexport const SimpleTime = Schema.Struct({\n  hours: Schema.Number.pipe(Schema.between(0, 23)),\n  minutes: Schema.Number.pipe(Schema.between(0, 59)),\n  seconds: Schema.Number.pipe(Schema.between(0, 59)),\n});\n\nexport type SimpleTime = Schema.Schema.Type<typeof SimpleTime>;\n\nexport const toSimpleTime = (date: Date): SimpleTime => ({\n  hours: date.getUTCHours(),\n  minutes: date.getUTCSeconds(),\n  seconds: date.getUTCSeconds(),\n});\n\n/**\n * Simple date-time compatible with HF.\n */\nexport const SimpleDateTime = Schema.extend(SimpleDate, SimpleTime);\n\nexport type SimpleDateTime = Schema.Schema.Type<typeof SimpleDateTime>;\n\nexport const toSimpleDateTime = (date: Date): SimpleDateTime => ({\n  ...toSimpleDate(date),\n  ...toSimpleTime(date),\n});\n\n/**\n * https://effect.website/docs/guides/schema/transformations#date-transformations\n */\n\n// TODO(burdon): Consider if transformations should be supported with Automerge.\n\n/**\n * Format: 2018-11-13\n */\nexport const DateOnly = /* Schema.transformOrFail(Schema.String, SimpleDate, {\n  strict: true,\n  decode: (str, _, ast) => {\n    if (!isValidDateFormat(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected YYYY-MM-DD format'));\n    }\n    if (!isValidDate(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Invalid date'));\n    }\n\n    const [year, month, day] = str.split('-').map(Number);\n    return ParseResult.succeed({ year, month, day });\n  },\n  encode: (date) => {\n    return ParseResult.succeed(\n      [\n        date.year.toString().padStart(4, '0'),\n        date.month.toString().padStart(2, '0'),\n        date.day.toString().padStart(2, '0'),\n      ].join('-'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Date),\n  Schema.annotations({\n    title: 'Date',\n    description: 'Valid date in ISO format',\n  }),\n);\n\n/**\n * Format: 20:20:39+00:00\n */\nexport const TimeOnly = /* Schema.transformOrFail(Schema.String, SimpleTime, {\n  strict: true,\n  decode: (str, _, ast) => {\n    if (!isValidTimeFormat(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));\n    }\n\n    const [hours, minutes, seconds] = str.split(':').map(Number);\n    return ParseResult.succeed({ hours, minutes, seconds });\n  },\n  encode: (time) => {\n    return ParseResult.succeed(\n      [\n        time.hours.toString().padStart(2, '0'),\n        time.minutes.toString().padStart(2, '0'),\n        time.seconds.toString().padStart(2, '0'),\n      ].join(':'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Time),\n  Schema.annotations({\n    title: 'Time',\n    description: 'Valid time in ISO format',\n  }),\n);\n\n/**\n * Format: 2018-11-13T20:20:39+00:00\n */\nexport const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime, {\n  strict: false,\n  decode: (str, _, ast) => {\n    const [date, time] = str.split('T');\n    if (!isValidDateFormat(date)) {\n      return ParseResult.fail(new ParseResult.Type(ast, date, 'Expected YYYY-MM-DD format'));\n    }\n    if (!isValidDate(date)) {\n      return ParseResult.fail(new ParseResult.Type(ast, date, 'Invalid date'));\n    }\n    if (!isValidTimeFormat(time)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));\n    }\n\n    const [year, month, day] = date.split('-').map(Number);\n    const [hours, minutes, seconds] = time.split(':').map(Number);\n    return ParseResult.succeed({ year, month, day, hours, minutes, seconds });\n  },\n  encode: (datetime) => {\n    return ParseResult.succeed(\n      [\n        [\n          datetime.year.toString().padStart(4, '0'),\n          datetime.month.toString().padStart(2, '0'),\n          datetime.day.toString().padStart(2, '0'),\n        ].join('-'),\n        [\n          datetime.hours.toString().padStart(2, '0'),\n          datetime.minutes.toString().padStart(2, '0'),\n          datetime.seconds.toString().padStart(2, '0'),\n        ].join(':'),\n      ].join('T'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.DateTime),\n  Schema.annotations({\n    title: 'DateTime',\n    description: 'Valid date and time in ISO format',\n  }),\n);\n\n/**\n * https://datatracker.ietf.org/doc/html/rfc3339#appendix-A\n */\n// TODO(burdon): Define duration type.\nexport const Duration = Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Duration),\n  Schema.annotations({\n    title: 'Duration',\n    description: 'Duration in ISO 8601 format',\n    [SchemaAST.ExamplesAnnotationId]: ['1h', '3D'],\n  }),\n);\n\n//\n// Utils\n//\n\n// YYYY-MM-DD\nconst DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}$/;\n\nconst _isValidDateFormat = (str: string) => DATE_REGEX.test(str);\n\nconst _isValidDate = (str: string) => {\n  const date = new Date(str);\n  return !isNaN(date.getTime()) && date.toISOString().startsWith(str);\n};\n\n// HH:mm:ss\nconst TIME_REGEX = /^([01]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)$/;\n\nconst _isValidTimeFormat = (str: string) => TIME_REGEX.test(str);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n/**\n * Schema for a single select option. Used to define choices in a {single|multi}-select field.\n */\nexport const SelectOption = Schema.Struct({\n  /** Stable identifier for the option. */\n  id: Schema.NonEmptyString,\n  title: Schema.String,\n  /** Color palette used for visual styling. */\n  color: Schema.String,\n}).pipe(Schema.mutable);\n\nexport type SelectOption = Schema.Schema.Type<typeof SelectOption>;\n"],
+  "mappings": "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",
+  "names": ["Function", "Option", "SchemaAST", "TypeEnum", "getTypeEnum", "property", "type", "undefined", "FormatAnnotationId", "Symbol", "for", "FormatAnnotation", "createAnnotationHelper", "getFormatAnnotation", "node", "pipe", "getAnnotation", "getOrUndefined", "TypeFormat", "FormatEnums", "Object", "values", "sort", "PropertyKind", "format", "typeToFormat", "formatToType", "OptionsAnnotationId", "OptionsAnnotation", "getOptionsAnnotation", "Schema", "encodeMultipleOf", "divisor", "Math", "pow", "encodeMultiple", "self", "undefined", "pipe", "multipleOf", "DecimalPrecision", "transform", "Number", "strict", "encode", "value", "decode", "log10", "annotations", "title", "CurrencyAnnotationId", "Symbol", "for", "Currency", "decimals", "code", "FormatAnnotation", "set", "TypeFormat", "description", "toUpperCase", "Integer", "int", "Percent", "Timestamp", "Schema", "clamp", "GeoPoint", "Tuple", "Number", "pipe", "annotations", "title", "clamp", "multipleOf", "optionalElement", "FormatAnnotation", "set", "TypeFormat", "description", "GeoLocation", "toGeoPoint", "longitude", "latitude", "height", "clampedLongitude", "clampedLatitude", "undefined", "fromGeoPoint", "geoPoint", "result", "Schema", "SchemaAST", "Email", "String", "pipe", "pattern", "FormatAnnotation", "set", "TypeFormat", "annotations", "title", "description", "Formula", "Hostname", "JSON", "Markdown", "Regex", "Text", "URL", "UUID", "ExamplesAnnotationId", "Schema", "Keys", "Schema", "SchemaAST", "SimpleDate", "Struct", "year", "Number", "pipe", "between", "month", "day", "SimpleTime", "Struct", "hours", "Number", "pipe", "between", "minutes", "seconds", "SimpleDateTime", "extend", "SimpleDate", "SimpleTime", "DateOnly", "String", "pipe", "FormatAnnotation", "set", "TypeFormat", "Date", "annotations", "title", "description", "TimeOnly", "Time", "DateTime", "Duration", "ExamplesAnnotationId", "Format", "TypeFormat", "DXN", "Schema", "Email", "Formula", "Hostname", "JSON", "Markdown", "Regex", "URL", "UUID", "Currency", "Integer", "Percent", "Timestamp", "Date", "DateOnly", "DateTime", "Duration", "Time", "TimeOnly", "GeoPoint", "Schema", "SelectOption", "Struct", "id", "NonEmptyString", "title", "String", "color", "pipe", "mutable"]
+}

package/dist/lib/browser/chunk-V7TON6BX.mjs

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

package/dist/lib/browser/chunk-V7TON6BX.mjs.map

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

package/dist/lib/browser/chunk-WABSVOOX.mjs

@@ -0,0 +1,303 @@
+import "@dxos/node-std/globals";
+import {
+  EntityKind,
+  createAnnotationHelper
+} from "./chunk-QU7PWSZD.mjs";
+
+// src/internal/types/typename.ts
+var ATTR_TYPE = "@type";
+var TypeId = Symbol.for("@dxos/echo/Type");
+var SchemaId = Symbol.for("@dxos/echo/Schema");
+var getSchema = (obj) => {
+  if (obj) {
+    return obj[SchemaId];
+  }
+};
+var setSchema = (obj, schema) => {
+  Object.defineProperty(obj, SchemaId, {
+    value: schema,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+
+// src/internal/annotations/annotations.ts
+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 { raise } from "@dxos/debug";
+import { Reference } from "@dxos/echo-protocol";
+import { getField } from "@dxos/effect";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/annotations/annotations.ts";
+var FIELD_PATH_ANNOTATION = "path";
+var FieldPath = (path) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
+var TypeIdentifierAnnotationId = Symbol.for("@dxos/schema/annotation/TypeIdentifier");
+var getTypeIdentifierAnnotation = (schema) => Function.flow(SchemaAST.getAnnotation(TypeIdentifierAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+var getSchemaDXN = (schema) => {
+  assertArgument(Schema.isSchema(schema), "schema", "invalid schema");
+  const id = getTypeIdentifierAnnotation(schema);
+  if (id) {
+    return DXN.parse(id);
+  }
+  const objectAnnotation = getTypeAnnotation(schema);
+  if (!objectAnnotation) {
+    return void 0;
+  }
+  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);
+};
+var getTypeReference = (schema) => {
+  if (!schema) {
+    return void 0;
+  }
+  const schemaDXN = getSchemaDXN(schema);
+  if (!schemaDXN) {
+    return void 0;
+  }
+  return Reference.fromDXN(schemaDXN);
+};
+var requireTypeReference = (schema) => {
+  const typeReference = getTypeReference(schema);
+  if (typeReference == null) {
+    throw new Error("Schema must be defined via TypedObject.");
+  }
+  return typeReference;
+};
+var getTypeDXNFromSpecifier = (input) => {
+  if (Schema.isSchema(input)) {
+    return getTypeReference(input)?.toDXN() ?? raise(new TypeError("Schema has no DXN"));
+  } else {
+    assertArgument(typeof input === "string", "input");
+    assertArgument(!input.startsWith("dxn:"), "input");
+    return DXN.fromTypename(input);
+  }
+};
+var TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\w+\.[a-zA-Z]\w{1,}\/[\w/_-]+$/)).annotations({
+  description: "Fully qualified globally unique typename",
+  example: "dxos.org/type/Message"
+});
+var VersionSchema = Schema.String.pipe(Schema.pattern(/^\d+.\d+.\d+$/)).annotations({
+  description: "Semantic version format: `major.minor.patch`",
+  example: "1.0.0"
+});
+var TypeMeta = Schema.Struct({
+  typename: TypenameSchema,
+  version: VersionSchema
+});
+var TypeAnnotationId = Symbol.for("@dxos/schema/annotation/Type");
+var TypeAnnotation = Schema.extend(TypeMeta, Schema.Struct({
+  kind: Schema.Enums(EntityKind),
+  /**
+   * If this is a relation, the schema of the source object.
+   * Must be present if entity kind is {@link EntityKind.Relation}.
+   */
+  sourceSchema: Schema.optional(DXN.Schema),
+  /**
+   * If this is a relation, the schema of the target object.
+   * Must be present if entity kind is {@link EntityKind.Relation}.
+   */
+  targetSchema: Schema.optional(DXN.Schema)
+}));
+var getTypeAnnotation = (schema) => {
+  assertArgument(schema != null && schema.ast != null, "schema", "invalid schema");
+  return Function.flow(SchemaAST.getAnnotation(TypeAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+};
+var getEntityKind = (schema) => getTypeAnnotation(schema)?.kind;
+var getSchemaTypename = (schema) => getTypeAnnotation(schema)?.typename;
+var getSchemaVersion = (schema) => getTypeAnnotation(schema)?.version;
+var getTypename = (obj) => {
+  const schema = getSchema(obj);
+  if (schema != null) {
+    return getSchemaTypename(schema);
+  } else {
+    const type = getTypeDXN(obj);
+    return type?.asTypeDXN()?.type;
+  }
+};
+var setTypename = (obj, typename) => {
+  invariant(typename instanceof DXN, "Invalid type.", {
+    F: __dxlog_file,
+    L: 231,
+    S: void 0,
+    A: [
+      "typename instanceof DXN",
+      "'Invalid type.'"
+    ]
+  });
+  Object.defineProperty(obj, TypeId, {
+    value: typename,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+var getTypeDXN = (obj) => {
+  if (!obj) {
+    return void 0;
+  }
+  const type = obj[TypeId];
+  if (!type) {
+    return void 0;
+  }
+  invariant(type instanceof DXN, "Invalid object.", {
+    F: __dxlog_file,
+    L: 258,
+    S: void 0,
+    A: [
+      "type instanceof DXN",
+      "'Invalid object.'"
+    ]
+  });
+  return type;
+};
+var isInstanceOf = (schema, object) => {
+  if (object == null) {
+    return false;
+  }
+  const schemaDXN = getSchemaDXN(schema);
+  if (!schemaDXN) {
+    throw new Error("Schema must have an object annotation.");
+  }
+  const type = getTypeDXN(object);
+  if (type && DXN.equals(type, schemaDXN)) {
+    return true;
+  }
+  const typename = getTypename(object);
+  if (!typename) {
+    return false;
+  }
+  const typeDXN = schemaDXN.asTypeDXN();
+  if (!typeDXN) {
+    return false;
+  }
+  return typeDXN.type === typename;
+};
+var PropertyMetaAnnotationId = Symbol.for("@dxos/schema/annotation/PropertyMeta");
+var PropertyMeta = (name, value) => {
+  return (self) => {
+    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId];
+    return self.annotations({
+      [PropertyMetaAnnotationId]: {
+        ...existingMeta,
+        [name]: value
+      }
+    });
+  };
+};
+var getPropertyMetaAnnotation = (prop, name) => Function.pipe(SchemaAST.getAnnotation(PropertyMetaAnnotationId)(prop.type), Option.map((meta) => meta[name]), Option.getOrElse(() => void 0));
+var ReferenceAnnotationId = Symbol.for("@dxos/schema/annotation/Reference");
+var getReferenceAnnotation = (schema) => Function.pipe(SchemaAST.getAnnotation(ReferenceAnnotationId)(schema.ast), Option.getOrElse(() => void 0));
+var SchemaMetaSymbol = Symbol.for("@dxos/schema/SchemaMeta");
+var SystemTypeAnnotationId = Symbol.for("@dxos/schema/annotation/SystemType");
+var SystemTypeAnnotation = createAnnotationHelper(SystemTypeAnnotationId);
+var LabelAnnotationId = Symbol.for("@dxos/schema/annotation/Label");
+var LabelAnnotation = createAnnotationHelper(LabelAnnotationId);
+var getLabel = (schema, object) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => [
+    "name"
+  ]));
+  for (const accessor of annotation) {
+    assertArgument(typeof accessor === "string", "accessor", "Label annotation must be a string or an array of strings");
+    const value = getField(object, accessor);
+    switch (typeof value) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "bigint":
+      case "symbol":
+        return value.toString();
+      case "undefined":
+      case "object":
+      case "function":
+        continue;
+    }
+  }
+  return void 0;
+};
+var setLabel = (schema, object, label) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option.map((field) => field[0]), Option.getOrElse(() => "name"));
+  object[annotation] = label;
+};
+var DescriptionAnnotationId = Symbol.for("@dxos/schema/annotation/Description");
+var DescriptionAnnotation = createAnnotationHelper(DescriptionAnnotationId);
+var getDescription = (schema, object) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => "description"));
+  assertArgument(typeof accessor === "string", "accessor", "Description annotation must be a string");
+  const value = getField(object, accessor);
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return value.toString();
+    case "undefined":
+    case "object":
+    case "function":
+    default:
+      return void 0;
+  }
+};
+var setDescription = (schema, object, description) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => "description"));
+  object[accessor] = description;
+};
+var FormInputAnnotationId = Symbol.for("@dxos/schema/annotation/FormInput");
+var FormInputAnnotation = createAnnotationHelper(FormInputAnnotationId);
+var FieldLookupAnnotationId = Symbol.for("@dxos/schema/annotation/FieldLookup");
+var GeneratorAnnotationId = Symbol.for("@dxos/schema/annotation/Generator");
+var GeneratorAnnotation = createAnnotationHelper(GeneratorAnnotationId);
+
+export {
+  ATTR_TYPE,
+  TypeId,
+  SchemaId,
+  getSchema,
+  setSchema,
+  FIELD_PATH_ANNOTATION,
+  FieldPath,
+  TypeIdentifierAnnotationId,
+  getTypeIdentifierAnnotation,
+  getSchemaDXN,
+  getTypeReference,
+  requireTypeReference,
+  getTypeDXNFromSpecifier,
+  TypenameSchema,
+  VersionSchema,
+  TypeMeta,
+  TypeAnnotationId,
+  TypeAnnotation,
+  getTypeAnnotation,
+  getEntityKind,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypename,
+  setTypename,
+  getTypeDXN,
+  isInstanceOf,
+  PropertyMetaAnnotationId,
+  PropertyMeta,
+  getPropertyMetaAnnotation,
+  ReferenceAnnotationId,
+  getReferenceAnnotation,
+  SchemaMetaSymbol,
+  SystemTypeAnnotationId,
+  SystemTypeAnnotation,
+  LabelAnnotationId,
+  LabelAnnotation,
+  getLabel,
+  setLabel,
+  DescriptionAnnotationId,
+  DescriptionAnnotation,
+  getDescription,
+  setDescription,
+  FormInputAnnotationId,
+  FormInputAnnotation,
+  FieldLookupAnnotationId,
+  GeneratorAnnotationId,
+  GeneratorAnnotation
+};
+//# sourceMappingURL=chunk-WABSVOOX.mjs.map

package/dist/lib/browser/chunk-WABSVOOX.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/types/typename.ts", "../../../src/internal/annotations/annotations.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\n/**\n * Property name for typename when object is serialized to JSON.\n */\nexport const ATTR_TYPE = '@type';\n\n/**\n * DXN to the object type.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Type');\n\n/**\n * Reference to the object schema.\n */\nexport const SchemaId = Symbol.for('@dxos/echo/Schema');\n\n/**\n * Returns the schema for the given object if one is defined.\n *\n * @internal (Use Obj.getSchema)\n */\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): For echo objects, this always returns the root schema.\nexport const getSchema = (obj: unknown | undefined): Schema.Schema.AnyNoContext | undefined => {\n  if (obj) {\n    return (obj as any)[SchemaId];\n  }\n};\n\n/**\n * @internal\n */\nexport const setSchema = (obj: any, schema: Schema.Schema.AnyNoContext): void => {\n  Object.defineProperty(obj, SchemaId, {\n    value: schema,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  });\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { raise } from '@dxos/debug';\nimport { Reference } from '@dxos/echo-protocol';\nimport { type JsonPath, getField } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Primitive } from '@dxos/util';\n\nimport { type AnyProperties, EntityKind, TypeId, getSchema } from '../types';\n\nimport { createAnnotationHelper } from './util';\n\n/**\n * @internal\n */\nexport const FIELD_PATH_ANNOTATION = 'path';\n\n/**\n * Sets the path for the field.\n * @param path Data source path in the json path format. This is the field path in the source object.\n */\n// TODO(burdon): Field, vs. path vs. property.\nexport const FieldPath = (path: string) => PropertyMeta(FIELD_PATH_ANNOTATION, path);\n\n//\n// Type\n//\n\n/**\n * ECHO identifier (for a stored schema).\n * Must be a `dxn:echo:` URI.\n */\nexport const TypeIdentifierAnnotationId = Symbol.for('@dxos/schema/annotation/TypeIdentifier');\n\nexport const getTypeIdentifierAnnotation = (schema: Schema.Schema.All) =>\n  Function.flow(\n    SchemaAST.getAnnotation<string>(TypeIdentifierAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n\n/**\n * @returns DXN of the schema.\n *\n * For non-stored schema returns `dxn:type:`.\n * For stored schema returns `dxn:echo:`.\n */\nexport const getSchemaDXN = (schema: Schema.Schema.All): DXN | undefined => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');\n  const id = getTypeIdentifierAnnotation(schema);\n  if (id) {\n    return DXN.parse(id);\n  }\n\n  // TODO(dmaretskyi): Add support for dynamic schema.\n  const objectAnnotation = getTypeAnnotation(schema);\n  if (!objectAnnotation) {\n    return undefined;\n  }\n\n  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);\n};\n\n/**\n * Returns a reference that will be used to point to a schema.\n * @deprecated Use {@link getSchemaDXN} instead.\n */\nexport const getTypeReference = (schema: Schema.Schema.All | undefined): Reference | undefined => {\n  if (!schema) {\n    return undefined;\n  }\n\n  const schemaDXN = getSchemaDXN(schema);\n  if (!schemaDXN) {\n    return undefined;\n  }\n  return Reference.fromDXN(schemaDXN);\n};\n\n/**\n * Returns a reference that will be used to point to a schema.\n * @throws If it is not possible to reference this schema.\n *\n * @deprecated Use {@link getSchemaDXN} instead.\n */\nexport const requireTypeReference = (schema: Schema.Schema.AnyNoContext): Reference => {\n  const typeReference = getTypeReference(schema);\n  if (typeReference == null) {\n    // TODO(burdon): Catalog user-facing errors (this is too verbose).\n    throw new Error('Schema must be defined via TypedObject.');\n  }\n\n  return typeReference;\n};\n\n/**\n * @param input schema or a typename string\n * @return type DXN\n */\nexport const getTypeDXNFromSpecifier = (input: Schema.Schema.All | string): DXN => {\n  if (Schema.isSchema(input)) {\n    return getTypeReference(input)?.toDXN() ?? raise(new TypeError('Schema has no DXN'));\n  } else {\n    assertArgument(typeof input === 'string', 'input');\n    assertArgument(!input.startsWith('dxn:'), 'input');\n    return DXN.fromTypename(input);\n  }\n};\n\n//\n// TypeAnnotation\n//\n\n/**\n * Fully qualified globally unique typename.\n * Example: `dxos.org/type/Message`\n */\n// TODO(burdon): Reconcile with short DXN format.\n// TODO(burdon): Change \"/type\" => \"/schema\" throughout.\nexport const TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\\w+\\.[a-zA-Z]\\w{1,}\\/[\\w/_-]+$/)).annotations(\n  {\n    description: 'Fully qualified globally unique typename',\n    example: 'dxos.org/type/Message',\n  },\n);\n\n/**\n * Semantic version format: `major.minor.patch`\n * Example: `1.0.0`\n */\nexport const VersionSchema = Schema.String.pipe(Schema.pattern(/^\\d+.\\d+.\\d+$/)).annotations({\n  description: 'Semantic version format: `major.minor.patch`',\n  example: '1.0.0',\n});\n\nexport const TypeMeta = Schema.Struct({\n  typename: TypenameSchema,\n  version: VersionSchema,\n});\n\nexport interface TypeMeta extends Schema.Schema.Type<typeof TypeMeta> {}\n\n/**\n * Entity type.\n */\nexport const TypeAnnotationId = Symbol.for('@dxos/schema/annotation/Type');\n\n/**\n * Payload stored under {@link TypeAnnotationId}.\n */\nexport const TypeAnnotation = Schema.extend(\n  TypeMeta,\n  Schema.Struct({\n    kind: Schema.Enums(EntityKind),\n\n    /**\n     * If this is a relation, the schema of the source object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    sourceSchema: Schema.optional(DXN.Schema),\n\n    /**\n     * If this is a relation, the schema of the target object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    targetSchema: Schema.optional(DXN.Schema),\n  }),\n);\n\nexport interface TypeAnnotation extends Schema.Schema.Type<typeof TypeAnnotation> {}\n\n/**\n * @returns {@link TypeAnnotation} from a schema.\n * Schema must have been created with {@link TypedObject} or {@link TypedLink} or manually assigned an appropriate annotation.\n */\nexport const getTypeAnnotation = (schema: Schema.Schema.All): TypeAnnotation | undefined => {\n  assertArgument(schema != null && schema.ast != null, 'schema', 'invalid schema');\n  return Function.flow(\n    SchemaAST.getAnnotation<TypeAnnotation>(TypeAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n};\n\n/**\n * @returns {@link EntityKind} from a schema.\n */\nexport const getEntityKind = (schema: Schema.Schema.All): EntityKind | undefined => getTypeAnnotation(schema)?.kind;\n\n/**\n * @internal\n * @returns Schema typename (without dxn: prefix or version number).\n */\nexport const getSchemaTypename = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.typename;\n\n/**\n * @internal\n * @returns Schema version in semver format.\n */\nexport const getSchemaVersion = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.version;\n\n/**\n * Gets the typename of the object without the version.\n * Returns only the name portion, not the DXN.\n * @example \"example.org/type/Contact\"\n *\n * @internal (use Obj.getTypename)\n */\nexport const getTypename = (obj: AnyProperties): string | undefined => {\n  const schema = getSchema(obj);\n  if (schema != null) {\n    // Try to extract typename from DXN.\n    return getSchemaTypename(schema);\n  } else {\n    const type = getTypeDXN(obj);\n    return type?.asTypeDXN()?.type;\n  }\n};\n\n/**\n * @internal (use Type.setTypename)\n */\n// TODO(dmaretskyi): Rename setTypeDXN.\nexport const setTypename = (obj: any, typename: DXN): void => {\n  invariant(typename instanceof DXN, 'Invalid type.');\n  Object.defineProperty(obj, TypeId, {\n    value: typename,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  });\n};\n\n/**\n * @returns Object type as {@link DXN}.\n * @returns undefined if the object doesn't have a type.\n * @example `dxn:example.com/type/Person:1.0.0`\n *\n * @internal (use Obj.getTypeDXN)\n */\n// TODO(burdon): Narrow type.\nexport const getTypeDXN = (obj: AnyProperties): DXN | undefined => {\n  if (!obj) {\n    return undefined;\n  }\n\n  const type = (obj as any)[TypeId];\n  if (!type) {\n    return undefined;\n  }\n\n  invariant(type instanceof DXN, 'Invalid object.');\n  return type;\n};\n\n/**\n * Checks if the object is an instance of the schema.\n * Only typename is compared, the schema version is ignored.\n *\n * The following cases are considered to mean that the object is an instance of the schema:\n *  - Object was created with this exact schema.\n *  - Object was created with a different version of this schema.\n *  - Object was created with a different schema (maybe dynamic) that has the same typename.\n */\n// TODO(burdon): Can we use `Schema.is`?\nexport const isInstanceOf = <Schema extends Schema.Schema.AnyNoContext>(\n  schema: Schema,\n  object: any,\n): object is Schema.Schema.Type<Schema> => {\n  if (object == null) {\n    return false;\n  }\n\n  const schemaDXN = getSchemaDXN(schema);\n  if (!schemaDXN) {\n    throw new Error('Schema must have an object annotation.');\n  }\n\n  const type = getTypeDXN(object);\n  if (type && DXN.equals(type, schemaDXN)) {\n    return true;\n  }\n\n  const typename = getTypename(object);\n  if (!typename) {\n    return false;\n  }\n\n  const typeDXN = schemaDXN.asTypeDXN();\n  if (!typeDXN) {\n    return false;\n  }\n\n  return typeDXN.type === typename;\n};\n\n//\n// PropertyMeta\n//\n\n/**\n * PropertyMeta (metadata for dynamic schema properties).\n * For user-defined annotations.\n */\nexport const PropertyMetaAnnotationId = Symbol.for('@dxos/schema/annotation/PropertyMeta');\n\nexport type PropertyMetaValue = Primitive | Record<string, Primitive> | Primitive[];\n\nexport type PropertyMetaAnnotation = {\n  [name: string]: PropertyMetaValue;\n};\n\n// TODO(wittjosiah): Align with other annotations.\n// TODO(wittjosiah): Why is this separate from FormatAnnotation?\nexport const PropertyMeta = (name: string, value: PropertyMetaValue) => {\n  return <A, I, R>(self: Schema.Schema<A, I, R>): Schema.Schema<A, I, R> => {\n    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId] as PropertyMetaAnnotation;\n    return self.annotations({\n      [PropertyMetaAnnotationId]: {\n        ...existingMeta,\n        [name]: value,\n      },\n    });\n  };\n};\n\nexport const getPropertyMetaAnnotation = <T>(prop: SchemaAST.PropertySignature, name: string) =>\n  Function.pipe(\n    SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(prop.type),\n    Option.map((meta) => meta[name] as T),\n    Option.getOrElse(() => undefined),\n  );\n\n//\n// Reference\n//\n\n/**\n * Schema reference.\n */\nexport const ReferenceAnnotationId = Symbol.for('@dxos/schema/annotation/Reference');\n\nexport type ReferenceAnnotationValue = TypeAnnotation;\n\nexport const getReferenceAnnotation = (schema: Schema.Schema.AnyNoContext) =>\n  Function.pipe(\n    SchemaAST.getAnnotation<ReferenceAnnotationValue>(ReferenceAnnotationId)(schema.ast),\n    Option.getOrElse(() => undefined),\n  );\n\n/**\n * SchemaMeta.\n */\nexport const SchemaMetaSymbol = Symbol.for('@dxos/schema/SchemaMeta');\nexport type SchemaMeta = TypeMeta & { id: string };\n\n/**\n * Identifies a schema as a schema for a hidden system type.\n */\nexport const SystemTypeAnnotationId = Symbol.for('@dxos/schema/annotation/SystemType');\nexport const SystemTypeAnnotation = createAnnotationHelper<boolean>(SystemTypeAnnotationId);\n\n/**\n * Identifies label property or JSON path expression.\n * Either a string or an array of strings representing field accessors each matched in priority order.\n */\nexport const LabelAnnotationId = Symbol.for('@dxos/schema/annotation/Label');\nexport const LabelAnnotation = createAnnotationHelper<string[]>(LabelAnnotationId);\n\n/**\n * Returns the label for a given object based on {@link LabelAnnotationId}.\n */\n// TODO(burdon): Convert to JsonPath?\nexport const getLabel = <S extends Schema.Schema.Any>(schema: S, object: Schema.Schema.Type<S>): string | undefined => {\n  const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => ['name']));\n  for (const accessor of annotation) {\n    assertArgument(\n      typeof accessor === 'string',\n      'accessor',\n      'Label annotation must be a string or an array of strings',\n    );\n    const value = getField(object, accessor as JsonPath);\n    switch (typeof value) {\n      case 'string':\n      case 'number':\n      case 'boolean':\n      case 'bigint':\n      case 'symbol':\n        return value.toString();\n      case 'undefined':\n      case 'object':\n      case 'function':\n        continue;\n    }\n  }\n\n  return undefined;\n};\n\n/**\n * Sets the label for a given object based on {@link LabelAnnotationId}.\n */\nexport const setLabel = <S extends Schema.Schema.Any>(schema: S, object: Schema.Schema.Type<S>, label: string) => {\n  const annotation = LabelAnnotation.get(schema).pipe(\n    Option.map((field) => field[0]),\n    Option.getOrElse(() => 'name'),\n  );\n  object[annotation] = label;\n};\n\n/**\n * Identifies description property or JSON path expression.\n * A string representing field accessor.\n */\nexport const DescriptionAnnotationId = Symbol.for('@dxos/schema/annotation/Description');\nexport const DescriptionAnnotation = createAnnotationHelper<string>(DescriptionAnnotationId);\n\n/**\n * Returns the label for a given object based on {@link LabelAnnotationId}.\n */\n// TODO(burdon): Convert to JsonPath?\nexport const getDescription = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n): string | undefined => {\n  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));\n  assertArgument(typeof accessor === 'string', 'accessor', 'Description annotation must be a string');\n  const value = getField(object, accessor as JsonPath);\n  switch (typeof value) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'bigint':\n    case 'symbol':\n      return value.toString();\n    case 'undefined':\n    case 'object':\n    case 'function':\n    default:\n      return undefined;\n  }\n};\n\n/**\n * Sets the description for a given object based on {@link DescriptionAnnotationId}.\n */\nexport const setDescription = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n  description: string,\n) => {\n  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));\n  object[accessor] = description;\n};\n\n/**\n * Identifies if a property should be included in a form or not.\n * By default, all properties are included in forms, so this is opt-out.\n */\n// TODO(burdon): UI concern.\nexport const FormInputAnnotationId = Symbol.for('@dxos/schema/annotation/FormInput');\nexport const FormInputAnnotation = createAnnotationHelper<boolean>(FormInputAnnotationId);\n\n/**\n * Default field to be used on referenced schema to lookup the value.\n */\nexport const FieldLookupAnnotationId = Symbol.for('@dxos/schema/annotation/FieldLookup');\n\n/**\n * Generate test data.\n */\nexport const GeneratorAnnotationId = Symbol.for('@dxos/schema/annotation/Generator');\n\nexport type GeneratorAnnotationValue =\n  | string\n  | {\n      generator: string;\n      args?: any[];\n      probability?: number;\n    };\n\nexport const GeneratorAnnotation = createAnnotationHelper<GeneratorAnnotationValue>(GeneratorAnnotationId);\n"],
+  "mappings": "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",
+  "names": ["ATTR_TYPE", "TypeId", "Symbol", "for", "SchemaId", "getSchema", "obj", "setSchema", "schema", "Object", "defineProperty", "value", "writable", "enumerable", "configurable", "Function", "Option", "Schema", "SchemaAST", "raise", "Reference", "getField", "assertArgument", "invariant", "DXN", "FIELD_PATH_ANNOTATION", "FieldPath", "path", "PropertyMeta", "TypeIdentifierAnnotationId", "Symbol", "for", "getTypeIdentifierAnnotation", "schema", "flow", "getAnnotation", "getOrElse", "undefined", "ast", "getSchemaDXN", "assertArgument", "isSchema", "id", "DXN", "parse", "objectAnnotation", "getTypeAnnotation", "fromTypenameAndVersion", "typename", "version", "getTypeReference", "schemaDXN", "Reference", "fromDXN", "requireTypeReference", "typeReference", "Error", "getTypeDXNFromSpecifier", "input", "toDXN", "raise", "TypeError", "startsWith", "fromTypename", "TypenameSchema", "String", "pipe", "pattern", "annotations", "description", "example", "VersionSchema", "TypeMeta", "Struct", "TypeAnnotationId", "TypeAnnotation", "extend", "kind", "Enums", "EntityKind", "sourceSchema", "optional", "Schema", "targetSchema", "getEntityKind", "getSchemaTypename", "getSchemaVersion", "getTypename", "obj", "getSchema", "type", "getTypeDXN", "asTypeDXN", "setTypename", "invariant", "Object", "defineProperty", "TypeId", "value", "writable", "enumerable", "configurable", "isInstanceOf", "object", "equals", "typeDXN", "PropertyMetaAnnotationId", "name", "self", "existingMeta", "getPropertyMetaAnnotation", "prop", "map", "meta", "ReferenceAnnotationId", "getReferenceAnnotation", "SchemaMetaSymbol", "SystemTypeAnnotationId", "SystemTypeAnnotation", "createAnnotationHelper", "LabelAnnotationId", "LabelAnnotation", "getLabel", "annotation", "get", "accessor", "getField", "toString", "setLabel", "label", "field", "DescriptionAnnotationId", "DescriptionAnnotation", "getDescription", "setDescription", "FormInputAnnotationId", "FormInputAnnotation", "FieldLookupAnnotationId", "GeneratorAnnotationId", "GeneratorAnnotation"]
+}