goscript 0.1.1 → 0.1.3

package/dist/gs/builtin/slice.js

@@ -1,38 +1,99 @@
-import { varRef } from './varRef.js';
+import { isVarRef, varRef } from './varRef.js';
+export class GoBinaryString extends String {
+    bytes;
+    constructor(bytes) {
+        super(bytesToBinaryString(bytes));
+        this.bytes = bytes.slice();
+    }
+    toString() {
+        return bytesToBinaryString(this.bytes);
+    }
+    valueOf() {
+        return this.toString();
+    }
+    [Symbol.toPrimitive]() {
+        return this.toString();
+    }
+}
+function isGoStringValue(value) {
+    return typeof value === 'string' || value instanceof GoBinaryString;
+}
+function goStringBytes(str) {
+    if (str instanceof GoBinaryString) {
+        return str.bytes.slice();
+    }
+    return new TextEncoder().encode(str);
+}
+function goStringComparableBytes(value) {
+    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) {
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        return new GoBinaryString(bytes);
+    }
+}
 const addressStride = 0x100000000;
 let nextAddressBase = 1;
 const addressBases = new WeakMap();
+function sliceIndexProperty(prop) {
+    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;
+}
 /**
  * wrapSliceProxy wraps a SliceProxy in a Proxy to intercept index access
  * and route it through the backing array.
  */
 function wrapSliceProxy(proxy) {
+    const meta = proxy.__meta__;
+    meta.target = proxy;
     const handler = {
         get(target, prop) {
-            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}`);
+                throw new Error(`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, prop, value) {
-            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}`);
+                throw new Error(`Slice index out of range: ${index} >= ${meta.length}`);
             }
             if (prop === 'length' || prop === '__meta__') {
                 return false;
@@ -42,6 +103,17 @@ function wrapSliceProxy(proxy) {
     };
     return new Proxy(proxy, handler);
 }
+function sliceProxyFromBacking(backing, offset, length, capacity, target) {
+    const proxyTargetArray = (target ?? new Array(length));
+    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(slice) {
     if (slice === null || slice === undefined) {
@@ -102,6 +174,21 @@ function normalizeSliceIndex(value) {
     }
     return Number(value);
 }
+function byteSliceMeta(slice) {
+    return slice.__meta__;
+}
+function byteSliceView(backing, offset, length, capacity) {
+    const view = backing.subarray(offset, offset + length);
+    if (capacity !== length) {
+        view.__meta__ = {
+            backing: backing,
+            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
@@ -125,21 +212,7 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
         if (actualCapacity === length) {
             return new Uint8Array(length);
         }
-        // If capacity > length, create a SliceProxy backed by a Uint8Array
-        const backingUint8 = new Uint8Array(actualCapacity);
-        const backingNumbers = Array.from(backingUint8); // Convert to number[] for backing
-        const proxyTargetArray = new Array(length);
-        for (let i = 0; i < length; i++) {
-            proxyTargetArray[i] = 0; // Initialize with zeros
-        }
-        const proxy = proxyTargetArray;
-        proxy.__meta__ = {
-            backing: backingNumbers,
-            offset: 0,
-            length: length,
-            capacity: actualCapacity,
-        };
-        return wrapSliceProxy(proxy);
+        return byteSliceView(new Uint8Array(actualCapacity), 0, length, actualCapacity);
     }
     const actualCapacity = capacity === undefined ? length : capacity;
     if (length < 0 || actualCapacity < 0 || length > actualCapacity) {
@@ -161,12 +234,11 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
         }
     };
     const backingArr = new Array(actualCapacity);
-    // Initialize the relevant part of the backing array
-    for (let i = 0; i < length; i++) {
+    // 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) {
         return backingArr;
@@ -187,9 +259,9 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
     // Create a proper Proxy with the handler for SliceProxy behavior
     const handler = {
         get(target, prop) {
-            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(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
@@ -203,9 +275,9 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
             return Reflect.get(target, prop);
         },
         set(target, prop, value) {
-            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;
@@ -222,14 +294,15 @@ export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
 };
 export function goSlice(// T can be number for Uint8Array case
 s, low, high, max) {
+    s = collectionValue(s);
     low = normalizeSliceIndex(low);
     high = normalizeSliceIndex(high);
     max = normalizeSliceIndex(max);
     const handler = {
         get(target, prop) {
-            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(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
@@ -252,9 +325,9 @@ s, low, high, max) {
             return Reflect.get(target, prop);
         },
         set(target, prop, value) {
-            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;
@@ -275,45 +348,29 @@ s, low, high, max) {
         },
     };
     if (s instanceof Uint8Array) {
+        const meta = byteSliceMeta(s);
+        const metaBacking = meta?.backing;
+        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) {
-            throw new Error(`Invalid slice indices: low ${actualLow}, high ${actualHigh} for Uint8Array of length ${s.length}`);
+        if (actualLow < 0 ||
+            actualHigh < actualLow ||
+            actualLow > baseCapacity ||
+            actualHigh > baseCapacity) {
+            throw new Error(`Invalid slice indices: low ${actualLow}, high ${actualHigh} for Uint8Array with capacity ${baseCapacity}`);
         }
         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}`);
