@delali/narsil 0.2.2 → 0.2.3-next.32

package/dist/vector/search-worker.d.ts

@@ -0,0 +1,373 @@
+import { V as VectorMetric } from '../brute-force-DbHYCTc3.js';
+
+/**
+ * A filter over store ordinals, one bit per ordinal, with the number of set
+ * bits alongside so a search can judge selectivity without a scan.
+ *
+ * A search checks membership by indexing a byte array rather than hashing a
+ * document id, and the whole filter posts to a worker as a few kilobytes of
+ * bytes rather than a set of strings.
+ *
+ * @internal
+ */
+interface OrdinalFilter {
+    /** One bit per ordinal, set where the ordinal passes the filter. */
+    bits: Uint8Array;
+    /** This many ordinals pass the filter. */
+    count: number;
+}
+
+/**
+ * Every stored vector in the form the engine hands to another thread.
+ *
+ * @internal
+ */
+interface VectorStoreSnapshot {
+    /** Each vector carries this many components. */
+    dimension: number;
+    /** The store spans this many ordinals, deleted ones included. */
+    slots: number;
+    /** This holds every vector end to end, `slots * dimension` components long. */
+    vectors: Float32Array;
+    /** Each ordinal's vector length, so a reader need not recompute it. */
+    magnitudes: Float64Array;
+    /** The document at each ordinal, `null` where the ordinal holds none. */
+    docIds: Array<string | null>;
+}
+
+/**
+ * The two constants a scalar quantizer turns a vector component into a byte
+ * with, and turns that byte back into a distance with.
+ *
+ * A worker holding a copy of a vector field receives these rather than deriving
+ * its own, because a copy taken after a delete would otherwise measure a
+ * narrower range of values and answer the same query differently from the
+ * thread that built the index.
+ *
+ * @internal
+ */
+interface ScalarQuantizerCalibration {
+    /** Each step of the byte scale spans this much of the component range. */
+    alpha: number;
+    /** The byte scale starts at this component value. */
+    offset: number;
+}
+
+/**
+ * Every node's neighbours in the flat form the engine hands to another thread.
+ *
+ * @internal
+ */
+interface AdjacencySnapshot {
+    /** Each node keeps this many neighbours per layer above the base. */
+    m: number;
+    /** Each node keeps this many neighbours on the base layer. */
+    mMax0: number;
+    /** The arrays span this many ordinals. */
+    capacity: number;
+    /** No node sits at an ordinal at or above this. */
+    slots: number;
+    /** The upper-layer arena holds this many entries in use. */
+    upperUsed: number;
+    /** Each ordinal's top layer, or -1 where no node sits there. */
+    nodeLevels: Int8Array;
+    /** The base layer's neighbours, a count followed by neighbours per ordinal. */
+    level0: Int32Array;
+    /** Where each ordinal's upper layers start, or -1 where it has none. */
+    upperBase: Int32Array;
+    /** Every upper layer's neighbours, a count followed by neighbours per layer. */
+    upper: Int32Array;
+}
+
+/**
+ * A built graph in the form the engine hands to another thread.
+ *
+ * @internal
+ */
+interface HNSWSnapshot {
+    /** Each vector carries this many components. */
+    dimension: number;
+    /** Each node keeps this many neighbours per layer. */
+    m: number;
+    /** The builder explored this many candidates while placing each node. */
+    efConstruction: number;
+    /** The graph ranks by this metric. */
+    metric: VectorMetric;
+    /** This holds every node's neighbours, laid out flat. */
+    adjacency: AdjacencySnapshot;
+    /** A byte per ordinal, set to 1 where the document has been deleted. */
+    tombstones: Uint8Array;
+    /** This many ordinals are tombstoned. */
+    tombstoneCount: number;
+    /** The graph holds this many nodes, tombstoned ones included. */
+    nodeCount: number;
+    /** The graph's own arrays span this many ordinals. */
+    capacity: number;
+    /** Every search starts at this ordinal, and it is -1 while the graph is empty. */
+    entryPointOrd: number;
+    /** The graph reaches this many layers. */
+    topLayer: number;
+}
+
+/**
+ * Where each region of a frozen generation sits inside its shared memory.
+ *
+ * The memory opens with one float32 query scratch slot and one code query
+ * scratch slot per worker, so concurrent searches never write over each
+ * other, followed by the float32 vector arena and the quantised code arena.
+ *
+ * @internal
+ */
+interface SharedGenerationLayout {
+    /** Each vector carries this many components. */
+    dimension: number;
+    /** The arenas span this many ordinals. */
+    slots: number;
+    /** The memory holds this many per-worker scratch slot pairs. */
+    workerSlots: number;
+    /** Each worker's float32 query scratch spans this many bytes. */
+    float32ScratchStride: number;
+    /** Each worker's code query scratch spans this many bytes. */
+    codeScratchStride: number;
+    /** The code query scratch slots start at this byte offset. */
+    codeScratchOffset: number;
+    /** The float32 vector arena starts at this byte offset. */
+    vectorsOffset: number;
+    /** The quantised code arena starts at this byte offset. */
+    codesOffset: number;
+    /** The memory spans this many bytes, a whole number of pages. */
+    totalBytes: number;
+}
+/**
+ * One frozen copy of a vector field, shared across every search thread.
+ *
+ * The typed arrays are views over shared buffers, so posting this to a worker
+ * hands over the same bytes rather than a copy, and nothing in it is written
+ * after the freeze apart from the per-worker scratch slots inside `memory`.
+ *
+ * @internal
+ */
+interface SharedGenerationSnapshot {
+    /** Each vector carries this many components. */
+    dimension: number;
+    /** The workers compute quantised distances when this reads `sq8`. */
+    quantization: 'sq8' | 'none';
+    /** The constants every code was derived with, present when quantised. */
+    calibration: ScalarQuantizerCalibration | null;
+    /** The shared memory holding the scratch slots and both arenas. */
+    memory: WebAssembly.Memory;
+    /** Where each region sits inside the shared memory. */
+    layout: SharedGenerationLayout;
+    /** Each ordinal's vector magnitude. */
+    magnitudes: Float64Array;
+    /** Each ordinal's code sum, present when quantised. */
+    codeSums: Float64Array;
+    /** Each ordinal's reconstructed code magnitude, present when quantised. */
+    codeMagnitudes: Float64Array;
+    /** A byte per ordinal, 1 where codes exist, present when quantised. */
+    codePresent: Uint8Array;
+    /** The built graph, its arrays backed by shared buffers. */
+    graph: HNSWSnapshot;
+    /**
+     * Each ordinal's document id rank in code point order, or
+     * the absent-document rank where the ordinal holds no document.
+     */
+    rankByOrdinal: Uint32Array;
+}
+
+/**
+ * One vector field's searchable state in the form the engine clones to a
+ * worker, used where the runtime cannot share memory.
+ *
+ * @internal
+ */
+interface WorkerCopySnapshot {
+    /** Each vector carries this many components. */
+    dimension: number;
+    /** The worker rebuilds a quantizer when this reads `sq8`. */
+    quantization: 'sq8' | 'none';
+    /**
+     * The constants the calling thread quantizes with, carried so that the worker
+     * derives the same codes rather than recalibrating over a set that a delete
+     * has already narrowed.
+     */
+    calibration: ScalarQuantizerCalibration | null;
+    /** This holds every vector and the document id at each ordinal. */
+    store: VectorStoreSnapshot;
+    /** This holds the built graph. */
+    graph: HNSWSnapshot;
+    /** These documents have been deleted and must not be returned. */
+    tombstones: string[];
+}
+
+/**
+ * Asks the search worker to hold a cloned copy of one vector field under a
+ * handle.
+ *
+ * These messages travel between the engine and its search worker entry point,
+ * and nothing here is part of the engine's supported surface.
+ *
+ * @internal
+ */
+interface VectorLoadRequest {
+    /** This marks the message as a cloned copy load. */
+    type: 'load';
+    /** The reply carries this back so the engine can match it to its caller. */
+    requestId: string;
+    /** Later messages name the copy by this handle. */
+    handle: string;
+    /** The worker rebuilds its searchable copy from this. */
+    snapshot: WorkerCopySnapshot;
+}
+/**
+ * Asks the search worker to open a frozen shared copy under a handle.
+ *
+ * @internal
+ */
+interface SharedCopyLoadRequest {
+    /** This marks the message as a shared copy load. */
+    type: 'loadShared';
+    /** The reply carries this back so the engine can match it to its caller. */
+    requestId: string;
+    /** Later messages name the copy by this handle. */
+    handle: string;
+    /** The worker writes query scratch into this reserved slot alone. */
+    scratchSlot: number;
+    /** The frozen copy, its buffers shared rather than cloned. */
+    snapshot: SharedGenerationSnapshot;
+}
+/**
+ * Asks the search worker to release a copy it holds.
+ *
+ * @internal
+ */
+interface VectorDropRequest {
+    /** This marks the message as a copy release. */
+    type: 'drop';
+    /** The reply carries this back so the engine can match it to its caller. */
+    requestId: string;
+    /** The worker releases the copy held under this handle. */
+    handle: string;
+}
+/**
+ * Asks the search worker to answer one nearest-neighbour query from a cloned
+ * copy.
+ *
+ * @internal
+ */
+interface VectorSearchRequest {
+    /** This marks the message as a search over a cloned copy. */
+    type: 'search';
+    /** The reply carries this back so the engine can match it to its caller. */
+    requestId: string;
+    /** The worker searches the copy held under this handle. */
+    handle: string;
+    /** The worker ranks against this query vector. */
+    query: Float32Array;
+    /** The worker returns at most this many results. */
+    k: number;
+    /** The worker ranks by this metric. */
+    metric: VectorMetric;
+    /** The worker drops any result scoring below this. */
+    minSimilarity: number;
+    /** The worker returns only ordinals this filter holds, when present. */
+    filter?: OrdinalFilter;
+    /** The worker explores this many candidates, or its own default when absent. */
+    efSearch?: number;
+}
+/**
+ * Asks the search worker to answer one nearest-neighbour query from a shared
+ * copy, returning ordinals for the engine to map back to document ids.
+ *
+ * @internal
+ */
+interface VectorOrdinalSearchRequest {
+    /** This marks the message as a search over a shared copy. */
+    type: 'searchOrdinals';
+    /** The reply carries this back so the engine can match it to its caller. */
+    requestId: string;
+    /** The worker searches the copy held under this handle. */
+    handle: string;
+    /** The worker ranks against this query vector. */
+    query: Float32Array;
+    /** The worker returns at most this many results. */
+    k: number;
+    /** The worker ranks by this metric. */
+    metric: VectorMetric;
+    /** The worker drops any result scoring below this. */
+    minSimilarity: number;
+    /** The worker returns only ordinals this filter holds, when present. */
+    filter?: OrdinalFilter;
+    /** The worker explores this many candidates, or its own default when absent. */
+    efSearch?: number;
+}
+/**
+ * Every message the engine posts to the search worker.
+ *
+ * @internal
+ */
+type VectorWorkerRequest = VectorLoadRequest | SharedCopyLoadRequest | VectorDropRequest | VectorSearchRequest | VectorOrdinalSearchRequest;
+/**
+ * What the search worker returns once a copy is loaded or released.
+ *
+ * @internal
+ */
+interface VectorAckResponse {
+    /** This marks the message as a completed load or release. */
+    type: 'ack';
+    /** This matches the request the engine sent. */
+    requestId: string;
+    /** This names the copy the acknowledgement belongs to. */
+    handle: string;
+}
+/**
+ * What the search worker returns for a completed search over a cloned copy.
+ *
+ * @internal
+ */
+interface VectorSearchResponse {
+    /** This marks the message as a completed search. */
+    type: 'result';
+    /** This matches the request the engine sent. */
+    requestId: string;
+    /** These document ids run best first. */
+    docIds: string[];
+    /** These scores line up with the document ids. */
+    scores: Float64Array;
+}
+/**
+ * What the search worker returns for a completed search over a shared copy.
+ *
+ * @internal
+ */
+interface VectorOrdinalSearchResponse {
+    /** This marks the message as a completed ordinal search. */
+    type: 'ordinalResult';
+    /** This matches the request the engine sent. */
+    requestId: string;
+    /** These store ordinals run best first. */
+    ordinals: Uint32Array;
+    /** These scores line up with the ordinals. */
+    scores: Float64Array;
+}
+/**
+ * What the search worker returns when a request fails.
+ *
+ * @internal
+ */
+interface VectorWorkerError {
+    /** This marks the message as a failure. */
+    type: 'error';
+    /** This matches the request the engine sent, and is absent for a load or release. */
+    requestId?: string;
+    /** This says why the request failed. */
+    message: string;
+}
+/**
+ * Every message the search worker posts back.
+ *
+ * @internal
+ */
+type VectorWorkerMessage = VectorAckResponse | VectorSearchResponse | VectorOrdinalSearchResponse | VectorWorkerError;
+
+export { type AdjacencySnapshot, type HNSWSnapshot, type OrdinalFilter, type ScalarQuantizerCalibration, type SharedCopyLoadRequest, type SharedGenerationLayout, type SharedGenerationSnapshot, type VectorAckResponse, type VectorDropRequest, type VectorLoadRequest, VectorMetric, type VectorOrdinalSearchRequest, type VectorOrdinalSearchResponse, type VectorSearchRequest, type VectorSearchResponse, type VectorStoreSnapshot, type VectorWorkerError, type VectorWorkerMessage, type VectorWorkerRequest, type WorkerCopySnapshot };

