buninu-browser 0.7.0 → 0.9.0

package/lib/renderer/dialog-client.js

@@ -0,0 +1,30 @@
+export async function createDialogClient(endpoint) {
+  const worker=new Worker(new URL('./dialog-worker.js',import.meta.url).href);
+  await new Promise((resolve,reject)=>{
+    worker.onmessage=({data})=>data.type==='ready'?resolve():reject(Error(data.message));
+    worker.onerror=event=>reject(Error(event.message));
+    worker.postMessage({type:'connect',endpoint});
+  }).catch(error=>{worker.terminate();throw error;});
+  let next=0,failed=false;const files=new Map();
+  worker.onerror=()=>{failed=true;for(const resolve of files.values())resolve({accept:false});files.clear();};
+  worker.onmessage=({data})=>{if(data.type==='files'){files.get(data.id)?.(data.result);files.delete(data.id);}};
+  const dialog = (type,message,defaultPrompt)=>{
+    if(failed)return type==='alert'?undefined:type==='confirm'?false:null;
+    const buffer=new SharedArrayBuffer(12,{maxByteLength:64*1024*1024}),state=new Int32Array(buffer,0,3);
+    worker.postMessage({type:'dialog',buffer,request:{type,message,defaultPrompt}});
+    while(Atomics.load(state,0)===0)Atomics.wait(state,0,0);
+    if(type==='alert')return undefined;
+    if(type==='confirm')return Boolean(state[2]);
+    if(!state[2])return null;
+    const text=new Uint16Array(buffer,12,state[1]);let value='';
+    for(let i=0;i<text.length;i+=8192)value+=String.fromCharCode(...text.subarray(i,i+8192));
+    return value;
+  };
+  dialog.pickFiles=options=>new Promise(resolve=>{
+    if(failed){resolve({accept:false});return;}
+    const id=++next;files.set(id,resolve);
+    try{worker.postMessage({type:'files',id,request:{type:'file',...options}});}
+    catch{files.delete(id);resolve({accept:false});}
+  });
+  return dialog;
+}

package/lib/renderer/dialog-worker.js

@@ -0,0 +1,35 @@
+// This worker stays responsive while the page thread waits synchronously for
+// alert/confirm/prompt. The authenticated socket is opened before seccomp.
+import {connectCompositor} from './compositor-channel.js';
+let pending=null,channel,fileId=null;
+function finishSync(buffer,result={}) {
+  const state=new Int32Array(buffer,0,3);
+  let value=String(result.promptText??'');
+  try { buffer.grow(12+value.length*2); }
+  catch { value='';result={accept:false}; }
+  const text=new Uint16Array(buffer,12);
+  for(let i=0;i<value.length;i++)text[i]=value.charCodeAt(i);
+  state[1]=value.length;state[2]=result.accept?1:0;
+  Atomics.store(state,0,1);Atomics.notify(state,0);
+}
+function finish(result={}) {
+  if(fileId!==null){postMessage({type:'files',id:fileId,result});fileId=null;return;}
+  if(!pending)return;
+  const buffer=pending;pending=null;
+  finishSync(buffer,result);
+}
+self.onmessage=async({data})=>{
+  if(data.type==='connect') {
+    try{channel=await connectCompositor(data.endpoint,message=>finish(message),()=>{channel=null;finish();});postMessage({type:'ready'});}
+    catch(error){postMessage({type:'error',message:String(error)});}
+  } else if(data.type==='files') {
+    if(pending||fileId!==null){postMessage({type:'files',id:data.id,result:{accept:false}});return;}
+    fileId=data.id;try{if(!channel)throw Error('Dialog channel closed');channel.send(data.request);}catch{finish();}
+  } else if(data.type==='dialog') {
+    // A page timer may request a synchronous dialog while a file picker is
+    // open. Never replace either outstanding reply or leave its page blocked.
+    if(pending||fileId!==null){finishSync(data.buffer,{accept:false});return;}
+    pending=data.buffer;
+    try{if(!channel)throw Error('Dialog channel closed');channel.send(data.request);}catch{finish();}
+  }
+};

