watr 4.7.2 → 5.1.0

package/src/template.js

@@ -19,6 +19,24 @@ import { resultType } from './const.js'
 /** Private Use Area character as placeholder for interpolation */
 const PUA = '\uE000'
 
+/**
+ * Apply a backend transform (`polyfill`/`optimize`), or throw an actionable
+ * pointer when this entry doesn't bundle it. The default `watr` build wires a
+ * lean backend (parse + compile) and leaves the heavy transforms to their own
+ * entries, so `compile(src, { optimize })` here directs you to compose instead.
+ *
+ * @param {Function|undefined} fn - transform from the backend
+ * @param {string} name - 'polyfill' | 'optimize'
+ * @param {Array} ast
+ * @param {any} opt - the option value
+ * @returns {Array} transformed AST
+ */
+function applyTransform(fn, name, ast, opt) {
+  if (typeof fn !== 'function')
+    throw Error(`watr: '${name}' is not bundled in this entry \u2014 import it from 'watr/${name}' and compose: compile(${name}(src))`)
+  return fn(ast, opt)
+}
+
 /**
  * Infer type of an expression AST node.
  * Used for auto-import parameter type inference.
@@ -209,9 +227,9 @@ export function compile(backend, source, values) {
       }
     }
 
-    // Apply transforms
-    if (opts.polyfill) ast = polyfill(ast, opts.polyfill)
-    if (opts.optimize) ast = optimize(ast, opts.optimize)
+    // Apply transforms (heavy passes live in separate entries — see applyTransform)
+    if (opts.polyfill) ast = applyTransform(polyfill, 'polyfill', ast, opts.polyfill)
+    if (opts.optimize) ast = applyTransform(optimize, 'optimize', ast, opts.optimize)
 
     const binary = emit(ast)
     // Attach imports for watr() to use
@@ -222,8 +240,8 @@ export function compile(backend, source, values) {
   // String/AST source with options
   if (opts.polyfill || opts.optimize) {
     let ast = typeof source === 'string' ? parse(source) : source
-    if (opts.polyfill) ast = polyfill(ast, opts.polyfill)
-    if (opts.optimize) ast = optimize(ast, opts.optimize)
+    if (opts.polyfill) ast = applyTransform(polyfill, 'polyfill', ast, opts.polyfill)
+    if (opts.optimize) ast = applyTransform(optimize, 'optimize', ast, opts.optimize)
     return emit(ast)
   }
   return emit(source)

package/src/util.js

@@ -1,23 +1,37 @@
+// Ambient source/position for err()'s "at line:col" suffix — set by assemble()
+// as it walks a module (err.loc/err.src used to be expando properties on the
+// `err` function itself; a self-hosted compile-clear-compile loop bump-allocates
+// a HASH props table the first time a property lands on a function value, and
+// that table dangles across an arena `_clear` between compiles — corrupting the
+// SECOND self-host compile. Plain module-level `let`s are a global-set, not a
+// dynamic-key write, so they carry no such table and are `_clear`-safe.
+let errLoc, errSrc
+
 /**
  * Throws an error with optional source position.
- * Uses err.src for source and err.loc for default position.
- * If pos provided or err.loc set, appends "at line:col".
+ * Uses the ambient errSrc for source and errLoc for default position.
+ * If pos provided or errLoc set, appends "at line:col".
  *
  * @param {string} text - Error message
- * @param {number} [pos] - Byte offset in source (defaults to err.loc)
+ * @param {number} [pos] - Byte offset in source (defaults to errLoc)
  * @throws {Error}
  */
