gofront 0.0.7 → 0.0.8

package/README.md

@@ -101,8 +101,8 @@ Walks the typed AST and emits clean, readable JavaScript. No intermediate repres
 — the codegen writes directly to an output buffer with indentation tracking.
 
 Runtime helpers (`__len`, `__append`, `__s`, `__sprintf`, `__cmul`, `__cdiv`, `__error`,
-`__errorIs`) are tree-shaken: only emitted when actually used. Optional inline source
-maps are supported via VLQ-encoded mappings.
+`__errorIs`, `__timeFmt`, `__timeParse`, `__pathClean`) are tree-shaken: only emitted
+when actually used. Optional inline source maps are supported via VLQ-encoded mappings.
 
 ---
 
@@ -464,21 +464,24 @@ signatures into GoFront's internal type representation.
 
 | Package | Functions |
 |---|---|
-| `fmt` | `Sprintf`, `Printf`, `Println`, `Print`, `Errorf`, `Fprintf`, `Fprintln`, `Fprint` — format verbs: `%v`, `%d`, `%s`, `%t`, `%x`, `%o`, `%b`, `%q`, `%e`, `%g`, `%w`, width/precision |
-| `strings` | `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `LastIndex`, `Count`, `Repeat`, `Replace`, `ReplaceAll`, `ToUpper`, `ToLower`, `TrimSpace`, `Trim`, `TrimPrefix`, `TrimSuffix`, `TrimLeft`, `TrimRight`, `Split`, `Join`, `EqualFold`; **`Builder`** type (`WriteString`, `WriteByte`, `WriteRune`, `Write`, `String`, `Len`, `Reset`, `Grow`) |
-| `bytes` | `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `Join`, `Split`, `Replace`, `ToUpper`, `ToLower`, `TrimSpace`, `Equal`, `Count`, `Repeat`; **`Buffer`** type (`WriteString`, `WriteByte`, `Write`, `String`, `Bytes`, `Len`, `Reset`) |
-| `strconv` | `Itoa`, `Atoi`, `FormatBool`, `FormatInt`, `FormatFloat`, `ParseFloat`, `ParseInt`, `ParseBool` |
-| `sort` | `Ints`, `Float64s`, `Strings`, `Slice`, `SliceStable`, `SliceIsSorted` |
-| `math` | `Abs`, `Floor`, `Ceil`, `Round`, `Sqrt`, `Cbrt`, `Pow`, `Log`, `Log2`, `Log10`, trig functions + `Pi`, `E`, `MaxFloat64`, `MaxInt`, `MinInt` |
+| `fmt` | `Sprintf`, `Printf`, `Println`, `Print`, `Errorf`, `Fprintf`, `Fprintln`, `Fprint` — format verbs: `%v`, `%d`, `%s`, `%t`, `%x`, `%o`, `%b`, `%q`, `%e`, `%g`, `%w`, width/precision; **scanning**: `Sscan`, `Sscanln`, `Sscanf` |
+| `strings` | `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `LastIndex`, `Count`, `Repeat`, `Replace`, `ReplaceAll`, `ToUpper`, `ToLower`, `TrimSpace`, `Trim`, `TrimPrefix`, `TrimSuffix`, `TrimLeft`, `TrimRight`, `Split`, `Join`, `EqualFold`, `Fields`, `Cut`, `CutPrefix`, `CutSuffix`, `SplitN`, `SplitAfter`, `SplitAfterN`, `IndexAny`, `LastIndexAny`, `ContainsAny`, `ContainsRune`, `IndexRune`, `IndexByte`, `LastIndexByte`, `Map`, `Title`, `ToTitle`, `TrimFunc`, `TrimLeftFunc`, `TrimRightFunc`, `IndexFunc`, `LastIndexFunc`, `NewReplacer`; **`Builder`** type; **`NewReader`** → reader shim |
+| `bytes` | `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `Join`, `Split`, `Replace`, `ToUpper`, `ToLower`, `TrimSpace`, `Equal`, `Count`, `Repeat`, `ReplaceAll`, `TrimPrefix`, `TrimSuffix`, `TrimLeft`, `TrimRight`, `TrimFunc`, `IndexByte`, `LastIndex`, `LastIndexByte`, `Fields`, `Cut`, `ContainsAny`, `ContainsRune`, `Map`, `SplitN`; **`Buffer`** type; **`NewReader`** → reader shim |
+| `strconv` | `Itoa`, `Atoi`, `FormatBool`, `FormatInt`, `FormatFloat`, `ParseFloat`, `ParseInt`, `ParseBool`, `Quote`, `Unquote`, `AppendInt`, `AppendFloat` |
+| `sort` | `Ints`, `Float64s`, `Strings`, `Slice`, `SliceStable`, `SliceIsSorted`, `Search`, `IntsAreSorted`, `Float64sAreSorted`, `StringsAreSorted` |
+| `math` | `Abs`, `Floor`, `Ceil`, `Round`, `Sqrt`, `Cbrt`, `Pow`, `Log`, `Log2`, `Log10`, `Sin`, `Cos`, `Tan`, `Atan`, `Atan2`, `Asin`, `Acos`, `Exp`, `Exp2`, `Trunc`, `Hypot`, `Signbit`, `Copysign`, `Dim`, `Remainder`, `Min`, `Max`, `Mod`, `Inf`, `IsNaN`, `IsInf`, `NaN` + `Pi`, `E`, `MaxFloat64`, `SmallestNonzeroFloat64`, `MaxInt`, `MinInt` |
+| `math/rand` | `Intn`, `Float64`, `Float32`, `Int`, `Int63`, `Int63n`, `Int31`, `Int31n`, `Seed` (no-op), `Shuffle`, `Perm` |
 | `errors` | `New`, `Is`, `Unwrap` — custom error types via interface satisfaction |
-| `time` | `Now`, `Since`, `Sleep` + `Millisecond`, `Second`, `Minute`, `Hour` constants |
+| `time` | `Now` → `time.Time`, `Since`, `Sleep`, `Parse`, `Unix`, `Date`; **`time.Time`** methods: `Format`, `String`, `Year`, `Month`, `Day`, `Hour`, `Minute`, `Second`, `Weekday`, `Unix`, `UnixMilli`, `Add`, `Sub`, `Before`, `After`, `Equal`; layout constants: `RFC3339`, `RFC3339Nano`, `DateOnly`, `TimeOnly`, `DateTime`; duration constants: `Millisecond`, `Second`, `Minute`, `Hour`; month/weekday constants |
 | `html` | `EscapeString`, `UnescapeString` |
 | `maps` | `Keys`, `Values`, `Clone`, `Copy`, `Equal`, `EqualFunc`, `Delete`, `DeleteFunc` |
 | `slices` | `Contains`, `Index`, `Equal`, `Compare`, `Sort`, `SortFunc`, `SortStableFunc`, `IsSorted`, `IsSortedFunc`, `Reverse`, `Max`, `Min`, `MaxFunc`, `MinFunc`, `Clone`, `Compact`, `CompactFunc`, `Concat`, `Delete`, `DeleteFunc`, `Insert`, `Replace`, `Grow`, `Clip` |
 | `regexp` | `MustCompile`, `Compile`, `MatchString`, `QuoteMeta`; **`*Regexp`** methods: `MatchString`, `FindString`, `FindStringIndex`, `FindAllString`, `FindStringSubmatch`, `FindAllStringSubmatch`, `ReplaceAllString`, `ReplaceAllLiteralString`, `Split`, `String`. Inline flags (`(?i)`, `(?m)`, `(?s)`) are extracted automatically into the JS `RegExp` constructor. |
 | `unicode` | `IsLetter`, `IsDigit`, `IsSpace`, `IsUpper`, `IsLower`, `IsPunct`, `IsControl`, `IsPrint`, `IsGraphic`, `ToUpper`, `ToLower` |
