goscript 0.1.3 → 0.1.4

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

@@ -58,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', () => {
@@ -115,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', () => {
@@ -146,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] {
@@ -155,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', () => {

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)

package/gs/fmt/meta.json

@@ -1,5 +1,10 @@
 {
+  "asyncFunctions": {
+    "Fprint": true,
+    "Fprintf": true,
+    "Fprintln": true
+  },
   "dependencies": [
     "errors"
   ]
-} 
+}

package/gs/github.com/aperturerobotics/starpc/srpc/index.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, it } from 'vitest'
 
 import * as context from '@goscript/context/index.js'
+import * as $ from '@goscript/builtin/index.js'
 
-import { MuxedConn, NewWebSocketConn } from './index.js'
+import { MuxedConn, NewClientSet, NewPrefixClient, NewWebSocketConn } from './index.js'
 
 describe('starpc/srpc override', () => {
   it('wraps websocket connections with the same outbound direction as Go', () => {
@@ -28,4 +29,10 @@ describe('starpc/srpc override', () => {
     expect(serverConn?.outbound).toBe(false)
     expect(clientConn?.outbound).toBe(true)
   })
+
+  it('registers prefixed clients as srpc.Client values', () => {
+    const client = NewPrefixClient(NewClientSet(null), ['plugin-host/'])
+
+    expect($.typeAssert(client, 'srpc.Client').ok).toBe(true)
+  })
 })

package/gs/github.com/aperturerobotics/starpc/srpc/index.ts

@@ -115,6 +115,33 @@ export interface Client {
   ): Promise<[Stream | null, $.GoError]>
 }
 
+$.registerInterfaceType('srpc.Client', null, [
+  {
+    name: 'ExecCall',
+    args: [
+      { name: 'ctx', type: 'context.Context' },
+      { name: 'service', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'method', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'in', type: 'srpc.Message' },
+      { name: 'out', type: 'srpc.Message' },
+    ],
+    returns: [{ name: '_r0', type: 'error' }],
+  },
+  {
+    name: 'NewStream',
+    args: [
+      { name: 'ctx', type: 'context.Context' },
+      { name: 'service', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'method', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      { name: 'firstMsg', type: 'srpc.Message' },
+    ],
+    returns: [
+      { name: '_r0', type: 'srpc.Stream' },
+      { name: '_r1', type: 'error' },
+    ],
+  },
+])
+
 export class ClientSet implements Client {
   private clients: $.Slice<Client | null>
 
@@ -395,6 +422,84 @@ class memoryStream implements Stream {
   }
 }
 
+class streamQueue {
+  private queue: (Message | null)[] = []
+  private waiters: ((msg: Message | null, err: $.GoError) => void)[] = []
+  private closed = false
+
+  public send(msg: Message | null): $.GoError {
+    if (this.closed) {
+      return ErrCompleted
+    }
+    const waiter = this.waiters.shift()
+    if (waiter != null) {
+      waiter(msg, null)
+      return null
+    }
+    this.queue.push(msg)
+    return null
+  }
+
+  public recv(msg: Message | null): MaybePromise<$.GoError> {
+    const next = this.queue.shift()
+    if (next !== undefined) {
+      if (msg != null && next != null) {
+        Object.assign(msg, next)
+      }
+      return null
+    }
+    if (this.closed) {
+      return io.EOF
+    }
+    return new Promise<$.GoError>((resolve) => {
+      this.waiters.push((sent, err) => {
+        if (msg != null && sent != null) {
+          Object.assign(msg, sent)
+        }
+        resolve(err)
+      })
+    })
+  }
+
+  public close(): $.GoError {
+    this.closed = true
+    for (const waiter of this.waiters.splice(0)) {
+      waiter(null, io.EOF)
+    }
+    return null
+  }
+}
+
+class pairedMemoryStream implements Stream {
+  constructor(
+    private ctx: context.Context,
+    private incoming: streamQueue,
+    private outgoing: streamQueue,
+  ) {}
+
+  public Context(): context.Context {
+    return this.ctx
+  }
+
+  public MsgSend(msg: Message | null): $.GoError {
+    return this.outgoing.send(msg)
+  }
+
+  public MsgRecv(msg: Message | null): MaybePromise<$.GoError> {
+    return this.incoming.recv(msg)
+  }
+
+  public CloseSend(): $.GoError {
+    return this.outgoing.close()
+  }
+
+  public Close(): $.GoError {
+    const incomingErr = this.incoming.close()
+    const outgoingErr = this.outgoing.close()
+    return incomingErr ?? outgoingErr
+  }
+}
+
 class streamWithClose implements Stream {
   constructor(
     private stream: Stream,
@@ -738,7 +843,7 @@ class transportClient implements Client {
     if (output != null) {
       output.Reset()
     }
-    return await writer?.Close() ?? null
+    return (await writer?.Close()) ?? null
   }
 
   public async NewStream(
@@ -792,7 +897,9 @@ export function NewClient(openStream: OpenStreamFunc | null): Client {
 class invokerClient implements Client {
   constructor(
     private invoker: Invoker | null,
-    private contextFn: ((ctx: context.Context) => context.Context) | null = null,
+    private contextFn:
+      | ((ctx: context.Context) => context.Context)
+      | null = null,
   ) {}
 
   public async ExecCall(
@@ -833,19 +940,36 @@ class invokerClient implements Client {
     if (this.invoker == null) {
       return [null, ErrNoAvailableClients]
     }
-    const stream = new memoryStream(
-      this.contextFn == null ? ctx : this.contextFn(ctx),
-      firstMsg,
+    const streamCtx = this.contextFn == null ? ctx : this.contextFn(ctx)
+    const clientInput = new streamQueue()
+    const serverInput = new streamQueue()
+    const clientStream = new pairedMemoryStream(
+      streamCtx,
+      clientInput,
+      serverInput,
+    )
+    const serverStream = new pairedMemoryStream(
+      streamCtx,
+      serverInput,
+      clientInput,
     )
+    if (firstMsg != null) {
+      const err = serverInput.send(firstMsg)
+      if (err != null) {
+        return [null, err]
+      }
+    }
     const pending = Promise.resolve(
-      this.invoker.InvokeMethod(service, method, stream),
+      this.invoker.InvokeMethod(service, method, serverStream),
     )
     pending.then(([handled, err]) => {
       if (!handled || err != null) {
-        stream.Close()
+        clientStream.Close()
+        return
       }
+      serverStream.CloseSend()
     })
-    return [stream, null]
+    return [clientStream, null]
   }
 }
 
@@ -936,7 +1060,9 @@ export class ServerRPC {
       stream,
     )
     const callErr = err ?? (handled ? null : ErrUnimplemented)
-    await this.writer?.WritePacket(NewCallDataPacket(null, false, true, callErr))
+    await this.writer?.WritePacket(
+      NewCallDataPacket(null, false, true, callErr),
+    )
     return callErr
   }
 
@@ -995,8 +1121,10 @@ export function NewServerPipe(server: Server | null): OpenStreamFunc {
     _ctx: context.Context,
     _msgHandler: PacketDataHandler,
     _closeHandler: CloseHandler,
-  ): [PacketWriter | null, $.GoError] => [new closedPacketWriter(), null]) as
-    OpenStreamFunc
+  ): [PacketWriter | null, $.GoError] => [
+    new closedPacketWriter(),
+    null,
+  ]) as OpenStreamFunc
   if (server != null) {
     openStream.__server = server
   }