jseption 0.0.6 → 0.0.7

package/README.md

@@ -200,7 +200,9 @@ const data = fromGuest(ctx, value);            // guest object graph -> plain ho
 ```
 
 Primitives cross unchanged. `toGuest` copies objects, arrays, Date, RegExp, Map, Set,
-typed arrays and Errors into guest equivalents, wraps host functions in guest functions
+typed arrays and Errors into guest equivalents (a `SharedArrayBuffer`, or any buffer with
+`{ liveBuffers: true }`, is handed over as the host memory itself, so a WebAssembly
+module's memory can be read and written from the guest), wraps host functions in guest functions
 (host exceptions become guest errors, returned promises are bridged, guest promise jobs
 run when they settle) and preserves shared references and cycles. `fromGuest` does the
 reverse, turning guest functions into host functions that call into the guest. See
@@ -224,7 +226,8 @@ exposeLive(ctx, 'store', store, { writable: true, allow: (target, key) => key !=
 ```
 
 Primitives cross as values, host arrays as snapshot guest arrays, `Date`/`RegExp`/typed
-arrays/errors as copies, promises as guest promises; guest arguments are copied
+arrays/errors as copies (shared memory, and any buffer under a `liveBuffers` policy, as
+the memory itself), promises as guest promises; guest arguments are copied
 (`fromGuest`), a proxy passed back is unwrapped to its host object, and guest callbacks
 become host functions. The sandbox rules are always on: host intrinsics (`Function`,
 `eval`, `globalThis`, `Object`, `Reflect`, `Proxy`, the intrinsic prototypes, ...) never

package/dist/builtins/typedarray.d.ts

@@ -4,8 +4,10 @@ export declare class JSArrayBufferData extends JSArrayBuffer {
     max_byte_length: number;
     dv: DataView | null;
     dv_data: Uint8Array | null;
-    constructor(len: number, shared: boolean, max_len: number);
+    constructor(len: number, shared: boolean, max_len: number, existing?: ArrayBuffer | SharedArrayBuffer);
 }
+export declare function isSharedArrayBuffer(v: unknown): v is SharedArrayBuffer;
+export declare function JS_NewArrayBufferFrom(ctx: JSContext, buffer: ArrayBuffer | SharedArrayBuffer): JSValue;
 export declare function JS_NewArrayBufferCopy(ctx: JSContext, buf: Uint8Array): JSValue;
 export declare function JS_DetachArrayBuffer(ctx: JSContext, obj: JSValue): void;
 export declare function is_typed_array_class(class_id: JSClassID): boolean;

package/dist/builtins/typedarray.js

@@ -44,16 +44,21 @@ export function typed_array_class_available(class_id) {
    --------------------------------------------------------------------- */
 /* array buffer data with the resizable extension. The host buffer is
    resizable (growable when shared) when max_len >= 0; 'data' is a length
-   tracking view over it. */
+   tracking view over it. With 'existing', the guest buffer is that host
+   buffer itself (JS_NewArrayBufferFrom): the two sides share the bytes. */
 export class JSArrayBufferData extends JSArrayBuffer {
     /* maximum byte length for resizable buffers, -1 otherwise */
     max_byte_length = -1;
     /* cached host DataView over 'data' */
     dv = null;
     dv_data = null;
-    constructor(len, shared, max_len) {
+    constructor(len, shared, max_len, existing) {
         let buffer;
-        if (shared)
+        if (existing) {
+            buffer = existing;
+            max_len = (shared ? existing.growable : existing.resizable) ? existing.maxByteLength : -1;
+        }
+        else if (shared)
             buffer = max_len >= 0 ? new SharedArrayBuffer(len, { maxByteLength: max_len }) : new SharedArrayBuffer(len);
         else
             buffer = max_len >= 0 ? new ArrayBuffer(len, { maxByteLength: max_len }) : new ArrayBuffer(len);
@@ -61,6 +66,10 @@ export class JSArrayBufferData extends JSArrayBuffer {
         this.max_byte_length = max_len;
     }
 }
+/* a host SharedArrayBuffer, where the host has one */
+export function isSharedArrayBuffer(v) {
+    return typeof SharedArrayBuffer === 'function' && v instanceof SharedArrayBuffer;
+}
 function array_buffer_get_dv(abuf) {
     const a = abuf;
     if (a.dv === null || a.dv_data !== abuf.data) {
@@ -87,7 +96,7 @@ function JS_ThrowTypeErrorArrayBufferOOB(ctx) {
 }
 /* XXX: we are currently limited to 2 GB */
 const ARRAY_BUFFER_MAX_LENGTH = 0x7fffffff;
-function js_array_buffer_constructor3(ctx, new_target, len, max_len, class_id, buf) {
+function js_array_buffer_constructor3(ctx, new_target, len, max_len, class_id, buf, existing) {
     const obj = js_create_from_ctor(ctx, new_target, class_id);
     if (JS_IsException(obj))
         return obj;
@@ -95,12 +104,21 @@ function js_array_buffer_constructor3(ctx, new_target, len, max_len, class_id, b
         return JS_ThrowRangeError(ctx, 'invalid array buffer length');
     if (max_len > ARRAY_BUFFER_MAX_LENGTH)
         return JS_ThrowRangeError(ctx, 'invalid array buffer maximum length');
-    const abuf = new JSArrayBufferData(len, class_id === 20 /* JSClassID.SHARED_ARRAY_BUFFER */, max_len);
+    const abuf = new JSArrayBufferData(len, class_id === 20 /* JSClassID.SHARED_ARRAY_BUFFER */, max_len, existing);
     if (buf)
         abuf.data.set(buf.subarray(0, len));
     Q.JS_SetOpaque(obj, abuf);
     return obj;
 }
+/* a guest ArrayBuffer (or SharedArrayBuffer) over the host buffer itself, not a
+   copy: what the guest writes the host sees, and the other way round. A
+   buffer is bytes: it reaches no host object, so sharing it keeps the
+   sandbox rules (its guest prototype is the guest's). The guest cannot
+   detach, resize or transfer it beyond what the host buffer allows. */
+export function JS_NewArrayBufferFrom(ctx, buffer) {
+    const shared = isSharedArrayBuffer(buffer);
+    return js_array_buffer_constructor3(ctx, undefined, buffer.byteLength, -1, shared ? 20 /* JSClassID.SHARED_ARRAY_BUFFER */ : 19 /* JSClassID.ARRAY_BUFFER */, null, buffer);
+}
 function js_array_buffer_constructor2(ctx, new_target, len, class_id) {
     return js_array_buffer_constructor3(ctx, new_target, len, -1, class_id, null);
 }