@cratestack/cbor-web 0.8.14 → 0.8.15

package/dist/wasm-pkg/cratestack_cbor_wasm.js

@@ -20,23 +20,31 @@ export function contentType() {
 }
 
 /**
- * Decodes CBOR bytes into a plain JS value. Malformed input surfaces as
- * a rejected/thrown `Error`, never a trap — see the module doc comment.
+ * Decodes CBOR bytes into a plain JS value. A CBOR byte string comes
+ * back as a `Uint8Array` — the inverse of [`encode`]'s handling, closing
+ * cratestack#783's symmetric decode half. Two things are load-bearing
+ * for that: `JsSerializable` (which pins `Value::Bytes` to
+ * `serialize_bytes` rather than the base64 string `Value` emits for
+ * human-readable formats, and `serde_wasm_bindgen::Serializer` reports
+ * itself as one), and leaving `serialize_bytes_as_arrays` at its default
+ * so `serialize_bytes` produces a `Uint8Array` and not a plain `Array`.
+ * Malformed input surfaces as a rejected/thrown `Error`, never a trap —
+ * see the module doc comment.
  *
  * Two `serde_wasm_bindgen` default `Serializer` behaviors would otherwise
  * corrupt the result, so this builds an explicit `Serializer` instead of
  * using the `to_value` convenience function:
  *   - `serialize_maps_as_objects(true)` — the default turns Rust maps
- *     (including `serde_json::Value::Object`) into JS `Map` instances,
- *     not plain `{}` objects. A `Map` round-trips fine through explicit
+ *     (including `Value::Map`) into JS `Map` instances, not plain `{}`
+ *     objects. A `Map` round-trips fine through explicit
  *     `.get()`/`.entries()` calls, but silently renders as `"{}"` under
  *     `JSON.stringify`, which isn't what a `decode(bytes): unknown`
  *     caller expects.
  *   - `serialize_missing_as_null(true)` — the default serializes both
- *     `serialize_none()` and `serialize_unit()` (what `serde_json::Value
- *     ::Null`'s own `Serialize` impl calls) as JS `undefined`, not
- *     `null`. An object property set to `undefined` is silently dropped
- *     by `JSON.stringify`, which is what made this look like data loss
+ *     `serialize_none()` (what `Value::Null` calls) and
+ *     `serialize_unit()` as JS `undefined`, not `null`. An object
+ *     property set to `undefined` is silently dropped by
+ *     `JSON.stringify`, which is what made this look like data loss
  *     during development rather than a `null`-vs-`undefined` mismatch.
  * @param {Uint8Array} bytes
  * @returns {any}
@@ -54,11 +62,15 @@ export function decode(bytes) {
 /**
  * Encodes an arbitrary JS value as CBOR bytes.
  *
- * `value` is deserialized into an owned `serde_json::Value` first (JS has
- * no notion of the concrete Rust types `CborCodec::encode<T>` is generic
- * over), then re-serialized through `EncodableValue` — see
- * `json_bridge.rs` for why that indirection exists rather than encoding
- * the `serde_json::Value` tree directly.
+ * `value` is deserialized into an owned `cratestack_core::Value` first
+ * (JS has no notion of the concrete Rust types `CborCodec::encode<T>` is
+ * generic over), then encoded. `Value` rather than `serde_json::Value`
+ * is what makes binary data work at all: a JS `Uint8Array`/`ArrayBuffer`
+ * lands in `Value::Bytes` (`serde-wasm-bindgen`'s `deserialize_any`
+ * routes both to `visit_byte_buf`) and goes out as a CBOR byte string,
+ * instead of degrading into a map of index→value that no `Vec<u8>` on
+ * the Rust side can decode — cratestack#783. See `value_bridge.rs` for
+ * the full rationale and the host-runnable byte assertions.
  * @param {any} value
  * @returns {Uint8Array}
  */
@@ -182,6 +194,10 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
+        __wbg_from_50138b2ca136f50c: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
         __wbg_get_197a3fe98f169e38: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -307,11 +323,16 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000004: function(arg0) {
+        __wbindgen_cast_0000000000000005: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratestack/cbor-web",
-  "version": "0.8.14",
+  "version": "0.8.15",
   "description": "wasm-bindgen CBOR codec for browser CrateStack RPC clients. Async one-time WASM init, synchronous encode/decode after — backed by the same Rust CborCodec the server and Rust client already use.",
   "license": "MIT",
   "repository": {
@@ -43,7 +43,7 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@cratestack/ts-types": "0.8.14"
+    "@cratestack/ts-types": "0.8.15"
   },
   "devDependencies": {
     "typescript": "^7.0.2",