-export const err = (text, pos=err.loc) => {
-  if (pos != null && err.src) {
+export const err = (text, pos=errLoc) => {
+  if (pos != null && errSrc) {
     let line = 1, col = 1
-    for (let i = 0; i < pos && i < err.src.length; i++) {
-      if (err.src[i] === '\n') line++, col = 1
+    for (let i = 0; i < pos && i < errSrc.length; i++) {
+      if (errSrc.charCodeAt(i) === 10) line++, col = 1
       else col++
     }
     text += ` at ${line}:${col}`
   }
   throw Error(text)
 }
+// Accessors for the ambient position/source (compile.js is the only writer).
+export const setErrLoc = (loc) => { errLoc = loc }
+export const setErrSrc = (src) => { errSrc = src }
+export const getErrLoc = () => errLoc
+export const getErrSrc = () => errSrc
 
 /** Regex to detect invalid underscore placement in numbers */
 export const sepRE = /^_|_$|[^\da-f]_|_[^\da-f]/i
@@ -97,7 +111,13 @@ export const clone = (node) => Array.isArray(node) ? node.map(clone) : node
  */
 export const walk = (node, fn, parent, idx) => {
   fn(node, parent, idx)
-  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walk(node[i], fn, node, i)
+  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) {
+    const c = node[i]
+    // leaves get their visit inline — half of all nodes are strings/numbers, and a
+    // full recursive frame per leaf dominates traversal cost on big modules
+    if (Array.isArray(c)) walk(c, fn, node, i)
+    else fn(c, node, i)
+  }
 }
 
 /**
@@ -115,7 +135,11 @@ export const walk = (node, fn, parent, idx) => {
  * @returns {any} The (possibly replaced) node
  */
 export const walkPost = (node, fn, parent, idx) => {
-  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) walkPost(node[i], fn, node, i)
+  if (Array.isArray(node)) for (let i = 0; i < node.length; i++) {
+    const c = node[i]
+    if (Array.isArray(c)) walkPost(c, fn, node, i)
+    else { const r = fn(c, node, i); if (r !== undefined) node[i] = r }
+  }
   const result = fn(node, parent, idx)
   if (result !== undefined && parent) parent[idx] = result
   return result !== undefined ? result : node

package/types/src/compile.d.ts

@@ -10,4 +10,5 @@ export default function compile(nodes: any): any;
  * summed from section sizes instead of building them (invariant-tested).
  */
 export function size(nodes: any): any;
+export function numdata(item: any): any[];
 //# sourceMappingURL=compile.d.ts.map

package/types/src/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AA4UA;;;;GAIG;AACH,iDAAiE;AAEjE;;;;GAIG;AACH,sCAA4D"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.js"],"names":[],"mappings":"AAsVA;;;;GAIG;AACH,iDAAiE;AAEjE;;;;GAIG;AACH,sCAA4D;AAg8BrD,0CAcN"}

package/types/src/const.d.ts

@@ -1,4 +1,5 @@
-export const INSTR: (string | string[])[];
+export const OPCODE: {};
+export const IMM: {};
 export function resultType(op: string): string | null;
 export namespace SECTION {
     export let custom: number;

package/types/src/const.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":"AAIA,0CA0KC;AAYM,+BAHI,MAAM,GACJ,MAAM,GAAC,IAAI,CAavB"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../src/const.js"],"names":[],"mappings":"AAgKa,wBAAW;AAAE,qBAAQ;AAoB3B,+BAHI,MAAM,GACJ,MAAM,GAAC,IAAI,CAavB"}

package/types/src/encode.d.ts

@@ -6,14 +6,7 @@
  * @returns {number[]} 5-byte array
  */
 export function uleb5(value: number): number[];
-/**
- * Encode signed LEB128 for i32 values.
- *
- * @param {number|string} n - Signed 32-bit value
- * @param {number[]} [buffer=[]] - Output buffer
- * @returns {number[]} Encoded bytes
- */
-export function i32(n: number | string, buffer?: number[]): number[];
+export function i32(n: any, buffer?: any[]): any[];
 export namespace i32 {
     function parse(n: any): any;
 }
@@ -28,32 +21,18 @@ export function i64(n: bigint | string, buffer?: number[]): number[];
 export namespace i64 {
     function parse(n: any): any;
 }
-export function f32(input: any, value: any, idx: any): number[];
+export function f32(input: any, out: any, value: any, idx: any): number[];
 export namespace f32 {
     function parse(input: any): number;
 }
-export function f64(input: any, value: any, idx: any): number[];
+export function f64(input: any, out: any, value: any, idx: any): any;
 export namespace f64 {
     function parse(input: any, max?: number): number;
 }
 export function uleb(n: number | bigint | string | null, buffer?: number[]): number[];
-/**
- * Encode signed LEB128 for i32 values.
- *
- * @param {number|string} n - Signed 32-bit value
- * @param {number[]} [buffer=[]] - Output buffer
- * @returns {number[]} Encoded bytes
- */
-export function i8(n: number | string, buffer?: number[]): number[];
+export function i8(n: any, buffer?: any[]): any[];
 export namespace i8 { }
