@doxsync/core 0.1.0-alpha.1

package/LICENSE-APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peterlits Zo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,193 @@
+# @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.
+
+## Build from this repository
+
+Install Rust, Node.js 22+, and `wasm-pack`, then run:
+
+```sh
+rustup target add wasm32-unknown-unknown
+cd doxsync-js
+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 copies the JS wrapper and declarations
+into `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:
+
+```sh
+cargo build --manifest-path ../doxsync-rs/Cargo.toml
+cargo build --manifest-path ../doxsync-rs/Cargo.toml \
+  --target wasm32-unknown-unknown --features wasm --release
+```
+
+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:
+
+```js
+import { init, Producer, Consumer } from "@doxsync/core";
+
+await init();
+const producer = new Producer({ count: 1n, ratio: 0.5 }, [1]);
+const consumer = new Consumer();
+
+try {
+  consumer.consumeDiff(producer.produceDiff()); // First message is a snapshot.
+  producer.replace({ count: 2n, ratio: 0.75 });
+
+  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
+} 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. 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`:
+
+```sh
+python3 -m http.server 8000
+```
+
+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`.
+
+```js
+try {
+  consumer.consumeDiff(receivedBytes);
+} catch (error) {
+  console.error(error.kind, error.message);
+}
+```
+
+The JS package exposes only `init`, `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
+
+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.

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+/** Numbers are floats; bigint values are integers in [-2^64, 2^64 - 1]. */
+export type SyncValue =
+  | null
+  | boolean
+  | string
+  | number
+  | bigint
+  | Uint8Array
+  | SyncValue[]
+  | { [key: string]: SyncValue };
+
+export type InitSource =
+  | string
+  | URL
+  | ArrayBuffer
+  | Uint8Array
+  | WebAssembly.Module;
+
+/** Rust errors thrown by synchronization and value conversion. */
+export interface DoxsyncError extends Error {
+  kind: "Internal" | "InvalidData" | "UnexpectedType";
+}
+
+/**
+ * Initialize once before constructing Producer or Consumer.
+ * Defaults to the packaged WASM. Concurrent calls share the first call's source
+ * and promise; failures can be retried. Later successful calls are no-ops.
+ * Strings are URLs, not filesystem paths; Node also accepts file: URLs.
+ */
+export function init(source?: InitSource): Promise<void>;
+
+export class Producer {
+  #private;
+  /**
+   * 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
+   * lists throw InvalidData errors. Order and duplicates do not matter.
+   */
+  constructor(value: SyncValue, protocols: readonly number[]);
+  /** Replaces the document after validating and copying the entire value. */
+  replace(value: SyncValue): void;
+  /**
+   * Returns a snapshot with protocol metadata on the first call, then changes.
+   * Returns undefined if unchanged. Retain each message until delivered in order.
+   */
+  produceDiff(): Uint8Array | undefined;
+  /** Release WASM resources. Safe to call repeatedly. */
+  free(): void;
+}
+
+export class Consumer {
+  #private;
+  constructor();
+  /**
+   * Applies one complete message. The first message must declare protocol 1.
+   * Failures leave the document, pools, and protocol state intact.
+   */
+  consumeDiff(bytes: Uint8Array): void;
+  /** Returns an independent copy, or undefined before the first snapshot. */
+  document(): SyncValue | undefined;
+  /** Release WASM resources. Safe to call repeatedly. */
+  free(): void;
+}

package/dist/index.js

@@ -0,0 +1,9 @@
+import { initialize } from "./runtime.js";
+
+export { Producer, Consumer } from "./runtime.js";
+
+export function init(source) {
+  return initialize(() => source === undefined
+    ? new URL("./wasm/doxsync_bg.wasm", import.meta.url)
+    : source);
+}

package/dist/node.js

@@ -0,0 +1,19 @@
+import { readFile } from "node:fs/promises";
+import { initialize } from "./runtime.js";
+
+export { Producer, Consumer } from "./runtime.js";
+
+export function init(source) {
+  return initialize(() => {
+    if (source === undefined) {
+      return readFile(new URL("./wasm/doxsync_bg.wasm", import.meta.url));
+    }
+    if (source instanceof URL && source.protocol === "file:") {
+      return readFile(source);
+    }
+    if (typeof source === "string" && source.startsWith("file:")) {
+      return readFile(new URL(source));
+    }
+    return source;
+  });
+}

package/dist/runtime.js

@@ -0,0 +1,85 @@
+import initWasm, {
+  Producer as WasmProducer,
+  Consumer as WasmConsumer,
+} from "./wasm/doxsync.js";
+
+let initialization;
+let initialized = false;
+
+export function initialize(loadSource) {
+  if (!initialization) {
+    initialization = Promise.resolve()
+      .then(loadSource)
+      .then((source) => initWasm({ module_or_path: source }))
+      .then(() => { initialized = true; })
+      .catch((error) => {
+        initialization = undefined;
+        throw error;
+      });
+  }
+  return initialization;
+}
+
+function requireInitialized() {
+  if (!initialized) {
+    throw new Error("Call and await init() before creating a doxsync object");
+  }
+}
+
+export class Producer {
+  #handle;
+
+  constructor(value, protocols) {
+    requireInitialized();
+    this.#handle = new WasmProducer(value, protocols);
+  }
+
+  #live() {
+    if (!this.#handle) throw new Error("Producer has been freed");
+    return this.#handle;
+  }
+
+  replace(value) {
+    this.#live().replace(value);
+  }
+
+  produceDiff() {
+    return this.#live().produceDiff();
+  }
+
+  free() {
+    if (this.#handle) {
+      this.#handle.free();
+      this.#handle = undefined;
+    }
+  }
+}
+
+export class Consumer {
+  #handle;
+
+  constructor() {
+    requireInitialized();
+    this.#handle = new WasmConsumer();
+  }
+
+  #live() {
+    if (!this.#handle) throw new Error("Consumer has been freed");
+    return this.#handle;
+  }
+
+  consumeDiff(bytes) {
+    this.#live().consumeDiff(bytes);
+  }
+
+  document() {
+    return this.#live().document();
+  }
+
+  free() {
+    if (this.#handle) {
+      this.#handle.free();
+      this.#handle = undefined;
+    }
+  }
+}

package/dist/wasm/doxsync.d.ts

@@ -0,0 +1,61 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class Consumer {
+    free(): void;
+    [Symbol.dispose](): void;
+    consumeDiff(bytes: any): void;
+    document(): any;
+    constructor();
+}
+
+export class Producer {
+    free(): void;
+    [Symbol.dispose](): void;
+    constructor(value: any, protocols: any);
+    produceDiff(): any;
+    replace(value: any): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    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_new: () => number;
+    readonly producer_new: (a: any, b: any) => [number, number, number];
+    readonly producer_produceDiff: (a: number) => [number, number, number];
+    readonly producer_replace: (a: number, b: any) => [number, number];
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;