@dxos/echo 0.8.4-main.c85a9c8dae → 0.8.4-main.d05673bc65

package/dist/lib/neutral/chunk-BOZZPUXE.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/JsonSchema/annotations.ts", "../../../src/internal/JsonSchema/json-schema-type.ts", "../../../src/internal/JsonSchema/json-schema.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { GeneratorAnnotationId, LabelAnnotationId, PropertyMetaAnnotationId } from '../Annotation';\nimport { CurrencyAnnotationId, FormatAnnotationId } from '../Format';\nimport { type JsonSchemaEchoAnnotations, type JsonSchemaType } from '../JsonSchema';\n\n//\n// This file configures annotations for JSON encoding/decoding.\n//\n\n// Go on the root level.\ntype RootJsonSchemaProperty = keyof JsonSchemaType;\n\n// Go on the namespaced `annotations` property.\ntype NamespacedJsonSchemaProperty = keyof JsonSchemaEchoAnnotations;\n\n/**\n * List of annotations for JSON encoding/decoding.\n * Omits default effect-schema annotations since they are encoded with default serializer.\n */\n// TODO(burdon): Reconcile with `EchoAnnotations`.\nexport const CustomAnnotations: Partial<Record<RootJsonSchemaProperty, symbol>> = {\n  format: FormatAnnotationId,\n  currency: CurrencyAnnotationId,\n};\n\n/**\n * List of annotations for JSON decoding only.\n * Includes default effect annotations.\n */\nexport const DecodedAnnotations: Partial<Record<RootJsonSchemaProperty, symbol>> = {\n  title: SchemaAST.TitleAnnotationId,\n  description: SchemaAST.DescriptionAnnotationId,\n};\n\n/**\n * Annotations that go into ECHO namespace in json-schema.\n */\n// TODO(dmaretskyi): Consider removing ECHO namespace and putting them at the top level.\n// TODO(dmaretskyi): Move to format.ts when circular imports are solved\nexport const EchoAnnotations: Partial<Record<NamespacedJsonSchemaProperty, symbol>> = {\n  // TODO(dmaretskyi): `FieldLookupAnnotationId` might go here, but lets remove it entirely and use LabelAnnotation instead.\n  meta: PropertyMetaAnnotationId,\n  generator: GeneratorAnnotationId,\n  labelProp: LabelAnnotationId,\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { JsonPath, type JsonProp } from '@dxos/effect';\n\nimport { FormatAnnotation, TypeFormat } from '../Format';\nimport { type Mutable } from '../common/proxy';\nimport { EntityKindSchema } from '../common/types';\n\n//\n// JSON Schema\n//\n\n// TODO(burdon): Reuse/reconcile with ScalarTypeEnum (handle arrays).\nconst SimpleTypes = Schema.Literal('array', 'boolean', 'integer', 'null', 'number', 'object', 'string');\n\nconst NonNegativeInteger = Schema.Number.pipe(Schema.greaterThanOrEqualTo(0));\n\nconst StringArray = Schema.Array(Schema.String);\n\nconst JsonSchemaOrBoolean = Schema.Union(\n  Schema.suspend(() => JsonSchemaType),\n  Schema.Boolean,\n);\n\n/**\n * Go under the `annotations` property.\n */\nexport const JsonSchemaEchoAnnotations = Schema.Struct({\n  /**\n   * Label for this schema.\n   * Mapped from {@link LabelAnnotationId}.\n   */\n  labelProp: Schema.optional(Schema.Union(JsonPath, Schema.Array(JsonPath))),\n\n  /**\n   * Generator function for this schema.\n   * Mapped from {@link GeneratorAnnotationId}.\n   */\n  generator: Schema.optional(Schema.Union(Schema.String, Schema.Tuple(Schema.String, Schema.Number))),\n\n  /**\n   * {@link PropertyMeta} annotations get serialized here.\n   */\n  meta: Schema.optional(\n    Schema.Record({\n      key: Schema.String,\n      value: Schema.Any,\n    }),\n  ),\n\n  /**\n   * @deprecated\n   */\n  // TODO(dmaretskyi): We risk old schema not passing validation due to the extra fields. Remove when we are sure this is safe.\n  type: Schema.optional(\n    Schema.Struct({\n      typename: Schema.String,\n      version: Schema.String,\n\n      // Not used.\n      schemaId: Schema.optional(Schema.String),\n    }),\n  ),\n\n  /**\n   * @deprecated Superseded by `meta`.\n   */\n  annotations: Schema.optional(\n    Schema.Record({\n      key: Schema.String,\n      value: Schema.Any,\n    }),\n  ),\n});\nexport type JsonSchemaEchoAnnotations = Schema.Schema.Type<typeof JsonSchemaEchoAnnotations>;\n\n/**\n * Describes a schema for the JSON-schema objects stored in ECHO.\n * Contains extensions for ECHO (e.g., references).\n * Ref: https://json-schema.org/draft-07/schema\n */\n// TODO(burdon): Integrate with Effect Serializable?\n// TODO(dmaretskyi): Update to latest draft: https://json-schema.org/draft/2020-12\nconst _JsonSchemaType = Schema.Struct({\n  /**\n   * Identifier for this schema.\n   * This schema might be referenced by $ref clause in other schemas.\n   */\n  // TODO(dmaretskyi): Specify how the ids are generated.\n  // TODO(dmaretskyi): For type dxns, should this include the version?\n  $id: Schema.optional(Schema.String),\n\n  /**\n   * Schema of this schema.\n   * Set to \"https://json-schema.org/draft-07/schema\".\n   */\n  $schema: Schema.optional(Schema.String),\n\n  /**\n   * Reference to another schema.\n   */\n  $ref: Schema.optional(Schema.String),\n\n  /**\n   * Comments are ignored when interpreting the schema.\n   */\n  $comment: Schema.optional(Schema.String),\n\n  /**\n   * Defines whether this schema is an object schema or a relation schema.\n   */\n  entityKind: Schema.optional(EntityKindSchema),\n\n  /**\n   * Typename of this schema.\n   * Only on schema representing an ECHO object.\n   *\n   * @example 'com.example.type.my-type'\n   */\n  typename: Schema.optional(Schema.String),\n\n  /**\n   * Version of this schema.\n   * Custom dialect for ECHO.\n   */\n  version: Schema.optional(Schema.String),\n\n  /**\n   * Target of this relation.\n   * Only for relation schemas.\n   * The referenced schema must be an object schema.\n   */\n  relationTarget: Schema.optional(Schema.suspend(() => JsonSchemaType)),\n\n  /**\n   * Source of this relation.\n   * Only for relation schemas.\n   * The referenced schema must be an object schema.\n   */\n  relationSource: Schema.optional(Schema.suspend(() => JsonSchemaType)),\n\n  /**\n   * Title of this schema.\n   */\n  title: Schema.optional(Schema.String),\n\n  /**\n   * Description of this schema.\n   */\n  description: Schema.optional(Schema.String),\n\n  /**\n   * Whether this schema is read-only.\n   */\n  readOnly: Schema.optional(Schema.Boolean),\n\n  /**\n   * Whether this schema is write-only.\n   */\n  writeOnly: Schema.optional(Schema.Boolean),\n\n  /**\n   * Examples of instances of this schema.\n   */\n  examples: Schema.optional(Schema.Array(Schema.Any)),\n\n  /**\n   * Default value for this schema.\n   */\n  default: Schema.optional(Schema.Any),\n\n  /**\n   * This schema only matches values that are equal to this value.\n   */\n  const: Schema.optional(Schema.Any),\n\n  /**\n   * This schema only matches one of the values in this array.\n   */\n  enum: Schema.optional(Schema.Array(Schema.Any)),\n\n  /**\n   * Base type of the schema.\n   */\n  type: Schema.optional(Schema.Union(SimpleTypes, Schema.Array(SimpleTypes))),\n\n  //\n  // Numbers.\n  //\n\n  multipleOf: Schema.optional(Schema.Number.pipe(Schema.greaterThan(0))),\n  maximum: Schema.optional(Schema.Number),\n  exclusiveMaximum: Schema.optional(Schema.Number),\n  minimum: Schema.optional(Schema.Number),\n  exclusiveMinimum: Schema.optional(Schema.Number),\n\n  //\n  // Strings.\n  //\n\n  maxLength: Schema.optional(NonNegativeInteger),\n\n  /**\n   * Regex pattern for strings.\n   */\n  pattern: Schema.optional(Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex))),\n\n  /**\n   * Serialized from {@link FormatAnnotationId}.\n   */\n  format: Schema.optional(Schema.String),\n\n  //\n  // Arrays\n  //\n\n  minLength: Schema.optional(NonNegativeInteger),\n  items: Schema.optional(\n    Schema.Union(\n      Schema.suspend(() => JsonSchemaType),\n      Schema.Array(Schema.suspend(() => JsonSchemaType)),\n    ),\n  ),\n  additionalItems: Schema.optional(\n    Schema.Union(\n      Schema.suspend(() => JsonSchemaType),\n      Schema.Boolean,\n    ),\n  ),\n  maxItems: Schema.optional(NonNegativeInteger),\n  minItems: Schema.optional(NonNegativeInteger),\n  uniqueItems: Schema.optional(Schema.Boolean),\n  contains: Schema.optional(Schema.suspend(() => JsonSchemaType)),\n\n  //\n  // Objects\n  //\n\n  maxProperties: Schema.optional(NonNegativeInteger),\n  minProperties: Schema.optional(NonNegativeInteger),\n  required: Schema.optional(StringArray),\n\n  /**\n   * Non-standard JSON Schema extension.\n   * Defines the order of properties in the object.\n   * The unmentioned properties are placed at the end.\n   *\n   * Related: https://github.com/json-schema/json-schema/issues/119\n   */\n  propertyOrder: Schema.optional(StringArray),\n\n  additionalProperties: Schema.optional(JsonSchemaOrBoolean),\n  properties: Schema.optional(\n    Schema.Record({\n      key: Schema.String,\n      value: Schema.suspend(() => JsonSchemaType),\n    }),\n  ),\n  patternProperties: Schema.optional(\n    Schema.Record({\n      key: Schema.String,\n      value: Schema.suspend(() => JsonSchemaType),\n    }),\n  ),\n  propertyNames: Schema.optional(Schema.suspend(() => JsonSchemaType)),\n\n  definitions: Schema.optional(\n    Schema.Record({\n      key: Schema.String,\n      value: Schema.suspend(() => JsonSchemaType),\n    }),\n  ),\n  dependencies: Schema.optional(\n    Schema.Record({\n      key: Schema.String,\n      value: Schema.suspend(() => Schema.Union(Schema.String, StringArray, JsonSchemaType)).annotations({\n        identifier: 'dependency',\n        description: 'Dependency',\n      }),\n    }),\n  ),\n\n  contentMediaType: Schema.optional(Schema.String),\n  contentEncoding: Schema.optional(Schema.String),\n\n  if: Schema.optional(Schema.suspend(() => JsonSchemaType)),\n  then: Schema.optional(Schema.suspend(() => JsonSchemaType)),\n  else: Schema.optional(Schema.suspend(() => JsonSchemaType)),\n  allOf: Schema.optional(Schema.Array(Schema.suspend(() => JsonSchemaType))),\n  anyOf: Schema.optional(Schema.Array(Schema.suspend(() => JsonSchemaType))),\n  oneOf: Schema.optional(Schema.Array(Schema.suspend(() => JsonSchemaType))),\n  not: Schema.optional(Schema.suspend(() => JsonSchemaType)),\n  $defs: Schema.optional(\n    Schema.Record({\n      key: Schema.String,\n      value: Schema.suspend(() => JsonSchemaType),\n    }),\n  ),\n\n  //\n  // ECHO extensions.\n  //\n\n  currency: Schema.optional(Schema.String),\n\n  reference: Schema.optional(\n    Schema.Struct({\n      schema: Schema.suspend(() => JsonSchemaType),\n      schemaVersion: Schema.optional(Schema.String),\n      schemaObject: Schema.optional(Schema.String),\n    }),\n  ),\n\n  /**\n   * ECHO-specific annotations.\n   */\n  // TODO(dmaretskyi): Since we are adding a lot of new extensions to the JSON Schema, it is safer to namespace them here.\n  annotations: Schema.optional(JsonSchemaEchoAnnotations),\n\n  /**\n   * @deprecated Use `annotations` instead.\n   */\n  echo: Schema.optional(JsonSchemaEchoAnnotations),\n}).annotations({ identifier: 'jsonSchema', description: 'JSON Schema' });\n\nexport const JsonSchemaFields = Object.keys(_JsonSchemaType.fields);\n\n/**\n * https://json-schema.org/draft-07/schema\n */\n// TODO(burdon): Reconcile with @effect/Schema/JSONSchema\nexport interface JsonSchemaType extends Schema.Schema.Type<typeof _JsonSchemaType> {}\n\nexport const JsonSchemaType: Schema.Schema<JsonSchemaType> = _JsonSchemaType;\n\n// TODO(burdon): Factor out JSON schema utils.\n\nexport const getSchemaProperty = (schema: JsonSchemaType, property: JsonProp): JsonSchemaType | undefined => {\n  return schema.properties?.[property];\n};\n\n// TODO(burdon): Properties should be ordered.\nexport const setSchemaProperty = (\n  schema: Mutable<JsonSchemaType>,\n  property: JsonProp,\n  value: Mutable<JsonSchemaType>,\n) => {\n  schema.properties ??= {};\n  schema.properties[property] = value;\n  return schema;\n};\n\n/**\n * @internal\n */\nexport const ECHO_ANNOTATIONS_NS_DEPRECATED_KEY: keyof JsonSchemaType = 'echo';\n\n/**\n * @internal\n */\nexport const ECHO_ANNOTATIONS_NS_KEY = 'annotations';\n\n/**\n * @internal\n * @returns ECHO annotations namespace object in its normalized form.\n *\n * `meta` holds PropertyMeta annotations.\n * `annotations` holds other annotations.\n */\nexport const getNormalizedEchoAnnotations = (obj: JsonSchemaType): JsonSchemaEchoAnnotations | undefined => {\n  if (obj[ECHO_ANNOTATIONS_NS_KEY] != null && obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY] != null) {\n    return normalizeEchoAnnotations({\n      ...obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY],\n      ...obj[ECHO_ANNOTATIONS_NS_KEY],\n    });\n  } else if (obj[ECHO_ANNOTATIONS_NS_KEY] != null) {\n    return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_KEY]!);\n  } else if (obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY] != null) {\n    return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY]!);\n  } else {\n    return undefined;\n  }\n};\n\nconst normalizeEchoAnnotations = (obj: JsonSchemaEchoAnnotations): JsonSchemaEchoAnnotations => {\n  if (!obj.annotations) {\n    return obj;\n  } else {\n    const res = {\n      ...obj,\n      meta: {\n        ...obj.annotations,\n        ...(obj.meta ?? {}),\n      },\n    };\n    delete res.annotations;\n    return res;\n  }\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Array from 'effect/Array';\nimport * as Function from 'effect/Function';\nimport * as JSONSchema from 'effect/JSONSchema';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { raise } from '@dxos/debug';\nimport { mapAst } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\nimport { log } from '@dxos/log';\nimport { clearUndefined, orderKeys, removeProperties } from '@dxos/util';\n\nimport {\n  type TypeAnnotation,\n  TypeAnnotationId,\n  TypeIdentifierAnnotationId,\n  makeTypeJsonSchemaAnnotation,\n} from '../Annotation';\nimport { type JsonSchemaReferenceInfo, createEchoReferenceSchema } from '../Ref';\nimport { ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION, EntityKind, EntityKindSchema } from '../common/types';\n\nimport { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';\nimport {\n  ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,\n  ECHO_ANNOTATIONS_NS_KEY,\n  type JsonSchemaEchoAnnotations,\n  type JsonSchemaType,\n  getNormalizedEchoAnnotations,\n} from './json-schema-type';\n\n// TODO(burdon): Are these values stored (can they be changed?)\nexport enum PropType {\n  NONE = 0,\n  STRING = 1, // TODO(burdon): vs TEXT?\n  NUMBER = 2,\n  BOOLEAN = 3,\n  DATE = 4,\n  REF = 5,\n  RECORD = 6,\n  ENUM = 7,\n}\n\n// TODO(burdon): Reconcile with @dxos/schema.\nexport const toPropType = (type?: PropType): string => {\n  switch (type) {\n    case PropType.STRING:\n      return 'string';\n    case PropType.NUMBER:\n      return 'number';\n    case PropType.BOOLEAN:\n      return 'boolean';\n    case PropType.DATE:\n      return 'date';\n    case PropType.REF:\n      return 'ref';\n    case PropType.RECORD:\n      return 'object';\n    default:\n      throw new Error(`Invalid type: ${type}`);\n  }\n};\n\nconst JSON_SCHEMA_URL = 'http://json-schema.org/draft-07/schema#';\n\nexport type JsonSchemaOptions = {\n  strict?: boolean;\n};\n\n/**\n * Convert effect schema to JSON Schema.\n * NOTE: This handles custom annotations.\n * @param schema\n */\n// TODO(burdon): Reconcile with possibly extending @effect/Schema/JSONSchema\n//  We add additional propertyOrder (but the object properties ARE ordered); and type \"string\" for literals.\n// TODO(wittjosiah): This is mutable because its a pojo, perhaps should be left as readonly at type level though?\nexport const toJsonSchema = (\n  schema: Schema.Schema.All,\n  options: JsonSchemaOptions = {},\n): Types.DeepMutable<JsonSchemaType> => {\n  assertArgument(Schema.isSchema(schema), 'schema');\n  let jsonSchema = _toJsonSchemaAST(schema.ast);\n  if (options.strict) {\n    // TOOD(burdon): Workaround to ensure JSON schema is valid (for agv parsing).\n    jsonSchema = removeProperties(jsonSchema, (key, value) => {\n      if (key === '$id' && value === '/schemas/any') {\n        return true;\n      }\n      if (key === '$ref' && value === '#/$defs/dependency') {\n        return true;\n      }\n      if (key === '$ref' && value === '#/$defs/jsonSchema') {\n        return true;\n      }\n\n      return false;\n    });\n  }\n\n  return jsonSchema;\n};\n\nconst _toJsonSchemaAST = (ast: SchemaAST.AST): Types.DeepMutable<JsonSchemaType> => {\n  const withRefinements = withEchoRefinements(ast, '#');\n  const jsonSchema = JSONSchema.fromAST(withRefinements, {\n    definitions: {},\n  }) as Types.DeepMutable<JsonSchemaType>;\n\n  return normalizeJsonSchema(jsonSchema);\n};\n\nconst withEchoRefinements = (\n  ast: SchemaAST.AST,\n  path: string | undefined,\n  suspendCache = new Map<SchemaAST.AST, string>(),\n): SchemaAST.AST => {\n  if (path) {\n    suspendCache.set(ast, path);\n  }\n\n  let recursiveResult: SchemaAST.AST;\n  if (SchemaAST.isSuspend(ast)) {\n    // Precompute JSON schema for suspended AST since effect serializer does not support it.\n    const suspendedAst = ast.f();\n    const cachedPath = suspendCache.get(suspendedAst);\n    if (cachedPath) {\n      recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {\n        [SchemaAST.JSONSchemaAnnotationId]: {\n          $ref: cachedPath,\n        },\n      });\n    } else {\n      const jsonSchema = _toJsonSchemaAST(suspendedAst);\n      recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {\n        [SchemaAST.JSONSchemaAnnotationId]: jsonSchema,\n      });\n    }\n  } else if (SchemaAST.isTypeLiteral(ast)) {\n    // Add property order annotations\n    recursiveResult = mapAst(ast, (ast, key) =>\n      withEchoRefinements(ast, path && typeof key === 'string' ? `${path}/${key}` : undefined, suspendCache),\n    );\n    recursiveResult = addJsonSchemaFields(recursiveResult, {\n      propertyOrder: [...ast.propertySignatures.map((p) => p.name)] as string[],\n    });\n  } else if (SchemaAST.isUndefinedKeyword(ast)) {\n    // Ignore undefined keyword that appears in the optional fields.\n    return ast;\n  } else {\n    recursiveResult = mapAst(ast, (ast, key) =>\n      withEchoRefinements(\n        ast,\n        path && (typeof key === 'string' || typeof key === 'number') ? `${path}/${key}` : undefined,\n        suspendCache,\n      ),\n    );\n  }\n\n  const annotationFields = annotations_toJsonSchemaFields(ast.annotations);\n  if (Object.keys(annotationFields).length === 0) {\n    return recursiveResult;\n  } else {\n    return addJsonSchemaFields(recursiveResult, annotationFields);\n  }\n};\n\n/**\n * Convert JSON schema to effect schema.\n * @param root\n * @param definitions\n */\nexport const toEffectSchema = (root: JsonSchemaType, _defs?: JsonSchemaType['$defs']): Schema.Schema.AnyNoContext => {\n  const defs = root.$defs ? { ..._defs, ...root.$defs } : (_defs ?? {});\n  if ('type' in root && root.type === 'object') {\n    return objectToEffectSchema(root, defs);\n  }\n\n  let result: Schema.Schema.AnyNoContext = Schema.Unknown;\n  if ('$ref' in root) {\n    switch (root.$ref) {\n      case '/schemas/echo/ref': {\n        result = refToEffectSchema(root);\n        break;\n      }\n    }\n  } else if ('$id' in root) {\n    switch (root.$id as string) {\n      case '/schemas/any': {\n        result = anyToEffectSchema(root as JSONSchema.JsonSchema7Any);\n        break;\n      }\n      case '/schemas/unknown': {\n        result = Schema.Unknown;\n        break;\n      }\n      case '/schemas/{}':\n      case '/schemas/object': {\n        result = Schema.Object;\n        break;\n      }\n      // Custom ECHO object reference.\n      case '/schemas/echo/ref': {\n        result = refToEffectSchema(root);\n        break;\n      }\n    }\n  } else if ('enum' in root) {\n    result = Schema.Union(...root.enum!.map((e) => Schema.Literal(e)));\n  } else if ('oneOf' in root) {\n    result = Schema.Union(...root.oneOf!.map((v) => toEffectSchema(v, defs)));\n  } else if ('anyOf' in root) {\n    result = Schema.Union(...root.anyOf!.map((v) => toEffectSchema(v, defs)));\n  } else if ('allOf' in root) {\n    if (root.allOf!.length === 1) {\n      result = toEffectSchema(root.allOf![0], defs);\n    } else {\n      log.warn('allOf with multiple schemas is not supported');\n      result = Schema.Unknown;\n    }\n  } else if ('type' in root) {\n    switch (root.type) {\n      case 'string': {\n        result = Schema.String;\n        if (root.pattern) {\n          result = result.pipe(Schema.pattern(new RegExp(root.pattern)));\n        }\n        break;\n      }\n      case 'number': {\n        result = Schema.Number;\n        break;\n      }\n      case 'integer': {\n        result = Schema.Number.pipe(Schema.int());\n        break;\n      }\n      case 'boolean': {\n        result = Schema.Boolean;\n        break;\n      }\n      case 'array': {\n        if (Array.isArray(root.items)) {\n          const [required, optional] = Function.pipe(\n            root.items,\n            Array.map((v) => toEffectSchema(v as JsonSchemaType, defs)),\n            Array.splitAt(root.minItems ?? root.items.length),\n          );\n          result = Schema.Tuple(...required, ...optional.map(Schema.optionalElement));\n        } else {\n          invariant(root.items);\n          const items = root.items;\n          result = Array.isArray(items)\n            ? Schema.Tuple(...items.map((v) => toEffectSchema(v as JsonSchemaType, defs)))\n            : Schema.Array(toEffectSchema(items as JsonSchemaType, defs));\n        }\n        break;\n      }\n      case 'null': {\n        result = Schema.Null;\n        break;\n      }\n    }\n  } else if ('$ref' in root) {\n    const refSegments = root.$ref!.split('/');\n    const jsonSchema = defs[refSegments[refSegments.length - 1]];\n    invariant(jsonSchema, `missing definition for ${root.$ref}`);\n    result = toEffectSchema(jsonSchema, defs).pipe(\n      Schema.annotations({ identifier: refSegments[refSegments.length - 1] }),\n    );\n  }\n\n  const annotations = jsonSchemaFieldsToAnnotations(root);\n\n  // log.info('toEffectSchema', { root, annotations });\n  result = result.annotations(annotations);\n\n  return result;\n};\n\nconst objectToEffectSchema = (root: JsonSchemaType, defs: JsonSchemaType['$defs']): Schema.Schema.AnyNoContext => {\n  invariant('type' in root && root.type === 'object', `not an object: ${root}`);\n\n  const echoRefinement: JsonSchemaEchoAnnotations = (root as any)[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];\n  const isEchoObject =\n    echoRefinement != null || ('$id' in root && typeof root.$id === 'string' && root.$id.startsWith('dxn:'));\n\n  let fields: Schema.Struct.Fields = {};\n  const propertyList = Object.entries(root.properties ?? {});\n  let immutableIdField: Schema.Schema.AnyNoContext | undefined;\n  for (const [key, value] of propertyList) {\n    if (isEchoObject && key === 'id') {\n      immutableIdField = toEffectSchema(value, defs);\n    } else {\n      // TODO(burdon): Mutable cast.\n      (fields as any)[key] = root.required?.includes(key)\n        ? toEffectSchema(value, defs)\n        : Schema.optional(toEffectSchema(value, defs));\n    }\n  }\n\n  if (root.propertyOrder) {\n    fields = orderKeys(fields, root.propertyOrder as any);\n  }\n\n  let schema: Schema.Schema<any, any, unknown>;\n  if (root.patternProperties) {\n    invariant(propertyList.length === 0, 'pattern properties mixed with regular properties are not supported');\n    invariant(\n      Object.keys(root.patternProperties).length === 1 && Object.keys(root.patternProperties)[0] === '',\n      'only one pattern property is supported',\n    );\n\n    schema = Schema.Record({ key: Schema.String, value: toEffectSchema(root.patternProperties[''], defs) });\n  } else if (typeof root.additionalProperties !== 'object') {\n    schema = Schema.Struct(fields);\n  } else {\n    const indexValue = toEffectSchema(root.additionalProperties, defs);\n    if (propertyList.length > 0) {\n      schema = Schema.Struct(fields, { key: Schema.String, value: indexValue });\n    } else {\n      schema = Schema.Record({ key: Schema.String, value: indexValue });\n    }\n  }\n\n  if (immutableIdField) {\n    schema = Schema.extend(schema, Schema.Struct({ id: immutableIdField }));\n  }\n\n  const annotations = jsonSchemaFieldsToAnnotations(root);\n  return schema.annotations(annotations) as any;\n};\n\nconst anyToEffectSchema = (root: JSONSchema.JsonSchema7Any): Schema.Schema.AnyNoContext => {\n  const echoRefinement: JsonSchemaEchoAnnotations = (root as any)[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];\n  // TODO(dmaretskyi): Is this branch still taken?\n  if ((echoRefinement as any)?.reference != null) {\n    const echoId = root.$id.startsWith('dxn:echo:') ? root.$id : undefined;\n    return createEchoReferenceSchema(\n      echoId,\n      (echoRefinement as any).reference.typename,\n      (echoRefinement as any).reference.version,\n    );\n  }\n\n  return Schema.Any;\n};\n\n// TODO(dmaretskyi): Types.\nconst refToEffectSchema = (root: any): Schema.Schema.AnyNoContext => {\n  if (!('reference' in root)) {\n    // Fallback to generic object ref when no reference info is provided.\n    return createEchoReferenceSchema(undefined, ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION);\n  }\n\n  const reference: JsonSchemaReferenceInfo = root.reference;\n  if (typeof reference !== 'object') {\n    throw new Error('Invalid reference field in ref schema');\n  }\n\n  const targetSchemaDXN = DXN.parse(reference.schema.$ref);\n  invariant(targetSchemaDXN.kind === DXN.kind.TYPE);\n\n  return createEchoReferenceSchema(\n    targetSchemaDXN.toString(),\n    targetSchemaDXN.kind === DXN.kind.TYPE ? targetSchemaDXN.parts[0] : undefined,\n    reference.schemaVersion,\n  );\n};\n\n//\n// Annotations\n//\n\nconst annotations_toJsonSchemaFields = (annotations: SchemaAST.Annotations): Record<symbol, any> => {\n  const schemaFields: Record<string, any> = {};\n\n  const echoAnnotations: Types.Mutable<JsonSchemaEchoAnnotations> = {};\n  for (const [key, annotationId] of Object.entries(EchoAnnotations)) {\n    if (annotations[annotationId] != null) {\n      echoAnnotations[key as keyof JsonSchemaEchoAnnotations] = annotations[annotationId] as any;\n    }\n  }\n  if (Object.keys(echoAnnotations).length > 0) {\n    // TODO(dmaretskyi): use new namespace.\n    schemaFields[ECHO_ANNOTATIONS_NS_KEY] = echoAnnotations;\n  }\n\n  const echoIdentifier = annotations[TypeIdentifierAnnotationId];\n  if (echoIdentifier) {\n    schemaFields[ECHO_ANNOTATIONS_NS_KEY] ??= {};\n    schemaFields[ECHO_ANNOTATIONS_NS_KEY].schemaId = echoIdentifier;\n  }\n\n  // Custom (at end).\n  for (const [key, annotationId] of Object.entries(CustomAnnotations)) {\n    const value = annotations[annotationId];\n    if (value != null) {\n      schemaFields[key] = value;\n    }\n  }\n\n  return schemaFields;\n};\n\nconst decodeTypeIdentifierAnnotation = (schema: JsonSchemaType): string | undefined => {\n  // Limit to dxn:echo: URIs.\n  if (schema.$id && schema.$id.startsWith('dxn:echo:')) {\n    return schema.$id;\n  } else if (schema.$id && schema.$id.startsWith('dxn:type:') && schema?.echo?.type?.schemaId) {\n    const id = schema?.echo?.type?.schemaId;\n    if (ObjectId.isValid(id)) {\n      return DXN.fromLocalObjectId(id).toString();\n    }\n  }\n  return undefined;\n};\n\nconst decodeTypeAnnotation = (schema: JsonSchemaType): TypeAnnotation | undefined => {\n  if (schema.typename) {\n    const annotation: Types.Mutable<TypeAnnotation> = {\n      // TODO(dmaretskyi): Decoding default.\n      kind: schema.entityKind ? Schema.decodeSync(EntityKindSchema)(schema.entityKind) : EntityKind.Object,\n      typename: schema.typename,\n      version: schema.version ?? '0.1.0',\n    };\n\n    if (annotation.kind === EntityKind.Relation) {\n      const source = schema.relationSource?.$ref ?? raise(new Error('Relation source not set'));\n      const target = schema.relationTarget?.$ref ?? raise(new Error('Relation target not set'));\n      annotation.sourceSchema = DXN.parse(source).toString();\n      annotation.targetSchema = DXN.parse(target).toString();\n    }\n\n    return annotation;\n  }\n\n  // Decode legacy schema.\n  if (!schema.typename && schema?.echo?.type) {\n    return {\n      kind: EntityKind.Object,\n      typename: schema.echo.type.typename,\n      version: schema.echo.type.version,\n    };\n  }\n\n  return undefined;\n};\n\nconst jsonSchemaFieldsToAnnotations = (schema: JsonSchemaType): SchemaAST.Annotations => {\n  const annotations: Types.Mutable<Schema.Annotations.Schema<any>> = {};\n\n  const echoAnnotations: JsonSchemaEchoAnnotations = getNormalizedEchoAnnotations(schema) ?? {};\n  if (echoAnnotations) {\n    for (const [key, annotationId] of Object.entries(EchoAnnotations)) {\n      if (echoAnnotations[key as keyof JsonSchemaEchoAnnotations]) {\n        annotations[annotationId] = echoAnnotations[key as keyof JsonSchemaEchoAnnotations];\n      }\n    }\n  }\n\n  const typeIdentifier = decodeTypeIdentifierAnnotation(schema);\n  annotations[TypeIdentifierAnnotationId] = typeIdentifier;\n  const typeAnnotation = decodeTypeAnnotation(schema);\n  if (typeAnnotation) {\n    annotations[TypeAnnotationId] = typeAnnotation;\n    annotations[SchemaAST.JSONSchemaAnnotationId] = makeTypeJsonSchemaAnnotation({\n      identifier: typeIdentifier,\n      kind: typeAnnotation.kind,\n      typename: typeAnnotation.typename,\n      version: typeAnnotation.version,\n      relationSource: typeAnnotation.sourceSchema,\n      relationTarget: typeAnnotation.targetSchema,\n    });\n  }\n\n  // Custom (at end).\n  for (const [key, annotationId] of Object.entries({ ...CustomAnnotations, ...DecodedAnnotations })) {\n    if (key in schema) {\n      annotations[annotationId] = (schema as any)[key];\n    }\n  }\n\n  return clearUndefined(annotations);\n};\n\nconst makeAnnotatedRefinement = (ast: SchemaAST.AST, annotations: SchemaAST.Annotations): SchemaAST.Refinement => {\n  return new SchemaAST.Refinement(ast, () => Option.none(), annotations);\n};\n\nconst addJsonSchemaFields = (ast: SchemaAST.AST, schema: JsonSchemaType): SchemaAST.AST =>\n  makeAnnotatedRefinement(ast, { [SchemaAST.JSONSchemaAnnotationId]: schema });\n\n/**\n * Fixes field order.\n * Sets `$schema` prop.\n */\nconst normalizeJsonSchema = (jsonSchema: Types.DeepMutable<JsonSchemaType>): Types.DeepMutable<JsonSchemaType> => {\n  if (jsonSchema.properties && 'id' in jsonSchema.properties) {\n    jsonSchema.properties = orderKeys(jsonSchema.properties, ['id']); // Put id first.\n  }\n\n  // TODO(dmaretskyi): Makes sure undefined is not left on optional fields for the resulting object.\n  jsonSchema.$schema = JSON_SCHEMA_URL;\n  jsonSchema = orderKeys(jsonSchema, [\n    '$schema',\n    '$id',\n\n    'entityKind',\n    'typename',\n    'version',\n    'relationTarget',\n    'relationSource',\n\n    'type',\n    'enum',\n\n    'properties',\n    'required',\n    'propertyOrder', // Custom.\n    'items',\n    'additionalProperties',\n\n    'anyOf',\n    'oneOf',\n  ]);\n  return jsonSchema;\n};\n"],
+  "mappings": "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",
+  "names": ["SchemaAST", "CustomAnnotations", "format", "FormatAnnotationId", "currency", "CurrencyAnnotationId", "DecodedAnnotations", "title", "TitleAnnotationId", "description", "DescriptionAnnotationId", "EchoAnnotations", "meta", "PropertyMetaAnnotationId", "generator", "GeneratorAnnotationId", "labelProp", "LabelAnnotationId", "Schema", "JsonPath", "SimpleTypes", "Literal", "NonNegativeInteger", "Number", "pipe", "greaterThanOrEqualTo", "StringArray", "Array", "String", "JsonSchemaOrBoolean", "Union", "suspend", "JsonSchemaType", "Boolean", "JsonSchemaEchoAnnotations", "Struct", "labelProp", "optional", "JsonPath", "generator", "Tuple", "meta", "Record", "key", "value", "Any", "type", "typename", "version", "schemaId", "annotations", "_JsonSchemaType", "$id", "$schema", "$ref", "$comment", "entityKind", "EntityKindSchema", "relationTarget", "relationSource", "title", "description", "readOnly", "writeOnly", "examples", "default", "const", "enum", "multipleOf", "greaterThan", "maximum", "exclusiveMaximum", "minimum", "exclusiveMinimum", "maxLength", "pattern", "FormatAnnotation", "set", "TypeFormat", "Regex", "format", "minLength", "items", "additionalItems", "maxItems", "minItems", "uniqueItems", "contains", "maxProperties", "minProperties", "required", "propertyOrder", "additionalProperties", "properties", "patternProperties", "propertyNames", "definitions", "dependencies", "identifier", "contentMediaType", "contentEncoding", "if", "then", "else", "allOf", "anyOf", "oneOf", "not", "$defs", "currency", "reference", "schema", "schemaVersion", "schemaObject", "echo", "JsonSchemaFields", "Object", "keys", "fields", "getSchemaProperty", "property", "setSchemaProperty", "ECHO_ANNOTATIONS_NS_DEPRECATED_KEY", "ECHO_ANNOTATIONS_NS_KEY", "getNormalizedEchoAnnotations", "obj", "normalizeEchoAnnotations", "undefined", "res", "Array", "Function", "JSONSchema", "Option", "Schema", "SchemaAST", "raise", "mapAst", "assertArgument", "invariant", "DXN", "ObjectId", "log", "clearUndefined", "orderKeys", "removeProperties", "PropType", "toPropType", "type", "Error", "JSON_SCHEMA_URL", "toJsonSchema", "schema", "options", "assertArgument", "isSchema", "jsonSchema", "_toJsonSchemaAST", "ast", "strict", "removeProperties", "key", "value", "withRefinements", "withEchoRefinements", "fromAST", "definitions", "normalizeJsonSchema", "path", "suspendCache", "Map", "set", "recursiveResult", "isSuspend", "suspendedAst", "f", "cachedPath", "get", "Suspend", "JSONSchemaAnnotationId", "$ref", "isTypeLiteral", "mapAst", "undefined", "addJsonSchemaFields", "propertyOrder", "propertySignatures", "map", "p", "name", "isUndefinedKeyword", "annotationFields", "annotations_toJsonSchemaFields", "annotations", "Object", "keys", "length", "toEffectSchema", "root", "_defs", "defs", "$defs", "objectToEffectSchema", "result", "Unknown", "refToEffectSchema", "$id", "anyToEffectSchema", "Union", "enum", "e", "Literal", "oneOf", "v", "anyOf", "allOf", "log", "warn", "String", "pattern", "pipe", "RegExp", "Number", "int", "Boolean", "isArray", "items", "required", "optional", "splitAt", "minItems", "Tuple", "optionalElement", "invariant", "Array", "Null", "refSegments", "split", "identifier", "jsonSchemaFieldsToAnnotations", "echoRefinement", "ECHO_ANNOTATIONS_NS_DEPRECATED_KEY", "isEchoObject", "startsWith", "fields", "propertyList", "entries", "properties", "immutableIdField", "includes", "orderKeys", "patternProperties", "Record", "additionalProperties", "Struct", "indexValue", "extend", "id", "reference", "echoId", "createEchoReferenceSchema", "typename", "version", "Any", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "targetSchemaDXN", "DXN", "parse", "kind", "TYPE", "toString", "parts", "schemaVersion", "schemaFields", "echoAnnotations", "annotationId", "EchoAnnotations", "ECHO_ANNOTATIONS_NS_KEY", "echoIdentifier", "TypeIdentifierAnnotationId", "schemaId", "CustomAnnotations", "decodeTypeIdentifierAnnotation", "echo", "ObjectId", "isValid", "fromLocalObjectId", "decodeTypeAnnotation", "annotation", "entityKind", "decodeSync", "EntityKindSchema", "EntityKind", "Relation", "source", "relationSource", "raise", "target", "relationTarget", "sourceSchema", "targetSchema", "getNormalizedEchoAnnotations", "typeIdentifier", "typeAnnotation", "TypeAnnotationId", "makeTypeJsonSchemaAnnotation", "DecodedAnnotations", "clearUndefined", "makeAnnotatedRefinement", "Refinement", "none", "$schema"]
+}

