@equationalapplications/core-llm-wiki 7.11.2 → 7.13.0

package/dist/{testing-B0UtFCq1.d.mts → testing-CqsXv2_l.d.mts}

@@ -209,6 +209,10 @@ interface HealResult {
      * cooldown", not "there is no more work" — it climbs back as the cooldown lapses
      * and as new facts are written. A host loop terminates, but it converges to
      * "corpus swept once this cooldown window", not to a drained queue.
+     *
+     * A pass that could not make progress (`searchUnavailable` or `budgetStop`
+     * set) leaves `remaining > 0`, so a convergence loop must also stop on those:
+     * `while (r.remaining > 0 && !r.searchUnavailable && !r.budgetStop)`.
      */
     remaining: number;
     /** Heal candidates inside the recheck cooldown. */
@@ -217,6 +221,12 @@ interface HealResult {
     budgetStop?: {
         requiredEstimate: number;
     };
+    /**
+     * True when the LLM pass was skipped because keyword search is unavailable
+     * (heal anchors need it; spec #280). Candidates stay eligible and unattempted;
+     * retry after `syncSearchIndex()` restores keyword search.
+     */
+    searchUnavailable?: true;
 }
 /**
  * Opt-in evidence check for LLM-authored facts (spec §6). Default off: 7.x
@@ -324,6 +334,12 @@ interface WikiConfig {
      * entries table, so memory stays flat at any size. The first `setup()` that
      * attaches FTS5 to an existing database rebuilds the index in one
      * transaction, holding the write lock for its whole duration.
+     * If FTS5 init fails under `'auto'`, `setup()` retries once after 250 ms and
+     * then completes with keyword search unavailable (queries throw
+     * `WikiSearchUnavailableError`); it never demotes to MiniSearch. MiniSearch
+     * is used only when pinned or when the SQLite build lacks FTS5/json1, and it
+     * holds all entry text in the JS heap: the measured ceiling is ~1M entries
+     * on a default Node heap (raise `--max-old-space-size` for larger stores).
      * @default 'auto'
      */
     indexStrategy?: 'fts5' | 'minisearch' | 'auto';
@@ -355,6 +371,27 @@ interface WikiConfig {
     maintenance?: 'auto' | 'deferred';
     /** `'auto'` mode only: also trigger the librarian when pending event text reaches ~this many tokens (chars/4). */
     autoLibrarianTokenThreshold?: number;
+    /**
+     * Migration policy for setup().
+     * - `'allow'`: Run all migrations (default, preserves existing behavior)
+     * - `'refuse'`: Throw WikiMigrationRequiredError before any mutations
+     * - `'auto'`: Run the source_ref normalize if pending; throw if a schema migration is pending
+     * @default 'allow'
+     */
+    migrations?: MigrationPolicy;
+    /**
+     * Wall-time budget (ms) for each keyword-index quantum: one per `setup()`
+     * (shared by the whole open — the deadline is captured when setup() starts)
+     * and one per no-arg `syncSearchIndex()`. Checked between chunk
+     * transactions, so one quantum can overrun it by up to two chunks. Ids a
+     * write stashed for the call (see `upsertGraph`) drain before the quantum
+     * and outside the budget. An index reset runs as one unchunked transaction and is
+     * not bounded by it either.
+     * Convergence of a large backlog or rebuild continues on later opens and
+     * `syncSearchIndex()` calls. Must be a positive finite number.
+     * @default 1500 (DEFAULT_SETUP_BUDGET_MS)
+     */
+    setupBudgetMs?: number;
 }
 interface ReadOptions {
     maxResults?: number;
@@ -1266,6 +1303,12 @@ interface EntityMaintenanceReport {
     reembedded: boolean;
     /** Set when a lock was held elsewhere; nothing ran for that job. */
     busy?: MaintenanceJob[];
+    /**
+     * Set when keyword search is unavailable and the job could not run for this
+     * entity (spec #280). Its watermark/checkpoint is kept; retry after
+     * `syncSearchIndex()` restores keyword search.
+     */
+    searchUnavailable?: MaintenanceJob[];
 }
 interface RunPendingMaintenanceResult {
     perEntity: EntityMaintenanceReport[];
@@ -1276,6 +1319,33 @@ interface RunPendingMaintenanceResult {
     remaining: number | null;
     stoppedReason: MaintenanceStopReason;
 }
+type MigrationPolicy = 'allow' | 'refuse' | 'auto';
+/** Work the migration gate found pending on an existing store. Watermarks are resume rowids (0 = not started). */
+type PendingMigrationWork = {
+    type: 'schema_migration';
+    fromVersion: number;
+    toVersion: number;
+} | {
+    type: 'source_ref_normalize';
+    entriesWatermark: number;
+    sourceRefIndexWatermark: number;
+};
+declare class WikiMigrationRequiredError extends Error {
+    readonly code = "WIKI_MIGRATION_REQUIRED";
+    readonly pendingWork: PendingMigrationWork;
+    constructor(message: string, pendingWork: PendingMigrationWork);
+}
+/**
+ * Thrown per keyword-search query while the keyword index is unavailable
+ * (FTS5 init failed after its retry; spec #280 Change 4). Writes keep working
+ * and the index converges once a later open or no-arg syncSearchIndex()
+ * re-inits successfully. `cause` is the underlying init error.
+ */
+declare class WikiSearchUnavailableError extends Error {
+    constructor(message?: string, cause?: unknown);
+}
+/** Proxy-safe `instanceof WikiSearchUnavailableError` (issue #96). */
+declare function isWikiSearchUnavailableError(err: unknown): boolean;
 
 interface WikiOutboxEvent<T = unknown> {
     id: string;
@@ -1395,6 +1465,8 @@ declare class EntryRepository extends BaseRepository {
     private static readonly MINI_SEARCH_LIVE_WHERE;
     private chunkSize;
     constructor(db: SQLiteAdapter, prefix: string, outbox: OutboxRepository);
+    /** Whether the entity has any non-deleted row (librarian gate: keyword ranking over zero facts is trivially empty). */
+    hasLiveEntry(entityId: string, tx?: SQLiteAdapter): Promise<boolean>;
     /**
      * Fetch facts by IDs, optionally scoped to entity IDs.
      * Returns facts in the order of the input IDs (first match wins).
@@ -1653,11 +1725,6 @@ declare class EntryRepository extends BaseRepository {
     hasLegacySourceTypes(tx?: SQLiteAdapter): Promise<boolean>;
     countLegacySourceTypes(tx?: SQLiteAdapter): Promise<number>;
     findAllForReembed(entityId?: string, tx?: SQLiteAdapter): Promise<ReembedCandidateRow[]>;
-    findRowsForSourceRefMigration(tx?: SQLiteAdapter): Promise<Array<{
-        rowid: number;
-        source_ref: string;
-    }>>;
-    updateSourceRefByRowid(rowid: number, sourceRef: string | null, tx: SQLiteAdapter): Promise<void>;
     findLatestSourceHash(entityId: string, sourceRef: string, tx?: SQLiteAdapter): Promise<string | null>;
     /**
      * Batch version of {@link findLatestSourceHash}. Returns a Map covering every
@@ -1972,6 +2039,25 @@ interface IndexSearchResult {
      */
     entity_id: string;
 }
+/** One drain turn's shape (spec #280 Change 3 "drain interface"). */
+interface DrainOptions {
+    /** `monotonicNow()` timestamp, checked between chunk transactions. Full mode only; default now + the strategy's budget. */
+    deadline?: number;
+    /**
+     * `'ledger'` (write turns): `ids` to completion, then at most ONE foreign
+     * chunk. `'full'` (setup(), no-arg syncSearchIndex()): `ids`, then the
+     * ledger until the deadline, then rebuild work. Default `'full'`.
+     */
+    mode?: 'ledger' | 'full';
+    /**
+     * The caller's own ledger ids: drained first, to completion, ≤500 per
+     * transaction. Not deadline-bound: the cost is proportional to a write the
+     * caller already made.
+     */
+    ids?: readonly string[];
+    /** With empty `ids` in ledger mode, the one foreign chunk is `fts_pending WHERE entity_id = ?`. */
+    entityId?: string;
+}
 /**
  * Keyword-index abstraction. The strategy owns its own backing store
  * (in-RAM MiniSearch vs on-disk FTS5) and is responsible for keeping it
@@ -2038,8 +2124,11 @@ interface IndexStrategy {
     /**
      * Create or verify the strategy's backing schema and run state changes.
      * Called once by `createIndexStrategy`, before the strategy is installed.
+     * `entriesExisted: false` marks a store `setup()` just created: FTS starts `live` with nothing to index.
      */
-    init?(): Promise<void>;
+    init?(opts?: {
+        entriesExisted?: boolean;
+    }): Promise<void>;
     /**
      * Apply every change recorded in the strategy's durable ledger, in bounded
      * chunks. A strategy that implements this keeps itself consistent with
@@ -2048,9 +2137,7 @@ interface IndexStrategy {
      * called from inside a `withTransactionAsync` callback; it opens its own
      * transactions.
      */
-    drain?(): Promise<void>;
-    /** Rebuild entirely in SQL from the source tables; no rows pass through JS. */
-    rebuildFromSource?(): Promise<void>;
+    drain?(opts?: DrainOptions): Promise<void>;
 }
 
 interface ScoredRow {
@@ -2123,10 +2210,15 @@ declare class SearchService {
      * service runs on an empty MiniSearch placeholder, as it always has.
      */
     setIndexStrategy(strategy: IndexStrategy): void;
+    /** False while the installed strategy is the degraded UnavailableIndexStrategy (spec #280 Change 4). */
+    isKeywordAvailable(): boolean;
+    /** True when the installed strategy drains a durable ledger (FTS5, or the degraded stand-in). */
+    hasLedger(): boolean;
     /**
      * One serialized drain turn for strategies with a durable ledger. Like
      * sync(), it never rejects: the keyword index is rebuildable, and a failed
-     * drain leaves the ledger rows in place for the next turn.
+     * drain leaves the ledger rows in place for the next turn. Resolves false
+     * when the drain failed.
      */
     private drainTurn;
     /**
@@ -2136,8 +2228,17 @@ declare class SearchService {
      * Rebuilds are serialized per instance and never reject: the keyword index
      * is a rebuildable cache over SQLite, so degraded keyword search is the
      * correct failure mode and killing the host process is not.
+     *
+     * With a ledger strategy, `sync()` runs one full quantum bounded by
+     * `opts.deadline`; `sync(entityId)` is a write turn (ledger only).
+     * `opts.ids` are the caller's touched ids: a ledger strategy drains them
+     * first, to completion; MiniSearch ignores them and rebuilds the entity in
+     * one scan.
      */
-    sync(entityId?: string): Promise<void>;
+    sync(entityId?: string, opts?: {
+        deadline?: number;
+        ids?: readonly string[];
+    }): Promise<void>;
     /**
      * Re-indexes only `ids` for `entityId`: drops each from the index, then
      * re-adds the ones still live in SQLite, so soft-deleted or missing ids end
@@ -2149,8 +2250,11 @@ declare class SearchService {
      * — including on an empty `ids` list, which is a no-op only for an entity
      * the index already tracks, and even then one that waits for rebuilds
      * already queued on the chain.
+     *
+     * Resolves false only when a ledger drain failed: the caller's ids were not
+     * applied (their ledger rows remain), so a caller holding them retries.
      */
-    syncEntries(entityId: string, ids: Iterable<string>): Promise<void>;
+    syncEntries(entityId: string, ids: Iterable<string>): Promise<boolean>;
     /**
      * Forces the entity's next syncEntries to rebuild it in full. For writes core
      * cannot index itself, such as upsertGraph inside a host transaction.
@@ -2161,8 +2265,11 @@ declare class SearchService {
      * so only those entities are rebuilt. Each rebuild still takes its own turn
      * on the sync chain, and like syncEntries this never rejects. With nothing
      * stale it resolves at once, without waiting on work already on the chain.
+     * Resolves false only when a ledger drain failed (see syncEntries).
      */
-    syncStale(): Promise<void>;
+    syncStale(opts?: {
+        ids?: readonly string[];
+    }): Promise<boolean>;
     /**
      * Clears the parsed vector cache. Useful for mid-loop flush guarantees
      * or memory pressure evictions.
@@ -2754,7 +2861,8 @@ declare class IngestionService {
      *
      * @returns Counts: nodesWritten (validated nodes persisted), edgesWritten
      *   (manifest-valid edges persisted), superseded (prior facts soft-deleted
-     *   plus prior source-ref edges hard-deleted).
+     *   plus prior source-ref edges hard-deleted), and supersededFactIds (the
+     *   ids of those soft-deleted facts, for the caller's post-commit index sync).
      *
      * Node-ownership pre-flight (spec §3, REQ-GRAPH-01): the first statement
      * is `assertGraphNodeOwnership(entityId, params.nodes, tx)`, which runs
@@ -2795,6 +2903,7 @@ declare class IngestionService {
         nodesWritten: number;
         edgesWritten: number;
         superseded: number;
+        supersededFactIds: string[];
     }>;
     /**
      * Full supersession + ownership path: identical to the pre-issue-#92 behavior
@@ -3192,7 +3301,8 @@ declare class MaintenanceService {
      *
      * Bounded: at most `batchSize` candidates per pass (#67). Loop on
      * `result.remaining > 0` for convergence — see {@link HealResult.remaining}
-     * for what convergence means here.
+     * for what convergence means here, and for the no-progress flags
+     * (`searchUnavailable`, `budgetStop`) a loop must also stop on.
      */
     doRunHeal(entityId: string, options?: {
         promptOverride?: string;
@@ -3368,6 +3478,7 @@ declare class WriteService {
      * {@link write}) so a partial pass retries on the next write.
      */
     private maybeRunHeal;
+    private warnedSearchUnavailable;
     private reportBackgroundFailure;
 }
 
@@ -3457,7 +3568,52 @@ declare class WikiMemory {
      * If `NODE_ENV` is not `"test"`, emits a single `console.warn` per instance (skipped when `process` is undefined).
      */
     get __testAccess(): WikiMemoryTestAccess;
-    setup(): Promise<void>;
+    /** Max upsertGraph node ids held for their post-commit sync (spec #280 id threading). */
+    static readonly UPSERT_ID_STASH_CAP = 10000;
+    /**
+     * upsertGraph node and superseded-fact ids per entity, awaiting syncSearchIndex(), each with the
+     * generation of its latest stash. Ids leave the stash only once a drain
+     * succeeded, so a failed drain retries them next call.
+     */
+    private upsertIdStash;
+    /** Total ids across upsertIdStash, kept in step so the cap check is O(1). */
+    private upsertIdStashSize;
+    /** Bumped per stashed id; a re-stash during an in-flight drain outlives that drain's drop. */
+    private upsertIdStashGen;
+    private stashUpsertIds;
+    /** Snapshot of the stash (one entity, or all) with generations, without removing anything. */
+    private peekStashedIds;
+    /**
+     * Removes a drained snapshot. An id re-stashed after the peek has a newer
+     * generation and stays: the drain may have run before that write committed.
+     */
+    private dropStashedIds;
+    /** `config.setupBudgetMs` or the default, validated: a positive finite number. */
+    private setupBudgetMs;
+    private reinitSearch;
+    /** Monotonic time before which a no-arg syncSearchIndex() skips the re-init (0 = no cooldown). */
+    private reinitRetryAt;
+    /** Consecutive failed re-inits; drives the exponential backoff. */
+    private reinitFailures;
+    /**
+     * Opens the store: migration gate, DDL, schema migrations, then the stamped
+     * source_ref normalize. Await it before any other call on this instance — the
+     * normalize commits in chunks, so a sourceRef-keyed call (forget, upsertGraph,
+     * hasChanged, ingest) issued before setup() resolves can see partially
+     * normalized refs.
+     *
+     * Pass `{ migrations: 'refuse' }` from inside a writer lease: pending one-time
+     * work then throws WikiMigrationRequiredError before any mutation, and the
+     * host runs a plain `setup()` outside the lease.
+     *
+     * Keyword-index catch-up work is bounded by `config.setupBudgetMs`; anything
+     * left converges on later opens and no-arg `syncSearchIndex()` calls. Not
+     * bounded: an index reset (tokenizer change, re-attach after detach, a lost
+     * or inconsistent index), which runs as one unchunked transaction.
+     */
+    setup(opts?: {
+        migrations?: MigrationPolicy;
+    }): Promise<void>;
     hasChanged(entityId: string, sourceRef: string, sourceHash: string): Promise<boolean>;
     /**
      * Batched overload.
@@ -3640,11 +3796,18 @@ declare class WikiMemory {
      * commit, so without this the nodes stay out of keyword, hybrid and
      * fallback retrieval until the entity's next core write.
      *
-     * With `entityId`, rebuilds that entity if it is stale or has never been
-     * indexed; otherwise it is a no-op that still waits for rebuilds already
-     * queued. Without an argument, rebuilds every entity currently marked
-     * stale; when none is, it resolves immediately and does not wait for rebuilds
-     * already queued.
+     * With `entityId`: drains that entity's pending `upsertGraph` ids (its new
+     * nodes and the facts they superseded) first, to completion, then at most
+     * one more ledger chunk — so its new nodes are searchable, and the
+     * superseded facts gone, when the call resolves, under any backlog. Without an
+     * argument: drains every stashed `upsertGraph` id across entities first,
+     * then runs one keyword-index quantum bounded by `config.setupBudgetMs`
+     * (backlog drain, then rebuild work while the index is rebuilding). Hosts
+     * with a long-lived process should call the no-arg form on their own
+     * schedule: that is what converges a rebuilding index. While keyword search
+     * is unavailable it first retries the index init; after a failed attempt it
+     * waits at least 5 s, doubling per consecutive failure up to 5 min (longer
+     * when an attempt is itself slow), before retrying again.
      *
      * Call only after the host's transaction commits: called inside it, the
      * rebuild may index rows that later roll back, or miss them and clear the
@@ -3661,6 +3824,12 @@ declare class WikiMemory {
      * @throws {TypeError} when `entityId` is given but is not a non-empty string.
      */
     syncSearchIndex(entityId?: string): Promise<void>;
+    /**
+     * True when a sync applied the stashed ids. While keyword search is
+     * unavailable the stand-in strategy's drain is a no-op that reports success,
+     * so the ids stay stashed for the first sync after a re-init (#284 review).
+     */
+    private syncDrained;
     exportDump(entityIds?: string[]): Promise<MemoryDump>;
     /** Entity summary prose persisted from an OKF profile ≥ 1 import; null when none stored. */
     getEntitySummary(entityId: string): Promise<string | null>;
@@ -3726,7 +3895,10 @@ declare class WikiMemory {
      * post-commit work (search sync, embedding, cache eviction). After the
      * transaction commits, call `syncSearchIndex(entityId)` — or
      * `syncSearchIndex()` after writing several entities in one transaction —
-     * to make the new nodes keyword-searchable. Embeddings still come from the maintenance
+     * to make the new nodes keyword-searchable: both forms drain this call's node ids
+     * first, to completion, so the nodes are searchable under any backlog (up to
+     * `WikiMemory.UPSERT_ID_STASH_CAP` pending ids; beyond that they converge with
+     * the backlog). Embeddings still come from the maintenance
      * sweep (`runLibrarian` / `runHeal` / `runOntologyBackfill` / `runPrune`,
      * scoped via `listEntityIds`).
      *
@@ -3887,4 +4059,4 @@ declare class WikiMemory {
     setGeneratedByTask(taskId: string, entityId: string, actor: string): Promise<void>;
 }
 
-export { type ReembedResult as $, ONTOLOGY_BACKFILL_RECHECK_MS as A, type OntologyBackfillResult as B, type ChunkFailure as C, type DegradedRecord as D, type EmbedFactResult as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type OntologyConfig as J, type OntologyEdgeType as K, type LLMProvider as L, type MemoryBundle as M, type OntologyManifest as N, ONTOLOGY_BACKFILL_BATCH_SIZE as O, type OntologyMode as P, type OntologyNodeType as Q, type ReadOptions as R, type SQLiteAdapter as S, type OntologyPromptContext as T, type OntologyUpdates as U, type PendingMaintenance as V, type WikiOptions as W, type PendingSourceStatus as X, type PromptOverrides as Y, PromptService as Z, PrunePartialFailureError as _, type MemoryDump as a, type RunPendingMaintenanceOptions as a0, type RunPendingMaintenanceResult as a1, type SupersedeReplacement as a2, type VectorRanker as a3, type VectorRankerFallback as a4, type VectorRankerRankArgs as a5, type VectorRankerSemanticResult as a6, WikiBusyError as a7, type WikiBusyOperation as a8, type WikiCheckpoint as a9, validateManifest as aA, EmbeddingService as aB, ImportExportService as aC, IngestionService as aD, JobManager as aE, MaintenanceService as aF, RetrievalService as aG, SearchService as aH, WriteService as aI, type WikiConfig as aa, type WikiDiagnostic as ab, type WikiDiagnosticCode as ac, type WikiDiagnosticDetail as ad, type WikiDiagnosticOperation as ae, type WikiDiagnosticSeverity as af, type WikiDiagnosticTrigger as ag, WikiDraftNotFound as ah, WikiDuplicateHashError as ai, type WikiEdge as aj, type WikiEvent as ak, type WikiFact as al, WikiGraphNodeOwnershipConflict as am, WikiIngestEmptyError as an, type WikiInstructions as ao, WikiInvalidReadOptions as ap, type WikiLintReport as aq, type WikiMemoryTestAccess as ar, type WikiOutboxEvent as as, WikiParseError as at, WikiSourceRefHashCollision as au, WikiStrictOntologyViolation as av, WikiSupersedeError as aw, type WikiSupersedeReason as ax, type WikiTask as ay, WikiTransactionError as az, type FormattedMemoryDump as b, WikiMemory as c, type ClassifierAnswer as d, type ClassifierQuestion as e, type ClassifyRequest as f, type ClassifyResponse as g, type DraftPage as h, type EmbedFailureKind as i, type EmbeddingMarkerKind as j, type EntityMaintenanceReport as k, type EntityStatus as l, type ExtractedFact as m, type ExtractedFactEdge as n, type ExtractedFactWithOntology as o, type ExtractedTask as p, type GraphTraversalOptions as q, type GroundingConfig as r, HEAL_RECHECK_MS as s, HOOK_TIMEOUT_MARKER as t, type HealResult as u, type LibrarianConfig as v, type LibrarianGateConfig as w, type MaintenanceJob as x, type MaintenanceStopReason as y, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as z };
+export { PromptService as $, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS as A, ONTOLOGY_BACKFILL_RECHECK_MS as B, type ChunkFailure as C, type DegradedRecord as D, type EmbedFactResult as E, type FormatContextOptions as F, type GraphNeighborhood as G, HEAL_BATCH_SIZE as H, type IngestDocumentResult as I, type OntologyBackfillResult as J, type OntologyConfig as K, type LLMProvider as L, type MemoryBundle as M, type OntologyEdgeType as N, ONTOLOGY_BACKFILL_BATCH_SIZE as O, type OntologyManifest as P, type OntologyMode as Q, type ReadOptions as R, type SQLiteAdapter as S, type OntologyNodeType as T, type OntologyPromptContext as U, type OntologyUpdates as V, type WikiOptions as W, type PendingMaintenance as X, type PendingMigrationWork as Y, type PendingSourceStatus as Z, type PromptOverrides as _, type MemoryDump as a, PrunePartialFailureError as a0, type ReembedResult as a1, type RunPendingMaintenanceOptions as a2, type RunPendingMaintenanceResult as a3, type SupersedeReplacement as a4, type VectorRanker as a5, type VectorRankerFallback as a6, type VectorRankerRankArgs as a7, type VectorRankerSemanticResult as a8, WikiBusyError as a9, WikiSupersedeError as aA, type WikiSupersedeReason as aB, type WikiTask as aC, WikiTransactionError as aD, isWikiSearchUnavailableError as aE, validateManifest as aF, EmbeddingService as aG, ImportExportService as aH, IngestionService as aI, JobManager as aJ, MaintenanceService as aK, RetrievalService as aL, SearchService as aM, WriteService as aN, type WikiBusyOperation as aa, type WikiCheckpoint as ab, type WikiConfig as ac, type WikiDiagnostic as ad, type WikiDiagnosticCode as ae, type WikiDiagnosticDetail as af, type WikiDiagnosticOperation as ag, type WikiDiagnosticSeverity as ah, type WikiDiagnosticTrigger as ai, WikiDraftNotFound as aj, WikiDuplicateHashError as ak, type WikiEdge as al, type WikiEvent as am, type WikiFact as an, WikiGraphNodeOwnershipConflict as ao, WikiIngestEmptyError as ap, type WikiInstructions as aq, WikiInvalidReadOptions as ar, type WikiLintReport as as, type WikiMemoryTestAccess as at, WikiMigrationRequiredError as au, type WikiOutboxEvent as av, WikiParseError as aw, WikiSearchUnavailableError as ax, WikiSourceRefHashCollision as ay, WikiStrictOntologyViolation as az, type FormattedMemoryDump as b, WikiMemory as c, type ClassifierAnswer as d, type ClassifierQuestion as e, type ClassifyRequest as f, type ClassifyResponse as g, type DraftPage as h, type EmbedFailureKind as i, type EmbeddingMarkerKind as j, type EntityMaintenanceReport as k, type EntityStatus as l, type ExtractedFact as m, type ExtractedFactEdge as n, type ExtractedFactWithOntology as o, type ExtractedTask as p, type GraphTraversalOptions as q, type GroundingConfig as r, HEAL_RECHECK_MS as s, HOOK_TIMEOUT_MARKER as t, type HealResult as u, type LibrarianConfig as v, type LibrarianGateConfig as w, type MaintenanceJob as x, type MaintenanceStopReason as y, type MigrationPolicy as z };