goscript 0.1.0 → 0.1.2

package/gs/builtin/slice.ts

@@ -1,3 +1,61 @@
+import { isVarRef, varRef, type VarRef } from './varRef.js'
+
+export class GoBinaryString extends String {
+  readonly bytes: Uint8Array
+
+  constructor(bytes: Uint8Array) {
+    super(bytesToBinaryString(bytes))
+    this.bytes = bytes.slice()
+  }
+
+  toString(): string {
+    return bytesToBinaryString(this.bytes)
+  }
+
+  valueOf(): string {
+    return this.toString()
+  }
+
+  [Symbol.toPrimitive](): string {
+    return this.toString()
+  }
+}
+
+type GoStringValue = string | GoBinaryString
+type GoStringBytes = GoStringValue | Slice<number> | Uint8Array
+
+function isGoStringValue(value: unknown): value is GoStringValue {
+  return typeof value === 'string' || value instanceof GoBinaryString
+}
+
+function goStringBytes(str: GoStringValue): Uint8Array {
+  if (str instanceof GoBinaryString) {
+    return str.bytes.slice()
+  }
+  return new TextEncoder().encode(str)
+}
+
+function goStringComparableBytes(value: GoStringBytes): Uint8Array {
+  if (isGoStringValue(value)) {
+    return goStringBytes(value)
+  }
+  if (value instanceof Uint8Array) {
+    return value
+  }
+  if (value === null || value === undefined) {
+    return new Uint8Array(0)
+  }
+  return Uint8Array.from(asArray(value))
+}
+
+function goStringFromBytes(bytes: Uint8Array): string {
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes)
+  } catch {
+    return new GoBinaryString(bytes) as unknown as string
+  }
+}
+
 /**
  * GoSliceObject contains metadata for complex slice views
  */
@@ -6,8 +64,13 @@ interface GoSliceObject<T> {
   offset: number // Offset into the backing array
   length: number // Length of the slice
   capacity: number // Capacity of the slice
+  target?: T[] // Materialized proxy target for JS array operations
 }
 
+const addressStride = 0x100000000
+let nextAddressBase = 1
+const addressBases = new WeakMap<object, number>()
+
 /**
  * SliceProxy is a proxy object for complex slices
  */
@@ -15,6 +78,25 @@ export type SliceProxy<T> = T[] & {
   __meta__: GoSliceObject<T>
 }
 
