jz 0.2.0 → 0.3.0

package/module/object.js

@@ -134,8 +134,9 @@ export default (ctx) => {
   ctx.core.emit[`.${VAL.CLOSURE}:hasOwnProperty`] = ctx.core.emit['.hasOwnProperty']
 
   ctx.core.emit['Object.values'] = (obj) => {
+    if (isHashTyped(obj)) return emitHashValues(obj)
     const schema = resolveSchema(obj)
-    if (!schema) err('Object.values requires object with known schema')
+    if (!schema) return emitRuntimeValues(obj)
     const va = asF64(emit(obj))
     const n = schema.length
     const t = temp('ov'), base = tempI32('vb')
@@ -225,6 +226,10 @@ export default (ctx) => {
     return typed(['block', ['result', 'f64'], ...body], 'f64')
   }
 
+  ctx.core.emit['Object.defineProperty'] = () => {
+    err('Object.defineProperty descriptor semantics are outside jz scope; jzify only folds static bundler export helpers')
+  }
+
   // Object.fromEntries(arr) → creates HASH from array of [key, value] pairs
   ctx.core.emit['Object.fromEntries'] = (arr) => {
     inc('__hash_new', '__hash_set')
@@ -450,6 +455,13 @@ function emitHashKeys(obj) {
     hashKeysFromTemp(t)], 'f64')
 }
 
+function emitHashValues(obj) {
+  const t = temp('hv')
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    hashValuesFromTemp(t)], 'f64')
+}
+
 // Inline body of the HASH walk against an already-bound f64 local. Shared by
 // the static-HASH path and the runtime-dispatch path so both produce the same
 // IR shape from the same source — only difference is whether they enter from
@@ -481,6 +493,33 @@ function hashKeysFromTemp(t) {
     out.ptr]
 }
 
+function hashValuesFromTemp(t) {
+  inc('__ptr_offset', '__cap', '__len')
+  const off = tempI32('hvo'), cap = tempI32('hvc'), n = tempI32('hvn')
+  const i = tempI32('hvi'), o = tempI32('hvj'), slot = tempI32('hvs')
+  const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${n}`], tag: 'hva' })
+  const id = ctx.func.uniq++
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${n}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    out.init,
+    ['local.set', `$${off}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${cap}`, ['call', '$__cap', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['local.set', `$${o}`, ['i32.const', 0]],
+    ['block', `$vbrk${id}`, ['loop', `$vloop${id}`,
+      ['br_if', `$vbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${cap}`]]],
+      ['local.set', `$${slot}`, ['i32.add', ['local.get', `$${off}`],
+        ['i32.mul', ['local.get', `$${i}`], ['i32.const', 24]]]],
+      ['if', ['f64.ne', ['f64.load', ['local.get', `$${slot}`]], ['f64.const', 0]],
+        ['then',
+          elemStore(out.local, o,
+            ['f64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 16]]]),
+          ['local.set', `$${o}`, ['i32.add', ['local.get', `$${o}`], ['i32.const', 1]]]]],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$vloop${id}`]]],
+    out.ptr]
+}
+
 // Type-unknown receiver: bind the value, branch on ptr-type. HASH walks the
 // probe table; OBJECT loads the schema's key array (registered statically at
 // compile time or lazily at runtime by JSON.parse via __jp_schema_get); other
@@ -509,6 +548,26 @@ function emitRuntimeKeys(obj) {
         ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
 }
 
+function emitRuntimeValues(obj) {
+  inc('__ptr_type')
+  if (!ctx.scope.globals.has('__schema_tbl'))
+    ctx.scope.globals.set('__schema_tbl', '(global $__schema_tbl (mut i32) (i32.const 0))')
+  const t = temp('rv'), tt = tempI32('rvt')
+  const empty = allocPtr({ type: PTR.ARRAY, len: 0, tag: 'rve' })
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    ['local.set', `$${tt}`, ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['if', ['result', 'f64'],
+      ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.HASH]],
+      ['then', hashValuesFromTemp(t)],
+      ['else', ['if', ['result', 'f64'],
+        ['i32.and',
+          ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.OBJECT]],
+          ['i32.ne', ['global.get', '$__schema_tbl'], ['i32.const', 0]]],
+        ['then', objectValuesFromTemp(t)],
+        ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
+}
+
 // Schema-keyed Object.keys: copy the schema's keys array (a jz Array of
 // STRINGs registered in __schema_tbl[sid]) into a fresh ARRAY so callers can
 // mutate without aliasing the schema substrate.
@@ -537,3 +596,31 @@ function objectKeysFromTemp(t) {
       ['br', `$kloop${id}`]]],
     mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
 }
