@kyneta/yjs-schema 1.3.1 → 1.4.0

package/src/change-mapping.ts

@@ -23,6 +23,9 @@ import type {
   Op,
   Path,
   ReplaceChange,
+  RichTextChange,
+  RichTextInstruction,
+  SchemaBinding,
   Schema as SchemaNode,
   SequenceChange,
   SequenceInstruction,
@@ -34,6 +37,7 @@ import {
   expandMapOpsToLeaves,
   KIND,
   RawPath,
+  richTextChange,
 } from "@kyneta/schema"
 import * as Y from "yjs"
 import { resolveYjsType } from "./yjs-resolve.js"
@@ -59,22 +63,45 @@ export function applyChangeToYjs(
   rootSchema: SchemaNode,
   path: Path,
   change: ChangeBase,
+  binding?: SchemaBinding,
 ): void {
   switch (change.type) {
     case "text":
-      applyTextChange(rootMap, rootSchema, path, change as TextChange)
+      applyTextChange(rootMap, rootSchema, path, change as TextChange, binding)
+      return
+
+    case "richtext":
+      applyRichTextChange(
+        rootMap,
+        rootSchema,
+        path,
+        change as RichTextChange,
+        binding,
+      )
       return
 
     case "sequence":
-      applySequenceChange(rootMap, rootSchema, path, change as SequenceChange)
+      applySequenceChange(
+        rootMap,
+        rootSchema,
+        path,
+        change as SequenceChange,
+        binding,
+      )
       return
 
     case "map":
-      applyMapChange(rootMap, rootSchema, path, change as MapChange)
+      applyMapChange(rootMap, rootSchema, path, change as MapChange, binding)
       return
 
     case "replace":
-      applyReplaceChange(rootMap, rootSchema, path, change as ReplaceChange)
+      applyReplaceChange(
+        rootMap,
+        rootSchema,
+        path,
+        change as ReplaceChange,
+        binding,
+      )
       return
 
     case "increment":
@@ -107,8 +134,9 @@ function applyTextChange(
   rootSchema: SchemaNode,
   path: Path,
   change: TextChange,
+  binding?: SchemaBinding,
 ): void {
-  const resolved = resolveYjsType(rootMap, rootSchema, path)
+  const { resolved } = resolveYjsType(rootMap, rootSchema, path, binding)
   if (!(resolved instanceof Y.Text)) {
     throw new Error(
       `applyChangeToYjs: TextChange target at path [${pathToString(path)}] is not a Y.Text`,
@@ -120,6 +148,40 @@ function applyTextChange(
   resolved.applyDelta(change.instructions as any)
 }
 
+// ---------------------------------------------------------------------------
+// Rich text change
+// ---------------------------------------------------------------------------
+
+function applyRichTextChange(
+  rootMap: Y.Map<any>,
+  rootSchema: SchemaNode,
+  path: Path,
+  change: RichTextChange,
+  binding?: SchemaBinding,
+): void {
+  const { resolved } = resolveYjsType(rootMap, rootSchema, path, binding)
+  if (!(resolved instanceof Y.Text)) {
+    throw new Error(
+      `applyChangeToYjs: RichTextChange target at path [${pathToString(path)}] is not a Y.Text`,
+    )
+  }
+  // Map RichTextInstruction → Yjs delta format
+  const delta = change.instructions.map((inst: RichTextInstruction) => {
+    if ("retain" in inst) return { retain: inst.retain }
+    if ("format" in inst) return { retain: inst.format, attributes: inst.marks }
+    if ("insert" in inst) {
+      const d: any = { insert: inst.insert }
+      if (inst.marks && Object.keys(inst.marks).length > 0) {
+        d.attributes = inst.marks
+      }
+      return d
+    }
+    if ("delete" in inst) return { delete: inst.delete }
+    throw new Error("applyRichTextChange: unknown instruction type")
+  })
+  resolved.applyDelta(delta as any)
+}
+
 // ---------------------------------------------------------------------------
 // Sequence change
 // ---------------------------------------------------------------------------
@@ -129,8 +191,9 @@ function applySequenceChange(
   rootSchema: SchemaNode,
   path: Path,
   change: SequenceChange,
+  binding?: SchemaBinding,
 ): void {
-  const resolved = resolveYjsType(rootMap, rootSchema, path)
+  const { resolved } = resolveYjsType(rootMap, rootSchema, path, binding)
   if (!(resolved instanceof Y.Array)) {
     throw new Error(
       `applyChangeToYjs: SequenceChange target at path [${pathToString(path)}] is not a Y.Array`,
@@ -168,8 +231,9 @@ function applyMapChange(
   rootSchema: SchemaNode,
   path: Path,
   change: MapChange,
+  binding?: SchemaBinding,
 ): void {
-  const resolved = resolveYjsType(rootMap, rootSchema, path)
+  const { resolved } = resolveYjsType(rootMap, rootSchema, path, binding)
   if (!(resolved instanceof Y.Map)) {
     throw new Error(
       `applyChangeToYjs: MapChange target at path [${pathToString(path)}] is not a Y.Map`,
@@ -191,7 +255,20 @@ function applyMapChange(
     for (const [key, value] of Object.entries(change.set)) {
       const fieldSchema = getFieldSchema(targetSchema, key)
       const yjsValue = maybeCreateSharedType(value, fieldSchema)
-      resolved.set(key, yjsValue)
+      // For product schemas (structs), use the identity hash as the map key.
+      // For map schemas (records), use the key as-is (no identity-keying).
+      let mapKey = key
+      if (binding && targetSchema[KIND] === "product") {
+        // Compute absolute schema path for this field.
+        const parentAbsPath = path.segments
+          .filter(s => s.role === "key")
+          .map(s => s.resolve() as string)
+          .join(".")
+        const absPath = parentAbsPath ? `${parentAbsPath}.${key}` : key
+        const identity = binding.forward.get(absPath) as string | undefined
+        if (identity) mapKey = identity
+      }
+      resolved.set(mapKey, yjsValue)
     }
   }
 }
@@ -205,6 +282,7 @@ function applyReplaceChange(
   rootSchema: SchemaNode,
   path: Path,
   change: ReplaceChange,
+  binding?: SchemaBinding,
 ): void {
   if (path.length === 0) {
     throw new Error(
@@ -214,16 +292,32 @@ function applyReplaceChange(
 
   // Target the parent container, using the last segment to identify
   // which child to replace.
-  const lastSeg = path.segments[path.segments.length - 1]!
+  const lastSeg = path.segments.at(-1)
+  if (!lastSeg) throw new Error("replaceChangeToDiff: empty path")
   const parentPath = path.slice(0, -1)
-  const parent = resolveYjsType(rootMap, rootSchema, parentPath)
+  const { resolved: parent } = resolveYjsType(
+    rootMap,
+    rootSchema,
+    parentPath,
+    binding,
+  )
 
   const resolved = lastSeg.resolve()
   if (parent instanceof Y.Map && lastSeg.role === "key") {
     // Resolve schema for the target field for structured value detection
     const targetSchema = resolveSchemaAtPath(rootSchema, path)
     const yjsValue = maybeCreateSharedType(change.value, targetSchema)
-    parent.set(resolved as string, yjsValue)
+    // Use identity hash for product-field boundaries.
+    let mapKey = resolved as string
+    if (binding) {
+      const absPath = path.segments
+        .filter(s => s.role === "key")
+        .map(s => s.resolve() as string)
+        .join(".")
+      const identity = binding.forward.get(absPath) as string | undefined
+      if (identity) mapKey = identity
+    }
+    parent.set(mapKey, yjsValue)
   } else if (parent instanceof Y.Array && lastSeg.role === "index") {
     const targetSchema = resolveSchemaAtPath(rootSchema, path)
     const yjsValue = maybeCreateSharedType(change.value, targetSchema)
@@ -243,8 +337,8 @@ function applyReplaceChange(
 
 /**
  * If the schema says the value should be a shared type (product → Y.Map,
- * sequence → Y.Array, text → Y.Text), create and populate it.
- * Otherwise return the plain value as-is.
+ * sequence → Y.Array, text → Y.Text, richtext → Y.Text), create and
+ * populate it. Otherwise return the plain value as-is.
  *
  * Uses populate-then-attach: the new shared type is fully populated
  * before being returned for insertion into its parent.
@@ -265,6 +359,29 @@ function maybeCreateSharedType(
       return text
     }
 
+    // Rich text → Y.Text (Yjs uses Y.Text for both plain and rich text)
+    case "richtext": {
+      const text = new Y.Text()
+      if (typeof value === "string" && value.length > 0) {
+        text.insert(0, value)
+      } else if (Array.isArray(value)) {
+        // RichTextDelta: array of { text, marks? } spans → Yjs delta
+        const delta = (
+          value as Array<{ text: string; marks?: Record<string, unknown> }>
+        ).map(span => {
+          const d: any = { insert: span.text }
+          if (span.marks && Object.keys(span.marks).length > 0) {
+            d.attributes = span.marks
+          }
+          return d
+        })
+        if (delta.length > 0) {
+          text.applyDelta(delta)
+        }
+      }
+      return text
+    }
+
     case "product": {
       if (
         value === null ||
@@ -359,7 +476,7 @@ function createStructuredMap(
     productSchema.fields as Record<string, SchemaNode>,
   )) {
     if (key in obj) continue // already processed above
-    if (fieldSchema[KIND] === "text") {
+    if (fieldSchema[KIND] === "text" || fieldSchema[KIND] === "richtext") {
       map.set(key, new Y.Text())
     }
   }
@@ -384,12 +501,16 @@ function createStructuredMap(
  *
  * @param events - The events from the `observeDeep` callback
  */
-export function eventsToOps(events: Y.YEvent<any>[], schema: SchemaNode): Op[] {
+export function eventsToOps(
+  events: Y.YEvent<any>[],
+  schema: SchemaNode,
+  binding?: SchemaBinding,
+): Op[] {
   const ops: Op[] = []
 
   for (const event of events) {
-    const kynetaPath = yjsPathToKynetaPath(event.path)
-    const change = eventToChange(event)
+    const kynetaPath = yjsPathToKynetaPath(event.path, binding)
+    const change = eventToChange(event, schema, kynetaPath, binding)
     if (change) {
       ops.push({ path: kynetaPath, change })
     }
@@ -408,11 +529,24 @@ export function eventsToOps(events: Y.YEvent<any>[], schema: SchemaNode): Op[] {
  * `event.path` from `observeDeep` is relative to the observed type.
  * Strings become key segments, numbers become index segments.
  */
-function yjsPathToKynetaPath(yjsPath: (string | number)[]): RawPath {
+function yjsPathToKynetaPath(
+  yjsPath: (string | number)[],
+  binding?: SchemaBinding,
+): RawPath {
   let path = RawPath.empty
   for (const segment of yjsPath) {
     if (typeof segment === "string") {
-      path = path.field(segment)
+      // Reverse-map identity hash → absolute schema path → leaf field name.
+      // Yjs events emit identity-keyed strings at product-field positions;
+      // we need to recover the original field name for kyneta schema paths.
+      const absPath = binding?.inverse.get(segment as any)
+      if (absPath) {
+        const lastDot = absPath.lastIndexOf(".")
+        const leaf = lastDot >= 0 ? absPath.slice(lastDot + 1) : absPath
+        path = path.field(leaf)
+      } else {
+        path = path.field(segment)
+      }
     } else if (typeof segment === "number") {
       path = path.item(segment)
     }
@@ -426,17 +560,33 @@ function yjsPathToKynetaPath(yjsPath: (string | number)[]): RawPath {
 
 /**
  * Convert a single Yjs event into a kyneta Change.
+ *
+ * For Y.Text events, dispatches to either `textEventToChange` or
+ * `richTextEventToChange` based on the schema at the event's path.
+ * Both text and richtext produce `Y.YTextEvent`, so schema awareness
+ * is required for correct dispatch.
+ *
  * Returns null for event types we can't map.
  */
-function eventToChange(event: Y.YEvent<any>): ChangeBase | null {
+function eventToChange(
+  event: Y.YEvent<any>,
+  rootSchema: SchemaNode,
+  kynetaPath: RawPath,
+  binding?: SchemaBinding,
+): ChangeBase | null {
   if (event.target instanceof Y.Text) {
+    // Both text and richtext use Y.Text — resolve the schema to dispatch.
+    const schemaAtPath = resolveSchemaAtPath(rootSchema, kynetaPath)
+    if (schemaAtPath[KIND] === "richtext") {
+      return richTextEventToChange(event)
+    }
     return textEventToChange(event)
   }
   if (event.target instanceof Y.Array) {
     return arrayEventToChange(event)
   }
   if (event.target instanceof Y.Map) {
-    return mapEventToChange(event)
+    return mapEventToChange(event, binding)
   }
   return null
 }
@@ -446,7 +596,7 @@ function eventToChange(event: Y.YEvent<any>): ChangeBase | null {
  *
  * `event.delta` uses the Quill Delta format, structurally identical to
  * kyneta `TextInstruction[]`. We strip the `attributes` field (rich text
- * formatting not surfaced by kyneta).
+ * formatting not surfaced by kyneta plain text).
  */
 function textEventToChange(event: Y.YEvent<any>): TextChange {
   const instructions: TextInstruction[] = []
@@ -464,6 +614,39 @@ function textEventToChange(event: Y.YEvent<any>): TextChange {
   return { type: "text", instructions }
 }
 
+/**
+ * Y.Text event → RichTextChange.
+ *
+ * `event.delta` uses the Quill Delta format. We map each delta op to a
+ * `RichTextInstruction`, preserving `attributes` as `marks` for format
+ * and insert instructions.
+ */
+function richTextEventToChange(event: Y.YEvent<any>): RichTextChange {
+  const instructions: RichTextInstruction[] = []
+
+  for (const delta of event.delta) {
+    if (delta.retain !== undefined) {
+      const attrs = (delta as any).attributes
+      if (attrs && Object.keys(attrs).length > 0) {
+        instructions.push({ format: delta.retain as number, marks: attrs })
+      } else {
+        instructions.push({ retain: delta.retain as number })
+      }
+    } else if (delta.insert !== undefined) {
+      const attrs = (delta as any).attributes
+      if (attrs && Object.keys(attrs).length > 0) {
+        instructions.push({ insert: delta.insert as string, marks: attrs })
+      } else {
+        instructions.push({ insert: delta.insert as string })
+      }
+    } else if (delta.delete !== undefined) {
+      instructions.push({ delete: delta.delete as number })
+    }
+  }
+
+  return richTextChange(instructions)
+}
+
 /**
  * Y.Array event → SequenceChange.
  *
@@ -497,7 +680,10 @@ function arrayEventToChange(event: Y.YEvent<any>): SequenceChange {
  * - `action: 'add'|'update'` → `set[key] = map.get(key)`
  * - `action: 'delete'` → `delete.push(key)`
  */
-function mapEventToChange(event: Y.YEvent<any>): MapChange | null {
+function mapEventToChange(
+  event: Y.YEvent<any>,
+  binding?: SchemaBinding,
+): MapChange | null {
   const set: Record<string, unknown> = {}
   const deleteKeys: string[] = []
   let hasSet = false
@@ -506,12 +692,20 @@ function mapEventToChange(event: Y.YEvent<any>): MapChange | null {
   const target = event.target as Y.Map<any>
 
   event.changes.keys.forEach((change: { action: string }, key: string) => {
+    // Reverse-map identity hash → absolute schema path → leaf field name.
+    const absPath = binding?.inverse.get(key as any)
+    const fieldName = absPath
+      ? absPath.lastIndexOf(".") >= 0
+        ? absPath.slice(absPath.lastIndexOf(".") + 1)
+        : absPath
+      : key
+
     if (change.action === "add" || change.action === "update") {
       const value = target.get(key)
-      set[key] = extractEventValue(value)
+      set[fieldName] = extractEventValue(value)
       hasSet = true
     } else if (change.action === "delete") {
-      deleteKeys.push(key)
+      deleteKeys.push(fieldName)
       hasDelete = true
     }
   })

package/src/index.ts

@@ -39,7 +39,7 @@ export {
 // Yjs-specific exports
 // ---------------------------------------------------------------------------
 
-export type { YjsCaps } from "./bind-yjs.js"
+export type { YjsLaws } from "./bind-yjs.js"
 // Namespace
 export { yjs } from "./bind-yjs.js"
 // Change mapping
@@ -48,6 +48,8 @@ export { applyChangeToYjs, eventsToOps } from "./change-mapping.js"
 export type { YjsNativeMap } from "./native-map.js"
 // Container creation
 export { ensureContainers } from "./populate.js"
+// Position conformance
+export { fromYjsAssoc, toYjsAssoc, YjsPosition } from "./position.js"
 // Reader
 export { yjsReader } from "./reader.js"
 // Substrate

package/src/populate.ts

@@ -13,8 +13,13 @@
 // Root container strategy: All schema fields are children of a single
 // root `Y.Map` obtained via `doc.getMap("root")`. This root map holds
 // shared types (Y.Text, Y.Array, Y.Map) and plain value slots uniformly.
+//
+// Identity-keying: when a SchemaBinding is provided, every product-field
+// boundary uses the identity hash (from binding.forward) instead of the
+// field name as the Y.Map key. The binding is threaded through all three
+// functions: ensureContainers, ensureRootField, ensureMapContainers.
 
-import type { Schema as SchemaNode } from "@kyneta/schema"
+import type { SchemaBinding, Schema as SchemaNode } from "@kyneta/schema"
 import { KIND, STRUCTURAL_YJS_CLIENT_ID, Zero } from "@kyneta/schema"
 import * as Y from "yjs"
 
@@ -44,15 +49,22 @@ import * as Y from "yjs"
  * then restores the caller's clientID. This produces byte-identical
  * structural ops across all peers, enabling Yjs deduplication on merge.
  *
+ * **Identity-keying:** When a `binding` is provided, each root field's
+ * key in the root Y.Map is the identity hash from `binding.forward`
+ * instead of the field name. Nested product fields are similarly keyed
+ * via `ensureMapContainers`.
+ *
  * @param doc - The Y.Doc to prepare
  * @param schema - The root document schema (a ProductSchema)
  * @param conditional - If true, skip fields that already exist in the root map.
  *   Context: jj:smmulzkm (two-phase substrate construction)
+ * @param binding - Optional SchemaBinding for identity-keyed containers.
  */
 export function ensureContainers(
   doc: Y.Doc,
   schema: SchemaNode,
   conditional = false,
+  binding?: SchemaBinding,
 ): void {
   const rootMap = doc.getMap("root")
 
@@ -70,8 +82,16 @@ export function ensureContainers(
       for (const [key, fieldSchema] of Object.entries(schema.fields).sort(
         ([a], [b]) => a.localeCompare(b),
       )) {
-        if (conditional && rootMap.has(key)) continue
-        ensureRootField(rootMap, key, fieldSchema as SchemaNode)
+        const identity = binding?.forward.get(key) as string | undefined
+        const mapKey = identity ?? key
+        if (conditional && rootMap.has(mapKey)) continue
+        ensureRootField(
+          rootMap,
+          mapKey,
+          fieldSchema as SchemaNode,
+          binding,
+          key,
+        )
       }
     })
   } finally {
@@ -94,19 +114,28 @@ export function ensureContainers(
  * - `"map"` → empty Y.Map
  * - `"scalar"` / `"sum"` → Zero.structural default
  * - `"counter"` / `"set"` / `"tree"` / `"movable"` → throw (not supported by Yjs)
+ *
+ * @param rootMap - The root Y.Map to set the field on.
+ * @param key - The key to use in the root map (identity hash or field name).
+ * @param fieldSchema - The schema for this field.
+ * @param binding - Optional SchemaBinding for nested identity-keying.
+ * @param prefix - The absolute schema path prefix for this field (used for nested lookups).
  */
 function ensureRootField(
   rootMap: Y.Map<unknown>,
   key: string,
   fieldSchema: SchemaNode,
+  binding?: SchemaBinding,
+  prefix?: string,
 ): void {
   switch (fieldSchema[KIND]) {
     case "text":
+    case "richtext":
       rootMap.set(key, new Y.Text())
       return
 
     case "product":
-      rootMap.set(key, ensureMapContainers(fieldSchema))
+      rootMap.set(key, ensureMapContainers(fieldSchema, binding, prefix))
       return
 
     case "sequence":
@@ -135,7 +164,7 @@ function ensureRootField(
     case "movable":
       throw new Error(
         `Yjs substrate does not support [KIND]="${fieldSchema[KIND]}". ` +
-          `Supported kinds: text, product, sequence, map, scalar, sum. ` +
+          `Supported kinds: text, richtext, product, sequence, map, scalar, sum. ` +
           `Encountered unsupported kind at root field "${key}".`,
       )
   }
@@ -152,8 +181,21 @@ function ensureRootField(
  * Only creates containers for fields that require Yjs shared types
  * (text → Y.Text, product → Y.Map, sequence → Y.Array, map → Y.Map).
  * Scalar and sum fields are set to their structural zero defaults.
+ *
+ * **Identity-keying:** When a `binding` is provided, computes the
+ * absolute schema path for each nested field (`prefix.fieldName`) and
+ * looks up the identity hash from `binding.forward`. The identity hash
+ * is used as the Y.Map entry key instead of the field name.
+ *
+ * @param schema - The product schema for this nested map.
+ * @param binding - Optional SchemaBinding for identity-keyed containers.
+ * @param prefix - The absolute schema path prefix (e.g. "meta" for fields under meta).
  */
-function ensureMapContainers(schema: SchemaNode): Y.Map<unknown> {
+function ensureMapContainers(
+  schema: SchemaNode,
+  binding?: SchemaBinding,
+  prefix?: string,
+): Y.Map<unknown> {
   const map = new Y.Map()
 
   if (schema[KIND] !== "product") return map
@@ -161,28 +203,33 @@ function ensureMapContainers(schema: SchemaNode): Y.Map<unknown> {
   for (const [key, fieldSchema] of Object.entries(
     schema.fields as Record<string, SchemaNode>,
   ).sort(([a], [b]) => a.localeCompare(b))) {
+    const absPath = prefix ? `${prefix}.${key}` : key
+    const identity = binding?.forward.get(absPath) as string | undefined
+    const mapKey = identity ?? key
+
     switch (fieldSchema[KIND]) {
       case "text":
-        map.set(key, new Y.Text())
+      case "richtext":
+        map.set(mapKey, new Y.Text())
         break
 
       case "product":
-        map.set(key, ensureMapContainers(fieldSchema))
+        map.set(mapKey, ensureMapContainers(fieldSchema, binding, absPath))
         break
 
       case "sequence":
-        map.set(key, new Y.Array())
+        map.set(mapKey, new Y.Array())
         break
 
       case "map":
-        map.set(key, new Y.Map())
+        map.set(mapKey, new Y.Map())
         break
 
       case "scalar":
       case "sum": {
         const zero = Zero.structural(fieldSchema)
         if (zero !== undefined) {
-          map.set(key, zero)
+          map.set(mapKey, zero)
         }
         break
       }
@@ -193,7 +240,7 @@ function ensureMapContainers(schema: SchemaNode): Y.Map<unknown> {
       case "movable":
         throw new Error(
           `Yjs substrate does not support [KIND]="${fieldSchema[KIND]}". ` +
-            `Supported kinds: text, product, sequence, map, scalar, sum. ` +
+            `Supported kinds: text, richtext, product, sequence, map, scalar, sum. ` +
             `Encountered unsupported kind at nested field "${key}".`,
         )
     }

package/src/position.ts

@@ -0,0 +1,45 @@
+// position — YjsPosition implementation.
+//
+// Wraps Yjs's RelativePosition to implement @kyneta/schema's Position interface.
+// Relative positions bind to specific item IDs in the Yjs document, making
+// resolve() a stateless query — transform() is a no-op.
+
+import type { Instruction, Position, Side } from "@kyneta/schema"
+import * as Y from "yjs"
+
+/** Map kyneta Side to Yjs assoc. Left → -1 (left-sticky), Right → 0 (right-sticky). */
+export function toYjsAssoc(side: Side): number {
+  return side === "left" ? -1 : 0
+}
+
+/** Map Yjs assoc to kyneta Side. Negative → left, non-negative → right. */
+export function fromYjsAssoc(assoc: number): Side {
+  return assoc < 0 ? "left" : "right"
+}
+
+export class YjsPosition implements Position {
+  readonly side: Side
+
+  constructor(
+    private readonly rpos: Y.RelativePosition,
+    private readonly doc: Y.Doc,
+  ) {
+    this.side = fromYjsAssoc(rpos.assoc)
+  }
+
+  resolve(): number | null {
+    const abs = Y.createAbsolutePositionFromRelativePosition(
+      this.rpos,
+      this.doc,
+    )
+    return abs ? abs.index : null
+  }
+
+  encode(): Uint8Array {
+    return Y.encodeRelativePosition(this.rpos)
+  }
+
+  transform(_instructions: readonly Instruction[]): void {
+    // No-op — Yjs relative positions resolve statelessly against the document.
+  }
+}