goscript 0.0.82 → 0.0.84

package/gs/builtin/hostio.ts

@@ -0,0 +1,298 @@
+export class HostUnsupportedError extends Error {
+  constructor() {
+    super('operation not implemented in JavaScript environment')
+  }
+}
+
+export type NodeFSModule = {
+  readSync(
+    fd: number,
+    buffer: Uint8Array,
+    offset?: number,
+    length?: number,
+    position?: number | null,
+  ): number
+  writeSync(
+    fd: number,
+    buffer: Uint8Array,
+    offset?: number,
+    length?: number,
+    position?: number | null,
+  ): number
+  closeSync?(fd: number): void
+  fstatSync?(fd: number): any
+  fsyncSync?(fd: number): void
+  ftruncateSync?(fd: number, len?: number): void
+  openSync?(path: string, flags: number | string, mode?: number): number
+  chmodSync?(path: string, mode: number): void
+  chownSync?(path: string, uid: number, gid: number): void
+  lchownSync?(path: string, uid: number, gid: number): void
+  linkSync?(existingPath: string, newPath: string): void
+  lstatSync?(path: string): any
+  mkdirSync?(path: string, options?: number | { mode?: number; recursive?: boolean }): void
+  readFileSync?(path: string): Uint8Array
+  readdirSync?(path: string, options?: { withFileTypes?: boolean }): any[]
+  readlinkSync?(path: string): string
+  renameSync?(oldPath: string, newPath: string): void
+  rmSync?(path: string, options?: { force?: boolean; recursive?: boolean }): void
+  rmdirSync?(path: string): void
+  statSync?(path: string): any
+  symlinkSync?(target: string, path: string): void
+  truncateSync?(path: string, len?: number): void
+  unlinkSync?(path: string): void
+  utimesSync?(path: string, atime: Date | number, mtime: Date | number): void
+  writeFileSync?(path: string, data: Uint8Array, options?: { mode?: number }): void
+}
+
+export type DenoStream = {
+  readSync?(buffer: Uint8Array): number | null
+  writeSync?(buffer: Uint8Array): number
+}
+
+export type DenoFileLike = DenoStream & {
+  close?(): void
+  rid?: number
+  seekSync?(offset: number, whence: number): number
+  syncSync?(): void
+  statSync?(): any
+  truncateSync?(len?: number): void
+}
+
+type HostReadFD = (fd: number, buffer: Uint8Array) => number | null
+type HostWriteFD = (fd: number, buffer: Uint8Array) => number
+type HostTextWrite = (data: string) => void
+
+export type HostRuntime = {
+  deno: any | null
+  nodeFS: NodeFSModule | null
+  platform: string
+  processObj: any | null
+  getEnv(name: string): string
+  getStdioHandle(fd: number): DenoFileLike | null
+  readFD: HostReadFD
+  writeFD: HostWriteFD
+  writeStderrText: HostTextWrite
+  writeStdoutText: HostTextWrite
+}
+
+const encoder = new TextEncoder()
+
+function getDynamicRequire(): ((specifier: string) => unknown) | null {
+  try {
+    return Function(
+      "return typeof require !== 'undefined' ? require : null",
+    )() as ((specifier: string) => unknown) | null
+  } catch {
+    return null
+  }
+}
+
+function writeAllSync(
+  writeChunk: (chunk: Uint8Array) => number,
+  buffer: Uint8Array,
+): number {
+  let offset = 0
+  while (offset < buffer.length) {
+    const n = writeChunk(buffer.subarray(offset))
+    if (!Number.isFinite(n) || n < 0) {
+      throw new Error(`invalid write result: ${n}`)
+    }
+    if (n === 0) {
+      throw new Error('short write')
+    }
+    offset += n
+  }
+  return buffer.length
+}
+
+function writeAllText(
+  writeChunk: (chunk: Uint8Array) => number,
+  data: string,
+): void {
+  const bytes = encoder.encode(data)
+  if (bytes.length === 0) {
+    return
+  }
+  writeAllSync(writeChunk, bytes)
+}
+
+function detectNodeFS(processObj: any | null): NodeFSModule | null {
+  if (processObj && typeof processObj.getBuiltinModule === 'function') {
+    const module = processObj.getBuiltinModule('fs')
+    if (
+      module &&
+      typeof module.readSync === 'function' &&
+      typeof module.writeSync === 'function'
+    ) {
+      return module as NodeFSModule
+    }
+  }
+
+  const requireFn = getDynamicRequire()
+  if (requireFn) {
+    for (const specifier of ['node:fs', 'fs']) {
+      try {
+        const module = requireFn(specifier) as NodeFSModule | null
+        if (
+          module &&
+          typeof module.readSync === 'function' &&
+          typeof module.writeSync === 'function'
+        ) {
+          return module
+        }
+      } catch {
+        // Try the next fallback.
+      }
+    }
+  }
+
+  return null
+}
+
+function unsupportedReadFD(_fd: number, _buffer: Uint8Array): number | null {
+  throw new HostUnsupportedError()
+}
+
+function unsupportedWriteFD(_fd: number, _buffer: Uint8Array): number {
+  throw new HostUnsupportedError()
+}
+
+function fallbackConsoleWriter(method: 'error' | 'log'): HostTextWrite {
+  return (data: string) => {
+    const consoleMethod = (globalThis as any).console?.[method]
+    if (!consoleMethod) {
+      return
+    }
+    if (data.endsWith('\n')) {
+      consoleMethod.call((globalThis as any).console, data.slice(0, -1))
+      return
+    }
+    consoleMethod.call((globalThis as any).console, data)
+  }
+}
+
+function detectHostRuntime(): HostRuntime {
+  const globalObj = globalThis as any
+  const deno = globalObj.Deno ?? null
+  const processObj = globalObj.process ?? null
+  const nodeFS = detectNodeFS(processObj)
+
+  const getStdioHandle = (fd: number): DenoFileLike | null => {
+    if (!deno) {
+      return null
+    }
+    switch (fd) {
+      case 0:
+        return deno.stdin ?? null
+      case 1:
+        return deno.stdout ?? null
+      case 2:
+        return deno.stderr ?? null
+      default:
+        return null
+    }
+  }
+
+  const platform =
+    deno?.build?.os ??
+    processObj?.platform ??
+    'unknown'
+
+  const getEnv = (name: string): string => {
+    if (deno?.env?.get) {
+      try {
+        return deno.env.get(name) ?? ''
+      } catch {
+        return ''
+      }
+    }
+    return processObj?.env?.[name] ?? ''
+  }
+
+  let readFD: HostReadFD = unsupportedReadFD
+  let writeFD: HostWriteFD = unsupportedWriteFD
+  let writeStdoutText: HostTextWrite = fallbackConsoleWriter('log')
+  let writeStderrText: HostTextWrite = fallbackConsoleWriter('error')
+
+  if (deno) {
+    readFD = (fd: number, buffer: Uint8Array): number | null => {
+      const handle = getStdioHandle(fd)
+      if (!handle || typeof handle.readSync !== 'function') {
+        throw new HostUnsupportedError()
+      }
+      return handle.readSync(buffer)
+    }
+    writeFD = (fd: number, buffer: Uint8Array): number => {
+      const handle = getStdioHandle(fd)
+      if (!handle || typeof handle.writeSync !== 'function') {
+        throw new HostUnsupportedError()
+      }
+      return writeAllSync(
+        (chunk: Uint8Array) => handle.writeSync!(chunk),
+        buffer,
+      )
+    }
+    writeStdoutText = (data: string) => {
+      const handle = getStdioHandle(1)
+      if (!handle || typeof handle.writeSync !== 'function') {
+        fallbackConsoleWriter('log')(data)
+        return
+      }
+      writeAllText((chunk: Uint8Array) => handle.writeSync!(chunk), data)
+    }
+    writeStderrText = (data: string) => {
+      const handle = getStdioHandle(2)
+      if (!handle || typeof handle.writeSync !== 'function') {
+        fallbackConsoleWriter('error')(data)
+        return
+      }
+      writeAllText((chunk: Uint8Array) => handle.writeSync!(chunk), data)
+    }
+  } else if (nodeFS) {
+    readFD = (fd: number, buffer: Uint8Array): number | null =>
+      nodeFS.readSync(fd, buffer, 0, buffer.length, null)
+    writeFD = (fd: number, buffer: Uint8Array): number =>
+      writeAllSync(
+        (chunk: Uint8Array) =>
+          nodeFS.writeSync(fd, chunk, 0, chunk.length, null),
+        buffer,
+      )
+    writeStdoutText = (data: string) =>
+      writeAllText(
+        (chunk: Uint8Array) => nodeFS.writeSync(1, chunk, 0, chunk.length, null),
+        data,
+      )
+    writeStderrText = (data: string) =>
+      writeAllText(
+        (chunk: Uint8Array) => nodeFS.writeSync(2, chunk, 0, chunk.length, null),
+        data,
+      )
+  }
+
+  return {
+    deno,
+    getEnv,
+    getStdioHandle,
+    nodeFS,
+    platform,
+    processObj,
+    readFD,
+    writeFD,
+    writeStderrText,
+    writeStdoutText,
+  }
+}
+
+export let hostRuntime = detectHostRuntime()
+
+export function resetHostRuntimeForTests(): void {
+  hostRuntime = detectHostRuntime()
+}
+
+export function writeHostStdoutText(data: string): void {
+  hostRuntime.writeStdoutText(data)
+}
+
+export function writeHostStderrText(data: string): void {
+  hostRuntime.writeStderrText(data)
+}

