@enfyra/kernel 1.1.63 → 2.0.0

package/dist/execution/worker.js

@@ -1,4 +1,6 @@
-"use strict";var ne=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var ae=ne((Ye,re)=>{"use strict";var{fork:ve}=require("child_process"),be=require("path");function xe({workerDir:e,activeTaskContexts:t}){let s=new Map,n=new Map,r=new Map,i=new Map,o=null,y=0,f=1e3;function w(l){return Math.max(1,Math.trunc(Number(l)||3e4))}function b(l,a,c){let p=new Error(l);return p.code=a,p.details=c,p}function R(l,a){for(let[c,p]of n)p.child===l&&(clearTimeout(p.timer),n.delete(c),r.delete(c),p.reject(a))}function d(l){for(let[a,c]of i)c.child===l&&(clearTimeout(c.timer),i.delete(a))}function u(l,a){if(!l.connected)return;let c=`cancel_${++y}`,p=setTimeout(()=>{i.delete(c);try{l.kill()}catch{}},f);p.unref?.(),i.set(c,{child:l,timer:p});try{l.send({op:"cancelTask",taskId:a,id:c})}catch{clearTimeout(p),i.delete(c);try{l.kill()}catch{}}}function m(l){let a=typeof l=="string"?JSON.parse(l):l;if(a?.error)throw new Error(a.error);return a?.value}async function v(l){let a=t.get(l.taskId);if(!a)throw new Error(`Package callback context not found: ${l.taskId}`);let c=JSON.stringify(l.callbackId),p=JSON.stringify(l.argsJson||"[]"),h=await a.evalClosure(`return __invokeRuntimeCallback(${c}, ${p});`,[],{arguments:{copy:!0},result:{promise:!0,copy:!0}});return m(h)}function k(){if(o&&o.connected)return o;let l=be.join(e,"package-runtime.child.js"),a=ve(l,[],{stdio:["ignore","ignore","ignore","ipc"],env:{PATH:process.env.PATH||"",HOME:process.env.HOME||"",NODE_ENV:process.env.NODE_ENV||"production",TMPDIR:process.env.TMPDIR||"",LANG:process.env.LANG||""}});return o=a,a.on("message",c=>{if(!c||!c.id)return;if(c.type==="pkgStreamChunk"){let h=r.get(c.id);if(!h)return;h.onChunk(Buffer.from(c.chunk||"","base64")).then(()=>{try{a.send({type:"pkgStreamAck",ackId:c.ackId})}catch{}}).catch(M=>{try{a.send({type:"pkgStreamError",ackId:c.ackId,error:{message:M.message,stack:M.stack}})}catch{}});return}if(c.type==="taskCancelled"){let h=i.get(c.id);if(!h||h.child!==a)return;clearTimeout(h.timer),i.delete(c.id);return}if(c.type==="pkgCallbackCall"){v(c).then(h=>{try{a.send({type:"pkgCallbackResult",id:c.id,value:h})}catch{}}).catch(h=>{try{a.send({type:"pkgCallbackError",id:c.id,error:{message:h.message,stack:h.stack}})}catch{}});return}let p=n.get(c.id);if(p)if(clearTimeout(p.timer),n.delete(c.id),r.delete(c.id),c.ok)p.resolve(c.value);else{c.error?.code==="ERR_PACKAGE_RUNTIME_TIMEOUT"&&u(a,p.taskId);let h=b(c.error?.message||"Package runtime call failed",c.error?.code,c.error?.details);h.stack=c.error?.stack||h.stack,p.reject(h)}}),a.on("exit",(c,p)=>{o===a&&(o=null),d(a),R(a,b(`Package runtime exited${p?` with signal ${p}`:` with code ${c}`}`,"ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))}),a.on("error",c=>{o===a&&(o=null),d(a),R(a,b(c.message,"ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))}),a}function P(l){return new Promise((a,c)=>{let p=k(),h=`pkg_${++y}`,M=w(l.timeoutMs),J=setTimeout(()=>{n.delete(h),r.delete(h),u(p,l.taskId),c(b(`Package runtime call timed out after ${M}ms`,"ERR_PACKAGE_RUNTIME_TIMEOUT",{outcome:"unknown_outcome",retryable:!1}))},M);n.set(h,{child:p,taskId:l.taskId,resolve:a,reject:c,timer:J});try{p.send({...l,id:h},I=>{I&&(clearTimeout(J),n.delete(h),c(I))})}catch(I){clearTimeout(J),n.delete(h),c(I)}})}function C(l,a,c,p=[],h=3e4){return new Promise((M,J)=>{let I=k(),N=`pkg_${++y}`,Q=w(h),ee=setTimeout(()=>{n.delete(N),r.delete(N),u(I,l),J(b(`Package runtime stream timed out after ${Q}ms`,"ERR_PACKAGE_RUNTIME_TIMEOUT",{outcome:"unknown_outcome",retryable:!1}))},Q);n.set(N,{child:I,taskId:l,resolve:M,reject:J,timer:ee}),r.set(N,{onChunk:c});try{I.send({op:"streamHandle",taskId:l,handleId:a,path:p,id:N,timeoutMs:Q},G=>{G&&(clearTimeout(ee),n.delete(N),r.delete(N),J(G))})}catch(G){clearTimeout(ee),n.delete(N),r.delete(N),J(G)}})}function D(l){try{if(!o||!o.connected)return;o.send({...l,id:`pkg_${++y}`,fire:!0})}catch{}}function _(l){try{if(!o||!o.connected)return;u(o,l)}catch{}}async function H(l,a){let c=s.get(l);if(!c)throw new Error("Package context is not available");if(a.handleId)return P({op:a.kind==="get"?"handleGet":"handleCall",taskId:l,handleId:a.handleId,path:a.path||[],argsJson:a.argsJson||"[]",timeoutMs:a.timeoutMs});let p=c.get(a.packageName);if(!p)throw new Error(`Package "${a.packageName}" is not available`);return P({op:a.kind==="construct"?"construct":"call",taskId:l,packageName:a.packageName,package:{name:p.name,fileUrl:p.fileUrl},path:a.path||[],argsJson:a.argsJson||"[]",timeoutMs:a.timeoutMs})}function g(l,a){s.set(l,a)}function x(l){s.delete(l),D({op:"releaseTask",taskId:l})}function $(){if(o){try{o.kill()}catch{}o=null}}return{cleanupTaskPackages:x,cancelTask:_,executePackageRuntimeCall:H,setTaskPackages:g,streamPackageHandle:C,shutdownPackageRuntime:$}}re.exports={createPackageRuntimeBridge:xe}});var oe=ne((Ze,se)=>{"use strict";var Pe=`
+"use strict";var xe=Object.defineProperty;var or=Object.getOwnPropertyDescriptor;var sr=Object.getOwnPropertyNames;var ir=Object.prototype.hasOwnProperty;var lr=(e,t)=>()=>(e&&(t=e(e=0)),t);var A=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),cr=(e,t)=>{for(var n in t)xe(e,n,{get:t[n],enumerable:!0})},ur=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of sr(t))!ir.call(e,i)&&i!==n&&xe(e,i,{get:()=>t[i],enumerable:!(r=or(t,i))||r.enumerable});return e};var $e=e=>ur(xe({},"__esModule",{value:!0}),e);var ie=A((Tn,ze)=>{"use strict";function dr(e){if(e instanceof Error)return e;if(e===null)return new Error("Script threw null");if(e===void 0)return new Error("Script threw undefined");let t;if(typeof e=="string")t=e;else{try{let r=JSON.stringify(e);typeof r=="string"&&(t=r)}catch{}if(t===void 0)try{t=String(e)}catch{t="Script threw a non-Error value"}}let n=new Error(t);if(e&&typeof e=="object"){for(let r of["code","statusCode","errorPath","details","executionStage"])try{e[r]!==void 0&&(n[r]=e[r])}catch{}try{typeof e.stack=="string"&&(n.stack=e.stack)}catch{}}return n}function Be(e){try{let t=JSON.parse(e.message);if(t&&t.__userThrow)return{...t,message:t.message??e.message}}catch{}return null}var fr=3;function De(e){if(typeof e!="string"||!e)return null;let t=e.split(`
+`);for(let n of t){let r=n.match(/(?:\(|\bat\s+)((?:handler|preHook #\d+|postHook #\d+)\.js):(\d+):(\d+)\)?\s*$/);if(!r)continue;let i=r[1],c=parseInt(r[2])-fr;if(!(c<=0))return{line:c,column:parseInt(r[3]),phase:i.replace(".js","")}}return null}function Le(e,t,n){if(!e||!t)return;let r=String(e).split(/\r?\n/),i=Math.max(1,t-1),s=Math.min(r.length,t+1),c=String(s).length,_=[];for(let m=i;m<=s;m++){let l=m===t?">":" ";_.push(`${l} ${String(m).padStart(c," ")}. ${r[m-1]??""}`),m===t&&n&&n>0&&_.push(`  ${" ".repeat(c)}  ${" ".repeat(Math.max(0,Math.min(r[m-1]?.length||0,n-1)))}^`)}return _.join(`
+`)}function Fe(e,t){if(!(!e||!t)){if(t[e.phase])return t[e.phase];if(e.phase?.startsWith("preHook"))return t.preHook;if(e.phase?.startsWith("postHook"))return t.postHook}}function _r(e,t){let n=Be(e);if(n)return{message:n.message,statusCode:n.statusCode,errorPath:n.errorPath,code:n.code??(Number.isInteger(n.statusCode)?`HTTP_${n.statusCode}`:void 0),details:n.details};let r=De(e.stack),i=e.message||"Unknown error",s=r?`${i} (${r.phase}, line ${r.line})`:i,c=Fe(r,t),_=r?Le(c,r.line,r.column):void 0;return{message:s,statusCode:e.statusCode||null,code:e.code,errorPath:e.errorPath,details:{...e.details&&typeof e.details=="object"?e.details:{},errorName:e.name||null,executionStage:e.executionStage||"runtime",...r?{...r,codeFrame:_}:{}}}}function Je(e){return e?.message==="Script execution timed out."}function je(e){return e?.message==="Isolate was disposed during execution due to memory limit"}function pr(e){Je(e)&&e?.code==null&&(e.code="ERR_SCRIPT_EXECUTION_TIMEOUT"),je(e)&&e?.code==null&&(e.code="ERR_ISOLATE_MEMORY_LIMIT",e.details={outcome:"unknown_outcome",retryable:!1})}ze.exports={normalizeThrownValue:dr,extractThrowInfo:Be,parseUserCodeLocation:De,formatCodeFrame:Le,findSourceForLocation:Fe,buildErrorPayload:_r,isNativeExecutionTimeout:Je,isIsolateMemoryLimit:je,normalizeNativeExecutionError:pr}});var Se=A((En,qe)=>{"use strict";var{createHash:mr}=require("crypto"),He=new WeakMap,yr=500,ve=4*1024*1024,hr=32*1024*1024;async function gr(e,t,n){let r=He.get(e);r||(r={entries:new Map,bytes:0},He.set(e,r));let i=Buffer.byteLength(t,"utf8");if(i>ve)throw new Error(`Executor script exceeds ${ve} bytes`);let s=mr("sha256").update(JSON.stringify([n,t])).digest("hex"),c=r.entries.get(s);if(c)return r.entries.delete(s),r.entries.set(s,c),c.script;let _;try{_=await e.compileScript(t,{filename:n})}catch(l){throw l&&typeof l=="object"&&(l.executionStage="compile"),l}if(r.entries.get(s))return _;for(r.entries.set(s,{script:_,bytes:i}),r.bytes+=i;r.entries.size>0&&(r.entries.size>yr||r.bytes>hr);){let l=r.entries.keys().next().value,p=r.entries.get(l);r.entries.delete(l),r.bytes-=p?.bytes||0}return _}qe.exports={getCachedScript:gr,SCRIPT_MAX_BYTES:ve}});var Ge=A((Mn,Ve)=>{"use strict";var{open:wr}=require("fs/promises"),{fileURLToPath:br}=require("url"),z=require("typescript"),{SCRIPT_MAX_BYTES:re}=Se(),{isNativeExecutionTimeout:kr,isIsolateMemoryLimit:xr}=ie();function vr(e){let t=Symbol("packageProxyFallback");async function n(c){if(typeof c.sourceCode=="string"&&c.sourceCode.length>0){if(Buffer.byteLength(c.sourceCode,"utf8")>re)throw new Error(`Package source exceeds ${re} bytes`);return c.sourceCode}let _=c.filePath;if(!_&&typeof c.fileUrl=="string"&&c.fileUrl.startsWith("file://")&&(_=br(c.fileUrl)),!_)return null;let m;try{if(m=await wr(_,"r"),(await m.stat()).size>re)throw new Error(`Package source exceeds ${re} bytes`);let p=Buffer.allocUnsafe(re+1),w=0;for(;w<p.length;){let{bytesRead:d}=await m.read(p,w,p.length-w,w);if(d===0)break;w+=d}if(w>re)throw new Error(`Package source exceeds ${re} bytes`);return p.subarray(0,w).toString("utf8")}catch(l){if(l?.code==="ENOENT")return null;throw l}finally{try{await m?.close()}catch{}}}async function r(c,_,m,l){let p=await n(m);if(p===null||z.createSourceFile(`pkg:${m.safeName}`,p,z.ScriptTarget.Latest,!1,z.ScriptKind.JS).statements.some(y=>z.isImportDeclaration(y)||z.isExportDeclaration(y)&&y.moduleSpecifier!==void 0))return t;let d;try{d=await c.compileModule(p,{filename:`pkg:${m.safeName}`}),await d.instantiate(_,y=>{throw new Error(`Unresolved import in package ${m.safeName}: ${y}`)})}catch(y){try{d?.release()}catch{}if(c.isDisposed||kr(y)||xr(y))throw y;return t}await d.evaluate({timeout:e(l)});let h=await d.namespace.get("default");return h!==void 0?typeof h?.derefInto=="function"?h.derefInto({release:!1}):h:d.namespace.derefInto({release:!1})}function i(c){if(c==null)return[];if(!Array.isArray(c))throw new Error("Executor pkgSources must be an array");let _=new Set,m=new Set;for(let l of c){if(!l||typeof l!="object")throw new Error("Executor package entries must be objects");if(typeof l.name!="string"||l.name.length===0)throw new Error("Executor package name must be a non-empty string");if(_.has(l.name))throw new Error(`Duplicate executor package name: ${l.name}`);if(typeof l.safeName!="string"||!/^[A-Za-z_$][\w$]*$/.test(l.safeName))throw new Error(`Invalid package safeName: ${l.safeName}`);if(m.has(l.safeName))throw new Error(`Duplicate executor package safeName: ${l.safeName}`);_.add(l.name),m.add(l.safeName)}return c}function s(c,_){let m=new Set(_.map(d=>d.name)),l=new Set,p=z.createSourceFile("package-references.js",String(c||""),z.ScriptTarget.Latest,!1,z.ScriptKind.JS),w=d=>{z.isCallExpression(d)&&z.isIdentifier(d.expression)&&d.expression.text==="require"&&d.arguments.length===1&&z.isStringLiteralLike(d.arguments[0])&&m.has(d.arguments[0].text)&&l.add(d.arguments[0].text),z.forEachChild(d,w)};return w(p),l}return{PACKAGE_PROXY_FALLBACK:t,loadEsmPackageIntoContext:r,validatePackageSources:i,collectIsolatePackageNames:s}}Ve.exports={createWorkerPackages:vr}});var We=A((Cn,Ke)=>{"use strict";Ke.exports=`
 "use strict";
 let $ctx = {};
 let $pkgs = {};
@@ -9,76 +11,208 @@ let __logBytes = 0;
 let __runtimeCallbackCounter = 0;
 let __runtimeCallbacks = new Map();
 let __pendingRuntimeTasks = [];
+let __streamTimerCounter = 0;
 
+const __trustedNow = Date.now.bind(Date);
 const __applyOpts = { result: { promise: true, copy: true } };
 
+const __typedArrayConstructors = Object.freeze(Object.assign(Object.create(null), {
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  ...(typeof Float16Array === 'undefined' ? {} : { Float16Array }),
+  Float32Array,
+  Float64Array,
+  ...(typeof BigInt64Array === 'undefined' ? {} : { BigInt64Array }),
+  ...(typeof BigUint64Array === 'undefined' ? {} : { BigUint64Array }),
+}));
+const __typedArrayTagGetter = Object.getOwnPropertyDescriptor(
+  Object.getPrototypeOf(Uint8Array.prototype),
+  Symbol.toStringTag,
+)?.get;
+const __dataViewByteLengthGetter = Object.getOwnPropertyDescriptor(
+  DataView.prototype,
+  'byteLength',
+)?.get;
+
+function __decodeTypedArray(payload) {
+  const name = String(payload.__typedArray || '');
+  const bytes = payload.bytes;
+  if (name === 'DataView') {
+    const buffer = Uint8Array.from(bytes || payload.data || []).buffer;
+    return new DataView(buffer);
+  }
+  const Ctor = __typedArrayConstructors[name];
+  if (typeof Ctor !== 'function') {
+    throw new TypeError('Unsupported typed array: ' + name);
+  }
+  if (Array.isArray(bytes)) {
+    const buffer = Uint8Array.from(bytes).buffer;
+    return new Ctor(buffer);
+  }
+  return new Ctor(payload.data || []);
+}
+
+function __isEnvelope(value, requiredKey, allowedKeys) {
+  if (value === null || (typeof value !== 'object' && typeof value !== 'function')) return false;
+  if (!Object.prototype.hasOwnProperty.call(value, requiredKey)) return false;
+  const allowed = new Set(allowedKeys);
+  return Object.keys(value).every((key) => allowed.has(key));
+}
+
+function __decodeNumber(value) {
+  if (value === 'nan') return NaN;
+  if (value === 'infinity') return Infinity;
+  if (value === '-infinity') return -Infinity;
+  if (value === '-0') return -0;
+  throw new TypeError('Unsupported encoded number: ' + value);
+}
+
+function __encodeNumber(value) {
+  if (Number.isNaN(value)) return { __number: 'nan' };
+  if (value === Infinity) return { __number: 'infinity' };
+  if (value === -Infinity) return { __number: '-infinity' };
+  if (Object.is(value, -0)) return { __number: '-0' };
+  return value;
+}
+
+function __collidesWithEnvelope(value) {
+  return (
+    __isEnvelope(value, '__plainObject', ['__plainObject'])
+    || __isEnvelope(value, '__number', ['__number'])
+    || __isEnvelope(value, '__bigint', ['__bigint'])
+    || __isEnvelope(value, '__nullPrototype', ['__nullPrototype'])
+    || (__isEnvelope(value, '__e', ['__e']) && value.__e === 'u')
+    || (__isEnvelope(value, '__e', ['__e', 'd']) && value.__e === 'v')
+    || __isEnvelope(value, '__fnRef', ['__fnRef'])
+    || __isEnvelope(value, '__pkgHandleArg', ['__pkgHandleArg'])
+    || __isEnvelope(value, '__pkgHandle', ['__pkgHandle'])
+    || __isEnvelope(value, '__date', ['__date'])
+    || __isEnvelope(value, '__set', ['__set'])
+    || __isEnvelope(value, '__map', ['__map'])
+    || __isEnvelope(value, '__regexp', ['__regexp'])
+    || __isEnvelope(value, '__error', ['__error'])
+    || __isEnvelope(value, '__url', ['__url'])
+    || __isEnvelope(value, '__urlSearchParams', ['__urlSearchParams'])
+    || __isEnvelope(value, '__blob', ['__blob'])
+    || __isEnvelope(value, '__file', ['__file'])
+    || __isEnvelope(value, '__formData', ['__formData'])
+    || __isEnvelope(value, '__typedArray', ['__typedArray', 'bytes', 'data'])
+    || __isEnvelope(value, '__arrayBuffer', ['__arrayBuffer'])
+  );
+}
+
+function __defineDataProperty(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  });
+}
+
 function __unwrapMainThreadPayload(v) {
-  if (v !== null && typeof v === 'object' && v.__e === 'u') return undefined;
-  if (v !== null && typeof v === 'object' && v.__e === 'v') return __unwrapMainThreadPayload(v.d);
-  if (v !== null && typeof v === 'object' && v.__date) return new Date(v.__date);
-  if (v !== null && typeof v === 'object' && v.__set) {
+  if (v === null || typeof v !== 'object') return v;
+  if (__isEnvelope(v, '__plainObject', ['__plainObject'])) {
+    const out = {};
+    for (const [key, value] of Object.entries(v.__plainObject || {})) {
+      __defineDataProperty(out, key, __unwrapMainThreadPayload(value));
+    }
+    return out;
+  }
+  if (__isEnvelope(v, '__number', ['__number'])) {
+    return __decodeNumber(v.__number);
+  }
+  if (__isEnvelope(v, '__bigint', ['__bigint'])) {
+    return BigInt(v.__bigint);
+  }
+  if (__isEnvelope(v, '__nullPrototype', ['__nullPrototype'])) {
+    const out = Object.create(null);
+    for (const [key, value] of Object.entries(v.__nullPrototype || {})) {
+      __defineDataProperty(out, key, __unwrapMainThreadPayload(value));
+    }
+    return out;
+  }
+  if (__isEnvelope(v, '__e', ['__e']) && v.__e === 'u') return undefined;
+  if (__isEnvelope(v, '__e', ['__e', 'd']) && v.__e === 'v') {
+    return __unwrapMainThreadPayload(v.d);
+  }
+  if (__isEnvelope(v, '__date', ['__date'])) return new Date(v.__date);
+  if (__isEnvelope(v, '__set', ['__set'])) {
     return new Set(v.__set.map(__unwrapMainThreadPayload));
   }
-  if (v !== null && typeof v === 'object' && v.__map) {
+  if (__isEnvelope(v, '__map', ['__map'])) {
     return new Map(v.__map.map(([key, value]) => [
       __unwrapMainThreadPayload(key),
       __unwrapMainThreadPayload(value),
     ]));
   }
-  if (v !== null && typeof v === 'object' && v.__regexp) {
+  if (__isEnvelope(v, '__regexp', ['__regexp'])) {
     return new RegExp(v.__regexp.source, v.__regexp.flags || '');
   }
-  if (v !== null && typeof v === 'object' && v.__error) {
+  if (__isEnvelope(v, '__error', ['__error'])) {
     const error = new Error(v.__error.message || '');
     error.name = v.__error.name || 'Error';
     if (v.__error.stack) error.stack = v.__error.stack;
     return error;
   }
-  if (v !== null && typeof v === 'object' && v.__url) return new URL(v.__url);
-  if (v !== null && typeof v === 'object' && v.__urlSearchParams) {
+  if (__isEnvelope(v, '__url', ['__url'])) return new URL(v.__url);
+  if (__isEnvelope(v, '__urlSearchParams', ['__urlSearchParams'])) {
     return new URLSearchParams(v.__urlSearchParams);
   }
-  if (v !== null && typeof v === 'object' && v.__blob) {
+  if (__isEnvelope(v, '__blob', ['__blob'])) {
     return new Blob([Uint8Array.from(v.__blob.data || [])], {
       type: v.__blob.type || '',
     });
   }
-  if (v !== null && typeof v === 'object' && v.__file) {
+  if (__isEnvelope(v, '__file', ['__file'])) {
     const parts = [Uint8Array.from(v.__file.data || [])];
     const options = {
       type: v.__file.type || '',
       lastModified: v.__file.lastModified,
     };
-    return typeof File !== 'undefined'
-      ? new File(parts, v.__file.name || 'file', options)
-      : new Blob(parts, options);
+    if (typeof File !== 'undefined') {
+      return new File(parts, v.__file.name || 'file', options);
+    }
+    const blob = new Blob(parts, options);
+    __defineDataProperty(blob, 'name', v.__file.name || 'file');
+    __defineDataProperty(blob, 'lastModified', v.__file.lastModified);
+    return blob;
   }
-  if (v !== null && typeof v === 'object' && v.__formData) {
+  if (__isEnvelope(v, '__formData', ['__formData'])) {
     const form = new FormData();
     for (const [key, value] of v.__formData) {
-      form.append(key, __unwrapMainThreadPayload(value));
+      const decoded = __unwrapMainThreadPayload(value);
+      if (
+        __isEnvelope(value, '__file', ['__file'])
+        && typeof File === 'undefined'
+      ) {
+        form.append(key, decoded, value.__file.name || 'file');
+      } else {
+        form.append(key, decoded);
+      }
     }
     return form;
   }
-  if (v !== null && typeof v === 'object' && v.__typedArray) {
-    const Ctor = globalThis[v.__typedArray] || Uint8Array;
-    return new Ctor(v.data || []);
+  if (__isEnvelope(v, '__typedArray', ['__typedArray', 'bytes', 'data'])) {
+    return __decodeTypedArray(v);
   }
-  if (v !== null && typeof v === 'object' && v.__arrayBuffer) {
+  if (__isEnvelope(v, '__arrayBuffer', ['__arrayBuffer'])) {
     return Uint8Array.from(v.__arrayBuffer).buffer;
   }
-  if (v !== null && typeof v === 'object' && v.__pkgHandle) {
+  if (__isEnvelope(v, '__pkgHandle', ['__pkgHandle'])) {
     return __createPkgHandleProxy(Promise.resolve(v.__pkgHandle), []);
   }
   if (Array.isArray(v)) return v.map(__unwrapMainThreadPayload);
-  if (v !== null && typeof v === 'object' && !v.__pkgHandle) {
-    const out = {};
-    for (const [key, value] of Object.entries(v)) {
-      out[key] = __unwrapMainThreadPayload(value);
-    }
-    return out;
+  const out = {};
+  for (const [key, value] of Object.entries(v)) {
+    __defineDataProperty(out, key, __unwrapMainThreadPayload(value));
   }
-  return v;
+  return out;
 }
 
 function __parseMainThreadResult(s) {
@@ -86,18 +220,84 @@ function __parseMainThreadResult(s) {
   return __unwrapMainThreadPayload(w);
 }
 
+`});var Ye=A((Rn,Xe)=>{"use strict";Xe.exports=`// A script may call the host without awaiting the result, and a host call
+// outlives the script that made it: a fire-and-forget call is still pending when
+// the task finishes, and the lifecycle rejects it then. V8 reports that
+// rejection as an unhandled rejection of the isolate, which the next script run
+// on the same lane inherits and fails with \u2014 one task killing another. Every
+// host-call promise is therefore marked handled where it is handed to the
+// script: awaiting the call still observes the rejection, while a call the
+// script ignores can no longer fail a different task.
+function __hostCallAsync(fn) {
+  return (...args) => {
+    const promise = fn(...args);
+    if (promise && typeof promise.catch === 'function') promise.catch(() => {});
+    return promise;
+  };
+}
+
 async function __call(type, dataJson) {
-  const r = await __callRef.apply(undefined, [__taskId, type, dataJson], __applyOpts);
+  const r = await __callRef.apply(undefined, [type, dataJson], __applyOpts);
   return __parseMainThreadResult(r);
 }
 
 function __remainingTaskTimeoutMs() {
   if (!__taskDeadlineMs) return 30000;
-  return Math.max(1, Math.ceil(__taskDeadlineMs - Date.now()));
+  const remainingMs = Math.ceil(__taskDeadlineMs - __trustedNow());
+  if (remainingMs <= 0) {
+    const error = new Error('Script execution timed out.');
+    error.code = 'ERR_SCRIPT_EXECUTION_TIMEOUT';
+    throw error;
+  }
+  return remainingMs;
+}
+
+async function __awaitBeforeDeadline(value, deadlineMs, timeoutError) {
+  const remainingMs = Math.ceil(deadlineMs - __trustedNow());
+  if (remainingMs <= 0) throw timeoutError();
+  const timerId = 'deadline_timer_' + (++__streamTimerCounter);
+  try {
+    const result = await Promise.race([
+      Promise.resolve(value),
+      __waitForStreamTimer(timerId, remainingMs).then((fired) => {
+        if (fired) throw timeoutError();
+        const error = new Error('Task is no longer active');
+        error.code = 'ERR_EXECUTION_ABORTED';
+        throw error;
+      }),
+    ]);
+    if (__trustedNow() >= deadlineMs) throw timeoutError();
+    return result;
+  } finally {
+    void __clearStreamTimer(timerId).catch(() => {});
+  }
+}
+
+function __taskTimeoutError() {
+  const error = new Error('Script execution timed out.');
+  error.code = 'ERR_SCRIPT_EXECUTION_TIMEOUT';
+  return error;
+}
+
+function __awaitTaskDeadline(value) {
+  return __awaitBeforeDeadline(value, __innerGuardDeadlineMs(), __taskTimeoutError);
+}
+
+// The host supplies task tolerance plus backstop grace; the V8 watchdog keeps
+// the original execution budget.
+let __innerGuardGraceMs = 500;
+
+function __innerGuardDeadlineMs() {
+  if (!__taskDeadlineMs) return __trustedNow() + 30000 + __innerGuardGraceMs;
+  return __taskDeadlineMs + __innerGuardGraceMs;
+}
+
+function __innerGuardTimeoutMs() {
+  return Math.max(1, Math.ceil(__innerGuardDeadlineMs() - __trustedNow()));
 }
 
 function __encodePkgCallPayload(payload) {
-  return JSON.stringify({ ...payload, timeoutMs: __remainingTaskTimeoutMs() });
+  return JSON.stringify({ ...payload, timeoutMs: __innerGuardTimeoutMs() });
 }
 
 function __bytesToBase64(bytes) {
@@ -118,6 +318,29 @@ function __bytesToBase64(bytes) {
   return out;
 }
 
+function __base64ToBytes(value) {
+  const encoded = String(value || '');
+  if (encoded.length % 4 !== 0) throw new TypeError('Invalid Base64 payload');
+  const padding = encoded.endsWith('==') ? 2 : encoded.endsWith('=') ? 1 : 0;
+  const length = encoded.length - padding;
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  const out = new Uint8Array(encoded.length / 4 * 3 - padding);
+  let bits = 0;
+  let bitCount = 0;
+  let offset = 0;
+  for (let i = 0; i < length; i++) {
+    const index = chars.indexOf(encoded[i]);
+    if (index < 0) throw new TypeError('Invalid Base64 payload');
+    bits = (bits << 6) | index;
+    bitCount += 6;
+    if (bitCount >= 8) {
+      bitCount -= 8;
+      out[offset++] = (bits >> bitCount) & 255;
+    }
+  }
+  return out;
+}
+
 function __streamChunkToBytes(chunk) {
   if (chunk === undefined || chunk === null) return new Uint8Array();
   if (typeof chunk === 'string') return new TextEncoder().encode(chunk);
@@ -128,105 +351,214 @@ function __streamChunkToBytes(chunk) {
   return new TextEncoder().encode(String(chunk));
 }
 
+function __responseBodyToBytes(value) {
+  if (typeof value === 'string') return new TextEncoder().encode(value);
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new TypeError('@RES.bytes requires a string, ArrayBuffer, or ArrayBuffer view');
+}
+
+function __encodeTypedArray(value) {
+  let name;
+  try {
+    __dataViewByteLengthGetter.call(value);
+    name = 'DataView';
+  } catch {
+    try { name = __typedArrayTagGetter.call(value); } catch {}
+  }
+  if (!name || (name !== 'DataView' && !__typedArrayConstructors[name])) {
+    throw new TypeError('Unsupported ArrayBuffer view');
+  }
+  return {
+    __typedArray: name,
+    bytes: Array.from(
+      new Uint8Array(value.buffer, value.byteOffset, value.byteLength),
+    ),
+  };
+}
+
 async function __encodeRuntimeArg(value, seen) {
+  if (value === undefined) return { __e: 'u' };
+  if (typeof value === 'number') return __encodeNumber(value);
+  if (typeof value === 'bigint') return { __bigint: value.toString() };
+  if (typeof value === 'function' && value.__pkgHandlePromise) {
+    return {
+      __pkgHandleArg: await __awaitTaskDeadline(value.__pkgHandlePromise),
+    };
+  }
+  if (
+    value !== null
+    && (typeof value === 'object' || typeof value === 'function')
+    && typeof value.then === 'function'
+  ) {
+    return __encodeRuntimeArg(await __awaitTaskDeadline(value), seen);
+  }
   if (typeof value === 'function') {
-    if (value.__pkgHandlePromise) {
-      return { __pkgHandleArg: await value.__pkgHandlePromise };
-    }
-    if (typeof value.then === 'function') {
-      return __encodeRuntimeArg(await value, seen);
-    }
     const id = 'fn_' + (++__runtimeCallbackCounter);
     __runtimeCallbacks.set(id, value);
     return { __fnRef: id };
   }
   if (!seen) seen = new WeakSet();
+  let tracked = false;
   if (value && typeof value === 'object') {
     if (seen.has(value)) return null;
     seen.add(value);
+    tracked = true;
   }
-  if (value instanceof Date) return { __date: value.toISOString() };
-  if (value instanceof Set) {
-    const items = [];
-    for (const item of value.values()) items.push(await __encodeRuntimeArg(item, seen));
-    return { __set: items };
-  }
-  if (value instanceof Map) {
-    const entries = [];
-    for (const [key, item] of value.entries()) {
-      entries.push([
-        await __encodeRuntimeArg(key, seen),
-        await __encodeRuntimeArg(item, seen),
-      ]);
+  try {
+    if (value instanceof Date) {
+      return {
+        __date: Number.isNaN(value.getTime()) ? 'Invalid Date' : value.toISOString(),
+      };
     }
-    return { __map: entries };
-  }
-  if (value instanceof RegExp) {
-    return { __regexp: { source: value.source, flags: value.flags } };
-  }
-  if (value instanceof Error) {
-    return {
-      __error: {
-        name: value.name,
-        message: value.message,
-        stack: value.stack,
-      },
-    };
-  }
-  if (typeof URL !== 'undefined' && value instanceof URL) return { __url: value.href };
-  if (typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams) {
-    return { __urlSearchParams: value.toString() };
-  }
-  if (typeof File !== 'undefined' && value instanceof File) {
-    return {
-      __file: {
-        name: value.name,
-        type: value.type,
-        lastModified: value.lastModified,
-        data: Array.from(new Uint8Array(await value.arrayBuffer())),
-      },
-    };
-  }
-  if (typeof Blob !== 'undefined' && value instanceof Blob) {
-    return {
-      __blob: {
-        type: value.type,
-        data: Array.from(new Uint8Array(await value.arrayBuffer())),
-      },
-    };
-  }
-  if (typeof FormData !== 'undefined' && value instanceof FormData) {
-    const entries = [];
-    for (const [key, item] of value.entries()) {
-      entries.push([key, await __encodeRuntimeArg(item, seen)]);
+    if (value instanceof Set) {
+      const items = [];
+      for (const item of value.values()) {
+        items.push(await __encodeRuntimeArg(item, seen));
+      }
+      return { __set: items };
     }
-    return { __formData: entries };
-  }
-  if (ArrayBuffer.isView(value)) {
-    return {
-      __typedArray: value.constructor?.name || 'Uint8Array',
-      data: Array.from(value),
-    };
-  }
-  if (value instanceof ArrayBuffer) {
-    return { __arrayBuffer: Array.from(new Uint8Array(value)) };
-  }
-  if (Array.isArray(value)) return Promise.all(value.map((item) => __encodeRuntimeArg(item, seen)));
-  if (value && typeof value === 'object') {
-    const out = {};
-    for (const key of Object.keys(value)) {
-      out[key] = await __encodeRuntimeArg(value[key], seen);
+    if (value instanceof Map) {
+      const entries = [];
+      for (const [key, item] of value.entries()) {
+        entries.push([
+          await __encodeRuntimeArg(key, seen),
+          await __encodeRuntimeArg(item, seen),
+        ]);
+      }
+      return { __map: entries };
     }
-    return out;
+    if (value instanceof RegExp) {
+      return { __regexp: { source: value.source, flags: value.flags } };
+    }
+    if (value instanceof Error) {
+      return {
+        __error: {
+          name: value.name,
+          message: value.message,
+          stack: value.stack,
+        },
+      };
+    }
+    if (typeof URL !== 'undefined' && value instanceof URL) {
+      return { __url: value.href };
+    }
+    if (typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams) {
+      return { __urlSearchParams: value.toString() };
+    }
+    if (
+      typeof Blob !== 'undefined'
+      && value instanceof Blob
+      && (
+        (typeof File !== 'undefined' && value instanceof File)
+        || (
+          typeof File === 'undefined'
+          && typeof value.name === 'string'
+          && typeof value.lastModified === 'number'
+        )
+      )
+    ) {
+      return {
+        __file: {
+          name: value.name,
+          type: value.type,
+          lastModified: value.lastModified,
+          data: Array.from(new Uint8Array(
+            await __awaitTaskDeadline(value.arrayBuffer()),
+          )),
+        },
+      };
+    }
+    if (typeof Blob !== 'undefined' && value instanceof Blob) {
+      return {
+        __blob: {
+          type: value.type,
+          data: Array.from(new Uint8Array(
+            await __awaitTaskDeadline(value.arrayBuffer()),
+          )),
+        },
+      };
+    }
+    if (typeof FormData !== 'undefined' && value instanceof FormData) {
+      const entries = [];
+      for (const [key, item] of value.entries()) {
+        entries.push([key, await __encodeRuntimeArg(item, seen)]);
+      }
+      return { __formData: entries };
+    }
+    if (ArrayBuffer.isView(value)) return __encodeTypedArray(value);
+    if (value instanceof ArrayBuffer) {
+      return { __arrayBuffer: Array.from(new Uint8Array(value)) };
+    }
+    if (Array.isArray(value)) {
+      const items = [];
+      for (const item of value) {
+        items.push(await __encodeRuntimeArg(item, seen));
+      }
+      return items;
+    }
+    if (value && typeof value === 'object') {
+      const out = {};
+      for (const key of Object.keys(value)) {
+        __defineDataProperty(
+          out,
+          key,
+          await __encodeRuntimeArg(value[key], seen),
+        );
+      }
+      if (Object.getPrototypeOf(value) === null) {
+        return { __nullPrototype: out };
+      }
+      return __collidesWithEnvelope(out) ? { __plainObject: out } : out;
+    }
+    return value;
+  } finally {
+    if (tracked) seen.delete(value);
   }
-  return value;
 }
 
 async function __stringifyRuntimeArgs(args) {
-  return JSON.stringify(await Promise.all(args.map((arg) => __encodeRuntimeArg(arg))));
+  const encoded = [];
+  const seen = new WeakSet();
+  for (const arg of args) {
+    encoded.push(await __encodeRuntimeArg(arg, seen));
+  }
+  return JSON.stringify(encoded);
+}
+
+`});var Ze=A((An,Qe)=>{"use strict";Qe.exports=`function __utf8IncompleteSuffixLength(bytes) {
+  if (bytes.byteLength === 0) return 0;
+  let start = bytes.byteLength - 1;
+  while (start > 0 && (bytes[start] & 0xc0) === 0x80) start--;
+  const lead = bytes[start];
+  const available = bytes.byteLength - start;
+  let expected = 0;
+  if (lead >= 0xc2 && lead <= 0xdf) expected = 2;
+  else if (lead >= 0xe0 && lead <= 0xef) expected = 3;
+  else if (lead >= 0xf0 && lead <= 0xf4) expected = 4;
+  else return 0;
+  if (available >= expected) return 0;
+  for (let index = start + 1; index < bytes.byteLength; index++) {
+    if ((bytes[index] & 0xc0) !== 0x80) return 0;
+  }
+  if (available >= 2) {
+    const second = bytes[start + 1];
+    if (lead === 0xe0 && second < 0xa0) return 0;
+    if (lead === 0xed && second > 0x9f) return 0;
+    if (lead === 0xf0 && second < 0x90) return 0;
+    if (lead === 0xf4 && second > 0x8f) return 0;
+  }
+  return available;
 }
 
 async function __streamResponseFromLocalReadable(stream, options) {
+  const { timeoutMs, idleTimeoutMs } = __normalizeStreamOptions(options);
+  const deadlineMs = __trustedNow() + Math.min(
+    timeoutMs,
+    __innerGuardTimeoutMs(),
+  );
   const observer = typeof options?.observer === 'function'
     ? options.observer
     : null;
@@ -234,35 +566,78 @@ async function __streamResponseFromLocalReadable(stream, options) {
     ? options.transform
     : null;
   const decoder = observer || transform ? new TextDecoder('utf-8') : null;
+  let pendingTransformBytes = new Uint8Array();
   const relayOptions = { ...(options || {}) };
   delete relayOptions.observer;
   delete relayOptions.transform;
+  const timeoutError = () => __streamTimeoutError(
+    timeoutMs,
+    { timeoutKind: 'total' },
+  );
+  const awaitStage = (value) => __awaitBeforeDeadline(
+    value,
+    deadlineMs,
+    timeoutError,
+  );
   const notifyObserver = async (text, kind) => {
     if (!observer) return;
     try {
-      await observer(text, kind);
-    } catch {}
+      await awaitStage(observer(text, kind));
+    } catch (error) {
+      if (
+        __trustedNow() >= deadlineMs
+        || error?.code === 'ERR_PACKAGE_STREAM_TIMEOUT'
+        || error?.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT'
+        || error?.code === 'ERR_EXECUTION_ABORTED'
+      ) {
+        throw error;
+      }
+    }
   };
   const relayChunk = async (chunk, kind, text) => {
     let output = chunk;
     if (transform) {
-      const transformed = await transform(text, kind);
+      const chunkBytes = __streamChunkToBytes(chunk);
+      const combined = new Uint8Array(
+        pendingTransformBytes.byteLength + chunkBytes.byteLength,
+      );
+      combined.set(pendingTransformBytes);
+      combined.set(chunkBytes, pendingTransformBytes.byteLength);
+      const suffixLength = kind === 'end'
+        ? 0
+        : __utf8IncompleteSuffixLength(combined);
+      const completedBytes = suffixLength === 0
+        ? combined
+        : combined.slice(0, combined.byteLength - suffixLength);
+      pendingTransformBytes = suffixLength === 0
+        ? new Uint8Array()
+        : combined.slice(combined.byteLength - suffixLength);
+      if (kind !== 'end' && text === '' && completedBytes.byteLength === 0) return;
+      const transformed = await awaitStage(transform(text, kind));
       if (transformed === null) return;
-      if (transformed !== undefined) output = String(transformed);
+      if (transformed === undefined) {
+        output = completedBytes;
+      } else {
+        output = String(transformed);
+      }
     }
     const bytes = __streamChunkToBytes(output);
     if (bytes.byteLength === 0) return;
-    await __call('resCall', JSON.stringify({
+    await awaitStage(__call('resCall', JSON.stringify({
       method: 'streamChunk',
       chunk: __bytesToBase64(bytes),
-    }));
+    })));
   };
-  await __call('resCall', JSON.stringify({
-    method: 'streamStart',
-    argsJson: JSON.stringify([null, relayOptions]),
-  }));
+  const iterator = __getStreamIterator(stream);
   try {
-    for await (const chunk of stream) {
+    await awaitStage(__call('resCall', JSON.stringify({
+      method: 'streamStart',
+      argsJson: JSON.stringify([null, relayOptions]),
+    })));
+    while (true) {
+      const next = await __nextStreamChunk(iterator, deadlineMs, idleTimeoutMs, timeoutMs);
+      if (next.done) break;
+      const chunk = next.value;
       let text = '';
       try { text = decoder ? decoder.decode(__streamChunkToBytes(chunk), { stream: true }) : ''; } catch {}
       await notifyObserver(text, 'chunk');
@@ -272,28 +647,38 @@ async function __streamResponseFromLocalReadable(stream, options) {
     try { endText = decoder ? decoder.decode() : ''; } catch {}
     await notifyObserver(endText, 'end');
     await relayChunk('', 'end', endText);
-    await __call('resCall', JSON.stringify({ method: 'streamEnd' }));
+    await awaitStage(__call('resCall', JSON.stringify({ method: 'streamEnd' })));
   } catch (error) {
-    try {
-      await __call('resCall', JSON.stringify({
+    const cleanup = Promise.allSettled([
+      __closeStreamIterator(iterator),
+      __call('resCall', JSON.stringify({
         method: 'streamError',
         error: {
           message: error && error.message ? error.message : String(error),
         },
-      }));
-    } catch {}
-    await notifyObserver('', 'error');
+      })),
+      notifyObserver('', 'error'),
+    ]);
+    if (__trustedNow() < deadlineMs) {
+      try { await awaitStage(cleanup); } catch {}
+    } else {
+      void cleanup;
+    }
     throw error;
   }
 }
 
 async function __drainPendingRuntimeTasks() {
+  let firstFailure;
   while (__pendingRuntimeTasks.length > 0) {
     const tasks = __pendingRuntimeTasks.splice(0, __pendingRuntimeTasks.length);
-    const results = await Promise.allSettled(tasks);
-    const failed = results.find((result) => result.status === 'rejected');
-    if (failed) throw failed.reason;
+    const results = await __awaitTaskDeadline(Promise.allSettled(tasks));
+    if (firstFailure === undefined) {
+      const failed = results.find((result) => result.status === 'rejected');
+      if (failed) firstFailure = { reason: failed.reason };
+    }
   }
+  if (firstFailure !== undefined) throw firstFailure.reason;
 }
 
 async function __invokeRuntimeCallback(id, argsJson) {
@@ -302,26 +687,38 @@ async function __invokeRuntimeCallback(id, argsJson) {
     return JSON.stringify({ error: 'Package callback not found: ' + id });
   }
   try {
-    const value = await fn(...JSON.parse(argsJson || '[]').map(__unwrapMainThreadPayload));
-    return JSON.stringify({ value: await __encodeRuntimeArg(value) });
+    const value = await __awaitTaskDeadline(
+      fn(...JSON.parse(argsJson || '[]').map(__unwrapMainThreadPayload)),
+    );
+    return JSON.stringify({
+      value: await __awaitTaskDeadline(__encodeRuntimeArg(value)),
+    });
   } catch (error) {
+    if (
+      error?.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT'
+      || error?.code === 'ERR_EXECUTION_ABORTED'
+    ) {
+      throw error;
+    }
     return JSON.stringify({ error: error && error.message ? error.message : String(error) });
   }
 }
 
-const __safeCloneFailed = Symbol('__safeCloneFailed');
+`});var tt=A((Nn,et)=>{"use strict";et.exports=`const __safeCloneFailed = Symbol('__safeCloneFailed');
 
 async function __safeClone(v, seen, cyclic) {
   if (!seen) {
     const cloned = await __safeClone(v, new WeakSet(), new WeakSet());
     return cloned === __safeCloneFailed ? null : cloned;
   }
-  if (v === undefined) return undefined;
+  if (v === undefined) return { __e: 'u' };
+  if (typeof v === 'bigint') return { __bigint: v.toString() };
   let tracked = false;
   try {
     if (v && typeof v.then === 'function') {
-      return await __safeClone(await v, seen, cyclic);
+      return await __safeClone(await __awaitTaskDeadline(v), seen, cyclic);
     }
+
     if (v && typeof v === 'object') {
       if (seen.has(v)) {
         cyclic.add(v);
@@ -331,6 +728,10 @@ async function __safeClone(v, seen, cyclic) {
       tracked = true;
     }
     if (v instanceof Date) return v.toISOString();
+    if (ArrayBuffer.isView(v)) return __encodeTypedArray(v);
+    if (v instanceof ArrayBuffer) {
+      return { __arrayBuffer: Array.from(new Uint8Array(v)) };
+    }
     if (v instanceof Set) {
       const out = [];
       for (const item of v.values()) {
@@ -340,12 +741,16 @@ async function __safeClone(v, seen, cyclic) {
       return cyclic.has(v) ? __safeCloneFailed : out;
     }
     if (v instanceof Map) {
-      const out = {};
+      const entries = [];
       for (const [key, item] of v.entries()) {
-        const cloned = await __safeClone(item, seen, cyclic);
-        out[String(key)] = cloned === __safeCloneFailed ? null : cloned;
+        const clonedKey = await __safeClone(key, seen, cyclic);
+        const clonedValue = await __safeClone(item, seen, cyclic);
+        entries.push([
+          clonedKey === __safeCloneFailed ? null : clonedKey,
+          clonedValue === __safeCloneFailed ? null : clonedValue,
+        ]);
       }
-      return cyclic.has(v) ? __safeCloneFailed : out;
+      return cyclic.has(v) ? __safeCloneFailed : { __map: entries };
     }
     if (Array.isArray(v)) {
       const out = [];
@@ -359,16 +764,32 @@ async function __safeClone(v, seen, cyclic) {
       const out = {};
       for (const key of Object.keys(v)) {
         const cloned = await __safeClone(v[key], seen, cyclic);
-        out[key] = cloned === __safeCloneFailed ? null : cloned;
+        __defineDataProperty(
+          out,
+          key,
+          cloned === __safeCloneFailed ? null : cloned,
+        );
       }
-      return cyclic.has(v) ? __safeCloneFailed : out;
+      if (cyclic.has(v)) return __safeCloneFailed;
+      if (Object.getPrototypeOf(v) === null) {
+        return { __nullPrototype: out };
+      }
+      return __collidesWithEnvelope(out) ? { __plainObject: out } : out;
     }
     if (typeof v === 'function' && v.__pkgHandlePromise) {
       return undefined;
     }
     return JSON.parse(JSON.stringify(v));
   }
-  catch { return null; }
+  catch (error) {
+    if (
+      error?.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT'
+      || error?.code === 'ERR_EXECUTION_ABORTED'
+    ) {
+      throw error;
+    }
+    return null;
+  }
   finally {
     if (tracked) seen.delete(v);
   }
@@ -377,6 +798,7 @@ async function __safeClone(v, seen, cyclic) {
 const __ctxChangeProtectedKeys = new Set([
   '$helpers',
   '$cache',
+  '$transaction',
   '$repos',
   '$req',
   '$res',
@@ -386,6 +808,7 @@ const __ctxChangeProtectedKeys = new Set([
   '$throw',
   '$trigger',
   '$pkgs',
+  '$streams',
   '$env',
 ]);
 
@@ -413,42 +836,294 @@ async function __extractResult(result, isAbsent) {
 
 const __throwDefaults = { 400: 'Bad request', 401: 'Unauthorized', 403: 'Forbidden', 404: 'Not found', 409: 'Conflict', 422: 'Validation failed', 429: 'Too many requests', 500: 'Internal server error', 503: 'Service unavailable' };
 
-if (typeof TextEncoder === 'undefined') {
+`});var nt=A((On,rt)=>{"use strict";rt.exports=`if (typeof TextEncoder === 'undefined') {
   globalThis.TextEncoder = class TextEncoder {
+    get encoding() { return 'utf-8'; }
+
     encode(input = '') {
-      const encoded = unescape(encodeURIComponent(String(input)));
-      const out = new Uint8Array(encoded.length);
-      for (let i = 0; i < encoded.length; i++) out[i] = encoded.charCodeAt(i);
-      return out;
+      const text = String(input);
+      const bytes = [];
+      for (let i = 0; i < text.length; i++) {
+        let codePoint = text.charCodeAt(i);
+        if (codePoint >= 0xd800 && codePoint <= 0xdbff) {
+          const next = text.charCodeAt(i + 1);
+          if (next >= 0xdc00 && next <= 0xdfff) {
+            codePoint = 0x10000 + ((codePoint - 0xd800) << 10) + (next - 0xdc00);
+            i++;
+          } else {
+            codePoint = 0xfffd;
+          }
+        } else if (codePoint >= 0xdc00 && codePoint <= 0xdfff) {
+          codePoint = 0xfffd;
+        }
+        if (codePoint <= 0x7f) {
+          bytes.push(codePoint);
+        } else if (codePoint <= 0x7ff) {
+          bytes.push(0xc0 | (codePoint >> 6), 0x80 | (codePoint & 0x3f));
+        } else if (codePoint <= 0xffff) {
+          bytes.push(
+            0xe0 | (codePoint >> 12),
+            0x80 | ((codePoint >> 6) & 0x3f),
+            0x80 | (codePoint & 0x3f),
+          );
+        } else {
+          bytes.push(
+            0xf0 | (codePoint >> 18),
+            0x80 | ((codePoint >> 12) & 0x3f),
+            0x80 | ((codePoint >> 6) & 0x3f),
+            0x80 | (codePoint & 0x3f),
+          );
+        }
+      }
+      return Uint8Array.from(bytes);
+    }
+
+    encodeInto(input = '', destination) {
+      if (!(destination instanceof Uint8Array)) {
+        throw new TypeError('TextEncoder.encodeInto requires a Uint8Array destination');
+      }
+      const text = String(input);
+      let read = 0;
+      let written = 0;
+      for (const character of text) {
+        const encoded = this.encode(character);
+        if (written + encoded.byteLength > destination.byteLength) break;
+        destination.set(encoded, written);
+        written += encoded.byteLength;
+        read += character.length;
+      }
+      return { read, written };
     }
   };
 }
 
 if (typeof TextDecoder === 'undefined') {
   globalThis.TextDecoder = class TextDecoder {
-    constructor() {
+    constructor(label = 'utf-8', options = {}) {
+      const normalizedLabel = String(label)
+        .replace(/^[\\t\\n\\f\\r ]+|[\\t\\n\\f\\r ]+$/g, '')
+        .toLowerCase();
+      if (![
+        'utf-8',
+        'utf8',
+        'unicode-1-1-utf-8',
+        'unicode11utf8',
+        'unicode20utf8',
+        'x-unicode20utf8',
+      ].includes(normalizedLabel)) {
+        throw new RangeError('Unsupported TextDecoder encoding: ' + label);
+      }
+      const normalizedOptions = options == null ? {} : options;
       this.__pending = new Uint8Array();
+      this.__fatal = Boolean(normalizedOptions.fatal);
+      this.__ignoreBOM = Boolean(normalizedOptions.ignoreBOM);
+      this.__atStart = true;
     }
 
+    get encoding() { return 'utf-8'; }
+    get fatal() { return this.__fatal; }
+    get ignoreBOM() { return this.__ignoreBOM; }
+
     decode(input = new Uint8Array(), options = {}) {
+      const normalizedOptions = options == null ? {} : options;
+      const stream = Boolean(normalizedOptions.stream);
+      if (!(input instanceof ArrayBuffer) && !ArrayBuffer.isView(input)) {
+        throw new TypeError('TextDecoder.decode requires an ArrayBuffer or ArrayBuffer view');
+      }
       const source = ArrayBuffer.isView(input) ? input : new Uint8Array(input);
       const bytes = new Uint8Array(this.__pending.length + source.byteLength);
       bytes.set(this.__pending);
-      bytes.set(new Uint8Array(source.buffer, source.byteOffset, source.byteLength), this.__pending.length);
-      let completeLength = bytes.length;
-      if (options.stream) {
-        let leadIndex = bytes.length - 1;
-        while (leadIndex >= 0 && bytes[leadIndex] >= 0x80 && bytes[leadIndex] <= 0xbf) leadIndex--;
-        if (leadIndex >= 0) {
-          const lead = bytes[leadIndex];
-          const expectedLength = lead >= 0xf0 ? 4 : lead >= 0xe0 ? 3 : lead >= 0xc0 ? 2 : 1;
-          if (expectedLength > bytes.length - leadIndex) completeLength = leadIndex;
+      bytes.set(
+        new Uint8Array(source.buffer, source.byteOffset, source.byteLength),
+        this.__pending.length,
+      );
+      const output = [];
+      const emitReplacement = () => {
+        if (this.__fatal) {
+          if (!stream) { this.__pending = new Uint8Array(); this.__atStart = true; }
+          throw new TypeError('The encoded data was not valid UTF-8');
+        }
+        output.push('\uFFFD');
+        this.__atStart = false;
+      };
+      let index = 0;
+      while (index < bytes.length) {
+        const first = bytes[index];
+        let expectedLength = 0;
+        let codePoint = 0;
+        let minimum = 0;
+        if (first <= 0x7f) {
+          codePoint = first;
+          expectedLength = 1;
+        } else if (first >= 0xc2 && first <= 0xdf) {
+          expectedLength = 2;
+          codePoint = first & 0x1f;
+          minimum = 0x80;
+        } else if (first >= 0xe0 && first <= 0xef) {
+          expectedLength = 3;
+          codePoint = first & 0x0f;
+          minimum = 0x800;
+        } else if (first >= 0xf0 && first <= 0xf4) {
+          expectedLength = 4;
+          codePoint = first & 0x07;
+          minimum = 0x10000;
+        } else {
+          emitReplacement();
+          index++;
+          continue;
+        }
+        let availableLength = Math.min(expectedLength, bytes.length - index);
+        let validPrefixLength = 1;
+        let validPrefix = true;
+        for (let offset = 1; offset < availableLength; offset++) {
+          const continuation = bytes[index + offset];
+          if (continuation < 0x80 || continuation > 0xbf || (offset === 1 && (
+            (first === 0xe0 && continuation < 0xa0)
+            || (first === 0xed && continuation > 0x9f)
+            || (first === 0xf0 && continuation < 0x90)
+            || (first === 0xf4 && continuation > 0x8f)
+          ))) {
+            validPrefix = false;
+            break;
+          }
+          validPrefixLength++;
+        }
+        if (!validPrefix) {
+          emitReplacement();
+          index += validPrefixLength;
+          continue;
+        }
+        const second = availableLength > 1 ? bytes[index + 1] : 0;
+        if (
+          availableLength > 1
+          && (
+            (first === 0xe0 && second < 0xa0)
+            || (first === 0xed && second > 0x9f)
+            || (first === 0xf0 && second < 0x90)
+            || (first === 0xf4 && second > 0x8f)
+          )
+        ) {
+          emitReplacement();
+          index++;
+          continue;
+        }
+        if (availableLength < expectedLength) {
+          if (stream) break;
+          emitReplacement();
+          index += availableLength;
+          continue;
         }
+        for (let offset = 1; offset < expectedLength; offset++) {
+          codePoint = (codePoint << 6) | (bytes[index + offset] & 0x3f);
+        }
+        if (
+          codePoint < minimum
+          || codePoint > 0x10ffff
+          || (codePoint >= 0xd800 && codePoint <= 0xdfff)
+        ) {
+          emitReplacement();
+          index++;
+          continue;
+        }
+        if (!(this.__atStart && !this.__ignoreBOM && codePoint === 0xfeff)) {
+          output.push(String.fromCodePoint(codePoint));
+        }
+        this.__atStart = false;
+        index += expectedLength;
       }
-      let binary = '';
-      for (let i = 0; i < completeLength; i++) binary += String.fromCharCode(bytes[i]);
-      this.__pending = options.stream ? bytes.slice(completeLength) : new Uint8Array();
-      return decodeURIComponent(escape(binary));
+      this.__pending = stream
+        ? bytes.slice(index)
+        : new Uint8Array();
+      if (!stream) this.__atStart = true;
+      return output.join('');
+    }
+  };
+}
+
+`});var ot=A((In,at)=>{"use strict";at.exports=`const __blobStates = new WeakMap();
+const __fallbackFiles = new WeakSet();
+
+function __normalizeBlobType(value) {
+  const text = String(value === undefined ? '' : value);
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    if (code < 0x20 || code > 0x7e) return '';
+  }
+  return text.toLowerCase();
+}
+
+if (typeof Blob === 'undefined') {
+  globalThis.Blob = class Blob {
+    constructor(parts = [], options = {}) {
+      const chunks = [];
+      let totalBytes = 0;
+      for (const part of parts) {
+        let bytes;
+        if (part instanceof Blob) {
+          bytes = __blobStates.get(part).bytes;
+        } else if (part instanceof ArrayBuffer) {
+          bytes = new Uint8Array(part);
+        } else if (ArrayBuffer.isView(part)) {
+          bytes = new Uint8Array(part.buffer, part.byteOffset, part.byteLength);
+        } else {
+          bytes = new TextEncoder().encode(String(part));
+        }
+        const snapshot = new Uint8Array(bytes);
+        chunks.push(snapshot);
+        totalBytes += snapshot.byteLength;
+      }
+      const bytes = new Uint8Array(totalBytes);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      __blobStates.set(this, {
+        bytes,
+        type: __normalizeBlobType(options?.type),
+      });
+    }
+
+    get size() {
+      return __blobStates.get(this).bytes.byteLength;
+    }
+
+    get type() {
+      return __blobStates.get(this).type;
+    }
+
+    async arrayBuffer() {
+      return new Uint8Array(__blobStates.get(this).bytes).buffer;
+    }
+
+    async text() {
+      return new TextDecoder('utf-8').decode(__blobStates.get(this).bytes);
+    }
+
+    slice(start = 0, end = this.size, contentType = '') {
+      const size = this.size;
+      const normalizeIndex = (value, fallback) => {
+        const number = Number(value);
+        if (Number.isNaN(number)) return 0;
+        if (number === Infinity) return size;
+        if (number === -Infinity) return 0;
+        const integer = Math.trunc(number);
+        return integer < 0
+          ? Math.max(size + integer, 0)
+          : Math.min(integer, size);
+      };
+      const relativeStart = normalizeIndex(start, 0);
+      const relativeEnd = normalizeIndex(end, size);
+      const span = Math.max(relativeEnd - relativeStart, 0);
+      const bytes = __blobStates.get(this).bytes.slice(
+        relativeStart,
+        relativeStart + span,
+      );
+      return new Blob([bytes], { type: contentType });
+    }
+
+    get [Symbol.toStringTag]() {
+      return 'Blob';
     }
   };
 }
@@ -459,8 +1134,41 @@ if (typeof FormData === 'undefined') {
       this.__entries = [];
     }
 
-    append(name, value) {
-      this.__entries.push([String(name), value]);
+    __normalizeValue(value, filename) {
+      const isBlob = typeof Blob !== 'undefined' && value instanceof Blob;
+      if (filename !== undefined && !isBlob) {
+        throw new TypeError('FormData filename requires a Blob value');
+      }
+      if (!isBlob) return String(value);
+      const resolvedFilename = filename === undefined ? 'blob' : String(filename);
+      if (typeof File !== 'undefined') {
+        if (value instanceof File && filename === undefined) return value;
+        return new File([value], resolvedFilename, { type: value.type });
+      }
+      if (filename === undefined && __fallbackFiles.has(value)) return value;
+      const blob = new Blob([value], { type: value.type });
+      __fallbackFiles.add(blob);
+      __defineDataProperty(blob, 'name', resolvedFilename);
+      __defineDataProperty(
+        blob,
+        'lastModified',
+        value.lastModified === undefined ? 0 : value.lastModified,
+      );
+      return blob;
+    }
+
+    append(name, value, filename) {
+      this.__entries.push([
+        String(name),
+        this.__normalizeValue(value, filename),
+      ]);
+    }
+
+    delete(name) {
+      const key = String(name);
+      for (let index = this.__entries.length - 1; index >= 0; index--) {
+        if (this.__entries[index][0] === key) this.__entries.splice(index, 1);
+      }
     }
 
     get(name) {
@@ -469,8 +1177,51 @@ if (typeof FormData === 'undefined') {
       return match ? match[1] : null;
     }
 
-    entries() {
-      return this.__entries[Symbol.iterator]();
+    getAll(name) {
+      const key = String(name);
+      return this.__entries
+        .filter(([entryName]) => entryName === key)
+        .map(([, value]) => value);
+    }
+
+    has(name) {
+      const key = String(name);
+      return this.__entries.some(([entryName]) => entryName === key);
+    }
+
+    set(name, value, filename) {
+      const key = String(name);
+      const normalized = this.__normalizeValue(value, filename);
+      const next = [];
+      let replaced = false;
+      for (const entry of this.__entries) {
+        if (entry[0] !== key) next.push(entry);
+        else if (!replaced) {
+          next.push([key, normalized]);
+          replaced = true;
+        }
+      }
+      if (!replaced) next.push([key, normalized]);
+      this.__entries.length = 0;
+      for (const entry of next) this.__entries.push(entry);
+    }
+
+    *entries() {
+      for (const [key, value] of this.__entries) yield [key, value];
+    }
+
+    *keys() {
+      for (const [key] of this.__entries) yield key;
+    }
+
+    *values() {
+      for (const [, value] of this.__entries) yield value;
+    }
+
+    forEach(callback, thisArg) {
+      for (const [key, value] of this.__entries) {
+        callback.call(thisArg, value, key, this);
+      }
     }
 
     [Symbol.iterator]() {
@@ -479,38 +1230,216 @@ if (typeof FormData === 'undefined') {
   };
 }
 
+`});var it=A((Un,st)=>{"use strict";st.exports=`function __decodeFormComponent(value) {
+  const text = String(value).replace(/\\+/g, ' ');
+  const bytes = [];
+  for (let index = 0; index < text.length;) {
+    if (
+      text[index] === '%'
+      && /^[0-9A-Fa-f]{2}$/.test(text.slice(index + 1, index + 3))
+    ) {
+      bytes.push(parseInt(text.slice(index + 1, index + 3), 16));
+      index += 3;
+      continue;
+    }
+    const codePoint = text.codePointAt(index);
+    const encoded = new TextEncoder().encode(String.fromCodePoint(codePoint));
+    bytes.push(...encoded);
+    index += codePoint > 0xffff ? 2 : 1;
+  }
+  return new TextDecoder('utf-8', { ignoreBOM: true }).decode(Uint8Array.from(bytes));
+}
+
+function __toUSVString(value) {
+  const text = String(value);
+  let output = '';
+  for (let index = 0; index < text.length; index++) {
+    const codeUnit = text.charCodeAt(index);
+    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+      const next = text.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        output += text[index] + text[index + 1];
+        index++;
+      } else {
+        output += '\uFFFD';
+      }
+    } else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+      output += '\uFFFD';
+    } else {
+      output += text[index];
+    }
+  }
+  return output;
+}
+
+function __encodeFormComponent(value) {
+  return encodeURIComponent(__toUSVString(value))
+    .replace(/[!'()~]/g, (character) =>
+      '%' + character.charCodeAt(0).toString(16).toUpperCase(),
+    )
+    .replace(/%20/g, '+');
+}
+
 if (typeof URLSearchParams === 'undefined') {
   globalThis.URLSearchParams = class URLSearchParams {
-    constructor(input = '') {
+    constructor(input = '', onChange) {
       this.__entries = [];
-      const inputText = String(input);
+      this.__onChange = typeof onChange === 'function' ? onChange : null;
+      if (input && typeof input !== 'string' && typeof input[Symbol.iterator] === 'function') {
+        for (const entry of input) {
+          if (!entry || typeof entry[Symbol.iterator] !== 'function') {
+            throw new TypeError('URLSearchParams entry must be iterable');
+          }
+          const pair = Array.from(entry);
+          if (pair.length !== 2) {
+            throw new TypeError('URLSearchParams entry must contain two values');
+          }
+          this.__entries.push([
+            __toUSVString(pair[0]),
+            __toUSVString(pair[1]),
+          ]);
+        }
+        return;
+      }
+      if (input && typeof input === 'object') {
+        for (const [key, value] of Object.entries(input)) {
+          this.__entries.push([
+            __toUSVString(key),
+            __toUSVString(value),
+          ]);
+        }
+        return;
+      }
+      const inputText = input === null ? '' : String(input);
       const text = inputText.startsWith('?') ? inputText.slice(1) : inputText;
       if (!text) return;
       for (const part of text.split('&')) {
         if (!part) continue;
-        const [key, value = ''] = part.split('=');
-        this.append(decodeURIComponent(key), decodeURIComponent(value));
+        const separator = part.indexOf('=');
+        const key = separator >= 0 ? part.slice(0, separator) : part;
+        const value = separator >= 0 ? part.slice(separator + 1) : '';
+        this.__entries.push([
+          __decodeFormComponent(key),
+          __decodeFormComponent(value),
+        ]);
       }
     }
 
-    append(name, value) {
-      this.__entries.push([String(name), String(value)]);
+    __changed() {
+      this.__onChange?.(this.toString());
+    }
+
+    __setChangeHandler(handler) {
+      this.__onChange = typeof handler === 'function' ? handler : null;
+    }
+
+    append(name, value) {
+      this.__entries.push([
+        __toUSVString(name),
+        __toUSVString(value),
+      ]);
+      this.__changed();
+    }
+
+    delete(name, value) {
+      const key = __toUSVString(name);
+      const normalizedValue = value === undefined ? null : __toUSVString(value);
+      for (let index = this.__entries.length - 1; index >= 0; index--) {
+        const [entryName, entryValue] = this.__entries[index];
+        if (
+          entryName === key
+          && (normalizedValue === null || entryValue === normalizedValue)
+        ) {
+          this.__entries.splice(index, 1);
+        }
+      }
+      this.__changed();
+    }
+
+    set(name, value) {
+      const key = __toUSVString(name);
+      const normalizedValue = __toUSVString(value);
+      const next = [];
+      let replaced = false;
+      for (const entry of this.__entries) {
+        if (entry[0] !== key) {
+          next.push(entry);
+        } else if (!replaced) {
+          next.push([key, normalizedValue]);
+          replaced = true;
+        }
+      }
+      if (!replaced) next.push([key, normalizedValue]);
+      this.__entries.length = 0;
+      for (const entry of next) this.__entries.push(entry);
+      this.__changed();
+    }
+
+    get(name) {
+      const key = __toUSVString(name);
+      const match = this.__entries.find(([entryName]) => entryName === key);
+      return match ? match[1] : null;
+    }
+
+    getAll(name) {
+      const key = __toUSVString(name);
+      return this.__entries
+        .filter(([entryName]) => entryName === key)
+        .map(([, value]) => value);
+    }
+
+    has(name, value) {
+      const key = __toUSVString(name);
+      const normalizedValue = value === undefined ? null : __toUSVString(value);
+      return this.__entries.some(([entryName, entryValue]) =>
+        entryName === key
+        && (normalizedValue === null || entryValue === normalizedValue),
+      );
+    }
+
+    sort() {
+      const sorted = this.__entries
+        .map((entry, index) => ({ entry, index }))
+        .sort((left, right) => {
+          let order = 0;
+          if (left.entry[0] < right.entry[0]) order = -1;
+          else if (left.entry[0] > right.entry[0]) order = 1;
+          return order || left.index - right.index;
+        })
+        .map(({ entry }) => entry);
+      this.__entries.length = 0;
+      for (const entry of sorted) this.__entries.push(entry);
+      this.__changed();
     }
 
-    get(name) {
-      const key = String(name);
-      const match = this.__entries.find(([entryName]) => entryName === key);
-      return match ? match[1] : null;
+    get size() {
+      return this.__entries.length;
     }
 
     toString() {
       return this.__entries
-        .map(([key, value]) => encodeURIComponent(key) + '=' + encodeURIComponent(value))
+        .map(([key, value]) =>
+          __encodeFormComponent(key) + '=' + __encodeFormComponent(value),
+        )
         .join('&');
     }
 
-    entries() {
-      return this.__entries[Symbol.iterator]();
+    *entries() {
+      for (const [key, value] of this.__entries) yield [key, value];
+    }
+
+    *keys() {
+      for (const [key] of this.__entries) yield key;
+    }
+
+    *values() {
+      for (const [, value] of this.__entries) yield value;
+    }
+
+    forEach(callback, thisArg) {
+      for (const [key, value] of this.__entries) {
+        callback.call(thisArg, value, key, this);
+      }
     }
 
     [Symbol.iterator]() {
@@ -519,49 +1448,176 @@ if (typeof URLSearchParams === 'undefined') {
   };
 }
 
+`});var ct=A(($n,lt)=>{"use strict";lt.exports=`function __parseNativeUrl(input, base, mutation) {
+  const result = __urlParseRef.applySync(
+    undefined,
+    [
+      String(input),
+      base === undefined ? undefined : String(base),
+      mutation ? JSON.stringify(mutation) : null,
+    ],
+    { arguments: { copy: true }, result: { copy: true } },
+  );
+  return JSON.parse(result);
+}
+
+const __urlStates = new WeakMap();
+const __urlSearchParamsOwners = new WeakMap();
+if (typeof URL === 'undefined' && typeof URLSearchParams.prototype.__setChangeHandler !== 'function') {
+  for (const method of ['append', 'delete', 'set', 'sort']) {
+    const intrinsic = URLSearchParams.prototype[method];
+    Object.defineProperty(URLSearchParams.prototype, method, {
+      value: function (...args) {
+        const result = intrinsic.apply(this, args);
+        const record = __urlSearchParamsOwners.get(this);
+        if (record && !record.muted) {
+          const serialized = record.serializeIntrinsic();
+          record.state = __parseNativeUrl(record.state.href, undefined, {
+            property: 'search', value: serialized ? '?' + serialized : '',
+          });
+          record.paramsSerialized = serialized;
+        }
+        return result;
+      }, writable: true, configurable: true,
+    });
+  }
+}
+
+function __getUrlState(url) {
+  const record = __urlStates.get(url);
+  if (!record) throw new TypeError('Illegal URL invocation');
+  return record;
+}
+
+function __replaceUrlSearchParams(url, search) {
+  const record = __getUrlState(url);
+  record.muted = true;
+  try {
+    const keys = Array.from(new Set(record.target.keys()));
+    for (const key of keys) record.deleteIntrinsic(key);
+    for (const [key, value] of new URLSearchParams(search)) {
+      record.appendIntrinsic(key, value);
+    }
+  } finally {
+    record.muted = false;
+  }
+  record.paramsSerialized = record.serializeIntrinsic();
+}
+
+function __syncUrlSearchParams(url) {
+  const record = __getUrlState(url);
+  if (record.muted) return record;
+  const serialized = record.serializeIntrinsic();
+  if (record.paramsSerialized !== serialized) {
+    const search = serialized ? '?' + serialized : '';
+    record.state = __parseNativeUrl(record.state.href, undefined, {
+      property: 'search',
+      value: search,
+    });
+    record.paramsSerialized = serialized;
+  }
+  return record;
+}
+
+function __applyUrlMutation(url, property, value) {
+  const record = __syncUrlSearchParams(url);
+  record.state = __parseNativeUrl(record.state.href, undefined, {
+    property,
+    value: __toUSVString(value),
+  });
+  __replaceUrlSearchParams(url, record.state.search);
+}
+
 if (typeof URL === 'undefined') {
   globalThis.URL = class URL {
-    constructor(input) {
-      this.href = String(input);
-      const schemeIndex = this.href.indexOf('://');
-      if (schemeIndex >= 0) {
-        const hostStart = schemeIndex + 3;
-        const hostEndCandidates = ['/', '?', '#']
-          .map((token) => this.href.indexOf(token, hostStart))
-          .filter((index) => index >= 0);
-        const hostEnd = hostEndCandidates.length ? Math.min(...hostEndCandidates) : this.href.length;
-        this.host = this.href.slice(hostStart, hostEnd);
+    constructor(input, base) {
+      const state = __parseNativeUrl(input, base);
+      const target = new URLSearchParams();
+      const record = {
+        state,
+        target,
+        muted: false,
+        paramsSerialized: '',
+        deleteIntrinsic: target.delete.bind(target),
+        appendIntrinsic: target.append.bind(target),
+        serializeIntrinsic: target.toString.bind(target),
+      };
+      __urlStates.set(this, record);
+      if (typeof target.__setChangeHandler === 'function') {
+        target.__setChangeHandler((serialized) => {
+          if (record.muted) return;
+          record.state = __parseNativeUrl(record.state.href, undefined, {
+            property: 'search',
+            value: serialized ? '?' + serialized : '',
+          });
+          record.paramsSerialized = serialized;
+        });
       } else {
-        this.host = '';
+        __urlSearchParamsOwners.set(target, record);
       }
-      const query = this.href.includes('?') ? this.href.slice(this.href.indexOf('?') + 1).split('#')[0] : '';
-      this.search = query ? '?' + query : '';
-      this.searchParams = new URLSearchParams(query);
+      Object.defineProperty(this, 'searchParams', {
+        value: target,
+        writable: false,
+        configurable: false,
+        enumerable: true,
+      });
+      __replaceUrlSearchParams(this, state.search);
     }
 
-    toString() {
-      return this.href;
+    get href() { return __syncUrlSearchParams(this).state.href; }
+    set href(value) {
+      const record = __getUrlState(this);
+      record.state = __parseNativeUrl(value, undefined);
+      __replaceUrlSearchParams(this, record.state.search);
     }
+    get origin() { return __syncUrlSearchParams(this).state.origin; }
+    get protocol() { return __syncUrlSearchParams(this).state.protocol; }
+    set protocol(value) { __applyUrlMutation(this, 'protocol', value); }
+    get username() { return __syncUrlSearchParams(this).state.username; }
+    set username(value) { __applyUrlMutation(this, 'username', value); }
+    get password() { return __syncUrlSearchParams(this).state.password; }
+    set password(value) { __applyUrlMutation(this, 'password', value); }
+    get host() { return __syncUrlSearchParams(this).state.host; }
+    set host(value) { __applyUrlMutation(this, 'host', value); }
+    get hostname() { return __syncUrlSearchParams(this).state.hostname; }
+    set hostname(value) { __applyUrlMutation(this, 'hostname', value); }
+    get port() { return __syncUrlSearchParams(this).state.port; }
+    set port(value) { __applyUrlMutation(this, 'port', value); }
+    get pathname() { return __syncUrlSearchParams(this).state.pathname; }
+    set pathname(value) { __applyUrlMutation(this, 'pathname', value); }
+    get search() { return __syncUrlSearchParams(this).state.search; }
+    set search(value) { __applyUrlMutation(this, 'search', value); }
+    get hash() { return __syncUrlSearchParams(this).state.hash; }
+    set hash(value) { __applyUrlMutation(this, 'hash', value); }
+
+    toString() { return this.href; }
+    toJSON() { return this.href; }
   };
 }
 
-function __createPkgHandleProxy(handlePromise, path) {
-  const fn = function (...args) {
-    return __createAsyncPkgResultProxy(
-      handlePromise.then((handleId) =>
-        __stringifyRuntimeArgs(args).then((argsJson) =>
-          __call('pkgCall', __encodePkgCallPayload({ handleId, path, argsJson, kind: 'call' })),
-        ),
-      ),
-      [],
-    );
-  };
+`});var dt=A((Bn,ut)=>{"use strict";ut.exports=`function __createPkgHandleProxy(handlePromise, path) {
+  // The handle promise is created eagerly by the caller, so a script that drops
+  // this proxy without awaiting it would leave the rejection unobserved and V8
+  // would report it against the isolate, failing the next task on the lane.
+  if (handlePromise && typeof handlePromise.catch === 'function') {
+    handlePromise.catch(() => {});
+  }
+  const fn = () => {};
   return new Proxy(fn, {
     get: (_, prop) => {
+      if (prop === Symbol.asyncIterator) {
+        return () => __createPkgStreamIterator(
+          handlePromise.then((handleId) => ({ handleId, path })),
+        );
+      }
       if (typeof prop === 'symbol') return undefined;
       if (prop === 'then') return undefined;
+      if (prop === '$property') {
+        return (key) => __createPkgHandleProxy(handlePromise, path.concat(key));
+      }
       if (prop === '__pkgHandle') return undefined;
       if (prop === '__pkgHandlePromise') return handlePromise;
+      if (prop === '__pkgHandlePath') return path;
       if (prop === '__enfyraLocalReadable') return undefined;
       return __createAsyncPkgResultProxy(
         handlePromise.then((handleId) =>
@@ -586,12 +1642,16 @@ function __createPkgHandleProxy(handlePromise, path) {
   });
 }
 
+function __formatResultPath(path) {
+  return path.map((key) => String(key)).join('.');
+}
+
 function __resolvePkgResultPath(base, path) {
   let current = base;
   let receiver = undefined;
   for (const key of path) {
     if (current === undefined || current === null) {
-      throw new Error('Package result property not found: ' + path.join('.'));
+      throw new Error('Package result property not found: ' + __formatResultPath(path));
     }
     receiver = current;
     current = current[key];
@@ -600,26 +1660,35 @@ function __resolvePkgResultPath(base, path) {
 }
 
 function __createAsyncPkgResultProxy(valuePromise, path) {
+  // Same reason as the main-result proxy: the host call behind this proxy is
+  // issued eagerly, so a script that drops the proxy without reading it would
+  // leave the rejection unobserved and V8 would report it against the isolate,
+  // failing whichever task runs next on the lane.
+  if (valuePromise && typeof valuePromise.catch === 'function') {
+    valuePromise.catch(() => {});
+  }
   const resolveValue = () => valuePromise.then(__wrapPkgValue);
   const resolvePath = () =>
     resolveValue().then((base) => __resolvePkgResultPath(base, path));
   const promiseForPath = () =>
     path.length === 0 ? resolveValue() : resolvePath().then(({ target }) => target);
 
-  const fn = function (...args) {
-    return __createAsyncPkgResultProxy(
-      resolvePath().then(({ target, receiver }) => {
-        if (typeof target !== 'function') {
-          throw new Error('Package result is not callable: ' + (path.join('.') || '<root>'));
-        }
-        return Reflect.apply(target, receiver, args);
-      }),
-      [],
-    );
-  };
+  const fn = () => {};
 
   return new Proxy(fn, {
     get: (_target, prop) => {
+      if (prop === Symbol.asyncIterator) {
+        return () => __createPkgStreamIterator(
+          promiseForPath().then(async (value) => {
+            const handlePromise = value && value.__pkgHandlePromise;
+            if (!handlePromise) throw new Error('Package result is not an async iterable');
+            return {
+              handleId: await handlePromise,
+              path: value.__pkgHandlePath || [],
+            };
+          }),
+        );
+      }
       if (typeof prop === 'symbol') return undefined;
       if (prop === '__pkgHandle') return undefined;
       if (prop === '__enfyraLocalReadable') return undefined;
@@ -646,13 +1715,19 @@ function __createAsyncPkgResultProxy(valuePromise, path) {
         const promise = promiseForPath();
         return promise.finally.bind(promise);
       }
+      if (prop === '$property') {
+        return (key) => __createAsyncPkgResultProxy(
+          valuePromise,
+          path.concat(key),
+        );
+      }
       return __createAsyncPkgResultProxy(valuePromise, path.concat(String(prop)));
     },
     apply: (_target, _thisArg, args) =>
       __createAsyncPkgResultProxy(
         resolvePath().then(({ target, receiver }) => {
           if (typeof target !== 'function') {
-            throw new Error('Package result is not callable: ' + (path.join('.') || '<root>'));
+            throw new Error('Package result is not callable: ' + (__formatResultPath(path) || '<root>'));
           }
           return Reflect.apply(target, receiver, args);
         }),
@@ -661,24 +1736,536 @@ function __createAsyncPkgResultProxy(valuePromise, path) {
   });
 }
 
-function __createAsyncMainResultProxy(valuePromise, path) {
+`});var _t=A((Dn,ft)=>{"use strict";ft.exports=`const __pkgStreamNextWithTimeout = Symbol('enfyra.packageStreamNextWithTimeout');
+const __trustedStreamCleanupIterators = new WeakSet();
+
+function __createPackageStreamError(message, code, details) {
+  const error = new Error(message);
+  if (code) error.code = code;
+  if (details !== undefined) error.details = details;
+  return error;
+}
+
+function __unwrapPackageStreamResult(result) {
+  if (result && result.__pkgStreamError) {
+    const payload = result.__pkgStreamError;
+    throw __createPackageStreamError(payload.message, payload.code, payload.details);
+  }
+  return result;
+}
+
+function __createPkgStreamIterator(descriptorPromise) {
+  let sessionPromise = null;
+  let cleanupPromise = null;
+  let closed = false;
+  let pending = false;
+
+  const call = async (method, data) => {
+    const result = await __call('pkgStreamCall', JSON.stringify({
+      method,
+      ...(data || {}),
+      timeoutMs: __innerGuardTimeoutMs(),
+    }));
+    return __unwrapPackageStreamResult(result);
+  };
+  const open = () => {
+    if (!sessionPromise) {
+      sessionPromise = descriptorPromise.then(({ handleId, path }) =>
+        call('open', { handleId, path: path || [] }).then((value) => value.streamId),
+      );
+    }
+    return sessionPromise;
+  };
+
+  const iterator = {
+    async next() {
+      return iterator[__pkgStreamNextWithTimeout]();
+    },
+    async [__pkgStreamNextWithTimeout](timeoutMs) {
+      if (closed) return { done: true, value: undefined };
+      if (pending) {
+        throw __createPackageStreamError(
+          'Concurrent package stream next() calls are not supported',
+          'ERR_PACKAGE_STREAM_CONCURRENT_NEXT',
+        );
+      }
+      pending = true;
+      try {
+        const streamId = await open();
+        if (closed) return { done: true, value: undefined };
+        const result = await call('next', {
+          streamId,
+          streamTimeoutMs: timeoutMs,
+        });
+        if (closed || result.done) {
+          closed = true;
+          return { done: true, value: undefined };
+        }
+        return { done: false, value: __base64ToBytes(result.chunk) };
+      } catch (error) {
+        try { await iterator.return(); } catch {}
+        throw error;
+      } finally {
+        pending = false;
+      }
+    },
+    return() {
+      if (cleanupPromise) return cleanupPromise;
+      closed = true;
+      cleanupPromise = sessionPromise
+        ? sessionPromise.then(
+            (streamId) => call('return', { streamId }),
+            () => undefined,
+          ).then(() => ({ done: true, value: undefined }))
+        : Promise.resolve({ done: true, value: undefined });
+      cleanupPromise.catch(() => {});
+      return cleanupPromise;
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+  __trustedStreamCleanupIterators.add(iterator);
+  return iterator;
+}
+
+function __getStreamIterator(readable) {
+  const iteratorMethod = readable?.[Symbol.asyncIterator];
+  if (typeof iteratorMethod !== 'function') {
+    throw new Error('$streams requires an async iterable readable stream');
+  }
+  return iteratorMethod.call(readable);
+}
+
+function __requestStreamReturn(iterator) {
+  try {
+    const result = iterator?.return?.();
+    if (result && typeof result.catch === 'function') result.catch(() => {});
+  } catch {}
+}
+
+async function __closeStreamIterator(iterator) {
+  const returnMethod = iterator?.return;
+  if (typeof returnMethod !== 'function') return;
+  if (__trustedStreamCleanupIterators.has(iterator)) {
+    try { await returnMethod.call(iterator); } catch {}
+    return;
+  }
+  __requestStreamReturn(iterator);
+}
+
+function __normalizeStreamOptions(options) {
+  const requestedTimeoutMs = Number(options?.timeoutMs);
+  const timeoutMs = Number.isFinite(requestedTimeoutMs)
+    ? Math.max(1, Math.trunc(requestedTimeoutMs))
+    : 30000;
+  const requestedIdleTimeoutMs = Number(options?.idleTimeoutMs);
+  const idleTimeoutMs = Number.isFinite(requestedIdleTimeoutMs) && requestedIdleTimeoutMs > 0
+    ? Math.max(1, Math.trunc(requestedIdleTimeoutMs))
+    : null;
+  const requestedMaxBytes = Number(options?.maxBytes);
+  const maxBytes = Number.isFinite(requestedMaxBytes) && requestedMaxBytes > 0
+    ? Math.max(1, Math.trunc(requestedMaxBytes))
+    : 8 * 1024 * 1024;
+  return { timeoutMs, idleTimeoutMs, maxBytes };
+}
+
+function __streamTimeoutError(timeoutMs, details) {
+  return __createPackageStreamError(
+    'Package stream timed out after ' + Math.max(1, Math.trunc(timeoutMs)) + 'ms',
+    'ERR_PACKAGE_STREAM_TIMEOUT',
+    { streamScoped: true, retryable: true, ...(details || {}) },
+  );
+}
+
+async function __waitForStreamTimer(timerId, timeoutMs) {
+  return await __streamTimerRef.apply(
+    undefined,
+    ['wait', timerId, timeoutMs],
+    __applyOpts,
+  );
+}
+
+async function __clearStreamTimer(timerId) {
+  return await __streamTimerRef.apply(
+    undefined,
+    ['clear', timerId, 0],
+    __applyOpts,
+  );
+}
+
+async function __nextStreamChunk(
+  iterator,
+  deadlineMs,
+  idleTimeoutMs,
+  totalTimeoutMs,
+) {
+  const remainingMs = Math.ceil(deadlineMs - __trustedNow());
+  if (remainingMs <= 0) {
+    throw __streamTimeoutError(totalTimeoutMs, { timeoutKind: 'total' });
+  }
+  const nextTimeoutMs = Math.min(
+    remainingMs,
+    Number.isFinite(idleTimeoutMs) && idleTimeoutMs > 0
+      ? Math.max(1, Math.trunc(idleTimeoutMs))
+      : remainingMs,
+  );
+  const timerId = 'stream_timer_' + (++__streamTimerCounter);
+  try {
+    const result = await Promise.race([
+      Promise.resolve().then(() => typeof iterator[__pkgStreamNextWithTimeout] === 'function'
+        ? iterator[__pkgStreamNextWithTimeout](nextTimeoutMs)
+        : iterator.next()),
+      __waitForStreamTimer(timerId, nextTimeoutMs).then((fired) => {
+        if (!fired) {
+          const error = new Error('Task is no longer active');
+          error.code = 'ERR_EXECUTION_ABORTED';
+          throw error;
+        }
+        throw __streamTimeoutError(
+          nextTimeoutMs < remainingMs ? nextTimeoutMs : totalTimeoutMs,
+          { timeoutKind: nextTimeoutMs < remainingMs ? 'idle' : 'total' },
+        );
+      }),
+    ]);
+    if (__trustedNow() >= deadlineMs) {
+      throw __streamTimeoutError(totalTimeoutMs, { timeoutKind: 'total' });
+    }
+    return result;
+  } catch (error) {
+    __requestStreamReturn(iterator);
+    throw error;
+  } finally {
+    void __clearStreamTimer(timerId).catch(() => {});
+  }
+}
+
+`});var mt=A((Ln,pt)=>{"use strict";pt.exports=`async function __preflightStream(readable, options) {
+  const iterator = __getStreamIterator(readable);
+  const { timeoutMs, idleTimeoutMs } = __normalizeStreamOptions(options);
+  const requestedMaxFirstChunkBytes = Number(options?.maxFirstChunkBytes);
+  const maxFirstChunkBytes = Number.isFinite(requestedMaxFirstChunkBytes)
+    && requestedMaxFirstChunkBytes > 0
+    ? Math.max(1, Math.trunc(requestedMaxFirstChunkBytes))
+    : null;
+  const deadlineMs = __trustedNow() + Math.min(timeoutMs, __innerGuardTimeoutMs());
+  let firstChunk;
+  try {
+    while (firstChunk === undefined) {
+      const next = await __nextStreamChunk(
+        iterator,
+        deadlineMs,
+        idleTimeoutMs,
+        timeoutMs,
+      );
+      if (next.done) {
+        throw __createPackageStreamError(
+          'Package stream ended before yielding bytes',
+          'ERR_PACKAGE_STREAM_EMPTY',
+        );
+      }
+      const bytes = __streamChunkToBytes(next.value);
+      if (bytes.byteLength > 0) {
+        if (maxFirstChunkBytes !== null && bytes.byteLength > maxFirstChunkBytes) {
+          throw __createPackageStreamError(
+            'Package stream first chunk exceeded maxFirstChunkBytes (' + maxFirstChunkBytes + ')',
+            'ERR_PACKAGE_STREAM_MAX_BYTES',
+            { maxBytes: maxFirstChunkBytes, firstChunk: true },
+          );
+        }
+        firstChunk = bytes;
+      }
+    }
+  } catch (error) {
+    await __closeStreamIterator(iterator);
+    throw error;
+  }
+
+  let consumed = false;
+  let closed = false;
+  let cleanupPromise = null;
+  let nextQueue = Promise.resolve();
+  let firstPending = true;
+  const close = () => {
+    if (cleanupPromise) return cleanupPromise;
+    closed = true;
+    cleanupPromise = (async () => {
+      await __closeStreamIterator(iterator);
+      return { done: true, value: undefined };
+    })();
+    return cleanupPromise;
+  };
+  const replayIterator = {
+    next() {
+      const operation = nextQueue.then(async () => {
+        if (closed) return { done: true, value: undefined };
+        if (firstPending) {
+          firstPending = false;
+          return { done: false, value: firstChunk };
+        }
+        try {
+          const next = await __nextStreamChunk(iterator, deadlineMs, idleTimeoutMs, timeoutMs);
+          if (closed || next.done) {
+            closed = true;
+            return { done: true, value: undefined };
+          }
+          return { done: false, value: __streamChunkToBytes(next.value) };
+        } catch (error) {
+          await close();
+          throw error;
+        }
+      });
+      nextQueue = operation.catch(() => {});
+      return operation;
+    },
+    return: close,
+    [Symbol.asyncIterator]() { return this; },
+  };
+  if (__trustedStreamCleanupIterators.has(iterator)) {
+    __trustedStreamCleanupIterators.add(replayIterator);
+  }
+  const stream = {
+    __enfyraLocalReadable: true,
+    __enfyraCancel: close,
+    [Symbol.asyncIterator]() {
+      if (consumed) {
+        throw __createPackageStreamError(
+          'Preflight stream already has a consumer',
+          'ERR_PACKAGE_STREAM_ALREADY_CONSUMED',
+        );
+      }
+      consumed = true;
+      return replayIterator;
+    },
+  };
+  return {
+    stream,
+    firstChunk: new Uint8Array(firstChunk),
+    cancel: close,
+  };
+}
+
+async function __readStream(readable, options, asText) {
+  const iterator = __getStreamIterator(readable);
+  const { timeoutMs, idleTimeoutMs, maxBytes } = __normalizeStreamOptions(options);
+  const deadlineMs = __trustedNow() + Math.min(timeoutMs, __innerGuardTimeoutMs());
+  const chunks = [];
+  const text = [];
+  const decoder = asText ? new TextDecoder('utf-8') : null;
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const next = await __nextStreamChunk(iterator, deadlineMs, idleTimeoutMs, timeoutMs);
+      if (next.done) break;
+      const bytes = __streamChunkToBytes(next.value);
+      if (bytes.byteLength === 0) continue;
+      totalBytes += bytes.byteLength;
+      if (totalBytes > maxBytes) {
+        throw __createPackageStreamError(
+          'Package stream exceeded maxBytes (' + maxBytes + ')',
+          'ERR_PACKAGE_STREAM_MAX_BYTES',
+          { maxBytes },
+        );
+      }
+      if (decoder) {
+        text.push(decoder.decode(bytes, { stream: true }));
+      } else {
+        chunks.push(new Uint8Array(bytes));
+      }
+    }
+  } catch (error) {
+    await __closeStreamIterator(iterator);
+    throw error;
+  }
+  if (decoder) {
+    text.push(decoder.decode());
+    return text.join('');
+  }
+  const output = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
+
+function __guardStream(readable, options) {
+  const { timeoutMs, idleTimeoutMs, maxBytes } = __normalizeStreamOptions(options);
+  let consumed = false;
+  const iterator = __getStreamIterator(readable);
+  let closed = false;
+  let cleanupPromise = null;
+  const close = () => {
+    if (cleanupPromise) return cleanupPromise;
+    closed = true;
+    cleanupPromise = (async () => {
+      await __closeStreamIterator(iterator);
+      return { done: true, value: undefined };
+    })();
+    return cleanupPromise;
+  };
+  return {
+    __enfyraLocalReadable: true,
+    __enfyraCancel: close,
+    [Symbol.asyncIterator]() {
+      if (consumed) {
+        throw __createPackageStreamError(
+          'Guarded stream already has a consumer',
+          'ERR_PACKAGE_STREAM_ALREADY_CONSUMED',
+        );
+      }
+      consumed = true;
+      const deadlineMs = __trustedNow() + Math.min(timeoutMs, __innerGuardTimeoutMs());
+      let totalBytes = 0;
+      let nextQueue = Promise.resolve();
+      const guardedIterator = {
+        next() {
+          const operation = nextQueue.then(async () => {
+            if (closed) return { done: true, value: undefined };
+            try {
+              const next = await __nextStreamChunk(iterator, deadlineMs, idleTimeoutMs, timeoutMs);
+              if (closed || next.done) {
+                closed = true;
+                return { done: true, value: undefined };
+              }
+              const bytes = __streamChunkToBytes(next.value);
+              totalBytes += bytes.byteLength;
+              if (totalBytes > maxBytes) {
+                throw __createPackageStreamError(
+                  'Package stream exceeded maxBytes (' + maxBytes + ')',
+                  'ERR_PACKAGE_STREAM_MAX_BYTES',
+                  { maxBytes },
+                );
+              }
+              return { done: false, value: next.value };
+            } catch (error) {
+              await close();
+              throw error;
+            }
+          });
+          nextQueue = operation.catch(() => {});
+          return operation;
+        },
+        return: close,
+        [Symbol.asyncIterator]() { return this; },
+      };
+      if (__trustedStreamCleanupIterators.has(iterator)) {
+        __trustedStreamCleanupIterators.add(guardedIterator);
+      }
+      return guardedIterator;
+    },
+  };
+}
+
+async function __cancelStream(readable) {
+  if (!readable) return;
+  if (readable.__enfyraLocalReadable && typeof readable.__enfyraCancel === 'function') {
+    await readable.__enfyraCancel();
+    return;
+  }
+  const iterator = __getStreamIterator(readable);
+  await __closeStreamIterator(iterator);
+}
+
+function __tapStream(readable, options) {
+  const onChunk = typeof options?.onChunk === 'function' ? options.onChunk : null;
+  const { timeoutMs } = __normalizeStreamOptions(options);
+  let consumed = false;
+  let closed = false;
+  let cleanupPromise = null;
+  let iterator = null;
+  let totalBytes = 0;
+  let nextQueue = Promise.resolve();
+  const close = () => {
+    if (cleanupPromise) return cleanupPromise;
+    closed = true;
+    cleanupPromise = (async () => {
+      if (iterator) await __closeStreamIterator(iterator);
+      else await __cancelStream(readable);
+      return { done: true, value: undefined };
+    })();
+    return cleanupPromise;
+  };
+  return {
+    __enfyraLocalReadable: true,
+    __enfyraCancel: close,
+    [Symbol.asyncIterator]() {
+      if (consumed) {
+        throw __createPackageStreamError(
+          'Tapped stream already has a consumer',
+          'ERR_PACKAGE_STREAM_ALREADY_CONSUMED',
+        );
+      }
+      consumed = true;
+      if (!closed) {
+        const guarded = __guardStream(readable, options);
+        iterator = __getStreamIterator(guarded);
+      }
+      const deadlineMs = __trustedNow() + Math.min(
+        timeoutMs,
+        __innerGuardTimeoutMs(),
+      );
+      const tappedIterator = {
+        next() {
+          const operation = nextQueue.then(async () => {
+            if (closed) return { done: true, value: undefined };
+            try {
+              const next = await iterator.next();
+              if (closed || next.done) {
+                closed = true;
+                return { done: true, value: undefined };
+              }
+              const bytes = __streamChunkToBytes(next.value);
+              totalBytes += bytes.byteLength;
+              if (onChunk) {
+                await __awaitBeforeDeadline(
+                  onChunk(new Uint8Array(bytes), totalBytes),
+                  deadlineMs,
+                  () => __streamTimeoutError(
+                    timeoutMs,
+                    { timeoutKind: 'total' },
+                  ),
+                );
+              }
+              if (closed) return { done: true, value: undefined };
+              return next;
+            } catch (error) {
+              await close();
+              throw error;
+            }
+          });
+          nextQueue = operation.catch(() => {});
+          return operation;
+        },
+        return: close,
+        [Symbol.asyncIterator]() { return this; },
+      };
+      if (__trustedStreamCleanupIterators.has(iterator)) {
+        __trustedStreamCleanupIterators.add(tappedIterator);
+      }
+      return tappedIterator;
+    },
+  };
+}
+
+`});var ht=A((Fn,yt)=>{"use strict";yt.exports=`function __createAsyncMainResultProxy(valuePromise, path) {
+  // The proxy is lazy: a script that ignores a package/helper call never reads
+  // its then method, so nothing would observe a rejection here and V8 would
+  // report it as an unhandled rejection of the isolate, failing whichever task
+  // runs next on the lane. Marking the source promise keeps the rejection
+  // observable for a script that awaits the proxy without letting an ignored
+  // call escape.
+  if (valuePromise && typeof valuePromise.catch === 'function') {
+    valuePromise.catch(() => {});
+  }
   const resolveValue = () => valuePromise;
   const resolvePath = () =>
     resolveValue().then((base) => __resolvePkgResultPath(base, path));
   const promiseForPath = () =>
     path.length === 0 ? resolveValue() : resolvePath().then(({ target }) => target);
 
-  const fn = function (...args) {
-    return __createAsyncMainResultProxy(
-      resolvePath().then(({ target, receiver }) => {
-        if (typeof target !== 'function') {
-          throw new Error('Async result is not callable: ' + (path.join('.') || '<root>'));
-        }
-        return Reflect.apply(target, receiver, args);
-      }),
-      [],
-    );
-  };
+  const fn = () => {};
 
   return new Proxy(fn, {
     get: (_target, prop) => {
@@ -694,13 +2281,19 @@ function __createAsyncMainResultProxy(valuePromise, path) {
         const promise = promiseForPath();
         return promise.finally.bind(promise);
       }
-      return __createAsyncMainResultProxy(valuePromise, path.concat(String(prop)));
+      if (prop === '$property') {
+        return (key) => __createAsyncMainResultProxy(
+          valuePromise,
+          path.concat(key),
+        );
+      }
+      return __createAsyncMainResultProxy(valuePromise, path.concat(prop));
     },
     apply: (_target, _thisArg, args) =>
       __createAsyncMainResultProxy(
         resolvePath().then(({ target, receiver }) => {
           if (typeof target !== 'function') {
-            throw new Error('Async result is not callable: ' + (path.join('.') || '<root>'));
+            throw new Error('Async result is not callable: ' + (__formatResultPath(path) || '<root>'));
           }
           return Reflect.apply(target, receiver, args);
         }),
@@ -717,14 +2310,14 @@ function __wrapPkgValue(value) {
 }
 
 function __createPkgProxy(packageName, path) {
-  const fn = function (...args) {
+  const fn = (function (...args) {
     return __createAsyncPkgResultProxy(
       __stringifyRuntimeArgs(args).then((argsJson) =>
         __call('pkgCall', __encodePkgCallPayload({ packageName, path, argsJson, kind: 'call' })),
       ),
       [],
     );
-  };
+  }).bind(null);
   return new Proxy(fn, {
     get: (_, prop) => {
       if (prop === 'then') return undefined;
@@ -753,35 +2346,112 @@ function __createPkgProxy(packageName, path) {
 }
 
 function __createReadableFrom(input) {
+  let consumed = false;
+  let sourceIterator = null;
+  let closed = false;
+  let cleanupPromise = null;
+  let nextQueue = Promise.resolve();
+  const close = () => {
+    if (cleanupPromise) return cleanupPromise;
+    closed = true;
+    cleanupPromise = (async () => {
+      if (sourceIterator) await __closeStreamIterator(sourceIterator);
+      return { done: true, value: undefined };
+    })();
+    return cleanupPromise;
+  };
   const stream = {
     __enfyraLocalReadable: true,
-    async *[Symbol.asyncIterator]() {
-      if (input && typeof input[Symbol.asyncIterator] === 'function') {
-        for await (const chunk of input) yield chunk;
-        return;
+    __enfyraCancel: close,
+    [Symbol.asyncIterator]() {
+      if (consumed) {
+        throw __createPackageStreamError(
+          'Readable.from stream already has a consumer',
+          'ERR_PACKAGE_STREAM_ALREADY_CONSUMED',
+        );
       }
-      if (input && typeof input[Symbol.iterator] === 'function' && typeof input !== 'string') {
-        for (const chunk of input) yield chunk;
-        return;
+      consumed = true;
+      if (!closed) {
+        if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+          let pending = true;
+          sourceIterator = {
+            next() {
+              if (!pending) return { done: true, value: undefined };
+              pending = false;
+              return { done: false, value: input };
+            },
+          };
+        } else if (input && typeof input[Symbol.asyncIterator] === 'function') {
+          sourceIterator = input[Symbol.asyncIterator]();
+        } else if (
+          input
+          && typeof input[Symbol.iterator] === 'function'
+          && typeof input !== 'string'
+        ) {
+          sourceIterator = input[Symbol.iterator]();
+        } else {
+          let pending = true;
+          sourceIterator = {
+            next() {
+              if (!pending) return { done: true, value: undefined };
+              pending = false;
+              return { done: false, value: input };
+            },
+          };
+        }
       }
-      yield input;
+      const iterator = {
+        next() {
+          const operation = nextQueue.then(async () => {
+            if (closed || !sourceIterator) {
+              return { done: true, value: undefined };
+            }
+            try {
+              const next = await sourceIterator.next();
+              if (closed || next.done) {
+                closed = true;
+                return { done: true, value: undefined };
+              }
+              const value = await next.value;
+              if (closed) return { done: true, value: undefined };
+              return { done: false, value };
+            } catch (error) {
+              await close();
+              throw error;
+            }
+          });
+          nextQueue = operation.catch(() => {});
+          return operation;
+        },
+        return: close,
+        [Symbol.asyncIterator]() { return this; },
+      };
+      if (__trustedStreamCleanupIterators.has(sourceIterator)) {
+        __trustedStreamCleanupIterators.add(iterator);
+      }
+      return iterator;
     },
   };
   return stream;
 }
 
-const __builtinModules = {
+const __builtinModules = Object.create(null);
+Object.assign(__builtinModules, {
   stream: {
     Readable: {
       from: __createReadableFrom,
     },
   },
-};
+});
 __builtinModules['node:stream'] = __builtinModules.stream;
 
 const require = (name) => {
-  if (__builtinModules[name] !== undefined) return __builtinModules[name];
-  if ($pkgs[name] === undefined) throw new Error('Module "' + name + '" is not available. Install it via Settings \\u2192 Packages');
+  if (Object.prototype.hasOwnProperty.call(__builtinModules, name)) {
+    return __builtinModules[name];
+  }
+  if (!Object.prototype.hasOwnProperty.call($pkgs, name)) {
+    throw new Error('Module "' + name + '" is not available. Install it via Settings \\u2192 Packages');
+  }
   return $pkgs[name];
 };
 
@@ -792,104 +2462,281 @@ const console = {
   info: (...a) => $ctx.$logs(...a),
 };
 
-function __resetTask(snapshot, taskId, timeoutMs, deadlineMs) {
+`});var wt=A((Jn,gt)=>{"use strict";gt.exports=`function __resetTask(snapshot, taskId, timeoutMs, deadlineMs, innerGuardGraceMs = 500) {
   $ctx = snapshot || {};
   $pkgs = {};
   __taskId = taskId;
+  __innerGuardGraceMs = innerGuardGraceMs;
   const providedDeadlineMs = Number(deadlineMs);
+  const requestedTimeoutMs = Number(timeoutMs);
+  const normalizedTimeoutMs = Number.isFinite(requestedTimeoutMs)
+    ? Math.max(1, Math.trunc(requestedTimeoutMs))
+    : 30000;
   __taskDeadlineMs = Number.isFinite(providedDeadlineMs) && providedDeadlineMs > 0
     ? providedDeadlineMs
-    : Date.now() + Math.max(1, Math.trunc(Number(timeoutMs) || 30000));
+    : __trustedNow() + normalizedTimeoutMs;
   __logs = [];
   __logBytes = 0;
   __runtimeCallbackCounter = 0;
   __runtimeCallbacks = new Map();
   __pendingRuntimeTasks = [];
+  __streamTimerCounter = 0;
   %%PKG_SETUP%%
   $ctx.$pkgs = $pkgs;
+  $ctx.$streams = {
+    preflight: __preflightStream,
+    readBytes: (readable, options) => __readStream(readable, options, false),
+    readText: (readable, options) => __readStream(readable, options, true),
+    guard: __guardStream,
+    tap: __tapStream,
+    cancel: __cancelStream,
+  };
   $ctx.$share = $ctx.$share || {};
   $ctx.$share.$logs = __logs;
   const __createRepoProxy = (table, access) => new Proxy({}, {
-    get: (_, method) => async (...args) =>
-      __call('repoCall', JSON.stringify({ table: String(table), access, method: String(method), argsJson: JSON.stringify(args) }))
+    get: (_, method) => {
+      if (method === 'then') return undefined;
+      return __hostCallAsync(async (...args) =>
+        __call('repoCall', JSON.stringify({
+          table: String(table),
+          access,
+          method: String(method),
+          argsJson: await __stringifyRuntimeArgs(args),
+        })));
+    }
   });
   const __secureRepos = new Proxy({}, {
-    get: (_, table) => __createRepoProxy(table, 'secure')
+    get: (_, table) => {
+      if (table === 'then') return undefined;
+      return __createRepoProxy(table, 'secure');
+    }
   });
   $ctx.$repos = new Proxy({}, {
-    get: (_, table) => String(table) === 'secure' ? __secureRepos : __createRepoProxy(table)
+    get: (_, table) => {
+      if (table === 'then') return undefined;
+      return String(table) === 'secure' ? __secureRepos : __createRepoProxy(table);
+    }
   });
   $ctx.$helpers = new Proxy({}, {
     get: (_, name) => {
+      if (name === 'then') return undefined;
       const basePath = String(name);
       const fn = (...args) =>
         __createAsyncMainResultProxy(
-          __call('helpersCall', JSON.stringify({ name: basePath, argsJson: JSON.stringify(args) })),
+          __stringifyRuntimeArgs(args).then((argsJson) =>
+            __call('helpersCall', JSON.stringify({ name: basePath, argsJson })),
+          ),
           [],
         );
       return new Proxy(fn, {
-        get: (_, subName) => (...args) =>
-          __createAsyncMainResultProxy(
-            __call('helpersCall', JSON.stringify({ name: basePath + '.' + String(subName), argsJson: JSON.stringify(args) })),
-            [],
-          )
+        get: (_, subName) => {
+          if (subName === 'then') return undefined;
+          return (...args) =>
+            __createAsyncMainResultProxy(
+              __stringifyRuntimeArgs(args).then((argsJson) =>
+                __call('helpersCall', JSON.stringify({
+                  name: basePath + '.' + String(subName),
+                  argsJson,
+                })),
+              ),
+              [],
+            );
+        }
       });
     }
   });
   $ctx.$socket = new Proxy({}, {
-    get: (_, method) => async (...args) =>
-      __call('socketCall', JSON.stringify({ method: String(method), argsJson: JSON.stringify(args) }))
+    get: (_, method) => {
+      if (method === 'then') return undefined;
+      return __hostCallAsync(async (...args) =>
+        __call('socketCall', JSON.stringify({
+          method: String(method),
+          argsJson: await __stringifyRuntimeArgs(args),
+        })));
+    }
   });
   $ctx.$cache = new Proxy({}, {
-    get: (_, method) => async (...args) =>
-      __call('cacheCall', JSON.stringify({ method: String(method), argsJson: JSON.stringify(args) }))
+    get: (_, method) => {
+      if (method === 'then') return undefined;
+      return __hostCallAsync(async (...args) =>
+        __call('cacheCall', JSON.stringify({
+          method: String(method),
+          argsJson: await __stringifyRuntimeArgs(args),
+        })));
+    }
   });
   $ctx.$transaction = {
-    run: async (...args) =>
+    run: __hostCallAsync(async (...args) =>
       __call('transactionCall', JSON.stringify({
         argsJson: await __stringifyRuntimeArgs(args)
-      }))
+      })))
   };
   $ctx.$storage = new Proxy({}, {
-    get: (_, method) => async (...args) =>
-      __call('storageCall', JSON.stringify({ method: String(method), argsJson: await __stringifyRuntimeArgs(args) }))
+    get: (_, method) => {
+      if (method === 'then') return undefined;
+      return __hostCallAsync(async (...args) =>
+        __call('storageCall', JSON.stringify({ method: String(method), argsJson: await __stringifyRuntimeArgs(args) })));
+    }
   });
   $ctx.$res = new Proxy({}, {
-    get: (_, method) => async (...args) => {
+    get: (_, method) => {
+      if (method === 'then') return undefined;
+      return __hostCallAsync(async (...args) => {
       const methodName = String(method);
       if (methodName === 'stream' && args[0]?.__enfyraLocalReadable) {
         const task = __streamResponseFromLocalReadable(args[0], args[1]);
         __pendingRuntimeTasks.push(task);
         return task;
       }
+      if (methodName === 'json') {
+        const jsonText = JSON.stringify(args[0]);
+        if (jsonText === undefined) {
+          throw new TypeError('@RES.json requires a JSON-serializable value');
+        }
+        return __call('resCall', JSON.stringify({
+          method: 'json',
+          jsonText,
+          options: args[1] || {},
+        }));
+      }
+      if (methodName === 'bytes') {
+        return __call('resCall', JSON.stringify({
+          method: 'bytes',
+          bytes: __bytesToBase64(__responseBodyToBytes(args[0])),
+          options: args[1] || {},
+        }));
+      }
       return __call('resCall', JSON.stringify({ method: methodName, argsJson: await __stringifyRuntimeArgs(args) }));
+      });
     }
   });
-  $ctx.$trigger = async (...args) =>
-    __call('dispatchCall', JSON.stringify({ method: 'trigger', argsJson: JSON.stringify(args) }));
+  $ctx.$trigger = __hostCallAsync(async (...args) =>
+    __call('dispatchCall', JSON.stringify({
+      method: 'trigger',
+      argsJson: await __stringifyRuntimeArgs(args),
+    })));
+  const safeDiagnosticString = (value) => {
+    try { return String(value); } catch { return '[Unserializable]'; }
+  };
+  const safeDiagnosticValue = (value, seen = new WeakSet(), depth = 0) => {
+    if (
+      value === null
+      || typeof value === 'string'
+      || typeof value === 'boolean'
+      || typeof value === 'number'
+    ) {
+      return value;
+    }
+    if (value === undefined) return undefined;
+    if (typeof value === 'bigint') return safeDiagnosticString(value);
+    if (typeof value === 'symbol') return safeDiagnosticString(value);
+    if (typeof value === 'function') return '[Function]';
+    if (depth >= 12) return '[MaxDepth]';
+    if (seen.has(value)) return '[Circular]';
+    seen.add(value);
+    try {
+      if (value instanceof Date) {
+        try { return value.toISOString(); } catch { return safeDiagnosticString(value); }
+      }
+      if (value instanceof Error) {
+        return {
+          name: safeDiagnosticString(value.name),
+          message: safeDiagnosticString(value.message),
+          stack: typeof value.stack === 'string' ? value.stack : undefined,
+        };
+      }
+      if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+        const bytes = value instanceof ArrayBuffer
+          ? new Uint8Array(value)
+          : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+        const output = Array.from(bytes.subarray(0, 1000));
+        if (bytes.byteLength > output.length) output.push('[Truncated]');
+        return output;
+      }
+      if (Array.isArray(value)) {
+        const output = [];
+        const length = Math.min(value.length, 1000);
+        for (let index = 0; index < length; index += 1) {
+          let descriptor;
+          try { descriptor = Object.getOwnPropertyDescriptor(value, String(index)); } catch {}
+          output.push(
+            descriptor && Object.prototype.hasOwnProperty.call(descriptor, 'value')
+              ? safeDiagnosticValue(descriptor.value, seen, depth + 1)
+              : descriptor
+                ? '[Accessor]'
+                : null,
+          );
+        }
+        if (value.length > length) output.push('[Truncated]');
+        return output;
+      }
+      const output = {};
+      let descriptors;
+      try { descriptors = Object.getOwnPropertyDescriptors(value); } catch {
+        return '[Unserializable]';
+      }
+      let count = 0;
+      for (const key of Object.keys(descriptors)) {
+        if (count >= 1000) {
+          output.__truncated = true;
+          break;
+        }
+        const descriptor = descriptors[key];
+        if (!descriptor.enumerable) continue;
+        __defineDataProperty(
+          output,
+          key,
+          Object.prototype.hasOwnProperty.call(descriptor, 'value')
+            ? safeDiagnosticValue(descriptor.value, seen, depth + 1)
+            : '[Accessor]',
+        );
+        count += 1;
+      }
+      return output;
+    } catch {
+      return '[Unserializable]';
+    } finally {
+      seen.delete(value);
+    }
+  };
+  const safeDiagnosticJson = (value) => {
+    try {
+      const text = JSON.stringify(safeDiagnosticValue(value));
+      return text === undefined
+        ? JSON.stringify(safeDiagnosticString(value))
+        : text;
+    } catch {
+      return '"[Unserializable]"';
+    }
+  };
   $ctx.$throw = new Proxy({}, {
-    get: (_, status) => (...args) => {
+    get: (_, status) => {
+      if (status === 'then') return undefined;
+      return (...args) => {
       const key = String(status);
       const throwPayload = (payload) => {
-        throw new Error(JSON.stringify({ __userThrow: true, ...payload }));
+        throw new Error(safeDiagnosticJson({ __userThrow: true, ...payload }));
       };
 
       if (key === 'http') {
         const code = Number(args[0]);
+        if (!Number.isInteger(code) || code < 400 || code > 599) {
+          throw new TypeError('$throw.http requires an integer HTTP status from 400 to 599');
+        }
         const message = args[1] !== undefined && args[1] !== null && args[1] !== ''
-          ? String(args[1])
+          ? safeDiagnosticString(args[1])
           : (__throwDefaults[code] || 'Error');
         throwPayload({
           errorPath: '$throw.http',
           statusCode: code,
           message,
-          details: args[2] || null,
+          details: args[2] ?? null,
         });
       }
 
       if (key === 'notFound') {
-        const resource = args[0] !== undefined && args[0] !== null && args[0] !== '' ? String(args[0]) : 'Resource';
-        const identifier = args[1] !== undefined && args[1] !== null ? String(args[1]) : undefined;
+        const resource = args[0] !== undefined && args[0] !== null && args[0] !== '' ? safeDiagnosticString(args[0]) : 'Resource';
+        const identifier = args[1] !== undefined && args[1] !== null ? safeDiagnosticString(args[1]) : undefined;
         throwPayload({
           errorPath: '$throw.notFound',
           statusCode: 404,
@@ -899,9 +2746,9 @@ function __resetTask(snapshot, taskId, timeoutMs, deadlineMs) {
       }
 
       if (key === 'duplicate') {
-        const resource = args[0] !== undefined && args[0] !== null && args[0] !== '' ? String(args[0]) : 'Resource';
-        const field = args[1] !== undefined && args[1] !== null && args[1] !== '' ? String(args[1]) : 'field';
-        const value = args[2] !== undefined && args[2] !== null ? String(args[2]) : 'value';
+        const resource = args[0] !== undefined && args[0] !== null && args[0] !== '' ? safeDiagnosticString(args[0]) : 'Resource';
+        const field = args[1] !== undefined && args[1] !== null && args[1] !== '' ? safeDiagnosticString(args[1]) : 'field';
+        const value = args[2] !== undefined && args[2] !== null ? safeDiagnosticString(args[2]) : 'value';
         throwPayload({
           errorPath: '$throw.duplicate',
           statusCode: 409,
@@ -910,24 +2757,58 @@ function __resetTask(snapshot, taskId, timeoutMs, deadlineMs) {
         });
       }
 
-      const code = parseInt(key);
-      const msg = (args[0] !== undefined && args[0] !== null && args[0] !== '') ? String(args[0]) : (__throwDefaults[code] || 'Error');
+      if (!/^\\d+$/.test(key)) {
+        throw new TypeError('$throw status must be an integer HTTP status');
+      }
+      const code = Number(key);
+      if (!Number.isInteger(code) || code < 400 || code > 599) {
+        throw new TypeError('$throw status must be from 400 to 599');
+      }
+      const msg = (args[0] !== undefined && args[0] !== null && args[0] !== '') ? safeDiagnosticString(args[0]) : (__throwDefaults[code] || 'Error');
       throwPayload({
         errorPath: Number.isFinite(code) ? '$throw.' + code : '$throw.' + key,
         statusCode: code,
         message: msg,
-        details: args[1] || null,
+        details: args[1] ?? null,
       });
+      };
     }
   });
+  const truncateLogText = (text, maxBytes) => {
+    const suffix = '[Truncated]';
+    let low = 0;
+    let high = text.length;
+    let result = JSON.stringify(suffix);
+    while (low <= high) {
+      const mid = Math.floor((low + high) / 2);
+      const candidate = JSON.stringify(text.slice(0, mid) + suffix);
+      if (new TextEncoder().encode(candidate).byteLength <= maxBytes) {
+        result = candidate;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return result;
+  };
   $ctx.$logs = (...args) => {
     for (const a of args) {
-      if (__logs.length >= 200 || __logBytes >= 40000) { $ctx.$share.$logsTruncated = true; break; }
-      let text;
-      try { text = JSON.stringify(a); } catch { text = String(a); }
-      text = text === undefined ? String(a) : text;
-      if (text.length > 8192) { text = JSON.stringify(text.slice(0, 8192) + '[Truncated]'); $ctx.$share.$logsTruncated = true; }
-      __logBytes += text.length;
+      if (__logs.length >= 200 || __logBytes >= 40000) {
+        $ctx.$share.$logsTruncated = true;
+        break;
+      }
+      let text = safeDiagnosticJson(a);
+      let textBytes = new TextEncoder().encode(text).byteLength;
+      if (textBytes > 8192) {
+        text = truncateLogText(text, 8192);
+        textBytes = new TextEncoder().encode(text).byteLength;
+        $ctx.$share.$logsTruncated = true;
+      }
+      if (__logBytes + textBytes > 40000) {
+        $ctx.$share.$logsTruncated = true;
+        break;
+      }
+      __logBytes += textBytes;
       try { __logs.push(JSON.parse(text)); } catch { __logs.push(text); }
     }
   };
@@ -958,50 +2839,49 @@ function __cleanupTask() {
   __runtimeCallbackCounter = 0;
   __runtimeCallbacks = new Map();
   __pendingRuntimeTasks = [];
+  __streamTimerCounter = 0;
   return true;
 }
-`;function Se(e){return Pe.replace("%%PKG_SETUP%%",e)}se.exports={buildSetupCode:Se}});var{parentPort:Ce}=require("worker_threads"),S=Ce||{on(e,t){e==="message"&&process.on("message",t)},postMessage(e){process.send?.(e)}},ie=require("fs"),{fileURLToPath:Re}=require("url"),{createPackageRuntimeBridge:$e}=ae(),{buildSetupCode:Te}=oe(),q;try{q=require("isolated-vm")}catch(e){S.postMessage({type:"error",message:"isolated-vm not available: "+e.message}),process.exit(1)}var K=new Map,pe=0,O=new Map,E=new Map,j=new Map,U=$e({workerDir:__dirname,activeTaskContexts:O}),Me=500,Ne=5e3,ce=new WeakMap,_e=new WeakMap,W={created:0,reused:0,released:0,evicted:0,scrubFailed:0};function B(e){let t=j.get(e);return Math.max(1,Math.ceil((t??Date.now()+3e4)-Date.now()))}var A=null,le=0,ue=0,de=0;async function Ae(){let e=Date.now();if(e-ue<Ne)return de;if(ue=e,!A)return 0;let t=0;for(let s of A){let n=s?.isolate;if(!(!n||n.isDisposed))try{let r=await n.getHeapStatistics(),i=r.heap_size_limit||1,o=r.used_heap_size/i;o>t&&(t=o)}catch{}}return de=t,t}async function F(e){e.heapRatio=await Ae(),e.runnerRssBytes=process.memoryUsage().rss,e.contextStats=Ee(),S.postMessage(e)}function Ee(){return{...W,idle:0}}function ge(e,t,s){if(!A){let n=Math.max(1,Math.trunc(Number(t)||8));A=new Array(n).fill(null)}for(let n=0;n<A.length;n++){let r=(le+n)%A.length,i=A[r];if((!i||!i.isolate||i.isolate.isDisposed)&&(i={isolate:new q.Isolate({memoryLimit:e}),taskIds:new Set},A[r]=i),i.taskIds.size<s)return le=(r+1)%A.length,i}throw new Error("No isolate lane is available")}function z(e,t,s){for(let n of[...e.taskIds])n!==t&&(e.taskIds.delete(n),E.delete(n),O.delete(n),j.delete(n),U.cancelTask(n),V(n),S.postMessage({type:"result",id:n,success:!1,error:{message:"Isolate was disposed because a sibling task could not continue",code:"ERR_EXECUTOR_ISOLATE_LOST",details:{outcome:"unknown_outcome",retryable:!1,reason:s}}}),S.postMessage({type:"taskReleased",id:n}));try{e.isolate.dispose()}catch{}}function Oe(e){let t=E.get(e);if(!t){S.postMessage({type:"taskCancelled",id:e});return}z(t,e,"sibling_cancelled"),U.cancelTask(e),E.delete(e),O.delete(e),j.delete(e),t.taskIds.delete(e),V(e),S.postMessage({type:"taskCancelled",id:e})}function ye(e,t){t.taskIds.delete(e)&&(O.delete(e),E.delete(e),j.delete(e),V(e),S.postMessage({type:"taskReleased",id:e}))}async function T(e,t,s){let n=ce.get(e);n||(n=new Map,ce.set(e,n));let r=n.get(t);if(r)return r;let i;try{i=await e.compileScript(t,{filename:s})}catch(o){throw o&&typeof o=="object"&&(o.executionStage="compile"),o}if(n.set(t,i),n.size>Me){let o=n.keys().next().value;n.delete(o)}return i}S.on("message",async e=>{if(e.type==="execute")Ge(e).catch(async t=>{await F({type:"result",id:e.id,success:!1,error:{message:t.message,stack:t.stack}})});else if(e.type==="executeBatch")We(e).catch(async t=>{await F({type:"result",id:e.id,success:!1,error:{message:t.message,stack:t.stack}})});else if(e.type==="invokeRuntimeCallback")Je(e).catch(t=>{S.postMessage({type:"runtimeCallbackResult",callId:e.callId,error:t?.message||String(t)})});else if(e.type==="callResult"){let t=K.get(e.callId);t&&(K.delete(e.callId),t.resolve(e.result))}else if(e.type==="callError"){let t=K.get(e.callId);t&&(K.delete(e.callId),t.reject(new Error(e.error)))}else e.type==="cancelTask"&&Oe(e.id)});async function Je(e){let t=O.get(e.id);if(!t){S.postMessage({type:"runtimeCallbackResult",callId:e.callId,error:`Runtime callback context not found: ${e.id}`});return}let s=await t.evalClosure(`return __invokeRuntimeCallback(${JSON.stringify(e.callbackId)}, ${JSON.stringify(e.argsJson||"[]")});`,[],{arguments:{copy:!0},result:{promise:!0,copy:!0}}),n=JSON.parse(s);S.postMessage({type:"runtimeCallbackResult",callId:e.callId,...n})}function L(e,t,s){return new Promise((n,r)=>{let i=`cb_${++pe}`;K.set(i,{resolve:n,reject:r}),S.postMessage({type:t,id:e,callId:i,...s})})}function Ie(e,t,s){S.postMessage({type:t,id:e,callId:`f_${++pe}`,...s})}async function je(e,t){if(t?.method!=="stream")return L(e,"resCall",t);let s=JSON.parse(t.argsJson||"[]"),n=s[0],r=s[1]||{},i=n?.__pkgHandleArg;if(!i)return L(e,"resCall",t);let o=r.observer&&typeof r.observer=="object"?r.observer.__fnRef:null,y=r.transform&&typeof r.transform=="object"?r.transform.__fnRef:null,f=o||y?new TextDecoder("utf-8"):null;delete r.observer,delete r.transform;let w={...r};await L(e,"resCall",{method:"streamStart",argsJson:JSON.stringify([null,w])});let b=async(u,m,v)=>{if(!u)return;let k=O.get(e);if(!k)return;let P=await k.evalClosure(`return __invokeRuntimeCallback(${JSON.stringify(u)}, ${JSON.stringify(JSON.stringify([m,v]))});`,[],{arguments:{copy:!0},result:{promise:!0,copy:!0}}),C=JSON.parse(P);if(C?.error)throw new Error(C.error);if(C?.value?.__e!=="u")return C?.value},R=async(u,m)=>{if(o)try{await b(o,u,m)}catch{}},d=async(u,m,v)=>{let k=u;if(y){let C=await b(y,v,m);if(C===null)return;C!==void 0&&(k=Buffer.from(String(C)))}let P=Buffer.from(k);P.length!==0&&await L(e,"resCall",{method:"streamChunk",chunk:P.toString("base64")})};try{await U.streamPackageHandle(e,i,async m=>{let v="";try{v=f?f.decode(Buffer.from(m),{stream:!0}):""}catch{}await R(v,"chunk"),await d(m,"chunk",v)},[],B(e));let u="";try{u=f?f.decode():""}catch{}await R(u,"end"),await d("","end",u),await L(e,"resCall",{method:"streamEnd"})}catch(u){try{await L(e,"resCall",{method:"streamError",error:{message:u.message,stack:u.stack}})}catch{}throw await R("","error"),u}return JSON.stringify({__e:"u"})}function Ue(e){if(typeof e.sourceCode=="string"&&e.sourceCode.length>0)return e.sourceCode;let t=e.filePath;return!t&&typeof e.fileUrl=="string"&&e.fileUrl.startsWith("file://")&&(t=Re(e.fileUrl)),!t||!ie.existsSync(t)?null:ie.readFileSync(t,"utf8")}async function He(e,t,s){try{let n=Ue(s);if(!n)return null;let r=await e.compileModule(n,{filename:`pkg:${s.safeName}`});await r.instantiate(t,o=>{throw new Error(`Unresolved import in package ${s.safeName}: ${o}`)}),await r.evaluate({timeout:1e4});let i=await r.namespace.get("default");return i!==void 0&&i.typeof!=="undefined"?i.derefInto({release:!1}):r.namespace.derefInto({release:!1})}catch{return null}}function he(e,t){let s=new Set(t.map(f=>f.name)),n=new Set,r=String(e||""),i=/\b(?:\$ctx\.)?\$pkgs\s*\[\s*(['"`])([^'"`]+)\1\s*\]/g,o=/\brequire\s*\(\s*(['"`])([^'"`]+)\1\s*\)/g,y=/\b(?:\$ctx\.)?\$pkgs\.([A-Za-z_$][\w$]*)/g;for(let f of[i,o])for(let w of r.matchAll(f)){let b=w[2];s.has(b)&&n.add(b)}for(let f of r.matchAll(y)){let w=f[1];s.has(w)&&n.add(w)}return n}async function Le(e,t,s,n){let r=await e.createContext(),i=r.global;await i.set("global",i.derefInto());let o=[],y=[],f=new Map;for(let d of s){f.set(d.name,d);let u=n.has(d.name)?await He(e,r,d):null;u!==null?(await i.set(`__pkg_${d.safeName}`,u),o.push(d)):y.push(d)}U.setTaskPackages(t,f),await i.set("__callRef",new q.Reference(async(d,u,m)=>{let v=JSON.parse(m);if(u==="pkgCall")try{return JSON.stringify(await U.executePackageRuntimeCall(d,v))}catch(k){throw new Error(JSON.stringify({__userThrow:!0,message:k.message,code:k.code,details:k.details}))}return u==="resCall"?je(d,v):L(d,u,v)})),await i.set("__fireRef",new q.Reference((d,u,m)=>{let v=JSON.parse(m);Ie(d,u,v)}));let w=o.map(d=>`$pkgs[${JSON.stringify(d.name)}] = __pkg_${d.safeName};`).concat(y.map(d=>`$pkgs[${JSON.stringify(d.name)}] = __createPkgProxy(${JSON.stringify(d.name)}, []);`)).join(`
-`),b=Te(w);return await(await T(e,b,"setup.js")).run(r,{timeout:B(t)}),_e.set(r,f),r}async function me(e,t,s,n,r,i,o){let y=e.isolate,f=await Le(y,t,s,r);W.created++,U.setTaskPackages(t,_e.get(f)||new Map);let w=f.global;return await w.set("__snapshot",new q.ExternalCopy(n).copyInto()),await w.set("__nextTaskId",t),await w.set("__nextTaskTimeoutMs",i),await w.set("__nextTaskDeadlineMs",o),await(await T(y,"__resetTask(__snapshot, __nextTaskId, __nextTaskTimeoutMs, __nextTaskDeadlineMs);","reset-task.js")).run(f,{timeout:B(t)}),f}async function ke(e,t){if(!(!t||e.isolate.isDisposed)){try{await(await T(e.isolate,"__cleanupTask();","cleanup-task.js")).run(t,{timeout:5e3})}catch{W.scrubFailed++;try{t.release()}catch{}return}try{t.release()}catch{}W.released++}}function Fe(e){try{let t=JSON.parse(e.message);if(t&&t.__userThrow)return{...t,message:t.message??e.message}}catch{}return null}var De=3,Be=["setup.js","extract.js","extract-error-ctx.js","set-status.js","populate-error.js"];function Ke(e){if(!e)return null;let t=e.split(`
-`);for(let s of t){let n=s.match(/at\s+(.+\.js):(\d+):(\d+)/);if(!n)continue;let r=n[1].trim();if(Be.includes(r)||r!=="handler.js"&&!r.startsWith("preHook #")&&!r.startsWith("postHook #"))continue;let o=parseInt(n[2])-De;if(!(o<=0))return{line:o,column:parseInt(n[3]),phase:r.replace(".js","")}}return null}function qe(e,t,s){if(!e||!t)return;let n=String(e).split(/\r?\n/),r=Math.max(1,t-1),i=Math.min(n.length,t+1),o=String(i).length,y=[];for(let f=r;f<=i;f++){let w=f===t?">":" ";y.push(`${w} ${String(f).padStart(o," ")}. ${n[f-1]??""}`),f===t&&s&&s>0&&y.push(`  ${" ".repeat(o)}  ${" ".repeat(Math.max(0,s-1))}^`)}return y.join(`
-`)}function Ve(e,t){if(!(!e||!t)){if(t[e.phase])return t[e.phase];if(e.phase?.startsWith("preHook"))return t.preHook;if(e.phase?.startsWith("postHook"))return t.postHook}}function te(e,t){let s=Fe(e);if(s)return{message:s.message,statusCode:s.statusCode,errorPath:s.errorPath,code:s.code??(Number.isInteger(s.statusCode)?`HTTP_${s.statusCode}`:void 0),details:s.details};let n=Ke(e.stack),r=e.message||"Unknown error",i=n?`${r} (${n.phase}, line ${n.line})`:r,o=Ve(n,t),y=n?qe(o,n.line,n.column):void 0;return{message:i,statusCode:e.statusCode||null,details:{errorName:e.name||null,executionStage:e.executionStage||"runtime",...n?{...n,codeFrame:y}:{}}}}function X(e){return e?.message==="Script execution timed out."}function Y(e){return e?.message==="Isolate was disposed during execution due to memory limit"}function we(e){X(e)&&e?.code==null&&(e.code="ERR_SCRIPT_EXECUTION_TIMEOUT"),Y(e)&&e?.code==null&&(e.code="ERR_ISOLATE_MEMORY_LIMIT",e.details={outcome:"unknown_outcome",retryable:!1})}async function Z(e,t,s){we(t);let n=te(t,s);t.details&&(n.details={...n.details,...t.details});let r,i=O.get(e),o=E.get(e);if(i&&o&&!o.isolate.isDisposed)try{let y=await T(o.isolate,"JSON.stringify({logs: __logs, truncated: $ctx.$share.$logsTruncated === true})","extract-diagnostic-logs.js");r=JSON.parse(await y.run(i,{timeout:100}))}catch{}await F({type:"result",id:e,success:!1,diagnosticLogs:r,error:{...n,stack:t.stack,code:n.code??t.code}})}async function Ge(e){let{id:t,code:s,pkgSources:n,snapshot:r,memoryLimitMb:i,isolatePoolSize:o,tasksPerIsolate:y}=e,f={handler:e.sourceCode||s||""},w=n||[],b=Math.max(1,Math.trunc(Number(e.timeoutMs)||3e4)),R=Date.now()+b;j.set(t,R);let d=he(s,w),u=ge(i,o,Math.max(1,Math.trunc(Number(y)||1)));u.taskIds.add(t),E.set(t,u);let m=u.isolate,v;try{v=await me(u,t,w,r,d,b,R)}catch(k){j.delete(t),E.delete(t),u.taskIds.delete(t),V(t),await Z(t,k,f),S.postMessage({type:"taskReleased",id:t});return}O.set(t,v);try{let k=`
-(async () => {
-  "use strict";
-  ${s}
-})().then((__result) => __extractResult(__result, __result === undefined));
-`,C=await(await T(m,k,"handler.js")).run(v,{timeout:B(t),promise:!0}),D=JSON.parse(C);await F({type:"result",id:t,success:!0,...D})}catch(k){u.taskIds.has(t)&&(await Z(t,k,f),(X(k)||Y(k))&&z(u,t,"sibling_execution_failure"))}finally{await ke(u,v),ye(t,u)}}async function We(e){let{id:t,codeBlocks:s,pkgSources:n,snapshot:r,memoryLimitMb:i,isolatePoolSize:o,tasksPerIsolate:y}=e,f=n||[],w=Math.max(1,Math.trunc(Number(e.timeoutMs)||3e4)),b=Date.now()+w;j.set(t,b);let R=he((s||[]).map(_=>_.code||"").join(`
-`),f),d=ge(i,o,Math.max(1,Math.trunc(Number(y)||1)));d.taskIds.add(t),E.set(t,d);let u=d.isolate,m;try{m=await me(d,t,f,r,R,w,b)}catch(_){j.delete(t),E.delete(t),d.taskIds.delete(t),V(t),await Z(t,_),S.postMessage({type:"taskReleased",id:t});return}O.set(t,m);let v=[],k=[],P={},C=0,D=0;for(let _ of s){let H=_.type||"handler",g=_.sourceCode||_.code||"";H==="postHook"?(D++,P[`postHook #${D}`]=g,P.postHook=g,k.push(_)):(H==="handler"?P.handler=g:(C++,P[`${H} #${C}`]=g,P.preHook=g),v.push(_))}try{let _=null;for(let g=0;g<v.length;g++){let x=v[g],$=x.type||"handler",l=$==="handler"?"handler":`${$} #${g+1}`,a;$==="preHook"?a=`
+`});var kt=A((jn,bt)=>{"use strict";var Sr=[We(),Ye(),Ze(),tt(),nt(),ot(),it(),ct(),dt(),_t(),mt(),ht(),wt()].join("");function Pr(e){return Sr.replace("%%PKG_SETUP%%",()=>e)}bt.exports={buildSetupCode:Pr}});var Pe={};cr(Pe,{INNER_GUARD_GRACE_MS:()=>Er,TASK_CANCEL_ACK_GRACE_MS:()=>Tr,TASK_TIMEOUT_TOLERANCE_RATIO:()=>Mr,getTaskCancellationTimeoutMs:()=>xt,getTaskInnerGuardGraceMs:()=>Cr});function xt(e){return Math.min(2147483647,e+Math.ceil(e*.15))}function Cr(e){return xt(e)-e+500}var Tr,Er,Mr,Te=lr(()=>{"use strict";Tr=1e4,Er=500,Mr=.15});var Me=A((zn,vt)=>{"use strict";var{randomUUID:Rr}=require("crypto"),pe=new WeakMap,Ee=new WeakMap;function Ar(e){let t=e.createInspectorSession(),n=new Map,r=new Map,i=new Map,s=0,c,_=Promise.resolve(),m=p=>new Promise((w,d)=>{let h=++s;i.set(h,{resolve:w,reject:d});try{t.dispatchProtocolMessage(JSON.stringify({id:h,method:p}))}catch(y){i.delete(h),d(y)}});t.onResponse=(p,w)=>{let d=JSON.parse(w),h=i.get(d.id);h&&(i.delete(d.id),d.error?h.reject(new Error(d.error.message)):h.resolve(d.result))},t.onNotification=p=>{let w=JSON.parse(p);if(w.method==="Debugger.scriptParsed"){let{scriptId:d,executionContextId:h,url:y}=w.params;n.set(d,h),y.startsWith("enfyra-task-context:")&&r.set(y,h)}else if(w.method==="Runtime.executionContextDestroyed"){let d=w.params.executionContextId;for(let[h,y]of n)y===d&&n.delete(h);for(let[h,y]of r)y===d&&r.delete(h)}else if(w.method==="Debugger.paused"){let d=c;d&&(d.handling=!0),(async()=>{try{let h=w.params.callFrames[0],y=n.get(h?.location?.scriptId),k=d&&r.get(d.marker);if(k!==void 0&&y===k&&d.isCancelling()){let x=m("Runtime.terminateExecution");await m("Debugger.resume").catch(()=>{}),await x}else await m("Debugger.resume")}finally{d?.complete()}})().catch(()=>d?.complete())}};let l=m("Runtime.enable").then(()=>m("Debugger.enable"));return{ready:l,forget(p){let w=pe.get(p),d=r.get(w);r.delete(w);for(let[h,y]of n)y===d&&n.delete(h);pe.delete(p)},interrupt(p,w){let d=_.catch(()=>{}).then(async()=>{if(await l,e.isDisposed||!w())return;let h,y=new Promise(E=>{h=E}),k={marker:pe.get(p),isCancelling:w,complete:h,handling:!1};c=k;let x;try{await m("Debugger.pause"),await Promise.race([y,new Promise(E=>{x=setTimeout(E,250)})]),k.handling&&await y}finally{clearTimeout(x),c===k&&(c=void 0)}});return _=d,d}}}async function Nr(e,t){let n="enfyra-task-context:"+Rr();pe.set(e,n),await e.eval("void 0;",{filename:n,timeout:t})}function Or(e,t){Ee.get(e)?.forget(t)}async function Ir(e,t,n){if(e.isolate.isDisposed||!n())return;let r=Ee.get(e.isolate);r||(r=Ar(e.isolate),Ee.set(e.isolate,r)),await r.interrupt(t,n)}vt.exports={registerTaskContext:Nr,forgetTaskContext:Or,interruptTask:Ir}});var Et=A((Hn,Tt)=>{"use strict";var{URL:St}=require("url"),{buildSetupCode:Ur}=kt(),{normalizeThrownValue:Pt}=ie(),{getTaskInnerGuardGraceMs:$r}=(Te(),$e(Pe)),{registerTaskContext:Br,forgetTaskContext:Dr}=Me();function Lr({ivm:e,packageRuntimeBridge:t,contextStats:n,getCachedScript:r,getTaskRemainingTimeoutMs:i,loadEsmPackageIntoContext:s,PACKAGE_PROXY_FALLBACK:c,executeResCall:_,callMain:m,waitForStreamTimer:l,clearStreamTimer:p,cleanupTaskPackages:w,isTaskCancelled:d}){let h=new WeakMap,y=new WeakMap;async function k(g,f,C,P){let S=await g.createContext({inspector:!0});try{let M=S.global;await M.set("global",M.derefInto());let U=[],q=[],D=new Map;for(let T of C){D.set(T.name,T);let F=P.has(T.name)?await s(g,S,T,f):c;F!==c?(await M.set(`__pkg_${T.safeName}`,F),U.push(T)):q.push(T)}t.setTaskPackages(f,D);let L=new Set(["pkgCall","pkgStreamCall","resCall","repoCall","helpersCall","socketCall","cacheCall","transactionCall","storageCall","dispatchCall"]);await M.set("__callRef",new e.Reference(async(T,F)=>{if(d(f))throw new Error("Task was cancelled");if(!L.has(T))throw new Error(`Unsupported host call type: ${T}`);let o=JSON.parse(F);if(T==="pkgCall")try{return JSON.stringify(await t.executePackageRuntimeCall(f,o))}catch(a){let u=Pt(a);throw new Error(JSON.stringify({__userThrow:!0,message:u.message,code:u.code,details:u.details}))}if(T==="pkgStreamCall")try{return JSON.stringify(await t.executePackageStreamCall(f,o))}catch(a){let u=Pt(a);return JSON.stringify({__pkgStreamError:{message:u.message,code:u.code,details:u.details}})}return T==="resCall"?_(f,o):m(f,T,o)})),await M.set("__urlParseRef",new e.Reference((T,F,o)=>{let a=F==null?new St(String(T)):new St(String(T),String(F));if(o){let u=JSON.parse(o),b=String(u.property);if(!["href","protocol","username","password","host","hostname","port","pathname","search","hash"].includes(b))throw new TypeError(`Unsupported URL property: ${b}`);a[b]=String(u.value)}return JSON.stringify({href:a.href,origin:a.origin,protocol:a.protocol,username:a.username,password:a.password,host:a.host,hostname:a.hostname,port:a.port,pathname:a.pathname,search:a.search,hash:a.hash})})),await M.set("__streamTimerRef",new e.Reference(async(T,F,o)=>T==="wait"?await l(f,F,o):T==="clear"?p(f,F):!1));let fe=U.map(T=>`$pkgs[${JSON.stringify(T.name)}] = __pkg_${T.safeName};`).concat(q.map(T=>`$pkgs[${JSON.stringify(T.name)}] = __createPkgProxy(${JSON.stringify(T.name)}, []);`)).join(`
+`),we=Ur(fe);return await(await r(g,we,"setup.js")).run(S,{timeout:i(f)}),h.set(S,D),S}catch(M){t.cancelTask(f),w(f);try{S.release()}catch{}throw M}}async function x(g,f,C,P,S,M,U){let q=g.isolate,D=await k(q,f,C,S);n.created++;try{t.setTaskPackages(f,h.get(D)||new Map);let L=D.global;return await L.set("__snapshot",new e.ExternalCopy(P).copyInto()),await L.set("__nextTaskId",f),await L.set("__nextTaskTimeoutMs",M),await L.set("__nextTaskDeadlineMs",U),await L.set("__nextTaskInnerGuardGraceMs",$r(M)),await(await r(q,"__resetTask(__snapshot, __nextTaskId, __nextTaskTimeoutMs, __nextTaskDeadlineMs, __nextTaskInnerGuardGraceMs);","reset-task.js")).run(D,{timeout:i(f)}),await Br(D,i(f)),D}catch(L){try{D.release()}catch{}throw L}}function E(g,f){if(!f)return Promise.resolve();let C=y.get(f);if(C)return C;let P=O(g,f).finally(()=>{Dr(g.isolate,f)});return y.set(f,P),P}async function O(g,f){if(g.isolate.isDisposed){try{f.release()}catch{}return}try{await(await r(g.isolate,"__cleanupTask();","cleanup-task.js")).run(f,{timeout:5e3})}catch{n.scrubFailed++;try{f.release()}catch{}return}try{f.release()}catch{}n.released++}async function v(g,f,C,P){if(P!==void 0){let q=`__extractResult(JSON.parse(${JSON.stringify(JSON.stringify(P))}), false)`,L=await(await g.compileScript(q,{filename:"extract.js"})).run(f,{timeout:i(C),promise:!0});return JSON.parse(L)}let U=await(await r(g,"__extractResult($ctx.$data, $ctx.$data === undefined)","extract.js")).run(f,{timeout:i(C),promise:!0});return JSON.parse(U)}return{prepareContext:x,releaseContext:E,extractFinalResult:v}}Tt.exports={createWorkerContext:Lr}});var Ct=A((qn,Mt)=>{"use strict";function Fr({callMain:e,activeTaskContexts:t,getTaskRemainingTimeoutMs:n,getTaskInnerGuardTimeoutMs:r=n,packageRuntimeBridge:i}){async function s(c,_){if(_?.method!=="stream")return e(c,"resCall",_);let m=JSON.parse(_.argsJson||"[]"),l=m[0],p=m[1]||{},w=l?.__pkgHandleArg;if(!w)return e(c,"resCall",_);let d=p.observer&&typeof p.observer=="object"?p.observer.__fnRef:null,h=p.transform&&typeof p.transform=="object"?p.transform.__fnRef:null,y=d||h?new TextDecoder("utf-8"):null;delete p.observer,delete p.transform;let k={...p};await e(c,"resCall",{method:"streamStart",argsJson:JSON.stringify([null,k])});let x=async(v,g,f)=>{if(!v)return;let C=t.get(c);if(!C)throw new Error("Response callback task is no longer active");let P=await C.evalClosure(`return __invokeRuntimeCallback(${JSON.stringify(v)}, ${JSON.stringify(JSON.stringify([g,f]))});`,[],{arguments:{copy:!0},result:{promise:!0,copy:!0},timeout:n(c)}),S=JSON.parse(P);if(S?.error)throw new Error(S.error);if(S?.value?.__e!=="u")return S?.value},E=async(v,g)=>{if(d)try{await x(d,v,g)}catch{}},O=async(v,g,f)=>{let C=v;if(h){let S=await x(h,f,g);if(S===null)return;S!==void 0&&(C=Buffer.from(String(S)))}let P=Buffer.from(C);P.length!==0&&await e(c,"resCall",{method:"streamChunk",chunk:P.toString("base64")})};try{await i.streamPackageHandle(c,w,async g=>{let f="";try{f=y?y.decode(Buffer.from(g),{stream:!0}):""}catch{}await E(f,"chunk"),await O(g,"chunk",f)},[],r(c));let v="";try{v=y?y.decode():""}catch{}await E(v,"end"),await O("","end",v),await e(c,"resCall",{method:"streamEnd"})}catch(v){try{await e(c,"resCall",{method:"streamError",error:{message:v.message,stack:v.stack}})}catch{}throw await E("","error"),v}return JSON.stringify({__e:"u"})}return{executeResCall:s}}Mt.exports={createWorkerResponse:Fr}});var Ut=A((Vn,It)=>{"use strict";var{normalizeThrownValue:Rt,normalizeNativeExecutionError:Ce,isNativeExecutionTimeout:At,isIsolateMemoryLimit:Nt,buildErrorPayload:Ot}=ie();function Jr(e){if(!Array.isArray(e))throw new Error("Executor codeBlocks must be an array");let t=new Set(["preHook","handler","postHook"]),n=0;for(let m of e){if(!m||typeof m!="object")throw new Error("Executor codeBlocks entries must be objects");let l=m.type||"handler";if(!t.has(l))throw new Error(`Unsupported executor code block type: ${l}`);l==="handler"&&n++}if(n>1)throw new Error("Executor batch may contain at most one handler block");let r=[],i=[],s={},c=0,_=0;for(let m of e){let l=m.type||"handler",p=m.sourceCode||m.code||"";l==="postHook"?(_++,s[`postHook #${_}`]=p,s.postHook=p,i.push(m)):(l==="handler"?s.handler=p:(c++,s[`${l} #${c}`]=p,s.preHook=p),r.push(m))}return{preHooksAndHandler:r,postHooks:i,sourceByPhase:s}}function jr({getCachedScript:e,getTaskRemainingTimeoutMs:t,extractFinalResult:n,postResultMessage:r,reportTaskFailure:i,runnerPort:s,failIsolateSiblings:c,isLaneUnusable:_}){async function m({id:l,isolate:p,context:w,entry:d,preHooksAndHandler:h,postHooks:y,sourceByPhase:k}){let x=null,E=0;for(let g of h){let f=g.type||"handler";f!=="handler"&&E++;let C=f==="handler"?"handler":`${f} #${E}`,P;f==="preHook"?P=`
 (async () => {
   "use strict";
-  ${x.code}
+  ${g.code}
 })().then((__r) => {
   if (__r !== undefined) return JSON.stringify({ __shortCircuit: true, value: __r });
   return JSON.stringify({ __shortCircuit: false });
-});`:a=`
+});`:P=`
 (async () => {
   "use strict";
-  ${x.code}
+  ${g.code}
 })().then((__r) => {
   $ctx.$data = __r;
   return "__handler_done__";
-});`;try{let p=await(await T(u,a,`${l}.js`)).run(m,{timeout:B(t),promise:!0});if($==="preHook"&&typeof p=="string"){let h=JSON.parse(p);if(h.__shortCircuit){let M=await fe(u,m,h.value);await F({type:"result",id:t,success:!0,...M,shortCircuit:!0});return}}}catch(c){_=c;break}}if(!_&&k.length>0&&await(await T(u,'$ctx.$statusCode = 200; "__status_set__";',"set-status.js")).run(m,{timeout:5e3}),_&&k.length>0){let g=te(_,P),x={message:g.message||"Unknown error",name:_.constructor?.name||"Error",stack:_.stack||"",statusCode:g.statusCode||500,details:g.details||{},timestamp:new Date().toISOString()},$=`
-$ctx.$error = ${JSON.stringify(x)};
+});`;try{let M=await(await e(p,P,`${C}.js`)).run(w,{timeout:t(l),promise:!0});if(f==="preHook"&&typeof M=="string"){let U=JSON.parse(M);if(U.__shortCircuit){let q=await n(p,w,l,U.value);await r({...q,type:"result",id:l,success:!0,shortCircuit:!0});return}}}catch(S){x=Rt(S);break}}x&&Ce(x);let O=!!(x&&(p.isDisposed||At(x)||Nt(x)));if(!x&&y.length>0&&await(await e(p,'if ($ctx.$statusCode === undefined || $ctx.$statusCode === null) $ctx.$statusCode = 200; "__status_set__";',"set-status.js")).run(w,{timeout:t(l)}),x&&y.length>0&&!O){let g=Ot(x,k),f=Number(g.statusCode),C=Number.isInteger(f)&&f>=100&&f<=599?f:500,P={message:g.message||"Unknown error",name:x.constructor?.name||"Error",stack:x.stack||"",statusCode:C,details:g.details||{},timestamp:new Date().toISOString()},S=`
+$ctx.$error = ${JSON.stringify(P)};
 $ctx.$data = null;
-$ctx.$statusCode = ${x.statusCode};
+$ctx.$statusCode = ${JSON.stringify(P.statusCode)};
 if ($ctx.$api) {
-  $ctx.$api.error = ${JSON.stringify(x)};
+  $ctx.$api.error = ${JSON.stringify(P)};
   $ctx.$api.response = {
-    statusCode: ${x.statusCode},
+    statusCode: ${P.statusCode},
     responseTime: $ctx.$api.request && $ctx.$api.request.timestamp
       ? Date.now() - new Date($ctx.$api.request.timestamp).getTime()
       : 0,
-    timestamp: ${JSON.stringify(x.timestamp)},
+    timestamp: ${JSON.stringify(P.timestamp)},
   };
 }
-"__error_populated__";`;await(await u.compileScript($,{filename:"populate-error.js"})).run(m,{timeout:5e3})}for(let g=0;g<k.length;g++){let x=k[g],$=`postHook #${g+1}`,l=`
+"__error_populated__";`;await(await p.compileScript(S,{filename:"populate-error.js"})).run(w,{timeout:t(l)})}for(let g=0;g<y.length&&!O;g++){let f=y[g],C=`postHook #${g+1}`,P=`
 (async () => {
   "use strict";
-  ${x.code}
+  ${f.code}
 })().then((__r) => {
   if (__r !== undefined) $ctx.$data = __r;
   return "__posthook_done__";
-});`;try{await(await T(u,l,`${$}.js`)).run(m,{timeout:B(t),promise:!0})}catch(a){S.postMessage({type:"executionError",id:t,sourceKind:"postHook",scriptId:x.scriptId,error:{message:a.message,stack:a.stack,code:a.code}})}}if(_){we(_);let g=te(_,P);_.details&&(g.details={...g.details,..._.details});let x;try{let a=await(await T(u,"(async () => JSON.stringify(await __extractCtxChanges()))()","extract-error-ctx.js")).run(m,{timeout:5e3,promise:!0});x=JSON.parse(a)}catch{}await F({type:"result",id:t,success:!1,error:{message:g.message,statusCode:g.statusCode,errorPath:g.errorPath,stack:_.stack,code:g.code??_.code,details:g.details},ctxChanges:x}),(X(_)||Y(_))&&z(d,t,"sibling_execution_failure");return}let H=await fe(u,m);await F({type:"result",id:t,success:!0,...H})}catch(_){d.taskIds.has(t)&&(await Z(t,_),(X(_)||Y(_))&&z(d,t,"sibling_execution_failure"))}finally{await ke(d,m),ye(t,d)}}function V(e){U.cleanupTaskPackages(e)}function ze(){U.shutdownPackageRuntime()}process.on("exit",ze);async function fe(e,t,s){if(s!==void 0){let o=`__extractResult(${JSON.stringify(s)}, false)`,f=await(await e.compileScript(o,{filename:"extract.js"})).run(t,{timeout:5e3,promise:!0});return JSON.parse(f)}let i=await(await T(e,"__extractResult($ctx.$data, $ctx.$data === undefined)","extract.js")).run(t,{timeout:5e3,promise:!0});return JSON.parse(i)}
+});`;try{await(await e(p,P,`${C}.js`)).run(w,{timeout:t(l),promise:!0})}catch(S){let M=Rt(S);if(Ce(M),p.isDisposed||At(M)||Nt(M)){x=M,O=!0;break}s.postMessage({type:"executionError",id:l,sourceKind:"postHook",scriptId:f.scriptId,error:{message:M.message,stack:M.stack,code:M.code}})}}if(x){Ce(x),i(l,x,k);let g=Ot(x,k);x.details&&(g.details={...g.details,...x.details});let f;try{let S=await(await e(p,"(async () => JSON.stringify(await __extractCtxChanges()))()","extract-error-ctx.js")).run(w,{timeout:t(l),promise:!0});f=JSON.parse(S)}catch{}await r({type:"result",id:l,success:!1,error:{message:g.message,statusCode:g.statusCode,errorPath:g.errorPath,stack:x.stack,code:g.code??x.code,details:g.details},ctxChanges:f}),_(d,x)&&c(d,l,"sibling_execution_failure");return}let v=await n(p,w,l);await r({...v,type:"result",id:l,success:!0})}return{executeWorkerBatch:m}}It.exports={prepareWorkerBatch:Jr,createWorkerBatch:jr}});var Bt=A((Gn,$t)=>{"use strict";var{fork:zr}=require("child_process"),Hr=require("path"),Re=3e4,qr=2147483647,Vr=1e3;function Gr({workerDir:e,activeTaskContexts:t,getTaskRemainingTimeoutMs:n=()=>Re}){let r=new Map,i=new Map,s=new Map,c=new Map,_=new Map,m=new WeakSet,l=null,p=0,w=!1,d=1e3;function h(o){let a=Number(o);return Number.isFinite(a)?Math.max(1,Math.min(qr,Math.trunc(a))):Re}function y(o,a,u){let b=new Error(o);return b.code=a,b.details=u,b}function k(o){try{if(o instanceof Error)return o}catch{}if(o===null)return new Error("Operation rejected with null");if(o===void 0)return new Error("Operation rejected with undefined");try{return new Error(typeof o=="string"?o:String(o))}catch{return new Error("Operation rejected with a non-Error value")}}function x(o,a){for(let[u,b]of i)b.child===o&&(clearTimeout(b.timer),i.delete(u),s.delete(u),b.reject(a))}function E(o){for(let[a,u]of c)u.child===o&&(clearTimeout(u.timer),c.delete(a))}function O(o,a){if(!o||m.has(o))return;m.add(o),l===o&&(l=null),E(o),x(o,a);try{o.disconnect()}catch{}try{o.kill("SIGTERM")}catch{}let u=setTimeout(()=>{if(!(o.exitCode!==null||o.signalCode!==null))try{o.kill("SIGKILL")}catch{}},Vr);u.unref?.(),o.once("exit",()=>clearTimeout(u))}function v(o,a){if(!o.connected)return;let u=`cancel_${++p}`,b=setTimeout(()=>{c.delete(u),O(o,y("Package runtime did not acknowledge task cancellation","ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))},d);b.unref?.(),c.set(u,{child:o,timer:b});try{o.send({op:"cancelTask",taskId:a,id:u})}catch{clearTimeout(b),c.delete(u);try{o.kill()}catch{}}}function g(o,a){if(!o.connected){O(o,y("Package runtime IPC is closed","ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}));return}try{o.send(a,u=>{u&&O(o,y(u.message,"ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))})}catch(u){let b=k(u);O(o,y(b.message,"ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))}}function f(o,a,u=0){if(!(u>=128||!o||typeof o!="object")){if(Object.keys(o).length===1&&typeof o.__fnRef=="string"){a.add(o.__fnRef);return}if(Array.isArray(o)){for(let b of o)f(b,a,u+1);return}for(let b of Object.values(o))f(b,a,u+1)}}function C(o,a){let u;try{u=JSON.parse(a||"[]")}catch{return}let b=_.get(o);b||(b=new Set,_.set(o,b)),f(u,b)}function P(o){let a=typeof o=="string"?JSON.parse(o):o;if(a?.error)throw new Error(a.error);return a?.value}async function S(o,a){if(o!==l||m.has(o))throw new Error("Package callback runtime is no longer active");if(!_.get(a.taskId)?.has(a.callbackId))throw new Error("Package callback is not authorized for this task");let b=t.get(a.taskId);if(!b)throw new Error(`Package callback context not found: ${a.taskId}`);let R=JSON.stringify(a.callbackId),j=JSON.stringify(a.argsJson||"[]"),J=await b.evalClosure(`return __invokeRuntimeCallback(${R}, ${j});`,[],{arguments:{copy:!0},result:{promise:!0,copy:!0},timeout:n(a.taskId)});return P(J)}function M(){if(w)throw y("Package runtime is shut down","ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1});if(l&&l.connected)return l;let o=Hr.join(e,"package-runtime.child.js"),a=zr(o,[],{stdio:["ignore","ignore","ignore","ipc"],env:{PATH:process.env.PATH||"",HOME:process.env.HOME||"",NODE_ENV:process.env.NODE_ENV||"production",TMPDIR:process.env.TMPDIR||"",LANG:process.env.LANG||""}});return l=a,a.on("message",u=>{if(!u||!u.id)return;if(u.type==="pkgStreamChunk"){let R=s.get(u.id);if(!R)return;Promise.resolve().then(()=>R.onChunk(Buffer.from(u.chunk||"","base64"))).then(()=>{try{a.send({type:"pkgStreamAck",ackId:u.ackId})}catch{}}).catch(j=>{let J=k(j);try{a.send({type:"pkgStreamError",ackId:u.ackId,error:{message:J.message,stack:J.stack}})}catch{}});return}if(u.type==="taskCancelled"){let R=c.get(u.id);if(!R||R.child!==a)return;clearTimeout(R.timer),c.delete(u.id);return}if(u.type==="pkgCallbackCall"){S(a,u).then(R=>{g(a,{type:"pkgCallbackResult",id:u.id,value:R})}).catch(R=>{let j=k(R);g(a,{type:"pkgCallbackError",id:u.id,error:{message:j.message,stack:j.stack}})});return}let b=i.get(u.id);if(b)if(clearTimeout(b.timer),i.delete(u.id),s.delete(u.id),u.ok)b.resolve(u.value);else{u.error?.code==="ERR_PACKAGE_RUNTIME_TIMEOUT"&&v(a,b.taskId);let R=y(u.error?.message||"Package runtime call failed",u.error?.code,u.error?.details);R.stack=u.error?.stack||R.stack,b.reject(R)}}),a.on("exit",(u,b)=>{O(a,y(`Package runtime exited${b?` with signal ${b}`:` with code ${u}`}`,"ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))}),a.on("disconnect",()=>{O(a,y("Package runtime disconnected","ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))}),a.on("error",u=>{O(a,y(u.message,"ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))}),a}function U(o){return new Promise((a,u)=>{let b=M();C(o.taskId,o.argsJson);let R=`pkg_${++p}`,j=h(o.timeoutMs),J=setTimeout(()=>{i.delete(R),s.delete(R),v(b,o.taskId),u(y(`Package runtime call timed out after ${j}ms`,"ERR_PACKAGE_RUNTIME_TIMEOUT",{outcome:"unknown_outcome",retryable:!1}))},j);i.set(R,{child:b,taskId:o.taskId,resolve:a,reject:u,timer:J});try{b.send({...o,timeoutMs:j,id:R},Z=>{Z&&(clearTimeout(J),i.delete(R),u(Z))})}catch(Z){clearTimeout(J),i.delete(R),u(Z)}})}function q(o,a,u,b=[],R=Re){return new Promise((j,J)=>{let Z=M(),W=`pkg_${++p}`,be=h(R),ke=setTimeout(()=>{i.delete(W),s.delete(W),v(Z,o),J(y(`Package runtime stream timed out after ${be}ms`,"ERR_PACKAGE_RUNTIME_TIMEOUT",{outcome:"unknown_outcome",retryable:!1}))},be);i.set(W,{child:Z,taskId:o,resolve:j,reject:J,timer:ke}),s.set(W,{onChunk:u});try{Z.send({op:"streamHandle",taskId:o,handleId:a,path:b,id:W,timeoutMs:be},_e=>{_e&&(clearTimeout(ke),i.delete(W),s.delete(W),J(_e))})}catch(_e){clearTimeout(ke),i.delete(W),s.delete(W),J(_e)}})}function D(o){try{if(!l||!l.connected)return;l.send({...o,id:`pkg_${++p}`,fire:!0})}catch{}}function L(o){try{if(!l||!l.connected)return;v(l,o)}catch{}}async function fe(o,a){let u=r.get(o);if(!u)throw new Error("Package context is not available");if(a.handleId!==null&&a.handleId!==void 0){if(a.kind!=="get"&&a.kind!=="call")throw new Error(`Unsupported package handle call kind: ${a.kind}`);return U({op:a.kind==="get"?"handleGet":"handleCall",taskId:o,handleId:a.handleId,path:a.path||[],argsJson:a.argsJson||"[]",timeoutMs:a.timeoutMs})}let b=u.get(a.packageName);if(!b)throw new Error(`Package "${a.packageName}" is not available`);if(a.kind!=="construct"&&a.kind!=="call")throw new Error(`Unsupported package call kind: ${a.kind}`);return U({op:a.kind==="construct"?"construct":"call",taskId:o,packageName:a.packageName,package:{name:b.name,fileUrl:b.fileUrl},path:a.path||[],argsJson:a.argsJson||"[]",timeoutMs:a.timeoutMs})}async function we(o,a){if(!r.get(o))throw new Error("Package context is not available");if(a.method==="open")return U({op:"streamIteratorOpen",taskId:o,handleId:a.handleId,path:a.path||[],timeoutMs:a.timeoutMs});if(a.method==="next")return U({op:"streamIteratorNext",taskId:o,streamId:a.streamId,streamTimeoutMs:a.streamTimeoutMs,timeoutMs:a.timeoutMs});if(a.method==="return")return U({op:"streamIteratorReturn",taskId:o,streamId:a.streamId,timeoutMs:a.timeoutMs});throw new Error(`Unsupported package stream method: ${a.method}`)}function Ue(o,a){r.set(o,a)}function T(o){r.delete(o),_.delete(o),D({op:"releaseTask",taskId:o})}function F(){w=!0;let o=l;o&&O(o,y("Package runtime was shut down","ERR_PACKAGE_RUNTIME_LOST",{outcome:"unknown_outcome",retryable:!1}))}return{cleanupTaskPackages:T,cancelTask:L,executePackageRuntimeCall:fe,executePackageStreamCall:we,setTaskPackages:Ue,streamPackageHandle:q,shutdownPackageRuntime:F}}$t.exports={createPackageRuntimeBridge:Gr}});var{normalizeThrownValue:me,buildErrorPayload:jt,isNativeExecutionTimeout:Kn,isIsolateMemoryLimit:Kr,normalizeNativeExecutionError:zt}=ie(),{getCachedScript:ye}=Se(),{createWorkerPackages:Wr}=Ge(),{createWorkerContext:Xr}=Et(),{createWorkerResponse:Yr}=Ct(),{prepareWorkerBatch:Qr,createWorkerBatch:Zr}=Ut(),{getTaskInnerGuardGraceMs:en}=(Te(),$e(Pe)),{interruptTask:tn}=Me(),{parentPort:Ht}=require("worker_threads"),N=Ht||{on(e,t){e==="message"&&process.on("message",t)},postMessage(e){process.send?.(e)}},{createPackageRuntimeBridge:rn}=Bt(),Ae;try{Ae=require("isolated-vm")}catch(e){N.postMessage({type:"error",message:"isolated-vm not available: "+e.message}),process.exit(1)}var Y=new Map,nn=0,V=new Map,I=new Map,B=new Map,ee=new Map,X=new Map,H=new Set,ae=new Set,K=new Set,te=new Set,le=new Set,G=rn({workerDir:__dirname,activeTaskContexts:V,getTaskRemainingTimeoutMs:ne}),an=1e5,on=128,sn=5e3,ln=25,qt={created:0,reused:0,released:0,evicted:0,scrubFailed:0},{PACKAGE_PROXY_FALLBACK:cn,loadEsmPackageIntoContext:un,validatePackageSources:Vt,collectIsolatePackageNames:Gt}=Wr(ne),{executeResCall:dn}=Yr({callMain:tr,activeTaskContexts:V,getTaskRemainingTimeoutMs:ne,getTaskInnerGuardTimeoutMs:Oe,packageRuntimeBridge:G}),{prepareContext:Kt,releaseContext:Ne,extractFinalResult:fn}=Xr({ivm:Ae,packageRuntimeBridge:G,contextStats:qt,getCachedScript:ye,getTaskRemainingTimeoutMs:ne,loadEsmPackageIntoContext:un,PACKAGE_PROXY_FALLBACK:cn,executeResCall:dn,callMain:tr,waitForStreamTimer:mn,clearStreamTimer:pn,cleanupTaskPackages:Q,isTaskCancelled:e=>K.has(e)}),{executeWorkerBatch:_n}=Zr({getCachedScript:ye,getTaskRemainingTimeoutMs:ne,extractFinalResult:fn,postResultMessage:he,reportTaskFailure:ge,runnerPort:N,failIsolateSiblings:de,isLaneUnusable:ue});function ne(e){let t=B.get(e);return Math.max(1,Math.ceil((t??Date.now()+3e4)-Date.now()))}function Oe(e){let t=B.get(e)??Date.now()+3e4,n=en(ee.get(e)??3e4);return Math.min(2147483647,Math.max(1,Math.ceil(t+n-Date.now())))}function pn(e,t){let n=X.get(e),r=n?.get(t);return r?(clearTimeout(r.timer),n.delete(t),n.size===0&&X.delete(e),r.resolve(!1),!0):!1}function oe(e){let t=X.get(e);if(t){X.delete(e);for(let n of t.values())clearTimeout(n.timer),n.resolve(!1)}}function se(e,t="Task is no longer active"){for(let[n,r]of Y)r.taskId===e&&(Y.delete(n),clearTimeout(r.timer),r.reject(new Error(t)))}function Wt(e){for(le.add(e);le.size>an;)le.delete(le.values().next().value)}function mn(e,t,n){let r=X.get(e)?.get(t);r&&(clearTimeout(r.timer),X.get(e).delete(t),r.resolve(!1));let i=Math.max(1,Math.min(Math.trunc(Number(n)||1),Oe(e))),s=X.get(e);return s||(s=new Map,X.set(e,s)),new Promise(c=>{let _=setTimeout(()=>{s.delete(t),s.size===0&&X.delete(e),c(!0)},i);s.set(t,{timer:_,resolve:c})})}var $=null,ce=null,Dt=0,Lt=0,Ft=0;async function yn(){let e=Date.now();if(e-Lt<sn)return Ft;if(Lt=e,!$)return 0;let t=$.map(s=>s?.isolate).filter(s=>s&&!s.isDisposed),n,r=await Promise.race([Promise.allSettled(t.map(s=>s.getHeapStatistics())),new Promise(s=>{n=setTimeout(()=>s([]),ln)})]);clearTimeout(n);let i=0;for(let s of r){if(s.status!=="fulfilled")continue;let c=s.value.heap_size_limit||1,_=s.value.used_heap_size/c;_>i&&(i=_)}return Ft=i,i}async function he(e,t={}){let n=e?.id;if(n){if(H.has(n)||ae.has(n)||K.has(n)||!t.allowInactive&&!I.has(n))return!1;ae.add(n)}try{if(e.heapRatio=await yn(),e.runnerRssBytes=process.memoryUsage().rss,e.contextStats=hn(),n){if(!t.allowInactive&&!I.has(n))return!1;H.add(n)}return N.postMessage(e),!0}finally{n&&ae.delete(n)}}function hn(){return{...qt,idle:0}}function Xt(e,t,n){if(!$)ce={memoryLimitMb:e,poolSize:t,tasksPerIsolate:n},$=new Array(t).fill(null);else if(ce.memoryLimitMb!==e||ce.poolSize!==t||ce.tasksPerIsolate!==n)throw new Error("Executor isolate pool configuration cannot change at runtime");for(let r=0;r<$.length;r++){let i=(Dt+r)%$.length,s=$[i];if((!s||!s.isolate||s.isolate.isDisposed)&&(s={isolate:new Ae.Isolate({memoryLimit:e,inspector:!0}),taskIds:new Set},$[i]=s),s.taskIds.size<n)return Dt=(i+1)%$.length,s}throw new Error("No isolate lane is available")}function Yt(e){return`${Array.isArray($)?$.indexOf(e):-1}`}function ue(e,t){return!!e?.isolate?.isDisposed||Kr(t)}function de(e,t,n){for(let r of[...e.taskIds]){if(r===t||ae.has(r))continue;e.taskIds.delete(r),I.delete(r),V.delete(r),B.delete(r),ee.delete(r),oe(r),se(r,n),G.cancelTask(r),Q(r),H.has(r)||(ge(r,Object.assign(new Error("Isolate was disposed because a sibling task could not continue"),{code:"ERR_EXECUTOR_ISOLATE_LOST",details:{outcome:"unknown_outcome",retryable:!1,reason:n}}),{}),H.add(r),N.postMessage({type:"result",id:r,success:!1,error:{message:"Isolate was disposed because a sibling task could not continue",code:"ERR_EXECUTOR_ISOLATE_LOST",details:{outcome:"unknown_outcome",retryable:!1,reason:n}}})),N.postMessage({type:"taskReleased",id:r}),H.delete(r),te.delete(r)}try{e.isolate.dispose()}catch{}}async function gn(e){if(H.has(e)||ae.has(e)||te.has(e)||K.has(e))return;let t=I.get(e);if(!t){N.postMessage({type:"taskCancelled",id:e});return}K.add(e);try{ue(t,null)&&de(t,e,"sibling_cancelled"),G.cancelTask(e),oe(e),se(e,"Task was cancelled"),Q(e);let n=V.get(e),r=!1,i=Ne(t,n).then(()=>{r=!0}),s;for(await Promise.race([i,new Promise(c=>{s=setTimeout(c,25)})]),clearTimeout(s);!r&&n&&!t.isolate.isDisposed;)await tn(t,n,()=>K.has(e)&&!r),r||await new Promise(c=>setTimeout(c,100));await i,I.delete(e),V.delete(e),B.delete(e),ee.delete(e),t.taskIds.delete(e),N.postMessage({type:"taskCancelled",id:e}),H.delete(e)}finally{K.delete(e),te.delete(e)}}function Qt(e,t){K.has(e)||I.get(e)!==t||!t.taskIds.has(e)||(t.taskIds.delete(e),V.delete(e),I.delete(e),B.delete(e),ee.delete(e),oe(e),se(e),Q(e),N.postMessage({type:"taskReleased",id:e}),H.delete(e),te.delete(e))}function Zt(e,t){return t.taskIds.has(e)&&!K.has(e)&&I.get(e)===t&&!t.isolate.isDisposed}function er(e,t,n,r){return!t.taskIds.has(e)||I.get(e)!==t?(B.delete(e),oe(e),se(e,"Task was cancelled during preparation"),G.cancelTask(e),Q(e),Promise.resolve()):(zt(n),ue(t,n)&&de(t,e,"sibling_preparation_failure"),B.delete(e),oe(e),se(e,"Task preparation failed"),I.delete(e),t.taskIds.delete(e),G.cancelTask(e),Q(e),Ie(e,n,r,{allowInactive:!0}).then(()=>{N.postMessage({type:"taskReleased",id:e}),H.delete(e),te.delete(e)}))}function wn(e){if(!e)return;let t=I.get(e);t&&t.taskIds.delete(e),I.delete(e),V.delete(e),B.delete(e),oe(e),se(e,"Task setup failed");try{G.cancelTask(e)}catch{}try{Q(e)}catch{}try{N.postMessage({type:"taskReleased",id:e})}catch{}H.delete(e),ae.delete(e),te.delete(e)}async function bn(e,t){let n=me(t);if(n.code==="ERR_EXECUTOR_DUPLICATE_TASK_ID"||n.code==="ERR_EXECUTOR_INVALID_TASK_ID"){N.postMessage({type:"protocolError",code:n.code,message:n.message});return}try{ge(e?.id,n,{}),await he({type:"result",id:e?.id,success:!1,error:{message:n.message,stack:n.stack,code:n.code}},{allowInactive:!0})}finally{wn(e?.id)}}function Jt(e,t){bn(e,t).catch(n=>{let r=me(n);try{N.postMessage({type:"protocolError",code:"ERR_EXECUTOR_RECOVERY_FAILED",message:r.message})}catch{}})}N.on("message",async e=>{if(!e||typeof e!="object"){N.postMessage({type:"protocolError",code:"ERR_EXECUTOR_INVALID_MESSAGE",message:"Executor message must be an object"});return}if(e.type==="execute")xn(e).catch(t=>Jt(e,t));else if(e.type==="executeBatch")vn(e).catch(t=>Jt(e,t));else if(e.type==="invokeRuntimeCallback")kn(e).catch(t=>{let n=me(t);try{N.postMessage({type:"runtimeCallbackResult",callId:e.callId,error:n.message})}catch{}});else if(e.type==="callResult"){let t=Y.get(e.callId);t&&(Y.delete(e.callId),clearTimeout(t.timer),t.resolve(e.result))}else if(e.type==="callError"){let t=Y.get(e.callId);t&&(Y.delete(e.callId),clearTimeout(t.timer),t.reject(new Error(e.error)))}else e.type==="cancelTask"?gn(e.id).catch(()=>{}):e.type==="shutdown"&&Sn()});async function kn(e){let t=V.get(e.id);if(!t){N.postMessage({type:"runtimeCallbackResult",callId:e.callId,error:`Runtime callback context not found: ${e.id}`});return}let n=await t.evalClosure(`return __invokeRuntimeCallback(${JSON.stringify(e.callbackId)}, ${JSON.stringify(e.argsJson||"[]")});`,[],{arguments:{copy:!0},result:{promise:!0,copy:!0},timeout:ne(e.id)}),r=JSON.parse(n);N.postMessage({...r,type:"runtimeCallbackResult",callId:e.callId})}function tr(e,t,n){return H.has(e)||K.has(e)||!I.has(e)||!B.has(e)?Promise.reject(new Error("Task is no longer active")):new Promise((r,i)=>{let s=`cb_${++nn}`,c=setTimeout(()=>{let _=Y.get(s);_&&(Y.delete(s),_.reject(new Error(`Host callback timed out: ${t}`)))},Oe(e));Y.set(s,{taskId:e,timer:c,resolve:r,reject:i}),N.postMessage({...n,type:t,id:e,callId:s})})}function ge(e,t,n){if(te.has(e)||K.has(e))return;te.add(e);let r=jt(t,n);N.postMessage({type:"taskFailure",id:e,error:{...r,stack:t.stack,code:r.code??t.code}})}async function Ie(e,t,n,r={}){t=me(t),zt(t),ge(e,t,n);let i=jt(t,n);t.details&&(i.details={...i.details,...t.details});let s,c=V.get(e),_=I.get(e);if(c&&_&&!_.isolate.isDisposed)try{let m=await ye(_.isolate,"JSON.stringify({logs: __logs, truncated: $ctx.$share.$logsTruncated === true})","extract-diagnostic-logs.js");s=JSON.parse(await m.run(c,{timeout:100}))}catch{}await he({type:"result",id:e,success:!1,diagnosticLogs:s,error:{...i,stack:t.stack,code:i.code??t.code}},{allowInactive:r.allowInactive===!0})}function rr(e){if(!e||typeof e!="string"){let t=new Error("Executor task id must be a non-empty string");throw t.code="ERR_EXECUTOR_INVALID_TASK_ID",t}if(I.has(e)||B.has(e)||H.has(e)||le.has(e)){let t=new Error(`Executor task id cannot be reused: ${e}`);throw t.code="ERR_EXECUTOR_DUPLICATE_TASK_ID",t}}function nr(e){let t=Number(e.timeoutMs??3e4),n=Number(e.memoryLimitMb??128),r=Number(e.isolatePoolSize??8),i=Number(e.tasksPerIsolate??1);if(!Number.isFinite(t)||!Number.isInteger(t)||t<=0||t>2147483647)throw new Error("Invalid executor timeoutMs");if(!Number.isFinite(n)||!Number.isInteger(n)||n<=0||n>on)throw new Error("Invalid executor memoryLimitMb");if(!Number.isFinite(r)||!Number.isInteger(r)||r<1||r>128)throw new Error("Invalid executor isolatePoolSize");if(!Number.isFinite(i)||!Number.isInteger(i)||i<1||i>64)throw new Error("Invalid executor tasksPerIsolate");return{timeoutMs:Math.trunc(t),memoryLimitMb:Math.trunc(n),isolatePoolSize:Math.trunc(r),tasksPerIsolate:Math.trunc(i)}}async function xn(e){let{id:t,code:n,pkgSources:r,snapshot:i}=e;rr(t),Wt(t);let{timeoutMs:s,memoryLimitMb:c,isolatePoolSize:_,tasksPerIsolate:m}=nr(e),l={handler:e.sourceCode||n||""},p=Vt(r),w=Date.now()+s;B.set(t,w),ee.set(t,s);let d=Gt(n,p),h=Xt(c,_,m);h.taskIds.add(t),I.set(t,h);let y=h.isolate,k;try{k=await Kt(h,t,p,i,d,s,w)}catch(E){await er(t,h,E,l);return}if(!Zt(t,h)){try{k.release()}catch{}G.cancelTask(t),Q(t);return}V.set(t,k);let x=ee.get(t);x!==void 0&&B.set(t,Date.now()+x),N.postMessage({type:"taskLane",id:t,laneKey:Yt(h)});try{let E=`
+(async () => {
+  "use strict";
+  ${n}
+})().then((__result) => __extractResult(__result, __result === undefined));
+`,v=await(await ye(y,E,"handler.js")).run(k,{timeout:ne(t),promise:!0}),g=JSON.parse(v);await he({...g,type:"result",id:t,success:!0})}catch(E){h.taskIds.has(t)&&(await Ie(t,E,l),ue(h,E)&&de(h,t,"sibling_execution_failure"))}finally{try{await Ne(h,k)}finally{Qt(t,h)}}}async function vn(e){let{id:t,codeBlocks:n,pkgSources:r,snapshot:i}=e;rr(t),Wt(t);let{preHooksAndHandler:s,postHooks:c,sourceByPhase:_}=Qr(n),{timeoutMs:m,memoryLimitMb:l,isolatePoolSize:p,tasksPerIsolate:w}=nr(e),d=Vt(r),h=Date.now()+m;B.set(t,h),ee.set(t,m);let y=Gt((n||[]).map(v=>v.code||"").join(`
+`),d),k=Xt(l,p,w);k.taskIds.add(t),I.set(t,k);let x=k.isolate,E;try{E=await Kt(k,t,d,i,y,m,h)}catch(v){await er(t,k,v,_);return}if(!Zt(t,k)){try{E.release()}catch{}G.cancelTask(t),Q(t);return}V.set(t,E);let O=ee.get(t);O!==void 0&&B.set(t,Date.now()+O),N.postMessage({type:"taskLane",id:t,laneKey:Yt(k)});try{await _n({id:t,isolate:x,context:E,entry:k,preHooksAndHandler:s,postHooks:c,sourceByPhase:_})}catch(v){k.taskIds.has(t)&&(await Ie(t,v,_),ue(k,v)&&de(k,t,"sibling_execution_failure"))}finally{try{await Ne(k,E)}finally{Qt(t,k)}}}function Q(e){G.cleanupTaskPackages(e)}function ar(){G.shutdownPackageRuntime()}function Sn(){if(ar(),$){for(let e of $)if(!(!e?.isolate||e.isolate.isDisposed))try{e.isolate.dispose()}catch{}$=null,ce=null}try{N.postMessage({type:"shutdownComplete"})}catch{}Ht?.close()}process.on("exit",ar);