pikelet-wasm 0.7.0

package/complete/sources.mjs

@@ -0,0 +1,186 @@
+export function httpRangeSource(url, options = {}) {
+    const stats = { requests: 0, bytes: 0, acceptRanges: null, etag: null, fullFallback: false, retries: 0, redirects: 0 };
+    const maxFullFallbackBytes = options.maxFullFallbackBytes ?? 64 * 1024 * 1024;
+    // Transient statuses are retried with capped exponential backoff
+    // (Retry-After honored when sane): CDNs rate-limit the parallel range
+    // bursts this reader legitimately issues — GitHub release assets answer
+    // 429 under an open's prefetch + first-query fan-out — and failing a
+    // whole query over a pressure signal wastes everything already fetched.
+    const maxRetries = options.maxRetries ?? 6;
+    const RETRYABLE = new Set([429, 502, 503, 504]);
+    const retryDelayMs = (attempt, response) => {
+        // GitHub's release CDN answers rate-limited range bursts with 429
+        // and a Retry-After of up to a minute; honoring it (capped) beats
+        // guessing. Without one, exponential backoff capped at 15 s.
+        const after = Number(response.headers.get('retry-after'));
+        if (Number.isFinite(after) && after >= 0 && after <= 90) return after * 1000;
+        return Math.min(15000, 250 * 2 ** attempt);
+    };
+    const cacheKeyParam = options.cacheKeyParam === undefined ? 'r'
+        : (options.cacheKeyParam === null || options.cacheKeyParam === false) ? null
+            : String(options.cacheKeyParam);
+    let full = null;
+
+    // Redirect memoization. A host that answers with a redirect (GitHub
+    // release assets: github.com 302s every hit to a signed CDN URL) would
+    // otherwise charge its rate-limited front door once per range read —
+    // ~130 hits for one wiki query, and github.com's frontend throttling,
+    // not the CDN, is what 429s the burst; the blob host behind the
+    // redirect serves parallel 206s happily. Resolve the chain once, pin
+    // the final URL, and re-resolve only when it stops being accepted
+    // (401/403 — signed URLs expire). Browsers cannot read Location from a
+    // cross-origin redirect (opaqueredirect), so resolution degrades to
+    // the un-pinned auto-follow behavior there.
+    let resolvedTarget = null; // { target, viaRedirect } | null (unresolved or unresolvable)
+    let resolving = null;
+    let sizeFromHead = null;
+    const resolveTarget = async () => {
+        if (resolvedTarget) return resolvedTarget;
+        resolving ??= (async () => {
+            let target = url;
+            let viaRedirect = false;
+            try {
+                for (let hop = 0; hop < 5; hop++) {
+                    const probe = await fetch(target, { method: 'HEAD', redirect: 'manual' });
+                    const location = probe.headers.get('location');
+                    if (probe.status >= 300 && probe.status < 400 && location) {
+                        target = new URL(location, target).href;
+                        viaRedirect = true;
+                        stats.redirects += 1;
+                        continue;
+                    }
+                    if (probe.type === 'opaqueredirect' || probe.status === 0) {
+                        // Browser CORS: the chain is invisible; let fetch
+                        // auto-follow per read as before.
+                        target = url;
+                        viaRedirect = false;
+                    } else if (probe.ok) {
+                        const len = Number(probe.headers.get('content-length'));
+                        if (Number.isFinite(len) && len > 0) sizeFromHead = len;
+                        stats.acceptRanges = probe.headers.get('accept-ranges');
+                        stats.etag = probe.headers.get('etag');
+                    }
+                    break;
+                }
+            } catch {
+                // HEAD unsupported or blocked: fall back to auto-follow.
+                target = url;
+                viaRedirect = false;
+            }
+            resolvedTarget = { target, viaRedirect };
+            resolving = null;
+            return resolvedTarget;
+        })();
+        return resolving;
+    };
+
+    return {
+        stats,
+        size: undefined,
+        preferredParallelism: options.preferredParallelism ?? 32,
+        preferredGapBytes: options.preferredGapBytes ?? 16 * 1024,
+
+        async init() {
+            await resolveTarget();
+            if (sizeFromHead !== null) this.size = sizeFromHead;
+        },
+
+        async read(offset, length) {
+            // After a one-time full download (host ignored Range) every read
+            // is served from memory; no further requests go out.
+            if (full) return full.subarray(offset, offset + length);
+            stats.requests += 1;
+            stats.bytes += length;
+            const end = offset + length - 1;
+            const headers = { Range: `bytes=${offset}-${end}` };
+            if (stats.etag) headers['If-Range'] = stats.etag;
+            const pinned = await resolveTarget();
+            // The per-range cache-key query defeats Chromium's same-URL
+            // cache-entry lock (concurrent fetches of one cacheable URL
+            // serialize on it). Hosts that sign the full query string
+            // (S3 presigned URLs and similar) can turn it off with
+            // options.cacheKeyParam: null — range reads then share the
+            // unmodified URL. A redirect-pinned target never gets the
+            // param: signed URLs sign their query string, and appending
+            // anything invalidates them.
+            const targetFor = ({ target, viaRedirect }) => (cacheKeyParam && !viaRedirect
+                ? `${target}${target.includes('?') ? '&' : '?'}${cacheKeyParam}=${offset}-${end}`
+                : target);
+            let response = await fetch(targetFor(pinned), { headers });
+            if ((response.status === 401 || response.status === 403) && pinned.viaRedirect) {
+                // The pinned signed URL expired; resolve a fresh one once
+                // and retry. Concurrent reads share the re-resolution.
+                if (resolvedTarget === pinned) resolvedTarget = null;
+                stats.retries += 1;
+                response = await fetch(targetFor(await resolveTarget()), { headers });
+            }
+            for (let attempt = 0; RETRYABLE.has(response.status) && attempt < maxRetries; attempt++) {
+                stats.retries += 1;
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs(attempt, response)));
+                response = await fetch(targetFor(resolvedTarget || pinned), { headers });
+            }
+
+            if (response.status === 206) {
+                // A 206 must be the range we asked for, and must say so: a
+                // host (or cache) answering with a different slice would
+                // otherwise be caught only downstream, by the digest on
+                // whatever that slice happens to be part of — and the lazy
+                // sketch rows have no per-row digest yet. RFC 9110 requires
+                // Content-Range on a 206, so its absence fails closed too.
+                const contentRange = response.headers.get('content-range');
+                const m = contentRange && /^bytes (\d+)-(\d+)\//.exec(contentRange);
+                if (!m || Number(m[1]) !== offset || Number(m[2]) > end) {
+                    throw new Error(`range read returned Content-Range ${contentRange || '(missing)'}, requested bytes ${offset}-${end}`);
+                }
+                const body = new Uint8Array(await response.arrayBuffer());
+                if (body.length !== Number(m[2]) - Number(m[1]) + 1) {
+                    throw new Error(`range read body is ${body.length} bytes for Content-Range ${contentRange}`);
+                }
+                return body;
+            }
+            if (response.status === 200) {
+                // An unknown size must refuse, not pass the gate: with no
+                // Content-Length (chunked body) and init() never called,
+                // size would be 0 and the cap check silently vacuous.
+                const size = Number(response.headers.get('content-length')) || this.size || 0;
+                if (size <= 0) {
+                    throw new Error('host ignores Range and reports no size; refusing unbounded full download (call init() first or fix the host)');
+                }
+                if (size > maxFullFallbackBytes) {
+                    throw new Error(`host ignores Range and the file is ${size} bytes; refusing full download`);
+                }
+                // Declared sizes are advisory (a chunked body can stream more
+                // than any header claimed), so the cap is enforced on the
+                // bytes actually received, aborting as soon as it is crossed.
+                const reader = response.body?.getReader?.();
+                if (!reader) {
+                    const bytes = new Uint8Array(await response.arrayBuffer());
+                    if (bytes.length > maxFullFallbackBytes) {
+                        throw new Error(`host ignores Range and streamed ${bytes.length} bytes; refusing full download over ${maxFullFallbackBytes}`);
+                    }
+                    full = bytes;
+                } else {
+                    const chunks = [];
+                    let received = 0;
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done) break;
+                        received += value.byteLength;
+                        if (received > maxFullFallbackBytes) {
+                            await reader.cancel().catch(() => {});
+                            throw new Error(`host ignores Range and streamed over ${maxFullFallbackBytes} bytes; aborting full download`);
+                        }
+                        chunks.push(value);
+                    }
+                    full = new Uint8Array(received);
+                    let at = 0;
+                    for (const chunk of chunks) { full.set(chunk, at); at += chunk.byteLength; }
+                }
+                stats.fullFallback = true;
+                console.warn('.pancake host does not honor Range; fell back to a one-time full download');
+                return full.subarray(offset, offset + length);
+            }
+            throw new Error(`range read failed: HTTP ${response.status}`);
+        },
+    };
+}

