@doxsync/core 0.1.0-alpha.2 → 0.1.0-alpha.4

package/README.md

@@ -1,207 +1,96 @@
 # @doxsync/core
 
-ESM bindings for the doxsync Rust synchronization engine, for modern browsers
-and Node.js 22+. Rust owns documents, diffing, message encoding, decoding, and
-state. JavaScript provides loading and a small synchronous API.
+Synchronize documents with compact updates in modern browsers and Node.js 22+.
+ESM and TypeScript are supported; your application supplies the transport.
 
-## Build from this repository
-
-Install Rust, Node.js 22.12+ (or 24+), and `wasm-pack`, then run:
-
-```sh
-rustup target add wasm32-unknown-unknown
-cd doxsync-js
-npm ci
-npm run build
-node examples/node.mjs
-```
-
-`npm run build` runs `wasm-pack` in release mode with the locked Cargo
-dependencies and the `wasm` feature, then builds the TypeScript wrapper with Vite in library mode.
-`vite-plugin-dts` generates type declarations in `dist/`. There are no npm runtime dependencies. To create a local npm
-tarball, run `npm pack`; it builds first and includes the WASM artifact.
-Installing that tarball does not require Rust or wasm-pack.
-
-The Rust crate continues to support native use without JS dependencies:
+## Install
 
 ```sh
-cargo build --manifest-path ../doxsync-rs/Cargo.toml
-cargo build --manifest-path ../doxsync-rs/Cargo.toml \
-  --target wasm32-unknown-unknown --features wasm --release
+npm install @doxsync/core
 ```
 
-The second command produces the Rust WASM artifact. Use `npm run build` to
-also generate the JS glue required to load it.
-
-## Synchronize a document
-
-After installing the package from the local tarball:
+## Quick start
 
 ```js
 import { init, Producer, Consumer, supportedProtocols } from "@doxsync/core";
 
 await init();
-const producer = new Producer({ count: 1n, ratio: 0.5 }, supportedProtocols());
+const producer = new Producer({ count: 1n }, supportedProtocols());
 const consumer = new Consumer();
 
 try {
-  consumer.consumeDiff(producer.produceDiff()); // First message is a snapshot.
-  producer.replace({ count: 2n, ratio: 0.75 });
+  consumer.consumeDiff(producer.produceDiff());
+  producer.replace({ count: 2n });
 
   const message = producer.produceDiff();
   if (message !== undefined) consumer.consumeDiff(message);
 
-  console.log(consumer.document()); // { count: 2n, ratio: 0.75 }
-  console.log(producer.produceDiff()); // undefined: no changes
+  console.log(consumer.document()); // { count: 2n }
 } finally {
   producer.free();
   consumer.free();
 }
 ```
 
-Each `consumeDiff` call takes one complete `Uint8Array` message. Transport is
-up to the application. Messages must be delivered reliably, exactly once, and
-in order to the corresponding consumer: the producer advances its baseline
-when it returns a message. Retain those bytes until delivery; calling
-`produceDiff` again does not retransmit them. For a new connection without
-shared state, create a new producer and consumer and start with a snapshot.
-
-`replace` copies and validates the input before changing the producer. It
-does not emit a message. `document()` returns `undefined` before a snapshot,
-and an independent JS value afterwards (including `null` for a null document).
-Mutating an input, returned document, or returned message does not change the
-engine's stored document. Invalid messages leave consumer state unchanged.
-
-Call `free()` when finished to release WASM resources promptly. It is
-idempotent; business methods throw after release. The generated bindings also
-provide garbage-collection cleanup, but its timing is not deterministic.
-
-## WASM initialization
-
-Call and await `init()` before creating either class or calling
-`supportedProtocols()`. Initialization is the
-only asynchronous operation. Concurrent calls share the first call's promise
-and source; successful initialization is reused, and failed initialization
-can be retried.
-
-- Browsers fetch the WASM next to the generated JS. Serve `dist/` over HTTP;
-  retain the `dist/wasm/` directory and serve `.wasm` as `application/wasm`.
-- Node.js uses the package's conditional export to read the same packaged
-  WASM from disk. Browser entry points contain no Node.js imports.
-- `init(source)` also accepts a URL string, `URL`, `ArrayBuffer`, `Uint8Array`,
-  or compiled `WebAssembly.Module`. Strings are URLs, not filesystem paths.
-  Node.js additionally reads `file:` URLs from disk.
-- Bundlers must deploy the WASM asset. If their asset handling changes its
-  location, pass the deployed URL or bytes explicitly; the package exports
-  the asset as `@doxsync/core/doxsync.wasm` for resolution by build tools.
-
-For a browser example, serve this directory and open `/examples/browser.html`:
+## API and delivery
 