-/**
- * Encode signed LEB128 for i32 values.
- *
- * @param {number|string} n - Signed 32-bit value
- * @param {number[]} [buffer=[]] - Output buffer
- * @returns {number[]} Encoded bytes
- */
-export function i16(n: number | string, buffer?: number[]): number[];
+export function i16(n: any, buffer?: any[]): any[];
 export namespace i16 { }
 export function v128(input: any): any[];
 //# sourceMappingURL=encode.d.ts.map

package/types/src/encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/encode.js"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH,6BAHW,MAAM,GACJ,MAAM,EAAE,CAapB;AAED;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;IAQD,4BAIC;;AAED;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAoBpB;;IAID,4BAmBC;;AAGD,gEAiBC;;IAoED,mCAA6D;;AAjE7D,gEAiBC;;IAED,iDA4CC;;AA1NM,wBAJI,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,IAAI,WACzB,MAAM,EAAE,GACN,MAAM,EAAE,CA8BpB;AAsBD;;;;;;GAMG;AACH,sBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;AApBD;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAepB;;AAwJM,wCAKN"}
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/encode.js"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH,6BAHW,MAAM,GACJ,MAAM,EAAE,CAapB;AAYD,mDAqBC;;IAQD,4BAIC;;AAED;;;;;;GAMG;AACH,uBAJW,MAAM,GAAC,MAAM,WACb,MAAM,EAAE,GACN,MAAM,EAAE,CAoBpB;;IAID,4BAmBC;;AAGD,0EAkBC;;IAiFD,mCAA6D;;AA7E7D,qEA6BC;;IAED,iDA4CC;;AAnPM,wBAJI,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,IAAI,WACzB,MAAM,EAAE,GACN,MAAM,EAAE,CA8BpB;AAgCD,kDAqBC;;AArBD,mDAqBC;;AAsKM,wCAKN"}

package/types/src/optimize.d.ts

@@ -18,12 +18,8 @@ export function binarySize(ast: any[]): number;
  * @returns {Array}
  */
 export function treeshake(ast: any[]): any[];
-/**
- * Fold constant expressions.
- * @param {Array} ast
- * @returns {Array}
- */
-export function fold(ast: any[]): any[];
+/** Constant folding as a standalone pass. */
+export function fold(ast: any): any;
 /**
  * Remove dead code after control flow terminators.
  * @param {Array} ast
@@ -37,25 +33,53 @@ export function deadcode(ast: any[]): any[];
  * @returns {Array}
  */
 export function localReuse(ast: any[]): any[];
+/** Identity elimination as a standalone pass. */
+export function identity(ast: any): any;
+/** Strength reduction as a standalone pass. */
+export function strength(ast: any): any;
+/**
+ * Simplify branches with constant conditions.
+ * @param {Array} ast
+ * @returns {Array}
+ */
+export function branch(ast: any[]): any[];
+export function propagate(ast: any): any;
 /**
- * Remove identity operations.
+ * Merge alias locals: `(local.set $A (local.tee $B V))` writes the same value into
+ * two slots. When that is the ONLY write either local ever gets, their write
+ * histories are identical — every read of $A (even one sequenced before the def,
+ * which sees the zero default on both) equals the same read of $B. So $A's reads
+ * rename to $B and the alias write drops. Params are excluded ($B would carry a
+ * call-argument value where $A held zero).
  * @param {Array} ast
  * @returns {Array}
  */
-export function identity(ast: any[]): any[];
+export function mergeLocals(ast: any[]): any[];
 /**
- * Strength reduction: replace expensive ops with cheaper equivalents.
+ * Local common-subexpression elimination: identical pure subtrees repeated within a
+ * straight-line scope compute once into a fresh local (first site tees, later sites
+ * get). Grouping stops at every invalidation: a statement that writes a local the
+ * expression reads, writes memory (for memory-reading exprs), or calls out (memory/
+ * global-reading exprs). Candidates come only from the unconditional part of each
+ * statement — nested control bodies are separate scopes with their own table.
+ * Fires only when the byte win is provable: (n−1)·bytes(expr) > tee+gets+decl cost.
  * @param {Array} ast
  * @returns {Array}
  */
