tjs-lang 0.8.7 → 0.9.1

package/src/lang/wasm-ready.test.ts

@@ -0,0 +1,94 @@
+/**
+ * `globalThis.__tjs_wasm_ready()` — an awaitable signal for WASM instantiation.
+ *
+ * The emitted bootstrap instantiates WASM asynchronously (fire-and-forget), so
+ * synchronous code right after transpile+eval used to hit the JS `fallback{}`
+ * because `globalThis.__tjs_wasm_N` wasn't set yet — with no way to await it
+ * (tosijs-ui feedback UI-#2, "bit us hard"). Now each module pushes its
+ * instantiation promise onto `globalThis.__tjs_wasm_pending` and
+ * `__tjs_wasm_ready()` awaits them all.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { tjs } from './index'
+import { createRuntime } from './runtime'
+
+const g = globalThis as any
+g.__tjs = createRuntime()
+
+// The `__tjs_wasm_*` globals are shared process-wide, so other test files that
+// eval a bootstrap can leave them set. Clear before each test so the
+// "undefined before ready" assertion reflects THIS module's state.
+const clearWasmGlobals = () => {
+  delete g.__tjs_wasm_pending
+  delete g.__tjs_wasm_ready
+  delete g.__tjs_wasm_0
+}
+
+const KERNEL = `function scale(arr: [0.0], len: 0, f: 0.0) {
+  wasm {
+    let s = f32x4_splat(f)
+    for (let i = 0; i < len; i += 4) { let o = i * 4; f32x4_store(arr, o, f32x4_mul(f32x4_load(arr, o), s)) }
+  } fallback { for (let i = 0; i < len; i++) arr[i] *= f }
+  return arr
+}`
+
+beforeEach(clearWasmGlobals)
+afterEach(clearWasmGlobals)
+
+describe('__tjs_wasm_ready', () => {
+  it('resolves once WASM is instantiated (was a fallback race before)', async () => {
+    const { code } = tjs(KERNEL)
+    new Function(code)() // run the bootstrap (fire-and-forget instantiation)
+
+    expect(typeof g.__tjs_wasm_ready).toBe('function')
+    // synchronously right after eval, the module isn't ready yet…
+    expect(g.__tjs_wasm_0).toBeUndefined()
+
+    await g.__tjs_wasm_ready()
+
+    // …now it is — a sync call here takes the WASM path, not the fallback.
+    expect(typeof g.__tjs_wasm_0).toBe('function')
+  })
+
+  it('accumulates pending across modules and awaits all', async () => {
+    new Function(tjs(KERNEL).code)()
+    const firstReady = g.__tjs_wasm_ready
+    new Function(tjs(KERNEL.replace('scale', 'scale2')).code)()
+    // same shared helper + a growing pending list, not overwritten per module
+    expect(g.__tjs_wasm_ready).toBe(firstReady)
+    expect(g.__tjs_wasm_pending.length).toBe(2)
+
+    await g.__tjs_wasm_ready()
+    expect(typeof g.__tjs_wasm_0).toBe('function')
+  })
+})
+
+describe('__tjs_wasm_enabled toggle (force the JS fallback for benchmarking)', () => {
+  // A scalar kernel so input validation passes (a Float32Array isn't
+  // `Array.isArray`, which would early-return before the dispatch). We spy on the
+  // compiled export to detect which path the dispatch takes.
+  const SCALAR = `function pick(x: 0.0) { wasm { return x } fallback { return x } }`
+
+  it('routes to the fallback when disabled, even though WASM is ready', async () => {
+    const pick = new Function(tjs(SCALAR).code + '\nreturn pick')()
+    await g.__tjs_wasm_ready()
+    const real = g.__tjs_wasm_0
+    let wasmCalls = 0
+    g.__tjs_wasm_0 = (...a: any[]) => {
+      wasmCalls++
+      return real(...a)
+    }
+
+    pick(1) // default (enabled) → WASM path
+    expect(wasmCalls).toBe(1)
+
+    g.__tjs_wasm_enabled = false
+    pick(1) // forced fallback → WASM not called
+    expect(wasmCalls).toBe(1)
+
+    g.__tjs_wasm_enabled = true
+    pick(1) // back to WASM
+    expect(wasmCalls).toBe(2)
+    delete g.__tjs_wasm_enabled
+  })
+})

package/src/lang/wasm-simd-ops.test.ts

@@ -0,0 +1,84 @@
+/**
+ * f32x4 min/max, lane comparisons (lt/le/gt/ge/eq/ne → mask), and select
+ * (branch-free blend) — the intrinsics that unlock DATA-DEPENDENT SIMD (clamp,
+ * saturate, SIMD Mandelbrot). Before this, f32x4 was arithmetic-only, so masked
+ * SIMD was impossible (tosijs-ui feedback UI-#6). Executed as real WASM and
+ * checked lane 0 via `extract_lane` (compares are checked through `select`, since
+ * a raw mask isn't a meaningful float).
+ */
+import { describe, it, expect } from 'bun:test'
+import { compileToWasm, instantiateWasm, type WasmBlock } from './wasm'
+
+/** Compile+instantiate a 2-arg f32 kernel `compute(a, b)` from a block body. */
+async function kernel(body: string, captures: string[]) {
+  const block: WasmBlock = { id: 'k', body, captures, start: 0, end: 0 }
+  const result = compileToWasm(block)
+  expect(result.error).toBeFalsy()
+  // SIMD modules import env.memory (for potential v128 load/store); provide one.
+  const memory = new WebAssembly.Memory({ initial: 16 })
+  const instance = await instantiateWasm(result.bytes, memory)
+  return instance.exports.compute as (...a: number[]) => number
+}
+
+describe('f32x4 min / max', () => {
+  it('max', async () => {
+    const f = await kernel(
+      'return f32x4_extract_lane(f32x4_max(f32x4_splat(a), f32x4_splat(b)), 0)',
+      ['a', 'b']
+    )
+    expect(f(3, 5)).toBe(5)
+    expect(f(-2, -8)).toBe(-2)
+    expect(f(4.5, 4.5)).toBe(4.5)
+  })
+  it('min', async () => {
+    const f = await kernel(
+      'return f32x4_extract_lane(f32x4_min(f32x4_splat(a), f32x4_splat(b)), 0)',
+      ['a', 'b']
+    )
+    expect(f(3, 5)).toBe(3)
+    expect(f(-2, -8)).toBe(-8)
+  })
+})
+
+describe('f32x4 select + comparisons (branch-free lane blend)', () => {
+  // select(cmp(a,b), 1, 2) → 1 when the comparison is true (mask lane all-1s), else 2
+  const via = (cmp: string) =>
+    kernel(
+      `return f32x4_extract_lane(f32x4_select(${cmp}(f32x4_splat(a), f32x4_splat(b)), f32x4_splat(1.0), f32x4_splat(2.0)), 0)`,
+      ['a', 'b']
+    )
+
+  it('gt', async () => {
+    const f = await via('f32x4_gt')
+    expect(f(5, 3)).toBe(1)
+    expect(f(3, 5)).toBe(2)
+  })
+  it('lt', async () => {
+    const f = await via('f32x4_lt')
+    expect(f(3, 5)).toBe(1)
+    expect(f(5, 3)).toBe(2)
+  })
+  it('ge / le at equality', async () => {
+    expect(await (await via('f32x4_ge'))(4, 4)).toBe(1)
+    expect(await (await via('f32x4_le'))(4, 4)).toBe(1)
+    expect(await (await via('f32x4_ge'))(3, 4)).toBe(2)
+  })
+  it('eq / ne', async () => {
+    expect(await (await via('f32x4_eq'))(4, 4)).toBe(1)
+    expect(await (await via('f32x4_eq'))(4, 5)).toBe(2)
+    expect(await (await via('f32x4_ne'))(4, 5)).toBe(1)
+  })
+})
+
+describe('clamp via min/max (the canonical use)', () => {
+  it('clamps to [lo, hi] on lane 0', async () => {
+    // clamp(v, lo, hi) = min(max(v, lo), hi); fix lo=0, hi=3 via constants
+    const f = await kernel(
+      'return f32x4_extract_lane(f32x4_min(f32x4_max(f32x4_splat(a), f32x4_splat(0.0)), f32x4_splat(3.0)), 0)',
+      ['a', 'b']
+    )
+    expect(f(-5, 0)).toBe(0)
+    expect(f(1.5, 0)).toBe(1.5)
+    expect(f(10, 0)).toBe(3)
+  })
+})

