goscript 0.1.2 → 0.1.4

package/gs/crypto/sha512/index.test.ts

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto'
 import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
 
-import { New, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
+import { New, Size, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
 
 describe('crypto/sha512 override', () => {
   it('matches Node digests', async () => {
@@ -18,7 +19,21 @@ describe('crypto/sha512 override', () => {
     h.Write(new TextEncoder().encode('go'))
     h.Write(new TextEncoder().encode('script'))
 
-    expect(toHex(await h.Sum(null))).toBe(nodeHash('sha512', new TextEncoder().encode('goscript')))
+    expect(toHex(await h.Sum(null))).toBe(
+      nodeHash('sha512', new TextEncoder().encode('goscript')),
+    )
+  })
+
+  it('appends into spare byte-slice backing', async () => {
+    const h = New()
+    h.Write(new TextEncoder().encode('abc'))
+
+    const backing = $.makeSlice<number>(Size, undefined, 'byte')
+    const out = await h.Sum($.goSlice(backing, 0, 0))
+    expect(out.length).toBe(Size)
+    expect(toHex($.bytesToUint8Array(backing))).toBe(
+      nodeHash('sha512', new TextEncoder().encode('abc')),
+    )
   })
 })
 

package/gs/crypto/sha512/index.ts

@@ -38,7 +38,7 @@ class Digest {
       this.canCopyHash ?
         new Uint8Array(this.hash!.copy!().digest())
       : await sum(this.algorithm, this.snapshotBytes())
-    return appendDigest($.bytesToUint8Array(b), digest)
+    return appendDigest(b, digest)
   }
 
   Reset(): void {
@@ -123,11 +123,8 @@ async function sum(
   return new Uint8Array(digest)
 }
 
-function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
-  const out = new Uint8Array(prefix.length + digest.length)
-  out.set(prefix)
-  out.set(digest, prefix.length)
-  return out
+function appendDigest(prefix: $.Bytes, digest: Uint8Array): $.Bytes {
+  return $.append(prefix as any, ...digest) as $.Bytes
 }
 
 function createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {

package/gs/embed/index.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest'
+
+import { cloneStructValue, markAsStructValue } from '@goscript/builtin/index.js'
+import { EOF } from '@goscript/io/index.js'
+import { ReadDir, ReadFile, Stat } from '@goscript/io/fs/index.js'
+
+import { FS } from './index.js'
+
+describe('embed.FS', () => {
+  it('clones embedded files as Go struct values', () => {
+    const original = markAsStructValue(
+      new FS(new Map([['config-set.bin', new Uint8Array([1, 2, 3])]])),
+    )
+
+    const cloned = cloneStructValue(original)
+    const [data, err] = cloned.ReadFile('config-set.bin')
+
+    expect(err).toBeNull()
+    expect(Array.from(data)).toEqual([1, 2, 3])
+  })
+
+  it('supports io/fs read, stat, and directory APIs', () => {
+    const fsys = markAsStructValue(
+      new FS(
+        new Map([
+          ['config-set.bin', new Uint8Array([1, 2, 3])],
+          ['assets/config.json', new Uint8Array([4])],
+        ]),
+      ),
+    )
+
+    const [data, readErr] = ReadFile(fsys, 'config-set.bin')
+    expect(readErr).toBeNull()
+    expect(Array.from(data)).toEqual([1, 2, 3])
+    data[0] = 9
+    const [dataAgain, readAgainErr] = ReadFile(fsys, 'config-set.bin')
+    expect(readAgainErr).toBeNull()
+    expect(Array.from(dataAgain)).toEqual([1, 2, 3])
+
+    const [rootEntries, rootErr] = ReadDir(fsys, '.')
+    expect(rootErr).toBeNull()
+    expect(rootEntries!.map((entry) => entry!.Name())).toEqual([
+      'assets',
+      'config-set.bin',
+    ])
+
+    const [assetInfo, statErr] = Stat(fsys, 'assets')
+    expect(statErr).toBeNull()
+    expect(assetInfo!.IsDir()).toBe(true)
+
+    const [assetEntries, assetErr] = ReadDir(fsys, 'assets')
+    expect(assetErr).toBeNull()
+    expect(assetEntries!.map((entry) => entry!.Name())).toEqual(['config.json'])
+  })
+
+  it('supports Open file reads and directory iteration', () => {
+    const fsys = markAsStructValue(
+      new FS(
+        new Map([
+          ['config-set.bin', new Uint8Array([1, 2, 3])],
+          ['assets/config.json', new Uint8Array([4])],
+        ]),
+      ),
+    )
+
+    const [file, openErr] = fsys.Open('config-set.bin')
+    expect(openErr).toBeNull()
+    const buffer = new Uint8Array(2)
+    const [firstRead, firstErr] = file!.Read(buffer)
+    expect(firstErr).toBeNull()
+    expect(firstRead).toBe(2)
+    expect(Array.from(buffer)).toEqual([1, 2])
+    const [secondRead, secondErr] = file!.Read(buffer)
+    expect(secondErr).toBeNull()
+    expect(secondRead).toBe(1)
+    expect(Array.from(buffer)).toEqual([3, 2])
+    const [eofRead, eofErr] = file!.Read(buffer)
+    expect(eofRead).toBe(0)
+    expect(eofErr).toBe(EOF)
+
+    const [dir, dirOpenErr] = fsys.Open('.')
+    expect(dirOpenErr).toBeNull()
+    const [entries, readDirErr] = dir!.ReadDir(1)
+    expect(readDirErr).toBeNull()
+    expect(entries!.map((entry) => entry!.Name())).toEqual(['assets'])
+  })
+})

package/gs/embed/index.ts

@@ -1,20 +1,244 @@
 import * as $ from '@goscript/builtin/index.js'
+import * as io from '@goscript/io/index.js'
 import * as fs from '@goscript/io/fs/index.js'
+import * as time from '@goscript/time/index.js'
 
 export class FS {
+  private files: Map<string, Uint8Array>
+
+  constructor(files?: Map<string, Uint8Array>) {
+    this.files = files ?? new Map()
+  }
+
+  clone(): FS {
+    const files = new Map<string, Uint8Array>()
+    for (const [name, data] of this.files) {
+      files.set(name, data.slice())
+    }
+    return $.markAsStructValue(new FS(files))
+  }
+
   Open(name: string): [fs.File, $.GoError] {
-    return [null, pathError('open', name)]
+    const err = validatePath('open', name)
+    if (err != null) {
+      return [null, err]
+    }
+    const data = this.files.get(name)
+    if (data !== undefined) {
+      return [new embedFile(name, data), null]
+    }
+    const entries = this.dirEntries(name)
+    if (entries === null) {
+      return [null, pathError('open', name, fs.ErrNotExist)]
+    }
+    return [new embedFile(name, null, entries), null]
   }
 
   ReadDir(name: string): [$.Slice<fs.DirEntry>, $.GoError] {
-    return [null, pathError('read', name)]
+    const err = validatePath('read', name)
+    if (err != null) {
+      return [null, err]
+    }
+    const entries = this.dirEntries(name)
+    if (entries === null) {
+      return [null, pathError('read', name, fs.ErrNotExist)]
+    }
+    return [entries, null]
   }
 
   ReadFile(name: string): [Uint8Array, $.GoError] {
-    return [new Uint8Array(0), pathError('read', name)]
+    const err = validatePath('read', name)
+    if (err != null) {
+      return [new Uint8Array(0), err]
+    }
+    const data = this.files.get(name)
+    if (data === undefined) {
+      const err = this.dirExists(name) ? fs.ErrInvalid : fs.ErrNotExist
+      return [new Uint8Array(0), pathError('read', name, err)]
+    }
+    return [data.slice(), null]
+  }
+
+  Stat(name: string): [fs.FileInfo, $.GoError] {
+    const err = validatePath('stat', name)
+    if (err != null) {
+      return [null, err]
+    }
+    const data = this.files.get(name)
+    if (data !== undefined) {
+      return [new embedFileInfo(baseName(name), data.byteLength, 0o444), null]
+    }
+    if (!this.dirExists(name)) {
+      return [null, pathError('stat', name, fs.ErrNotExist)]
+    }
+    return [new embedFileInfo(baseName(name), 0, fs.ModeDir | 0o555), null]
+  }
+
+  private dirEntries(name: string): $.Slice<fs.DirEntry> | null {
+    if (!this.dirExists(name)) {
+      return null
+    }
+    const prefix = name === '.' ? '' : name + '/'
+    const entries = new Map<string, fs.DirEntry>()
+    for (const [filePath, data] of this.files) {
+      if (prefix !== '' && !filePath.startsWith(prefix)) {
+        continue
+      }
+      const rest = prefix === '' ? filePath : filePath.slice(prefix.length)
+      if (rest === '') {
+        continue
+      }
+      const slash = rest.indexOf('/')
+      const childName = slash === -1 ? rest : rest.slice(0, slash)
+      if (entries.has(childName)) {
+        continue
+      }
+      const isDir = slash !== -1
+      const info =
+        isDir ?
+          new embedFileInfo(childName, 0, fs.ModeDir | 0o555)
+        : new embedFileInfo(childName, data.byteLength, 0o444)
+      entries.set(childName, new embedDirEntry(info))
+    }
+    return Array.from(entries.values()).sort((a, b) =>
+      a!.Name().localeCompare(b!.Name()),
+    )
+  }
+
+  private dirExists(name: string): boolean {
+    if (name === '.') {
+      return true
+    }
+    const prefix = name + '/'
+    for (const path of this.files.keys()) {
+      if (path.startsWith(prefix)) {
+        return true
+      }
+    }
+    return false
+  }
+}
+
+class embedFile {
+  private offset = 0
+  private dirOffset = 0
+
+  constructor(
+    private readonly name: string,
+    private readonly data: Uint8Array | null,
+    private readonly entries: $.Slice<fs.DirEntry> = [],
+  ) {}
+
+  Close(): $.GoError {
+    return null
+  }
+
+  Read(buffer: Uint8Array): [number, $.GoError] {
+    if (this.data === null) {
+      return [0, pathError('read', this.name, fs.ErrInvalid)]
+    }
+    if (this.offset >= this.data.byteLength) {
+      return [0, io.EOF]
+    }
+    const n = Math.min(buffer.byteLength, this.data.byteLength - this.offset)
+    buffer.set(this.data.subarray(this.offset, this.offset + n))
+    this.offset += n
+    return [n, null]
+  }
+
+  ReadDir(n: number): [$.Slice<fs.DirEntry>, $.GoError] {
+    if (this.data !== null) {
+      return [null, pathError('readdir', this.name, fs.ErrInvalid)]
+    }
+    const allEntries = this.entries ?? []
+    if (n <= 0) {
+      const entries = allEntries.slice(this.dirOffset)
+      this.dirOffset = allEntries.length
+      return [entries, null]
+    }
+    if (this.dirOffset >= allEntries.length) {
+      return [[], io.EOF]
+    }
+    const entries = allEntries.slice(this.dirOffset, this.dirOffset + n)
+    this.dirOffset += entries.length
+    return [entries, null]
+  }
+
+  Stat(): [fs.FileInfo, $.GoError] {
+    if (this.data === null) {
+      return [new embedFileInfo(baseName(this.name), 0, fs.ModeDir | 0o555), null]
+    }
+    return [new embedFileInfo(baseName(this.name), this.data.byteLength, 0o444), null]
+  }
+}
+
+class embedFileInfo {
+  constructor(
+    private readonly name: string,
+    private readonly size: number,
+    private readonly mode: fs.FileMode,
+  ) {}
+
+  IsDir(): boolean {
+    return fs.FileMode_IsDir(this.mode)
+  }
+
+  ModTime(): time.Time {
+    return new time.Time()
+  }
+
+  Mode(): fs.FileMode {
+    return this.mode
+  }
+
+  Name(): string {
+    return this.name
+  }
+
+  Size(): number {
+    return this.size
+  }
+
+  Sys(): null {
+    return null
+  }
+}
+
+class embedDirEntry {
+  constructor(private readonly info: fs.FileInfo) {}
+
+  Info(): [fs.FileInfo, $.GoError] {
+    return [this.info, null]
+  }
+
+  IsDir(): boolean {
+    return this.info!.IsDir()
+  }
+
+  Name(): string {
+    return this.info!.Name()
+  }
+
+  Type(): fs.FileMode {
+    return fs.fileModeType(this.info!.Mode())
   }
 }
 
-function pathError(op: string, name: string): $.GoError {
-  return new fs.PathError({ Op: op, Path: name, Err: fs.ErrNotExist })
+function validatePath(op: string, name: string): $.GoError {
+  if (!fs.ValidPath(name)) {
+    return pathError(op, name, fs.ErrInvalid)
+  }
+  return null
+}
+
+function pathError(op: string, name: string, err: $.GoError): $.GoError {
+  return new fs.PathError({ Op: op, Path: name, Err: err })
+}
+
+function baseName(name: string): string {
+  const idx = name.lastIndexOf('/')
+  if (idx === -1) {
+    return name
+  }
+  return name.slice(idx + 1)
 }

package/gs/fmt/fmt.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { resetHostRuntimeForTests } from '@goscript/builtin/hostio.js'
+import * as $ from '@goscript/builtin/index.js'
 import * as fmt from './fmt.js'
 
 const originalDeno = (globalThis as any).Deno
@@ -57,6 +58,15 @@ describe('fmt basic value formatting', () => {
     expect(fmt.Sprintf('Type: %T', 3.14)).toBe('Type: float64')
     expect(fmt.Sprintf('Type: %T', 'hello')).toBe('Type: string')
     expect(fmt.Sprintf('Type: %T', true)).toBe('Type: bool')
+    expect(
+      fmt.Sprintf(
+        'Type: %T',
+        $.namedValueInterfaceValue(123, 'int', {}, {
+          kind: $.TypeKind.Basic,
+          name: 'int',
+        }),
+      ),
+    ).toBe('Type: int')
   })
 
   it('%d truncation behavior including negatives', () => {
@@ -114,6 +124,20 @@ describe('fmt basic value formatting', () => {
     // We prefer GoString() first
     expect(fmt.Sprintf('%v', goStringer)).toBe('<go stringer>')
   })
+
+  it('%w formats errors by Error method', () => {
+    const err = $.newError('root')
+    expect(fmt.Errorf('wrap: %w', err)?.Error()).toBe('wrap: root')
+  })
+
+  it('%s formats stringers by String method', () => {
+    const stringer = {
+      String() {
+        return 'string-value'
+      },
+    }
+    expect(fmt.Sprintf('value=%s', stringer)).toBe('value=string-value')
+  })
 })
 
 describe('fmt spacing rules', () => {
@@ -145,7 +169,7 @@ describe('fmt spacing rules', () => {
     expect(output).toBe('hi there 1 2\n')
   })
 
-  it('Fprint/Fprintln behave like Print/Println with writers', () => {
+  it('Fprint/Fprintln behave like Print/Println with writers', async () => {
     const chunks: Uint8Array[] = []
     const writer = {
       Write(b: Uint8Array): [number, any] {
@@ -154,14 +178,29 @@ describe('fmt spacing rules', () => {
       },
     }
 
-    let [n, err] = fmt.Fprint(writer, 1, 2, 'x', 3)
+    let [n, err] = await fmt.Fprint(writer, 1, 2, 'x', 3)
     expect(err).toBeNull()
     expect(n).toBe(5) // "1 2x3".length
     expect(new TextDecoder().decode(chunks[0])).toBe('1 2x3')
-    ;[, err] = fmt.Fprintln(writer, 'hi', 'there', 1, 2)
+    ;[, err] = await fmt.Fprintln(writer, 'hi', 'there', 1, 2)
     expect(err).toBeNull()
     expect(new TextDecoder().decode(chunks[1])).toBe('hi there 1 2\n')
   })
+
+  it('Fprintf awaits async writers', async () => {
+    const chunks: Uint8Array[] = []
+    const writer = {
+      async Write(b: Uint8Array): Promise<[number, any]> {
+        chunks.push(b)
+        return [b.length, null]
+      },
+    }
+
+    const [n, err] = await fmt.Fprintf(writer, 'n=%d s=%s', 7, 'ok')
+    expect(err).toBeNull()
+    expect(n).toBe(8)
+    expect(new TextDecoder().decode(chunks[0])).toBe('n=7 s=ok')
+  })
 })
 
 describe('fmt parseFormat basic cases', () => {
@@ -187,3 +226,22 @@ describe('fmt parseFormat basic cases', () => {
     expect(fmt.Sprintf('%c', 65)).toBe('A')
   })
 })
+
+describe('fmt scanning', () => {
+  it('scans decimal fields separated by literals', () => {
+    const start = $.varRef(0)
+    const end = $.varRef(0)
+
+    const [n, err] = fmt.Sscanf(
+      'bytes=12-34',
+      'bytes=%d-%d',
+      $.interfaceValue(start, '*int64'),
+      $.interfaceValue(end, '*int64'),
+    )
+
+    expect(err).toBeNull()
+    expect(n).toBe(2)
+    expect(start.value).toBe(12)
+    expect(end.value).toBe(34)
+  })
+})

package/gs/fmt/fmt.ts

@@ -34,15 +34,20 @@ function formatValue(value: any, verb: string): string {
   switch (verb) {
     case 'v': // default format
       return defaultFormat(value)
+    case 'w': // wrapped error
+      return defaultFormat(value)
     case 'd': // decimal integer
       return String(Math.trunc(Number(value)))
     case 'f': // decimal point, no exponent
       return Number(value).toString()
     case 's': // string
-      return String(value)
+      if (typeof value === 'string') return value
+      if (value instanceof Uint8Array) return $.bytesToString(value)
+      return defaultFormat(value)
     case 't': // boolean
       return value ? 'true' : 'false'
     case 'T': // type (approximate Go names for primitives we need)
+      if (hasGoTypeName(value)) return value.__goType
       if (typeof value === 'number') {
         return Number.isInteger(value) ? 'int' : 'float64'
       }
@@ -85,6 +90,14 @@ function formatValue(value: any, verb: string): string {
   }
 }
 
+function hasGoTypeName(value: unknown): value is { __goType: string } {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as { __goType?: unknown }).__goType === 'string'
+  )
+}
+
 function defaultFormat(value: any): string {
   if (value === null || value === undefined) return '<nil>'
   if (typeof value === 'boolean') return value ? 'true' : 'false'
@@ -120,6 +133,9 @@ function defaultFormat(value: any): string {
         // Ignore error by continuing to next case.
       }
     }
+    if ('__goValue' in value) {
+      return defaultFormat((value as { __goValue: unknown }).__goValue)
+    }
     // Basic Map/Set rendering
     if (value instanceof Map) {
       const parts: string[] = []
@@ -357,8 +373,21 @@ export function Sprintln(...a: any[]): string {
   return a.map(defaultFormat).join(' ') + '\n'
 }
 
+async function writeToWriter(
+  w: any,
+  out: string,
+): Promise<[number, $.GoError | null]> {
+  if (w && w.Write) {
+    return await w.Write(new TextEncoder().encode(out))
+  }
+  return [0, $.newError('Writer does not implement Write method')]
+}
+
 // Fprint functions (write to Writer) - simplified implementation
-export function Fprint(w: any, ...a: any[]): [number, $.GoError | null] {
+export async function Fprint(
+  w: any,
+  ...a: any[]
+): Promise<[number, $.GoError | null]> {
   // Same spacing as Print
   let out = ''
   for (let i = 0; i < a.length; i++) {
@@ -369,32 +398,26 @@ export function Fprint(w: any, ...a: any[]): [number, $.GoError | null] {
     }
     out += defaultFormat(a[i])
   }
-  if (w && w.Write) {
-    return w.Write(new TextEncoder().encode(out))
-  }
-  return [0, $.newError('Writer does not implement Write method')]
+  return await writeToWriter(w, out)
 }
 
-export function Fprintf(
+export async function Fprintf(
   w: any,
   format: string,
   ...a: any[]
-): [number, $.GoError | null] {
+): Promise<[number, $.GoError | null]> {
   const result = parseFormat(format, a)
-  if (w && w.Write) {
-    return w.Write(new TextEncoder().encode(result))
-  }
-  return [0, $.newError('Writer does not implement Write method')]
+  return await writeToWriter(w, result)
 }
 
-export function Fprintln(w: any, ...a: any[]): [number, $.GoError | null] {
+export async function Fprintln(
+  w: any,
+  ...a: any[]
+): Promise<[number, $.GoError | null]> {
   // Same behavior as Println
   const body = a.map(defaultFormat).join(' ')
   const result = body + '\n'
-  if (w && w.Write) {
-    return w.Write(new TextEncoder().encode(result))
-  }
-  return [0, $.newError('Writer does not implement Write method')]
+  return await writeToWriter(w, result)
 }
 
 // Append functions (append to byte slice)
@@ -488,12 +511,82 @@ export function Sscan(_str: string, ..._a: any[]): [number, $.GoError | null] {
 }
 
 export function Sscanf(
-  _str: string,
-  _format: string,
-  ..._a: any[]
+  str: string,
+  format: string,
+  ...a: any[]
 ): [number, $.GoError | null] {
-  // TODO: Implement formatted scanning from string
-  return [0, $.newError('Sscanf not implemented')]
+  const parts = buildScanPattern(format)
+  if (parts == null) {
+    return [0, $.newError(`unsupported Sscanf format: ${format}`)]
+  }
+  const match = parts.pattern.exec(str)
+  if (match == null) {
+    return [0, $.newError('input does not match format')]
+  }
+
+  let assigned = 0
+  for (let i = 0; i < parts.verbs.length && i < a.length; i++) {
+    const raw = match[i + 1]
+    const value = parts.verbs[i] === 'd' ? Number.parseInt(raw, 10) : raw
+    if (!assignScanValue(a[i], value)) {
+      return [assigned, $.newError('scan destination is not assignable')]
+    }
+    assigned++
+  }
+  return [assigned, null]
+}
+
+function buildScanPattern(
+  format: string,
+): { pattern: RegExp; verbs: string[] } | null {
+  let source = '^'
+  const verbs: string[] = []
+  for (let i = 0; i < format.length; i++) {
+    const ch = format[i]
+    if (ch !== '%') {
+      source += /\s/.test(ch) ? '\\s+' : escapeRegExp(ch)
+      continue
+    }
+    const verb = format[++i]
+    if (verb === '%') {
+      source += '%'
+      continue
+    }
+    if (verb === 'd') {
+      source += '([+-]?\\d+)'
+      verbs.push(verb)
+      continue
+    }
+    if (verb === 's') {
+      source += '(\\S+)'
+      verbs.push(verb)
+      continue
+    }
+    return null
+  }
+  source += '$'
+  return { pattern: new RegExp(source), verbs }
+}
+
+function assignScanValue(target: any, value: string | number): boolean {
+  const ref =
+    $.isVarRef(target) ? target
+    : (
+      target != null &&
+      typeof target === 'object' &&
+      $.isVarRef(target.__goValue)
+    ) ?
+      target.__goValue
+    : null
+  if (ref == null) {
+    return false
+  }
+  ref.value = value
+  return true
+}
+
+function escapeRegExp(ch: string): string {
+  return ch.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
 }
 
 export function Sscanln(