package/complete/student-abstention.mjs

@@ -0,0 +1,102 @@
+// Abstention scoring, extracted from 03's worker.js and parameterized on
+// the calibration model. Pure JS, no runtime dependencies — shared by the
+// Node spike facade and the browser one-file reader. The scoreQuery import
+// is the only coupling to the encoder module (they form one
+// query-interpretation unit; see spec/COMPLETE_PROFILE.md section 3.6).
+
+import { scoreQuery } from './student-embedder.mjs';
+
+export function buildKnownBucketTables(model) {
+    const word = new Set();
+    let maxIdf = 0;
+    for (const entry of model?.wordBuckets || []) {
+        if (!Array.isArray(entry) || entry.length < 2) continue;
+        const bucket = Number(entry[0]);
+        const idf = Number(entry[1]);
+        if (Number.isInteger(bucket) && bucket >= 0) {
+            word.add(bucket);
+            if (idf > maxIdf) maxIdf = idf;
+        }
+    }
+    const char = new Set();
+    for (const value of model?.charBuckets || []) {
+        const bucket = Number(value);
+        if (Number.isInteger(bucket) && bucket >= 0) char.add(bucket);
+    }
+    return { word, char, maxIdf: maxIdf || 255 };
+}
+
+export function computeKnownFractions(features, model) {
+    if (!model) return { known_word: 0, known_char: 0, n_feats: features.length };
+    const tables = model._knownBucketTables || (model._knownBucketTables = buildKnownBucketTables(model));
+    let wordKnown = 0;
+    let wordTotal = 0;
+    let charKnown = 0;
+    let charTotal = 0;
+    for (const feature of features) {
+        if (feature.family === 'word') {
+            wordTotal += 1;
+            if (tables.word.has(feature.bucket)) wordKnown += 1;
+        } else if (feature.family === 'char') {
+            charTotal += 1;
+            if (tables.char.has(feature.bucket)) charKnown += 1;
+        }
+    }
+    return {
+        known_word: wordTotal > 0 ? wordKnown / wordTotal : 0,
+        known_char: charTotal > 0 ? charKnown / charTotal : 0,
+        n_feats: features.length,
+    };
+}
+
+export function computeHiddenProbe(embedded, model) {
+    const probe = model?.hiddenProbe;
+    if (!probe || !Array.isArray(probe.weights) || !embedded.hidden) return 0;
+    let logit = Number(probe.bias) || 0;
+    const limit = Math.min(probe.weights.length, embedded.hidden.length);
+    for (let index = 0; index < limit; index++) {
+        logit += (Number(probe.weights[index]) || 0) * embedded.hidden[index];
+    }
+    if (logit >= 0) {
+        const z = Math.exp(-logit);
+        return 1 / (1 + z);
+    }
+    const z = Math.exp(logit);
+    return z / (1 + z);
+}
+
+export function computeMatchQuality(hits, embedded, model) {
+    if (!model) return { match_quality: 'unscored' };
+    const d0 = hits.length > 0 ? hits[0].distance : 1;
+    const marginIndex = Math.min(4, hits.length - 1);
+    const margin = marginIndex > 0 ? hits[marginIndex].distance - d0 : 0;
+    const known = computeKnownFractions(embedded.features, model);
+    const signals = {
+        d0,
+        margin,
+        pre_norm: embedded.preNorm,
+        known_word: known.known_word,
+        known_char: known.known_char,
+        hidden_probe: computeHiddenProbe(embedded, model),
+        n_feats: known.n_feats,
+    };
+    return scoreQuery(signals, model);
+}
+
+export function computePreSearchAbstention(embedded, model) {
+    if (!model) return null;
+    const thresholds = model.thresholds || {};
+    const minFeatures = Number.isInteger(thresholds.minFeatures) ? thresholds.minFeatures : 3;
+    const preNormFloor = Number.isFinite(thresholds.preNormFloor) ? thresholds.preNormFloor : 0.4;
+    if (embedded.features.length >= minFeatures && embedded.preNorm >= preNormFloor) return null;
+    const known = computeKnownFractions(embedded.features, model);
+    return scoreQuery({
+        d0: 1,
+        margin: 0,
+        pre_norm: embedded.preNorm,
+        known_word: known.known_word,
+        known_char: known.known_char,
+        hidden_probe: computeHiddenProbe(embedded, model),
+        n_feats: known.n_feats,
+    }, model);
+}