package/dist/vector/search-worker.mjs

@@ -0,0 +1,279 @@
+import { createScalarQuantizer, deriveSq8Constants, arenaQuantizedDistance, quantizeVectorInto, quantizedMagnitude, scalarQuantizedDistance } from '../chunk-OBXS7OZM.mjs';
+import { searchOrdinals, createVectorStore, createHNSWIndex, createSharedArenaSimd, importAdjacency, arenaFloat32Distance, ABSENT_DOCUMENT_RANK } from '../chunk-WDL632CN.mjs';
+import '../chunk-BFIH7OV5.mjs';
+
+// src/vector/shared-generation/worker-view.ts
+function createVectorReader(snapshot, simd, scratchSlot) {
+  const { layout, magnitudes, rankByOrdinal } = snapshot;
+  const { dimension, slots } = layout;
+  const vectors = new Float32Array(snapshot.memory.buffer, layout.vectorsOffset, slots * dimension);
+  const scratchByteOffset = scratchSlot * layout.float32ScratchStride;
+  const scratch = simd ? new Float32Array(snapshot.memory.buffer, scratchByteOffset, dimension) : null;
+  const holdsDocument = (ordinal) => ordinal >= 0 && ordinal < slots && rankByOrdinal[ordinal] !== ABSENT_DOCUMENT_RANK;
+  return {
+    entryForOrdinal(ordinal) {
+      if (!holdsDocument(ordinal)) return void 0;
+      const base = ordinal * dimension;
+      return { vector: vectors.subarray(base, base + dimension), magnitude: magnitudes[ordinal] };
+    },
+    prepareQueryArena(query) {
+      if (!simd || !scratch || query.length !== dimension) return null;
+      scratch.set(query, 0);
+      return { magnitude: simd.magnitude(scratchByteOffset, dimension) };
+    },
+    distanceFromArena(prepared, ordinal, metric) {
+      if (!simd || !holdsDocument(ordinal)) return Number.POSITIVE_INFINITY;
+      const byteOffset = layout.vectorsOffset + ordinal * dimension * 4;
+      return arenaFloat32Distance(
+        simd,
+        scratchByteOffset,
+        byteOffset,
+        dimension,
+        metric,
+        prepared.magnitude,
+        magnitudes[ordinal]
+      );
+    }
+  };
+}
+function createQuantizerReader(snapshot, simd, scratchSlot) {
+  if (snapshot.quantization !== "sq8" || snapshot.calibration === null) return void 0;
+  const { layout, codeSums, codeMagnitudes, codePresent } = snapshot;
+  const { dimension, slots } = layout;
+  const constants = deriveSq8Constants(snapshot.calibration.alpha, snapshot.calibration.offset, dimension);
+  const codes = new Uint8Array(snapshot.memory.buffer, layout.codesOffset, slots * dimension);
+  const scratchByteOffset = layout.codeScratchOffset + scratchSlot * layout.codeScratchStride;
+  const scratch = simd ? new Uint8Array(snapshot.memory.buffer, scratchByteOffset, dimension) : null;
+  let liveCodes = 0;
+  for (let ordinal = 0; ordinal < codePresent.length; ordinal++) {
+    if (codePresent[ordinal] === 1) liveCodes++;
+  }
+  const holdsCodes = (ordinal) => ordinal >= 0 && ordinal < slots && codePresent[ordinal] === 1;
+  return {
+    get size() {
+      return liveCodes;
+    },
+    isCalibrated: () => true,
+    prepareQuery(query) {
+      const quantized = new Uint8Array(dimension);
+      const { sum, sumSq } = quantizeVectorInto(quantized, query, dimension, constants);
+      return { quantized, sum, sumSq, magnitude: quantizedMagnitude(constants, sumSq, sum) };
+    },
+    distanceFromPreparedByOrdinal(prepared, ordinal, metric) {
+      if (!holdsCodes(ordinal)) return Number.POSITIVE_INFINITY;
+      return scalarQuantizedDistance(
+        codes,
+        codeSums,
+        codeMagnitudes,
+        dimension,
+        constants,
+        prepared.quantized,
+        prepared.sum,
+        prepared.magnitude,
+        ordinal,
+        metric
+      );
+    },
+    prepareQueryArena(query) {
+      if (!simd || !scratch) return null;
+      const { sum, sumSq } = quantizeVectorInto(scratch, query, dimension, constants);
+      return { sum, sumSq, magnitude: quantizedMagnitude(constants, sumSq, sum) };
+    },
+    distanceFromArena(prepared, ordinal, metric) {
+      if (!simd || !holdsCodes(ordinal)) return Number.POSITIVE_INFINITY;
+      return arenaQuantizedDistance(
+        simd,
+        scratchByteOffset,
+        layout.codesOffset + ordinal * dimension,
+        dimension,
+        constants,
+        prepared.sum,
+        prepared.magnitude,
+        codeSums[ordinal],
+        codeMagnitudes[ordinal],
+        metric
+      );
+    }
+  };
+}
+function openSharedWorkerCopy(snapshot, scratchSlot) {
+  if (scratchSlot < 0 || scratchSlot >= snapshot.layout.workerSlots) {
+    throw new Error(`Scratch slot ${scratchSlot} is outside the ${snapshot.layout.workerSlots} reserved slots`);
+  }
+  const simd = createSharedArenaSimd(snapshot.memory);
+  const adjacency = importAdjacency(snapshot.graph.adjacency);
+  const capacity = Math.max(snapshot.graph.capacity, adjacency.capacity);
+  const searchState = {
+    dimension: snapshot.dimension,
+    store: createVectorReader(snapshot, simd, scratchSlot),
+    quantizer: createQuantizerReader(snapshot, simd, scratchSlot),
+    adjacency,
+    tombstones: snapshot.graph.tombstones,
+    tombstoneCount: snapshot.graph.tombstoneCount,
+    nodeCount: snapshot.graph.nodeCount,
+    capacity,
+    visited: new Uint32Array(capacity),
+    visitStamp: 0,
+    entryPointOrd: snapshot.graph.entryPointOrd,
+    topLayer: snapshot.graph.topLayer
+  };
+  return { searchState, rankByOrdinal: snapshot.rankByOrdinal };
+}
+
+// src/vector/worker-copy.ts
+function restoreWorkerCopy(snapshot) {
+  const store = createVectorStore();
+  store.restoreSnapshot(snapshot.store);
+  const tombstones = new Set(snapshot.tombstones);
+  let quantizer = null;
+  if (snapshot.quantization === "sq8") {
+    const sq8 = createScalarQuantizer(snapshot.dimension, store);
+    if (snapshot.calibration !== null) {
+      sq8.restoreCalibration(snapshot.calibration.alpha, snapshot.calibration.offset);
+    } else {
+      const live = [];
+      for (const [docId, entry] of store.entries()) {
+        if (tombstones.has(docId)) continue;
+        live.push(entry.vector);
+      }
+      sq8.calibrate(live);
+    }
+    for (const [docId, entry] of store.entries()) {
+      if (tombstones.has(docId)) continue;
+      sq8.quantize(docId, entry.vector);
+    }
+    quantizer = sq8;
+  }
+  const graph = createHNSWIndex(
+    snapshot.dimension,
+    store,
+    { m: snapshot.graph.m, efConstruction: snapshot.graph.efConstruction, metric: snapshot.graph.metric },
+    quantizer ?? void 0
+  );
+  graph.restoreSnapshot(snapshot.graph);
+  return { store, graph, tombstones };
+}
+
+// src/vector/search-worker.ts
+var MAX_WORKER_COPIES = 64;
+var copies = /* @__PURE__ */ new Map();
+function ensureRoom(handle) {
+  if (!copies.has(handle) && copies.size >= MAX_WORKER_COPIES) {
+    throw new Error(`Search worker already holds ${MAX_WORKER_COPIES} copies`);
+  }
+}
+function handleLoad(request) {
+  ensureRoom(request.handle);
+  copies.set(request.handle, { kind: "clone", copy: restoreWorkerCopy(request.snapshot) });
+  return { type: "ack", requestId: request.requestId, handle: request.handle };
+}
+function handleLoadShared(request) {
+  ensureRoom(request.handle);
+  copies.set(request.handle, { kind: "shared", copy: openSharedWorkerCopy(request.snapshot, request.scratchSlot) });
+  return { type: "ack", requestId: request.requestId, handle: request.handle };
+}
+function handleDrop(request) {
+  copies.delete(request.handle);
+  return { type: "ack", requestId: request.requestId, handle: request.handle };
+}
+function handleSearch(request) {
+  const entry = copies.get(request.handle);
+  if (!entry) {
+    throw new Error(`Search worker holds no copy for handle ${request.handle}`);
+  }
+  if (entry.kind !== "clone") {
+    throw new Error(`Handle ${request.handle} holds a shared copy, which answers ordinal searches alone`);
+  }
+  const hits = entry.copy.graph.search(
+    request.query,
+    request.k,
+    request.metric,
+    request.minSimilarity,
+    request.filter,
+    request.efSearch
+  );
+  const docIds = [];
+  const scores = new Float64Array(hits.length);
+  for (let i = 0; i < hits.length; i++) {
+    docIds.push(hits[i].docId);
+    scores[i] = hits[i].score;
+  }
+  return { type: "result", requestId: request.requestId, docIds, scores };
+}
+function handleSearchOrdinals(request) {
+  const entry = copies.get(request.handle);
+  if (!entry) {
+    throw new Error(`Search worker holds no copy for handle ${request.handle}`);
+  }
+  if (entry.kind !== "shared") {
+    throw new Error(`Handle ${request.handle} holds a cloned copy, which answers document id searches alone`);
+  }
+  const hits = searchOrdinals(
+    entry.copy.searchState,
+    request.query,
+    request.k,
+    request.metric,
+    request.minSimilarity,
+    entry.copy.rankByOrdinal,
+    request.filter,
+    request.efSearch
+  );
+  const ordinals = new Uint32Array(hits.length);
+  const scores = new Float64Array(hits.length);
+  for (let i = 0; i < hits.length; i++) {
+    ordinals[i] = hits[i].ord;
+    scores[i] = hits[i].score;
+  }
+  return { type: "ordinalResult", requestId: request.requestId, ordinals, scores };
+}
+function handleAnyRequest(raw) {
+  const request = raw;
+  if (request.type === "load") return handleLoad(request);
+  if (request.type === "loadShared") return handleLoadShared(request);
+  if (request.type === "drop") return handleDrop(request);
+  if (request.type === "search") return handleSearch(request);
+  if (request.type === "searchOrdinals") return handleSearchOrdinals(request);
+  throw new Error(`Unknown request type: ${request.type}`);
+}
+function errorFor(raw, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const requestId = raw.requestId;
+  return typeof requestId === "string" ? { type: "error", requestId, message } : { type: "error", message };
+}
+function setupWorker() {
+  setupAsync().catch((err) => {
+    console.error("Vector search worker setup failed:", err);
+  });
+}
+async function setupAsync() {
+  let parentPort = null;
+  try {
+    const workerThreads = await import('worker_threads');
+    parentPort = workerThreads.parentPort ?? null;
+  } catch {
+    parentPort = null;
+  }
+  if (parentPort) {
+    const port = parentPort;
+    port.on("message", (raw) => {
+      try {
+        port.postMessage(handleAnyRequest(raw));
+      } catch (err) {
+        port.postMessage(errorFor(raw, err));
+      }
+    });
+    return;
+  }
+  const globalSelf = typeof self !== "undefined" ? self : void 0;
+  if (globalSelf && typeof globalSelf.postMessage === "function") {
+    const webSelf = globalSelf;
+    webSelf.onmessage = (event) => {
+      try {
+        webSelf.postMessage(handleAnyRequest(event.data));
+      } catch (err) {
+        webSelf.postMessage(errorFor(event.data, err));
+      }
+    };
+  }
+}
+setupWorker();