goscript 0.2.5 → 0.2.7

package/gs/net/http/meta.json

@@ -4,8 +4,11 @@
     "Head": true,
     "Post": true,
     "PostForm": true,
+    "ReadRequest": true,
+    "ReadResponse": true,
     "Redirect": true,
     "ServeContent": true,
+    "ServeFileFS": true,
     "SetCookie": true
   },
   "asyncMethods": {

package/gs/os/stat.gs.ts

@@ -9,7 +9,7 @@ export function Stat(name: string): [null | {
 	ModTime(): any
 	Mode(): any
 	Name(): string
-	Size(): number
+	Size(): bigint
 	Sys(): null | any
 }, $.GoError] {
 	// testlog.Stat(name) // Testlog not available in JavaScript
@@ -29,7 +29,7 @@ export function Lstat(name: string): [null | {
 	ModTime(): Time
 	Mode(): FileMode
 	Name(): string
-	Size(): number
+	Size(): bigint
 	Sys(): null | any
 }, $.GoError] {
 	// testlog.Stat(name) // Testlog not available in JavaScript

package/gs/os/types.gs.ts

@@ -73,8 +73,8 @@ export class File {
 		return [0, ErrUnimplemented]
 	}
 
-	public Seek(offset: number, whence: number): [number, $.GoError] {
-		return [0, ErrUnimplemented]
+	public Seek(offset: bigint, whence: number): [bigint, $.GoError] {
+		return [0n, ErrUnimplemented]
 	}
 
 	public WriteString(s: string): [number, $.GoError] {

package/gs/os/types_js.gs.ts

@@ -163,7 +163,7 @@ class hostFileInfo {
 
 	constructor(init?: Partial<{modTime?: time.Time, mode?: fs.FileMode, name?: string, size?: number, sys?: HostStatLike | null}>) {
 		this.name = init?.name ?? ""
-		this.modTime = init?.modTime ?? time.Unix(0, 0)
+		this.modTime = init?.modTime ?? time.Unix(0n, 0n)
 		this.mode = init?.mode ?? 0
 		this.size = init?.size ?? 0
 		this.sys = init?.sys ?? null
@@ -185,8 +185,8 @@ class hostFileInfo {
 		return this.name
 	}
 
-	public Size(): number {
-		return this.size
+	public Size(): bigint {
+		return BigInt(this.size)
 	}
 
 	public Sys(): HostStatLike | null {
@@ -212,10 +212,10 @@ export function createFileInfo(name: string, stat: HostStatLike): fs.FileInfo {
 	}
 
 	return new hostFileInfo({
-		modTime: time.UnixMilli(mtimeMs),
+		modTime: time.UnixMilli(BigInt(Math.trunc(mtimeMs))),
 		mode,
 		name: normalizedName,
-		size: stat.size ?? 0,
+		size: Math.trunc(stat.size ?? 0),
 		sys: stat,
 	})
 }
@@ -589,15 +589,15 @@ export class File {
 		}
 	}
 
-	public Seek(offset: number, whence: number): [number, $.GoError] {
+	public Seek(offset: bigint, whence: number): [bigint, $.GoError] {
 		const handle = this.file?.handle
 		if (!handle || typeof handle.seekSync !== "function") {
-			return [0, ErrUnimplemented]
+			return [0n, ErrUnimplemented]
 		}
 		try {
-			return [handle.seekSync(offset, whence), null]
+			return [BigInt(handle.seekSync(Number(offset), whence)), null]
 		} catch (err) {
-			return [0, newHostError(err)]
+			return [0n, newHostError(err)]
 		}
 	}
 

package/gs/os/types_unix.gs.ts

@@ -82,9 +82,9 @@ class fileStat {
 		return (fileStat!.Mode() & fs.ModeDir) !== 0
 	}
 
-	public Size(): number {
+	public Size(): bigint {
 		const fs = this
-		return fs!.size
+		return BigInt(fs!.size)
 	}
 
 	public Mode(): fs.FileMode {

package/gs/os/zero_copy_posix.gs.ts

@@ -20,9 +20,9 @@ export function wrapSyscallError(name: string, err: $.GoError): $.GoError {
 // tryLimitedReader tries to assert the io.Reader to io.LimitedReader, it returns the io.LimitedReader,
 // the underlying io.Reader and the remaining amount of bytes if the assertion succeeds,
 // otherwise it just returns the original io.Reader and the theoretical unlimited remaining amount of bytes.
-export function tryLimitedReader(r: io.Reader): [io.LimitedReader | null, io.Reader, number] {
+export function tryLimitedReader(r: io.Reader): [io.LimitedReader | null, io.Reader, bigint] {
 	// by default, copy until EOF
-	let remain: number = Number.MAX_SAFE_INTEGER - 1
+	let remain: bigint = (1n << 63n) - 1n
 
 	let { value: lr, ok: ok } = $.typeAssert<io.LimitedReader | null>(r, {kind: $.TypeKind.Pointer, elemType: 'io.LimitedReader'})
 	if (!ok) {

package/gs/path/filepath/match.test.ts

@@ -173,6 +173,22 @@ describe('path/filepath - Pattern matching functions', () => {
         expect(err1).toBeNull()
         expect(match1).toBe(false)
       })
+
+      it('should not let a star cross a path separator', () => {
+        // Go: '*' matches a non-Separator run only.
+        const [m1, e1] = Match('*c', 'a/c')
+        expect(e1).toBeNull()
+        expect(m1).toBe(false)
+
+        const [m2, e2] = Match('*', 'a/b')
+        expect(e2).toBeNull()
+        expect(m2).toBe(false)
+
+        // A star can still consume the run right up to a separator.
+        const [m3, e3] = Match('*/c', 'a/c')
+        expect(e3).toBeNull()
+        expect(m3).toBe(true)
+      })
     })
 
     describe('Error cases', () => {

package/gs/path/filepath/match.ts

@@ -102,20 +102,24 @@ function matchPattern(pattern: string, name: string): boolean {
 
     switch (p) {
       case '*':
-        // Handle star - match any sequence of characters
+        // Handle star - match any sequence of non-Separator characters.
         patternIndex++
         if (patternIndex >= pattern.length) {
-          // Pattern ends with *, matches rest of name
-          return true
+          // Trailing * matches the rest of name unless it crosses a separator.
+          return name.substring(nameIndex).indexOf('/') < 0
         }
 
-        // Try to match the rest of the pattern with remaining name
+        // Try to match the rest of the pattern with remaining name, but the
+        // star cannot consume a separator (Go matches non-Separator runs only).
         for (let i = nameIndex; i <= name.length; i++) {
           if (
             matchPattern(pattern.substring(patternIndex), name.substring(i))
           ) {
             return true
           }
+          if (i < name.length && name[i] === '/') {
+            break
+          }
         }
         return false
 

package/gs/path/filepath/path.test.ts

@@ -1,5 +1,12 @@
 import { describe, it, expect } from 'vitest'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import {
@@ -18,6 +25,7 @@ import {
   HasPrefix,
   Abs,
   Rel,
+  Localize,
   EvalSymlinks,
   Walk,
   WalkDir,
@@ -177,9 +185,11 @@ describe('path/filepath - Path manipulation functions', () => {
       expect(err1).toBeNull()
       expect(result1).toBe('/absolute/path')
 
+      // A relative path is joined against the real working directory, matching
+      // Go's filepath.Abs (os.Getwd), not a fabricated root.
       const [result2, err2] = Abs('relative/path')
       expect(err2).toBeNull()
-      expect(result2).toBe('/relative/path')
+      expect(result2).toBe(Join(process.cwd(), 'relative/path'))
     })
   })
 
@@ -193,17 +203,66 @@ describe('path/filepath - Path manipulation functions', () => {
       expect(err2).toBeNull()
       expect(result2).toBe('bin')
 
+      // Go emits ".." components to climb out of base before descending into
+      // the divergent target tail.
       const [result3, err3] = Rel('/usr/local', '/other/path')
       expect(err3).toBeNull()
-      expect(result3).toBe('/other/path')
+      expect(result3).toBe('../../other/path')
+
+      const [result4, err4] = Rel('/a/b', '/a/c')
+      expect(err4).toBeNull()
+      expect(result4).toBe('../c')
+
+      const [result5, err5] = Rel('a/b', 'a/c')
+      expect(err5).toBeNull()
+      expect(result5).toBe('../c')
+
+      // A relative base cannot be made relative to an absolute target.
+      const [, err6] = Rel('a/b', '/a/c')
+      expect(err6).not.toBeNull()
+    })
+  })
+
+  describe('Localize', () => {
+    it('should accept io/fs.ValidPath inputs and reject the rest', () => {
+      const [ok, okErr] = Localize('a/b')
+      expect(okErr).toBeNull()
+      expect(ok).toBe('a/b')
+
+      const [dot, dotErr] = Localize('.')
+      expect(dotErr).toBeNull()
+      expect(dot).toBe('.')
+
+      for (const bad of ['', '/a', '../a', 'a/../b', 'a/']) {
+        const [, err] = Localize(bad)
+        expect(err).not.toBeNull()
+      }
     })
   })
 
   describe('EvalSymlinks', () => {
-    it('should return cleaned path (stubbed)', () => {
-      const [result, err] = EvalSymlinks('/path/with/../dots')
-      expect(err).toBeNull()
-      expect(result).toBe('/path/dots')
+    it('should resolve symlinks against the host filesystem', () => {
+      // realpathSync canonicalizes the temp root (macOS /var -> /private/var) so
+      // the expected resolved path uses the same canonical base.
+      const root = realpathSync(
+        mkdtempSync(join(tmpdir(), 'goscript-filepath-eval-')),
+      )
+      try {
+        mkdirSync(join(root, 'real'))
+        writeFileSync(join(root, 'real', 'file.txt'), 'ok')
+        symlinkSync(join(root, 'real'), join(root, 'link'))
+
+        const [result, err] = EvalSymlinks(join(root, 'link', 'file.txt'))
+        expect(err).toBeNull()
+        expect(result).toBe(join(root, 'real', 'file.txt'))
+      } finally {
+        rmSync(root, { force: true, recursive: true })
+      }
+    })
+
+    it('should error when a path component does not exist', () => {
+      const [, err] = EvalSymlinks('/goscript-nonexistent-xyz/file')
+      expect(err).not.toBeNull()
     })
   })
 
@@ -226,6 +285,28 @@ describe('path/filepath - Path manipulation functions', () => {
         rmSync(root, { force: true, recursive: true })
       }
     })
+
+    it('should not descend into a symlinked directory (Lstat walk)', async () => {
+      const root = mkdtempSync(join(tmpdir(), 'goscript-filepath-walklink-'))
+      try {
+        mkdirSync(join(root, 'real'))
+        writeFileSync(join(root, 'real', 'inside.txt'), 'ok')
+        symlinkSync(join(root, 'real'), join(root, 'link'))
+
+        const visited: string[] = []
+        const err = await Walk(root, (path) => {
+          visited.push(path.slice(root.length).replace(/^\/?/, '') || '.')
+          return null
+        })
+
+        expect(err).toBeNull()
+        // The symlink is visited but not traversed, so link/inside.txt never
+        // appears.
+        expect(visited).toEqual(['.', 'link', 'real', 'real/inside.txt'])
+      } finally {
+        rmSync(root, { force: true, recursive: true })
+      }
+    })
   })
 
   describe('WalkDir', () => {
@@ -296,9 +377,10 @@ describe('Complex path operations', () => {
     expect(Clean('a/b/../../c')).toBe('c')
     expect(Clean('../../a/b')).toBe('../../a/b')
 
-    // Test Join with various inputs
+    // Test Join with various inputs. A later absolute element does not discard
+    // earlier elements; Go joins the suffix and Clean collapses double slashes.
     expect(Join('/a', '../b', 'c')).toBe('/b/c')
-    expect(Join('a', '/b', 'c')).toBe('/b/c')
+    expect(Join('a', '/b', 'c')).toBe('a/b/c')
 
     // Test Split edge cases
     expect(Split('/a/')).toEqual(['/a/', ''])

package/gs/path/filepath/path.ts

@@ -1,8 +1,12 @@
 // Package filepath implements utility routines for manipulating filename paths
 // in a way compatible with the target operating system-defined file paths.
 import * as $ from '@goscript/builtin/index.js'
-import { getHostRuntime } from '@goscript/builtin/hostio.js'
+import {
+  getCurrentWorkingDirectory,
+  getHostRuntime,
+} from '@goscript/builtin/hostio.js'
 import type { DirEntry } from '@goscript/io/fs/fs.js'
+import { ValidPath } from '@goscript/io/fs/fs.js'
 import { FileInfoToDirEntry } from '@goscript/io/fs/readdir.js'
 
 type JoinElement = string | $.Slice<string>
@@ -142,32 +146,15 @@ export function Clean(path: string): string {
 // an empty string.
 export function Join(...elem: JoinElement[]): string {
   const partsArg = normalizeJoinElements(elem)
-  if (partsArg.length === 0) {
-    return ''
-  }
-
-  // Filter out empty elements but handle absolute paths
-  const parts: string[] = []
-
-  for (const e of partsArg) {
-    if (e === '') {
-      continue
+  // Join all elements from the first non-empty one onward, then Clean. A later
+  // absolute element does not discard earlier elements (Go joins the suffix and
+  // lets Clean collapse the resulting double separators).
+  for (let i = 0; i < partsArg.length; i++) {
+    if (partsArg[i] !== '') {
+      return Clean(partsArg.slice(i).join('/'))
     }
-
-    // If this element is absolute, start over from here
-    if (IsAbs(e)) {
-      parts.length = 0 // Clear previous parts
-      parts.push(e)
-    } else {
-      parts.push(e)
-    }
-  }
-
-  if (parts.length === 0) {
-    return ''
   }
-
-  return Clean(parts.join('/'))
+  return ''
 }
 
 // Split splits path immediately following the final Separator,
@@ -278,38 +265,183 @@ export function HasPrefix(p: string, prefix: string): boolean {
   return false
 }
 
-// Stubs for functions that require filesystem operations
-// These are simplified implementations for compatibility
-
+// Abs returns an absolute representation of path. If the path is not absolute
+// it is joined with the current working directory to turn it into an absolute
+// path, then Cleaned. This mirrors Go's filepath.Abs, which calls os.Getwd for
+// relative inputs rather than fabricating a root.
 export function Abs(path: string): [string, $.GoError] {
   if (IsAbs(path)) {
     return [Clean(path), null]
   }
-  // In a real implementation, this would resolve relative to current working directory
-  // For our purposes, we'll just prepend a fake absolute path
-  return ['/' + Clean(path), null]
+  const wd = getCurrentWorkingDirectory()
+  if (wd === null) {
+    return ['', $.newError('filepath: cannot determine working directory')]
+  }
+  return [Join(wd, path), null]
 }
 
 export function Rel(basepath: string, targpath: string): [string, $.GoError] {
-  // Simplified implementation - in reality this is much more complex
   const base = Clean(basepath)
   const targ = Clean(targpath)
-
-  if (base === targ) {
+  if (targ === base) {
     return ['.', null]
   }
 
-  // Very basic relative path calculation
-  if (targ.startsWith(base + '/')) {
-    return [targ.substring(base.length + 1), null]
+  const b = base === '.' ? '' : base
+  const t = targ === '.' ? '' : targ
+  const baseSlashed = b.length > 0 && b[0] === '/'
+  const targSlashed = t.length > 0 && t[0] === '/'
+  if (baseSlashed !== targSlashed) {
+    return [
+      '',
+      $.newError(`Rel: can't make ${targpath} relative to ${basepath}`),
+    ]
+  }
+
+  // Walk both paths element by element until they first differ.
+  const bl = b.length
+  const tl = t.length
+  let b0 = 0
+  let bi = 0
+  let t0 = 0
+  let ti = 0
+  for (;;) {
+    while (bi < bl && b[bi] !== '/') {
+      bi++
+    }
+    while (ti < tl && t[ti] !== '/') {
+      ti++
+    }
+    if (t.slice(t0, ti) !== b.slice(b0, bi)) {
+      break
+    }
+    if (bi < bl) {
+      bi++
+    }
+    if (ti < tl) {
+      ti++
+    }
+    b0 = bi
+    t0 = ti
+  }
+  if (b.slice(b0, bi) === '..') {
+    return [
+      '',
+      $.newError(`Rel: can't make ${targpath} relative to ${basepath}`),
+    ]
+  }
+
+  if (b0 !== bl) {
+    // Base elements remain; emit one ".." per leftover base element, then the
+    // remaining target tail.
+    let seps = 0
+    for (let i = b0; i < bl; i++) {
+      if (b[i] === '/') {
+        seps++
+      }
+    }
+    let out = '..'
+    for (let i = 0; i < seps; i++) {
+      out += '/..'
+    }
+    if (t0 !== tl) {
+      out += '/' + t.slice(t0)
+    }
+    return [out, null]
   }
-
-  return [targ, null]
+  return [t.slice(t0), null]
 }
 
+// EvalSymlinks returns the path name after the evaluation of any symbolic
+// links. This is a lexical port of Go's path/filepath walkSymlinks: it resolves
+// each component with Lstat and follows symlinks with Readlink, preserving the
+// relative-vs-absolute shape of the input. It deliberately does not use a host
+// realpath, which would always force an absolute result and would not surface
+// Go's per-component ENOTDIR and link-cycle errors. volLen is 0 for a relative
+// input and 1 for an absolute root.
 export function EvalSymlinks(path: string): [string, $.GoError] {
-  // No filesystem support, just return the cleaned path
-  return [Clean(path), null]
+  let p = path
+  const volLen = p.length > 0 && p[0] === '/' ? 1 : 0
+  const vol = p.slice(0, volLen)
+  let dest = vol
+  let linksWalked = 0
+  for (let start = volLen; start < p.length; ) {
+    while (start < p.length && p[start] === '/') {
+      start++
+    }
+    let end = start
+    while (end < p.length && p[end] !== '/') {
+      end++
+    }
+
+    const component = p.slice(start, end)
+    if (end === start) {
+      break
+    } else if (component === '.') {
+      start = end
+      continue
+    } else if (component === '..') {
+      // Back up to the previous component unless it is itself a kept "..".
+      let r = dest.length - 1
+      for (; r >= volLen; r--) {
+        if (dest[r] === '/') {
+          break
+        }
+      }
+      if (r < volLen || dest.slice(r + 1) === '..') {
+        if (dest.length > volLen) {
+          dest += '/'
+        }
+        dest += '..'
+      } else {
+        dest = dest.slice(0, r)
+      }
+      start = end
+      continue
+    }
+
+    if (dest.length > volLen && dest[dest.length - 1] !== '/') {
+      dest += '/'
+    }
+    dest += component
+
+    const [stat, statErr] = lstatPath(dest)
+    if (statErr !== null) {
+      return ['', statErr]
+    }
+    if (!statIsSymlink(stat!)) {
+      if (!statIsDir(stat!) && end < p.length) {
+        return ['', $.newError('not a directory')]
+      }
+      start = end
+      continue
+    }
+
+    linksWalked++
+    if (linksWalked > 255) {
+      return ['', $.newError('EvalSymlinks: too many links')]
+    }
+    const [link, linkErr] = readlinkPath(dest)
+    if (linkErr !== null) {
+      return ['', linkErr]
+    }
+    p = link! + p.slice(end)
+    if (link!.length > 0 && link![0] === '/') {
+      // Absolute symlink target: restart from the root.
+      dest = '/'
+    } else {
+      // Relative symlink target: replace the last component of dest.
+      let r = dest.length - 1
+      for (; r >= volLen; r--) {
+        if (dest[r] === '/') {
+          break
+        }
+      }
+      dest = r < volLen ? vol : dest.slice(0, r)
+    }
+    start = 0
+  }
+  return [Clean(dest), null]
 }
 
 export function Glob(_pattern: string): [string[], $.GoError] {
@@ -345,8 +477,13 @@ export async function WalkDir(
   return await walkDirHost(root, walkFn)
 }
 
-// Localize is a stub - in Go it's used for Windows path localization
+// Localize converts a slash-separated path into an operating system path.
+// The input must be a valid path as reported by io/fs.ValidPath. On a
+// Unix-like target the only further restriction is the absence of a NUL byte.
 export function Localize(path: string): [string, $.GoError] {
+  if (!ValidPath(path) || path.indexOf('\x00') >= 0) {
+    return ['', $.newError('invalid path')]
+  }
   return [path, null]
 }
 
@@ -377,6 +514,13 @@ function statIsDir(stat: HostStat): boolean {
   return !!stat.isDirectory
 }
 
+function statIsSymlink(stat: any): boolean {
+  if (typeof stat?.isSymbolicLink === 'function') {
+    return stat.isSymbolicLink()
+  }
+  return !!stat?.isSymlink
+}
+
 function fileInfo(path: string, stat: HostStat): any {
   return {
     IsDir: () => statIsDir(stat),
@@ -392,20 +536,50 @@ function dirEntry(path: string, stat: HostStat): DirEntry {
   return FileInfoToDirEntry(fileInfo(path, stat))
 }
 
-function statPath(path: string): [HostStat | null, $.GoError] {
+// lstatPath stats a path without following a terminal symlink, matching Go's
+// Walk/WalkDir, which Lstat every entry so a symlinked directory is reported as
+// a symlink and is never descended into. Falls back to stat only when the host
+// exposes no lstat.
+function lstatPath(path: string): [HostStat | null, $.GoError] {
+  const runtime = getHostRuntime()
+  const deno = runtime.deno
+  const denoStat = deno?.lstatSync ?? deno?.statSync
+  if (denoStat) {
+    try {
+      return [denoStat.call(deno, path), null]
+    } catch (err) {
+      return [null, hostError(err)]
+    }
+  }
+
+  const nodeFS = runtime.nodeFS
+  const nodeStat = nodeFS?.lstatSync ?? nodeFS?.statSync
+  if (nodeStat) {
+    try {
+      return [nodeStat.call(nodeFS, path), null]
+    } catch (err) {
+      return [null, hostError(err)]
+    }
+  }
+
+  return [null, $.newError('filesystem not supported')]
+}
+
+function readlinkPath(path: string): [string | null, $.GoError] {
   const runtime = getHostRuntime()
-  if (runtime.deno?.statSync) {
+  const deno = runtime.deno
+  if (deno?.readLinkSync) {
     try {
-      return [runtime.deno.statSync(path), null]
+      return [deno.readLinkSync(path), null]
     } catch (err) {
       return [null, hostError(err)]
     }
   }
 
   const nodeFS = runtime.nodeFS
-  if (nodeFS?.statSync) {
+  if (nodeFS?.readlinkSync) {
     try {
-      return [nodeFS.statSync(path), null]
+      return [String(nodeFS.readlinkSync(path)), null]
     } catch (err) {
       return [null, hostError(err)]
     }
@@ -452,7 +626,7 @@ function readDir(path: string): [HostEntry[] | null, $.GoError] {
 }
 
 async function walkHost(path: string, walkFn: WalkFunc): Promise<$.GoError> {
-  const [stat, statErr] = statPath(path)
+  const [stat, statErr] = lstatPath(path)
   if (statErr !== null) {
     return await walkFn(path, null, statErr)
   }
@@ -514,7 +688,7 @@ async function walkDirHost(
   path: string,
   walkFn: WalkDirFunc,
 ): Promise<$.GoError> {
-  const [stat, statErr] = statPath(path)
+  const [stat, statErr] = lstatPath(path)
   if (statErr !== null) {
     return normalizeRootWalkDirErr(await walkFn(path, null, statErr))
   }