+type ByteSlice = Uint8Array & {
+  __meta__?: GoSliceObject<number>
+}
+
+function sliceIndexProperty(prop: string | symbol): number {
+  if (typeof prop !== 'string' || prop.length === 0) {
+    return -1
+  }
+  let index = 0
+  for (let i = 0; i < prop.length; i++) {
+    const digit = prop.charCodeAt(i) - 48
+    if (digit < 0 || digit > 9) {
+      return -1
+    }
+    index = index * 10 + digit
+  }
+  return index
+}
+
 /**
  * Slice<T> is a union type that is either a plain array or a proxy
  * null represents the nil state.
@@ -32,39 +114,41 @@ export type Slice<T> =
  * and route it through the backing array.
  */
 function wrapSliceProxy<T>(proxy: SliceProxy<T>): SliceProxy<T> {
+  const meta = proxy.__meta__
+  meta.target = proxy
   const handler = {
     get(target: any, prop: string | symbol): any {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const index = Number(prop)
-        if (index >= 0 && index < target.__meta__.length) {
-          return target.__meta__.backing[target.__meta__.offset + index]
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index < meta.length) {
+          return meta.backing[meta.offset + index]
         }
         throw new Error(
-          `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+          `Slice index out of range: ${index} >= ${meta.length}`,
         )
       }
 
       if (prop === 'length') {
-        return target.__meta__.length
+        return meta.length
       }
 
       if (prop === '__meta__') {
-        return target.__meta__
+        return meta
       }
 
       return Reflect.get(target, prop)
     },
 
     set(target: any, prop: string | symbol, value: any): boolean {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const index = Number(prop)
-        if (index >= 0 && index < target.__meta__.length) {
-          target.__meta__.backing[target.__meta__.offset + index] = value
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index < meta.length) {
+          meta.backing[meta.offset + index] = value
           target[index] = value // Also update the proxy target for consistency
           return true
         }
         throw new Error(
-          `Slice index out of range: ${index} >= ${target.__meta__.length}`,
+          `Slice index out of range: ${index} >= ${meta.length}`,
         )
       }
 
@@ -79,6 +163,24 @@ function wrapSliceProxy<T>(proxy: SliceProxy<T>): SliceProxy<T> {
   return new Proxy(proxy, handler) as SliceProxy<T>
 }
 
+function sliceProxyFromBacking<T>(
+  backing: T[],
+  offset: number,
+  length: number,
+  capacity: number,
+  target?: T[],
+): SliceProxy<T> {
+  const proxyTargetArray = (target ?? new Array<T>(length)) as SliceProxy<T>
+  proxyTargetArray.length = length
+  if (target === undefined) {
+    for (let i = 0; i < length; i++) {
+      proxyTargetArray[i] = backing[offset + i]
+    }
+  }
+  proxyTargetArray.__meta__ = { backing, offset, length, capacity }
+  return wrapSliceProxy(proxyTargetArray)
+}
+
 // asArray converts a slice to a JavaScript array.
 export function asArray<T>(slice: Slice<T>): T[] {
   if (slice === null || slice === undefined) {
@@ -104,6 +206,48 @@ export function asArray<T>(slice: Slice<T>): T[] {
   return []
 }
 
+export function sliceToArray<T>(
+  slice: Slice<T> | Uint8Array,
+  length: number,
+  typeHint?: string,
+): T[] | Uint8Array {
+  if (len(slice) < length) {
+    throw new Error(
+      `runtime error: cannot convert slice with length ${len(slice)} to array with length ${length}`,
+    )
+  }
+  if (typeHint === 'byte') {
+    return new Uint8Array(
+      asArray(slice as Slice<T>).slice(0, length) as number[],
+    )
+  }
+  return asArray(slice as Slice<T>).slice(0, length)
+}
+
+export function sliceToArrayPointer<T>(
+  slice: Slice<T> | Uint8Array,
+  length: number,
+  typeHint?: string,
+): VarRef<T[] | Uint8Array> {
+  if (len(slice) < length) {
+    throw new Error(
+      `runtime error: cannot convert slice with length ${len(slice)} to array pointer with length ${length}`,
+    )
+  }
+  if (typeHint === 'byte') {
+    if (slice instanceof Uint8Array) {
+      return varRef(goSlice(slice, 0, length) as unknown as Uint8Array)
+    }
+    return varRef(
+      goSlice(slice as Slice<T>, 0, length) as unknown as Uint8Array,
+    )
+  }
+  if (slice instanceof Uint8Array) {
+    return varRef(goSlice(slice, 0, length) as unknown as T[])
+  }
+  return varRef(goSlice(slice, 0, length) as T[])
+}
+
 /**
  * isComplexSlice checks if a slice is a complex slice (has __meta__ property)
  */
@@ -117,6 +261,35 @@ function isComplexSlice<T>(slice: Slice<T>): slice is SliceProxy<T> {
   )
 }
 
+function normalizeSliceIndex(value: number | undefined): number | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+  return Number(value)
+}
+
+function byteSliceMeta(slice: Uint8Array): GoSliceObject<number> | undefined {
+  return (slice as ByteSlice).__meta__
+}
+
+function byteSliceView(
+  backing: Uint8Array,
+  offset: number,
+  length: number,
+  capacity: number,
+): Uint8Array {
+  const view = backing.subarray(offset, offset + length) as ByteSlice
+  if (capacity !== length) {
+    view.__meta__ = {
+      backing: backing as unknown as number[],
+      offset,
+      length,
+      capacity,
+    }
+  }
+  return view
+}
+
 /**
  * isSliceProxy checks if a slice is a SliceProxy (has __meta__ property)
  * This is an alias for isComplexSlice for better type hinting
@@ -135,6 +308,7 @@ export const makeSlice = <T>(
   length: number,
   capacity?: number,
   typeHint?: string,
+  zeroFactory?: () => T,
 ): Slice<T> => {
   if (typeHint === 'byte') {
     const actualCapacity = capacity === undefined ? length : capacity
@@ -149,24 +323,7 @@ export const makeSlice = <T>(
       return new Uint8Array(length) as Slice<T>
     }
 
-    // If capacity > length, create a SliceProxy backed by a Uint8Array
-    const backingUint8 = new Uint8Array(actualCapacity)
-    const backingNumbers = Array.from(backingUint8) as T[] // Convert to number[] for backing
-
-    const proxyTargetArray = new Array<T>(length)
-    for (let i = 0; i < length; i++) {
-      proxyTargetArray[i] = 0 as T // Initialize with zeros
-    }
-
-    const proxy = proxyTargetArray as SliceProxy<T>
-    proxy.__meta__ = {
-      backing: backingNumbers,
-      offset: 0,
-      length: length,
-      capacity: actualCapacity,
-    }
-
-    return wrapSliceProxy(proxy) as Slice<T>
+    return byteSliceView(new Uint8Array(actualCapacity), 0, length, actualCapacity) as Slice<T>
   }
 
   const actualCapacity = capacity === undefined ? length : capacity
@@ -176,28 +333,28 @@ export const makeSlice = <T>(
     )
   }
 
-  let zeroVal: any
-  switch (typeHint) {
-    case 'number':
-      zeroVal = 0
-      break
-    case 'boolean':
-      zeroVal = false
-      break
-    case 'string':
-      zeroVal = ''
-      break
-    default:
-      zeroVal = null // Default for objects, complex types, or unspecified
+  const zeroValue = (): T => {
+    if (zeroFactory !== undefined) {
+      return zeroFactory()
+    }
+    switch (typeHint) {
+      case 'number':
+        return 0 as T
+      case 'boolean':
+        return false as T
+      case 'string':
+        return '' as T
+      default:
+        return null as T // Default for objects, complex types, or unspecified
+    }
   }
 
   const backingArr = new Array<T>(actualCapacity)
-  // Initialize the relevant part of the backing array
-  for (let i = 0; i < length; i++) {
-    backingArr[i] = zeroVal
+  // Go zero-initializes the whole backing array. Elements beyond len become
+  // observable when a slice is resliced up to cap.
+  for (let i = 0; i < actualCapacity; i++) {
+    backingArr[i] = zeroValue()
   }
-  // The rest of backingArr (from length to actualCapacity-1) remains uninitialized (undefined),
-  // representing available capacity.
 
   // OPTIMIZATION: If length equals capacity, return backing array directly
   if (length === actualCapacity) {
@@ -208,7 +365,7 @@ export const makeSlice = <T>(
   // Its elements up to 'length' should reflect the initialized part of the slice.
   const proxyTargetArray = new Array<T>(length)
   for (let i = 0; i < length; i++) {
-    proxyTargetArray[i] = backingArr[i] // Or simply zeroVal
+    proxyTargetArray[i] = backingArr[i]
   }
 
   const proxy = proxyTargetArray as SliceProxy<T>
@@ -222,9 +379,9 @@ export const makeSlice = <T>(
   // Create a proper Proxy with the handler for SliceProxy behavior
   const handler = {
     get(target: any, prop: string | symbol): any {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const index = Number(prop)
-        if (index >= 0 && index < target.__meta__.length) {
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index < target.__meta__.length) {
           return target.__meta__.backing[target.__meta__.offset + index]
         }
         throw new Error(
@@ -244,9 +401,9 @@ export const makeSlice = <T>(
     },
 
     set(target: any, prop: string | symbol, value: any): boolean {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const index = Number(prop)
-        if (index >= 0 && index < target.__meta__.length) {
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index < target.__meta__.length) {
           target.__meta__.backing[target.__meta__.offset + index] = value
           target[index] = value // Also update the proxy target for consistency
           return true
@@ -296,11 +453,16 @@ export function goSlice<T>( // T can be number for Uint8Array case
   high?: number,
   max?: number,
 ): Slice<T> {
+  s = collectionValue(s) as Slice<T> | Uint8Array
+  low = normalizeSliceIndex(low)
+  high = normalizeSliceIndex(high)
+  max = normalizeSliceIndex(max)
+
   const handler = {
     get(target: any, prop: string | symbol): any {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const index = Number(prop)
-        if (index >= 0 && index < target.__meta__.length) {
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index < target.__meta__.length) {
           return target.__meta__.backing[target.__meta__.offset + index]
         }
         throw new Error(
@@ -335,10 +497,11 @@ export function goSlice<T>( // T can be number for Uint8Array case
     },
 
     set(target: any, prop: string | symbol, value: any): boolean {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const index = Number(prop)
-        if (index >= 0 && index < target.__meta__.length) {
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index < target.__meta__.length) {
           target.__meta__.backing[target.__meta__.offset + index] = value
+          target[index] = value
           return true
         }
         if (
@@ -346,6 +509,7 @@ export function goSlice<T>( // T can be number for Uint8Array case
           target.__meta__.length < target.__meta__.capacity
         ) {
           target.__meta__.backing[target.__meta__.offset + index] = value
+          target[index] = value
           target.__meta__.length++
           return true
         }
@@ -363,54 +527,51 @@ export function goSlice<T>( // T can be number for Uint8Array case
   }
 
   if (s instanceof Uint8Array) {
+    const meta = byteSliceMeta(s)
+    const metaBacking = meta?.backing as unknown
+    const backing =
+      metaBacking instanceof Uint8Array ? metaBacking : s
+    const baseOffset = meta?.offset ?? 0
+    const baseCapacity = meta?.capacity ?? s.length
     const actualLow = low ?? 0
     const actualHigh = high ?? s.length
 
-    if (actualLow < 0 || actualHigh < actualLow || actualHigh > s.length) {
+    if (
+      actualLow < 0 ||
+      actualHigh < actualLow ||
+      actualLow > baseCapacity ||
+      actualHigh > baseCapacity
+    ) {
       throw new Error(
-        `Invalid slice indices: low ${actualLow}, high ${actualHigh} for Uint8Array of length ${s.length}`,
+        `Invalid slice indices: low ${actualLow}, high ${actualHigh} for Uint8Array with capacity ${baseCapacity}`,
       )
     }
 
-    const subArrayView = s.subarray(actualLow, actualHigh) // This is Uint8Array
+    const newLength = actualHigh - actualLow
 
     if (max !== undefined) {
-      if (max < actualHigh || max > s.length) {
+      if (max < actualHigh || max > baseCapacity) {
         // max is relative to the original s.length (capacity)
         throw new Error(
-          `Invalid max index: ${max}. Constraints: low ${actualLow} <= high ${actualHigh} <= max <= original_length ${s.length}`,
+          `Invalid max index: ${max}. Constraints: low ${actualLow} <= high ${actualHigh} <= max <= capacity ${baseCapacity}`,
         )
       }
 
-      const newLength = subArrayView.length // actualHigh - actualLow
       const newCap = max - actualLow // Capacity of the new slice view
-
-      if (newCap !== newLength) {
-        // Capacity is different from length, so return SliceProxy<number>
-        // The original s was Uint8Array, so T is effectively 'number' for this path.
-        const backingNumbers = Array.from(subArrayView) // Convert Uint8Array data to number[]
-
-        const proxyTarget = {
-          __meta__: {
-            backing: backingNumbers, // number[]
-            offset: 0, // Offset is 0 because backingNumbers is a direct copy
-            length: newLength,
-            capacity: newCap,
-          },
-        }
-        // Explicitly cast to Slice<T> after ensuring T is number for this branch.
-        return new Proxy(
-          proxyTarget,
-          handler,
-        ) as unknown as SliceProxy<number> as Slice<T>
-      } else {
-        // newCap === newLength, standard Uint8Array is fine.
-        return subArrayView as Slice<T> // T is number
-      }
-    } else {
-      // max is not defined, return the Uint8Array subarray view directly.
-      return subArrayView as Slice<T> // T is number
+      return byteSliceView(
+        backing,
+        baseOffset + actualLow,
+        newLength,
+        newCap,
+      ) as Slice<T>
     }
+
+    return byteSliceView(
+      backing,
+      baseOffset + actualLow,
+      newLength,
+      baseCapacity - actualLow,
+    ) as Slice<T>
   }
 
   // Handle nil slices - in Go, slicing a nil slice with valid bounds returns nil
@@ -501,7 +662,7 @@ export function goSlice<T>( // T can be number for Uint8Array case
   const newOffset = oldOffset + low
 
   // OPTIMIZATION: If the result would have offset=0 and length=capacity, return backing directly
-  if (newOffset === 0 && newLength === newCap) {
+  if (newOffset === 0 && newLength === newCap && backing.length === newLength) {
     return backing as Slice<T>
   }
 
@@ -555,9 +716,9 @@ export const arrayToSlice = <T>(
 
   const handler = {
     get(target: any, prop: string | symbol): any {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const index = Number(prop)
-        if (index >= 0 && index < target.__meta__.length) {
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index < target.__meta__.length) {
           return target.__meta__.backing[target.__meta__.offset + index]
         }
         throw new Error(
@@ -592,9 +753,9 @@ export const arrayToSlice = <T>(
     },
 
     set(target: any, prop: string | symbol, value: any): boolean {
-      if (typeof prop === 'string' && /^\d+$/.test(prop)) {
-        const index = Number(prop)
-        if (index >= 0 && index < target.__meta__.length) {
+      const index = sliceIndexProperty(prop)
+      if (index >= 0) {
+        if (index < target.__meta__.length) {
           target.__meta__.backing[target.__meta__.offset + index] = value
           return true
         }
@@ -639,37 +800,51 @@ export const arrayToSlice = <T>(
  */
 export const len = <T = unknown, V = unknown>(
   obj:
-    | string
+    | GoStringValue
     | Array<T>
     | Slice<T>
     | Map<T, V>
     | Set<T>
     | Uint8Array
+    | { len(): number }
     | null
     | undefined,
 ): number => {
+  obj = collectionValue(obj) as typeof obj
   if (obj === null || obj === undefined) {
     return 0
   }
 
   if (typeof obj === 'string') {
-    return stringLen(obj) // Call new stringLen for strings
+    return stringLen(obj)
+  }
+
+  if (obj instanceof Uint8Array) {
+    return obj.length
+  }
+
+  if (Array.isArray(obj)) {
+    const meta = (obj as unknown as SliceProxy<T>).__meta__
+    if (meta !== undefined) {
+      return meta.length
+    }
+    return obj.length
   }
 
   if (obj instanceof Map || obj instanceof Set) {
     return obj.size
   }
 
-  if (obj instanceof Uint8Array) {
-    return obj.length
+  if (obj instanceof GoBinaryString) {
+    return stringLen(obj)
   }
 
-  if (isComplexSlice(obj)) {
-    return obj.__meta__.length
+  if (isComplexSlice(obj as any)) {
+    return (obj as unknown as SliceProxy<T>).__meta__.length
   }
 
-  if (Array.isArray(obj)) {
-    return obj.length
+  if (typeof (obj as any).len === 'function') {
+    return (obj as { len(): number }).len()
   }
 
   throw new Error('cannot determine len of this type')
@@ -680,23 +855,30 @@ export const len = <T = unknown, V = unknown>(
  * @param obj The slice.
  * @returns The capacity of the slice.
  */
-export const cap = <T>(obj: Slice<T> | Uint8Array): number => {
+export const cap = <T>(
+  obj: Slice<T> | Uint8Array | { cap(): number } | null | undefined,
+): number => {
+  obj = collectionValue(obj) as typeof obj
   if (obj === null || obj === undefined) {
     return 0
   }
 
-  if (obj instanceof Uint8Array) {
-    return obj.length // Uint8Array capacity is its length
+  if (isComplexSlice(obj as any)) {
+    return (obj as SliceProxy<T>).__meta__.capacity
   }
 
-  if (isComplexSlice(obj)) {
-    return obj.__meta__.capacity
+  if (obj instanceof Uint8Array) {
+    return obj.length // Uint8Array capacity is its length
   }
 
   if (Array.isArray(obj)) {
     return obj.length
   }
 
+  if (typeof (obj as any).cap === 'function') {
+    return (obj as { cap(): number }).cap()
+  }
+
   return 0
 }
 
@@ -711,6 +893,7 @@ export const cap = <T>(obj: Slice<T> | Uint8Array): number => {
 export function append(slice: Uint8Array, ...elements: any[]): Uint8Array
 // Overload for null slice with number elements - returns number slice (Bytes compatible)
 export function append(slice: null, ...elements: number[]): Slice<number>
+export function append<T>(slice: null, ...elements: T[]): Slice<T>
 export function append<T>(slice: Slice<T>, ...elements: any[]): Slice<T>
 export function append<T>(
   slice: Slice<T> | Uint8Array | null,
@@ -719,59 +902,11 @@ export function append<T>(
   // 1. Flatten all elements from the varargs `...elements` into `varargsElements`.
   // Determine if the result should be a Uint8Array.
   const inputIsUint8Array = slice instanceof Uint8Array
-  const appendingUint8Array = elements.some((el) => el instanceof Uint8Array)
-  const produceUint8Array =
-    inputIsUint8Array ||
-    appendingUint8Array ||
-    (slice === null && appendingUint8Array)
+  const produceUint8Array = inputIsUint8Array
 
   // If producing Uint8Array, all elements must be numbers and potentially flattened from other Uint8Arrays/number slices.
   if (produceUint8Array) {
-    let combinedBytes: number[] = []
-    // Add bytes from the original slice if it exists and is numeric.
-    if (inputIsUint8Array) {
-      combinedBytes.push(...Array.from(slice as Uint8Array))
-    } else if (slice !== null && slice !== undefined) {
-      // Original was Slice<number> or number[]
-      const sliceLen = len(slice)
-      for (let i = 0; i < sliceLen; i++) {
-        const val = (slice as any)[i]
-        if (typeof val !== 'number') {
-          throw new Error(
-            'Cannot produce Uint8Array: original slice contains non-number elements.',
-          )
-        }
-        combinedBytes.push(val)
-      }
-    }
-    // Add bytes from the varargs elements.
-    // For Uint8Array, elements are always flattened if they are slices/Uint8Arrays.
-    for (const item of elements) {
-      if (item instanceof Uint8Array) {
-        combinedBytes.push(...Array.from(item))
-      } else if (isComplexSlice(item) || Array.isArray(item)) {
-        const itemLen = len(item as Slice<any>)
-        for (let i = 0; i < itemLen; i++) {
-          const val = (item as any)[i]
-          if (typeof val !== 'number') {
-            throw new Error(
-              'Cannot produce Uint8Array: appended elements contain non-numbers.',
-            )
-          }
-          combinedBytes.push(val)
-        }
-      } else {
-        if (typeof item !== 'number') {
-          throw new Error(
-            'Cannot produce Uint8Array: appended elements contain non-numbers.',
-          )
-        }
-        combinedBytes.push(item)
-      }
-    }
-    const newArr = new Uint8Array(combinedBytes.length)
-    newArr.set(combinedBytes)
-    return newArr as any
+    return appendByteSlice(slice as Uint8Array, elements) as any
   }
 
   // Handle generic Slice<T> (non-Uint8Array result).
@@ -783,28 +918,30 @@ export function append<T>(
     return slice as any
   }
 
-  let originalElements: T[] = []
+  let originalElements: T[] | undefined
+  let oldLength = 0
   let oldCapacity: number
   let isOriginalComplex = false
   let originalBacking: T[] | undefined = undefined
+  let originalTarget: T[] | undefined = undefined
   let originalOffset = 0
 
   if (slice === null || slice === undefined) {
     oldCapacity = 0
   } else if (isComplexSlice(slice)) {
     const meta = slice.__meta__
-    for (let i = 0; i < meta.length; i++)
-      originalElements.push(meta.backing[meta.offset + i])
+    oldLength = meta.length
     oldCapacity = meta.capacity
     isOriginalComplex = true
     originalBacking = meta.backing
+    originalTarget = meta.target
     originalOffset = meta.offset
   } else {
     // Simple T[] array
     originalElements = (slice as T[]).slice()
-    oldCapacity = (slice as T[]).length
+    oldLength = originalElements.length
+    oldCapacity = oldLength
   }
-  const oldLength = originalElements.length
   const newLength = oldLength + numAdded
 
   // Case 1: Modify in-place if original was SliceProxy and has enough capacity.
@@ -812,16 +949,19 @@ export function append<T>(
     for (let i = 0; i < numAdded; i++) {
       originalBacking[originalOffset + oldLength + i] = elements[i] as T
     }
-    const resultProxy = new Array(newLength) as SliceProxy<T>
-    for (let i = 0; i < newLength; i++)
-      resultProxy[i] = originalBacking[originalOffset + i]
-    resultProxy.__meta__ = {
-      backing: originalBacking,
-      offset: originalOffset,
-      length: newLength,
-      capacity: oldCapacity,
+    const target = originalTarget
+    if (target !== undefined) {
+      for (let i = 0; i < numAdded; i++) {
+        target[oldLength + i] = elements[i] as T
+      }
     }
-    return wrapSliceProxy(resultProxy) as any
+    return sliceProxyFromBacking(
+      originalBacking,
+      originalOffset,
+      newLength,
+      oldCapacity,
+      target,
+    ) as any
   }
 
   // Case 2: Reallocation is needed.
@@ -838,22 +978,87 @@ export function append<T>(
   }
 
   const newBacking = new Array<T>(newCapacity)
-  for (let i = 0; i < oldLength; i++) {
-    newBacking[i] = originalElements[i]
+  if (isOriginalComplex && originalBacking) {
+    for (let i = 0; i < oldLength; i++) {
+      newBacking[i] = originalBacking[originalOffset + i]
+    }
+  } else if (originalElements !== undefined) {
+    for (let i = 0; i < oldLength; i++) {
+      newBacking[i] = originalElements[i]
+    }
   }
   for (let i = 0; i < numAdded; i++) {
     newBacking[oldLength + i] = elements[i] as T
   }
 
-  const resultProxy = new Array(newLength) as SliceProxy<T>
-  for (let i = 0; i < newLength; i++) resultProxy[i] = newBacking[i]
-  resultProxy.__meta__ = {
-    backing: newBacking,
-    offset: 0,
-    length: newLength,
-    capacity: newCapacity,
+  return sliceProxyFromBacking(newBacking, 0, newLength, newCapacity) as any
+}
+
+function appendByteSlice(slice: Uint8Array, elements: any[]): Uint8Array {
+  const meta = byteSliceMeta(slice)
+  const metaBacking = meta?.backing as unknown
+  const backing =
+    metaBacking instanceof Uint8Array ? metaBacking : slice
+  const offset = meta?.offset ?? 0
+  const oldLength = slice.length
+  const oldCapacity = meta?.capacity ?? oldLength
+  let added = 0
+  for (const item of elements) {
+    added += byteElementLength(item)
+  }
+  const newLength = oldLength + added
+  if (newLength <= oldCapacity) {
+    const view = byteSliceView(backing, offset, newLength, oldCapacity)
+    writeByteElements(view, oldLength, elements)
+    return view
+  }
+  const next = new Uint8Array(newLength)
+  next.set(slice)
+  writeByteElements(next, oldLength, elements)
+  return next
+}
+
+function byteElementLength(item: any): number {
+  if (item instanceof Uint8Array) {
+    return item.length
+  }
+  if (isComplexSlice(item) || Array.isArray(item)) {
+    return len(item as Slice<any>)
+  }
+  if (typeof item !== 'number') {
+    throw new Error('Cannot produce Uint8Array: appended elements contain non-numbers.')
+  }
+  return 1
+}
+
+function writeByteElements(dst: Uint8Array, offset: number, elements: any[]): void {
+  let cursor = offset
+  for (const item of elements) {
+    if (item instanceof Uint8Array) {
+      dst.set(item, cursor)
+      cursor += item.length
+      continue
+    }
+    if (isComplexSlice(item) || Array.isArray(item)) {
+      const itemLen = len(item as Slice<any>)
+      for (let i = 0; i < itemLen; i++) {
+        const value = (item as any)[i]
+        if (typeof value !== 'number') {
+          throw new Error(
+            'Cannot produce Uint8Array: appended elements contain non-numbers.',
+          )
+        }
+        dst[cursor] = value
+        cursor++
+      }
+      continue
+    }
+    if (typeof item !== 'number') {
+      throw new Error('Cannot produce Uint8Array: appended elements contain non-numbers.')
+    }
+    dst[cursor] = item
+    cursor++
   }
-  return wrapSliceProxy(resultProxy) as any
 }
 
 /**
@@ -868,14 +1073,14 @@ export function copy<T>(dst: Slice<T>, src: Slice<T>): number
 export function copy<T>(dst: Slice<T>, src: string): number
 export function copy<T>(
   dst: Slice<T> | Uint8Array,
-  src: Slice<T> | Uint8Array | string,
+  src: Slice<T> | Uint8Array | GoStringValue,
 ): number {
   if (dst === null) {
     return 0
   }
 
   // Handle string source first
-  if (typeof src === 'string') {
+  if (isGoStringValue(src)) {
     return copyFromString(dst, src)
   }
 
@@ -916,9 +1121,13 @@ export function copy<T>(
 /**
  * Helper: Copy from string to any destination type
  */
-function copyFromString<T>(dst: Slice<T> | Uint8Array, src: string): number {
+function copyFromString<T>(
+  dst: Slice<T> | Uint8Array,
+  src: GoStringValue,
+): number {
   const dstLen = dst instanceof Uint8Array ? dst.length : len(dst)
-  const count = Math.min(dstLen, src.length)
+  const bytes = goStringBytes(src)
+  const count = Math.min(dstLen, bytes.length)
 
   if (count === 0) {
     return 0
@@ -926,18 +1135,18 @@ function copyFromString<T>(dst: Slice<T> | Uint8Array, src: string): number {
 
   if (dst instanceof Uint8Array) {
     for (let i = 0; i < count; i++) {
-      dst[i] = src.charCodeAt(i)
+      dst[i] = bytes[i]
     }
   } else if (isComplexSlice(dst)) {
     const dstMeta = dst.__meta__
     for (let i = 0; i < count; i++) {
-      const byteVal = src.charCodeAt(i)
+      const byteVal = bytes[i]
       dstMeta.backing[dstMeta.offset + i] = byteVal as unknown as T
       ;(dst as any)[i] = byteVal
     }
   } else if (Array.isArray(dst)) {
     for (let i = 0; i < count; i++) {
-      dst[i] = src.charCodeAt(i) as unknown as T
+      dst[i] = bytes[i] as unknown as T
     }
   }
 
@@ -952,15 +1161,9 @@ function copyToUint8Array(
   src: Slice<number>,
   count: number,
 ): number {
-  if (isComplexSlice(src)) {
-    const srcMeta = src.__meta__
-    for (let i = 0; i < count; i++) {
-      dst[i] = srcMeta.backing[srcMeta.offset + i]
-    }
-  } else if (Array.isArray(src)) {
-    for (let i = 0; i < count; i++) {
-      dst[i] = src[i]
-    }
+  const values = copySliceValues(src, count)
+  for (let i = 0; i < count; i++) {
+    dst[i] = values[i]
   }
   return count
 }
@@ -973,15 +1176,16 @@ function copyFromUint8Array<T>(
   src: Uint8Array,
   count: number,
 ): number {
+  const values = Array.from(src.subarray(0, count))
   if (isComplexSlice(dst)) {
     const dstMeta = dst.__meta__
     for (let i = 0; i < count; i++) {
-      dstMeta.backing[dstMeta.offset + i] = src[i] as unknown as T
-      ;(dst as any)[i] = src[i]
+      dstMeta.backing[dstMeta.offset + i] = values[i] as unknown as T
+      ;(dst as any)[i] = values[i]
     }
   } else if (Array.isArray(dst)) {
     for (let i = 0; i < count; i++) {
-      dst[i] = src[i] as unknown as T
+      dst[i] = values[i] as unknown as T
     }
   }
   return count
@@ -995,37 +1199,36 @@ function copyBetweenSlices<T>(
   src: Slice<T>,
   count: number,
 ): number {
+  const values = copySliceValues(src, count)
   if (isComplexSlice(dst)) {
     const dstMeta = dst.__meta__
-
-    if (isComplexSlice(src)) {
-      const srcMeta = src.__meta__
-      for (let i = 0; i < count; i++) {
-        dstMeta.backing[dstMeta.offset + i] =
-          srcMeta.backing[srcMeta.offset + i]
-        ;(dst as any)[i] = srcMeta.backing[srcMeta.offset + i]
-      }
-    } else if (Array.isArray(src)) {
-      for (let i = 0; i < count; i++) {
-        dstMeta.backing[dstMeta.offset + i] = src[i]
-        ;(dst as any)[i] = src[i]
-      }
+    for (let i = 0; i < count; i++) {
+      dstMeta.backing[dstMeta.offset + i] = values[i]
+      ;(dst as any)[i] = values[i]
     }
   } else if (Array.isArray(dst)) {
-    if (isComplexSlice(src)) {
-      const srcMeta = src.__meta__
-      for (let i = 0; i < count; i++) {
-        dst[i] = srcMeta.backing[srcMeta.offset + i]
-      }
-    } else if (Array.isArray(src)) {
-      for (let i = 0; i < count; i++) {
-        dst[i] = src[i]
-      }
+    for (let i = 0; i < count; i++) {
+      dst[i] = values[i]
     }
   }
   return count
 }
 
+function copySliceValues<T>(src: Slice<T>, count: number): T[] {
+  const values = new Array<T>(count)
+  if (isComplexSlice(src)) {
+    const srcMeta = src.__meta__
+    for (let i = 0; i < count; i++) {
+      values[i] = srcMeta.backing[srcMeta.offset + i]
+    }
+  } else if (Array.isArray(src)) {
+    for (let i = 0; i < count; i++) {
+      values[i] = src[i]
+    }
+  }
+  return values
+}
+
 /**
  * Accesses an element at a specific index for various Go-like types (string, slice, array).
  * Mimics Go's indexing behavior: `myCollection[index]`
@@ -1038,14 +1241,14 @@ function copyBetweenSlices<T>(
  * @throws Error if index is out of bounds or type is unsupported.
  */
 export function index<T>(
-  collection: string | Slice<T> | T[],
+  collection: GoStringValue | Slice<T> | T[],
   index: number,
 ): T | number {
   if (collection === null || collection === undefined) {
     throw new Error('runtime error: index on nil or undefined collection')
   }
 
-  if (typeof collection === 'string') {
+  if (isGoStringValue(collection)) {
     return indexString(collection, index) // Use the existing indexString for byte access
   } else if (collection instanceof Uint8Array) {
     if (index < 0 || index >= collection.length) {
@@ -1072,6 +1275,151 @@ export function index<T>(
   throw new Error('runtime error: index on unsupported type')
 }
 
+/**
+ * indexRef returns an addressable reference to a slice or array element.
+ */
+export function indexRef<T>(
+  collection: Slice<T> | T[] | Uint8Array,
+  index: number,
+): VarRef<T> {
+  if (collection === null || collection === undefined) {
+    throw new Error('runtime error: index on nil or undefined collection')
+  }
+  if (collection instanceof Uint8Array) {
+    if (index < 0 || index >= collection.length) {
+      throw new Error(
+        `runtime error: index out of range [${index}] with length ${collection.length}`,
+      )
+    }
+    return {
+      get value() {
+        return collection[index] as T
+      },
+      set value(value: T) {
+        collection[index] = value as number
+      },
+      __isVarRef: true,
+      __goAddress: () => indexAddress(collection, index),
+      __goCollection: collection,
+      __goIndex: index,
+    }
+  }
+  if (isComplexSlice(collection)) {
+    if (index < 0 || index >= collection.__meta__.length) {
+      throw new Error(
+        `runtime error: index out of range [${index}] with length ${collection.__meta__.length}`,
+      )
+    }
+    const backingIndex = collection.__meta__.offset + index
+    return {
+      get value() {
+        return collection.__meta__.backing[backingIndex]
+      },
+      set value(value: T) {
+        collection[index] = value
+      },
+      __isVarRef: true,
+      __goAddress: () => indexAddress(collection, index),
+      __goCollection: collection,
+      __goIndex: index,
+    }
+  }
+  if (Array.isArray(collection)) {
+    if (index < 0 || index >= collection.length) {
+      throw new Error(
+        `runtime error: index out of range [${index}] with length ${collection.length}`,
+      )
+    }
+    return {
+      get value() {
+        return collection[index]
+      },
+      set value(value: T) {
+        collection[index] = value
+      },
+      __isVarRef: true,
+      __goAddress: () => indexAddress(collection, index),
+      __goCollection: collection,
+      __goIndex: index,
+    }
+  }
+  throw new Error('runtime error: index on unsupported type')
+}
+
+/**
+ * arrayPointerFromIndexRef turns &slice[i] into a pointer to an N-element array
+ * view. This models unsafe conversions such as (*[64]byte)(unsafe.Pointer(&b[0]))
+ * for packages that immediately slice or index the resulting array pointer.
+ */
+export function arrayPointerFromIndexRef<T>(
+  ref: VarRef<T>,
+  length: number,
+): VarRef<Slice<T> | T[] | Uint8Array> {
+  const collection = ref.__goCollection as
+    | Slice<T>
+    | T[]
+    | Uint8Array
+    | undefined
+  if (collection === undefined) {
+    throw new Error(
+      'unsafe array pointer requires an indexed collection reference',
+    )
+  }
+  const index = ref.__goIndex ?? 0
+  return varRef(
+    goSlice(collection as any, index, index + length) as
+      | Slice<T>
+      | T[]
+      | Uint8Array,
+  )
+}
+
+/**
+ * indexAddress returns a stable synthetic address for an addressable slice or
+ * array element.
+ */
+export function indexAddress<T>(
+  collection: Slice<T> | T[] | Uint8Array,
+  index: number,
+): number {
+  if (collection === null || collection === undefined) {
+    throw new Error('runtime error: index on nil or undefined collection')
+  }
+
+  let backing: object
+  let backingIndex: number
+  let length: number
+  if (collection instanceof Uint8Array) {
+    backing = collection.buffer
+    backingIndex = collection.byteOffset + index
+    length = collection.length
+  } else if (isComplexSlice(collection)) {
+    backing = collection.__meta__.backing
+    backingIndex = collection.__meta__.offset + index
+    length = collection.__meta__.length
+  } else if (Array.isArray(collection)) {
+    backing = collection
+    backingIndex = index
+    length = collection.length
+  } else {
+    throw new Error('runtime error: index on unsupported type')
+  }
+
+  if (index < 0 || index >= length) {
+    throw new Error(
+      `runtime error: index out of range [${index}] with length ${length}`,
+    )
+  }
+
+  let base = addressBases.get(backing)
+  if (base === undefined) {
+    base = nextAddressBase * addressStride
+    nextAddressBase++
+    addressBases.set(backing, base)
+  }
+  return base + backingIndex
+}
+
 /**
  * Converts a string to an array of Unicode code points (runes).
  * @param str The input string.
@@ -1081,6 +1429,22 @@ export const stringToRunes = (str: string): number[] => {
   return Array.from(str).map((c) => c.codePointAt(0) || 0)
 }
 
+/**
+ * Returns Go range pairs for a string: UTF-8 byte offset and rune value.
+ * @param str The input string.
+ * @returns Index/rune pairs matching Go's `for i, r := range str`.
+ */
+export const rangeString = (str: string): Array<[number, number]> => {
+  const encoder = new TextEncoder()
+  const pairs: Array<[number, number]> = []
+  let offset = 0
+  for (const char of str) {
+    pairs.push([offset, char.codePointAt(0) || 0])
+    offset += encoder.encode(char).length
+  }
+  return pairs
+}
+
 /**
  * Converts a single-character string to its Unicode code point (rune).
  * Used for readable rune constants like $.stringToRune('/') instead of 47.
@@ -1122,10 +1486,10 @@ export const byte = (n: number): number => {
  * @throws Error if index is out of bounds.
  */
 export const indexString = (
-  str: string | import('./builtin.js').Bytes,
+  str: GoStringValue | import('./builtin.js').Bytes,
   index: number,
 ): number => {
-  if (typeof str !== 'string') {
+  if (!isGoStringValue(str)) {
     // Bytes - access directly
     if (str instanceof Uint8Array) {
       if (index < 0 || index >= str.length) {
@@ -1148,7 +1512,7 @@ export const indexString = (
     }
     return str[index]
   }
-  const bytes = new TextEncoder().encode(str)
+  const bytes = goStringBytes(str)
   if (index < 0 || index >= bytes.length) {
     throw new Error(
       `runtime error: index out of range [${index}] with length ${bytes.length}`,
@@ -1163,8 +1527,8 @@ export const indexString = (
  * @param str The string.
  * @returns The number of bytes in the UTF-8 representation of the string.
  */
-export const stringLen = (str: string): number => {
-  return new TextEncoder().encode(str).length
+export const stringLen = (str: GoStringValue): number => {
+  return goStringBytes(str).length
 }
 
 /**
@@ -1177,11 +1541,11 @@ export const stringLen = (str: string): number => {
  * @throws Error if the slice would create invalid UTF-8.
  */
 export const sliceString = (
-  str: string,
+  str: GoStringValue,
   low?: number,
   high?: number,
 ): string => {
-  const bytes = new TextEncoder().encode(str)
+  const bytes = goStringBytes(str)
   const actualLow = low === undefined ? 0 : low
   const actualHigh = high === undefined ? bytes.length : high
 
@@ -1203,21 +1567,7 @@ export const sliceString = (
     )
   }
 
-  const slicedBytes = bytes.subarray(actualLow, actualHigh)
-
-  try {
-    // Attempt to decode with strict UTF-8 validation
-    const result = new TextDecoder('utf-8', { fatal: true }).decode(slicedBytes)
-    return result
-  } catch (e: unknown) {
-    // If we get here, the slice would create invalid UTF-8
-    // This is a fundamental limitation of JavaScript string handling
-    throw new Error(
-      `Cannot slice string at byte indices [${actualLow}:${actualHigh}] because it would create invalid UTF-8. ` +
-        `This is a limitation of JavaScript's string handling.`,
-      { cause: e },
-    )
-  }
+  return goStringFromBytes(bytes.subarray(actualLow, actualHigh))
 }
 
 /**
@@ -1231,9 +1581,7 @@ export const bytesToString = (
   if (bytes === null) return ''
   // If it's already a string, just return it
   if (typeof bytes === 'string') return bytes
-  if (bytes instanceof Uint8Array) {
-    return new TextDecoder().decode(bytes)
-  }
+  if (bytes instanceof Uint8Array) return goStringFromBytes(bytes)
   // Ensure we get a plain number[] for Uint8Array.from
   let byteArray: number[]
   if (isComplexSlice(bytes)) {
@@ -1246,7 +1594,114 @@ export const bytesToString = (
     // For simple T[] slices
     byteArray = bytes
   }
-  return new TextDecoder().decode(Uint8Array.from(byteArray))
+  return goStringFromBytes(Uint8Array.from(byteArray)) as string
+}
+
+export function stringEqual(
+  left: GoStringBytes,
+  right: GoStringBytes,
+): boolean {
+  const leftBytes = goStringComparableBytes(left)
+  const rightBytes = goStringComparableBytes(right)
+  if (leftBytes.length !== rightBytes.length) {
+    return false
+  }
+  for (let i = 0; i < leftBytes.length; i++) {
+    if (leftBytes[i] !== rightBytes[i]) {
+      return false
+    }
+  }
+  return true
+}
+
+export function stringCompare(
+  left: GoStringBytes,
+  right: GoStringBytes,
+): number {
+  if (!isGoStringValue(left) && !isGoStringValue(right)) {
+    const leftBytes = byteStringView(left)
+    const rightBytes = byteStringView(right)
+    const leftLen = leftBytes.length
+    const rightLen = rightBytes.length
+    const sharedLen = Math.min(leftLen, rightLen)
+    for (let i = 0; i < sharedLen; i++) {
+      const diff =
+        (leftBytes.backing[leftBytes.offset + i] ?? 0) -
+        (rightBytes.backing[rightBytes.offset + i] ?? 0)
+      if (diff !== 0) {
+        return diff
+      }
+    }
+    return leftLen - rightLen
+  }
+
+  const leftBytes = goStringComparableBytes(left)
+  const rightBytes = goStringComparableBytes(right)
+  const sharedLen = Math.min(leftBytes.length, rightBytes.length)
+  for (let i = 0; i < sharedLen; i++) {
+    const diff = leftBytes[i] - rightBytes[i]
+    if (diff !== 0) {
+      return diff
+    }
+  }
+  return leftBytes.length - rightBytes.length
+}
+
+type ByteStringView = {
+  backing: ArrayLike<number>
+  offset: number
+  length: number
+}
+
+function byteStringView(value: GoStringBytes): ByteStringView {
+  value = collectionValue(value) as GoStringBytes
+  if (value === null || value === undefined) {
+    return { backing: [], offset: 0, length: 0 }
+  }
+  if (value instanceof Uint8Array) {
+    return { backing: value, offset: 0, length: value.length }
+  }
+  if (Array.isArray(value)) {
+    const meta = (value as unknown as SliceProxy<number>).__meta__
+    if (meta !== undefined) {
+      return {
+        backing: meta.backing,
+        offset: meta.offset,
+        length: meta.length,
+      }
+    }
+    return { backing: value, offset: 0, length: value.length }
+  }
+  const meta = (value as unknown as SliceProxy<number>).__meta__
+  return {
+    backing: meta.backing,
+    offset: meta.offset,
+    length: meta.length,
+  }
+}
+
+function collectionValue(value: unknown): unknown {
+  if (isVarRef(value)) {
+    return collectionValue(value.value)
+  }
+  if (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { __goType?: unknown }).__goType === 'string' &&
+    '__goValue' in value
+  ) {
+    return collectionValue((value as { __goValue: unknown }).__goValue)
+  }
+  return value
+}
+
+function bytesToBinaryString(bytes: Uint8Array): string {
+  const chunkSize = 0x8000
+  let out = ''
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    out += String.fromCharCode(...bytes.subarray(i, i + chunkSize))
+  }
+  return out
 }
 
 /**
@@ -1255,10 +1710,10 @@ export const bytesToString = (
  * @returns A Uint8Array representing the UTF-8 bytes of the string.
  */
 export function stringToBytes(
-  s: string | import('./builtin.js').Bytes,
+  s: GoStringValue | import('./builtin.js').Bytes,
 ): Uint8Array {
-  if (typeof s === 'string') {
-    return new TextEncoder().encode(s)
+  if (isGoStringValue(s)) {
+    return goStringBytes(s)
   }
   // Already bytes - normalize to Uint8Array
   if (s instanceof Uint8Array) {
@@ -1271,6 +1726,71 @@ export function stringToBytes(
   return new Uint8Array(Array.isArray(s) ? s : [])
 }
 
+type StringHeaderData = {
+  kind: 'string'
+  value: string
+}
+
+export function stringHeaderRef(s: VarRef<string>): VarRef<{
+  Data: StringHeaderData
+  Len: number
+}> {
+  return varRef({
+    get Data(): StringHeaderData {
+      return { kind: 'string', value: s.value }
+    },
+    set Data(_value: StringHeaderData) {},
+    get Len(): number {
+      return stringToBytes(s.value).length
+    },
+    set Len(_value: number) {},
+  })
+}
+
+export function sliceHeaderRef(b: VarRef<Slice<number>>): VarRef<{
+  Data: StringHeaderData | null
+  Len: number
+  Cap: number
+}> {
+  let data: StringHeaderData | null = null
+  let length = 0
+  let capacity = 0
+  const refresh = () => {
+    if (data === null) {
+      return
+    }
+    const bytes = stringToBytes(data.value)
+    const out = makeSlice<number>(length, Math.max(capacity, length), 'byte')
+    if (out !== null) {
+      copy(out, goSlice(bytes, 0, Math.min(length, bytes.length)))
+    }
+    b.value = out
+  }
+  return varRef({
+    get Data(): StringHeaderData | null {
+      return data
+    },
+    set Data(value: StringHeaderData | null) {
+      data = value
+      refresh()
+    },
+    get Len(): number {
+      return length
+    },
+    set Len(value: number) {
+      length = value
+      refresh()
+    },
+    get Cap(): number {
+      return capacity
+    },
+    set Cap(value: number) {
+      capacity = value
+      refresh()
+    },
+  })
+}
+
 /**
  * Handles string() conversion for values that could be either string or []byte.
  * Used for generic type parameters with constraint []byte|string.
@@ -1283,8 +1803,8 @@ export function genericBytesOrStringToString(
   if (value === null || value === undefined) {
     return ''
   }
-  if (typeof value === 'string') {
-    return value
+  if (isGoStringValue(value)) {
+    return value as string
   }
   return bytesToString(value)
 }
@@ -1298,10 +1818,10 @@ export function genericBytesOrStringToString(
  * @returns The byte value at the specified index
  */
 export function indexStringOrBytes(
-  value: string | import('./builtin.js').Bytes,
+  value: GoStringValue | import('./builtin.js').Bytes,
   index: number,
 ): number {
-  if (typeof value === 'string') {
+  if (isGoStringValue(value)) {
     return indexString(value, index)
   } else if (value instanceof Uint8Array) {
     // For Uint8Array, direct access returns the byte value
@@ -1337,9 +1857,9 @@ export function indexStringOrBytes(
  * @returns The sliced value of the same type as input
  */
 export function sliceStringOrBytes<
-  T extends string | import('./builtin.js').Bytes,
+  T extends GoStringValue | import('./builtin.js').Bytes,
 >(value: T, low?: number, high?: number, max?: number): T {
-  if (typeof value === 'string') {
+  if (isGoStringValue(value)) {
     // For strings, use sliceString and ignore max parameter
     return sliceString(value, low, high) as T
   } else {