package/src/lang/wasm.ts

@@ -262,6 +262,19 @@ const SimdOp = {
   f32x4_sub: 0xe5,
   f32x4_mul: 0xe6,
   f32x4_div: 0xe7,
+  f32x4_min: 0xe8,
+  f32x4_max: 0xe9,
+
+  // f32x4 comparisons → v128 lane mask (all-1s / all-0s per lane)
+  f32x4_eq: 0x41,
+  f32x4_ne: 0x42,
+  f32x4_lt: 0x43,
+  f32x4_gt: 0x44,
+  f32x4_le: 0x45,
+  f32x4_ge: 0x46,
+
+  // Lane-wise blend: bitselect(a, b, mask) — bits of a where mask=1, else b.
+  v128_bitselect: 0x52,
 } as const
 
 /** Reverse lookup for SIMD opcodes */
@@ -1160,6 +1173,18 @@ function compileBinaryExpr(
     return [Op.f64_const, ...encodeF64(0)]
   }
 
+  // Lint the i32/i32 division footgun: `/` with two integer operands (loop vars,
+  // `0`-annotated params, int literals) does TRUNCATING integer division, and the
+  // coercion to f64 only happens at the *next* operator — so `x / w - 0.5` is
+  // silently `0 - 0.5` for all `x < w`. Warn once per block; add `+ 0.0` to an
+  // operand to force f64 division. (UI-#4 — this is a warning, not an error:
+  // integer division may be intended.)
+  if (node.operator === '/' && opType === 'i32') {
+    const msg =
+      "integer division: '/' with two i32 operands truncates (result coerces to f64 only at the next operator). Add `+ 0.0` to an operand to force f64 division."
+    if (!ctx.warnings.includes(msg)) ctx.warnings.push(msg)
+  }
+
   return [...leftCode, ...rightCode, opcode]
 }
 
