jz 0.3.0 → 0.3.1

package/README.md

@@ -82,7 +82,16 @@ Options are passed as `jz(source, opts)` or `compile(source, opts)`. Common ones
 
 ```sh
 # Compile
-jz program.js # → program.wasm
+jz program.js              # → program.wasm
+jz program.js --wat        # → program.wat
+jz program.js -o out.wasm  # custom output (- for stdout)
+
+# Optimization level: -O0 off, -O1 size-only, -O2 default, -O3 aggressive
+# aliases: -Os/--optimize size, -Ob/balanced, -Of/speed
+jz program.js -O3
+
+# Runtime-service lowering: js (default) or wasi
+jz program.js --host wasi
 
 # Evaluate
 jz -e "1 + 2" # 3
@@ -91,6 +100,8 @@ jz -e "1 + 2" # 3
 jz --help
 ```
 
+Other flags: `--strict` (no auto-`jzify`, reject dynamic fallbacks), `--jzify` (transform JS → jz, no compile), `--no-alloc` (omit `_alloc`/`_clear`), `--names` (emit wasm `name` section), `--resolve` (Node.js bare-specifier resolution), `--imports <file.json>` (host import specs).
+
 ## Language
 
 JZ is a strict functional JS subset. Built-in `jzify` transform extends support to legacy patterns.

package/cli.js

@@ -32,13 +32,21 @@ Examples:
   jz program.js --wat              # → program.wat
   jz program.js -o out.wasm        # custom output name
   jz program.js -o -               # write to stdout
+  jz program.js -O3                # aggressive optimization
+  jz program.js -Os                # optimize for size
+  jz program.js --host wasi        # emit WASI Preview 1 imports
   jz --strict program.js           # strict mode
   jz --jzify lib.js                # → lib.jz
   jz -e "1 + 2"
 
 Options:
   --output, -o <file>       Output file (.wat, .wasm, or - for stdout)
-  --strict                  Strict jz mode (no auto-transform)
+  -O<n>, --optimize <n>     Optimization level: 0 off, 1 size-only, 2 default,
+                            3 aggressive. Aliases: -Os/size, -Ob/balanced, -Of/speed.
+  --host <js|wasi>          Runtime-service lowering (default js)
+  --no-alloc                Omit _alloc/_clear allocator exports (standalone wasm)
+  --names                   Emit wasm name section for profilers/debuggers
+  --strict                  Strict jz mode (no auto-transform), reject dynamic fallbacks
   --jzify                   Transform JS to jz (no compilation)
   --eval, -e                Evaluate expression or file
   --wat                     Output WAT text instead of binary
@@ -109,16 +117,31 @@ async function handleJzify(args) {
   }
 }
 
+// -O<n>/-Os/-Ob/-Of and --optimize <val> → value accepted by compile()'s `optimize` opt
+const OPT_ALIAS = { s: 'size', b: 'balanced', f: 'speed' }
+function parseOptimize(v) {
+  if (v == null) return undefined
+  if (/^\d+$/.test(v)) return +v
+  return OPT_ALIAS[v] ?? v
+}
+
 async function handleCompile(args) {
   let inputFile = null, outputFile = null, wat = false, strict = false, resolveNode = false, importsFile = null
+  let optimize, host, alloc = true, names = false
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--output' || args[i] === '-o') outputFile = args[++i]
-    else if (args[i] === '--wat') wat = true
-    else if (args[i] === '--strict') strict = true
-    else if (args[i] === '--resolve') resolveNode = true
-    else if (args[i] === '--imports') importsFile = args[++i]
-    else if (!inputFile) inputFile = args[i]
+    const a = args[i]
+    if (a === '--output' || a === '-o') outputFile = args[++i]
+    else if (a === '--wat') wat = true
+    else if (a === '--strict') strict = true
+    else if (a === '--resolve') resolveNode = true
+    else if (a === '--imports') importsFile = args[++i]
+    else if (a === '--optimize' || a === '-O') optimize = parseOptimize(args[++i])
+    else if (/^-O.+/.test(a)) optimize = parseOptimize(a.slice(2))
+    else if (a === '--host') host = args[++i]
+    else if (a === '--no-alloc') alloc = false
+    else if (a === '--names') names = true
+    else if (!inputFile) inputFile = a
   }
 
   if (!inputFile) throw new Error('No input file specified')
