teptris 0.3.3 → 0.3.5

package/dist/teptris.mjs

@@ -1,2 +1,16 @@
-async function Module(moduleArg={}){var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("node:module");var require=createRequire(import.meta.url)}var programArgs=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("node:fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("node:path").dirname(require("node:url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}programArgs=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var isFileURI=filename=>filename.startsWith("file://");class EmscriptenEH{}class EmscriptenSjLj extends EmscriptenEH{}var runtimeInitialized=false;function getMemoryBuffer(){return wasmMemory.buffer}function updateMemoryViews(){if(HEAP8?.buffer?.resizable)return;var b=getMemoryBuffer();HEAP8=new Int8Array(b);HEAPU8=new Uint8Array(b)}function preRun(){var preRun=Module["preRun"];if(preRun){if(typeof preRun=="function")preRun=[preRun];onPreRuns.push(...preRun)}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["d"]()}function postRun(){var postRun=Module["postRun"];if(postRun){if(typeof postRun=="function")postRun=[postRun];onPostRuns.push(...postRun)}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what=`Aborted(${what})`;err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("teptris.wasm")}return new URL("teptris.wasm",import.meta.url).href}function getBinarySync(file){if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();var instantiateWasm=Module["instantiateWasm"];if(instantiateWasm){return new Promise(resolve=>{instantiateWasm(info,inst=>resolve(receiveInstance(inst)))})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var HEAP8;var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var onPreRuns=[];var noExitRuntime=true;var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var HEAPU8;var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var ___assert_fail=(condition,filename,line,func)=>abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["arguments"])programArgs=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];var preInit=Module["preInit"];if(preInit){if(typeof preInit=="function")Module["preInit"]=preInit=[preInit];while(preInit.length>0){preInit.shift()()}}}Module["UTF8ToString"]=UTF8ToString;Module["stringToUTF8"]=stringToUTF8;Module["lengthBytesUTF8"]=lengthBytesUTF8;var _teptris_wasm_load,_teptris_wasm_last_error,_teptris_wasm_last_error_line,_teptris_wasm_last_error_column,_teptris_wasm_json,_teptris_wasm_json_len,_teptris_wasm_free,_teptris_wasm_builder_new,_teptris_wasm_builder_free,_teptris_wasm_builder_put_string,_teptris_wasm_builder_put_integer,_teptris_wasm_builder_put_float,_teptris_wasm_builder_put_boolean,_teptris_wasm_builder_put_datetime,_teptris_wasm_builder_open_table,_teptris_wasm_builder_open_array,_teptris_wasm_builder_close,_teptris_wasm_builder_finish,_teptris_wasm_builder_finish_json_natural,_teptris_wasm_toml,_teptris_wasm_toml_len,_malloc,_teptris_version_string,memory,__indirect_function_table,wasmMemory;function assignWasmExports(wasmExports){_teptris_wasm_load=Module["_teptris_wasm_load"]=wasmExports["e"];_teptris_wasm_last_error=Module["_teptris_wasm_last_error"]=wasmExports["f"];_teptris_wasm_last_error_line=Module["_teptris_wasm_last_error_line"]=wasmExports["g"];_teptris_wasm_last_error_column=Module["_teptris_wasm_last_error_column"]=wasmExports["h"];_teptris_wasm_json=Module["_teptris_wasm_json"]=wasmExports["i"];_teptris_wasm_json_len=Module["_teptris_wasm_json_len"]=wasmExports["j"];_teptris_wasm_free=Module["_teptris_wasm_free"]=wasmExports["k"];_teptris_wasm_builder_new=Module["_teptris_wasm_builder_new"]=wasmExports["l"];_teptris_wasm_builder_free=Module["_teptris_wasm_builder_free"]=wasmExports["m"];_teptris_wasm_builder_put_string=Module["_teptris_wasm_builder_put_string"]=wasmExports["n"];_teptris_wasm_builder_put_integer=Module["_teptris_wasm_builder_put_integer"]=wasmExports["o"];_teptris_wasm_builder_put_float=Module["_teptris_wasm_builder_put_float"]=wasmExports["p"];_teptris_wasm_builder_put_boolean=Module["_teptris_wasm_builder_put_boolean"]=wasmExports["q"];_teptris_wasm_builder_put_datetime=Module["_teptris_wasm_builder_put_datetime"]=wasmExports["r"];_teptris_wasm_builder_open_table=Module["_teptris_wasm_builder_open_table"]=wasmExports["s"];_teptris_wasm_builder_open_array=Module["_teptris_wasm_builder_open_array"]=wasmExports["t"];_teptris_wasm_builder_close=Module["_teptris_wasm_builder_close"]=wasmExports["u"];_teptris_wasm_builder_finish=Module["_teptris_wasm_builder_finish"]=wasmExports["v"];_teptris_wasm_builder_finish_json_natural=Module["_teptris_wasm_builder_finish_json_natural"]=wasmExports["w"];_teptris_wasm_toml=Module["_teptris_wasm_toml"]=wasmExports["x"];_teptris_wasm_toml_len=Module["_teptris_wasm_toml_len"]=wasmExports["y"];_malloc=Module["_malloc"]=wasmExports["z"];_teptris_version_string=Module["_teptris_version_string"]=wasmExports["A"];memory=wasmMemory=wasmExports["c"];__indirect_function_table=wasmExports["__indirect_function_table"]}var wasmImports={a:___assert_fail,b:_emscripten_resize_heap};async function run(){preRun();var setStatus=Module["setStatus"];if(setStatus){setStatus("Running...");await new Promise(resolve=>setTimeout(resolve,1));setTimeout(setStatus,1,"")}if(ABORT)return;initRuntime();Module["onRuntimeInitialized"]?.();postRun()}var wasmExports;wasmExports=await createWasm();await run();
-;return Module}export default Module;
+
+var Module = (() => {
+  var _scriptName = import.meta.url;
+  
+  return (
+async function(moduleArg = {}) {
+  var moduleRtn;
+
+var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string"&&process.type!="renderer";if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("module");let dirname=import.meta.url;if(dirname.startsWith("data:")){dirname="/"}var require=createRequire(dirname)}var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");var nodePath=require("path");if(!import.meta.url.startsWith("data:")){scriptDirectory=nodePath.dirname(require("url").fileURLToPath(import.meta.url))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(!Module["thisProgram"]&&process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptName){scriptDirectory=_scriptName}if(scriptDirectory.startsWith("blob:")){scriptDirectory=""}else{scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}{readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];var wasmBinary=Module["wasmBinary"];var wasmMemory;var ABORT=false;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAP64,HEAPU64,HEAPF64;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b);Module["HEAP64"]=HEAP64=new BigInt64Array(b);Module["HEAPU64"]=HEAPU64=new BigUint64Array(b)}var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";var isDataURI=filename=>filename.startsWith(dataURIPrefix);var isFileURI=filename=>filename.startsWith("file://");function findWasmBinary(){if(Module["locateFile"]){var f="teptris.wasm";if(!isDataURI(f)){return locateFile(f)}return f}return new URL("teptris.wasm",import.meta.url).href}var wasmBinaryFile;function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["c"];updateMemoryViews();addOnInit(wasmExports["d"]);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);readyPromiseReject(e)}}wasmBinaryFile??=findWasmBinary();try{var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);receiveInstantiationResult(result);return result}catch(e){readyPromiseReject(e);return}}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var noExitRuntime=Module["noExitRuntime"]||true;var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead=NaN)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var ___assert_fail=(condition,filename,line,func)=>abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var wasmImports={a:___assert_fail,b:_emscripten_resize_heap};var wasmExports;createWasm();var ___wasm_call_ctors=()=>(___wasm_call_ctors=wasmExports["d"])();var _teptris_wasm_load=Module["_teptris_wasm_load"]=(a0,a1)=>(_teptris_wasm_load=Module["_teptris_wasm_load"]=wasmExports["e"])(a0,a1);var _teptris_wasm_last_error=Module["_teptris_wasm_last_error"]=()=>(_teptris_wasm_last_error=Module["_teptris_wasm_last_error"]=wasmExports["f"])();var _teptris_wasm_last_error_line=Module["_teptris_wasm_last_error_line"]=()=>(_teptris_wasm_last_error_line=Module["_teptris_wasm_last_error_line"]=wasmExports["g"])();var _teptris_wasm_last_error_column=Module["_teptris_wasm_last_error_column"]=()=>(_teptris_wasm_last_error_column=Module["_teptris_wasm_last_error_column"]=wasmExports["h"])();var _teptris_wasm_json=Module["_teptris_wasm_json"]=()=>(_teptris_wasm_json=Module["_teptris_wasm_json"]=wasmExports["i"])();var _teptris_wasm_json_len=Module["_teptris_wasm_json_len"]=()=>(_teptris_wasm_json_len=Module["_teptris_wasm_json_len"]=wasmExports["j"])();var _teptris_wasm_free=Module["_teptris_wasm_free"]=a0=>(_teptris_wasm_free=Module["_teptris_wasm_free"]=wasmExports["k"])(a0);var _teptris_wasm_alloc=Module["_teptris_wasm_alloc"]=a0=>(_teptris_wasm_alloc=Module["_teptris_wasm_alloc"]=wasmExports["l"])(a0);var _teptris_wasm_builder_new=Module["_teptris_wasm_builder_new"]=()=>(_teptris_wasm_builder_new=Module["_teptris_wasm_builder_new"]=wasmExports["m"])();var _teptris_wasm_builder_free=Module["_teptris_wasm_builder_free"]=a0=>(_teptris_wasm_builder_free=Module["_teptris_wasm_builder_free"]=wasmExports["n"])(a0);var _teptris_wasm_builder_put_string=Module["_teptris_wasm_builder_put_string"]=(a0,a1,a2)=>(_teptris_wasm_builder_put_string=Module["_teptris_wasm_builder_put_string"]=wasmExports["o"])(a0,a1,a2);var _teptris_wasm_builder_put_integer=Module["_teptris_wasm_builder_put_integer"]=(a0,a1,a2)=>(_teptris_wasm_builder_put_integer=Module["_teptris_wasm_builder_put_integer"]=wasmExports["p"])(a0,a1,a2);var _teptris_wasm_builder_put_float=Module["_teptris_wasm_builder_put_float"]=(a0,a1,a2)=>(_teptris_wasm_builder_put_float=Module["_teptris_wasm_builder_put_float"]=wasmExports["q"])(a0,a1,a2);var _teptris_wasm_builder_put_boolean=Module["_teptris_wasm_builder_put_boolean"]=(a0,a1,a2)=>(_teptris_wasm_builder_put_boolean=Module["_teptris_wasm_builder_put_boolean"]=wasmExports["r"])(a0,a1,a2);var _teptris_wasm_builder_put_datetime=Module["_teptris_wasm_builder_put_datetime"]=(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)=>(_teptris_wasm_builder_put_datetime=Module["_teptris_wasm_builder_put_datetime"]=wasmExports["s"])(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10);var _teptris_wasm_builder_open_table=Module["_teptris_wasm_builder_open_table"]=(a0,a1)=>(_teptris_wasm_builder_open_table=Module["_teptris_wasm_builder_open_table"]=wasmExports["t"])(a0,a1);var _teptris_wasm_builder_open_array=Module["_teptris_wasm_builder_open_array"]=(a0,a1)=>(_teptris_wasm_builder_open_array=Module["_teptris_wasm_builder_open_array"]=wasmExports["u"])(a0,a1);var _teptris_wasm_builder_close=Module["_teptris_wasm_builder_close"]=a0=>(_teptris_wasm_builder_close=Module["_teptris_wasm_builder_close"]=wasmExports["v"])(a0);var _teptris_wasm_builder_finish=Module["_teptris_wasm_builder_finish"]=a0=>(_teptris_wasm_builder_finish=Module["_teptris_wasm_builder_finish"]=wasmExports["w"])(a0);var _teptris_wasm_builder_finish_json_natural=Module["_teptris_wasm_builder_finish_json_natural"]=a0=>(_teptris_wasm_builder_finish_json_natural=Module["_teptris_wasm_builder_finish_json_natural"]=wasmExports["x"])(a0);var _teptris_wasm_toml=Module["_teptris_wasm_toml"]=()=>(_teptris_wasm_toml=Module["_teptris_wasm_toml"]=wasmExports["y"])();var _teptris_wasm_toml_len=Module["_teptris_wasm_toml_len"]=()=>(_teptris_wasm_toml_len=Module["_teptris_wasm_toml_len"]=wasmExports["z"])();var _teptris_wasm_plan_build=Module["_teptris_wasm_plan_build"]=(a0,a1,a2,a3,a4,a5)=>(_teptris_wasm_plan_build=Module["_teptris_wasm_plan_build"]=wasmExports["A"])(a0,a1,a2,a3,a4,a5);var _teptris_wasm_plan_free=Module["_teptris_wasm_plan_free"]=a0=>(_teptris_wasm_plan_free=Module["_teptris_wasm_plan_free"]=wasmExports["B"])(a0);var _teptris_wasm_poke_u32=Module["_teptris_wasm_poke_u32"]=(a0,a1,a2)=>(_teptris_wasm_poke_u32=Module["_teptris_wasm_poke_u32"]=wasmExports["C"])(a0,a1,a2);var _teptris_wasm_poke_u8=Module["_teptris_wasm_poke_u8"]=(a0,a1,a2)=>(_teptris_wasm_poke_u8=Module["_teptris_wasm_poke_u8"]=wasmExports["D"])(a0,a1,a2);var _teptris_wasm_plan_walk=Module["_teptris_wasm_plan_walk"]=(a0,a1,a2)=>(_teptris_wasm_plan_walk=Module["_teptris_wasm_plan_walk"]=wasmExports["E"])(a0,a1,a2);var _teptris_version_string=Module["_teptris_version_string"]=()=>(_teptris_version_string=Module["_teptris_version_string"]=wasmExports["G"])();Module["UTF8ToString"]=UTF8ToString;Module["stringToUTF8"]=stringToUTF8;Module["lengthBytesUTF8"]=lengthBytesUTF8;var calledRun;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function run(){if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run();moduleRtn=readyPromise;
+
+
+  return moduleRtn;
+}
+);
+})();
+export default Module;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teptris",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "TOML for JavaScript/TypeScript at libteptris speed (WebAssembly, no fallback) - version tracks the engine ({engine}.{iteration}; npm semver is 3-part)",
   "type": "module",
   "main": "src/index.js",
