@kyneta/yjs-schema 1.3.0 → 1.4.0

package/README.md

@@ -8,19 +8,20 @@ Wraps a `Y.Doc` with schema-aware typed reads, writes, versioning, and export/im
 
 ```ts
 import {
-  createYjsDoc,
+  createDoc,
   change,
   subscribe,
   Schema,
   text,
+  yjs,
   version,
   exportSnapshot,
   exportSince,
   importDelta,
 } from "@kyneta/yjs-schema"
 
-// Define a schema
-const TodoDoc = Schema.struct({
+// Define a schema and bind to Yjs substrate
+const TodoDoc = yjs.bind(Schema.struct({
   title: text(),
   items: Schema.list(
     Schema.struct({
@@ -28,10 +29,10 @@ const TodoDoc = Schema.struct({
       done: Schema.boolean(),
     }),
   ),
-})
+}))
 
 // Create a document with optional seed values
-const doc = createYjsDoc(TodoDoc, {
+const doc = createDoc(TodoDoc, {
   title: "My Todos",
   items: [{ name: "Buy milk", done: false }],
 })
@@ -66,16 +67,16 @@ subscribe(doc, (changeset) => {
 
 ### Unsupported
 
-- **`Schema.annotated("counter")`** — Yjs has no native counter type. Use `Schema.number()` with `ReplaceChange` instead. Attempting to use a counter annotation will throw at construction time.
-- **`Schema.annotated("movable")`** — Yjs has no native movable list. Will throw at construction time.
-- **`Schema.annotated("tree")`** — Yjs has no native tree type. Will throw at construction time.
+- **`Schema.counter()`** — Yjs has no native counter type. Use `Schema.number()` with `ReplaceChange` instead. Attempting to use a counter annotation will throw at construction time.
+- **`Schema.movableList()`** — Yjs has no native movable list. Will throw at construction time.
+- **`Schema.tree()`** — Yjs has no native tree type. Will throw at construction time.
 
 ## Sync
 
 ```ts
 import {
-  createYjsDoc,
-  createYjsDocFromSnapshot,
+  createDoc,
+  yjs,
   version,
   exportSnapshot,
   exportSince,
@@ -83,12 +84,14 @@ import {
   change,
 } from "@kyneta/yjs-schema"
 
+const MyDoc = yjs.bind(MySchema)
+
 // Peer A creates a doc
-const docA = createYjsDoc(MySchema, { title: "Draft" })
+const docA = createDoc(MyDoc, { title: "Draft" })
 
 // Peer B bootstraps from a full snapshot
 const snapshot = exportSnapshot(docA)
-const docB = createYjsDocFromSnapshot(MySchema, snapshot)
+const docB = createDoc(MyDoc, snapshot)
 
 // After mutations on A, sync incrementally
 const vBefore = version(docB)
@@ -102,10 +105,10 @@ importDelta(docB, delta!)
 ## Exchange Integration
 
 ```ts
-import { bindYjs } from "@kyneta/yjs-schema"
+import { yjs } from "@kyneta/yjs-schema"
 import { Schema, text } from "@kyneta/yjs-schema"
 
-const TodoDoc = bindYjs(Schema.struct({
+const TodoDoc = yjs.bind(Schema.struct({
   title: text(),
   items: Schema.list(Schema.struct({
     name: Schema.string(),
@@ -117,16 +120,17 @@ const TodoDoc = bindYjs(Schema.struct({
 const doc = exchange.get("my-todos", TodoDoc)
 ```
 
-`bindYjs` produces a `BoundSchema` with `strategy: "causal"`, which the exchange uses for bidirectional CRDT sync.
+`yjs.bind()` produces a `BoundSchema` with the collaborative `SyncProtocol`, which the exchange uses for bidirectional CRDT sync.
 
 ## Escape Hatch
 
 Access the underlying `Y.Doc` for direct Yjs API usage:
 
 ```ts
-import { yjs } from "@kyneta/yjs-schema"
+import { yjs, createDoc } from "@kyneta/yjs-schema"
 
-const doc = createYjsDoc(MySchema)
+const MyDoc = yjs.bind(MySchema)
+const doc = createDoc(MyDoc)
 const yjsDoc = yjs(doc)
 
 // Use with Yjs ecosystem
@@ -152,28 +156,27 @@ Because `yjs(doc)` returns a standard `Y.Doc`, the entire Yjs provider ecosystem
 
 | Export | Description |
 |---|---|
-| `createYjsDoc(schema, docOrSeed?)` | Create a live Yjs-backed document |
-| `createYjsDocFromSnapshot(schema, payload)` | Reconstruct from snapshot |
+| `createDoc(schema, docOrSeed?)` | Create a live Yjs-backed document *(re-exported from `@kyneta/schema`)* |
 | `version(doc)` | Current `YjsVersion` |
-| `exportSnapshot(doc)` | Full state as `SubstratePayload` |
+| `exportEntirety(doc)` | Full state as `SubstratePayload` |
 | `exportSince(doc, since)` | Delta since version |
-| `importDelta(doc, payload, origin?)` | Apply delta from peer |
+| `merge(doc, payload, origin?)` | Apply delta from peer |
 | `change(doc, fn)` | Transactional mutation |
 | `subscribe(doc, callback)` | Observe changes |
-| `bindYjs(schema)` | Bind schema for exchange use |
+| `yjs.bind(schema)` | Bind schema for exchange use |
 | `yjs(ref)` | Escape hatch → `Y.Doc` |
-| `text()` | `Schema.annotated("text")` convenience |
+| `text()` | `Schema.text()` convenience — collaborative text schema kind |
 
 ### Low-level primitives (power users)
 
 | Export | Description |
 |---|---|
 | `YjsVersion` | Version class wrapping Yjs state vectors |
-| `yjsStoreReader(doc, schema)` | Live `StoreReader` over Yjs types |
+| `yjsReader(doc, schema)` | Live `StoreReader` over Yjs types |
 | `resolveYjsType(rootMap, schema, path)` | Path resolution |
 | `applyChangeToYjs(rootMap, schema, path, change)` | kyneta → Yjs |
 | `eventsToOps(events)` | Yjs → kyneta |
-| `populateRoot(doc, schema, seed)` | Root container population |
+| `ensureContainers(doc, schema, seed)` | Root container population |
 | `createYjsSubstrate(doc, schema)` | Low-level substrate construction |
 | `yjsSubstrateFactory` | `SubstrateFactory<YjsVersion>` |
 

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-export { Changeset } from '@kyneta/changefeed';
-import { NativeMap, SubstrateNamespace, CrdtStrategy, Schema, Path, ChangeBase, Op, Reader, Version, Substrate, ReplicaFactory, SubstrateFactory, Segment } from '@kyneta/schema';
-export { DocRef, NATIVE, Op, Ref, Schema, SubstratePayload, applyChanges, change, createDoc, createRef, exportEntirety, exportSince, merge, subscribe, subscribeNode, unwrap, version } from '@kyneta/schema';
-import * as Y from 'yjs';
+import { BindingTarget, ChangeBase, DocRef, Instruction, NATIVE, NativeMap, Op, Op as Op$1, Path, Position, Reader, Ref, ReplicaFactory, Schema, Schema as Schema$1, SchemaBinding, Segment, Side, Substrate, SubstrateFactory, SubstratePayload, Version, applyChanges, change, createDoc, createRef, exportEntirety, exportSince, merge, subscribe, subscribeNode, unwrap, version } from "@kyneta/schema";
+import * as Y from "yjs";
+import { Doc } from "yjs";
+import { Changeset } from "@kyneta/changefeed";
 
+//#region src/native-map.d.ts
 /**
  * NativeMap for the Yjs CRDT substrate.
  *
@@ -20,36 +21,41 @@ import * as Y from 'yjs';
  * - `sum → undefined` (no container; stored in parent map)
  */
 interface YjsNativeMap extends NativeMap {
-    readonly root: Y.Doc;
-    readonly text: Y.Text;
-    readonly counter: undefined;
-    readonly list: Y.Array<unknown>;
-    readonly movableList: undefined;
-    readonly struct: Y.Map<unknown>;
-    readonly map: Y.Map<unknown>;
-    readonly tree: undefined;
-    readonly set: undefined;
-    readonly scalar: undefined;
-    readonly sum: undefined;
+  readonly root: Y.Doc;
+  readonly text: Y.Text;
+  readonly counter: undefined;
+  readonly list: Y.Array<unknown>;
+  readonly movableList: undefined;
+  readonly struct: Y.Map<unknown>;
+  readonly map: Y.Map<unknown>;
+  readonly tree: undefined;
+  readonly set: undefined;
+  readonly scalar: undefined;
+  readonly sum: undefined;
 }
-
+//#endregion
+//#region src/bind-yjs.d.ts
+/**
+ * Yjs composition-law tags — the set of concurrent composition laws
+ * that the Yjs substrate faithfully implements.
+ */
+type YjsLaws = "lww" | "positional-ot" | "lww-per-key" | "lww-tag-replaced";
 /**
- * The Yjs CRDT substrate namespace.
+ * The Yjs CRDT binding target.
  *
- * - `yjs.bind(schema)` — collaborative sync (default)
- * - `yjs.bind(schema, "ephemeral")` — ephemeral/presence broadcast
- * - `yjs.replica()` — collaborative replication (default)
- * - `yjs.replica("ephemeral")` — ephemeral replication
+ * - `yjs.bind(schema)` — bind a schema to Yjs with collaborative sync
+ * - `yjs.replica()` — create a collaborative replica
  *
- * Strategy is constrained to `CrdtStrategy` (`"collaborative" | "ephemeral"`).
- * Passing `"authoritative"` is a compile error.
+ * Laws are constrained to `YjsLaws` — schemas requiring composition laws
+ * outside this set (e.g. `"additive"` from `Schema.counter()`,
+ * `"positional-ot-move"` from `Schema.movableList()`) are rejected at
+ * compile time.
  *
  * To access the underlying Y.Doc, use `unwrap(ref)` from `@kyneta/schema`.
  */
-/** The closed set of capability tags that the Yjs substrate supports. */
-type YjsCaps = "text" | "json";
-declare const yjs: SubstrateNamespace<CrdtStrategy, YjsCaps, YjsNativeMap>;
-
+declare const yjs: BindingTarget<YjsLaws, YjsNativeMap>;
+//#endregion
+//#region src/change-mapping.d.ts
 /**
  * Apply a kyneta Change to the Yjs shared type tree imperatively.
  *
@@ -62,7 +68,7 @@ declare const yjs: SubstrateNamespace<CrdtStrategy, YjsCaps, YjsNativeMap>;
  * @param path - The path to the target
  * @param change - The kyneta Change to apply
  */
-declare function applyChangeToYjs(rootMap: Y.Map<any>, rootSchema: Schema, path: Path, change: ChangeBase): void;
+declare function applyChangeToYjs(rootMap: Y.Map<any>, rootSchema: Schema$1, path: Path, change: ChangeBase, binding?: SchemaBinding): void;
 /**
  * Convert `observeDeep` events into kyneta `Op[]` for changefeed delivery.
  *
@@ -76,8 +82,9 @@ declare function applyChangeToYjs(rootMap: Y.Map<any>, rootSchema: Schema, path:
  *
  * @param events - The events from the `observeDeep` callback
  */
-declare function eventsToOps(events: Y.YEvent<any>[], schema: Schema): Op[];
-
+declare function eventsToOps(events: Y.YEvent<any>[], schema: Schema$1, binding?: SchemaBinding): Op$1[];
+//#endregion
+//#region src/populate.d.ts
 /**
  * Ensure that a Y.Doc's root map contains the correct Yjs shared types
  * matching the schema structure.
@@ -100,13 +107,35 @@ declare function eventsToOps(events: Y.YEvent<any>[], schema: Schema): Op[];
  * 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.
  */
-declare function ensureContainers(doc: Y.Doc, schema: Schema, conditional?: boolean): void;
-
+declare function ensureContainers(doc: Y.Doc, schema: Schema$1, conditional?: boolean, binding?: SchemaBinding): void;
+//#endregion
+//#region src/position.d.ts
+/** Map kyneta Side to Yjs assoc. Left → -1 (left-sticky), Right → 0 (right-sticky). */
+declare function toYjsAssoc(side: Side): number;
+/** Map Yjs assoc to kyneta Side. Negative → left, non-negative → right. */
+declare function fromYjsAssoc(assoc: number): Side;
+declare class YjsPosition implements Position {
+  private readonly rpos;
+  private readonly doc;
+  readonly side: Side;
+  constructor(rpos: Y.RelativePosition, doc: Y.Doc);
+  resolve(): number | null;
+  encode(): Uint8Array;
+  transform(_instructions: readonly Instruction[]): void;
+}
+//#endregion
+//#region src/reader.d.ts
 /**
  * Creates a Reader that navigates the Yjs shared type tree live,
  * using the schema as a type witness to determine navigation at each
@@ -120,58 +149,106 @@ declare function ensureContainers(doc: Y.Doc, schema: Schema, conditional?: bool
  *
  * @param doc - The Y.Doc to read from.
  * @param schema - The root schema for the document.
+ * @param binding - Optional SchemaBinding for identity-keyed navigation.
  */
-declare function yjsReader(doc: Y.Doc, schema: Schema): Reader;
-
+declare function yjsReader(doc: Y.Doc, schema: Schema$1, binding?: SchemaBinding): Reader;
+//#endregion
+//#region src/version.d.ts
 /**
- * A Version wrapping a Yjs state vector.
+ * A Version wrapping a Yjs snapshot (state vector + delete set).
  *
- * State vectors track the complete peer state — which operations from
- * each client have been observed. This is the right abstraction for sync
- * diffing: `exportSince(version)` uses the state vector to compute the
- * minimal update payload via `Y.encodeStateAsUpdate(doc, sv)`.
+ * The state vector tracks which insertions from each client have been
+ * observed. The delete set tracks which of those items have been
+ * tombstoned. Together they fully describe a Yjs document's state.
  *
- * `serialize()` encodes to base64 for text-safe embedding.
- * `compare()` decodes both state vectors and performs standard
- * version-vector partial-order comparison over the client-clock maps.
+ * - `sv` is used by `exportSince()` to compute the minimal update payload
+ *   via `Y.encodeStateAsUpdate(doc, sv)`.
+ * - `snapshotBytes` is the encoded Yjs `Snapshot` (SV + delete set),
+ *   used for equality comparison: two documents are "equal" only when
+ *   both their inserts and deletes match.
+ *
+ * `compare()` first performs standard version-vector partial-order
+ * comparison on the state vectors. If the SVs are equal, it falls
+ * through to a byte-level comparison of the snapshot bytes — if they
+ * differ (same inserts, different deletes), the result is "concurrent",
+ * ensuring the sync protocol pushes the divergent deletes.
  */
 declare class YjsVersion implements Version {
-    readonly sv: Uint8Array;
-    constructor(sv: Uint8Array);
-    /**
-     * Serialize the state vector to a base64 string.
-     *
-     * The encoding is: raw state vector bytes → base64.
-     * This is text-safe for embedding in HTML meta tags, URL parameters, etc.
-     */
-    serialize(): string;
-    /**
-     * Compare with another version using version-vector partial order.
-     *
-     * Delegates to the shared `versionVectorCompare` utility after decoding
-     * both state vectors via `Y.decodeStateVector()`.
-     *
-     * @throws If `other` is not a `YjsVersion`.
-     */
-    compare(other: Version): "behind" | "equal" | "ahead" | "concurrent";
-    /**
-     * Greatest lower bound (lattice meet) of two Yjs versions.
-     *
-     * Decodes both state vectors, computes the component-wise minimum
-     * via the shared `versionVectorMeet` utility, and encodes the result
-     * back to a Yjs state vector.
-     *
-     * @throws If `other` is not a `YjsVersion`.
-     */
-    meet(other: Version): YjsVersion;
-    /**
-     * Parse a serialized YjsVersion string back into a YjsVersion.
-     *
-     * The inverse of `serialize()`: base64 → `Uint8Array`.
-     */
-    static parse(serialized: string): YjsVersion;
+  /** Encoded state vector — used by exportSince(). */
+  readonly sv: Uint8Array;
+  /**
+   * Encoded Yjs snapshot (state vector + delete set) — used for equality
+   * comparison. Two documents are "equal" only if both their inserts
+   * (state vector) and deletes (delete set) match.
+   */
+  readonly snapshotBytes: Uint8Array;
+  constructor(sv: Uint8Array, snapshotBytes?: Uint8Array);
+  /**
+   * Construct a version from a live `Y.Doc` by snapshotting its full state.
+   *
+   * Walks the struct store to derive the delete set — O(n) in the number
+   * of items. Use {@link fromDeleteSet} for the incremental path.
+   */
+  static fromDoc(doc: Doc): YjsVersion;
+  /**
+   * Construct a version from a `Y.Doc`'s state vector and an externally
+   * maintained delete set — the incremental path that avoids a struct
+   * store walk.
+   *
+   * @param doc  The live Y.Doc (for the state vector).
+   * @param ds   An accumulated delete set, kept in sync by merging
+   *             `transaction.deleteSet` on each transaction.
+   */
+  static fromDeleteSet(doc: Doc, ds: ReturnType<typeof Y.createDeleteSet>): YjsVersion;
+  /**
+   * Serialize to a text-safe string.
+   *
+   * Format: `base64(sv) + "." + base64(snapshotBytes)`.
+   * The "." separator is unambiguous since base64 never contains ".".
+   */
+  serialize(): string;
+  /**
+   * Compare with another version using version-vector partial order,
+   * extended with delete-set equality checking.
+   *
+   * 1. Decode both state vectors and compare via `versionVectorCompare`.
+   * 2. If the SV comparison yields anything other than "equal", return it.
+   * 3. If the SVs are equal, compare snapshot bytes for byte equality.
+   *    If they differ (same inserts, different deletes), return "concurrent"
+   *    — both sides may have tombstones the other lacks.
+   * 4. "equal" is returned only when BOTH the state vector AND the
+   *    delete set match.
+   *
+   * @throws If `other` is not a `YjsVersion`.
+   */
+  compare(other: Version): "behind" | "equal" | "ahead" | "concurrent";
+  /**
+   * Greatest lower bound (lattice meet) of two Yjs versions.
+   *
+   * Decodes both state vectors, computes the component-wise minimum
+   * via `versionVectorMeet`, and encodes the result back to a Yjs
+   * state vector.
+   *
+   * The meet snapshot uses the meet SV with no delete-set information
+   * (conservative lower bound). meet() feeds into advance(), which Yjs
+   * does not support incrementally, so this is safe.
+   *
+   * @throws If `other` is not a `YjsVersion`.
+   */
+  meet(other: Version): YjsVersion;
+  /**
+   * Parse a serialized YjsVersion string back into a YjsVersion.
+   *
+   * New format: `base64(sv) + "." + base64(snapshotBytes)`.
+   * Legacy format (no "."): `base64(sv)` only — constructed with
+   * `snapshotBytes` equal to the SV bytes. When compared against a
+   * new-format version with matching SVs, the differing snapshot bytes
+   * yield "concurrent", triggering a safe redundant sync push.
+   */
+  static parse(serialized: string): YjsVersion;
 }
-
+//#endregion
+//#region src/substrate.d.ts
 /**
  * Creates a `Substrate<YjsVersion>` wrapping a user-provided Y.Doc.
  *
@@ -189,37 +266,59 @@ declare class YjsVersion implements Version {
  * @param doc - The Y.Doc to wrap. The substrate does NOT own the doc;
  *   the caller is responsible for its lifecycle.
  * @param schema - The root schema for the document.
+ * @param binding - Optional SchemaBinding for identity-keyed containers.
  */
-declare function createYjsSubstrate(doc: Y.Doc, schema: Schema): Substrate<YjsVersion>;
+declare function createYjsSubstrate(doc: Y.Doc, schema: Schema$1, binding?: SchemaBinding): Substrate<YjsVersion>;
 declare const yjsReplicaFactory: ReplicaFactory<YjsVersion>;
 declare const yjsSubstrateFactory: SubstrateFactory<YjsVersion>;
-
+//#endregion
+//#region src/yjs-resolve.d.ts
 /**
  * Navigate one step deeper into the Yjs shared type tree.
  *
  * Uses `instanceof` for runtime type discrimination:
- * - `Y.Map` → `.get(key)`
+ * - `Y.Map` → `.get(key)` — uses the identity hash when provided
  * - `Y.Array` → `.get(index)`
  * - `Y.Text` → terminal (cannot step further)
  * - Plain value → terminal (return `undefined`)
  *
  * @param current - The current position (a Yjs shared type or plain value)
  * @param segment - The path segment to follow
+ * @param identity - Optional identity hash to use instead of the segment's resolved value
  */
-declare function stepIntoYjs(current: unknown, segment: Segment): unknown;
+declare function stepIntoYjs(current: unknown, segment: Segment, identity?: string): unknown;
+/**
+ * Result of resolving a Yjs shared type at a path.
+ *
+ * Includes both the resolved Yjs value and the schema at that position,
+ * enabling callers to distinguish between schema kinds that map to the
+ * same Yjs type (e.g. "text" vs "richtext" both use Y.Text).
+ */
+interface ResolvedYjs {
+  readonly resolved: unknown;
+  readonly schema: Schema$1;
+}
 /**
  * Resolve a Yjs shared type (or plain value) at the given path.
  *
  * Left-folds over path segments using `advanceSchema` for pure schema
  * descent and `stepIntoYjs` for Yjs-specific navigation.
  *
- * Returns the Yjs shared type or plain value at the terminal position.
- * For an empty path, returns the root map itself.
+ * When a `binding` is provided, each step computes the absolute schema
+ * path and looks up the identity hash from `binding.forward`. This
+ * identity hash is used instead of the field name at every product-field
+ * boundary (root and nested).
+ *
+ * Returns both the Yjs shared type (or plain value) and the schema at
+ * the terminal position. For an empty path, returns the root map and
+ * root schema.
  *
  * @param rootMap - The root `Y.Map` obtained via `doc.getMap("root")`
  * @param rootSchema - The root document schema
  * @param path - The path to resolve
+ * @param binding - Optional SchemaBinding for identity-keyed navigation.
  */
-declare function resolveYjsType(rootMap: Y.Map<any>, rootSchema: Schema, path: Path): unknown;
-
-export { type YjsCaps, type YjsNativeMap, YjsVersion, applyChangeToYjs, createYjsSubstrate, ensureContainers, eventsToOps, resolveYjsType, stepIntoYjs, yjs, yjsReader, yjsReplicaFactory, yjsSubstrateFactory };
+declare function resolveYjsType(rootMap: Y.Map<any>, rootSchema: Schema$1, path: Path, binding?: SchemaBinding): ResolvedYjs;
+//#endregion
+export { type Changeset, type DocRef, NATIVE, type Op, type Ref, Schema, type SubstratePayload, type YjsLaws, type YjsNativeMap, YjsPosition, YjsVersion, applyChangeToYjs, applyChanges, change, createDoc, createRef, createYjsSubstrate, ensureContainers, eventsToOps, exportEntirety, exportSince, fromYjsAssoc, merge, resolveYjsType, stepIntoYjs, subscribe, subscribeNode, toYjsAssoc, unwrap, version, yjs, yjsReader, yjsReplicaFactory, yjsSubstrateFactory };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/native-map.ts","../src/bind-yjs.ts","../src/change-mapping.ts","../src/populate.ts","../src/position.ts","../src/reader.ts","../src/version.ts","../src/substrate.ts","../src/yjs-resolve.ts"],"mappings":"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"}