tjs-lang 0.8.0 → 0.8.2

package/src/lang/parser-params.ts

@@ -276,7 +276,7 @@ export function transformParenExpressions(
 
       // Check for safety marker right after opening paren: (? or (!
       const afterParen = source[i + matchLen]
-      let safetyMarker: '?' | '!' | null = null
+      let safetyMarker: '?' | '!' | null
       let paramStart = i + matchLen
 
       if (afterParen === '?' || afterParen === '!') {

package/src/lang/parser-transforms.ts

@@ -296,7 +296,7 @@ export function extractWasmFunctions(source: string): {
       i++
       continue
     }
-    let paramsSource = source.slice(parensStart, j - 1)
+    const paramsSource = source.slice(parensStart, j - 1)
     // j now points just past the closing `)`
 
     // Phase 2: detect `(!` — reserved syntax for unsafe wasm functions
@@ -413,7 +413,10 @@ export function composeImportedWasmFunctions(
   source: string,
   options: {
     loader?: {
-      load(specifier: string, importerPath?: string): {
+      load(
+        specifier: string,
+        importerPath?: string
+      ): {
         parseResult: { wasmBlocks: WasmBlock[] }
       } | null
     }
@@ -466,7 +469,8 @@ export function composeImportedWasmFunctions(
   // Default imports, namespace imports, and side-effect imports are left
   // alone — only named-bindings are candidates for wasm composition.
   // Multiline imports are supported via the [^}]*? non-greedy match.
-  const importRe = /^(\s*)import\s*\{([^}]*?)\}\s*from\s*(['"])([^'"]+)\3\s*;?\s*$/gm
+  const importRe =
+    /^(\s*)import\s*\{([^}]*?)\}\s*from\s*(['"])([^'"]+)\3\s*;?\s*$/gm
 
   const replaced = source.replace(
     importRe,
@@ -514,13 +518,11 @@ export function composeImportedWasmFunctions(
         // `import { outer } from 'lib'` work when outer internally calls
         // inner — both end up in the consumer's composed module.
         pullInTransitively(wasmBlock, importedWasmFunctions)
-        const argNames = wasmBlock.captures.map((c) =>
-          c.split(':')[0].trim()
-        )
+        const argNames = wasmBlock.captures.map((c) => c.split(':')[0].trim())
         wrappers.push(
-          `function ${local}(${argNames.join(
-            ', '
-          )}) { return globalThis.${wasmBlock.id}(${argNames.join(', ')}) }`
+          `function ${local}(${argNames.join(', ')}) { return globalThis.${
+            wasmBlock.id
+          }(${argNames.join(', ')}) }`
         )
       }
 
@@ -3376,15 +3378,7 @@ export function transformPolymorphicConstructors(
       })
     }
 
-    // Keep the first constructor in the class, remove the rest
-    // Build new class body with only the first constructor
-    let newBody = body.slice(0, ctors[0].fullEnd)
-    // Skip subsequent constructors
-    const afterLastCtor = ctors[ctors.length - 1].fullEnd
-    newBody += body.slice(afterLastCtor)
-
-    // But we need to remove just the extra constructors, keeping other methods
-    // Better approach: remove constructors 2..N from the body
+    // Remove the extra constructors, keeping the first constructor and other methods
     let cleanBody = body
     for (let i = ctors.length - 1; i >= 1; i--) {
       const ctor = ctors[i]

package/src/lang/parser-types.ts

@@ -15,6 +15,17 @@ export interface ParseOptions {
    * When true, skips == to Is() transformation since the VM handles == correctly.
    */
   vmTarget?: boolean
+  /**
+   * Source dialect — tells the transpiler what kind of source this string is:
+   * - `'tjs'`: native TJS, all footgun-removal modes ON (structural `==`,
+   *   `TjsStandard`, etc.). This is the default for a bare string.
+   * - `'js'`: plain JavaScript — modes OFF and `safety: 'none'`, so the source's
+   *   own semantics are preserved (no `==`→`Eq`, no truthiness rewrite, etc.).
+   *
+   * Authoritative when set; otherwise the dialect is inferred (the fromTS
+   * annotation and `vmTarget` ⇒ JS-compatible). See PRINCIPLES.md (TJS ⊇ JS).
+   */
+  dialect?: 'js' | 'tjs'
   /**
    * Optional ModuleLoader for cross-file `wasm function` composition (Phase 3).
    * When provided, imports are resolved at transpile time and matching wasm
@@ -109,6 +120,12 @@ export interface PreprocessOptions {
    * Default: false (transform == to Is() for TJS code running in regular JS)
    */
   vmTarget?: boolean
+  /**
+   * Source dialect: `'js'` ⇒ modes OFF / `safety: 'none'` (preserve plain-JS
+   * semantics); `'tjs'` ⇒ native modes ON. Authoritative when set; otherwise
+   * inferred from the fromTS annotation / `vmTarget`. See ParseOptions.dialect.
+   */
+  dialect?: 'js' | 'tjs'
   /**
    * Optional ModuleLoader for cross-file `wasm function` composition (Phase 3).
    * See ParseOptions.moduleLoader for details.

package/src/lang/parser.test.ts

@@ -814,13 +814,19 @@ test 'always fails' { throw new Error('intentional') }
   })
 
   describe('Error handling', () => {
-    it('should reject multiple functions', () => {
-      expect(() =>
-        transpile(`
-        function a() {}
-        function b() {}
+    it('accepts multiple functions as local helpers (last is the entry)', () => {
+      // Multiple top-level functions are now the local-helpers feature: the
+      // last declaration is the entry point, the rest are helpers called by
+      // name via callLocal. See use-cases/local-helpers.test.ts for semantics.
+      const { ast } = transpile(`
+        function helper(x: 0): 0 { return x }
+        function main(n: 0): 0 {
+          const r = helper(n)
+          return r
+        }
       `)
-      ).toThrow('Only a single function')
+      // Unused/used helpers are collected onto the root node by name.
+      expect((ast as any).helpers?.helper).toBeDefined()
     })
 
     it('should require a function when only a class is provided', () => {

package/src/lang/parser.ts

@@ -135,9 +135,17 @@ export function preprocess(
   // The /* tjs <- filename */ annotation is the signal
   const isFromTS = /\/\*\s*tjs\s*<-\s*\S+\s*\*\//.test(source)
 
-  // Native TJS: all modes ON by default (TJS is its own language)
-  // TS-originated or VM target (AJS): all modes OFF, safety none (JS-compatible)
-  const isCompat = isFromTS || options.vmTarget
+  // Native TJS: all modes ON by default (TJS is its own language).
+  // Plain JS (dialect: 'js'), TS-originated, or VM target: all modes OFF +
+  // safety none, so the source's own semantics are preserved (JS-compatible).
+  // An explicit `dialect` is authoritative; otherwise infer from the fromTS
+  // annotation / vmTarget. See PRINCIPLES.md (TJS ⊇ JS).
+  const isCompat =
+    options.dialect === 'js'
+      ? true
+      : options.dialect === 'tjs'
+      ? false
+      : isFromTS || options.vmTarget
   const tjsModes: TjsModes = isCompat
     ? {
         tjsEquals: false,
@@ -452,6 +460,7 @@ export function parse(
     filename = '<source>',
     colonShorthand = true,
     vmTarget = false,
+    dialect,
   } = options
 
   // Preprocess for custom syntax
@@ -472,6 +481,7 @@ export function parse(
   } = colonShorthand
     ? preprocess(source, {
         vmTarget,
+        dialect,
         moduleLoader: options.moduleLoader,
         filename: options.filename,
       })
@@ -602,6 +612,106 @@ export function validateSingleFunction(
   return functions[0]
 }
 
+/**
+ * Extract top-level function declarations from the parsed program.
+ *
+ * Returns `{ entry, helpers }` where:
+ *   - `entry` is the last function declaration (the agent's entry point)
+ *   - `helpers` are all preceding function declarations, looked up by name
+ *
+ * This matches the natural "helpers first, agent last" pattern, including
+ * the TOOL_LIBRARY use case where helper async wrappers are prepended
+ * before the user-supplied agent function.
+ *
+ * Same top-level construct restrictions as `validateSingleFunction`:
+ * imports, exports, and classes are rejected.
+ */
+export function extractFunctions(
+  ast: Program,
+  filename?: string
+): { entry: FunctionDeclaration; helpers: Map<string, FunctionDeclaration> } {
+  // Top-level construct checks (same as validateSingleFunction)
+  for (const node of ast.body) {
+    if (node.type === 'ImportDeclaration') {
+      throw new SyntaxError(
+        'Imports are not supported. All atoms must be registered with the VM.',
+        node.loc?.start || { line: 1, column: 0 },
+        undefined,
+        filename
+      )
+    }
+
+    if (
+      node.type === 'ExportNamedDeclaration' ||
+      node.type === 'ExportDefaultDeclaration'
+    ) {
+      throw new SyntaxError(
+        'Exports are not supported. The function is automatically exported.',
+        node.loc?.start || { line: 1, column: 0 },
+        undefined,
+        filename
+      )
+    }
+
+    if (node.type === 'ClassDeclaration') {
+      throw new SyntaxError(
+        'Classes are not supported. Agent99 uses functional composition.',
+        node.loc?.start || { line: 1, column: 0 },
+        undefined,
+        filename
+      )
+    }
+  }
+
+  const functions = ast.body.filter(
+    (node): node is FunctionDeclaration => node.type === 'FunctionDeclaration'
+  )
+
+  if (functions.length === 0) {
+    throw new SyntaxError(
+      'Source must contain a function declaration',
+      { line: 1, column: 0 },
+      undefined,
+      filename
+    )
+  }
+
+  const entry = functions[functions.length - 1]
+  const helpers = new Map<string, FunctionDeclaration>()
+
+  for (let i = 0; i < functions.length - 1; i++) {
+    const fn = functions[i]
+    const name = fn.id?.name
+    if (!name) {
+      throw new SyntaxError(
+        'Helper function must have a name',
+        fn.loc?.start || { line: 1, column: 0 },
+        undefined,
+        filename
+      )
+    }
+    if (helpers.has(name)) {
+      throw new SyntaxError(
+        `Duplicate helper function name: ${name}`,
+        fn.loc?.start || { line: 1, column: 0 },
+        undefined,
+        filename
+      )
+    }
+    if (name === entry.id?.name) {
+      throw new SyntaxError(
+        `Helper function cannot share a name with the entry function: ${name}`,
+        fn.loc?.start || { line: 1, column: 0 },
+        undefined,
+        filename
+      )
+    }
+    helpers.set(name, fn)
+  }
+
+  return { entry, helpers }
+}
+
 /**
  * Extract TDoc comment from before a function
  *

package/src/lang/perf.test.ts

@@ -60,8 +60,12 @@ describe('TJS Performance', () => {
       console.log(`    Median: ${median.toFixed(0)}ms`)
       console.log(`    Max:    ${max.toFixed(0)}ms`)
 
-      // Cold start should be under 200ms
-      expect(median).toBeLessThan(200)
+      // Regression guardrail, not a micro-benchmark: this wall-clock is
+      // dominated by `bun` process spawn + module-graph load (the one-line
+      // transpile is negligible), so it's machine- and load-dependent. Keep the
+      // bar generous — it catches a gross regression (cold start ballooning to
+      // seconds) without flaking on a loaded box or slower CI.
+      expect(median).toBeLessThan(500)
     })
 
     it('should measure tjs emit time', async () => {
@@ -84,7 +88,8 @@ describe('TJS Performance', () => {
       console.log(`\n  tjs emit cold start (5 runs):`)
       console.log(`    Median: ${median.toFixed(0)}ms`)
 
-      expect(median).toBeLessThan(200)
+      // Generous regression guardrail — see the tjsx cold-start note above.
+      expect(median).toBeLessThan(500)
     })
 
     it('should measure tjs check time', async () => {
@@ -107,7 +112,8 @@ describe('TJS Performance', () => {
       console.log(`\n  tjs check cold start (5 runs):`)
       console.log(`    Median: ${median.toFixed(0)}ms`)
 
-      expect(median).toBeLessThan(200)
+      // Generous regression guardrail — see the tjsx cold-start note above.
+      expect(median).toBeLessThan(500)
     })
   })
 

package/src/lang/runtime.ts

@@ -73,7 +73,6 @@ export {
 }
 
 // Version from package.json - injected at build time or imported
-// eslint-disable-next-line @typescript-eslint/no-var-requires
 const pkg = require('../../package.json') as { version: string }
 
 export const TJS_VERSION: string = pkg.version

package/src/lang/subset-invariant.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'bun:test'
+import { tjs, transpile } from './index'
+
+/**
+ * Guards the language subset invariants engraved in PRINCIPLES.md:
+ *
+ *   AJS  ⊆  TJS            — every legal AJS source is legal TJS source
+ *   JS   ⊆  TJS (no modes) — every legal JS program is legal TJS
+ *
+ * TJS may do MORE with the same source (enforce contracts, run signature
+ * tests) but must never REJECT source the subset accepts. The classic way this
+ * breaks: a build-time signature test that can't *run* (it calls an AJS atom
+ * that doesn't exist at build time, etc.) gets escalated into a transpile
+ * error. Such tests must be *inconclusive*, never failing.
+ */
+describe('Language subset invariants (PRINCIPLES.md)', () => {
+  // Representative AJS-shaped sources. Each must be valid AJS (transpile to a
+  // VM AST) AND valid TJS (tjs() must not throw). Several carry return types
+  // and call atoms — the exact shape that used to be illegal TJS.
+  const ajsSnippets: Array<[string, string]> = [
+    [
+      'agent returning an object (no types)',
+      `function main(n: 0) {\n  return { doubled: n * 2 }\n}`,
+    ],
+    [
+      'atom call + return type',
+      `function main(url: ''): { x: '' } {\n  const x = httpFetch({ url })\n  return { x }\n}`,
+    ],
+    [
+      'helper with a typed signature',
+      `function double(x: 0): 0 {\n  return x * 2\n}\nfunction main(n: 0) {\n  const d = double(n)\n  return { d }\n}`,
+    ],
+    [
+      'helper that calls an atom + return type',
+      `function fetchIt(u: ''): '' {\n  const r = httpFetch({ url: u })\n  return r\n}\nfunction main(url: '') {\n  const x = fetchIt(url)\n  return { x }\n}`,
+    ],
+    [
+      'consistent signature example still validates',
+      `function add(a: 2, b: 3): 5 {\n  return a + b\n}\nfunction main(x: 0, y: 0) {\n  const s = add(x, y)\n  return { s }\n}`,
+    ],
+  ]
+
+  describe('TJS ⊇ AJS', () => {
+    for (const [label, src] of ajsSnippets) {
+      it(`valid as both AJS and TJS: ${label}`, () => {
+        // Valid AJS (produces a VM AST)…
+        expect(() => transpile(src, { vmTarget: true })).not.toThrow()
+        // …and therefore must be valid TJS (never rejected).
+        expect(() => tjs(src)).not.toThrow()
+      })
+    }
+  })
+
+  it('un-runnable signature tests are inconclusive, not failures', () => {
+    const r = tjs(
+      `function main(url: ''): { x: '' } {\n  const x = httpFetch({ url })\n  return { x }\n}`
+    )
+    const sig = r.testResults?.find((t: any) => t.isSignatureTest)
+    expect(sig).toBeDefined()
+    expect(sig?.passed).toBe(false)
+    expect(sig?.inconclusive).toBe(true)
+  })
+
+  it('still REJECTS a genuinely inconsistent signature example (validation intact)', () => {
+    // 2 + 3 = 5, not 99 — the test runs cleanly and mismatches → hard failure.
+    expect(() =>
+      tjs(`function add(a: 2, b: 3): 99 {\n  return a + b\n}`)
+    ).toThrow(/inconsistent/)
+  })
+
+  describe('TJS (no modes) ⊇ JS', () => {
+    // Plain JavaScript under options-off TJS (TjsCompat disables all modes).
+    const jsSnippets: Array<[string, string]> = [
+      ['arithmetic fn', `function f(x) { return x + 1 }`],
+      [
+        'control flow + array methods',
+        `function f(xs) {\n  let total = 0\n  for (const x of xs) { total += x }\n  return xs.map(v => v * 2).filter(v => v > total)\n}`,
+      ],
+      [
+        'object + destructuring',
+        `function f(o) {\n  const { a, b } = o\n  return { ...o, sum: a + b }\n}`,
+      ],
+    ]
+    for (const [label, src] of jsSnippets) {
+      it(`accepts plain JS: ${label}`, () => {
+        expect(() => tjs(`TjsCompat\n${src}`)).not.toThrow()
+      })
+    }
+  })
+})

package/src/lang/transpiler.ts

@@ -16,6 +16,14 @@ export { transpile, ajs, tjs, createAgent, getToolDefinitions } from './core'
 // Parser
 export { parse, preprocess, extractTDoc } from './parser'
 
+// Dialect resolution for file-based tooling (extension → dialect)
+export {
+  dialectForFilename,
+  sourceKindForFilename,
+  type Dialect,
+  type SourceKind,
+} from './dialect'
+
 // AST emitter
 export { transformFunction } from './emitters/ast'
 

package/src/lang/types.ts

@@ -225,6 +225,21 @@ export interface TransformContext {
   filename: string
   /** Options */
   options: TranspileOptions
+  /**
+   * Helper functions (top-level functions declared before the entry function).
+   * Calls to these names emit `callLocal` instead of treating them as atom calls.
+   */
+  helpers?: Map<string, any /* FunctionDeclaration */>
+  /**
+   * Cache of transformed helper bodies. Lazily populated as helpers are
+   * referenced from the entry function (or from other helpers).
+   */
+  helperSteps?: Map<string, { steps: any[]; paramNames: string[] }>
+  /**
+   * Names of helpers currently being transformed. Used to detect direct or
+   * transitive recursion.
+   */
+  helperTransforming?: Set<string>
 }
 
 /** Create a child context for nested scopes */
@@ -239,6 +254,9 @@ export function createChildContext(parent: TransformContext): TransformContext {
     source: parent.source,
     filename: parent.filename,
     options: parent.options,
+    helpers: parent.helpers,
+    helperSteps: parent.helperSteps,
+    helperTransforming: parent.helperTransforming,
   }
 }
 

package/src/lang/wasm.test.ts

@@ -1901,8 +1901,14 @@ describe('module consolidation (Phase 0.5)', () => {
 
       const result = compileBlocksToModule(blocks)
       expect(result.exports).toHaveLength(2)
-      expect(result.exports[0]).toMatchObject({ id: 'b0', exportName: 'compute_0' })
-      expect(result.exports[1]).toMatchObject({ id: 'b1', exportName: 'compute_1' })
+      expect(result.exports[0]).toMatchObject({
+        id: 'b0',
+        exportName: 'compute_0',
+      })
+      expect(result.exports[1]).toMatchObject({
+        id: 'b1',
+        exportName: 'compute_1',
+      })
 
       // Instantiate and confirm both exports work
       const instance = await instantiateWasm(result.bytes)
@@ -2117,10 +2123,8 @@ function dbl(arr: Float32Array, len: 0) {
         buf[1] = 2
         buf[2] = 3
         buf[3] = 4
-
         ;(globalThis as any).__test_inc(buf, 4) // [2, 3, 4, 5]
         expect(Array.from(buf)).toEqual([2, 3, 4, 5])
-
         ;(globalThis as any).__test_dbl(buf, 4) // [4, 6, 8, 10]
         expect(Array.from(buf)).toEqual([4, 6, 8, 10])
       } finally {
@@ -2313,14 +2317,20 @@ describe('boundary distribution form (Phase 4)', () => {
   async function dynamicImportLibrary(transpiled: string): Promise<any> {
     const { tmpdir } = await import('node:os')
     const { join } = await import('node:path')
-    const { writeFileSync, unlinkSync } = await import('node:fs')
+    const { writeFileSync, unlinkSync, realpathSync } = await import('node:fs')
+    const { pathToFileURL } = await import('node:url')
     const path = join(
       tmpdir(),
       `tjs-lib-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.mjs`
     )
     writeFileSync(path, transpiled)
+    // Resolve macOS /var → /private/var symlink and use file:// URL — bun's
+    // resolver in subsequent test cases (after a `new Function(emittedCode)`
+    // execution earlier in the same file) fails on bare absolute paths with
+    // "Cannot find module ... from ''". This form is robust to that state.
+    const url = pathToFileURL(realpathSync(path)).href
     try {
-      const mod = await import(path)
+      const mod = await import(url)
       // Wait for the async wasm bootstrap inside the module to finish.
       // The bootstrap runs as a top-level IIFE; instantiation is async.
       await new Promise((r) => setTimeout(r, 100))
@@ -2384,9 +2394,7 @@ export wasm function mul(a: f64, b: f64): f64 { return a * b }
     // Both should produce the same numeric results.
     const { tjs } = await import('./index')
     const { createRuntime } = await import('./runtime')
-    const { ModuleLoader, inMemoryFileSystem } = await import(
-      './module-loader'
-    )
+    const { ModuleLoader, inMemoryFileSystem } = await import('./module-loader')
 
     const librarySource = `
 export wasm function dot3(
@@ -2568,9 +2576,7 @@ function compute(x: 0.0): 0.0 {
     expect(result.code).toContain('globalThis.__tjs_wasm_fast(a)')
     // The remaining import keeps `slow` only
     expect(result.code).toMatch(/import\s*\{\s*slow\s*\}\s*from/)
-    expect(result.code).not.toMatch(
-      /import\s*\{\s*fast\s*,\s*slow\s*\}\s*from/
-    )
+    expect(result.code).not.toMatch(/import\s*\{\s*fast\s*,\s*slow\s*\}\s*from/)
   })
 
   it('composes multiple wasm functions from one library', async () => {
@@ -3046,9 +3052,7 @@ wasm function isOdd(n: i32): f64 {
     // inner loop.
     const { tjs } = await import('./index')
     const { createRuntime } = await import('./runtime')
-    const { ModuleLoader, inMemoryFileSystem } = await import(
-      './module-loader'
-    )
+    const { ModuleLoader, inMemoryFileSystem } = await import('./module-loader')
 
     const loader = new ModuleLoader({
       fs: inMemoryFileSystem({
@@ -3162,7 +3166,9 @@ wasm function caller(): f64 {
 `
     const result = tjs(source, { runTests: false })
     // caller fails because takesTwo gets one arg instead of two
-    const callerResult = result.wasmCompiled!.find((b) => b.id === '__tjs_wasm_caller')
+    const callerResult = result.wasmCompiled!.find(
+      (b) => b.id === '__tjs_wasm_caller'
+    )
     expect(callerResult).toBeDefined()
     expect(callerResult!.success).toBe(false)
     expect(callerResult!.error).toMatch(/takesTwo expects 2 arguments, got 1/)

package/src/linalg/linalg.test.ts

@@ -14,9 +14,10 @@
  */
 
 import { describe, it, expect } from 'bun:test'
-import { readFileSync } from 'node:fs'
+import { readFileSync, realpathSync } from 'node:fs'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
+import { pathToFileURL } from 'node:url'
 import { writeFileSync, unlinkSync } from 'node:fs'
 
 const LINALG_PATH = join(import.meta.dir, 'index.tjs')
@@ -41,8 +42,13 @@ async function dynamicImportLibrary(transpiled: string): Promise<any> {
     `linalg-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.mjs`
   )
   writeFileSync(path, transpiled)
+  // Resolve macOS /var → /private/var symlink and use file:// URL — bun's
+  // resolver in subsequent test cases (after a `new Function(emittedCode)`
+  // execution earlier in the same file) fails on bare absolute paths with
+  // "Cannot find module ... from ''". This form is robust to that state.
+  const url = pathToFileURL(realpathSync(path)).href
   try {
-    const mod = await import(path)
+    const mod = await import(url)
     // Wait for the async wasm bootstrap inside the module to finish
     await new Promise((r) => setTimeout(r, 100))
     return mod
@@ -203,8 +209,14 @@ function cosine(a, b, n) {
       // Orthogonal vectors → cosine 0
       const ox = wasmBuffer(Float32Array, 4)
       const oy = wasmBuffer(Float32Array, 4)
-      ox[0] = 1; ox[1] = 0; ox[2] = 0; ox[3] = 0
-      oy[0] = 0; oy[1] = 1; oy[2] = 0; oy[3] = 0
+      ox[0] = 1
+      ox[1] = 0
+      ox[2] = 0
+      ox[3] = 0
+      oy[0] = 0
+      oy[1] = 1
+      oy[2] = 0
+      oy[3] = 0
       const ortho = (globalThis as any).__test_cosine(ox, oy, 4)
       expect(ortho).toBeCloseTo(0, 4)
     } finally {

package/src/linalg/vector-search.bench.test.ts

@@ -30,10 +30,7 @@ import { describe, it, expect } from 'bun:test'
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 
-const LINALG_SOURCE = readFileSync(
-  join(import.meta.dir, 'index.tjs'),
-  'utf8'
-)
+const LINALG_SOURCE = readFileSync(join(import.meta.dir, 'index.tjs'), 'utf8')
 
 // The inline baseline — single wasm{} block computing dot, magA, magB
 // together. Mirrors what guides/examples/tjs/wasm-vector-search.md does.
@@ -161,7 +158,12 @@ async function loadVariant(
   fnName: string,
   varName: string
 ): Promise<{
-  search: (corpus: Float32Array, query: Float32Array, count: number, dim: number) => number
+  search: (
+    corpus: Float32Array,
+    query: Float32Array,
+    count: number,
+    dim: number
+  ) => number
   wasmBuffer: (Ctor: any, len: number) => any
 }> {
   await new Function(
@@ -296,13 +298,28 @@ describe('Canonical demo: vector-search across three forms', () => {
         const warmCount = Math.min(100, cfg.count)
         for (let w = 0; w < 3; w++) {
           inline.search(inlineCorpus, inlineQuery, warmCount, cfg.dim)
-          composedJs.search(composedJsCorpus, composedJsQuery, warmCount, cfg.dim)
-          composedWasm.search(composedWasmCorpus, composedWasmQuery, warmCount, cfg.dim)
+          composedJs.search(
+            composedJsCorpus,
+            composedJsQuery,
+            warmCount,
+            cfg.dim
+          )
+          composedWasm.search(
+            composedWasmCorpus,
+            composedWasmQuery,
+            warmCount,
+            cfg.dim
+          )
         }
 
         // Time inline
         const inlineStart = performance.now()
-        const inlineIdx = inline.search(inlineCorpus, inlineQuery, cfg.count, cfg.dim)
+        const inlineIdx = inline.search(
+          inlineCorpus,
+          inlineQuery,
+          cfg.count,
+          cfg.dim
+        )
         const inlineMs = performance.now() - inlineStart
 
         // Time composed JS-outer-loop
@@ -352,9 +369,13 @@ describe('Canonical demo: vector-search across three forms', () => {
         const jsRatio = t.composedJsMs / t.inlineMs
         const wasmRatio = t.composedWasmMs / t.inlineMs
         console.log(
-          `  ${t.label.padEnd(12)} | ${t.inlineMs.toFixed(2).padStart(8)} | ${t.composedJsMs
+          `  ${t.label.padEnd(12)} | ${t.inlineMs
+            .toFixed(2)
+            .padStart(8)} | ${t.composedJsMs
+            .toFixed(2)
+            .padStart(11)} | ${jsRatio
             .toFixed(2)
-            .padStart(11)} | ${jsRatio.toFixed(2).padStart(6)}x | ${t.composedWasmMs
+            .padStart(6)}x | ${t.composedWasmMs
             .toFixed(2)
             .padStart(13)} | ${wasmRatio.toFixed(2).padStart(5)}x`
         )