@delali/narsil 0.3.1-next.72 → 0.3.1-next.73

package/dist/{chunk-LCCL6EEH.mjs → chunk-WVDFG45M.mjs}

@@ -1,7 +1,7 @@
 import { OSQ_STEPS, OSQ_GRID, OSQ_REFINE_ROUNDS, OSQ_REFINE_TOLERANCE, OSQ4_NARROW_DIMENSION_LIMIT, DEFAULT_OSQ4_NARROW_OVERSAMPLE, DEFAULT_OVERSAMPLE_BY_BITS, OSQ_QUERY_BITS, OSQ_LAMBDA } from './chunk-ZJ4CSAB2.mjs';
-import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, nativeSearchCoreIsEnabled, loadNativeCore, stopUsingTheNativeSearchCore, noteFallback, MAX_LAYER_CAP, PLACEMENT_ROOM_REQUESTS, INITIAL_LIST_CAPACITY, DEFAULT_EF_SEARCH, INITIAL_UPPER_SLOTS } from './chunk-P2ZZN32C.mjs';
+import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, nativeSearchCoreIsEnabled, loadNativeCore, stopUsingTheNativeSearchCore, noteFallback, MAX_LAYER_CAP, PLACEMENT_ROOM_REQUESTS, INITIAL_LIST_CAPACITY, DEFAULT_EF_SEARCH, INITIAL_UPPER_SLOTS } from './chunk-PU43WDY4.mjs';
 import { compareCodePoints } from './chunk-LJYTW7GT.mjs';
-import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { readSync, closeSync, openSync } from 'fs';
 
 // src/vector/constants.ts
@@ -3651,6 +3651,13 @@ function createVectorStore(options) {
         yield [docId, entryAt(open, ordinal)];
       }
     },