+                throw new Error(`Invalid max index: ${max}. Constraints: low ${actualLow} <= high ${actualHigh} <= max <= capacity ${baseCapacity}`);
             }
             const newCap = max - actualLow; // Capacity of the new slice view
-            if (newCap !== newLength) {
-                const proxyTarget = new Array(newLength);
-                proxyTarget.__meta__ = {
-                    backing: s,
-                    offset: actualLow,
-                    length: newLength,
-                    capacity: newCap,
-                };
-                return new Proxy(proxyTarget, handler);
-            }
-            else {
-                // newCap === newLength, standard Uint8Array is fine.
-                return s.subarray(actualLow, actualHigh); // T is number
-            }
+            return byteSliceView(backing, baseOffset + actualLow, newLength, newCap);
         }
-        if (actualHigh !== s.length) {
-            const proxyTarget = new Array(newLength);
-            proxyTarget.__meta__ = {
-                backing: s,
-                offset: actualLow,
-                length: newLength,
-                capacity: s.length - actualLow,
-            };
-            return new Proxy(proxyTarget, handler);
-        }
-        // max is not defined and length equals capacity, return the Uint8Array view directly.
-        return s.subarray(actualLow, actualHigh); // T is number
+        return byteSliceView(backing, baseOffset + actualLow, newLength, baseCapacity - actualLow);
     }
     // Handle nil slices - in Go, slicing a nil slice with valid bounds returns nil
     if (s === null || s === undefined) {
@@ -385,7 +442,7 @@ s, low, high, max) {
     const newLength = high - low;
     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;
     }
     // Create an array-like target with the correct length