-```sh
-python3 -m http.server 8000
-```
+- `await init(source?)`: initialize once before using the API. Other calls are synchronous.
+- `supportedProtocols()`: get supported versions. For remote peers, pass the
+  **consumer's** advertised list to `new Producer(value, protocols)`.
+- `producer.replace(value)`: validate and copy a new document without sending it.
+- `producer.produceDiff()`: return a `Uint8Array`, or `undefined` if unchanged.
+  The first message contains the complete document.
+- `consumer.consumeDiff(message)`: apply one complete message. Invalid messages
+  throw and leave the consumer unchanged.
+- `consumer.document()`: return an independent copy, or `undefined` before the first message.
+- `free()`: release each instance when finished.
+
+Deliver messages exactly once and in order to the matching consumer. Keep each
+message until delivered: calling `produceDiff()` again does not retransmit it.
+If either side loses its session state, create a new producer and consumer.
+
+## Supported values
 
-The browser demo changes the producer randomly every 1.5 seconds and delivers
-messages after a simulated 1-second delay. It shows both documents, highlights
-updated lines, and lists the actual message bytes and delivery status. Adjust
-the delay or update interval, pause automatic changes, step manually, or reset
-the session. Pausing lets queued messages finish; changing latency never
-reorders messages. Some iterations deliberately leave the document unchanged
-to demonstrate that no message is produced.
-
-Browsers must support WebAssembly, BigInt, ESM, and private class fields. No
-CommonJS entry point or polyfills are supplied.
-
-## Values and errors
-
-| JavaScript | doxsync |
-| --- | --- |
-| `null`, `boolean`, `string` | Null, Bool, UTF-8 text |
-| `number` | Float, including `-0`, NaN, and infinities |
-| `bigint` | Int in `[-2^64, 2^64 - 1]` |
-| `Uint8Array` (including Node Buffer) | Binary string, copied |
-| Dense arrays | Arrays, copied recursively |
-| Plain or null-prototype objects | Maps with string keys |
-
-`42` and `42n` are different document values. Integers from Rust always read
-back as `bigint`, including small integers. Floating-point NaN values remain
-NaN, but JS does not promise to preserve NaN payload bits.
-
-Maps use own enumerable string properties, not inherited or non-enumerable
-properties. Output maps are ordinary objects; keys such as `__proto__` are
-defined as safe own data properties. Arrays serialize their indexed elements;
-extra named properties are not part of the document. Object identity and
-insertion order are not preserved. Shared references are copied by value.
-
-Unsupported values are rejected: `undefined`, functions, symbols (including
-enumerable symbol map keys), sparse arrays, cyclic references, accessor
-properties used as document values, out-of-range integers, unpaired UTF-16
-surrogates in strings or keys, and objects such as Date, Map, Set, or class
-instances. Use values from the same JS realm as the library; custom prototypes
-and proxies are not supported as a document model.
-
-Rust and conversion errors are JS `Error` instances with `kind` equal to
-`Internal`, `InvalidData`, or `UnexpectedType`. Initialization, lifecycle,
-and host JavaScript exceptions may be ordinary errors without `kind`.
-TypeScript declarations include `SyncValue`, `InitSource`, and `DoxsyncError`.
+Use `null`, booleans, strings, numbers, `bigint`, `Uint8Array`, dense arrays,
+and plain objects with string keys. Nested values are copied by value.
+`number` and `bigint` are distinct; integers must be in `[-2^64, 2^64 - 1]`.
+`undefined`, cycles, sparse arrays, getters, functions, and objects such as
+`Date`, `Map`, or custom class instances are not supported.
+
+For exact decimals, import `Decimal` from this package and use strings:
 
 ```js
-try {
-  consumer.consumeDiff(receivedBytes);
-} catch (error) {
-  console.error(error.kind, error.message);
-}
+import { Decimal } from "@doxsync/core";
+const price = new Decimal("12.34");
+```
+
+Decimals must be finite, fit a 96-bit coefficient, and have scale 0–28;
+unsupported values are rejected without rounding. Trailing zeros are not preserved.
+Protocol 1 delivers decimals as strings; protocols 2 and 3 preserve Decimal values.
+The producer automatically selects the highest version supported by both peers.
+
+Errors may expose `kind`: `InvalidData`, `UnexpectedType`, or `Internal`.
+Initialization and lifecycle errors may be ordinary JavaScript errors.
+
+## Browser setup
+
+Deploy the packaged WASM asset alongside the JavaScript. If your bundler relocates
+it, pass its deployed URL or bytes to `init(source)`. The asset is exported as
+`@doxsync/core/doxsync.wasm`; serve `.wasm` files as `application/wasm`.
+Node.js loads the packaged asset automatically. Without a bundler, also provide
+an import map for `decimal.js`; see the [browser example](examples/browser.html).
+
+## Build from source
+
+Requires Rust, wasm-pack, Node.js 22.12+ (or 24+), and pnpm 9.15.0.
+
+```sh
+rustup target add wasm32-unknown-unknown
+cd doxsync-js
+pnpm install --frozen-lockfile
+pnpm build
+pnpm example
 ```
 