+| `unicode/utf8` | `RuneCountInString`, `RuneLen`, `ValidString`, `ValidRune`, `DecodeRuneInString`, `DecodeLastRuneInString`, `FullRuneInString`; constants `RuneError`, `MaxRune`, `UTFMax` |
+| `path` | `Base`, `Dir`, `Ext`, `Join`, `Clean`, `IsAbs`, `Split`, `Match`; `"path/filepath"` is an alias |
 | `os` | `Exit`, `Args`, `Getenv` |
-| `io` | `Writer`, `Reader`, `ReadWriter`, `Closer` interface types — used for accepting `*strings.Builder`, `*bytes.Buffer`, or any compatible writer/reader |
+| `io` | `Writer`, `Reader`, `ReadWriter`, `Closer` interface types; `ReadAll`, `EOF`, `Discard`, `WriteString` |
 | `gom` | Browser-native declarative DOM component library. **Types**: `Node` (interface), `NodeFunc`, `Group`. **Core**: `El(tag, children...)`, `Text(s)`, `Mount(sel, node)`, `MountTo(sel, node)`. **Attributes**: `Attr`, `Class`, `Href`, `Type`, `Src`, `Placeholder`, `DataAttr`, `Style`, `For`, `Name`, `Value`, `Target`, `Rel`, `Alt`, `Title`, `Draggable`, `Role`, `AriaLabel`, `StyleAttr`; boolean: `Disabled`, `Checked`, `Selected`, `Readonly`. **Logic**: `If(cond, node)`, `Map(slice, fn)`. **Elements**: full HTML element set (`Div`, `Span`, `Button`, `Input`, `Ul`, `Li`, `Table`, `Form`, `Img`, `A`, `H1`–`H6`, …) |
 
 ### Packages & imports
@@ -558,11 +561,18 @@ Design documents for planned features are organised by release under `docs/v*/`
 ## Tests
 
 ```sh
-npm test
+npm run test:unit   # unit tests only (~1076 tests, no browser required)
+npm run test:e2e    # E2E tests (Playwright, headless Chromium)
+npm test            # both
 ```
 
-990 tests covering language features, type errors, edge cases, DOM (jsdom), external
-`.d.ts`, npm resolver, multi-file compilation, embedded structs, string formatting, map
-iteration order, integer overflow semantics, unused variable detection, unused import
-detection, semantic difference verification, stdlib shim packages, generics (type params,
-inference, constraints), and both example apps.
+**Unit tests** (1076) cover language features, type errors, edge cases, DOM (jsdom),
+external `.d.ts`, npm resolver, multi-file compilation, embedded structs, string
+formatting, map iteration order, integer overflow semantics, unused variable detection,
+unused import detection, semantic difference verification, stdlib shim packages, and
+generics.
+
+**E2E tests** (74, Playwright) run all three example apps in a real browser and verify
+CRUD, filtering, priority mode, persistence (reload), drag-and-drop reordering, and sync
+status. Per-app suites check app-specific behaviour: scoped styles, stats bar, loading
+placeholder, and `gom.If` conditional rendering.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "0.0.7",
+	"version": "0.0.8",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -34,14 +34,18 @@
 		"build:simple": "node src/index.js example/simple/src -o example/simple/app.js",
 		"build:reactive": "node src/index.js example/reactive/src -o example/reactive/app.js",
 		"build:gom": "node src/index.js example/gom/src -o example/gom/app.js",
-		"test": "node test/unit/run.js",
+		"test": "npm run test:unit && npm run test:e2e",
+		"test:unit": "node test/unit/run.js",
+		"test:e2e": "playwright test",
 		"format": "biome format --write .",
-		"check": "biome check .",
+		"check": "biome check . && node src/index.js example/simple/src --check && node src/index.js example/reactive/src --check && node src/index.js example/gom/src --check",
 		"prepare": "husky"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.4.12",
+		"@playwright/test": "^1.59.1",
 		"husky": "^9.1.7",
-		"jsdom": "^29.0.2"
+		"jsdom": "^29.0.2",
+		"serve": "^14.2.6"
 	}
 }

package/src/codegen/expressions.js

@@ -2,8 +2,6 @@
 
 import { ERROR, isComplex } from "../typechecker/types.js";
 
