jz 0.2.0 → 0.2.1

package/README.md

@@ -32,7 +32,7 @@ JZ distills the modern functional core – the "good parts" ([Crockford](https:/
 | Parsing / transforms        | Async / I/O-heavy logic    |
 | WASM utilities              | JavaScript runtime         |
 
-Inspired by [porffor](https://github.com/CanadaHonk/porffor) and [piezo](https://github.com/dy/piezo).
+<!-- Inspired by [porffor](https://github.com/CanadaHonk/porffor) and [piezo](https://github.com/dy/piezo). -->
 <!-- Used internally by: web-audio-api, color-space, audiojs -->
 
 
@@ -66,7 +66,7 @@ Options are passed as `jz(source, opts)` or `compile(source, opts)`. Common ones
 | `jzify: true` | Accept broader JS patterns such as `var`, `function`, `switch`, `arguments`, `==`, and `undefined` by lowering them to the JZ subset. |
 | `modules: { specifier: source }` | Bundle static ES imports into one WASM module. CLI import resolution does this from files automatically. |
 | `imports: { mod: host }` | Wire host namespaces/functions used by `import { fn } from "mod"`; functions may be plain JS functions or `{ fn, returns }` specs. |
-| `memory` | Pass `memory: N` to create owned memory with `N` initial pages, or pass `memory: jz.memory()` / `WebAssembly.Memory` to share memory across modules. `memoryPages` remains as a legacy alias for the page count. |
+| `memory` | Pass `memory: N` to create owned memory with `N` initial pages, or pass `memory: jz.memory()` / `WebAssembly.Memory` to share memory across modules. |
 | `host: 'js' \| 'wasi'` | Select runtime-service lowering. Default `js` uses small `env.*` imports auto-wired by `jz()`; `wasi` emits WASI Preview 1 imports for wasmtime/wasmer/deno. |
 | `optimize` | `false`/`0` disables optimization, `1` keeps cheap size passes, `true`/`2` is the default, `3` enables aggressive experimental passes, object form overrides individual passes. |
 | `strict: true` | Reject dynamic fallbacks such as unknown receiver method calls, `obj[k]`, and `for-in` instead of emitting JS-host dynamic dispatch. |
@@ -495,7 +495,6 @@ cc program.c -o program
 | [poly](bench/poly/poly.js) | 0.27ms<br>1.4kB | 1.62ms<br>1014 B | fails | 0.73ms<br>1.3kB | 0.81ms<br>359 B | 0.57ms | 0.79ms | 0.89ms | 0.63ms | 0.60ms |
 | [callback](bench/callback/callback.js) | 0.03ms<br>1.6kB | 0.69ms<br>828 B | fails | 1.04ms<br>1.9kB | 0.24ms<br>267 B | 0.08ms | 0.23ms | 0.01ms | 0.12ms | 1.78ms |
 | [json](bench/json/json.js) | 0.24ms<br>11.0kB | 0.37ms<br>1.2kB | fails | — | — | 0.03ms | 1.05ms | <0.01ms | 0.03ms | 1.21ms |
-| [json-dynamic](bench/json-dynamic/json-dynamic.js) | 0.24ms<br>11.3kB | 0.39ms<br>1.2kB | — | — | — | — | — | — | — | — |
 | [watr](bench/watr/watr.js) | 1.04ms<br>169.8kB | 1.05ms<br>2.6kB | fails | — | — | — | — | — | — | — |
 
 _Numbers from `node bench/bench.mjs` on Apple Silicon. Porffor cells were refreshed with `porf` 0.61.13; `fails` means the latest Porffor compiler/runtime did not complete that benchmark._

package/index.js

@@ -163,8 +163,6 @@ jz.memory = enhanceMemory
  *   receiver method calls) at compile time. Avoids pulling dynamic-dispatch stdlib
  *   into output; large size win for static programs.
  * @param {WebAssembly.Memory|number} [opts.memory] - Shared memory import, or
- *   initial page count for owned memory when a number is passed.
- * @param {number} [opts.memoryPages] - Legacy alias for owned/imported memory
  *   initial page count. Prefer `memory: N` for owned memory.
  * @param {boolean} [opts.alloc=true] - Export raw allocator helpers
  *   (`_alloc`, `_clear`) for JS memory wrapping. Set false for standalone host-run
@@ -194,7 +192,6 @@ jz.compile = (code, opts = {}) => {
 
   if (typeof opts.memory === 'number') ctx.memory.pages = opts.memory
   else if (opts.memory) ctx.memory.shared = true
-  if (opts.memoryPages) ctx.memory.pages = opts.memoryPages
   if (opts.modules) ctx.module.importSources = opts.modules
   if (opts.imports) {
     ctx.module.hostImports = opts.imports

package/module/date.js

@@ -1,9 +1,10 @@
 /**
  * Date module — deterministic UTC algorithms first.
  *
- * Current scope: Date.UTC(...), Date object construction, UTC getters/setters,
- * toISOString, toUTCString. Local-time methods, parsing, and locale-sensitive
- * formatting are deliberately staged later.
+ * Current scope: Date.UTC(...), Date object construction, timestamp/string
+ * construction, UTC getters/setters, UTC-backed local getters, toISOString,
+ * toUTCString. Timezone-aware local-time methods and locale-sensitive formatting
+ * are deliberately staged later.
  *
  * @module date
  */
@@ -23,6 +24,9 @@ export default (ctx) => {
     __date_make_time: [],
     __date_time_clip: [],
     __date_utc: ['__date_make_day', '__date_make_time', '__date_time_clip'],
+    __date_digit: ['__char_at'],
+    __date_parse_iso_date: ['__str_byteLen', '__char_at', '__date_digit', '__date_make_day', '__date_time_clip'],
+    __date_from_value: ['__ptr_type', '__to_num', '__date_parse_iso_date'],
     __date_day: [],
     __date_time_within_day: ['__date_day'],
     __date_weekday: ['__date_day'],
@@ -149,6 +153,66 @@ export default (ctx) => {
           (f64.const ${MS_PER_DAY}))
         (call $__date_make_time (local.get $hours) (local.get $minutes) (local.get $seconds) (local.get $ms)))))`
 
+  ctx.core.stdlib['__date_digit'] = `(func $__date_digit (param $str i64) (param $i i32) (result i32)
+    (local $c i32)
+    (local.set $c (call $__char_at (local.get $str) (local.get $i)))
+    (if (result i32)
+      (i32.and (i32.ge_s (local.get $c) (i32.const 48)) (i32.le_s (local.get $c) (i32.const 57)))
+      (then (i32.sub (local.get $c) (i32.const 48)))
+      (else (i32.const -1))))`
+
+  ctx.core.stdlib['__date_parse_iso_date'] = `(func $__date_parse_iso_date (param $str i64) (result f64)
+    (local $y f64) (local $m f64) (local $d f64)
+    (local $d0 i32) (local $d1 i32) (local $d2 i32) (local $d3 i32)
+    (if (i32.lt_s (call $__str_byteLen (local.get $str)) (i32.const 10))
+      (then (return (f64.const nan))))
+    (if (i32.ne (call $__char_at (local.get $str) (i32.const 4)) (i32.const 45))
+      (then (return (f64.const nan))))
+    (if (i32.ne (call $__char_at (local.get $str) (i32.const 7)) (i32.const 45))
+      (then (return (f64.const nan))))
+
+    (local.set $d0 (call $__date_digit (local.get $str) (i32.const 0)))
+    (local.set $d1 (call $__date_digit (local.get $str) (i32.const 1)))
+    (local.set $d2 (call $__date_digit (local.get $str) (i32.const 2)))
+    (local.set $d3 (call $__date_digit (local.get $str) (i32.const 3)))
+    (if (i32.or (i32.or (i32.lt_s (local.get $d0) (i32.const 0)) (i32.lt_s (local.get $d1) (i32.const 0)))
+        (i32.or (i32.lt_s (local.get $d2) (i32.const 0)) (i32.lt_s (local.get $d3) (i32.const 0))))
+      (then (return (f64.const nan))))
+    (local.set $y (f64.convert_i32_s
+      (i32.add
+        (i32.add (i32.mul (local.get $d0) (i32.const 1000)) (i32.mul (local.get $d1) (i32.const 100)))
+        (i32.add (i32.mul (local.get $d2) (i32.const 10)) (local.get $d3)))))
+
+    (local.set $d0 (call $__date_digit (local.get $str) (i32.const 5)))
+    (local.set $d1 (call $__date_digit (local.get $str) (i32.const 6)))
+    (if (i32.or (i32.lt_s (local.get $d0) (i32.const 0)) (i32.lt_s (local.get $d1) (i32.const 0)))
+      (then (return (f64.const nan))))
+    (local.set $m (f64.convert_i32_s (i32.add (i32.mul (local.get $d0) (i32.const 10)) (local.get $d1))))
+    (if (i32.or (f64.lt (local.get $m) (f64.const 1)) (f64.gt (local.get $m) (f64.const 12)))
+      (then (return (f64.const nan))))
+
+    (local.set $d0 (call $__date_digit (local.get $str) (i32.const 8)))
+    (local.set $d1 (call $__date_digit (local.get $str) (i32.const 9)))
+    (if (i32.or (i32.lt_s (local.get $d0) (i32.const 0)) (i32.lt_s (local.get $d1) (i32.const 0)))
+      (then (return (f64.const nan))))
+    (local.set $d (f64.convert_i32_s (i32.add (i32.mul (local.get $d0) (i32.const 10)) (local.get $d1))))
+    (if (i32.or (f64.lt (local.get $d) (f64.const 1)) (f64.gt (local.get $d) (f64.const 31)))
+      (then (return (f64.const nan))))
+
+    (call $__date_time_clip
+      (f64.mul
+        (call $__date_make_day (local.get $y) (f64.sub (local.get $m) (f64.const 1)) (local.get $d))
+        (f64.const ${MS_PER_DAY}))))`
+
+  ctx.core.stdlib['__date_from_value'] = `(func $__date_from_value (param $v i64) (result f64)
+    (local $f f64)
+    (local.set $f (f64.reinterpret_i64 (local.get $v)))
+    (if (f64.eq (local.get $f) (local.get $f))
+      (then (return (call $__date_time_clip (local.get $f)))))
+    (if (i32.eq (call $__ptr_type (local.get $v)) (i32.const ${PTR.STRING}))
+      (then (return (call $__date_parse_iso_date (local.get $v)))))
+    (call $__date_time_clip (call $__to_num (local.get $v))))`
+
   // ── Time decomposition (ECMA-262 §21.4.1) ────────────────────────────────
 
   ctx.core.stdlib['__date_day'] = `(func $__date_day (param $t f64) (result f64)
@@ -513,13 +577,26 @@ export default (ctx) => {
   // Represented as PTR.OBJECT with a single f64 slot at offset 0 (the time value).
   // No schemaId (aux=0); dynamic property access falls through to undefined.
 
-  ctx.core.emit['new.Date'] = (ms) => {
+  ctx.core.emit['new.Date'] = (ms, month, date, hours, minutes, seconds, millis) => {
     let timeVal
     if (ms === undefined || ms === null) {
-      timeVal = typed(['f64.const', NaN], 'f64')
+      const now = ctx.core.emit['Date.now']
+      if (!now) throw new Error('Date constructor requires Date.now support')
+      timeVal = now()
+    } else if (!missingArg(month)) {
+      inc('__date_utc')
+      timeVal = typed(['call', '$__date_utc',
+        asF64(dateArg(ms, NaN, true)),
+        asF64(dateArg(month, 0)),
+        asF64(dateArg(date, 1)),
+        asF64(dateArg(hours, 0)),
+        asF64(dateArg(minutes, 0)),
+        asF64(dateArg(seconds, 0)),
+        asF64(dateArg(millis, 0)),
+      ], 'f64')
     } else {
-      inc('__date_time_clip')
-      timeVal = typed(['call', '$__date_time_clip', toNumF64(ms, emit(ms))], 'f64')
+      inc('__date_from_value')
+      timeVal = typed(['call', '$__date_from_value', ['i64.reinterpret_f64', asF64(emit(ms))]], 'f64')
     }
     const out = allocPtr({ type: PTR.OBJECT, len: 1, cap: 1, stride: 8, tag: 'date' })
     return typed(['block', ['result', 'f64'],
@@ -585,6 +662,21 @@ export default (ctx) => {
   ctx.core.emit['.getUTCMilliseconds'] = dateGetter('__date_ms_from_time')
   ctx.core.emit[`.${VAL.DATE}:getUTCMilliseconds`] = dateGetter('__date_ms_from_time')
 
+  // UTC-backed local getters. Full timezone-aware local time is intentionally
+  // staged separately; these aliases make deterministic/server Date use cases
+  // available without a timezone database.
+  ctx.core.emit['.getFullYear'] = ctx.core.emit['.getUTCFullYear']
+  ctx.core.emit[`.${VAL.DATE}:getFullYear`] = ctx.core.emit[`.${VAL.DATE}:getUTCFullYear`]
+
+  ctx.core.emit['.getMonth'] = ctx.core.emit['.getUTCMonth']
+  ctx.core.emit[`.${VAL.DATE}:getMonth`] = ctx.core.emit[`.${VAL.DATE}:getUTCMonth`]
+
+  ctx.core.emit['.getDate'] = ctx.core.emit['.getUTCDate']
+  ctx.core.emit[`.${VAL.DATE}:getDate`] = ctx.core.emit[`.${VAL.DATE}:getUTCDate`]
+
+  ctx.core.emit['.getDay'] = ctx.core.emit['.getUTCDay']
+  ctx.core.emit[`.${VAL.DATE}:getDay`] = ctx.core.emit[`.${VAL.DATE}:getUTCDay`]
+
   // ── UTC setter emit handlers ──────────────────────────────────────────────
 
   const emitDatePtr = (dateExpr) =>

package/module/string.js

@@ -959,6 +959,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/package.json

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

package/src/analyze.js

@@ -359,7 +359,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 +1263,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',
 ])

package/src/autoload.js

@@ -14,7 +14,7 @@ export const PROP_MODULES = Object.assign(Object.create(null), {
   every: ['core', 'array'], some: ['core', 'array'], flat: ['core', 'array'], flatMap: ['core', 'array'],
   join: ['core', 'array'], copyWithin: ['core', 'array'], at: ['core', 'array'],
   charAt: ['core', 'string'], charCodeAt: ['core', 'string'], codePointAt: ['core', 'string'],
-  toUpperCase: ['core', 'string'], toLowerCase: ['core', 'string'], trim: ['core', 'string'],
+  toUpperCase: ['core', 'string'], toLowerCase: ['core', 'string'], toLocaleLowerCase: ['core', 'string'], trim: ['core', 'string'],
   trimStart: ['core', 'string'], trimEnd: ['core', 'string'],
   split: ['core', 'string'], replace: ['core', 'string'], replaceAll: ['core', 'string'],
   repeat: ['core', 'string'], startsWith: ['core', 'string'], endsWith: ['core', 'string'],
@@ -168,7 +168,7 @@ export const includeForRuntimeCtor = name => {
   const kind = runtimeCtorKind(name)
   if (kind === 'typedarray') includeMods('core', 'typedarray')
   else if (kind === 'collection') includeMods('core', 'collection')
-  else if (kind === 'date') includeMods('core', 'date')
+  else if (kind === 'date') includeMods('core', 'console', 'date')
   return kind
 }
 

package/src/emit.js

@@ -867,6 +867,20 @@ const cmpOp = (i32op, f64op, fn) => (a, b) => {
     inc('__str_cmp')
     return typed([`i32.${i32op}`, ['call', '$__str_cmp', asI64(va), asI64(vb)], ['i32.const', 0]], 'i32')
   }
+  if (vta === VAL.DATE || vtb === VAL.DATE) {
+    const dateNum = (node, v, vt) => {
+      if (vt !== VAL.DATE) return toNumF64(node, v)
+      const ptr = v.ptrKind === VAL.DATE
+        ? v
+        : ['i32.wrap_i64', ['i64.reinterpret_f64', asF64(v)]]
+      return typed(['f64.load', ptr], 'f64')
+    }
+    return typed([`f64.${f64op}`, dateNum(a, va, vta), dateNum(b, vb, vtb)], 'i32')
+  }
+  if (vtb === VAL.NUMBER && needsRelationalToNumber(a, vta))
+    return typed([`f64.${f64op}`, toNumF64(a, va), asF64(vb)], 'i32')
+  if (vta === VAL.NUMBER && needsRelationalToNumber(b, vtb))
+    return typed([`f64.${f64op}`, asF64(va), toNumF64(b, vb)], 'i32')
   const ai = intConstValue(a), bi = intConstValue(b)
   if (va.type === 'i32' && bi != null) return typed([`i32.${i32op}`, va, ['i32.const', bi]], 'i32')
   if (vb.type === 'i32' && ai != null) return typed([`i32.${i32op}`, ['i32.const', ai], vb], 'i32')
@@ -874,6 +888,16 @@ const cmpOp = (i32op, f64op, fn) => (a, b) => {
     ? typed([`i32.${i32op}`, va, vb], 'i32') : typed([`f64.${f64op}`, asF64(va), asF64(vb)], 'i32')
 }
 
+function needsRelationalToNumber(expr, vt) {
+  if (vt === VAL.STRING) return true
+  if (vt != null) return false
+  return mayReadBoxedValue(expr)
+}
+
+function mayReadBoxedValue(expr) {
+  return Array.isArray(expr) && (expr[0] === '.' || expr[0] === '[]' || expr[0] === '?.' || expr[0] === '?.[]')
+}
+
 function intConstValue(expr) {
   if (typeof expr === 'number' && Number.isInteger(expr)) return expr
   if (Array.isArray(expr) && expr[0] == null && typeof expr[1] === 'number' && Number.isInteger(expr[1])) return expr[1]

package/src/ir.js

@@ -347,6 +347,12 @@ export function toNumF64(node, v) {
   if (v.type === 'i32' || isLit(v)) return asF64(v)
   const vt = keyValType(node)
   if (vt === VAL.NUMBER || vt === VAL.BIGINT) return asF64(v)
+  if (vt === VAL.DATE) {
+    const ptr = v.ptrKind === VAL.DATE
+      ? v
+      : ['i32.wrap_i64', ['i64.reinterpret_f64', asF64(v)]]
+    return typed(['f64.load', ptr], 'f64')
+  }
   // intCertain locals: every reachable def is integer-valued, so the binding
   // never carries a NaN-boxed pointer — skip the __to_num wrapper.
   if (typeof node === 'string' && repOf(node)?.intCertain === true) return asF64(v)

package/src/plan.js

@@ -329,6 +329,24 @@ const collectScalarTypedArrayWrites = (node, name, len, out = new Set()) => {
   return out
 }
 
+const hasScalarTypedArrayRead = (node, name) => {
+  if (!Array.isArray(node)) return false
+  const op = node[0]
+  const isTarget = target => Array.isArray(target) && target[0] === '[]' && target[1] === name
+  if ((op === '++' || op === '--') && isTarget(node[1])) return true
+  if (ASSIGN_TARGET_OPS.has(op)) {
+    if (isTarget(node[1])) {
+      if (op !== '=') return true
+      for (let i = 2; i < node.length; i++) if (hasScalarTypedArrayRead(node[i], name)) return true
+      return false
+    }
+  }
+  if (op === '[]' && node[1] === name) return true
+  if (op === '=>') return false
+  for (let i = 1; i < node.length; i++) if (hasScalarTypedArrayRead(node[i], name)) return true
+  return false
+}
+
 const scalarizeTypedArrayLiteralSeq = (seq) => {
   if (!Array.isArray(seq) || seq[0] !== ';') return { node: seq, changed: false }
   let changed = false
@@ -553,6 +571,7 @@ const scalarTypedParamCandidates = (func, sites, fixedByFunc) => {
 
 const scalarizeTypedArrayParams = (func, paramCands) => {
   for (const [name, c] of [...paramCands]) if (!safeScalarTypedArrayUse(func.body, name, c.len)) paramCands.delete(name)
+  for (const [name] of [...paramCands]) if (!hasScalarTypedArrayRead(func.body, name)) paramCands.delete(name)
   if (!paramCands.size) return { body: func.body, changed: false }
   const arrays = new Map()
   for (const [name, c] of paramCands) {
@@ -920,6 +939,7 @@ const inlineHotInternalCalls = (programFacts, ast) => {
   if (cfg && cfg.sourceInline === false) return false
 
   const fixedByFunc = new Map(ctx.func.list.map(func => [func, fixedTypedArraysInBody(func.body)]))
+  const typedByFunc = new Map(ctx.func.list.map(func => [func, analyzeBody(func.body).typedElems]))
   const sitesByCallee = new Map()
   for (const cs of programFacts.callSites) {
     const list = sitesByCallee.get(cs.callee)
@@ -942,8 +962,22 @@ const inlineHotInternalCalls = (programFacts, ast) => {
       return typeof arg === 'string' && fixedByFunc.get(site.callerFunc)?.has(arg)
     }))
   }
-  const hasFixedTypedArrayHotSites = (func, sites) =>
-    hasFixedTypedArraySites(func, sites) && sites.some(site => site.callerFunc?.body && containsNode(site.callerFunc.body, site.node))
+  const hasFullyFixedTypedArraySites = (func, sites) => {
+    const params = func.sig?.params || []
+    if (!sites?.length) return false
+    let sawTypedArg = false
+    for (const site of sites) {
+      const typed = typedByFunc.get(site.callerFunc)
+      const fixed = fixedByFunc.get(site.callerFunc)
+      for (let i = 0; i < params.length; i++) {
+        const arg = site.argList[i]
+        if (typeof arg !== 'string' || !typed?.has(arg)) continue
+        sawTypedArg = true
+        if (!fixed?.has(arg)) return false
+      }
+    }
+    return sawTypedArg
+  }
 
   const candidates = new Map()
   for (const func of ctx.func.list) {
@@ -951,6 +985,7 @@ const inlineHotInternalCalls = (programFacts, ast) => {
     if (func.defaults && Object.keys(func.defaults).length) continue
     const sites = sitesByCallee.get(func.name)
     const fixedTypedArraySite = hasFixedTypedArraySites(func, sites)
+    const fullyFixedTypedArraySite = hasFullyFixedTypedArraySites(func, sites)
     if (!sites || sites.length < 1 || (!fixedTypedArraySite && sites.length > 2) || sites.length > 8) continue
     const stmts = blockStmts(func.body)
     // Expression-bodied arrow funcs (`(c) => expr`) have no block — body IS the
@@ -980,7 +1015,7 @@ const inlineHotInternalCalls = (programFacts, ast) => {
     // loop carries most of the cost. Inlining them into a host that V8 can't
     // tier up (e.g. a once-called wrapper) freezes the kernel in baseline.
     // Keep them as standalone functions so V8 wasm tier-up can warm them.
-    if (loopDepth(func.body, 0) >= 2 && !fixedTypedArraySite) continue
+    if (loopDepth(func.body, 0) >= 2 && !fullyFixedTypedArraySite) continue
     // Factory functions that allocate pointers (`new TypedArray`, `new Array`,
     // object/array literals returned) break downstream pointer-ABI specialization
     // when inlined: narrow.js can't trace the post-inline alias chain back to a

package/src/prepare.js

@@ -1475,6 +1475,7 @@ const handlers = {
   'new'(ctor, ...args) {
     let name = ctor, ctorArgs = args
     if (Array.isArray(ctor) && ctor[0] === '()') { name = ctor[1]; ctorArgs = ctor.slice(2) }
+    if (name === 'Date' && ctorArgs.length === 1 && ctorArgs[0] == null) ctorArgs = []
     // Flatten comma-grouped args: [',', a, b, c] → [a, b, c]
     if (ctorArgs.length === 1 && Array.isArray(ctorArgs[0]) && ctorArgs[0][0] === ',')
       ctorArgs = ctorArgs[0].slice(1)