-export function strength(ast: any[]): any[];
+export function cse(ast: any[]): any[];
 /**
- * Simplify branches with constant conditions.
+ * Macro inlining: a function whose whole body is ONE small expression using each
+ * param exactly once, in declaration order, expands at every call site by
+ * substituting the arguments positionally — no wrapper, no locals, argument
+ * evaluation order preserved verbatim (so impure args stay sound). The husk loses
+ * its callers and treeshake collects it; the expansion feeds fold/offset/cse.
  * @param {Array} ast
  * @returns {Array}
  */
-export function branch(ast: any[]): any[];
-export function propagate(ast: any): any;
+export function inlineMacro(ast: any[], { pin }?: {
+    pin?: any;
+}): any[];
+export function tailmerge(ast: any): any;
 export function inline(ast: any, { simdOnly, pin }?: {
     simdOnly?: boolean;
     pin?: any;
@@ -137,12 +161,8 @@ export const OPTS: any;
  * @returns {Array}
  */
 export function vacuum(ast: any[]): any[];
-/**
- * Apply peephole optimizations.
- * @param {Array} ast
- * @returns {Array}
- */
-export function peephole(ast: any[]): any[];
+/** Peephole rules as a standalone pass. */
+export function peephole(ast: any): any;
 /**
  * Replace `global.get` of an immutable, const-initialised global with the
  * constant — but only when it doesn't grow the module. A `global.get` costs
@@ -158,12 +178,7 @@ export function peephole(ast: any[]): any[];
 export function globals(ast: any[]): any[];
 /** Match (type.load/store (i32.add ptr (type.const N))) and fold offset */
 export function offset(ast: any): any;
-/**
- * Remove br to a block's own label when it is the last instruction.
- * @param {Array} ast
- * @returns {Array}
- */
-export function unbranch(ast: any[]): any[];
+export function unbranch(ast: any): any;
 /**
  * Collapse the `while`-emit idiom into a single loop.
  *
@@ -196,14 +211,7 @@ export function loopify(ast: any[]): any[];
  * @returns {Array}
  */
 export function stripmut(ast: any[]): any[];
-/**
- * Simplify (if cond (then (br $label))) → (br_if $label cond)
- * and (if cond (then) (else (br $label))) → (br_if $label (i32.eqz cond))
- * Only when the br is the sole instruction in the arm.
- * @param {Array} ast
- * @returns {Array}
- */
-export function brif(ast: any[]): any[];
+export function brif(ast: any): any;
 /**
  * Fold identical trailing code out of if/else arms.
  * (if cond (then A X) (else B X)) → (if cond (then A) (else B)) X

package/types/src/optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AAsxHA,gEA6FC;AA/zHD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAOlB;AA8CD;;;;;GAKG;AACH,6CAgJC;AAwUD;;;;GAIG;AACH,wCAkDC;AA0YD;;;;GAIG;AACH,4CAqBC;AA+CD;;;;;GAKG;AACH,8CAmDC;AAndD;;;;GAIG;AACH,4CASC;AAID;;;;GAIG;AACH,4CAwDC;AAID;;;;GAIG;AACH,0CA6CC;AAuyBD,yCAqCC;AAmND;;;QAqEC;AAuQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;UA+IC;AA/aD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAwOC;AA0gDD;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AArlC9D;;;;;GAKG;AACH,0CA8DC;AA+ED;;;;GAIG;AACH,4CAQC;AAiCD;;;;;;;;;;;GAWG;AACH,2CAyDC;AAID,2EAA2E;AAC3E,sCAgEC;AAID;;;;GAIG;AACH,4CAyCC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CAiDC;AAID;;;;;GAKG;AACH,4CAqBC;AAID;;;;;;GAMG;AACH,wCAmBC;AAID;;;;;GAKG;AACH,4CAiDC;AAoCD;;;;;GAKG;AACH,0CA8DC;AAwWD,uCAyBC;AA7XD;;;;;GAKG;AACH,8CAyEC;AA2ID;;;;GAIG;AACH,4CAyDC;AAqBD;;;;;GAKG;AACH,iDAgBC;AA/sCD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDAyFC"}
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/optimize.js"],"names":[],"mappings":"AA4lMA,gEA+MC;AArxMD;;;;GAIG;AACH,4BAHW,GAAG,GACD,MAAM,CAOlB;AAED;;;;GAIG;AACH,wCAFa,MAAM,CAOlB;AA8CD;;;;;GAKG;AACH,6CAmSC;AAgbD,6CAA6C;AAC7C,oCAA6C;AA2iB7C;;;;GAIG;AACH,4CAqBC;AAoCD;;;;;GAKG;AACH,8CAkFC;AAvlBD,iDAAiD;AACjD,wCAAqD;AAgErD,+CAA+C;AAC/C,wCAAqD;AAIrD;;;;GAIG;AACH,0CA0KC;AAotED,yCA8EC;AA7HD;;;;;;;;;GASG;AACH,+CAuBC;AA3tBD;;;;;;;;;;GAUG;AACH,uCAsJC;AAED;;;;;;;;GAQG;AACH;;UA8DC;AAkZD,yCA4DC;AAkWD;;;QAqEC;AAuQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;UA2JC;AA3bD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sCAwOC;AAgjED;;;;;;;;GAQG;AACH,gCAHW,OAAO,GAAC,MAAM,MAAO,OAc/B;AAvBD,qEAAqE;AACrE,uBAA8D;AA1iD9D;;;;;GAKG;AACH,0CAyEC;AA8FD,2CAA2C;AAC3C,wCAAqD;AAwDrD;;;;;;;;;;;GAWG;AACH,2CAiHC;AAID,2EAA2E;AAC3E,sCAgEC;AA0BD,wCA0DC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CAiDC;AAID;;;;;GAKG;AACH,4CAqBC;AA6BD,oCAuCC;AAID;;;;;GAKG;AACH,4CAiDC;AAuCD;;;;;GAKG;AACH,0CAqFC;AA2cD,uCAyBC;AAheD;;;;;GAKG;AACH,8CAyEC;AAiLD;;;;GAIG;AACH,4CAsHC;AAqBD;;;;;GAKG;AACH,iDAgBC;AAtjDD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+CAiFC;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,kDA8JC"}

package/types/src/template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/template.js"],"names":[],"mappings":"AA4HA;;;;;;;;;;GAUG;AACH,8CAPW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GAIH,UAAU,CAgGtB;AAED;;;;;;;GAOG;AACH,2CAJW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GACH,WAAW,CAAC,OAAO,CAO/B"}
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/template.js"],"names":[],"mappings":"AA8IA;;;;;;;;;;GAUG;AACH,8CAPW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GAIH,UAAU,CAgGtB;AAED;;;;;;;GAOG;AACH,2CAJW,MAAM,WAAO,oBAAoB,UACjC,GAAG,EAAE,GACH,WAAW,CAAC,OAAO,CAO/B"}

package/types/src/util.d.ts

@@ -1,13 +1,8 @@
-/**
- * Throws an error with optional source position.
- * Uses err.src for source and err.loc for default position.
- * If pos provided or err.loc set, appends "at line:col".
- *
- * @param {string} text - Error message
- * @param {number} [pos] - Byte offset in source (defaults to err.loc)
- * @throws {Error}
- */
-export const err: (text: string, pos?: number) => never;
+export function err(text: string, pos?: number): never;
+export function setErrLoc(loc: any): void;
+export function setErrSrc(src: any): void;
+export function getErrLoc(): any;
+export function getErrSrc(): any;
 /** Regex to detect invalid underscore placement in numbers */
 export const sepRE: RegExp;
 /** Regex to match valid integer literals (decimal or hex) */

package/types/src/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mBAAoB,MAJT,MAIa,EAAE,MAHf,MAG0B,WAUpC;AAED,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C;AAUzD,4BAHI,GAAG,GACD,GAAG,CAE2D;AASpE,2BALI,GAAG,yBAEH,GAAG,QACH,MAAM,QAKhB;AAgBM,+BANI,GAAG,yBAEH,GAAG,QACH,MAAM,GACJ,GAAG,CAOf"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.js"],"names":[],"mappings":"AAkBO,0BAJI,MAAM,QACN,MAAM,SAahB;AAEM,0CAA2C;AAC3C,0CAA2C;AAC3C,iCAA8B;AAC9B,iCAA8B;AAErC,8DAA8D;AAC9D,2BAAiD;AAEjD,6DAA6D;AAC7D,2BAAiD;AAe1C,uBAHI,MAAM,GACJ,MAAM,EAAE,CA8BpB;AAUM,4BAHI,MAAM,GACJ,MAAM,CAE6C;AAUzD,4BAHI,GAAG,GACD,GAAG,CAE2D;AASpE,2BALI,GAAG,yBAEH,GAAG,QACH,MAAM,QAWhB;AAgBM,+BANI,GAAG,yBAEH,GAAG,QACH,MAAM,GACJ,GAAG,CAWf"}