-const globalError = ERROR;
-
 const INT_TYPE_NAMES = new Set([
 	"int",
 	"uint",
@@ -163,7 +161,7 @@ export const expressionGenMethods = {
 							return "process.argv";
 					}
 				}
-				// time constants (nanosecond durations)
+				// time constants (nanosecond durations and layout strings)
 				if (expr.expr.kind === "Ident" && expr.expr.name === "time") {
 					switch (expr.field) {
 						case "Millisecond":
@@ -174,6 +172,68 @@ export const expressionGenMethods = {
 							return "60000000000";
 						case "Hour":
 							return "3600000000000";
+						case "RFC3339":
+							return '"2006-01-02T15:04:05Z07:00"';
+						case "RFC3339Nano":
+							return '"2006-01-02T15:04:05.999999999Z07:00"';
+						case "DateOnly":
+							return '"2006-01-02"';
+						case "TimeOnly":
+							return '"15:04:05"';
+						case "DateTime":
+							return '"2006-01-02 15:04:05"';
+						case "UTC":
+						case "Local":
+							return "null";
+						case "January":
+							return "1";
+						case "February":
+							return "2";
+						case "March":
+							return "3";
+						case "April":
+							return "4";
+						case "May":
+							return "5";
+						case "June":
+							return "6";
+						case "July":
+							return "7";
+						case "August":
+							return "8";
+						case "September":
+							return "9";
+						case "October":
+							return "10";
+						case "November":
+							return "11";
+						case "December":
+							return "12";
+						case "Sunday":
+							return "0";
+						case "Monday":
+							return "1";
+						case "Tuesday":
+							return "2";
+						case "Wednesday":
+							return "3";
+						case "Thursday":
+							return "4";
+						case "Friday":
+							return "5";
+						case "Saturday":
+							return "6";
+					}
+				}
+				// utf8 constants
+				if (expr.expr.kind === "Ident" && expr.expr.name === "utf8") {
+					switch (expr.field) {
+						case "RuneError":
+							return "0xFFFD";
+						case "MaxRune":
+							return "0x10FFFF";
+						case "UTFMax":
+							return "4";
 					}
 				}
 				const base = this.genExpr(expr.expr);
@@ -456,7 +516,7 @@ export const expressionGenMethods = {
 			expr.func.kind === "SelectorExpr" &&
 			expr.func.field === "Error" &&
 			expr.func.expr._type &&
-			(expr.func.expr._type === globalError ||
+			(expr.func.expr._type === ERROR ||
 				expr.func.expr._type?.name === "error" ||
 				(expr.func.expr._type?.kind === "named" &&
 					expr.func.expr._type?.underlying?.kind === "interface"))
@@ -485,6 +545,9 @@ export const expressionGenMethods = {
 			if (recvName === "regexp.Regexp") {
 				return this._genRegexpMethodCall(expr.func.field, expr);
 			}
+			if (recvName === "time.Time") {
+				return this._genTimeMethodCall(expr.func.field, expr);
+			}
 		}
 
 		// Mark the callee so SelectorExpr knows it's being called, not used as a value
@@ -1096,6 +1159,10 @@ export const expressionGenMethods = {
 				// strings.Builder has { _buf: string }, bytes.Buffer has { _buf: [] }.
 				return `((b,s) => { const w = b?.value ?? b; if (typeof w.WriteString === "function") return [w.WriteString(s), null]; if (typeof w._buf === "string") { w._buf += s; return [s.length, null]; } if (Array.isArray(w._buf)) { w._buf.push(...new TextEncoder().encode(s)); return [s.length, null]; } return [0, "io.WriteString: unsupported writer"]; })(${w}, ${s})`;
 			}
+			case "ReadAll": {
+				const r = this.genExpr(expr.args[0]);
+				return `((r) => { const w = r?.value ?? r; if (typeof w._src === "string") { const s = w._src.slice(w._pos); w._pos = w._src.length; return [[...s].map(c => c.charCodeAt(0)), null]; } if (Array.isArray(w._src)) { const b = w._src.slice(w._pos); w._pos = w._src.length; return [b, null]; } const chunks = []; const buf = new Array(4096); let err = null; while (!err) { const [n, e] = w.Read(buf); if (n > 0) chunks.push(...buf.slice(0, n)); err = e; } return [chunks, err === "EOF" ? null : err]; })(${r})`;
+			}
 		}
 		return undefined;
 	},
@@ -1202,6 +1269,12 @@ export const expressionGenMethods = {
 				return this._genHtml(fn, a);
 			case "io":
 				return this._genIo(fn, a, expr);
+			case "rand":
+				return this._genRand(fn, a);
+			case "utf8":
+				return this._genUtf8(fn, a);
+			case "path":
+				return this._genPath(fn, a, expr);
 			case "gom":
 				return this._genGom(fn, expr);
 			default:
@@ -1425,6 +1498,31 @@ export const expressionGenMethods = {
 					return `(${buf} += __sprintf("%v\\n", ${restJs}))`;
 				return `(${buf} += __sprintf("%v", ${restJs}))`;
 			}
+			case "Sscan": {
+				const strArg = this.genExpr(expr.args[0]);
+				const restArgs = expr.args
+					.slice(1)
+					.map((e) => this.genExpr(e))
+					.join(", ");
+				return `((str, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { const t = tokens[i]; const p = ptrs[i]; if (typeof p.value === "number") p.value = Number(t); else if (typeof p.value === "boolean") p.value = t === "true"; else p.value = t; n++; } return [n, n < ptrs.length ? "unexpected EOF" : null]; })(${strArg}, ${restArgs})`;
+			}
+			case "Sscanln": {
+				const strArg = this.genExpr(expr.args[0]);
+				const restArgs = expr.args
+					.slice(1)
+					.map((e) => this.genExpr(e))
+					.join(", ");
+				return `((str, ...ptrs) => { const line = str.split("\\n")[0]; const tokens = line.trim().split(/\\s+/).filter(Boolean); let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { const t = tokens[i]; const p = ptrs[i]; if (typeof p.value === "number") p.value = Number(t); else if (typeof p.value === "boolean") p.value = t === "true"; else p.value = t; n++; } return [n, n < ptrs.length ? "unexpected EOF" : null]; })(${strArg}, ${restArgs})`;
+			}
+			case "Sscanf": {
+				const strArg = this.genExpr(expr.args[0]);
+				const fmtArg = this.genExpr(expr.args[1]);
+				const restArgs = expr.args
+					.slice(2)
+					.map((e) => this.genExpr(e))
+					.join(", ");
+				return `((str, _fmt, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { const t = tokens[i]; const p = ptrs[i]; if (typeof p.value === "number") p.value = Number(t); else if (typeof p.value === "boolean") p.value = t === "true"; else p.value = t; n++; } return [n, n < ptrs.length ? "input does not match format" : null]; })(${strArg}, ${fmtArg}, ${restArgs})`;
+			}
 			default:
 				return undefined;
 		}
@@ -1473,6 +1571,56 @@ export const expressionGenMethods = {
 				return `${args[0]}.join(${args[1]})`;
 			case "EqualFold":
 				return `${args[0]}.toLowerCase() === ${args[1]}.toLowerCase()`;
+			case "Fields":
+				return `(${args[0]}).trim() === '' ? [] : (${args[0]}).trim().split(/\\s+/)`;
+			case "Cut":
+				return `((s, sep) => { const i = s.indexOf(sep); return i < 0 ? [s, "", false] : [s.slice(0, i), s.slice(i + sep.length), true]; })(${args[0]}, ${args[1]})`;
+			case "CutPrefix":
+				return `(${args[0]}).startsWith(${args[1]}) ? [(${args[0]}).slice((${args[1]}).length), true] : [${args[0]}, false]`;
+			case "CutSuffix":
+				return `(${args[0]}).endsWith(${args[1]}) ? [(${args[0]}).slice(0, -(${args[1]}).length), true] : [${args[0]}, false]`;
+			case "SplitN":
+				return `((s, sep, n) => { if (n === 0) return []; if (n < 0) return s.split(sep); const r = []; let cur = s; for (let i = 1; i < n && cur.length; i++) { const j = cur.indexOf(sep); if (j < 0) break; r.push(cur.slice(0, j)); cur = cur.slice(j + sep.length); } r.push(cur); return r; })(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "SplitAfter":
+				return `((s, sep) => { if (sep === "") return [...s]; const r = []; let cur = s; while (cur.length) { const j = cur.indexOf(sep); if (j < 0) { r.push(cur); break; } r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } return r; })(${args[0]}, ${args[1]})`;
+			case "SplitAfterN":
+				return `((s, sep, n) => { if (n === 0) return []; if (n < 0 || sep === "") return ((s, sep) => { if (sep === "") return [...s]; const r = []; let cur = s; while (cur.length) { const j = cur.indexOf(sep); if (j < 0) { r.push(cur); break; } r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } return r; })(s, sep); const r = []; let cur = s; for (let i = 1; i < n && cur.length; i++) { const j = cur.indexOf(sep); if (j < 0) break; r.push(cur.slice(0, j + sep.length)); cur = cur.slice(j + sep.length); } r.push(cur); return r; })(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "IndexAny":
+				return `((s, chars) => { let m = -1; for (const c of chars) { const i = s.indexOf(c); if (i >= 0 && (m < 0 || i < m)) m = i; } return m; })(${args[0]}, ${args[1]})`;
+			case "LastIndexAny":
+				return `((s, chars) => { let m = -1; for (const c of chars) { const i = s.lastIndexOf(c); if (i > m) m = i; } return m; })(${args[0]}, ${args[1]})`;
+			case "ContainsAny":
+				return `[...(${args[1]})].some(c => (${args[0]}).includes(c))`;
+			case "ContainsRune":
+				return `(${args[0]}).includes(String.fromCodePoint(${args[1]}))`;
+			case "IndexRune":
+				return `(${args[0]}).indexOf(String.fromCodePoint(${args[1]}))`;
+			case "IndexByte":
+				return `(${args[0]}).indexOf(String.fromCharCode(${args[1]}))`;
+			case "LastIndexByte":
+				return `(${args[0]}).lastIndexOf(String.fromCharCode(${args[1]}))`;
+			case "Map":
+				return `[...(${args[1]})].map(c => String.fromCodePoint((${args[0]})(c.codePointAt(0)))).join("")`;
+			case "Title":
+				return `(${args[0]}).replace(/\\b\\w/g, c => c.toUpperCase())`;
+			case "ToTitle":
+				return `(${args[0]}).toUpperCase()`;
+			case "TrimFunc":
+				return `((s, f) => { let l = 0, r = s.length; while (l < r && f(s.codePointAt(l))) l++; while (r > l && f(s.codePointAt(r - 1))) r--; return s.slice(l, r); })(${args[0]}, ${args[1]})`;
+			case "TrimLeftFunc":
+				return `((s, f) => { let l = 0; while (l < s.length && f(s.codePointAt(l))) l++; return s.slice(l); })(${args[0]}, ${args[1]})`;
+			case "TrimRightFunc":
+				return `((s, f) => { let r = s.length; while (r > 0 && f(s.codePointAt(r - 1))) r--; return s.slice(0, r); })(${args[0]}, ${args[1]})`;
+			case "IndexFunc":
+				return `((s, f) => { for (let i = 0; i < s.length; i++) { const cp = s.codePointAt(i); if (f(cp)) return i; if (cp > 0xFFFF) i++; } return -1; })(${args[0]}, ${args[1]})`;
+			case "LastIndexFunc":
+				return `((s, f) => { for (let i = s.length - 1; i >= 0; i--) { const cp = s.codePointAt(i); if (f(cp)) return i; } return -1; })(${args[0]}, ${args[1]})`;
+			case "NewReader":
+				return `{_src: ${args[0]}, _pos: 0, Read(p) { const n = Math.min(p.length, this._src.length - this._pos); for (let i = 0; i < n; i++) p[i] = this._src.charCodeAt(this._pos + i); this._pos += n; return [n, n === 0 ? "EOF" : null]; }, Len() { return this._src.length - this._pos; }, Reset(s) { this._src = s; this._pos = 0; }}`;
+			case "NewReplacer": {
+				const allArgs = args.join(", ");
+				return `((...pairs) => { const p = []; for (let i = 0; i < pairs.length; i += 2) p.push([pairs[i], pairs[i+1]]); return { _p: p, Replace(s) { let r = s; for (const [o, n] of this._p) r = r.split(o).join(n); return r; } }; })(${allArgs})`;
+			}
 			default:
 				return undefined;
 		}
@@ -1511,6 +1659,38 @@ export const expressionGenMethods = {
 				return `${__bs}(${args[0]}).split(${__bs}(${args[1]})).map(p => ${__sb}(p))`;
 			case "Join":
 				return `${__sb}(${args[0]}.map(p => ${__bs}(p)).join(${__bs}(${args[1]})))`;
+			case "ReplaceAll":
+				return `((b, o, n) => { const r = []; let i = 0; while (i <= b.length - o.length) { if (o.every((v, j) => b[i + j] === v)) { r.push(...n); i += o.length; } else r.push(b[i++]); } return r.concat(b.slice(i)); })(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "TrimPrefix":
+				return `((b, p) => p.every((v, i) => b[i] === v) ? b.slice(p.length) : b.slice())(${args[0]}, ${args[1]})`;
+			case "TrimSuffix":
+				return `((b, s) => s.length && s.every((v, i) => b[b.length - s.length + i] === v) ? b.slice(0, -s.length) : b.slice())(${args[0]}, ${args[1]})`;
+			case "TrimLeft":
+				return `((b, c) => { let i = 0; while (i < b.length && c.includes(String.fromCharCode(b[i]))) i++; return b.slice(i); })(${args[0]}, ${args[1]})`;
+			case "TrimRight":
+				return `((b, c) => { let i = b.length; while (i > 0 && c.includes(String.fromCharCode(b[i - 1]))) i--; return b.slice(0, i); })(${args[0]}, ${args[1]})`;
+			case "TrimFunc":
+				return `((b, f) => { let l = 0, r = b.length; while (l < r && f(b[l])) l++; while (r > l && f(b[r - 1])) r--; return b.slice(l, r); })(${args[0]}, ${args[1]})`;
+			case "IndexByte":
+				return `(${args[0]}).indexOf(${args[1]})`;
+			case "LastIndex":
+				return `((b, s) => { for (let i = b.length - s.length; i >= 0; i--) if (s.every((v, j) => b[i + j] === v)) return i; return -1; })(${args[0]}, ${args[1]})`;
+			case "LastIndexByte":
+				return `(${args[0]}).lastIndexOf(${args[1]})`;
+			case "Fields":
+				return `((b) => { const s = String.fromCharCode(...b).trim(); return s === '' ? [] : s.split(/\\s+/).map(w => [...w].map(c => c.charCodeAt(0))); })(${args[0]})`;
+			case "Cut":
+				return `((b, sep) => { for (let i = 0; i <= b.length - sep.length; i++) if (sep.every((v, j) => b[i + j] === v)) return [b.slice(0, i), b.slice(i + sep.length), true]; return [b.slice(), [], false]; })(${args[0]}, ${args[1]})`;
+			case "ContainsAny":
+				return `[...(${args[1]})].some(c => (${args[0]}).includes(c.charCodeAt(0)))`;
+			case "ContainsRune":
+				return `(${args[0]}).includes(${args[1]})`;
+			case "Map":
+				return `(${args[1]}).map(v => (${args[0]})(v))`;
+			case "SplitN":
+				return `((b, sep, n) => { if (n === 0) return []; if (n < 0) return ((b, sep) => { const r = []; let i = 0; while (i <= b.length) { const j = b.findIndex((_, k) => k >= i && sep.every((v, l) => b[k + l] === sep[l])); if (j < 0 || j >= b.length) break; r.push(b.slice(i, j)); i = j + sep.length; } r.push(b.slice(i)); return r; })(b, sep); const r = []; let i = 0; for (let c = 1; c < n; c++) { const j = b.findIndex((_, k) => k >= i && sep.every((v, l) => b[k + l] === sep[l])); if (j < 0) break; r.push(b.slice(i, j)); i = j + sep.length; } r.push(b.slice(i)); return r; })(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "NewReader":
+				return `{_src: ${args[0]}, _pos: 0, Read(p) { const n = Math.min(p.length, this._src.length - this._pos); for (let i = 0; i < n; i++) p[i] = this._src[this._pos + i]; this._pos += n; return [n, n === 0 ? "EOF" : null]; }, Len() { return this._src.length - this._pos; }, Reset(b) { this._src = b; this._pos = 0; }}`;
 			default:
 				return undefined;
 		}
@@ -1535,6 +1715,14 @@ export const expressionGenMethods = {
 				return `(Number.isNaN(parseInt(${args[0]}, ${args[1]} || 10)) ? [0, "invalid syntax"] : [parseInt(${args[0]}, ${args[1]} || 10), null])`;
 			case "ParseBool":
 				return `(${args[0]} === "true" || ${args[0]} === "1" ? [true, null] : ${args[0]} === "false" || ${args[0]} === "0" ? [false, null] : [false, "invalid syntax"])`;
+			case "Quote":
+				return `JSON.stringify(${args[0]})`;
+			case "Unquote":
+				return `((s) => { try { const v = JSON.parse(s); return [v, null]; } catch(e) { return ["", "invalid syntax"]; } })(${args[0]})`;
+			case "AppendInt":
+				return `[...(${args[0]}), ...new TextEncoder().encode((${args[1]}).toString(${args[2]}))]`;
+			case "AppendFloat":
+				return `[...(${args[0]}), ...new TextEncoder().encode(${args[1]}.toFixed(${args[3]} < 0 ? 6 : ${args[3]}))]`;
 			default:
 				return undefined;
 		}
@@ -1553,6 +1741,12 @@ export const expressionGenMethods = {
 				return `${args[0]}.sort((a, b) => ${args[1]}(a, b) ? -1 : ${args[1]}(b, a) ? 1 : 0)`;
 			case "SliceIsSorted":
 				return `${args[0]}.every((v, i, a) => i === 0 || ${args[1]}(a[i - 1], v))`;
+			case "Search":
+				return `((n, f) => { let lo = 0, hi = n; while (lo < hi) { const mid = (lo + hi) >>> 1; if (f(mid)) hi = mid; else lo = mid + 1; } return lo; })(${args[0]}, ${args[1]})`;
+			case "IntsAreSorted":
+			case "Float64sAreSorted":
+			case "StringsAreSorted":
+				return `(${args[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`;
 			default:
 				return undefined;
 		}
@@ -1601,6 +1795,30 @@ export const expressionGenMethods = {
 				return `(${args[1]} > 0 ? ${args[0]} === Infinity : ${args[1]} < 0 ? ${args[0]} === -Infinity : !Number.isFinite(${args[0]}))`;
 			case "NaN":
 				return "NaN";
+			case "Atan":
+				return `Math.atan(${args[0]})`;
+			case "Atan2":
+				return `Math.atan2(${args[0]}, ${args[1]})`;
+			case "Asin":
+				return `Math.asin(${args[0]})`;
+			case "Acos":
+				return `Math.acos(${args[0]})`;
+			case "Exp":
+				return `Math.exp(${args[0]})`;
+			case "Exp2":
+				return `Math.pow(2, ${args[0]})`;
+			case "Trunc":
+				return `Math.trunc(${args[0]})`;
+			case "Hypot":
+				return `Math.hypot(${args[0]}, ${args[1]})`;
+			case "Signbit":
+				return `(${args[0]} < 0 || Object.is(${args[0]}, -0))`;
+			case "Copysign":
+				return `(Math.abs(${args[0]}) * (${args[1]} < 0 || Object.is(${args[1]}, -0) ? -1 : 1))`;
+			case "Dim":
+				return `Math.max(${args[0]} - ${args[1]}, 0)`;
+			case "Remainder":
+				return `(${args[0]} - Math.round(${args[0]} / ${args[1]}) * ${args[1]})`;
 			default:
 				return undefined;
 		}
@@ -1665,15 +1883,142 @@ export const expressionGenMethods = {
 		}
 	},
 
+	_genTimeMethodCall(method, expr) {
+		const recv = expr.func.expr;
+		const recvJs = this.genExpr(recv);
+		const args = expr.args.map((a) => this.genExpr(a));
+		switch (method) {
+			case "Format":
+				this._usesTimeFmt = true;
+				return `__timeFmt(${recvJs}._d, ${args[0]})`;
+			case "String":
+				this._usesTimeFmt = true;
+				return `__timeFmt(${recvJs}._d, "2006-01-02T15:04:05Z07:00")`;
+			case "Year":
+				return `${recvJs}._d.getFullYear()`;
+			case "Month":
+				return `${recvJs}._d.getMonth() + 1`;
+			case "Day":
+				return `${recvJs}._d.getDate()`;
+			case "Hour":
+				return `${recvJs}._d.getHours()`;
+			case "Minute":
+				return `${recvJs}._d.getMinutes()`;
+			case "Second":
+				return `${recvJs}._d.getSeconds()`;
+			case "Weekday":
+				return `${recvJs}._d.getDay()`;
+			case "Unix":
+				return `Math.floor(${recvJs}._d.getTime() / 1000)`;
+			case "UnixMilli":
+				return `${recvJs}._d.getTime()`;
+			case "Add":
+				return `{_d: new Date(${recvJs}._d.getTime() + (${args[0]}))}`;
+			case "Sub":
+				return `${recvJs}._d.getTime() - (${args[0]})._d.getTime()`;
+			case "Before":
+				return `${recvJs}._d < (${args[0]})._d`;
+			case "After":
+				return `${recvJs}._d > (${args[0]})._d`;
+			case "Equal":
+				return `${recvJs}._d.getTime() === (${args[0]})._d.getTime()`;
+			default:
+				return undefined;
+		}
+	},
+
 	_genTime(fn, a) {
 		const args = a();
 		switch (fn) {
 			case "Now":
-				return "Date.now()";
+				return "{_d: new Date()}";
 			case "Since":
-				return `(Date.now() - ${args[0]})`;
+				return `(Date.now() - (${args[0]})._d.getTime())`;
 			case "Sleep":
 				return `await new Promise(r => setTimeout(r, ${args[0]} / 1000000))`;
+			case "Parse":
+				this._usesTimeParse = true;
+				return `__timeParse(${args[0]}, ${args[1]})`;
+			case "Unix":
+				return `{_d: new Date((${args[0]}) * 1000)}`;
+			case "Date":
+				return `{_d: new Date(${args[0]}, ${args[1]} - 1, ${args[2]}, ${args[3]}, ${args[4]}, ${args[5]})}`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genRand(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "Intn":
+			case "Int63n":
+			case "Int31n":
+				return `Math.floor(Math.random() * ${args[0]})`;
+			case "Float64":
+			case "Float32":
+				return "Math.random()";
+			case "Int":
+			case "Int31":
+				return "Math.floor(Math.random() * 2147483647)";
+			case "Int63":
+				return "Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)";
+			case "Seed":
+				return "(void 0)";
+			case "Shuffle":
+				return `((n, f) => { for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); f(i, j); } })(${args[0]}, ${args[1]})`;
+			case "Perm":
+				return `((n) => { const a = Array.from({length: n}, (_, i) => i); for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; })(${args[0]})`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genUtf8(fn, a) {
+		const args = a();
+		switch (fn) {
+			case "RuneCountInString":
+				return `[...(${args[0]})].length`;
+			case "RuneLen":
+				return `((r) => r < 0 ? -1 : r <= 0x7F ? 1 : r <= 0x7FF ? 2 : r <= 0xFFFF ? (r >= 0xD800 && r <= 0xDFFF ? -1 : 3) : r <= 0x10FFFF ? 4 : -1)(${args[0]})`;
+			case "ValidString":
+				return `/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/.test(${args[0]}) === false`;
+			case "ValidRune":
+				return `(${args[0]}) >= 0 && (${args[0]}) <= 0x10FFFF && !((${args[0]}) >= 0xD800 && (${args[0]}) <= 0xDFFF)`;
+			case "DecodeRuneInString":
+				return `((s) => { if (!s) return [0xFFFD, 0]; const cp = s.codePointAt(0); return [cp, cp > 0xFFFF ? 2 : 1]; })(${args[0]})`;
+			case "DecodeLastRuneInString":
+				return `((s) => { if (!s) return [0xFFFD, 0]; const i = s.length > 1 && s.charCodeAt(s.length - 1) >= 0xDC00 && s.charCodeAt(s.length - 1) <= 0xDFFF ? s.length - 2 : s.length - 1; const cp = s.codePointAt(i); return [cp, cp > 0xFFFF ? 2 : 1]; })(${args[0]})`;
+			case "FullRuneInString":
+				return `(${args[0]}).length > 0`;
+			default:
+				return undefined;
+		}
+	},
+
+	_genPath(fn, a, expr) {
+		const args = a();
+		switch (fn) {
+			case "Base":
+				return `((p) => { if (!p) return "."; const stripped = p.replace(/\\/+$/, ""); if (!stripped) return "/"; const i = stripped.lastIndexOf("/"); return i < 0 ? stripped : stripped.slice(i + 1) || "/"; })(${args[0]})`;
+			case "Dir":
+				return `((p) => { const i = p.lastIndexOf("/"); if (i < 0) return "."; if (i === 0) return "/"; return p.slice(0, i); })(${args[0]})`;
+			case "Ext":
+				return `((p) => { const b = p.slice(p.lastIndexOf("/") + 1); const i = b.lastIndexOf("."); return i <= 0 ? "" : b.slice(i); })(${args[0]})`;
+			case "Join": {
+				this._usesPathClean = true;
+				const allArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
+				return `__pathClean([${allArgs}].filter(x => x !== "").join("/"))`;
+			}
+			case "Clean":
+				this._usesPathClean = true;
+				return `__pathClean(${args[0]})`;
+			case "IsAbs":
+				return `(${args[0]}).startsWith("/")`;
+			case "Split":
+				return `((p) => { const i = p.lastIndexOf("/"); return i < 0 ? ["", p] : [p.slice(0, i + 1), p.slice(i + 1)]; })(${args[0]})`;
+			case "Match":
+				return `((pat, name) => { try { const sp=/[.+^$()|[\\]\\\\]/g; const re = new RegExp("^" + pat.replace(sp, "\\\\$&").replace(/\\*/g, "[^/]*").replace(/\\?/g, "[^/]") + "$"); return [re.test(name), null]; } catch(e) { return [false, "syntax error in pattern"]; } })(${args[0]}, ${args[1]})`;
 			default:
 				return undefined;
 		}

package/src/codegen/source-map.js

@@ -16,9 +16,10 @@ function vlqEncode(value) {
 	return result;
 }
 
-export function buildSourceMap(sources, mappings) {
-	// sources:  string[]
-	// mappings: Array<{ genLine: number, srcLine: number, srcFileIdx?: number }>  (0-based)
+export function buildSourceMap(sources, mappings, sourcesContent) {
+	// sources:         string[]
+	// mappings:        Array<{ genLine: number, srcLine: number, srcFileIdx?: number }>  (0-based)
+	// sourcesContent:  string[] | undefined — original file contents, embedded for DevTools
 	// Emits one segment per generated line, column 0 → source line (delta-encoded).
 	const lines = [];
 	let prevSrcLine = 0;
@@ -44,10 +45,12 @@ export function buildSourceMap(sources, mappings) {
 			lines.push(""); // no mapping for this generated line
 		}
 	}
-	return JSON.stringify({
+	const map = {
 		version: 3,
 		sources,
 		names: [],
 		mappings: lines.join(";"),
-	});
+	};
+	if (sourcesContent) map.sourcesContent = sourcesContent;
+	return JSON.stringify(map);
 }

package/src/codegen.js

@@ -52,6 +52,9 @@ export class CodeGen {
 		this._usesCdiv = false;
 		this._usesError = false;
 		this._usesErrorIs = false;
+		this._usesPathClean = false;
+		this._usesTimeFmt = false;
+		this._usesTimeParse = false;
 		// Iterator (range-over-func) context
 		this._inIteratorBody = false;
 		this._iterDepth = 0;
@@ -226,6 +229,47 @@ export class CodeGen {
 			helpers.push(
 				'var __errorIs = __errorIs || function(err, target) { while (err !== null && err !== undefined) { if (err === target) return true; if (typeof err === "object" && typeof target === "object" && err._msg !== undefined && target._msg !== undefined && err._msg === target._msg) return true; err = err?._cause ?? null; } return false; };',
 			);
+		if (this._usesPathClean)
+			helpers.push(
+				'var __pathClean = __pathClean || function(p) { if (!p) return "."; const abs = p.startsWith("/"); const parts = p.split("/").reduce((acc, s) => { if (s === "" || s === ".") return acc; if (s === "..") { if (acc.length && acc[acc.length-1] !== "..") acc.pop(); else if (!abs) acc.push(".."); } else acc.push(s); return acc; }, []); return (abs ? "/" : "") + (parts.join("/") || "."); };',
+			);
+		if (this._usesTimeFmt)
+			helpers.push(
+				[
+					"var __timeFmt = __timeFmt || function(d, layout) {",
+					'const pad = (n, w=2) => String(n).padStart(w, "0");',
+					'const DAYS=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];',
+					'const MONTHS=["January","February","March","April","May","June","July","August","September","October","November","December"];',
+					"return layout.replace(/2006|06|Monday|Mon|January|Jan|01|1|02|2|15|PM|3|04|4|05|5|Z07:00|\\.000|\\.999/g, t => {",
+					"switch(t){",
+					'case "2006": return d.getFullYear();',
+					'case "06": return String(d.getFullYear()).slice(-2);',
+					'case "Monday": return DAYS[d.getDay()];',
+					'case "Mon": return DAYS[d.getDay()].slice(0,3);',
+					'case "January": return MONTHS[d.getMonth()];',
+					'case "Jan": return MONTHS[d.getMonth()].slice(0,3);',
+					'case "01": return pad(d.getMonth()+1);',
+					'case "1": return String(d.getMonth()+1);',
+					'case "02": return pad(d.getDate());',
+					'case "2": return String(d.getDate());',
+					'case "15": return pad(d.getHours());',
+					'case "PM": return d.getHours()<12?"AM":"PM";',
+					'case "3": return String(d.getHours()%12||12);',
+					'case "04": return pad(d.getMinutes());',
+					'case "4": return String(d.getMinutes());',
+					'case "05": return pad(d.getSeconds());',
+					'case "5": return String(d.getSeconds());',
+					'case "Z07:00": { const o=-d.getTimezoneOffset(); return o===0?"Z":(o>0?"+":"-")+pad(Math.floor(Math.abs(o)/60))+":"+pad(Math.abs(o)%60); }',
+					'case ".000": return "."+pad(d.getMilliseconds(),3);',
+					'case ".999": return d.getMilliseconds()>0?"."+String(d.getMilliseconds()).replace(/0+$/,""):"";',
+					"default: return t;}});",
+					"};",
+				].join(""),
+			);
+		if (this._usesTimeParse)
+			helpers.push(
+				'var __timeParse = __timeParse || function(layout, value) { try { const d = new Date(value); if (isNaN(d.getTime())) throw 0; return [{_d:d}, null]; } catch { return [{_d:new Date(0)}, "parsing time: cannot parse"]; } };',
+			);
 
 		if (helpers.length > 0) this.out.unshift(...helpers, "");
 
@@ -248,9 +292,10 @@ export class CodeGen {
 
 	// Returns a source map JSON string for the last generate() call.
 	// sources: string[] of source filenames (relative to the output file).
-	getSourceMap(sources) {
+	// sourcesContent: string[] of original file contents (embedded for DevTools breakpoints).
+	getSourceMap(sources, sourcesContent) {
 		const srcArray = Array.isArray(sources) ? sources : [sources];
-		return buildSourceMap(srcArray, this._srcMappings);
+		return buildSourceMap(srcArray, this._srcMappings, sourcesContent);
 	}
 
 	// ── Type declarations ────────────────────────────────────────
@@ -534,7 +579,10 @@ export class CodeGen {
 				}
 			} else {
 				const zero = spec.type ? this.zeroValueForTypeNode(spec.type) : "null";
-				for (const name of spec.names) this.line(`let ${name} = ${zero};`);
+				for (const name of spec.names) {
+					const val = this._boxedVars.has(name) ? `{ value: ${zero} }` : zero;
+					this.line(`let ${name} = ${val};`);
+				}
 			}
 		}
 	}

package/src/compiler.js

@@ -170,7 +170,8 @@ export function compileFiles(files, options = {}) {
 	if (options.sourceMap) {
 		const outputDir = options.outputDir ?? fromDir;
 		const sourceFiles = files.map((f) => relative(outputDir, f));
-		const map = codegen.getSourceMap(sourceFiles);
+		const sourcesContent = files.map((f) => readFileSync(f, "utf8"));
+		const map = codegen.getSourceMap(sourceFiles, sourcesContent);
 		const b64 = Buffer.from(map).toString("base64");
 		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 	}

package/src/dev-server.js

@@ -10,6 +10,7 @@ const MIME = {
 	".js": "application/javascript; charset=utf-8",
 	".css": "text/css; charset=utf-8",
 	".json": "application/json; charset=utf-8",
+	".go": "text/plain; charset=utf-8",
 	".svg": "image/svg+xml",
 	".png": "image/png",
 	".jpg": "image/jpeg",

package/src/index.js

@@ -232,7 +232,7 @@ function runCompile() {
 	if (sourceMap) {
 		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
 		const srcPath = relative(outputDir, inputPath);
-		const map = cg.getSourceMap(srcPath);
+		const map = cg.getSourceMap(srcPath, [source]);
 		const b64 = Buffer.from(map).toString("base64");
 		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
 	}

package/src/resolver.js

@@ -25,11 +25,39 @@ function findNodeModules(startDir) {
 	}
 }
 
+// Built-in stdlib package paths that are always available as globals — no resolution needed.
+const BUILTIN_PACKAGES = new Set([
+	"fmt",
+	"strings",
+	"bytes",
+	"strconv",
+	"sort",
+	"math",
+	"math/rand",
+	"errors",
+	"time",
+	"unicode",
+	"unicode/utf8",
+	"os",
+	"slices",
+	"html",
+	"io",
+	"gom",
+	"maps",
+	"regexp",
+	"path",
+	"path/filepath",
+]);
+
 // Returns true for local relative paths (start with ./ or ../)
 export function isLocalPath(importPath) {
 	return importPath.startsWith("./") || importPath.startsWith("../");
 }
 
+export function isBuiltinPackage(importPath) {
+	return BUILTIN_PACKAGES.has(importPath);
+}
+
 // Resolve a local relative import path to an absolute directory of .go files.
 // Returns the absolute dir path, or null if it doesn't contain any .go files.
 export function resolveGwDir(importPath, fromFile) {
@@ -85,6 +113,7 @@ export function resolveAll(imports, fromFile, parseDts) {
 		for (const { path } of imp.imports) {
 			if (path.startsWith("js:")) continue; // handled separately
 			if (isLocalPath(path)) continue; // local .go packages — handled by compiler
+			if (isBuiltinPackage(path)) continue; // built-in stdlib namespaces — always available
 
 			if (resolved.has(path)) continue;
 

package/src/typechecker/stdlib.js

@@ -8,6 +8,9 @@
 
 import { ANY, BOOL, ERROR, FLOAT64, INT, STRING, VOID } from "./types.js";
 
+// time.Time named type — used by the time package
+const TIME_T = { kind: "named", name: "time.Time", underlying: ANY };
+
 export function setupGlobals(globals, types) {
 	// Browser globals — typed as 'any' so any access/call is permitted
 	const browserGlobals = [
@@ -113,6 +116,24 @@ export function setupGlobals(globals, types) {
 				returns: [INT, ERROR],
 				variadic: true,
 			},
+			Sscan: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [INT, ERROR],
+				variadic: true,
+			},
+			Sscanln: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [INT, ERROR],
+				variadic: true,
+			},
+			Sscanf: {
+				kind: "func",
+				params: [STRING, STRING, ANY],
+				returns: [INT, ERROR],
+				variadic: true,
+			},
 		},
 	});
 
@@ -164,6 +185,71 @@ export function setupGlobals(globals, types) {
 				returns: [STRING],
 			},
 			EqualFold: strFn2(STRING, BOOL),
+			Fields: strFn1({ kind: "slice", elem: STRING }),
+			Cut: {
+				kind: "func",
+				params: [STRING, STRING],
+				returns: [STRING, STRING, BOOL],
+			},
+			CutPrefix: {
+				kind: "func",
+				params: [STRING, STRING],
+				returns: [STRING, BOOL],
+			},
+			CutSuffix: {
+				kind: "func",
+				params: [STRING, STRING],
+				returns: [STRING, BOOL],
+			},
+			SplitN: strFn3(STRING, INT, { kind: "slice", elem: STRING }),
+			SplitAfter: strFn2(STRING, { kind: "slice", elem: STRING }),
+			SplitAfterN: strFn3(STRING, INT, { kind: "slice", elem: STRING }),
+			IndexAny: strFn2(STRING, INT),
+			LastIndexAny: strFn2(STRING, INT),
+			ContainsAny: strFn2(STRING, BOOL),
+			ContainsRune: strFn2(INT, BOOL),
+			IndexRune: strFn2(INT, INT),
+			IndexByte: strFn2(INT, INT),
+			LastIndexByte: strFn2(INT, INT),
+			Map: {
+				kind: "func",
+				params: [ANY, STRING],
+				returns: [STRING],
+			},
+			Title: strFn1(STRING),
+			ToTitle: strFn1(STRING),
+			TrimFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [STRING],
+			},
+			TrimLeftFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [STRING],
+			},
+			TrimRightFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [STRING],
+			},
+			IndexFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [INT],
+			},
+			LastIndexFunc: {
+				kind: "func",
+				params: [STRING, ANY],
+				returns: [INT],
+			},
+			NewReplacer: {
+				kind: "func",
+				params: [STRING],
+				returns: [ANY],
+				variadic: true,
+			},
+			NewReader: { kind: "func", params: [STRING], returns: [ANY] },
 		},
 	});
 
@@ -205,6 +291,46 @@ export function setupGlobals(globals, types) {
 				params: [{ kind: "slice", elem: BYTE_SLICE }, BYTE_SLICE],
 				returns: [BYTE_SLICE],
 			},
+			ReplaceAll: {
+				kind: "func",
+				params: [BYTE_SLICE, BYTE_SLICE, BYTE_SLICE],
+				returns: [BYTE_SLICE],
+			},
+			TrimPrefix: byFn2(BYTE_SLICE, BYTE_SLICE),
+			TrimSuffix: byFn2(BYTE_SLICE, BYTE_SLICE),
+			TrimLeft: byFn2(STRING, BYTE_SLICE),
+			TrimRight: byFn2(STRING, BYTE_SLICE),
+			TrimFunc: {
+				kind: "func",
+				params: [BYTE_SLICE, ANY],
+				returns: [BYTE_SLICE],
+			},
+			IndexByte: byFn2(INT, INT),
+			LastIndex: byFn2(BYTE_SLICE, INT),
+			LastIndexByte: byFn2(INT, INT),
+			Fields: byFn1({ kind: "slice", elem: BYTE_SLICE }),
+			Cut: {
+				kind: "func",
+				params: [BYTE_SLICE, BYTE_SLICE],
+				returns: [BYTE_SLICE, BYTE_SLICE, BOOL],
+			},
+			ContainsAny: byFn2(STRING, BOOL),
+			ContainsRune: byFn2(INT, BOOL),
+			Map: {
+				kind: "func",
+				params: [ANY, BYTE_SLICE],
+				returns: [BYTE_SLICE],
+			},
+			SplitN: {
+				kind: "func",
+				params: [BYTE_SLICE, BYTE_SLICE, INT],
+				returns: [{ kind: "slice", elem: BYTE_SLICE }],
+			},
+			NewReader: {
+				kind: "func",
+				params: [BYTE_SLICE],
+				returns: [ANY],
+			},
 		},
 	});
 
