@equationalapplications/core-llm-wiki 7.12.0 → 7.13.1

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

@@ -379,6 +379,19 @@ interface WikiConfig {
      * @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;
@@ -2026,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
@@ -2092,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
@@ -2102,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 {
@@ -2179,10 +2212,13 @@ declare class SearchService {
     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;
     /**
@@ -2192,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
@@ -2205,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.
@@ -2217,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.
@@ -2810,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
@@ -2851,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
@@ -3515,6 +3568,28 @@ declare class WikiMemory {
      * If `NODE_ENV` is not `"test"`, emits a single `console.warn` per instance (skipped when `process` is undefined).
      */
     get __testAccess(): WikiMemoryTestAccess;
+    /** 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;
@@ -3530,6 +3605,11 @@ declare class WikiMemory {
      * 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;
@@ -3716,14 +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. 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.
+     * 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
@@ -3740,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>;
@@ -3805,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`).
      *

package/dist/{testing-7d76Ptlq.d.ts → testing-CqsXv2_l.d.ts}

@@ -379,6 +379,19 @@ interface WikiConfig {
      * @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;
@@ -2026,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
@@ -2092,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
@@ -2102,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 {
@@ -2179,10 +2212,13 @@ declare class SearchService {
     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;
     /**
@@ -2192,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
@@ -2205,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.
@@ -2217,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.
@@ -2810,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
@@ -2851,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
@@ -3515,6 +3568,28 @@ declare class WikiMemory {
      * If `NODE_ENV` is not `"test"`, emits a single `console.warn` per instance (skipped when `process` is undefined).
      */
     get __testAccess(): WikiMemoryTestAccess;
+    /** 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;
@@ -3530,6 +3605,11 @@ declare class WikiMemory {
      * 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;
@@ -3716,14 +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. 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.
+     * 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
@@ -3740,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>;
@@ -3805,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`).
      *

package/dist/testing.d.mts

@@ -1,2 +1,2 @@
-export { aG as EmbeddingService, aH as ImportExportService, aI as IngestionService, aJ as JobManager, aJ as JobManagerType, aK as MaintenanceService, aL as RetrievalService, aM as SearchService, aM as SearchServiceType, at as WikiMemoryTestAccess, aN as WriteService } from './testing-7d76Ptlq.mjs';
+export { aG as EmbeddingService, aH as ImportExportService, aI as IngestionService, aJ as JobManager, aJ as JobManagerType, aK as MaintenanceService, aL as RetrievalService, aM as SearchService, aM as SearchServiceType, at as WikiMemoryTestAccess, aN as WriteService } from './testing-CqsXv2_l.mjs';
 import '@equationalapplications/core-okf';

package/dist/testing.d.ts

@@ -1,2 +1,2 @@
-export { aG as EmbeddingService, aH as ImportExportService, aI as IngestionService, aJ as JobManager, aJ as JobManagerType, aK as MaintenanceService, aL as RetrievalService, aM as SearchService, aM as SearchServiceType, at as WikiMemoryTestAccess, aN as WriteService } from './testing-7d76Ptlq.js';
+export { aG as EmbeddingService, aH as ImportExportService, aI as IngestionService, aJ as JobManager, aJ as JobManagerType, aK as MaintenanceService, aL as RetrievalService, aM as SearchService, aM as SearchServiceType, at as WikiMemoryTestAccess, aN as WriteService } from './testing-CqsXv2_l.js';
 import '@equationalapplications/core-okf';