package/dist/lib/neutral/{chunk-ZWKJ4LZJ.mjs → chunk-CIRHIEMW.mjs}

@@ -1,10 +1,10 @@
 import {
   Unknown
-} from "./chunk-KGV3QIRX.mjs";
+} from "./chunk-NQRLRYJM.mjs";
 import {
   KindId,
   SnapshotKindId
-} from "./chunk-W7OP5HGZ.mjs";
+} from "./chunk-UFDK26FO.mjs";
 import {
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
@@ -20,9 +20,7 @@ import {
   deleteKeys,
   getDXN,
   getDatabase,
-  getDescription,
   getKeys,
-  getLabel,
   getMetaChecked,
   getObjectDXN,
   getSnapshot,
@@ -32,26 +30,28 @@ import {
   makeObject,
   objectToJSON,
   removeTag,
-  setDescription,
-  setLabel,
   setValue,
   sort,
   sortByLabel,
   sortByTypename,
   subscribe,
   version
-} from "./chunk-PP4DNUZU.mjs";
+} from "./chunk-TQQZLKB7.mjs";
 import {
   ParentId,
+  getDescription,
+  getLabel,
   getSchema,
   getTypeAnnotation,
   getTypeDXN,
-  getTypename
-} from "./chunk-F7KMHDPJ.mjs";
+  getTypename,
+  setDescription,
+  setLabel
+} from "./chunk-SEMVAGBM.mjs";
 import {
   EntityKind,
   SchemaKindId
-} from "./chunk-4KG6IGL4.mjs";
+} from "./chunk-WYOKA6AE.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -116,7 +116,7 @@ var Unknown3 = Schema.Struct({
   // NOTE: The EchoRelationSchema annotation is required for Ref.Ref(Relation.Unknown) to work.
   //   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.
   EchoRelationSchema({
-    typename: "dxos.org/schema/AnyRelation",
+    typename: "org.dxos.schema.any-relation",
     version: "0.0.0",
     source: Unknown,
     target: Unknown
@@ -163,7 +163,7 @@ var getSourceDXN = (value) => {
   const dxn = value[RelationSourceDXNId];
   invariant(dxn instanceof DXN, void 0, {
     F: __dxlog_file,
-    L: 211,
+    L: 214,
     S: void 0,
     A: [
       "dxn instanceof DXN",
@@ -178,7 +178,7 @@ var getTargetDXN = (value) => {
   const dxn = value[RelationTargetDXNId];
   invariant(dxn instanceof DXN, void 0, {
     F: __dxlog_file,
-    L: 224,
+    L: 227,
     S: void 0,
     A: [
       "dxn instanceof DXN",
@@ -193,7 +193,7 @@ var getSource = (relation) => {
   const obj = relation[RelationSourceId];
   invariant(obj !== void 0, `Invalid source: ${relation.id}`, {
     F: __dxlog_file,
-    L: 237,
+    L: 240,
     S: void 0,
     A: [
       "obj !== undefined",
@@ -208,7 +208,7 @@ var getTarget = (relation) => {
   const obj = relation[RelationTargetId];
   invariant(obj !== void 0, `Invalid target: ${relation.id}`, {
     F: __dxlog_file,
-    L: 250,
+    L: 253,
     S: void 0,
     A: [
       "obj !== undefined",
@@ -295,4 +295,4 @@ export {
   version2 as version,
   Relation_exports
 };
-//# sourceMappingURL=chunk-ZWKJ4LZJ.mjs.map
+//# sourceMappingURL=chunk-CIRHIEMW.mjs.map

package/dist/lib/neutral/chunk-CIRHIEMW.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Relation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, type ObjectId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as entityInternal from './internal/Entity';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Type from './Type';\n\nexport type Endpoints<Source, Target> = {\n  [Source]: Source;\n  [Target]: Target;\n};\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends internal.AnyEntity, Endpoints<Source, Target>, Entity.OfKind<internal.EntityKind.Relation> {}\n\n/**\n * Relation with no known properties beyond id, kind, source, and target.\n * Use this when the relation's schema/properties are not known.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO relation, use `Relation.isRelation`.\n */\nexport interface Unknown extends BaseRelation<Obj.Unknown, Obj.Unknown> {}\n\n/**\n * Runtime Effect schema for any ECHO relation.\n * Use for validation, parsing, or as a reference target for collections.\n * A relation has `id`, source, and target fields plus any additional properties.\n *\n * NOTE: `Schema.is(Type.Relation)` does STRUCTURAL validation only (checks for `id` field).\n * Use `Relation.isRelation()` for proper ECHO instance type guards that check the KindId brand.\n *\n * @example\n * ```ts\n * // Structural type guard (accepts any object with id field)\n * if (Schema.is(Type.Relation)(unknownValue)) { ... }\n *\n * // ECHO instance type guard (checks KindId brand)\n * if (Relation.isRelation(unknownValue)) { ... }\n * ```\n */\n// TODO(dmaretskyi): Change ObjModule.Any to ObjModule.Unknown to have stricter types.\nexport const Unknown: Type.Relation<Unknown, Obj.Any, Obj.Any> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  // TODO(dmaretskyi): Clean this up.\n  // NOTE: The EchoRelationSchema annotation is required for Ref.Ref(Relation.Unknown) to work.\n  //   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.\n  internal.EchoRelationSchema({\n    typename: 'org.dxos.schema.any-relation',\n    version: '0.0.0',\n    source: Obj.Unknown,\n    target: Obj.Unknown,\n  }),\n  (schema) =>\n    Object.assign(schema, {\n      [internal.SchemaKindId]: (schema as any)[internal.SchemaKindId],\n    }) as unknown as Type.Relation<Unknown, Obj.Any, Obj.Any>,\n);\n\n/**\n * Relation type with specific source and target types.\n */\nexport type OfShape<Source extends Obj.Unknown, Target extends Obj.Unknown, Props> = BaseRelation<Source, Target> &\n  Props;\n\n/**\n * Base type for snapshot relations (has SnapshotKindId instead of KindId).\n */\ninterface BaseRelationSnapshot<Source, Target> extends internal.AnyEntity, Endpoints<Source, Target> {\n  readonly [Entity.SnapshotKindId]: internal.EntityKind.Relation;\n  readonly id: ObjectId;\n}\n\n/**\n * JSON-encoded properties for relations.\n */\nexport interface BaseRelationJson {\n  id: string;\n  [internal.ATTR_RELATION_SOURCE]: string;\n  [internal.ATTR_RELATION_TARGET]: string;\n}\n\n/**\n * Immutable snapshot of an ECHO relation.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> &\n  BaseRelationSnapshot<Obj.Unknown, Obj.Unknown>;\n\nexport const Source: unique symbol = entityInternal.RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = entityInternal.RelationTargetId as any;\nexport type Target = typeof Target;\n\n/**\n * Get relation source type.\n */\nexport type SourceOf<A> = A extends Endpoints<infer S, infer _T> ? S : never;\n\n/**\n * Get relation target type.\n */\nexport type TargetOf<A> = A extends Endpoints<infer _S, infer T> ? T : never;\n\n/**\n * Internal props type for relation instance creation.\n */\ntype MakePropsInternal<T extends Unknown> = {\n  id?: ObjectId;\n  [Meta]?: internal.ObjectMeta;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Entity.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema.\n * Takes a schema type (created with Type.Relation) and extracts the props type.\n */\nexport type MakeProps<S extends Type.AnyRelation> = MakePropsInternal<Schema.Schema.Type<S>>;\n\n/**\n * Creates new relation.\n * @param schema - Relation schema.\n * @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.\n * @param meta - Relation metadata. (deprecated; use [Obj.Meta] instead)\n * @returns\n */\n// NOTE: Writing the definition this way (with generic over schema) makes typescript perfer to infer the type from the first param (this schema) rather than the second param (the props).\n// TODO(dmaretskyi): Move meta into props.\nexport const make = <S extends Type.AnyRelation>(\n  schema: S,\n  props: NoInfer<MakeProps<S>>,\n): Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation> => {\n  assertArgument(\n    internal.getTypeAnnotation(schema)?.kind === internal.EntityKind.Relation,\n    'schema',\n    'Expected a relation schema',\n  );\n  assertArgument(props[internal.ParentId] === undefined, 'props', 'Parent is not allowed for relations');\n\n  let meta: internal.ObjectMeta | undefined = undefined;\n\n  if (props[internal.MetaId] != null) {\n    meta = props[internal.MetaId] as any;\n    delete props[internal.MetaId];\n  }\n\n  const sourceDXN = internal.getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = internal.getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[internal.RelationSourceDXNId] = sourceDXN;\n  (props as any)[internal.RelationTargetDXNId] = targetDXN;\n\n  return internal.makeObject<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (internal.ATTR_RELATION_SOURCE in value || internal.ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  // Check for reactive relation (KindId) or snapshot (SnapshotKindId).\n  const kind = (value as any)[Entity.KindId] ?? (value as any)[Entity.SnapshotKindId];\n  return kind === internal.EntityKind.Relation;\n};\n\nexport const isSnapshot = (value: unknown): value is Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[Entity.SnapshotKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * @returns Relation source DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const dxn = (value as internal.InternalObjectProps)[internal.RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const dxn = (value as internal.InternalObjectProps)[internal.RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): SourceOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationSourceId];\n  invariant(obj !== undefined, `Invalid source: ${relation.id}`);\n  return obj as SourceOf<T>;\n};\n\n/**\n * @returns Relation target.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Unknown | Snapshot>(relation: T): TargetOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationTargetId];\n  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\n  return obj as TargetOf<T>;\n};\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of a relation within `Relation.change`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an echo relation within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Relation.change` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.change` for objects.\n * @param callback - The callback that performs mutations on the relation.\n *\n * @example\n * ```ts\n * const worksFor = Relation.make(EmployedBy, {\n *   [Relation.Source]: person,\n *   [Relation.Target]: company,\n *   role: 'Engineer',\n * });\n *\n * // Mutate within Relation.change\n * Relation.change(worksFor, (r) => {\n *   r.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.change` for objects.\n */\nexport const change = <T extends Unknown>(relation: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(relation, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of a relation.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive relation at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(rel: T) => Snapshot<T> = internal.getSnapshot as any;\n\n//\n// Subscribe\n//\n\n/**\n * Subscribe to relation updates.\n * The callback is called synchronously when the relation is modified.\n * Only accepts reactive relations (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (rel: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(rel, callback);\n};\n\n//\n// Property Access\n//\n\n/**\n * Get a deeply nested property from a relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getValue = (rel: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return internal.getValue(rel, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on a relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setValue: (rel: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  internal.setValue as any;\n\n//\n// Type\n//\n\n/**\n * Get the DXN of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => internal.getDXN(entity);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeDXN = internal.getTypeDXN;\n\n/**\n * Get the schema of the relation.\n * Returns the branded ECHO schema used to create the relation.\n */\nexport const getSchema: (rel: unknown | undefined) => Type.AnyEntity | undefined = internal.getSchema as any;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the relation belongs to.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): Database.Database | undefined => internal.getDatabase(entity);\n\n//\n// Meta\n//\n\n/**\n * Property that accesses metadata for an entity.\n *\n * Alias for `Entity.Meta`.\n */\nexport const Meta = internal.MetaId;\n\n/**\n * Deeply read-only version of ObjectMeta.\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.change` callback.\n */\nexport type Meta = internal.Meta;\n\n/**\n * Get the metadata for a relation.\n * Returns mutable meta when passed a mutable relation (inside `Relation.change` callback).\n * Returns read-only meta when passed a regular relation or snapshot.\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * @returns Foreign keys for the relation from the specified source.\n * Accepts both reactive relations and snapshots.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Delete all keys from the relation for the specified source.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => internal.deleteKeys(entity, source);\n\n/**\n * Add a tag to the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => internal.removeTag(entity, tag);\n\n/**\n * Check if the relation is deleted.\n * Accepts both reactive relations and snapshots.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);\n\n/**\n * Get the description of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Set the description of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  internal.setDescription(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of a relation.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Converts relation to its JSON representation.\n * Accepts both reactive relations and snapshots.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n//\n// Sorting\n//\n\n/**\n * Comparator function type for sorting relations.\n * Accepts both reactive relations and snapshots.\n */\nexport type Comparator = internal.Comparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = internal.sortByLabel as Comparator;\nexport const sortByTypename: Comparator = internal.sortByTypename as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => internal.sort(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport const VersionTypeId = internal.VersionTypeId;\nexport const isVersion = internal.isVersion;\n\n/**\n * Represent relation version.\n */\nexport type Version = internal.EntityVersion;\n\n/**\n * Returns the version of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => internal.version(entity);\n"],
+  "mappings": "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",
+  "names": ["Unknown", "VersionTypeId", "addTag", "change", "deleteKeys", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "createJsonPath", "assertArgument", "invariant", "DXN", "assumeType", "Unknown", "Struct", "id", "String", "pipe", "extend", "Record", "key", "value", "EchoRelationSchema", "typename", "version", "source", "target", "schema", "Object", "assign", "SchemaKindId", "Source", "RelationSourceId", "Target", "RelationTargetId", "make", "props", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "Relation", "ParentId", "undefined", "meta", "MetaId", "sourceDXN", "getObjectDXN", "raise", "Error", "targetDXN", "RelationSourceDXNId", "RelationTargetDXNId", "makeObject", "isRelation", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "KindId", "SnapshotKindId", "isSnapshot", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "getTarget", "change", "callback", "internal", "getSnapshot", "subscribe", "rel", "getValue", "path", "createJsonPath", "setValue", "getDXN", "entity", "getTypeDXN", "getSchema", "getTypename", "getDatabase", "Meta", "getMeta", "getMetaChecked", "getKeys", "deleteKeys", "addTag", "tag", "removeTag", "isDeleted", "getLabel", "setLabel", "label", "getDescription", "setDescription", "description", "toJSON", "objectToJSON", "sortByLabel", "sortByTypename", "sort", "comparators", "VersionTypeId", "isVersion"]
+}

package/dist/lib/neutral/{chunk-GFNCSK7F.mjs → chunk-DYDJBZEG.mjs}

@@ -1,13 +1,14 @@
 import {
   object
-} from "./chunk-T4MPQJ7X.mjs";
+} from "./chunk-RMLF7JOZ.mjs";
 import {
   getKeys,
   make
-} from "./chunk-KGV3QIRX.mjs";
+} from "./chunk-NQRLRYJM.mjs";
 import {
-  FormInputAnnotation
-} from "./chunk-F7KMHDPJ.mjs";
+  FormInputAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-SEMVAGBM.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -41,11 +42,11 @@ var Feed = Schema.Struct({
   /** Identifier for the feed's kind (e.g., plugin id). */
   kind: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional)
 }).pipe(object({
-  typename: "dxos.org/type/Feed",
+  typename: "org.dxos.type.feed",
   version: "0.1.0"
-}));
-var DXN_KEY = "dxos.org/key/feed";
-var make2 = (props) => make(Feed, props);
+}), SystemTypeAnnotation.set(true));
+var DXN_KEY = "org.dxos.key.feed";
+var make2 = (props = {}) => make(Feed, props);
 var getQueueDxn = (feed) => {
   const keys = getKeys(feed, DXN_KEY);
   return keys.length === 0 ? void 0 : DXN.parse(keys[0].id);
@@ -98,4 +99,4 @@ export {
   setRetention,
   Feed_exports
 };
-//# sourceMappingURL=chunk-GFNCSK7F.mjs.map
+//# sourceMappingURL=chunk-DYDJBZEG.mjs.map

package/dist/lib/neutral/chunk-DYDJBZEG.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Feed.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport type * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\n\nimport { DXN } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport type * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport * as Type from './Type';\n\n/**\n * Runtime schema for a Feed object.\n *\n * @example\n * ```ts\n * const feed = Obj.make(Feed.Feed, { name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });\n * ```\n */\nexport const Feed = Schema.Struct({\n  /** User-facing display name. */\n  name: Schema.String.pipe(Schema.optional),\n  /** Identifier for the feed's kind (e.g., plugin id). */\n  kind: Schema.String.pipe(internal.FormInputAnnotation.set(false), Schema.optional),\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.feed',\n    version: '0.1.0',\n  }),\n  internal.SystemTypeAnnotation.set(true),\n);\n\n/**\n * TypeScript instance type for a Feed object.\n */\nexport interface Feed extends Schema.Schema.Type<typeof Feed> {}\n\n//\n// Types\n//\n\n/**\n * Meta key source for storing the backing DXN bound to a feed object.\n */\n// TODO(dmaretskyi): Enforce that Feed ObjectId = feed storage ID. And remove this key.\nexport const DXN_KEY = 'org.dxos.key.feed';\n\n/**\n * Opaque cursor for iterating over feed items.\n */\n// TODO(dmaretskyi): T needs to be referenced in the type structure for typescript to respect it during inference and type-checking.\nexport interface Cursor<T = Obj.Snapshot> {\n  readonly _tag: 'Cursor';\n}\n\n/**\n * Retention options for a feed.\n */\nexport interface RetentionOptions {\n  /** Retain items after this cursor position. */\n  // TODO(wittjosiah): Use FeedCursor from @dxos/feed?\n  cursor?: string;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates a new feed object.\n *\n * @example\n * ```ts\n * const feed = Feed.make({ name: 'notifications', kind: 'org.dxos.plugin.notifications.v1' });\n * ```\n */\n// TODO(wittjosiah): How to control the feed namespace (data/trace)? Why do feeds have namespaces?\nexport const make = (props: Obj.MakeProps<typeof Feed> = {}): Feed => Obj.make(Feed, props);\n\n/**\n * Reads the queue DXN from feed metadata.\n *\n * @deprecated\n */\n// TODO(wittjosiah): Align backing feed dxn's with object DXN.\nexport const getQueueDxn = (feed: Feed): DXN | undefined => {\n  const keys = Obj.getKeys(feed, DXN_KEY);\n  return keys.length === 0 ? undefined : DXN.parse(keys[0].id);\n};\n\n//\n// Service\n//\n\n/**\n * Effect service for feed operations.\n * Provides the bridge to the underlying storage implementation.\n * Must be provided by the application layer (e.g., echo-db).\n */\nexport class Service extends Context.Tag('@dxos/echo/Feed/Service')<\n  Service,\n  {\n    /**\n     * Appends items to a feed.\n     */\n    append(feed: Feed, items: Entity.Unknown[]): Promise<void>;\n\n    /**\n     * Removes items from a feed by ID.\n     */\n    // TODO(dmaretskyi): Change type to ObjectId.\n    remove(feed: Feed, ids: string[]): Promise<void>;\n\n    /**\n     * Queries items in a feed.\n     */\n    query: {\n      <Q extends Query.Any>(feed: Feed, query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n      <F extends Filter.Any>(feed: Feed, filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n    };\n  }\n>() {}\n\n/**\n * Layer that provides a Feed service that throws when accessed.\n * Useful as a default layer when no feed service is available.\n */\nexport const notAvailable: Layer.Layer<Service> = Layer.succeed(Service, {\n  append: () => {\n    throw new Error('Feed.Service not available');\n  },\n  remove: () => {\n    throw new Error('Feed.Service not available');\n  },\n  query: () => {\n    throw new Error('Feed.Service not available');\n  },\n} as Context.Tag.Service<Service>);\n\n//\n// Operations\n//\n\n/**\n * Appends items to a feed.\n *\n * @example\n * ```ts\n * yield* Feed.append(feed, [Obj.make(Notification, { title: 'Hello' })]);\n * ```\n */\nexport const append = (feed: Feed, items: Entity.Unknown[]): Effect.Effect<void, never, Service> =>\n  Effect.gen(function* () {\n    const service = yield* Service;\n    yield* Effect.promise(() => service.append(feed, items));\n  });\n\n/**\n * Removes items from a feed.\n *\n * @example\n * ```ts\n * yield* Feed.remove(feed, [item]);\n * ```\n */\n// TODO(dmaretskyi): Should we allow snapshots here? - what does it mean to remove a snapshot?\nexport const remove = (feed: Feed, items: (Entity.Unknown | Obj.Snapshot)[]): Effect.Effect<void, never, Service> =>\n  Effect.gen(function* () {\n    const service = yield* Service;\n    const ids = items.map((item) => item.id);\n    yield* Effect.promise(() => service.remove(feed, ids));\n  });\n\n/**\n * Creates a reactive query over items in a feed.\n *\n * @example\n * ```ts\n * const result = yield* Feed.query(feed, Filter.type(Person));\n * ```\n */\n// TODO(dmaretskyi): Suport chained queries:\n//                   const result = yield* feed.pipe(Feed.query(Filter.type(Person))); result.subscribe(...)\n//                   const objects = yield* feed.pipe(Feed.query(Filter.type(Person))).run;\n//                   const object = yield* feed.pipe(Feed.query(Filter.type(Person))).first;\n// ... unify for Database and schema queries.\nexport const query: {\n  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, Service>;\n} = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>\n  Service.pipe(Effect.map((service) => service.query(feed, queryOrFilter as any) as QueryResult.QueryResult<any>));\n\n/**\n * Executes a feed query once and returns the results.\n *\n * @example\n * ```ts\n * const items = yield* Feed.runQuery(feed, Filter.type(Person));\n * ```\n */\nexport const runQuery: {\n  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n} = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>\n  query(feed, queryOrFilter as any).pipe(Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())));\n\n/**\n * Creates a cursor for iterating over feed items.\n * Currently stubbed — cursor operations are not yet implemented.\n *\n * @example\n * ```ts\n * const cursor = yield* Feed.cursor<Person>(feed);\n * const item = yield* Feed.next(cursor);\n * ```\n */\n// TODO(wittjosiah): Implement cursor operations. Use Effect streams?\nexport const cursor = <T = Obj.Snapshot>(_feed: Feed): Effect.Effect<Cursor<T>, never, Service> =>\n  Effect.succeed({ _tag: 'Cursor' } as Cursor<T>);\n\n/**\n * Returns the next item from a feed cursor.\n * Currently stubbed — cursor operations are not yet implemented.\n */\nexport const next = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<T, never, Service> =>\n  Effect.die('Feed.next is not yet implemented');\n\n/**\n * Returns the next item from a feed cursor as an Option.\n * Currently stubbed — cursor operations are not yet implemented.\n */\nexport const nextOption = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<Option.Option<T>, never, Service> =>\n  Effect.die('Feed.nextOption is not yet implemented');\n\n/**\n * Sets the local retention policy for a feed.\n * Currently stubbed — queues do not yet support retention.\n *\n * @example\n * ```ts\n * yield* Feed.setRetention(feed, { count: 1000 });\n * ```\n */\n// TODO(feed): Implement when queue retention is supported.\nexport const setRetention = (_feed: Feed, _options: RetentionOptions): Effect.Effect<void, never, Service> =>\n  Effect.void;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAAA;;;;;;;;cAAAA;EAAA;;;;;;;;AAMA,YAAYC,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AAEvB,YAAYC,YAAY;AAExB,SAASC,WAAW;AAkBb,IAAMC,OAAcC,cAAO;;EAEhCC,MAAaC,cAAOC,KAAYC,eAAQ;;EAExCC,MAAaH,cAAOC,KAAcG,oBAAoBC,IAAI,KAAA,GAAeH,eAAQ;AACnF,CAAA,EAAGD,KACIK,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACSC,qBAAqBJ,IAAI,IAAA,CAAA;AAgB7B,IAAMK,UAAU;AAgChB,IAAMC,QAAO,CAACC,QAAoC,CAAC,MAAgBD,KAAKd,MAAMe,KAAAA;AAQ9E,IAAMC,cAAc,CAACC,SAAAA;AAC1B,QAAMC,OAAWC,QAAQF,MAAMJ,OAAAA;AAC/B,SAAOK,KAAKE,WAAW,IAAIC,SAAYC,IAAIC,MAAML,KAAK,CAAA,EAAGM,EAAE;AAC7D;AAWO,IAAMC,UAAN,cAA8BC,YAAI,yBAAA,EAAA,EAAA;AAsBpC;AAME,IAAMC,eAA2CC,cAAQH,SAAS;EACvEI,QAAQ,MAAA;AACN,UAAM,IAAIC,MAAM,4BAAA;EAClB;EACAC,QAAQ,MAAA;AACN,UAAM,IAAID,MAAM,4BAAA;EAClB;EACAE,OAAO,MAAA;AACL,UAAM,IAAIF,MAAM,4BAAA;EAClB;AACF,CAAA;AAcO,IAAMD,SAAS,CAACZ,MAAYgB,UAC1BC,WAAI,aAAA;AACT,QAAMC,UAAU,OAAOV;AACvB,SAAcW,eAAQ,MAAMD,QAAQN,OAAOZ,MAAMgB,KAAAA,CAAAA;AACnD,CAAA;AAWK,IAAMF,SAAS,CAACd,MAAYgB,UAC1BC,WAAI,aAAA;AACT,QAAMC,UAAU,OAAOV;AACvB,QAAMY,MAAMJ,MAAMK,IAAI,CAACC,SAASA,KAAKf,EAAE;AACvC,SAAcY,eAAQ,MAAMD,QAAQJ,OAAOd,MAAMoB,GAAAA,CAAAA;AACnD,CAAA;AAeK,IAAML,QAGT,CAACf,MAAYuB,kBACff,QAAQrB,KAAYkC,WAAI,CAACH,YAAYA,QAAQH,MAAMf,MAAMuB,aAAAA,CAAAA,CAAAA;AAUpD,IAAMC,WAGT,CAACxB,MAAYuB,kBACfR,MAAMf,MAAMuB,aAAAA,EAAsBpC,KAAYsC,eAAQ,CAACC,gBAAuBP,eAAQ,MAAMO,YAAYC,IAAG,CAAA,CAAA,CAAA;AAatG,IAAMC,SAAS,CAAmBC,UAChClB,eAAQ;EAAEmB,MAAM;AAAS,CAAA;AAM3B,IAAMC,OAAO,CAAmBC,YAC9BC,WAAI,kCAAA;AAMN,IAAMC,aAAa,CAAmBF,YACpCC,WAAI,wCAAA;AAYN,IAAME,eAAe,CAACN,OAAaO,aACjCC;",
+  "names": ["make", "Context", "Effect", "Layer", "Schema", "DXN", "Feed", "Struct", "name", "String", "pipe", "optional", "kind", "FormInputAnnotation", "set", "object", "typename", "version", "SystemTypeAnnotation", "DXN_KEY", "make", "props", "getQueueDxn", "feed", "keys", "getKeys", "length", "undefined", "DXN", "parse", "id", "Service", "Tag", "notAvailable", "succeed", "append", "Error", "remove", "query", "items", "gen", "service", "promise", "ids", "map", "item", "queryOrFilter", "runQuery", "flatMap", "queryResult", "run", "cursor", "_feed", "_tag", "next", "_cursor", "die", "nextOption", "setRetention", "_options", "void"]
+}

package/dist/lib/neutral/{chunk-QXF3LGN2.mjs → chunk-FXEG7EOK.mjs}

@@ -1,8 +1,10 @@
+import {
+  RefArray
+} from "./chunk-YWXWXIE5.mjs";
 import {
   Ref,
-  RefArray,
   getSchemaReference
-} from "./chunk-PP4DNUZU.mjs";
+} from "./chunk-43Y5DOS6.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -40,4 +42,4 @@ export {
   isRefType,
   Ref_exports
 };
-//# sourceMappingURL=chunk-QXF3LGN2.mjs.map
+//# sourceMappingURL=chunk-FXEG7EOK.mjs.map

package/dist/lib/neutral/chunk-FXEG7EOK.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Ref.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport type * as Entity from './Entity';\nimport * as refInternal from './internal/Ref';\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Obj from './Obj';\n\n/**\n * Instance type for a reference.\n *\n * Reference can point to any object or relation.\n * References are lazy loaded.\n *\n * `ref.dxn` is the DXN of the referenced object.\n *\n * @example\n * ```ts\n * const taskRef: Ref<Task> = Ref.make(task);\n *\n * await taskRef.load(); // Returns Promise<Task>\n * yield* Database.load(taskRef); // Effectful version.\n *\n * database.makeRef(dxn); // Create a ref from a DXN.\n * ```\n */\nexport type Ref<T> = refInternal.Ref<T>;\nexport type Unknown = refInternal.Ref<Obj.Unknown>;\n\n/**\n * Factory function to create a Ref schema for the given target schema.\n * Use this in schema definitions to declare reference fields.\n *\n * @example\n * ```ts\n * const Task = Schema.Struct({\n *   assignee: Ref.Ref(Person),  // Creates a Ref schema\n * }).pipe(Type.object({ typename: 'Task', version: '0.1.0' }));\n * ```\n */\nexport const Ref: <S extends Schema.Schema.Any>(schema: S) => RefSchema<Schema.Schema.Type<S>> = refInternal.Ref;\n\nexport const Array = refInternal.RefArray;\n\n/**\n * TypeScript type for a Ref schema.\n * This is the type of the SCHEMA itself, not the runtime ref instance.\n * For the instance type, use `Ref.Ref<T>` from the Ref module.\n *\n * @example\n * ```ts\n * // Schema type annotation (rarely needed, usually inferred):\n * const refSchema: Ref.RefSchema<typeof Task> = Ref.Ref(Task);\n *\n * // Instance type annotation (use Ref.Ref instead):\n * const refInstance: Ref.Ref<Task> = Ref.make(task);\n * ```\n */\n// TODO(dmaretskyi): Investigate if we can remove this type.\n//                   Post DX-836 it will become just `Schema.Schema<Ref.Ref<T>>`.\n//                   NOTE: This could be Type.Ref<T> instead, but since it going to be removed, it's better to keep it here, self-contained.\nexport interface RefSchema<T extends Entity.Unknown> extends refInternal.RefSchema<T> {}\n\n/**\n * Extract reference target.\n */\nexport type Target<R extends Unknown> = R extends refInternal.Ref<infer T> ? T : never;\n\n/**\n * Reference resolver.\n */\nexport type Resolver = refInternal.RefResolver;\n\nexport const isRef: (value: unknown) => value is Unknown = refInternal.Ref.isRef;\n\nexport const make = refInternal.Ref.make;\n\n// TODO(dmaretskyi): Consider just allowing `make` to accept DXN.\nexport const fromDXN = refInternal.Ref.fromDXN;\n\n// TODO(wittjosiah): Factor out?\nexport const isRefType = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation<JsonSchema.JsonSchema>(ast, SchemaAST.JSONSchemaAnnotationId).pipe(\n    Option.flatMap((jsonSchema) => ('$id' in jsonSchema ? Option.some(jsonSchema) : Option.none())),\n    Option.flatMap((jsonSchema) => {\n      const { typename } = refInternal.getSchemaReference(jsonSchema) ?? {};\n      return typename ? Option.some(true) : Option.some(false);\n    }),\n    Option.getOrElse(() => false),\n  );\n};\n"],
+  "mappings": ";;;;;;;;;;;;AAAA;;;aAAAA;EAAA;;;;;AAMA,YAAYC,YAAY;AAExB,YAAYC,eAAe;AAuCpB,IAAMC,OAAgGA;AAEtG,IAAMC,QAAoBC;AA+B1B,IAAMC,QAA0DH,IAAIG;AAEpE,IAAMC,OAAmBJ,IAAII;AAG7B,IAAMC,UAAsBL,IAAIK;AAGhC,IAAMC,YAAY,CAACC,QAAAA;AACxB,SAAiBC,wBAAqCD,KAAeE,gCAAsB,EAAEC,KACpFC,eAAQ,CAACC,eAAgB,SAASA,aAAoBC,YAAKD,UAAAA,IAAqBE,YAAI,CAAA,GACpFH,eAAQ,CAACC,eAAAA;AACd,UAAM,EAAEG,SAAQ,IAAiBC,mBAAmBJ,UAAAA,KAAe,CAAC;AACpE,WAAOG,WAAkBF,YAAK,IAAA,IAAeA,YAAK,KAAA;EACpD,CAAA,GACOI,iBAAU,MAAM,KAAA,CAAA;AAE3B;",
+  "names": ["Ref", "Option", "SchemaAST", "Ref", "Array", "RefArray", "isRef", "make", "fromDXN", "isRefType", "ast", "getAnnotation", "JSONSchemaAnnotationId", "pipe", "flatMap", "jsonSchema", "some", "none", "typename", "getSchemaReference", "getOrElse"]
+}

package/dist/lib/neutral/{chunk-DZQSL6RW.mjs → chunk-FZO7LQO7.mjs}

@@ -28,7 +28,7 @@ import {
   getOptionsAnnotation,
   getTypeEnum,
   typeToFormat
-} from "./chunk-M2KVTHZM.mjs";
+} from "./chunk-B5OXLWZL.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -70,4 +70,4 @@ __export(Format_exports, {
 export {
   Format_exports
 };
-//# sourceMappingURL=chunk-DZQSL6RW.mjs.map
+//# sourceMappingURL=chunk-FZO7LQO7.mjs.map

package/dist/lib/neutral/{chunk-DZQSL6RW.mjs.map → chunk-FZO7LQO7.mjs.map}

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/Format.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as internal from './internal';\n\nexport * from './internal/formats';\n\nexport type Format = internal.TypeFormat;\n"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as internal from './internal';\n\nexport * from './internal/Format';\n\nexport type Format = internal.TypeFormat;\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
   "names": []
 }

package/dist/lib/neutral/{chunk-AQP4QKYP.mjs → chunk-KTAWP7GI.mjs}

@@ -1,21 +1,21 @@
 import {
   getQueueDxn
-} from "./chunk-GFNCSK7F.mjs";
+} from "./chunk-DYDJBZEG.mjs";
 import {
   everything,
   is,
   props,
   type
-} from "./chunk-ALOGSVBP.mjs";
+} from "./chunk-NXMFBIT5.mjs";
 import {
   getTypename
-} from "./chunk-KGV3QIRX.mjs";
+} from "./chunk-NQRLRYJM.mjs";
 import {
   isDatabase
-} from "./chunk-5ELDDYWE.mjs";
+} from "./chunk-NEGC54NE.mjs";
 import {
   getTypeDXNFromSpecifier
-} from "./chunk-F7KMHDPJ.mjs";
+} from "./chunk-SEMVAGBM.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -183,10 +183,10 @@ var QueryClass = class _QueryClass {
     }
     if (items.length > 0) {
       const typename = getTypename(items[0]);
-      if (typename === "dxos.org/type/View") {
+      if (typename === "org.dxos.type.view") {
         throw new Error("Query.from(view) is not yet supported.");
       }
-      if (typename === "dxos.org/type/Collection") {
+      if (typename === "org.dxos.type.collection") {
         throw new Error("Query.from(collection) is not yet supported.");
       }
     }
@@ -280,4 +280,4 @@ export {
   from,
   Query_exports
 };
-//# sourceMappingURL=chunk-AQP4QKYP.mjs.map
+//# sourceMappingURL=chunk-KTAWP7GI.mjs.map

package/dist/lib/neutral/chunk-KTAWP7GI.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Query.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\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 type * as Collection from './Collection';\nimport * as Database from './Database';\nimport type * as Dataset from './Dataset';\nimport * as Feed from './Feed';\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Order from './Order';\nimport type * as Ref from './Ref';\nimport type * as Relation from './Relation';\nimport type * as View from './View';\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.Unknown\n      ? Ref.Target<T[K]>\n      : T[K] extends Ref.Unknown | 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. If not provided, matches any type.\n   * @param key - Property path inside the referencing object that is a reference. If not provided, matches any property.\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  'referencedBy'<S extends Schema.Schema.All>(target: S | string): Query<Schema.Schema.Type<S>>;\n  'referencedBy'(): Query<any>;\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<Relation.SourceOf<T>>;\n\n  /**\n   * For a query for relations, get the target objects.\n   * @returns Query for the target objects.\n   */\n  'target'(): Query<Relation.TargetOf<T>>;\n\n  /**\n   * Get the parent object of the current selection.\n   * @returns Query for the parent objects.\n   */\n  'parent'(): Query<any>;\n\n  /**\n   * Get all child objects of the current selection.\n   * @returns Query for the child objects.\n   */\n  'children'(): Query<any>;\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   * Limit the number of results.\n   * @param limit - Maximum number of results to return.\n   * @returns Query for the limited results.\n   */\n  'limit'(limit: number): Query<T>;\n\n  /**\n   * Query from selected databases only.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from(db);\n   * ```\n   *\n   * @param options.includeFeeds [false] - Whether to include feeds in the query. Default is to query from automerge documents only.\n   */\n  'from'(database: Database.Database | Database.Database[], options?: { includeFeeds?: boolean }): Query<T>;\n\n  /**\n   * Query from selected feeds only.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from(feed);\n   * ```\n   *\n   */\n  'from'(feeds: Feed.Feed | Feed.Feed[]): Query<T>;\n\n  /**\n   * Query from all accessible spaces.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from('all-accessible-spaces');\n   * ```\n   *\n   * @param options.includeFeeds [false] - Whether to include feeds in the query. Default is to query from automerge documents only.\n   */\n  'from'(allSpaces: 'all-accessible-spaces', options?: { includeFeeds?: boolean }): Query<T>;\n\n  /**\n   * Query from a dataset.\n   * Currently only feeds are supported.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.type(Person).from(feed);\n   * ```\n   */\n  'from'(dataset: Dataset.Dataset): Query<T>;\n\n  /**\n   * Query from the results of another query.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.props({ foo: 'foo' })).from(Query.select(Filter.type(Contact)).reference('org'));\n   * ```\n   */\n  'from'(query: Any): Query<T>;\n\n  /**\n   * Query from a raw scope specification.\n   */\n  'from'(scope: QueryAST.Scope): 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 = target !== undefined ? internal.getTypeDXNFromSpecifier(target) : null;\n    return new QueryClass({\n      type: 'incoming-references',\n      anchor: this.ast,\n      property: key ?? null,\n      typename: dxn?.toString() ?? null,\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: relation !== undefined ? Filter.type(relation, predicates).ast : undefined,\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: relation !== undefined ? Filter.type(relation, predicates).ast : undefined,\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  parent(): Any {\n    return new QueryClass({\n      type: 'hierarchy-traversal',\n      anchor: this.ast,\n      direction: 'to-parent',\n    });\n  }\n\n  children(): Any {\n    return new QueryClass({\n      type: 'hierarchy-traversal',\n      anchor: this.ast,\n      direction: 'to-children',\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  limit(limit: number): Any {\n    return new QueryClass({\n      type: 'limit',\n      query: this.ast,\n      limit,\n    });\n  }\n\n  from(\n    arg:\n      | Database.Database\n      | Database.Database[]\n      | Feed.Feed\n      | Feed.Feed[]\n      | Collection.Collection\n      | View.View\n      | Any\n      | QueryAST.Scope\n      | 'all-accessible-spaces',\n    options?: { includeFeeds?: boolean },\n  ): Any {\n    if (is(arg)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'query', query: arg.ast },\n      });\n    }\n\n    if (arg === 'all-accessible-spaces') {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: {\n          _tag: 'scope',\n          scope: {\n            ...(options?.includeFeeds ? { allQueuesFromSpaces: true } : {}),\n          },\n        },\n      });\n    }\n\n    if (_isScope(arg)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'scope', scope: arg },\n      });\n    }\n\n    const items = Array.isArray(arg) ? arg : [arg];\n\n    if (items.length > 0 && Database.isDatabase(items[0])) {\n      const databases = items as Database.Database[];\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: {\n          _tag: 'scope',\n          scope: {\n            spaceIds: databases.map((db) => db.spaceId),\n            ...(options?.includeFeeds ? { allQueuesFromSpaces: true } : {}),\n          },\n        },\n      });\n    }\n\n    if (items.length > 0) {\n      const typename = Obj.getTypename(items[0] as Obj.Unknown);\n      // TODO(dmaretskyi): Support querying from views.\n      if (typename === 'org.dxos.type.view') {\n        throw new Error('Query.from(view) is not yet supported.');\n      }\n      // TODO(dmaretskyi): Support querying from collections.\n      if (typename === 'org.dxos.type.collection') {\n        throw new Error('Query.from(collection) is not yet supported.');\n      }\n    }\n\n    const feeds = items as Feed.Feed[];\n    const queueDxns = feeds.flatMap((feed) => {\n      const dxn = Feed.getQueueDxn(feed);\n      return dxn ? [dxn.toString()] : [];\n    });\n    return new QueryClass({\n      type: 'from',\n      query: this.ast,\n      from: {\n        _tag: 'scope',\n        scope: {\n          queues: queueDxns,\n        },\n      },\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\n/**\n * Create a query scoped to a data source.\n * The returned query selects everything from the source; chain `.select()` to narrow results.\n *\n * @param source - Data source: database, feed, 'all-accessible-spaces', or another query.\n * @returns Query scoped to the given source.\n */\nexport const from = (\n  source:\n    | Database.Database\n    | Database.Database[]\n    | Feed.Feed\n    | Feed.Feed[]\n    | Any\n    | QueryAST.Scope\n    | 'all-accessible-spaces',\n  options?: { includeFeeds?: boolean },\n): Any => {\n  const baseQuery: QueryAST.Query = {\n    type: 'select',\n    filter: Filter.everything().ast,\n  };\n  const wrapper = new QueryClass(baseQuery);\n  return wrapper.from(source as any, options);\n};\n\nconst SCOPE_KEYS = new Set(['spaceIds', 'queues', 'allQueuesFromSpaces']);\n\n/** Detect a raw Scope object (plain object with only Scope-valid keys). */\nconst _isScope = (value: unknown): value is QueryAST.Scope => {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    return false;\n  }\n  return Object.keys(value).every((key) => SCOPE_KEYS.has(key));\n};\n"],
+  "mappings": "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",
+  "names": ["is", "type", "QueryClass", "ast", "variance", "select", "filter", "is", "type", "selection", "props", "reference", "key", "anchor", "property", "referencedBy", "target", "dxn", "undefined", "getTypeDXNFromSpecifier", "typename", "toString", "sourceOf", "relation", "predicates", "direction", "targetOf", "source", "parent", "children", "orderBy", "order", "query", "map", "o", "limit", "from", "arg", "options", "_tag", "scope", "includeFeeds", "allQueuesFromSpaces", "_isScope", "items", "Array", "isArray", "length", "isDatabase", "databases", "spaceIds", "db", "spaceId", "getTypename", "Error", "feeds", "queueDxns", "flatMap", "feed", "getQueueDxn", "queues", "value", "fromAst", "schema", "all", "queries", "TypeError", "q", "without", "exclude", "baseQuery", "everything", "wrapper", "SCOPE_KEYS", "Set", "Object", "keys", "every", "has"]
+}