@@ -241,6 +367,22 @@ export function setupGlobals(globals, types) {
 				params: [STRING],
 				returns: [BOOL, ERROR],
 			},
+			Quote: { kind: "func", params: [STRING], returns: [STRING] },
+			Unquote: {
+				kind: "func",
+				params: [STRING],
+				returns: [STRING, ERROR],
+			},
+			AppendInt: {
+				kind: "func",
+				params: [{ kind: "slice", elem: INT }, INT, INT],
+				returns: [{ kind: "slice", elem: INT }],
+			},
+			AppendFloat: {
+				kind: "func",
+				params: [{ kind: "slice", elem: INT }, FLOAT64, INT, INT, INT],
+				returns: [{ kind: "slice", elem: INT }],
+			},
 		},
 	});
 
@@ -279,6 +421,26 @@ export function setupGlobals(globals, types) {
 				params: [ANY, ANY],
 				returns: [BOOL],
 			},
+			Search: {
+				kind: "func",
+				params: [INT, ANY],
+				returns: [INT],
+			},
+			IntsAreSorted: {
+				kind: "func",
+				params: [{ kind: "slice", elem: INT }],
+				returns: [BOOL],
+			},
+			Float64sAreSorted: {
+				kind: "func",
+				params: [{ kind: "slice", elem: FLOAT64 }],
+				returns: [BOOL],
+			},
+			StringsAreSorted: {
+				kind: "func",
+				params: [{ kind: "slice", elem: STRING }],
+				returns: [BOOL],
+			},
 		},
 	});
 
