tabulark 0.0.4 → 0.1.0

package/dist/wasm/parquet/tabulark_parquet_bg.wasm.d.ts

@@ -0,0 +1,25 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_wasmruntime_free: (a: number, b: number) => void;
+export const wasmruntime_adapterApiVersion: (a: number) => number;
+export const wasmruntime_adapterId: (a: number, b: number) => void;
+export const wasmruntime_batchLayoutVersion: (a: number) => number;
+export const wasmruntime_beginOpen: (a: number, b: number, c: number, d: number) => void;
+export const wasmruntime_beginRead: (a: number, b: number, c: number, d: number) => void;
+export const wasmruntime_cancelOperation: (a: number, b: number) => number;
+export const wasmruntime_closeSource: (a: number, b: number) => number;
+export const wasmruntime_closeTable: (a: number, b: number) => number;
+export const wasmruntime_continueOperation: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const wasmruntime_metadata: (a: number, b: number, c: number) => void;
+export const wasmruntime_new: (a: number, b: number) => void;
+export const wasmruntime_openTable: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wasmruntime_presentation: (a: number, b: number, c: number) => void;
+export const wasmruntime_protocolVersion: (a: number) => number;
+export const wasmruntime_readPresentationRange: (a: number, b: number, c: number, d: number) => void;
+export const wasmruntime_shutdown: (a: number) => void;
+export const __wbindgen_export_0: (a: number, b: number) => number;
+export const __wbindgen_export_1: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export_2: (a: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export_3: (a: number, b: number, c: number) => void;

package/dist/worker/wasm-adapter.d.ts

@@ -0,0 +1,57 @@
+import type { OfficialAdapterId } from "../adapters.js";
+interface AdapterPendingRead {
+    readonly operationHandle: string | number;
+    readonly action: Readonly<{
+        readonly kind: "read-bytes";
+        readonly offset: number;
+        readonly length: number;
+    }>;
+}
+export interface AdapterReadBytesStep extends AdapterPendingRead {
+    readonly kind: "read-bytes";
+}
+export interface AdapterOpenProgressStep extends AdapterPendingRead {
+    readonly kind: "open-progress";
+    readonly sourceHandle: string | number;
+    readonly tables: unknown;
+    readonly metadata: unknown;
+    readonly progress: unknown;
+    readonly warnings?: unknown;
+}
+export interface AdapterOpenCompleteStep {
+    readonly kind: "open-complete";
+    readonly sourceHandle: string | number;
+    readonly tables: unknown;
+    readonly metadata: unknown;
+    readonly progress?: unknown;
+    readonly warnings?: unknown;
+}
+export interface AdapterReadCompleteStep {
+    readonly kind: "read-complete";
+    readonly batch: unknown;
+}
+export type AdapterOpenStep = AdapterReadBytesStep | AdapterOpenProgressStep | AdapterOpenCompleteStep;
+export type AdapterReadStep = AdapterReadBytesStep | AdapterReadCompleteStep;
+export type AdapterOperationStep = AdapterOpenStep | AdapterReadStep;
+/**
+ * The sole translation layer between the Worker protocol and wasm-bindgen.
+ * Bulk arrays are copied by the Worker before they are transferred, never by
+ * this adapter, so the runtime may safely return views into WebAssembly memory.
+ */
+export declare class WasmAdapter {
+    #private;
+    private constructor();
+    static load(moduleUrl: string, expectedAdapterId: OfficialAdapterId, config: unknown): Promise<WasmAdapter>;
+    metadata(sourceHandle: string | number): unknown;
+    presentation(tableHandle: string | number): unknown;
+    readPresentationRange(tableHandle: string | number, request: unknown): unknown;
+    beginOpen(options: unknown, sourceLength: number): AdapterOpenStep;
+    continueOperation(operationHandle: string | number, absoluteOffset: number, bytes: Uint8Array, eof: boolean): AdapterOperationStep;
+    openTable(sourceHandle: string | number, tableId: string): unknown;
+    beginRead(tableHandle: string | number, request: unknown): AdapterReadStep;
+    cancelOperation(operationHandle: string | number): void;
+    closeTable(tableHandle: string | number): void;
+    closeSource(sourceHandle: string | number): void;
+    dispose(): void;
+}
+export {};

package/dist/worker/worker-errors.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedError } from "../protocol.js";
+export declare class ProtocolFault extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly details?: unknown;
+    constructor(code: string, message: string, retryable?: boolean, details?: unknown, cause?: unknown);
+}
+export declare function faultFromUnknown(error: unknown, fallback: string): ProtocolFault;
+export declare function serializeFault(error: unknown, fallback: string): SerializedError;

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker.js

