@kainoa/5c-mcp 0.4.0

package/dist/server.js

@@ -0,0 +1,4968 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { readFileSync, realpathSync } from "node:fs";
+import { createServer } from "node:http";
+import { pathToFileURL } from "node:url";
+
+// ../core/dist/index.js
+import { createHash } from "node:crypto";
+import {
+  mkdir,
+  open,
+  readFile,
+  rename,
+  unlink,
+  writeFile
+} from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+
+// ../../node_modules/.pnpm/minisearch@7.2.0/node_modules/minisearch/dist/es/index.js
+var ENTRIES = "ENTRIES";
+var KEYS = "KEYS";
+var VALUES = "VALUES";
+var LEAF = "";
+var TreeIterator = class {
+  constructor(set, type) {
+    const node = set._tree;
+    const keys = Array.from(node.keys());
+    this.set = set;
+    this._type = type;
+    this._path = keys.length > 0 ? [{ node, keys }] : [];
+  }
+  next() {
+    const value = this.dive();
+    this.backtrack();
+    return value;
+  }
+  dive() {
+    if (this._path.length === 0) {
+      return { done: true, value: void 0 };
+    }
+    const { node, keys } = last$1(this._path);
+    if (last$1(keys) === LEAF) {
+      return { done: false, value: this.result() };
+    }
+    const child = node.get(last$1(keys));
+    this._path.push({ node: child, keys: Array.from(child.keys()) });
+    return this.dive();
+  }
+  backtrack() {
+    if (this._path.length === 0) {
+      return;
+    }
+    const keys = last$1(this._path).keys;
+    keys.pop();
+    if (keys.length > 0) {
+      return;
+    }
+    this._path.pop();
+    this.backtrack();
+  }
+  key() {
+    return this.set._prefix + this._path.map(({ keys }) => last$1(keys)).filter((key) => key !== LEAF).join("");
+  }
+  value() {
+    return last$1(this._path).node.get(LEAF);
+  }
+  result() {
+    switch (this._type) {
+      case VALUES:
+        return this.value();
+      case KEYS:
+        return this.key();
+      default:
+        return [this.key(), this.value()];
+    }
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+};
+var last$1 = (array) => {
+  return array[array.length - 1];
+};
+var fuzzySearch = (node, query, maxDistance) => {
+  const results = /* @__PURE__ */ new Map();
+  if (query === void 0)
+    return results;
+  const n = query.length + 1;
+  const m = n + maxDistance;
+  const matrix = new Uint8Array(m * n).fill(maxDistance + 1);
+  for (let j = 0; j < n; ++j)
+    matrix[j] = j;
+  for (let i = 1; i < m; ++i)
+    matrix[i * n] = i;
+  recurse(node, query, maxDistance, results, matrix, 1, n, "");
+  return results;
+};
+var recurse = (node, query, maxDistance, results, matrix, m, n, prefix) => {
+  const offset = m * n;
+  key: for (const key of node.keys()) {
+    if (key === LEAF) {
+      const distance = matrix[offset - 1];
+      if (distance <= maxDistance) {
+        results.set(prefix, [node.get(key), distance]);
+      }
+    } else {
+      let i = m;
+      for (let pos = 0; pos < key.length; ++pos, ++i) {
+        const char = key[pos];
+        const thisRowOffset = n * i;
+        const prevRowOffset = thisRowOffset - n;
+        let minDistance = matrix[thisRowOffset];
+        const jmin = Math.max(0, i - maxDistance - 1);
+        const jmax = Math.min(n - 1, i + maxDistance);
+        for (let j = jmin; j < jmax; ++j) {
+          const different = char !== query[j];
+          const rpl = matrix[prevRowOffset + j] + +different;
+          const del = matrix[prevRowOffset + j + 1] + 1;
+          const ins = matrix[thisRowOffset + j] + 1;
+          const dist = matrix[thisRowOffset + j + 1] = Math.min(rpl, del, ins);
+          if (dist < minDistance)
+            minDistance = dist;
+        }
+        if (minDistance > maxDistance) {
+          continue key;
+        }
+      }
+      recurse(node.get(key), query, maxDistance, results, matrix, i, n, prefix + key);
+    }
+  }
+};
+var SearchableMap = class _SearchableMap {
+  /**
+   * The constructor is normally called without arguments, creating an empty
+   * map. In order to create a {@link SearchableMap} from an iterable or from an
+   * object, check {@link SearchableMap.from} and {@link
+   * SearchableMap.fromObject}.
+   *
+   * The constructor arguments are for internal use, when creating derived
+   * mutable views of a map at a prefix.
+   */
+  constructor(tree = /* @__PURE__ */ new Map(), prefix = "") {
+    this._size = void 0;
+    this._tree = tree;
+    this._prefix = prefix;
+  }
+  /**
+   * Creates and returns a mutable view of this {@link SearchableMap},
+   * containing only entries that share the given prefix.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * let map = new SearchableMap()
+   * map.set("unicorn", 1)
+   * map.set("universe", 2)
+   * map.set("university", 3)
+   * map.set("unique", 4)
+   * map.set("hello", 5)
+   *
+   * let uni = map.atPrefix("uni")
+   * uni.get("unique") // => 4
+   * uni.get("unicorn") // => 1
+   * uni.get("hello") // => undefined
+   *
+   * let univer = map.atPrefix("univer")
+   * univer.get("unique") // => undefined
+   * univer.get("universe") // => 2
+   * univer.get("university") // => 3
+   * ```
+   *
+   * @param prefix  The prefix
+   * @return A {@link SearchableMap} representing a mutable view of the original
+   * Map at the given prefix
+   */
+  atPrefix(prefix) {
+    if (!prefix.startsWith(this._prefix)) {
+      throw new Error("Mismatched prefix");
+    }
+    const [node, path] = trackDown(this._tree, prefix.slice(this._prefix.length));
+    if (node === void 0) {
+      const [parentNode, key] = last(path);
+      for (const k of parentNode.keys()) {
+        if (k !== LEAF && k.startsWith(key)) {
+          const node2 = /* @__PURE__ */ new Map();
+          node2.set(k.slice(key.length), parentNode.get(k));
+          return new _SearchableMap(node2, prefix);
+        }
+      }
+    }
+    return new _SearchableMap(node, prefix);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear
+   */
+  clear() {
+    this._size = void 0;
+    this._tree.clear();
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete
+   * @param key  Key to delete
+   */
+  delete(key) {
+    this._size = void 0;
+    return remove(this._tree, key);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries
+   * @return An iterator iterating through `[key, value]` entries.
+   */
+  entries() {
+    return new TreeIterator(this, ENTRIES);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach
+   * @param fn  Iteration function
+   */
+  forEach(fn) {
+    for (const [key, value] of this) {
+      fn(key, value, this);
+    }
+  }
+  /**
+   * Returns a Map of all the entries that have a key within the given edit
+   * distance from the search key. The keys of the returned Map are the matching
+   * keys, while the values are two-element arrays where the first element is
+   * the value associated to the key, and the second is the edit distance of the
+   * key to the search key.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * let map = new SearchableMap()
+   * map.set('hello', 'world')
+   * map.set('hell', 'yeah')
+   * map.set('ciao', 'mondo')
+   *
+   * // Get all entries that match the key 'hallo' with a maximum edit distance of 2
+   * map.fuzzyGet('hallo', 2)
+   * // => Map(2) { 'hello' => ['world', 1], 'hell' => ['yeah', 2] }
+   *
+   * // In the example, the "hello" key has value "world" and edit distance of 1
+   * // (change "e" to "a"), the key "hell" has value "yeah" and edit distance of 2
+   * // (change "e" to "a", delete "o")
+   * ```
+   *
+   * @param key  The search key
+   * @param maxEditDistance  The maximum edit distance (Levenshtein)
+   * @return A Map of the matching keys to their value and edit distance
+   */
+  fuzzyGet(key, maxEditDistance) {
+    return fuzzySearch(this._tree, key, maxEditDistance);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get
+   * @param key  Key to get
+   * @return Value associated to the key, or `undefined` if the key is not
+   * found.
+   */
+  get(key) {
+    const node = lookup(this._tree, key);
+    return node !== void 0 ? node.get(LEAF) : void 0;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has
+   * @param key  Key
+   * @return True if the key is in the map, false otherwise
+   */
+  has(key) {
+    const node = lookup(this._tree, key);
+    return node !== void 0 && node.has(LEAF);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys
+   * @return An `Iterable` iterating through keys
+   */
+  keys() {
+    return new TreeIterator(this, KEYS);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set
+   * @param key  Key to set
+   * @param value  Value to associate to the key
+   * @return The {@link SearchableMap} itself, to allow chaining
+   */
+  set(key, value) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = void 0;
+    const node = createPath(this._tree, key);
+    node.set(LEAF, value);
+    return this;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size
+   */
+  get size() {
+    if (this._size) {
+      return this._size;
+    }
+    this._size = 0;
+    const iter = this.entries();
+    while (!iter.next().done)
+      this._size += 1;
+    return this._size;
+  }
+  /**
+   * Updates the value at the given key using the provided function. The function
+   * is called with the current value at the key, and its return value is used as
+   * the new value to be set.
+   *
+   * ### Example:
+   *
+   * ```javascript
+   * // Increment the current value by one
+   * searchableMap.update('somekey', (currentValue) => currentValue == null ? 0 : currentValue + 1)
+   * ```
+   *
+   * If the value at the given key is or will be an object, it might not require
+   * re-assignment. In that case it is better to use `fetch()`, because it is
+   * faster.
+   *
+   * @param key  The key to update
+   * @param fn  The function used to compute the new value from the current one
+   * @return The {@link SearchableMap} itself, to allow chaining
+   */
+  update(key, fn) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = void 0;
+    const node = createPath(this._tree, key);
+    node.set(LEAF, fn(node.get(LEAF)));
+    return this;
+  }
+  /**
+   * Fetches the value of the given key. If the value does not exist, calls the
+   * given function to create a new value, which is inserted at the given key
+   * and subsequently returned.
+   *
+   * ### Example:
+   *
+   * ```javascript
+   * const map = searchableMap.fetch('somekey', () => new Map())
+   * map.set('foo', 'bar')
+   * ```
+   *
+   * @param key  The key to update
+   * @param initial  A function that creates a new value if the key does not exist
+   * @return The existing or new value at the given key
+   */
+  fetch(key, initial) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = void 0;
+    const node = createPath(this._tree, key);
+    let value = node.get(LEAF);
+    if (value === void 0) {
+      node.set(LEAF, value = initial());
+    }
+    return value;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values
+   * @return An `Iterable` iterating through values.
+   */
+  values() {
+    return new TreeIterator(this, VALUES);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator
+   */
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * Creates a {@link SearchableMap} from an `Iterable` of entries
+   *
+   * @param entries  Entries to be inserted in the {@link SearchableMap}
+   * @return A new {@link SearchableMap} with the given entries
+   */
+  static from(entries) {
+    const tree = new _SearchableMap();
+    for (const [key, value] of entries) {
+      tree.set(key, value);
+    }
+    return tree;
+  }
+  /**
+   * Creates a {@link SearchableMap} from the iterable properties of a JavaScript object
+   *
+   * @param object  Object of entries for the {@link SearchableMap}
+   * @return A new {@link SearchableMap} with the given entries
+   */
+  static fromObject(object) {
+    return _SearchableMap.from(Object.entries(object));
+  }
+};
+var trackDown = (tree, key, path = []) => {
+  if (key.length === 0 || tree == null) {
+    return [tree, path];
+  }
+  for (const k of tree.keys()) {
+    if (k !== LEAF && key.startsWith(k)) {
+      path.push([tree, k]);
+      return trackDown(tree.get(k), key.slice(k.length), path);
+    }
+  }
+  path.push([tree, key]);
+  return trackDown(void 0, "", path);
+};
+var lookup = (tree, key) => {
+  if (key.length === 0 || tree == null) {
+    return tree;
+  }
+  for (const k of tree.keys()) {
+    if (k !== LEAF && key.startsWith(k)) {
+      return lookup(tree.get(k), key.slice(k.length));
+    }
+  }
+};
+var createPath = (node, key) => {
+  const keyLength = key.length;
+  outer: for (let pos = 0; node && pos < keyLength; ) {
+    for (const k of node.keys()) {
+      if (k !== LEAF && key[pos] === k[0]) {
+        const len = Math.min(keyLength - pos, k.length);
+        let offset = 1;
+        while (offset < len && key[pos + offset] === k[offset])
+          ++offset;
+        const child2 = node.get(k);
+        if (offset === k.length) {
+          node = child2;
+        } else {
+          const intermediate = /* @__PURE__ */ new Map();
+          intermediate.set(k.slice(offset), child2);
+          node.set(key.slice(pos, pos + offset), intermediate);
+          node.delete(k);
+          node = intermediate;
+        }
+        pos += offset;
+        continue outer;
+      }
+    }
+    const child = /* @__PURE__ */ new Map();
+    node.set(key.slice(pos), child);
+    return child;
+  }
+  return node;
+};
+var remove = (tree, key) => {
+  const [node, path] = trackDown(tree, key);
+  if (node === void 0) {
+    return;
+  }
+  node.delete(LEAF);
+  if (node.size === 0) {
+    cleanup(path);
+  } else if (node.size === 1) {
+    const [key2, value] = node.entries().next().value;
+    merge(path, key2, value);
+  }
+};
+var cleanup = (path) => {
+  if (path.length === 0) {
+    return;
+  }
+  const [node, key] = last(path);
+  node.delete(key);
+  if (node.size === 0) {
+    cleanup(path.slice(0, -1));
+  } else if (node.size === 1) {
+    const [key2, value] = node.entries().next().value;
+    if (key2 !== LEAF) {
+      merge(path.slice(0, -1), key2, value);
+    }
+  }
+};
+var merge = (path, key, value) => {
+  if (path.length === 0) {
+    return;
+  }
+  const [node, nodeKey] = last(path);
+  node.set(nodeKey + key, value);
+  node.delete(nodeKey);
+};
+var last = (array) => {
+  return array[array.length - 1];
+};
+var OR = "or";
+var AND = "and";
+var AND_NOT = "and_not";
+var MiniSearch = class _MiniSearch {
+  /**
+   * @param options  Configuration options
+   *
+   * ### Examples:
+   *
+   * ```javascript
+   * // Create a search engine that indexes the 'title' and 'text' fields of your
+   * // documents:
+   * const miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * ```
+   *
+   * ### ID Field:
+   *
+   * ```javascript
+   * // Your documents are assumed to include a unique 'id' field, but if you want
+   * // to use a different field for document identification, you can set the
+   * // 'idField' option:
+   * const miniSearch = new MiniSearch({ idField: 'key', fields: ['title', 'text'] })
+   * ```
+   *
+   * ### Options and defaults:
+   *
+   * ```javascript
+   * // The full set of options (here with their default value) is:
+   * const miniSearch = new MiniSearch({
+   *   // idField: field that uniquely identifies a document
+   *   idField: 'id',
+   *
+   *   // extractField: function used to get the value of a field in a document.
+   *   // By default, it assumes the document is a flat object with field names as
+   *   // property keys and field values as string property values, but custom logic
+   *   // can be implemented by setting this option to a custom extractor function.
+   *   extractField: (document, fieldName) => document[fieldName],
+   *
+   *   // tokenize: function used to split fields into individual terms. By
+   *   // default, it is also used to tokenize search queries, unless a specific
+   *   // `tokenize` search option is supplied. When tokenizing an indexed field,
+   *   // the field name is passed as the second argument.
+   *   tokenize: (string, _fieldName) => string.split(SPACE_OR_PUNCTUATION),
+   *
+   *   // processTerm: function used to process each tokenized term before
+   *   // indexing. It can be used for stemming and normalization. Return a falsy
+   *   // value in order to discard a term. By default, it is also used to process
+   *   // search queries, unless a specific `processTerm` option is supplied as a
+   *   // search option. When processing a term from a indexed field, the field
+   *   // name is passed as the second argument.
+   *   processTerm: (term, _fieldName) => term.toLowerCase(),
+   *
+   *   // searchOptions: default search options, see the `search` method for
+   *   // details
+   *   searchOptions: undefined,
+   *
+   *   // fields: document fields to be indexed. Mandatory, but not set by default
+   *   fields: undefined
+   *
+   *   // storeFields: document fields to be stored and returned as part of the
+   *   // search results.
+   *   storeFields: []
+   * })
+   * ```
+   */
+  constructor(options) {
+    if ((options === null || options === void 0 ? void 0 : options.fields) == null) {
+      throw new Error('MiniSearch: option "fields" must be provided');
+    }
+    const autoVacuum = options.autoVacuum == null || options.autoVacuum === true ? defaultAutoVacuumOptions : options.autoVacuum;
+    this._options = {
+      ...defaultOptions,
+      ...options,
+      autoVacuum,
+      searchOptions: { ...defaultSearchOptions, ...options.searchOptions || {} },
+      autoSuggestOptions: { ...defaultAutoSuggestOptions, ...options.autoSuggestOptions || {} }
+    };
+    this._index = new SearchableMap();
+    this._documentCount = 0;
+    this._documentIds = /* @__PURE__ */ new Map();
+    this._idToShortId = /* @__PURE__ */ new Map();
+    this._fieldIds = {};
+    this._fieldLength = /* @__PURE__ */ new Map();
+    this._avgFieldLength = [];
+    this._nextId = 0;
+    this._storedFields = /* @__PURE__ */ new Map();
+    this._dirtCount = 0;
+    this._currentVacuum = null;
+    this._enqueuedVacuum = null;
+    this._enqueuedVacuumConditions = defaultVacuumConditions;
+    this.addFields(this._options.fields);
+  }
+  /**
+   * Adds a document to the index
+   *
+   * @param document  The document to be indexed
+   */
+  add(document) {
+    const { extractField, stringifyField, tokenize, processTerm, fields, idField } = this._options;
+    const id = extractField(document, idField);
+    if (id == null) {
+      throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+    }
+    if (this._idToShortId.has(id)) {
+      throw new Error(`MiniSearch: duplicate ID ${id}`);
+    }
+    const shortDocumentId = this.addDocumentId(id);
+    this.saveStoredFields(shortDocumentId, document);
+    for (const field of fields) {
+      const fieldValue = extractField(document, field);
+      if (fieldValue == null)
+        continue;
+      const tokens = tokenize(stringifyField(fieldValue, field), field);
+      const fieldId = this._fieldIds[field];
+      const uniqueTerms = new Set(tokens).size;
+      this.addFieldLength(shortDocumentId, fieldId, this._documentCount - 1, uniqueTerms);
+      for (const term of tokens) {
+        const processedTerm = processTerm(term, field);
+        if (Array.isArray(processedTerm)) {
+          for (const t of processedTerm) {
+            this.addTerm(fieldId, shortDocumentId, t);
+          }
+        } else if (processedTerm) {
+          this.addTerm(fieldId, shortDocumentId, processedTerm);
+        }
+      }
+    }
+  }
+  /**
+   * Adds all the given documents to the index
+   *
+   * @param documents  An array of documents to be indexed
+   */
+  addAll(documents) {
+    for (const document of documents)
+      this.add(document);
+  }
+  /**
+   * Adds all the given documents to the index asynchronously.
+   *
+   * Returns a promise that resolves (to `undefined`) when the indexing is done.
+   * This method is useful when index many documents, to avoid blocking the main
+   * thread. The indexing is performed asynchronously and in chunks.
+   *
+   * @param documents  An array of documents to be indexed
+   * @param options  Configuration options
+   * @return A promise resolving to `undefined` when the indexing is done
+   */
+  addAllAsync(documents, options = {}) {
+    const { chunkSize = 10 } = options;
+    const acc = { chunk: [], promise: Promise.resolve() };
+    const { chunk, promise } = documents.reduce(({ chunk: chunk2, promise: promise2 }, document, i) => {
+      chunk2.push(document);
+      if ((i + 1) % chunkSize === 0) {
+        return {
+          chunk: [],
+          promise: promise2.then(() => new Promise((resolve) => setTimeout(resolve, 0))).then(() => this.addAll(chunk2))
+        };
+      } else {
+        return { chunk: chunk2, promise: promise2 };
+      }
+    }, acc);
+    return promise.then(() => this.addAll(chunk));
+  }
+  /**
+   * Removes the given document from the index.
+   *
+   * The document to remove must NOT have changed between indexing and removal,
+   * otherwise the index will be corrupted.
+   *
+   * This method requires passing the full document to be removed (not just the
+   * ID), and immediately removes the document from the inverted index, allowing
+   * memory to be released. A convenient alternative is {@link
+   * MiniSearch#discard}, which needs only the document ID, and has the same
+   * visible effect, but delays cleaning up the index until the next vacuuming.
+   *
+   * @param document  The document to be removed
+   */
+  remove(document) {
+    const { tokenize, processTerm, extractField, stringifyField, fields, idField } = this._options;
+    const id = extractField(document, idField);
+    if (id == null) {
+      throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+    }
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      throw new Error(`MiniSearch: cannot remove document with ID ${id}: it is not in the index`);
+    }
+    for (const field of fields) {
+      const fieldValue = extractField(document, field);
+      if (fieldValue == null)
+        continue;
+      const tokens = tokenize(stringifyField(fieldValue, field), field);
+      const fieldId = this._fieldIds[field];
+      const uniqueTerms = new Set(tokens).size;
+      this.removeFieldLength(shortId, fieldId, this._documentCount, uniqueTerms);
+      for (const term of tokens) {
+        const processedTerm = processTerm(term, field);
+        if (Array.isArray(processedTerm)) {
+          for (const t of processedTerm) {
+            this.removeTerm(fieldId, shortId, t);
+          }
+        } else if (processedTerm) {
+          this.removeTerm(fieldId, shortId, processedTerm);
+        }
+      }
+    }
+    this._storedFields.delete(shortId);
+    this._documentIds.delete(shortId);
+    this._idToShortId.delete(id);
+    this._fieldLength.delete(shortId);
+    this._documentCount -= 1;
+  }
+  /**
+   * Removes all the given documents from the index. If called with no arguments,
+   * it removes _all_ documents from the index.
+   *
+   * @param documents  The documents to be removed. If this argument is omitted,
+   * all documents are removed. Note that, for removing all documents, it is
+   * more efficient to call this method with no arguments than to pass all
+   * documents.
+   */
+  removeAll(documents) {
+    if (documents) {
+      for (const document of documents)
+        this.remove(document);
+    } else if (arguments.length > 0) {
+      throw new Error("Expected documents to be present. Omit the argument to remove all documents.");
+    } else {
+      this._index = new SearchableMap();
+      this._documentCount = 0;
+      this._documentIds = /* @__PURE__ */ new Map();
+      this._idToShortId = /* @__PURE__ */ new Map();
+      this._fieldLength = /* @__PURE__ */ new Map();
+      this._avgFieldLength = [];
+      this._storedFields = /* @__PURE__ */ new Map();
+      this._nextId = 0;
+    }
+  }
+  /**
+   * Discards the document with the given ID, so it won't appear in search results
+   *
+   * It has the same visible effect of {@link MiniSearch.remove} (both cause the
+   * document to stop appearing in searches), but a different effect on the
+   * internal data structures:
+   *
+   *   - {@link MiniSearch#remove} requires passing the full document to be
+   *   removed as argument, and removes it from the inverted index immediately.
+   *
+   *   - {@link MiniSearch#discard} instead only needs the document ID, and
+   *   works by marking the current version of the document as discarded, so it
+   *   is immediately ignored by searches. This is faster and more convenient
+   *   than {@link MiniSearch#remove}, but the index is not immediately
+   *   modified. To take care of that, vacuuming is performed after a certain
+   *   number of documents are discarded, cleaning up the index and allowing
+   *   memory to be released.
+   *
+   * After discarding a document, it is possible to re-add a new version, and
+   * only the new version will appear in searches. In other words, discarding
+   * and re-adding a document works exactly like removing and re-adding it. The
+   * {@link MiniSearch.replace} method can also be used to replace a document
+   * with a new version.
+   *
+   * #### Details about vacuuming
+   *
+   * Repetite calls to this method would leave obsolete document references in
+   * the index, invisible to searches. Two mechanisms take care of cleaning up:
+   * clean up during search, and vacuuming.
+   *
+   *   - Upon search, whenever a discarded ID is found (and ignored for the
+   *   results), references to the discarded document are removed from the
+   *   inverted index entries for the search terms. This ensures that subsequent
+   *   searches for the same terms do not need to skip these obsolete references
+   *   again.
+   *
+   *   - In addition, vacuuming is performed automatically by default (see the
+   *   `autoVacuum` field in {@link Options}) after a certain number of
+   *   documents are discarded. Vacuuming traverses all terms in the index,
+   *   cleaning up all references to discarded documents. Vacuuming can also be
+   *   triggered manually by calling {@link MiniSearch#vacuum}.
+   *
+   * @param id  The ID of the document to be discarded
+   */
+  discard(id) {
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      throw new Error(`MiniSearch: cannot discard document with ID ${id}: it is not in the index`);
+    }
+    this._idToShortId.delete(id);
+    this._documentIds.delete(shortId);
+    this._storedFields.delete(shortId);
+    (this._fieldLength.get(shortId) || []).forEach((fieldLength, fieldId) => {
+      this.removeFieldLength(shortId, fieldId, this._documentCount, fieldLength);
+    });
+    this._fieldLength.delete(shortId);
+    this._documentCount -= 1;
+    this._dirtCount += 1;
+    this.maybeAutoVacuum();
+  }
+  maybeAutoVacuum() {
+    if (this._options.autoVacuum === false) {
+      return;
+    }
+    const { minDirtFactor, minDirtCount, batchSize, batchWait } = this._options.autoVacuum;
+    this.conditionalVacuum({ batchSize, batchWait }, { minDirtCount, minDirtFactor });
+  }
+  /**
+   * Discards the documents with the given IDs, so they won't appear in search
+   * results
+   *
+   * It is equivalent to calling {@link MiniSearch#discard} for all the given
+   * IDs, but with the optimization of triggering at most one automatic
+   * vacuuming at the end.
+   *
+   * Note: to remove all documents from the index, it is faster and more
+   * convenient to call {@link MiniSearch.removeAll} with no argument, instead
+   * of passing all IDs to this method.
+   */
+  discardAll(ids) {
+    const autoVacuum = this._options.autoVacuum;
+    try {
+      this._options.autoVacuum = false;
+      for (const id of ids) {
+        this.discard(id);
+      }
+    } finally {
+      this._options.autoVacuum = autoVacuum;
+    }
+    this.maybeAutoVacuum();
+  }
+  /**
+   * It replaces an existing document with the given updated version
+   *
+   * It works by discarding the current version and adding the updated one, so
+   * it is functionally equivalent to calling {@link MiniSearch#discard}
+   * followed by {@link MiniSearch#add}. The ID of the updated document should
+   * be the same as the original one.
+   *
+   * Since it uses {@link MiniSearch#discard} internally, this method relies on
+   * vacuuming to clean up obsolete document references from the index, allowing
+   * memory to be released (see {@link MiniSearch#discard}).
+   *
+   * @param updatedDocument  The updated document to replace the old version
+   * with
+   */
+  replace(updatedDocument) {
+    const { idField, extractField } = this._options;
+    const id = extractField(updatedDocument, idField);
+    this.discard(id);
+    this.add(updatedDocument);
+  }
+  /**
+   * Triggers a manual vacuuming, cleaning up references to discarded documents
+   * from the inverted index
+   *
+   * Vacuuming is only useful for applications that use the {@link
+   * MiniSearch#discard} or {@link MiniSearch#replace} methods.
+   *
+   * By default, vacuuming is performed automatically when needed (controlled by
+   * the `autoVacuum` field in {@link Options}), so there is usually no need to
+   * call this method, unless one wants to make sure to perform vacuuming at a
+   * specific moment.
+   *
+   * Vacuuming traverses all terms in the inverted index in batches, and cleans
+   * up references to discarded documents from the posting list, allowing memory
+   * to be released.
+   *
+   * The method takes an optional object as argument with the following keys:
+   *
+   *   - `batchSize`: the size of each batch (1000 by default)
+   *
+   *   - `batchWait`: the number of milliseconds to wait between batches (10 by
+   *   default)
+   *
+   * On large indexes, vacuuming could have a non-negligible cost: batching
+   * avoids blocking the thread for long, diluting this cost so that it is not
+   * negatively affecting the application. Nonetheless, this method should only
+   * be called when necessary, and relying on automatic vacuuming is usually
+   * better.
+   *
+   * It returns a promise that resolves (to undefined) when the clean up is
+   * completed. If vacuuming is already ongoing at the time this method is
+   * called, a new one is enqueued immediately after the ongoing one, and a
+   * corresponding promise is returned. However, no more than one vacuuming is
+   * enqueued on top of the ongoing one, even if this method is called more
+   * times (enqueuing multiple ones would be useless).
+   *
+   * @param options  Configuration options for the batch size and delay. See
+   * {@link VacuumOptions}.
+   */
+  vacuum(options = {}) {
+    return this.conditionalVacuum(options);
+  }
+  conditionalVacuum(options, conditions) {
+    if (this._currentVacuum) {
+      this._enqueuedVacuumConditions = this._enqueuedVacuumConditions && conditions;
+      if (this._enqueuedVacuum != null) {
+        return this._enqueuedVacuum;
+      }
+      this._enqueuedVacuum = this._currentVacuum.then(() => {
+        const conditions2 = this._enqueuedVacuumConditions;
+        this._enqueuedVacuumConditions = defaultVacuumConditions;
+        return this.performVacuuming(options, conditions2);
+      });
+      return this._enqueuedVacuum;
+    }
+    if (this.vacuumConditionsMet(conditions) === false) {
+      return Promise.resolve();
+    }
+    this._currentVacuum = this.performVacuuming(options);
+    return this._currentVacuum;
+  }
+  async performVacuuming(options, conditions) {
+    const initialDirtCount = this._dirtCount;
+    if (this.vacuumConditionsMet(conditions)) {
+      const batchSize = options.batchSize || defaultVacuumOptions.batchSize;
+      const batchWait = options.batchWait || defaultVacuumOptions.batchWait;
+      let i = 1;
+      for (const [term, fieldsData] of this._index) {
+        for (const [fieldId, fieldIndex] of fieldsData) {
+          for (const [shortId] of fieldIndex) {
+            if (this._documentIds.has(shortId)) {
+              continue;
+            }
+            if (fieldIndex.size <= 1) {
+              fieldsData.delete(fieldId);
+            } else {
+              fieldIndex.delete(shortId);
+            }
+          }
+        }
+        if (this._index.get(term).size === 0) {
+          this._index.delete(term);
+        }
+        if (i % batchSize === 0) {
+          await new Promise((resolve) => setTimeout(resolve, batchWait));
+        }
+        i += 1;
+      }
+      this._dirtCount -= initialDirtCount;
+    }
+    await null;
+    this._currentVacuum = this._enqueuedVacuum;
+    this._enqueuedVacuum = null;
+  }
+  vacuumConditionsMet(conditions) {
+    if (conditions == null) {
+      return true;
+    }
+    let { minDirtCount, minDirtFactor } = conditions;
+    minDirtCount = minDirtCount || defaultAutoVacuumOptions.minDirtCount;
+    minDirtFactor = minDirtFactor || defaultAutoVacuumOptions.minDirtFactor;
+    return this.dirtCount >= minDirtCount && this.dirtFactor >= minDirtFactor;
+  }
+  /**
+   * Is `true` if a vacuuming operation is ongoing, `false` otherwise
+   */
+  get isVacuuming() {
+    return this._currentVacuum != null;
+  }
+  /**
+   * The number of documents discarded since the most recent vacuuming
+   */
+  get dirtCount() {
+    return this._dirtCount;
+  }
+  /**
+   * A number between 0 and 1 giving an indication about the proportion of
+   * documents that are discarded, and can therefore be cleaned up by vacuuming.
+   * A value close to 0 means that the index is relatively clean, while a higher
+   * value means that the index is relatively dirty, and vacuuming could release
+   * memory.
+   */
+  get dirtFactor() {
+    return this._dirtCount / (1 + this._documentCount + this._dirtCount);
+  }
+  /**
+   * Returns `true` if a document with the given ID is present in the index and
+   * available for search, `false` otherwise
+   *
+   * @param id  The document ID
+   */
+  has(id) {
+    return this._idToShortId.has(id);
+  }
+  /**
+   * Returns the stored fields (as configured in the `storeFields` constructor
+   * option) for the given document ID. Returns `undefined` if the document is
+   * not present in the index.
+   *
+   * @param id  The document ID
+   */
+  getStoredFields(id) {
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      return void 0;
+    }
+    return this._storedFields.get(shortId);
+  }
+  /**
+   * Search for documents matching the given search query.
+   *
+   * The result is a list of scored document IDs matching the query, sorted by
+   * descending score, and each including data about which terms were matched and
+   * in which fields.
+   *
+   * ### Basic usage:
+   *
+   * ```javascript
+   * // Search for "zen art motorcycle" with default options: terms have to match
+   * // exactly, and individual terms are joined with OR
+   * miniSearch.search('zen art motorcycle')
+   * // => [ { id: 2, score: 2.77258, match: { ... } }, { id: 4, score: 1.38629, match: { ... } } ]
+   * ```
+   *
+   * ### Restrict search to specific fields:
+   *
+   * ```javascript
+   * // Search only in the 'title' field
+   * miniSearch.search('zen', { fields: ['title'] })
+   * ```
+   *
+   * ### Field boosting:
+   *
+   * ```javascript
+   * // Boost a field
+   * miniSearch.search('zen', { boost: { title: 2 } })
+   * ```
+   *
+   * ### Prefix search:
+   *
+   * ```javascript
+   * // Search for "moto" with prefix search (it will match documents
+   * // containing terms that start with "moto" or "neuro")
+   * miniSearch.search('moto neuro', { prefix: true })
+   * ```
+   *
+   * ### Fuzzy search:
+   *
+   * ```javascript
+   * // Search for "ismael" with fuzzy search (it will match documents containing
+   * // terms similar to "ismael", with a maximum edit distance of 0.2 term.length
+   * // (rounded to nearest integer)
+   * miniSearch.search('ismael', { fuzzy: 0.2 })
+   * ```
+   *
+   * ### Combining strategies:
+   *
+   * ```javascript
+   * // Mix of exact match, prefix search, and fuzzy search
+   * miniSearch.search('ismael mob', {
+   *  prefix: true,
+   *  fuzzy: 0.2
+   * })
+   * ```
+   *
+   * ### Advanced prefix and fuzzy search:
+   *
+   * ```javascript
+   * // Perform fuzzy and prefix search depending on the search term. Here
+   * // performing prefix and fuzzy search only on terms longer than 3 characters
+   * miniSearch.search('ismael mob', {
+   *  prefix: term => term.length > 3
+   *  fuzzy: term => term.length > 3 ? 0.2 : null
+   * })
+   * ```
+   *
+   * ### Combine with AND:
+   *
+   * ```javascript
+   * // Combine search terms with AND (to match only documents that contain both
+   * // "motorcycle" and "art")
+   * miniSearch.search('motorcycle art', { combineWith: 'AND' })
+   * ```
+   *
+   * ### Combine with AND_NOT:
+   *
+   * There is also an AND_NOT combinator, that finds documents that match the
+   * first term, but do not match any of the other terms. This combinator is
+   * rarely useful with simple queries, and is meant to be used with advanced
+   * query combinations (see later for more details).
+   *
+   * ### Filtering results:
+   *
+   * ```javascript
+   * // Filter only results in the 'fiction' category (assuming that 'category'
+   * // is a stored field)
+   * miniSearch.search('motorcycle art', {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * ```
+   *
+   * ### Wildcard query
+   *
+   * Searching for an empty string (assuming the default tokenizer) returns no
+   * results. Sometimes though, one needs to match all documents, like in a
+   * "wildcard" search. This is possible by passing the special value
+   * {@link MiniSearch.wildcard} as the query:
+   *
+   * ```javascript
+   * // Return search results for all documents
+   * miniSearch.search(MiniSearch.wildcard)
+   * ```
+   *
+   * Note that search options such as `filter` and `boostDocument` are still
+   * applied, influencing which results are returned, and their order:
+   *
+   * ```javascript
+   * // Return search results for all documents in the 'fiction' category
+   * miniSearch.search(MiniSearch.wildcard, {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * ```
+   *
+   * ### Advanced combination of queries:
+   *
+   * It is possible to combine different subqueries with OR, AND, and AND_NOT,
+   * and even with different search options, by passing a query expression
+   * tree object as the first argument, instead of a string.
+   *
+   * ```javascript
+   * // Search for documents that contain "zen" and ("motorcycle" or "archery")
+   * miniSearch.search({
+   *   combineWith: 'AND',
+   *   queries: [
+   *     'zen',
+   *     {
+   *       combineWith: 'OR',
+   *       queries: ['motorcycle', 'archery']
+   *     }
+   *   ]
+   * })
+   *
+   * // Search for documents that contain ("apple" or "pear") but not "juice" and
+   * // not "tree"
+   * miniSearch.search({
+   *   combineWith: 'AND_NOT',
+   *   queries: [
+   *     {
+   *       combineWith: 'OR',
+   *       queries: ['apple', 'pear']
+   *     },
+   *     'juice',
+   *     'tree'
+   *   ]
+   * })
+   * ```
+   *
+   * Each node in the expression tree can be either a string, or an object that
+   * supports all {@link SearchOptions} fields, plus a `queries` array field for
+   * subqueries.
+   *
+   * Note that, while this can become complicated to do by hand for complex or
+   * deeply nested queries, it provides a formalized expression tree API for
+   * external libraries that implement a parser for custom query languages.
+   *
+   * @param query  Search query
+   * @param searchOptions  Search options. Each option, if not given, defaults to the corresponding value of `searchOptions` given to the constructor, or to the library default.
+   */
+  search(query, searchOptions = {}) {
+    const { searchOptions: globalSearchOptions } = this._options;
+    const searchOptionsWithDefaults = { ...globalSearchOptions, ...searchOptions };
+    const rawResults = this.executeQuery(query, searchOptions);
+    const results = [];
+    for (const [docId, { score, terms, match }] of rawResults) {
+      const quality = terms.length || 1;
+      const result = {
+        id: this._documentIds.get(docId),
+        score: score * quality,
+        terms: Object.keys(match),
+        queryTerms: terms,
+        match
+      };
+      Object.assign(result, this._storedFields.get(docId));
+      if (searchOptionsWithDefaults.filter == null || searchOptionsWithDefaults.filter(result)) {
+        results.push(result);
+      }
+    }
+    if (query === _MiniSearch.wildcard && searchOptionsWithDefaults.boostDocument == null) {
+      return results;
+    }
+    results.sort(byScore);
+    return results;
+  }
+  /**
+   * Provide suggestions for the given search query
+   *
+   * The result is a list of suggested modified search queries, derived from the
+   * given search query, each with a relevance score, sorted by descending score.
+   *
+   * By default, it uses the same options used for search, except that by
+   * default it performs prefix search on the last term of the query, and
+   * combine terms with `'AND'` (requiring all query terms to match). Custom
+   * options can be passed as a second argument. Defaults can be changed upon
+   * calling the {@link MiniSearch} constructor, by passing a
+   * `autoSuggestOptions` option.
+   *
+   * ### Basic usage:
+   *
+   * ```javascript
+   * // Get suggestions for 'neuro':
+   * miniSearch.autoSuggest('neuro')
+   * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 0.46240 } ]
+   * ```
+   *
+   * ### Multiple words:
+   *
+   * ```javascript
+   * // Get suggestions for 'zen ar':
+   * miniSearch.autoSuggest('zen ar')
+   * // => [
+   * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
+   * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
+   * // ]
+   * ```
+   *
+   * ### Fuzzy suggestions:
+   *
+   * ```javascript
+   * // Correct spelling mistakes using fuzzy search:
+   * miniSearch.autoSuggest('neromancer', { fuzzy: 0.2 })
+   * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 1.03998 } ]
+   * ```
+   *
+   * ### Filtering:
+   *
+   * ```javascript
+   * // Get suggestions for 'zen ar', but only within the 'fiction' category
+   * // (assuming that 'category' is a stored field):
+   * miniSearch.autoSuggest('zen ar', {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * // => [
+   * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
+   * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
+   * // ]
+   * ```
+   *
+   * @param queryString  Query string to be expanded into suggestions
+   * @param options  Search options. The supported options and default values
+   * are the same as for the {@link MiniSearch#search} method, except that by
+   * default prefix search is performed on the last term in the query, and terms
+   * are combined with `'AND'`.
+   * @return  A sorted array of suggestions sorted by relevance score.
+   */
+  autoSuggest(queryString, options = {}) {
+    options = { ...this._options.autoSuggestOptions, ...options };
+    const suggestions = /* @__PURE__ */ new Map();
+    for (const { score, terms } of this.search(queryString, options)) {
+      const phrase = terms.join(" ");
+      const suggestion = suggestions.get(phrase);
+      if (suggestion != null) {
+        suggestion.score += score;
+        suggestion.count += 1;
+      } else {
+        suggestions.set(phrase, { score, terms, count: 1 });
+      }
+    }
+    const results = [];
+    for (const [suggestion, { score, terms, count }] of suggestions) {
+      results.push({ suggestion, terms, score: score / count });
+    }
+    results.sort(byScore);
+    return results;
+  }
+  /**
+   * Total number of documents available to search
+   */
+  get documentCount() {
+    return this._documentCount;
+  }
+  /**
+   * Number of terms in the index
+   */
+  get termCount() {
+    return this._index.size;
+  }
+  /**
+   * Deserializes a JSON index (serialized with `JSON.stringify(miniSearch)`)
+   * and instantiates a MiniSearch instance. It should be given the same options
+   * originally used when serializing the index.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // If the index was serialized with:
+   * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * miniSearch.addAll(documents)
+   *
+   * const json = JSON.stringify(miniSearch)
+   * // It can later be deserialized like this:
+   * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
+   * ```
+   *
+   * @param json  JSON-serialized index
+   * @param options  configuration options, same as the constructor
+   * @return An instance of MiniSearch deserialized from the given JSON.
+   */
+  static loadJSON(json, options) {
+    if (options == null) {
+      throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+    }
+    return this.loadJS(JSON.parse(json), options);
+  }
+  /**
+   * Async equivalent of {@link MiniSearch.loadJSON}
+   *
+   * This function is an alternative to {@link MiniSearch.loadJSON} that returns
+   * a promise, and loads the index in batches, leaving pauses between them to avoid
+   * blocking the main thread. It tends to be slower than the synchronous
+   * version, but does not block the main thread, so it can be a better choice
+   * when deserializing very large indexes.
+   *
+   * @param json  JSON-serialized index
+   * @param options  configuration options, same as the constructor
+   * @return A Promise that will resolve to an instance of MiniSearch deserialized from the given JSON.
+   */
+  static async loadJSONAsync(json, options) {
+    if (options == null) {
+      throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+    }
+    return this.loadJSAsync(JSON.parse(json), options);
+  }
+  /**
+   * Returns the default value of an option. It will throw an error if no option
+   * with the given name exists.
+   *
+   * @param optionName  Name of the option
+   * @return The default value of the given option
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // Get default tokenizer
+   * MiniSearch.getDefault('tokenize')
+   *
+   * // Get default term processor
+   * MiniSearch.getDefault('processTerm')
+   *
+   * // Unknown options will throw an error
+   * MiniSearch.getDefault('notExisting')
+   * // => throws 'MiniSearch: unknown option "notExisting"'
+   * ```
+   */
+  static getDefault(optionName) {
+    if (defaultOptions.hasOwnProperty(optionName)) {
+      return getOwnProperty(defaultOptions, optionName);
+    } else {
+      throw new Error(`MiniSearch: unknown option "${optionName}"`);
+    }
+  }
+  /**
+   * @ignore
+   */
+  static loadJS(js, options) {
+    const { index, documentIds, fieldLength, storedFields, serializationVersion } = js;
+    const miniSearch = this.instantiateMiniSearch(js, options);
+    miniSearch._documentIds = objectToNumericMap(documentIds);
+    miniSearch._fieldLength = objectToNumericMap(fieldLength);
+    miniSearch._storedFields = objectToNumericMap(storedFields);
+    for (const [shortId, id] of miniSearch._documentIds) {
+      miniSearch._idToShortId.set(id, shortId);
+    }
+    for (const [term, data] of index) {
+      const dataMap = /* @__PURE__ */ new Map();
+      for (const fieldId of Object.keys(data)) {
+        let indexEntry = data[fieldId];
+        if (serializationVersion === 1) {
+          indexEntry = indexEntry.ds;
+        }
+        dataMap.set(parseInt(fieldId, 10), objectToNumericMap(indexEntry));
+      }
+      miniSearch._index.set(term, dataMap);
+    }
+    return miniSearch;
+  }
+  /**
+   * @ignore
+   */
+  static async loadJSAsync(js, options) {
+    const { index, documentIds, fieldLength, storedFields, serializationVersion } = js;
+    const miniSearch = this.instantiateMiniSearch(js, options);
+    miniSearch._documentIds = await objectToNumericMapAsync(documentIds);
+    miniSearch._fieldLength = await objectToNumericMapAsync(fieldLength);
+    miniSearch._storedFields = await objectToNumericMapAsync(storedFields);
+    for (const [shortId, id] of miniSearch._documentIds) {
+      miniSearch._idToShortId.set(id, shortId);
+    }
+    let count = 0;
+    for (const [term, data] of index) {
+      const dataMap = /* @__PURE__ */ new Map();
+      for (const fieldId of Object.keys(data)) {
+        let indexEntry = data[fieldId];
+        if (serializationVersion === 1) {
+          indexEntry = indexEntry.ds;
+        }
+        dataMap.set(parseInt(fieldId, 10), await objectToNumericMapAsync(indexEntry));
+      }
+      if (++count % 1e3 === 0)
+        await wait(0);
+      miniSearch._index.set(term, dataMap);
+    }
+    return miniSearch;
+  }
+  /**
+   * @ignore
+   */
+  static instantiateMiniSearch(js, options) {
+    const { documentCount, nextId, fieldIds, averageFieldLength, dirtCount, serializationVersion } = js;
+    if (serializationVersion !== 1 && serializationVersion !== 2) {
+      throw new Error("MiniSearch: cannot deserialize an index created with an incompatible version");
+    }
+    const miniSearch = new _MiniSearch(options);
+    miniSearch._documentCount = documentCount;
+    miniSearch._nextId = nextId;
+    miniSearch._idToShortId = /* @__PURE__ */ new Map();
+    miniSearch._fieldIds = fieldIds;
+    miniSearch._avgFieldLength = averageFieldLength;
+    miniSearch._dirtCount = dirtCount || 0;
+    miniSearch._index = new SearchableMap();
+    return miniSearch;
+  }
+  /**
+   * @ignore
+   */
+  executeQuery(query, searchOptions = {}) {
+    if (query === _MiniSearch.wildcard) {
+      return this.executeWildcardQuery(searchOptions);
+    }
+    if (typeof query !== "string") {
+      const options2 = { ...searchOptions, ...query, queries: void 0 };
+      const results2 = query.queries.map((subquery) => this.executeQuery(subquery, options2));
+      return this.combineResults(results2, options2.combineWith);
+    }
+    const { tokenize, processTerm, searchOptions: globalSearchOptions } = this._options;
+    const options = { tokenize, processTerm, ...globalSearchOptions, ...searchOptions };
+    const { tokenize: searchTokenize, processTerm: searchProcessTerm } = options;
+    const terms = searchTokenize(query).flatMap((term) => searchProcessTerm(term)).filter((term) => !!term);
+    const queries = terms.map(termToQuerySpec(options));
+    const results = queries.map((query2) => this.executeQuerySpec(query2, options));
+    return this.combineResults(results, options.combineWith);
+  }
+  /**
+   * @ignore
+   */
+  executeQuerySpec(query, searchOptions) {
+    const options = { ...this._options.searchOptions, ...searchOptions };
+    const boosts = (options.fields || this._options.fields).reduce((boosts2, field) => ({ ...boosts2, [field]: getOwnProperty(options.boost, field) || 1 }), {});
+    const { boostDocument, weights, maxFuzzy, bm25: bm25params } = options;
+    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
+    const data = this._index.get(query.term);
+    const results = this.termResults(query.term, query.term, 1, query.termBoost, data, boosts, boostDocument, bm25params);
+    let prefixMatches;
+    let fuzzyMatches;
+    if (query.prefix) {
+      prefixMatches = this._index.atPrefix(query.term);
+    }
+    if (query.fuzzy) {
+      const fuzzy = query.fuzzy === true ? 0.2 : query.fuzzy;
+      const maxDistance = fuzzy < 1 ? Math.min(maxFuzzy, Math.round(query.term.length * fuzzy)) : fuzzy;
+      if (maxDistance)
+        fuzzyMatches = this._index.fuzzyGet(query.term, maxDistance);
+    }
+    if (prefixMatches) {
+      for (const [term, data2] of prefixMatches) {
+        const distance = term.length - query.term.length;
+        if (!distance) {
+          continue;
+        }
+        fuzzyMatches === null || fuzzyMatches === void 0 ? void 0 : fuzzyMatches.delete(term);
+        const weight = prefixWeight * term.length / (term.length + 0.3 * distance);
+        this.termResults(query.term, term, weight, query.termBoost, data2, boosts, boostDocument, bm25params, results);
+      }
+    }
+    if (fuzzyMatches) {
+      for (const term of fuzzyMatches.keys()) {
+        const [data2, distance] = fuzzyMatches.get(term);
+        if (!distance) {
+          continue;
+        }
+        const weight = fuzzyWeight * term.length / (term.length + distance);
+        this.termResults(query.term, term, weight, query.termBoost, data2, boosts, boostDocument, bm25params, results);
+      }
+    }
+    return results;
+  }
+  /**
+   * @ignore
+   */
+  executeWildcardQuery(searchOptions) {
+    const results = /* @__PURE__ */ new Map();
+    const options = { ...this._options.searchOptions, ...searchOptions };
+    for (const [shortId, id] of this._documentIds) {
+      const score = options.boostDocument ? options.boostDocument(id, "", this._storedFields.get(shortId)) : 1;
+      results.set(shortId, {
+        score,
+        terms: [],
+        match: {}
+      });
+    }
+    return results;
+  }
+  /**
+   * @ignore
+   */
+  combineResults(results, combineWith = OR) {
+    if (results.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const operator = combineWith.toLowerCase();
+    const combinator = combinators[operator];
+    if (!combinator) {
+      throw new Error(`Invalid combination operator: ${combineWith}`);
+    }
+    return results.reduce(combinator) || /* @__PURE__ */ new Map();
+  }
+  /**
+   * Allows serialization of the index to JSON, to possibly store it and later
+   * deserialize it with {@link MiniSearch.loadJSON}.
+   *
+   * Normally one does not directly call this method, but rather call the
+   * standard JavaScript `JSON.stringify()` passing the {@link MiniSearch}
+   * instance, and JavaScript will internally call this method. Upon
+   * deserialization, one must pass to {@link MiniSearch.loadJSON} the same
+   * options used to create the original instance that was serialized.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // Serialize the index:
+   * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * miniSearch.addAll(documents)
+   * const json = JSON.stringify(miniSearch)
+   *
+   * // Later, to deserialize it:
+   * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
+   * ```
+   *
+   * @return A plain-object serializable representation of the search index.
+   */
+  toJSON() {
+    const index = [];
+    for (const [term, fieldIndex] of this._index) {
+      const data = {};
+      for (const [fieldId, freqs] of fieldIndex) {
+        data[fieldId] = Object.fromEntries(freqs);
+      }
+      index.push([term, data]);
+    }
+    return {
+      documentCount: this._documentCount,
+      nextId: this._nextId,
+      documentIds: Object.fromEntries(this._documentIds),
+      fieldIds: this._fieldIds,
+      fieldLength: Object.fromEntries(this._fieldLength),
+      averageFieldLength: this._avgFieldLength,
+      storedFields: Object.fromEntries(this._storedFields),
+      dirtCount: this._dirtCount,
+      index,
+      serializationVersion: 2
+    };
+  }
+  /**
+   * @ignore
+   */
+  termResults(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData, fieldBoosts, boostDocumentFn, bm25params, results = /* @__PURE__ */ new Map()) {
+    if (fieldTermData == null)
+      return results;
+    for (const field of Object.keys(fieldBoosts)) {
+      const fieldBoost = fieldBoosts[field];
+      const fieldId = this._fieldIds[field];
+      const fieldTermFreqs = fieldTermData.get(fieldId);
+      if (fieldTermFreqs == null)
+        continue;
+      let matchingFields = fieldTermFreqs.size;
+      const avgFieldLength = this._avgFieldLength[fieldId];
+      for (const docId of fieldTermFreqs.keys()) {
+        if (!this._documentIds.has(docId)) {
+          this.removeTerm(fieldId, docId, derivedTerm);
+          matchingFields -= 1;
+          continue;
+        }
+        const docBoost = boostDocumentFn ? boostDocumentFn(this._documentIds.get(docId), derivedTerm, this._storedFields.get(docId)) : 1;
+        if (!docBoost)
+          continue;
+        const termFreq = fieldTermFreqs.get(docId);
+        const fieldLength = this._fieldLength.get(docId)[fieldId];
+        const rawScore = calcBM25Score(termFreq, matchingFields, this._documentCount, fieldLength, avgFieldLength, bm25params);
+        const weightedScore = termWeight * termBoost * fieldBoost * docBoost * rawScore;
+        const result = results.get(docId);
+        if (result) {
+          result.score += weightedScore;
+          assignUniqueTerm(result.terms, sourceTerm);
+          const match = getOwnProperty(result.match, derivedTerm);
+          if (match) {
+            match.push(field);
+          } else {
+            result.match[derivedTerm] = [field];
+          }
+        } else {
+          results.set(docId, {
+            score: weightedScore,
+            terms: [sourceTerm],
+            match: { [derivedTerm]: [field] }
+          });
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * @ignore
+   */
+  addTerm(fieldId, documentId, term) {
+    const indexData = this._index.fetch(term, createMap);
+    let fieldIndex = indexData.get(fieldId);
+    if (fieldIndex == null) {
+      fieldIndex = /* @__PURE__ */ new Map();
+      fieldIndex.set(documentId, 1);
+      indexData.set(fieldId, fieldIndex);
+    } else {
+      const docs = fieldIndex.get(documentId);
+      fieldIndex.set(documentId, (docs || 0) + 1);
+    }
+  }
+  /**
+   * @ignore
+   */
+  removeTerm(fieldId, documentId, term) {
+    if (!this._index.has(term)) {
+      this.warnDocumentChanged(documentId, fieldId, term);
+      return;
+    }
+    const indexData = this._index.fetch(term, createMap);
+    const fieldIndex = indexData.get(fieldId);
+    if (fieldIndex == null || fieldIndex.get(documentId) == null) {
+      this.warnDocumentChanged(documentId, fieldId, term);
+    } else if (fieldIndex.get(documentId) <= 1) {
+      if (fieldIndex.size <= 1) {
+        indexData.delete(fieldId);
+      } else {
+        fieldIndex.delete(documentId);
+      }
+    } else {
+      fieldIndex.set(documentId, fieldIndex.get(documentId) - 1);
+    }
+    if (this._index.get(term).size === 0) {
+      this._index.delete(term);
+    }
+  }
+  /**
+   * @ignore
+   */
+  warnDocumentChanged(shortDocumentId, fieldId, term) {
+    for (const fieldName of Object.keys(this._fieldIds)) {
+      if (this._fieldIds[fieldName] === fieldId) {
+        this._options.logger("warn", `MiniSearch: document with ID ${this._documentIds.get(shortDocumentId)} has changed before removal: term "${term}" was not present in field "${fieldName}". Removing a document after it has changed can corrupt the index!`, "version_conflict");
+        return;
+      }
+    }
+  }
+  /**
+   * @ignore
+   */
+  addDocumentId(documentId) {
+    const shortDocumentId = this._nextId;
+    this._idToShortId.set(documentId, shortDocumentId);
+    this._documentIds.set(shortDocumentId, documentId);
+    this._documentCount += 1;
+    this._nextId += 1;
+    return shortDocumentId;
+  }
+  /**
+   * @ignore
+   */
+  addFields(fields) {
+    for (let i = 0; i < fields.length; i++) {
+      this._fieldIds[fields[i]] = i;
+    }
+  }
+  /**
+   * @ignore
+   */
+  addFieldLength(documentId, fieldId, count, length) {
+    let fieldLengths = this._fieldLength.get(documentId);
+    if (fieldLengths == null)
+      this._fieldLength.set(documentId, fieldLengths = []);
+    fieldLengths[fieldId] = length;
+    const averageFieldLength = this._avgFieldLength[fieldId] || 0;
+    const totalFieldLength = averageFieldLength * count + length;
+    this._avgFieldLength[fieldId] = totalFieldLength / (count + 1);
+  }
+  /**
+   * @ignore
+   */
+  removeFieldLength(documentId, fieldId, count, length) {
+    if (count === 1) {
+      this._avgFieldLength[fieldId] = 0;
+      return;
+    }
+    const totalFieldLength = this._avgFieldLength[fieldId] * count - length;
+    this._avgFieldLength[fieldId] = totalFieldLength / (count - 1);
+  }
+  /**
+   * @ignore
+   */
+  saveStoredFields(documentId, doc) {
+    const { storeFields, extractField } = this._options;
+    if (storeFields == null || storeFields.length === 0) {
+      return;
+    }
+    let documentFields = this._storedFields.get(documentId);
+    if (documentFields == null)
+      this._storedFields.set(documentId, documentFields = {});
+    for (const fieldName of storeFields) {
+      const fieldValue = extractField(doc, fieldName);
+      if (fieldValue !== void 0)
+        documentFields[fieldName] = fieldValue;
+    }
+  }
+};
+MiniSearch.wildcard = Symbol("*");
+var getOwnProperty = (object, property) => Object.prototype.hasOwnProperty.call(object, property) ? object[property] : void 0;
+var combinators = {
+  [OR]: (a, b) => {
+    for (const docId of b.keys()) {
+      const existing = a.get(docId);
+      if (existing == null) {
+        a.set(docId, b.get(docId));
+      } else {
+        const { score, terms, match } = b.get(docId);
+        existing.score = existing.score + score;
+        existing.match = Object.assign(existing.match, match);
+        assignUniqueTerms(existing.terms, terms);
+      }
+    }
+    return a;
+  },
+  [AND]: (a, b) => {
+    const combined = /* @__PURE__ */ new Map();
+    for (const docId of b.keys()) {
+      const existing = a.get(docId);
+      if (existing == null)
+        continue;
+      const { score, terms, match } = b.get(docId);
+      assignUniqueTerms(existing.terms, terms);
+      combined.set(docId, {
+        score: existing.score + score,
+        terms: existing.terms,
+        match: Object.assign(existing.match, match)
+      });
+    }
+    return combined;
+  },
+  [AND_NOT]: (a, b) => {
+    for (const docId of b.keys())
+      a.delete(docId);
+    return a;
+  }
+};
+var defaultBM25params = { k: 1.2, b: 0.7, d: 0.5 };
+var calcBM25Score = (termFreq, matchingCount, totalCount, fieldLength, avgFieldLength, bm25params) => {
+  const { k, b, d } = bm25params;
+  const invDocFreq = Math.log(1 + (totalCount - matchingCount + 0.5) / (matchingCount + 0.5));
+  return invDocFreq * (d + termFreq * (k + 1) / (termFreq + k * (1 - b + b * fieldLength / avgFieldLength)));
+};
+var termToQuerySpec = (options) => (term, i, terms) => {
+  const fuzzy = typeof options.fuzzy === "function" ? options.fuzzy(term, i, terms) : options.fuzzy || false;
+  const prefix = typeof options.prefix === "function" ? options.prefix(term, i, terms) : options.prefix === true;
+  const termBoost = typeof options.boostTerm === "function" ? options.boostTerm(term, i, terms) : 1;
+  return { term, fuzzy, prefix, termBoost };
+};
+var defaultOptions = {
+  idField: "id",
+  extractField: (document, fieldName) => document[fieldName],
+  stringifyField: (fieldValue, fieldName) => fieldValue.toString(),
+  tokenize: (text) => text.split(SPACE_OR_PUNCTUATION),
+  processTerm: (term) => term.toLowerCase(),
+  fields: void 0,
+  searchOptions: void 0,
+  storeFields: [],
+  logger: (level, message) => {
+    if (typeof (console === null || console === void 0 ? void 0 : console[level]) === "function")
+      console[level](message);
+  },
+  autoVacuum: true
+};
+var defaultSearchOptions = {
+  combineWith: OR,
+  prefix: false,
+  fuzzy: false,
+  maxFuzzy: 6,
+  boost: {},
+  weights: { fuzzy: 0.45, prefix: 0.375 },
+  bm25: defaultBM25params
+};
+var defaultAutoSuggestOptions = {
+  combineWith: AND,
+  prefix: (term, i, terms) => i === terms.length - 1
+};
+var defaultVacuumOptions = { batchSize: 1e3, batchWait: 10 };
+var defaultVacuumConditions = { minDirtFactor: 0.1, minDirtCount: 20 };
+var defaultAutoVacuumOptions = { ...defaultVacuumOptions, ...defaultVacuumConditions };
+var assignUniqueTerm = (target, term) => {
+  if (!target.includes(term))
+    target.push(term);
+};
+var assignUniqueTerms = (target, source) => {
+  for (const term of source) {
+    if (!target.includes(term))
+      target.push(term);
+  }
+};
+var byScore = ({ score: a }, { score: b }) => b - a;
+var createMap = () => /* @__PURE__ */ new Map();
+var objectToNumericMap = (object) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(object)) {
+    map.set(parseInt(key, 10), object[key]);
+  }
+  return map;
+};
+var objectToNumericMapAsync = async (object) => {
+  const map = /* @__PURE__ */ new Map();
+  let count = 0;
+  for (const key of Object.keys(object)) {
+    map.set(parseInt(key, 10), object[key]);
+    if (++count % 1e3 === 0) {
+      await wait(0);
+    }
+  }
+  return map;
+};
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var SPACE_OR_PUNCTUATION = /[\n\r\p{Z}\p{P}]+/u;
+
+// ../core/dist/index.js
+var rawDateSchema = z.object({
+  year: z.number(),
+  month: z.number().min(1).max(12),
+  day: z.number().min(1).max(31)
+});
+var rawCourseCodeSchema = z.object({
+  department: z.string(),
+  courseNumber: z.number(),
+  suffix: z.string(),
+  affiliation: z.string()
+});
+var rawScheduleSchema = z.object({
+  startTime: z.number(),
+  // seconds since midnight
+  endTime: z.number(),
+  days: z.array(z.string()),
+  locations: z.array(z.string())
+});
+var rawSectionSchema = z.object({
+  courseAreas: z.array(z.string()),
+  credits: z.number(),
+  permCount: z.number().default(0),
+  seatsTotal: z.number(),
+  seatsFilled: z.number(),
+  status: z.string(),
+  // O | C | R | U (keep raw; map to labels downstream)
+  startDate: rawDateSchema,
+  endDate: rawDateSchema,
+  instructors: z.array(z.object({ name: z.string() })),
+  course: z.object({
+    code: rawCourseCodeSchema,
+    title: z.string(),
+    description: z.string(),
+    primaryAssociation: z.string(),
+    potentialError: z.boolean().default(false)
+  }),
+  schedules: z.array(rawScheduleSchema),
+  potentialError: z.boolean().default(false),
+  identifier: z.object({
+    department: z.string(),
+    courseNumber: z.number(),
+    suffix: z.string(),
+    affiliation: z.string(),
+    sectionNumber: z.number(),
+    year: z.number(),
+    term: z.string(),
+    // FA | SP | SU
+    half: z.nullable(z.object({ prefix: z.string(), number: z.number() }))
+  })
+});
+var rawSectionsSchema = z.array(rawSectionSchema);
+var rawHistoryEntrySchema = z.object({
+  code: rawCourseCodeSchema,
+  terms: z.array(z.object({ year: z.number(), term: z.string() }))
+});
+var rawHistorySchema = z.array(rawHistoryEntrySchema);
+var rawTermSchema = z.object({ year: z.number(), term: z.string() });
+var rawCourseAreaSchema = z.object({
+  area: z.string(),
+  description: z.string()
+});
+var termSchema = z.string().regex(/^(FA|SP|SU)\d{4}$/, "Term must look like FA2026");
+var daySchema = z.enum(["M", "T", "W", "R", "F", "S", "U"]);
+var statusSchema = z.enum(["O", "C", "R", "U"]);
+var meetingSchema = z.object({
+  days: z.array(daySchema),
+  startMin: z.number(),
+  // minutes since midnight (math)
+  endMin: z.number(),
+  startStr: z.string(),
+  // "13:15" (quote)
+  endStr: z.string(),
+  start12: z.string(),
+  // "1:15 PM" (display)
+  end12: z.string(),
+  locations: z.array(z.string())
+});
+var sectionSchema = z.object({
+  id: z.string(),
+  // "CSCI 051 PO-01 FA2026" (canonical, frozen v1)
+  term: termSchema,
+  year: z.number(),
+  termCode: z.enum(["FA", "SP", "SU"]),
+  half: z.nullable(z.object({ prefix: z.string(), number: z.number() })),
+  dept: z.string(),
+  number: z.number(),
+  suffix: z.string(),
+  school: z.string(),
+  // affiliation, uppercase (PO/CM/HM/SC/PZ + KS/JP/…)
+  sectionNo: z.number(),
+  code: z.string(),
+  // "CSCI 051" (dept + zero-padded + suffix, no school)
+  title: z.string(),
+  description: z.string(),
+  areas: z.array(z.string()),
+  instructors: z.array(z.string()),
+  meetings: z.array(meetingSchema),
+  credits: z.number(),
+  status: statusSchema,
+  statusLabel: z.string(),
+  // Open | Closed | Reopened | Unknown
+  seats: z.object({
+    filled: z.number(),
+    total: z.number(),
+    available: z.number(),
+    permCount: z.number()
+  }),
+  startDate: z.string(),
+  // ISO
+  endDate: z.string(),
+  potentialError: z.boolean(),
+  primaryAssociation: z.string(),
+  affiliation: z.string()
+});
+var cacheMetaSchema = z.object({
+  term: z.string(),
+  fetched_at: z.string(),
+  etag: z.string().nullable(),
+  hash: z.string(),
+  count: z.number(),
+  source_url: z.string(),
+  ttl_kind: z.string(),
+  stale: z.boolean(),
+  source: z.enum(["live", "stale-cache", "offline-file"]),
+  quarantined: z.number().int().nonnegative().default(0),
+  // Sections dropped because a later row produced the same canonical ID
+  // (e.g. two half-semester rows collapsing onto one ID). Surfaced, never silent.
+  duplicate_ids: z.number().int().nonnegative().optional()
+});
+var DEFAULT_API_BASE = "https://banana.hyperschedule.io/v4";
+var USER_AGENT = "5C-Index/0.1 (+research/edu; cache 60s)";
+function apiBase() {
+  const override = process.env.FIVE_C_API_BASE?.trim();
+  return override ? override.replace(/\/+$/, "") : DEFAULT_API_BASE;
+}
+async function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function fetchJson(url, validate, opts = {}, fetchFn = globalThis.fetch) {
+  const { etag, timeoutMs = 15e3, retries = 3 } = opts;
+  let lastErr = null;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+      const res = await fetchFn(url, {
+        signal: ctrl.signal,
+        headers: {
+          Accept: "application/json",
+          "User-Agent": USER_AGENT,
+          ...etag ? { "If-None-Match": etag } : {}
+        }
+      });
+      if (res.status === 304) {
+        clearTimeout(timer);
+        return { data: void 0, etag: etag ?? null, notModified: true };
+      }
+      if (res.status === 404) {
+        const err = new Error(`Not found: ${url}`);
+        err.code = "E_NOT_FOUND_UPSTREAM";
+        throw err;
+      }
+      if (res.status === 429 || res.status >= 500) {
+        const retryAfter = res.headers.get("Retry-After");
+        const wait2 = retryAfter ? Math.min(Number.parseInt(retryAfter, 10) * 1e3 || 2e3, 15e3) : Math.min(500 * 2 ** attempt + Math.random() * 250, 8e3);
+        lastErr = new Error(`Upstream ${res.status} for ${url}`);
+        if (attempt < retries) {
+          clearTimeout(timer);
+          await sleep(wait2);
+          continue;
+        }
+        throw lastErr;
+      }
+      if (!res.ok) {
+        const err = new Error(`Upstream ${res.status} for ${url}`);
+        err.code = "E_FETCH";
+        throw err;
+      }
+      const json = await res.json();
+      clearTimeout(timer);
+      return {
+        data: validate(json),
+        etag: res.headers.get("ETag"),
+        notModified: false
+      };
+    } catch (err) {
+      clearTimeout(timer);
+      if (err.code === "E_NOT_FOUND_UPSTREAM") throw err;
+      if (err.name === "AbortError") {
+        lastErr = new Error(`Timeout fetching ${url}`);
+      } else {
+        lastErr = err;
+      }
+      if (attempt < retries && (!err.code || err.code === "E_FETCH")) {
+        if (err.code === "E_FETCH") throw err;
+        await sleep(Math.min(500 * 2 ** attempt + Math.random() * 250, 8e3));
+        continue;
+      }
+      throw lastErr;
+    }
+  }
+  throw lastErr;
+}
+function fetchAllTerms(opts, fetchFn) {
+  return fetchJson(
+    `${apiBase()}/term/all`,
+    (u) => rawTermSchema.array().parse(u),
+    opts,
+    fetchFn
+  );
+}
+function fetchCurrentTerm(opts, fetchFn) {
+  return fetchJson(
+    `${apiBase()}/term/current`,
+    (u) => rawTermSchema.parse(u),
+    opts,
+    fetchFn
+  );
+}
+function fetchOfferingHistory(term, opts, fetchFn) {
+  return fetchJson(
+    `${apiBase()}/offering-history/${term}`,
+    (u) => rawHistorySchema.parse(u),
+    opts,
+    fetchFn
+  );
+}
+var SCHOOL_ALIASES = {
+  pomona: "PO",
+  "pomona college": "PO",
+  po: "PO",
+  // Registrar data uses CM (not CMC) — all Claremont McKenna inputs map to CM.
+  cm: "CM",
+  cmc: "CM",
+  "claremont mckenna": "CM",
+  "claremont mckenna college": "CM",
+  mckenna: "CM",
+  "harvey mudd": "HM",
+  "harvey mudd college": "HM",
+  mudd: "HM",
+  hmc: "HM",
+  hm: "HM",
+  scripps: "SC",
+  "scripps college": "SC",
+  sc: "SC",
+  pitzer: "PZ",
+  "pitzer college": "PZ",
+  pz: "PZ",
+  cgu: "CG",
+  cg: "CG",
+  keck: "KS",
+  ks: "KS"
+};
+function normalizeSchool(input) {
+  const key = input.trim().toLowerCase();
+  if (SCHOOL_ALIASES[key]) return SCHOOL_ALIASES[key];
+  return input.trim().toUpperCase();
+}
+var DISTINCTIVE_SCHOOL_WORDS = {
+  mudd: "HM",
+  hmc: "HM",
+  pomona: "PO",
+  pitzer: "PZ",
+  scripps: "SC",
+  mckenna: "CM",
+  cmc: "CM",
+  keck: "KS"
+};
+function detectSchoolMention(text) {
+  const words = text.toLowerCase().split(/[^a-z]+/).filter(Boolean);
+  for (const w of words) {
+    const hit = DISTINCTIVE_SCHOOL_WORDS[w];
+    if (hit) return hit;
+  }
+  return null;
+}
+function secToMin(sec) {
+  return Math.floor(sec / 60);
+}
+function minToStr(min) {
+  const h = Math.floor(min / 60);
+  const m = min % 60;
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+}
+function minTo12(min) {
+  const h24 = Math.floor(min / 60);
+  const m = min % 60;
+  const suffix = h24 >= 12 ? "PM" : "AM";
+  const h12 = h24 % 12 === 0 ? 12 : h24 % 12;
+  return `${h12}:${String(m).padStart(2, "0")} ${suffix}`;
+}
+function sectionId(args) {
+  const num = String(args.number).padStart(3, "0");
+  const sec = String(args.sectionNo).padStart(2, "0");
+  return `${args.dept.toUpperCase()} ${num}${args.suffix.toUpperCase()} ${args.school.toUpperCase()}-${sec} ${args.term.toUpperCase()}`;
+}
+function courseCode(dept, number, suffix) {
+  return `${dept.toUpperCase()} ${String(number).padStart(3, "0")}${suffix.toUpperCase()}`;
+}
+var CODE_RE = /^([A-Za-z]{2,4})?\s*(\d{1,3}[A-Za-z]?)?(?:\s*[- ]?\s*([A-Za-z]{2}))?(?:\s*[- ]?\s*0?(\d{1,2}))?\s*$/;
+var TERM_RE = /\b((?:FA|SP|SU)\s*\d{2,4}|(?:Fall|Spring|Summer)\s*\d{2,4}|\d{4}\s*(?:FA|SP|SU))\b/i;
+function parseCode(input) {
+  const out = {};
+  let rest = input.trim();
+  const termMatch = rest.match(TERM_RE);
+  if (termMatch) {
+    const normalized = normalizeTerm(termMatch[1]);
+    if (normalized) out.term = normalized;
+    rest = rest.replace(termMatch[0], " ").trim();
+  }
+  const m = rest.match(CODE_RE);
+  if (!m || !m[1] && !m[2]) return out;
+  if (m[1]) out.dept = m[1].toUpperCase();
+  if (m[2]) {
+    const numPart = m[2].match(/^(\d+)([A-Za-z]?)$/);
+    if (numPart) {
+      out.number = Number.parseInt(numPart[1], 10);
+      out.numberRaw = numPart[1];
+      if (numPart[2]) out.suffix = numPart[2].toUpperCase();
+    }
+  }
+  if (m[3]) out.school = normalizeSchool(m[3]);
+  if (m[4]) out.sectionNo = Number.parseInt(m[4], 10);
+  return out;
+}
+function normalizeTerm(input) {
+  const t = input.trim().toUpperCase().replace(/[\s;_-]+/g, "");
+  const seasonMap = {
+    FA: "FA",
+    F: "FA",
+    FALL: "FA",
+    SP: "SP",
+    S: "SP",
+    SPRING: "SP",
+    P: "SP",
+    SU: "SU",
+    SUMMER: "SU",
+    U: "SU"
+  };
+  let m = t.match(/^(FA|SP|SU|FALL|SPRING|SUMMER|F|S|P|U)(\d{2}|\d{4})$/);
+  if (m) {
+    const season = seasonMap[m[1]];
+    const year = m[2].length === 2 ? `20${m[2]}` : m[2];
+    return `${season}${year}`;
+  }
+  m = t.match(/^(\d{4})(FA|SP|SU|FALL|SPRING|SUMMER)$/);
+  if (m) {
+    const season = m[2] === "FALL" ? "FA" : m[2] === "SPRING" ? "SP" : m[2] === "SUMMER" ? "SU" : m[2];
+    return `${season}${m[1]}`;
+  }
+  m = t.match(/^(\d{4})(FA|SP|SU)$/);
+  if (m) return `${m[2]}${m[1]}`;
+  return null;
+}
+function termLabel(term) {
+  const m = term.match(/^(FA|SP|SU)(\d{4})$/);
+  if (!m) return term;
+  const season = m[1] === "FA" ? "Fall" : m[1] === "SP" ? "Spring" : "Summer";
+  return `${season} ${m[2]}`;
+}
+function isRegistrable(status) {
+  return status === "O" || status === "R";
+}
+var SEASON_ORDER = { SP: 0, SU: 1, FA: 2 };
+function termRecency(term) {
+  const m = term.match(/^(FA|SP|SU)(\d{4})$/);
+  if (!m) return Number.NaN;
+  return Number(m[2]) * 10 + (SEASON_ORDER[m[1]] ?? 0);
+}
+function compareTermRecencyDesc(a, b) {
+  const ra = termRecency(a);
+  const rb = termRecency(b);
+  if (Number.isNaN(ra) && Number.isNaN(rb)) return a.localeCompare(b);
+  if (Number.isNaN(ra)) return 1;
+  if (Number.isNaN(rb)) return -1;
+  return rb - ra;
+}
+var DAY_ALIASES = {
+  M: "M",
+  MON: "M",
+  T: "T",
+  TU: "T",
+  TUE: "T",
+  W: "W",
+  WED: "W",
+  R: "R",
+  TH: "R",
+  THU: "R",
+  F: "F",
+  FRI: "F",
+  S: "S",
+  SA: "S",
+  SAT: "S",
+  U: "U",
+  SU: "U",
+  SUN: "U"
+};
+function normalizeDays(input) {
+  const t = input.trim().toUpperCase();
+  if (t === "DAILY" || t === "WEEKDAYS") return ["M", "T", "W", "R", "F"];
+  if (t === "WEEKENDS") return ["S", "U"];
+  if (t === "ANY") return [];
+  const cleaned = t.replace(/[^A-Z]/g, " ");
+  const tokens = cleaned.split(/\s+/).filter(Boolean);
+  const out = [];
+  for (const tok of tokens) {
+    let rest = tok;
+    const matched = [];
+    let ok = true;
+    while (rest.length > 0) {
+      const three = DAY_ALIASES[rest.slice(0, 3)];
+      const two = DAY_ALIASES[rest.slice(0, 2)];
+      const one = DAY_ALIASES[rest.slice(0, 1)];
+      if (three && rest.length >= 3 && ["MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"].includes(
+        rest.slice(0, 3)
+      )) {
+        matched.push(three);
+        rest = rest.slice(3);
+      } else if (two && ["TU", "TH", "SA", "SU", "MO", "WE", "FR"].includes(rest.slice(0, 2))) {
+        matched.push(two);
+        rest = rest.slice(2);
+      } else if (one) {
+        matched.push(one);
+        rest = rest.slice(1);
+      } else {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) return null;
+    out.push(...matched);
+  }
+  const order = ["M", "T", "W", "R", "F", "S", "U"];
+  const unique = [...new Set(out)].sort(
+    (a, b) => order.indexOf(a) - order.indexOf(b)
+  );
+  return unique.length === 0 ? null : unique;
+}
+function parseTime(input) {
+  let t = input.trim().toLowerCase();
+  t = t.replace(/^(after|before|at|around)\s+/, "");
+  if (t === "morning" || t === "mornings") return 8 * 60;
+  if (t === "afternoon" || t === "afternoons") return 12 * 60;
+  if (t === "evening" || t === "evenings" || t === "night") return 17 * 60;
+  if (t === "noon") return 12 * 60;
+  if (t === "midnight") return 0;
+  const m = t.match(/^(\d{1,4})(?::(\d{2}))?\s*([ap])\.?m?\.?$/);
+  if (m) {
+    let h;
+    let min = m[2] ? Number.parseInt(m[2], 10) : 0;
+    if (m[1].length > 2 && !m[2]) {
+      h = Number.parseInt(m[1].slice(0, -2), 10);
+      min = Number.parseInt(m[1].slice(-2), 10);
+    } else {
+      h = Number.parseInt(m[1], 10);
+    }
+    const ap = m[3];
+    if (h < 1 || h > 12 || min > 59) return null;
+    if (ap === "p" && h !== 12) h += 12;
+    if (ap === "a" && h === 12) h = 0;
+    return h * 60 + min;
+  }
+  const m24 = t.match(/^(\d{1,2})(?::(\d{2}))?$/);
+  if (m24) {
+    const h = Number.parseInt(m24[1], 10);
+    const min = m24[2] ? Number.parseInt(m24[2], 10) : 0;
+    if (h > 23 || min > 59) return null;
+    return h * 60 + min;
+  }
+  const m4 = t.match(/^(\d{3,4})$/);
+  if (m4) {
+    const h = Number.parseInt(m4[1].slice(0, -2), 10);
+    const min = Number.parseInt(m4[1].slice(-2), 10);
+    if (h > 23 || min > 59) return null;
+    return h * 60 + min;
+  }
+  return null;
+}
+var STATUS_LABELS = {
+  O: "Open",
+  C: "Closed",
+  R: "Reopened",
+  U: "Unknown"
+};
+function toISO(d) {
+  const mm = String(d.month).padStart(2, "0");
+  const dd = String(d.day).padStart(2, "0");
+  return `${d.year}-${mm}-${dd}`;
+}
+var VALID_DAYS = /* @__PURE__ */ new Set(["M", "T", "W", "R", "F", "S", "U"]);
+function normalizeSection(raw) {
+  const id = raw.identifier;
+  const term = `${id.term}${id.year}`;
+  const school = id.affiliation.toUpperCase();
+  const status = ["O", "C", "R", "U"].includes(raw.status) ? raw.status : "U";
+  const meetings = [];
+  let droppedMeetings = false;
+  for (const s of raw.schedules.filter(
+    (x) => !(x.startTime === 0 && x.endTime === 0 && x.days.length === 0)
+  )) {
+    const startMin = secToMin(s.startTime);
+    const endMin = secToMin(s.endTime);
+    if (endMin <= startMin) {
+      droppedMeetings = true;
+      continue;
+    }
+    meetings.push({
+      days: s.days.filter((d) => VALID_DAYS.has(d)),
+      startMin,
+      endMin,
+      startStr: minToStr(startMin),
+      endStr: minToStr(endMin),
+      start12: minTo12(startMin),
+      end12: minTo12(endMin),
+      locations: s.locations.map((l) => l.trim()).filter((l) => l.length > 0)
+    });
+  }
+  const available = Math.max(0, raw.seatsTotal - raw.seatsFilled);
+  return {
+    id: sectionId({
+      dept: id.department,
+      number: id.courseNumber,
+      suffix: id.suffix,
+      school,
+      sectionNo: id.sectionNumber,
+      term
+    }),
+    term,
+    year: id.year,
+    termCode: ["FA", "SP", "SU"].includes(id.term) ? id.term : "FA",
+    half: id.half,
+    dept: id.department.toUpperCase(),
+    number: id.courseNumber,
+    suffix: id.suffix.toUpperCase(),
+    school,
+    sectionNo: id.sectionNumber,
+    code: courseCode(id.department, id.courseNumber, id.suffix),
+    title: raw.course.title,
+    description: raw.course.description,
+    areas: raw.courseAreas,
+    instructors: raw.instructors.map((i) => i.name.replace(/\s+/g, " ").trim()),
+    meetings,
+    credits: raw.credits,
+    status,
+    statusLabel: STATUS_LABELS[status] ?? "Unknown",
+    seats: {
+      filled: raw.seatsFilled,
+      total: raw.seatsTotal,
+      available,
+      permCount: raw.permCount
+    },
+    startDate: toISO(raw.startDate),
+    endDate: toISO(raw.endDate),
+    potentialError: raw.potentialError || raw.course.potentialError || droppedMeetings,
+    primaryAssociation: raw.course.primaryAssociation,
+    affiliation: school
+  };
+}
+var SEAT_TTL_MS = 6e4;
+var SCHEDULE_TTL_MS = 30 * 6e4;
+var HISTORY_TTL_MS = 24 * 60 * 6e4;
+var CURRENT_TERM_TTL_MS = 5 * 6e4;
+var NEGATIVE_TTL_MS = 5 * 6e4;
+var HISTORY_MEM_CAP = 8;
+function cacheDir() {
+  const override = process.env.FIVE_C_DATA_DIR ?? process.env.FIVE_C_CACHE_DIR ?? null;
+  return override ?? join(homedir(), ".5c-index", "cache");
+}
+function files(term) {
+  const dir = cacheDir();
+  return {
+    dir,
+    data: join(dir, `${term}.json`),
+    meta: join(dir, `${term}.meta.json`),
+    history: join(dir, `${term}.history.json`),
+    neg: join(dir, `${term}.neg.json`)
+  };
+}
+function currentTermFile() {
+  return join(cacheDir(), "current-term.json");
+}
+function sha1(s) {
+  return createHash("sha1").update(s).digest("hex");
+}
+var mem = /* @__PURE__ */ new Map();
+var memHistory = /* @__PURE__ */ new Map();
+var negative = /* @__PURE__ */ new Map();
+var inflightRefresh = /* @__PURE__ */ new Map();
+var inflightHistory = /* @__PURE__ */ new Map();
+var currentTermMem = null;
+function getCurrentTermMem() {
+  return currentTermMem;
+}
+function setCurrentTermMem(value, at) {
+  currentTermMem = { value, at };
+}
+function isStale(meta) {
+  const t = Date.parse(meta.fetched_at);
+  if (!Number.isFinite(t)) return true;
+  const age = Date.now() - t;
+  if (!Number.isFinite(age) || age < 0) return true;
+  return age > SEAT_TTL_MS;
+}
+function historyIsStale(fetched_at) {
+  const t = Date.parse(fetched_at);
+  if (!Number.isFinite(t)) return true;
+  const age = Date.now() - t;
+  if (!Number.isFinite(age) || age < 0) return true;
+  return age > HISTORY_TTL_MS;
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function atomicWrite(path, content) {
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  await writeFile(tmp, content);
+  try {
+    const fh = await open(tmp, "r");
+    try {
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+    await rename(tmp, path);
+  } catch {
+    try {
+      await unlink(tmp);
+    } catch {
+    }
+    throw new Error(`Atomic write failed for ${path}`);
+  }
+}
+function countTolerance(metaCount) {
+  return Math.max(10, Math.floor(metaCount * 0.1));
+}
+function validateSnapshot(sections, meta) {
+  const m = cacheMetaSchema.safeParse(meta);
+  if (!m.success) return null;
+  const s = sectionSchema.array().safeParse(sections);
+  if (!s.success) return null;
+  if (s.data.length === 0) return null;
+  if (Math.abs(s.data.length - m.data.count) > countTolerance(m.data.count)) {
+    return null;
+  }
+  return { sections: s.data, meta: m.data };
+}
+function quarantineRawSections(data) {
+  const whole = rawSectionsSchema.safeParse(data);
+  if (whole.success) return { raw: whole.data, quarantined: 0 };
+  if (!Array.isArray(data)) return { raw: [], quarantined: 0 };
+  const good = [];
+  let quarantined = 0;
+  for (const item of data) {
+    const r = rawSectionSchema.safeParse(item);
+    if (r.success) good.push(r.data);
+    else quarantined++;
+  }
+  return { raw: good, quarantined };
+}
+async function readSnapshot(T) {
+  const f = files(T);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    let metaRaw;
+    let dataRaw;
+    try {
+      metaRaw = await readFile(f.meta, "utf8");
+      dataRaw = await readFile(f.data, "utf8");
+    } catch {
+      return null;
+    }
+    let metaParsed;
+    try {
+      metaParsed = JSON.parse(metaRaw);
+    } catch {
+      return null;
+    }
+    const meta = metaParsed;
+    if (typeof meta?.hash === "string" && sha1(dataRaw) !== meta.hash) {
+      if (attempt === 0) {
+        await sleep2(50);
+        continue;
+      }
+      return null;
+    }
+    let sectionsRaw;
+    try {
+      sectionsRaw = JSON.parse(dataRaw);
+    } catch {
+      return null;
+    }
+    return validateSnapshot(sectionsRaw, metaParsed);
+  }
+  return null;
+}
+async function loadTerm(term, opts = {}) {
+  const T = term.toUpperCase();
+  const cached = mem.get(T);
+  if (cached) {
+    if (cached.sections.length === 0) {
+      mem.delete(T);
+    } else if (!isStale(cached.meta)) {
+      return cached;
+    }
+  }
+  const disk = await readSnapshot(T);
+  if (disk) {
+    disk.meta.stale = isStale(disk.meta);
+    disk.meta.source = disk.meta.stale ? "stale-cache" : "live";
+    mem.set(T, disk);
+    if (disk.meta.stale && opts.allowStale !== false) {
+      void refreshTerm(T, { fetchFn: opts.fetchFn }).catch(() => {
+      });
+      return disk;
+    }
+    if (!disk.meta.stale) return disk;
+  } else {
+    const staleMem = mem.get(T);
+    if (staleMem && staleMem.sections.length > 0 && opts.allowStale !== false) {
+      staleMem.meta.stale = true;
+      staleMem.meta.source = "stale-cache";
+      void refreshTerm(T, { fetchFn: opts.fetchFn }).catch(() => {
+      });
+      return staleMem;
+    }
+  }
+  return refreshTerm(T, { fetchFn: opts.fetchFn });
+}
+async function readNegative(T) {
+  const f = files(T);
+  try {
+    const raw = await readFile(f.neg, "utf8");
+    const at = JSON.parse(raw).at;
+    if (typeof at === "number" && Number.isFinite(at)) {
+      if (Date.now() - at < NEGATIVE_TTL_MS) {
+        negative.set(T, at);
+        return at;
+      }
+      void unlink(f.neg).catch(() => {
+      });
+      negative.delete(T);
+      return null;
+    }
+  } catch {
+  }
+  const memAt = negative.get(T);
+  if (memAt !== void 0) {
+    if (Date.now() - memAt < NEGATIVE_TTL_MS) return memAt;
+    negative.delete(T);
+  }
+  return null;
+}
+async function writeNegative(T) {
+  const at = Date.now();
+  negative.set(T, at);
+  try {
+    const f = files(T);
+    await mkdir(f.dir, { recursive: true });
+    await atomicWrite(f.neg, JSON.stringify({ at }));
+  } catch {
+  }
+}
+async function clearNegative(T) {
+  negative.delete(T);
+  try {
+    await unlink(files(T).neg);
+  } catch {
+  }
+}
+function termNotFound(T) {
+  return Object.assign(new Error(`Term ${T} not available upstream (404)`), {
+    code: "E_TERM_NOT_FOUND"
+  });
+}
+async function refreshTerm(term, opts = {}) {
+  const T = term.toUpperCase();
+  if (!opts.force) {
+    const neg = await readNegative(T);
+    if (neg !== null) {
+      throw Object.assign(
+        new Error(`Term ${T} recently 404'd upstream; retry shortly`),
+        { code: "E_TERM_NOT_FOUND" }
+      );
+    }
+  }
+  const key = opts.force ? `${T}:force` : T;
+  const inflight = inflightRefresh.get(key);
+  if (inflight) return inflight;
+  const p = refreshTermInner(T, opts).then((entry) => {
+    inflightRefresh.delete(key);
+    return entry;
+  }).catch((err) => {
+    inflightRefresh.delete(key);
+    throw err;
+  });
+  inflightRefresh.set(key, p);
+  return p;
+}
+async function refreshTermInner(T, opts) {
+  const f = files(T);
+  let prevEtag = null;
+  try {
+    const metaRaw = await readFile(f.meta, "utf8");
+    prevEtag = JSON.parse(metaRaw).etag ?? null;
+  } catch {
+  }
+  async function doFetch(etag) {
+    return fetchJson(
+      `${apiBase()}/sections/${T}`,
+      (u) => u,
+      { etag: opts.force ? null : etag },
+      opts.fetchFn
+    );
+  }
+  let res;
+  try {
+    res = await doFetch(prevEtag);
+  } catch (err) {
+    if (err.code === "E_NOT_FOUND_UPSTREAM") {
+      await writeNegative(T);
+      const disk2 = await readSnapshot(T);
+      if (disk2) {
+        disk2.meta.stale = true;
+        disk2.meta.source = "offline-file";
+        mem.set(T, disk2);
+        return disk2;
+      }
+      throw termNotFound(T);
+    }
+    const disk = await readSnapshot(T);
+    if (disk) {
+      disk.meta.stale = true;
+      disk.meta.source = "offline-file";
+      mem.set(T, disk);
+      return disk;
+    }
+    throw err;
+  }
+  if (res === void 0 || res.notModified) {
+    const disk = await readSnapshot(T);
+    if (!disk) {
+      try {
+        res = await doFetch(null);
+      } catch (err) {
+        if (err.code === "E_NOT_FOUND_UPSTREAM") {
+          await writeNegative(T);
+          throw termNotFound(T);
+        }
+        throw err;
+      }
+      if (res === void 0 || res.notModified) {
+        throw termNotFound(T);
+      }
+      return persistFresh(T, res.data, res.etag);
+    }
+    disk.meta.fetched_at = nowISO();
+    disk.meta.stale = false;
+    disk.meta.source = "live";
+    await atomicWrite(f.meta, JSON.stringify(disk.meta, null, 1));
+    mem.set(T, disk);
+    return disk;
+  }
+  return persistFresh(T, res.data, res.etag);
+}
+async function persistFresh(T, data, etag) {
+  const f = files(T);
+  const { raw, quarantined } = quarantineRawSections(data);
+  if (raw.length === 0) {
+    const disk = await readSnapshot(T);
+    if (disk) {
+      disk.meta.stale = true;
+      disk.meta.source = "offline-file";
+      mem.set(T, disk);
+      return disk;
+    }
+    throw Object.assign(
+      new Error(`Upstream payload for term ${T} contained no usable sections`),
+      { code: "E_FETCH" }
+    );
+  }
+  const sections = raw.map(normalizeSection).filter((s) => s.term === T);
+  if (sections.length === 0) {
+    const disk = await readSnapshot(T);
+    if (disk) {
+      disk.meta.stale = true;
+      disk.meta.source = "offline-file";
+      mem.set(T, disk);
+      return disk;
+    }
+    throw Object.assign(
+      new Error(`No sections for term ${T} after term filter`),
+      { code: "E_FETCH" }
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  let duplicateIds = 0;
+  for (const s of sections) {
+    if (seen.has(s.id)) {
+      duplicateIds++;
+      continue;
+    }
+    seen.add(s.id);
+    deduped.push(s);
+  }
+  const prevDisk = await readSnapshot(T);
+  if (prevDisk) {
+    const total = raw.length + quarantined;
+    const badRatio = total > 0 ? quarantined / total : 0;
+    const droppedBelowHalf = deduped.length < Math.ceil(prevDisk.sections.length / 2);
+    if (quarantined >= 10 && badRatio > 0.05 || droppedBelowHalf) {
+      prevDisk.meta.stale = true;
+      prevDisk.meta.source = "offline-file";
+      mem.set(T, prevDisk);
+      throw Object.assign(
+        new Error(
+          `Refusing snapshot for ${T}: ${quarantined} quarantined row(s), count ${prevDisk.sections.length} \u2192 ${deduped.length}. Keeping last-good snapshot.`
+        ),
+        { code: "E_FETCH" }
+      );
+    }
+  }
+  const dataText = JSON.stringify(deduped);
+  const meta = {
+    term: T,
+    fetched_at: nowISO(),
+    etag,
+    hash: sha1(dataText),
+    count: deduped.length,
+    source_url: `${apiBase()}/sections/${T}`,
+    ttl_kind: "seats:60s/schedules:30min",
+    stale: false,
+    source: "live",
+    quarantined,
+    duplicate_ids: duplicateIds
+  };
+  await mkdir(f.dir, { recursive: true });
+  await atomicWrite(f.data, dataText);
+  await atomicWrite(f.meta, JSON.stringify(meta, null, 1));
+  const entry = { sections: deduped, meta };
+  mem.set(T, entry);
+  await clearNegative(T);
+  try {
+    if (currentTermMem?.value === T) {
+      await writeCurrentTermFile(T);
+    } else {
+      const cur = await readCurrentTermFile();
+      if (cur?.value === T) await writeCurrentTermFile(T);
+    }
+  } catch {
+  }
+  return entry;
+}
+async function readCurrentTermFile() {
+  try {
+    const raw = await readFile(currentTermFile(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.value !== "string" || !/^(FA|SP|SU)\d{4}$/.test(parsed.value) || typeof parsed?.at !== "number" || !Number.isFinite(parsed.at)) {
+      return null;
+    }
+    return { value: parsed.value, at: parsed.at };
+  } catch {
+    return null;
+  }
+}
+async function writeCurrentTermFile(value) {
+  const payload = { value, at: Date.now() };
+  try {
+    await mkdir(cacheDir(), { recursive: true });
+    await atomicWrite(currentTermFile(), JSON.stringify(payload));
+  } catch {
+  }
+  setCurrentTermMem(payload.value, payload.at);
+  return payload;
+}
+function memHistorySet(T, payload) {
+  memHistory.delete(T);
+  memHistory.set(T, payload);
+  while (memHistory.size > HISTORY_MEM_CAP) {
+    const oldest = memHistory.keys().next();
+    if (oldest.done) break;
+    memHistory.delete(oldest.value);
+  }
+}
+async function loadHistory(term, opts = {}) {
+  const T = term.toUpperCase();
+  const cached = memHistory.get(T);
+  if (cached && !historyIsStale(cached.fetched_at)) {
+    memHistory.delete(T);
+    memHistory.set(T, cached);
+    return { ...cached, stale: false };
+  }
+  const inflight = inflightHistory.get(T);
+  if (inflight) return inflight;
+  const p = loadHistoryInner(T, opts, cached ?? null).then((entry) => {
+    inflightHistory.delete(T);
+    return entry;
+  }).catch((err) => {
+    inflightHistory.delete(T);
+    throw err;
+  });
+  inflightHistory.set(T, p);
+  return p;
+}
+async function loadHistoryInner(T, opts, staleMem) {
+  const f = files(T);
+  let staleDisk = null;
+  try {
+    const raw = await readFile(f.history, "utf8");
+    const parsed = JSON.parse(raw);
+    const entries = rawHistorySchema.safeParse(parsed?.entries);
+    if (entries.success && typeof parsed?.fetched_at === "string" && !historyIsStale(parsed.fetched_at)) {
+      const payload = { entries: entries.data, fetched_at: parsed.fetched_at };
+      memHistorySet(T, payload);
+      return { ...payload, stale: false };
+    }
+    if (entries.success && typeof parsed?.fetched_at === "string") {
+      staleDisk = { entries: entries.data, fetched_at: parsed.fetched_at };
+    }
+  } catch {
+  }
+  try {
+    const res = await fetchOfferingHistory(T, {}, opts.fetchFn);
+    const entries = rawHistorySchema.parse(res.data);
+    const payload = { entries, fetched_at: nowISO() };
+    await mkdir(f.dir, { recursive: true });
+    await atomicWrite(f.history, JSON.stringify(payload));
+    memHistorySet(T, payload);
+    return { ...payload, stale: false };
+  } catch (err) {
+    if (staleMem) {
+      memHistorySet(T, staleMem);
+      return { ...staleMem, stale: true };
+    }
+    if (staleDisk) {
+      memHistorySet(T, staleDisk);
+      return { ...staleDisk, stale: true };
+    }
+    if (err.code === "E_NOT_FOUND_UPSTREAM") {
+      throw termNotFound(T);
+    }
+    throw err;
+  }
+}
+var WALK = {
+  PO: { PO: 0, SC: 5, CM: 8, HM: 10, PZ: 12 },
+  SC: { PO: 5, SC: 0, CM: 5, HM: 8, PZ: 10 },
+  CM: { PO: 8, SC: 5, CM: 0, HM: 6, PZ: 8 },
+  HM: { PO: 10, SC: 8, CM: 6, HM: 0, PZ: 5 },
+  PZ: { PO: 12, SC: 10, CM: 8, HM: 5, PZ: 0 }
+};
+function walkNeed(a, b) {
+  if (a === "BLOCK" || b === "BLOCK") return 0;
+  return WALK[a]?.[b] ?? (a === b ? 0 : 10);
+}
+function meetingsOverlap(a, b) {
+  if (!a.days.some((d) => b.days.includes(d))) return false;
+  return a.startMin < b.endMin && b.startMin < a.endMin;
+}
+function overlapMinutes(a, b) {
+  if (!a.days.some((d) => b.days.includes(d))) return 0;
+  return Math.max(
+    0,
+    Math.min(a.endMin, b.endMin) - Math.max(a.startMin, b.startMin)
+  );
+}
+function dateOverlap(a, b) {
+  if (!a.half && !b.half) return true;
+  return a.startDate <= b.endDate && b.startDate <= a.endDate;
+}
+function sectionsOverlap(a, b) {
+  if (!dateOverlap(a, b)) return false;
+  for (const ma of a.meetings) {
+    for (const mb of b.meetings) {
+      if (meetingsOverlap(ma, mb)) return true;
+    }
+  }
+  return false;
+}
+function findConflicts(sections, passingMinutes = 10) {
+  const conflicts = [];
+  const warnings = [];
+  for (let i = 0; i < sections.length; i++) {
+    for (let j = i + 1; j < sections.length; j++) {
+      const a = sections[i];
+      const b = sections[j];
+      if (a.meetings.length === 0 || b.meetings.length === 0) {
+        warnings.push(
+          `Time TBA for ${a.meetings.length === 0 ? a.id : b.id}; skipped in conflict check.`
+        );
+        continue;
+      }
+      if (!dateOverlap(a, b)) continue;
+      for (const ma of a.meetings) {
+        for (const mb of b.meetings) {
+          const common = ma.days.filter((d) => mb.days.includes(d));
+          if (common.length === 0) continue;
+          const ov = overlapMinutes(ma, mb);
+          if (ov > 0) {
+            const start = Math.max(ma.startMin, mb.startMin);
+            const end = Math.min(ma.endMin, mb.endMin);
+            conflicts.push({
+              a: a.id,
+              b: b.id,
+              days: common,
+              overlap: `${minToStr(start)}-${minToStr(end)}`,
+              overlap_minutes: ov,
+              severity: "hard"
+            });
+          } else {
+            const gap = mb.startMin >= ma.endMin ? mb.startMin - ma.endMin : ma.startMin >= mb.endMin ? ma.startMin - mb.endMin : 0;
+            if (gap < passingMinutes) {
+              conflicts.push({
+                a: a.id,
+                b: b.id,
+                days: common,
+                overlap: `gap ${gap}min (${minToStr(ma.startMin)}-${minToStr(ma.endMin)} vs ${minToStr(mb.startMin)}-${minToStr(mb.endMin)})`,
+                overlap_minutes: 0,
+                severity: "tight"
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return { conflicts, warnings };
+}
+function travelWarnings(sections, passingMinutes = 10) {
+  const out = [];
+  const days = ["M", "T", "W", "R", "F", "S", "U"];
+  for (const day of days) {
+    const blocks = sections.flatMap(
+      (s) => s.meetings.filter((m) => m.days.includes(day)).map((m) => ({ s, m }))
+    );
+    blocks.sort((x, y) => x.m.startMin - y.m.startMin);
+    for (let i = 0; i + 1 < blocks.length; i++) {
+      const prev = blocks[i];
+      const next = blocks[i + 1];
+      if (prev.s.id === next.s.id) continue;
+      if (!dateOverlap(prev.s, next.s)) continue;
+      if (prev.m.endMin > next.m.startMin) continue;
+      const gap = next.m.startMin - prev.m.endMin;
+      const sameLoc = !!prev.m.locations[0] && !!next.m.locations[0] && prev.m.locations[0].toLowerCase() === next.m.locations[0].toLowerCase();
+      const need = sameLoc ? 0 : walkNeed(prev.s.school, next.s.school);
+      if (prev.s.school !== next.s.school && !sameLoc && (gap < need || gap <= passingMinutes)) {
+        out.push({
+          from: prev.s.id,
+          to: next.s.id,
+          from_school: prev.s.school,
+          to_school: next.s.school,
+          gap_minutes: gap,
+          message: gap < need ? `TIGHT: only ~${gap}min from ${prev.s.school} to ${next.s.school} on ${day} (${minToStr(prev.m.endMin)} \u2192 ${minToStr(next.m.startMin)}), needs ~${need}min.` : `Cross-campus ${prev.s.school}\u2192${next.s.school} on ${day} with ~${gap}min gap.`
+        });
+      }
+    }
+  }
+  return out;
+}
+function totalCredits(sections) {
+  return Math.round(sections.reduce((sum, s) => sum + s.credits, 0) * 100) / 100;
+}
+function weeklyGrid(sections) {
+  const days = ["M", "T", "W", "R", "F", "S", "U"];
+  const lines = [];
+  for (const day of days) {
+    const blocks = sections.flatMap(
+      (s) => s.meetings.filter((m) => m.days.includes(day)).map((m) => ({ s, m }))
+    );
+    blocks.sort((a, b) => a.m.startMin - b.m.startMin);
+    if (blocks.length === 0) {
+      lines.push(`${day}: \u2014`);
+      continue;
+    }
+    const cells = blocks.map(
+      (b) => `${minToStr(b.m.startMin)}-${minToStr(b.m.endMin)} ${b.s.code} (${b.s.school})`
+    ).join(" | ");
+    lines.push(`${day}: ${cells}`);
+  }
+  return lines.join("\n");
+}
+function checkSchedule(sections, opts = {}) {
+  const passing = opts.passingMinutes ?? 10;
+  const { conflicts, warnings } = findConflicts(sections, passing);
+  const travel = travelWarnings(sections, passing);
+  const seat_problems = sections.filter((s) => s.school !== "BLOCK").filter((s) => !isRegistrable(s.status) || s.seats.available <= 0).map((s) => ({
+    id: s.id,
+    reason: !isRegistrable(s.status) ? `Closed by registrar (status ${s.status}; cap ${s.seats.total}, filled ${s.seats.filled})` : `No remaining capacity (status ${s.status}; filled ${s.seats.filled}/${s.seats.total})`
+  }));
+  const skipped_tba = sections.filter((s) => s.meetings.length === 0).map((s) => s.id);
+  for (const s of sections) {
+    if (s.potentialError) {
+      warnings.push(
+        `${s.id}: source data flagged potential_error; treat its times as unreliable.`
+      );
+    }
+  }
+  const hard = conflicts.filter((c) => c.severity === "hard");
+  return {
+    ok: hard.length === 0 && seat_problems.length === 0,
+    complete: skipped_tba.length === 0 && sections.every((s) => !s.potentialError),
+    skipped_tba,
+    total_credits: totalCredits(sections),
+    class_count: sections.length,
+    conflicts,
+    travel_warnings: travel,
+    seat_problems,
+    warnings,
+    weekly_grid: weeklyGrid(sections)
+  };
+}
+var FilterError = class extends Error {
+  code = "E_BAD_FILTER";
+  hint;
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+  }
+};
+var KNOWN_SCHOOLS = [
+  "PO",
+  "CM",
+  "HM",
+  "SC",
+  "PZ",
+  "CG",
+  "KS",
+  "JP",
+  "JT",
+  "JM",
+  "AF",
+  "CH",
+  "AA"
+];
+var SCHOOLS_HINT = `Valid: ${KNOWN_SCHOOLS.join(" ")} (codes or names like Pomona, CMC, Harvey Mudd).`;
+function normalizeFilters(raw) {
+  const out = { normalized: {}, warnings: [] };
+  const list = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+  const schools = list(raw.school);
+  if (schools.length > 0) {
+    out.schools = schools.map((s) => {
+      const code = normalizeSchool(s);
+      if (!KNOWN_SCHOOLS.includes(code)) {
+        throw new FilterError(`Unknown school '${s}'.`, SCHOOLS_HINT);
+      }
+      return code;
+    });
+    out.normalized.school = out.schools;
+  }
+  const depts = list(raw.dept);
+  if (depts.length > 0) {
+    out.departments = depts.map((d) => {
+      const clean = d.trim().toUpperCase();
+      if (!/^[A-Z]{2,4}$/.test(clean)) {
+        throw new FilterError(
+          `Bad --dept '${d}'.`,
+          "Use 2\u20134 letter codes, e.g. --dept CSCI MATH."
+        );
+      }
+      return clean;
+    });
+    out.normalized.dept = out.departments;
+  }
+  if (raw.days) {
+    const days = normalizeDays(raw.days);
+    if (!days) {
+      throw new FilterError(
+        `Unknown days '${raw.days}'.`,
+        "Valid: M T W R F S U combos like MWF, TR, T/R, TuTh. R=Thursday."
+      );
+    }
+    out.days = days;
+    out.normalized.days = days.join("");
+  }
+  if (raw.after) {
+    const min = parseTime(raw.after);
+    if (min === null) {
+      throw new FilterError(
+        `Unparseable time '${raw.after}'.`,
+        "Try --after 1pm, --after 13:00, --after 10:00am."
+      );
+    }
+    out.afterMin = min;
+    out.normalized.after = raw.after;
+  }
+  if (raw.before) {
+    const min = parseTime(raw.before);
+    if (min === null) {
+      throw new FilterError(
+        `Unparseable time '${raw.before}'.`,
+        "Try --before 5pm, --before 17:00."
+      );
+    }
+    out.beforeMin = min;
+    out.normalized.before = raw.before;
+  }
+  if (out.afterMin !== void 0 && out.beforeMin !== void 0 && out.afterMin > out.beforeMin) {
+    throw new FilterError(
+      `Inverted time window: after ${raw.after} but before ${raw.before}.`,
+      "The window must satisfy after <= before."
+    );
+  }
+  if (raw.instructor) {
+    out.instructor = raw.instructor.trim();
+    out.normalized.instructor = out.instructor;
+  }
+  const areas = list(raw.area);
+  if (areas.length > 0) {
+    out.areas = areas.map((a) => a.trim().toUpperCase());
+    out.normalized.area = out.areas;
+  }
+  if (raw.credits) {
+    const m = raw.credits.match(/^(\d+(?:\.\d+)?)(?:\s*-\s*(\d+(?:\.\d+)?))?$/);
+    if (!m) {
+      throw new FilterError(
+        `Unparseable credits '${raw.credits}'.`,
+        "Try --credits 1 or --credits 0.5-1."
+      );
+    }
+    out.creditsMin = Number.parseFloat(m[1]);
+    out.creditsMax = m[2] ? Number.parseFloat(m[2]) : Number.parseFloat(m[1]);
+  }
+  if (raw.creditsMin !== void 0) out.creditsMin = raw.creditsMin;
+  if (raw.creditsMax !== void 0) out.creditsMax = raw.creditsMax;
+  if (raw.open !== void 0) out.openOnly = raw.open;
+  if (raw.excludeConflictsWith && raw.excludeConflictsWith.length > 0) {
+    out.excludeConflictIds = raw.excludeConflictsWith;
+  }
+  return out;
+}
+function matchesFilters(s, f) {
+  if (f.excludeConflictIds && f.excludeConflictIds.length > 0 && f.excludeConflictIds.includes(s.id)) {
+    return false;
+  }
+  if (f.schools && f.schools.length > 0 && !f.schools.includes(s.school))
+    return false;
+  if (f.departments && f.departments.length > 0 && !f.departments.includes(s.dept)) {
+    return false;
+  }
+  if (f.codePrefix) {
+    const flat = `${s.dept}${String(s.number).padStart(3, "0")}${s.suffix}`;
+    if (!flat.startsWith(f.codePrefix.toUpperCase())) return false;
+  }
+  if (f.days && f.days.length > 0) {
+    const sectionDays = new Set(s.meetings.flatMap((m) => m.days));
+    if (s.meetings.length === 0) return false;
+    for (const d of f.days) if (!sectionDays.has(d)) return false;
+  }
+  const afterMin = f.afterMin;
+  if (afterMin !== void 0) {
+    if (s.meetings.length === 0) return false;
+    if (!s.meetings.every((m) => m.startMin >= afterMin)) return false;
+  }
+  const beforeMin = f.beforeMin;
+  if (beforeMin !== void 0) {
+    if (s.meetings.length === 0) return false;
+    if (!s.meetings.every((m) => m.endMin <= beforeMin)) return false;
+  }
+  if (f.instructor) {
+    const q = f.instructor.toLowerCase();
+    if (!s.instructors.some((i) => i.toLowerCase().includes(q))) return false;
+  }
+  if (f.areas && f.areas.length > 0) {
+    const upper = s.areas.map((a) => a.toUpperCase());
+    if (!f.areas.some((a) => upper.includes(a))) return false;
+  }
+  if (f.creditsMin !== void 0 && s.credits < f.creditsMin) return false;
+  if (f.creditsMax !== void 0 && s.credits > f.creditsMax) return false;
+  if (f.openOnly && !isRegistrable(s.status)) return false;
+  return true;
+}
+function emptyHistory(codeQuery, note, provenance) {
+  return {
+    code: codeQuery.trim().toUpperCase().slice(0, 32),
+    offerings: [],
+    rotation_note: note,
+    verdict: "No history found.",
+    ...provenance
+  };
+}
+function courseHistory(entries, sections, codeQuery, opts = {}) {
+  const limit = opts.limit ?? 6;
+  const provenance = {
+    fetched_at: opts.fetched_at ?? "",
+    stale: opts.stale ?? false,
+    snapshot_term: opts.snapshot_term ?? "",
+    enrichment: opts.enrichment ?? null
+  };
+  const parsed = parseCode(codeQuery);
+  if (!parsed.dept && parsed.number === void 0) {
+    return emptyHistory(
+      codeQuery,
+      `No offering history found for '${codeQuery}'. Try a course code like 'CSCI 151'.`,
+      provenance
+    );
+  }
+  if (parsed.number === void 0) {
+    return emptyHistory(
+      codeQuery,
+      "History needs a course number, e.g. 'CSCI 151'. Department-only queries match too many courses.",
+      provenance
+    );
+  }
+  const matched = entries.filter(
+    (e) => e.code.department.toUpperCase() === parsed.dept && e.code.courseNumber === parsed.number && (parsed.suffix ? (e.code.suffix ?? "").toUpperCase() === parsed.suffix : true)
+  );
+  if (matched.length === 0) {
+    return emptyHistory(
+      codeQuery,
+      `No offering history found for '${codeQuery}'.`,
+      provenance
+    );
+  }
+  const byAff = /* @__PURE__ */ new Map();
+  for (const e of matched) {
+    const aff = e.code.affiliation.toUpperCase();
+    const list = byAff.get(aff) ?? [];
+    list.push(e);
+    byAff.set(aff, list);
+  }
+  const campusFilter = (opts.campuses ?? []).map(normalizeSchool);
+  const wantedSchools = parsed.school ? [parsed.school] : campusFilter.length > 0 ? campusFilter : [...byAff.keys()];
+  const available = wantedSchools.filter((s) => byAff.has(s));
+  if (available.length === 0) {
+    return emptyHistory(
+      codeQuery,
+      `No offering history for ${parsed.dept} ${String(parsed.number).padStart(3, "0")} at ${wantedSchools.join(", ")}; it exists at ${[...byAff.keys()].join(", ")}.`,
+      provenance
+    );
+  }
+  const chosen = available.map((school) => {
+    const list = [...byAff.get(school) ?? []].sort(
+      (a, b) => b.terms.length - a.terms.length
+    );
+    return { school, entry: list[0] };
+  });
+  const byTerm = /* @__PURE__ */ new Map();
+  for (const s of sections) {
+    const group = byTerm.get(s.term) ?? [];
+    group.push(s);
+    byTerm.set(s.term, group);
+  }
+  const enrichFor = (school, termKey) => (byTerm.get(termKey) ?? []).filter(
+    (s) => s.dept === parsed.dept && s.number === parsed.number && (!parsed.suffix || s.suffix === parsed.suffix) && s.school === school
+  );
+  const allTermKeys = chosen.flatMap(
+    ({ school, entry }) => entry.terms.map((t) => ({ school, key: `${t.term}${t.year}` }))
+  );
+  const code = `${parsed.dept} ${String(parsed.number).padStart(3, "0")}${parsed.suffix ?? ""}`;
+  const sortedKeys = [...new Set(allTermKeys.map((x) => x.key))].sort(
+    compareTermRecencyDesc
+  );
+  const offerings = [];
+  for (const key of sortedKeys.slice(0, limit)) {
+    for (const { school, entry } of chosen) {
+      if (!entry.terms.some((t) => `${t.term}${t.year}` === key)) continue;
+      const inTerm = enrichFor(school, key);
+      const instructors = [...new Set(inTerm.flatMap((s) => s.instructors))];
+      const first = inTerm[0];
+      offerings.push({
+        term: key,
+        instructors,
+        campus: first?.school ?? school,
+        seats: first ? { capacity: first.seats.total, enrolled: first.seats.filled } : null
+      });
+    }
+  }
+  const windowKeys = [...new Set(allTermKeys.map((x) => x.key))].sort(
+    compareTermRecencyDesc
+  );
+  const span = windowKeys.length > 1 ? `${termLabel(windowKeys[windowKeys.length - 1])}\u2013${termLabel(windowKeys[0])}` : termLabel(windowKeys[0] ?? "");
+  const fa = windowKeys.filter((k) => k.startsWith("FA")).length;
+  const sp = windowKeys.filter((k) => k.startsWith("SP")).length;
+  const total = windowKeys.length;
+  let cadence = "irregularly";
+  if (fa > 0 && sp === 0) cadence = "fall-only";
+  else if (sp > 0 && fa === 0) cadence = "spring-only";
+  else if (fa > 0 && sp > 0) cadence = "both semesters";
+  const shortWindow = total <= 2 ? " Short window; treat any rotation pattern as weak evidence." : "";
+  if (chosen.length > 1) {
+    const schools = chosen.map((c) => c.school).join(", ");
+    return {
+      code,
+      offerings,
+      rotation_note: `${code} has separate histories at ${schools}; offerings below are labeled by campus. Specify a school for a single-course verdict.`,
+      verdict: `History exists at ${schools}; specify a school (e.g. '${code} ${chosen[0].school}') for a per-course verdict.`,
+      ...provenance
+    };
+  }
+  let verdict;
+  if (fa > 0 && sp === 0) {
+    verdict = `Fall-only in observed history (FA ${fa}, SP 0; window ${span}).${shortWindow}`;
+  } else if (sp > 0 && fa === 0) {
+    verdict = `Spring-only in observed history (SP ${sp}, FA 0; window ${span}).${shortWindow}`;
+  } else if (sp > fa + 1) {
+    verdict = `Usually spring (SP ${sp} vs FA ${fa} in window ${span}).${shortWindow}`;
+  } else if (fa > sp + 1) {
+    verdict = `Usually fall (FA ${fa} vs SP ${sp} in window ${span}).${shortWindow}`;
+  } else {
+    verdict = `Offered both semesters (FA ${fa}, SP ${sp} in window ${span}).${shortWindow}`;
+  }
+  const rotation_note = `Offered in ${total} term(s) across ${span} in available history (${cadence}: FA ${fa}, SP ${sp}). Instructors are only known for terms with a local snapshot.`;
+  return { code, offerings, rotation_note, verdict, ...provenance };
+}
+function toDoc(s) {
+  return {
+    id: s.id,
+    code: `${s.dept} ${String(s.number).padStart(3, "0")}${s.suffix} ${s.school}`,
+    title: s.title,
+    instructors: s.instructors.join(" "),
+    areas: s.areas.join(" "),
+    description: s.description
+  };
+}
+function codeAwareTokenize(text) {
+  return text.toLowerCase().replace(/([a-z])(\d)/g, "$1 $2").split(/[^a-z0-9]+/).filter((t) => t.length > 0);
+}
+var BOOST = {
+  code: 5,
+  title: 3,
+  instructors: 2.5,
+  areas: 1.5,
+  description: 1
+};
+var MiniSearchProvider = class {
+  mini;
+  byId = /* @__PURE__ */ new Map();
+  docs = [];
+  built = false;
+  constructor() {
+    this.mini = new MiniSearch({
+      fields: ["code", "title", "instructors", "areas", "description"],
+      storeFields: ["id", "code", "title"],
+      searchOptions: {
+        boost: BOOST,
+        prefix: true,
+        fuzzy: 0.3,
+        combineWith: "AND"
+      },
+      tokenize: codeAwareTokenize,
+      processTerm: (t) => t.toLowerCase()
+    });
+  }
+  build(sections) {
+    this.setSections(sections);
+    this.ensureIndex();
+  }
+  /** Cheap path: byId only, no MiniSearch build (~65-90ms saved). */
+  setSections(sections) {
+    this.byId = new Map(sections.map((s) => [s.id, s]));
+    this.docs = sections.map(toDoc);
+    this.built = false;
+    this.mini.removeAll();
+  }
+  /** Build the MiniSearch index on first full-text need. Idempotent. */
+  ensureIndex() {
+    if (this.built) return;
+    this.mini.removeAll();
+    if (this.docs.length > 0) this.mini.addAll(this.docs);
+    this.built = true;
+  }
+  get indexBuilt() {
+    return this.built;
+  }
+  /**
+   * Candidate-union pipeline. Deterministic pre-passes (exact code, code
+   * prefix, dept) contribute scored candidates; free-text queries union
+   * title-phrase candidates with full-text results. Hard filters apply
+   * ONCE over the union, so a filter narrower than a pre-pass can never
+   * silently delete valid matches. Code-shaped queries stay strict: a
+   * dept+number that matches nothing is "not found", never fuzzy soup.
+   */
+  query(q, f) {
+    const query = q.trim();
+    const tokens = codeAwareTokenize(query);
+    const parsed = parseCode(query);
+    const all = [...this.byId.values()];
+    const cand = /* @__PURE__ */ new Map();
+    const add = (s, score, why) => {
+      const cur = cand.get(s.id);
+      if (!cur) {
+        cand.set(s.id, { s, score, why: [...why] });
+        return;
+      }
+      if (score > cur.score) cur.score = score;
+      for (const w of why) if (!cur.why.includes(w)) cur.why.push(w);
+    };
+    const codeShaped = !!parsed.dept && parsed.number !== void 0;
+    if (codeShaped) {
+      const num = String(parsed.number).padStart(3, "0");
+      const exact = all.filter(
+        (s) => s.dept === parsed.dept && String(s.number).padStart(3, "0") === num && s.suffix === (parsed.suffix ?? "") && (!parsed.school || s.school === parsed.school)
+      );
+      if (exact.length > 0) {
+        for (const s of exact) add(s, 100, ["exact-code"]);
+        return this.finalize([...cand.values()], f, tokens);
+      }
+      const prefix = `${parsed.dept}${parsed.number}`.toLowerCase();
+      const prefixed = all.filter(
+        (s) => s.dept === parsed.dept && (!parsed.suffix || s.suffix === parsed.suffix) && (!parsed.school || s.school === parsed.school) && `${s.dept}${s.number}`.toLowerCase().startsWith(prefix)
+      );
+      if (prefixed.length > 0) {
+        for (const s of prefixed) add(s, 50, ["code-prefix"]);
+        return this.finalize([...cand.values()], f, tokens);
+      }
+      return this.finalize([], f, tokens);
+    }
+    if (parsed.dept && parsed.number === void 0) {
+      const deptHit = all.filter(
+        (s) => s.dept === parsed.dept && (!parsed.school || s.school === parsed.school)
+      );
+      for (const s of deptHit) add(s, 50, ["dept"]);
+    }
+    if (query.length === 0) {
+      for (const s of all) add(s, 1, ["browse"]);
+      return this.finalize([...cand.values()], f, tokens);
+    }
+    const phrase = query.replace(/^"|"$/g, "").toLowerCase();
+    if (phrase.length >= 4) {
+      for (const s of all.filter((x) => x.title.toLowerCase().includes(phrase)))
+        add(s, 30, ["title-phrase"]);
+    }
+    this.ensureIndex();
+    let results = this.mini.search(query);
+    let orFallback = false;
+    if (results.length === 0 && tokens.length > 1) {
+      results = this.mini.search(query, { combineWith: "OR" });
+      orFallback = true;
+    }
+    const ql = query.toLowerCase();
+    for (const r of results) {
+      const s = this.byId.get(r.id);
+      if (!s) continue;
+      const why = [];
+      if (s.title.toLowerCase().includes(ql)) why.push(`title:${ql}`);
+      if (s.dept.toLowerCase() === ql || s.code.toLowerCase().startsWith(ql)) {
+        why.push(`code:${ql}`);
+      }
+      if (s.instructors.some((i) => i.toLowerCase().includes(ql))) {
+        why.push(`instructor:${ql}`);
+      }
+      let score = r.score;
+      if (orFallback) {
+        const coverage = Object.keys(r.match ?? {}).length;
+        score = r.score * 0.5 * (1 + coverage);
+        why.push("or-fallback");
+      }
+      add(s, score, why.length > 0 ? why : ["text"]);
+    }
+    return this.finalize([...cand.values()], f, tokens);
+  }
+  finalize(scored, f, queryTokens = []) {
+    const out = [];
+    for (const { s, score, why } of scored) {
+      if (!matchesFilters(s, f)) continue;
+      let adj = score;
+      if (queryTokens.length > 0) {
+        const titleTokens = new Set(codeAwareTokenize(s.title));
+        if (queryTokens.every((t) => titleTokens.has(t))) {
+          adj += 8;
+          why.push("title-words");
+        }
+      }
+      if (s.status === "O") adj += 5;
+      else if (s.status === "C") adj -= 10;
+      else if (s.status === "R") adj += 2;
+      if (s.seats.available >= 3) adj += 3;
+      else if (s.seats.available > 0) adj += 1;
+      if (s.potentialError) adj -= 5;
+      out.push({
+        section: s,
+        score: adj,
+        match: why,
+        fetched_at: "",
+        stale: false
+      });
+    }
+    out.sort(
+      (a, b) => b.score - a.score || b.section.seats.available - a.section.seats.available || a.section.id.localeCompare(b.section.id)
+    );
+    return out;
+  }
+  toJSON() {
+    this.ensureIndex();
+    return JSON.stringify({
+      index: this.mini.toJSON(),
+      ids: [...this.byId.keys()]
+    });
+  }
+  get size() {
+    return this.byId.size;
+  }
+};
+function mergedDays(s) {
+  const order = ["M", "T", "W", "R", "F", "S", "U"];
+  const set = new Set(s.meetings.flatMap((m) => m.days));
+  return order.filter((d) => set.has(d)).join("");
+}
+function toCompactHit(h, fetched_at, explain, stale = false) {
+  const s = h.section;
+  return {
+    id: s.id,
+    term: s.term,
+    school: s.school,
+    code: s.code,
+    section: String(s.sectionNo).padStart(2, "0"),
+    title: s.title,
+    instructors: s.instructors,
+    // Summary across meetings; the per-block truth is in meetings[].
+    days: mergedDays(s),
+    start: s.meetings.length > 0 ? s.meetings[0].startStr : null,
+    end: s.meetings.length > 0 ? s.meetings[0].endStr : null,
+    meetings: s.meetings.length === 0 ? [] : s.meetings.map((m) => ({
+      days: m.days.join(""),
+      start: m.startStr,
+      end: m.endStr,
+      location: m.locations[0] ?? null
+    })),
+    credits: s.credits,
+    potential_error: s.potentialError,
+    seats_open: s.seats.available,
+    seats_total: s.seats.total,
+    status: s.status,
+    match: {
+      score: Math.round(h.score * 100) / 100,
+      why: explain ? h.match : h.match.slice(0, 1)
+    },
+    fetched_at,
+    stale
+  };
+}
+function paginate(hits, opts) {
+  const total = hits.length;
+  const slice = hits.slice(opts.offset, opts.offset + opts.limit);
+  const has_more = opts.offset + opts.limit < total;
+  const hint = total === 0 ? "No matches. Try fewer filters, a different term, or drop --open." : opts.offset >= total ? `Offset ${opts.offset} is past the end (total ${total}); re-run with --offset 0 or narrow filters.` : has_more ? `${total} hits, showing ${slice.length}. Re-run with --offset ${opts.offset + opts.limit} or narrow filters.` : null;
+  return {
+    term: opts.term,
+    total,
+    limit: opts.limit,
+    offset: opts.offset,
+    has_more,
+    next_offset: has_more ? opts.offset + opts.limit : null,
+    hits: slice.map(
+      (h) => toCompactHit(h, opts.fetched_at, opts.explain, opts.stale)
+    ),
+    hint,
+    suggestions: opts.suggestions ?? [],
+    fetched_at: opts.fetched_at,
+    stale: opts.stale,
+    snapshot_id: opts.snapshot_id ?? null
+  };
+}
+var providers = /* @__PURE__ */ new Map();
+function getProvider(term, sections, hash) {
+  const key = `${term}:${hash}`;
+  const hit = providers.get(key);
+  if (hit) return hit;
+  if (providers.size >= 4) {
+    const oldest = providers.keys().next();
+    if (!oldest.done) providers.delete(oldest.value);
+  }
+  const provider = new MiniSearchProvider();
+  provider.setSections(sections);
+  providers.set(key, provider);
+  return provider;
+}
+function snapshotMeta(m) {
+  return {
+    fetched_at: m.fetched_at,
+    stale: m.stale,
+    quarantined: m.quarantined ?? 0,
+    duplicate_ids: m.duplicate_ids ?? 0
+  };
+}
+function combinedMeta(metas) {
+  const first = metas[0];
+  if (!first) {
+    return { fetched_at: "", stale: false, quarantined: 0, duplicate_ids: 0 };
+  }
+  return {
+    fetched_at: first.fetched_at,
+    stale: metas.some((m) => m.stale),
+    quarantined: metas.reduce((n, m) => n + (m.quarantined ?? 0), 0),
+    duplicate_ids: metas.reduce((n, m) => n + (m.duplicate_ids ?? 0), 0)
+  };
+}
+function badTermError(input) {
+  return Object.assign(
+    new Error(`Unparseable term '${input}'. Use a term like FA2026.`),
+    {
+      code: "E_BAD_TERM",
+      hint: "Use a term like FA2026 \u2014 run list_terms to see available terms."
+    }
+  );
+}
+function usageError(message, hint) {
+  return Object.assign(new Error(message), { code: "E_USAGE", hint });
+}
+async function resolveTerm(raw, fetchFn) {
+  if (raw === void 0) return defaultTerm(fetchFn);
+  const norm = normalizeTerm(raw);
+  if (!norm) throw badTermError(raw);
+  return norm.toUpperCase();
+}
+async function loadTermStrict(term, fetchFn, allowFallback) {
+  try {
+    const value = await loadTerm(term, { fetchFn });
+    return value;
+  } catch (err) {
+    const e = err;
+    if (e.code !== "E_TERM_NOT_FOUND") throw err;
+    if (!allowFallback) {
+      try {
+        const { available: available2 } = await listTerms({ limit: 8, fetchFn });
+        e.available = available2.map(
+          (t) => t.code
+        );
+      } catch {
+      }
+      e.hint = "Term not published upstream. Run list_terms for available terms, or opt into serving the newest available term.";
+      throw e;
+    }
+    const { available } = await listTerms({ limit: 8, fetchFn });
+    const served = available[0]?.code;
+    if (!served || served === term) throw err;
+    const value = await loadTerm(served, { fetchFn });
+    return {
+      ...value,
+      fallback: { requested: term, served },
+      warning: `Term ${term} is not published; showing ${served} instead.`
+    };
+  }
+}
+function isCompleteIdentity(parsed) {
+  return !!parsed.dept && parsed.number !== void 0 && !!parsed.school && parsed.sectionNo !== void 0;
+}
+function resolveInput(input, parsed, targetTerm, sections, strict) {
+  if (isCompleteIdentity(parsed)) {
+    const canonical = sectionId({
+      dept: parsed.dept,
+      number: parsed.number,
+      suffix: parsed.suffix ?? "",
+      school: parsed.school,
+      sectionNo: parsed.sectionNo,
+      term: targetTerm
+    });
+    const exact = sections.find((s) => s.id === canonical);
+    return exact ? { section: exact } : {};
+  }
+  if (strict) return {};
+  if (!parsed.dept && parsed.number === void 0) return {};
+  const matches = sections.filter(
+    (s) => (!parsed.dept || s.dept === parsed.dept) && (parsed.number === void 0 || s.number === parsed.number) && (!parsed.suffix || s.suffix === parsed.suffix) && (!parsed.school || s.school === parsed.school) && (parsed.sectionNo === void 0 || s.sectionNo === parsed.sectionNo)
+  );
+  if (matches.length === 1) return { section: matches[0] };
+  if (matches.length > 1) return { ambiguous: matches.map((s) => s.id) };
+  return {};
+}
+async function loadTermsForInputs(termKeys, fetchFn, allowFallback) {
+  const loaded = /* @__PURE__ */ new Map();
+  const terms = [];
+  let fallback;
+  let warning;
+  for (const t of termKeys) {
+    const v = await loadTermStrict(t, fetchFn, allowFallback);
+    if (v.fallback && !fallback) {
+      fallback = v.fallback;
+      warning = v.warning;
+    }
+    loaded.set(v.meta.term, { sections: v.sections, meta: v.meta });
+    terms.push({
+      term: v.meta.term,
+      fetched_at: v.meta.fetched_at,
+      stale: v.meta.stale
+    });
+  }
+  return { loaded, terms, ...fallback ? { fallback, warning } : {} };
+}
+function validateIdList(ids) {
+  if (!Array.isArray(ids) || ids.some((i) => typeof i !== "string")) {
+    throw usageError(
+      "Expected an array of section ID strings.",
+      "Pass IDs like 'CSCI 005 HM-01 FA2026'."
+    );
+  }
+}
+async function searchClasses(query, opts = {}) {
+  const filters = normalizeFilters({
+    school: opts.schools,
+    dept: opts.depts,
+    days: opts.days,
+    after: opts.after,
+    before: opts.before,
+    instructor: opts.instructor,
+    area: opts.areas,
+    credits: opts.credits,
+    open: opts.open,
+    excludeConflictsWith: opts.excludeConflictsWith
+  });
+  if (opts.code !== void 0 && opts.code.trim() !== "") {
+    const parsed = parseCode(opts.code);
+    if (!parsed.dept && parsed.number === void 0) {
+      throw new FilterError(
+        `Unparseable --code '${opts.code}'.`,
+        "Try --code 'CSCI 051', --code CSCI, or --code 'CSCI 051 PO'."
+      );
+    }
+    if (parsed.dept) {
+      let prefix = parsed.dept;
+      if (parsed.numberRaw !== void 0) {
+        prefix += parsed.numberRaw.length === 2 ? parsed.numberRaw : parsed.numberRaw.padStart(3, "0");
+      }
+      if (parsed.suffix) prefix += parsed.suffix;
+      filters.codePrefix = prefix;
+      if (parsed.school && !filters.schools) {
+        filters.schools = [parsed.school];
+      }
+    }
+  }
+  const requested = await resolveTerm(opts.term, opts.fetchFn);
+  const { sections, meta, fallback, warning } = await loadTermStrict(
+    requested,
+    opts.fetchFn,
+    opts.allowTermFallback ?? false
+  );
+  const served = fallback?.served ?? requested;
+  const provider = getProvider(served, sections, meta.hash);
+  let hits = provider.query(query ?? "", filters);
+  hits = sortHits(hits, opts.sort ?? "relevance");
+  if (filters.excludeConflictIds && filters.excludeConflictIds.length > 0) {
+    const anchors = filters.excludeConflictIds;
+    const missing = anchors.filter((id) => !sections.some((s) => s.id === id));
+    if (missing.length > 0) {
+      throw Object.assign(
+        new Error(
+          `Unknown exclusion anchor(s): ${missing.join(", ")}. Anchors must be canonical IDs in the searched term.`
+        ),
+        {
+          code: "E_NOT_FOUND",
+          not_found: missing,
+          hint: "Resolve IDs via search first, then pass them verbatim."
+        }
+      );
+    }
+    const anchored = sections.filter((s) => anchors.includes(s.id));
+    hits = hits.filter(
+      (h) => !anchors.includes(h.section.id) && !anchored.some(
+        (a) => a.id !== h.section.id && sectionsOverlap(a, h.section)
+      )
+    );
+  }
+  const limit = Math.min(Math.max(opts.limit ?? 10, 1), 50);
+  const offset = Math.max(opts.offset ?? 0, 0);
+  const suggestions = recallSuggestions(query ?? "", filters, sections);
+  if (resultWillBeEmptyCodeQuery(query ?? "", hits)) {
+    const parsed = parseCode(query ?? "");
+    const label = `${parsed.dept} ${String(parsed.number).padStart(3, "0")}${parsed.suffix ?? ""}`.trim();
+    suggestions.unshift(
+      `No ${label} in ${served} \u2014 check the course number, or browse with --dept ${parsed.dept} (departments:["${parsed.dept}"]).`
+    );
+  }
+  const result = paginate(hits, {
+    limit,
+    offset,
+    term: served,
+    fetched_at: meta.fetched_at,
+    stale: meta.stale,
+    explain: opts.explain ?? false,
+    snapshot_id: meta.hash.slice(0, 12),
+    suggestions
+  });
+  return {
+    result,
+    normalized: { ...filters.normalized, term: served },
+    meta: snapshotMeta(meta),
+    ...fallback ? { fallback, warning } : {}
+  };
+}
+var MAX_IDS = 20;
+async function getClasses(ids, opts = {}) {
+  validateIdList(ids);
+  if (ids.length === 0) {
+    throw usageError(
+      "get needs at least one ID.",
+      "Pass 1-20 canonical section IDs."
+    );
+  }
+  if (ids.length > MAX_IDS) {
+    throw usageError(
+      `Too many IDs (${ids.length}); the cap is ${MAX_IDS}.`,
+      "Split the batch into multiple calls."
+    );
+  }
+  const explicitTerm = opts.term !== void 0 ? await resolveTerm(opts.term, opts.fetchFn) : void 0;
+  const inputs = ids.map((id) => ({ id, parsed: parseCode(id) }));
+  const needDefault = explicitTerm === void 0 && inputs.some((x) => !x.parsed.term);
+  const defTerm = needDefault ? await defaultTerm(opts.fetchFn) : null;
+  const termKey = (x) => {
+    const t = x.parsed.term ?? explicitTerm ?? defTerm;
+    if (!t) throw badTermError("");
+    return t;
+  };
+  const distinctTerms = [...new Set(inputs.map(termKey))];
+  const { loaded, terms, fallback, warning } = await loadTermsForInputs(
+    distinctTerms,
+    opts.fetchFn,
+    opts.allowTermFallback ?? false
+  );
+  const classes = [];
+  const not_found = [];
+  const ambiguous = [];
+  const suggestions = [];
+  for (const x of inputs) {
+    const t = termKey(x);
+    const { sections } = loaded.get(t) ?? { sections: [] };
+    const res = resolveInput(x.id, x.parsed, t, sections, false);
+    const section = res.section;
+    if (section) {
+      if (!classes.some((c) => c.id === section.id)) classes.push(section);
+      continue;
+    }
+    if (res.ambiguous && res.ambiguous.length > 0) {
+      ambiguous.push({ input: x.id, section_ids: res.ambiguous });
+      continue;
+    }
+    not_found.push(x.id);
+    const sug = suggestIds(sections, x.id);
+    if (sug.length > 0) suggestions.push({ input: x.id, ids: sug });
+  }
+  return {
+    result: { classes, not_found, ambiguous, suggestions, terms },
+    meta: combinedMeta([...loaded.values()].map((v) => v.meta)),
+    terms,
+    ...fallback ? { fallback, warning } : {}
+  };
+}
+async function checkScheduleByIds(ids, opts = {}) {
+  validateIdList(ids);
+  if (ids.length === 0) {
+    throw usageError(
+      "check needs at least one ID.",
+      "Pass canonical section IDs, e.g. 'CSCI 005 HM-01 FA2026'."
+    );
+  }
+  if (ids.length > MAX_IDS) {
+    throw usageError(
+      `Too many IDs (${ids.length}); the cap is ${MAX_IDS}.`,
+      "Split the schedule into multiple checks."
+    );
+  }
+  const explicitTerm = opts.term !== void 0 ? await resolveTerm(opts.term, opts.fetchFn) : void 0;
+  const inputs = ids.map((id) => ({ id, parsed: parseCode(id) }));
+  const needDefault = explicitTerm === void 0 && inputs.some((x) => !x.parsed.term);
+  const defTerm = needDefault ? await defaultTerm(opts.fetchFn) : null;
+  const termKey = (x) => {
+    const t = x.parsed.term ?? explicitTerm ?? defTerm;
+    if (!t) throw badTermError("");
+    return t;
+  };
+  const distinctTerms = [...new Set(inputs.map(termKey))];
+  const { loaded, terms, fallback, warning } = await loadTermsForInputs(
+    distinctTerms,
+    opts.fetchFn,
+    opts.allowTermFallback ?? false
+  );
+  const resolved = [];
+  const failed = [];
+  for (const x of inputs) {
+    const t = termKey(x);
+    const { sections } = loaded.get(t) ?? { sections: [] };
+    const res = resolveInput(x.id, x.parsed, t, sections, true);
+    const section = res.section;
+    if (section) {
+      if (!resolved.some((s) => s.id === section.id)) resolved.push(section);
+    } else {
+      failed.push(x.id);
+    }
+  }
+  if (failed.length > 0) {
+    throw Object.assign(
+      new Error(
+        `Unknown or incomplete section ID(s): ${failed.join(", ")}. Schedule checks need full IDs (dept, number, school, section, term).`
+      ),
+      {
+        code: "E_NOT_FOUND",
+        not_found: failed,
+        hint: "Search first, then pass IDs like 'CSCI 005 HM-01 FA2026' verbatim."
+      }
+    );
+  }
+  const resolvedTerms = [...new Set(resolved.map((s) => s.term))];
+  if (resolvedTerms.length > 1) {
+    throw usageError(
+      `check is term-scoped; these IDs span ${resolvedTerms.join(", ")}.`,
+      "Run one check per term."
+    );
+  }
+  const result = checkSchedule(resolved, {
+    passingMinutes: opts.passingMinutes
+  });
+  return {
+    result,
+    sections: resolved,
+    resolved: resolved.map((s) => s.id),
+    meta: combinedMeta([...loaded.values()].map((v) => v.meta)),
+    terms,
+    ...fallback ? { fallback, warning } : {}
+  };
+}
+async function listTerms(opts = {}) {
+  const res = await fetchAllTerms({}, opts.fetchFn);
+  let current = "FA2026";
+  try {
+    const cur = await fetchCurrentTerm({}, opts.fetchFn);
+    current = `${cur.data.term}${cur.data.year}`;
+  } catch {
+    const all = res.data.map((t) => `${t.term}${t.year}`).sort(compareTermRecencyDesc);
+    current = all[0] ?? current;
+  }
+  const limit = opts.limit ?? 6;
+  const infos = res.data.map((t) => {
+    const code = `${t.term}${t.year}`;
+    return {
+      code,
+      label: termLabel(code),
+      year: t.year,
+      term: t.term,
+      is_current: code === current
+    };
+  }).sort((a, b) => compareTermRecencyDesc(a.code, b.code));
+  const sliced = infos.slice(0, limit);
+  if (!sliced.some((t) => t.is_current)) {
+    const cur = infos.find((t) => t.is_current);
+    if (cur) {
+      if (sliced.length === limit) sliced.pop();
+      sliced.unshift(cur);
+    }
+  }
+  return { current, available: sliced };
+}
+async function getCourseHistory(code, opts = {}) {
+  const requested = await resolveTerm(opts.term, opts.fetchFn);
+  const { sections, meta, fallback, warning } = await loadTermStrict(
+    requested,
+    opts.fetchFn,
+    opts.allowTermFallback ?? false
+  );
+  const served = fallback?.served ?? requested;
+  const provenance = {
+    // fetched_at/stale describe the HISTORY source; enrichment describes
+    // the sections snapshot. Two sources, two clocks.
+    snapshot_term: served,
+    enrichment: {
+      term: served,
+      fetched_at: meta.fetched_at,
+      stale: meta.stale
+    }
+  };
+  let entries = [];
+  let historyFreshness = { fetched_at: "", stale: false };
+  try {
+    const h = await loadHistory(served, { fetchFn: opts.fetchFn });
+    entries = h.entries;
+    historyFreshness = { fetched_at: h.fetched_at, stale: h.stale };
+  } catch (err) {
+    if (err.code !== "E_TERM_NOT_FOUND") throw err;
+  }
+  const result = courseHistory(entries, sections, code, {
+    campuses: opts.campuses,
+    limit: opts.limit,
+    fetched_at: historyFreshness.fetched_at,
+    stale: historyFreshness.stale,
+    ...provenance
+  });
+  if (result.offerings.length > 0)
+    return { ...result, ...fallback ? { fallback, warning } : {} };
+  try {
+    const { available } = await listTerms({ limit: 8, fetchFn: opts.fetchFn });
+    const seen = /* @__PURE__ */ new Set([served]);
+    for (const t of available.map((x) => x.code)) {
+      if (seen.has(t)) continue;
+      seen.add(t);
+      try {
+        const {
+          entries: e2,
+          fetched_at: hf,
+          stale: hs
+        } = await loadHistory(t, {
+          fetchFn: opts.fetchFn
+        });
+        const probe = courseHistory(e2, [], code, {
+          campuses: opts.campuses,
+          limit: opts.limit,
+          fetched_at: hf,
+          stale: hs
+        });
+        if (probe.offerings.length > 0) {
+          const { sections: s2, meta: m2 } = await loadTerm(t, {
+            fetchFn: opts.fetchFn
+          });
+          const r2 = courseHistory(e2, s2, code, {
+            campuses: opts.campuses,
+            limit: opts.limit,
+            fetched_at: hf,
+            stale: hs,
+            snapshot_term: t,
+            enrichment: {
+              term: t,
+              fetched_at: m2.fetched_at,
+              stale: m2.stale
+            }
+          });
+          return {
+            ...r2,
+            rotation_note: `${r2.rotation_note} (Not offered in ${served}; history resolved via ${t}.)`,
+            ...fallback ? { fallback, warning } : {}
+          };
+        }
+      } catch {
+        continue;
+      }
+      if (seen.size >= 5) break;
+    }
+  } catch {
+  }
+  return { ...result, ...fallback ? { fallback, warning } : {} };
+}
+async function defaultTerm(fetchFn) {
+  const now = Date.now();
+  const mem2 = getCurrentTermMem();
+  if (mem2 && now - mem2.at < CURRENT_TERM_TTL_MS) {
+    return mem2.value;
+  }
+  let staleFile = null;
+  try {
+    const file = await readCurrentTermFile();
+    if (file) {
+      if (now - file.at < CURRENT_TERM_TTL_MS) {
+        setCurrentTermMem(file.value, file.at);
+        return file.value;
+      }
+      staleFile = file.value;
+    }
+  } catch {
+  }
+  try {
+    const cur = await fetchCurrentTerm({}, fetchFn);
+    const value = `${cur.data.term}${cur.data.year}`;
+    await writeCurrentTermFile(value);
+    return value;
+  } catch {
+    const known = mem2?.value ?? staleFile;
+    if (known) return known;
+    throw Object.assign(
+      new Error(
+        "Cannot determine the current term: network unavailable and no cached value."
+      ),
+      {
+        code: "E_NO_CURRENT_TERM",
+        hint: "Pass an explicit term like --term FA2026, or run `5c terms` once while online."
+      }
+    );
+  }
+}
+function suggestIds(sections, id, n = 3) {
+  const parsed = parseCode(id);
+  const scored = sections.map((s) => {
+    let score = 0;
+    if (parsed.dept && s.dept === parsed.dept) score += 3;
+    if (parsed.number !== void 0 && s.number === parsed.number) score += 3;
+    if (parsed.school && s.school === parsed.school) score += 2;
+    return { s, score };
+  });
+  return scored.filter((x) => x.score > 0).sort((a, b) => b.score - a.score || a.s.id.localeCompare(b.s.id)).slice(0, n).map((x) => x.s.id);
+}
+function sortHits(hits, sort) {
+  const arr = [...hits];
+  if (sort === "time") {
+    arr.sort(
+      (a, b) => earliestStart(a.section) - earliestStart(b.section) || a.section.id.localeCompare(b.section.id)
+    );
+  } else if (sort === "seats") {
+    arr.sort(
+      (a, b) => b.section.seats.available - a.section.seats.available || a.section.id.localeCompare(b.section.id)
+    );
+  } else if (sort === "code") {
+    arr.sort((a, b) => a.section.id.localeCompare(b.section.id));
+  }
+  return arr;
+}
+function earliestStart(s) {
+  const starts = s.meetings.map((m) => m.startMin);
+  return starts.length > 0 ? Math.min(...starts) : Number.MAX_SAFE_INTEGER;
+}
+var DEPT_NAMES = [
+  ["computer science", "CSCI"],
+  ["mathematics", "MATH"],
+  ["economics", "ECON"],
+  ["psychology", "PSYC"],
+  ["physics", "PHYS"],
+  ["chemistry", "CHEM"],
+  ["biology", "BIOL"],
+  ["english", "ENGL"],
+  ["history", "HIST"],
+  ["philosophy", "PHIL"],
+  ["sociology", "SOC"],
+  ["anthropology", "ANTH"],
+  ["neuroscience", "NEUR"],
+  ["astronomy", "ASTR"],
+  ["geology", "GEOL"],
+  ["politics", "POLI"],
+  ["statistics", "MATH"],
+  ["ethics", "PHIL"],
+  ["arabic", "ARBC"],
+  ["spanish", "SPAN"],
+  ["portuguese", "PORT"],
+  ["film", "MS"],
+  ["media", "MS"],
+  ["music", "MUS"],
+  ["math", "MATH"],
+  ["art", "ART"]
+];
+function resultWillBeEmptyCodeQuery(query, hits) {
+  if (hits.length > 0) return false;
+  const parsed = parseCode(query);
+  return !!parsed.dept && parsed.number !== void 0;
+}
+function recallSuggestions(query, filters, sections) {
+  const out = [];
+  const padded = ` ${query.toLowerCase().trim()} `;
+  if (padded.trim().length === 0) return out;
+  const asCode = parseCode(query);
+  const codeShaped = !!asCode.dept && asCode.number !== void 0;
+  if (!codeShaped && (!filters.departments || filters.departments.length === 0)) {
+    for (const [name, code] of DEPT_NAMES) {
+      if (padded.includes(` ${name} `) && sections.some((s) => s.dept === code)) {
+        out.push(
+          `'${query.trim()}' matches department ${code} \u2014 retry with --dept ${code} (departments:["${code}"]) for full recall.`
+        );
+        break;
+      }
+    }
+  }
+  if (!filters.schools || filters.schools.length === 0) {
+    const mentioned = detectSchoolMention(query);
+    if (mentioned) {
+      out.push(
+        `Query mentions a college \u2014 retry with --school ${mentioned} to narrow, or leave blank for all 5Cs.`
+      );
+    }
+  }
+  return out;
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/errors.ts
+var RETRYABLE = /* @__PURE__ */ new Set(["E_FETCH", "E_NO_CURRENT_TERM"]);
+function recoveryOf(e) {
+  switch (e.code) {
+    case "E_TERM_NOT_FOUND":
+    case "E_BAD_TERM":
+      return e.available?.length ? `Recovery: call list_terms and retry with one of ${e.available.join(", ")}, or pass allow_term_fallback: true to serve the newest.` : "Recovery: call list_terms and retry with an available term.";
+    case "E_NO_CURRENT_TERM":
+      return "Recovery: pass an explicit term; retry once the network is reachable.";
+    case "E_NOT_FOUND":
+      return "Recovery: search_classes to resolve the ID, then pass it verbatim. Loose or partial IDs are never guessed at.";
+    case "E_BAD_FILTER":
+    case "E_USAGE":
+      return "Recovery: fix the named argument and retry; nothing was fetched.";
+    default:
+      return RETRYABLE.has(e.code ?? "") ? "Recovery: retry once. If it fails again, report what you have and its timestamp." : "Recovery: report the failure; do not substitute another term's data.";
+  }
+}
+function toolError(err) {
+  const e = err ?? {};
+  const parts = [e.message ?? String(err)];
+  if (e.not_found?.length) parts.push(`Unresolved: ${e.not_found.join(", ")}.`);
+  if (e.hint && e.hint !== e.message) parts.push(e.hint);
+  parts.push(recoveryOf(e));
+  if (e.code) parts.push(`(code: ${e.code})`);
+  return {
+    isError: true,
+    content: [{ type: "text", text: parts.join(" ") }]
+  };
+}
+
+// src/schemas.ts
+import { z as z2 } from "zod";
+var SCHOOLS = [
+  "PO",
+  "CM",
+  "CMC",
+  "HM",
+  "SC",
+  "PZ",
+  "CG",
+  "KS",
+  "JP",
+  "JT",
+  "JM",
+  "AF",
+  "CH",
+  "AA"
+];
+var DAYS = ["M", "T", "W", "R", "F", "S", "U"];
+var SORTS = ["relevance", "time", "seats", "code"];
+var fallbackSchema = z2.object({
+  requested: z2.string(),
+  served: z2.string()
+}).strict();
+var termProvenanceSchema = z2.object({
+  term: z2.string(),
+  fetched_at: z2.string(),
+  stale: z2.boolean()
+}).strict();
+var ingestFields = {
+  fetched_at: z2.string().describe("When this process obtained the snapshot."),
+  stale: z2.boolean().describe("Snapshot past the seat TTL; treat seats as indicative."),
+  quarantined: z2.number().int().describe("Rows dropped at ingest. Nonzero means incomplete coverage."),
+  duplicate_ids: z2.number().int().describe("Rows collapsed onto an existing canonical ID at ingest.")
+};
+var searchInputSchema = z2.object({
+  query: z2.string().optional().describe(
+    "Free text over title/description/code/instructor. Empty = browse with filters."
+  ),
+  term: z2.string().optional().describe(
+    "Term code, e.g. 'FA2026'. Defaults to current. Call list_terms if unsure."
+  ),
+  schools: z2.array(z2.enum(SCHOOLS)).optional().describe(
+    "Filter to colleges (5Cs + joint: KS JP JT JM AF CH AA; CG Claremont Graduate). CM is canonical for Claremont McKenna; CMC accepted as alias."
+  ),
+  departments: z2.array(z2.string()).optional().describe("Dept codes, e.g. ['ECON','CSCI']. Case-insensitive."),
+  code: z2.string().optional().describe(
+    "Course-code prefix. 'CSCI 051' matches that course; 'CSCI 05' matches the 050-059 family; 'CSCI' matches the department."
+  ),
+  days: z2.array(z2.enum(DAYS)).optional().describe(
+    "Must meet on ALL listed days, within the whole time window. R=Thursday."
+  ),
+  starts_after: z2.string().optional().describe(
+    "Earliest start 24h 'HH:MM', e.g. '13:00'. Applies to every meeting of a hit."
+  ),
+  ends_before: z2.string().optional().describe(
+    "Latest end 24h 'HH:MM'. An inverted window (start after end) is an error, not an empty result."
+  ),
+  instructor: z2.string().optional().describe("Instructor name substring."),
+  course_areas: z2.array(z2.string()).optional().describe(
+    "GE/area codes as the registrar writes them, e.g. ['QR']. Codes are per-college; a code from one campus does not apply at another."
+  ),
+  availability: z2.enum(["any", "has_seat"]).default("any").describe(
+    "has_seat = registrar status says registrable (Open/Reopened). Computed capacity is reported, not used as eligibility."
+  ),
+  credits_min: z2.number().min(0).max(99).optional().describe("Minimum credits; pairs with credits_max as a range."),
+  credits_max: z2.number().min(0).max(99).optional().describe("Maximum credits; pairs with credits_min as a range."),
+  sort: z2.enum(SORTS).default("relevance").describe(
+    "Result order: relevance (default), time (earliest first), seats (most open first), code."
+  ),
+  explain: z2.boolean().default(false).describe("Include multi-signal match explanations per hit."),
+  exclude_conflicts_with: z2.array(z2.string()).optional().describe(
+    "Canonical section IDs in the searched term; overlapping hits are dropped. An unresolvable anchor is an error, never a silent no-op."
+  ),
+  allow_term_fallback: z2.boolean().default(false).describe(
+    "When the requested term is unpublished, serve the newest available term instead and say so. Default false: an unpublished term is an error naming the available terms."
+  ),
+  limit: z2.number().int().min(1).max(50).default(10),
+  offset: z2.number().int().min(0).default(0)
+}).strict();
+var getInputSchema = z2.object({
+  ids: z2.array(z2.string()).min(1).max(20).describe("Canonical section IDs, e.g. 'CSCI 051 PO-01 FA2026'."),
+  term: z2.string().optional().describe("Term hint when IDs carry no term."),
+  allow_term_fallback: z2.boolean().default(false)
+}).strict();
+var checkInputSchema = z2.object({
+  ids: z2.array(z2.string()).min(1).max(20).describe(
+    "Section IDs to audit together. Every ID must resolve exactly; unknown IDs fail the whole call."
+  ),
+  term: z2.string().optional().describe("Term code, e.g. 'FA2026'."),
+  passing_minutes: z2.number().int().min(0).max(60).default(10).describe("Minimum acceptable gap between consecutive classes."),
+  allow_term_fallback: z2.boolean().default(false)
+}).strict();
+var termsInputSchema = z2.object({
+  limit: z2.number().int().min(1).max(20).default(6).describe("Most recent N terms.")
+}).strict();
+var historyInputSchema = z2.object({
+  code: z2.string().describe("Course code without section, e.g. 'ECON 101', 'CSCI 151'."),
+  schools: z2.array(z2.enum(SCHOOLS)).optional().describe(
+    "Filter to campuses. CM is canonical for Claremont McKenna; CMC accepted as alias."
+  ),
+  limit: z2.number().int().min(1).max(12).default(6),
+  term: z2.string().optional().describe(
+    "Term code anchoring instructor/seat enrichment, e.g. 'FA2026'. Defaults to current."
+  ),
+  allow_term_fallback: z2.boolean().default(false)
+}).strict();
+var meetingBlockSchema = z2.object({
+  days: z2.string().describe("Merged day letters for one meeting block."),
+  start: z2.string().describe("'HH:MM'"),
+  end: z2.string().describe("'HH:MM'"),
+  location: z2.string().nullable()
+}).strict();
+var compactHitSchema = z2.object({
+  id: z2.string(),
+  term: z2.string(),
+  school: z2.string(),
+  code: z2.string(),
+  section: z2.string(),
+  title: z2.string(),
+  instructors: z2.array(z2.string()),
+  days: z2.string().describe('Merged across meetings; "" when TBA.'),
+  start: z2.string().nullable(),
+  end: z2.string().nullable(),
+  meetings: z2.array(meetingBlockSchema).describe("Per-block truth; the summary above may combine blocks."),
+  credits: z2.number(),
+  potential_error: z2.boolean().describe("Source data flagged unreliable; verify before relying on it."),
+  seats_open: z2.number(),
+  seats_total: z2.number(),
+  status: z2.string().describe("O=Open C=Closed R=Reopened U=unknown."),
+  match: z2.object({ score: z2.number(), why: z2.array(z2.string()) }).strict(),
+  fetched_at: z2.string(),
+  stale: z2.boolean()
+}).strict();
+var searchOutputSchema = z2.object({
+  term: z2.string(),
+  total_count: z2.number(),
+  has_more: z2.boolean(),
+  next_offset: z2.number().nullable(),
+  hits: z2.array(compactHitSchema),
+  hint: z2.string().nullable(),
+  suggestions: z2.array(z2.string()),
+  snapshot_id: z2.string().nullable().describe("Compare across pages: a change means the snapshot rotated."),
+  applied_filters: z2.record(z2.string(), z2.unknown()).describe("Filters as resolved, including the serving term."),
+  seats_note: z2.string(),
+  ...ingestFields,
+  fallback: fallbackSchema.optional(),
+  warning: z2.string().optional()
+}).strict();
+var getOutputSchema = z2.object({
+  classes: z2.array(sectionSchema),
+  not_found: z2.array(z2.string()),
+  ambiguous: z2.array(
+    z2.object({ input: z2.string(), section_ids: z2.array(z2.string()) }).strict()
+  ).describe("Loose inputs matching several sections; ask the user which."),
+  suggestions: z2.array(
+    z2.object({ input: z2.string(), ids: z2.array(z2.string()) }).strict()
+  ),
+  terms: z2.array(termProvenanceSchema).describe("One entry per snapshot used, in resolution order."),
+  ...ingestFields,
+  fallback: fallbackSchema.optional(),
+  warning: z2.string().optional()
+}).strict();
+var checkOutputSchema = z2.object({
+  ok: z2.boolean().describe("No hard conflicts and no closed sections."),
+  complete: z2.boolean().describe(
+    "False when some inputs could not be fully audited (TBA times, flagged data). ok:true never implies a complete audit."
+  ),
+  skipped_tba: z2.array(z2.string()).describe("Sections with unknown meeting times; not conflict-checked."),
+  total_credits: z2.number(),
+  class_count: z2.number(),
+  conflicts: z2.array(
+    z2.object({
+      a: z2.string(),
+      b: z2.string(),
+      days: z2.array(z2.string()),
+      overlap: z2.string(),
+      overlap_minutes: z2.number(),
+      severity: z2.enum(["hard", "tight"])
+    }).strict()
+  ),
+  travel_warnings: z2.array(
+    z2.object({
+      from: z2.string(),
+      to: z2.string(),
+      from_school: z2.string(),
+      to_school: z2.string(),
+      gap_minutes: z2.number(),
+      message: z2.string()
+    }).strict()
+  ),
+  seat_problems: z2.array(
+    z2.object({ id: z2.string(), reason: z2.string() }).strict()
+  ),
+  warnings: z2.array(z2.string()),
+  weekly_grid: z2.string(),
+  checked: z2.array(z2.string()).describe("Section IDs that were audited."),
+  terms: z2.array(termProvenanceSchema),
+  ...ingestFields,
+  fallback: fallbackSchema.optional(),
+  warning: z2.string().optional()
+}).strict();
+var termsOutputSchema = z2.object({
+  current_term: z2.string(),
+  terms: z2.array(
+    z2.object({
+      code: z2.string(),
+      label: z2.string(),
+      year: z2.number(),
+      term: z2.string(),
+      is_current: z2.boolean()
+    }).strict()
+  )
+}).strict();
+var historyOutputSchema = z2.object({
+  code: z2.string(),
+  offerings: z2.array(
+    z2.object({
+      term: z2.string(),
+      instructors: z2.array(z2.string()),
+      campus: z2.string(),
+      seats: z2.object({ capacity: z2.number(), enrolled: z2.number() }).strict().nullable()
+    }).strict()
+  ),
+  rotation_note: z2.string().describe("Describes the window actually observed."),
+  verdict: z2.string(),
+  fetched_at: z2.string().describe("Freshness of the offering-history source."),
+  stale: z2.boolean(),
+  snapshot_term: z2.string(),
+  enrichment: z2.object({
+    term: z2.string(),
+    fetched_at: z2.string(),
+    stale: z2.boolean()
+  }).strict().nullable().optional().describe("Freshness of the sections snapshot used for seats."),
+  fallback: fallbackSchema.optional(),
+  warning: z2.string().optional()
+}).strict();
+
+// src/text.ts
+function provenanceLines(p) {
+  const out = [];
+  if (p.fallback) {
+    out.push(
+      `Note: term ${p.fallback.requested} is not published; showing ${p.fallback.served}.`
+    );
+  } else if (p.warning) {
+    out.push(`Note: ${p.warning}`);
+  }
+  const stale = p.stale ? " (STALE)" : "";
+  out.push(
+    `Seats as of ${p.fetched_at}${stale} \u2014 verify in CX before enrolling.`
+  );
+  if (p.quarantined > 0) {
+    out.push(
+      `Coverage warning: ${p.quarantined} row(s) were dropped at ingest \u2014 results may be incomplete.`
+    );
+  }
+  if (p.duplicate_ids > 0) {
+    out.push(
+      `Coverage note: ${p.duplicate_ids} row(s) collapsed onto an existing ID at ingest (same dept/number/school/section).`
+    );
+  }
+  return out;
+}
+function moreLine(has_more, next_offset) {
+  if (!has_more || next_offset === null) return null;
+  return `More results: call again with offset ${next_offset}.`;
+}
+function searchText(p) {
+  const lines = [];
+  if (p.total_count === 0) {
+    lines.push(`No matches in ${p.term}.`);
+    lines.push(`Filters applied: ${JSON.stringify(p.applied_filters)}.`);
+  } else {
+    lines.push(
+      `${p.total_count} match(es) in ${p.term} (showing ${p.hits.length}, as of ${p.fetched_at}).`
+    );
+    for (const h of p.hits) {
+      const seats = `${h.seats_open}/${h.seats_total} open`;
+      const credits = h.credits > 0 ? `, ${h.credits} cr` : "";
+      const flagged = h.potential_error ? " [source data flagged]" : "";
+      lines.push(
+        `- ${h.id} \u2014 ${h.title} [${h.status}${credits}, ${seats}]${flagged}`
+      );
+      const meets = h.meetings.length > 0 ? h.meetings.map(
+        (m) => `${m.days || "TBA"} ${m.start}-${m.end}${m.location ? ` @ ${m.location}` : ""}`
+      ).join("; ") : "TBA (no scheduled meeting time)";
+      lines.push(`  Meets: ${meets}`);
+    }
+  }
+  if (p.hint) lines.push(p.hint);
+  const more = moreLine(p.has_more, p.next_offset);
+  if (more) lines.push(more);
+  for (const s of p.suggestions) lines.push(`Suggestion: ${s}`);
+  if (p.snapshot_id)
+    lines.push(
+      `Snapshot: ${p.snapshot_id} (same id across pages = same data).`
+    );
+  lines.push(...provenanceLines(p));
+  return lines.join("\n");
+}
+function getText(p) {
+  const lines = [];
+  for (const amb of p.ambiguous) {
+    lines.push(
+      `AMBIGUOUS: '${amb.input}' matches ${amb.section_ids.length} sections. Ask the user which, or pass a full ID: ${amb.section_ids.join(" | ")}`
+    );
+  }
+  if (p.not_found.length > 0) {
+    const sug = p.suggestions.filter((s) => p.not_found.includes(s.input)).map((s) => `${s.input} \u2192 ${s.ids.join(", ")}`).join("; ");
+    lines.push(
+      `NOT FOUND: ${p.not_found.join(", ")}.${sug ? ` Closest: ${sug}.` : ""} Search first, then pass IDs verbatim.`
+    );
+  }
+  for (const c of p.classes) {
+    const meets = c.meetings.length > 0 ? c.meetings.map(
+      (m) => `${m.days.join("")} ${m.start12}\u2013${m.end12} @ ${m.locations.join("; ") || "TBA"}`
+    ).join("\n  ") : "TBA";
+    lines.push(
+      `- ${c.id} \u2014 ${c.title} [${c.statusLabel}] ${c.credits} credit(s)`,
+      `  Meets: ${meets}`,
+      `  Seats: ${c.seats.available} open (${c.seats.filled}/${c.seats.total}; ${c.seats.permCount} instructor permits, not waitlist)`,
+      `  Instructors: ${c.instructors.join(", ") || "staff TBD"}`,
+      `  Areas: ${c.areas.join(", ") || "\u2014"} | Dates: ${c.startDate} \u2192 ${c.endDate}`,
+      `  ${c.description.split("\n")[0] ?? ""}`
+    );
+    if (c.potentialError) {
+      lines.push(`  Warning: source data for ${c.id} is flagged unreliable.`);
+    }
+    if (p.terms.length > 1) {
+      const t = p.terms.find((x) => x.term === c.term);
+      if (t?.stale) lines.push(`  Note: ${c.term} snapshot is stale.`);
+    }
+  }
+  for (const t of p.terms) {
+    lines.push(`${t.term}: as of ${t.fetched_at}${t.stale ? " (STALE)" : ""}`);
+  }
+  lines.push(...provenanceLines(p));
+  return lines.join("\n");
+}
+function checkText(p) {
+  const lines = [];
+  const completeness = p.complete ? "audit complete" : `audit INCOMPLETE \u2014 ${p.skipped_tba.length} section(s) have unknown meeting times`;
+  lines.push(
+    p.ok ? `OK: no hard conflicts and no closed sections (${p.class_count} classes, ${p.total_credits} credits; ${completeness}).` : `NOT OK (${p.class_count} classes, ${p.total_credits} credits; ${completeness}).`
+  );
+  if (p.skipped_tba.length > 0) {
+    lines.push(
+      `Not checked (TBA times): ${p.skipped_tba.join(", ")}. TBA is absence of evidence, not evidence of a free slot.`
+    );
+  }
+  if (p.conflicts.length > 0) {
+    lines.push(
+      `Conflicts: ${p.conflicts.map(
+        (c) => `[${c.severity}] ${c.a} vs ${c.b} (${c.days.join("")} ${c.overlap})`
+      ).join("; ")}.`
+    );
+  } else {
+    lines.push("No time conflicts among the sections with known times.");
+  }
+  for (const t of p.travel_warnings) lines.push(`Travel: ${t.message}`);
+  if (p.seat_problems.length > 0) {
+    lines.push(
+      `Seats: ${p.seat_problems.map((s) => `${s.id} \u2014 ${s.reason}`).join("; ")}.`
+    );
+  }
+  for (const w of p.warnings) lines.push(`Warning: ${w}`);
+  lines.push(`Checked: ${p.checked.join(", ")}`);
+  lines.push(...provenanceLines(p));
+  return lines.join("\n");
+}
+function termsText(p) {
+  return `Current: ${p.current_term}. Terms: ${p.terms.map((t) => `${t.code} (${t.label})`).join(", ")}.`;
+}
+function historyText(p) {
+  const lines = [];
+  lines.push(`${p.code}: ${p.verdict}`);
+  lines.push(p.rotation_note);
+  if (p.offerings.length === 0) {
+    lines.push("No prior offerings found in the history source.");
+  } else {
+    for (const o of p.offerings) {
+      const seats = o.seats ? `${o.seats.enrolled}/${o.seats.capacity} enrolled` : "seats unknown";
+      lines.push(
+        `- ${o.term} @ ${o.campus} \u2014 ${o.instructors.join(", ") || "staff TBD"} (${seats})`
+      );
+    }
+  }
+  lines.push(`History as of ${p.fetched_at}${p.stale ? " (STALE)" : ""}.`);
+  if (p.enrichment) {
+    lines.push(
+      `Seats enriched from ${p.enrichment.term} snapshot as of ${p.enrichment.fetched_at}${p.enrichment.stale ? " (STALE)" : ""}.`
+    );
+  }
+  if (p.fallback) {
+    lines.push(
+      `Note: term ${p.fallback.requested} is not published; showing ${p.fallback.served}.`
+    );
+  } else if (p.warning) {
+    lines.push(`Note: ${p.warning}`);
+  }
+  return lines.join("\n");
+}
+
+// src/server.ts
+var VERSION = packageVersion();
+var SEATS_NOTE = "Seats are a snapshot; verify in CX before enrolling.";
+var READONLY = { readOnlyHint: true, openWorldHint: true };
+var MAX_BODY_BYTES = 1 * 1024 * 1024;
+function packageVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(new URL("../package.json", import.meta.url), "utf8")
+    );
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var INSTRUCTIONS = `5C course search (Pomona, CM/Claremont McKenna, Harvey Mudd, Scripps, Pitzer).
+Workflow: list_terms if the term is vague -> search_classes (limit 10) -> get_classes to expand -> check_schedule to validate.
+Page with offset/next_offset/has_more (+total_count); don't widen queries. Seats are snapshots: always state fetched_at ("as of ..."). Never promise enrollment.
+Honesty rules: an unpublished term is an error, not a substitution, unless you pass allow_term_fallback. check_schedule ok:true does not mean complete:true \u2014 TBA sections are not checked. Report quarantined > 0 as incomplete coverage.`;
+function createMcpServer() {
+  const server = new McpServer(
+    { name: "5c-index", version: VERSION },
+    { instructions: INSTRUCTIONS }
+  );
+  registerTools(server);
+  return server;
+}
+function okPayload(payload) {
+  return { structuredContent: payload };
+}
+function registerTools(server) {
+  server.registerTool(
+    "search_classes",
+    {
+      title: "Search 5C Classes",
+      description: `Search current/upcoming 5C course offerings by keyword, department, campus, time, instructor, seats. USE for all discovery queries ('CS classes at Mudd Tuesday afternoons with open seats'). Do NOT use to validate a fixed schedule (use check_schedule) or for full details (use get_classes with returned IDs). Trust registrar status (O/C/R), not seat arithmetic: availability:"has_seat" means the registrar says registrable. TBA sections never match day/time filters. Unknown parameters are rejected \u2014 use availability (not open_only) and instructor singular (not instructors). Example: {"query":"microeconomics","schools":["PO","CM"],"term":"FA2026","availability":"has_seat","limit":10}.`,
+      inputSchema: searchInputSchema,
+      outputSchema: searchOutputSchema,
+      annotations: { ...READONLY }
+    },
+    async (args) => {
+      try {
+        const credits = args.credits_min !== void 0 || args.credits_max !== void 0 ? `${args.credits_min ?? 0}-${args.credits_max ?? 999}` : void 0;
+        const { result, normalized, meta, fallback, warning } = await searchClasses(args.query ?? "", {
+          term: args.term,
+          schools: args.schools,
+          depts: args.departments,
+          code: args.code,
+          days: args.days?.join(""),
+          after: args.starts_after,
+          before: args.ends_before,
+          instructor: args.instructor,
+          areas: args.course_areas,
+          open: args.availability === "has_seat" ? true : void 0,
+          credits,
+          sort: args.sort,
+          explain: args.explain,
+          excludeConflictsWith: args.exclude_conflicts_with,
+          limit: args.limit,
+          offset: args.offset,
+          allowTermFallback: args.allow_term_fallback
+        });
+        const payload = {
+          term: result.term,
+          total_count: result.total,
+          has_more: result.has_more,
+          next_offset: result.next_offset,
+          hits: result.hits,
+          hint: result.hint,
+          suggestions: result.suggestions,
+          snapshot_id: result.snapshot_id,
+          applied_filters: normalized,
+          seats_note: SEATS_NOTE,
+          fetched_at: meta.fetched_at,
+          stale: meta.stale,
+          quarantined: meta.quarantined,
+          duplicate_ids: meta.duplicate_ids,
+          ...fallback ? { fallback } : {},
+          ...warning ? { warning } : {}
+        };
+        return {
+          content: [{ type: "text", text: searchText(payload) }],
+          ...okPayload(payload)
+        };
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "get_classes",
+    {
+      title: "Get Class Details",
+      description: 'Fetch full details for 1-20 class IDs from a prior search_classes call (description, seats, all meeting blocks, areas, dates). USE to expand hits before presenting or before check_schedule. Do NOT use for discovery \u2014 requires IDs. Unknown IDs come back in not_found with suggestions; loose IDs that match several sections come back in ambiguous (ask the user, never pick for them). Example: {"ids":["CSCI 051 PO-01 FA2026"]}.',
+      inputSchema: getInputSchema,
+      outputSchema: getOutputSchema,
+      annotations: { ...READONLY }
+    },
+    async (args) => {
+      try {
+        const { result, meta, fallback, warning } = await getClasses(args.ids, {
+          term: args.term,
+          allowTermFallback: args.allow_term_fallback
+        });
+        const payload = {
+          classes: result.classes,
+          not_found: result.not_found,
+          ambiguous: result.ambiguous,
+          suggestions: result.suggestions,
+          terms: result.terms,
+          fetched_at: meta.fetched_at,
+          stale: meta.stale,
+          quarantined: meta.quarantined,
+          duplicate_ids: meta.duplicate_ids,
+          ...fallback ? { fallback } : {},
+          ...warning ? { warning } : {}
+        };
+        const nothingResolved = payload.classes.length === 0;
+        return {
+          content: [{ type: "text", text: getText(payload) }],
+          ...okPayload(payload),
+          ...nothingResolved ? { isError: true } : {}
+        };
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "check_schedule",
+    {
+      title: "Check Schedule Conflicts",
+      description: `Audit 1-20 class IDs for time conflicts, cross-campus travel risk, credit totals, and closed sections. USE whenever the user asks 'can I take A+B?', 'does this schedule work?'. Do NOT use for finding classes. The server does all time math \u2014 never compute overlaps yourself. Read complete/skipped_tba: TBA sections are not checked, so ok:true with complete:false is a partial answer. Half-semester sections only conflict on overlapping dates. Example: {"ids":["CSCI 051 PO-01 FA2026","MATH 031 PO-02 FA2026"],"term":"FA2026"}.`,
+      inputSchema: checkInputSchema,
+      outputSchema: checkOutputSchema,
+      annotations: { ...READONLY }
+    },
+    async (args) => {
+      try {
+        const { result, resolved, meta, terms, fallback, warning } = await checkScheduleByIds(args.ids, {
+          term: args.term,
+          passingMinutes: args.passing_minutes,
+          allowTermFallback: args.allow_term_fallback
+        });
+        const payload = {
+          ok: result.ok,
+          complete: result.complete,
+          skipped_tba: result.skipped_tba,
+          total_credits: result.total_credits,
+          class_count: result.class_count,
+          conflicts: result.conflicts,
+          travel_warnings: result.travel_warnings,
+          seat_problems: result.seat_problems,
+          warnings: result.warnings,
+          weekly_grid: result.weekly_grid,
+          checked: resolved,
+          terms,
+          fetched_at: meta.fetched_at,
+          stale: meta.stale,
+          quarantined: meta.quarantined,
+          duplicate_ids: meta.duplicate_ids,
+          ...fallback ? { fallback } : {},
+          ...warning ? { warning } : {}
+        };
+        return {
+          content: [{ type: "text", text: checkText(payload) }],
+          ...okPayload(payload)
+        };
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "list_terms",
+    {
+      title: "List Academic Terms",
+      description: "List available term codes with labels (e.g. FA2026 = Fall 2026). USE first when the user's term is ambiguous ('next semester', 'fall') or before search_classes with an explicit term. Do NOT call repeatedly \u2014 cache the result for the session. Example: {}.",
+      inputSchema: termsInputSchema,
+      outputSchema: termsOutputSchema,
+      annotations: { ...READONLY }
+    },
+    async (args) => {
+      try {
+        const { current, available } = await listTerms({ limit: args.limit });
+        const payload = {
+          current_term: current,
+          terms: available
+        };
+        return {
+          content: [{ type: "text", text: termsText(payload) }],
+          ...okPayload(payload)
+        };
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "get_course_history",
+    {
+      title: "Get Course History",
+      description: `Show past offerings of a course across terms (instructors, terms offered, rotation signal). USE for 'who usually teaches X?', 'how often is X offered?', 'is it likely in spring?'. Do NOT use for current availability (use search_classes). The rotation_note names the window actually observed \u2014 never claim a pattern the note does not support. Example: {"code":"ECON 101","schools":["PO"]}.`,
+      inputSchema: historyInputSchema,
+      outputSchema: historyOutputSchema,
+      annotations: { ...READONLY }
+    },
+    async (args) => {
+      try {
+        const h = await getCourseHistory(args.code, {
+          campuses: args.schools,
+          limit: args.limit,
+          term: args.term,
+          allowTermFallback: args.allow_term_fallback
+        });
+        const payload = {
+          code: h.code,
+          offerings: h.offerings,
+          rotation_note: h.rotation_note,
+          verdict: h.verdict,
+          fetched_at: h.fetched_at,
+          stale: h.stale,
+          snapshot_term: h.snapshot_term,
+          ...h.enrichment ? { enrichment: h.enrichment } : {},
+          ...h.fallback ? { fallback: h.fallback } : {},
+          ...h.warning ? { warning: h.warning } : {}
+        };
+        return {
+          content: [{ type: "text", text: historyText(payload) }],
+          ...okPayload(payload)
+        };
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
+}
+async function serveStdio() {
+  await createMcpServer().connect(new StdioServerTransport());
+}
+async function serveHttp(host, port) {
+  const httpServer = createServer(async (req, res) => {
+    if (req.method !== "POST" || req.url?.split("?")[0] !== "/mcp") {
+      res.writeHead(req.method === "POST" ? 404 : 405, {
+        "Content-Type": "application/json"
+      });
+      res.end(JSON.stringify({ error: "Use POST /mcp" }));
+      return;
+    }
+    try {
+      let size = 0;
+      const body = await new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (c) => {
+          size += c.length;
+          if (size > MAX_BODY_BYTES) {
+            reject(
+              Object.assign(new Error("Request body too large"), {
+                code: "E_TOO_LARGE"
+              })
+            );
+            req.destroy();
+            return;
+          }
+          chunks.push(c);
+        });
+        req.on("end", () => {
+          try {
+            resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+          } catch (e) {
+            reject(e);
+          }
+        });
+        req.on("error", reject);
+      });
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0
+        // stateless
+      });
+      await createMcpServer().connect(transport);
+      await transport.handleRequest(req, res, body);
+    } catch (err) {
+      const tooLarge = err.code === "E_TOO_LARGE";
+      console.error("MCP HTTP error:", err);
+      if (!res.headersSent) {
+        res.writeHead(tooLarge ? 413 : 500, {
+          "Content-Type": "application/json"
+        });
+        res.end(
+          JSON.stringify({
+            error: tooLarge ? "Body too large" : "Internal error"
+          })
+        );
+      }
+    }
+  });
+  httpServer.listen(port, host, () => {
+    const bound = httpServer.address();
+    const actual = typeof bound === "object" && bound ? bound.port : port;
+    console.error(
+      `5c-mcp listening (stateless Streamable HTTP) on http://${host}:${actual}/mcp`
+    );
+  });
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (!args.includes("--http")) {
+    await serveStdio();
+    return;
+  }
+  const argValue = (flag) => {
+    const i = args.indexOf(flag);
+    return i >= 0 ? args[i + 1] : void 0;
+  };
+  const rawPort = argValue("--port");
+  const port = rawPort !== void 0 ? Number.parseInt(rawPort, 10) : 3e3;
+  const binding = Number.isFinite(port) ? port : 3e3;
+  const host = argValue("--host") ?? "127.0.0.1";
+  await serveHttp(host, binding);
+}
+var isDirectRun = (() => {
+  const argv1 = process.argv[1];
+  if (!argv1) return false;
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(argv1)).href;
+  } catch {
+    return import.meta.url === pathToFileURL(argv1).href;
+  }
+})();
+if (isDirectRun) {
+  main().catch((err) => {
+    console.error("5c-mcp fatal:", err);
+    process.exit(1);
+  });
+}
+export {
+  createMcpServer,
+  isDirectRun
+};