+    *docIds() {
+      if (open === null) return;
+      for (let ordinal = 0; ordinal < ordToDoc.length; ordinal++) {
+        const docId = ordToDoc[ordinal];
+        if (docId !== void 0) yield docId;
+      }
+    },
     clear() {
       forgetDocuments();
       if (open === null) return;
@@ -3789,30 +3796,24 @@ function savedTopLayer(state, ordinal) {
   if (ordinal === NO_ORDINAL || isTombstoned(state, ordinal)) return NO_LAYER;
   return Math.min(nodeMaxLayer(state, ordinal), MAX_LAYER_CAP);
 }
-function largestNeighbourValueCount(state, topLayers) {
+function neighbourValueCount(state, topLayers, start, end) {
   let values = 0;
-  for (let number = 0; number < topLayers.length; number++) {
+  for (let number = start; number < end; number++) {
     const top = topLayers[number];
     if (top < 0) continue;
     values += state.adjacency.level0Stride + top * state.adjacency.upperStride;
   }
   return values;
 }
-function serializeNumberedGraph(state, numberOfOrdinal, ordinalOfNumber) {
+function serializePart(state, numbers, start, end) {
+  const { numberOfOrdinal, ordinalOfNumber, topLayers } = numbers;
   const adjacency = state.adjacency;
-  const slots = adjacencySlots(adjacency);
-  const topLayers = new Int8Array(ordinalOfNumber.length).fill(-1);
-  const levels = new Uint8Array(ordinalOfNumber.length);
-  for (let number = 0; number < ordinalOfNumber.length; number++) {
-    const ordinal = ordinalOfNumber[number];
-    if (ordinal >= slots) continue;
-    topLayers[number] = savedTopLayer(state, ordinal);
-    levels[number] = topLayers[number] + 1;
-  }
-  const values = new Uint32Array(largestNeighbourValueCount(state, topLayers));
+  const levels = new Uint8Array(end - start);
+  const values = new Uint32Array(neighbourValueCount(state, topLayers, start, end));
   let cursor = 0;
-  for (let number = 0; number < ordinalOfNumber.length; number++) {
+  for (let number = start; number < end; number++) {
     const top = topLayers[number];
+    levels[number - start] = top + 1;
     for (let layer = 0; layer <= top; layer++) {
       const base = layerBase(adjacency, ordinalOfNumber[number], layer);
       const array = layerArray(adjacency, layer);
@@ -3830,18 +3831,33 @@ function serializeNumberedGraph(state, numberOfOrdinal, ordinalOfNumber) {
       values[countAt] = cursor - countAt - 1;
     }
   }
+  return { levels, neighbours: littleEndianBytesOf(values.subarray(0, cursor)) };
+}
+function serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize) {
+  const slots = adjacencySlots(state.adjacency);
+  const topLayers = new Int8Array(ordinalOfNumber.length).fill(-1);
+  for (let number = 0; number < ordinalOfNumber.length; number++) {
+    const ordinal = ordinalOfNumber[number];
+    if (ordinal >= slots) continue;
+    topLayers[number] = savedTopLayer(state, ordinal);
+  }
   const entryOrdinal = entryPointOf(state);
   const entryNumber = entryOrdinal >= 0 && entryOrdinal < numberOfOrdinal.length ? numberOfOrdinal[entryOrdinal] : NO_NUMBER;
   const entryHoldsNode = entryNumber !== NO_NUMBER && topLayers[entryNumber] >= 0;
-  return {
+  const header = {
     entryPoint: entryHoldsNode ? entryNumber : null,
     maxLayer: Math.max(0, Math.min(topLayerOf(state), MAX_LAYER_CAP)),
     m: state.M,
     efConstruction: state.efCons,
-    metric: state.buildMetric,
-    levels,
-    neighbours: littleEndianBytesOf(values.subarray(0, cursor))
+    metric: state.buildMetric
   };
+  const numbers = { numberOfOrdinal, ordinalOfNumber, topLayers };
+  const parts = [];
+  for (let start = 0; start < ordinalOfNumber.length; start += partSize) {
+    const end = Math.min(start + partSize, ordinalOfNumber.length);
+    parts.push({ ...header, ...serializePart(state, numbers, start, end) });
+  }
+  return parts;
 }
 function endsInsideAList() {
   throw new NarsilError(
@@ -3862,95 +3878,78 @@ function requireWholeNeighbourLists(graph) {
     }
   }
 }
-function topLayerIn(graph, number) {
-  return number < graph.levels.length ? graph.levels[number] - 1 : -1;
+function topLayerInParts(graph, number) {
+  const part = graph.parts[Math.floor(number / graph.partSize)];
+  if (part === void 0) return -1;
+  const at = number % graph.partSize;
+  return at < part.levels.length ? part.levels[at] - 1 : -1;
+}
+function highestNodeOrdinal(graph, ordinalAt) {
+  let highest = -1;
+  for (let p = 0; p < graph.parts.length; p++) {
+    const levels = graph.parts[p].levels;
+    for (let at = 0; at < levels.length; at++) {
+      const ordinal = ordinalAt(p * graph.partSize + at);
+      if (levels[at] > 0 && ordinal > highest) highest = ordinal;
+    }
+  }
+  return highest;
 }
 function deserializeNumberedGraph(state, graph, ordinalOfNumber) {
-  requireWholeNeighbourLists(graph);
+  for (const part of graph.parts) requireWholeNeighbourLists(part);
   resetGraph(state);
-  const values = valuesOf(graph.neighbours);
   const ordinalAt = (number) => number < ordinalOfNumber.length ? ordinalOfNumber[number] : NO_ORDINAL;
-  let highestOrdinal = -1;
-  for (let number = 0; number < graph.levels.length; number++) {
-    if (graph.levels[number] > 0 && ordinalAt(number) > highestOrdinal) highestOrdinal = ordinalAt(number);
-  }
+  const highestOrdinal = highestNodeOrdinal(graph, ordinalAt);
   if (highestOrdinal >= 0) ensureCapacity(state, highestOrdinal + 1);
   const kept = [];
-  let cursor = 0;
   let highestLayer = -1;
   let nodeOnHighestLayer = NO_ORDINAL;
-  for (let number = 0; number < graph.levels.length; number++) {
-    const top = graph.levels[number] - 1;
-    if (top < 0) continue;
-    const ordinal = ordinalAt(number);
-    const keptTop = Math.min(top, MAX_LAYER_CAP);
-    if (ordinal !== NO_ORDINAL) {
-      createNode(state.adjacency, ordinal, keptTop);
-      Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
-      if (keptTop > highestLayer) {
-        highestLayer = keptTop;
-        nodeOnHighestLayer = ordinal;
-      }
-    }
-    for (let layer = 0; layer <= top; layer++) {
-      const count = values[cursor];
-      kept.length = 0;
-      const limit = maxConns(state, layer);
-      for (let i = 1; i <= count && kept.length < limit; i++) {
-        const neighbour = values[cursor + i];
-        const neighbourOrdinal = ordinalAt(neighbour);
-        if (neighbourOrdinal === NO_ORDINAL || neighbour === number || topLayerIn(graph, neighbour) < layer) continue;
-        if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
+  for (let p = 0; p < graph.parts.length; p++) {
+    const part = graph.parts[p];
+    const values = valuesOf(part.neighbours);
+    let cursor = 0;
+    for (let at = 0; at < part.levels.length; at++) {
+      const number = p * graph.partSize + at;
+      const top = part.levels[at] - 1;
+      if (top < 0) continue;
+      const ordinal = ordinalAt(number);
+      const keptTop = Math.min(top, MAX_LAYER_CAP);
+      if (ordinal !== NO_ORDINAL) {
+        createNode(state.adjacency, ordinal, keptTop);
+        Atomics.add(state.header, GRAPH_NODE_COUNT, 1);
+        if (keptTop > highestLayer) {
+          highestLayer = keptTop;
+          nodeOnHighestLayer = ordinal;
+        }
       }
-      cursor += count + 1;
-      if (ordinal !== NO_ORDINAL && layer <= keptTop) {
-        replaceNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
+      for (let layer = 0; layer <= top; layer++) {
+        const count = values[cursor];
+        kept.length = 0;
+        const limit = maxConns(state, layer);
+        for (let i = 1; i <= count && kept.length < limit; i++) {
+          const neighbour = values[cursor + i];
+          const neighbourOrdinal = ordinalAt(neighbour);
+          if (neighbourOrdinal === NO_ORDINAL || neighbour === number) continue;
+          if (topLayerInParts(graph, neighbour) < layer) continue;
+          if (!kept.includes(neighbourOrdinal)) kept.push(neighbourOrdinal);
+        }
+        cursor += count + 1;
+        if (ordinal !== NO_ORDINAL && layer <= keptTop) {
+          replaceNeighbors(state.adjacency, ordinal, layer, kept, kept.length);
+        }
       }
     }
   }
-  const entryOrdinal = graph.entryPoint === null ? NO_ORDINAL : ordinalAt(graph.entryPoint);
-  const entryTop = graph.entryPoint === null ? -1 : Math.min(topLayerIn(graph, graph.entryPoint), MAX_LAYER_CAP);
+  const first = graph.parts[0];
+  const entryPoint = first === void 0 ? null : first.entryPoint;
+  const entryOrdinal = entryPoint === null ? NO_ORDINAL : ordinalAt(entryPoint);
+  const entryTop = entryPoint === null ? -1 : Math.min(topLayerInParts(graph, entryPoint), MAX_LAYER_CAP);
   const entryIsUsable = entryOrdinal !== NO_ORDINAL && entryTop >= 0;
   Atomics.store(state.header, GRAPH_ENTRY_POINT, entryIsUsable ? entryOrdinal : nodeOnHighestLayer);
   Atomics.store(state.header, GRAPH_TOP_LAYER, entryIsUsable ? entryTop : highestLayer);
 }
 
 // src/vector/hnsw/persistence.ts
-function serializeGraph(state, store) {
-  const nodeArray = [];
-  const slots = adjacencySlots(state.adjacency);
-  for (let ord = 0; ord < slots; ord++) {
-    const maxLayer = nodeMaxLayer(state, ord);
-    if (maxLayer === -1) continue;
-    if (isTombstoned(state, ord)) continue;
-    const docId = store.docIdForOrdinal(ord);
-    if (docId === void 0) continue;
-    const layerConns = [];
-    for (let layer = 0; layer <= maxLayer; layer++) {
-      const liveNeighbors = [];
-      for (const neighborOrd of collectNeighbors(state.adjacency, ord, layer)) {
-        if (isTombstoned(state, neighborOrd)) continue;
-        const neighborDoc = store.docIdForOrdinal(neighborOrd);
-        if (neighborDoc === void 0) continue;
-        liveNeighbors.push(neighborDoc);
-      }
-      if (liveNeighbors.length > 0) {
-        layerConns.push([layer, liveNeighbors]);
-      }
-    }
-    nodeArray.push([docId, maxLayer, layerConns]);
-  }
-  const entryOrd = entryPointOf(state);
-  const entryPoint = entryOrd === -1 ? null : store.docIdForOrdinal(entryOrd) ?? null;
-  return {
-    entryPoint,
-    maxLayer: topLayerOf(state),
-    m: state.M,
-    efConstruction: state.efCons,
-    metric: state.buildMetric,
-    nodes: nodeArray
-  };
-}
 function resolveNodes(state, store, data) {
   const nodes = [];
   let maxOrd = -1;
@@ -4186,13 +4185,12 @@ function createHNSWIndex(dimension, store, config, quantizer, handles) {
     compactTombstones: () => exclusively(() => compactTombstones(state)),
     rebuild: () => exclusively(() => rebuild(state)),
     exclusively,
-    serialize: () => serializeGraph(state, store),
     deserialize: (data) => exclusively(() => deserializeGraph(state, store, data)),
-    serializeNumbered: (numberOfOrdinal, ordinalOfNumber) => serializeNumberedGraph(state, numberOfOrdinal, ordinalOfNumber),
+    serializeNumbered: (numberOfOrdinal, ordinalOfNumber, partSize) => serializeNumberedGraphParts(state, numberOfOrdinal, ordinalOfNumber, partSize),
     deserializeNumbered: (graph, ordinalOfNumber) => exclusively(() => deserializeNumberedGraph(state, graph, ordinalOfNumber)),
     exportSnapshot: () => exportSnapshot(state),
     restoreSnapshot: (snapshot) => exclusively(() => restoreSnapshot(state, snapshot))
   };
 }
 
-export { DISK_STORAGE_BLOCK_BYTES, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, MAX_WORKER_COPIES, SCRATCH_SLOTS_PER_THREAD_POOL, STORE_CALIBRATION_GENERATION, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_SEARCH_TIMEOUT_MS, addToOrdinalFilter, cosineSimilarityWithMagnitudes, createHNSWIndex, createOrdinalFilter, createOsqQuantizer, createVectorStore, dotProduct, entryForOrd, euclideanDistance, isSimdAvailable, isTombstoned, magnitude, nativeScoresOf, nativeStoreScratchBytes, openSharedVectorField, ordinalFilterHas, ordinalFilterValues, osqBitsOf, osqRecordBytes, releaseLocksHeldBy, removeFromOrdinalFilter, requireWholeNeighbourLists, sharedMemoryAvailable, toDistance, toScore };
+export { DISK_STORAGE_BLOCK_BYTES, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, MAX_WORKER_COPIES, SCRATCH_SLOTS_PER_THREAD_POOL, STORE_CALIBRATION_GENERATION, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_SEARCH_TIMEOUT_MS, addToOrdinalFilter, cosineSimilarityWithMagnitudes, createHNSWIndex, createOrdinalFilter, createOsqQuantizer, createVectorStore, dotProduct, entryForOrd, euclideanDistance, isSimdAvailable, isTombstoned, magnitude, nativeScoresOf, nativeStoreScratchBytes, openSharedVectorField, ordinalFilterHas, ordinalFilterValues, osqBitsOf, osqRecordBytes, releaseLocksHeldBy, removeFromOrdinalFilter, requireWholeNeighbourLists, sharedMemoryAvailable, toDistance, toScore, topLayerInParts };

package/dist/{chunk-3HQPUCCT.mjs → chunk-XW25X6AU.mjs}

@@ -1,55 +1,6 @@
-import { MATCHER_STATE_BUDGET_BYTES, bitsetHas, bitsetSet, PATTERN_RUN_CODE_POINTS, MATCHER_SIMULATION_BYTES_PER_POSITION, MATCHER_STATE_OVERHEAD_BYTES, MATCHER_CODE_POINT_BYTES } from './chunk-ZKRV5M2P.mjs';
-
-// src/core/pattern-index/matcher-budget.ts
-var POSITIONS_PER_WORD = 32;
-function positionWords(positions) {
-  return Math.max(1, Math.ceil(positions / POSITIONS_PER_WORD));
-}
-function automatonBytes(positions) {
-  return 2 * positionWords(positions) * Uint32Array.BYTES_PER_ELEMENT + positions * MATCHER_CODE_POINT_BYTES;
-}
-function smallestMatcherBytes(positions) {
-  return automatonBytes(positions) + positions * MATCHER_SIMULATION_BYTES_PER_POSITION + MATCHER_STATE_OVERHEAD_BYTES + positions * Uint32Array.BYTES_PER_ELEMENT;
-}
-function widestPatternSplit(positions) {
-  return Math.max(1, Math.floor(MATCHER_STATE_BUDGET_BYTES / smallestMatcherBytes(positions)));
-}
-
-// src/pattern/automaton.ts
-function setPosition(words, position) {
-  words[position >>> 5] |= 1 << (position & 31);
-}
-function hasPosition(words, position) {
-  return (words[position >>> 5] & 1 << (position & 31)) !== 0;
-}
-function literalAutomaton(codePoints, anchoredStart, anchoredEnd) {
-  const size = codePoints.length;
-  const words = positionWords(size);
-  const first = new Uint32Array(words);
-  const last = new Uint32Array(words);
-  if (size > 0) {
-    setPosition(first, 0);
-    setPosition(last, size - 1);
-  }
-  return {
-    size,
-    words,
-    first,
-    last,
-    nullable: size === 0,
-    anchoredStart,
-    anchoredEnd,
-    bytes: automatonBytes(size),
-    accepts: (position, codePoint) => codePoints[position] === codePoint,
-    followerCount: (position) => position + 1 < size ? 1 : 0,
-    follower: (position) => position + 1
-  };
-}
+import { bitsetHas, bitsetSet, PATTERN_RUN_CODE_POINTS } from './chunk-ZKRV5M2P.mjs';
 
 // src/pattern/constants.ts
-var MATCHER_TRANSITION_BYTES = 48;
-var MATCHER_KEY_CHARACTER_BYTES = 2;
-var MATCHER_MIN_CODE_POINTS_PER_STATE = 10;
 var SHORTLIST_RUN_LOOKUPS = 16;
 var SHORTLIST_INTERSECT_RATIO = 8;
 var RUN_LIST_INITIAL_CAPACITY = 4;
@@ -57,205 +8,86 @@ var RUN_LIST_COMPACTION_FRACTION = 0.5;
 var RUN_ENTRY_OVERHEAD_BYTES = 140;
 var DOCUMENT_ENTRY_BYTES = 24;
 
-// src/pattern/position-simulation.ts
-var LAST_STAMP = 4294967295;
-var PositionSimulation = class {
-  constructor(automaton) {
-    this.automaton = automaton;
-    this.active = new Uint32Array(automaton.size);
-    this.following = new Uint32Array(automaton.size);
-    this.marks = new Uint32Array(automaton.size);
-    const first = [];
-    for (let position = 0; position < automaton.size; position++) {
-      if (hasPosition(automaton.first, position)) first.push(position);
-    }
-    this.first = Uint32Array.from(first);
-  }
+// src/pattern/literal-matcher.ts
+function bordersOf(codePoints) {
+  const length = codePoints.length;
+  const borders = new Uint32Array(length + 1);
+  let border = 0;
+  for (let at = 1; at < length; at++) {
+    while (border > 0 && codePoints[at] !== codePoints[border]) border = borders[border];
+    if (codePoints[at] === codePoints[border]) border++;
+    borders[at + 1] = border;
+  }
+  return borders;
+}
+function reachablePositionsOf(borders, length) {
+  const reachable = new Uint32Array(length + 1);
+  for (let prefix = 1; prefix <= length; prefix++) {
+    reachable[prefix] = (prefix < length ? 1 : 0) + reachable[borders[prefix]];
+  }
+  return reachable;
+}
+var LiteralMatcher = class {
+  constructor(codePoints, anchoredStart, anchoredEnd) {
+    this.codePoints = codePoints;
+    this.anchoredStart = anchoredStart;
+    this.anchoredEnd = anchoredEnd;
+    this.borders = bordersOf(codePoints);
+    this.reachable = reachablePositionsOf(this.borders, codePoints.length);
+  }
+  borders;
+  reachable;
+  prefix = 0;
+  alive = true;
   accepting = false;
-  active;
-  following;
-  marks;
-  first;
-  activeCount = 0;
-  stamp = 0;
-  get steps() {
-    return this.activeCount;
-  }
-  get bytes() {
-    return this.automaton.size * MATCHER_SIMULATION_BYTES_PER_POSITION;
-  }
-  reset() {
-    this.active.set(this.first);
-    this.activeCount = this.first.length;
-    this.accepting = this.automaton.nullable;
-  }
-  get firstPositions() {
-    return this.first;
-  }
-  load(active, accepting) {
-    this.active.set(active);
-    this.activeCount = active.length;
-    this.accepting = accepting;
-  }
-  sortedActive() {
-    return this.active.slice(0, this.activeCount).sort();
-  }
-  advance(codePoint) {
-    const { automaton, marks } = this;
-    const following = this.following;
-    const stamp = this.nextStamp();
-    let count = 0;
-    let accepting = false;
-    for (let at = 0; at < this.activeCount; at++) {
-      const position = this.active[at];
-      if (!automaton.accepts(position, codePoint)) continue;
-      if (hasPosition(automaton.last, position)) accepting = true;
-      const followers = automaton.followerCount(position);
-      for (let index = 0; index < followers; index++) {
-        const follower = automaton.follower(position, index);
-        if (marks[follower] === stamp) continue;
-        marks[follower] = stamp;
-        following[count++] = follower;
-      }
-    }
-    if (!automaton.anchoredStart) {
-      for (const position of this.first) {
-        if (marks[position] === stamp) continue;
-        marks[position] = stamp;
-        following[count++] = position;
-      }
-      if (automaton.nullable) accepting = true;
-    }
-    this.following = this.active;
-    this.active = following;
-    this.activeCount = count;
-    this.accepting = accepting;
-  }
-  nextStamp() {
-    if (this.stamp === LAST_STAMP) {
-      this.marks.fill(0);
-      this.stamp = 0;
-    }
-    this.stamp++;
-    return this.stamp;
-  }
-};
-
-// src/pattern/lazy-dfa.ts
-var UNCACHED_GENERATION = -1;
-function stateKey(active, accepting) {
-  return `${active.join(",")}${accepting ? "+" : "-"}`;
-}
-function stateBytes(active, key) {
-  return MATCHER_STATE_OVERHEAD_BYTES + active.byteLength + key.length * MATCHER_KEY_CHARACTER_BYTES;
-}
-var LazyDfa = class {
-  constructor(automaton, stateLimitBytes) {
-    this.automaton = automaton;
-    this.simulation = new PositionSimulation(automaton);
-    this.cacheLimitBytes = stateLimitBytes - automaton.bytes - this.simulation.bytes;
-    this.start = this.intern(this.simulation.firstPositions, automaton.nullable);
-    this.state = this.start;
-    if (this.wantsSimulation()) this.simulate(this.start);
-  }
-  states = /* @__PURE__ */ new Map();
-  generation = 0;
-  cachedBytes = 0;
-  codePointsSinceReset = 0;
-  start;
-  state;
-  simulating = false;
   decided = null;
-  simulation;
-  cacheLimitBytes;
   begin() {
     this.decided = null;
-    if (this.simulating) this.simulation.reset();
-    else this.state = this.start;
-    if (!this.automaton.anchoredEnd && this.accepting()) return this.decide(true);
+    this.prefix = 0;
+    this.alive = this.codePoints.length > 0;
+    this.accepting = this.codePoints.length === 0;
+    if (!this.anchoredEnd && this.accepting) return this.decide(true);
     return true;
   }
   feed(codePoint, tally) {
-    const steps = this.simulating ? this.simulation.steps : this.state.active.length;
-    if (steps === 0) return this.decide(!this.automaton.anchoredStart && this.automaton.nullable);
+    const steps = this.steps();
+    if (steps === 0) return this.decide(!this.anchoredStart && this.codePoints.length === 0);
     tally.add(steps);
-    if (this.simulating) {
-      this.simulation.advance(codePoint);
-    } else {
-      this.codePointsSinceReset++;
-      this.state = this.step(this.state, codePoint);
-      if (this.wantsSimulation()) this.simulate(this.state);
-    }
-    if (!this.automaton.anchoredEnd && this.accepting()) return this.decide(true);
+    if (this.anchoredStart) this.advanceAnchored(codePoint);
+    else this.advance(codePoint);
+    if (!this.anchoredEnd && this.accepting) return this.decide(true);
     return true;
   }
   matched() {
-    return this.decided ?? (this.automaton.anchoredEnd && this.accepting());
+    return this.decided ?? (this.anchoredEnd && this.accepting);
+  }
+  steps() {
+    const length = this.codePoints.length;
+    if (length === 0) return 0;
+    if (this.anchoredStart) return this.alive && this.prefix < length ? 1 : 0;
+    return 1 + this.reachable[this.prefix];
+  }
+  advanceAnchored(codePoint) {
+    if (this.codePoints[this.prefix] === codePoint) {
+      this.prefix++;
+      this.accepting = this.prefix === this.codePoints.length;
+      return;
+    }
+    this.alive = false;
+    this.accepting = false;
   }
-  accepting() {
-    return this.simulating ? this.simulation.accepting : this.state.accepting;
+  advance(codePoint) {
+    const { codePoints, borders } = this;
+    let prefix = this.prefix === codePoints.length ? borders[this.prefix] : this.prefix;
+    while (prefix > 0 && codePoints[prefix] !== codePoint) prefix = borders[prefix];
+    if (codePoints[prefix] === codePoint) prefix++;
+    this.prefix = prefix;
+    this.accepting = prefix === codePoints.length;
   }
   decide(outcome) {
     this.decided = outcome;
     return false;
   }
-  wantsSimulation() {
-    return !this.simulating && this.state.generation === UNCACHED_GENERATION;
-  }
-  simulate(from) {
-    this.dropCache();
-    this.state = this.start;
-    this.simulation.load(from.active, from.accepting);
-    this.simulating = true;
-  }
-  dropCache() {
-    for (const state of this.states.values()) state.next.clear();
-    this.start.next.clear();
-    this.state.next.clear();
-    this.states = /* @__PURE__ */ new Map();
-    this.cachedBytes = 0;
-  }
-  step(state, codePoint) {
-    const current = state.generation === this.generation;
-    if (current) {
-      const cached = state.next.get(codePoint);
-      if (cached !== void 0) return cached;
-    }
-    const { simulation } = this;
-    simulation.load(state.active, state.accepting);
-    simulation.advance(codePoint);
-    const next = this.intern(simulation.sortedActive(), simulation.accepting);
-    if (!current || state.generation !== this.generation || next.generation !== this.generation) return next;
-    if (!this.reserve(MATCHER_TRANSITION_BYTES) || state.generation !== this.generation) return next;
-    state.next.set(codePoint, next);
-    return next;
-  }
-  intern(active, accepting) {
-    const key = stateKey(active, accepting);
-    const existing = this.states.get(key);
-    if (existing !== void 0) return existing;
-    if (!this.reserve(stateBytes(active, key))) {
-      return { active, accepting, generation: UNCACHED_GENERATION, next: /* @__PURE__ */ new Map() };
-    }
-    const state = { active, accepting, generation: this.generation, next: /* @__PURE__ */ new Map() };
-    this.states.set(key, state);
-    return state;
-  }
-  reserve(bytes) {
-    if (this.cachedBytes + bytes <= this.cacheLimitBytes) {
-      this.cachedBytes += bytes;
-      return true;
-    }
-    if (this.states.size === 0 || this.codePointsSinceReset < MATCHER_MIN_CODE_POINTS_PER_STATE * this.states.size) {
-      return false;
-    }
-    this.dropCache();
-    this.codePointsSinceReset = 0;
-    this.generation++;
-    this.start = this.intern(this.start.active, this.start.accepting);
-    if (this.start.generation === UNCACHED_GENERATION) return false;
-    return this.reserve(bytes);
-  }
 };
 
 // src/pattern/text.ts
@@ -391,10 +223,7 @@ function matcherFor(request) {
   const { operator, text, caseFold, host } = request;
   const testCodePoints = [];
   appendTextCodePoints(text, caseFold, host, testCodePoints);
-  return new LazyDfa(
-    literalAutomaton(testCodePoints, ANCHORED_START.has(operator), ANCHORED_END.has(operator)),
-    request.meter.matcherStateBytes
-  );
+  return new LiteralMatcher(Uint32Array.from(testCodePoints), ANCHORED_START.has(operator), ANCHORED_END.has(operator));
 }
 function matchesText(matcher, text, caseFold, host, folded, tally) {
   if (!matcher.begin()) return matcher.matched();
@@ -782,4 +611,4 @@ var patternSearchModule = {
   matchInto: matchPattern
 };
 
-export { GrowableUint32, patternSearchModule, widestPatternSplit };
+export { GrowableUint32, patternSearchModule };

package/dist/{chunk-2X2ZQOAB.mjs → chunk-ZULSEZCE.mjs}

@@ -1,9 +1,8 @@
-import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, DEFAULT_LIMIT, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, ABSOLUTE_WINDOWS_PATH_PATTERN, MODULE_URL_SCHEME_PATTERN, DEFAULT_OFFSET } from './chunk-XZ4PAREY.mjs';
-import { clampRowCount, sortSignatureOf, requireSortableFields, decodePageCursor, requireMatchingCursor, resolveProjection, encodePageCursor, requireWithinResultWindow, normalizeSort, fanOutQuery, sortModesOf, applySorting, applyPagination, projectionKeepsField, countsWithoutScores, fanOutMatchCount, tokenize, fnv1aBytes, requireValidFilter, createPatternWorkMeter, everyValueFacetConfig, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, partitionsIn, undeclaredFieldOnStrictIndex, fuzzyTermMatches } from './chunk-QR4OKRVY.mjs';
-import { MIN_PATTERN_VALUE_LIMIT, MAX_PATTERN_VALUE_LIMIT, DEFAULT_MAX_PER_GROUP, flattenSchema, DEFAULT_LINEAR_ALPHA, MIN_LINEAR_ALPHA, MAX_LINEAR_ALPHA, DEFAULT_RANK_CONSTANT, MIN_RANK_CONSTANT, DEFAULT_FUZZY_PREFIX_LENGTH, RESULT_WINDOW, isWordIndexedFieldType, isGeopointOrVectorType, MAX_TOLERANCE, MAX_PREFIX_LENGTH } from './chunk-M6XF5HDE.mjs';
+import { clampRowCount, sortSignatureOf, requireSortableFields, decodePageCursor, requireMatchingCursor, resolveProjection, encodePageCursor, requireWithinResultWindow, normalizeSort, fanOutQuery, sortModesOf, applySorting, applyPagination, projectionKeepsField, countsWithoutScores, fanOutMatchCount, tokenize, fnv1aBytes, requireValidFilter, createPatternWorkMeter, everyValueFacetConfig, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, partitionsIn, undeclaredFieldOnStrictIndex, fuzzyTermMatches } from './chunk-3YKWSO54.mjs';
+import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, MIN_PATTERN_VALUE_LIMIT, MAX_PATTERN_VALUE_LIMIT, DEFAULT_LIMIT, DEFAULT_MAX_PER_GROUP, flattenSchema, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, ABSOLUTE_WINDOWS_PATH_PATTERN, MODULE_URL_SCHEME_PATTERN, DEFAULT_LINEAR_ALPHA, MIN_LINEAR_ALPHA, MAX_LINEAR_ALPHA, DEFAULT_RANK_CONSTANT, MIN_RANK_CONSTANT, DEFAULT_OFFSET, DEFAULT_FUZZY_PREFIX_LENGTH, RESULT_WINDOW, isWordIndexedFieldType, isGeopointOrVectorType, MAX_TOLERANCE, MAX_PREFIX_LENGTH } from './chunk-AK3BLGCI.mjs';
 import { MIN_OVERSAMPLE } from './chunk-ZJ4CSAB2.mjs';
 import { holdsUnpairedSurrogate, compareCodePoints, compareComparableKeys } from './chunk-LJYTW7GT.mjs';
-import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 
 // src/search/cursor-binding.ts
 var ABSENT_TAG = 0;