-The JS package exposes `init`, `supportedProtocols`, `Producer`, and `Consumer`
-at runtime.
-Rust's lower-level Document, Value, and Message APIs remain internal to this
-binding, and the wire protocol is shared with native Rust.
-
-### Protocol negotiation
-
-Call `supportedProtocols()` after `await init()` to get all protocol versions
-supported by the local build, currently `[1]`. Each call returns an independent
-ordinary `number[]`; modifying it does not affect subsequent calls or the engine.
-No producer or consumer instance is needed. Rust callers can use
-`doxsync::supported_protocols() -> &'static [u32]` without initialization.
-
-For peers running in separate processes, have the consumer advertise its list
-and pass that received list to the producer. The examples above use the local
-list because both peers share the same build. This query reports supported
-versions, not the version negotiated for an individual stream.
-
-The second `Producer` constructor argument is required: pass an array of protocol
-versions supported by the consumer, such as `[1]`. Versions must be integers in
-`[0, 2^32 - 1]`. The producer selects the highest version supported by both peers;
-order and duplicates do not matter. Currently only version `1` is implemented.
-Empty or incompatible lists, omitted arguments, and invalid values throw an error
-with `kind: "InvalidData"`.
-
-The first packed message starts its metadata with protocol instruction `2` followed
-by the selected version, currently `1`; both are unsigned variable-length integers.
-Later messages omit this declaration and retain the same protocol for the stream.
-The consumer rejects first messages without a leading protocol declaration,
-unsupported versions, and repeated declarations. Legacy messages without version
-metadata are no longer accepted. Both peers must be upgraded together.
-
-Failed encoding or consumption preserves protocol initialization state as well as
-pool state, allowing retries. Keep and deliver packed messages in order as usual.
-
-### Path key encoding
-
-Protocol v1 path definitions use the low two bits of each segment's unsigned
-variable-length integer as a tag: `0b00` carries a UTF-8 byte length followed by
-the key bytes, `0b01` carries an array index, and `0b10` carries a string pool
-index. The payload is shifted left by two bits before adding the tag; `0b11`
-is reserved and rejected.
-
-A cached key uses `0b10` only when its reference is strictly shorter than its
-literal encoding. Uncached keys remain inline without adding string pool entries.
-The initial snapshot populates the string pool, so subsequent path definitions
-can reuse those keys. Once a whole path is cached, actions reuse its path pool ID.
-String pool updates precede path definitions; referenced strings stay resident
-through message encoding and are resolved when the consumer reads the definition.
-
-This extends v1 directly. Both peers must be upgraded together: older decoders
-reject the new `0b10` path segment tag.
+To run the browser example, serve `doxsync-js/` with `python3 -m http.server 8000`
+and open `/packages/core/examples/browser.html`.

package/dist/decimal.d.ts

