goscript 0.0.84 → 0.1.0

package/go.mod

@@ -6,17 +6,17 @@ toolchain go1.26.2
 
 require (
 	github.com/aperturerobotics/cli v1.1.0
+	github.com/aperturerobotics/json-iterator-lite v1.0.1-0.20251104042408-0c9eb8a3f726
 	github.com/aperturerobotics/protobuf-go-lite v0.12.2
 	github.com/aperturerobotics/util v1.33.0
 	github.com/pkg/errors v0.9.1
 	github.com/sirupsen/logrus v1.9.5-0.20260309202648-9f0600962f75
-	golang.org/x/mod v0.34.0
 	golang.org/x/tools v0.43.0
 )
 
 require (
-	github.com/aperturerobotics/json-iterator-lite v1.0.1-0.20251104042408-0c9eb8a3f726 // indirect
 	github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342 // indirect
+	golang.org/x/mod v0.34.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/sys v0.42.0 // indirect
 )

package/gs/builtin/builtin.ts

@@ -2,6 +2,15 @@ import type { Slice, SliceProxy } from './slice.js'
 import { writeHostStdoutText } from './hostio.js'
 import { formatPrintedArgs } from './print.js'
 import { isSliceProxy } from './slice.js'
+import { isVarRef, type VarRef } from './varRef.js'
+
+/**
+ * Implementation of Go's built-in print function
+ * @param args Arguments to print
+ */
+export function print(...args: any[]): void {
+  writeHostStdoutText(args.length === 0 ? '' : formatPrintedArgs(args))
+}
 
 /**
  * Implementation of Go's built-in println function
@@ -69,6 +78,24 @@ export function assignStruct<T>(target: T, source: T): void {
   }
 }
 
+/**
+ * pointerValue unwraps a Go pointer value for generated field, method, and
+ * dereference access. Struct pointers may be represented directly as class
+ * instances or indirectly as VarRef values when the pointer came from taking a
+ * variable's address.
+ */
+export function pointerValue<T>(value: T | VarRef<T> | null | undefined): T {
+  if (value === null || value === undefined) {
+    throw new Error(
+      'runtime error: invalid memory address or nil pointer dereference',
+    )
+  }
+  if (isVarRef(value)) {
+    return value.value as T
+  }
+  return value
+}
+
 // Bytes represents all valid []byte representations in TypeScript
 // This includes Uint8Array (the preferred representation) and $.Slice<number> (which includes null)
 export type Bytes = Uint8Array | Slice<number>

package/gs/builtin/hostio.test.ts