package/lib/renderer/eval-environment.js

@@ -0,0 +1,28 @@
+// Sloppy direct eval can add var/function bindings to its caller. A private
+// environment per invocation keeps those bindings out of the page global.
+const targets = new WeakMap();
+export function evalEnvironment(global, parent = null) {
+  const bindings = Object.create(null);
+  const fallback = parent ?? global;
+  const proxy = new Proxy(bindings, {
+    get(target, key) {
+      if (Object.hasOwn(target, key)) return target[key];
+      if (key in fallback) return fallback[key];
+      if (typeof key === 'symbol') return undefined;
+      throw new ReferenceError(`${key} is not defined`);
+    },
+    has: (target, key) => Object.hasOwn(target, key) || key in fallback,
+    set(target, key, value) {
+      if (Object.hasOwn(target, key)) target[key] = value;
+      else fallback[key] = value;
+      return true;
+    },
+    deleteProperty(target, key) {return Object.hasOwn(target,key) ? delete target[key] : delete fallback[key];},
+  });
+  targets.set(proxy,bindings);
+  return proxy;
+}
+export function declareEvalBinding(environment, name) {
+  const target = targets.get(environment);
+  if (target && !Object.hasOwn(target,name)) target[name] = undefined;
+}

package/lib/renderer/file-input.js