package/gs/builtin/print.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest'
+
+import { formatPrintedArgs } from './print.js'
+
+describe('builtin println formatting', () => {
+  it('formats Uint8Array values with a stable inspect-style representation', () => {
+    expect(
+      formatPrintedArgs(['b2:', new Uint8Array([72, 101, 108, 108, 111])]),
+    ).toBe('b2: Uint8Array(5) [ 72, 101, 108, 108, 111 ]')
+  })
+
+  it('quotes nested string array elements', () => {
+    expect(formatPrintedArgs(['strings.Split:', ['a', 'b', 'c']])).toBe(
+      'strings.Split: [ "a", "b", "c" ]',
+    )
+  })
+
+  it('formats plain objects across multiple lines', () => {
+    expect(
+      formatPrintedArgs([
+        'out:',
+        {
+          exampleField: new Uint8Array([104, 101, 108, 108, 111]),
+          exampleText: 'world',
+        },
+      ]),
+    ).toBe(`out: {
+  exampleField: Uint8Array(5) [ 104, 101, 108, 108, 111 ],
+  exampleText: "world",
+}`)
+  })
+
+  it('formats goscript struct field bags using field values', () => {
+    expect(
+      formatPrintedArgs([
+        {
+          _fields: {
+            Name: { value: 'hello' },
+            Count: { value: 3 },
+          },
+        },
+      ]),
+    ).toBe(`{
+  Name: "hello",
+  Count: 3,
+}`)
+  })
+})