package/types/watr.d.ts

@@ -17,18 +17,17 @@ export function watr(source: string | TemplateStringsArray, ...values: any[]): W
  *
  * @param {string|TemplateStringsArray} source - WAT source or template strings
  * @param {...any} values - Interpolation values (for template literal).
- *   Last value can be an options object: { polyfill, optimize }.
  * @returns {Uint8Array} WebAssembly binary
  *
  * @example
  * compile('(func (export "f") (result i32) (i32.const 42))')
  * compile`(func (export "f") (result f64) (f64.const ${Math.PI}))`
- * compile(src, { polyfill: true, optimize: true })
+ * // transforms ship as separate entries — compose them:
+ * // import optimize from 'watr/optimize'
+ * // compile(optimize(src))
  */
 export function compile(source: string | TemplateStringsArray, ...values: any[]): Uint8Array;
 import parse from './src/parse.js';
 import print from './src/print.js';
-import _polyfill from './src/polyfill.js';
-import _optimize from './src/optimize.js';
-export { parse, print, _polyfill as polyfill, _optimize as optimize };
+export { parse, print };
 //# sourceMappingURL=watr.d.ts.map

package/types/watr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AAiCA;;;;;;;;;;;GAWG;AACH,6BATW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAS/B;AA/BD;;;;;;;;;;;;GAYG;AACH,gCAVW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GAEJ,UAAU,CAStB;kBAxBiB,gBAAgB;kBAChB,gBAAgB;sBACZ,mBAAmB;sBACnB,mBAAmB"}
+{"version":3,"file":"watr.d.ts","sourceRoot":"","sources":["../watr.js"],"names":[],"mappings":";AAoCA;;;;;;;;;;;GAWG;AACH,6BATW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,WAAW,CAAC,OAAO,CAS/B;AAhCD;;;;;;;;;;;;;GAaG;AACH,gCAXW,MAAM,GAAC,oBAAoB,aACxB,GAAG,EAAA,GACJ,UAAU,CAWtB;kBA3BiB,gBAAgB;kBAChB,gBAAgB"}