+
+function objectValuesFromTemp(t) {
+  inc('__alloc_hdr', '__ptr_offset')
+  const sid = tempI32('ovs'), src = tempI32('ovsrc'), n = tempI32('ovn')
+  const base = tempI32('ovbase'), out = tempI32('ovo'), i = tempI32('ovi')
+  const id = ctx.func.uniq++
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${sid}`, ['i32.wrap_i64', ['i64.and',
+      ['i64.shr_u', ['i64.reinterpret_f64', ['local.get', `$${t}`]], ['i64.const', LAYOUT.AUX_SHIFT]],
+      ['i64.const', LAYOUT.AUX_MASK]]]],
+    ['local.set', `$${src}`, ['i32.wrap_i64', ['i64.and',
+      ['i64.load', ['i32.add', ['global.get', '$__schema_tbl'], ['i32.shl', ['local.get', `$${sid}`], ['i32.const', 3]]]],
+      ['i64.const', LAYOUT.OFFSET_MASK]]]],
+    ['local.set', `$${n}`, ['i32.load', ['i32.sub', ['local.get', `$${src}`], ['i32.const', 8]]]],
+    ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${out}`, ['call', '$__alloc_hdr',
+      ['local.get', `$${n}`], ['local.get', `$${n}`], ['i32.const', 8]]],
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['block', `$ovbrk${id}`, ['loop', `$ovloop${id}`,
+      ['br_if', `$ovbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
+      ['f64.store',
+        ['i32.add', ['local.get', `$${out}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]],
+        ['f64.load',
+          ['i32.add', ['local.get', `$${base}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$ovloop${id}`]]],
+    mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
+}

package/module/string.js

