goscript 0.0.76 → 0.0.78

package/gs/github.com/aperturerobotics/wasivm/wazero/kernel/runtime/browser/browser.ts

@@ -0,0 +1,238 @@
+// Package browser_runtime implements VmRuntime backed by the browser
+// WebAssembly API. Pure TypeScript -- no syscall/js indirection.
+
+import type * as vmruntime from '../runtime.js'
+
+// Runtime implements VmRuntime using the browser WebAssembly API.
+export class Runtime implements vmruntime.VmRuntime {
+  constructor() {}
+
+  // Compile calls WebAssembly.compile and returns a Module.
+  async Compile(
+    _ctx: any,
+    wasm: Uint8Array | number[],
+  ): Promise<Module> {
+    const bytes = wasm instanceof Uint8Array ? wasm : new Uint8Array(wasm)
+    const compiled = await WebAssembly.compile(bytes.buffer as ArrayBuffer)
+    return new Module(compiled)
+  }
+
+  // Close is a no-op for the browser runtime.
+  async Close(_ctx: any): Promise<null> {
+    return null
+  }
+}
+
+// New creates a new browser-backed VmRuntime.
+export function New(): Runtime {
+  return new Runtime()
+}
+
+// Module wraps a WebAssembly.Module.
+export class Module implements vmruntime.VmModule {
+  constructor(private readonly wasmModule: WebAssembly.Module) {}
+
+  // Instantiate creates an instance with host functions wired as imports.
+  async Instantiate(
+    ctx: any,
+    config: vmruntime.VmModuleConfig,
+  ): Promise<Instance> {
+    const imports = this.buildImports(ctx, config.HostFunctions)
+    const wasmInst = await WebAssembly.instantiate(this.wasmModule, imports)
+    const inst = new Instance(wasmInst)
+    // Patch the captured instance reference in host function closures.
+    if ((imports as any).__instRef) {
+      ;(imports as any).__instRef.current = inst
+    }
+    return inst
+  }
+
+  // Close is a no-op.
+  async Close(_ctx: any): Promise<null> {
+    return null
+  }
+
+  // buildImports constructs the WebAssembly imports object.
+  private buildImports(
+    ctx: any,
+    hostFns: Map<string, vmruntime.HostFunction> | null,
+  ): WebAssembly.Imports {
+    const imports: Record<string, Record<string, WebAssembly.ImportValue>> = {}
+    if (!hostFns) return imports
+
+    // Shared mutable ref -- patched after instantiation.
+    const instRef: { current: Instance | null } = { current: null }
+
+    hostFns.forEach((fn, key) => {
+      let modName = 'env'
+      let funcName = key
+      const dot = key.indexOf('.')
+      if (dot !== -1) {
+        modName = key.substring(0, dot)
+        funcName = key.substring(dot + 1)
+      }
+      if (!imports[modName]) imports[modName] = {}
+
+      imports[modName][funcName] = (...args: number[]) => {
+        const stack = new BigInt64Array(args.length)
+        for (let i = 0; i < args.length; i++) {
+          stack[i] = BigInt(args[i])
+        }
+        const u64Stack: number[] = args.map((a) => a >>> 0)
+        const err = fn(ctx, instRef.current, u64Stack)
+        if (err) throw err
+        // WASM i32 return: first stack element.
+        if (u64Stack.length > 0) return u64Stack[0]
+      }
+    })
+
+    // Stash the ref so Instantiate can patch it.
+    ;(imports as any).__instRef = instRef
+    return imports
+  }
+}
+
+// Instance wraps a WebAssembly.Instance.
+export class Instance implements vmruntime.VmInstance {
+  private readonly exports: WebAssembly.Exports
+
+  constructor(private readonly wasmInstance: WebAssembly.Instance) {
+    this.exports = wasmInstance.exports
+  }
+
+  // Call invokes an exported function by name.
+  async Call(
+    _ctx: any,
+    name: string,
+    ...args: number[]
+  ): Promise<number[] | null> {
+    const fn = this.exports[name]
+    if (typeof fn !== 'function') return null
+    const result = (fn as (...args: number[]) => unknown)(...args)
+    if (result === undefined) return null
+    return [result as number]
+  }
+
+  // Memory returns the instance's linear memory.
+  Memory(): BrowserMemory | null {
+    const mem = this.exports.memory
+    if (!(mem instanceof WebAssembly.Memory)) return null
+    return new BrowserMemory(mem)
+  }
+
+  // ExportedFunction returns a callable reference.
+  ExportedFunction(name: string): BrowserFunction | null {
+    const fn = this.exports[name]
+    if (typeof fn !== 'function') return null
+    return new BrowserFunction(fn as (...args: number[]) => unknown)
+  }
+
+  // ExportedGlobal returns a reference to an exported global.
+  ExportedGlobal(name: string): BrowserGlobal | null {
+    const g = this.exports[name]
+    if (!(g instanceof WebAssembly.Global)) return null
+    return new BrowserGlobal(g)
+  }
+
+  // Close is a no-op.
+  async Close(_ctx: any): Promise<null> {
+    return null
+  }
+}
+
+// BrowserFunction wraps a WebAssembly exported function.
+export class BrowserFunction implements vmruntime.VmFunction {
+  constructor(private readonly fn: (...args: number[]) => unknown) {}
+
+  async Call(_ctx: any, ...args: number[]): Promise<number[] | null> {
+    const result = this.fn(...args)
+    if (result === undefined) return null
+    return [result as number]
+  }
+}
+
+// BrowserGlobal wraps a WebAssembly.Global.
+export class BrowserGlobal implements vmruntime.VmGlobal {
+  constructor(private readonly global: WebAssembly.Global) {}
+
+  Get(): number {
+    return this.global.value as number
+  }
+
+  Set(val: number): void {
+    this.global.value = val
+  }
+}
+
+// BrowserMemory wraps WebAssembly.Memory with typed DataView access.
+export class BrowserMemory implements vmruntime.VmMemory {
+  constructor(private readonly mem: WebAssembly.Memory) {}
+
+  private get buf(): ArrayBuffer {
+    return this.mem.buffer
+  }
+
+  Read(offset: number, length: number): [Uint8Array, boolean] {
+    if (offset + length > this.buf.byteLength) return [new Uint8Array(0), false]
+    return [new Uint8Array(this.buf, offset, length), true]
+  }
+
+  ReadByteAt(offset: number): [number, boolean] {
+    if (offset >= this.buf.byteLength) return [0, false]
+    return [new Uint8Array(this.buf, offset, 1)[0], true]
+  }
+
+  ReadUint32Le(offset: number): [number, boolean] {
+    if (offset + 4 > this.buf.byteLength) return [0, false]
+    return [new DataView(this.buf).getUint32(offset, true), true]
+  }
+
+  ReadUint64Le(offset: number): [bigint, boolean] {
+    if (offset + 8 > this.buf.byteLength) return [0n, false]
+    const dv = new DataView(this.buf)
+    const lo = BigInt(dv.getUint32(offset, true))
+    const hi = BigInt(dv.getUint32(offset + 4, true))
+    return [lo | (hi << 32n), true]
+  }
+
+  Write(offset: number, data: Uint8Array | number[]): boolean {
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data)
+    if (offset + bytes.length > this.buf.byteLength) return false
+    new Uint8Array(this.buf, offset, bytes.length).set(bytes)
+    return true
+  }
+
+  WriteByteAt(offset: number, val: number): boolean {
+    if (offset >= this.buf.byteLength) return false
+    new Uint8Array(this.buf, offset, 1)[0] = val
+    return true
+  }
+
+  WriteUint32Le(offset: number, val: number): boolean {
+    if (offset + 4 > this.buf.byteLength) return false
+    new DataView(this.buf).setUint32(offset, val, true)
+    return true
+  }
+
+  WriteUint64Le(offset: number, val: bigint | number): boolean {
+    if (offset + 8 > this.buf.byteLength) return false
+    const v = typeof val === 'bigint' ? val : BigInt(val)
+    const dv = new DataView(this.buf)
+    dv.setUint32(offset, Number(v & 0xffffffffn), true)
+    dv.setUint32(offset + 4, Number((v >> 32n) & 0xffffffffn), true)
+    return true
+  }
+
+  Size(): number {
+    return this.buf.byteLength
+  }
+
+  Grow(pages: number): [number, boolean] {
+    try {
+      const prev = this.mem.grow(pages)
+      return [prev, true]
+    } catch {
+      return [0, false]
+    }
+  }
+}