package/gs/builtin/print.ts

@@ -0,0 +1,154 @@
+import { asArray, isSliceProxy, type Slice } from './slice.js'
+
+/**
+ * formatPrintedArgs formats builtin println arguments deterministically.
+ */
+export function formatPrintedArgs(args: readonly any[]): string {
+  return args.map((arg) => formatPrintedValue(arg)).join(' ')
+}
+
+/**
+ * formatPrintedValue formats a single builtin println argument deterministically.
+ */
+export function formatPrintedValue(value: any): string {
+  return formatValue(value, 0, false, new WeakSet<object>())
+}
+
+function formatValue(
+  value: any,
+  depth: number,
+  nested: boolean,
+  seen: WeakSet<object>,
+): string {
+  if (value === null) {
+    return 'null'
+  }
+
+  if (value === undefined) {
+    return '<nil>'
+  }
+
+  if (typeof value === 'string') {
+    return nested ? JSON.stringify(value) : value
+  }
+
+  if (typeof value === 'boolean' || typeof value === 'number') {
+    return String(value)
+  }
+
+  if (typeof value === 'bigint') {
+    return value.toString()
+  }
+
+  if (value instanceof Uint8Array) {
+    return formatUint8Array(value)
+  }
+
+  if (Array.isArray(value)) {
+    return formatArray(value, depth, seen)
+  }
+
+  if (isSliceProxy(value as Slice<unknown>)) {
+    return formatArray(asArray(value as Slice<unknown>), depth, seen)
+  }
+
+  if (typeof value === 'function') {
+    return value.name ? `[Function: ${value.name}]` : '[Function]'
+  }
+
+  if (typeof value !== 'object') {
+    return String(value)
+  }
+
+  if (seen.has(value)) {
+    return '[Circular]'
+  }
+  seen.add(value)
+
+  try {
+    if (value instanceof Map) {
+      return formatArray(
+        Array.from(value.entries()).map(([k, v]) => `${formatValue(k, depth + 1, true, seen)} => ${formatValue(v, depth + 1, true, seen)}`),
+        depth,
+        seen,
+      )
+    }
+
+    if (value instanceof Set) {
+      return formatArray(Array.from(value.values()), depth, seen)
+    }
+
+    if (value instanceof Error) {
+      return value.message || value.toString()
+    }
+
+    if (typeof value.GoString === 'function') {
+      return value.GoString()
+    }
+
+    if (typeof value.Error === 'function') {
+      return value.Error()
+    }
+
+    if (typeof value.String === 'function') {
+      return value.String()
+    }
+
+    const entries = getObjectEntries(value)
+    if (entries.length === 0) {
+      return '{}'
+    }
+
+    return formatObject(entries, depth, seen)
+  } finally {
+    seen.delete(value)
+  }
+}
+
+function formatUint8Array(value: Uint8Array): string {
+  if (value.length === 0) {
+    return 'Uint8Array(0) []'
+  }
+
+  return `Uint8Array(${value.length}) [ ${Array.from(value).join(', ')} ]`
+}
+
+function formatArray(value: readonly any[], depth: number, seen: WeakSet<object>): string {
+  if (value.length === 0) {
+    return '[]'
+  }
+
+  return `[ ${value.map((item) => formatValue(item, depth + 1, true, seen)).join(', ')} ]`
+}
+
+function formatObject(
+  entries: readonly [string, any][],
+  depth: number,
+  seen: WeakSet<object>,
+): string {
+  const pad = '  '.repeat(depth + 1)
+  const closePad = '  '.repeat(depth)
+  const body = entries
+    .map(
+      ([key, value]) =>
+        `${pad}${key}: ${formatValue(value, depth + 1, true, seen)},`,
+    )
+    .join('\n')
+
+  return `{\n${body}\n${closePad}}`
+}
+
+function getObjectEntries(value: Record<string, any>): [string, any][] {
+  const fields = value._fields
+  if (fields && typeof fields === 'object' && !Array.isArray(fields)) {
+    return Object.keys(fields).map((key) => {
+      const field = fields[key]
+      if (field && typeof field === 'object' && 'value' in field) {
+        return [key, field.value]
+      }
+      return [key, field]
+    })
+  }
+
+  return Object.entries(value).filter(([, entry]) => typeof entry !== 'function')
+}