@@ -883,11 +883,12 @@ export default (ctx) => {
 
   ctx.core.emit['.string:slice'] = (str, start, end) => {
     inc('__str_slice')
-    if (end != null) return typed(['call', '$__str_slice', asI64(emit(str)), asI32(emit(start)), asI32(emit(end))], 'f64')
+    const startIR = start == null ? ['i32.const', 0] : asI32(emit(start))
+    if (end != null) return typed(['call', '$__str_slice', asI64(emit(str)), startIR, asI32(emit(end))], 'f64')
     const t = temp('t')
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${t}`, asF64(emit(str))],
-      ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${t}`]], asI32(emit(start)),
+      ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${t}`]], startIR,
         ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]], 'f64')
   }
 
@@ -959,6 +960,11 @@ export default (ctx) => {
     return typed(['call', '$__str_case', asI64(emit(str)), ['i32.const', 65], ['i32.const', 90], ['i32.const', 32]], 'f64')
   }
 
+  // Locale-specific casing needs ICU/CLDR data. jz intentionally has no
+  // runtime, so this follows the existing ASCII-only lowercase helper and
+  // ignores optional locale arguments.
+  ctx.core.emit['.toLocaleLowerCase'] = ctx.core.emit['.toLowerCase']
+
   // Byte-wise variant of String.prototype.localeCompare. Returns -1/0/1 from
   // an unsigned byte-by-byte compare with shorter-string-sorts-first tiebreak.
   // NOT locale-aware: real localeCompare is ICU-driven (CLDR collation, case

package/module/typedarray.js

@@ -587,8 +587,14 @@ export default (ctx) => {
     }
     return `(func $__typed_idx (param $ptr i64) (param $i i32) (result f64)
     (local $off i32) (local $et i32) (local $len i32) (local $aux i32)
-    (local.set $aux (call $__ptr_aux (local.get $ptr)))
     (local.set $off (call $__ptr_offset (local.get $ptr)))
+    ;; ARRAY fast path: __ptr_offset already followed any forwarding — read header len + f64.load, no $__len call.
+    (if (i32.and (i32.eq (call $__ptr_type (local.get $ptr)) (i32.const ${PTR.ARRAY})) (i32.ge_u (local.get $off) (i32.const 8)))
+      (then (return (if (result f64)
+        (i32.and (i32.ge_s (local.get $i) (i32.const 0)) (i32.lt_u (local.get $i) (i32.load (i32.sub (local.get $off) (i32.const 8)))))
+        (then (f64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))
+        (else (f64.const nan:${UNDEF_NAN}))))))
+    (local.set $aux (call $__ptr_aux (local.get $ptr)))
     (if
       (i32.and
         (i32.eq (call $__ptr_type (local.get $ptr)) (i32.const ${PTR.TYPED}))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jz",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Modern functional JS compiling to WASM",
   "main": "index.js",
   "type": "module",
@@ -38,8 +38,8 @@
   "author": "Dmitry Iv",
   "license": "MIT",
   "dependencies": {
-    "subscript": "^10.4.2",
-    "watr": "^4.5.1"
+    "subscript": "^10.4.7",
+    "watr": "^4.5.3"
   },
   "keywords": [
     "javascript",

package/src/analyze.js

@@ -33,11 +33,27 @@ export const STMT_OPS = new Set([';', 'let', 'const', 'return', 'if', 'for', 'fo
   '=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '>>=', '<<=', '>>>=', '||=', '&&=', '??=',
   'throw', 'try', 'catch', 'finally', '++', '--', '()'])
 
+/** Assignment operators — shared across analyze, plan, emit. */
+export const ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '>>=', '<<=', '>>>=', '||=', '&&=', '??='])
+
 /** Distinguish a function block body `{ ... }` from an expression-bodied object literal `({a:1})`.
  *  Both share the `'{}'` op tag; blocks have a non-`':'` first child (object literals start with key:val pairs). */
 export const isBlockBody = (body) =>
   Array.isArray(body) && body[0] === '{}' && body[1]?.[0] !== ':'
 
+/** Extract integer value from AST literal node. Returns null if not a 32-bit integer. */
+export function intLiteralValue(expr) {
+  let v = null
+  if (typeof expr === 'number') v = expr
+  else if (Array.isArray(expr) && expr[0] == null && typeof expr[1] === 'number') v = expr[1]
+  else if (Array.isArray(expr) && expr[0] === 'u-' && typeof expr[1] === 'number') v = -expr[1]
+  else if (typeof expr === 'string') v = repOf(expr)?.intConst ?? ctx.scope.constInts?.get(expr) ?? null
+  return v != null && Number.isInteger(v) && v >= -2147483648 && v <= 2147483647 ? v : null
+}
+
+/** Non-negative integer literal — used for string/typed-array index bounds. */
+export const nonNegIntLiteral = (node) => { const n = intLiteralValue(node); return n != null && n >= 0 ? n : null }
+
 /** Collect all `return X` expressions (X != null) from a function body, skipping nested arrow funcs.
  *  Pushes into `out`. Non-returning paths are silently skipped — pair with `alwaysReturns` if total
  *  coverage matters, or with `hasBareReturn` to detect `return;` (undef result). */
@@ -359,7 +375,7 @@ export function valTypeOf(expr) {
       if (method === 'add' || method === 'delete') return VAL.SET
       if (method === 'set') return VAL.MAP
       // String-returning methods
-      if (['toUpperCase', 'toLowerCase', 'trim', 'trimStart', 'trimEnd',
+      if (['toUpperCase', 'toLowerCase', 'toLocaleLowerCase', 'trim', 'trimStart', 'trimEnd',
         'repeat', 'padStart', 'padEnd', 'replace', 'replaceAll', 'charAt', 'substring'].includes(method)) return VAL.STRING
       if (method === 'split') return VAL.ARRAY
       // slice/concat preserve caller type (string.slice → string, array.slice → array)
@@ -1263,7 +1279,7 @@ export function invalidateLocalsCache(body) {
 // concat) that strings share with arrays/typed-arrays.
 const STRING_ONLY_METHODS = new Set([
   'charCodeAt', 'charAt', 'codePointAt', 'startsWith', 'endsWith',
-  'toUpperCase', 'toLowerCase', 'normalize', 'localeCompare',
+  'toUpperCase', 'toLowerCase', 'toLocaleLowerCase', 'normalize', 'localeCompare',
   'padStart', 'padEnd', 'repeat', 'trimStart', 'trimEnd', 'trim',
   'matchAll', 'match', 'replace', 'replaceAll', 'split',
 ])
@@ -1892,8 +1908,6 @@ export function analyzePtrUnboxable(body, locals, boxed) {
     for (const a of args) collect(a)
   }
 
-  const ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=',
-    '<<=', '>>=', '>>>=', '||=', '&&=', '??='])
   const NULL_CMP_OPS = new Set(['==', '!=', '===', '!=='])
 
   function check(node) {
@@ -2035,8 +2049,6 @@ export function findFreeVars(node, bound, free, scope) {
   for (const a of args) findFreeVars(a, bound, free, scope)
 }
 
-const ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '>>=', '<<=', '>>>=', '||=', '&&=', '??='])
-
 /** Check if any of the given variable names are assigned anywhere in the AST. */
 export function findMutations(node, names, mutated) {
   if (node == null || typeof node !== 'object' || !Array.isArray(node)) return