package/watr.js

@@ -7,25 +7,28 @@
 import _compile from './src/compile.js'
 import parse from './src/parse.js'
 import print from './src/print.js'
-import _polyfill from './src/polyfill.js'
-import _optimize from './src/optimize.js'
 import { compile as _tcompile, watr as _twatr } from './src/template.js'
 
-/** JS-source backend primitives for the tagged-template layer. */
-const backend = { parse, compile: _compile, optimize: _optimize, polyfill: _polyfill }
+/** JS-source backend primitives for the tagged-template layer.
+ *  `polyfill` and `optimize` are intentionally NOT wired here — they're heavy
+ *  (the optimizer alone is ~5× the core encoder) and ship as separate entries,
+ *  `watr/polyfill` and `watr/optimize`, that you compose explicitly:
+ *  `compile(optimize(src))`. This keeps the default bundle minimal. */
+const backend = { parse, compile: _compile }
 
 /**
  * Compile WAT to binary. Supports both string and template literal.
  *
  * @param {string|TemplateStringsArray} source - WAT source or template strings
  * @param {...any} values - Interpolation values (for template literal).
- *   Last value can be an options object: { polyfill, optimize }.
  * @returns {Uint8Array} WebAssembly binary
  *
  * @example
  * compile('(func (export "f") (result i32) (i32.const 42))')
  * compile`(func (export "f") (result f64) (f64.const ${Math.PI}))`
- * compile(src, { polyfill: true, optimize: true })
+ * // transforms ship as separate entries — compose them:
+ * // import optimize from 'watr/optimize'
+ * // compile(optimize(src))
  */
 function compile(source, ...values) {
   return _tcompile(backend, source, values)
@@ -48,4 +51,4 @@ function watr(source, ...values) {
 }
 
 export default watr
-export { watr, compile, parse, print, _polyfill as polyfill, _optimize as optimize }
+export { watr, compile, parse, print }