goscript 0.0.83 → 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/file_unix_js.test.ts

@@ -4,6 +4,7 @@ import * as io from '@goscript/io/index.js'
 
 import { NewFile, Stderr, Stdin, Stdout } from './file_unix_js.gs.js'
 import { ErrClosed } from './error.gs.js'
+import { createHostFile, resetHostRuntimeForTests } from './types_js.gs.js'
 
 const originalDeno = (globalThis as any).Deno
 const originalProcess = (globalThis as any).process
@@ -20,6 +21,8 @@ afterEach(() => {
   } else {
     ;(globalThis as any).process = originalProcess
   }
+
+  resetHostRuntimeForTests()
 })
 
 describe('os stdio', () => {
@@ -45,6 +48,7 @@ describe('os stdio', () => {
       stdout: { writeSync: stdoutWriteSync },
     }
     delete (globalThis as any).process
+    resetHostRuntimeForTests()
 
     const input = NewFile(0, 'stdin')
     const output = NewFile(1, 'stdout')
@@ -93,6 +97,7 @@ describe('os stdio', () => {
         writeSync,
       })),
     }
+    resetHostRuntimeForTests()
 
     const input = NewFile(0, 'stdin')
     const output = NewFile(1, 'stdout')
@@ -117,6 +122,7 @@ describe('os stdio', () => {
       stdin: { readSync: stdinReadSync },
     }
     delete (globalThis as any).process
+    resetHostRuntimeForTests()
 
     const input = NewFile(0, 'stdin')!
     const [readN, readErr] = input.Read(new Uint8Array(1))
@@ -128,4 +134,51 @@ describe('os stdio', () => {
     expect(closedN).toBe(0)
     expect(closedErr).toBe(ErrClosed)
   })
+
+  it('retries short writes until the full buffer is written', () => {
+    const writeSync = vi
+      .fn<(buffer: Uint8Array) => number>()
+      .mockImplementationOnce((_buffer: Uint8Array) => 2)
+      .mockImplementationOnce((buffer: Uint8Array) => buffer.length)
+
+    ;(globalThis as any).Deno = {
+      stdout: { writeSync },
+    }
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    const output = NewFile(1, 'stdout')!
+    const [writeN, writeErr] = output.Write(new Uint8Array([1, 2, 3, 4, 5]))
+    expect(writeN).toBe(5)
+    expect(writeErr).toBeNull()
+    expect(writeSync).toHaveBeenCalledTimes(2)
+    expect(Array.from(writeSync.mock.calls[1][0])).toEqual([3, 4, 5])
+  })
+
+  it('prefers direct handle read and write methods when available', () => {
+    const handle = {
+      readSync: vi.fn((buffer: Uint8Array) => {
+        buffer.set([11, 12, 13], 0)
+        return 3
+      }),
+      writeSync: vi
+        .fn<(buffer: Uint8Array) => number>()
+        .mockImplementationOnce((_buffer: Uint8Array) => 1)
+        .mockImplementationOnce((buffer: Uint8Array) => buffer.length),
+    }
+
+    const file = createHostFile('host-file', 99, handle)
+    const readBuf = new Uint8Array(4)
+
+    const [readN, readErr] = file.Read(readBuf)
+    expect(readN).toBe(3)
+    expect(readErr).toBeNull()
+    expect(Array.from(readBuf.slice(0, 3))).toEqual([11, 12, 13])
+
+    const [writeN, writeErr] = file.Write(new Uint8Array([21, 22, 23]))
+    expect(writeN).toBe(3)
+    expect(writeErr).toBeNull()
+    expect(handle.writeSync).toHaveBeenCalledTimes(2)
+    expect(Array.from(handle.writeSync.mock.calls[1][0])).toEqual([22, 23])
+  })
 })