@@ -1,6 +1,10 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 import {
+  getHostRuntime,
+  HostRuntimeOwner,
+  type HostRuntime,
+  isMainScript,
   resetHostRuntimeForTests,
   writeHostStderrText,
   writeHostStdoutText,
@@ -10,6 +14,8 @@ const originalDeno = (globalThis as any).Deno
 const originalProcess = (globalThis as any).process
 
 afterEach(() => {
+  vi.restoreAllMocks()
+
   if (originalDeno === undefined) {
     delete (globalThis as any).Deno
   } else {
@@ -25,6 +31,40 @@ afterEach(() => {
   resetHostRuntimeForTests()
 })
 
+function runtimeFixture(platform: string): HostRuntime {
+  return {
+    deno: null,
+    getEnv: () => '',
+    getStdioHandle: () => null,
+    nodeFS: null,
+    platform,
+    processObj: null,
+    readFD: () => null,
+    writeFD: () => 0,
+    writeStderrText: () => {},
+    writeStdoutText: () => {},
+  }
+}
+
+describe('hostio runtime owner', () => {
+  it('caches host capability detection until reset', () => {
+    let detects = 0
+    const owner = new HostRuntimeOwner(() => {
+      detects++
+      return runtimeFixture(`host-${detects}`)
+    })
+
+    expect(owner.current().platform).toBe('host-1')
+    expect(owner.current().platform).toBe('host-1')
+    expect(detects).toBe(1)
+
+    owner.reset()
+
+    expect(owner.current().platform).toBe('host-2')
+    expect(detects).toBe(2)
+  })
+})
+
 describe('hostio text writes', () => {
   it('uses sync node fs writes for stdout and stderr', () => {
     const writes: Array<{ fd: number; bytes: number[] }> = []
@@ -66,4 +106,141 @@ describe('hostio text writes', () => {
     expect((globalThis as any).process.stdout.write).not.toHaveBeenCalled()
     expect((globalThis as any).process.stderr.write).not.toHaveBeenCalled()
   })
+
+  it('falls back to node fs when Deno is present without sync stdio', () => {
+    const writes: Array<{ fd: number; bytes: number[] }> = []
+    const writeSync = vi.fn(
+      (
+        fd: number,
+        buffer: Uint8Array,
+        _offset?: number,
+        length?: number,
+        _position?: number | null,
+      ) => {
+        writes.push({
+          bytes: Array.from(buffer.subarray(0, length ?? buffer.length)),
+          fd,
+        })
+        return length ?? buffer.length
+      },
+    )
+
+    ;(globalThis as any).Deno = {
+      stderr: {},
+      stdout: {},
+    }
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    writeHostStdoutText('bun\n')
+    writeHostStderrText('err\n')
+
+    expect(writeSync).toHaveBeenCalledTimes(2)
+    expect(writes).toEqual([
+      { bytes: [98, 117, 110, 10], fd: 1 },
+      { bytes: [101, 114, 114, 10], fd: 2 },
+    ])
+    expect(getHostRuntime().platform).toBe('unknown')
+  })
+
+  it('prefers Deno sync stdio when it is available', () => {
+    const denoWrites: Array<{ bytes: number[]; stream: string }> = []
+    const nodeWriteSync = vi.fn()
+    const denoWriteSync = vi.fn((buffer: Uint8Array) => {
+      denoWrites.push({
+        bytes: Array.from(buffer),
+        stream: 'stdout',
+      })
+      return buffer.length
+    })
+
+    ;(globalThis as any).Deno = {
+      build: { os: 'darwin' },
+      stdout: { writeSync: denoWriteSync },
+    }
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync: nodeWriteSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    writeHostStdoutText('deno\n')
+
+    expect(denoWriteSync).toHaveBeenCalledTimes(1)
+    expect(nodeWriteSync).not.toHaveBeenCalled()
+    expect(denoWrites).toEqual([
+      { bytes: [100, 101, 110, 111, 10], stream: 'stdout' },
+    ])
+    expect(getHostRuntime().platform).toBe('darwin')
+  })
+
+  it('uses console fallback in browser-like hosts', () => {
+    const consoleLog = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    delete (globalThis as any).Deno
+    delete (globalThis as any).process
+    resetHostRuntimeForTests()
+
+    writeHostStdoutText('browser\n')
+
+    expect(getHostRuntime().platform).toBe('unknown')
+    expect(getHostRuntime().nodeFS).toBeNull()
+    expect(consoleLog).toHaveBeenCalledWith('browser')
+  })
+})
+
+describe('hostio isMainScript', () => {
+  it('returns true when the runtime marks the module as main', () => {
+    expect(
+      isMainScript({
+        main: true,
+        url: 'file:///tmp/example.gs.ts',
+      }),
+    ).toBe(true)
+  })
+
+  it('matches process argv[1] against the module url', () => {
+    delete (globalThis as any).Deno
+    ;(globalThis as any).process = {
+      argv: ['bun', './dist/app.gs.ts'],
+      cwd: vi.fn(() => '/tmp/project'),
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync: vi.fn(),
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    expect(
+      isMainScript({
+        url: 'file:///tmp/project/dist/app.gs.ts',
+      }),
+    ).toBe(true)
+  })
+
+  it('returns false when the module was imported instead of executed', () => {
+    delete (globalThis as any).Deno
+    ;(globalThis as any).process = {
+      argv: ['bun', './runner.ts'],
+      cwd: vi.fn(() => '/tmp/project'),
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync: vi.fn(),
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    expect(
+      isMainScript({
+        url: 'file:///tmp/project/dist/app.gs.ts',
+      }),
+    ).toBe(false)
+  })
 })

package/gs/builtin/hostio.ts

@@ -29,19 +29,29 @@ export type NodeFSModule = {
   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
+  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
+  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
+  writeFileSync?(
+    path: string,
+    data: Uint8Array,
+    options?: { mode?: number },
+  ): void
 }
 
 export type DenoStream = {
@@ -75,6 +85,13 @@ export type HostRuntime = {
   writeStdoutText: HostTextWrite
 }
 
+export type HostRuntimeDetector = () => HostRuntime
+
+export type MainScriptMeta = {
+  url: string
+  main?: boolean
+}
+
 const encoder = new TextEncoder()
 
 function getDynamicRequire(): ((specifier: string) => unknown) | null {
@@ -149,12 +166,66 @@ function detectNodeFS(processObj: any | null): NodeFSModule | null {
   return null
 }
 
-function unsupportedReadFD(_fd: number, _buffer: Uint8Array): number | null {
-  throw new HostUnsupportedError()
+function hasURLScheme(path: string): boolean {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(path)
+}
+
+function isAbsoluteScriptPath(path: string): boolean {
+  return path.startsWith('/') || /^[A-Za-z]:[\\/]/.test(path)
+}
+
+function normalizePath(path: string): string {
+  return path.replace(/\\/g, '/')
+}
+
+function absolutePathToFileURL(path: string, isDirectory: boolean): string {
+  const normalized = normalizePath(path)
+  const suffix = isDirectory && !normalized.endsWith('/') ? '/' : ''
+  if (/^[A-Za-z]:\//.test(normalized)) {
+    return new URL(`file:///${normalized}${suffix}`).href
+  }
+  return new URL(`file://${normalized}${suffix}`).href
+}
+
+function getCurrentWorkingDirectory(): string | null {
+  const runtime = getHostRuntime()
+  try {
+    if (typeof runtime.processObj?.cwd === 'function') {
+      return runtime.processObj.cwd()
+    }
+  } catch {
+    // Fall through to Deno cwd.
+  }
+
+  try {
+    if (typeof runtime.deno?.cwd === 'function') {
+      return runtime.deno.cwd()
+    }
+  } catch {
+    // No cwd fallback available.
+  }
+
+  return null
 }
 
-function unsupportedWriteFD(_fd: number, _buffer: Uint8Array): number {
-  throw new HostUnsupportedError()
+function fileURLFromScriptPath(path: string): string | null {
+  try {
+    if (hasURLScheme(path)) {
+      return new URL(path).href
+    }
+
+    if (isAbsoluteScriptPath(path)) {
+      return absolutePathToFileURL(path, false)
+    }
+
+    const cwd = getCurrentWorkingDirectory()
+    if (!cwd) {
+      return null
+    }
+    return new URL(normalizePath(path), absolutePathToFileURL(cwd, true)).href
+  } catch {
+    return null
+  }
 }
 
 function fallbackConsoleWriter(method: 'error' | 'log'): HostTextWrite {
@@ -193,10 +264,7 @@ function detectHostRuntime(): HostRuntime {
     }
   }
 
-  const platform =
-    deno?.build?.os ??
-    processObj?.platform ??
-    'unknown'
+  const platform = deno?.build?.os ?? processObj?.platform ?? 'unknown'
 
   const getEnv = (name: string): string => {
     if (deno?.env?.get) {
@@ -209,64 +277,67 @@ function detectHostRuntime(): HostRuntime {
     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()
-      }
+  const readFD: HostReadFD = (
+    fd: number,
+    buffer: Uint8Array,
+  ): number | null => {
+    const handle = getStdioHandle(fd)
+    if (handle && typeof handle.readSync === 'function') {
       return handle.readSync(buffer)
     }
-    writeFD = (fd: number, buffer: Uint8Array): number => {
-      const handle = getStdioHandle(fd)
-      if (!handle || typeof handle.writeSync !== 'function') {
-        throw new HostUnsupportedError()
-      }
+    if (nodeFS) {
+      return nodeFS.readSync(fd, buffer, 0, buffer.length, null)
+    }
+    throw new HostUnsupportedError()
+  }
+  const writeFD: HostWriteFD = (fd: number, buffer: Uint8Array): number => {
+    const handle = getStdioHandle(fd)
+    if (handle && typeof handle.writeSync === 'function') {
       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(
+    if (nodeFS) {
+      return writeAllSync(
         (chunk: Uint8Array) =>
           nodeFS.writeSync(fd, chunk, 0, chunk.length, null),
         buffer,
       )
-    writeStdoutText = (data: string) =>
+    }
+    throw new HostUnsupportedError()
+  }
+  const writeStdoutText: HostTextWrite = (data: string) => {
+    const handle = getStdioHandle(1)
+    if (handle && typeof handle.writeSync === 'function') {
+      writeAllText((chunk: Uint8Array) => handle.writeSync!(chunk), data)
+      return
+    }
+    if (nodeFS) {
       writeAllText(
-        (chunk: Uint8Array) => nodeFS.writeSync(1, chunk, 0, chunk.length, null),
+        (chunk: Uint8Array) =>
+          nodeFS.writeSync(1, chunk, 0, chunk.length, null),
         data,
       )
-    writeStderrText = (data: string) =>
+      return
+    }
+    fallbackConsoleWriter('log')(data)
+  }
+  const writeStderrText: HostTextWrite = (data: string) => {
+    const handle = getStdioHandle(2)
+    if (handle && typeof handle.writeSync === 'function') {
+      writeAllText((chunk: Uint8Array) => handle.writeSync!(chunk), data)
+      return
+    }
+    if (nodeFS) {
       writeAllText(
-        (chunk: Uint8Array) => nodeFS.writeSync(2, chunk, 0, chunk.length, null),
+        (chunk: Uint8Array) =>
+          nodeFS.writeSync(2, chunk, 0, chunk.length, null),
         data,
       )
+      return
+    }
+    fallbackConsoleWriter('error')(data)
   }
 
   return {
@@ -283,16 +354,60 @@ function detectHostRuntime(): HostRuntime {
   }
 }
 
-export let hostRuntime = detectHostRuntime()
+export class HostRuntimeOwner {
+  private runtime: HostRuntime
+
+  constructor(
+    private readonly detector: HostRuntimeDetector = detectHostRuntime,
+  ) {
+    this.runtime = detector()
+  }
+
+  current(): HostRuntime {
+    return this.runtime
+  }
+
+  reset(): void {
+    this.runtime = this.detector()
+  }
+}
+
+export const hostRuntimeOwner = new HostRuntimeOwner()
+
+export function getHostRuntime(): HostRuntime {
+  return hostRuntimeOwner.current()
+}
 
 export function resetHostRuntimeForTests(): void {
-  hostRuntime = detectHostRuntime()
+  hostRuntimeOwner.reset()
 }
 
 export function writeHostStdoutText(data: string): void {
-  hostRuntime.writeStdoutText(data)
+  getHostRuntime().writeStdoutText(data)
 }
 
 export function writeHostStderrText(data: string): void {
-  hostRuntime.writeStderrText(data)
+  getHostRuntime().writeStderrText(data)
+}
+
+export function isMainScript(meta: MainScriptMeta): boolean {
+  if (meta.main === true) {
+    return true
+  }
+
+  const entryPath = getHostRuntime().processObj?.argv?.[1]
+  if (typeof entryPath !== 'string' || entryPath === '') {
+    return false
+  }
+
+  const entryURL = fileURLFromScriptPath(entryPath)
+  if (!entryURL) {
+    return false
+  }
+
+  try {
+    return new URL(meta.url).href === entryURL
+  } catch {
+    return meta.url === entryURL
+  }
 }

package/gs/builtin/index.ts

@@ -6,3 +6,4 @@ export * from './type.js'
 export * from './varRef.js'
 export * from './defer.js'
 export * from './errors.js'
+export * from './hostio.js'