tetr-ttrx 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TTRX contributors
+
+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,71 @@
+# TTRX
+
+TTRX is a Rust converter for TETR.IO `.ttr` and `.ttrm` replay files. It writes a versioned `.ttrx` binary container and converts that container back to canonical JSON.
+
+The first implemented profile is `source-semantic`: it preserves the parsed JSON data model, including object and array order, duplicate object keys, exact number lexemes, unknown fields, and unknown events. Whitespace and equivalent string escaping are canonicalized when decoding. Because input events and their values are retained, the reverse conversion preserves the source behavior without inventing game state.
+
+This profile is the first vertical implementation of the converter. Deterministic action compilation and board regeneration described in the design documents are future format profiles; they are not claimed by the current executable.
+
+## Build and use
+
+```powershell
+cargo build --release -p ttrx-cli
+
+target\release\ttrx encode replay.ttr
+target\release\ttrx encode match.ttrm -o match.ttrx
+target\release\ttrx decode match.ttrx
+target\release\ttrx inspect match.ttrx
+target\release\ttrx verify replay.ttr
+```
+
+Output files are not overwritten unless `--force` is supplied, and `--force` only replaces a regular file. `encode` infers `.ttr` or `.ttrm` from the extension and also checks the replay shape. `decode` restores the extension recorded in the container. Use `-o` to choose another output path.
+
+On Windows, replacing an existing file uses a uniquely named sibling backup because the standard rename operation cannot replace a destination. Ordinary failures restore that backup. If the process or machine stops between the two rename operations, the previous file may remain beside the output under a hidden `previous` temporary name and can be restored manually.
+
+The core crate has no external dependencies. The WebAssembly wrapper uses `wasm-bindgen`; the CLI uses only the standard library and `ttrx-core`.
+
+## WebAssembly
+
+The wrapper exports `encode_ttr`, `encode_ttrm`, `decode_ttrx`, `ttrx_source_extension`, source/container inspection and verification functions, plus `ttrx_version`. `ttrx_source_extension` tells a browser caller whether decoded bytes should be saved as `.ttr`, `.ttrm`, or `.json`. Build it and generate Node.js glue with the pinned `wasm-bindgen` schema version:
+
+```powershell
+rustup target add wasm32-unknown-unknown
+cargo install --locked wasm-bindgen-cli --version 0.2.126
+wasm-bindgen --version # must report wasm-bindgen 0.2.126
+cargo build --release -p ttrx-wasm --target wasm32-unknown-unknown
+wasm-bindgen target\wasm32-unknown-unknown\release\ttrx_wasm.wasm `
+  --target nodejs --out-dir work\wasm
+node scripts\wasm-smoke.cjs work\wasm\ttrx_wasm.js replay.ttr match.ttrm
+```
+
+The exported encode/decode functions accept and return JavaScript `Uint8Array` values. Browser bundlers can use the same Wasm artifact with the matching `wasm-bindgen` target and CLI version.
+
+## npm package
+
+The `tetr-ttrx` npm package ships the WebAssembly converter for Node.js and browser-aware bundlers. It exposes the same eleven functions documented above, with CommonJS and ES module entry points for Node.js and an ES module WebAssembly entry point selected by browser bundlers.
+
+```sh
+npm install tetr-ttrx
+```
+
+```js
+import { readFile, writeFile } from 'node:fs/promises';
+import { decode_ttrx, encode_ttr } from 'tetr-ttrx';
+
+const source = await readFile('replay.ttr');
+const container = encode_ttr(source);
+await writeFile('replay.ttrx', container);
+
+const canonicalJson = decode_ttrx(container);
+await writeFile('replay.decoded.ttr', canonicalJson);
+```
+
+CommonJS consumers can use `const ttrx = require('tetr-ttrx')`. The `inspect_*` and `verify_*` functions return human-readable strings; the encode/decode functions accept and return `Uint8Array` values and throw JavaScript errors for invalid inputs.
+
+To build the npm package from source, install the `wasm32-unknown-unknown` Rust target and `wasm-bindgen-cli` 0.2.126, then run `npm run build`. `npm test` runs the Rust workspace tests, and `npm run test:package` checks both Node.js module formats after a build.
+
+## Fidelity
+
+The current profile is stricter than placement-only equivalence: it round-trips the complete parsed JSON tree. It does not promise byte-for-byte JSON identity because insignificant whitespace and equivalent escapes are not retained. No TETR.IO game engine is run during conversion, so `verify` proves container/data-model round-trip, not independent board simulation.
+
+See [project requirements](docs/ttrx/requirements.md), [TTRX 1.0 binary format](docs/ttrx/format-v1.md), [implementation status](docs/ttrx/implementation-status.md), [validation evidence](docs/ttrx/validation.md), [TETR.IO source audit](docs/tetrio/README.md), and [open verification work](docs/tetrio/verification/coverage-and-open-items.md).

package/dist/bundler/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/bundler/ttrx_wasm.d.ts

@@ -0,0 +1,106 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Decode a TTRX container to canonical TETR.IO replay JSON bytes.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container header, checksum, payload, or
+ * decoded JSON data model is invalid.
+ */
+export function decode_ttrx(container: Uint8Array): Uint8Array;
+
+/**
+ * Encode one single-player TETR.IO replay JSON document.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the bytes are invalid JSON, do not contain a
+ * single-player replay, or cannot be represented by the TTRX codec.
+ */
+export function encode_ttr(source: Uint8Array): Uint8Array;
+
+/**
+ * Encode one multiplayer TETR.IO replay JSON document.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the bytes are invalid JSON, do not contain a
+ * multiplayer replay, or cannot be represented by the TTRX codec.
+ */
+export function encode_ttrm(source: Uint8Array): Uint8Array;
+
+/**
+ * Describe a single-player source replay without executing game rules.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the source is invalid JSON or its structure
+ * is incompatible with a single-player replay.
+ */
+export function inspect_ttr(source: Uint8Array): string;
+
+/**
+ * Describe a multiplayer source replay without executing game rules.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the source is invalid JSON or its structure
+ * is incompatible with a multiplayer replay.
+ */
+export function inspect_ttrm(source: Uint8Array): string;
+
+/**
+ * Validate and describe both the binary container and its decoded replay.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container or decoded replay is invalid.
+ */
+export function inspect_ttrx(container: Uint8Array): string;
+
+/**
+ * Return the source extension recorded by a TTRX container (`ttr`, `ttrm`,
+ * or `json` when the source kind is unknown).
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container is invalid.
+ */
+export function ttrx_source_extension(container: Uint8Array): string;
+
+/**
+ * Return the converter package version.
+ */
+export function ttrx_version(): string;
+
+/**
+ * Verify a single-player source replay through an encode/decode round trip.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when validation, encoding, decoding, or semantic
+ * data-model comparison fails.
+ */
+export function verify_ttr(source: Uint8Array): string;
+
+/**
+ * Verify a multiplayer source replay through an encode/decode round trip.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when validation, encoding, decoding, or semantic
+ * data-model comparison fails.
+ */
+export function verify_ttrm(source: Uint8Array): string;
+
+/**
+ * Validate a binary container and verify its decoded replay data model.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when container validation or the decoded replay's
+ * encode/decode verification fails.
+ */
+export function verify_ttrx(container: Uint8Array): string;

package/dist/bundler/ttrx_wasm.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./ttrx_wasm.d.ts" */
+import * as wasm from "./ttrx_wasm_bg.wasm";
+import { __wbg_set_wasm } from "./ttrx_wasm_bg.js";
+
+__wbg_set_wasm(wasm);
+
+export {
+    decode_ttrx, encode_ttr, encode_ttrm, inspect_ttr, inspect_ttrm, inspect_ttrx, ttrx_source_extension, ttrx_version, verify_ttr, verify_ttrm, verify_ttrx
+} from "./ttrx_wasm_bg.js";

package/dist/bundler/ttrx_wasm_bg.js

@@ -0,0 +1,457 @@
+/**
+ * Decode a TTRX container to canonical TETR.IO replay JSON bytes.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container header, checksum, payload, or
+ * decoded JSON data model is invalid.
+ * @param {Uint8Array} container
+ * @returns {Uint8Array}
+ */
+export function decode_ttrx(container) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(container, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.decode_ttrx(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Encode one single-player TETR.IO replay JSON document.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the bytes are invalid JSON, do not contain a
+ * single-player replay, or cannot be represented by the TTRX codec.
+ * @param {Uint8Array} source
+ * @returns {Uint8Array}
+ */
+export function encode_ttr(source) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.encode_ttr(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Encode one multiplayer TETR.IO replay JSON document.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the bytes are invalid JSON, do not contain a
+ * multiplayer replay, or cannot be represented by the TTRX codec.
+ * @param {Uint8Array} source
+ * @returns {Uint8Array}
+ */
+export function encode_ttrm(source) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.encode_ttrm(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Describe a single-player source replay without executing game rules.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the source is invalid JSON or its structure
+ * is incompatible with a single-player replay.
+ * @param {Uint8Array} source
+ * @returns {string}
+ */
+export function inspect_ttr(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.inspect_ttr(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Describe a multiplayer source replay without executing game rules.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the source is invalid JSON or its structure
+ * is incompatible with a multiplayer replay.
+ * @param {Uint8Array} source
+ * @returns {string}
+ */
+export function inspect_ttrm(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.inspect_ttrm(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Validate and describe both the binary container and its decoded replay.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container or decoded replay is invalid.
+ * @param {Uint8Array} container
+ * @returns {string}
+ */
+export function inspect_ttrx(container) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(container, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.inspect_ttrx(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Return the source extension recorded by a TTRX container (`ttr`, `ttrm`,
+ * or `json` when the source kind is unknown).
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container is invalid.
+ * @param {Uint8Array} container
+ * @returns {string}
+ */
+export function ttrx_source_extension(container) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(container, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ttrx_source_extension(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Return the converter package version.
+ * @returns {string}
+ */
+export function ttrx_version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.ttrx_version(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Verify a single-player source replay through an encode/decode round trip.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when validation, encoding, decoding, or semantic
+ * data-model comparison fails.
+ * @param {Uint8Array} source
+ * @returns {string}
+ */
+export function verify_ttr(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.verify_ttr(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Verify a multiplayer source replay through an encode/decode round trip.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when validation, encoding, decoding, or semantic
+ * data-model comparison fails.
+ * @param {Uint8Array} source
+ * @returns {string}
+ */
+export function verify_ttrm(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.verify_ttrm(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Validate a binary container and verify its decoded replay data model.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when container validation or the decoded replay's
+ * encode/decode verification fails.
+ * @param {Uint8Array} container
+ * @returns {string}
+ */
+export function verify_ttrx(container) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(container, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.verify_ttrx(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+}
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}

package/dist/bundler/ttrx_wasm_bg.wasm.d.ts

@@ -0,0 +1,17 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const decode_ttrx: (a: number, b: number, c: number) => void;
+export const encode_ttr: (a: number, b: number, c: number) => void;
+export const encode_ttrm: (a: number, b: number, c: number) => void;
+export const inspect_ttr: (a: number, b: number, c: number) => void;
+export const inspect_ttrm: (a: number, b: number, c: number) => void;
+export const inspect_ttrx: (a: number, b: number, c: number) => void;
+export const ttrx_source_extension: (a: number, b: number, c: number) => void;
+export const ttrx_version: (a: number) => void;
+export const verify_ttr: (a: number, b: number, c: number) => void;
+export const verify_ttrm: (a: number, b: number, c: number) => void;
+export const verify_ttrx: (a: number, b: number, c: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number) => void;

package/dist/node/index.mjs

@@ -0,0 +1,17 @@
+import binding from './ttrx_wasm.js';
+
+export const {
+  decode_ttrx,
+  encode_ttr,
+  encode_ttrm,
+  inspect_ttr,
+  inspect_ttrm,
+  inspect_ttrx,
+  ttrx_source_extension,
+  ttrx_version,
+  verify_ttr,
+  verify_ttrm,
+  verify_ttrx,
+} = binding;
+
+export default binding;

package/dist/node/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/node/ttrx_wasm.d.ts

@@ -0,0 +1,106 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Decode a TTRX container to canonical TETR.IO replay JSON bytes.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container header, checksum, payload, or
+ * decoded JSON data model is invalid.
+ */
+export function decode_ttrx(container: Uint8Array): Uint8Array;
+
+/**
+ * Encode one single-player TETR.IO replay JSON document.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the bytes are invalid JSON, do not contain a
+ * single-player replay, or cannot be represented by the TTRX codec.
+ */
+export function encode_ttr(source: Uint8Array): Uint8Array;
+
+/**
+ * Encode one multiplayer TETR.IO replay JSON document.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the bytes are invalid JSON, do not contain a
+ * multiplayer replay, or cannot be represented by the TTRX codec.
+ */
+export function encode_ttrm(source: Uint8Array): Uint8Array;
+
+/**
+ * Describe a single-player source replay without executing game rules.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the source is invalid JSON or its structure
+ * is incompatible with a single-player replay.
+ */
+export function inspect_ttr(source: Uint8Array): string;
+
+/**
+ * Describe a multiplayer source replay without executing game rules.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the source is invalid JSON or its structure
+ * is incompatible with a multiplayer replay.
+ */
+export function inspect_ttrm(source: Uint8Array): string;
+
+/**
+ * Validate and describe both the binary container and its decoded replay.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container or decoded replay is invalid.
+ */
+export function inspect_ttrx(container: Uint8Array): string;
+
+/**
+ * Return the source extension recorded by a TTRX container (`ttr`, `ttrm`,
+ * or `json` when the source kind is unknown).
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container is invalid.
+ */
+export function ttrx_source_extension(container: Uint8Array): string;
+
+/**
+ * Return the converter package version.
+ */
+export function ttrx_version(): string;
+
+/**
+ * Verify a single-player source replay through an encode/decode round trip.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when validation, encoding, decoding, or semantic
+ * data-model comparison fails.
+ */
+export function verify_ttr(source: Uint8Array): string;
+
+/**
+ * Verify a multiplayer source replay through an encode/decode round trip.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when validation, encoding, decoding, or semantic
+ * data-model comparison fails.
+ */
+export function verify_ttrm(source: Uint8Array): string;
+
+/**
+ * Validate a binary container and verify its decoded replay data model.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when container validation or the decoded replay's
+ * encode/decode verification fails.
+ */
+export function verify_ttrx(container: Uint8Array): string;

package/dist/node/ttrx_wasm.js

@@ -0,0 +1,472 @@
+/* @ts-self-types="./ttrx_wasm.d.ts" */
+
+/**
+ * Decode a TTRX container to canonical TETR.IO replay JSON bytes.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container header, checksum, payload, or
+ * decoded JSON data model is invalid.
+ * @param {Uint8Array} container
+ * @returns {Uint8Array}
+ */
+function decode_ttrx(container) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(container, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.decode_ttrx(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.decode_ttrx = decode_ttrx;
+
+/**
+ * Encode one single-player TETR.IO replay JSON document.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the bytes are invalid JSON, do not contain a
+ * single-player replay, or cannot be represented by the TTRX codec.
+ * @param {Uint8Array} source
+ * @returns {Uint8Array}
+ */
+function encode_ttr(source) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.encode_ttr(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.encode_ttr = encode_ttr;
+
+/**
+ * Encode one multiplayer TETR.IO replay JSON document.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the bytes are invalid JSON, do not contain a
+ * multiplayer replay, or cannot be represented by the TTRX codec.
+ * @param {Uint8Array} source
+ * @returns {Uint8Array}
+ */
+function encode_ttrm(source) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.encode_ttrm(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export2(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.encode_ttrm = encode_ttrm;
+
+/**
+ * Describe a single-player source replay without executing game rules.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the source is invalid JSON or its structure
+ * is incompatible with a single-player replay.
+ * @param {Uint8Array} source
+ * @returns {string}
+ */
+function inspect_ttr(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.inspect_ttr(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.inspect_ttr = inspect_ttr;
+
+/**
+ * Describe a multiplayer source replay without executing game rules.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the source is invalid JSON or its structure
+ * is incompatible with a multiplayer replay.
+ * @param {Uint8Array} source
+ * @returns {string}
+ */
+function inspect_ttrm(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.inspect_ttrm(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.inspect_ttrm = inspect_ttrm;
+
+/**
+ * Validate and describe both the binary container and its decoded replay.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container or decoded replay is invalid.
+ * @param {Uint8Array} container
+ * @returns {string}
+ */
+function inspect_ttrx(container) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(container, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.inspect_ttrx(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.inspect_ttrx = inspect_ttrx;
+
+/**
+ * Return the source extension recorded by a TTRX container (`ttr`, `ttrm`,
+ * or `json` when the source kind is unknown).
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when the container is invalid.
+ * @param {Uint8Array} container
+ * @returns {string}
+ */
+function ttrx_source_extension(container) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(container, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ttrx_source_extension(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.ttrx_source_extension = ttrx_source_extension;
+
+/**
+ * Return the converter package version.
+ * @returns {string}
+ */
+function ttrx_version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.ttrx_version(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.ttrx_version = ttrx_version;
+
+/**
+ * Verify a single-player source replay through an encode/decode round trip.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when validation, encoding, decoding, or semantic
+ * data-model comparison fails.
+ * @param {Uint8Array} source
+ * @returns {string}
+ */
+function verify_ttr(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.verify_ttr(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.verify_ttr = verify_ttr;
+
+/**
+ * Verify a multiplayer source replay through an encode/decode round trip.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when validation, encoding, decoding, or semantic
+ * data-model comparison fails.
+ * @param {Uint8Array} source
+ * @returns {string}
+ */
+function verify_ttrm(source) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(source, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.verify_ttrm(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.verify_ttrm = verify_ttrm;
+
+/**
+ * Validate a binary container and verify its decoded replay data model.
+ *
+ * # Errors
+ *
+ * Returns a JavaScript error when container validation or the decoded replay's
+ * encode/decode verification fails.
+ * @param {Uint8Array} container
+ * @returns {string}
+ */
+function verify_ttrx(container) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(container, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.verify_ttrx(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.verify_ttrx = verify_ttrx;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+    };
+    return {
+        __proto__: null,
+        "./ttrx_wasm_bg.js": import0,
+    };
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/ttrx_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;

package/dist/node/ttrx_wasm_bg.wasm.d.ts

@@ -0,0 +1,17 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const decode_ttrx: (a: number, b: number, c: number) => void;
+export const encode_ttr: (a: number, b: number, c: number) => void;
+export const encode_ttrm: (a: number, b: number, c: number) => void;
+export const inspect_ttr: (a: number, b: number, c: number) => void;
+export const inspect_ttrm: (a: number, b: number, c: number) => void;
+export const inspect_ttrx: (a: number, b: number, c: number) => void;
+export const ttrx_source_extension: (a: number, b: number, c: number) => void;
+export const ttrx_version: (a: number) => void;
+export const verify_ttr: (a: number, b: number, c: number) => void;
+export const verify_ttrm: (a: number, b: number, c: number) => void;
+export const verify_ttrx: (a: number, b: number, c: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number) => void;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "tetr-ttrx",
+  "version": "0.1.0",
+  "description": "Convert TETR.IO .ttr and .ttrm replays to a compact, reversible .ttrx binary format.",
+  "license": "MIT",
+  "author": "daejunnom",
+  "type": "commonjs",
+  "main": "./dist/node/ttrx_wasm.js",
+  "module": "./dist/bundler/ttrx_wasm.js",
+  "browser": "./dist/bundler/ttrx_wasm.js",
+  "types": "./dist/node/ttrx_wasm.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/node/ttrx_wasm.d.ts",
+      "browser": "./dist/bundler/ttrx_wasm.js",
+      "import": "./dist/node/index.mjs",
+      "require": "./dist/node/ttrx_wasm.js",
+      "default": "./dist/bundler/ttrx_wasm.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": [
+    "./dist/bundler/ttrx_wasm.js"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "tetrio",
+    "tetris",
+    "replay",
+    "wasm",
+    "webassembly",
+    "ttrx"
+  ],
+  "scripts": {
+    "build": "node scripts/build-npm.mjs",
+    "check:release": "node scripts/check-release-version.mjs",
+    "test": "cargo test --workspace --all-targets --locked",
+    "test:package:cjs": "node scripts/npm-package-smoke.cjs",
+    "test:package:esm": "node scripts/npm-package-smoke.mjs",
+    "test:package": "npm run test:package:cjs && npm run test:package:esm",
+    "prepack": "npm run build && npm run test:package"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/daejunnom/TTRX"
+  },
+  "bugs": {
+    "url": "https://github.com/daejunnom/TTRX/issues"
+  },
+  "homepage": "https://github.com/daejunnom/TTRX#readme"
+}