@@ -0,0 +1,2 @@
+var PROTOCOL_VERSION=3;var ADAPTER_API_VERSION=2;var BATCH_LAYOUT_VERSION=1;function isRecord(value){return typeof value==="object"&&value!==null}var TabularkError=class _TabularkError extends Error{code;retryable;details;constructor(code,message,options={}){super(message,{cause:options.cause});this.name="TabularkError";this.code=code;this.retryable=options.retryable??false;this.details=code==="RESOURCE_LIMIT"?normalizeResourceLimitDetails(options.details):options.details}static fromSerialized(error){return new _TabularkError(error.code,error.message,{retryable:error.retryable,details:error.details})}};function normalizeResourceLimitDetails(details){const raw=isRecord2(details)?details:{};const resource=typeof raw.resource==="string"&&raw.resource.length>0?raw.resource:typeof raw.resourceCategory==="string"&&raw.resourceCategory.length>0?raw.resourceCategory:inferResource(raw);if(isQuantity(raw.requiredBytes)&&isQuantity(raw.availableBytes)){return Object.freeze({...raw,resource})}if(isQuantity(raw.required)&&isQuantity(raw.available)){return Object.freeze({...raw,resource})}const byteLimit=firstQuantity(raw,["maxDecodedBytes","maxOutputBytes","maxMetadataBytes","maxBlockBytes","maxDisplayCellBytes","maxDisplayBytes","maxSourceBytes","maxFieldBytes","maxBatchBytes","maxOperationBytes","maxZipEntryBytes","maxZipUncompressedBytes","maxCfbStreamBytes"]);if(byteLimit!==void 0){const requiredBytes=firstQuantity(raw,["decodedBytes","outputBytes","metadataBytes","blockBytes","displayCellBytes","displayBytes","sourceBytes","fieldBytes","batchBytes","operationBytes"])??byteLimit+1;return Object.freeze({...raw,resource,requiredBytes,availableBytes:byteLimit})}const available=firstQuantity(raw,["limit","maxCells","maxRangeCells","maxSources","maxActiveRanges","maxRangeWaiters","maxColumns","maxFields","maxNestingDepth","maxWorksheetRows","maxWorksheetColumns","maxStyles","maxMergedRegions"])??0;const required=firstQuantity(raw,["cells","cellCount","visibleCellCount","sources","activeRanges","rangeWaiters","columns","fields","nestingDepth","worksheetRows","worksheetColumns","styles","mergedRegions"])??available+1;return Object.freeze({...raw,resource,required,available})}function inferResource(details){const keys=Object.keys(details).join(" ").toLowerCase();if(keys.includes("source"))return keys.includes("byte")?"source-staging":"source-slots";if(keys.includes("metadata"))return"metadata";if(keys.includes("decoded")||keys.includes("decompress"))return"decompression";if(keys.includes("display"))return"display-values";if(keys.includes("field"))return"field";if(keys.includes("batch"))return"batch";if(keys.includes("range")||keys.includes("cell"))return"range-cells";if(keys.includes("column"))return"columns";if(keys.includes("nest"))return"descriptor-nesting";if(keys.includes("worksheet"))return"worksheet-dimensions";return"adapter-resource"}function firstQuantity(details,names){for(const name of names){if(isQuantity(details[name]))return details[name]}return void 0}function isQuantity(value){return typeof value==="number"&&Number.isFinite(value)&&value>=0}function isRecord2(value){return typeof value==="object"&&value!==null&&!Array.isArray(value)}function invalidArgument(message,details){return new TabularkError("INVALID_ARGUMENT",message,{details})}var DEFAULT_MEMORY_BUDGET_BYTES=256*1024*1024;var MAX_ARRAY_BUFFER_BYTES=128*1024*1024;var MAX_RANGE_CELLS=25e4;var DEFAULT_TO_ROWS_CELL_LIMIT=1e4;var MAX_NESTING_DEPTH=64;var INDEX_BUDGET_MAX_BYTES=64*1024*1024;var WORKER_RANGE_CACHE_MAX_BYTES=96*1024*1024;var MAIN_THREAD_RANGE_CACHE_MAX_BYTES=32*1024*1024;var FIELD_AND_BATCH_MAX_BYTES=8*1024*1024;var MAX_SOURCES=2;var MAX_ACTIVE_RANGES=2;var MAX_RANGE_WAITERS=8;function deriveMemoryBudgetLimits(memoryBudgetBytes){assertPositiveSafeInteger(memoryBudgetBytes,"memoryBudgetBytes");const oneEighth=Math.floor(memoryBudgetBytes/8);const oneThirtySecond=Math.floor(memoryBudgetBytes/32);const adapterRuntimePoolBytes=Math.max(1,Math.floor(memoryBudgetBytes/2));const operationBudgetBytes=Math.max(1,Math.floor(memoryBudgetBytes/8));const workerRangeCacheBytes=Math.min(WORKER_RANGE_CACHE_MAX_BYTES,Math.floor(memoryBudgetBytes/8*3));return Object.freeze({memoryBudgetBytes,adapterRuntimePoolBytes,operationBudgetBytes,indexBudgetBytes:Math.min(INDEX_BUDGET_MAX_BYTES,oneEighth),adapterTileCacheBudgetBytes:Math.min(WORKER_RANGE_CACHE_MAX_BYTES,operationBudgetBytes),workerRangeCacheBytes,workerDatasetRangeCacheBytes:Math.floor(workerRangeCacheBytes/MAX_SOURCES),mainThreadRangeCacheBytes:Math.min(MAIN_THREAD_RANGE_CACHE_MAX_BYTES,oneEighth),maxFieldBytes:Math.min(FIELD_AND_BATCH_MAX_BYTES,oneThirtySecond),maxBatchBytes:Math.min(FIELD_AND_BATCH_MAX_BYTES,oneThirtySecond),maxArrayBufferBytes:Math.min(MAX_ARRAY_BUFFER_BYTES,Math.floor(memoryBudgetBytes/2)),maxSources:MAX_SOURCES,maxActiveRanges:MAX_ACTIVE_RANGES,maxRangeWaiters:MAX_RANGE_WAITERS})}var MemoryReservationLedger=class{#capacityBytes;#usedBytes=0;constructor(capacityBytes){assertPositiveSafeInteger(capacityBytes,"capacityBytes");this.#capacityBytes=capacityBytes}get capacityBytes(){return this.#capacityBytes}get usedBytes(){return this.#usedBytes}get availableBytes(){return this.#capacityBytes-this.#usedBytes}reserve(resource,bytes){if(!Number.isSafeInteger(bytes)||bytes<0){throw invalidArgument("Reservation bytes must be a non-negative safe integer")}const availableBytes=this.availableBytes;if(bytes>availableBytes){throw new TabularkError("RESOURCE_LIMIT",`Insufficient memory reservation capacity for ${resource}`,{details:{resource,requiredBytes:bytes,availableBytes}})}this.#usedBytes+=bytes;let released=false;return Object.freeze({resource,bytes,release:()=>{if(released)return;released=true;this.#usedBytes-=bytes}})}};var ColumnarTableBatch=class{tableId;revision;schemaVersion;range;columns;complete;#buffers;#wireColumns;constructor(value){if(value.layoutVersion!==BATCH_LAYOUT_VERSION){throw invalidArgument(`Batch layout ${String(value.layoutVersion)} is incompatible with layout ${BATCH_LAYOUT_VERSION}`)}this.tableId=value.tableId;this.revision=value.revision;this.schemaVersion=value.schemaVersion;this.range=Object.freeze({...value.range});this.#buffers=Object.freeze(value.buffers.map(asUint8Array));this.#wireColumns=Object.freeze(value.columns.map(column=>freezeWireColumn(column)));this.complete=value.complete;validateWireBatch(this.range,this.#buffers,this.#wireColumns);this.columns=Object.freeze(this.#wireColumns.map((column,index)=>new LogicalBatchColumn(column,this.#buffers,this.range.rowCount,this.range.columnStart+index)))}toRows(options={}){const maxCells=normalizeCellLimit(options.maxCells);assertCellLimit(this.range.rowCount,this.columns.length,maxCells);const rows=Array.from({length:this.range.rowCount},()=>Array(this.columns.length));for(let columnIndex=0;columnIndex<this.columns.length;columnIndex+=1){for(let rowIndex=0;rowIndex<this.range.rowCount;rowIndex+=1){rows[rowIndex][columnIndex]=this.columns[columnIndex].getValue(rowIndex)}}return rows}toDisplayRows(options={}){const maxCells=normalizeCellLimit(options.maxCells);assertCellLimit(this.range.rowCount,this.columns.length,maxCells);const rows=Array.from({length:this.range.rowCount},()=>Array(this.columns.length));for(let columnIndex=0;columnIndex<this.columns.length;columnIndex+=1){for(let rowIndex=0;rowIndex<this.range.rowCount;rowIndex+=1){rows[rowIndex][columnIndex]=this.columns[columnIndex].getDisplayValue(rowIndex)}}return rows}};var LogicalBatchColumn=class{columnId;columnIndex;rowCount;#wire;#buffers;constructor(wire,buffers,rowCount,columnIndex){this.columnId=wire.columnId;this.columnIndex=columnIndex;this.rowCount=rowCount;this.#wire=wire;this.#buffers=buffers;Object.freeze(this)}getValue(rowOffset){assertBatchRowOffset(rowOffset,this.rowCount);return decodeNativeValue(this.#wire.native,rowOffset,this.#buffers,0)}getDisplayValue(rowOffset){assertBatchRowOffset(rowOffset,this.rowCount);return decodeDisplayValue(this.#wire.display,rowOffset,this.#buffers,this.columnId)}toValues(options={}){const maxCells=normalizeCellLimit(options.maxCells);assertCellLimit(this.rowCount,1,maxCells);return Array.from({length:this.rowCount},(_,index)=>this.getValue(index))}toDisplayValues(options={}){const maxCells=normalizeCellLimit(options.maxCells);assertCellLimit(this.rowCount,1,maxCells);return Array.from({length:this.rowCount},(_,index)=>this.getDisplayValue(index))}};function assertBatchRowOffset(rowOffset,rowCount){if(!Number.isSafeInteger(rowOffset)||rowOffset<0||rowOffset>=rowCount){throw invalidArgument(`Batch row offset must be an integer from 0 through ${Math.max(0,rowCount-1)}`)}}function decodeDisplayValue(display,rowOffset,buffers,columnId){const physicalIndex=(display.offset??0)+rowOffset;if(!validAt(display.validity,physicalIndex,buffers)){return null}const offsets=regionView(display.offsets,buffers,"display offsets");const data=regionView(display.data,buffers,"display data");const start=readUnsignedOffset(offsets,physicalIndex,4);const end=readUnsignedOffset(offsets,physicalIndex+1,4);if(end<start||end>data.byteLength){throw invalidArgument(`Column ${columnId} has invalid display offsets`)}return new TextDecoder().decode(data.subarray(start,end))}function validateRange(request){for(const[name,value]of Object.entries(request)){assertNonNegativeSafeInteger(value,name)}if(!Number.isSafeInteger(request.rowStart+request.rowCount)||!Number.isSafeInteger(request.columnStart+request.columnCount)){throw new TabularkError("INVALID_RANGE","Range end must be a safe integer")}const cells=request.rowCount*request.columnCount;if(!Number.isSafeInteger(cells)||cells>MAX_RANGE_CELLS){throw new TabularkError("RESOURCE_LIMIT",`A range may contain at most ${MAX_RANGE_CELLS} cells`,{details:{resource:"range-cells",required:cells,available:MAX_RANGE_CELLS,cells,limit:MAX_RANGE_CELLS}})}return Object.freeze({...request})}function normalizeDataType(value,depth=0){if(depth>=MAX_NESTING_DEPTH){throw invalidArgument(`Arrow data type nesting may not exceed ${MAX_NESTING_DEPTH}`)}if(!isRecord3(value)||typeof value.type!=="string"){throw invalidArgument("Column dataType must be a recursive Arrow data type descriptor")}const type={"u-int8":"uint8","u-int16":"uint16","u-int32":"uint32","u-int64":"uint64"}[value.type]??value.type;const simple=new Set(["unknown","null","boolean","int8","int16","int32","int64","uint8","uint16","uint32","uint64","float16","float32","float64","date32","date64","binary","large-binary","binary-view","utf8","large-utf8","utf8-view"]);if(simple.has(type)){return Object.freeze({type})}if(type==="timestamp"){return Object.freeze({type,unit:timeUnit(value.unit),...typeof value.timezone==="string"?{timezone:value.timezone}:{}})}if(type==="time32"||type==="time64"||type==="duration"){return Object.freeze({type,unit:timeUnit(value.unit)})}if(type==="interval"){return Object.freeze({type,unit:intervalUnit(value.unit)})}if(type==="fixed-size-binary"){return Object.freeze({type,byteWidth:positiveInteger(value.byteWidth??value.byte_width,"byteWidth")})}if(type==="decimal32"||type==="decimal64"||type==="decimal128"||type==="decimal256"){return Object.freeze({type,precision:positiveInteger(value.precision,"precision"),scale:integer(value.scale,"scale")})}if(type==="list"||type==="large-list"||type==="list-view"||type==="large-list-view"){return Object.freeze({type,field:normalizeField(value.field,depth+1)})}if(type==="fixed-size-list"){return Object.freeze({type,field:normalizeField(value.field,depth+1),listSize:positiveInteger(value.listSize??value.list_size,"listSize")})}if(type==="struct"){if(!Array.isArray(value.fields)){throw invalidArgument("Struct fields must be an array")}return Object.freeze({type,fields:Object.freeze(value.fields.map(field=>normalizeField(field,depth+1)))})}if(type==="union"){if(!Array.isArray(value.fields)||value.mode!=="sparse"&&value.mode!=="dense"){throw invalidArgument("Union dataType requires a mode and fields")}return Object.freeze({type,mode:value.mode,fields:Object.freeze(value.fields.map(entry=>{if(!isRecord3(entry)){throw invalidArgument("Union field entries must be objects")}return Object.freeze({typeId:integer(entry.typeId,"typeId"),field:normalizeField(entry.field,depth+1)})}))})}if(type==="dictionary"){return Object.freeze({type,indexType:normalizeDataType(value.indexType,depth+1),valueType:normalizeDataType(value.valueType,depth+1),...value.ordered===true?{ordered:true}:{}})}if(type==="map"){return Object.freeze({type,entries:normalizeField(value.entries,depth+1),keysSorted:value.keysSorted===true||value.keys_sorted===true})}if(type==="run-end-encoded"){return Object.freeze({type,runEnds:normalizeField(value.runEnds??value.run_ends,depth+1),values:normalizeField(value.values,depth+1)})}if(type==="extension"){if(typeof value.name!=="string"||value.name.length===0){throw invalidArgument("Arrow extension name must be a non-empty string")}return Object.freeze({type,name:value.name,...typeof value.metadata==="string"?{metadata:value.metadata}:{},storageType:normalizeDataType(value.storageType,depth+1)})}throw invalidArgument(`Unknown Arrow data type: ${type}`)}function normalizeField(value,depth){if(!isRecord3(value)){throw invalidArgument("Arrow field must be an object")}const metadata=isRecord3(value.metadata)?Object.freeze(Object.fromEntries(Object.entries(value.metadata).map(([key,entry])=>[key,String(entry)]))):void 0;return Object.freeze({name:typeof value.name==="string"?value.name:"",nullable:value.nullable!==false,dataType:normalizeDataType(value.dataType,depth),...metadata?{metadata}:{}})}function validateWireBatch(range,buffers,columns){validateRange(range);if(columns.length!==range.columnCount){throw invalidArgument(`Batch has ${columns.length} columns; expected ${range.columnCount}`)}for(const[index,column]of columns.entries()){validateDisplay(column.display,range.rowCount,buffers,column.columnId);validateNative(column.native,buffers,0,`columns[${index}].native`);if(column.native.length<range.rowCount){throw invalidArgument(`Column ${column.columnId} is shorter than the returned range`)}}}function validateDisplay(display,rows,buffers,columnId){const offset=display.offset??0;assertNonNegativeSafeInteger(offset,"display offset");const offsets=regionView(display.offsets,buffers,"display offsets");if(offsets.byteLength<(offset+rows+1)*4){throw invalidArgument(`Column ${columnId} has incomplete display offsets`)}const data=regionView(display.data,buffers,"display data");if(display.validity){const validity=regionView(display.validity,buffers,"display validity");if(validity.byteLength<Math.ceil((offset+rows)/8)){throw invalidArgument(`Column ${columnId} has an incomplete display validity bitmap`)}}let previous=0;for(let index=offset;index<=offset+rows;index+=1){const next=readUnsignedOffset(offsets,index,4);if(next<previous||next>data.byteLength){throw invalidArgument(`Column ${columnId} has invalid display offsets`)}previous=next}}function validateNative(descriptor,buffers,depth,name){if(depth>=MAX_NESTING_DEPTH){throw invalidArgument(`Native column nesting may not exceed ${MAX_NESTING_DEPTH}`)}assertNonNegativeSafeInteger(descriptor.length,`${name}.length`);assertNonNegativeSafeInteger(descriptor.offset??0,`${name}.offset`);normalizeDataType(descriptor.dataType,depth);const regions=[descriptor.validity,descriptor.values,descriptor.offsets,descriptor.sizes,descriptor.data,descriptor.typeIds,descriptor.unionOffsets,...descriptor.variadicBuffers??[]];for(const region of regions){if(region){regionView(region,buffers,name)}}for(const[index,child]of(descriptor.children??[]).entries()){validateNative(child,buffers,depth+1,`${name}.children[${index}]`)}if(descriptor.dictionary){validateNative(descriptor.dictionary,buffers,depth+1,`${name}.dictionary`)}if(descriptor.runEnds){validateNative(descriptor.runEnds,buffers,depth+1,`${name}.runEnds`)}}function decodeNativeValue(descriptor,logicalIndex,buffers,depth){if(depth>=MAX_NESTING_DEPTH){throw invalidArgument(`Native value nesting may not exceed ${MAX_NESTING_DEPTH}`)}if(logicalIndex<0||logicalIndex>=descriptor.length){throw invalidArgument("Native value index is outside its descriptor")}const physicalIndex=(descriptor.offset??0)+logicalIndex;if(!validAt(descriptor.validity,physicalIndex,buffers)){return null}const type=unwrapExtension(descriptor.dataType);switch(type.type){case"null":return null;case"unknown":{const bytes=decodeVariableBytes(descriptor,buffers,physicalIndex,4);return new TextDecoder().decode(bytes)}case"boolean":{const values=requiredRegion(descriptor.values,buffers,"boolean values");const bitIndex=(descriptor.values?.bitOffset??0)+physicalIndex;return(values[bitIndex>>>3]&1<<(bitIndex&7))!==0}case"int8":return readNumber(descriptor,buffers,physicalIndex,1,"signed");case"uint8":return readNumber(descriptor,buffers,physicalIndex,1,"unsigned");case"int16":return readNumber(descriptor,buffers,physicalIndex,2,"signed");case"uint16":return readNumber(descriptor,buffers,physicalIndex,2,"unsigned");case"int32":return readNumber(descriptor,buffers,physicalIndex,4,"signed");case"uint32":return readNumber(descriptor,buffers,physicalIndex,4,"unsigned");case"int64":return readBigInt(descriptor,buffers,physicalIndex,true);case"uint64":return readBigInt(descriptor,buffers,physicalIndex,false);case"float16":return decodeFloat16(readNumber(descriptor,buffers,physicalIndex,2,"unsigned"));case"float32":return readFloat(descriptor,buffers,physicalIndex,4);case"float64":return readFloat(descriptor,buffers,physicalIndex,8);case"utf8":case"large-utf8":{const bytes=decodeVariableBytes(descriptor,buffers,physicalIndex,type.type==="large-utf8"?8:4);return new TextDecoder().decode(bytes)}case"binary":case"large-binary":return decodeVariableBytes(descriptor,buffers,physicalIndex,type.type==="large-binary"?8:4).slice();case"utf8-view":return new TextDecoder().decode(decodeViewBytes(descriptor,buffers,physicalIndex));case"binary-view":return decodeViewBytes(descriptor,buffers,physicalIndex).slice();case"fixed-size-binary":{const data=requiredRegion(descriptor.data??descriptor.values,buffers,"fixed-size binary data");const start=physicalIndex*type.byteWidth;return checkedSlice(data,start,start+type.byteWidth,"fixed-size binary data").slice()}case"decimal32":case"decimal64":case"decimal128":case"decimal256":{const width={decimal32:4,decimal64:8,decimal128:16,decimal256:32}[type.type];return Object.freeze({kind:"decimal",unscaled:readSignedLittleEndian(requiredRegion(descriptor.values,buffers,"decimal values"),physicalIndex*width,width),precision:type.precision,scale:type.scale})}case"date32":return Object.freeze({kind:"date32",value:readNumber(descriptor,buffers,physicalIndex,4,"signed")});case"date64":return Object.freeze({kind:"date64",value:readBigInt(descriptor,buffers,physicalIndex,true),unit:"millisecond"});case"time32":return Object.freeze({kind:"time32",value:readNumber(descriptor,buffers,physicalIndex,4,"signed"),unit:type.unit});case"time64":return Object.freeze({kind:"time64",value:readBigInt(descriptor,buffers,physicalIndex,true),unit:type.unit});case"timestamp":return Object.freeze({kind:"timestamp",value:readBigInt(descriptor,buffers,physicalIndex,true),unit:type.unit,...type.timezone===void 0?{}:{timezone:type.timezone}});case"duration":return Object.freeze({kind:"duration",value:readBigInt(descriptor,buffers,physicalIndex,true),unit:type.unit});case"interval":return decodeInterval(descriptor,buffers,physicalIndex,type.unit);case"list":case"large-list":case"list-view":case"large-list-view":case"map":return decodeListLike(descriptor,buffers,physicalIndex,type,depth);case"fixed-size-list":{const child=requiredChild(descriptor,0,"fixed-size list");const start=physicalIndex*type.listSize;return Object.freeze(Array.from({length:type.listSize},(_,index)=>decodeNativeValue(child,start+index-(child.offset??0),buffers,depth+1)))}case"struct":{const result={};for(let index=0;index<type.fields.length;index+=1){const child=requiredChild(descriptor,index,"struct");result[type.fields[index].name]=decodeNativeValue(child,physicalIndex-(child.offset??0),buffers,depth+1)}return Object.freeze(result)}case"union":{const typeIds=requiredRegion(descriptor.typeIds,buffers,"union type ids");if(physicalIndex>=typeIds.byteLength){throw invalidArgument("Union type id is out of bounds")}const typeId=new DataView(typeIds.buffer,typeIds.byteOffset,typeIds.byteLength).getInt8(physicalIndex);const fieldIndex=type.fields.findIndex(entry=>entry.typeId===typeId);if(fieldIndex<0){throw invalidArgument(`Union type id ${typeId} has no child`)}const child=requiredChild(descriptor,fieldIndex,"union");const childPhysical=type.mode==="dense"?readSignedOffset(requiredRegion(descriptor.unionOffsets??descriptor.offsets,buffers,"union offsets"),physicalIndex,4):physicalIndex;return Object.freeze({kind:"union",typeId,value:decodeNativeValue(child,childPhysical-(child.offset??0),buffers,depth+1)})}case"dictionary":{const keys=descriptor.children?.[0]??descriptor;const dictionary=descriptor.dictionary??descriptor.children?.[1];if(!dictionary||!keys){throw invalidArgument("Dictionary descriptor has no dictionary values")}const index=readIndex(keys,buffers,physicalIndex,type.indexType);if(index<0||index>=dictionary.length){throw invalidArgument("Dictionary index is out of bounds")}return decodeNativeValue(dictionary,index,buffers,depth+1)}case"run-end-encoded":{const runEnds=descriptor.runEnds??descriptor.children?.[0];const values=descriptor.children?.[descriptor.runEnds?0:1];if(!runEnds||!values){throw invalidArgument("Run-end encoded descriptor is incomplete")}const logicalPosition=physicalIndex+1;let run=0;while(run<runEnds.length&&numericIndexValue(runEnds,buffers,run)<logicalPosition){run+=1}if(run>=values.length){throw invalidArgument("Run-end encoded value is out of bounds")}return decodeNativeValue(values,run,buffers,depth+1)}case"extension":throw invalidArgument("Nested extension data type could not be unwrapped")}}function decodeListLike(descriptor,buffers,physicalIndex,type,depth){const width=type.type==="large-list"||type.type==="large-list-view"?8:4;const offsets=requiredRegion(descriptor.offsets,buffers,"list offsets");const start=readSignedOffset(offsets,physicalIndex,width);const end=type.type==="list-view"||type.type==="large-list-view"?start+readSignedOffset(requiredRegion(descriptor.sizes,buffers,"list sizes"),physicalIndex,width):readSignedOffset(offsets,physicalIndex+1,width);if(start<0||end<start){throw invalidArgument("List offsets are invalid")}const child=requiredChild(descriptor,0,type.type);const values=Object.freeze(Array.from({length:end-start},(_,index)=>decodeNativeValue(child,start+index-(child.offset??0),buffers,depth+1)));if(type.type!=="map"){return values}return Object.freeze(values.map(entry=>{if(!isRecord3(entry)){throw invalidArgument("Map entries must decode from a struct")}const record=entry;const entryType=type.entries.dataType;const fields=entryType.type==="struct"?entryType.fields:[];const keyName=fields[0]?.name??"key";const valueName=fields[1]?.name??"value";return Object.freeze({key:record[keyName]??null,value:record[valueName]??null})}))}function decodeInterval(descriptor,buffers,index,unit){const values=requiredRegion(descriptor.values,buffers,"interval values");const view=new DataView(values.buffer,values.byteOffset,values.byteLength);if(unit==="year-month"){ensureViewRange(view,index*4,4,"year-month interval");return Object.freeze({kind:"interval",unit,months:view.getInt32(index*4,true)})}if(unit==="day-time"){const offset2=index*8;ensureViewRange(view,offset2,8,"day-time interval");return Object.freeze({kind:"interval",unit,days:view.getInt32(offset2,true),milliseconds:view.getInt32(offset2+4,true)})}const offset=index*16;ensureViewRange(view,offset,16,"month-day-nano interval");return Object.freeze({kind:"interval",unit,months:view.getInt32(offset,true),days:view.getInt32(offset+4,true),nanoseconds:view.getBigInt64(offset+8,true)})}function decodeVariableBytes(descriptor,buffers,index,offsetWidth){const offsets=requiredRegion(descriptor.offsets,buffers,"variable offsets");const data=requiredRegion(descriptor.data??descriptor.values,buffers,"variable data");const start=readUnsignedOffset(offsets,index,offsetWidth);const end=readUnsignedOffset(offsets,index+1,offsetWidth);return checkedSlice(data,start,end,"variable data")}function decodeViewBytes(descriptor,buffers,index){const views=requiredRegion(descriptor.values,buffers,"view values");const view=new DataView(views.buffer,views.byteOffset,views.byteLength);const offset=index*16;ensureViewRange(view,offset,16,"view value");const length=view.getInt32(offset,true);if(length<0){throw invalidArgument("View length must be non-negative")}if(length<=12){return checkedSlice(views,offset+4,offset+4+length,"inline view")}const bufferIndex=view.getInt32(offset+8,true);const dataOffset=view.getInt32(offset+12,true);const data=descriptor.variadicBuffers?.[bufferIndex];if(!data||dataOffset<0){throw invalidArgument("View references an invalid variadic buffer")}return checkedSlice(regionView(data,buffers,"view data"),dataOffset,dataOffset+length,"view data")}function readNumber(descriptor,buffers,index,width,signedness){const values=requiredRegion(descriptor.values,buffers,"numeric values");const view=new DataView(values.buffer,values.byteOffset,values.byteLength);const offset=index*width;ensureViewRange(view,offset,width,"numeric value");if(width===1)return signedness==="signed"?view.getInt8(offset):view.getUint8(offset);if(width===2)return signedness==="signed"?view.getInt16(offset,true):view.getUint16(offset,true);return signedness==="signed"?view.getInt32(offset,true):view.getUint32(offset,true)}function readFloat(descriptor,buffers,index,width){const values=requiredRegion(descriptor.values,buffers,"floating-point values");const view=new DataView(values.buffer,values.byteOffset,values.byteLength);const offset=index*width;ensureViewRange(view,offset,width,"floating-point value");return width===4?view.getFloat32(offset,true):view.getFloat64(offset,true)}function readBigInt(descriptor,buffers,index,signed){const values=requiredRegion(descriptor.values,buffers,"64-bit values");const view=new DataView(values.buffer,values.byteOffset,values.byteLength);const offset=index*8;ensureViewRange(view,offset,8,"64-bit value");return signed?view.getBigInt64(offset,true):view.getBigUint64(offset,true)}function readIndex(descriptor,buffers,index,dataType){const type=unwrapExtension(dataType).type;let value;if(type==="int8")value=readNumber(descriptor,buffers,index,1,"signed");else if(type==="uint8")value=readNumber(descriptor,buffers,index,1,"unsigned");else if(type==="int16")value=readNumber(descriptor,buffers,index,2,"signed");else if(type==="uint16")value=readNumber(descriptor,buffers,index,2,"unsigned");else if(type==="int32")value=readNumber(descriptor,buffers,index,4,"signed");else if(type==="uint32")value=readNumber(descriptor,buffers,index,4,"unsigned");else if(type==="int64")value=readBigInt(descriptor,buffers,index,true);else if(type==="uint64")value=readBigInt(descriptor,buffers,index,false);else throw invalidArgument("Dictionary index type must be an integer");const numeric=typeof value==="bigint"?Number(value):value;if(!Number.isSafeInteger(numeric)){throw invalidArgument("Dictionary index exceeds the JavaScript safe integer range")}return numeric}function numericIndexValue(descriptor,buffers,index){const type=unwrapExtension(descriptor.dataType);return readIndex({...descriptor,dataType:{type:"dictionary",indexType:type,valueType:{type:"null"}}},buffers,index,type)}function readSignedLittleEndian(bytes,offset,width){const slice=checkedSlice(bytes,offset,offset+width,"signed integer");let value=0n;for(let index=slice.byteLength-1;index>=0;index-=1){value=value<<8n|BigInt(slice[index])}const sign=1n<<BigInt(width*8-1);return(value&sign)===0n?value:value-(1n<<BigInt(width*8))}function readUnsignedOffset(bytes,index,width){const value=readOffset(bytes,index,width,false);if(value<0){throw invalidArgument("Offset must be non-negative")}return value}function readSignedOffset(bytes,index,width){return readOffset(bytes,index,width,true)}function readOffset(bytes,index,width,signed){const view=new DataView(bytes.buffer,bytes.byteOffset,bytes.byteLength);const offset=index*width;ensureViewRange(view,offset,width,"offset");const value=width===4?signed?view.getInt32(offset,true):view.getUint32(offset,true):signed?view.getBigInt64(offset,true):view.getBigUint64(offset,true);const numeric=typeof value==="bigint"?Number(value):value;if(!Number.isSafeInteger(numeric)){throw invalidArgument("Offset exceeds the JavaScript safe integer range")}return numeric}function validAt(validity,index,buffers){if(!validity)return true;const bitmap=regionView(validity,buffers,"validity bitmap");const bitIndex=(validity.bitOffset??0)+index;if(bitIndex<0||bitIndex>>>3>=bitmap.byteLength){throw invalidArgument("Validity bitmap index is out of bounds")}return(bitmap[bitIndex>>>3]&1<<(bitIndex&7))!==0}function requiredRegion(region,buffers,name){if(!region)throw invalidArgument(`${name} are missing`);return regionView(region,buffers,name)}function regionView(region,buffers,name){if(!isRecord3(region)||!Number.isSafeInteger(region.buffer)||region.buffer<0){throw invalidArgument(`${name} references an invalid buffer`)}const buffer=buffers[region.buffer];if(!buffer)throw invalidArgument(`${name} references a missing buffer`);const byteOffset=region.byteOffset??0;const byteLength=region.byteLength??buffer.byteLength-byteOffset;if(!Number.isSafeInteger(byteOffset)||byteOffset<0||!Number.isSafeInteger(byteLength)||byteLength<0||byteOffset+byteLength>buffer.byteLength){throw invalidArgument(`${name} region is outside its buffer`)}return buffer.subarray(byteOffset,byteOffset+byteLength)}function requiredChild(descriptor,index,name){const child=descriptor.children?.[index];if(!child)throw invalidArgument(`${name} descriptor has no child ${index}`);return child}function checkedSlice(bytes,start,end,name){if(!Number.isSafeInteger(start)||!Number.isSafeInteger(end)||start<0||end<start||end>bytes.byteLength){throw invalidArgument(`${name} slice is out of bounds`)}return bytes.subarray(start,end)}function ensureViewRange(view,offset,width,name){if(offset<0||offset+width>view.byteLength){throw invalidArgument(`${name} is out of bounds`)}}function unwrapExtension(dataType){let current=dataType;for(let depth=0;current.type==="extension";depth+=1){if(depth>=MAX_NESTING_DEPTH)throw invalidArgument("Extension nesting is too deep");current=current.storageType}return current}function freezeWireColumn(column){return Object.freeze({columnId:column.columnId,native:freezeNative(column.native),display:Object.freeze({...column.display,data:freezeRegion(column.display.data),offsets:freezeRegion(column.display.offsets),...column.display.validity?{validity:freezeRegion(column.display.validity)}:{}})})}function freezeNative(descriptor){const freezeOptionalRegion=region=>region?freezeRegion(region):void 0;return Object.freeze({...descriptor,dataType:freezeDataType(descriptor.dataType),...freezeOptionalRegion(descriptor.validity)?{validity:freezeOptionalRegion(descriptor.validity)}:{},...freezeOptionalRegion(descriptor.values)?{values:freezeOptionalRegion(descriptor.values)}:{},...freezeOptionalRegion(descriptor.offsets)?{offsets:freezeOptionalRegion(descriptor.offsets)}:{},...freezeOptionalRegion(descriptor.sizes)?{sizes:freezeOptionalRegion(descriptor.sizes)}:{},...freezeOptionalRegion(descriptor.data)?{data:freezeOptionalRegion(descriptor.data)}:{},...freezeOptionalRegion(descriptor.typeIds)?{typeIds:freezeOptionalRegion(descriptor.typeIds)}:{},...freezeOptionalRegion(descriptor.unionOffsets)?{unionOffsets:freezeOptionalRegion(descriptor.unionOffsets)}:{},...descriptor.variadicBuffers?{variadicBuffers:Object.freeze(descriptor.variadicBuffers.map(freezeRegion))}:{},...descriptor.children?{children:Object.freeze(descriptor.children.map(freezeNative))}:{},...descriptor.dictionary?{dictionary:freezeNative(descriptor.dictionary)}:{},...descriptor.runEnds?{runEnds:freezeNative(descriptor.runEnds)}:{}})}function freezeRegion(region){return Object.freeze({...region})}function freezeDataType(dataType){return normalizeDataTypeUnchecked(dataType,0)}function normalizeDataTypeUnchecked(value,depth){return normalizeDataType(value,depth)}function timeUnit(value){if(value==="second"||value==="millisecond"||value==="microsecond"||value==="nanosecond"){return value}throw invalidArgument("Arrow time unit is invalid")}function intervalUnit(value){if(value==="year-month"||value==="day-time"||value==="month-day-nano")return value;throw invalidArgument("Arrow interval unit is invalid")}function decodeFloat16(bits){const sign=(bits&32768)===0?1:-1;const exponent=bits>>>10&31;const fraction=bits&1023;if(exponent===0)return sign*2**-14*(fraction/1024);if(exponent===31)return fraction===0?sign*Infinity:Number.NaN;return sign*2**(exponent-15)*(1+fraction/1024)}function normalizeCellLimit(value){const maxCells=value??DEFAULT_TO_ROWS_CELL_LIMIT;assertPositiveSafeInteger(maxCells,"maxCells");return maxCells}function assertCellLimit(rows,columns,maxCells){const cellCount=rows*columns;if(!Number.isSafeInteger(cellCount)||cellCount>maxCells){throw new TabularkError("RESOURCE_LIMIT",`Decoding ${cellCount} cells exceeds the toRows limit of ${maxCells}`,{details:{resource:"row-materialization-cells",required:cellCount,available:maxCells,cellCount,maxCells}})}}function integer(value,name){if(!Number.isSafeInteger(value))throw invalidArgument(`${name} must be a safe integer`);return value}function positiveInteger(value,name){const result=integer(value,name);if(result<=0)throw invalidArgument(`${name} must be positive`);return result}function asUint8Array(value){if(value instanceof ArrayBuffer)return new Uint8Array(value);return new Uint8Array(value.buffer,value.byteOffset,value.byteLength)}function isRecord3(value){return typeof value==="object"&&value!==null}function assertNonNegativeSafeInteger(value,name){if(!Number.isSafeInteger(value)||value<0){throw invalidArgument(`${name} must be a non-negative safe integer`,{name,value})}}function assertPositiveSafeInteger(value,name){if(!Number.isSafeInteger(value)||value<=0){throw invalidArgument(`${name} must be a positive safe integer`,{name,value})}}var PermitQueueFullError=class extends Error{constructor(maxWaiters){super(`The permit queue already has ${maxWaiters} waiters`);this.maxWaiters=maxWaiters;this.name="PermitQueueFullError"}maxWaiters};var AsyncPermitQueue=class{#maxActive;#maxWaiters;#waiters=[];#active=0;constructor(maxActive,maxWaiters){if(!Number.isSafeInteger(maxActive)||maxActive<=0){throw new RangeError("maxActive must be a positive safe integer")}if(!Number.isSafeInteger(maxWaiters)||maxWaiters<0){throw new RangeError("maxWaiters must be a non-negative safe integer")}this.#maxActive=maxActive;this.#maxWaiters=maxWaiters}acquire(key){if(this.#active<this.#maxActive){this.#active+=1;return Promise.resolve(this.#releaseOnce())}if(this.#waiters.length>=this.#maxWaiters){return Promise.reject(new PermitQueueFullError(this.#maxWaiters))}return new Promise((resolve,reject)=>{this.#waiters.push({key,resolve,reject})})}cancel(key,reason){const index=this.#waiters.findIndex(waiter2=>waiter2.key===key);if(index<0){return false}const[waiter]=this.#waiters.splice(index,1);waiter.reject(reason);this.#wakeWaiters();return true}#releaseOnce(){let released=false;return()=>{if(released){return}released=true;this.#active-=1;this.#wakeWaiters()}}#wakeWaiters(){while(this.#active<this.#maxActive&&this.#waiters.length>0){const waiter=this.#waiters.shift();this.#active+=1;waiter.resolve(this.#releaseOnce())}}};var ByteLruCache=class{#maxBytes;#entries=new Map;#onRemove;#byteLength=0;constructor(maxBytes,options={}){if(!Number.isSafeInteger(maxBytes)||maxBytes<0){throw new RangeError("maxBytes must be a non-negative safe integer")}this.#maxBytes=maxBytes;this.#onRemove=options.onRemove}get maxBytes(){return this.#maxBytes}get(key){const entry=this.#entries.get(key);if(!entry){return void 0}this.#entries.delete(key);this.#entries.set(key,entry);return entry.value}set(key,value,byteLength){if(!Number.isSafeInteger(byteLength)||byteLength<0){throw new RangeError("byteLength must be a non-negative safe integer")}if(byteLength>this.#maxBytes){return}const existing=this.#entries.get(key);if(existing){this.#remove(key,existing)}while(this.#byteLength+byteLength>this.#maxBytes){const oldestKey=this.#entries.keys().next().value;if(oldestKey===void 0){break}const oldest=this.#entries.get(oldestKey);this.#remove(oldestKey,oldest)}this.#entries.set(key,{value,byteLength});this.#byteLength+=byteLength}deleteWhere(predicate){for(const[key,entry]of this.#entries){if(!predicate(key,entry.value)){continue}this.#remove(key,entry)}}clear(){for(const[key,entry]of this.#entries){this.#onRemove?.(key,entry.value,entry.byteLength)}this.#entries.clear();this.#byteLength=0}#remove(key,entry){this.#entries.delete(key);this.#byteLength-=entry.byteLength;this.#onRemove?.(key,entry.value,entry.byteLength)}};function rangeCacheKey(owner,revision,schemaVersion,range){return JSON.stringify([owner,revision,schemaVersion,range.rowStart,range.rowCount,range.columnStart,range.columnCount])}function cloneWireTableBatch(batch){return{layoutVersion:batch.layoutVersion,tableId:batch.tableId,revision:batch.revision,schemaVersion:batch.schemaVersion,range:{...batch.range},buffers:batch.buffers.map(buffer=>Uint8Array.from(asUint8Array2(buffer)).buffer),columns:batch.columns,complete:batch.complete}}function wireBatchByteLength(batch){return batch.buffers.reduce((total,buffer)=>total+buffer.byteLength,0)}function asUint8Array2(value){return value instanceof ArrayBuffer?new Uint8Array(value):new Uint8Array(value.buffer,value.byteOffset,value.byteLength)}var ProtocolFault=class extends Error{code;retryable;details;constructor(code,message,retryable=false,details,cause){super(message,{cause});this.name="ProtocolFault";this.code=code;this.retryable=retryable;this.details=code==="RESOURCE_LIMIT"?normalizeResourceLimitDetails(details):details}};function faultFromUnknown(error,fallback){if(error instanceof ProtocolFault){return error}if(isRecord(error)){return new ProtocolFault(typeof error.code==="string"?error.code:"RUNTIME_FAILURE",typeof error.message==="string"?error.message:fallback,error.retryable===true,error.details,error)}if(error instanceof Error){return new ProtocolFault("RUNTIME_FAILURE",error.message||fallback,false,void 0,error)}return new ProtocolFault("RUNTIME_FAILURE",fallback,false,{value:String(error)})}function serializeFault(error,fallback){const fault=faultFromUnknown(error,fallback);const details=fault.code==="RESOURCE_LIMIT"?normalizeResourceLimitDetails(fault.details):fault.details;return{code:fault.code,message:fault.message,retryable:fault.retryable,...details===void 0?{}:{details:normalizeFaultDetails(fault.code,details)}}}function normalizeFaultDetails(code,details){if(code!=="RESOURCE_LIMIT"||!isRecord(details)){return details}const resource=typeof details.resource==="string"?details.resource:typeof details.resourceCategory==="string"?details.resourceCategory:void 0;if(resource===void 0||details.resource===resource){return details}const{resourceCategory:_legacyResourceCategory,...rest}=details;return{...rest,resource}}var WasmAdapter=class _WasmAdapter{#runtime;constructor(runtime){this.#runtime=runtime}static async load(moduleUrl,expectedAdapterId,config){let bindings;try{bindings=await import(moduleUrl);if(typeof bindings.default!=="function"){throw new TypeError("The WebAssembly module does not export a default initializer")}await bindings.default();const Runtime=bindings.WasmRuntime;if(typeof Runtime!=="function"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE",`The ${expectedAdapterId} artifact does not export its official runtime class`)}const adapter=new _WasmAdapter(new Runtime(config));try{adapter.#validateContract(expectedAdapterId)}catch(error){try{adapter.dispose()}catch{}throw error}return adapter}catch(error){if(error instanceof ProtocolFault){throw error}throw new ProtocolFault("RUNTIME_FAILURE","Failed to initialize the Tabulark WebAssembly runtime",false,{moduleUrl},error)}}metadata(sourceHandle){return this.#call("metadata",()=>this.#runtime.metadata(sourceHandle))}presentation(tableHandle){return this.#call("presentation",()=>this.#runtime.presentation(tableHandle))}readPresentationRange(tableHandle,request){return this.#call("readPresentationRange",()=>this.#runtime.readPresentationRange(tableHandle,request))}beginOpen(options,sourceLength){return this.#call("beginOpen",()=>this.#runtime.beginOpen(options,sourceLength))}continueOperation(operationHandle2,absoluteOffset,bytes,eof){return this.#call("continueOperation",()=>this.#runtime.continueOperation(operationHandle2,absoluteOffset,bytes,eof))}openTable(sourceHandle,tableId){return this.#call("openTable",()=>this.#runtime.openTable(sourceHandle,tableId))}beginRead(tableHandle,request){return this.#call("beginRead",()=>this.#runtime.beginRead(tableHandle,request))}cancelOperation(operationHandle2){this.#call("cancelOperation",()=>this.#runtime.cancelOperation(operationHandle2))}closeTable(tableHandle){this.#call("closeTable",()=>this.#runtime.closeTable(tableHandle))}closeSource(sourceHandle){this.#call("closeSource",()=>this.#runtime.closeSource(sourceHandle))}dispose(){try{this.#runtime.shutdown()}catch{}this.#runtime.free?.()}#validateContract(expectedAdapterId){const runtime=this.#runtime;const required=["protocolVersion","adapterApiVersion","batchLayoutVersion","adapterId","beginOpen","continueOperation","openTable","metadata","presentation","readPresentationRange","beginRead","cancelOperation","closeTable","closeSource","shutdown"];for(const name of required){if(typeof runtime[name]!=="function"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE",`WebAssembly adapter does not export ${name}`)}}const protocolVersion=this.#call("protocolVersion",()=>this.#runtime.protocolVersion());const adapterVersion=this.#call("adapterApiVersion",()=>this.#runtime.adapterApiVersion());const layoutVersion=this.#call("batchLayoutVersion",()=>this.#runtime.batchLayoutVersion());const adapterId=this.#call("adapterId",()=>this.#runtime.adapterId());if(protocolVersion!==PROTOCOL_VERSION||adapterVersion!==ADAPTER_API_VERSION||layoutVersion!==BATCH_LAYOUT_VERSION||adapterId!==expectedAdapterId){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE",`Adapter ${adapterId} protocol/ABI/layout ${protocolVersion}/${adapterVersion}/${layoutVersion} is incompatible with ${expectedAdapterId} ${PROTOCOL_VERSION}/${ADAPTER_API_VERSION}/${BATCH_LAYOUT_VERSION}`)}}#call(operation,call){try{return call()}catch(error){throw faultFromUnknown(error,`WebAssembly ${operation} failed`)}}};var official_adapters_default={manifestVersion:1,adapters:[{id:"tabulark:delimited",entrypoint:".",exportName:"delimitedAdapter",wasm:{packageName:"tabulark-delimited-wasm",crateArtifact:"tabulark_delimited",outputName:"tabulark_delimited",outputDirectory:"dist/wasm/delimited",modulePath:"./wasm/delimited/tabulark_delimited.js",runtimeExport:"WasmRuntime"},options:{allowedKeys:["dialect","header","mode","delimiter","sourceName"]},resources:{sourceAccess:"streaming",supportsPresentation:false,runtimeWeight:1}},{id:"tabulark:arrow-ipc",entrypoint:"./arrow",exportName:"arrowIpcAdapter",wasm:{packageName:"tabulark-arrow-wasm",crateArtifact:"tabulark_arrow",outputName:"tabulark_arrow",outputDirectory:"dist/wasm/arrow",modulePath:"./wasm/arrow/tabulark_arrow.js",runtimeExport:"WasmRuntime"},options:{allowedKeys:["container","sourceName"]},resources:{sourceAccess:"range",supportsPresentation:false,runtimeWeight:1}},{id:"tabulark:parquet",entrypoint:"./parquet",exportName:"parquetAdapter",wasm:{packageName:"tabulark-parquet-wasm",crateArtifact:"tabulark_parquet",outputName:"tabulark_parquet",outputDirectory:"dist/wasm/parquet",modulePath:"./wasm/parquet/tabulark_parquet.js",runtimeExport:"WasmRuntime"},options:{allowedKeys:["sourceName"]},resources:{sourceAccess:"range",supportsPresentation:false,runtimeWeight:2}},{id:"tabulark:excel",entrypoint:"./excel",exportName:"excelAdapter",wasm:{packageName:"tabulark-excel-wasm",crateArtifact:"tabulark_excel",outputName:"tabulark_excel",outputDirectory:"dist/wasm/excel",modulePath:"./wasm/excel/tabulark_excel.js",runtimeExport:"WasmRuntime"},options:{allowedKeys:["format","sourceName"]},resources:{sourceAccess:"staged",supportsPresentation:true,runtimeWeight:2}}]};var manifestEntries=validateManifest(official_adapters_default);var OFFICIAL_ADAPTER_IDS=Object.freeze(manifestEntries.map(entry=>entry.id));var OFFICIAL_ADAPTER_MANIFEST=Object.freeze(manifestEntries.map(entry=>Object.freeze({...entry,wasm:Object.freeze({...entry.wasm}),options:Object.freeze({allowedKeys:Object.freeze([...entry.options.allowedKeys])}),resources:Object.freeze({...entry.resources})})));var byId=new Map(OFFICIAL_ADAPTER_MANIFEST.map(entry=>[entry.id,entry]));function isOfficialAdapterId(value){return typeof value==="string"&&byId.has(value)}function officialAdapterManifestEntry(id){const entry=byId.get(id);if(!entry){throw new TypeError(`Unknown official adapter: ${id}`)}return entry}function officialAdapterModuleUrl(id){return new URL(officialAdapterManifestEntry(id).wasm.modulePath,import.meta.url).href}function validateManifest(value){if(!isRecord4(value)||value.manifestVersion!==1||!Array.isArray(value.adapters)){throw new TypeError("The official adapter manifest has an unsupported shape or version")}if(value.adapters.length===0){throw new TypeError("The official adapter manifest must contain at least one adapter")}const ids=new Set;const entrypoints=new Set;const outputDirectories=new Set;return value.adapters.map((candidate,index)=>{if(!isRecord4(candidate)){throw new TypeError(`Official adapter manifest entry ${index} must be an object`)}const{id,entrypoint,exportName,wasm,options,resources}=candidate;if(!isKnownOfficialAdapterId(id)||ids.has(id)){throw new TypeError(`Official adapter manifest entry ${index} has an invalid or duplicate id`)}if(entrypoint!=="."&&entrypoint!=="./arrow"&&entrypoint!=="./parquet"&&entrypoint!=="./excel"||entrypoints.has(entrypoint)||typeof exportName!=="string"||exportName.length===0){throw new TypeError(`Official adapter manifest entry ${index} has an invalid entrypoint or export`)}if(!isRecord4(wasm)||typeof wasm.packageName!=="string"||typeof wasm.crateArtifact!=="string"||typeof wasm.outputName!=="string"||typeof wasm.outputDirectory!=="string"||!wasm.outputDirectory.startsWith("dist/wasm/")||wasm.outputDirectory.includes("..")||outputDirectories.has(wasm.outputDirectory)||typeof wasm.modulePath!=="string"||!wasm.modulePath.startsWith("./wasm/")||wasm.modulePath.includes("..")||wasm.modulePath.includes("?")||wasm.modulePath.includes("#")||wasm.runtimeExport!=="WasmRuntime"||wasm.modulePath!==`./${wasm.outputDirectory.replace(/^dist\//u,"")}/${wasm.outputName}.js`){throw new TypeError(`Official adapter manifest entry ${index} has an invalid WASM artifact`)}if(!isRecord4(options)||!Array.isArray(options.allowedKeys)||options.allowedKeys.some(key=>typeof key!=="string")||new Set(options.allowedKeys).size!==options.allowedKeys.length){throw new TypeError(`Official adapter manifest entry ${index} has invalid option keys`)}if(!isRecord4(resources)||resources.sourceAccess!=="streaming"&&resources.sourceAccess!=="range"&&resources.sourceAccess!=="staged"||typeof resources.supportsPresentation!=="boolean"||!Number.isSafeInteger(resources.runtimeWeight)||resources.runtimeWeight<=0){throw new TypeError(`Official adapter manifest entry ${index} has an invalid resource policy`)}ids.add(id);entrypoints.add(entrypoint);outputDirectories.add(wasm.outputDirectory);return candidate})}function isKnownOfficialAdapterId(value){return value==="tabulark:delimited"||value==="tabulark:arrow-ipc"||value==="tabulark:parquet"||value==="tabulark:excel"}function isRecord4(value){return typeof value==="object"&&value!==null}var CHUNK_BYTES=1024*1024;var MAX_ARROW_SOURCE_BYTES=4294967295;var INITIAL_READ_LIMIT_BYTES=8*CHUNK_BYTES;var INITIAL_ROW_TARGET=256;var MAX_IN_FLIGHT_RANGES=MAX_ACTIVE_RANGES+MAX_RANGE_WAITERS;var scope=globalThis;var shuttingDown=false;var nextDatasetHandle=1;var nextTableHandle=1;var rangeCacheBudgetBytes=0;var memoryLimits;var memoryLedger;var sourceSlotsInUse=0;var rangeRequestsInFlight=0;var adapterRegistrations=new Map;var adapterLoads=new Map;var loadedAdapters=new Map;var adapterRuntimeReservations=new Map;var datasets=new Map;var tables=new Map;var activeRequests=new Map;var openedDatasetsByRequest=new Map;var rangePermits=new AsyncPermitQueue(MAX_ACTIVE_RANGES,MAX_RANGE_WAITERS);scope.addEventListener("message",event=>{void dispatch(event.data)});async function dispatch(value){if(!isRequest(value)){return}const request=value;if(request.protocolVersion!==PROTOCOL_VERSION){postFailure(request.requestId,new ProtocolFault("PROTOCOL_INCOMPATIBLE",`Worker protocol ${PROTOCOL_VERSION} cannot serve protocol ${String(request.protocolVersion)}`));return}try{const result=await runOperation(request);try{postSuccess(request.requestId,result.kind,result.data,result.transfer)}finally{result.release?.()}if(request.op==="listTables"){flushPendingDatasetEvents(request.payload)}if(request.op==="shutdown"){setTimeout(()=>scope.close(),0)}}catch(error){postFailure(request.requestId,error)}}async function runOperation(request){switch(request.op){case"hello":return{kind:"hello",data:await hello(request.payload)};case"openSource":return{kind:"dataset",data:await openSource(request.requestId,request.payload)};case"listTables":return{kind:"tables",data:listTables(request.payload)};case"openTable":return{kind:"table",data:openTable(request.payload)};case"getMetadata":return{kind:"metadata",data:getMetadata(request.payload)};case"getPresentation":return{kind:"presentation",data:getPresentation(request.payload)};case"readPresentationRange":return{kind:"presentationRange",data:readPresentationRange(request.payload)};case"readRange":return readRange(request.requestId,request.payload);case"cancel":cancel(request.payload);return{kind:"acknowledged"};case"closeTable":closeTable(request.payload);return{kind:"acknowledged"};case"closeSource":closeSource(request.payload);return{kind:"acknowledged"};case"shutdown":shutdown();return{kind:"acknowledged"};default:throw new ProtocolFault("INVALID_ARGUMENT",`Unknown operation: ${String(request.op)}`)}}async function hello(value){const payload=expectRecord(value,"hello payload");if(!Number.isSafeInteger(payload.memoryBudgetBytes)||payload.memoryBudgetBytes<=0){throw new ProtocolFault("INVALID_ARGUMENT","memoryBudgetBytes must be a positive safe integer")}if(!Array.isArray(payload.adapters)||payload.adapters.length===0){throw new ProtocolFault("INVALID_ARGUMENT","hello adapters must be a non-empty array")}const registrations=new Map;for(const entry of payload.adapters){if(!isRecord(entry)||!isOfficialAdapterId(entry.id)||Object.keys(entry).some(key=>key!=="id")){throw new ProtocolFault("INVALID_ARGUMENT","hello contains an invalid official adapter")}if(registrations.has(entry.id)){throw new ProtocolFault("INVALID_ARGUMENT",`Adapter ${entry.id} is registered more than once`)}registrations.set(entry.id,Object.freeze({id:entry.id,moduleUrl:adapterModuleUrl(entry.id)}))}if(memoryLimits){const sameIds=registrations.size===adapterRegistrations.size&&[...registrations.keys()].every(id=>adapterRegistrations.has(id));if(payload.memoryBudgetBytes!==memoryLimits.memoryBudgetBytes||!sameIds){throw new ProtocolFault("INVALID_ARGUMENT","The Worker hello handshake cannot be reconfigured after initialization")}return helloResult()}const limits=deriveMemoryBudgetLimits(payload.memoryBudgetBytes);adapterRegistrations=registrations;memoryLimits=limits;memoryLedger=new MemoryReservationLedger(payload.memoryBudgetBytes);rangeCacheBudgetBytes=limits.workerDatasetRangeCacheBytes;return helloResult()}function helloResult(){return{protocolVersion:PROTOCOL_VERSION,adapterApiVersion:ADAPTER_API_VERSION,batchLayoutVersion:BATCH_LAYOUT_VERSION,adapters:Object.freeze([...adapterRegistrations.keys()]),transferableBatches:true}}function createActiveOpenRequest(requestId){return{requestId,kind:"open",cancelled:false,cancellation:createRequestCancellation()}}function createRequestCancellation(){let resolveCancellation;const promise=new Promise(resolve=>{resolveCancellation=resolve});return{promise,resolve:resolveCancellation}}async function openSource(requestId,value){const active=createActiveOpenRequest(requestId);activeRequests.set(requestId,active);let dataset;let sourceHandle;let releaseSourceSlot;let opened=false;try{const limits=requireMemoryLimits();const payload=expectRecord(value,"openSource payload");if(!isOfficialAdapterId(payload.adapterId)){throw new ProtocolFault("INVALID_ARGUMENT","openSource adapterId is not registered")}if(!isRecord(payload.options)||Array.isArray(payload.options)){throw new ProtocolFault("INVALID_ARGUMENT","openSource options must be an object")}let source;if(payload.source instanceof Blob){source=payload.source}else if(payload.source instanceof ArrayBuffer){if(payload.source.byteLength>limits.maxArrayBufferBytes){throw new ProtocolFault("RESOURCE_LIMIT",`ArrayBuffer sources larger than ${limits.maxArrayBufferBytes} bytes must be supplied as a Blob`,false,{resource:"source-staging",requiredBytes:payload.source.byteLength,availableBytes:limits.maxArrayBufferBytes})}source=new Blob([payload.source])}else{throw new ProtocolFault("INVALID_ARGUMENT","source must be a Blob or ArrayBuffer")}releaseSourceSlot=reserveSourceSlot();const runtime=await awaitOperationStep(loadAdapter(payload.adapterId),active);active.adapter=runtime;const initialStep=runtime.beginOpen(adapterOpenOptions(payload,limits),source.size);const openRaw=await runOpenUntilPublished(runtime,source,initialStep,active,payload.adapterId);const progressiveOpen=isProgressiveOpenStep(openRaw);if(openRaw.sourceHandle===void 0||openRaw.sourceHandle===null){throw new ProtocolFault("RUNTIME_FAILURE","Adapter open did not return a sourceHandle")}sourceHandle=operationHandle(openRaw.sourceHandle,"sourceHandle");throwIfCancelled(active);const datasetHandle=`d${nextDatasetHandle++}`;const initialMetadata=normalizeMetadata(openRaw.metadata,normalizeDescriptor(openRaw.table,0));const initialTables=normalizeDescriptors(Array.isArray(openRaw.tables)?openRaw.tables:void 0,openRaw.table,initialMetadata);const openedDataset={handle:datasetHandle,openRequestId:requestId,source,adapterId:payload.adapterId,adapter:runtime,sourceHandle,tables:initialTables,metadata:initialMetadata,scanOffset:progressiveOpen?0:source.size,scanDone:!progressiveOpen,closed:false,eventsReady:false,pendingWarnings:progressiveOpen?[]:Array.isArray(openRaw.warnings)?[...openRaw.warnings]:[],waiters:new Set,rangeCache:createRangeCache(),...active.openedWorksheetReservation===void 0?{}:{openedWorksheetReservation:active.openedWorksheetReservation},releaseSourceSlot};dataset=openedDataset;delete active.openedWorksheetReservation;datasets.set(datasetHandle,openedDataset);releaseSourceSlot=void 0;active.datasetHandle=datasetHandle;if(progressiveOpen){applyProgressiveOpenStep(openedDataset,openRaw,false);await scanInitialPrefix(openedDataset,active);throwIfCancelled(active);delete active.operationHandle;if(!openedDataset.scanDone){openedDataset.scanPromise=scanOpenToEnd(openedDataset)}else{openedDataset.pendingProgress=scanProgress(openedDataset)}}openedDatasetsByRequest.set(requestId,datasetHandle);opened=true;return{datasetHandle}}finally{activeRequests.delete(requestId);if(!opened){if(dataset&&!dataset.closed){closeDatasetState(dataset,false)}else if(!dataset&&sourceHandle!==void 0){try{active.adapter?.closeSource(sourceHandle)}catch{}}}active.openedWorksheetReservation?.release();releaseSourceSlot?.()}}function adapterOpenOptions(payload,limits){const sourceName=typeof payload.options.sourceName==="string"&&payload.options.sourceName.length>0?payload.options.sourceName:void 0;if(payload.adapterId==="tabulark:delimited"){const delimiter=payload.options.delimiter;const header=payload.options.header;const mode=payload.options.mode;if(!isValidDelimiter(delimiter)){throw new ProtocolFault("INVALID_ARGUMENT","Delimited adapter delimiter must be one non-NUL ASCII byte other than CR, LF, or quote")}if(header!=="first-row"&&header!=="none"){throw new ProtocolFault("INVALID_ARGUMENT","Delimited adapter header must be first-row or none")}if(mode!=="lenient"&&mode!=="strict"){throw new ProtocolFault("INVALID_ARGUMENT","Delimited adapter mode must be lenient or strict")}return Object.freeze({delimiter,header:header==="first-row",mode,checkpointInterval:1024,tableName:sourceName??"Table 1",limits:Object.freeze({maxFieldBytes:limits.maxFieldBytes,maxColumns:16384,maxCellsPerRange:25e4,maxBatchBytes:limits.maxBatchBytes,maxDiagnostics:1e3})})}if(payload.adapterId==="tabulark:arrow-ipc"){const container=payload.options.container;if(container!=="auto"&&container!=="file"&&container!=="stream"){throw new ProtocolFault("INVALID_ARGUMENT","Arrow adapter container must be auto, file, or stream")}return Object.freeze({container,tableName:sourceName??"Arrow IPC",limits:Object.freeze({maxSourceBytes:MAX_ARROW_SOURCE_BYTES,maxDecodedBytes:limits.operationBudgetBytes,maxOutputBytes:limits.maxBatchBytes,maxMetadataBytes:limits.maxFieldBytes,maxBlockBytes:Math.min(64*1024*1024,Math.max(1,Math.floor(limits.operationBudgetBytes/4))),streamChunkBytes:Math.min(32*1024,Math.max(1,Math.floor(limits.operationBudgetBytes/16))),maxFields:16384,maxNestingDepth:64,maxRangeCells:25e4,maxDisplayCellBytes:Math.min(1024*1024,Math.max(1,Math.floor(limits.operationBudgetBytes/16)))})})}if(payload.adapterId==="tabulark:parquet"){return Object.freeze({sourceName:sourceName??"Parquet"})}const format=payload.options.format;if(format!=="auto"&&format!=="xls"&&format!=="xlsx"){throw new ProtocolFault("INVALID_ARGUMENT","Excel adapter format must be auto, xls, or xlsx")}return Object.freeze({format,...sourceName===void 0?{}:{sourceName}})}function listTables(value){const payload=expectRecord(value,"listTables payload");const dataset=requireDataset(payload.datasetHandle);return dataset.tables}function openTable(value){const payload=expectRecord(value,"openTable payload");const dataset=requireDataset(payload.datasetHandle);if(typeof payload.tableId!=="string"){throw new ProtocolFault("INVALID_ARGUMENT","tableId must be a string")}if(!dataset.tables.some(table=>table.id===payload.tableId)){throw new ProtocolFault("INVALID_ARGUMENT",`Unknown table: ${payload.tableId}`)}const tableHandle=`t${nextTableHandle++}`;const result=dataset.adapter.openTable(dataset.sourceHandle,payload.tableId);const raw=isRecord(result)?result:{};const adapterTableHandle=operationHandle(raw.tableHandle??raw.handle??result,"openTable tableHandle");const descriptor=dataset.tables.find(candidate=>candidate.id===payload.tableId)??{id:payload.tableId,name:payload.tableId};const metadata=normalizeMetadata(raw.metadata??dataset.adapter.metadata(adapterTableHandle),descriptor);tables.set(tableHandle,{handle:tableHandle,datasetHandle:dataset.handle,tableId:payload.tableId,adapterTableHandle,metadata,closed:false});return{id:payload.tableId,name:dataset.tables.find(descriptor2=>descriptor2.id===payload.tableId)?.name??payload.tableId,tableHandle}}function getMetadata(value){const payload=expectRecord(value,"getMetadata payload");const table=requireTable(payload.tableHandle);const dataset=requireDataset(table.datasetHandle);const metadata=normalizeMetadata(dataset.adapter.metadata(table.adapterTableHandle),{id:table.tableId,name:table.metadata.name});table.metadata=metadata;return metadata}function getPresentation(value){const payload=expectRecord(value,"getPresentation payload");const table=requireTable(payload.tableHandle);const dataset=requireDataset(table.datasetHandle);return normalizePresentationResult(dataset.adapter.presentation(table.adapterTableHandle),table)}function readPresentationRange(value){const payload=expectRecord(value,"readPresentationRange payload");const table=requireTable(payload.tableHandle);const dataset=requireDataset(table.datasetHandle);const range=normalizeRange(payload.range);const result=dataset.adapter.readPresentationRange(table.adapterTableHandle,range);return normalizePresentationRangeResult(result,table,range)}function normalizePresentationResult(value,table){if(value===null||value===void 0)return null;const raw=expectRecord(value,"table presentation");if(raw.kind!=="spreadsheet-v1"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter returned an unknown presentation kind")}if(raw.tableId!==void 0&&raw.tableId!==table.tableId){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter presentation belongs to another table")}return{...raw,kind:"spreadsheet-v1",tableId:table.tableId,revision:numberOr(raw.revision,table.metadata.revision)}}function normalizePresentationRangeResult(value,table,requested){if(value===null||value===void 0)return null;const raw=expectRecord(value,"presentation range");if(raw.kind!=="spreadsheet-v1"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter returned an unknown presentation range kind")}if(raw.tableId!==void 0&&raw.tableId!==table.tableId){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter presentation range belongs to another table")}const range=isRecord(raw.range)?normalizeRange(raw.range):requested;if(range.rowStart!==requested.rowStart||range.rowCount!==requested.rowCount||range.columnStart!==requested.columnStart||range.columnCount!==requested.columnCount){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter presentation range is not aligned with the requested range")}return{...raw,kind:"spreadsheet-v1",tableId:table.tableId,revision:numberOr(raw.revision,table.metadata.revision),range}}function isProgressiveOpenStep(value){if(!isRecord(value)||value.kind!=="open-progress"||!isRecord(value.action)){return false}return value.action.kind==="read-bytes"&&value.sourceHandle!==void 0&&value.metadata!==void 0&&isRecord(value.progress)}function applyProgressiveOpenStep(dataset,value,emitEvents){const sourceHandle=operationHandle(value.sourceHandle,"sourceHandle");if(sourceHandle!==dataset.sourceHandle){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter open changed its sourceHandle")}const metadata=normalizeMetadata(value.metadata,dataset.tables[0]);const progress=value.progress===void 0&&value.kind==="open-complete"?Object.freeze({bytesScanned:dataset.source.size,rowsDiscovered:discoveredRows(metadata),done:true}):normalizeOpenProgress(value.progress,dataset.source.size);if(progress.bytesScanned<dataset.scanOffset){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter scan bytes regressed")}const previousMetadata=JSON.stringify(dataset.metadata);const tableDescriptors=normalizeDescriptors(Array.isArray(value.tables)?value.tables:void 0,value.table,metadata);const complete=value.kind==="open-complete";if(complete!==progress.done){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter completion and progress disagree")}if(progress.rowsDiscovered!==discoveredRows(metadata)){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter progress and metadata row counts disagree")}const action=isRecord(value.action)?value.action:void 0;if(!progress.done&&!action){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter scan returned neither progress action nor completion")}if(progress.done&&action){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Completed adapter scan returned another read action")}if(action&&nonNegativeSafeInteger(action.offset,"read-bytes offset")!==progress.bytesScanned){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter action does not begin at the scanned prefix")}dataset.metadata=metadata;dataset.tables=tableDescriptors;dataset.scanOffset=progress.bytesScanned;dataset.scanDone=progress.done;if(action){dataset.scanOperationHandle=operationHandle(value.operationHandle,"operationHandle");dataset.scanStep=value}else{delete dataset.scanOperationHandle;delete dataset.scanStep}if(emitEvents&&dataset.eventsReady&&JSON.stringify(metadata)!==previousMetadata){emitMetadataUpdate(dataset)}const warnings=Array.isArray(value.warnings)?value.warnings:value.warning===void 0?[]:[value.warning];if(!emitEvents||!dataset.eventsReady){dataset.pendingWarnings.push(...warnings)}else{emitWarnings(dataset,warnings)}if(emitEvents){publishScanProgress(dataset)}notifyScanWaiters(dataset)}async function scanInitialPrefix(dataset,active){while(!dataset.closed&&!dataset.scanDone&&dataset.scanOffset<Math.min(dataset.source.size,INITIAL_READ_LIMIT_BYTES)&&discoveredRows(dataset.metadata)<INITIAL_ROW_TARGET){await scanOpenNextChunk(dataset,active,false)}if(!dataset.closed&&dataset.source.size===0&&!dataset.scanDone){await scanOpenNextChunk(dataset,active,false)}throwIfCancelled(active);if(dataset.closed){throw new ProtocolFault("HANDLE_CLOSED","The source was closed while opening")}}async function scanOpenToEnd(dataset){try{while(!dataset.closed&&!dataset.scanDone){await scanOpenNextChunk(dataset,void 0,true)}}catch(error){if(dataset.closed){return}const failure=error instanceof ProtocolFault?error:new ProtocolFault("RUNTIME_FAILURE","Background source scanning failed",false,void 0,error);dataset.scanError=failure;dataset.scanDone=true;delete dataset.scanStep;delete dataset.scanOperationHandle;notifyScanWaiters(dataset);try{emit({event:"runtimeError",datasetHandle:dataset.handle,tableId:dataset.metadata.tableId,revision:dataset.metadata.revision,payload:serializeFault(failure,"Background source scanning failed")})}finally{closeDatasetState(dataset,true,failure)}}}async function scanOpenNextChunk(dataset,active,emitEvents){if(dataset.closed||dataset.scanDone){return}const step=dataset.scanStep;if(!step){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter scan has no pending read action")}if(step.kind!=="open-progress"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter scan did not return an open-progress step")}const action=isRecord(step.action)?step.action:void 0;if(!action||action.kind!=="read-bytes"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter scan requested an unsupported action")}const operation=operationHandle(step.operationHandle,"operationHandle");const offset=nonNegativeSafeInteger(action.offset,"read-bytes offset");const length=nonNegativeSafeInteger(action.length,"read-bytes length");const limits=requireMemoryLimits();const readLimit=operationReadLimit(dataset.adapterId,limits);if(length>readLimit||!Number.isSafeInteger(offset+length)||offset+length>dataset.source.size){throw new ProtocolFault("RESOURCE_LIMIT","Adapter scan read-bytes action exceeds the source or engine memory budget",false,{resource:operationResource(dataset.adapterId),requiredBytes:length,availableBytes:readLimit,offset,sourceLength:dataset.source.size})}dataset.scanOperationHandle=operation;if(active){active.operationHandle=operation;throwIfCancelled(active)}const reservation=reserveOperationMemory(dataset.adapterId,length);const read=await acquireReservedBlobRead(dataset.source.slice(offset,offset+length),reservation,active);let next;try{const bytes=new Uint8Array(read.buffer);if(dataset.closed){return}if(active){throwIfCancelled(active)}next=expectRecord(dataset.adapter.continueOperation(operation,offset,bytes,offset+length>=dataset.source.size),"adapter scan result")}finally{read.release()}if(dataset.closed){return}applyProgressiveOpenStep(dataset,next,emitEvents);if(active){active.operationHandle=dataset.scanOperationHandle}}function normalizeOpenProgress(value,sourceSize){const raw=expectRecord(value,"adapter scan progress");const bytesScanned=nonNegativeSafeInteger(raw.bytesScanned,"progress bytesScanned");const rowsDiscovered=nonNegativeSafeInteger(raw.rowsDiscovered,"progress rowsDiscovered");if(bytesScanned>sourceSize||typeof raw.done!=="boolean"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Delimited scan progress is invalid")}return Object.freeze({bytesScanned,rowsDiscovered,done:raw.done})}function discoveredRows(metadata){return metadata.extent.rows.kind==="unknown"?0:metadata.extent.rows.value}function scanProgress(dataset){return Object.freeze({bytesScanned:dataset.scanOffset,rowsDiscovered:discoveredRows(dataset.metadata),done:dataset.scanDone})}function publishScanProgress(dataset){const progress=scanProgress(dataset);if(!dataset.eventsReady){dataset.pendingProgress=progress;return}emit({event:"progress",datasetHandle:dataset.handle,tableId:dataset.metadata.tableId,revision:dataset.metadata.revision,payload:{sourceHandle:dataset.handle,tableId:dataset.metadata.tableId,revision:dataset.metadata.revision,...progress}})}function emitMetadataUpdate(dataset){emit({event:"metadata",datasetHandle:dataset.handle,tableId:dataset.metadata.tableId,revision:dataset.metadata.revision,payload:dataset.metadata});for(const table of tables.values()){if(table.datasetHandle===dataset.handle&&table.tableId===dataset.metadata.tableId&&!table.closed){table.metadata=dataset.metadata;emit({event:"metadata",datasetHandle:dataset.handle,tableHandle:table.handle,tableId:table.tableId,revision:dataset.metadata.revision,payload:dataset.metadata})}}}async function waitUntilIndexed(dataset,request,active){if(request.rowCount===0){return}while(!dataset.scanDone&&discoveredRows(dataset.metadata)<=request.rowStart){throwIfCancelled(active);await new Promise(resolve=>dataset.waiters.add(resolve))}throwIfCancelled(active);if(dataset.scanError){throw dataset.scanError}}function notifyScanWaiters(dataset){const waiters=[...dataset.waiters];dataset.waiters.clear();for(const resolve of waiters){resolve()}}async function readRange(requestId,value){const payload=expectRecord(value,"readRange payload");const table=requireTable(payload.tableHandle);const dataset=requireDataset(table.datasetHandle);const runtime=dataset.adapter;const request=normalizeRange(payload.range);const key=rangeCacheKey(table.tableId,table.metadata.revision,table.metadata.schema.version,request);const cached=dataset.rangeCache.get(key);if(cached){const reservation=requireMemoryLedger().reserve("batch",wireBatchByteLength(cached.batch));try{const batch=cloneWireTableBatch(cached.batch);return{kind:"batch",data:batch,transfer:collectBatchTransfers(batch),release:reservation.release}}catch(error){reservation.release();throw error}}if(rangeRequestsInFlight>=MAX_IN_FLIGHT_RANGES){throw new ProtocolFault("RESOURCE_LIMIT",`The engine may have at most ${MAX_IN_FLIGHT_RANGES} in-flight range requests`,false,{resource:"range-request-slots",required:rangeRequestsInFlight+1,available:MAX_IN_FLIGHT_RANGES,maxActiveRanges:MAX_ACTIVE_RANGES,maxRangeWaiters:MAX_RANGE_WAITERS})}rangeRequestsInFlight+=1;const active={requestId,kind:"range",datasetHandle:dataset.handle,tableHandle:table.handle,adapter:runtime,cancelled:false,cancellation:createRequestCancellation()};activeRequests.set(requestId,active);let releasePermit;try{await waitUntilIndexed(dataset,request,active);throwIfCancelled(active);try{releasePermit=await rangePermits.acquire(requestId)}catch(error){if(error instanceof PermitQueueFullError){throw new ProtocolFault("RESOURCE_LIMIT",`The range queue may contain at most ${error.maxWaiters} waiters`,false,{resource:"range-waiter-slots",required:error.maxWaiters+1,available:error.maxWaiters,maxActiveRanges:MAX_ACTIVE_RANGES,maxRangeWaiters:error.maxWaiters})}throw error}throwIfCancelled(active);const rawBatch=await runAdapterOperation(runtime,dataset.source,runtime.beginRead(table.adapterTableHandle,request),active,dataset.adapterId);throwIfCancelled(active);const rawBatchBytes=rawBatchByteLength(rawBatch);const batchReservation=requireMemoryLedger().reserve("batch",rawBatchBytes);let batch;try{batch=copyBatch(rawBatch,table,dataset,request)}catch(error){batchReservation.release();throw error}if(batch.complete){cacheBatch(dataset,table,request,batch)}const transfer=collectBatchTransfers(batch);return{kind:"batch",data:batch,transfer,release:batchReservation.release}}finally{activeRequests.delete(requestId);releasePermit?.();rangeRequestsInFlight-=1}}function cancel(value){const payload=expectRecord(value,"cancel payload");if(typeof payload.targetRequestId!=="string"){throw new ProtocolFault("INVALID_ARGUMENT","cancel targetRequestId must be a string")}const active=activeRequests.get(payload.targetRequestId);if(active){cancelActive(active);return{cancelled:true}}const datasetHandle=openedDatasetsByRequest.get(payload.targetRequestId);if(!datasetHandle){return{cancelled:false}}const dataset=datasets.get(datasetHandle);if(!dataset||dataset.closed){openedDatasetsByRequest.delete(payload.targetRequestId);return{cancelled:false}}closeDatasetState(dataset,false);return{cancelled:true}}function closeTable(value){const payload=expectRecord(value,"closeTable payload");if(typeof payload.tableHandle!=="string"){throw new ProtocolFault("INVALID_ARGUMENT","tableHandle must be a string")}const table=tables.get(payload.tableHandle);if(!table||table.closed){return{closed:true}}closeTableState(table,true);return{closed:true}}function closeSource(value){const payload=expectRecord(value,"closeSource payload");if(typeof payload.datasetHandle!=="string"){throw new ProtocolFault("INVALID_ARGUMENT","datasetHandle must be a string")}const dataset=datasets.get(payload.datasetHandle);if(!dataset||dataset.closed){return{closed:true}}closeDatasetState(dataset,true);return{closed:true}}function shutdown(){if(shuttingDown){return{closed:true}}shuttingDown=true;for(const dataset of[...datasets.values()]){closeDatasetState(dataset,false)}for(const adapter of loadedAdapters.values()){adapter.dispose()}for(const reservation of adapterRuntimeReservations.values()){reservation.release()}adapterRuntimeReservations.clear();loadedAdapters.clear();adapterLoads.clear();adapterRegistrations.clear();return{closed:true}}function reserveSourceSlot(){const limits=requireMemoryLimits();if(sourceSlotsInUse>=limits.maxSources){throw new ProtocolFault("RESOURCE_LIMIT",`The engine may retain at most ${limits.maxSources} sources or in-flight opens`,false,{resource:"source-slots",required:sourceSlotsInUse+1,available:limits.maxSources,maxSources:limits.maxSources})}sourceSlotsInUse+=1;let released=false;return()=>{if(released){return}released=true;sourceSlotsInUse-=1}}function awaitOperationStep(operation,active){return Promise.race([operation,active.cancellation.promise.then(()=>{throw new ProtocolFault("CANCELLED",active.kind==="open"?"The open request was cancelled":"The range request was cancelled")})])}async function acquireReservedBlobRead(blob,reservation,active){let operation;try{operation=blob.arrayBuffer()}catch(error){reservation.release();throw error}try{const buffer=active===void 0?await operation:await awaitOperationStep(operation,active);return Object.freeze({buffer,release:reservation.release})}catch(error){if(active?.cancelled){void operation.then(()=>reservation.release(),()=>reservation.release())}else{reservation.release()}throw error}}function flushPendingDatasetEvents(value){const payload=isRecord(value)?value:{};if(typeof payload.datasetHandle!=="string"){return}const dataset=datasets.get(payload.datasetHandle);if(!dataset||dataset.closed||dataset.eventsReady){return}dataset.eventsReady=true;emitWarnings(dataset,dataset.pendingWarnings.splice(0));if(dataset.pendingProgress){const progress=dataset.pendingProgress;delete dataset.pendingProgress;emit({event:"progress",datasetHandle:dataset.handle,tableId:dataset.metadata.tableId,revision:dataset.metadata.revision,payload:{sourceHandle:dataset.handle,tableId:dataset.metadata.tableId,revision:dataset.metadata.revision,...progress}})}}function emitWarnings(dataset,warnings){for(const warning of warnings){emit({event:"warning",datasetHandle:dataset.handle,tableId:dataset.metadata.tableId,payload:{handle:dataset.handle,...isRecord(warning)?warning:{kind:"warning",message:String(warning)}}})}}function cancelActive(active,failure){if(active.cancelled){if(active.kind==="range"&&active.failure===void 0&&failure!==void 0){active.failure=failure}return}active.cancelled=true;if(active.operationHandle!==void 0){try{active.adapter?.cancelOperation(active.operationHandle)}catch{}}active.cancellation.resolve();if(active.kind==="open"){if(active.datasetHandle){const dataset2=datasets.get(active.datasetHandle);if(dataset2&&!dataset2.closed){closeDatasetState(dataset2,false)}}return}if(failure!==void 0){active.failure=failure}rangePermits.cancel(active.requestId,failure??new ProtocolFault("CANCELLED","The range request was cancelled"));const dataset=datasets.get(active.datasetHandle);if(dataset){notifyScanWaiters(dataset)}}function throwIfCancelled(active){if(active.cancelled){if(active.kind==="range"&&active.failure!==void 0){throw active.failure}throw new ProtocolFault("CANCELLED",active.kind==="open"?"The open request was cancelled":"The range request was cancelled")}}function closeTableState(table,emitEvent,failure){table.closed=true;for(const active of activeRequests.values()){if(active.kind==="range"&&active.tableHandle===table.handle){cancelActive(active,failure)}}tables.delete(table.handle);const dataset=datasets.get(table.datasetHandle);if(dataset){try{dataset.adapter.closeTable(table.adapterTableHandle)}catch{}}if(emitEvent){emit({event:"closed",datasetHandle:table.datasetHandle,tableHandle:table.handle,tableId:table.tableId,revision:table.metadata.revision,payload:{handle:table.handle,kind:"table"}})}}function closeDatasetState(dataset,emitEvent,failure){dataset.closed=true;dataset.pendingWarnings.length=0;delete dataset.pendingProgress;openedDatasetsByRequest.delete(dataset.openRequestId);dataset.rangeCache.clear();dataset.openedWorksheetReservation?.release();notifyScanWaiters(dataset);if(dataset.scanOperationHandle!==void 0){try{dataset.adapter.cancelOperation(dataset.scanOperationHandle)}catch{}delete dataset.scanOperationHandle;delete dataset.scanStep}for(const table of[...tables.values()]){if(table.datasetHandle===dataset.handle){closeTableState(table,emitEvent,failure)}}for(const active of activeRequests.values()){if(active.datasetHandle===dataset.handle){cancelActive(active,failure)}}datasets.delete(dataset.handle);dataset.releaseSourceSlot();try{dataset.adapter.closeSource(dataset.sourceHandle)}catch{}if(emitEvent){emit({event:"closed",datasetHandle:dataset.handle,tableId:dataset.metadata.tableId,revision:dataset.metadata.revision,payload:{handle:dataset.handle,kind:"source"}})}}function copyBatch(value,table,dataset,request){const raw=expectRecord(value,"range batch");if(!Array.isArray(raw.columns)){throw new ProtocolFault("RUNTIME_FAILURE","Range batch columns must be an array")}const rawRange=isRecord(raw.range)?raw.range:{};const range={rowStart:numberOr(rawRange.rowStart,request.rowStart),rowCount:numberOr(rawRange.rowCount,0),columnStart:numberOr(rawRange.columnStart,request.columnStart),columnCount:numberOr(rawRange.columnCount,raw.columns.length)};if(raw.layoutVersion!==BATCH_LAYOUT_VERSION){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE",`Adapter returned batch layout ${String(raw.layoutVersion)}; expected ${BATCH_LAYOUT_VERSION}`)}const buffers=copyBufferPool(raw.buffers);const columns=raw.columns.map((column,index)=>copyGenericColumn(column,range.rowCount,index));const batch={layoutVersion:BATCH_LAYOUT_VERSION,tableId:typeof raw.tableId==="string"?raw.tableId:table.tableId,revision:numberOr(raw.revision,table.metadata.revision),schemaVersion:numberOr(raw.schemaVersion,table.metadata.schema.version),range,buffers,columns,complete:raw.complete!==false};new ColumnarTableBatch(batch);return batch}function rawBatchByteLength(value){const raw=expectRecord(value,"range batch");if(!Array.isArray(raw.buffers)){throw new ProtocolFault("RUNTIME_FAILURE","Layout-v1 batch buffers must be an array")}let total=0;for(const[index,buffer]of raw.buffers.entries()){const bytes=buffer instanceof ArrayBuffer?buffer.byteLength:ArrayBuffer.isView(buffer)?buffer.byteLength:void 0;if(bytes===void 0){throw new ProtocolFault("RUNTIME_FAILURE",`batch buffer ${index} must be a Uint8Array`)}total+=bytes;if(!Number.isSafeInteger(total)){throw new ProtocolFault("RESOURCE_LIMIT","Batch buffers exceed the safe integer range",false,{resource:"batch",requiredBytes:total,availableBytes:Number.MAX_SAFE_INTEGER})}}return total}function createRangeCache(){return new ByteLruCache(rangeCacheBudgetBytes,{onRemove:(_key,entry)=>entry.reservation.release()})}function cacheBatch(dataset,table,request,batch){const byteLength=wireBatchByteLength(batch);if(byteLength>dataset.rangeCache.maxBytes){return}let reservation;try{reservation=requireMemoryLedger().reserve("range-cache",byteLength)}catch{return}try{const cachedBatch=cloneWireTableBatch(batch);dataset.rangeCache.set(rangeCacheKey(table.tableId,batch.revision,batch.schemaVersion,request),Object.freeze({batch:cachedBatch,reservation}),byteLength)}catch(error){reservation.release();throw error}}function copyBufferPool(value){if(!Array.isArray(value)){throw new ProtocolFault("RUNTIME_FAILURE","Layout-v1 batch buffers must be an array")}return value.map((entry,index)=>copyBytes(entry,`batch buffer ${index}`).buffer)}function copyGenericColumn(value,rows,index){const raw=expectRecord(value,"batch column");return Object.freeze({columnId:typeof raw.columnId==="string"?raw.columnId:`c${index}`,native:copyNativeDescriptor(raw.native,rows,0),display:copyDisplayDescriptor(raw.display)})}function copyNativeDescriptor(value,fallbackLength,depth){if(depth>=64){throw new ProtocolFault("RESOURCE_LIMIT","Native descriptor nesting may not exceed 64",false,{resource:"descriptor-nesting",required:depth+1,available:64})}const raw=expectRecord(value,"native column descriptor");const encoding=typeof raw.encoding==="string"?raw.encoding:"";const common={...encoding.length===0?{}:{encoding},dataType:raw.dataType,length:numberOr(raw.length,fallbackLength),...raw.validity===void 0?{}:{validity:copyRegion(raw.validity,"validity")}};switch(encoding){case"null":return Object.freeze(common);case"bitmap":return Object.freeze({...common,values:copyRegion(raw.values,"bitmap values")});case"fixed-width":return Object.freeze({...common,values:copyRegion(raw.values,"fixed-width values")});case"variable-width":return Object.freeze({...common,offsets:copyRegion(raw.offsets,"variable-width offsets"),data:copyRegion(raw.values,"variable-width values")});case"view":return Object.freeze({...common,values:copyRegion(raw.views,"view records"),variadicBuffers:Object.freeze((Array.isArray(raw.buffers)?raw.buffers:[]).map(entry=>copyRegion(entry,"view buffer")))});case"list":return Object.freeze({...common,offsets:copyRegion(raw.offsets,"list offsets"),children:Object.freeze([copyNativeDescriptor(raw.values,0,depth+1)])});case"list-view":return Object.freeze({...common,offsets:copyRegion(raw.offsets,"list-view offsets"),sizes:copyRegion(raw.sizes,"list-view sizes"),children:Object.freeze([copyNativeDescriptor(raw.values,0,depth+1)])});case"fixed-size-list":return Object.freeze({...common,children:Object.freeze([copyNativeDescriptor(raw.values,0,depth+1)])});case"struct":return Object.freeze({...common,children:Object.freeze((Array.isArray(raw.fields)?raw.fields:[]).map(field=>copyNativeDescriptor(field,0,depth+1)))});case"union":{const fields=Array.isArray(raw.fields)?raw.fields:[];return Object.freeze({...common,typeIds:copyRegion(raw.typeIds??raw.type_ids,"union type ids"),...raw.offsets===void 0?{}:{unionOffsets:copyRegion(raw.offsets,"union offsets")},children:Object.freeze(fields.map(field=>{const entry=expectRecord(field,"union child");return Object.freeze({...copyNativeDescriptor(entry.values,0,depth+1),typeId:numberOr(entry.typeId,0)})}))})}case"dictionary":return Object.freeze({...common,children:Object.freeze([copyNativeDescriptor(raw.keys,common.length,depth+1),copyNativeDescriptor(raw.values,0,depth+1)]),dictionary:copyNativeDescriptor(raw.values,0,depth+1)});case"run-end-encoded":return Object.freeze({...common,runEnds:copyNativeDescriptor(raw.runEnds??raw.run_ends,0,depth+1),children:Object.freeze([copyNativeDescriptor(raw.values,0,depth+1)])});default:throw new ProtocolFault("PROTOCOL_INCOMPATIBLE",`Adapter returned an unknown native array encoding: ${encoding||"<missing>"}`)}}function copyDisplayDescriptor(value){const raw=expectRecord(value,"display column descriptor");if(raw.encoding!=="variable-width"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter display columns must use the UTF-8 variable-width layout")}return Object.freeze({encoding:"utf8",data:copyRegion(raw.values,"display values"),offsets:copyRegion(raw.offsets,"display offsets"),...raw.validity===void 0?{}:{validity:copyRegion(raw.validity,"display validity")}})}function copyRegion(value,name){const wrapper=expectRecord(value,`${name} region`);const raw=isRecord(wrapper.buffer)?wrapper.buffer:wrapper;if(!Number.isSafeInteger(raw.buffer)||raw.buffer<0){throw new ProtocolFault("RUNTIME_FAILURE",`${name} region has an invalid buffer index`)}return Object.freeze({buffer:raw.buffer,...raw.byteOffset===void 0?{}:{byteOffset:numberOr(raw.byteOffset,0)},...raw.byteLength===void 0?{}:{byteLength:numberOr(raw.byteLength,0)},...wrapper.bitOffset===void 0?{}:{bitOffset:numberOr(wrapper.bitOffset,0)}})}function copyBytes(value,name){if(value instanceof ArrayBuffer){return Uint8Array.from(new Uint8Array(value))}if(ArrayBuffer.isView(value)){return Uint8Array.from(new Uint8Array(value.buffer,value.byteOffset,value.byteLength))}throw new ProtocolFault("RUNTIME_FAILURE",`${name} must be a Uint8Array`)}function collectBatchTransfers(batch){const transfers=new Set;for(const buffer of batch.buffers){transfers.add(buffer instanceof ArrayBuffer?buffer:buffer.buffer)}return[...transfers]}function normalizeMetadata(value,fallback){const raw=isRecord(value)?value:{};const rawExtent=isRecord(raw.extent)?raw.extent:{};const rawSchema=isRecord(raw.schema)?raw.schema:{};const columns=Array.isArray(rawSchema.columns)?rawSchema.columns.map((column,index)=>normalizeColumn(column,index)):[];return{tableId:typeof raw.tableId==="string"?raw.tableId:fallback?.id??"table-0",name:typeof raw.name==="string"?raw.name:fallback?.name??"Table 1",revision:numberOr(raw.revision,0),extent:{rows:normalizeAxis(rawExtent.rows,"at-least",0),columns:normalizeAxis(rawExtent.columns,"exact",columns.length)},schema:{version:numberOr(rawSchema.version,0),columns},capabilities:isRecord(raw.capabilities)?{...raw.capabilities,randomAccess:raw.capabilities.randomAccess==="full"?"full":"indexed-prefix",typedValues:raw.capabilities.typedValues===true,search:raw.capabilities.search===true,sort:raw.capabilities.sort===true,filter:raw.capabilities.filter===true,multiTable:raw.capabilities.multiTable===true}:{randomAccess:"indexed-prefix",typedValues:false,search:false,sort:false,filter:false,multiTable:false}}}function normalizeColumn(value,index){const raw=isRecord(value)?value:{};return{id:typeof raw.id==="string"?raw.id:`c${index}`,name:typeof raw.name==="string"?raw.name:`column_${index+1}`,index:numberOr(raw.index,index),dataType:normalizeDataType(raw.dataType??{type:"unknown"}),nullable:raw.nullable!==false,...isRecord(raw.metadata)?{metadata:Object.freeze(Object.fromEntries(Object.entries(raw.metadata).map(([key,entry])=>[key,String(entry)])))}:{}}}function normalizeAxis(value,fallbackKind,fallbackValue){if(isRecord(value)){if(value.kind==="unknown"){return{kind:"unknown"}}if((value.kind==="exact"||value.kind==="at-least")&&Number.isSafeInteger(value.value)&&value.value>=0){return{kind:value.kind,value:value.value}}}return{kind:fallbackKind,value:fallbackValue}}function isValidDelimiter(value){if(typeof value!=="string"||value.length!==1){return false}const byte=value.charCodeAt(0);return byte<=127&&byte!==0&&byte!==13&&byte!==10&&byte!==34}function normalizeDescriptors(value,single,metadata){const candidates=Array.isArray(value)&&value.length>0?value:single===void 0?[]:[single];const descriptors=candidates.map((entry,index)=>normalizeDescriptor(entry,index));return descriptors.length>0?descriptors:[{id:metadata.tableId,name:metadata.name}]}function normalizeDescriptor(value,index){const raw=isRecord(value)?value:{};return{id:typeof raw.id==="string"?raw.id:`table-${index}`,name:typeof raw.name==="string"?raw.name:`Table ${index+1}`}}function normalizeRange(value){const raw=expectRecord(value,"range request");const request={rowStart:raw.rowStart,rowCount:raw.rowCount,columnStart:raw.columnStart,columnCount:raw.columnCount};for(const[name,field]of Object.entries(request)){if(!Number.isSafeInteger(field)||field<0){throw new ProtocolFault("INVALID_RANGE",`${name} must be a non-negative safe integer`)}}return request}function numberOr(value,fallback){return Number.isSafeInteger(value)&&value>=0?value:fallback}function adapterModuleUrl(id){const testUrls=globalThis.__tabularkTestOnlyAdapterModuleUrls;const testUrl=testUrls?.[id];return typeof testUrl==="string"&&testUrl.length>0?testUrl:officialAdapterModuleUrl(id)}async function loadAdapter(id){if(shuttingDown){throw new ProtocolFault("HANDLE_CLOSED","The Worker runtime is not available")}const registration=adapterRegistrations.get(id);if(!registration){throw new ProtocolFault("INVALID_ARGUMENT",`Adapter ${id} is not registered`)}const existing=adapterLoads.get(id);if(existing)return existing;const limits=requireMemoryLimits();if(!isOfficialAdapterId(id)){throw new ProtocolFault("INVALID_ARGUMENT",`Adapter ${id} is not official`)}const runtimeBudgetBytes=adapterRuntimeBudget(id,limits);const reservation=requireMemoryLedger().reserve("adapter-runtime",runtimeBudgetBytes);adapterRuntimeReservations.set(id,reservation);const loading=WasmAdapter.load(registration.moduleUrl,registration.id,{memoryBudgetBytes:runtimeBudgetBytes,indexBudgetBytes:Math.min(limits.indexBudgetBytes,Math.floor(runtimeBudgetBytes/2)),tileCacheBudgetBytes:Math.min(limits.adapterTileCacheBudgetBytes,Math.floor(runtimeBudgetBytes/2)),chunkBytes:Math.min(CHUNK_BYTES,limits.operationBudgetBytes),checkpointRows:1024,maxFieldBytes:limits.maxFieldBytes,maxColumns:16384,maxRangeCells:25e4,maxBatchBytes:limits.maxBatchBytes,maxSources:limits.maxSources,maxActiveRanges:limits.maxActiveRanges}).then(loaded=>{loadedAdapters.set(id,loaded);return loaded}).catch(error=>{adapterLoads.delete(id);loadedAdapters.delete(id);adapterRuntimeReservations.get(id)?.release();adapterRuntimeReservations.delete(id);throw error});adapterLoads.set(id,loading);return loading}function adapterRuntimeBudget(id,limits){const registrations=[...adapterRegistrations.keys()].filter(isOfficialAdapterId);const totalWeight=registrations.reduce((total,adapterId)=>total+officialAdapterManifestEntry(adapterId).resources.runtimeWeight,0);const weight=officialAdapterManifestEntry(id).resources.runtimeWeight;return Math.max(1,Math.floor(limits.adapterRuntimePoolBytes*weight/Math.max(1,totalWeight)))}function operationResource(id){return id==="tabulark:parquet"?"compressed-page":"source-staging"}function operationReadLimit(id,limits){return id==="tabulark:excel"?limits.maxArrayBufferBytes:limits.operationBudgetBytes}function reserveOperationMemory(id,bytes){return requireMemoryLedger().reserve(operationResource(id),bytes)}async function runOpenUntilPublished(adapter,source,initial,active,adapterId){let step=initial;let complete=false;let published=false;try{for(;;){throwIfCancelled(active);const raw=expectRecord(step,"adapter open result");if(isProgressiveOpenStep(raw)){published=true;return raw}if(raw.kind==="open-complete"){complete=true;delete active.operationHandle;return raw}if(raw.kind!=="read-bytes"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter open returned an invalid discriminated step")}const action=isRecord(raw.action)?raw.action:void 0;if(!action){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter read-bytes step has no action")}if(action.kind!=="read-bytes"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter requested an unsupported action")}active.operationHandle=operationHandle(raw.operationHandle,"operationHandle");const offset=nonNegativeSafeInteger(action.offset,"read-bytes offset");const length=nonNegativeSafeInteger(action.length,"read-bytes length");const limits=requireMemoryLimits();const readLimit=operationReadLimit(adapterId,limits);if(length>readLimit||!Number.isSafeInteger(offset+length)||offset+length>source.size){throw new ProtocolFault("RESOURCE_LIMIT","Adapter read-bytes action exceeds the source or engine memory budget",false,{resource:operationResource(adapterId),requiredBytes:length,availableBytes:readLimit,offset,sourceLength:source.size})}const reservation=reserveOperationMemory(adapterId,length);const read=await acquireReservedBlobRead(source.slice(offset,offset+length),reservation,active);try{const bytes=new Uint8Array(read.buffer);throwIfCancelled(active);if(adapterId==="tabulark:excel"&&active.openedWorksheetReservation===void 0){active.openedWorksheetReservation=requireMemoryLedger().reserve("opened-worksheet",source.size)}step=adapter.continueOperation(active.operationHandle,offset,bytes,offset+length>=source.size)}finally{read.release()}}}finally{if(!complete&&!published&&active.operationHandle!==void 0){try{adapter.cancelOperation(active.operationHandle)}catch{}delete active.operationHandle}}}async function runAdapterOperation(adapter,source,initial,active,adapterId){let step=initial;let complete=false;try{for(;;){throwIfCancelled(active);const raw=expectRecord(step,"adapter operation result");if(raw.kind==="read-complete"){complete=true;delete active.operationHandle;return raw.batch}if(raw.kind!=="read-bytes"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter read returned an invalid discriminated step")}const action=isRecord(raw.action)?raw.action:void 0;if(!action){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter read-bytes step has no action")}if(action.kind!=="read-bytes"){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE","Adapter requested an unsupported action")}active.operationHandle=operationHandle(raw.operationHandle,"operationHandle");const offset=nonNegativeSafeInteger(action.offset,"read-bytes offset");const length=nonNegativeSafeInteger(action.length,"read-bytes length");const limits=requireMemoryLimits();const readLimit=operationReadLimit(adapterId,limits);if(length>readLimit||!Number.isSafeInteger(offset+length)||offset+length>source.size){throw new ProtocolFault("RESOURCE_LIMIT","Adapter read-bytes action exceeds the source or engine memory budget",false,{resource:operationResource(adapterId),requiredBytes:length,availableBytes:readLimit,offset,sourceLength:source.size})}const reservation=reserveOperationMemory(adapterId,length);const read=await acquireReservedBlobRead(source.slice(offset,offset+length),reservation,active);try{const bytes=new Uint8Array(read.buffer);throwIfCancelled(active);step=adapter.continueOperation(active.operationHandle,offset,bytes,offset+length>=source.size)}finally{read.release()}}}finally{if(!complete&&active.operationHandle!==void 0){try{adapter.cancelOperation(active.operationHandle)}catch{}delete active.operationHandle}}}function operationHandle(value,name){if(typeof value==="string"&&value.length>0)return value;if(Number.isSafeInteger(value)&&value>=0)return value;throw new ProtocolFault("PROTOCOL_INCOMPATIBLE",`${name} must be a handle`)}function nonNegativeSafeInteger(value,name){if(!Number.isSafeInteger(value)||value<0){throw new ProtocolFault("PROTOCOL_INCOMPATIBLE",`${name} must be a non-negative safe integer`)}return value}function requireMemoryLimits(){if(!memoryLimits){throw new ProtocolFault("HANDLE_CLOSED","The Worker runtime is not available")}return memoryLimits}function requireMemoryLedger(){if(!memoryLedger){throw new ProtocolFault("HANDLE_CLOSED","The Worker memory ledger is not available")}return memoryLedger}function requireDataset(value){if(typeof value!=="string"){throw new ProtocolFault("INVALID_ARGUMENT","datasetHandle must be a string")}const dataset=datasets.get(value);if(!dataset||dataset.closed){throw new ProtocolFault("HANDLE_CLOSED","The dataset is closed")}return dataset}function requireTable(value){if(typeof value!=="string"){throw new ProtocolFault("INVALID_ARGUMENT","tableHandle must be a string")}const table=tables.get(value);if(!table||table.closed){throw new ProtocolFault("HANDLE_CLOSED","The table is closed")}return table}function expectRecord(value,name){if(!isRecord(value)){throw new ProtocolFault("INVALID_ARGUMENT",`${name} must be an object`)}return value}function isRequest(value){return isRecord(value)&&typeof value.requestId==="string"&&typeof value.op==="string"&&"payload"in value}function postSuccess(requestId,kind,data,transfer=[]){const response={protocolVersion:PROTOCOL_VERSION,requestId,status:"success",result:data===void 0?{kind}:{kind,data}};scope.postMessage(response,transfer)}function postFailure(requestId,error){const response={protocolVersion:PROTOCOL_VERSION,requestId,status:"failure",error:serializeFault(error,"Worker operation failed")};scope.postMessage(response)}function emit(event){scope.postMessage({protocolVersion:PROTOCOL_VERSION,...event})}
+//# sourceMappingURL=worker.js.map