@@ -19,6 +19,10 @@
     "test": "node --test test/test.mjs test/package.test.mjs"
   },
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leptris/teptris-ts.git"
+  },
   "engines": {
     "node": ">=20"
   },

package/src/index.d.ts

@@ -47,6 +47,28 @@ export interface TeptrisApi {
 
   /** The libteptris engine version inside this build. */
   engineVersion(): string;
+
+  /** Compile a descriptor plan (once) — materialize only the planned
+   *  keys of any document via planWalk. Rows: a string name is a
+   *  scalar; kind "collection" walks an array; kind "raw" takes the
+   *  untouched subtree; rows: [...] walks a nested table. */
+  planBuild(rows: PlanRowSpec[]): number;
+
+  /** Walk one TOML document against the plan; returns only the
+   *  planned keys (natural shapes: RFC 3339 datetime strings,
+   *  non-finite floats as null). Throws on parse/plan errors. */
+  planWalk(plan: number, toml: string): TomlTable;
+
+  /** Release a compiled plan. */
+  planFree(plan: number): void;
+}
+
+/** One planned key of a {@link PlanRowSpec} tree. */
+export interface PlanRowSpec {
+  name: string;
+  kind?: "scalar" | "collection" | "raw";
+  /** Nested table rows — makes this row a nested table. */
+  rows?: PlanRowSpec[];
 }
 
 /** Instantiate the WebAssembly engine and return the API. */