@@ -327,6 +489,26 @@ export function setupGlobals(globals, types) {
 				returns: [BOOL],
 			},
 			NaN: { kind: "func", params: [], returns: [FLOAT64] },
+			Atan: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Atan2: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
+			Asin: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Acos: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Exp: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Exp2: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Trunc: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+			Hypot: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
+			Signbit: { kind: "func", params: [FLOAT64], returns: [BOOL] },
+			Copysign: {
+				kind: "func",
+				params: [FLOAT64, FLOAT64],
+				returns: [FLOAT64],
+			},
+			Dim: { kind: "func", params: [FLOAT64, FLOAT64], returns: [FLOAT64] },
+			Remainder: {
+				kind: "func",
+				params: [FLOAT64, FLOAT64],
+				returns: [FLOAT64],
+			},
 			// Constants
 			Pi: FLOAT64,
 			E: FLOAT64,
@@ -353,15 +535,57 @@ export function setupGlobals(globals, types) {
 		kind: "namespace",
 		name: "time",
 		members: {
-			Now: { kind: "func", params: [], returns: [ANY] },
-			Since: { kind: "func", params: [ANY], returns: [ANY] },
+			Now: { kind: "func", params: [], returns: [TIME_T] },
+			Since: { kind: "func", params: [TIME_T], returns: [INT] },
 			Sleep: { kind: "func", params: [ANY], returns: [VOID], async: true },
+			Parse: {
+				kind: "func",
+				params: [STRING, STRING],
+				returns: [TIME_T, ERROR],
+			},
+			Unix: { kind: "func", params: [INT, INT], returns: [TIME_T] },
+			Date: {
+				kind: "func",
+				params: [INT, INT, INT, INT, INT, INT, INT, ANY],
+				returns: [TIME_T],
+			},
 			Millisecond: INT,
 			Second: INT,
 			Minute: INT,
 			Hour: INT,
+			// Layout constants
+			RFC3339: STRING,
+			RFC3339Nano: STRING,
+			DateOnly: STRING,
+			TimeOnly: STRING,
+			DateTime: STRING,
+			// Location constants
+			UTC: ANY,
+			Local: ANY,
+			// Month constants
+			January: INT,
+			February: INT,
+			March: INT,
+			April: INT,
+			May: INT,
+			June: INT,
+			July: INT,
+			August: INT,
+			September: INT,
+			October: INT,
+			November: INT,
+			December: INT,
+			// Weekday constants
+			Sunday: INT,
+			Monday: INT,
+			Tuesday: INT,
+			Wednesday: INT,
+			Thursday: INT,
+			Friday: INT,
+			Saturday: INT,
 		},
 	});