@@ -0,0 +1,49 @@
+// Selected files are capabilities granted by the browser UI, never host paths.
+const selections=new WeakMap();
+export function inputFiles(node){
+ if(node?.tagName!=='INPUT'||node.type!=='file')return null;
+ let list=selections.get(node);
+ // The DOM owns reset/value="" semantics. Do not keep a stale selection after
+ // it replaces its FileList (including form.reset()).
+ if(!list||list!==node.files){list=Object.freeze(Object.assign(Array.from(node.files??[]), {item(index){return this[index]??null;}}));node.files=list;selections.set(node,list);}
+ return list;
+}
+export async function chooseInputFiles(node,pick,window){
+ if(node?.tagName!=='INPUT'||node.type!=='file'||node.disabled||!pick)return;
+ const result=await pick({multiple:node.hasAttribute('multiple'),accept:node.getAttribute('accept')??''});
+ if(!result?.accept){node.dispatchEvent(new window.Event('cancel',{bubbles:true}));return;}
+ const files=(result.files??[]).map(f=>new File([Uint8Array.fromBase64(f.data)],f.name,{type:f.type,lastModified:f.lastModified}));
+ if(!node.hasAttribute('multiple'))files.splice(1);
+ const list=Object.freeze(Object.assign(files,{item(index){return this[index]??null;}}));
+ selections.set(node,list);
+ node.files=list;
+ node.dispatchEvent(new window.Event('input',{bubbles:true,composed:true}));
+ node.dispatchEvent(new window.Event('change',{bubbles:true}));
+}
+export function fileReaderInterface({EventTarget,realm,window,runTask}){
+ class FileReader extends EventTarget {
+  #serial=0; #result=null; #error=null; #state=0;
+  get result(){return this.#result;}get error(){return this.#error;}get readyState(){return this.#state;}
+  #emit(type){runTask(()=>this.dispatchEvent(realm.wrapEvent(new window.ProgressEvent(type))));}
+  #read(blob,kind,encoding){
+   if(!(blob instanceof Blob))throw new TypeError('Expected a Blob');
+   if(this.#state===1)throw new DOMException('A read is already in progress','InvalidStateError');
+   const serial=++this.#serial;this.#state=1;this.#result=null;this.#error=null;
+   setTimeout(async()=>{if(serial!==this.#serial)return;this.#emit('loadstart');
+    try {const bytes=new Uint8Array(await blob.arrayBuffer());if(serial!==this.#serial)return;
+     this.#result=kind==='array'?bytes.buffer:kind==='data'?`data:${blob.type||'application/octet-stream'};base64,${bytes.toBase64()}`:kind==='binary'?Array.from(bytes,b=>String.fromCharCode(b)).join(''):new TextDecoder(encoding).decode(bytes);
+     this.#state=2;this.#emit('progress');this.#emit('load');
+    }catch(e){this.#error=new DOMException(String(e),'NotReadableError');this.#state=2;this.#emit('error');}
+    if(serial===this.#serial)this.#emit('loadend');
+   },0);
+  }
+  readAsDataURL(blob){this.#read(blob,'data');}readAsText(blob,encoding='utf-8'){this.#read(blob,'text',encoding);}
+  readAsArrayBuffer(blob){this.#read(blob,'array');}readAsBinaryString(blob){this.#read(blob,'binary');}
+  abort(){const loading=this.#state===1;++this.#serial;this.#result=null;if(loading){this.#state=2;this.#emit('abort');this.#emit('loadend');}}
+ }
+ for(const [k,v] of Object.entries({EMPTY:0,LOADING:1,DONE:2})){Object.defineProperty(FileReader,k,{value:v});Object.defineProperty(FileReader.prototype,k,{value:v});}
+ for(const type of ['loadstart','progress','load','error','abort','loadend']){
+  const handlers=new WeakMap();Object.defineProperty(FileReader.prototype,'on'+type,{configurable:true,enumerable:true,get(){return handlers.get(this)??null;},set(fn){const old=handlers.get(this);if(old)this.removeEventListener(type,old);if(typeof fn==='function'){handlers.set(this,fn);this.addEventListener(type,fn);}else handlers.delete(this);}});
+ }
+ return FileReader;
+}

package/lib/renderer/host.js

@@ -59,6 +59,10 @@ export class RendererHost {
   #rawFrames = null;
   #startEpoch = 0;
   #closed = false;
+  #dialogChannel = null;
+  #dialogAbort = null;
+  #onDialog;
+  #dialogPending = false;
   #rejectStartup = null;
   #entry;
   #args;
@@ -115,9 +119,11 @@ export class RendererHost {
     network = new NetworkService({ fetch: fetchImpl }), onFrame = null, onLifecycle = null,
     // A dedicated loopback socket works independently of the main thread on all platforms.
     compositor = entry === DEFAULT_ENTRY,
+    onDialog = null,
     clipboardRead = readClipboard,
     clipboardWrite = writeClipboard,
   } = {}) {
+    this.#onDialog = onDialog;
     this.#clipboardRead = clipboardRead;
     this.#clipboardWrite = clipboardWrite;
     this.#onFrame = onFrame;
@@ -153,6 +159,19 @@ export class RendererHost {
         ()=>this.#closeChannel(channel));
       if (epoch !== this.#startEpoch) { channel?.transport.close(); throw Error('Renderer startup cancelled'); }
       this.#channel = channel;
+      const dialogAbort=new AbortController();
+      const dialogChannel = this.#onDialog ? await listenCompositor(async request => {
+        if (!['alert','confirm','prompt','file'].includes(request?.type)) return;
+        let result = {accept:false};
+        this.#dialogPending=true;
+        try { result = await this.#onDialog?.({type:request.type,multiple:!!request.multiple,accept:String(request.accept??''),message:String(request.message??''),defaultPrompt:String(request.defaultPrompt??'')},dialogAbort.signal) ?? result; }
+        catch {}
+        finally { this.#dialogPending=false; }
+        try { dialogChannel.send(result); } catch {}
+      }, () => dialogAbort.abort()) : null;
+      if (epoch !== this.#startEpoch) { dialogChannel?.close(); channel?.transport.close(); throw Error('Renderer startup cancelled'); }
+      this.#dialogChannel = dialogChannel;
+      this.#dialogAbort = dialogAbort;
       // No inherited environment: nothing from the controller leaks in.
       // Windows programs need SystemRoot to load system libraries.
       let env = process.platform === "win32" && process.env.SystemRoot ? { SystemRoot: process.env.SystemRoot } : {};
@@ -163,6 +182,7 @@ export class RendererHost {
 
       const child = Bun.spawn({
         cmd: [process.execPath, this.#entry, ...this.#args,
+          ...(dialogChannel ? [`--dialog-endpoint=${JSON.stringify(dialogChannel.endpoint)}`] : []),
           RENDER_INTERVAL_FLAG + renderMinInterval(process.env.BUNINU_RENDER_MIN_INTERVAL),
           ...(logging ? [RENDERER_LOG_FLAG] : []), ...(compositor ? [COMPOSITOR_FLAG, `--compositor-endpoint=${JSON.stringify(channel.transport.endpoint)}`] : []),
           ...(process.env.BUNINU_VERIFY_STYLE ? [VERIFY_STYLE_FLAG] : []), ...(process.env.BUNINU_FULL_STYLE ? [FULL_STYLE_FLAG] : [])],
@@ -179,6 +199,8 @@ export class RendererHost {
           else this.#handleMessage(child, message);
         },
         onExit: (_process, exitCode, signalCode) => {
+          dialogAbort.abort();dialogChannel?.close();
+          if(this.#dialogChannel===dialogChannel)this.#dialogChannel=null;
           this.#closeChannel(channel);
           this.#closeSockets(child);
           this.#closeAudio(child);
@@ -202,7 +224,7 @@ export class RendererHost {
         pipeToLog(child.stdout, `renderer ${child.pid}`, (chunk) => process.stdout.write(chunk));
         pipeToLog(child.stderr, `renderer ${child.pid}`, (chunk) => process.stderr.write(chunk));
       }
-    })().catch(error=>{ if(epoch===this.#startEpoch){this.#closeChannel(this.#channel);this.#ready=null;} rejectReady(error); });
+    })().catch(error=>{ if(epoch===this.#startEpoch){this.#closeChannel(this.#channel);this.#dialogAbort?.abort();this.#dialogChannel?.close();this.#dialogChannel=null;this.#ready=null;} rejectReady(error); });
     return this.#ready;
   }
 
@@ -319,6 +341,8 @@ export class RendererHost {
 
   close() {
     this.#closed = true;
+    this.#dialogAbort?.abort();this.#dialogAbort=null;
+    this.#dialogChannel?.close();this.#dialogChannel=null;
     this.#startEpoch++;
     this.#rejectStartup?.(Error("Renderer closed during startup")); this.#rejectStartup=null;
     this.#rawFrames?.close(); this.#rawFrames=null;
@@ -351,7 +375,9 @@ export class RendererHost {
       const navigating = method === 'loadDocument' || method === 'showFragment';
       // A watchdog is opt-in: elapsed time alone cannot distinguish a slow
       // renderer from a hung one, including title queries during page loading.
-      const timer = navigating || !(timeout > 0) ? null : setTimeout(() => {
+      let timer;
+      const watchdog = () => {
+        if(this.#dialogPending){timer=setTimeout(watchdog,timeout);return;}
         this.#pending.delete(id);
         // Watchdog: a renderer that misses its deadline is killed outright.
         this.#child = null;
@@ -360,7 +386,8 @@ export class RendererHost {
         this.#rawFrames?.close(); this.#rawFrames=null;
         child.kill(9);
         reject(new Error(`renderer ${method} timed out after ${timeout}ms`));
-      }, timeout);
+      };
+      timer = navigating || !(timeout > 0) ? null : setTimeout(watchdog,timeout);
       this.#pending.set(id, {
         resolve: (value) => {
           clearTimeout(timer);
@@ -571,7 +598,9 @@ export class RendererHost {
         if (this.#audio.get(id) !== entry) throw Error("Audio owner closed");
         return client.openPlayback({
         rate, channels, name: String(name ?? "audio").slice(0, 200),
-        leadSeconds: name === "piano" ? 0.12 : undefined,
+        // Live synthesis must not pre-render the decoded-media PCM reserve.
+        leadSeconds: name === "piano" || name === "Web Audio" ? 0.12 : undefined,
+        adaptiveLead: name === "Web Audio",
         onRequest: (bytes) => send({ event: "request", bytes }),
         onTiming: name === "piano" ? null : (timing) => send({ event: "timing", ...timing }),
         onTimingError: (error) => send({ event: "timing-error", message: String(error?.message ?? error) }),

package/lib/renderer/html-drag.js

@@ -0,0 +1,77 @@
+// Text drag data stays in the binding realm; never expose Happy DOM objects.
+const stores = new WeakMap();
+const transfers = new WeakMap();
+const normalize = type => ({text:'text/plain',url:'text/uri-list'}[String(type).toLowerCase()] ?? String(type).toLowerCase());
+export class DataTransfer {
+  constructor() { stores.set(this, {mode:'readwrite', data:new Map(), drop:'none', effect:'uninitialized'}); }
+  get types() { return Object.freeze([...stores.get(this).data.keys()]); }
+  get files() { return Object.freeze([]); }
+  getData(type) { const s=stores.get(this); return ['readwrite','readonly'].includes(s.mode) ? s.data.get(normalize(type)) ?? '' : ''; }
+  setData(type, value) { const s=stores.get(this); if(s.mode==='readwrite')s.data.set(normalize(type),String(value)); }
+  clearData(type) { const s=stores.get(this); if(s.mode==='readwrite'){if(type===undefined)s.data.clear();else s.data.delete(normalize(type));} }
+  get dropEffect(){return stores.get(this).drop;}
+  set dropEffect(value){if(['none','copy','link','move'].includes(value))stores.get(this).drop=value;}
+  get effectAllowed(){return stores.get(this).effect;}
+  set effectAllowed(value){const s=stores.get(this);if(s.mode==='readwrite'&&['none','copy','copyLink','copyMove','link','linkMove','move','all','uninitialized'].includes(value))s.effect=value;}
+}
+export function dragData(event){return transfers.get(event);}
+export function dragEvent(window,type,init,data){
+  const event=new window.MouseEvent(type,init);
+  transfers.set(event,data);
+  return event;
+}
+export function setDragMode(data,mode){stores.get(data).mode=mode;}
+
+/** Pointer-driven HTML text drag lifecycle, separate from canvas mouse drawing. */
+export class HTMLDrag {
+  constructor(window,realm,source,x,y){
+    Object.assign(this,{window,realm,source,x,y,startX:x,startY:y,active:false,target:null,accepted:false});
+    this.data=new DataTransfer();
+    const url=source.tagName==='A'?source.href:source.tagName==='IMG'?source.src:null;
+    if(url){this.data.setData('text/uri-list',url);this.data.setData('text/plain',url);}
+  }
+  emit(target,type,x,y,options={}){
+    const modifiers=options.modifiers??0;
+    return this.realm.dispatch(target,dragEvent(this.window,type,{bubbles:true,cancelable:type!=='dragleave'&&type!=='dragend',
+      clientX:x,clientY:y,button:0,buttons:type==='dragend'||type==='drop'?0:1,
+      altKey:!!(modifiers&1),ctrlKey:!!(modifiers&2),metaKey:!!(modifiers&4),shiftKey:!!(modifiers&8)},this.data));
+  }
+  move(target,x,y,options){
+    this.x=x;this.y=y;
+    if(this.cancelled)return false;
+    if(!this.active){
+      if(Math.hypot(x-this.startX,y-this.startY)<5)return false;
+      const cancelled=this.emit(this.source,'dragstart',this.startX,this.startY,options);
+      setDragMode(this.data,'protected');
+      if(cancelled||!this.source.isConnected){this.cancelled=true;setDragMode(this.data,'disabled');return false;}
+      this.active=true;
+      this.realm.dispatch(this.source,new this.window.PointerEvent('pointercancel',{bubbles:true,pointerId:1,pointerType:'mouse',isPrimary:true}));
+    }
+    this.emit(this.source,'drag',x,y,options);
+    if(target!==this.target){
+      if(target)this.emit(target,'dragenter',x,y,options);
+      if(this.target)this.emit(this.target,'dragleave',x,y,options);
+      this.target=target;
+    }
+    const allowed={none:[],copy:['copy'],link:['link'],move:['move'],copyLink:['copy','link'],copyMove:['copy','move'],linkMove:['link','move'],all:['copy','link','move'],uninitialized:['copy','link','move']}[this.data.effectAllowed];
+    this.data.dropEffect=allowed[0]??'none';
+    this.accepted=!!target&&this.emit(target,'dragover',x,y,options);
+    this.accepted=this.accepted&&allowed.includes(this.data.dropEffect);
+    if(!this.accepted)this.data.dropEffect='none';
+    return true;
+  }
+  end(x=this.x,y=this.y,options={},cancel=false){
+    if(!this.active){setDragMode(this.data,'disabled');return false;}
+    if(!cancel&&this.accepted&&this.target?.isConnected){setDragMode(this.data,'readonly');this.emit(this.target,'drop',x,y,options);}
+    else {this.data.dropEffect='none';if(this.target)this.emit(this.target,'dragleave',x,y,options);}
+    setDragMode(this.data,'protected');
+    this.emit(this.source,'dragend',x,y,options);
+    setDragMode(this.data,'disabled');this.active=false;return true;
+  }
+}
+
+export function isDraggable(element){
+  const value=element?.getAttribute?.('draggable')?.toLowerCase();
+  if(value==='true'||value==='false')return value==='true';
+  return element?.tagName==='IMG'||element?.tagName==='A'&&element.hasAttribute('href');
+}

package/lib/renderer/image-loading.js

@@ -1,18 +1,61 @@
 // Image bytes are decoded by our renderer, not Happy DOM's disabled loader.
 // Share their state with HTMLImageElement's page-facing IDL attributes.
 const states = new WeakMap();
+const decodes = new WeakMap();
+const encodingError = () => new DOMException('The image cannot be decoded.', 'EncodingError');
+
+export function imageSourceChanged(element) {
+  const waiting=decodes.get(element);if(!waiting)return;
+  const src=element.getAttribute('src');
+  for(const item of waiting)if(item.src!==src){waiting.delete(item);item.reject(encodingError());}
+  if(!waiting.size)decodes.delete(element);
+}
+
+function decodeImage(element,request) {
+  return new Promise((resolve,reject)=>{
+    // Like HTML's decode algorithm, inspect the current request in a
+    // microtask: img.decode(); img.src=... in the same task is supported.
+    queueMicrotask(()=>{
+      const src=element.getAttribute('src');
+      if(!src){reject(encodingError());return;}
+      const state=states.get(element);
+      if(state?.src===src&&state.complete){state.decoded?resolve():reject(encodingError());return;}
+      const waiting=decodes.get(element)??new Set();
+      const item={src,resolve,reject};waiting.add(item);decodes.set(element,waiting);
+      try{request(element);}catch(error){waiting.delete(item);reject(error);}
+    });
+  });
+}
 
 export function beginImageLoad(element, src) {
+  imageSourceChanged(element);
   states.set(element, { src, complete: false, width: 0, height: 0 });
 }
 
 export function finishImageLoad(element, src, resource, dispatch = () => {}) {
   if (element.getAttribute('src') !== src) return;
-  states.set(element, { src, complete: true, width: resource?.width ?? 0, height: resource?.height ?? 0 });
+  states.set(element, { src, complete: true, decoded:!!resource, width: resource?.width ?? 0, height: resource?.height ?? 0 });
+  const waiting=decodes.get(element);
+  if(waiting){decodes.delete(element);for(const item of waiting){
+    if(item.src===src&&resource)item.resolve();else item.reject(encodingError());
+  }}
   dispatch(resource ? 'load' : 'error');
 }
 
-export function installImageLoadingAttributes(prototype, nodeOf) {
+export function installImageLoadingAttributes(prototype, nodeOf, request = () => {}, renderedSize = () => null) {
+  Object.defineProperty(prototype,'decode',{configurable:true,enumerable:true,writable:true,
+    value:function decode(){return decodeImage(nodeOf(this),request);}});
+  for(const dimension of ['width','height'])Object.defineProperty(prototype,dimension,{
+    configurable:true,enumerable:true,
+    get(){
+      const node=nodeOf(this),rendered=node.isConnected?renderedSize(node):null;
+      if(rendered)return Math.max(0,Math.floor(rendered[dimension]));
+      const attribute=node.getAttribute(dimension);
+      if(attribute!==null){const n=/^\s*\+?(\d+)/.exec(attribute);return n?Math.min(2147483647,Number(n[1])):0;}
+      const state=states.get(node);return state?.src===node.getAttribute('src')?state[dimension]:0;
+    },
+    set(value){const node=nodeOf(this);node.setAttribute(dimension,String(Number(value)>>>0));request(node);},
+  });
   for (const [property, field] of [['naturalWidth', 'width'], ['naturalHeight', 'height'], ['complete', 'complete']]) {
     Object.defineProperty(prototype, property, {
       configurable: true, enumerable: true,

package/lib/renderer/main.js

@@ -1,3 +1,4 @@
+import { createDialogClient } from "./dialog-client.js";
 import { RENDER_INTERVAL_FLAG, renderMinInterval } from "./render-interval.js";
 /**
  * Renderer process entry point.
@@ -156,6 +157,8 @@ const audio = {
 // Workers load their module from disk, so this happens before seccomp.
 const frameBuffers = new SharedFramePool();
 const compositor = process.argv.includes(COMPOSITOR_FLAG) ? await startCompositor() : null;
+const dialogEndpoint=process.argv.find(arg=>arg.startsWith('--dialog-endpoint='));
+const dialog=dialogEndpoint?await createDialogClient(JSON.parse(dialogEndpoint.slice('--dialog-endpoint='.length))):undefined;
 // Started before the sandbox closes: the worker loads its module from disk.
 const rewriteScript = await startScriptRewriter();
 
@@ -253,6 +256,7 @@ function clipboardWrite(text, type = 'clipboard-write') {
 }
 
 const renderer = await createPageRenderer({
+  dialog,
   renderMinInterval: renderMinInterval(process.argv.find(arg => arg.startsWith(RENDER_INTERVAL_FLAG))?.slice(RENDER_INTERVAL_FLAG.length)),
   fetchResource,
   rewriteScript,

package/lib/renderer/module-transform.js

@@ -126,12 +126,14 @@ export function transformModule(source) {
 
   // import.meta and import() can appear anywhere in the module; most
   // modules have neither, and then the extra walk is skipped.
-  if (/\bimport\s*[.(]/.test(source)) walk(program, (node) => {
+  if (/\bimport\b/.test(source)) walk(program, (node) => {
     if (node.type === "MetaProperty" && node.meta.name === "import") {
       edits.push({ start: node.start, end: node.end, text: `${MODULE}.meta` });
     } else if (node.type === "ImportExpression") {
-      // Replace only `import(`; the arguments keep their own edits.
-      edits.push({ start: node.start, end: node.source.start, text: `${MODULE}.importDynamic(` });
+      // Replace only the keyword. Acorn excludes grouping parentheses from
+      // node.source.start; consuming them would leave unmatched closing
+      // parentheses after property-read rewriting or author grouping.
+      edits.push({ start: node.start, end: node.start + 6, text: `${MODULE}.importDynamic` });
     }
     return true;
   });

package/lib/renderer/page-builtins.js

@@ -0,0 +1,59 @@
+// Mutable boxed-primitive prototypes belong to one page, never SES's shared
+// frozen intrinsics. This module receives only the page's tamed globals.
+export function installPagePrimitiveBuiltins(compartment, pageGlobal) {
+  const prototypes = new Map(), boundMethods = new WeakMap();
+  for (const name of ['Number', 'String', 'Boolean']) {
+    const Base = pageGlobal[name];
+    const Local = compartment.evaluate(`((Base, construct) => function ${name}(...args) {
+      return new.target ? construct(Base, args, new.target) : Base(...args);
+    })(${name}, Reflect.construct)`);
+    const prototype = Reflect.construct(Base, [name === 'String' ? '' : name === 'Boolean' ? false : 0]);
+    for (const key of Reflect.ownKeys(Base.prototype)) {
+      if (key === 'constructor' || Object.hasOwn(prototype, key)) continue;
+      const descriptor = {...Object.getOwnPropertyDescriptor(Base.prototype, key), configurable: true};
+      if ('value' in descriptor) descriptor.writable = true;
+      Object.defineProperty(prototype, key, descriptor);
+    }
+    Object.setPrototypeOf(prototype, Object.getPrototypeOf(Base.prototype));
+    Object.defineProperty(prototype, 'constructor', {value: Local, writable: true, configurable: true});
+    Object.defineProperty(Local, 'prototype', {value: prototype});
+    Object.defineProperty(Local, 'length', {value: 1, configurable: true});
+    for (const key of Reflect.ownKeys(Base)) if (!['name', 'length', 'prototype'].includes(key))
+      Object.defineProperty(Local, key, {...Object.getOwnPropertyDescriptor(Base, key), configurable: true});
+    const ordinaryHasInstance=Function.prototype[Symbol.hasInstance];
+    Object.defineProperty(Local,Symbol.hasInstance,{value(value){
+      return Reflect.apply(ordinaryHasInstance,this,[value]) || this===Local && Reflect.apply(ordinaryHasInstance,Base,[value]);
+    },configurable:true});
+    pageGlobal[name] = Local;
+    prototypes.set(name.toLowerCase(), prototype);
+  }
+  // Return actual values for ordinary reads and retain the original receiver
+  // for method calls, including strict functions invoked on primitive values.
+  return (receiver, key, call = false) => {
+    key = typeof key === 'string' || typeof key === 'symbol' ? key : Reflect.ownKeys({[key]:0})[0];
+    const type = typeof receiver, primitive = prototypes.get(type);
+    let value;
+    if (primitive) {
+      const indexedString = type === 'string' && (key === 'length' || /^(0|[1-9]\d*)$/.test(String(key)));
+      value = indexedString ? Reflect.get(Object(receiver), key, receiver) : Reflect.get(primitive, key, receiver);
+    } else {
+      // Null/undefined throw normally. Never replace or mutate a host prototype.
+      if(receiver===null||receiver===undefined)throw new TypeError('Cannot read property '+String(key)+' of '+receiver);
+      value = receiver[key];
+      if (value === undefined && !Object.hasOwn(Object(receiver), key)) {
+        const local = Array.isArray(receiver) ? pageGlobal.Array.prototype
+          : type === 'function' ? pageGlobal.Function.prototype : null;
+        if (local && Object.hasOwn(local, key)) value = Reflect.get(local, key, receiver);
+      }
+    }
+    if (!call || typeof value !== 'function') return value;
+    if (receiver !== null && (type === 'object' || type === 'function')) {
+      let methods=boundMethods.get(receiver);
+      if(!methods){methods=new WeakMap();boundMethods.set(receiver,methods);}
+      let bound=methods.get(value);
+      if(!bound){const fn=value;bound=(...args)=>Reflect.apply(fn,receiver,args);methods.set(fn,bound);}
+      return bound;
+    }
+    return (...args)=>Reflect.apply(value,receiver,args);
+  };
+}