package/src/index.js

@@ -5,7 +5,7 @@ const KIND_OFFSET = 4, KIND_LOCAL_DT = 5, KIND_DATE = 6, KIND_TIME = 7;
 
 function cstr(mod, s) {
   const bytes = mod.lengthBytesUTF8(s) + 1;
-  const ptr = mod._malloc(bytes);
+  const ptr = mod._teptris_wasm_alloc(bytes);
   mod.stringToUTF8(s, ptr, bytes);
   return ptr;
 }
@@ -199,7 +199,129 @@ export function initApi(mod) {
     return UTF8ToString(mod._teptris_version_string());
   }
 
-  return { loads, dump, dumpJson, engineVersion };
+  // ---- descriptor plans: compile once, materialize only planned keys
+
+  function planError() {
+    const e = new Error(UTF8ToString(mod._teptris_wasm_last_error()));
+    e.line = mod._teptris_wasm_last_error_line();
+    e.column = mod._teptris_wasm_last_error_column();
+    return e;
+  }
+
+  // rows: "name" (scalar) | { name, kind: "collection" | "raw" } |
+  // { name, rows: [...] } (nested). Returns an opaque plan handle.
+  function planBuild(rows) {
+    if (!Array.isArray(rows) || rows.length === 0) {
+      throw new TypeError("planBuild expects a non-empty array of rows");
+    }
+    const flat = []; // { np, kind, sub }
+    const first = [0];
+    const namePtrs = [];
+    const pending = []; // [flatSlot, children]
+    for (const r of rows) {
+      const name = typeof r === "string" ? r : r.name;
+      let kind = 1; // scalar
+      if (typeof r === "object" && Array.isArray(r.rows)) {
+        kind = 3; // nested — sub patched after the child block
+        const slot = flat.length;
+        const np = mod._teptris_wasm_alloc(name.length + 1);
+        stringToUTF8(name, np, name.length + 1);
+        namePtrs.push(np);
+        flat.push({ np, kind, sub: 0 });
+        pending.push([slot, r.rows]);
+      } else {
+        if (typeof r === "object" && r.kind === "collection") kind = 2;
+        else if (typeof r === "object" && r.kind === "raw") kind = 4;
+        const np = mod._teptris_wasm_alloc(name.length + 1);
+        stringToUTF8(name, np, name.length + 1);
+        namePtrs.push(np);
+        flat.push({ np, kind, sub: 0 });
+      }
+    }
+    // parent rows first; sub-plans laid out after them (first[] grows
+    // in plan order — the C layout contract). SIBLING nested rows must
+    // not capture the same index: patch sub after each child block.
+    for (const [slot, children] of pending) {
+      first.push(flat.length);
+      flattenInto(children, flat, first, namePtrs, pending);
+      flat[slot].sub = first.length - 1;
+    }
+    // the end sentinel for the last plan (first[] has plan_count+1
+    // entries — its absence made every sub index point past the end)
+    first.push(flat.length);
+    const namesBuf = mod._teptris_wasm_alloc(4 * flat.length);
+    const kindsBuf = mod._teptris_wasm_alloc(flat.length);
+    const subsBuf = mod._teptris_wasm_alloc(4 * flat.length);
+    const firstBuf = mod._teptris_wasm_alloc(4 * first.length);
+    flat.forEach((f, i) => {
+      mod._teptris_wasm_poke_u32(namesBuf, i, f.np);
+      mod._teptris_wasm_poke_u8(kindsBuf, i, f.kind);
+      mod._teptris_wasm_poke_u32(subsBuf, i, f.sub);
+    });
+    first.forEach((v, i) => mod._teptris_wasm_poke_u32(firstBuf, i, v));
+    const plan = mod._teptris_wasm_plan_build(
+      namesBuf, kindsBuf, subsBuf, flat.length, firstBuf, first.length);
+    namePtrs.forEach((np) => mod._teptris_wasm_free(np));
+    mod._teptris_wasm_free(namesBuf);
+    mod._teptris_wasm_free(kindsBuf);
+    mod._teptris_wasm_free(subsBuf);
+    mod._teptris_wasm_free(firstBuf);
+    if (!plan) {
+      throw planError();
+    }
+    return plan;
+  }
+
+  function flattenInto(rows, flat, first, namePtrs, pending) {
+    const slots = []; // [flatSlot, children]
+    for (const r of rows) {
+      const name = typeof r === "string" ? r : r.name;
+      let kind = 1;
+      if (typeof r === "object" && Array.isArray(r.rows)) {
+        kind = 3;
+        const slot = flat.length;
+        const np = mod._teptris_wasm_alloc(name.length + 1);
+        stringToUTF8(name, np, name.length + 1);
+        namePtrs.push(np);
+        flat.push({ np, kind, sub: 0 });
+        slots.push([slot, r.rows]);
+      } else {
+        if (typeof r === "object" && r.kind === "collection") kind = 2;
+        else if (typeof r === "object" && r.kind === "raw") kind = 4;
+        const np = mod._teptris_wasm_alloc(name.length + 1);
+        stringToUTF8(name, np, name.length + 1);
+        namePtrs.push(np);
+        flat.push({ np, kind, sub: 0 });
+      }
+    }
+    for (const [slot, children] of slots) {
+      first.push(flat.length);
+      flattenInto(children, flat, first, namePtrs, pending);
+      flat[slot].sub = first.length - 1;
+    }
+  }
+
+  function planWalk(plan, toml) {
+    if (typeof toml !== "string") {
+      throw new TypeError("planWalk expects a TOML string");
+    }
+    const p = cstr(mod, toml);
+    const st = mod._teptris_wasm_plan_walk(plan, p, lengthBytesUTF8(toml));
+    freeCstr(mod, p);
+    if (st !== 0) {
+      throw planError();
+    }
+    const jptr = mod._teptris_wasm_json();
+    const value = JSON.parse(UTF8ToString(jptr));
+    mod._teptris_wasm_free(jptr);
+    return value;
+  }
+
+  function planFree(plan) {
+    mod._teptris_wasm_plan_free(plan);
+  }
+
+  return { loads, dump, dumpJson, planBuild, planWalk, planFree, engineVersion };
 }
 
 // The consumer entry: instantiate the engine once, get the API.

