tjs-lang 0.7.6 → 0.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tjs-lang",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Type-safe JavaScript dialect with runtime validation, sandboxed VM execution, and AI agent orchestration. Transpiles TypeScript to validated JS with fuel-metered execution for untrusted code.",
   "keywords": [
     "typescript",

package/src/lang/codegen.test.ts

@@ -947,6 +947,46 @@ function isEqual(! a: null, b: null):! true { return a == b }`
       // No coercion: 0 != '' (unlike JS ==)
       expect(isEqual(0, '')).toBe(false)
     })
+
+    it('typeof transform skips string/template/comment bodies (regression)', () => {
+      // Previously the typeof→TypeOf rewrite was a naive regex that also
+      // mangled `'typeof x'` inside string literals. The replacement is now
+      // tokenizer-aware.
+      const tjsSource = `
+const label = 'typeof null is null'
+const tpl = \`type marker: typeof x\`
+// typeof y
+const t = typeof null
+`
+      const { code } = tjs(tjsSource)
+      expect(code).toContain("'typeof null is null'")
+      expect(code).toContain('`type marker: typeof x`')
+      expect(code).toContain('TypeOf(null)')
+    })
+
+    it('applies TjsEquals to test/mock bodies (regression)', () => {
+      // Native TJS has TjsEquals on by default. Test bodies are extracted as
+      // raw text before parsing, so == inside them must also be transformed.
+      const tjsSource = `const foo = '' == false
+
+test 'top-level == is transformed' {
+  expect(foo).toBe(false)
+}
+
+test '== inside test block is transformed' {
+  expect('' == false).toBe(false)
+  expect('' != false).toBe(true)
+}
+
+test '=== identity is preserved' {
+  expect('' === false).toBe(false)
+  expect(0 === 0).toBe(true)
+}
+`
+      const { testResults } = tjs(tjsSource, { runTests: 'report' })
+      const failures = (testResults || []).filter((r) => !r.passed)
+      expect(failures).toEqual([])
+    })
   })
 
   describe('TjsStandard (ASI protection)', () => {

package/src/lang/emitters/js-tests.ts

@@ -657,6 +657,12 @@ export function runAllTests(
   // Build mock setup
   const mockSetup = mocks.map((m) => m.body).join('\n')
 
+  // Test bodies may reference Is/IsNot/Eq/NotEq/TypeOf — these come from the
+  // == / != / typeof source-level transforms applied to test bodies in js.ts.
+  // The module's own destructuring may not include them (if the module never
+  // uses ==), so each test block re-destructures into its own block scope.
+  const testRuntimeImports = `const { Is, IsNot, Eq, NotEq, TypeOf } = globalThis.__tjs ?? {};`
+
   // Build test execution code that runs all tests in sequence
   const testBodies = tests
     .map((t, i) => {
@@ -668,6 +674,7 @@ export function runAllTests(
       return `
     // Test ${i}: ${t.description}
     try {
+      ${testRuntimeImports}
       ${body}
       __testResults.push({ idx: ${i}, passed: true });
     } catch (e) {

package/src/lang/emitters/js.ts

@@ -53,7 +53,12 @@ import {
   extractTDoc,
   preprocess,
   transformExtensionCalls,
+  stripLineComments,
 } from '../parser'
+import {
+  transformEqualityToStructural,
+  transformIsOperators,
+} from '../parser-transforms'
 import type { TypeDescriptor, ParameterDescriptor } from '../types'
 import { inferTypeFromValue, parseParameter } from '../inference'
 import { extractTests } from '../tests'
@@ -576,6 +581,10 @@ export function transpileToJS(
   } = options
   const warnings: string[] = []
 
+  // Strip single-line comments early — apostrophes in comments (e.g. "don't")
+  // confuse brace matching in test extraction and other transforms
+  source = stripLineComments(source)
+
   // Extract source file annotation if present (from TS transpilation)
   const sourceFileAnnotation = extractSourceFileAnnotation(source)
   const effectiveFilename = sourceFileAnnotation || filename
@@ -600,6 +609,23 @@ export function transpileToJS(
   // Preprocess source (handles TJS syntax transformations)
   const preprocessed = preprocess(cleanSource)
 
+  // Apply the same source-level equality transforms to extracted test/mock
+  // bodies so they observe the module's TJS semantics (e.g. structural ==).
+  // Test bodies are extracted as raw text before parse(), so they would
+  // otherwise run with native JS == coercion regardless of TjsEquals mode.
+  for (const t of tests) {
+    t.body = transformIsOperators(t.body)
+    if (preprocessed.tjsModes.tjsEquals) {
+      t.body = transformEqualityToStructural(t.body)
+    }
+  }
+  for (const m of mocks) {
+    m.body = transformIsOperators(m.body)
+    if (preprocessed.tjsModes.tjsEquals) {
+      m.body = transformEqualityToStructural(m.body)
+    }
+  }
+
   // Build types map for all functions
   const allTypes: Record<string, TJSTypeInfo> = {}
 

package/src/lang/features.test.ts

@@ -153,6 +153,28 @@ describe('Inline Tests', () => {
     expect(result.tests[0].body).toContain('assert')
   })
 
+  it('should extract test descriptions containing other quote types', () => {
+    // Regression: previously the regex excluded all quote chars from
+    // descriptions, so `test 'has "quotes"' { }` was silently dropped.
+    const result = extractTests(`
+      test 'typeof null is "null"' {
+        assert(true)
+      }
+      test "single 'apostrophe' inside" {
+        assert(true)
+      }
+      test \`backticks with "double" and 'single'\` {
+        assert(true)
+      }
+    `)
+    expect(result.tests.length).toBe(3)
+    expect(result.tests[0].description).toBe('typeof null is "null"')
+    expect(result.tests[1].description).toBe("single 'apostrophe' inside")
+    expect(result.tests[2].description).toBe(
+      `backticks with "double" and 'single'`
+    )
+  })
+
   it('should remove tests from output code', () => {
     const result = extractTests(`
       function add(a, b) { return a + b }

package/src/lang/parser-transforms.ts

@@ -593,6 +593,201 @@ export function insertAsiProtection(source: string): string {
   return result.join('\n')
 }
 
+/**
+ * Replace `typeof X` with `TypeOf(X)` outside string/template/comment/regex bodies.
+ * X may be `ident`, `ident.foo`, `ident?.foo`, etc. Anything that doesn't look
+ * like a simple identifier expression (e.g. `typeof (x + 1)`) is left alone.
+ */
+function transformTypeofKeyword(source: string): string {
+  type Match = { keywordStart: number; operandEnd: number; operand: string }
+  const matches: Match[] = []
+  let i = 0
+  let state: TokenizerState = 'normal'
+  const templateStack: number[] = []
+
+  while (i < source.length) {
+    const char = source[i]
+    const nextChar = source[i + 1]
+
+    switch (state) {
+      case 'single-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === "'") state = 'normal'
+        i++
+        continue
+      case 'double-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '"') state = 'normal'
+        i++
+        continue
+      case 'template-string':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '$' && nextChar === '{') {
+          i += 2
+          templateStack.push(1)
+          state = 'normal'
+          continue
+        }
+        if (char === '`') state = 'normal'
+        i++
+        continue
+      case 'line-comment':
+        if (char === '\n') state = 'normal'
+        i++
+        continue
+      case 'block-comment':
+        if (char === '*' && nextChar === '/') {
+          i += 2
+          state = 'normal'
+          continue
+        }
+        i++
+        continue
+      case 'regex':
+        if (char === '\\' && i + 1 < source.length) {
+          i += 2
+          continue
+        }
+        if (char === '[') {
+          i++
+          while (i < source.length && source[i] !== ']') {
+            if (source[i] === '\\' && i + 1 < source.length) i += 2
+            else i++
+          }
+          if (i < source.length) i++
+          continue
+        }
+        if (char === '/') {
+          i++
+          while (i < source.length && /[gimsuy]/.test(source[i])) i++
+          state = 'normal'
+          continue
+        }
+        i++
+        continue
+      case 'normal':
+        if (templateStack.length > 0) {
+          if (char === '{') {
+            templateStack[templateStack.length - 1]++
+          } else if (char === '}') {
+            templateStack[templateStack.length - 1]--
+            if (templateStack[templateStack.length - 1] === 0) {
+              templateStack.pop()
+              i++
+              state = 'template-string'
+              continue
+            }
+          }
+        }
+        if (char === "'") {
+          i++
+          state = 'single-string'
+          continue
+        }
+        if (char === '"') {
+          i++
+          state = 'double-string'
+          continue
+        }
+        if (char === '`') {
+          i++
+          state = 'template-string'
+          continue
+        }
+        if (char === '/' && nextChar === '/') {
+          i += 2
+          state = 'line-comment'
+          continue
+        }
+        if (char === '/' && nextChar === '*') {
+          i += 2
+          state = 'block-comment'
+          continue
+        }
+        if (char === '/') {
+          let j = i - 1
+          while (j >= 0 && /\s/.test(source[j])) j--
+          const beforeChar = j >= 0 ? source[j] : ''
+          const isRegexContext =
+            !beforeChar ||
+            /[=(!,;:{[&|?+\-*%<>~^]/.test(beforeChar) ||
+            (j >= 5 &&
+              /\b(return|case|throw|in|of|typeof|instanceof|new|delete|void)$/.test(
+                source.slice(Math.max(0, j - 10), j + 1)
+              ))
+          if (isRegexContext) {
+            i++
+            state = 'regex'
+            continue
+          }
+        }
+
+        // Detect `typeof <ident-chain>` — only when preceded by a non-word
+        // boundary and followed by whitespace then an identifier.
+        if (
+          char === 't' &&
+          source.slice(i, i + 6) === 'typeof' &&
+          (i === 0 || !/[\w$]/.test(source[i - 1])) &&
+          /\s/.test(source[i + 6] ?? '')
+        ) {
+          let j = i + 6
+          while (j < source.length && /\s/.test(source[j])) j++
+          if (j < source.length && /[a-zA-Z_$]/.test(source[j])) {
+            const operandStart = j
+            while (j < source.length && /[\w$]/.test(source[j])) j++
+            // Optional `.name` or `?.name` chains
+            while (j < source.length) {
+              if (source[j] === '.' && /[a-zA-Z_$]/.test(source[j + 1] ?? '')) {
+                j++
+                while (j < source.length && /[\w$]/.test(source[j])) j++
+              } else if (
+                source[j] === '?' &&
+                source[j + 1] === '.' &&
+                /[a-zA-Z_$]/.test(source[j + 2] ?? '')
+              ) {
+                j += 2
+                while (j < source.length && /[\w$]/.test(source[j])) j++
+              } else {
+                break
+              }
+            }
+            matches.push({
+              keywordStart: i,
+              operandEnd: j,
+              operand: source.slice(operandStart, j),
+            })
+            i = j
+            continue
+          }
+        }
+        break
+    }
+    i++
+  }
+
+  if (matches.length === 0) return source
+
+  // Apply replacements from end to start so earlier positions remain valid.
+  let result = source
+  for (let k = matches.length - 1; k >= 0; k--) {
+    const m = matches[k]
+    result =
+      result.slice(0, m.keywordStart) +
+      `TypeOf(${m.operand})` +
+      result.slice(m.operandEnd)
+  }
+  return result
+}
+
 /**
  * Transform == and != to Is() and IsNot() calls
  *
@@ -606,11 +801,11 @@ export function insertAsiProtection(source: string): string {
  * 2. Transform from end to start (so positions remain valid)
  */
 export function transformEqualityToStructural(source: string): string {
-  // Transform typeof to TypeOf() — fixes typeof null === 'object'
-  source = source.replace(
-    /\btypeof\s+([a-zA-Z_$][\w$.]*(?:\?\.[\w$]+)*)/g,
-    'TypeOf($1)'
-  )
+  // Transform typeof to TypeOf() — fixes typeof null === 'object'.
+  // Uses the same tokenizer state machine as the equality pass so it skips
+  // string/template/comment/regex bodies (a regex replace would rewrite
+  // 'typeof x' inside string literals).
+  source = transformTypeofKeyword(source)
 
   // First pass: find all == and != positions (outside strings/comments/regex)
   const equalityOps: Array<{ pos: number; op: '==' | '!=' }> = []
@@ -2642,9 +2837,43 @@ export function extractAndRunTests(
         let depth = 1
         let k = bodyStart
 
-        // Find matching closing brace
+        // Find matching closing brace (skip strings and comments)
+        let inStr: string | null = null
+        let escaped = false
         while (k < source.length && depth > 0) {
           const char = source[k]
+          if (escaped) {
+            escaped = false
+            k++
+            continue
+          }
+          if (char === '\\' && inStr) {
+            escaped = true
+            k++
+            continue
+          }
+          if (inStr) {
+            if (char === inStr) inStr = null
+            k++
+            continue
+          }
+          // Line comment — skip to end of line
+          if (char === '/' && source[k + 1] === '/') {
+            const nl = source.indexOf('\n', k)
+            k = nl === -1 ? source.length : nl + 1
+            continue
+          }
+          // Block comment — skip to */
+          if (char === '/' && source[k + 1] === '*') {
+            const end = source.indexOf('*/', k + 2)
+            k = end === -1 ? source.length : end + 2
+            continue
+          }
+          if (char === "'" || char === '"' || char === '`') {
+            inStr = char
+            k++
+            continue
+          }
           if (char === '{') depth++
           else if (char === '}') depth--
           k++

package/src/lang/parser.ts

@@ -56,6 +56,52 @@ import {
 // Re-export transformExtensionCalls for js.ts
 export { transformExtensionCalls } from './parser-transforms'
 
+/**
+ * Strip single-line comments (//) from source.
+ * Replaces comment content with spaces to preserve character offsets.
+ * Skips // inside strings and block comments.
+ */
+export function stripLineComments(source: string): string {
+  let result = ''
+  let i = 0
+  while (i < source.length) {
+    const ch = source[i]
+    // String literals — skip to closing quote
+    if (ch === "'" || ch === '"' || ch === '`') {
+      const quote = ch
+      result += ch
+      i++
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === '\\') {
+          result += source[i++]
+        }
+        if (i < source.length) result += source[i++]
+      }
+      if (i < source.length) result += source[i++] // closing quote
+      continue
+    }
+    // Block comment — pass through (may contain //)
+    if (ch === '/' && source[i + 1] === '*') {
+      const end = source.indexOf('*/', i + 2)
+      const slice = end === -1 ? source.slice(i) : source.slice(i, end + 2)
+      result += slice
+      i += slice.length
+      continue
+    }
+    // Line comment — replace with spaces to preserve offsets
+    if (ch === '/' && source[i + 1] === '/') {
+      const nl = source.indexOf('\n', i)
+      const end = nl === -1 ? source.length : nl
+      result += ' '.repeat(end - i)
+      i = end // leave \n for next iteration
+      continue
+    }
+    result += ch
+    i++
+  }
+  return result
+}
+
 export function preprocess(
   source: string,
   options: PreprocessOptions = {}
@@ -182,6 +228,11 @@ export function preprocess(
     )
   }
 
+  // Strip single-line comments early — they confuse brace matching,
+  // ASI protection, and test extraction (e.g. apostrophes in comments)
+  // Preserves line structure by keeping the newline
+  source = stripLineComments(source)
+
   // TjsStandard mode: insert semicolons to prevent ASI footguns
   // Must happen early before other transformations modify line structure
   if (tjsModes.tjsStandard) {

package/src/lang/tests.ts

@@ -106,15 +106,17 @@ function extractEmbeddedTests(source: string): ExtractedTest[] {
   const tests: ExtractedTest[] = []
 
   // Match: /*test 'description' { ... }*/  or  /*test { ... }*/
+  // Each quote type gets its own alternative so the description can contain
+  // the other quote types (e.g. `test 'typeof null is "null"' {`).
   const embeddedRegex =
-    /\/\*test\s+(['"`])([^'"`]*)\1\s*\{([\s\S]*?)\}\s*\*\/|\/\*test\s*\{([\s\S]*?)\}\s*\*\//g
+    /\/\*test\s+'([^']*)'\s*\{([\s\S]*?)\}\s*\*\/|\/\*test\s+"([^"]*)"\s*\{([\s\S]*?)\}\s*\*\/|\/\*test\s+`([^`]*)`\s*\{([\s\S]*?)\}\s*\*\/|\/\*test\s*\{([\s\S]*?)\}\s*\*\//g
 
   let match
   while ((match = embeddedRegex.exec(source)) !== null) {
-    // Group 2 = description for quoted, group 3 = body for quoted
-    // Group 4 = body for anonymous
-    const desc = match[2] || `embedded test ${tests.length + 1}`
-    const body = (match[3] || match[4] || '').trim()
+    // Groups: 1/3/5 = description for ' " ` ; 2/4/6 = body for ' " ` ; 7 = body for anonymous
+    const desc =
+      match[1] || match[3] || match[5] || `embedded test ${tests.length + 1}`
+    const body = (match[2] || match[4] || match[6] || match[7] || '').trim()
 
     tests.push({
       description: desc,
@@ -145,8 +147,10 @@ export function extractTests(source: string): TestExtractionResult {
   //   test { ... }                   (anonymous test)
   //   test 'description' { ... }     (canonical TJS)
   //   test('description') { ... }    (also valid - parenthesized string is still a string)
+  // Each quote type has its own alternative so the description can contain
+  // the other quote types (e.g. `test 'typeof null is "null"' {`).
   const testRegex =
-    /test\s+(['"`])([^'"`]*)\1\s*\{|test\s*\(\s*(['"`])([^'"`]*)\3\s*\)\s*\{|test\s*\{/g
+    /test\s+'([^']*)'\s*\{|test\s+"([^"]*)"\s*\{|test\s+`([^`]*)`\s*\{|test\s*\(\s*'([^']*)'\s*\)\s*\{|test\s*\(\s*"([^"]*)"\s*\)\s*\{|test\s*\(\s*`([^`]*)`\s*\)\s*\{|test\s*\{/g
   const mockRegex = /mock\s*\{/g
 
   let cleanCode = source
@@ -164,8 +168,17 @@ export function extractTests(source: string): TestExtractionResult {
       continue
     }
 
-    // Description is in group 2 for `test 'desc'`, group 4 for `test('desc')`, or undefined for `test {`
-    const desc = match[2] || match[4] || `test ${tests.length + 1}`
+    // Groups 1/2/3 = `test 'desc'` / `test "desc"` / `test \`desc\``
+    // Groups 4/5/6 = parenthesized variants
+    // No group when description is omitted
+    const desc =
+      match[1] ||
+      match[2] ||
+      match[3] ||
+      match[4] ||
+      match[5] ||
+      match[6] ||
+      `test ${tests.length + 1}`
     const bodyStart = match.index + match[0].length
 
     // Find matching closing brace