package/complete/student-embedder.mjs

@@ -0,0 +1,231 @@
+const MAGIC = 'PSTU';
+const VERSION = 1;
+const HEADER_BYTES = 32;
+const TOKEN_RE = /[a-z0-9]+/g;
+
+function align4(value) {
+  return (value + 3) & ~3;
+}
+
+function hash32(text, seed) {
+  let hash = seed >>> 0;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+export function extractStudentFeatures(text, model) {
+  return extractStudentFeatureRecords(text, model).map((feature) => feature.bucket);
+}
+
+export function extractStudentFeatureRecords(text, model) {
+  const tokens = String(text || '').toLowerCase().match(TOKEN_RE) || [];
+  const features = [];
+  const limit = model.maxFeatures;
+
+  const push = (feature, family) => {
+    if (features.length < limit) {
+      features.push({
+        bucket: hash32(feature, model.hashSeed) % model.bucketCount,
+        family
+      });
+    }
+  };
+
+  for (let tokenIndex = 0; tokenIndex < tokens.length && features.length < limit; tokenIndex++) {
+    const token = tokens[tokenIndex].slice(0, 48);
+    push(`w:${token}`, 'word');
+
+    const padded = `^${token}$`;
+    for (let width = 3; width <= 5 && features.length < limit; width++) {
+      for (let start = 0; start + width <= padded.length && features.length < limit; start++) {
+        push(`c${width}:${padded.slice(start, start + width)}`, 'char');
+      }
+    }
+
+    if (tokenIndex > 0) {
+      push(`b:${tokens[tokenIndex - 1].slice(0, 48)}:${token}`, 'word');
+    }
+  }
+
+  return features;
+}
+
+export function loadStudentModel(input) {
+  const bytes = input instanceof Uint8Array
+    ? input
+    : input instanceof ArrayBuffer
+      ? new Uint8Array(input)
+      : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  if (bytes.byteLength < HEADER_BYTES) throw new Error('Student model is truncated');
+
+  const magic = String.fromCharCode(...bytes.subarray(0, 4));
+  if (magic !== MAGIC) throw new Error(`Invalid student model magic: ${magic}`);
+
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const version = view.getUint32(4, true);
+  if (version !== VERSION) throw new Error(`Unsupported student model version: ${version}`);
+
+  const bucketCount = view.getUint32(8, true);
+  const hiddenDim = view.getUint32(12, true);
+  const outputDim = view.getUint32(16, true);
+  const hashSeed = view.getUint32(20, true);
+  const maxFeatures = view.getUint32(24, true);
+  if (!bucketCount || !hiddenDim || !outputDim || !maxFeatures) {
+    throw new Error('Student model has invalid dimensions');
+  }
+
+  let offset = HEADER_BYTES;
+  const embeddingScalesBytes = bucketCount * 4;
+  const embeddingBytes = bucketCount * hiddenDim;
+  const projectionScalesBytes = outputDim * 4;
+  const projectionBytes = outputDim * hiddenDim;
+  const biasBytes = outputDim * 4;
+  const required = align4(offset + embeddingScalesBytes + embeddingBytes)
+    + projectionScalesBytes + projectionBytes + biasBytes;
+  if (required !== bytes.byteLength) {
+    throw new Error(`Student model size mismatch: expected ${required}, received ${bytes.byteLength}`);
+  }
+
+  const embeddingScales = new Float32Array(
+    bytes.buffer,
+    bytes.byteOffset + offset,
+    bucketCount
+  );
+  offset += embeddingScalesBytes;
+  const embeddingWeights = new Int8Array(
+    bytes.buffer,
+    bytes.byteOffset + offset,
+    embeddingBytes
+  );
+  offset = align4(offset + embeddingBytes);
+  const projectionScales = new Float32Array(
+    bytes.buffer,
+    bytes.byteOffset + offset,
+    outputDim
+  );
+  offset += projectionScalesBytes;
+  const projectionWeights = new Int8Array(
+    bytes.buffer,
+    bytes.byteOffset + offset,
+    projectionBytes
+  );
+  offset += projectionBytes;
+  const projectionBias = new Float32Array(
+    bytes.buffer,
+    bytes.byteOffset + offset,
+    outputDim
+  );
+
+  return {
+    version,
+    bucketCount,
+    hiddenDim,
+    outputDim,
+    hashSeed,
+    maxFeatures,
+    embeddingScales,
+    embeddingWeights,
+    projectionScales,
+    projectionWeights,
+    projectionBias,
+    byteLength: bytes.byteLength,
+    _bytes: bytes,
+  };
+}
+
+export function embedTextWithStudent(text, model) {
+  const features = extractStudentFeatureRecords(text, model);
+  const hidden = new Float32Array(model.hiddenDim);
+  const output = new Float32Array(model.outputDim);
+  if (features.length === 0) {
+    return { vector: output, preNorm: 0, features, hidden };
+  }
+
+  for (const { bucket } of features) {
+    const scale = model.embeddingScales[bucket];
+    const rowOffset = bucket * model.hiddenDim;
+    for (let column = 0; column < model.hiddenDim; column++) {
+      hidden[column] += model.embeddingWeights[rowOffset + column] * scale;
+    }
+  }
+
+  const inverseCount = 1 / features.length;
+  for (let column = 0; column < model.hiddenDim; column++) {
+    hidden[column] = Math.tanh(hidden[column] * inverseCount);
+  }
+  const hiddenOutput = new Float32Array(hidden);
+
+  let normSquared = 0;
+  for (let row = 0; row < model.outputDim; row++) {
+    const scale = model.projectionScales[row];
+    const rowOffset = row * model.hiddenDim;
+    let value = model.projectionBias[row];
+    for (let column = 0; column < model.hiddenDim; column++) {
+      value += model.projectionWeights[rowOffset + column] * scale * hidden[column];
+    }
+    output[row] = value;
+    normSquared += value * value;
+  }
+
+  const norm = Math.sqrt(normSquared);
+  if (!(norm > 0) || !Number.isFinite(norm)) {
+    return { vector: new Float32Array(model.outputDim), preNorm: 0, features, hidden: hiddenOutput };
+  }
+  const inverseNorm = 1 / norm;
+  for (let row = 0; row < model.outputDim; row++) output[row] *= inverseNorm;
+  return { vector: output, preNorm: norm, features, hidden: hiddenOutput };
+}
+
+function sigmoid(value) {
+  if (value >= 0) {
+    const z = Math.exp(-value);
+    return 1 / (1 + z);
+  }
+  const z = Math.exp(value);
+  return z / (1 + z);
+}
+
+export function scoreQuery(signals, abstention) {
+  if (!abstention) {
+    return { match_quality: 'unscored' };
+  }
+  const featureNames = abstention.features || ['d0', 'margin', 'pre_norm', 'known_word', 'known_char'];
+  const weights = abstention.weights || [];
+  let logit = Number(abstention.bias) || 0;
+  for (let i = 0; i < featureNames.length; i++) {
+    logit += (Number(weights[i]) || 0) * (Number(signals[featureNames[i]]) || 0);
+  }
+
+  const confidence = sigmoid(logit);
+  const thresholds = abstention.thresholds || {};
+  const hard = Number.isFinite(thresholds.hard) ? thresholds.hard : 0.05;
+  const weak = Number.isFinite(thresholds.weak) ? thresholds.weak : 0;
+  const preNormFloor = Number.isFinite(thresholds.preNormFloor) ? thresholds.preNormFloor : 0.4;
+  const minFeatures = Number.isInteger(thresholds.minFeatures) ? thresholds.minFeatures : 3;
+  const epsilon = 1e-6;
+  const floorTriggered = confidence < hard
+    || (Number(signals.n_feats) || 0) < minFeatures
+    || (Number(signals.pre_norm) || 0) < preNormFloor;
+  const match_quality = floorTriggered
+    ? 'none'
+    : confidence + epsilon >= weak
+      ? 'strong'
+      : 'weak';
+  return {
+    match_quality,
+    score: confidence,
+    confidence: Math.round(confidence * 1000) / 1000,
+    signals: {
+      d0: signals.d0,
+      margin: signals.margin,
+      pre_norm: signals.pre_norm,
+      known_word: signals.known_word,
+      known_char: signals.known_char,
+      hidden_probe: signals.hidden_probe,
+      n_feats: signals.n_feats
+    }
+  };
+}

package/complete/wordpiece.mjs

@@ -0,0 +1,68 @@
+// Minimal BERT WordPiece tokenizer (uncased): lowercase, accent-strip via
+// NFD, punctuation/CJK splitting, greedy longest-match with ## pieces,
+// [CLS]/[SEP] framing. Parity-tested against the HF tokenizer on the wiki
+// eval queries; pure JS so it runs wherever the reader runs.
+
+export function createWordPiece(vocabText) {
+  const vocab = new Map();
+  vocabText.split('\n').forEach((token, id) => vocab.set(token, id));
+  const CLS = vocab.get('[CLS]');
+  const SEP = vocab.get('[SEP]');
+  const UNK = vocab.get('[UNK]');
+  const MAX_WORD = 100;
+
+  const isPunct = (c) => {
+    const cp = c.codePointAt(0);
+    if ((cp >= 33 && cp <= 47) || (cp >= 58 && cp <= 64)
+      || (cp >= 91 && cp <= 96) || (cp >= 123 && cp <= 126)) return true;
+    return /\p{P}/u.test(c);
+  };
+  const isCjk = (c) => {
+    const cp = c.codePointAt(0);
+    return (cp >= 0x4e00 && cp <= 0x9fff) || (cp >= 0x3400 && cp <= 0x4dbf)
+      || (cp >= 0xf900 && cp <= 0xfaff) || (cp >= 0x20000 && cp <= 0x2a6df);
+  };
+
+  function basicTokenize(text) {
+    const cleaned = text.normalize('NFD').replace(/\p{Mn}/gu, '').toLowerCase()
+      .replace(/[\u0000\uFFFD\u0001-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '');
+    const out = [];
+    let current = '';
+    const flush = () => { if (current) { out.push(current); current = ''; } };
+    for (const c of cleaned) {
+      if (/\s/.test(c)) { flush(); continue; }
+      if (isPunct(c) || isCjk(c)) { flush(); out.push(c); continue; }
+      current += c;
+    }
+    flush();
+    return out;
+  }
+
+  function wordpiece(word) {
+    if (word.length > MAX_WORD) return [UNK];
+    const pieces = [];
+    let start = 0;
+    while (start < word.length) {
+      let end = word.length;
+      let piece = null;
+      while (start < end) {
+        const candidate = (start > 0 ? '##' : '') + word.slice(start, end);
+        if (vocab.has(candidate)) { piece = vocab.get(candidate); break; }
+        end--;
+      }
+      if (piece === null) return [UNK];
+      pieces.push(piece);
+      start = end;
+    }
+    return pieces;
+  }
+
+  return {
+    encode(text) {
+      const ids = [CLS];
+      for (const word of basicTokenize(text)) ids.push(...wordpiece(word));
+      ids.push(SEP);
+      return ids;
+    },
+  };
+}

package/dist/engine.js

@@ -0,0 +1,2 @@
+var P=(()=>{var _scriptName=globalThis.document?.currentScript?.src;return async function(moduleArg={}){var moduleRtn;var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=false;var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};if(typeof __filename!="undefined"){_scriptName=__filename}else{}var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("node:fs");scriptDirectory=__dirname+"/";readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var isFileURI=filename=>filename.startsWith("file://");var readyPromiseResolve,readyPromiseReject;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;var HEAP64,HEAPU64;var runtimeInitialized=false;function updateMemoryViews(){var b=wasmMemory.buffer;HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["t"]()}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject?.(e);throw e}var wasmBinaryFile;function findWasmBinary(){return locateFile("engine.wasm")}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){return new Promise((resolve,reject)=>{Module["instantiateWasm"](info,(inst,mod)=>{resolve(receiveInstance(inst,mod))})})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var addOnPostRun=cb=>onPostRuns.push(cb);var onPreRuns=[];var addOnPreRun=cb=>onPreRuns.push(cb);var noExitRuntime=true;var stackRestore=val=>__emscripten_stack_restore(val);var stackSave=()=>_emscripten_stack_get_current();var exceptionCaught=[];var uncaughtExceptionCount=0;var ___cxa_begin_catch=ptr=>{var info=new ExceptionInfo(ptr);if(!info.get_caught()){info.set_caught(true);uncaughtExceptionCount--}info.set_rethrown(false);exceptionCaught.push(info);return ___cxa_get_exception_ptr(ptr)};var exceptionLast=0;var ___cxa_end_catch=()=>{_setThrew(0,0);var info=exceptionCaught.pop();___cxa_decrement_exception_refcount(info.excPtr);exceptionLast=0};class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12]=caught}get_caught(){return HEAP8[this.ptr+12]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13]=rethrown}get_rethrown(){return HEAP8[this.ptr+13]!=0}init(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor)}set_adjusted_ptr(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}}var setTempRet0=val=>__emscripten_tempret_set(val);var findMatchingCatch=args=>{var thrown=exceptionLast;if(!thrown){setTempRet0(0);return 0}var info=new ExceptionInfo(thrown);info.set_adjusted_ptr(thrown);var thrownType=info.get_type();if(!thrownType){setTempRet0(0);return thrown}for(var caughtType of args){if(caughtType===0||caughtType===thrownType){break}var adjusted_ptr_addr=info.ptr+16;if(___cxa_can_catch(caughtType,thrownType,adjusted_ptr_addr)){setTempRet0(caughtType);return thrown}}setTempRet0(thrownType);return thrown};var ___cxa_find_matching_catch_2=()=>findMatchingCatch([]);var ___cxa_find_matching_catch_3=arg0=>findMatchingCatch([arg0]);var ___cxa_throw=(ptr,type,destructor)=>{var info=new ExceptionInfo(ptr);info.init(type,destructor);___cxa_increment_exception_refcount(ptr);exceptionLast=ptr;uncaughtExceptionCount++;throw exceptionLast};var ___resumeException=ptr=>{if(!exceptionLast){exceptionLast=ptr}throw exceptionLast};var __abort_js=()=>abort("");var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var wasmTableMirror=[];var getWasmTableEntry=funcPtr=>{var func=wasmTableMirror[funcPtr];if(!func){wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].shift()()}}}Module["ccall"]=ccall;Module["cwrap"]=cwrap;var _pancake_init,_pancake_add,_pancake_bulk_insert,_pancake_query,_pancake_query_filtered,_pancake_delete,_pancake_compact,_pancake_compact_remap,_pancake_count,_pancake_memory,_pancake_ghost_count,_pancake_ghost_ratio,_pancake_export,_pancake_import,_pancake_dispose,_pancake_dimension,_emsc_malloc,_emsc_free,_pancake_profile_print,_pancake_profile_reset,_pancake_sketch_scan,_pancake_shutdown_all,_shutdown_all,_setThrew,__emscripten_tempret_set,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,___cxa_increment_exception_refcount,___cxa_decrement_exception_refcount,___cxa_can_catch,___cxa_get_exception_ptr,memory,__indirect_function_table,wasmMemory,wasmTable;function assignWasmExports(wasmExports){_pancake_init=Module["_pancake_init"]=wasmExports["u"];_pancake_add=Module["_pancake_add"]=wasmExports["v"];_pancake_bulk_insert=Module["_pancake_bulk_insert"]=wasmExports["x"];_pancake_query=Module["_pancake_query"]=wasmExports["y"];_pancake_query_filtered=Module["_pancake_query_filtered"]=wasmExports["z"];_pancake_delete=Module["_pancake_delete"]=wasmExports["A"];_pancake_compact=Module["_pancake_compact"]=wasmExports["B"];_pancake_compact_remap=Module["_pancake_compact_remap"]=wasmExports["C"];_pancake_count=Module["_pancake_count"]=wasmExports["D"];_pancake_memory=Module["_pancake_memory"]=wasmExports["E"];_pancake_ghost_count=Module["_pancake_ghost_count"]=wasmExports["F"];_pancake_ghost_ratio=Module["_pancake_ghost_ratio"]=wasmExports["G"];_pancake_export=Module["_pancake_export"]=wasmExports["H"];_pancake_import=Module["_pancake_import"]=wasmExports["I"];_pancake_dispose=Module["_pancake_dispose"]=wasmExports["J"];_pancake_dimension=Module["_pancake_dimension"]=wasmExports["K"];_emsc_malloc=Module["_emsc_malloc"]=wasmExports["L"];_emsc_free=Module["_emsc_free"]=wasmExports["M"];_pancake_profile_print=Module["_pancake_profile_print"]=wasmExports["N"];_pancake_profile_reset=Module["_pancake_profile_reset"]=wasmExports["O"];_pancake_sketch_scan=Module["_pancake_sketch_scan"]=wasmExports["P"];_pancake_shutdown_all=Module["_pancake_shutdown_all"]=wasmExports["Q"];_shutdown_all=Module["_shutdown_all"]=wasmExports["R"];_setThrew=wasmExports["S"];__emscripten_tempret_set=wasmExports["T"];__emscripten_stack_restore=wasmExports["U"];__emscripten_stack_alloc=wasmExports["V"];_emscripten_stack_get_current=wasmExports["W"];___cxa_increment_exception_refcount=wasmExports["X"];___cxa_decrement_exception_refcount=wasmExports["Y"];___cxa_can_catch=wasmExports["Z"];___cxa_get_exception_ptr=wasmExports["_"];memory=wasmMemory=wasmExports["s"];__indirect_function_table=wasmTable=wasmExports["w"]}var wasmImports={l:___cxa_begin_catch,o:___cxa_end_catch,a:___cxa_find_matching_catch_2,i:___cxa_find_matching_catch_3,n:___cxa_throw,d:___resumeException,p:__abort_js,q:_emscripten_resize_heap,c:invoke_ii,m:invoke_iii,k:invoke_iiii,f:invoke_iiiiii,b:invoke_v,g:invoke_vii,e:invoke_viii,h:invoke_viiii,j:invoke_viiiii,r:invoke_viiiiiii};function invoke_ii(index,a1){var sp=stackSave();try{return getWasmTableEntry(index)(a1)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiii(index,a1,a2,a3){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_vii(index,a1,a2){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_v(index){var sp=stackSave();try{getWasmTableEntry(index)()}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viii(index,a1,a2,a3){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iii(index,a1,a2){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiiiiii(index,a1,a2,a3,a4,a5,a6,a7){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4,a5,a6,a7)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiiii(index,a1,a2,a3,a4,a5){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4,a5)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiii(index,a1,a2,a3,a4){var sp=stackSave();try{getWasmTableEntry(index)(a1,a2,a3,a4)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiiiii(index,a1,a2,a3,a4,a5){var sp=stackSave();try{return getWasmTableEntry(index)(a1,a2,a3,a4,a5)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function run(){preRun();function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve?.(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}var wasmExports;wasmExports=await (createWasm());run();if(runtimeInitialized){moduleRtn=Module}else{moduleRtn=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject})}
+;return moduleRtn}})();if(typeof exports==="object"&&typeof module==="object"){module.exports=P;module.exports.default=P}else if(typeof define==="function"&&define["amd"])define([],()=>P);