package/src/teptris_wasm.c

@@ -59,6 +59,12 @@ int teptris_wasm_json_len(void) { return (int)g_json_len; }
 EMSCRIPTEN_KEEPALIVE
 void teptris_wasm_free(void *p) { free(p); }
 
+/* JS-side allocations MUST go through the same allocator as free()
+ * above: force-exporting _malloc alongside ASAN's own malloc/free
+ * splits the heap across two allocators and every free misreports. */
+EMSCRIPTEN_KEEPALIVE
+void *teptris_wasm_alloc(size_t n) { return malloc(n); }
+
 /* ---- builder surface (the dump side) ----------------------------- *
  * 1:1 with teptris_builder_*: the JS wrapper drives the same stack
  * discipline (open/close, NULL key = array element) the C and Rust
@@ -163,3 +169,418 @@ const char *teptris_wasm_toml(void) { return g_toml; }
 
 EMSCRIPTEN_KEEPALIVE
 int teptris_wasm_toml_len(void) { return (int)g_toml_len; }
+
+/* ------------------------------------------------ descriptor plans -- *
+ * Plan an once, walk many documents: only the planned keys are
+ * materialized (the engine plan API). The JS side flattens the plan
+ * tree honoring plan p's contiguous range [first[p], first[p+1]) and
+ * passes parallel arrays; materialization goes through the builder so
+ * the emitter stays the single formatting truth, and RAW rows re-use
+ * the plain node accessors. */
+
+#include "teptris/plan.h"
+
+EMSCRIPTEN_KEEPALIVE
+void *teptris_wasm_plan_build(const char **names, const uint8_t *kinds,
+                              const uint32_t *subs, uint32_t nrows,
+                              const uint32_t *first, uint32_t nfirst) {
+    if (nrows == 0 || nfirst < 2) {
+        snprintf(last_error, sizeof last_error, "plan needs rows");
+        return NULL;
+    }
+    teptris_plan_row *rows = malloc(nrows * sizeof *rows);
+    if (rows == NULL) {
+        return NULL;
+    }
+    for (uint32_t i = 0; i < nrows; i++) {
+        rows[i].name = names[i];
+        rows[i].kind = kinds[i];
+        rows[i].sub = subs[i];
+    }
+    teptris_plan_spec spec;
+    spec.abi_version = TEPTRIS_PLAN_ABI_VERSION;
+    spec.plan_count = nfirst - 1;
+    spec.plans = rows;
+    spec.plan_first_row = first;
+    teptris_status st;
+    teptris_plan *p = teptris_plan_build(&spec, &st);
+    free(rows);
+    if (st != TEPTRIS_OK) {
+        snprintf(last_error, sizeof last_error, "plan build failed (%s)",
+                 teptris_status_string(st));
+        return NULL;
+    }
+    return p;
+}
+
+EMSCRIPTEN_KEEPALIVE
+void teptris_wasm_plan_free(teptris_plan *plan) { teptris_plan_free(plan); }
+
+/* JS cannot write typed memory without heap views (which detach on
+ * memory growth) — two trivial pokes keep plan-spec assembly on the
+ * C side of the line. */
+EMSCRIPTEN_KEEPALIVE
+void teptris_wasm_poke_u32(uint32_t *p, uint32_t i, uint32_t v) {
+    p[i] = v;
+}
+
+EMSCRIPTEN_KEEPALIVE
+void teptris_wasm_poke_u8(uint8_t *p, uint32_t i, uint8_t v) {
+    p[i] = v;
+}
+
+static int put_scalar_result(teptris_builder *b, const char *key,
+                             const teptris_plan_result *res, uint32_t i) {
+    teptris_datetime dt;
+    switch (teptris_plan_result_value_kind_at(res, i)) {
+    case TEPTRIS_STRING: {
+        teptris_view v;
+        if (teptris_plan_result_string_at(res, i, &v) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_string(b, key, strlen(key), v.ptr, v.len)
+               != TEPTRIS_OK;
+    }
+    case TEPTRIS_INTEGER: {
+        int64_t iv;
+        if (teptris_plan_result_integer_at(res, i, &iv) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_integer(b, key, strlen(key), iv)
+               != TEPTRIS_OK;
+    }
+    case TEPTRIS_FLOAT: {
+        double dv;
+        if (teptris_plan_result_float_at(res, i, &dv) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_float(b, key, strlen(key), dv) != TEPTRIS_OK;
+    }
+    case TEPTRIS_BOOLEAN: {
+        bool bv;
+        if (teptris_plan_result_boolean_at(res, i, &bv) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_boolean(b, key, strlen(key), bv)
+               != TEPTRIS_OK;
+    }
+    case TEPTRIS_DATETIME_OFFSET:
+    case TEPTRIS_DATETIME_LOCAL:
+    case TEPTRIS_DATE_LOCAL:
+    case TEPTRIS_TIME_LOCAL:
+        if (teptris_plan_result_datetime_at(res, i, &dt) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_datetime(b, key, strlen(key),
+                                            (teptris_kind)teptris_plan_result_value_kind_at(
+                                                res, i),
+                                            &dt)
+               != TEPTRIS_OK;
+    default:
+        return 1;
+    }
+}
+
+static int put_array_scalar_result(teptris_builder *b,
+                                   const teptris_plan_result *res, uint32_t i,
+                                   uint32_t j) {
+    teptris_datetime dt;
+    switch (teptris_plan_result_array_value_kind_at(res, i, j)) {
+    case TEPTRIS_STRING: {
+        teptris_view v;
+        if (teptris_plan_result_array_string_at(res, i, j, &v) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_string(b, NULL, 0, v.ptr, v.len)
+               != TEPTRIS_OK;
+    }
+    case TEPTRIS_INTEGER: {
+        int64_t iv;
+        if (teptris_plan_result_array_integer_at(res, i, j, &iv)
+            != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_integer(b, NULL, 0, iv) != TEPTRIS_OK;
+    }
+    case TEPTRIS_FLOAT: {
+        double dv;
+        if (teptris_plan_result_array_float_at(res, i, j, &dv) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_float(b, NULL, 0, dv) != TEPTRIS_OK;
+    }
+    case TEPTRIS_BOOLEAN: {
+        bool bv;
+        if (teptris_plan_result_array_boolean_at(res, i, j, &bv)
+            != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_boolean(b, NULL, 0, bv) != TEPTRIS_OK;
+    }
+    case TEPTRIS_DATETIME_OFFSET:
+    case TEPTRIS_DATETIME_LOCAL:
+    case TEPTRIS_DATE_LOCAL:
+    case TEPTRIS_TIME_LOCAL:
+        if (teptris_plan_result_array_datetime_at(res, i, j, &dt)
+            != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_datetime(b, NULL, 0,
+                                            (teptris_kind)teptris_plan_result_array_value_kind_at(
+                                                res, i, j),
+                                            &dt)
+               != TEPTRIS_OK;
+    default:
+        return 1;
+    }
+}
+
+static int put_node(teptris_builder *b, const char *key, size_t klen,
+                    const teptris_node *n);
+
+static int put_node_array(teptris_builder *b, const char *key,
+                          const teptris_node *n) {
+    if (teptris_builder_open_array(b, key, key ? strlen(key) : 0)
+        != TEPTRIS_OK) {
+        snprintf(last_error, sizeof last_error,
+                 "plan asm: open_array failed");
+        return 1;
+    }
+    size_t n2 = teptris_node_array_length(n);
+    for (size_t j = 0; j < n2; j++) {
+            if (put_node(b, NULL, 0, teptris_node_array_at(n, j)) != 0) {
+            snprintf(last_error, sizeof last_error,
+                     "plan asm: array elem %zu put_node failed", (size_t)j);
+            return 1;
+        }
+    }
+    if (teptris_builder_close(b) != TEPTRIS_OK) {
+        snprintf(last_error, sizeof last_error,
+                 "plan asm: close array failed");
+        return 1;
+    }
+    return 0;
+}
+
+static int put_node(teptris_builder *b, const char *key, size_t klen,
+                    const teptris_node *n) {
+    teptris_view v;
+    int64_t iv;
+    double dv;
+    bool bv;
+    teptris_datetime dt;
+    switch (teptris_node_kind(n)) {
+    case TEPTRIS_STRING:
+        if (teptris_node_string(n, &v) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_string(b, key, klen, v.ptr, v.len)
+               != TEPTRIS_OK;
+    case TEPTRIS_INTEGER:
+        if (teptris_node_integer(n, &iv) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_integer(b, key, klen, iv) != TEPTRIS_OK;
+    case TEPTRIS_FLOAT:
+        if (teptris_node_float(n, &dv) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_float(b, key, klen, dv) != TEPTRIS_OK;
+    case TEPTRIS_BOOLEAN:
+        if (teptris_node_boolean(n, &bv) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_boolean(b, key, klen, bv ? 1 : 0)
+               != TEPTRIS_OK;
+    case TEPTRIS_DATETIME_OFFSET:
+    case TEPTRIS_DATETIME_LOCAL:
+    case TEPTRIS_DATE_LOCAL:
+    case TEPTRIS_TIME_LOCAL:
+        if (teptris_node_datetime(n, &dt) != TEPTRIS_OK) {
+            return 1;
+        }
+        return teptris_builder_put_datetime(b, key, klen,
+                                            teptris_node_kind(n), &dt)
+               != TEPTRIS_OK;
+    case TEPTRIS_TABLE: {
+        if (teptris_builder_open_table(b, key, klen) != TEPTRIS_OK) {
+            snprintf(last_error, sizeof last_error,
+                     "plan asm: open_table failed (klen %zu)", klen);
+            return 1;
+        }
+        size_t n2 = teptris_node_table_length(n);
+        for (size_t j = 0; j < n2; j++) {
+            teptris_view child_key;
+            const teptris_node *child =
+                teptris_node_table_at(n, j, &child_key);
+            if (child != NULL
+                && put_node(b, child_key.ptr, child_key.len, child) != 0) {
+                snprintf(last_error, sizeof last_error,
+                         "plan asm: table child %zu put_node failed",
+                         (size_t)j);
+                return 1;
+            }
+        }
+        if (teptris_builder_close(b) != TEPTRIS_OK) {
+            snprintf(last_error, sizeof last_error,
+                     "plan asm: close table failed");
+            return 1;
+        }
+        return 0;
+    }
+    case TEPTRIS_ARRAY:
+        return put_node_array(b, key, n);
+    default:
+        return 1;
+    }
+}
+
+static int asm_table_rows(teptris_builder *b, const teptris_plan *p,
+                          const teptris_plan_result *res, uint32_t plan_idx);
+
+static int asm_table_rows(teptris_builder *b, const teptris_plan *p,
+                          const teptris_plan_result *res, uint32_t plan_idx) {
+    uint32_t n = teptris_plan_row_count(p, plan_idx);
+    for (uint32_t i = 0; i < n; i++) {
+        uint8_t kind = teptris_plan_result_kind_at(res, i);
+        if (kind == 0 /* MISSING */) {
+            continue;
+        }
+        const char *key = teptris_plan_row_name_at(p, plan_idx, i);
+        switch (kind) {
+        case 1 /* SCALAR */:
+            if (put_scalar_result(b, key, res, i) != 0) {
+                return 1;
+            }
+            break;
+        case 2 /* ARRAY */: {
+            uint32_t n2 = teptris_plan_result_array_len_at(res, i);
+            uint32_t sub = teptris_plan_row_sub_at(p, plan_idx, i);
+            if (teptris_builder_open_array(b, key, strlen(key)) != TEPTRIS_OK) {
+                return 1;
+            }
+            for (uint32_t j = 0; j < n2; j++) {
+                if (teptris_plan_result_array_kind_at(res, i, j) == 3 /* TABLE */) {
+                    teptris_plan_result *entry =
+                        teptris_plan_result_array_entry_at(res, i, j);
+                    if (entry == NULL) {
+                        return 1;
+                    }
+                    int rc = asm_table_rows(b, p, entry, sub);
+                    teptris_plan_result_view_free(entry);
+                    if (rc != 0) {
+                        return 1;
+                    }
+                } else if (put_array_scalar_result(b, res, i, j) != 0) {
+                    return 1;
+                }
+            }
+            if (teptris_builder_close(b) != TEPTRIS_OK) {
+                return 1;
+            }
+            break;
+        }
+        case 3 /* TABLE */: {
+            teptris_plan_result *sub = teptris_plan_result_row_view(res, i);
+            if (sub == NULL) {
+                return 1;
+            }
+            uint32_t sub_idx = teptris_plan_row_sub_at(p, plan_idx, i);
+            if (teptris_builder_open_table(b, key, strlen(key))
+                != TEPTRIS_OK) {
+                return 1;
+            }
+            int rc = asm_table_rows(b, p, sub, sub_idx);
+            teptris_plan_result_view_free(sub);
+            if (rc != 0 || teptris_builder_close(b) != TEPTRIS_OK) {
+                return 1;
+            }
+            break;
+        }
+        case 4 /* RAW */: {
+            const teptris_node *raw = teptris_plan_result_raw_at(res, i);
+            if (raw == NULL) {
+                snprintf(last_error, sizeof last_error,
+                         "plan asm: raw row %u has no node", (unsigned)i);
+                return 1;
+            }
+            /* put_node sets its own specific message */
+            if (put_node(b, key, strlen(key), raw) != 0) {
+                return 1;
+            }
+            break;
+            break;
+        }
+        default:
+            snprintf(last_error, sizeof last_error,
+                     "plan asm: row %u unexpected kind %d", (unsigned)i,
+                     (int)kind);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+EMSCRIPTEN_KEEPALIVE
+int teptris_wasm_plan_walk(void *plan, const char *data, size_t len) {
+    teptris_document *doc = NULL;
+    teptris_status st = teptris_parse(data, len, NULL, &doc);
+    if (st != TEPTRIS_OK || doc == NULL) {
+        if (doc != NULL) {
+            const teptris_error *e = teptris_document_error(doc);
+            snprintf(last_error, sizeof last_error, "%s", e->message);
+            last_error_line = (int)e->line;
+            last_error_column = (int)e->column;
+            teptris_document_free(doc);
+        } else {
+            snprintf(last_error, sizeof last_error, "parse failed");
+        }
+        return (int)st;
+    }
+    teptris_status wst;
+    teptris_plan_result *res = teptris_plan_walk(
+        (const teptris_plan *)plan, teptris_document_root(doc), &wst);
+    if (wst != TEPTRIS_OK || res == NULL) {
+        snprintf(last_error, sizeof last_error, "plan walk failed (%s)",
+                 teptris_status_string(wst));
+        teptris_document_free(doc);
+        return (int)wst;
+    }
+    teptris_builder *b = teptris_builder_new();
+    int rc = 0;
+    if (b == NULL) {
+        snprintf(last_error, sizeof last_error,
+                 "plan materialize: out of memory");
+        rc = TEPTRIS_ERR_STATE;
+    } else if (asm_table_rows(b, (const teptris_plan *)plan, res, 0) != 0) {
+        /* asm_table_rows set last_error with the failing row */
+        rc = TEPTRIS_ERR_STATE;
+    }
+    if (rc == 0) {
+        teptris_document *out = NULL;
+        st = teptris_builder_finish(b, &out);
+        teptris_builder_free(b);
+        if (st != TEPTRIS_OK) {
+            teptris_document_free(out);
+            teptris_document_free(doc);
+            teptris_plan_result_free(res);
+            return (int)st;
+        }
+        char *buf = NULL;
+        size_t blen = 0;
+        st = teptris_document_emit_json_natural(out, &buf, &blen);
+        teptris_document_free(out);
+        if (st != TEPTRIS_OK) {
+            teptris_document_free(doc);
+            teptris_plan_result_free(res);
+            return (int)st;
+        }
+        g_json = buf;
+        g_json_len = blen;
+    } else {
+        teptris_builder_free(b);
+    }
+    teptris_plan_result_free(res);
+    teptris_document_free(doc);
+    return rc;
+}