goscript 0.1.0 → 0.1.2

package/dist/gs/builtin/slice.js

@@ -1,34 +1,99 @@
+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;
@@ -38,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) {
@@ -58,6 +134,30 @@ export function asArray(slice) {
     }
     return [];
 }
+export function sliceToArray(slice, length, typeHint) {
+    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).slice(0, length));
+    }
+    return asArray(slice).slice(0, length);
+}
+export function sliceToArrayPointer(slice, length, typeHint) {
+    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));
+        }
+        return varRef(goSlice(slice, 0, length));
+    }
+    if (slice instanceof Uint8Array) {
+        return varRef(goSlice(slice, 0, length));
+    }
+    return varRef(goSlice(slice, 0, length));
+}
 /**
  * isComplexSlice checks if a slice is a complex slice (has __meta__ property)
  */
@@ -68,6 +168,27 @@ function isComplexSlice(slice) {
         '__meta__' in slice &&
         slice.__meta__ !== undefined);
 }
+function normalizeSliceIndex(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    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
@@ -81,7 +202,7 @@ export function isSliceProxy(slice) {
  * @param capacity The capacity of the slice (optional).
  * @returns A new slice.
  */
-export const makeSlice = (length, capacity, typeHint) => {
+export const makeSlice = (length, capacity, typeHint, zeroFactory) => {
     if (typeHint === 'byte') {
         const actualCapacity = capacity === undefined ? length : capacity;
         if (length < 0 || actualCapacity < 0 || length > actualCapacity) {
@@ -91,47 +212,33 @@ export const makeSlice = (length, capacity, typeHint) => {
         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) {
         throw new Error(`Invalid slice length (${length}) or capacity (${actualCapacity})`);
     }
-    let zeroVal;
-    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 = () => {
+        if (zeroFactory !== undefined) {
+            return zeroFactory();
+        }
+        switch (typeHint) {
+            case 'number':
+                return 0;
+            case 'boolean':
+                return false;
+            case 'string':
+                return '';
+            default:
+                return null; // Default for objects, complex types, or unspecified
+        }
+    };
     const backingArr = new Array(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) {
         return backingArr;
@@ -140,7 +247,7 @@ export const makeSlice = (length, capacity, typeHint) => {
     // Its elements up to 'length' should reflect the initialized part of the slice.
     const proxyTargetArray = new Array(length);
     for (let i = 0; i < length; i++) {
-        proxyTargetArray[i] = backingArr[i]; // Or simply zeroVal
+        proxyTargetArray[i] = backingArr[i];
     }
     const proxy = proxyTargetArray;
     proxy.__meta__ = {
@@ -152,9 +259,9 @@ export const makeSlice = (length, capacity, typeHint) => {
     // 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}`);
@@ -168,9 +275,9 @@ export const makeSlice = (length, capacity, typeHint) => {
             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;
@@ -187,11 +294,15 @@ export const makeSlice = (length, capacity, typeHint) => {
 };
 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}`);
@@ -214,15 +325,17 @@ 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;
                 }
                 if (index === target.__meta__.length &&
                     target.__meta__.length < target.__meta__.capacity) {
                     target.__meta__.backing[target.__meta__.offset + index] = value;
+                    target[index] = value;
                     target.__meta__.length++;
                     return true;
                 }
@@ -235,43 +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 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}`);
+                throw new Error(`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);
-            }
-            else {
-                // newCap === newLength, standard Uint8Array is fine.
-                return subArrayView; // T is number
-            }
-        }
-        else {
-            // max is not defined, return the Uint8Array subarray view directly.
-            return subArrayView; // T is number
+            return byteSliceView(backing, baseOffset + actualLow, newLength, newCap);
         }
+        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) {
@@ -343,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
@@ -387,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}`);
@@ -412,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;
                 }
@@ -449,23 +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
+        return stringLen(obj);
+    }
+    if (obj instanceof Uint8Array) {
+        return obj.length;
+    }
+    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 Uint8Array) {
-        return obj.length;
+    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');
 };
@@ -475,72 +585,32 @@ 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) {
     // 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 = [];
-        // Add bytes from the original slice if it exists and is numeric.
-        if (inputIsUint8Array) {
-            combinedBytes.push(...Array.from(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) {
-                combinedBytes.push(...Array.from(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,
@@ -549,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;
@@ -604,29 +673,88 @@ 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 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) {
     if (dst === null) {
         return 0;
     }
     // Handle string source first
-    if (typeof src === 'string') {
+    if (isGoStringValue(src)) {
         return copyFromString(dst, src);
     }
     if (src === null) {
@@ -661,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;
@@ -689,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;
 }
@@ -706,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;
@@ -724,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]`
@@ -771,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) {
@@ -794,6 +915,120 @@ export function index(collection, index) {
     }
     throw new Error('runtime error: index on unsupported type');
 }
+/**
+ * indexRef returns an addressable reference to a slice or array element.
+ */
+export function indexRef(collection, index) {
+    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];
+            },
+            set value(value) {
+                collection[index] = value;
+            },
+            __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) {
+                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) {
+                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(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.
+ */
+export function indexAddress(collection, index) {
+    if (collection === null || collection === undefined) {
+        throw new Error('runtime error: index on nil or undefined collection');
+    }
+    let backing;
+    let backingIndex;
+    let length;
+    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.
@@ -802,6 +1037,21 @@ export function index(collection, index) {
 export const stringToRunes = (str) => {
     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) => {
+    const encoder = new TextEncoder();
+    const pairs = [];
+    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.
@@ -840,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) {
@@ -857,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}`);
     }
@@ -870,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.
@@ -882,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) {
@@ -898,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.
@@ -922,9 +1161,8 @@ export const bytesToString = (bytes) => {
     // 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;
     if (isComplexSlice(bytes)) {
@@ -935,16 +1173,102 @@ export const bytesToString = (bytes) => {
         // For simple T[] slices
         byteArray = bytes;
     }
-    return new TextDecoder().decode(Uint8Array.from(byteArray));
+    return goStringFromBytes(Uint8Array.from(byteArray));
 };
+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;
+        }
+    }
+    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;
+    let out = '';
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        out += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return out;
+}
 /**
  * Converts a string to a Uint8Array (byte slice).
  * @param s The input string.
  * @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) {
@@ -956,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.
@@ -966,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);
@@ -980,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) {
@@ -1012,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);
     }