tjs-lang 0.6.27 → 0.6.31

package/bin/dev.ts

@@ -77,8 +77,8 @@ async function buildDemo() {
       naming: 'tjs-runtime.js',
     })
 
-    // Copy static files
-    await $`cp demo/index.html demo/static/favicon.svg demo/static/photo-*.jpg tjs-lang.svg .demo/`
+    // Copy static files (including TFS service worker — must not be bundled)
+    await $`cp demo/index.html demo/static/favicon.svg demo/static/photo-*.jpg tjs-lang.svg demo/src/tfs-worker.js .demo/`
     await $`cp -r demo/static/texts .demo/`
 
     console.log('Build complete!')
@@ -195,6 +195,111 @@ const server = Bun.serve({
       })
     }
 
+    // TFS proxy — resolve npm packages from jsdelivr CDN
+    // This is the server-side fallback when the service worker can't intercept
+    // (e.g. blob iframes, first load before SW is active)
+    if (pathname.startsWith('/tfs/')) {
+      const tfsPath = pathname.slice(5)
+      const CDN_BASE = 'https://cdn.jsdelivr.net/npm'
+
+      // Parse package@version/subpath
+      let name: string, version: string, subpath: string
+      if (tfsPath.startsWith('@')) {
+        const match = tfsPath.match(/^(@[^/]+\/[^/@]+)(?:@([^/]+))?(\/.*)?$/)
+        if (match) {
+          name = match[1]
+          version = match[2] || 'latest'
+          subpath = match[3] || ''
+        } else {
+          return new Response('invalid tfs path', { status: 400 })
+        }
+      } else {
+        const match = tfsPath.match(/^([^/@]+)(?:@([^/]+))?(\/.*)?$/)
+        if (match) {
+          name = match[1]
+          version = match[2] || 'latest'
+          subpath = match[3] || ''
+        } else {
+          return new Response('invalid tfs path', { status: 400 })
+        }
+      }
+
+      try {
+        // If no subpath, resolve ESM entry point from package.json
+        if (!subpath) {
+          const pkgRes = await fetch(
+            `${CDN_BASE}/${name}@${version}/package.json`
+          )
+          if (pkgRes.ok) {
+            const pkg = await pkgRes.json()
+            const exp = pkg.exports
+            let entryPath: string | null = null
+
+            if (exp) {
+              // exports can be { ".": { import: "..." } } or { import: "..." }
+              const dot = exp['.'] ?? exp
+              if (typeof dot === 'string') entryPath = dot
+              else if (dot?.import)
+                entryPath =
+                  typeof dot.import === 'string'
+                    ? dot.import
+                    : dot.import?.default
+              else if (dot?.default) entryPath = dot.default
+            }
+            if (!entryPath) entryPath = pkg.module || pkg.main || '/index.js'
+            subpath = entryPath!.startsWith('/')
+              ? entryPath!
+              : entryPath!.startsWith('./')
+              ? entryPath!.slice(1)
+              : `/${entryPath}`
+          }
+        }
+
+        const cdnUrl = `${CDN_BASE}/${name}@${version}${subpath}`
+        const cdnRes = await fetch(cdnUrl)
+        if (!cdnRes.ok) {
+          return new Response(`package not found: ${name}@${version}`, {
+            status: 404,
+          })
+        }
+
+        let body = await cdnRes.text()
+        const origin = new URL(req.url).origin
+        const pkgBase = `${CDN_BASE}/${name}@${version}`
+
+        // Rewrite imports in the fetched module:
+        // - Bare specifiers → /tfs/ (transitive deps)
+        // - Relative imports → absolute CDN URLs (sibling files)
+        body = body.replace(
+          /((?:import|export)\s+(?:[\w\s{},*]+\s+from\s+)?)(['"])([^'"]+)\2/g,
+          (match: string, prefix: string, quote: string, spec: string) => {
+            if (spec.startsWith('http://') || spec.startsWith('https://'))
+              return match
+            if (spec.startsWith('./') || spec.startsWith('../')) {
+              // Relative import → resolve against CDN package path
+              const dir = subpath ? subpath.replace(/\/[^/]*$/, '') : '/dist'
+              // Add .js extension if missing (CDN requires it)
+              const specWithExt = /\.\w+$/.test(spec) ? spec : `${spec}.js`
+              const resolved = new URL(specWithExt, `${pkgBase}${dir}/`).href
+              return `${prefix}${quote}${resolved}${quote}`
+            }
+            if (spec.startsWith('/')) return match
+            // Bare specifier → route through /tfs/
+            return `${prefix}${quote}${origin}/tfs/${spec}${quote}`
+          }
+        )
+
+        return new Response(body, {
+          headers: {
+            'Content-Type': 'application/javascript',
+            'Access-Control-Allow-Origin': '*',
+          },
+        })
+      } catch (err: any) {
+        return new Response(`tfs error: ${err.message}`, { status: 502 })
+      }
+    }
+
     // For SPA routing, serve index.html for unknown paths
     const indexFile = Bun.file(join(DOCS_DIR, 'index.html'))
     if (await indexFile.exists()) {

package/demo/docs.json

@@ -115,7 +115,7 @@
     "type": "example",
     "group": "basics",
     "order": 15,
-    "code": "TjsEquals\n\n/*#\n## The Problem with JavaScript ==\n\nJavaScript's `==` does type coercion, producing surprises:\n\n    0 == ''          // true in JS (!)\n    false == []      // true in JS (!)\n    '' == false      // true in JS (!)\n    null == 0        // false in JS (but null == undefined is true)\n\nJavaScript's `===` fixes coercion but can't compare values:\n\n    new String('hi') === 'hi'    // false in JS (different types)\n    new Boolean(false) === false // false in JS (object vs primitive)\n\n## TJS Equality (TjsEquals)\n\n`==` becomes **honest equality**: no coercion, but unwraps\nboxed primitives. Fast O(1) — no deep comparison.\n\n`Is` / `IsNot` are **structural equality**: deep comparison\nfor when you explicitly need it. O(n) cost is visible.\n*/\n\n// --- Honest equality (==) fixes coercion ---\nconsole.log('== fixes JS coercion:')\nconsole.log('  0 == \"\":', 0 == '')             // false (JS: true)\nconsole.log('  false == []:', false == [])      // false (JS: true)\nconsole.log('  false == \"\":', false == '')      // false (JS: true)\nconsole.log('  1 == \"1\":', 1 == '1')           // false (JS: true)\n\n// --- Boxed primitives unwrap ---\nconsole.log('')\nconsole.log('== unwraps boxed primitives:')\nconsole.log('  new String(\"hi\") == \"hi\":', new String('hi') == 'hi')   // true\nconsole.log('  new Boolean(false) == false:', new Boolean(false) == false)  // true\nconsole.log('  new Number(42) == 42:', new Number(42) == 42)           // true\n\n// --- Nullish equality preserved ---\nconsole.log('')\nconsole.log('Nullish equality (useful pattern preserved):')\nconsole.log('  null == undefined:', null == undefined)   // true\nconsole.log('  null == 0:', null == 0)                   // false\nconsole.log('  null == \"\":', null == '')                  // false\n\n// --- Objects/arrays: reference equality (fast, O(1)) ---\nconsole.log('')\nconsole.log('== on objects/arrays is reference equality (fast):')\nconst obj = {x: 1}\nconsole.log('  obj == obj:', obj == obj)                   // true (same ref)\nconsole.log('  {x:1} == {x:1}:', {x: 1} == {x: 1})       // false (different refs)\nconsole.log('  [1,2] == [1,2]:', [1, 2] == [1, 2])        // false (different refs)\n\n// --- Is/IsNot: explicit deep structural comparison ---\nconsole.log('')\nconsole.log('Is/IsNot for deep structural comparison (explicit):')\nconsole.log('  {x:1} Is {x:1}:', Is({x: 1}, {x: 1}))          // true\nconsole.log('  [1,2,3] Is [1,2,3]:', Is([1,2,3], [1,2,3]))    // true\nconsole.log('  [1,2] Is [2,1]:', Is([1,2], [2,1]))             // false (order matters)\n\n// Sets compare by membership, not order\nconsole.log('  Set([1,2]) Is Set([2,1]):', Is(new Set([1,2]), new Set([2,1])))  // true\n\n// --- typeof null fixed ---\nconsole.log('')\nconsole.log('typeof null fixed:')\nconsole.log('  typeof null:', typeof null)                 // 'null' (JS: 'object')\nconsole.log('  typeof undefined:', typeof undefined)       // 'undefined'\nconsole.log('  typeof 42:', typeof 42)                     // 'number' (unchanged)\n\n// --- === unchanged: identity comparison ---\nconsole.log('')\nconsole.log('=== is unchanged (identity):')\nconsole.log('  obj === obj:', obj === obj)               // true\nconsole.log('  {x:1} === {x:1}:', {x: 1} === {x: 1})   // false\n\ntest 'typeof null is null, not object' {\n  expect(TypeOf(null)).toBe('null')\n  expect(TypeOf(undefined)).toBe('undefined')\n  expect(TypeOf(42)).toBe('number')\n  expect(TypeOf('hi')).toBe('string')\n  expect(TypeOf(true)).toBe('boolean')\n  expect(TypeOf({})).toBe('object')\n}\n\ntest 'Eq fixes coercion' {\n  expect(Eq(0, '')).toBe(false)\n  expect(Eq(false, [])).toBe(false)\n  expect(Eq('', false)).toBe(false)\n}\n\ntest 'Eq unwraps boxed primitives' {\n  expect(Eq(new String('hi'), 'hi')).toBe(true)\n  expect(Eq(new Boolean(false), false)).toBe(true)\n  expect(Eq(new Number(42), 42)).toBe(true)\n}\n\ntest 'Eq preserves nullish equality' {\n  expect(Eq(null, undefined)).toBe(true)\n  expect(Eq(null, 0)).toBe(false)\n}\n\ntest 'Is does deep structural comparison' {\n  expect(Is({a: 1, b: 2}, {a: 1, b: 2})).toBe(true)\n  expect(Is([1, 2, 3], [1, 2, 3])).toBe(true)\n  expect(Is([1, 2], [2, 1])).toBe(false)\n}",
+    "code": "TjsEquals\n\n/*#\n## The Problem with JavaScript ==\n\nJavaScript's `==` does type coercion, producing surprises:\n\n    0 == ''          // true in JS (!)\n    false == []      // true in JS (!)\n    '' == false      // true in JS (!)\n    null == 0        // false in JS (but null == undefined is true)\n\nJavaScript's `===` fixes coercion but can't compare values:\n\n    new String('hi') === 'hi'    // false in JS (different types)\n    new Boolean(false) === false // false in JS (object vs primitive)\n\n## TJS Equality (TjsEquals)\n\n`==` becomes **honest equality**: no coercion, but unwraps\nboxed primitives. Fast O(1) — no deep comparison.\n\n`Is` / `IsNot` are **structural equality**: deep comparison\nfor when you explicitly need it. O(n) cost is visible.\n*/\n\n// --- Honest equality (==) fixes coercion ---\nconsole.log('== fixes JS coercion:')\nconsole.log('  [] == ![]:', [] == ![])          // false (JS: true!)\nconsole.log('  0 == \"\":', 0 == '')             // false (JS: true)\nconsole.log('  false == []:', false == [])      // false (JS: true)\nconsole.log('  false == \"\":', false == '')      // false (JS: true)\nconsole.log('  1 == \"1\":', 1 == '1')           // false (JS: true)\n\n// --- Boxed primitives unwrap ---\nconsole.log('')\nconsole.log('== unwraps boxed primitives:')\nconsole.log('  new String(\"hi\") == \"hi\":', new String('hi') == 'hi')   // true\nconsole.log('  new Boolean(false) == false:', new Boolean(false) == false)  // true\nconsole.log('  new Number(42) == 42:', new Number(42) == 42)           // true\n\n// --- Nullish equality preserved ---\nconsole.log('')\nconsole.log('Nullish equality (useful pattern preserved):')\nconsole.log('  null == undefined:', null == undefined)   // true\nconsole.log('  null == 0:', null == 0)                   // false\nconsole.log('  null == \"\":', null == '')                  // false\n\n// --- Objects/arrays: reference equality (fast, O(1)) ---\nconsole.log('')\nconsole.log('== on objects/arrays is reference equality (fast):')\nconst obj = {x: 1}\nconsole.log('  obj == obj:', obj == obj)                   // true (same ref)\nconsole.log('  {x:1} == {x:1}:', {x: 1} == {x: 1})       // false (different refs)\nconsole.log('  [1,2] == [1,2]:', [1, 2] == [1, 2])        // false (different refs)\n\n// --- Is/IsNot: explicit deep structural comparison ---\nconsole.log('')\nconsole.log('Is/IsNot for deep structural comparison (explicit):')\nconsole.log('  {x:1} Is {x:1}:', Is({x: 1}, {x: 1}))          // true\nconsole.log('  [1,2,3] Is [1,2,3]:', Is([1,2,3], [1,2,3]))    // true\nconsole.log('  [1,2] Is [2,1]:', Is([1,2], [2,1]))             // false (order matters)\n\n// Sets compare by membership, not order\nconsole.log('  Set([1,2]) Is Set([2,1]):', Is(new Set([1,2]), new Set([2,1])))  // true\n\n// --- typeof null fixed ---\nconsole.log('')\nconsole.log('typeof null fixed:')\nconsole.log('  typeof null:', typeof null)                 // 'null' (JS: 'object')\nconsole.log('  typeof undefined:', typeof undefined)       // 'undefined'\nconsole.log('  typeof 42:', typeof 42)                     // 'number' (unchanged)\n\n// --- === unchanged: identity comparison ---\nconsole.log('')\nconsole.log('=== is unchanged (identity):')\nconsole.log('  obj === obj:', obj === obj)               // true\nconsole.log('  {x:1} === {x:1}:', {x: 1} === {x: 1})   // false\n\ntest 'typeof null is null, not object' {\n  expect(TypeOf(null)).toBe('null')\n  expect(TypeOf(undefined)).toBe('undefined')\n  expect(TypeOf(42)).toBe('number')\n  expect(TypeOf('hi')).toBe('string')\n  expect(TypeOf(true)).toBe('boolean')\n  expect(TypeOf({})).toBe('object')\n}\n\ntest 'Eq fixes coercion' {\n  expect(Eq(0, '')).toBe(false)\n  expect(Eq(false, [])).toBe(false)\n  expect(Eq('', false)).toBe(false)\n}\n\ntest 'Eq unwraps boxed primitives' {\n  expect(Eq(new String('hi'), 'hi')).toBe(true)\n  expect(Eq(new Boolean(false), false)).toBe(true)\n  expect(Eq(new Number(42), 42)).toBe(true)\n}\n\ntest 'Eq preserves nullish equality' {\n  expect(Eq(null, undefined)).toBe(true)\n  expect(Eq(null, 0)).toBe(false)\n}\n\ntest 'Is does deep structural comparison' {\n  expect(Is({a: 1, b: 2}, {a: 1, b: 2})).toBe(true)\n  expect(Is([1, 2, 3], [1, 2, 3])).toBe(true)\n  expect(Is([1, 2], [2, 1])).toBe(false)\n}",
     "language": "tjs",
     "description": "JavaScript `==` is broken. TJS fixes it without breaking anything."
   },
@@ -357,6 +357,42 @@
     "language": "tjs",
     "description": "Named types with runtime validation. Type, Generic, FunctionPredicate, Enum, Union."
   },
+  {
+    "title": "Inline WASM",
+    "filename": "wasm-basics.md",
+    "path": "guides/examples/tjs/wasm-basics.md",
+    "section": "tjs",
+    "type": "example",
+    "group": "patterns",
+    "order": 25,
+    "code": "/*#\n## The Problem\n\nUsing WebAssembly in JavaScript requires:\n1. Write WAT or compile from C/Rust\n2. Load a separate .wasm file\n3. Instantiate the module async\n4. Marshal data between JS and WASM heaps\n\nTJS does all of this for you. Write WASM inline using JS-like\nsyntax, it compiles at transpile time and embeds as base64.\n\n## Syntax\n\n    function fast(x: 0, y: 0) {\n      wasm {\n        // JS-like syntax compiled to WASM bytecode\n      } fallback {\n        // JS fallback if WASM unavailable\n        return x + y\n      }\n    }\n\n    // Or with a return value:\n    function compute(x: 0) {\n      return wasm {\n        x * x + 1\n      } fallback {\n        return x * x + 1\n      }\n    }\n\nParam types: `i32` (integer), `f32`/`f64` (float), `Float32Array`, etc.\n*/\n\n// --- Basic: integer math in WASM ---\n\nfunction addInts(! a: 0, b: 0) -! 0 {\n  return wasm {\n    a + b\n  } fallback {\n    return a + b\n  }\n}\n\nfunction factorial(! n: 0) -! 0 {\n  return wasm {\n    let result = 1\n    for (let i = 2; i <= n; i++) {\n      result = result * i\n    }\n  } fallback {\n    let result = 1\n    for (let i = 2; i <= n; i++) result *= i\n    return result\n  }\n}\n\n// --- Float math ---\n\nfunction lerp(! a: 0.0, b: 0.0, t: 0.0) -! 0.0 {\n  return wasm {\n    a + (b - a) * t\n  } fallback {\n    return a + (b - a) * t\n  }\n}\n\n// --- Array processing ---\n\nfunction sumArray(! arr: Float32Array, len: 0) -! 0.0 {\n  return wasm {\n    let sum = 0.0\n    for (let i = 0; i < len; i++) {\n      let off = i * 4\n      sum = sum + f32x4_extract_lane(f32x4_load(arr, off), 0)\n    }\n  } fallback {\n    let sum = 0\n    for (let i = 0; i < len; i++) sum += arr[i]\n    return sum\n  }\n}\n\nconsole.log('addInts(3, 4):', addInts(3, 4))\nconsole.log('factorial(10):', factorial(10))\nconsole.log('lerp(0, 100, 0.25):', lerp(0.0, 100.0, 0.25))\nconsole.log('sumArray([1,2,3,4]):', sumArray(new Float32Array([1, 2, 3, 4]), 4))",
+    "language": "tjs",
+    "description": "Write WebAssembly inline — compiled at transpile time, embedded in the output."
+  },
+  {
+    "title": "WASM SIMD",
+    "filename": "wasm-simd.md",
+    "path": "guides/examples/tjs/wasm-simd.md",
+    "section": "tjs",
+    "type": "example",
+    "group": "patterns",
+    "order": 26,
+    "code": "/*#\n## SIMD: Single Instruction, Multiple Data\n\nSIMD processes 4 float values per instruction — a 4x throughput\nimprovement for vectorized math. TJS provides SIMD via `f32x4_*`\nintrinsics that compile directly to WASM SIMD opcodes.\n\n### Available Intrinsics\n\n| Intrinsic | Operation |\n|-----------|-----------|\n| `f32x4_load(arr, offset)` | Load 4 floats from array |\n| `f32x4_store(arr, offset, vec)` | Store 4 floats to array |\n| `f32x4_splat(value)` | Fill all 4 lanes with one value |\n| `f32x4_add(a, b)` | Add 4 pairs |\n| `f32x4_sub(a, b)` | Subtract 4 pairs |\n| `f32x4_mul(a, b)` | Multiply 4 pairs |\n| `f32x4_div(a, b)` | Divide 4 pairs |\n| `f32x4_neg(a)` | Negate 4 values |\n| `f32x4_sqrt(a)` | Square root of 4 values |\n| `f32x4_extract_lane(vec, lane)` | Get one float (0-3) |\n| `f32x4_replace_lane(vec, lane, val)` | Set one float |\n*/\n\n// --- Scale an array by a constant (SIMD: 4 elements per step) ---\n\nfunction scale(! arr: Float32Array, len: 0, factor: 0.0) {\n  wasm {\n    let s = f32x4_splat(factor)\n    for (let i = 0; i < len; i += 4) {\n      let off = i * 4\n      let v = f32x4_load(arr, off)\n      f32x4_store(arr, off, f32x4_mul(v, s))\n    }\n  } fallback {\n    for (let i = 0; i < len; i++) arr[i] *= factor\n  }\n}\n\n// --- Dot product (sum of element-wise products) ---\n\nfunction dot(! a: Float32Array, b: Float32Array, len: 0) -! 0.0 {\n  return wasm {\n    let acc = f32x4_splat(0.0)\n    for (let i = 0; i < len; i += 4) {\n      let off = i * 4\n      let va = f32x4_load(a, off)\n      let vb = f32x4_load(b, off)\n      acc = f32x4_add(acc, f32x4_mul(va, vb))\n    }\n    // Sum the 4 lanes\n    f32x4_extract_lane(acc, 0)\n      + f32x4_extract_lane(acc, 1)\n      + f32x4_extract_lane(acc, 2)\n      + f32x4_extract_lane(acc, 3)\n  } fallback {\n    let sum = 0\n    for (let i = 0; i < len; i++) sum += a[i] * b[i]\n    return sum\n  }\n}\n\n// --- Demo ---\n\nconst SIZE = 1024\n\n// Create test arrays\nconst arr = new Float32Array(SIZE)\nconst a = new Float32Array(SIZE)\nconst b = new Float32Array(SIZE)\n\nfor (let i = 0; i < SIZE; i++) {\n  arr[i] = i + 1\n  a[i] = 1.0\n  b[i] = 2.0\n}\n\n// Scale\nscale(arr, SIZE, 0.5)\nconsole.log('scale([1..1024], 0.5) first 4:', arr[0], arr[1], arr[2], arr[3])\n\n// Dot product: 1.0 * 2.0 * 1024 = 2048\nconst d = dot(a, b, SIZE)\nconsole.log('dot([1,1,...], [2,2,...], 1024):', d)\n\n// Benchmark\nconst iters = 1000\nconst t0 = performance.now()\nfor (let i = 0; i < iters; i++) scale(arr, SIZE, 1.001)\nconst elapsed = performance.now() - t0\nconsole.log(`${iters} scale ops on ${SIZE} floats: ${elapsed.toFixed(1)}ms`)",
+    "language": "tjs",
+    "description": "Process 4 floats per instruction. No setup, no toolchain."
+  },
+  {
+    "title": "WASM Memory",
+    "filename": "wasm-memory.md",
+    "path": "guides/examples/tjs/wasm-memory.md",
+    "section": "tjs",
+    "type": "example",
+    "group": "patterns",
+    "order": 27,
+    "code": "/*#\n## How Data Moves Between JS and WASM\n\nThe #1 WebAssembly question: \"How do I get my data into WASM?\"\nTJS handles it automatically. Three modes:\n\n### 1. Scalars — pass through\n`i32`, `f32`, `f64` go directly as WASM parameters. No marshaling.\n\n### 2. Regular typed arrays — transparent copy\nPass a normal `Float32Array` and TJS copies it into WASM memory\nbefore the call, then copies results back out after. You don't\nhave to think about it.\n\n### 3. `wasmBuffer()` — zero-copy shared memory\nAllocate directly in WASM memory. Both JS and WASM see the same\nbytes. No copy in, no copy out. Mutations are instantly visible.\n\n    const xs = wasmBuffer(Float32Array, 50000)\n    xs[0] = 3.14        // JS writes to WASM memory\n    wasmFunction(xs)     // WASM reads/writes the same memory\n    console.log(xs[0])   // JS sees WASM's mutations immediately\n\n### Supported types\n`Float32Array`, `Float64Array`, `Int32Array`, `Uint8Array`\n\n### How it works internally\nAll WASM blocks in a file share one `WebAssembly.Memory` (64MB).\n`wasmBuffer` is a bump allocator — it hands out slices of this memory.\nWhen a typed array argument's `.buffer === wasmMemory.buffer`, the\nwrapper skips the copy and passes the byte offset directly.\n*/\n\n// --- Regular arrays: transparent copy ---\n\nfunction addOne(! arr: Float32Array, len: 0) {\n  wasm {\n    for (let i = 0; i < len; i += 4) {\n      let off = i * 4\n      let v = f32x4_load(arr, off)\n      let ones = f32x4_splat(1.0)\n      f32x4_store(arr, off, f32x4_add(v, ones))\n    }\n  } fallback {\n    for (let i = 0; i < len; i++) arr[i] += 1\n  }\n}\n\n// Regular Float32Array — TJS copies in before, copies out after\nconst regular = new Float32Array([10, 20, 30, 40])\naddOne(regular, 4)\nconsole.log('Regular array after WASM:', Array.from(regular))\n// [11, 21, 31, 41] — changes visible in JS\n\n// --- wasmBuffer: zero-copy shared memory ---\n\nconst shared = wasmBuffer(Float32Array, 4)\nshared[0] = 100\nshared[1] = 200\nshared[2] = 300\nshared[3] = 400\n\naddOne(shared, 4)\nconsole.log('wasmBuffer after WASM:', Array.from(shared))\n// [101, 201, 301, 401] — zero copy, same memory\n\n// --- Practical: large array processing ---\n\nconst SIZE = 10000\nconst data = wasmBuffer(Float32Array, SIZE)\nfor (let i = 0; i < SIZE; i++) data[i] = i * 0.01\n\n// Process in WASM — no marshaling overhead\nfunction normalize(! arr: Float32Array, len: 0) {\n  wasm {\n    // Find max (scalar — SIMD max needs horizontal reduction)\n    let max = 0.0\n    for (let i = 0; i < len; i++) {\n      let off = i * 4\n      let v = f32x4_extract_lane(f32x4_load(arr, off), 0)\n      if (v > max) { max = v }\n    }\n    // Scale to [0, 1]\n    if (max > 0.0) {\n      let inv = f32x4_splat(1.0 / max)\n      for (let i = 0; i < len; i += 4) {\n        let off = i * 4\n        f32x4_store(arr, off, f32x4_mul(f32x4_load(arr, off), inv))\n      }\n    }\n  } fallback {\n    let max = 0\n    for (let i = 0; i < len; i++) if (arr[i] > max) max = arr[i]\n    if (max > 0) for (let i = 0; i < len; i++) arr[i] /= max\n  }\n}\n\nconst t0 = performance.now()\nnormalize(data, SIZE)\nconst elapsed = performance.now() - t0\n\nconsole.log(`Normalized ${SIZE} floats in ${elapsed.toFixed(2)}ms`)\nconsole.log('First 4:', data[0].toFixed(4), data[1].toFixed(4), data[2].toFixed(4), data[3].toFixed(4))\nconsole.log('Last:', data[SIZE - 1].toFixed(4))",
+    "language": "tjs",
+    "description": "Zero-copy arrays and automatic data marshaling between JS and WASM."
+  },
   {
     "title": "React Todo (Comparison)",
     "filename": "react-todo-comparison.md",

package/demo/src/imports.test.ts

@@ -1,206 +1,91 @@
 /**
- * Unit tests for import resolution infrastructure
- *
- * Tests the synchronous functions that don't require browser/network.
+ * Unit tests for TFS import resolution
  */
 
 import { describe, it, expect } from 'bun:test'
-import {
-  extractImports,
-  getCDNUrl,
-  generateImportMap,
-  generateImportMapScript,
-  wrapAsModule,
-  clearModuleCache,
-  getCacheStats,
-} from './imports'
+import { extractImports, rewriteImports } from './imports'
 
 describe('extractImports', () => {
   it('should extract named imports', () => {
-    const source = `import { foo, bar } from 'some-package'`
-    expect(extractImports(source)).toEqual(['some-package'])
+    expect(extractImports(`import { foo } from 'pkg'`)).toEqual(['pkg'])
   })
 
   it('should extract default imports', () => {
-    const source = `import React from 'react'`
-    expect(extractImports(source)).toEqual(['react'])
-  })
-
-  it('should extract namespace imports', () => {
-    const source = `import * as lodash from 'lodash'`
-    expect(extractImports(source)).toEqual(['lodash'])
-  })
-
-  it('should extract side-effect imports', () => {
-    const source = `import 'polyfill'`
-    expect(extractImports(source)).toEqual(['polyfill'])
-  })
-
-  it('should extract re-exports', () => {
-    const source = `export { foo } from 'some-package'`
-    expect(extractImports(source)).toEqual(['some-package'])
-  })
-
-  it('should handle multiple imports', () => {
-    const source = `
-      import { add } from 'lodash'
-      import { format } from 'date-fns'
-      import React from 'react'
-    `
-    expect(extractImports(source)).toEqual(['lodash', 'date-fns', 'react'])
-  })
-
-  it('should deduplicate imports', () => {
-    const source = `
-      import { add } from 'lodash'
-      import { subtract } from 'lodash'
-    `
-    expect(extractImports(source)).toEqual(['lodash'])
+    expect(extractImports(`import React from 'react'`)).toEqual(['react'])
   })
 
   it('should ignore relative imports', () => {
-    const source = `
-      import { foo } from './local'
-      import { bar } from '../parent'
-      import { baz } from '/absolute'
-      import { qux } from 'npm-package'
-    `
-    expect(extractImports(source)).toEqual(['npm-package'])
-  })
-
-  it('should handle subpath imports', () => {
-    const source = `import { debounce } from 'lodash/debounce'`
-    expect(extractImports(source)).toEqual(['lodash/debounce'])
-  })
-
-  it('should handle scoped packages', () => {
-    const source = `import { something } from '@scope/package'`
-    expect(extractImports(source)).toEqual(['@scope/package'])
+    expect(
+      extractImports(`import { a } from './local'\nimport { b } from 'pkg'`)
+    ).toEqual(['pkg'])
   })
 
-  it('should handle scoped packages with subpaths', () => {
-    const source = `import { util } from '@scope/package/utils'`
-    expect(extractImports(source)).toEqual(['@scope/package/utils'])
+  it('should handle versioned specifiers', () => {
+    expect(extractImports(`import { x } from 'tosijs@1.3.11'`)).toEqual([
+      'tosijs@1.3.11',
+    ])
   })
 
-  it('should handle double quotes', () => {
-    const source = `import { foo } from "some-package"`
-    expect(extractImports(source)).toEqual(['some-package'])
-  })
-
-  it('should return empty array for no imports', () => {
-    const source = `const x = 1; function foo() { return x }`
-    expect(extractImports(source)).toEqual([])
+  it('should deduplicate', () => {
+    expect(
+      extractImports(`import { a } from 'pkg'\nimport { b } from 'pkg'`)
+    ).toEqual(['pkg'])
   })
 })
 
-describe('getCDNUrl', () => {
-  it('should generate URL for simple package', () => {
-    expect(getCDNUrl('some-unknown-package')).toBe(
-      'https://cdn.jsdelivr.net/npm/some-unknown-package'
+describe('rewriteImports', () => {
+  it('should rewrite bare specifiers to /tfs/', () => {
+    expect(rewriteImports(`import { foo } from 'tosijs'`)).toBe(
+      `import { foo } from '/tfs/tosijs'`
     )
   })
 
-  it('should use pinned version and path for known packages', () => {
-    // tosijs has pinned version and path
-    expect(getCDNUrl('tosijs')).toBe(
-      'https://cdn.jsdelivr.net/npm/tosijs@1.2.0/dist/module.js'
-    )
-    // date-fns has pinned version but no path
-    expect(getCDNUrl('date-fns')).toBe(
-      'https://cdn.jsdelivr.net/npm/date-fns@3.6.0'
+  it('should handle versioned specifiers', () => {
+    expect(rewriteImports(`import { x } from 'tosijs@1.3.11'`)).toBe(
+      `import { x } from '/tfs/tosijs@1.3.11'`
     )
   })
 
-  it('should handle subpath imports with pinned version', () => {
-    expect(getCDNUrl('lodash-es/debounce')).toBe(
-      'https://cdn.jsdelivr.net/npm/lodash-es@4.17.21/debounce'
-    )
+  it('should handle subpath imports', () => {
+    expect(
+      rewriteImports(`import { debounce } from 'lodash-es/debounce'`)
+    ).toBe(`import { debounce } from '/tfs/lodash-es/debounce'`)
   })
 
   it('should handle scoped packages', () => {
-    expect(getCDNUrl('@scope/package')).toBe(
-      'https://cdn.jsdelivr.net/npm/@scope/package'
+    expect(rewriteImports(`import { x } from '@scope/pkg'`)).toBe(
+      `import { x } from '/tfs/@scope/pkg'`
     )
   })
 
-  it('should handle scoped packages with subpaths', () => {
-    expect(getCDNUrl('@scope/package/utils')).toBe(
-      'https://cdn.jsdelivr.net/npm/@scope/package/utils'
+  it('should not rewrite relative imports', () => {
+    expect(rewriteImports(`import { x } from './local'`)).toBe(
+      `import { x } from './local'`
     )
   })
 
-  it('should handle packages with pinned version but no path', () => {
-    // lodash-es is pinned but has no explicit path
-    expect(getCDNUrl('lodash-es')).toBe(
-      'https://cdn.jsdelivr.net/npm/lodash-es@4.17.21'
+  it('should not rewrite absolute imports', () => {
+    expect(rewriteImports(`import { x } from '/abs/path'`)).toBe(
+      `import { x } from '/abs/path'`
     )
   })
-})
-
-describe('generateImportMap', () => {
-  it('should generate import map for specifiers', () => {
-    const result = generateImportMap(['tosijs', 'date-fns'])
-    expect(result).toEqual({
-      imports: {
-        tosijs: 'https://cdn.jsdelivr.net/npm/tosijs@1.2.0/dist/module.js',
-        'date-fns': 'https://cdn.jsdelivr.net/npm/date-fns@3.6.0',
-      },
-    })
-  })
 
-  it('should handle empty array', () => {
-    expect(generateImportMap([])).toEqual({ imports: {} })
+  it('should not rewrite http imports', () => {
+    expect(
+      rewriteImports(`import { x } from 'https://cdn.example.com/pkg.js'`)
+    ).toBe(`import { x } from 'https://cdn.example.com/pkg.js'`)
   })
 
-  it('should handle subpath imports', () => {
-    const result = generateImportMap(['lodash-es/debounce'])
-    expect(result.imports['lodash-es/debounce']).toBe(
-      'https://cdn.jsdelivr.net/npm/lodash-es@4.17.21/debounce'
-    )
+  it('should handle multiple imports', () => {
+    const source = `import { a } from 'pkg-a'\nimport { b } from 'pkg-b'`
+    const result = rewriteImports(source)
+    expect(result).toContain("from '/tfs/pkg-a'")
+    expect(result).toContain("from '/tfs/pkg-b'")
   })
-})
-
-describe('generateImportMapScript', () => {
-  it('should generate script tag with import map', () => {
-    const importMap = {
-      imports: {
-        tosijs: 'https://cdn.jsdelivr.net/npm/tosijs@1.0.10/dist/module.js',
-      },
-    }
-    const script = generateImportMapScript(importMap)
 
-    expect(script).toContain('<script type="importmap">')
-    expect(script).toContain('</script>')
-    expect(script).toContain('"tosijs"')
-    expect(script).toContain(
-      'https://cdn.jsdelivr.net/npm/tosijs@1.0.10/dist/module.js'
+  it('should handle re-exports', () => {
+    expect(rewriteImports(`export { foo } from 'pkg'`)).toBe(
+      `export { foo } from '/tfs/pkg'`
     )
   })
 })
-
-describe('wrapAsModule', () => {
-  it('should wrap code in module script tag', () => {
-    const code = 'console.log("hello")'
-    const wrapped = wrapAsModule(code)
-
-    expect(wrapped).toContain('<script type="module">')
-    expect(wrapped).toContain('</script>')
-    expect(wrapped).toContain(code)
-  })
-})
-
-describe('module cache', () => {
-  it('should start empty', () => {
-    clearModuleCache()
-    const stats = getCacheStats()
-    expect(stats.size).toBe(0)
-    expect(stats.entries).toEqual([])
-  })
-
-  it('should clear cache', () => {
-    // Just verify it doesn't throw
-    clearModuleCache()
-    expect(getCacheStats().size).toBe(0)
-  })
-})