feat: rewrite router in tu

Co-authored-by: Codex <codex@openai.com>

Author: mowtwo

.gitignore

@@ -1,6 +1,8 @@
 node_modules/
 dist/
 lib/
+.tu-build/
+.tu-check/
 .turbo/
 coverage/
 *.log

packages/compiler/src/ast.ts

@@ -271,6 +271,8 @@ export interface Param extends Ranged {
   name: string
   /** Type annotation as a raw identifier ('string', 'number'…) — full type AST lands later. */
   type?: string
+  /** True when the parameter was written with a `?` marker, e.g. `opts?: T`. */
+  optional?: boolean
   /** Source byte range of the type expression, when a `: T` annotation exists. */
   typeStart?: number
   typeEnd?: number

packages/compiler/src/codegen.ts

@@ -2510,6 +2510,7 @@ class Codegen {
       // TS's implicit `any`. Forces narrow / cast at use sites; pairs
       // with the M8 `type.as` helper for typed runtime casts.
       if (this.tsMode) {
+        if (p.optional) this.write('?')
         this.write(': ')
         if (p.type !== undefined && p.typeStart !== undefined && p.typeEnd !== undefined) {
           this.mark(p.typeStart, p.typeEnd, () => this.write(p.type!))
@@ -2873,6 +2874,7 @@ class Codegen {
         // with single-file first-call inference for omitted annotations.
         if (this.tsMode) {
           const inferred = this.inferredParamTypes.get(node)?.get(i)
+          if (p.optional) this.write('?')
           this.write(': ')
           if (p.type !== undefined && p.typeStart !== undefined && p.typeEnd !== undefined) {
             this.mark(p.typeStart, p.typeEnd, () => this.write(p.type!))

packages/compiler/src/parser.ts

@@ -2023,11 +2023,9 @@ export class Parser {
     let typeStart: number | undefined
     let typeEnd: number | undefined
     let endOffset = nameTok.end
-    // TS-style optional param: `(name?: T)`. Tu mirrors the syntax — the
-    // `?` is folded into the emitted TS type span so tsserver sees a
-    // proper optional. We append ` | undefined` rather than rewriting
-    // the param name to `name?` since codegen emits the param name in
-    // a JS context where `?` would be a syntax error.
+    // TS-style optional param: `(name?: T)`. Tu mirrors the syntax and
+    // preserves the optional marker for TS emit / declaration generation.
+    // JS emit still writes a plain parameter name.
     let optional = false
     if (this.peek().kind === TokenKind.Question) {
       optional = true
@@ -2037,14 +2035,13 @@ export class Parser {
     if (this.peek().kind === TokenKind.Colon) {
       this.pos++
       const span = this.parseRawTypeUntilParamBoundary()
-      type = optional ? `(${span.text}) | undefined` : span.text
+      type = span.text
       typeStart = span.start
       typeEnd = span.end
       endOffset = span.end
     } else if (optional) {
-      // `name?` with no colon = implicit `unknown | undefined`. Pass the
-      // narrower `undefined` through; tsserver will widen as needed.
-      type = 'undefined'
+      // `name?` with no colon = optional `unknown`.
+      type = 'unknown'
     }
     return type === undefined
       ? {
@@ -2056,6 +2053,7 @@ export class Parser {
         }
       : {
           name: nameTok.text,
+          optional,
           type,
           typeStart,
           typeEnd,

packages/compiler/tests/codegen.test.ts

@@ -182,9 +182,9 @@ describe('codegen', () => {
     expect(js).toContain('((p.a || p.b) && p.c)')
   })
 
-  it('TS-style optional param `name?: T` lowers to `(T) | undefined` in TS-emit', () => {
+  it('TS-style optional param `name?: T` stays optional in TS-emit', () => {
     const ts = compileToTS('export let f = (x: string, y?: boolean) => true')
-    expect(ts).toContain('y: (boolean) | undefined')
+    expect(ts).toContain('y?: boolean')
   })
 
   it('flattens block-bodied lambdas to expression form when single child', () => {

packages/compiler/tests/parser.test.ts

@@ -118,6 +118,17 @@ describe('parser', () => {
     ])
   })
 
+  it('parses optional typed parameters', () => {
+    const tree = ast('let f = (name: string, active?: boolean) => "ok"')
+    const lambda = (tree.body[0] as { value: unknown }).value as {
+      params: { name: string; type?: string; optional?: boolean }[]
+    }
+    expect(lambda.params).toMatchObject([
+      { name: 'name', type: 'string' },
+      { name: 'active', type: 'boolean', optional: true },
+    ])
+  })
+
   it('parses tag-call with props and nested children', () => {
     const tree = ast(`
       let App = () => {

packages/router/package.json

@@ -36,13 +36,17 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run",
-    "check": "tsc --noEmit -p tsconfig.json",
-    "clean": "rm -rf dist *.tsbuildinfo"
+    "build": "node scripts/build.mjs",
+    "test": "pnpm run build && vitest run",
+    "check": "node scripts/check.mjs",
+    "clean": "rm -rf dist .tu-build .tu-check *.tsbuildinfo"
   },
   "dependencies": {
-    "@tu-lang/runtime": "workspace:*"
+    "@tu-lang/runtime": "workspace:*",
+    "@tu-lang/std": "workspace:*"
+  },
+  "devDependencies": {
+    "@tu-lang/compiler": "workspace:*"
   },
   "publishConfig": {
     "access": "public"

packages/router/scripts/build.mjs

@@ -0,0 +1,43 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawn } from 'node:child_process'
+import { compileToTSWithMap, compileWithMap } from '@tu-lang/compiler'
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..')
+const sourcePath = join(root, 'src', 'index.tu')
+const distDir = join(root, 'dist')
+const buildDir = join(root, '.tu-build')
+const source = await readFile(sourcePath, 'utf8')
+const filename = 'src/index.tu'
+
+await rm(distDir, { recursive: true, force: true })
+await rm(buildDir, { recursive: true, force: true })
+await mkdir(distDir, { recursive: true })
+await mkdir(buildDir, { recursive: true })
+
+const stripInlineMap = (code) => code.replace(/\n?\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,[A-Za-z0-9+/=]+\n?$/, '')
+
+const js = compileWithMap(source, { filename })
+await writeFile(join(distDir, 'index.js'), `${stripInlineMap(js.code)}\n//# sourceMappingURL=index.js.map\n`)
+await writeFile(join(distDir, 'index.js.map'), JSON.stringify({
+  ...js.map,
+  file: 'index.js',
+  sources: ['../src/index.tu'],
+}))
+
+const ts = compileToTSWithMap(source, { filename })
+await writeFile(join(buildDir, 'index.ts'), stripInlineMap(ts.code))
+
+await new Promise((resolve, reject) => {
+  const child = spawn(
+    process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm',
+    ['exec', 'tsc', '-p', 'tsconfig.dts.json'],
+    { cwd: root, stdio: 'inherit' }
+  )
+  child.on('error', reject)
+  child.on('exit', (code) => {
+    if (code === 0) resolve()
+    else reject(new Error(`tsc exited with code ${code}`))
+  })
+})

packages/router/scripts/check.mjs

@@ -0,0 +1,29 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawn } from 'node:child_process'
+import { compileToTSWithMap } from '@tu-lang/compiler'
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..')
+const checkDir = join(root, '.tu-check')
+const source = await readFile(join(root, 'src', 'index.tu'), 'utf8')
+const stripInlineMap = (code) => code.replace(/\n?\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,[A-Za-z0-9+/=]+\n?$/, '')
+
+await rm(checkDir, { recursive: true, force: true })
+await mkdir(checkDir, { recursive: true })
+
+const ts = compileToTSWithMap(source, { filename: 'src/index.tu' })
+await writeFile(join(checkDir, 'index.ts'), stripInlineMap(ts.code))
+
+await new Promise((resolve, reject) => {
+  const child = spawn(
+    process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm',
+    ['exec', 'tsc', '-p', 'tsconfig.check.json'],
+    { cwd: root, stdio: 'inherit' }
+  )
+  child.on('error', reject)
+  child.on('exit', (code) => {
+    if (code === 0) resolve()
+    else reject(new Error(`tsc exited with code ${code}`))
+  })
+})

packages/router/src/index.test.ts

@@ -6,7 +6,7 @@ import {
   joinRoutePaths,
   renderRoute,
   renderRouteToString,
-} from './index.js'
+} from '../dist/index.js'
 
 describe('@tu-lang/router', () => {
   it('matches static routes and renders route bodies', async () => {