goscript 0.1.1 → 0.1.2

package/gs/crypto/sha256/index.ts

@@ -0,0 +1,150 @@
+import * as $ from '@goscript/builtin/index.js'
+import {
+  getHostRuntime,
+  type NodeCryptoHash,
+} from '@goscript/builtin/hostio.js'
+
+export const Size = 32
+export const Size224 = 28
+export const BlockSize = 64
+
+type ShaAlgorithm = 'sha224' | 'sha256'
+
+class Sha256Error {
+  constructor(private readonly message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+}
+
+class Digest {
+  private chunks: Uint8Array[] = []
+  private dataLength = 0
+  private hash: NodeCryptoHash | null
+  private canCopyHash: boolean
+
+  constructor(private readonly algorithm: ShaAlgorithm) {
+    this.hash = createNodeHash(algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(p)
+    this.hash?.update(bytes)
+    if (!this.canCopyHash) {
+      this.chunks.push(bytes.slice())
+      this.dataLength += bytes.length
+    }
+    return [bytes.length, null]
+  }
+
+  async Sum(b: $.Bytes): Promise<$.Bytes> {
+    const digest =
+      this.canCopyHash ?
+        new Uint8Array(this.hash!.copy!().digest())
+      : await sum(this.algorithm, this.snapshotBytes())
+    return appendDigest($.bytesToUint8Array(b), digest)
+  }
+
+  Reset(): void {
+    this.chunks = []
+    this.dataLength = 0
+    this.hash = createNodeHash(this.algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Size(): number {
+    return this.algorithm === 'sha224' ? Size224 : Size
+  }
+
+  BlockSize(): number {
+    return BlockSize
+  }
+
+  private snapshotBytes(): Uint8Array {
+    return concatChunks(this.chunks, this.dataLength)
+  }
+}
+
+export function New(): any {
+  return new Digest('sha256')
+}
+
+export function New224(): any {
+  return new Digest('sha224')
+}
+
+export async function Sum224(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha224', data)
+}
+
+export async function Sum256(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha256', data)
+}
+
+async function sum(
+  algorithm: ShaAlgorithm,
+  data: $.Bytes,
+): Promise<Uint8Array> {
+  const hash = createNodeHash(algorithm)
+  if (hash != null) {
+    return new Uint8Array(hash.update($.bytesToUint8Array(data)).digest())
+  }
+
+  if (algorithm === 'sha224') {
+    throw new Error(
+      new Sha256Error('crypto/sha256: SHA-224 digest is unavailable').Error(),
+    )
+  }
+
+  const subtle = subtleCrypto()
+  if (subtle == null) {
+    throw new Error(
+      new Sha256Error('crypto/sha256: WebCrypto digest is unavailable').Error(),
+    )
+  }
+
+  const digest = await subtle.digest(
+    'SHA-256',
+    $.bytesToUint8Array(data) as unknown as BufferSource,
+  )
+  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 createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {
+  const nodeCrypto = getHostRuntime().nodeCrypto
+  if (!nodeCrypto?.createHash) {
+    return null
+  }
+  try {
+    return nodeCrypto.createHash(algorithm)
+  } catch {
+    return null
+  }
+}
+
+function concatChunks(chunks: Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function subtleCrypto(): SubtleCrypto | null {
+  const crypto = globalThis.crypto
+  if (crypto?.subtle && typeof crypto.subtle.digest === 'function') {
+    return crypto.subtle
+  }
+  return null
+}

package/gs/crypto/sha256/meta.json

@@ -0,0 +1,9 @@
+{
+  "asyncFunctions": {
+    "Sum224": true,
+    "Sum256": true
+  },
+  "asyncMethods": {
+    "Digest.Sum": true
+  }
+}

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

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto'
+import { describe, expect, it } from 'vitest'
+
+import { New, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
+
+describe('crypto/sha512 override', () => {
+  it('matches Node digests', async () => {
+    const data = new TextEncoder().encode('goscript sha512')
+
+    expect(toHex(await Sum512(data))).toBe(nodeHash('sha512', data))
+    expect(toHex(await Sum384(data))).toBe(nodeHash('sha384', data))
+    expect(toHex(await Sum512_224(data))).toBe(nodeHash('sha512-224', data))
+    expect(toHex(await Sum512_256(data))).toBe(nodeHash('sha512-256', data))
+  })
+
+  it('supports incremental hash.Hash use', async () => {
+    const h = New()
+    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')))
+  })
+})
+
+function nodeHash(algorithm: string, data: Uint8Array): string {
+  return createHash(algorithm).update(data).digest('hex')
+}
+
+function toHex(value: Uint8Array): string {
+  return Buffer.from(value).toString('hex')
+}

package/gs/crypto/sha512/index.ts

@@ -0,0 +1,161 @@
+import * as $ from '@goscript/builtin/index.js'
+import {
+  getHostRuntime,
+  type NodeCryptoHash,
+} from '@goscript/builtin/hostio.js'
+
+export const Size = 64
+export const Size224 = 28
+export const Size256 = 32
+export const Size384 = 48
+export const BlockSize = 128
+
+type ShaAlgorithm = 'sha384' | 'sha512' | 'sha512-224' | 'sha512-256'
+
+class Digest {
+  private chunks: Uint8Array[] = []
+  private dataLength = 0
+  private hash: NodeCryptoHash | null
+  private canCopyHash: boolean
+
+  constructor(private readonly algorithm: ShaAlgorithm) {
+    this.hash = createNodeHash(algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Write(p: $.Bytes): [number, $.GoError] {
+    const bytes = $.bytesToUint8Array(p)
+    this.hash?.update(bytes)
+    if (!this.canCopyHash) {
+      this.chunks.push(bytes.slice())
+      this.dataLength += bytes.length
+    }
+    return [bytes.length, null]
+  }
+
+  async Sum(b: $.Bytes): Promise<$.Bytes> {
+    const digest =
+      this.canCopyHash ?
+        new Uint8Array(this.hash!.copy!().digest())
+      : await sum(this.algorithm, this.snapshotBytes())
+    return appendDigest($.bytesToUint8Array(b), digest)
+  }
+
+  Reset(): void {
+    this.chunks = []
+    this.dataLength = 0
+    this.hash = createNodeHash(this.algorithm)
+    this.canCopyHash = typeof this.hash?.copy === 'function'
+  }
+
+  Size(): number {
+    switch (this.algorithm) {
+      case 'sha384':
+        return Size384
+      case 'sha512-224':
+        return Size224
+      case 'sha512-256':
+        return Size256
+      default:
+        return Size
+    }
+  }
+
+  BlockSize(): number {
+    return BlockSize
+  }
+
+  private snapshotBytes(): Uint8Array {
+    return concatChunks(this.chunks, this.dataLength)
+  }
+}
+
+export function New(): any {
+  return new Digest('sha512')
+}
+
+export function New384(): any {
+  return new Digest('sha384')
+}
+
+export function New512_224(): any {
+  return new Digest('sha512-224')
+}
+
+export function New512_256(): any {
+  return new Digest('sha512-256')
+}
+
+export async function Sum384(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha384', data)
+}
+
+export async function Sum512(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512', data)
+}
+
+export async function Sum512_224(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512-224', data)
+}
+
+export async function Sum512_256(data: $.Bytes): Promise<Uint8Array> {
+  return sum('sha512-256', data)
+}
+
+async function sum(
+  algorithm: ShaAlgorithm,
+  data: $.Bytes,
+): Promise<Uint8Array> {
+  const hash = createNodeHash(algorithm)
+  if (hash != null) {
+    return new Uint8Array(hash.update($.bytesToUint8Array(data)).digest())
+  }
+
+  const subtle = subtleCrypto()
+  if (subtle == null || (algorithm !== 'sha384' && algorithm !== 'sha512')) {
+    throw new Error(`crypto/sha512: ${algorithm} digest is unavailable`)
+  }
+
+  const digest = await subtle.digest(
+    algorithm === 'sha384' ? 'SHA-384' : 'SHA-512',
+    $.bytesToUint8Array(data) as unknown as BufferSource,
+  )
+  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 createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {
+  const nodeCrypto = getHostRuntime().nodeCrypto
+  if (!nodeCrypto?.createHash) {
+    return null
+  }
+  try {
+    return nodeCrypto.createHash(algorithm)
+  } catch {
+    return null
+  }
+}
+
+function concatChunks(chunks: Uint8Array[], length: number): Uint8Array {
+  const out = new Uint8Array(length)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.length
+  }
+  return out
+}
+
+function subtleCrypto(): SubtleCrypto | null {
+  const crypto = globalThis.crypto
+  if (crypto?.subtle && typeof crypto.subtle.digest === 'function') {
+    return crypto.subtle
+  }
+  return null
+}

package/gs/crypto/sha512/meta.json

@@ -0,0 +1,11 @@
+{
+  "asyncFunctions": {
+    "Sum384": true,
+    "Sum512": true,
+    "Sum512_224": true,
+    "Sum512_256": true
+  },
+  "asyncMethods": {
+    "Digest.Sum": true
+  }
+}

package/gs/encoding/json/index.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Marshal, MarshalIndent, Unmarshal } from './index.js'
+import { Marshal, MarshalIndent, Unmarshal, type Unmarshaler } from './index.js'
 
 class Person {
   public _fields = {
@@ -17,14 +17,36 @@ class Person {
     [],
     Person,
     {
-      Name: { type: { kind: $.TypeKind.Basic, name: 'string' }, tag: 'json:"name"' },
+      Name: {
+        type: { kind: $.TypeKind.Basic, name: 'string' },
+        tag: 'json:"name"',
+      },
       Age: { type: { kind: $.TypeKind.Basic, name: 'int' }, tag: 'json:"age"' },
-      Active: { type: { kind: $.TypeKind.Basic, name: 'bool' }, tag: 'json:"active"' },
+      Active: {
+        type: { kind: $.TypeKind.Basic, name: 'bool' },
+        tag: 'json:"active"',
+      },
     },
   )
 }
 
 describe('encoding/json override', () => {
+  it('registers the Unmarshaler interface shape', () => {
+    class CustomUnmarshaler implements Unmarshaler {
+      UnmarshalJSON(_data: $.Slice<number>): $.GoError {
+        return null
+      }
+    }
+
+    const [value, ok] = $.typeAssertTuple<Unmarshaler>(
+      new CustomUnmarshaler(),
+      'json.Unmarshaler',
+    )
+
+    expect(ok).toBe(true)
+    expect(value.UnmarshalJSON($.stringToBytes('{}'))).toBeNull()
+  })
+
   it('marshals struct fields through json tags', () => {
     const person = new Person()
     person._fields.Name.value = 'Alice'

package/gs/encoding/json/index.ts

@@ -1,5 +1,25 @@
 import * as $ from '@goscript/builtin/index.js'
 
+export interface Unmarshaler {
+  UnmarshalJSON(data: $.Slice<number>): $.GoError
+}
+
+$.registerInterfaceType('json.Unmarshaler', null, [
+  {
+    name: 'UnmarshalJSON',
+    args: [
+      {
+        name: 'data',
+        type: {
+          kind: $.TypeKind.Slice,
+          elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+        },
+      },
+    ],
+    returns: [{ type: 'GoError' }],
+  },
+])
+
 export function Marshal(v: unknown): [$.Slice<number>, $.GoError] {
   try {
     return [$.stringToBytes(JSON.stringify(marshalValue(v))), null]
@@ -147,9 +167,7 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
   )
 }
 
-function structFieldMetadata(
-  value: unknown,
-): Record<string, { tag?: string }> {
+function structFieldMetadata(value: unknown): Record<string, { tag?: string }> {
   if (value === null || typeof value !== 'object') {
     return {}
   }

package/gs/errors/errors.test.ts

@@ -43,7 +43,10 @@ describe('errors.AsType', () => {
 
   it('walks wrapped errors depth first', () => {
     const dns = $.interfaceValue<$.GoError>(new DNSError(), '*net.DNSError')
-    const wrapped = $.interfaceValue<$.GoError>(new Wrapper(dns), '*main.Wrapper')
+    const wrapped = $.interfaceValue<$.GoError>(
+      new Wrapper(dns),
+      '*main.Wrapper',
+    )
 
     const [matched, ok] = AsType(dnsTypeArgs, Join(null, wrapped))
 

package/gs/errors/errors.ts

@@ -191,10 +191,7 @@ export function As(err: $.GoError, target: any): boolean {
     throw new Error('errors: target cannot be nil')
   }
 
-  // Check if err matches target type
-  if (err.constructor === target.constructor) {
-    // Copy properties from err to target
-    Object.assign(target, err)
+  if (assignAsTarget(err, target)) {
     return true
   }
 
@@ -230,6 +227,36 @@ export function As(err: $.GoError, target: any): boolean {
   return false
 }
 
+function assignAsTarget(err: Exclude<$.GoError, null>, target: any): boolean {
+  const targetType = asTargetType(target)
+  if (targetType !== undefined) {
+    const [matched, ok] = $.typeAssertTuple<any>(err, targetType)
+    if (!ok) {
+      return false
+    }
+    if ($.isVarRef(target)) {
+      target.value = matched
+      return true
+    }
+    Object.assign(target, matched)
+    return true
+  }
+
+  if (err.constructor === target.constructor) {
+    Object.assign(target, err)
+    return true
+  }
+  return false
+}
+
+function asTargetType(target: any): string | undefined {
+  const goType = target?.__goType
+  if (typeof goType !== 'string' || !goType.startsWith('*')) {
+    return undefined
+  }
+  return goType.slice(1)
+}
+
 // AsType finds the first error in err's tree that matches the generic error
 // type E, returning the matching error and true. Otherwise it returns E's zero
 // value and false.
@@ -263,10 +290,7 @@ function asType(
     const result = (err as any).Unwrap()
     if (Array.isArray(result)) {
       for (const wrappedErr of result) {
-        if (
-          wrappedErr &&
-          typeof wrappedErr.Error === 'function'
-        ) {
+        if (wrappedErr && typeof wrappedErr.Error === 'function') {
           const [matched, matchedOK] = asType(wrappedErr, typeInfo, zero)
           if (matchedOK) {
             return [matched, true]

package/gs/fmt/fmt.test.ts

@@ -36,7 +36,9 @@ function captureStdout(run: () => void): string {
           length?: number,
           _position?: number | null,
         ) => {
-          buf += new TextDecoder().decode(chunk.subarray(0, length ?? chunk.length))
+          buf += new TextDecoder().decode(
+            chunk.subarray(0, length ?? chunk.length),
+          )
           return length ?? chunk.length
         },
       ),

package/gs/fmt/fmt.ts

@@ -408,11 +408,7 @@ export function Append(b: $.Bytes, ...a: any[]): $.Bytes {
   return newArray
 }
 
-export function Appendf(
-  b: $.Bytes,
-  format: string,
-  ...a: any[]
-): $.Bytes {
+export function Appendf(b: $.Bytes, format: string, ...a: any[]): $.Bytes {
   const result = parseFormat(format, a)
   const encoded = new TextEncoder().encode(result)
   const base = $.bytesToUint8Array(b)

package/gs/github.com/aperturerobotics/protobuf-go-lite/index.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, it } from 'vitest'
 
+import * as $ from '../../../builtin/index.js'
 import {
   AppendVarint,
+  type CloneMessage,
   CompareEqualVT,
+  ConsumeVarint,
   DecodeFixed32,
   DecodeFixed64,
   DecodeVarint,
@@ -13,6 +16,7 @@ import {
   ErrIntOverflow,
   ErrInvalidLength,
   ErrUnexpectedEndOfGroup,
+  IsEqualVTSlice,
   SizeOfVarint,
   Skip,
 } from './index.js'
@@ -25,6 +29,30 @@ class TestValue {
   }
 }
 
+class TestCloneMessage implements CloneMessage {
+  SizeVT(): number {
+    return 0
+  }
+
+  MarshalToSizedBufferVT(): [$.Slice<number>, $.GoError] {
+    return [null, null]
+  }
+
+  MarshalVT(): [$.Slice<number>, $.GoError] {
+    return [null, null]
+  }
+
+  UnmarshalVT(): $.GoError {
+    return null
+  }
+
+  Reset(): void {}
+
+  CloneMessageVT(): CloneMessage | null {
+    return new TestCloneMessage()
+  }
+}
+
 describe('protobuf-go-lite EqualVT helpers', () => {
   it('accepts compiler-emitted runtime type arguments', () => {
     const equal = CompareEqualVT<TestValue>({
@@ -35,6 +63,31 @@ describe('protobuf-go-lite EqualVT helpers', () => {
     expect(equal(new TestValue('a'), new TestValue('b'))).toBe(false)
     expect(equal(null, null)).toBe(true)
   })
+
+  it('accepts nullable generated message slices', () => {
+    const left: $.Slice<TestValue | $.VarRef<TestValue> | null> = [
+      $.varRef(new TestValue('x')),
+      null,
+    ]
+    const right: $.Slice<TestValue | $.VarRef<TestValue> | null> = [
+      new TestValue('x'),
+      null,
+    ]
+
+    expect(IsEqualVTSlice(left, right)).toBe(true)
+  })
+})
+
+describe('protobuf-go-lite runtime interfaces', () => {
+  it('registers CloneMessage metadata for Go type assertions', () => {
+    const [value, ok] = $.typeAssertTuple<CloneMessage | null>(
+      new TestCloneMessage(),
+      'protobuf_go_lite.CloneMessage',
+    )
+
+    expect(ok).toBe(true)
+    expect(value?.CloneMessageVT()).toBeInstanceOf(TestCloneMessage)
+  })
 })
 
 describe('protobuf-go-lite wire helpers', () => {
@@ -50,9 +103,14 @@ describe('protobuf-go-lite wire helpers', () => {
     expect(DecodeVarintInt32(buf, offset)).toEqual([300, 4, null])
     expect(DecodeVarintInt64(buf, offset)).toEqual([300, 4, null])
     expect(DecodeVarintUint32(buf, offset)).toEqual([300, 4, null])
-    expect(Array.from(AppendVarint([], 300) as number[])).toEqual([
-      0xac,
-      0x02,
+    expect(Array.from(AppendVarint([], 300) as number[])).toEqual([0xac, 0x02])
+    expect(SizeOfVarint(0xffffffffffffffffn)).toBe(10)
+    expect(Array.from(AppendVarint([], 0xffffffffffffffffn) as number[])).toEqual([
+      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01,
+    ])
+    expect(ConsumeVarint(AppendVarint([], 0xffffffffffffffffn))).toEqual([
+      0xffffffffffffffffn,
+      10,
     ])
   })
 
@@ -80,10 +138,7 @@ describe('protobuf-go-lite wire helpers', () => {
       5,
       null,
     ])
-    expect(Skip(new Uint8Array([0x0c]))).toEqual([
-      0,
-      ErrUnexpectedEndOfGroup,
-    ])
+    expect(Skip(new Uint8Array([0x0c]))).toEqual([0, ErrUnexpectedEndOfGroup])
   })
 
   it('reports protobuf wire errors as Go errors', () => {