@@ -1808,8 +1833,17 @@ function compileSIMDCall(
     case 'f32x4_add':
     case 'f32x4_sub':
     case 'f32x4_mul':
-    case 'f32x4_div': {
-      // Binary v128 op: f32x4_add(a, b) → v128
+    case 'f32x4_div':
+    case 'f32x4_min':
+    case 'f32x4_max':
+    case 'f32x4_eq':
+    case 'f32x4_ne':
+    case 'f32x4_lt':
+    case 'f32x4_gt':
+    case 'f32x4_le':
+    case 'f32x4_ge': {
+      // Binary v128 op: f(a, b) → v128. The comparisons (eq/ne/lt/gt/le/ge)
+      // return a v128 lane mask (all-1s where true, all-0s else).
       code.push(...compileExpression(args[0], ctx))
       code.push(...compileExpression(args[1], ctx))
       const opMap: Record<string, number> = {
@@ -1817,11 +1851,36 @@ function compileSIMDCall(
         f32x4_sub: SimdOp.f32x4_sub,
         f32x4_mul: SimdOp.f32x4_mul,
         f32x4_div: SimdOp.f32x4_div,
+        f32x4_min: SimdOp.f32x4_min,
+        f32x4_max: SimdOp.f32x4_max,
+        f32x4_eq: SimdOp.f32x4_eq,
+        f32x4_ne: SimdOp.f32x4_ne,
+        f32x4_lt: SimdOp.f32x4_lt,
+        f32x4_gt: SimdOp.f32x4_gt,
+        f32x4_le: SimdOp.f32x4_le,
+        f32x4_ge: SimdOp.f32x4_ge,
       }
       code.push(...encodeSIMD(opMap[name]))
       return code
     }
 
+    case 'f32x4_select': {
+      // Branch-free lane blend: f32x4_select(mask, a, b) → a where the mask lane
+      // is true (all-1s, e.g. from a compare), b where false. Maps to
+      // v128.bitselect(a, b, mask) — bits of a where mask=1, of b where mask=0.
+      if (args.length !== 3) {
+        ctx.errors.push(
+          `f32x4_select expects (mask, a, b) — 3 args, got ${args.length}`
+        )
+        return [Op.f64_const, ...encodeF64(0)]
+      }
+      code.push(...compileExpression(args[1], ctx)) // a (bitselect v1)
+      code.push(...compileExpression(args[2], ctx)) // b (bitselect v2)
+      code.push(...compileExpression(args[0], ctx)) // mask
+      code.push(...encodeSIMD(SimdOp.v128_bitselect))
+      return code
+    }
+
     case 'f32x4_neg':
     case 'f32x4_sqrt': {
       // Unary v128 op: f32x4_neg(a) → v128

package/src/schema/index.ts

@@ -0,0 +1,62 @@
+/**
+ * `tjs-lang/schema` — tosijs-schema, pre-wired with predicate support.
+ *
+ * A drop-in for `tosijs-schema` that additionally evaluates the `$predicate`
+ * keyword: importing this module registers tjs-lang's verified predicate engine
+ * as the evaluator, so JSON-Schema validation is predicate-aware **out of the
+ * box** — no manual `setPredicateEvaluator` call. Everything tosijs-schema
+ * exports is re-exported here, so this is the only import a consumer needs:
+ *
+ * ```ts
+ * import { s, validate } from 'tjs-lang/schema'
+ * // a schema whose node carries `$predicate` now validates computationally
+ * ```
+ *
+ * Why it lives here and not in tosijs-schema: tjs-lang depends on tosijs-schema,
+ * so the reverse would be a circular dependency. This entry sits on the side of
+ * the graph that may know about both — it's the "batteries-included" packaging
+ * of the two.
+ *
+ * Registration is a global (tosijs-schema keeps one evaluator), so importing
+ * this module makes `$predicate` work for tosijs-schema usage app-wide, even in
+ * code that imports `tosijs-schema` directly. Call `setPredicateEvaluator(null)`
+ * to opt back out, or `installPredicateSupport(opts)` to re-install with custom
+ * options (fuel budget, atom-aware effects, etc.).
+ */
+import { setPredicateEvaluator, getPredicateEvaluator } from 'tosijs-schema'
+import {
+  createPredicateEvaluator,
+  type PredicateEvaluatorOptions,
+} from '../lang/predicate'
+
+// The full tosijs-schema surface (s, validate, filter, diff, types,
+// setPredicateEvaluator, getPredicateEvaluator, PredicateEvaluator, …).
+export * from 'tosijs-schema'
+// The evaluator factory, for advanced/custom wiring.
+export {
+  createPredicateEvaluator,
+  type PredicateEvaluatorOptions,
+} from '../lang/predicate'
+
+let installed = false
+
+/**
+ * Register tjs-lang's predicate engine as tosijs-schema's `$predicate` evaluator.
+ * Called automatically when this module is imported; exposed so callers can
+ * re-install with custom {@link PredicateEvaluatorOptions} (e.g. a smaller fuel
+ * budget, or an atom-aware effectful set) after opting out.
+ */
+export function installPredicateSupport(
+  opts?: PredicateEvaluatorOptions
+): void {
+  setPredicateEvaluator(createPredicateEvaluator(opts))
+  installed = true
+}
+
+/** True once predicate support has been installed (and not since cleared). */
+export function predicateSupportInstalled(): boolean {
+  return installed && getPredicateEvaluator() !== null
+}
+
+// Batteries included: wire the engine up on import.
+installPredicateSupport()

package/src/schema/schema.test.ts

@@ -0,0 +1,66 @@
+/**
+ * `tjs-lang/schema` — tosijs-schema pre-wired with predicate support. Importing
+ * the module should make `$predicate` validation work with no manual wiring, and
+ * re-export the whole tosijs-schema surface. Runs against the real published
+ * tosijs-schema (node_modules), so it also guards the version/API contract.
+ */
+import { describe, it, expect, afterAll } from 'bun:test'
+import {
+  validate,
+  s,
+  setPredicateEvaluator,
+  getPredicateEvaluator,
+  installPredicateSupport,
+  predicateSupportInstalled,
+  createPredicateEvaluator,
+} from './index'
+import { cssStyleSchema, cssColorSchema } from '../css'
+
+// Leave the global evaluator registered for other suites (import order is
+// nondeterministic); this module's contract is "installed after import".
+afterAll(() => installPredicateSupport())
+
+describe('tjs-lang/schema is batteries-included', () => {
+  it('registers the predicate evaluator on import', () => {
+    expect(predicateSupportInstalled()).toBe(true)
+    expect(typeof getPredicateEvaluator()).toBe('function')
+  })
+
+  it('re-exports the tosijs-schema surface', () => {
+    expect(typeof validate).toBe('function')
+    expect(typeof s).toBe('object') // the builder proxy
+    expect(typeof setPredicateEvaluator).toBe('function')
+    expect(typeof createPredicateEvaluator).toBe('function')
+  })
+
+  it('validates a $predicate node out of the box (CSS color)', () => {
+    const color = cssColorSchema()
+    expect(validate('#3a3', color)).toBe(true)
+    expect(validate('notacolor', color)).toBe(false) // predicate ran, no manual wiring
+  })
+
+  it('validates the recursive CSS style structure', () => {
+    const style = cssStyleSchema()
+    expect(
+      validate({ color: 'red', '&:hover': { color: 'var(--accent)' } }, style)
+    ).toBe(true)
+    expect(validate({ '  bad key  ': 'red' }, style)).toBe(false)
+    expect(validate('not-an-object', style)).toBe(false)
+  })
+
+  it('opting out (setPredicateEvaluator(null)) falls back to structural only', () => {
+    setPredicateEvaluator(null)
+    const color = cssColorSchema()
+    // naive: only `type: string` is checked, so a non-color string passes
+    expect(validate('notacolor', color)).toBe(true)
+    // re-install for the remaining assertions
+    installPredicateSupport()
+    expect(validate('notacolor', color)).toBe(false)
+  })
+
+  it('installPredicateSupport accepts custom options (fuel budget)', () => {
+    installPredicateSupport({ fuel: 500_000 })
+    expect(predicateSupportInstalled()).toBe(true)
+    expect(validate('#fff', cssColorSchema())).toBe(true)
+  })
+})

package/src/use-cases/bootstrap.test.ts

@@ -14,6 +14,7 @@
 import { describe, it, expect } from 'bun:test'
 import { fromTS } from '../lang/emitters/from-ts'
 import { tjs } from '../lang'
+import { emitVerifiedPredicate } from '../lang/predicate'
 import * as fs from 'fs'
 import * as path from 'path'
 
@@ -528,10 +529,16 @@ describe('Bootstrap Canary', () => {
       // Step 2: Execute the combined transpiled parser modules
       const execStart = performance.now()
 
-      const parserModule = new Function(`
+      // parser-transforms.ts calls emitVerifiedPredicate (from predicate.ts, an
+      // acorn-backed engine module not in this parser-only bundle) — inject the
+      // native one so the self-hosted preprocess can verify Type/Generic predicates.
+      const parserModule = new Function(
+        'emitVerifiedPredicate',
+        `
         ${combinedCode}
         return { preprocess };
-      `)()
+      `
+      )(emitVerifiedPredicate)
       const execTime = performance.now() - execStart
 
       expect(typeof parserModule.preprocess).toBe('function')
@@ -639,10 +646,13 @@ describe('Bootstrap Canary', () => {
         combinedCode += stripped + '\n'
       }
 
-      const bootstrappedParser = new Function(`
+      const bootstrappedParser = new Function(
+        'emitVerifiedPredicate',
+        `
         ${combinedCode}
         return { preprocess };
-      `)()
+      `
+      )(emitVerifiedPredicate)
 
       // Import native parser
       const nativeParser = require('../lang/parser')