@gnufoo/canaad 0.5.1 → 2.0.0

package/README.md

@@ -1,84 +1,116 @@
-# @gnufoo/canaad
+# canaad-wasm
 
-AAD canonicalization in your browser or Worker. Same spec, same bytes.
+[![npm](https://img.shields.io/npm/v/@gnufoo%2Fcanaad)](https://www.npmjs.com/package/@gnufoo/canaad)
 
-```bash
-npm install @gnufoo/canaad
+AAD canonicalization for the browser and Cloudflare Workers. Same spec, same bytes as canaad-core.
+
+## Initialize
+
+WASM must be initialized once before any function calls.
+
+Browser / Cloudflare Workers:
+
+```typescript
+import init, { canonicalizeDefault } from '@gnufoo/canaad';
+
+await init();
 ```
 
-## canonicalize
+Node.js:
 
 ```typescript
-import { canonicalize, canonicalizeString, validate, hash } from '@gnufoo/canaad';
+import { readFileSync } from 'node:fs';
+import { initSync, canonicalizeDefault } from '@gnufoo/canaad';
 
-const bytes = canonicalize('{"v":1,"tenant":"org_abc","resource":"secrets/db","purpose":"encryption"}');
-const str = canonicalizeString('{"v":1,"tenant":"org_abc","resource":"secrets/db","purpose":"encryption"}');
-const ok = validate(json);
-const sha = hash(json);  // 32-byte SHA-256
+initSync({ module: readFileSync(new URL('./canaad_wasm_bg.wasm', import.meta.url)) });
 ```
 
-## build
+## Default profile
 
 ```typescript
-import { AadBuilder } from '@gnufoo/canaad';
+const bytes = canonicalizeDefault('{"v":1,"tenant":"org_abc","resource":"secrets/db","purpose":"encryption"}');
+// → Uint8Array
 
-const aad = new AadBuilder()
-    .tenant("org_abc")
-    .resource("secrets/db")
-    .purpose("encryption")
-    .timestamp(1706400000)
-    .extensionString("x_vault_cluster", "us-east-1")
-    .extensionInt("x_app_priority", 5)
-    .build();        // Uint8Array
+const str = canonicalizeDefaultString('{"v":1,"tenant":"org_abc","resource":"secrets/db","purpose":"encryption"}');
+// → string
+
+const ok = validateDefault('{"v":1,"tenant":"org_abc","resource":"secrets/db","purpose":"encryption"}');
+// → boolean
 ```
 
-Numbers only — no BigInt. `build()` and `buildString()` validate all inputs:
+## Generic object layer
+
+Canonicalize any valid JSON object — no required fields, no version check:
 
-- NaN, Infinity, negative, fractional → rejected
-- `-0.0` → allowed (equals 0 in IEEE 754)
-- integers > 2^53-1 → rejected (JS safe integer limit)
+```typescript
+const bytes = canonicalizeObject('{"z":"last","a":"first"}');
+// → Uint8Array
 
-## exports
+const str = canonicalizeObjectString('{"z":"last","a":"first"}');
+// → '{"a":"first","z":"last"}'
+
+const ok = validateObject('{"anything":"goes"}');
+// → true
+```
 
-This package follows the gnufoo tool package format with four entry points:
+Use this layer to build custom profiles.
 
-| Import | What you get |
-|--------|-------------|
-| `@gnufoo/canaad` | Direct WASM functions (after init) |
-| `@gnufoo/canaad/init` | `initWasm()` + `isInitialized()` |
-| `@gnufoo/canaad/meta` | Zod schemas + metadata (no WASM, SSG-safe) |
-| `@gnufoo/canaad/tool` | `toolDefinition` with `execute()` |
+## Hash
 
-The `/meta` import is safe for static site generation — no WASM loaded.
+SHA-256 of the canonical form (default profile):
 
-The `/tool` path validates inputs via Zod (`z.number().int().nonnegative()` for timestamps and extension integers). Direct WASM imports bypass Zod — the Rust layer validates as defense-in-depth.
+```typescript
+const sha = hash('{"v":1,"tenant":"org_abc","resource":"secrets/db","purpose":"encryption"}');
+// → Uint8Array (32 bytes)
+```
 
-## cloudflare workers
+## Build
 
 ```typescript
-import wasmModule from '@gnufoo/canaad/canaad_wasm_bg.wasm';
-import { toolDefinition } from '@gnufoo/canaad/tool';
+import { AadBuilder } from '@gnufoo/canaad';
 
-await toolDefinition.initWasm(wasmModule);
+const aad = new AadBuilder()
+    .tenant("org_abc")
+    .resource("secrets/db")
+    .purpose("encryption")
+    .timestamp(1706400000)
+    .extensionString("x_vault_cluster", "us-east-1")
+    .extensionInt("x_app_priority", 5)
+    .build();        // → Uint8Array
 
-const result = await toolDefinition.execute({
-    action: 'build',
-    tenant: 'org_abc',
-    resource: 'secrets/db',
-    purpose: 'encryption',
-});
+const str = new AadBuilder()
+    .tenant("org_abc")
+    .resource("secrets/db")
+    .purpose("encryption")
+    .buildString();  // → string
 ```
 
-## browser (vite)
+Numbers only — no BigInt. `build()` and `buildString()` reject NaN, Infinity, negative, fractional, and values above `Number.MAX_SAFE_INTEGER`.
 
-With `vite-plugin-wasm` and `vite-plugin-top-level-await`:
+## Constants
 
 ```typescript
-import { toolDefinition } from '@gnufoo/canaad/tool';
+SPEC_VERSION()        // → 1  (current AAD spec version)
+MAX_SAFE_INTEGER()    // → 9007199254740991  (2^53 - 1, max allowed integer value)
+MAX_SERIALIZED_BYTES() // → 16384  (16 KiB size limit)
+```
+
+## Errors
 
-await toolDefinition.initWasm();
+Failed calls throw with a descriptive message:
+
+```typescript
+try {
+    canonicalizeDefault('{"v":1}');
+} catch (e) {
+    console.error(e.message);  // "missing required field: tenant"
+}
 ```
 
-## license
+## Build from source
+
+```bash
+wasm-pack build --target web --out-dir ../../pkg crates/canaad-wasm
+```
 
-MIT OR Apache-2.0
+`--target web` exports an explicit `init()` you control — works with Cloudflare Workers and Vite.

package/canaad_wasm.d.ts

@@ -2,83 +2,99 @@
 /* eslint-disable */
 
 /**
- * Fluent builder for AAD objects. Chain setters, call `build()` or `buildString()`.
+ * fluent builder for AAD objects. Chain setters, call `build()` or `buildString()`.
  */
 export class AadBuilder {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Builds AAD and returns canonical bytes.
+     * builds AAD and returns canonical bytes.
      */
     build(): Uint8Array;
     /**
-     * Builds AAD and returns canonical UTF-8 string.
+     * builds AAD and returns canonical UTF-8 string.
      */
     buildString(): string;
     /**
-     * Adds an integer extension. Validated at `build()`.
+     * adds an integer extension. Validated at `build()`.
      */
     extensionInt(key: string, value: number): AadBuilder;
     /**
-     * Adds a string extension. Key format: `x_<app>_<field>`.
+     * adds a string extension. Key format: `x_<app>_<field>`.
      */
     extensionString(key: string, value: string): AadBuilder;
     /**
-     * Creates a new AAD builder.
+     * creates an empty builder. Setters store raw values; validation runs on `build()`.
      */
     constructor();
     /**
-     * Sets the purpose. 1+ bytes, no NUL.
+     * sets the purpose. 1+ bytes, no NUL.
      */
     purpose(value: string): AadBuilder;
     /**
-     * Sets the resource. 1-1024 bytes, no NUL.
+     * sets the resource. 1-1024 bytes, no NUL.
      */
     resource(value: string): AadBuilder;
     /**
-     * Sets the tenant. 1-256 bytes, no NUL.
+     * sets the tenant. 1-256 bytes, no NUL.
      */
     tenant(value: string): AadBuilder;
     /**
-     * Sets the timestamp. Validated at `build()`.
+     * sets the timestamp. Validated at `build()`.
      */
     timestamp(ts: number): AadBuilder;
 }
 
 /**
- * Maximum safe integer (2^53 - 1).
+ * maximum safe integer (2^53 - 1).
  */
 export function MAX_SAFE_INTEGER(): number;
 
 /**
- * Maximum serialized AAD size in bytes (16 KiB).
+ * maximum serialized AAD size in bytes (16 KiB).
  */
 export function MAX_SERIALIZED_BYTES(): number;
 
 /**
- * Current AAD specification version (always 1).
+ * current AAD specification version (always 1).
  */
 export function SPEC_VERSION(): number;
 
 /**
- * Parses and canonicalizes a JSON string to bytes (RFC 8785).
+ * parses and canonicalizes a JSON string to bytes using the default AAD profile.
  */
-export function canonicalize(json: string): Uint8Array;
+export function canonicalizeDefault(json: string): Uint8Array;
 
 /**
- * Parses and canonicalizes a JSON string to a UTF-8 string.
+ * parses and canonicalizes a JSON string to a UTF-8 string using the default AAD profile.
  */
-export function canonicalizeString(json: string): string;
+export function canonicalizeDefaultString(json: string): string;
 
 /**
- * SHA-256 hash of the canonical JSON form.
+ * canonicalizes any valid JSON object to bytes (core rules only, no profile fields required).
+ */
+export function canonicalizeObject(json: string): Uint8Array;
+
+/**
+ * canonicalizes any valid JSON object to a UTF-8 string (core rules only, no profile fields required).
+ */
+export function canonicalizeObjectString(json: string): string;
+
+/**
+ * SHA-256 hash of the canonical JSON form (default AAD profile).
  */
 export function hash(json: string): Uint8Array;
 
 /**
- * Validates a JSON string against the AAD specification.
+ * validates a JSON string against the default AAD profile. Returns false on any error.
+ */
+export function validateDefault(json: string): boolean;
+
+/**
+ * validates a JSON string against core rules only (size, duplicate keys, object shape).
+ * Returns false on any error.
  */
-export function validate(json: string): boolean;
+export function validateObject(json: string): boolean;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
@@ -97,10 +113,13 @@ export interface InitOutput {
     readonly aadbuilder_resource: (a: number, b: number, c: number) => number;
     readonly aadbuilder_tenant: (a: number, b: number, c: number) => number;
     readonly aadbuilder_timestamp: (a: number, b: number) => number;
-    readonly canonicalize: (a: number, b: number) => [number, number, number, number];
-    readonly canonicalizeString: (a: number, b: number) => [number, number, number, number];
+    readonly canonicalizeDefault: (a: number, b: number) => [number, number, number, number];
+    readonly canonicalizeDefaultString: (a: number, b: number) => [number, number, number, number];
+    readonly canonicalizeObject: (a: number, b: number) => [number, number, number, number];
+    readonly canonicalizeObjectString: (a: number, b: number) => [number, number, number, number];
     readonly hash: (a: number, b: number) => [number, number, number, number];
-    readonly validate: (a: number, b: number) => number;
+    readonly validateDefault: (a: number, b: number) => number;
+    readonly validateObject: (a: number, b: number) => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;

package/canaad_wasm.js

@@ -1,7 +1,7 @@
 /* @ts-self-types="./canaad_wasm.d.ts" */
 
 /**
- * Fluent builder for AAD objects. Chain setters, call `build()` or `buildString()`.
+ * fluent builder for AAD objects. Chain setters, call `build()` or `buildString()`.
  */
 export class AadBuilder {
     static __wrap(ptr) {
@@ -22,7 +22,7 @@ export class AadBuilder {
         wasm.__wbg_aadbuilder_free(ptr, 0);
     }
     /**
-     * Builds AAD and returns canonical bytes.
+     * builds AAD and returns canonical bytes.
      * @returns {Uint8Array}
      */
     build() {
@@ -35,7 +35,7 @@ export class AadBuilder {
         return v1;
     }
     /**
-     * Builds AAD and returns canonical UTF-8 string.
+     * builds AAD and returns canonical UTF-8 string.
      * @returns {string}
      */
     buildString() {
@@ -57,7 +57,7 @@ export class AadBuilder {
         }
     }
     /**
-     * Adds an integer extension. Validated at `build()`.
+     * adds an integer extension. Validated at `build()`.
      * @param {string} key
      * @param {number} value
      * @returns {AadBuilder}
@@ -70,7 +70,7 @@ export class AadBuilder {
         return AadBuilder.__wrap(ret);
     }
     /**
-     * Adds a string extension. Key format: `x_<app>_<field>`.
+     * adds a string extension. Key format: `x_<app>_<field>`.
      * @param {string} key
      * @param {string} value
      * @returns {AadBuilder}
@@ -85,7 +85,7 @@ export class AadBuilder {
         return AadBuilder.__wrap(ret);
     }
     /**
-     * Creates a new AAD builder.
+     * creates an empty builder. Setters store raw values; validation runs on `build()`.
      */
     constructor() {
         const ret = wasm.aadbuilder_new();
@@ -94,7 +94,7 @@ export class AadBuilder {
         return this;
     }
     /**
-     * Sets the purpose. 1+ bytes, no NUL.
+     * sets the purpose. 1+ bytes, no NUL.
      * @param {string} value
      * @returns {AadBuilder}
      */
@@ -106,7 +106,7 @@ export class AadBuilder {
         return AadBuilder.__wrap(ret);
     }
     /**
-     * Sets the resource. 1-1024 bytes, no NUL.
+     * sets the resource. 1-1024 bytes, no NUL.
      * @param {string} value
      * @returns {AadBuilder}
      */
@@ -118,7 +118,7 @@ export class AadBuilder {
         return AadBuilder.__wrap(ret);
     }
     /**
-     * Sets the tenant. 1-256 bytes, no NUL.
+     * sets the tenant. 1-256 bytes, no NUL.
      * @param {string} value
      * @returns {AadBuilder}
      */
@@ -130,7 +130,7 @@ export class AadBuilder {
         return AadBuilder.__wrap(ret);
     }
     /**
-     * Sets the timestamp. Validated at `build()`.
+     * sets the timestamp. Validated at `build()`.
      * @param {number} ts
      * @returns {AadBuilder}
      */
@@ -143,7 +143,7 @@ export class AadBuilder {
 if (Symbol.dispose) AadBuilder.prototype[Symbol.dispose] = AadBuilder.prototype.free;
 
 /**
- * Maximum safe integer (2^53 - 1).
+ * maximum safe integer (2^53 - 1).
  * @returns {number}
  */
 export function MAX_SAFE_INTEGER() {
@@ -152,7 +152,7 @@ export function MAX_SAFE_INTEGER() {
 }
 
 /**
- * Maximum serialized AAD size in bytes (16 KiB).
+ * maximum serialized AAD size in bytes (16 KiB).
  * @returns {number}
  */
 export function MAX_SERIALIZED_BYTES() {
@@ -161,7 +161,7 @@ export function MAX_SERIALIZED_BYTES() {
 }
 
 /**
- * Current AAD specification version (always 1).
+ * current AAD specification version (always 1).
  * @returns {number}
  */
 export function SPEC_VERSION() {
@@ -170,14 +170,14 @@ export function SPEC_VERSION() {
 }
 
 /**
- * Parses and canonicalizes a JSON string to bytes (RFC 8785).
+ * parses and canonicalizes a JSON string to bytes using the default AAD profile.
  * @param {string} json
  * @returns {Uint8Array}
  */
-export function canonicalize(json) {
+export function canonicalizeDefault(json) {
     const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.canonicalize(ptr0, len0);
+    const ret = wasm.canonicalizeDefault(ptr0, len0);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
@@ -187,17 +187,17 @@ export function canonicalize(json) {
 }
 
 /**
- * Parses and canonicalizes a JSON string to a UTF-8 string.
+ * parses and canonicalizes a JSON string to a UTF-8 string using the default AAD profile.
  * @param {string} json
  * @returns {string}
  */
-export function canonicalizeString(json) {
+export function canonicalizeDefaultString(json) {
     let deferred3_0;
     let deferred3_1;
     try {
         const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.canonicalizeString(ptr0, len0);
+        const ret = wasm.canonicalizeDefaultString(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -213,7 +213,50 @@ export function canonicalizeString(json) {
 }
 
 /**
- * SHA-256 hash of the canonical JSON form.
+ * canonicalizes any valid JSON object to bytes (core rules only, no profile fields required).
+ * @param {string} json
+ * @returns {Uint8Array}
+ */
+export function canonicalizeObject(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.canonicalizeObject(ptr0, len0);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
+/**
+ * canonicalizes any valid JSON object to a UTF-8 string (core rules only, no profile fields required).
+ * @param {string} json
+ * @returns {string}
+ */
+export function canonicalizeObjectString(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.canonicalizeObjectString(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * SHA-256 hash of the canonical JSON form (default AAD profile).
  * @param {string} json
  * @returns {Uint8Array}
  */
@@ -230,14 +273,27 @@ export function hash(json) {
 }
 
 /**
- * Validates a JSON string against the AAD specification.
+ * validates a JSON string against the default AAD profile. Returns false on any error.
+ * @param {string} json
+ * @returns {boolean}
+ */
+export function validateDefault(json) {
+    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.validateDefault(ptr0, len0);
+    return ret !== 0;
+}
+
+/**
+ * validates a JSON string against core rules only (size, duplicate keys, object shape).
+ * Returns false on any error.
  * @param {string} json
  * @returns {boolean}
  */
-export function validate(json) {
+export function validateObject(json) {
     const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.validate(ptr0, len0);
+    const ret = wasm.validateObject(ptr0, len0);
     return ret !== 0;
 }
 

package/canaad_wasm_bg.wasm.d.ts

@@ -14,10 +14,13 @@ export const aadbuilder_purpose: (a: number, b: number, c: number) => number;
 export const aadbuilder_resource: (a: number, b: number, c: number) => number;
 export const aadbuilder_tenant: (a: number, b: number, c: number) => number;
 export const aadbuilder_timestamp: (a: number, b: number) => number;
-export const canonicalize: (a: number, b: number) => [number, number, number, number];
-export const canonicalizeString: (a: number, b: number) => [number, number, number, number];
+export const canonicalizeDefault: (a: number, b: number) => [number, number, number, number];
+export const canonicalizeDefaultString: (a: number, b: number) => [number, number, number, number];
+export const canonicalizeObject: (a: number, b: number) => [number, number, number, number];
+export const canonicalizeObjectString: (a: number, b: number) => [number, number, number, number];
 export const hash: (a: number, b: number) => [number, number, number, number];
-export const validate: (a: number, b: number) => number;
+export const validateDefault: (a: number, b: number) => number;
+export const validateObject: (a: number, b: number) => number;
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __externref_table_dealloc: (a: number) => void;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;

package/package.json

@@ -1,47 +1,33 @@
 {
   "name": "@gnufoo/canaad",
-  "version": "0.5.1",
   "type": "module",
-  "types": "canaad_wasm.d.ts",
-  "exports": {
-    ".": {
-      "types": "./canaad_wasm.d.ts",
-      "import": "./canaad_wasm.js"
-    },
-    "./meta": {
-      "types": "./meta.d.ts",
-      "import": "./meta.js"
-    },
-    "./tool": {
-      "types": "./tool.d.ts",
-      "import": "./tool.js"
-    },
-    "./init": {
-      "types": "./init.d.ts",
-      "import": "./init.js"
-    }
-  },
-  "dependencies": {
-    "zod": "^3.24.0"
+  "description": "WASM bindings for AAD canonicalization per RFC 8785",
+  "version": "2.0.0",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gnufood/canaad"
   },
   "files": [
-    "*.js",
-    "*.d.ts",
-    "*.wasm"
+    "canaad_wasm.js",
+    "canaad_wasm.d.ts",
+    "canaad_wasm_bg.wasm",
+    "canaad_wasm_bg.wasm.d.ts"
   ],
+  "types": "canaad_wasm.d.ts",
   "sideEffects": false,
   "keywords": [
     "aead",
     "aad",
     "canonicalization",
     "jcs",
-    "rfc8785",
-    "wasm"
+    "rfc8785"
   ],
-  "license": "MIT OR Apache-2.0",
-  "description": "AAD canonicalization library (RFC 8785)",
-  "repository": {
-    "url": "https://gnu.foo/projects/canaad"
+  "exports": {
+    ".": {
+      "types": "./canaad_wasm.d.ts",
+      "import": "./canaad_wasm.js"
+    }
   },
   "homepage": "https://gnu.foo/projects/canaad",
   "bugs": {

package/canaad_wasm_bg.js

@@ -1,527 +0,0 @@
-/**
- * Builder for constructing AAD objects programmatically.
- *
- * Provides a fluent API for building AAD with method chaining.
- * All setter methods return a new builder to enable chaining.
- *
- * # Example (JavaScript)
- *
- * ```javascript
- * const builder = new AadBuilder()
- *     .tenant("org_abc")
- *     .resource("secrets/db")
- *     .purpose("encryption")
- *     .timestamp(1706400000)
- *     .extensionString("x_vault_cluster", "us-east-1");
- *
- * const bytes = builder.build();
- * const canonical = builder.buildString();
- * ```
- */
-export class AadBuilder {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(AadBuilder.prototype);
-        obj.__wbg_ptr = ptr;
-        AadBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AadBuilderFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_aadbuilder_free(ptr, 0);
-    }
-    /**
-     * Builds the AAD and returns the canonical bytes.
-     *
-     * # Returns
-     *
-     * A `Uint8Array` containing the UTF-8 encoded canonical JSON.
-     *
-     * # Errors
-     *
-     * Throws a JavaScript error if:
-     * - Required fields (tenant, resource, purpose) are missing
-     * - Any field value is invalid
-     * - Extension keys don't match the required pattern
-     * - The serialized output exceeds 16 KiB
-     * @returns {Uint8Array}
-     */
-    build() {
-        const ret = wasm.aadbuilder_build(this.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Builds the AAD and returns the canonical string.
-     *
-     * # Returns
-     *
-     * The canonical (JCS) representation as a string.
-     *
-     * # Errors
-     *
-     * Throws a JavaScript error if:
-     * - Required fields (tenant, resource, purpose) are missing
-     * - Any field value is invalid
-     * - Extension keys don't match the required pattern
-     * - The serialized output exceeds 16 KiB
-     * @returns {string}
-     */
-    buildString() {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const ret = wasm.aadbuilder_buildString(this.__wbg_ptr);
-            var ptr1 = ret[0];
-            var len1 = ret[1];
-            if (ret[3]) {
-                ptr1 = 0; len1 = 0;
-                throw takeFromExternrefTable0(ret[2]);
-            }
-            deferred2_0 = ptr1;
-            deferred2_1 = len1;
-            return getStringFromWasm0(ptr1, len1);
-        } finally {
-            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
-        }
-    }
-    /**
-     * Adds an integer extension field.
-     *
-     * Extension keys must match pattern `x_<app>_<field>` where:
-     * - `<app>` is one or more lowercase letters
-     * - `<field>` is one or more lowercase letters or underscores
-     *
-     * # Arguments
-     *
-     * * `key` - Extension key (e.g., `x_app_priority`)
-     * * `value` - Integer value (0 to 2^53-1)
-     *
-     * # Returns
-     *
-     * A new builder with the extension added.
-     * @param {string} key
-     * @param {number} value
-     * @returns {AadBuilder}
-     */
-    extensionInt(key, value) {
-        const ptr = this.__destroy_into_raw();
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.aadbuilder_extensionInt(ptr, ptr0, len0, value);
-        return AadBuilder.__wrap(ret);
-    }
-    /**
-     * Adds a string extension field.
-     *
-     * Extension keys must match pattern `x_<app>_<field>` where:
-     * - `<app>` is one or more lowercase letters
-     * - `<field>` is one or more lowercase letters or underscores
-     *
-     * # Arguments
-     *
-     * * `key` - Extension key (e.g., `x_vault_cluster`)
-     * * `value` - String value (no NUL bytes)
-     *
-     * # Returns
-     *
-     * A new builder with the extension added.
-     * @param {string} key
-     * @param {string} value
-     * @returns {AadBuilder}
-     */
-    extensionString(key, value) {
-        const ptr = this.__destroy_into_raw();
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.aadbuilder_extensionString(ptr, ptr0, len0, ptr1, len1);
-        return AadBuilder.__wrap(ret);
-    }
-    /**
-     * Creates a new AAD builder.
-     */
-    constructor() {
-        const ret = wasm.aadbuilder_new();
-        this.__wbg_ptr = ret >>> 0;
-        AadBuilderFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Sets the purpose or usage context.
-     *
-     * # Arguments
-     *
-     * * `value` - Purpose description (1+ bytes, no NUL bytes)
-     *
-     * # Returns
-     *
-     * A new builder with the purpose set.
-     * @param {string} value
-     * @returns {AadBuilder}
-     */
-    purpose(value) {
-        const ptr = this.__destroy_into_raw();
-        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.aadbuilder_purpose(ptr, ptr0, len0);
-        return AadBuilder.__wrap(ret);
-    }
-    /**
-     * Sets the resource path or identifier.
-     *
-     * # Arguments
-     *
-     * * `value` - Resource path (1-1024 bytes, no NUL bytes)
-     *
-     * # Returns
-     *
-     * A new builder with the resource set.
-     * @param {string} value
-     * @returns {AadBuilder}
-     */
-    resource(value) {
-        const ptr = this.__destroy_into_raw();
-        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.aadbuilder_resource(ptr, ptr0, len0);
-        return AadBuilder.__wrap(ret);
-    }
-    /**
-     * Sets the tenant identifier.
-     *
-     * # Arguments
-     *
-     * * `value` - Tenant identifier (1-256 bytes, no NUL bytes)
-     *
-     * # Returns
-     *
-     * A new builder with the tenant set.
-     * @param {string} value
-     * @returns {AadBuilder}
-     */
-    tenant(value) {
-        const ptr = this.__destroy_into_raw();
-        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.aadbuilder_tenant(ptr, ptr0, len0);
-        return AadBuilder.__wrap(ret);
-    }
-    /**
-     * Sets the timestamp.
-     *
-     * # Arguments
-     *
-     * * `ts` - Unix timestamp (0 to 2^53-1)
-     *
-     * # Returns
-     *
-     * A new builder with the timestamp set.
-     * @param {number} ts
-     * @returns {AadBuilder}
-     */
-    timestamp(ts) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.aadbuilder_timestamp(ptr, ts);
-        return AadBuilder.__wrap(ret);
-    }
-}
-if (Symbol.dispose) AadBuilder.prototype[Symbol.dispose] = AadBuilder.prototype.free;
-
-/**
- * Returns the maximum safe integer value (2^53 - 1).
- *
- * This is the maximum integer value that can be exactly represented in
- * JavaScript's Number type.
- * @returns {number}
- */
-export function MAX_SAFE_INTEGER() {
-    const ret = wasm.MAX_SAFE_INTEGER();
-    return ret;
-}
-
-/**
- * Returns the maximum serialized AAD size in bytes (16 KiB).
- * @returns {number}
- */
-export function MAX_SERIALIZED_BYTES() {
-    const ret = wasm.MAX_SERIALIZED_BYTES();
-    return ret >>> 0;
-}
-
-/**
- * Returns the current AAD specification version.
- *
- * Currently always returns 1.
- * @returns {number}
- */
-export function SPEC_VERSION() {
-    const ret = wasm.SPEC_VERSION();
-    return ret >>> 0;
-}
-
-/**
- * Parses and canonicalizes a JSON string to bytes.
- *
- * This function:
- * 1. Parses the JSON with duplicate key detection
- * 2. Validates all fields according to the AAD specification
- * 3. Returns the canonical (JCS) representation as bytes
- *
- * # Arguments
- *
- * * `json` - A JSON string containing an AAD object
- *
- * # Returns
- *
- * A `Uint8Array` containing the UTF-8 encoded canonical JSON.
- *
- * # Errors
- *
- * Throws a JavaScript error if:
- * - The JSON is invalid or contains duplicate keys
- * - Any field violates AAD constraints
- * - The serialized output exceeds 16 KiB
- * @param {string} json
- * @returns {Uint8Array}
- */
-export function canonicalize(json) {
-    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.canonicalize(ptr0, len0);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v2;
-}
-
-/**
- * Parses and canonicalizes a JSON string to a UTF-8 string.
- *
- * This is equivalent to `canonicalize` but returns a string instead of bytes.
- *
- * # Arguments
- *
- * * `json` - A JSON string containing an AAD object
- *
- * # Returns
- *
- * The canonical (JCS) representation as a string.
- *
- * # Errors
- *
- * Throws a JavaScript error if:
- * - The JSON is invalid or contains duplicate keys
- * - Any field violates AAD constraints
- * - The serialized output exceeds 16 KiB
- * @param {string} json
- * @returns {string}
- */
-export function canonicalizeString(json) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.canonicalizeString(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
-        if (ret[3]) {
-            ptr2 = 0; len2 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
-    } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-    }
-}
-
-/**
- * Computes the SHA-256 hash of the canonical JSON form.
- *
- * This function:
- * 1. Parses and validates the JSON
- * 2. Canonicalizes according to RFC 8785
- * 3. Returns the SHA-256 hash of the canonical bytes
- *
- * # Arguments
- *
- * * `json` - A JSON string containing an AAD object
- *
- * # Returns
- *
- * A 32-byte `Uint8Array` containing the SHA-256 hash.
- *
- * # Errors
- *
- * Throws a JavaScript error if:
- * - The JSON is invalid or contains duplicate keys
- * - Any field violates AAD constraints
- * - The serialized output exceeds 16 KiB
- * @param {string} json
- * @returns {Uint8Array}
- */
-export function hash(json) {
-    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.hash(ptr0, len0);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v2;
-}
-
-/**
- * Validates a JSON string against the AAD specification.
- *
- * This function performs full validation without returning the context.
- * Use this for quick validation checks.
- *
- * # Arguments
- *
- * * `json` - A JSON string to validate
- *
- * # Returns
- *
- * `true` if the JSON is valid AAD, `false` otherwise.
- * @param {string} json
- * @returns {boolean}
- */
-export function validate(json) {
-    const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.validate(ptr0, len0);
-    return ret !== 0;
-}
-export function __wbg_Error_8c4e43fe74559d73(arg0, arg1) {
-    const ret = Error(getStringFromWasm0(arg0, arg1));
-    return ret;
-}
-export function __wbg___wbindgen_throw_be289d5034ed271b(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-}
-export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_externrefs;
-    const offset = table.grow(4);
-    table.set(0, undefined);
-    table.set(offset + 0, undefined);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-}
-const AadBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_aadbuilder_free(ptr >>> 0, 1));
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-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));
-}
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    };
-}
-
-let WASM_VECTOR_LEN = 0;
-
-
-let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}

package/errors.d.ts

@@ -1,5 +0,0 @@
-/** Thrown when an operation is called before `initWasm()` completes. */
-export declare class WasmNotInitializedError extends Error {
-  /** Discriminant for branded error handling — always `'WasmNotInitializedError'`. */
-  readonly kind: 'WasmNotInitializedError';
-}

package/errors.js

@@ -1,10 +0,0 @@
-/** Thrown when an operation is called before `initWasm()` completes. */
-export class WasmNotInitializedError extends Error {
-  /** Discriminant for branded error handling — always `'WasmNotInitializedError'`. */
-  kind = 'WasmNotInitializedError';
-
-  constructor() {
-    super('WASM not initialized. Call initWasm() first.');
-    this.name = 'WasmNotInitializedError';
-  }
-}

package/init.d.ts

@@ -1,11 +0,0 @@
-/**
- * Initialize WASM. Call once before using any WASM functions.
- *
- * @param wasmModule - pass a precompiled WebAssembly.Module in Workers, omit in browser
- */
-export function initWasm(wasmModule?: WebAssembly.Module): Promise<void>;
-
-/**
- * True if WASM has been initialized via `initWasm()`.
- */
-export function isInitialized(): boolean;

package/init.js

@@ -1,27 +0,0 @@
-import init from './canaad_wasm.js';
-
-let initialized = false;
-let initPromise = null;
-
-/**
- * Initialize WASM. Call once before using any WASM functions.
- *
- * @param {WebAssembly.Module | undefined} wasmModule - pass a precompiled module in Workers, omit in browser
- */
-export async function initWasm(wasmModule) {
-  if (initialized) return;
-  if (initPromise) return initPromise;
-
-  initPromise = init(wasmModule).then(() => {
-    initialized = true;
-  });
-
-  return initPromise;
-}
-
-/**
- * True if WASM has been initialized via `initWasm()`.
- */
-export function isInitialized() {
-  return initialized;
-}

package/meta.d.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-
-/** Validates and parses all AAD action inputs. */
-export declare const inputSchema: z.ZodType;
-
-/** Validates and parses all AAD action outputs. */
-export declare const outputSchema: z.ZodType;
-
-/** Discriminated union of all action input shapes. */
-export type CanaadInput = z.infer<typeof inputSchema>;
-
-/** Discriminated union of all action output shapes. */
-export type CanaadOutput = z.infer<typeof outputSchema>;
-
-/** Tool metadata: id, name, slug, description, category, execution type, positional args, schemas, and optional registry links. */
-export declare const meta: {
-  id: string;
-  name: string;
-  slug: string;
-  description: string;
-  category: string;
-  executionType: string;
-  positionalArgs: { order: string[]; required: number };
-  packages?: { npm?: string; crates?: string };
-  inputSchema: typeof inputSchema;
-  outputSchema: typeof outputSchema;
-};

package/meta.js

@@ -1,61 +0,0 @@
-import { z } from 'zod';
-
-// AAD spec: tenant field capped at 256 UTF-8 bytes.
-const TENANT_MAX_BYTES = 256;
-// AAD spec: resource field capped at 1024 UTF-8 bytes.
-const RESOURCE_MAX_BYTES = 1024;
-const encoder = new TextEncoder();
-
-const extensionSchema = z.object({
-  key: z.string().regex(/^x_[a-z]+_[a-z_]+$/),
-  value: z.union([z.string(), z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)]),
-});
-
-export const inputSchema = z.discriminatedUnion('action', [
-  z.object({
-    action: z.literal('canonicalize'),
-    input: z.string(),
-    outputFormat: z.enum(['bytes', 'string']).default('string'),
-  }),
-  z.object({
-    action: z.literal('validate'),
-    input: z.string(),
-  }),
-  z.object({
-    action: z.literal('hash'),
-    input: z.string(),
-    outputFormat: z.enum(['hex', 'base64']).default('hex'),
-  }),
-  z.object({
-    action: z.literal('build'),
-    tenant: z.string().min(1).refine(s => encoder.encode(s).length <= TENANT_MAX_BYTES, `tenant exceeds ${TENANT_MAX_BYTES} bytes`),
-    resource: z.string().min(1).refine(s => encoder.encode(s).length <= RESOURCE_MAX_BYTES, `resource exceeds ${RESOURCE_MAX_BYTES} bytes`),
-    purpose: z.string().min(1),
-    timestamp: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
-    extensions: z.array(extensionSchema).optional(),
-    outputFormat: z.enum(['bytes', 'string']).default('string'),
-  }),
-]);
-
-export const outputSchema = z.discriminatedUnion('action', [
-  z.object({ action: z.literal('canonicalize'), output: z.union([z.string(), z.array(z.number())]), outputFormat: z.enum(['bytes', 'string']) }),
-  z.object({ action: z.literal('validate'), valid: z.boolean() }),
-  z.object({ action: z.literal('hash'), hash: z.string(), outputFormat: z.enum(['hex', 'base64']) }),
-  z.object({ action: z.literal('build'), output: z.union([z.string(), z.array(z.number())]), outputFormat: z.enum(['bytes', 'string']) }),
-]);
-
-export const meta = {
-  id: 'canaad',
-  name: 'canaad',
-  slug: 'canaad',
-  description: 'canonicalize JSON for AAD (Additional Authenticated Data) per RFC 8785',
-  category: 'crypto',
-  executionType: 'hybrid',
-  positionalArgs: { order: ['action', 'input'], required: 1 },
-  packages: {
-    npm: '@gnufoo/canaad',
-    crates: 'canaad-core',
-  },
-  inputSchema,
-  outputSchema,
-};

package/tool.d.ts

@@ -1,14 +0,0 @@
-import type { meta, CanaadInput, CanaadOutput } from './meta.js';
-import type { initWasm, isInitialized } from './init.js';
-
-/**
- * Main tool export. Merges AAD metadata with WASM lifecycle methods and the action dispatcher.
- */
-export declare const toolDefinition: typeof meta & {
-  initWasm: typeof initWasm;
-  isInitialized: typeof isInitialized;
-  /** Dispatches an AAD action to WASM. Requires prior `initWasm()` call. */
-  execute(input: CanaadInput): Promise<CanaadOutput>;
-};
-
-export { WasmNotInitializedError } from './errors.js';

package/tool.js

@@ -1,50 +0,0 @@
-import { meta, inputSchema } from './meta.js';
-import { initWasm, isInitialized } from './init.js';
-import { canonicalize, canonicalizeString, hash, validate, AadBuilder } from './canaad_wasm.js';
-import { WasmNotInitializedError } from './errors.js';
-const bytesToHex = (bytes) => Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
-const bytesToBase64 = (bytes) => globalThis.btoa(String.fromCharCode(...bytes));
-/**
- * Main tool export. Merges AAD metadata with WASM lifecycle methods and the action dispatcher.
- */
-export const toolDefinition = {
-  ...meta,
-  initWasm,
-  isInitialized,
-
-  /**
-   * Dispatches an AAD action to WASM. Requires prior `initWasm()` call.
-   */
-  async execute(rawInput) {
-    if (!isInitialized()) {
-      throw new WasmNotInitializedError();
-    }
-    const input = inputSchema.parse(rawInput);
-    switch (input.action) {
-      case 'canonicalize': {
-        if (input.outputFormat === 'bytes') {
-          return { action: 'canonicalize', output: Array.from(canonicalize(input.input)), outputFormat: 'bytes' };
-        }
-        return { action: 'canonicalize', output: canonicalizeString(input.input), outputFormat: 'string' };
-      }
-      case 'validate':
-        return { action: 'validate', valid: validate(input.input) };
-      case 'hash': {
-        const h = hash(input.input);
-        return { action: 'hash', hash: input.outputFormat === 'base64' ? bytesToBase64(h) : bytesToHex(h), outputFormat: input.outputFormat };
-      }
-      case 'build': {
-        let b = new AadBuilder().tenant(input.tenant).resource(input.resource).purpose(input.purpose);
-        if (input.timestamp !== undefined) b = b.timestamp(input.timestamp);
-        for (const ext of input.extensions || []) {
-          b = typeof ext.value === 'string' ? b.extensionString(ext.key, ext.value) : b.extensionInt(ext.key, ext.value);
-        }
-        if (input.outputFormat === 'bytes') {
-          return { action: 'build', output: Array.from(b.build()), outputFormat: 'bytes' };
-        }
-        return { action: 'build', output: b.buildString(), outputFormat: 'string' };
-      }
-    }
-  },
-};
-export { WasmNotInitializedError } from './errors.js';