@@ -0,0 +1,3 @@
+import { Decimal } from 'decimal.js';
+export declare function decimalToString(value: unknown): string | undefined;
+export declare function decimalFromString(value: string): Decimal;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { InitSource } from './types.js';
 export type { SyncValue, InitSource, DoxsyncError } from './types.js';
+export { Decimal } from 'decimal.js';
 export { Producer, Consumer, supportedProtocols } from './runtime.js';
 /**
  * Initialize once before constructing Producer or Consumer or calling supportedProtocols.

package/dist/index.js

@@ -1,6 +1,7 @@
-import { i as e, n as t, r as n, t as r } from "./runtime-CJqt5vND.js";
+import { i as e, n as t, r as n, t as r } from "./runtime-BePF61JJ.js";
+import { Decimal as i } from "decimal.js";
 //#region src/index.ts
-function i(e) {
+function a(e) {
 	return n(() => e === void 0 ? new URL(
 		/* @vite-ignore */
 		"./wasm/doxsync_bg.wasm",
@@ -8,4 +9,4 @@ function i(e) {
 	) : e);
 }
 //#endregion
-export { r as Consumer, t as Producer, i as init, e as supportedProtocols };
+export { r as Consumer, i as Decimal, t as Producer, a as init, e as supportedProtocols };

package/dist/node.d.ts

@@ -1,5 +1,6 @@
 import { InitSource } from './types.js';
 export type { SyncValue, InitSource, DoxsyncError } from './types.js';
+export { Decimal } from 'decimal.js';
 export { Producer, Consumer, supportedProtocols } from './runtime.js';
 /**
  * Initialize once before constructing Producer or Consumer or calling supportedProtocols.

package/dist/node.js

@@ -1,12 +1,13 @@
-import { i as e, n as t, r as n, t as r } from "./runtime-CJqt5vND.js";
-import { readFile as i } from "node:fs/promises";
+import { i as e, n as t, r as n, t as r } from "./runtime-BePF61JJ.js";
+import { Decimal as i } from "decimal.js";
+import { readFile as a } from "node:fs/promises";
 //#region src/node.ts
-function a(e) {
-	return n(() => e === void 0 ? i(new URL(
+function o(e) {
+	return n(() => e === void 0 ? a(new URL(
 		/* @vite-ignore */
 		"./wasm/doxsync_bg.wasm",
 		import.meta.url
-	)) : e instanceof URL && e.protocol === "file:" ? i(e) : typeof e == "string" && e.startsWith("file:") ? i(new URL(e)) : e);
+	)) : e instanceof URL && e.protocol === "file:" ? a(e) : typeof e == "string" && e.startsWith("file:") ? a(new URL(e)) : e);
 }
 //#endregion
-export { r as Consumer, t as Producer, a as init, e as supportedProtocols };
+export { r as Consumer, i as Decimal, t as Producer, o as init, e as supportedProtocols };

package/dist/runtime-BePF61JJ.js

@@ -0,0 +1,72 @@
+import { Decimal as e } from "decimal.js";
+import t, { Consumer as n, Producer as r, supportedProtocols as i } from "./wasm/doxsync.js";
+//#region src/decimal.ts
+var a = e.clone({
+	precision: 29,
+	minE: -100,
+	maxE: 100
+});
+function o(t) {
+	if (e.isDecimal(t)) {
+		if (!t.isFinite() || t.decimalPlaces() > 28 || t.e > 28) throw Object.assign(/* @__PURE__ */ Error("Decimal outside the supported coefficient or scale range"), { kind: "InvalidData" });
+		return t.toFixed();
+	}
+}
+function s(e) {
+	return new a(e);
+}
+//#endregion
+//#region src/runtime.ts
+var c, l = !1;
+function u(e) {
+	return c ||= Promise.resolve().then(e).then((e) => t({ module_or_path: e })).then(() => {
+		l = !0;
+	}).catch((e) => {
+		throw c = void 0, e;
+	}), c;
+}
+function d() {
+	if (!l) throw Error("Call and await init() before using the doxsync API");
+}
+function f() {
+	return d(), i();
+}
+var p = class {
+	#e;
+	constructor(e, t) {
+		d(), this.#e = new r(e, t, o);
+	}
+	#t() {
+		if (!this.#e) throw Error("Producer has been freed");
+		return this.#e;
+	}
+	replace(e) {
+		this.#t().replace(e);
+	}
+	produceDiff() {
+		return this.#t().produceDiff();
+	}
+	free() {
+		this.#e &&= (this.#e.free(), void 0);
+	}
+}, m = class {
+	#e;
+	constructor() {
+		d(), this.#e = new n();
+	}
+	#t() {
+		if (!this.#e) throw Error("Consumer has been freed");
+		return this.#e;
+	}
+	consumeDiff(e) {
+		this.#t().consumeDiff(e);
+	}
+	document() {
+		return this.#t().document(s);
+	}
+	free() {
+		this.#e &&= (this.#e.free(), void 0);
+	}
+};
+//#endregion
+export { f as i, p as n, u as r, m as t };