@@ -178,7 +201,12 @@ async function handleCompile(args) {
   const opts = {
     wat,
     jzify: !strict && !inputFile.endsWith('.jz'),
+    strict,
     importMetaUrl: pathToFileURL(resolve(inputFile)).href,
+    ...(optimize !== undefined && { optimize }),
+    ...(host && { host }),
+    ...(alloc === false && { alloc: false }),
+    ...(names && { profileNames: true }),
     ...(Object.keys(modules).length && { modules }),
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jz",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Modern functional JS compiling to WASM",
   "main": "index.js",
   "type": "module",

package/src/jzify.js

@@ -210,13 +210,35 @@ function transformScope(node) {
     // Hoist functions AFTER imports (imports must be processed first for scope resolution)
     const imports = rest.filter(s => Array.isArray(s) && s[0] === 'import')
     const nonImports = rest.filter(s => !(Array.isArray(s) && s[0] === 'import'))
-    const all = [...imports, ...hoisted, ...nonImports]
+    const all = dedupeRedecls([...imports, ...hoisted, ...nonImports])
     return all.length === 0 ? null : all.length === 1 ? all[0] : [';', ...all]
   }
 
   return transform(node)
 }
 
+/**
+ * Drop redundant re-declarations of the same name within one scope's statement
+ * list. JS allows `function f(){} var f;`, `var x; var x;`, `var x = 1; var x;` —
+ * jzify lowers `function`→`const` and `var`→`let`, which would otherwise emit two
+ * bindings for one slot (and a typed-slot clash in codegen). The first declaration
+ * wins; a later redeclaration keeps only its initializer, as a plain assignment.
+ */
+function dedupeRedecls(stmts) {
+  const nameOf = s => Array.isArray(s) && (s[0] === 'let' || s[0] === 'const' || s[0] === 'var')
+    ? (typeof s[1] === 'string' ? s[1]
+      : Array.isArray(s[1]) && s[1][0] === '=' && typeof s[1][1] === 'string' ? s[1][1] : null)
+    : null
+  const seen = new Set(), out = []
+  for (const s of stmts) {
+    const n = nameOf(s)
+    if (n == null) { out.push(s); continue }
+    if (seen.has(n)) { if (Array.isArray(s[1]) && s[1][0] === '=') out.push(['=', s[1][1], s[1][2]]); continue }
+    seen.add(n); out.push(s)
+  }
+  return out
+}
+
 /** Wrap function body for arrow conversion */
 function wrapArrowBody(body) {
   const t = transformScope(body)
@@ -247,6 +269,19 @@ function usesArguments(node) {
   return false
 }
 
+// `arguments` is the implicit object only if the function body doesn't declare a
+// local of that name. Scan the body's own statement list (not nested scopes) for
+// `var/let/const arguments` — a regular `function` with `var arguments;` just has
+// an ordinary local, no arguments object.
+function bindsArguments(body) {
+  const isArgDecl = s => Array.isArray(s) && (s[0] === 'var' || s[0] === 'let' || s[0] === 'const') &&
+    s.slice(1).some(d => d === 'arguments' || (Array.isArray(d) && d[0] === '=' && d[1] === 'arguments'))
+  let n = body
+  if (Array.isArray(n) && n[0] === '{}') n = n[1]
+  if (Array.isArray(n) && n[0] === ';') return n.slice(1).some(isArgDecl)
+  return isArgDecl(n)
+}
+
 function renameArguments(node, to) {
   if (node === 'arguments') return to
   if (!Array.isArray(node)) return node
@@ -278,8 +313,13 @@ function paramList(params) {
 const isDestructurePat = p => Array.isArray(p) && (p[0] === '[]' || p[0] === '{}' || (p[0] === '=' && isDestructurePat(p[1])))
 
 function lowerArguments(params, body) {
+  // A function body that declares its own `arguments` local: it's an ordinary
+  // variable, not the implicit object \u2014 rename it out of jz's reserved set,
+  // no rest param synthesized.
+  if (bindsArguments(body)) body = renameArguments(body, `\uE001arg${argsIdx++}`)
   const paramsNeedLowering = paramList(params).some(isDestructurePat)
-  if (!paramsNeedLowering && !usesArguments(params) && !usesArguments(body)) return [params, body]
+  const usesArgsObj = usesArguments(params) || usesArguments(body)
+  if (!paramsNeedLowering && !usesArgsObj) return [params, body]
   const name = `\uE001arg${argsIdx++}`
   const decls = []
   for (const [idx, param] of paramList(params).entries()) {
@@ -293,7 +333,7 @@ function lowerArguments(params, body) {
     }
     decls.push(['=', param, ['[]', name, [null, idx]]])
   }
-  const renamed = renameArguments(body, name)
+  const renamed = usesArgsObj ? renameArguments(body, name) : body
   return [['()', ['...', name]], decls.length ? prependParamDecls(['let', ...decls], renamed) : renamed]
 }