@scriptc/compiler 0.2.0 → 0.2.2

package/dist/backend/llvm/emitter.d.ts

@@ -25,6 +25,8 @@ export interface LlvmTargetOptions {
     runtimeAbiMarker?: boolean;
 }
 export declare function emitLlvmModule(mod: IrModule, options?: LlvmTargetOptions): string;
+/** Keep large translation units below the host's single-string limit. */
+export declare function emitLlvmModuleSource(mod: IrModule, options?: LlvmTargetOptions): string | readonly string[];
 export declare class LlEmitter {
     readonly mod: IrModule;
     private readonly debug;
@@ -42,8 +44,8 @@ export declare class LlEmitter {
      * immortal (rc == SIZE_MAX) static per (union, unit tag).
      * RC entry points and the collector skip immortals. */
     private readonly unitInstances;
-    /** Interned regex literals: "<flags>/<pattern>" → { symbol, interned
-     * source/flags literal refs } — one immortal ScrRegex per distinct
+    /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
+     * source/flags literal refs } — one immortal ScrRegex template per distinct
      * (pattern, flags) pair; the bytecode slot starts null and the runtime
      * compiles it lazily on first use. The source/flags strings intern at
      * REGISTRATION (bodies emit before the literal table flushes). */
@@ -216,6 +218,7 @@ export declare class LlEmitter {
      * outer native call. */
     private emitFfiCallbackDefs;
     emit(): string;
+    emitParts(): string[];
     /** LIBRARY mode: the profile-declared external definitions — the
      * export-map wrappers plus init / sink-registration / reset / collect.
      * Plain `define` (not `define internal`) — the exact linkage distinction
@@ -538,7 +541,7 @@ export declare class LlEmitter {
     }): string;
     cryptoBytesThunkFor(cbT: IrType & {
         kind: "func";
-    }): string;
+    }, arrayBuffer?: boolean): string;
     zlibBytesThunkFor(cbT: IrType & {
         kind: "func";
     }): string;

package/dist/backend/llvm/emitter.js

@@ -30,7 +30,7 @@ import { findConstantNumericTables } from "../../ir/constant-tables.js";
 import { allocateFfiCallbackAdapters, hasForeignFfiCallback, hasRetainedFfiCallback } from "../ffi-callbacks.js";
 import { RUNTIME_ABI_MARKER } from "../runtime-abi.js";
 import { computeMayThrow } from "../may-throw.js";
-import { mangleArgPack, mangleAsyncSpawn, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper } from "../mangle.js";
+import { mangleArgPack, mangleAsyncSpawn, mangleClassObj, mangleClassStruct, mangleFnClosure, mangleFunction, mangleGenDrop, mangleGenSpawn, mangleGlobal, mangleLocal, mangleRecordStruct, mangleTrampoline, mangleWrapper, mangleVtInstance } from "../mangle.js";
 import { BlockBuilder } from "./blocks.js";
 import { LlvmDebugInfo } from "./debug-info.js";
 import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl, llvmCommentText } from "./common.js";
@@ -57,7 +57,7 @@ import { buildClassGraph, classEnvironmentIndex, classFieldIndex, classStructSym
 import { LlDyn } from "./dyn.js";
 import { LlvmUnsupportedError } from "./unsupported.js";
 import { LlWalkers } from "./walkers.js";
-import { arrNewCall, boxAccess, boxNewCall, computeTraced, elemAccess, FN_ATTRS, llFieldType, releaseSym, retainSym, traceArg, vAdapters, } from "./shapes.js";
+import { arrNewCall, boxAccess, boxNewCall, computeTraced, elemAccess, FN_ATTRS, llFieldType, releaseSym, retainSym, traceArg, typedRefConstructor, vAdapters, } from "./shapes.js";
 export { LlvmUnsupportedError } from "./unsupported.js";
 function ffiCallbackDummyLl(callback) {
     switch (callback.returns) {
@@ -88,6 +88,14 @@ export function emitLlvmModule(mod, options = {}) {
     // Keep source storage intact for debugger inspection in dev builds.
     return new LlEmitter(options.debugSources === undefined ? scalarizeNumericRecords(mod) : mod, options).emit();
 }
+/** Keep large translation units below the host's single-string limit. */
+export function emitLlvmModuleSource(mod, options = {}) {
+    const parts = new LlEmitter(options.debugSources === undefined ? scalarizeNumericRecords(mod) : mod, options).emitParts();
+    const length = parts.reduce((total, part) => total + part.length, Math.max(0, parts.length - 1));
+    if (length <= 256 * 1024 * 1024)
+        return parts.join("\n");
+    return parts.flatMap((part, index) => index === 0 ? [part] : ["\n", part]);
+}
 function llStrBytes(text) {
     return llBytes(Buffer.from(text, "utf8"));
 }
@@ -108,8 +116,8 @@ export class LlEmitter {
      * immortal (rc == SIZE_MAX) static per (union, unit tag).
      * RC entry points and the collector skip immortals. */
     unitInstances = new Map();
-    /** Interned regex literals: "<flags>/<pattern>" → { symbol, interned
-     * source/flags literal refs } — one immortal ScrRegex per distinct
+    /** Regex literal templates: "<flags>/<pattern>" → { symbol, interned
+     * source/flags literal refs } — one immortal ScrRegex template per distinct
      * (pattern, flags) pair; the bytecode slot starts null and the runtime
      * compiles it lazily on first use. The source/flags strings intern at
      * REGISTRATION (bodies emit before the literal table flushes). */
@@ -310,6 +318,8 @@ export class LlEmitter {
             cstr: (text) => this.cstr(text),
             unitInstanceRef: (unionId, tag) => this.unitInstanceRef(unionId, tag),
             liveDynRefAdapter: (type) => this.liveDynRefAdapter(type),
+            liveDynUnionRefAdapter: (type) => this.liveDynUnionRefAdapter(type),
+            dynPromiseAdapter: (type) => this.dynPromiseAdapter(type),
             isErrorClass: (name) => this.classMeta.get(name)?.root.def.name === "%Error",
             classSubtypes: (name) => {
                 const target = this.classMetaOf(name);
@@ -670,11 +680,32 @@ export class LlEmitter {
         return { globals, defs };
     }
     emit() {
+        return this.emitParts().join("\n");
+    }
+    emitParts() {
         // Function bodies first (the literal/unit/fn-value tables fill as they
         // emit), then the file assembles around them — the runtime ABI’s order.
         const fnDefs = [];
         for (const fn of this.mod.functions)
             fnDefs.push(this.emitFunction(fn));
+        const errorViews = [];
+        for (const property of ["name", "message"])
+            if (this.mod.functions.some((fn) => fn.name === `%error.${property}.read`)) {
+                this.declare(`declare void @scr_error_install_${property}_reader(ptr)`);
+                errorViews.push(`  call void @scr_error_install_${property}_reader(ptr @${mangleFunction(`%error.${property}.read`)})`);
+            }
+        for (const meta of this.classMeta.values()) {
+            if (meta.def.runtime || meta.root.def.name !== "%Error")
+                continue;
+            const type = { kind: "object", className: meta.def.name };
+            const adapter = this.liveDynRefAdapter(type);
+            const rc = vAdapters(this.shapeHost, type);
+            const key = typeKey(type);
+            const name = `sc_error_view_${errorViews.length}`;
+            this.resolveThunkDefs.push(`define internal ptr @${name}(ptr %v) ${FN_ATTRS} {`, `entry:`, `  %d = call ptr ${typedRefConstructor(this.shapeHost, type)}(ptr %v, ptr ${rc.retain}, ptr ${rc.release}, ptr ${this.cstr(key)}, ${this.sizeType} ${Buffer.byteLength(key, "utf8")}, ptr @${adapter.snapshot}, ptr ${adapter.commit})`, `  ret ptr %d`, `}`, ``);
+            this.declare(`declare void @scr_error_register_dyn(ptr, ptr)`);
+            errorViews.push(`  call void @scr_error_register_dyn(ptr @${mangleVtInstance(meta.def.name)}, ptr @${name})`);
+        }
         const layouts = emitLlvmLayouts(this.shapeHost, this.mod, this.classMeta, this.classObjs, this.fnByName, (t) => this.llType(t));
         const shapes = layouts.records;
         const classShapes = layouts.classes;
@@ -723,9 +754,11 @@ export class LlEmitter {
         // sc_release_globals tail). Only when the dispatch unit is even
         // linked (defineProps is the only writer).
         const runtimeFeatures = moduleRuntimeFeatures(this.mod);
-        const fnValueProps = runtimeFeatures.dynInvoke ? [...this.fnValues] : [];
+        const fnValueProps = [...this.fnValues];
         if (fnValueProps.length > 0)
             this.declare(`declare void @scr_box_release(ptr)`);
+        if (this.classObjs.size > 0)
+            this.declare(`declare void @scr_classobj_clear_properties(ptr)`);
         const globalReleaseLines = (prefix) => {
             const lines = [];
             globals.forEach((g, i) => {
@@ -738,6 +771,8 @@ export class LlEmitter {
                 // cleared so a second release path stays idempotent.
                 lines.push(`  %${prefix}fp${i} = load ptr, ptr getelementptr inbounds (%ScrClosure, ptr @${mangleFnClosure(name)}, i64 0, i32 3)`, `  call void @scr_box_release(ptr %${prefix}fp${i}) ; ${name}.props`, `  store ptr null, ptr getelementptr inbounds (%ScrClosure, ptr @${mangleFnClosure(name)}, i64 0, i32 3)`);
             });
+            for (const name of this.classObjs.keys())
+                lines.push(`  call void @scr_classobj_clear_properties(ptr @${mangleClassObj(name)})`);
             return lines;
         };
         // Exit listeners can read MODULE GLOBALS directly, so they must run
@@ -781,6 +816,15 @@ export class LlEmitter {
             this.declare(`declare void @scr_events_install()`);
         if (usesChildProcess)
             this.declare(`declare void @scr_child_dyn_install()`);
+        const childStreamBoxes = usesChildProcess && usesStream &&
+            this.classMeta.has("%Readable") && this.classMeta.has("%Writable")
+            ? [this.dyn.toDynHelper({ kind: "object", className: "%Readable" }),
+                this.dyn.toDynHelper({ kind: "object", className: "%Writable" })]
+            : null;
+        if (childStreamBoxes) {
+            this.declare(`@scr_stream_child_ops = external constant { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }`);
+            this.declare(`declare void @scr_child_dyn_streams_install(ptr, ptr, ptr)`);
+        }
         if (usesFsWatch)
             this.declare(`declare void @scr_watch_install()`);
         if (this.ffiHasForeignCallback)
@@ -970,16 +1014,16 @@ export class LlEmitter {
             `%ScrUnion = type { ${this.sizeType}, i32, ptr, ptr, ptr, i64 }`,
             `%ScrClosure = type { ${this.sizeType}, ptr, ${this.sizeType}, ptr, i32 }`,
             `%ScrFfiTable = type { ptr, ${this.sizeType}, ${this.sizeType}, ptr, i8, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
-            `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr }`,
+            `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr, double, ptr }`,
             // ScrArr mirrors scr_runtime.h field-for-field. Live dynamic stream
             // commits swap its mutable dense, sparse, presence, and property
             // storage while preserving the target object's identity.
-            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ${this.sizeType} }`,
+            `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ${this.sizeType}, ptr }`,
             // The runtime error prefix { rc, vt, name, message, code, cause } and the
             // class-object shape { rc, pre, post, ctor, name } — field reads on
             // builtin errors and classval loads GEP through these.
-            `%ScrError = type { ${this.sizeType}, ptr, ptr, ptr, ptr, ptr }`,
-            `%ScrClassObj = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ptr }`,
+            `%ScrError = type { ${this.sizeType}, ptr, ptr, ptr, ptr, ptr, i8, i8, i8, i8, i8, ptr, ptr }`,
+            `%ScrClassObj = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`,
             // The runtime emitter prefix { rc, vt, reg, cls } — user subclasses
             // embed it (classes.ts), and bare-emitter GEPs address through it.
             `%ScrEmitter = type { ${this.sizeType}, ptr, ptr, ptr }`,
@@ -1054,7 +1098,7 @@ export class LlEmitter {
             // One immortal ScrRegex per (pattern, flags) literal, pointing at
             // the interned source/flags strings. The bc slot starts null (lazy
             // compile, cached by the runtime) — a mutable global, not constant.
-            out.push(`@${re.sym} = internal ${tl}global %ScrRegex { ${this.sizeType} -1, ptr ${re.src}, ptr ${re.fl}, ptr null } ; ${key.replace(/\n/g, "\\n")}`);
+            out.push(`@${re.sym} = internal ${tl}global %ScrRegex { ${this.sizeType} -1, ptr ${re.src}, ptr ${re.fl}, ptr null, double 0.0, ptr null } ; ${key.replace(/\n/g, "\\n")}`);
         }
         if (this.regexInstances.size > 0)
             out.push(``);
@@ -1068,7 +1112,7 @@ export class LlEmitter {
             const present = n === 0
                 ? "zeroinitializer"
                 : `[ ${inst.slots.map(() => "i8 1").join(", ")} ]`;
-            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, ptr null, ptr null, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null, ${this.sizeType} 0, ${this.sizeType} 0, ptr null, ${this.sizeType} 0, ${this.sizeType} 0 }`);
+            out.push(`@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, ptr null, ptr null, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null, ${this.sizeType} 0, ${this.sizeType} 0, ptr null, ${this.sizeType} 0, ${this.sizeType} 0, ptr null }`);
         }
         if (this.templateStringsInstances.size > 0)
             out.push(``);
@@ -1145,12 +1189,15 @@ export class LlEmitter {
             out.push(line);
         for (const line of this.resolveThunkDefs)
             out.push(line);
-        out.push(fnDefs.join("\n\n"), ``);
+        out.push(fnDefs[0] ?? "");
+        for (let i = 1; i < fnDefs.length; i++)
+            out.push("", fnDefs[i]);
+        out.push("");
         // main(): scr_init, the program-dependent error-vt interval stamps,
         // scr_lib_init(argc, argv), then the entry function. An uncaught
         // exception escaping top-level code prints and exits 1 (Node).
         // The exception epilogue is emitted when the entry may throw.
-        const stamps = [];
+        const stamps = [...errorViews];
         for (const iv of this.errorIntervals) {
             const fields = [[0, iv.pre], [1, iv.post]];
             for (const [field, value] of fields) {
@@ -1202,13 +1249,13 @@ export class LlEmitter {
             out.push(``);
             if (this.debug !== null)
                 out.push(this.debug.render());
-            return out.join("\n");
+            return out;
         }
         out.push(`define i32 @${this.wasi ? "__main_argc_argv" : "main"}(i32 %argc, ptr %argv) ${FN_ATTRS} {`, `entry:`, ...(this.runtimeAbiMarker ? [`  call void @${RUNTIME_ABI_MARKER}()`] : []), `  call void @scr_init()`, ...stamps, 
         // Event-surface programs (signal/exit listeners) fill the loop's
         // nullable event hooks before %main — scr_events.c links only when
         // this line is emitted (native-toolchain.ts gates on the same predicate).
-        ...(usesEvents ? [`  call void @scr_events_install()`] : []), ...(usesChildProcess ? [`  call void @scr_child_dyn_install()`] : []), 
+        ...(usesEvents ? [`  call void @scr_events_install()`] : []), ...(usesChildProcess ? [`  call void @scr_child_dyn_install()`] : []), ...(childStreamBoxes ? [`  call void @scr_child_dyn_streams_install(ptr @scr_stream_child_ops, ptr @${childStreamBoxes[0]}, ptr @${childStreamBoxes[1]})`] : []), 
         // fs.watch programs fill the loop's watch hooks the same way —
         // scr_watch.c links only when this line is emitted.
         ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(this.ffiHasForeignCallback ? [`  call void @scr_ffi_install()`] : []), ...(snapshotsTlsCa ? [`  call void @scr_tls_ca_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(embedsZlib ? [`  call void @scr_zlib_island_install()`] : []), ...(embedsNet ? [`  call void @scr_net_island_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesDgram ? [`  call void @scr_dgram_install()`] : []), ...(usesHttp2 ? [`  call void @scr_http2_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(usesIsland
@@ -1314,7 +1361,7 @@ export class LlEmitter {
         `attributes #0 = { sanitize_address }`, ...(this.wasi ? [`attributes #1 = { sanitize_address presplitcoroutine }`] : []), ...(hasNoInlineRecordClone ? [`attributes #2 = { noinline sanitize_address }`] : []), ``);
         if (this.debug !== null)
             out.push(this.debug.render());
-        return out.join("\n");
+        return out;
     }
     /** LIBRARY mode: the profile-declared external definitions — the
      * export-map wrappers plus init / sink-registration / reset / collect.
@@ -1682,6 +1729,10 @@ export class LlEmitter {
                         this.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
                         tr.push(`  call void @scr_promise_fulfill_str(ptr %pr, ptr %r) ; moves in`);
                         break;
+                    case "dyn":
+                        this.declare(`declare void @scr_promise_resolve_dyn(ptr, ptr)`);
+                        tr.push(`  call void @scr_promise_resolve_dyn(ptr %pr, ptr %r) ; moves in`);
+                        break;
                     default: {
                         const v = vAdapters(this.shapeHost, ret);
                         this.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
@@ -2784,6 +2835,10 @@ export class LlEmitter {
                 this.declare(`declare void @scr_promise_fulfill_str(ptr, ptr)`);
                 this.B.line(`call void @scr_promise_fulfill_str(ptr ${pr}, ptr ${v.name}) ; moves in`);
                 break;
+            case "dyn":
+                this.declare(`declare void @scr_promise_resolve_dyn(ptr, ptr)`);
+                this.B.line(`call void @scr_promise_resolve_dyn(ptr ${pr}, ptr ${v.name}) ; moves in`);
+                break;
             default: {
                 const rc = vAdapters(this.shapeHost, ret);
                 this.declare(`declare void @scr_promise_fulfill_ref(ptr, ptr, ptr, ptr, ptr)`);
@@ -3151,8 +3206,8 @@ export class LlEmitter {
             case "bytesSet": {
                 // Typed-array element write: same evaluation order as arraySet;
                 // the value is a scalar (the kind-specific inline path coerces
-                // JS-exactly), so no ownership moves. Any invalid index traps — no
-                // append. IrBytesElem is static, so never rediscover it through the
+                // JS-exactly), so no ownership moves. Invalid writes are ignored.
+                // IrBytesElem is static, so never rediscover it through the
                 // generic runtime switch in a hot loop.
                 const arr = this.emitStableReceiver(s.arr, [s.index, s.value]);
                 const integerIndex = this.emitIntegerLoopIndex(s.index);
@@ -3185,6 +3240,17 @@ export class LlEmitter {
                 else {
                     this.storeField(ptr, type, v.name);
                 }
+                if (s.kind === "fieldSet" && s.field === "name" && this.classMeta.get(s.className)?.root.def.name === "%Error") {
+                    const present = this.classFieldPtr(obj.name, s.className, "%namePresent").ptr;
+                    const enumerable = this.classFieldPtr(obj.name, s.className, "%nameEnumerable").ptr;
+                    const wasPresent = B.tmp(), wasEnumerable = B.tmp(), isPresent = B.tmp(), nextEnumerable = B.tmp();
+                    B.line(`${wasPresent} = load i8, ptr ${present}`);
+                    B.line(`${wasEnumerable} = load i8, ptr ${enumerable}`);
+                    B.line(`${isPresent} = icmp ne i8 ${wasPresent}, 0`);
+                    B.line(`${nextEnumerable} = select i1 ${isPresent}, i8 ${wasEnumerable}, i8 1`);
+                    B.line(`store i8 1, ptr ${present}`);
+                    B.line(`store i8 ${nextEnumerable}, ptr ${enumerable}`);
+                }
                 break;
             }
             case "recordKeyDelete": {
@@ -3709,10 +3775,9 @@ export class LlEmitter {
             case "rethrow": {
                 // Re-raise the saved snapshot (payload retained — the binding
                 // local releases with its scope) and unwind like `throw`.
-                const c = B.tmp();
-                B.line(`${c} = load ptr, ptr %${mangleLocal(s.localId)}`);
+                const c = this.emitExpr({ kind: "varRef", localId: s.localId, type: CAUGHT, loc: s.loc });
                 this.declare(`declare void @scr_rethrow(ptr)`);
-                B.line(`call void @scr_rethrow(ptr ${c})`);
+                B.line(`call void @scr_rethrow(ptr ${c.name})`);
                 this.emitUnwind();
                 break;
             }
@@ -3830,8 +3895,17 @@ export class LlEmitter {
                 this.emitBlock(s.catchBody, (scope) => {
                     const c = B.tmp();
                     B.line(`${c} = call ptr @scr_exc_take() ; catch binding`);
-                    B.line(`store ptr ${c}, ptr ${slot}`);
-                    scope.push({ slot, type: CAUGHT });
+                    if (this.currentLocals.get(s.catchLocalId)?.boxed) {
+                        const box = B.tmp();
+                        B.line(`${box} = ${boxNewCall(this.shapeHost, CAUGHT)} ; captured exception`);
+                        this.boxSet(box, CAUGHT, c);
+                        B.line(`store ptr ${box}, ptr ${slot}`);
+                        scope.push({ slot, type: CAUGHT, boxed: true });
+                    }
+                    else {
+                        B.line(`store ptr ${c}, ptr ${slot}`);
+                        scope.push({ slot, type: CAUGHT });
+                    }
                 });
             }
             else {
@@ -4189,8 +4263,8 @@ export class LlEmitter {
     fsRenameThunkFor(cbT) {
         return fsRenameThunkFor(this, cbT);
     }
-    cryptoBytesThunkFor(cbT) {
-        return cryptoBytesThunkFor(this, cbT);
+    cryptoBytesThunkFor(cbT, arrayBuffer = false) {
+        return cryptoBytesThunkFor(this, cbT, arrayBuffer);
     }
     zlibBytesThunkFor(cbT) {
         return zlibBytesThunkFor(this, cbT);