package/dist/lib/neutral/{chunk-5ELDDYWE.mjs → chunk-NEGC54NE.mjs}

@@ -1,9 +1,9 @@
 import {
   isInstanceOf
-} from "./chunk-F7KMHDPJ.mjs";
+} from "./chunk-SEMVAGBM.mjs";
 import {
   ObjectNotFoundError
-} from "./chunk-MXQJZCPY.mjs";
+} from "./chunk-UBEZSGXY.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -78,7 +78,7 @@ var resolve = (ref, schema) => Effect.gen(function* () {
   }
   invariant(!schema || isInstanceOf(schema, object), "Object type mismatch.", {
     F: __dxlog_file,
-    L: 228,
+    L: 230,
     S: this,
     A: [
       "!schema || isInstanceOf(schema, object)",
@@ -127,4 +127,4 @@ export {
   runSchemaQuery,
   Database_exports
 };
-//# sourceMappingURL=chunk-5ELDDYWE.mjs.map
+//# sourceMappingURL=chunk-NEGC54NE.mjs.map

package/dist/lib/neutral/chunk-NEGC54NE.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Database.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { promiseWithCauseCapture } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { DXN, type SpaceId } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport * as Err from './Err';\nimport type * as Filter from './Filter';\nimport type * as Hypergraph from './Hypergraph';\nimport { isInstanceOf } from './internal/Annotation';\nimport type { Ref } from './internal/Ref/ref';\nimport { type AnyProperties } from './internal/common/types';\nimport type * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport type * as SchemaRegistry from './SchemaRegistry';\nimport type * as Type from './Type';\n\n/**\n * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\nexport interface QueryFn {\n  <Q extends Query.Any>(query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n  <F extends Filter.Any>(filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n}\n\n/**\n * Common interface for Database and Queue.\n */\nexport interface Queryable {\n  query: QueryFn;\n}\n\nexport type GetObjectByIdOptions = {\n  deleted?: boolean;\n};\n\nexport type ObjectPlacement = 'root-doc' | 'linked-doc';\n\nexport type AddOptions = {\n  /**\n   * Where to place the object in the Automerge document tree.\n   * Root document is always loaded with the space.\n   * Linked documents are loaded lazily.\n   * Placing large number of objects in the root document may slow down the initial load.\n   *\n   * @default 'linked-doc'\n   */\n  placeIn?: ObjectPlacement;\n};\n\nexport type FlushOptions = {\n  /**\n   * Write any pending changes to disk.\n   * @default true\n   */\n  disk?: boolean;\n\n  /**\n   * Wait for pending index updates.\n   * @default true\n   */\n  indexes?: boolean;\n\n  /**\n   * Flush pending updates to objects and queries.\n   * @default false\n   */\n  updates?: boolean;\n};\n\n/**\n * Identifier denoting an ECHO Database.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Database');\nexport type TypeId = typeof TypeId;\n\n/**\n * ECHO Database interface.\n */\nexport interface Database extends Queryable {\n  readonly [TypeId]: TypeId;\n\n  get spaceId(): SpaceId;\n\n  // TODO(burdon): Can we move this into graph?\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\n\n  get graph(): Hypergraph.Hypergraph;\n\n  toJSON(): object;\n\n  /**\n   * Return object by local ID.\n   */\n  getObjectById<T extends Obj.Unknown = Obj.OfShape<AnyProperties>>(\n    id: string,\n    opts?: GetObjectByIdOptions,\n  ): T | undefined;\n\n  /**\n   * Query objects.\n   */\n  query: QueryFn;\n\n  /**\n   * Creates a reference to an existing object in the database.\n   *\n   * NOTE: The reference may be dangling if the object is not present in the database.\n   * NOTE: Difference from `Ref.fromDXN`\n   * `Ref.fromDXN(dxn)` returns an unhydrated reference. The `.load` and `.target` APIs will not work.\n   * `db.makeRef(dxn)` is preferable in cases with access to the database.\n   */\n  makeRef<T extends Entity.Unknown = Entity.Unknown>(dxn: DXN): Ref<T>;\n\n  /**\n   * Adds object to the database.\n   */\n  add<T extends Entity.Unknown = Entity.Unknown>(obj: T, opts?: AddOptions): T;\n\n  /**\n   * Removes object from the database.\n   */\n  // TODO(burdon): Return true if removed (currently throws if not present).\n  remove(obj: Entity.Unknown): void;\n\n  /**\n   * Wait for all pending changes to be saved to disk.\n   * Optionaly waits for changes to be propagated to indexes and event handlers.\n   */\n  flush(opts?: FlushOptions): Promise<void>;\n}\n\nexport const isDatabase = (obj: unknown): obj is Database => {\n  return obj ? typeof obj === 'object' && TypeId in obj && obj[TypeId] === TypeId : false;\n};\n\nexport const Database: Schema.Schema<Database> = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));\n\n/**\n * Effect service tag for Database dependency injection.\n */\nexport class Service extends Context.Tag('@dxos/echo/Database/Service')<\n  Service,\n  {\n    readonly db: Database;\n  }\n>() {}\n\n/**\n * Layer that provides a Database service that throws when accessed.\n * Useful as a default layer when no database is available.\n */\nexport const notAvailable = Layer.succeed(Service, {\n  get db(): Database {\n    throw new Error('Database not available');\n  },\n});\n\n/**\n * Creates a Database service instance from a Database.\n */\nexport const makeService = (db: Database): Context.Tag.Service<Service> => {\n  return {\n    get db() {\n      return db;\n    },\n  };\n};\n\n/**\n * Creates a Layer that provides the Database service.\n */\nexport const layer = (db: Database): Layer.Layer<Service> => {\n  return Layer.succeed(Service, makeService(db));\n};\n\n/**\n * Returns the space ID of the database.\n */\nexport const spaceId = Effect.gen(function* () {\n  const { db } = yield* Service;\n  return db.spaceId;\n});\n\n/**\n * Resolves an object by its DXN.\n */\nexport const resolve: {\n  // No type check.\n  (ref: DXN | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;\n  // Check matches schema.\n  <S extends Type.AnyEntity>(\n    ref: DXN | Ref<any>,\n    schema: S,\n  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;\n} = (<S extends Type.AnyEntity>(\n  ref: DXN | Ref<any>,\n  schema?: S,\n): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service> =>\n  Effect.gen(function* () {\n    const { db } = yield* Service;\n    const dxn = ref instanceof DXN ? ref : ref.dxn;\n    const object = yield* promiseWithCauseCapture(() =>\n      db.graph\n        .createRefResolver({\n          context: {\n            space: db.spaceId,\n          },\n        })\n        .resolve(dxn),\n    );\n\n    if (!object) {\n      return yield* Effect.fail(new Err.ObjectNotFoundError(dxn));\n    }\n    invariant(!schema || isInstanceOf(schema, object), 'Object type mismatch.');\n    return object as any;\n  })) as any;\n\n/**\n * Loads an object reference.\n */\nexport const load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.ObjectNotFoundError, never> = Effect.fn(function* (ref) {\n  const object = yield* promiseWithCauseCapture(() => ref.tryLoad());\n  if (!object) {\n    return yield* Effect.fail(new Err.ObjectNotFoundError(ref.dxn));\n  }\n  return object;\n});\n\n/**\n * Loads an object reference option.\n */\n// TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.\nexport const loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(function* (ref) {\n  const object = yield* load(ref).pipe(Effect.catchTag('ObjectNotFoundError', () => Effect.succeed(undefined)));\n\n  return Option.fromNullable(object);\n});\n\n/**\n * Adds an object to the database.\n * @see {@link Database.add}\n */\nexport const add = <T extends Entity.Unknown>(obj: T): Effect.Effect<T, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.add(obj)));\n\n/**\n * Removes an object from the database.\n * @see {@link Database.remove}\n */\nexport const remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.remove(obj)));\n\n/**\n * Flushes pending changes to disk.\n * @see {@link Database.flush}\n */\nexport const flush = (opts?: FlushOptions) =>\n  Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));\n\n/**\n * Creates a `QueryResult` object that can be subscribed to.\n */\nexport const query: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  Service.pipe(\n    Effect.map(({ db }) => db.query(queryOrFilter as any) as QueryResult.QueryResult<any>),\n    Effect.withSpan('Database.query'),\n  );\n\n/**\n * Executes the query once and returns the results.\n */\nexport const runQuery: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  query(queryOrFilter as any).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));\n\n/**\n * Creates a schema query result that can be subscribed to.\n */\n// TODO(dmaretskyi): Change API to `yield* Database.querySchema(...).first` and `yield* Database.querySchema(...).schema`.\nexport const schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<QueryResult.QueryResult<SchemaRegistry.ExtractQueryResult<Q>>, never, Service> =>\n  Service.pipe(\n    Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)),\n    Effect.withSpan('Database.schemaQuery'),\n  );\n\n/**\n * Executes a schema query once and returns the results.\n */\nexport const runSchemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<SchemaRegistry.ExtractQueryResult<Q>[], never, Service> =>\n  schemaQuery(schemaQueryOptions).pipe(\n    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n  );\n"],
+  "mappings": "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",
+  "names": ["Context", "Effect", "Layer", "Option", "Schema", "promiseWithCauseCapture", "invariant", "DXN", "TypeId", "Symbol", "for", "isDatabase", "obj", "Database", "Any", "pipe", "filter", "space", "Service", "Tag", "notAvailable", "succeed", "db", "Error", "makeService", "layer", "spaceId", "gen", "resolve", "ref", "schema", "dxn", "DXN", "object", "promiseWithCauseCapture", "graph", "createRefResolver", "context", "fail", "ObjectNotFoundError", "invariant", "isInstanceOf", "load", "fn", "tryLoad", "loadOption", "catchTag", "undefined", "fromNullable", "add", "map", "remove", "flush", "opts", "flatMap", "query", "queryOrFilter", "withSpan", "runQuery", "queryResult", "run", "schemaQuery", "schemaQueryOptions", "schemaRegistry", "runSchemaQuery"]
+}