package/gs/fmt/fmt.test.ts

@@ -1,38 +1,49 @@
-import { describe, it, expect } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { resetHostRuntimeForTests } from '@goscript/builtin/hostio.js'
 import * as fmt from './fmt.js'
 
-// Helper to capture stdout via internal stdout.write
-// We will monkey-patch global process.stdout.write if available
+const originalDeno = (globalThis as any).Deno
+const originalProcess = (globalThis as any).process
+
+afterEach(() => {
+  if (originalDeno === undefined) {
+    delete (globalThis as any).Deno
+  } else {
+    ;(globalThis as any).Deno = originalDeno
+  }
+
+  if (originalProcess === undefined) {
+    delete (globalThis as any).process
+  } else {
+    ;(globalThis as any).process = originalProcess
+  }
+
+  resetHostRuntimeForTests()
+})
+
+// Helper to capture stdout via the hostio text output path.
 function captureStdout(run: () => void): string {
   let buf = ''
-  const hasProcess =
-    typeof process !== 'undefined' &&
-    (process as any).stdout &&
-    typeof (process as any).stdout.write === 'function'
-
-  if (hasProcess) {
-    const orig = (process as any).stdout.write
-    ;(process as any).stdout.write = (chunk: any) => {
-      buf += typeof chunk === 'string' ? chunk : String(chunk)
-      return true
-    }
-    try {
-      run()
-    } finally {
-      ;(process as any).stdout.write = orig
-    }
-  } else {
-    // Fallback: spy on console.log for environments without process
-    const origLog = console.log
-    ;(console as any).log = (msg: any) => {
-      buf += String(msg) + '\n'
-    }
-    try {
-      run()
-    } finally {
-      console.log = origLog
-    }
+  delete (globalThis as any).Deno
+  ;(globalThis as any).process = {
+    getBuiltinModule: vi.fn(() => ({
+      readSync: vi.fn(),
+      writeSync: vi.fn(
+        (
+          _fd: number,
+          chunk: Uint8Array,
+          _offset?: number,
+          length?: number,
+          _position?: number | null,
+        ) => {
+          buf += new TextDecoder().decode(chunk.subarray(0, length ?? chunk.length))
+          return length ?? chunk.length
+        },
+      ),
+    })),
   }
+  resetHostRuntimeForTests()
+  run()
 
   return buf
 }

package/gs/fmt/fmt.ts

@@ -3,6 +3,7 @@
 
 import * as $ from '@goscript/builtin/index.js'
 import * as errors from '@goscript/errors/index.js'
+import { writeHostStdoutText } from '@goscript/builtin/hostio.js'
 
 // Basic interfaces
 export interface Stringer {
@@ -259,28 +260,7 @@ function parseFormat(format: string, args: any[]): string {
 // Global stdout simulation for Print functions
 let stdout = {
   write: (data: string) => {
-    // Use process.stdout.write if available (Node.js), otherwise fallback to console.log
-    // but we need to avoid adding extra newlines that console.log adds
-    if (
-      typeof process !== 'undefined' &&
-      process.stdout &&
-      process.stdout.write
-    ) {
-      process.stdout.write(data)
-    } else {
-      // In browser environments, we need to use console.log but handle newlines carefully
-      // If the data already ends with \n, we should strip it to avoid double newlines
-      if (data.endsWith('\n')) {
-        console.log(data.slice(0, -1))
-      } else {
-        // Use console.log without adding newline by using a custom method
-        if (console.log) {
-          // For data without newlines, we can just print it directly
-          // This is a bit of a hack but works for most cases
-          console.log(data)
-        }
-      }
-    }
+    writeHostStdoutText(data)
   },
 }
 

package/gs/os/dir.gs.ts

@@ -1,42 +1,54 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
+import { createFileInfo, getDeno, getNodeFS, newHostError } from "./types_js.gs.js";
+import { FileInfoToDirEntry } from "@goscript/io/fs/readdir.js";
 
 import * as fs from "@goscript/io/fs/index.js"
 
 type DirEntry = fs.DirEntry;
 
-// ReadDir reads the named directory,
-// returning all its directory entries sorted by filename.
-// If an error occurs reading the directory,
-// ReadDir returns the entries it was able to read before the error,
-// along with the error.
 export function ReadDir(name: string): [$.Slice<DirEntry>, $.GoError] {
-	// Directory reading not supported in JavaScript environment
+	const denoObj = getDeno()
+	if (denoObj?.readDirSync) {
+		try {
+			const entries: DirEntry[] = []
+			for (const entry of denoObj.readDirSync(name)) {
+				const dirEntry = FileInfoToDirEntry(createFileInfo(entry.name, {
+					isDirectory: () => entry.isDirectory,
+					isSymbolicLink: () => entry.isSymlink,
+					mode: 0,
+					size: 0,
+				}))
+				if (dirEntry !== null) {
+					entries.push(dirEntry)
+				}
+			}
+			entries.sort((a, b) => (a?.Name() ?? "").localeCompare(b?.Name() ?? ""))
+			return [$.arrayToSlice(entries), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.readdirSync) {
+		try {
+			const entries = nodeFS.readdirSync(name, { withFileTypes: true }).map((entry: any) =>
+				FileInfoToDirEntry(createFileInfo(entry.name, {
+					isDirectory: () => typeof entry.isDirectory === "function" ? entry.isDirectory() : false,
+					isSymbolicLink: () => typeof entry.isSymbolicLink === "function" ? entry.isSymbolicLink() : false,
+					mode: 0,
+					size: 0,
+				}))
+			).filter((entry: DirEntry | null): entry is DirEntry => entry !== null)
+			entries.sort((a, b) => (a?.Name() ?? "").localeCompare(b?.Name() ?? ""))
+			return [$.arrayToSlice(entries), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
 	return [null, ErrUnimplemented]
 }
 
-// CopyFS copies the file system fsys into the directory dir,
-// creating dir if necessary.
-//
-// Files are created with mode 0o666 plus any execute permissions
-// from the source, and directories are created with mode 0o777
-// (before umask).
-//
-// CopyFS will not overwrite existing files. If a file name in fsys
-// already exists in the destination, CopyFS will return an error
-// such that errors.Is(err, fs.ErrExist) will be true.
-//
-// Symbolic links in fsys are not supported. A *PathError with Err set
-// to ErrInvalid is returned when copying from a symbolic link.
-//
-// Symbolic links in dir are followed.
-//
-// New files added to fsys (including if dir is a subdirectory of fsys)
-// while CopyFS is running are not guaranteed to be copied.
-//
-// Copying stops at and returns the first error encountered.
 export function CopyFS(dir: string, fsys: fs.FS): $.GoError {
-	// File system copying not supported in JavaScript environment
 	return ErrUnimplemented
 }
-