+	types.set("time.Time", TIME_T);
 
 	// unicode package
 	const runeToStr = { kind: "func", params: [INT], returns: [BOOL] };
@@ -455,22 +679,30 @@ export function setupGlobals(globals, types) {
 	// io package — Writer interface + WriteString
 	// io.Writer is typed as ANY so GoFront's built-in writer types (strings.Builder,
 	// bytes.Buffer) are accepted without explicit interface-satisfaction registration.
+	const BYTE_SLICE_IO = { kind: "slice", elem: INT };
 	globals.define("io", {
 		kind: "namespace",
 		name: "io",
 		members: {
 			Writer: ANY,
+			Reader: ANY,
 			EOF: ERROR,
 			WriteString: {
 				kind: "func",
 				params: [ANY, STRING],
 				returns: [INT, ERROR],
 			},
+			ReadAll: {
+				kind: "func",
+				params: [ANY],
+				returns: [BYTE_SLICE_IO, ERROR],
+			},
 			Discard: ANY,
 		},
 	});
 	// Register io.Writer as a type alias so it resolves in parameter/field annotations.
 	types.set("io.Writer", ANY);
+	types.set("io.Reader", ANY);
 
 	// gom package — browser-native component built-in
 	const GOM_NODE_T = {
@@ -742,6 +974,77 @@ export function setupGlobals(globals, types) {
 		},
 	});
 
