@absolutejs/sync 0.10.0 → 0.12.0

package/README.md

@@ -345,30 +345,33 @@ it, ~3 store round-trips every 20ms ran the voice pipeline far slower than real
 
 ### `@absolutejs/sync/client`
 
-| Export                                            | What it is                                                                                                                                                         |
-| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `createSyncSubscriber({ topics, onEvent, url? })` | Browser SSE client.                                                                                                                                                |
-| `createLiveQuery({ topics, fetcher, ... })`       | Hydrate-once, refetch-on-event observable query store.                                                                                                             |
-| `jsonFetcher(url, init?)`                         | Default `fetcher`: GET + JSON parse, forwards the abort signal.                                                                                                    |
-| `createSyncCollection({ url, collection, ... })`  | Live diff-driven collection store with optimistic `mutate`.                                                                                                        |
-| `createSyncClient({ url })`                       | One socket, many collections (`client.collection(...)`). Applies a multi-collection mutation's diffs as one **consistent frame** — no torn cross-collection paint. |
-| `createPresence({ url, room, state })`            | Join a presence room: see who's online / typing (`get` + `subscribe`) and publish your own state (`set`).                                                          |
-| `localStorageMutationStorage(key)`                | `localStorage`-backed offline write queue for `createSyncCollection`.                                                                                              |
-| `localStorageCollectionCache(key)`                | `localStorage`-backed local-first read cache: confirmed rows survive a reload, resume from the cached version.                                                     |
-| `indexedDbCollectionCache({ key, ... })`          | IndexedDB-backed local-first read cache — durable, large-capacity. Same resume semantics, async storage.                                                           |
+| Export                                                         | What it is                                                                                                                                                                                                                                                             |
+| -------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `createSyncSubscriber({ topics, onEvent, url? })`              | Browser SSE client.                                                                                                                                                                                                                                                    |
+| `createLiveQuery({ topics, fetcher, ... })`                    | Hydrate-once, refetch-on-event observable query store.                                                                                                                                                                                                                 |
+| `jsonFetcher(url, init?)`                                      | Default `fetcher`: GET + JSON parse, forwards the abort signal.                                                                                                                                                                                                        |
+| `createSyncCollection({ url, collection, ... })`               | Live diff-driven collection store with optimistic `mutate`.                                                                                                                                                                                                            |
+| `createSyncClient({ url })`                                    | One socket, many collections (`client.collection(...)`). Applies a multi-collection mutation's diffs as one **consistent frame** — no torn cross-collection paint.                                                                                                     |
+| `createPresence({ url, room, state })`                         | Join a presence room: see who's online / typing (`get` + `subscribe`) and publish your own state (`set`).                                                                                                                                                              |
+| `createCollaborativeText({ url, collection, id, field, ... })` | Live CRDT collaborative-text controller (`get`/`subscribe`/`setText`/`close`): tracks a row's CRDT field, merges remote edits into a local replica, and broadcasts via the engine's `"<collection>:merge"` mutation. Backs the `useCollaborativeText` framework hooks. |
+| `localStorageMutationStorage(key)`                             | `localStorage`-backed offline write queue for `createSyncCollection`.                                                                                                                                                                                                  |
+| `localStorageCollectionCache(key)`                             | `localStorage`-backed local-first read cache: confirmed rows survive a reload, resume from the cached version.                                                                                                                                                         |
+| `indexedDbCollectionCache({ key, ... })`                       | IndexedDB-backed local-first read cache — durable, large-capacity. Same resume semantics, async storage.                                                                                                                                                               |
 
 ### Framework bindings — `@absolutejs/sync/{react,vue,svelte,angular}`
 
 Idiomatic wrappers over `createSyncCollection`, one per framework, so a live
 collection is one call. Each returns the same `{ data, status, error, mutate }`