package/gs/github.com/aperturerobotics/wasivm/wazero/kernel/runtime/browser/index.ts

@@ -0,0 +1 @@
+export * from './browser.js'

package/gs/github.com/aperturerobotics/wasivm/wazero/kernel/runtime/browser/meta.json

@@ -0,0 +1,12 @@
+{
+  "dependencies": [],
+  "asyncMethods": {
+    "Runtime.Compile": true,
+    "Runtime.Close": true,
+    "Module.Instantiate": true,
+    "Module.Close": true,
+    "Instance.Call": true,
+    "Instance.Close": true,
+    "Function.Call": true
+  }
+}

package/gs/github.com/aperturerobotics/wasivm/wazero/kernel/runtime/index.ts

@@ -0,0 +1 @@
+export * from './runtime.js'

package/gs/github.com/aperturerobotics/wasivm/wazero/kernel/runtime/meta.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": [],
+  "asyncMethods": {
+    "ExitError.Error": false,
+    "ExitError.ExitCode": false,
+    "NewExitError": false
+  }
+}

package/gs/github.com/aperturerobotics/wasivm/wazero/kernel/runtime/runtime.ts

@@ -0,0 +1,94 @@
+// Package vmruntime defines abstract interfaces for WASM execution engines.
+
+// VmRuntime abstracts the WASM execution engine.
+export interface VmRuntime {
+  Compile(ctx: any, wasm: Uint8Array | number[]): Promise<VmModule>
+  Close(ctx: any): Promise<any>
+}
+
+// VmModule represents a compiled WASM module.
+export interface VmModule {
+  Instantiate(ctx: any, config: VmModuleConfig): Promise<VmInstance>
+  Close(ctx: any): Promise<any>
+}
+
+// VmModuleConfig contains configuration for module instantiation.
+export interface VmModuleConfig {
+  Name: string
+  Args: string[] | null
+  Env: string[] | null
+  Stdin: any
+  Stdout: any
+  Stderr: any
+  HostFunctions: Map<string, HostFunction> | null
+}
+
+// HostFunction is a host-provided function callable from WASM.
+export type HostFunction = (
+  ctx: any,
+  inst: VmInstance | null,
+  stack: number[],
+) => any
+
+// VmInstance represents a running WASM module instance.
+export interface VmInstance {
+  Call(ctx: any, name: string, ...args: number[]): Promise<number[] | null>
+  Memory(): VmMemory | null
+  ExportedFunction(name: string): VmFunction | null
+  ExportedGlobal(name: string): VmGlobal | null
+  Close(ctx: any): Promise<any>
+}
+
+// VmFunction represents an exported WASM function.
+export interface VmFunction {
+  Call(ctx: any, ...args: number[]): Promise<number[] | null>
+}
+
+// VmGlobal represents an exported WASM global variable.
+export interface VmGlobal {
+  Get(): number
+  Set(val: number): void
+}
+
+// VmMemory abstracts access to WASM linear memory.
+export interface VmMemory {
+  Read(offset: number, length: number): [Uint8Array | number[], boolean]
+  ReadByteAt(offset: number): [number, boolean]
+  ReadUint32Le(offset: number): [number, boolean]
+  ReadUint64Le(offset: number): [bigint | number, boolean]
+  Write(offset: number, data: Uint8Array | number[]): boolean
+  WriteByteAt(offset: number, val: number): boolean
+  WriteUint32Le(offset: number, val: number): boolean
+  WriteUint64Le(offset: number, val: bigint | number): boolean
+  Size(): number
+  Grow(pages: number): [number, boolean]
+}
+
+// ExitError represents a clean process exit with a status code.
+export class ExitError extends Error {
+  public Code: number
+
+  constructor(code: number) {
+    super('exit: ' + code)
+    this.Code = code
+  }
+
+  ExitCode(): number {
+    return this.Code
+  }
+}
+
+// NewExitError creates an ExitError with the given code.
+export function NewExitError(code: number): ExitError {
+  return new ExitError(code)
+}
+
+// Snapshotable is an optional extension for VmInstance.
+export interface Snapshotable {
+  Snapshot(): Snapshot
+}
+
+// Snapshot represents a captured execution state.
+export interface Snapshot {
+  Restore(returnValues: number[]): void
+}