@@ -429,9 +486,9 @@ export const arrayToSlice = (arr, depth = 1) => {
     };
     const handler = {
         get(target, prop) {
-            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(`Slice index out of range: ${index} >= ${target.__meta__.length}`);
@@ -454,9 +511,9 @@ export const arrayToSlice = (arr, depth = 1) => {
             return Reflect.get(target, prop);
         },
         set(target, prop, value) {
-            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;
                 }
@@ -491,26 +548,34 @@ export const arrayToSlice = (arr, depth = 1) => {
  * @returns The length of the collection.
  */
 export const len = (obj) => {
+    obj = collectionValue(obj);
     if (obj === null || obj === undefined) {
         return 0;
     }
     if (typeof obj === 'string') {
-        return stringLen(obj); // Call new stringLen for strings
-    }
-    if (obj instanceof Map || obj instanceof Set) {
-        return obj.size;
+        return stringLen(obj);
     }
     if (obj instanceof Uint8Array) {
         return obj.length;
     }
-    if (typeof obj.len === 'function') {
-        return obj.len();
+    if (Array.isArray(obj)) {
+        const meta = obj.__meta__;
+        if (meta !== undefined) {
+            return meta.length;
+        }
+        return obj.length;
+    }
+    if (obj instanceof Map || obj instanceof Set) {
+        return obj.size;
+    }
+    if (obj instanceof GoBinaryString) {
+        return stringLen(obj);
     }
     if (isComplexSlice(obj)) {
         return obj.__meta__.length;
     }
-    if (Array.isArray(obj)) {
-        return obj.length;
+    if (typeof obj.len === 'function') {
+        return obj.len();
     }
     throw new Error('cannot determine len of this type');
 };
@@ -520,18 +585,22 @@ export const len = (obj) => {
  * @returns The capacity of the slice.
  */
 export const cap = (obj) => {
+    obj = collectionValue(obj);
     if (obj === null || obj === undefined) {
         return 0;
     }
-    if (obj instanceof Uint8Array) {
-        return obj.length; // Uint8Array capacity is its length
-    }
     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.cap === 'function') {
+        return obj.cap();
+    }
     return 0;
 };
 export function append(slice, ...elements) {
@@ -541,48 +610,7 @@ export function append(slice, ...elements) {
     const produceUint8Array = inputIsUint8Array;
     // If producing Uint8Array, all elements must be numbers and potentially flattened from other Uint8Arrays/number slices.
     if (produceUint8Array) {
-        let combinedBytes = [];
-        // Add bytes from the original slice if it exists and is numeric.
-        if (inputIsUint8Array) {
-            appendBytes(combinedBytes, slice);
-        }
-        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[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) {
-                appendBytes(combinedBytes, item);
-            }
-            else if (isComplexSlice(item) || Array.isArray(item)) {
-                const itemLen = len(item);
-                for (let i = 0; i < itemLen; i++) {
-                    const val = item[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;
+        return appendByteSlice(slice, elements);
     }
     // Handle generic Slice<T> (non-Uint8Array result).
     // In this case, `elements` are treated as individual items to append,
@@ -591,45 +619,44 @@ export function append(slice, ...elements) {
     if (numAdded === 0) {
         return slice;
     }
-    let originalElements = [];
+    let originalElements;
+    let oldLength = 0;
     let oldCapacity;
     let isOriginalComplex = false;
     let originalBacking = undefined;
+    let originalTarget = 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.slice();
-        oldCapacity = slice.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.
     if (isOriginalComplex && newLength <= oldCapacity && originalBacking) {
         for (let i = 0; i < numAdded; i++) {
             originalBacking[originalOffset + oldLength + i] = elements[i];
         }
-        const resultProxy = new Array(newLength);
-        for (let i = 0; i < newLength; i++)
-            resultProxy[i] = originalBacking[originalOffset + i];
-        resultProxy.__meta__ = {
-            backing: originalBacking,
-            offset: originalOffset,
-            length: newLength,
-            capacity: oldCapacity,
-        };
-        return wrapSliceProxy(resultProxy);
+        const target = originalTarget;
+        if (target !== undefined) {
+            for (let i = 0; i < numAdded; i++) {
+                target[oldLength + i] = elements[i];
+            }
+        }
+        return sliceProxyFromBacking(originalBacking, originalOffset, newLength, oldCapacity, target);
     }
     // Case 2: Reallocation is needed.
     let newCapacity = oldCapacity;
@@ -646,26 +673,80 @@ export function append(slice, ...elements) {
         newCapacity = newLength;
     }
     const newBacking = new Array(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];
     }
-    const resultProxy = new Array(newLength);
-    for (let i = 0; i < newLength; i++)
-        resultProxy[i] = newBacking[i];
-    resultProxy.__meta__ = {
-        backing: newBacking,
-        offset: 0,
-        length: newLength,
-        capacity: newCapacity,
-    };
-    return wrapSliceProxy(resultProxy);
+    return sliceProxyFromBacking(newBacking, 0, newLength, newCapacity);
+}
+function appendByteSlice(slice, elements) {
+    const meta = byteSliceMeta(slice);
+    const metaBacking = meta?.backing;
+    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 appendBytes(dst, src) {
-    for (let i = 0; i < src.length; i++) {
-        dst.push(src[i]);
+function byteElementLength(item) {
+    if (item instanceof Uint8Array) {
+        return item.length;
+    }
+    if (isComplexSlice(item) || Array.isArray(item)) {
+        return len(item);
+    }
+    if (typeof item !== 'number') {
+        throw new Error('Cannot produce Uint8Array: appended elements contain non-numbers.');
+    }
+    return 1;
+}
+function writeByteElements(dst, offset, elements) {
+    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);
+            for (let i = 0; i < itemLen; i++) {
+                const value = item[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++;
     }
 }
 export function copy(dst, src) {
@@ -673,7 +754,7 @@ export function copy(dst, src) {
         return 0;
     }
     // Handle string source first
-    if (typeof src === 'string') {
+    if (isGoStringValue(src)) {
         return copyFromString(dst, src);
     }
     if (src === null) {
@@ -708,26 +789,27 @@ export function copy(dst, src) {
  */
 function copyFromString(dst, src) {
     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;
     }
     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;
             dst[i] = byteVal;
         }
     }
     else if (Array.isArray(dst)) {
         for (let i = 0; i < count; i++) {
-            dst[i] = src.charCodeAt(i);
+            dst[i] = bytes[i];
         }
     }
     return count;
@@ -736,16 +818,9 @@ function copyFromString(dst, src) {
  * Helper: Copy from Slice<number> to Uint8Array
  */
 function copyToUint8Array(dst, src, count) {
-    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;
 }
@@ -753,16 +828,17 @@ function copyToUint8Array(dst, src, count) {
  * Helper: Copy from Uint8Array to Slice<T>
  */
 function copyFromUint8Array(dst, src, count) {
+    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];
-            dst[i] = src[i];
+            dstMeta.backing[dstMeta.offset + i] = values[i];
+            dst[i] = values[i];
         }
     }
     else if (Array.isArray(dst)) {
         for (let i = 0; i < count; i++) {
-            dst[i] = src[i];
+            dst[i] = values[i];
         }
     }
     return count;
@@ -771,38 +847,36 @@ function copyFromUint8Array(dst, src, count) {
  * Helper: Copy between two Slice<T> instances
  */
 function copyBetweenSlices(dst, src, count) {
+    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[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[i] = src[i];
-            }
+        for (let i = 0; i < count; i++) {
+            dstMeta.backing[dstMeta.offset + i] = values[i];
+            dst[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(src, count) {
+    const values = new Array(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]`
@@ -818,7 +892,7 @@ export function index(collection, index) {
     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) {
@@ -861,6 +935,8 @@ export function indexRef(collection, index) {
             },
             __isVarRef: true,
             __goAddress: () => indexAddress(collection, index),
+            __goCollection: collection,
+            __goIndex: index,
         };
     }
     if (isComplexSlice(collection)) {
@@ -877,6 +953,8 @@ export function indexRef(collection, index) {
             },
             __isVarRef: true,
             __goAddress: () => indexAddress(collection, index),
+            __goCollection: collection,
+            __goIndex: index,
         };
     }
     if (Array.isArray(collection)) {
@@ -892,10 +970,25 @@ export function indexRef(collection, index) {
             },
             __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(ref, length) {
+    const collection = ref.__goCollection;
+    if (collection === undefined) {
+        throw new Error('unsafe array pointer requires an indexed collection reference');
+    }
+    const index = ref.__goIndex ?? 0;
+    return varRef(goSlice(collection, index, index + length));
+}
 /**
  * indexAddress returns a stable synthetic address for an addressable slice or
  * array element.
@@ -997,7 +1090,7 @@ export const byte = (n) => {
  * @throws Error if index is out of bounds.
  */
 export const indexString = (str, index) => {
-    if (typeof str !== 'string') {
+    if (!isGoStringValue(str)) {
         // Bytes - access directly
         if (str instanceof Uint8Array) {
             if (index < 0 || index >= str.length) {
@@ -1014,7 +1107,7 @@ export const indexString = (str, index) => {
         }
         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}`);
     }
@@ -1027,7 +1120,7 @@ export const indexString = (str, index) => {
  * @returns The number of bytes in the UTF-8 representation of the string.
  */
 export const stringLen = (str) => {
-    return new TextEncoder().encode(str).length;
+    return goStringBytes(str).length;
 };
 /**
  * Slices a string based on byte indices.
@@ -1039,7 +1132,7 @@ export const stringLen = (str) => {
  * @throws Error if the slice would create invalid UTF-8.
  */
 export const sliceString = (str, low, high) => {
-    const bytes = new TextEncoder().encode(str);
+    const bytes = goStringBytes(str);
     const actualLow = low === undefined ? 0 : low;
     const actualHigh = high === undefined ? bytes.length : high;
     if (actualLow < 0 || actualHigh < actualLow || actualHigh > bytes.length) {
@@ -1055,18 +1148,7 @@ export const sliceString = (str, low, high) => {
         }
         throw new Error(`runtime error: slice bounds out of range [${actualLow}:${actualHigh}] with length ${bytes.length}`);
     }
-    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) {
-        // 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));
 };
 /**
  * Converts a Slice<number> (byte array) to a string using TextDecoder.
@@ -1080,7 +1162,7 @@ export const bytesToString = (bytes) => {
     if (typeof bytes === 'string')
         return bytes;
     if (bytes instanceof Uint8Array)
-        return decodeGoStringBytes(bytes);
+        return goStringFromBytes(bytes);
     // Ensure we get a plain number[] for Uint8Array.from
     let byteArray;
     if (isComplexSlice(bytes)) {
@@ -1091,15 +1173,85 @@ export const bytesToString = (bytes) => {
         // For simple T[] slices
         byteArray = bytes;
     }
-    return decodeGoStringBytes(Uint8Array.from(byteArray));
+    return goStringFromBytes(Uint8Array.from(byteArray));
 };
-function decodeGoStringBytes(bytes) {
-    try {
-        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+export function stringEqual(left, right) {
+    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;
+        }
     }
-    catch {
-        return bytesToBinaryString(bytes);
+    return true;
+}
+export function stringCompare(left, right) {
+    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;
+}
+function byteStringView(value) {
+    value = collectionValue(value);
+    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.__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.__meta__;
+    return {
+        backing: meta.backing,
+        offset: meta.offset,
+        length: meta.length,
+    };
+}
+function collectionValue(value) {
+    if (isVarRef(value)) {
+        return collectionValue(value.value);
+    }
+    if (typeof value === 'object' &&
+        value !== null &&
+        typeof value.__goType === 'string' &&
+        '__goValue' in value) {
+        return collectionValue(value.__goValue);
+    }
+    return value;
 }
 function bytesToBinaryString(bytes) {
     const chunkSize = 0x8000;
@@ -1115,8 +1267,8 @@ function bytesToBinaryString(bytes) {
  * @returns A Uint8Array representing the UTF-8 bytes of the string.
  */
 export function stringToBytes(s) {
-    if (typeof s === 'string') {
-        return new TextEncoder().encode(s);
+    if (isGoStringValue(s)) {
+        return goStringBytes(s);
     }
     // Already bytes - normalize to Uint8Array
     if (s instanceof Uint8Array) {
@@ -1128,6 +1280,57 @@ export function stringToBytes(s) {
     // Handle array or slice types
     return new Uint8Array(Array.isArray(s) ? s : []);
 }
+export function stringHeaderRef(s) {
+    return varRef({
+        get Data() {
+            return { kind: 'string', value: s.value };
+        },
+        set Data(_value) { },
+        get Len() {
+            return stringToBytes(s.value).length;
+        },
+        set Len(_value) { },
+    });
+}
+export function sliceHeaderRef(b) {
+    let data = null;
+    let length = 0;
+    let capacity = 0;
+    const refresh = () => {
+        if (data === null) {
+            return;
+        }
+        const bytes = stringToBytes(data.value);
+        const out = makeSlice(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() {
+            return data;
+        },
+        set Data(value) {
+            data = value;
+            refresh();
+        },
+        get Len() {
+            return length;
+        },
+        set Len(value) {
+            length = value;
+            refresh();
+        },
+        get Cap() {
+            return capacity;
+        },
+        set Cap(value) {
+            capacity = value;
+            refresh();
+        },
+    });
+}
 /**
  * Handles string() conversion for values that could be either string or []byte.
  * Used for generic type parameters with constraint []byte|string.
@@ -1138,7 +1341,7 @@ export function genericBytesOrStringToString(value) {
     if (value === null || value === undefined) {
         return '';
     }
-    if (typeof value === 'string') {
+    if (isGoStringValue(value)) {
         return value;
     }
     return bytesToString(value);
@@ -1152,7 +1355,7 @@ export function genericBytesOrStringToString(value) {
  * @returns The byte value at the specified index
  */
 export function indexStringOrBytes(value, index) {
-    if (typeof value === 'string') {
+    if (isGoStringValue(value)) {
         return indexString(value, index);
     }
     else if (value instanceof Uint8Array) {
@@ -1184,7 +1387,7 @@ export function indexStringOrBytes(value, index) {
  * @returns The sliced value of the same type as input
  */
 export function sliceStringOrBytes(value, low, high, max) {
-    if (typeof value === 'string') {
+    if (isGoStringValue(value)) {
         // For strings, use sliceString and ignore max parameter
         return sliceString(value, low, high);
     }