package/dist/runtime.d.ts

@@ -1,7 +1,7 @@
 import { InitSource, SyncValue } from './types.js';
 export declare function initialize(loadSource: () => InitSource | Promise<InitSource>): Promise<void>;
 /**
- * Returns all protocol versions supported by this build, currently [1].
+ * Returns all protocol versions supported by this build, currently [1, 2, 3].
  * Requires await init(). Each call returns an independent ordinary array.
  * Consumers can advertise this list to producers for protocol negotiation.
  */
@@ -11,8 +11,10 @@ export declare class Producer {
     /**
      * Copies the value into WASM and selects the highest common protocol version.
      * protocols lists the consumer's supported versions as u32 integers.
-     * Currently only 1 is supported. Missing, invalid, empty, or incompatible
+     * Versions 1, 2, and 3 are supported. Missing, invalid, empty, or incompatible
      * lists throw InvalidData errors. Order and duplicates do not matter.
+     * Protocol 1 transmits Decimal values as strings; protocols 2 and 3 preserve the type.
+     * Protocols 2 and 3 also pool binary values; both peers must support that extension.
      */
     constructor(value: SyncValue, protocols: readonly number[]);
     /** Replaces the document after validating and copying the entire value. */
@@ -29,11 +31,13 @@ export declare class Consumer {
     #private;
     constructor();
     /**
-     * Applies one complete message. The first message must declare protocol 1.
+     * Applies one complete message. The first message must declare protocol 1, 2, or 3.
      * Failures leave the document, pools, and protocol state intact.
      */
     consumeDiff(bytes: Uint8Array): void;
-    /** Returns an independent copy, or undefined before the first snapshot. */
+    /** Returns an independent copy, or undefined before the first snapshot.
+     * Protocol 2 and 3 decimals become decimal.js instances; their original scale is lost.
+     */
     document(): SyncValue | undefined;
     /** Release WASM resources. Safe to call repeatedly. */
     free(): void;

package/dist/types.d.ts

@@ -1,5 +1,8 @@
-/** Numbers are floats; bigint values are integers in [-2^64, 2^64 - 1]. */
-export type SyncValue = null | boolean | string | number | bigint | Uint8Array | SyncValue[] | {
+import { Decimal } from 'decimal.js';
+/** Numbers are floats; bigint values are integers in [-2^64, 2^64 - 1].
+ * Decimal instances preserve numeric value, but not trailing zeros.
+ */
+export type SyncValue = null | boolean | string | number | bigint | Decimal | Uint8Array | SyncValue[] | {
     [key: string]: SyncValue;
 };
 export type InitSource = string | URL | ArrayBuffer | Uint8Array | WebAssembly.Module;

package/dist/wasm/doxsync.d.ts

@@ -5,14 +5,14 @@ export class Consumer {
     free(): void;
     [Symbol.dispose](): void;
     consumeDiff(bytes: any): void;
-    document(): any;
+    document(decimal_from_string: Function): any;
     constructor();
 }
 
 export class Producer {
     free(): void;
     [Symbol.dispose](): void;
-    constructor(value: any, protocols: any);
+    constructor(value: any, protocols: any, decimal_to_string: Function);
     produceDiff(): any;
     replace(value: any): void;
 }
@@ -26,9 +26,9 @@ export interface InitOutput {
     readonly __wbg_consumer_free: (a: number, b: number) => void;
     readonly __wbg_producer_free: (a: number, b: number) => void;
     readonly consumer_consumeDiff: (a: number, b: any) => [number, number];
-    readonly consumer_document: (a: number) => [number, number, number];
+    readonly consumer_document: (a: number, b: any) => [number, number, number];
     readonly consumer_new: () => number;
-    readonly producer_new: (a: any, b: any) => [number, number, number];
+    readonly producer_new: (a: any, b: any, c: any) => [number, number, number];
     readonly producer_produceDiff: (a: number) => [number, number, number];
     readonly producer_replace: (a: number, b: any) => [number, number];
     readonly supportedProtocols: () => any;

package/dist/wasm/doxsync.js

@@ -21,10 +21,11 @@ export class Consumer {
         }
     }
     /**
+     * @param {Function} decimal_from_string
      * @returns {any}
      */
-    document() {
-        const ret = wasm.consumer_document(this.__wbg_ptr);
+    document(decimal_from_string) {
+        const ret = wasm.consumer_document(this.__wbg_ptr, decimal_from_string);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -53,9 +54,10 @@ export class Producer {
     /**
      * @param {any} value
      * @param {any} protocols
+     * @param {Function} decimal_to_string
      */
-    constructor(value, protocols) {
-        const ret = wasm.producer_new(value, protocols);
+    constructor(value, protocols, decimal_to_string) {
+        const ret = wasm.producer_new(value, protocols, decimal_to_string);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -156,6 +158,10 @@ function __wbg_get_imports() {
             const ret = arg0.add(arg1);
             return ret;
         },
+        __wbg_call_6bcf8d3e20937e46: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_charCodeAt_90635349fbda9f5f: function(arg0, arg1) {
             const ret = arg0.charCodeAt(arg1 >>> 0);
             return ret;

package/dist/wasm/doxsync_bg.wasm.d.ts

@@ -4,9 +4,9 @@ export const memory: WebAssembly.Memory;
 export const __wbg_consumer_free: (a: number, b: number) => void;
 export const __wbg_producer_free: (a: number, b: number) => void;
 export const consumer_consumeDiff: (a: number, b: any) => [number, number];
-export const consumer_document: (a: number) => [number, number, number];
+export const consumer_document: (a: number, b: any) => [number, number, number];
 export const consumer_new: () => number;
-export const producer_new: (a: any, b: any) => [number, number, number];
+export const producer_new: (a: any, b: any, c: any) => [number, number, number];
 export const producer_produceDiff: (a: number) => [number, number, number];
 export const producer_replace: (a: number, b: any) => [number, number];
 export const supportedProtocols: () => any;

package/examples/browser.html

@@ -5,6 +5,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title>doxsync · Sync playground</title>
     <link rel="stylesheet" href="./browser.css">
+    <script type="importmap">
+      { "imports": { "decimal.js": "../node_modules/decimal.js/decimal.mjs" } }
+    </script>
     <script type="module" src="./browser.js"></script>
   </head>
   <body>

package/examples/browser.js

@@ -11,6 +11,7 @@ let loading = false;
 const initialDocument = () => ({
   title: "doxsync playground",
   visitors: 12n,
+  price: new bindings.Decimal("12.34"),
   online: true,
   settings: { theme: "light", volume: 60 },
   tags: ["rust", "wasm"],
@@ -28,6 +29,7 @@ const delayValue = () => {
 // suffix preserves bigint's type instead of presenting it as a JSON string.
 function format(value, depth = 0) {
   if (typeof value === "bigint") return `${value}n`;
+  if (bindings.Decimal.isDecimal(value)) return `Decimal("${value.toFixed()}")`;
   if (value === null || typeof value !== "object") return JSON.stringify(value);
   const array = Array.isArray(value);
   const entries = array ? value : Object.keys(value).sort();
@@ -219,6 +221,7 @@ function send(summary) {
 }
 
 const mutations = [
+  (doc) => { doc.price = doc.price.plus("0.01"); return `price → ${doc.price.toFixed(2)}`; },
   (doc) => { const delta = BigInt(number(1, 5)); doc.visitors += delta; return `visitors increased by ${delta}`; },
   (doc) => { doc.online = !doc.online; return `online → ${doc.online}`; },
   (doc) => { doc.settings.theme = pick(["light", "dark", "system"].filter((value) => value !== doc.settings.theme)); return `settings.theme → ${doc.settings.theme}`; },
@@ -246,7 +249,13 @@ function mutate() {
   try {
     // Producer owns a copy. Keep this display model in step with successfully
     // accepted replacements; no JS implementation of the diff algorithm.
-    const next = structuredClone(state.document);
+    // Copy this demo's containers explicitly: structuredClone cannot copy Decimal.
+    const next = {
+      ...state.document,
+      settings: { ...state.document.settings },
+      tags: [...state.document.tags],
+      price: new bindings.Decimal(state.document.price),
+    };
     const summary = pick(mutations)(next);
     state.producer.replace(next);
     state.document = next;

package/examples/node.mjs

@@ -1,17 +1,18 @@
-import { init, Producer, Consumer, supportedProtocols } from "@doxsync/core";
+import { init, Producer, Consumer, Decimal, supportedProtocols } from "@doxsync/core";
 
 await init();
-const producer = new Producer({ count: 1n, data: new Uint8Array([1, 2, 3]) }, supportedProtocols());
+const producer = new Producer({ count: 1n, price: new Decimal("12.34"), data: new Uint8Array([1, 2, 3]) }, supportedProtocols());
 const consumer = new Consumer();
 
 try {
   consumer.consumeDiff(producer.produceDiff());
   console.log("Snapshot:", consumer.document());
 
-  producer.replace({ count: 2n, data: new Uint8Array([1, 2, 3]) });
+  producer.replace({ count: 2n, price: new Decimal("12.35"), data: new Uint8Array([1, 2, 3]) });
   const message = producer.produceDiff();
   if (message !== undefined) consumer.consumeDiff(message);
   console.log("Updated:", consumer.document());
+  console.log("Exact price:", consumer.document().price.toFixed(2));
   console.log("Unchanged:", producer.produceDiff());
 } finally {
   producer.free();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doxsync/core",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0-alpha.4",
   "description": "JavaScript bindings for the doxsync Rust synchronization engine",
   "type": "module",
   "engines": {
@@ -24,18 +24,21 @@
   ],
   "scripts": {
     "build": "node scripts/build-wasm.mjs && vite build",
-    "prepack": "npm run build"
+    "prepack": "pnpm run build"
   },
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/PeterlitsZo/doxsync.git",
-    "directory": "doxsync-js"
+    "directory": "doxsync-js/packages/core"
   },
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^6.0.3",
     "vite": "^8.3.0",
     "vite-plugin-dts": "^5.1.1"
+  },
+  "dependencies": {
+    "decimal.js": "^10.6.0"
   }
 }

package/dist/runtime-CJqt5vND.js

@@ -1,55 +0,0 @@
-import e, { Consumer as t, Producer as n, supportedProtocols as r } from "./wasm/doxsync.js";
-//#region src/runtime.ts
-var i, a = !1;
-function o(t) {
-	return i ||= Promise.resolve().then(t).then((t) => e({ module_or_path: t })).then(() => {
-		a = !0;
-	}).catch((e) => {
-		throw i = void 0, e;
-	}), i;
-}
-function s() {
-	if (!a) throw Error("Call and await init() before using the doxsync API");
-}
-function c() {
-	return s(), r();
-}
-var l = class {
-	#e;
-	constructor(e, t) {
-		s(), this.#e = new n(e, t);
-	}
-	#t() {
-		if (!this.#e) throw Error("Producer has been freed");
-		return this.#e;
-	}
-	replace(e) {
-		this.#t().replace(e);
-	}
-	produceDiff() {
-		return this.#t().produceDiff();
-	}
-	free() {
-		this.#e &&= (this.#e.free(), void 0);
-	}
-}, u = class {
-	#e;
-	constructor() {
-		s(), this.#e = new t();
-	}
-	#t() {
-		if (!this.#e) throw Error("Consumer has been freed");
-		return this.#e;
-	}
-	consumeDiff(e) {
-		this.#t().consumeDiff(e);
-	}
-	document() {
-		return this.#t().document();
-	}
-	free() {
-		this.#e &&= (this.#e.free(), void 0);
-	}
-};
-//#endregion
-export { c as i, l as n, o as r, u as t };