-and is SSR-safe (the socket opens on the client only).
+and is SSR-safe (the socket opens on the client only). Each also ships a
+**collaborative-text** binding over `createCollaborativeText` — a CRDT shared text
+field in one call (`text`/`setText`/`status`).
 
-| Subpath    | Export                                   | What it is                                           |
-| ---------- | ---------------------------------------- | ---------------------------------------------------- |
-| `/react`   | `useSyncCollection(options)`             | React hook (re-renders on diffs).                    |
-| `/vue`     | `useSyncCollection(options)`             | Vue composable (reactive refs).                      |
-| `/svelte`  | `createSyncCollectionStore(options)`     | Svelte readable store (`$store` → state) + `mutate`. |
-| `/angular` | `SyncCollectionService.connect(options)` | Angular service returning signals.                   |
+| Subpath    | Collection                               | Collaborative text                              |
+| ---------- | ---------------------------------------- | ----------------------------------------------- |
+| `/react`   | `useSyncCollection(options)`             | `useCollaborativeText(options)`                 |
+| `/vue`     | `useSyncCollection(options)`             | `useCollaborativeText(options)`                 |
+| `/svelte`  | `createSyncCollectionStore(options)`     | `createCollaborativeTextStore(options)`         |
+| `/angular` | `SyncCollectionService.connect(options)` | `SyncCollectionService.collaborativeText(opts)` |
 
 ```tsx
 // React
@@ -389,38 +392,39 @@ mutate({
 
 ### `@absolutejs/sync/engine`
 
-| Export                                                                                   | What it is                                                                                                                                                                                                             |
-| ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `createSyncEngine()`                                                                     | Registry + view syncer: `register`, `subscribe`, `applyChange`, `connectSource`, `registerMutation`, `registerWriter`, `runMutation`.                                                                                  |
-| `defineCollection({ name, hydrate, key?, match?, authorize?, tables? })`                 | Define a syncable collection.                                                                                                                                                                                          |
-| `defineMutation({ name, handler, authorize? })`                                          | Define a server mutation. Its `handler` gets `actions.insert/update/delete` (write through a registered `TableWriter` → persists + emits in one step) plus `actions.change` (escape hatch). Changes commit atomically. |
-| `registerWriter(table, { insert, update, delete })`                                      | Teach the engine how to persist a table (any ORM), so writes auto-emit — you can't write without going live.                                                                                                           |
-| `createAggregate({ key, groupBy?, value? })`                                             | Incremental count/sum/avg/min/max by group.                                                                                                                                                                            |
-| `createMaterializedView({ key, match, equals? })`                                        | The predicate-matching IVM primitive (`apply`/`reset` → diffs).                                                                                                                                                        |
-| `createPollingChangeSource({ poll, intervalMs?, startSeq?, onProcessed? })`              | DB-agnostic CDC `ChangeSource` that tails a changelog (outbox) table.                                                                                                                                                  |
-| `engine.connectCluster(bus)` + `createInMemoryClusterBus()`                              | Horizontal scale: fan changes across server instances over a `ClusterBus` (BYO Redis/Postgres; in-memory bus for dev).                                                                                                 |
-| `createPresenceHub()` + `syncSocket({ engine, presence })`                               | Ephemeral room-scoped presence (online / typing / cursors) over the same socket — not persisted, auto-cleaned on disconnect.                                                                                           |
-| `query(source).filter().map().join().leftJoin().groupBy().orderBy()`                     | Declarative incremental query builder (the operator graph).                                                                                                                                                            |
-| `defineGraphCollection({ name, query, key, authorize? })`                                | Run a `query` as a live collection.                                                                                                                                                                                    |
-| `defineReactiveQuery({ name, run, key })` + `registerReactive` / `registerReader`        | Read-set-tracked query: `run(ctx)` reads via `ctx.db` (`all`/`get`/`where`) and re-runs only when the rows/ranges it read change — no `match`, no manual emit.                                                         |
-| `definePermissions({ [table]: { read?, insert?, update?, delete?, write? } })`           | Declarative row-level access control. Pass as `createSyncEngine({ permissions })` or `registerPermissions(table, rules)`. Read rules filter every row emitted; write rules gate `actions.insert/update/delete`.        |
-| `defineSchema({ [table]: { fields, version?, migrate? } })` + `field` kit                | Declarative row schema. Pass as `createSyncEngine({ schemas })` or `registerSchema(table, schema)`. Writes are validated (bad write → `SchemaError`); `migrate` lazily upcasts rows on read (no DB migration needed).  |
-| `defineSearchCollection({ name, table, index, source, key, limit? })` + `registerSearch` | Live search collection: the subscription's `params` are the query (string/vector), the ranked top-K stream back as a normal collection, re-ranked as rows change. Each row carries its score under `_score`.           |
-| `createTextIndex({ key, fields, tokenize?, stopwords?, k1?, b? })`                       | Incremental BM25 full-text index (keyword search). Implements `SearchIndex`; usable standalone or inside a search collection.                                                                                          |
-| `createVectorIndex({ key, embedding, metric? })`                                         | Incremental vector index (cosine/dot/euclidean exact k-NN) for semantic search — pairs with `@absolutejs/ai` / `@absolutejs/rag` for RAG retrieval on your own data.                                                   |
-| `defineSchedule({ name, pattern, run })` + `registerSchedule` / `runSchedule`            | Scheduled function: `run({ db, actions })` fires on a cron `pattern`; its writes go live through the change feed. Wire triggers with the `scheduled` plugin (or call `runSchedule(name)` on demand).                   |
+| Export                                                                                   | What it is                                                                                                                                                                                                                                                                                                                               |
+| ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `createSyncEngine()`                                                                     | Registry + view syncer: `register`, `subscribe`, `applyChange`, `connectSource`, `registerMutation`, `registerWriter`, `runMutation`.                                                                                                                                                                                                    |
+| `defineCollection({ name, hydrate, key?, match?, authorize?, tables? })`                 | Define a syncable collection.                                                                                                                                                                                                                                                                                                            |
+| `defineMutation({ name, handler, authorize? })`                                          | Define a server mutation. Its `handler` gets `actions.insert/update/delete` (write through a registered `TableWriter` → persists + emits in one step) plus `actions.change` (escape hatch). Changes commit atomically.                                                                                                                   |
+| `registerWriter(table, { insert, update, delete })`                                      | Teach the engine how to persist a table (any ORM), so writes auto-emit — you can't write without going live.                                                                                                                                                                                                                             |
+| `createAggregate({ key, groupBy?, value? })`                                             | Incremental count/sum/avg/min/max by group.                                                                                                                                                                                                                                                                                              |
+| `createMaterializedView({ key, match, equals? })`                                        | The predicate-matching IVM primitive (`apply`/`reset` → diffs).                                                                                                                                                                                                                                                                          |
+| `createPollingChangeSource({ poll, intervalMs?, startSeq?, onProcessed? })`              | DB-agnostic CDC `ChangeSource` that tails a changelog (outbox) table.                                                                                                                                                                                                                                                                    |
+| `engine.connectCluster(bus)` + `createInMemoryClusterBus()`                              | Horizontal scale: fan changes across server instances over a `ClusterBus` (BYO Redis/Postgres; in-memory bus for dev).                                                                                                                                                                                                                   |
+| `createPresenceHub()` + `syncSocket({ engine, presence })`                               | Ephemeral room-scoped presence (online / typing / cursors) over the same socket — not persisted, auto-cleaned on disconnect.                                                                                                                                                                                                             |
+| `query(source).filter().map().join().leftJoin().groupBy().orderBy()`                     | Declarative incremental query builder (the operator graph).                                                                                                                                                                                                                                                                              |
+| `defineGraphCollection({ name, query, key, authorize? })`                                | Run a `query` as a live collection.                                                                                                                                                                                                                                                                                                      |
+| `defineReactiveQuery({ name, run, key })` + `registerReactive` / `registerReader`        | Read-set-tracked query: `run(ctx)` reads via `ctx.db` (`all`/`get`/`where`) and re-runs only when the rows/ranges it read change — no `match`, no manual emit.                                                                                                                                                                           |
+| `definePermissions({ [table]: { read?, insert?, update?, delete?, write? } })`           | Declarative row-level access control. Pass as `createSyncEngine({ permissions })` or `registerPermissions(table, rules)`. Read rules filter every row emitted; write rules gate `actions.insert/update/delete`.                                                                                                                          |
+| `defineSchema({ [table]: { fields, version?, migrate? } })` + `field` kit                | Declarative row schema. Pass as `createSyncEngine({ schemas })` or `registerSchema(table, schema)`. Writes are validated (bad write → `SchemaError`); `migrate` lazily upcasts rows on read (no DB migration needed).                                                                                                                    |
+| `registerCrdt(table, { [field]: mergeable })`                                            | Declare CRDT fields (a `CrdtMergeable` like `rgaText`, or `yjsText` from `@absolutejs/sync-yjs`). The engine **merges** those fields on `actions.insert/update` instead of overwriting — conflict-free collaborative editing with no merge code — and auto-registers a `"<table>:merge"` mutation the `useCollaborativeText` hooks call. |
+| `defineSearchCollection({ name, table, index, source, key, limit? })` + `registerSearch` | Live search collection: the subscription's `params` are the query (string/vector), the ranked top-K stream back as a normal collection, re-ranked as rows change. Each row carries its score under `_score`.                                                                                                                             |
+| `createTextIndex({ key, fields, tokenize?, stopwords?, k1?, b? })`                       | Incremental BM25 full-text index (keyword search). Implements `SearchIndex`; usable standalone or inside a search collection.                                                                                                                                                                                                            |
+| `createVectorIndex({ key, embedding, metric? })`                                         | Incremental vector index (cosine/dot/euclidean exact k-NN) for semantic search — pairs with `@absolutejs/ai` / `@absolutejs/rag` for RAG retrieval on your own data.                                                                                                                                                                     |
+| `defineSchedule({ name, pattern, run })` + `registerSchedule` / `runSchedule`            | Scheduled function: `run({ db, actions })` fires on a cron `pattern`; its writes go live through the change feed. Wire triggers with the `scheduled` plugin (or call `runSchedule(name)` on demand).                                                                                                                                     |
 
 ### `@absolutejs/sync/crdt`
 
-Conflict-free replicated data types — pure, **zero-dependency**, and isomorphic (same code client and server). They merge concurrent edits from different tabs/devices without a server round-trip per keystroke and without clobbering: every `merge` is commutative, associative, and idempotent, so replicas converge no matter the order. They ride the existing engine with no engine changes — store the CRDT state as a row field and have a mutation `merge` the incoming state into the stored one.
+Conflict-free replicated data types — pure, **zero-dependency**, and isomorphic (same code client and server). They merge concurrent edits from different tabs/devices without a server round-trip per keystroke and without clobbering: every `merge` is commutative, associative, and idempotent, so replicas converge no matter the order. They ride the existing engine with no engine changes — store the CRDT state as a row field. The declarative path is one line each end: server `engine.registerCrdt(table, { field: rgaText })` (auto-merges that field on write), client `useCollaborativeText({ collection, id, field, url })`. The primitives below are also usable directly.
 
-| Export                                       | What it is                                                                                                                                                                                                                         |
-| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `counter`                                    | PN-counter: `create/value/increment/decrement/merge`. Concurrent increments and decrements across replicas all survive.                                                                                                            |
-| `lww`                                        | Last-write-wins register: `create/set/merge`. The latest timestamp wins (replica id breaks ties) — for "just take the newest value" fields.                                                                                        |
-| `createTextCrdt(replica, initial?)`          | Collaborative text (an RGA sequence CRDT): `text/insert/delete/setText/merge/state`. Drive it from an input via `setText`; broadcast `state()`; apply remote state via `merge` — concurrent edits merge and converge.              |
-| `textOf(state)` / `mergeTextState(a, b)`     | Pure helpers for the text state — use them server-side (e.g. a merge-on-write mutation) with no live instance.                                                                                                                     |
-| `CrdtText<State>` / `TextCrdtAdapter<State>` | The pluggable collaborative-text contract. `rgaText` is the first-party (zero-dep) backend; swap in an adapter from the `sync-adapters` repo (e.g. `@absolutejs/sync-yjs`, which wraps the Yjs staple) behind the same call sites. |
+| Export                                       | What it is                                                                                                                                                                                                                                                                                           |
+| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `counter`                                    | PN-counter: `create/value/increment/decrement/merge`. Concurrent increments and decrements across replicas all survive.                                                                                                                                                                              |
+| `lww`                                        | Last-write-wins register: `create/set/merge`. The latest timestamp wins (replica id breaks ties) — for "just take the newest value" fields.                                                                                                                                                          |
+| `createTextCrdt(replica, initial?)`          | Collaborative text (an RGA sequence CRDT): `text/insert/delete/setText/merge/state` + `takeDelta`. Drive it via `setText`; apply remote state via `merge`; `takeDelta()` returns just this client's new ops (a delta-state) so uploads are O(edit), not O(doc). Concurrent edits merge and converge. |
+| `textOf(state)` / `mergeTextState(a, b)`     | Pure helpers for the text state — use them server-side (e.g. a merge-on-write mutation) with no live instance.                                                                                                                                                                                       |
+| `CrdtText<State>` / `TextCrdtAdapter<State>` | The pluggable collaborative-text contract. `rgaText` is the first-party (zero-dep) backend; swap in an adapter from the `sync-adapters` repo (e.g. `@absolutejs/sync-yjs`, which wraps the Yjs staple) behind the same call sites.                                                                   |
 
 ### `@absolutejs/sync/postgres`
 

package/dist/angular/index.js

@@ -68,6 +68,191 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
 
+// src/crdt/index.ts
+var sumValues = (counts) => Object.values(counts).reduce((total, value) => total + value, 0);
+var mergeMax = (a, b) => {
+  const merged = { ...a };
+  for (const [replica, value] of Object.entries(b)) {
+    merged[replica] = Math.max(merged[replica] ?? 0, value);
+  }
+  return merged;
+};
+var counter = {
+  create: () => ({ increments: {}, decrements: {} }),
+  value: (state) => sumValues(state.increments) - sumValues(state.decrements),
+  increment: (state, replica, by = 1) => ({
+    increments: {
+      ...state.increments,
+      [replica]: (state.increments[replica] ?? 0) + by
+    },
+    decrements: state.decrements
+  }),
+  decrement: (state, replica, by = 1) => ({
+    increments: state.increments,
+    decrements: {
+      ...state.decrements,
+      [replica]: (state.decrements[replica] ?? 0) + by
+    }
+  }),
+  merge: (a, b) => ({
+    increments: mergeMax(a.increments, b.increments),
+    decrements: mergeMax(a.decrements, b.decrements)
+  })
+};
+var lww = {
+  create: (value, replica, timestamp = Date.now()) => ({ value, timestamp, replica }),
+  set: (value, replica, timestamp = Date.now()) => ({
+    value,
+    timestamp,
+    replica
+  }),
+  merge: (a, b) => {
+    if (b.timestamp > a.timestamp) {
+      return b;
+    }
+    if (b.timestamp < a.timestamp) {
+      return a;
+    }
+    return b.replica > a.replica ? b : a;
+  }
+};
+var compare = (a, b) => {
+  if (a.clock !== b.clock) {
+    return b.clock - a.clock;
+  }
+  if (a.replica === b.replica) {
+    return 0;
+  }
+  return a.replica > b.replica ? -1 : 1;
+};
+var linearize = (elements) => {
+  const children = new Map;
+  for (const element of elements) {
+    const list = children.get(element.after);
+    if (list === undefined) {
+      children.set(element.after, [element]);
+    } else {
+      list.push(element);
+    }
+  }
+  for (const list of children.values()) {
+    list.sort(compare);
+  }
+  const ordered = [];
+  const stack = [...children.get(null) ?? []].reverse();
+  while (stack.length > 0) {
+    const element = stack.pop();
+    ordered.push(element);
+    const kids = children.get(element.id);
+    if (kids !== undefined) {
+      for (let index = kids.length - 1;index >= 0; index -= 1) {
+        stack.push(kids[index]);
+      }
+    }
+  }
+  return ordered;
+};
+var textOf = (state) => linearize(state.elements).filter((element) => !element.deleted).map((element) => element.value).join("");
+var mergeTextState = (a, b) => {
+  const byId = new Map;
+  for (const element of [...a.elements, ...b.elements]) {
+    const existing = byId.get(element.id);
+    byId.set(element.id, existing === undefined ? element : { ...existing, deleted: existing.deleted || element.deleted });
+  }
+  return { elements: [...byId.values()] };
+};
+var createTextCrdt = (replica, initial) => {
+  const elements = new Map;
+  const pending = new Map;
+  let clock = 0;
+  if (initial !== undefined) {
+    for (const element of initial.elements) {
+      elements.set(element.id, element);
+      clock = Math.max(clock, element.clock);
+    }
+  }
+  const visible = () => linearize([...elements.values()]).filter((element) => !element.deleted);
+  const insert = (index, value) => {
+    const seen = visible();
+    let after = index <= 0 ? null : seen[index - 1]?.id ?? null;
+    for (const char of [...value]) {
+      clock += 1;
+      const element = {
+        id: `${replica}:${clock}`,
+        replica,
+        clock,
+        after,
+        value: char,
+        deleted: false
+      };
+      elements.set(element.id, element);
+      pending.set(element.id, element);
+      after = element.id;
+    }
+  };
+  const remove = (index, count) => {
+    const seen = visible();
+    for (let offset = 0;offset < count; offset += 1) {
+      const target = seen[index + offset];
+      if (target !== undefined) {
+        const tombstoned = { ...target, deleted: true };
+        elements.set(target.id, tombstoned);
+        pending.set(target.id, tombstoned);
+      }
+    }
+  };
+  return {
+    text: () => textOf({ elements: [...elements.values()] }),
+    insert,
+    delete: remove,
+    merge: (state) => {
+      for (const element of state.elements) {
+        const existing = elements.get(element.id);
+        elements.set(element.id, existing === undefined ? element : {
+          ...existing,
+          deleted: existing.deleted || element.deleted
+        });
+        clock = Math.max(clock, element.clock);
+      }
+    },
+    setText: (next) => {
+      const current = textOf({ elements: [...elements.values()] });
+      if (current === next) {
+        return;
+      }
+      let prefix = 0;
+      const maxPrefix = Math.min(current.length, next.length);
+      while (prefix < maxPrefix && current[prefix] === next[prefix]) {
+        prefix += 1;
+      }
+      let suffix = 0;
+      while (suffix < maxPrefix - prefix && current[current.length - 1 - suffix] === next[next.length - 1 - suffix]) {
+        suffix += 1;
+      }
+      const removed = current.length - prefix - suffix;
+      if (removed > 0) {
+        remove(prefix, removed);
+      }
+      const inserted = next.slice(prefix, next.length - suffix);
+      if (inserted.length > 0) {
+        insert(prefix, inserted);
+      }
+    },
+    state: () => ({ elements: [...elements.values()] }),
+    takeDelta: () => {
+      const delta = { elements: [...pending.values()] };
+      pending.clear();
+      return delta;
+    }
+  };
+};
+var rgaText = {
+  create: createTextCrdt,
+  empty: () => ({ elements: [] }),
+  merge: mergeTextState,
+  textOf
+};
+
 // src/angular/sync-collection.service.ts
 import { computed, Injectable, signal } from "@angular/core";
 
@@ -390,6 +575,65 @@ var createSyncCollection = (options) => {
   };
 };
 
+// src/client/collaborativeText.ts
+var createCollaborativeText = (options) => {
+  const keyField = options.keyField ?? "id";
+  const mutation = options.mutation ?? `${options.collection}:merge`;
+  const replica = options.replica ?? globalThis.crypto.randomUUID();
+  const make = options.create ?? ((id) => createTextCrdt(id));
+  const crdt = make(replica);
+  let current = { status: "connecting", text: "" };
+  const subscribers = new Set;
+  const emit = () => {
+    for (const run of subscribers) {
+      run(current);
+    }
+  };
+  const collection = createSyncCollection({
+    collection: options.collection,
+    key: (row) => row[keyField],
+    url: options.url
+  });
+  const apply = (state) => {
+    let { text } = current;
+    const row = state.data.find((candidate) => candidate[keyField] === options.id);
+    const fieldState = row?.[options.field];
+    if (fieldState !== undefined) {
+      crdt.merge(fieldState);
+      text = crdt.text();
+    }
+    current = { status: state.status, text };
+    emit();
+  };
+  apply(collection.get());
+  const unsubscribe = collection.subscribe(apply);
+  return {
+    get: () => current,
+    subscribe(run) {
+      subscribers.add(run);
+      run(current);
+      return () => {
+        subscribers.delete(run);
+      };
+    },
+    setText(next) {
+      crdt.setText(next);
+      current = { status: current.status, text: next };
+      emit();
+      const payload = crdt.takeDelta ? crdt.takeDelta() : crdt.state();
+      collection.mutate({
+        args: { [keyField]: options.id, [options.field]: payload },
+        name: mutation
+      });
+    },
+    close() {
+      unsubscribe();
+      collection.close();
+      subscribers.clear();
+    }
+  };
+};
+
 // src/angular/sync-collection.service.ts
 var _dec = [
   Injectable({ providedIn: "root" })
@@ -398,6 +642,7 @@ var _init = __decoratorStart(undefined);
 
 class SyncCollectionService {
   collections = new Set;
+  texts = new Set;
   connect(options) {
     const data = signal([]);
     const status = signal("connecting");
@@ -422,11 +667,34 @@ class SyncCollectionService {
       status: computed(() => status())
     };
   }
+  collaborativeText(options) {
+    const text = signal("");
+    const status = signal("connecting");
+    let controller = null;
+    if (typeof window !== "undefined") {
+      controller = createCollaborativeText(options);
+      this.texts.add(controller);
+      controller.subscribe((state) => {
+        text.set(state.text);
+        status.set(state.status);
+      });
+    }
+    const setText = (next) => controller?.setText(next);
+    return {
+      setText,
+      status: computed(() => status()),
+      text: computed(() => text())
+    };
+  }
   ngOnDestroy() {
     for (const collection of this.collections) {
       collection.close();
     }
     this.collections.clear();
+    for (const text of this.texts) {
+      text.close();
+    }
+    this.texts.clear();
   }
 }
 SyncCollectionService = __decorateElement(_init, 0, "SyncCollectionService", _dec, SyncCollectionService);
@@ -437,5 +705,5 @@ export {
   SyncCollectionService
 };
 
-//# debugId=C534ED0FEAC9CC6664756E2164756E21
+//# debugId=248B59EB4C19056664756E2164756E21
 //# sourceMappingURL=index.js.map