tjs-lang 0.6.19 → 0.6.26

package/src/lang/emitters/dts.test.ts

@@ -364,6 +364,28 @@ export class Counter {
     expect(dts).not.toContain('for(')
     expect(dts).not.toContain('while(')
   })
+
+  it('should not emit onstructor (constructor with missing c)', () => {
+    const source = `
+export class Foo {
+  constructor(x: 0) {
+    this.x = x
+  }
+
+  bar() {
+    return this.x
+  }
+}
+`
+    const result = transpileToJS(source, { runTests: false })
+    const dts = generateDTS(result, source)
+
+    // constructor should appear exactly once, correctly spelled
+    const ctorMatches = dts.match(/constructor/g)
+    expect(ctorMatches).toHaveLength(1)
+    expect(dts).toContain('constructor(x: number)')
+    expect(dts).toContain('bar(')
+  })
 })
 
 describe('generateDTS — Type declarations', () => {

package/src/lang/emitters/dts.ts

@@ -331,7 +331,11 @@ function detectClasses(source: string): Map<string, ClassInfo> {
           const methodMatch = classBody.slice(pos).match(/^(\w+)\s*\(/)
           if (methodMatch) {
             const name = methodMatch[1]
-            if (name !== 'constructor' && name !== 'get' && name !== 'set') {
+            if (name === 'constructor' || name === 'get' || name === 'set') {
+              // Skip past the keyword to avoid re-matching a suffix
+              pos += name.length
+              continue
+            } else {
               // Find matching close paren
               const parenStart = pos + methodMatch[0].length - 1
               let depth = 1

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

@@ -5,6 +5,7 @@
  */
 
 import { transformExtensionCalls } from '../parser'
+import { installRuntime } from '../runtime'
 import type { TypeDescriptor } from '../types'
 import type { ExtractedTest, ExtractedMock } from '../tests'
 
@@ -299,15 +300,12 @@ export function stripModuleSyntax(code: string): string {
 export function stripTjsPreamble(code: string): string {
   // Remove the __tjs runtime setup lines:
   // const __tjs = globalThis.__tjs?.createRuntime?.() ?? globalThis.__tjs;
-  // const { Is, IsNot } = __tjs ?? {};
+  // const { Is, IsNot, Eq, NotEq } = __tjs ?? {};
   let result = code.replace(
     /^const __tjs = globalThis\.__tjs\?\.createRuntime\?\.\(\) \?\? globalThis\.__tjs;\n?/m,
     ''
   )
-  result = result.replace(
-    /^const \{ (?:Is|IsNot|Is, IsNot) \} = __tjs \?\? \{\};\n?/m,
-    ''
-  )
+  result = result.replace(/^const \{ [\w, ]+ \} = __tjs \?\? \{\};\n?/m, '')
   return result
 }
 
@@ -333,10 +331,7 @@ function buildResolvedImportsCode(
 
   for (const [specifier, moduleCode] of Object.entries(resolvedImports)) {
     // Strip module syntax from the imported code too (it may have exports)
-    let cleanCode = stripModuleSyntax(moduleCode)
-    // Strip __tjs preamble to avoid duplicate declarations
-    // (test execution context provides its own __tjs stub)
-    cleanCode = stripTjsPreamble(cleanCode)
+    const cleanCode = stripModuleSyntax(moduleCode)
 
     lines.push(`// Resolved import: ${specifier}`)
     lines.push(cleanCode)
@@ -554,9 +549,9 @@ export function runAllTests(
     })
 
   // Strip import/export for test execution (can't use modules in new Function)
-  let executableCode = stripModuleSyntax(transpiledCode)
+  const executableCode = stripModuleSyntax(transpiledCode)
   // Strip __tjs preamble - test context provides its own stub
-  executableCode = stripTjsPreamble(executableCode)
+  // Real runtime installed via installRuntime() — preamble finds it via globalThis.__tjs
 
   // Build resolved imports code - inject imported module code into execution context
   const importedCode = buildResolvedImportsCode(resolvedImports)
@@ -619,12 +614,11 @@ export function runAllTests(
     )
     .join('\n')
 
-  // TJS stub setup/restore
+  // Install real TJS runtime for test execution
+  installRuntime()
+
   const tjsStub = `
     const __saved_tjs = globalThis.__tjs;
-    class __MonadicError extends Error { constructor(m,p,e,a,c){super(m);this.name='MonadicError';this.path=p;this.expected=e;this.actual=a;this.callStack=c;} }
-    const __stub_tjs = { version: '0.0.0', MonadicError: __MonadicError, pushStack: () => {}, popStack: () => {}, getStack: () => [], typeError: (path, expected, value) => new __MonadicError(\`Type error at \${path}: expected \${expected}\`, path, expected, typeof value), createRuntime: function() { return this; } };
-    globalThis.__tjs = __stub_tjs;
   `
   const tjsRestore = `globalThis.__tjs = __saved_tjs;`
 
@@ -815,9 +809,9 @@ function runTestBlocks(
   const results: TestResult[] = []
 
   // Strip import/export for test execution (can't use modules in new Function)
-  let executableCode = stripModuleSyntax(transpiledCode)
+  const executableCode = stripModuleSyntax(transpiledCode)
   // Strip __tjs preamble - test context provides its own stub
-  executableCode = stripTjsPreamble(executableCode)
+  // Real runtime installed via installRuntime() — preamble finds it via globalThis.__tjs
 
   // Build resolved imports code - inject imported module code into execution context
   const importedCode = buildResolvedImportsCode(resolvedImports)
@@ -1176,9 +1170,9 @@ function runSignatureTest(
   const description = `${funcName} signature example`
 
   // Strip import/export for test execution (can't use modules in new Function)
-  let executableCode = stripModuleSyntax(transpiledCode)
+  const executableCode = stripModuleSyntax(transpiledCode)
   // Strip __tjs preamble - test context provides its own stub
-  executableCode = stripTjsPreamble(executableCode)
+  // Real runtime installed via installRuntime() — preamble finds it via globalThis.__tjs
 
   // Build resolved imports code - inject imported module code into execution context
   const importedCode = buildResolvedImportsCode(resolvedImports)

package/src/lang/emitters/js.ts

@@ -787,20 +787,52 @@ export function transpileToJS(
   const needsStack = code.includes('__tjs.pushStack(')
   const needsIs = code.includes('Is(')
   const needsIsNot = code.includes('IsNot(')
+  const needsEq = code.includes('Eq(')
+  const needsNotEq = code.includes('NotEq(')
+  // Type system constructors (from Type/Generic/FunctionPredicate/Enum/Union declarations)
+  const needsType = /\bType\(/.test(code)
+  const needsGeneric = /\bGeneric\(/.test(code)
+  const needsFunctionPredicate = /\bFunctionPredicate\(/.test(code)
+  const needsEnum = /\bEnum\(/.test(code)
+  const needsUnion = /\bUnion\(/.test(code)
   const needsSafeEval = preprocessed.tjsModes.tjsSafeEval
 
-  if (needsTypeError || needsStack || needsIs || needsIsNot || needsSafeEval) {
+  const needsRuntime =
+    needsTypeError ||
+    needsStack ||
+    needsIs ||
+    needsIsNot ||
+    needsEq ||
+    needsNotEq ||
+    needsType ||
+    needsGeneric ||
+    needsFunctionPredicate ||
+    needsEnum ||
+    needsUnion ||
+    needsSafeEval
+
+  if (needsRuntime) {
     // Create isolated runtime instance for this module
     // Falls back to shared global if createRuntime not available
     let preamble =
       'const __tjs = globalThis.__tjs?.createRuntime?.() ?? globalThis.__tjs;\n'
 
-    // Add destructured imports for Is/IsNot if used
-    if (needsIs || needsIsNot) {
-      const imports = [needsIs && 'Is', needsIsNot && 'IsNot']
-        .filter(Boolean)
-        .join(', ')
-      preamble += `const { ${imports} } = __tjs ?? {};\n`
+    // Add destructured imports for runtime functions if used
+    const runtimeImports = [
+      needsIs && 'Is',
+      needsIsNot && 'IsNot',
+      needsEq && 'Eq',
+      needsNotEq && 'NotEq',
+      needsType && 'Type',
+      needsGeneric && 'Generic',
+      needsFunctionPredicate && 'FunctionPredicate',
+      needsEnum && 'Enum',
+      needsUnion && 'Union',
+    ]
+      .filter(Boolean)
+      .join(', ')
+    if (runtimeImports) {
+      preamble += `const { ${runtimeImports} } = __tjs ?? {};\n`
     }
 
     code = preamble + code

package/src/lang/parser-transforms.ts

@@ -764,7 +764,7 @@ export function transformEqualityToStructural(source: string): string {
   let result = source
   for (let k = equalityOps.length - 1; k >= 0; k--) {
     const { pos, op } = equalityOps[k]
-    const funcName = op === '==' ? 'Is' : 'IsNot'
+    const funcName = op === '==' ? 'Eq' : 'NotEq'
 
     // Find left operand boundary
     const leftBoundary = findLeftOperandBoundary(result, pos)
@@ -827,8 +827,8 @@ function findLeftOperandBoundary(source: string, opPos: number): number {
       continue
     }
 
-    // Track depth of parens/brackets (reversed since we're going backwards)
-    if (char === ')' || char === ']') {
+    // Track depth of parens/brackets/braces (reversed since we're going backwards)
+    if (char === ')' || char === ']' || char === '}') {
       depth++
       i--
       continue
@@ -843,6 +843,15 @@ function findLeftOperandBoundary(source: string, opPos: number): number {
       // The expression starts AFTER it, not including it
       return i + 1
     }
+    if (char === '{') {
+      if (depth > 0) {
+        depth--
+        i--
+        continue
+      }
+      // Opening brace at depth 0 — could be block statement boundary
+      return i + 1
+    }
 
     // Inside nested expression - keep scanning
     if (depth > 0) {
@@ -852,7 +861,7 @@ function findLeftOperandBoundary(source: string, opPos: number): number {
 
     // At depth 0 - check for expression boundaries
     // Statement delimiters
-    if (char === ';' || char === '{' || char === '}') {
+    if (char === ';') {
       return i + 1
     }
 
@@ -880,11 +889,15 @@ function findLeftOperandBoundary(source: string, opPos: number): number {
             'delete',
             'await',
             'yield',
-            'new',
           ].includes(word)
         ) {
           return wordEnd
         }
+        // 'new' is part of the operand (new Foo() == bar),
+        // so include it by continuing the scan
+        if (word === 'new') {
+          return wordStart
+        }
       }
     }
 

package/src/lang/roundtrip.test.ts

@@ -16,7 +16,7 @@ import { Is, IsNot, MonadicError } from './runtime'
 
 // Set up the minimal runtime needed for transpiled code
 beforeAll(() => {
-  ;(globalThis as any).__tjs = {
+  (globalThis as any).__tjs = {
     Is,
     IsNot,
     pushStack: () => {},

package/src/lang/runtime.ts

@@ -381,6 +381,15 @@ export function Is(a: unknown, b: unknown): boolean {
     return (b as any).Equals(a)
   }
 
+  // Unwrap boxed primitives (new String, new Number, new Boolean)
+  // so structural equality honors the intent: new String('foo') == 'foo'
+  if (a instanceof String || a instanceof Number || a instanceof Boolean) {
+    a = a.valueOf()
+  }
+  if (b instanceof String || b instanceof Number || b instanceof Boolean) {
+    b = b.valueOf()
+  }
+
   // Identical references or primitives
   if (a === b) return true
 
@@ -401,6 +410,36 @@ export function Is(a: unknown, b: unknown): boolean {
   // Primitives that aren't === are not equal
   if (typeof a !== 'object') return false
 
+  // Sets — order-independent element equality
+  if (a instanceof Set && b instanceof Set) {
+    if ((a as Set<unknown>).size !== (b as Set<unknown>).size) return false
+    for (const v of a as Set<unknown>) {
+      if (!(b as Set<unknown>).has(v)) return false
+    }
+    return true
+  }
+
+  // Maps — key-value structural equality
+  if (a instanceof Map && b instanceof Map) {
+    if ((a as Map<unknown, unknown>).size !== (b as Map<unknown, unknown>).size)
+      return false
+    for (const [k, v] of a as Map<unknown, unknown>) {
+      if (!(b as Map<unknown, unknown>).has(k)) return false
+      if (!Is(v, (b as Map<unknown, unknown>).get(k))) return false
+    }
+    return true
+  }
+
+  // Dates — compare timestamps
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime()
+  }
+
+  // RegExps — compare string representation
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.toString() === b.toString()
+  }
+
   // Arrays
   if (Array.isArray(a) && Array.isArray(b)) {
     if (a.length !== b.length) return false
@@ -424,6 +463,47 @@ export function IsNot(a: unknown, b: unknown): boolean {
   return !Is(a, b)
 }
 
+/**
+ * Honest equality — what == should have been.
+ *
+ * Like === but fixes the two remaining footguns:
+ * 1. Unwraps boxed primitives: new String('foo') Eq 'foo' → true
+ * 2. Nullish equality: null Eq undefined → true
+ *
+ * Does NOT do deep structural comparison on objects/arrays (that's O(n)).
+ * Use Is/IsNot for explicit structural comparison when you need it.
+ *
+ * Usage: `a == b` with TjsEquals transforms to `Eq(a, b)`
+ */
+export function Eq(a: unknown, b: unknown): boolean {
+  // Unwrap boxed primitives
+  if (a instanceof String || a instanceof Number || a instanceof Boolean) {
+    a = a.valueOf()
+  }
+  if (b instanceof String || b instanceof Number || b instanceof Boolean) {
+    b = b.valueOf()
+  }
+
+  // Identical references or primitives
+  if (a === b) return true
+
+  // null and undefined are equal to each other
+  if ((a === null || a === undefined) && (b === null || b === undefined)) {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Honest inequality — what != should have been.
+ *
+ * Usage: `a != b` with TjsEquals transforms to `NotEq(a, b)`
+ */
+export function NotEq(a: unknown, b: unknown): boolean {
+  return !Eq(a, b)
+}
+
 /**
  * Check if a value is a TJS error
  */
@@ -739,7 +819,7 @@ export function wrap<T extends (...args: any[]) => any>(
   meta: FunctionMeta
 ): T {
   // Always attach metadata for introspection/autocomplete
-  ;(fn as any).__tjs = meta
+  (fn as any).__tjs = meta
 
   // Determine if we need a wrapper at all
   // Polymorphic dispatchers handle their own routing — no wrapping needed
@@ -1199,6 +1279,9 @@ export function createRuntime() {
     // Structural equality
     Is,
     IsNot,
+    // Honest equality (== / != with TjsEquals)
+    Eq,
+    NotEq,
     tjsEquals,
     // Extensions
     registerExtension: instanceRegisterExtension,
@@ -1272,9 +1355,12 @@ export const runtime = {
   LegalDate,
   TPair,
   TRecord,
-  // Structural equality (used by == and != in TJS)
+  // Structural equality (used by Is/IsNot operators)
   Is,
   IsNot,
+  // Honest equality (used by == and != with TjsEquals)
+  Eq,
+  NotEq,
 }
 
 /**

package/src/lang/wasm.ts

@@ -2130,7 +2130,7 @@ export async function registerWasmBlock(block: WasmBlock): Promise<boolean> {
   }
 
   // Register globally
-  ;(globalThis as any)[block.id] = result.fn
+  (globalThis as any)[block.id] = result.fn
 
   return true
 }

package/dist/bin/benchmarks.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env bun
-/**
- * TJS Benchmark Runner
- *
- * Runs performance benchmarks and generates benchmarks.md
- *
- * Usage: bun bin/benchmarks.ts
- */
-export {};

package/dist/bin/dev.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/bin/docs.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/bin/select-local-models.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/examples/modules/dist/main.d.ts

@@ -1,34 +0,0 @@
-export function calculate(x?: number, y?: number): any;
-export namespace calculate {
-    namespace __tjs {
-        namespace params {
-            namespace x {
-                export namespace type {
-                    let kind: string;
-                }
-                export let required: boolean;
-                let _default: null;
-                export { _default as default };
-            }
-            namespace y {
-                export namespace type_1 {
-                    let kind_1: string;
-                    export { kind_1 as kind };
-                }
-                export { type_1 as type };
-                let required_1: boolean;
-                export { required_1 as required };
-                let _default_1: null;
-                export { _default_1 as default };
-            }
-        }
-        namespace returns {
-            export namespace type_2 {
-                let kind_2: string;
-                export { kind_2 as kind };
-            }
-            export { type_2 as type };
-        }
-        let source: string;
-    }
-}

package/dist/examples/modules/dist/math.d.ts

@@ -1,120 +0,0 @@
-export function add(a?: number, b?: number): any;
-export namespace add {
-    namespace __tjs {
-        namespace params {
-            namespace a {
-                export namespace type {
-                    let kind: string;
-                }
-                export let required: boolean;
-                let _default: null;
-                export { _default as default };
-            }
-            namespace b {
-                export namespace type_1 {
-                    let kind_1: string;
-                    export { kind_1 as kind };
-                }
-                export { type_1 as type };
-                let required_1: boolean;
-                export { required_1 as required };
-                let _default_1: null;
-                export { _default_1 as default };
-            }
-        }
-        namespace returns {
-            export namespace type_2 {
-                let kind_2: string;
-                export { kind_2 as kind };
-            }
-            export { type_2 as type };
-        }
-        let source: string;
-    }
-}
-export function subtract(a?: number, b?: number): any;
-export namespace subtract {
-    export namespace __tjs_1 {
-        export namespace params_1 {
-            export namespace a_1 {
-                export namespace type_3 {
-                    let kind_3: string;
-                    export { kind_3 as kind };
-                }
-                export { type_3 as type };
-                let required_2: boolean;
-                export { required_2 as required };
-                let _default_2: null;
-                export { _default_2 as default };
-            }
-            export { a_1 as a };
-            export namespace b_1 {
-                export namespace type_4 {
-                    let kind_4: string;
-                    export { kind_4 as kind };
-                }
-                export { type_4 as type };
-                let required_3: boolean;
-                export { required_3 as required };
-                let _default_3: null;
-                export { _default_3 as default };
-            }
-            export { b_1 as b };
-        }
-        export { params_1 as params };
-        export namespace returns_1 {
-            export namespace type_5 {
-                let kind_5: string;
-                export { kind_5 as kind };
-            }
-            export { type_5 as type };
-        }
-        export { returns_1 as returns };
-        let source_1: string;
-        export { source_1 as source };
-    }
-    export { __tjs_1 as __tjs };
-}
-export function multiply(a?: number, b?: number): any;
-export namespace multiply {
-    export namespace __tjs_2 {
-        export namespace params_2 {
-            export namespace a_2 {
-                export namespace type_6 {
-                    let kind_6: string;
-                    export { kind_6 as kind };
-                }
-                export { type_6 as type };
-                let required_4: boolean;
-                export { required_4 as required };
-                let _default_4: null;
-                export { _default_4 as default };
-            }
-            export { a_2 as a };
-            export namespace b_2 {
-                export namespace type_7 {
-                    let kind_7: string;
-                    export { kind_7 as kind };
-                }
-                export { type_7 as type };
-                let required_5: boolean;
-                export { required_5 as required };
-                let _default_5: null;
-                export { _default_5 as default };
-            }
-            export { b_2 as b };
-        }
-        export { params_2 as params };
-        export namespace returns_2 {
-            export namespace type_8 {
-                let kind_8: string;
-                export { kind_8 as kind };
-            }
-            export { type_8 as type };
-        }
-        export { returns_2 as returns };
-        let source_2: string;
-        export { source_2 as source };
-    }
-    export { __tjs_2 as __tjs };
-}