package/gs/io/fs/format.ts

@@ -16,12 +16,9 @@ export function FormatFileInfo(info: FileInfo): string {
   b.push(' ')
 
   let size = info!.Size()
-  let usize: number = 0
-  if (size >= 0) {
-    usize = size as number
-  } else {
+  const usize = size >= 0 ? size : -size
+  if (size < 0) {
     b.push('-')
-    usize = -size as number
   }
 
   b.push(usize.toString())

package/gs/io/fs/glob.ts

@@ -70,7 +70,6 @@ export function globWithLimit(
   depth: number,
 ): [$.Slice<string>, $.GoError] {
   let matches: $.Slice<string> = null
-  let err: $.GoError = null
   {
     // This limit is added to prevent stack exhaustion issues. See
     // CVE-2022-30630.
@@ -87,15 +86,15 @@ export function globWithLimit(
 
     // Check pattern is well-formed.
     {
-      let [, err] = path.Match(pattern, '')
-      if (err != null) {
-        return [null, err]
+      const [, matchErr] = path.Match(pattern, '')
+      if (matchErr != null) {
+        return [null, matchErr]
       }
     }
     if (!hasMeta(pattern)) {
       {
-        ;[, err] = Stat(fsys, pattern)
-        if (err != null) {
+        const [, statErr] = Stat(fsys, pattern)
+        if (statErr != null) {
           return [null, null]
         }
       }
@@ -114,21 +113,21 @@ export function globWithLimit(
       return [null, path.ErrBadPattern]
     }
 
-    let m: $.Slice<string>
-    ;[m, err] = globWithLimit(fsys, dir, depth + 1)
-    if (err != null) {
-      return [null, err]
+    const [dirs, dirErr] = globWithLimit(fsys, dir, depth + 1)
+    if (dirErr != null) {
+      return [null, dirErr]
     }
-    for (let _i = 0; _i < $.len(m); _i++) {
-      const d = m![_i]
+    for (let _i = 0; _i < $.len(dirs); _i++) {
+      const d = dirs![_i]
       {
-        ;[matches, err] = glob(fsys, d, file, matches)
-        if (err != null) {
-          return [matches, err]
+        const [nextMatches, globErr] = glob(fsys, d, file, matches)
+        matches = nextMatches
+        if (globErr != null) {
+          return [matches, globErr]
         }
       }
     }
-    return [matches, err]
+    return [matches, null]
   }
 }
 
@@ -155,15 +154,13 @@ export function glob(
   pattern: string,
   matches: $.Slice<string>,
 ): [$.Slice<string>, $.GoError] {
-  let m: $.Slice<string> = null
-  let e: $.GoError = null
+  let m = matches
   {
-    m = matches
     let [infos, err] = ReadDir(fs, dir)
 
     // ignore I/O error
     if (err != null) {
-      return [m, e]
+      return [m, null]
     }
 
     for (let _i = 0; _i < $.len(infos); _i++) {
@@ -179,7 +176,7 @@ export function glob(
         }
       }
     }
-    return [m, e]
+    return [m, null]
   }
 }
 

package/gs/path/match.ts

@@ -45,13 +45,7 @@ export function Match(pattern: string, name: string): [boolean, $.GoError] {
     // Before returning false with no error,
     // check that the remainder of the pattern is syntactically valid.
     Pattern: for (; $.len(pattern) > 0; ) {
-      let star: boolean = false
-      let chunk: string = ''
-      let rest: string = ''
-      let scanResult = scanChunk(pattern)
-      star = scanResult[0]
-      chunk = scanResult[1]
-      rest = scanResult[2]
+      const [star, chunk, rest] = scanChunk(pattern)
       pattern = rest
 
       // Trailing * matches rest of string unless it has a /.
@@ -104,13 +98,7 @@ export function Match(pattern: string, name: string): [boolean, $.GoError] {
       // Before returning false with no error,
       // check that the remainder of the pattern is syntactically valid.
       for (; $.len(pattern) > 0; ) {
-        // let star2: boolean = false
-        let chunk2: string = ''
-        let rest2: string = ''
-        let scanResult2 = scanChunk(pattern)
-        // star2 = scanResult2[0]
-        chunk2 = scanResult2[1]
-        rest2 = scanResult2[2]
+        const [, chunk2, rest2] = scanChunk(pattern)
         pattern = rest2
         {
           let [, , err] = matchChunk(chunk2, '')
@@ -135,7 +123,7 @@ export function scanChunk(pattern: string): [boolean, string, string] {
       star = true
     }
     let inrange = false
-    let i: number = 0
+    let i: number
 
     // error check handled in matchChunk: bad pattern.
     Scan: for (i = 0; i < $.len(pattern); i++) {
@@ -174,7 +162,7 @@ export function matchChunk(
   chunk: string,
   s: string,
 ): [string, boolean, $.GoError] {
-  let err: $.GoError = null
+  let err: $.GoError
   {
     // failed records whether the match has failed.
     // After the match fails, the loop continues on processing chunk,
@@ -200,10 +188,9 @@ export function matchChunk(
         case 91: {
           let r: number = 0
           if (!failed) {
-            let n: number = 0
-            let decoded = utf8.DecodeRuneInString(s)
+            const decoded = utf8.DecodeRuneInString(s)
             r = decoded[0]
-            n = decoded[1]
+            const n = decoded[1]
             s = $.sliceString(s, n, undefined)
           }
           chunk = $.sliceString(chunk, 1, undefined)
@@ -223,10 +210,10 @@ export function matchChunk(
               chunk = $.sliceString(chunk, 1, undefined)
               break
             }
-            let lo: number = 0
-            let hi: number = 0
+            let lo: number
+            let hi: number
             {
-              let escResult = getEsc(chunk)
+              const escResult = getEsc(chunk)
               lo = escResult[0]
               chunk = escResult[1]
               err = escResult[2]

package/gs/reflect/index.ts

@@ -16,6 +16,7 @@ export {
   SendDir,
   BothDir,
   getInterfaceTypeByName,
+  getInterfaceLiteralTypeByName,
 } from './type.js'
 export type { Type, ChanDir, Kind } from './type.js'
 export { DeepEqual } from './deepequal.js'

package/gs/reflect/type.ts

@@ -1492,7 +1492,10 @@ function typeImplementsInterface(
   interfaceType: Type,
 ): boolean {
   // Get the interface name and look it up in the type registry
-  const interfaceName = interfaceType.String()
+  const interfaceName =
+    interfaceType instanceof InterfaceType ?
+      interfaceType.registeredName() || interfaceType.String()
+    : interfaceType.String()
   const interfaceTypeInfo = builtinGetTypeByName(interfaceName)
 
   if (!interfaceTypeInfo || !isInterfaceTypeInfo(interfaceTypeInfo)) {
@@ -1797,7 +1800,10 @@ class ChannelType implements Type {
 
 // Interface type implementation
 class InterfaceType implements Type {
-  constructor(private _name: string = 'interface{}') {}
+  constructor(
+    private _name: string = 'interface{}',
+    private _registeredName?: string,
+  ) {}
 
   public String(): string {
     return this._name
@@ -1820,10 +1826,30 @@ class InterfaceType implements Type {
   }
 
   public PkgPath?(): string {
+    if (
+      this._name === 'interface{}' ||
+      this._name.startsWith('interface {')
+    ) {
+      return ''
+    }
+    const dotIndex = this._name.lastIndexOf('.')
+    if (dotIndex > 0) {
+      return this._name.substring(0, dotIndex)
+    }
     return ''
   }
 
   public Name(): string {
+    if (
+      this._name === 'interface{}' ||
+      this._name.startsWith('interface {')
+    ) {
+      return this._name
+    }
+    const dotIndex = this._name.lastIndexOf('.')
+    if (dotIndex >= 0) {
+      return this._name.substring(dotIndex + 1)
+    }
     return this._name
   }
 
@@ -1868,6 +1894,10 @@ class InterfaceType implements Type {
   public Bits(): number {
     throw new Error('reflect: call of reflect.Type.Bits on interface Type')
   }
+
+  public registeredName(): string | undefined {
+    return this._registeredName
+  }
 }
 
 function getTypeOf(value: ReflectValue): Type {
@@ -2161,30 +2191,37 @@ export function TypeFor(): Type {
 export function getInterfaceTypeByName(name: string): Type {
   const typeInfo = builtinGetTypeByName(name)
   if (typeInfo && typeInfo.kind === TypeKind.Interface) {
-    // InterfaceTypeInfo
+    return new InterfaceType(name, name)
+  }
+  return new InterfaceType('interface{}')
+}
+
+export function getInterfaceLiteralTypeByName(name: string): Type {
+  const typeInfo = builtinGetTypeByName(name)
+  if (typeInfo && typeInfo.kind === TypeKind.Interface) {
     const methods = (typeInfo as any).methods || []
-    if (methods.length > 0) {
-      // Build interface signature with methods
-      const methodSigs = methods
-        .map((m: any) => {
-          const args =
-            m.args
-              ?.map((a: any) => (typeof a === 'string' ? a : 'any'))
-              .join(', ') || ''
-          const returns = m.returns?.map((r: any) =>
-            typeof r === 'string' ? r : 'any',
-          )
-          let returnSig = ''
-          if (returns && returns.length === 1) {
-            returnSig = ` ${returns[0]}`
-          } else if (returns && returns.length > 1) {
-            returnSig = ` (${returns.join(', ')})`
-          }
-          return `${m.name}(${args})${returnSig}`
-        })
-        .join('; ')
-      return new InterfaceType(`interface { ${methodSigs} }`)
-    }
+    if (methods.length === 0) {
+      return new InterfaceType('interface{}', name)
+    }
+    const methodSigs = methods
+      .map((m: any) => {
+        const args =
+          m.args
+            ?.map((a: any) => (typeof a === 'string' ? a : 'any'))
+            .join(', ') || ''
+        const returns = m.returns?.map((r: any) =>
+          typeof r === 'string' ? r : 'any',
+        )
+        let returnSig = ''
+        if (returns && returns.length === 1) {
+          returnSig = ` ${returns[0]}`
+        } else if (returns && returns.length > 1) {
+          returnSig = ` (${returns.join(', ')})`
+        }
+        return `${m.name}(${args})${returnSig}`
+      })
+      .join('; ')
+    return new InterfaceType(`interface { ${methodSigs} }`, name)
   }
   return new InterfaceType('interface{}')
 }

package/gs/strings/iter.ts

@@ -25,7 +25,7 @@ const asciiSpace: { [key: number]: boolean } = {
 export function Lines(s: string): iter.Seq<string> {
   return (_yield: ((p0: string) => boolean) | null): void => {
     for (; $.len(s) > 0; ) {
-      let line: string = ''
+      let line: string
       {
         let i = IndexByte(s, 10)
         if (i >= 0) {