+	// math/rand package — import "math/rand" → local name "rand"
+	globals.define("rand", {
+		kind: "namespace",
+		name: "rand",
+		members: {
+			Intn: { kind: "func", params: [INT], returns: [INT] },
+			Float64: { kind: "func", params: [], returns: [FLOAT64] },
+			Float32: { kind: "func", params: [], returns: [FLOAT64] },
+			Int: { kind: "func", params: [], returns: [INT] },
+			Int63: { kind: "func", params: [], returns: [INT] },
+			Int63n: { kind: "func", params: [INT], returns: [INT] },
+			Int31: { kind: "func", params: [], returns: [INT] },
+			Int31n: { kind: "func", params: [INT], returns: [INT] },
+			Seed: { kind: "func", params: [INT], returns: [VOID] },
+			Shuffle: { kind: "func", params: [INT, ANY], returns: [VOID] },
+			Perm: {
+				kind: "func",
+				params: [INT],
+				returns: [{ kind: "slice", elem: INT }],
+			},
+		},
+	});
+
+	// unicode/utf8 package — import "unicode/utf8" → local name "utf8"
+	globals.define("utf8", {
+		kind: "namespace",
+		name: "utf8",
+		members: {
+			RuneCountInString: { kind: "func", params: [STRING], returns: [INT] },
+			RuneLen: { kind: "func", params: [INT], returns: [INT] },
+			ValidString: { kind: "func", params: [STRING], returns: [BOOL] },
+			ValidRune: { kind: "func", params: [INT], returns: [BOOL] },
+			DecodeRuneInString: {
+				kind: "func",
+				params: [STRING],
+				returns: [INT, INT],
+			},
+			DecodeLastRuneInString: {
+				kind: "func",
+				params: [STRING],
+				returns: [INT, INT],
+			},
+			FullRuneInString: { kind: "func", params: [STRING], returns: [BOOL] },
+			// Constants
+			RuneError: INT,
+			MaxRune: INT,
+			UTFMax: INT,
+		},
+	});
+
+	// path package — import "path" or "path/filepath" → local name "path"
+	globals.define("path", {
+		kind: "namespace",
+		name: "path",
+		members: {
+			Base: { kind: "func", params: [STRING], returns: [STRING] },
+			Dir: { kind: "func", params: [STRING], returns: [STRING] },
+			Ext: { kind: "func", params: [STRING], returns: [STRING] },
+			Join: {
+				kind: "func",
+				params: [STRING],
+				returns: [STRING],
+				variadic: true,
+			},
+			Clean: { kind: "func", params: [STRING], returns: [STRING] },
+			IsAbs: { kind: "func", params: [STRING], returns: [BOOL] },
+			Split: { kind: "func", params: [STRING], returns: [STRING, STRING] },
+			Match: { kind: "func", params: [STRING, STRING], returns: [BOOL, ERROR] },
+		},
+	});
+
 	// Built-in functions
 	globals.define("append", { kind: "builtin", name: "append" });
 	globals.define("len", { kind: "builtin", name: "len" });

package/src/typechecker/types.js

@@ -93,14 +93,6 @@ export const BASIC_TYPES = {
 
 export const COMPARABLE = { kind: "basic", name: "comparable" };
 
-export function isTypeParam(t) {
-	return t?.kind === "typeParam";
-}
-
-export function isGeneric(t) {
-	return t?.kind === "generic";
-}
-
 function makeBasicPredicate(...names) {
 	const set = new Set(names);
 	const pred = (t) => {
@@ -137,13 +129,6 @@ export function isNil(t) {
 export function isVoid(t) {
 	return t?.kind === "basic" && t.name === "void";
 }
-export function isError(t) {
-	if (!t) return false;
-	if (t === ERROR) return true;
-	if (t.kind === "interface" && t.name === "error") return true;
-	if (t.kind === "named" && isError(t.underlying)) return true;
-	return false;
-}
 export function isPointer(t) {
 	if (!t) return false;
 	if (t.kind === "pointer") return true;