@remnic/core 9.69.56 → 9.69.58

package/dist/conflict-policy-DyJ2wd-h.d.ts

@@ -1,4 +0,0 @@
-declare const CONFLICT_POLICIES: readonly ["skip", "overwrite", "dedupe"];
-type ConflictPolicy = typeof CONFLICT_POLICIES[number];
-
-export type { ConflictPolicy as C };

package/dist/connectors-cli-2iaQ5tX2.d.ts

@@ -1,263 +0,0 @@
-import { b as ConnectorCursor, a as ConnectorDocument } from './framework-CNDn2164.js';
-
-/**
- * @remnic/core — Live Connectors State Store (issue #683 PR 1/N)
- *
- * Persists per-connector cursor + sync metadata to
- *   `<memoryDir>/state/connectors/<id>.json`
- *
- * Reasons this lives next to memory data, not in user config:
- *   - cursors are *operational* state that should travel with the memory
- *     directory when a user moves it across machines;
- *   - it keeps memory + ingest provenance co-located so tooling that backs up
- *     the memory directory captures cursor state too.
- *
- * Atomic-write contract (CLAUDE.md gotcha #54):
- *   - We NEVER `rmSync(target)` before `renameSync(tmp, target)`.
- *   - Writes go to a sibling tmp file and `rename()` swaps it in.
- *   - On error, the tmp file is best-effort cleaned up; the previous good
- *     state file is left untouched.
- *
- * Privacy: cursors are opaque connector-defined strings. We do not log them
- * and do not surface them through user-visible APIs. Document content NEVER
- * touches this module.
- */
-
-/**
- * Status of the most recent sync attempt for a connector.
- *
- * `"never"` is distinct from `"success"` so callers can detect
- * "registered but never run" without inspecting timestamps. Per CLAUDE.md
- * gotcha #34, we deliberately distinguish empty/unknown from failure states.
- */
-type ConnectorSyncStatus = "success" | "error" | "never";
-/**
- * Persisted per-connector state.
- *
- * Stored as pretty-printed JSON for human inspection — the file is small
- * (one record per connector) and operators may need to debug stuck cursors
- * by hand.
- */
-interface ConnectorState {
-    /** Connector id. Matches the filename stem. */
-    readonly id: string;
-    /** Last persisted cursor, or `null` if the connector has never synced. */
-    readonly cursor: ConnectorCursor | null;
-    /** ISO 8601 timestamp of the last completed sync attempt, or `null`. */
-    readonly lastSyncAt: string | null;
-    /** Status of the last completed sync attempt. */
-    readonly lastSyncStatus: ConnectorSyncStatus;
-    /** Optional error message from the last failed sync. Truncated to 1 KB. */
-    readonly lastSyncError?: string;
-    /** Cumulative count of documents successfully imported across all syncs. */
-    readonly totalDocsImported: number;
-    /** ISO 8601 timestamp of when this state record was last written. */
-    readonly updatedAt: string;
-}
-/**
- * Read the persisted state for a single connector.
- *
- * Returns `null` if the file does not exist (ENOENT). Throws on any other
- * I/O error or on shape mismatch — operators should see corruption loudly.
- *
- * Rejects symlinks anywhere on the path so a planted symlink can't redirect
- * reads outside the memory root. (PR #724 review.)
- */
-declare function readConnectorState(memoryDir: string, id: string): Promise<ConnectorState | null>;
-/**
- * Write state atomically: create-tmp + rename. Never destroys the previous
- * file before the new one is in place — see CLAUDE.md gotcha #54.
- *
- * We accept `Omit<ConnectorState, "updatedAt">` and stamp `updatedAt`
- * ourselves so callers can't accidentally persist a stale timestamp.
- */
-declare function writeConnectorState(memoryDir: string, id: string, state: Omit<ConnectorState, "updatedAt">): Promise<ConnectorState>;
-/**
- * Enumerate every persisted connector state. Returns an empty array when
- * the directory does not exist yet (clean install, no syncs ever run).
- *
- * Files that do not match the `<id>.json` naming rule are skipped — this
- * keeps stray editor backups (`.json~`, `.swp`) from breaking enumeration.
- *
- * Corruption (unparseable JSON, shape mismatch, id mismatch) is also
- * skipped so one bad file doesn't take down the listing. Operators
- * inspecting `state/connectors/` can still see the offending file by hand.
- *
- * **Genuine I/O failures (`EACCES`, `EIO`, etc.) are NOT swallowed** —
- * silently returning an incomplete state set would make active connectors
- * appear missing and trigger duplicate ingestion on the next scheduler tick.
- * (PR #724 review.)
- */
-declare function listConnectorStates(memoryDir: string): Promise<ConnectorState[]>;
-
-/**
- * `remnic connectors` CLI helpers (issue #683 PR 6/N).
- *
- * Three subcommands:
- *
- *   remnic connectors list
- *     Lists all configured live connectors, their enabled state, last poll
- *     time, and last error.  Output formats: text (default), markdown, json.
- *
- *   remnic connectors status
- *     Identical data to `list` but defaults to JSON output so scripts can
- *     reliably parse it.  Accepts `--format` to override.
- *
- *   remnic connectors run <name>
- *     Manually triggers a single `syncIncremental()` pass for the named
- *     connector.  Operator debug surface — useful when you want to test
- *     credentials without waiting for the scheduler tick.  Prints the
- *     number of new documents imported plus any error.
- *
- * Design decisions:
- *
- *   - Pure functions for list / status / run option parsing so they can be
- *     unit-tested without booting an orchestrator (CLAUDE.md rules 14 + 51).
- *   - Rendering lives here (not in cli.ts) so HTTP/MCP surfaces can reuse the
- *     same output without forking formatting (CLAUDE.md rule 22).
- *   - The `run` command requires the caller to pass a `pollFn` callback
- *     (wrapping the actual connector's `syncIncremental`).  This keeps the
- *     helper module free of direct orchestrator / live-connector imports while
- *     still being testable (CLAUDE.md rule 33 — mock signatures must match
- *     production).
- *   - CLAUDE.md rule 51: invalid `--format` throws with listed options; unknown
- *     connector name in `run` throws a descriptive error; `--format` without a
- *     value is caught by Commander's built-in argument check.
- *   - `runConnectorPollOnce` encapsulates the persist-before-cursor-advance
- *     contract (CLAUDE.md gotcha #25, #43) so it can be unit-tested in
- *     isolation without an orchestrator.
- */
-
-/**
- * A lightweight descriptor for one live connector, assembled from the parsed
- * config and any persisted state.  The CLI handler builds this from
- * `orchestrator.config.connectors` + `listConnectorStates(memoryDir)`.
- */
-interface ConnectorRow {
-    /** Stable connector id (e.g. `"google-drive"`, `"notion"`). */
-    id: string;
-    /** Human-readable display name. */
-    displayName: string;
-    /** Whether the operator has enabled this connector in config. */
-    enabled: boolean;
-    /** Persisted sync state, or `null` if no sync has ever run. */
-    state: ConnectorState | null;
-}
-interface ConnectorRowDefinition {
-    id: string;
-    displayName: string;
-    enabled: boolean;
-}
-declare function buildConnectorRowsFromDefinitions(definitions: readonly ConnectorRowDefinition[], states: readonly ConnectorState[]): ConnectorRow[];
-/**
- * Result returned by the `run` command's poll function.
- */
-interface ConnectorRunResult {
-    /** Number of new documents imported in this pass. */
-    docsImported: number;
-    /**
-     * Error message if the sync or ingest failed, undefined on full success.
-     * When only the cursor write failed after a successful ingest, this field is
-     * undefined and `stateWriteError` carries the failure. When persisting error
-     * state fails after a sync/ingest error, both fields are set so callers can
-     * preserve the primary failure while also reporting stale persisted state.
-     */
-    error?: string;
-    /**
-     * Set when cursor/error-state persistence fails. On the success path,
-     * `docsImported` reflects the actual count of successfully ingested docs so
-     * the operator knows data was persisted even though the cursor did not
-     * advance. On the error path, `error` preserves the primary sync/ingest
-     * failure and this field reports the secondary persistence failure.
-     */
-    stateWriteError?: string;
-}
-declare const CONNECTORS_OUTPUT_FORMATS: readonly ["text", "markdown", "json"];
-type ConnectorsOutputFormat = (typeof CONNECTORS_OUTPUT_FORMATS)[number];
-/**
- * Validate `--format <fmt>`.  Throws a listed-options error for any value not
- * in `CONNECTORS_OUTPUT_FORMATS`.  Returns the given default when the value is
- * `undefined` (no flag supplied).
- */
-declare function parseConnectorsFormat(value: unknown, defaultFormat?: ConnectorsOutputFormat): ConnectorsOutputFormat;
-interface ParsedConnectorsListOptions {
-    format: ConnectorsOutputFormat;
-}
-interface ParsedConnectorsStatusOptions {
-    /** `status` defaults to JSON for scripting; `--format` can override. */
-    format: ConnectorsOutputFormat;
-}
-/**
- * Validate the option bag for `remnic connectors list`.
- */
-declare function parseConnectorsListOptions(options: Record<string, unknown>): ParsedConnectorsListOptions;
-/**
- * Validate the option bag for `remnic connectors status`.
- * Defaults to `json` (machine-readable) unless `--format` overrides.
- */
-declare function parseConnectorsStatusOptions(options: Record<string, unknown>): ParsedConnectorsStatusOptions;
-/**
- * Validate the positional `<name>` argument for `remnic connectors run`.
- */
-declare function parseConnectorsRunName(rawName: unknown): string;
-/**
- * Render connector rows for `remnic connectors list` / `remnic connectors status`.
- */
-declare function renderConnectorsList(rows: readonly ConnectorRow[], format: ConnectorsOutputFormat): string;
-/**
- * Render the result of a manual `remnic connectors run <name>` invocation.
- */
-declare function renderConnectorsRunResult(connectorId: string, result: ConnectorRunResult, format: ConnectorsOutputFormat): string;
-/**
- * Arguments for a single connector poll pass.
- *
- * All I/O is injectable so callers (cli.ts) can supply real implementations
- * and tests can supply lightweight stubs without booting an orchestrator.
- */
-interface RunConnectorPollOnceArgs {
-    /** Connector identifier (used in error/success state writes). */
-    connectorId: string;
-    /** Prior persisted state, or `null` on the very first sync. */
-    priorState: ConnectorState | null;
-    /**
-     * Perform a single incremental sync.  Returns newly-fetched documents and
-     * the cursor that should be persisted on success.
-     */
-    syncFn: (cursor: ConnectorCursor | null) => Promise<{
-        newDocs: ConnectorDocument[];
-        nextCursor: ConnectorCursor;
-    }>;
-    /**
-     * Ingest fetched documents into the memory layer.  Called BEFORE the cursor
-     * is advanced.  If this throws the cursor is NOT advanced (CLAUDE.md gotcha
-     * #25 — don't destroy old state before confirming new state succeeds).
-     */
-    ingestFn: (docs: ConnectorDocument[]) => Promise<void>;
-    /**
-     * Persist connector state (cursor + metadata).  Called after `ingestFn`
-     * succeeds (success path) or when `syncFn` / `ingestFn` throws (error path,
-     * with old cursor retained).
-     */
-    writeCursorFn: (state: {
-        cursor: ConnectorCursor | null;
-        lastSyncStatus: ConnectorSyncStatus;
-        lastSyncError?: string;
-        totalDocsImported: number;
-    }) => Promise<void>;
-}
-/**
- * Execute one `syncIncremental` pass for a live connector, enforcing the
- * persist-before-advance-cursor contract.
- *
- * Invariant (CLAUDE.md gotcha #25 + #43):
- *   1. `syncFn` fetches new docs and a next cursor.
- *   2. `ingestFn` persists the docs into the memory layer.
- *   3. Only if (2) succeeds does `writeCursorFn` advance the cursor.
- *   4. If (1) or (2) throws, `writeCursorFn` is still called but retains the
- *      **prior** cursor so the next poll re-fetches the same window.
- *
- * Returns the `ConnectorRunResult` that `cli.ts` uses for output rendering.
- */
-declare function runConnectorPollOnce(args: RunConnectorPollOnceArgs): Promise<ConnectorRunResult>;
-
-export { type ConnectorRunResult as C, type ParsedConnectorsListOptions as P, type RunConnectorPollOnceArgs as R, type ConnectorsOutputFormat as a, CONNECTORS_OUTPUT_FORMATS as b, type ConnectorRow as c, type ConnectorState as d, type ConnectorSyncStatus as e, type ParsedConnectorsStatusOptions as f, parseConnectorsListOptions as g, parseConnectorsRunName as h, parseConnectorsStatusOptions as i, renderConnectorsList as j, renderConnectorsRunResult as k, listConnectorStates as l, runConnectorPollOnce as m, type ConnectorRowDefinition as n, buildConnectorRowsFromDefinitions as o, parseConnectorsFormat as p, readConnectorState as r, writeConnectorState as w };

package/dist/dependency-propagation-delivery-BrhPjAHQ.d.ts

@@ -1,41 +0,0 @@
-import { m as MemoryFrontmatter } from './types-Du6VdoAg.js';
-
-/**
- * Bounded, one-hop invalidation propagation for linked memories.
- *
- * Propagation hooks stay at orchestration call sites. They never live inside
- * StorageManager, so propagation supersessions cannot recurse.
- */
-
-interface PropagationEvent {
-    /** Snapshot captured before the primary supersession or deletion. */
-    oldMemory: {
-        content: string;
-        frontmatter: MemoryFrontmatter;
-        path?: string;
-    };
-    replacementId: string | null;
-    replacementContent: string | null;
-    cause: "contradiction" | "temporal_supersession" | "consolidation_invalidate" | "consolidation_merge";
-    namespaceScope: string;
-    temporalMutation?: {
-        supersededAt: string;
-        invalidAt?: string;
-        matchedKeys: string[];
-    };
-}
-
-interface DependencyPropagationPreparationToken {
-    jobId: string;
-    revision: number;
-    ownsPreparedJob: boolean;
-    reservationId: string;
-}
-interface DependencyPropagationDeliveryPort {
-    prepare(event: PropagationEvent): Promise<DependencyPropagationPreparationToken | null>;
-    afterMutation(token: DependencyPropagationPreparationToken | null, event: PropagationEvent): Promise<void>;
-    cancel(token: DependencyPropagationPreparationToken | null): Promise<void>;
-    deferPrepared(token: DependencyPropagationPreparationToken | null): Promise<void>;
-}
-
-export type { DependencyPropagationDeliveryPort as D };

package/dist/faiss-adapter-BHecI1fF.d.ts

@@ -1,73 +0,0 @@
-import { ConversationChunk } from './conversation-index/chunker.js';
-import { SearchBackend } from './search/port.js';
-import { launchProcess } from './runtime/child-process.js';
-
-interface ConversationSearchResult {
-    path: string;
-    snippet: string;
-    score: number;
-}
-declare function searchConversationIndex(qmd: SearchBackend, query: string, maxResults: number): Promise<ConversationSearchResult[]>;
-declare function searchConversationIndexFaissFailOpen(adapter: FaissConversationIndexAdapter | undefined, query: string, maxResults: number): Promise<ConversationSearchResult[]>;
-
-interface FaissAdapterConfig {
-    memoryDir: string;
-    scriptPath?: string;
-    pythonBin?: string;
-    modelId: string;
-    indexDir: string;
-    upsertTimeoutMs: number;
-    searchTimeoutMs: number;
-    healthTimeoutMs: number;
-    maxBatchSize: number;
-    maxSearchK: number;
-    spawnFn?: typeof launchProcess;
-}
-interface FaissHealthResult {
-    ok: boolean;
-    status: "ok" | "degraded" | "error";
-    indexPath: string;
-    message?: string;
-    manifest?: {
-        version: number;
-        modelId: string;
-        normalizedModelId: string;
-        dimension: number;
-        chunkCount: number;
-        updatedAt: string;
-        lastSuccessfulRebuildAt: string;
-    };
-}
-interface FaissInspectResult extends FaissHealthResult {
-    metadata: {
-        chunkCount: number;
-        hasIndex: boolean;
-        hasMetadata: boolean;
-        hasManifest: boolean;
-    };
-}
-declare class FaissAdapterError extends Error {
-    readonly code: "timeout" | "non_zero_exit" | "malformed_output";
-    constructor(message: string, code: "timeout" | "non_zero_exit" | "malformed_output");
-}
-declare function resolveDefaultFaissScriptPath(fromModuleUrl?: string): string;
-declare class FaissConversationIndexAdapter {
-    private readonly config;
-    private readonly pythonBin;
-    private readonly scriptPath;
-    private readonly indexPath;
-    private readonly maxBatchSize;
-    private readonly spawnFn;
-    constructor(config: FaissAdapterConfig);
-    upsertChunks(chunks: ConversationChunk[], options?: {
-        retentionCutoffMs?: number;
-    }): Promise<number>;
-    searchChunks(query: string, topK: number): Promise<ConversationSearchResult[]>;
-    health(): Promise<FaissHealthResult>;
-    inspect(): Promise<FaissInspectResult>;
-    rebuildChunks(chunks: ConversationChunk[]): Promise<number>;
-    private runCommand;
-}
-declare function failOpenFaissHealth(adapter: FaissConversationIndexAdapter | undefined): Promise<FaissHealthResult>;
-
-export { type ConversationSearchResult as C, FaissConversationIndexAdapter as F, searchConversationIndexFaissFailOpen as a, type FaissAdapterConfig as b, FaissAdapterError as c, type FaissHealthResult as d, type FaissInspectResult as e, failOpenFaissHealth as f, resolveDefaultFaissScriptPath as r, searchConversationIndex as s };

package/dist/framework-CNDn2164.d.ts

@@ -1,170 +0,0 @@
-/**
- * @remnic/core — Live Connectors Framework (issue #683 PR 1/N)
- *
- * Defines the contract that every "live" connector (Drive, Notion, Gmail,
- * GitHub, ...) must satisfy. A live connector is **continuous**: it runs on a
- * schedule, persists a cursor to disk, and ingests *new* documents since the
- * last sync. This is distinct from one-shot importers in
- * `packages/remnic-core/src/importers/` which transform an entire export file
- * in a single pass.
- *
- * This module is intentionally pure types + interfaces. No I/O. No schedule
- * wiring. Concrete connectors (PRs 2–5), the maintenance scheduler hookup
- * (separate PR), and the CLI surface (PR 6) are deferred.
- *
- * Naming caveat: `packages/remnic-core/src/connectors/` is already scoped to
- * the Codex marketplace integration. The live-connector framework lives under
- * the `live/` subdirectory to avoid collision. Do not import Codex symbols
- * from here, and do not import live-connector symbols from the Codex code.
- */
-/**
- * Free-form connector configuration. Validated by each connector's
- * `validateConfig` implementation and passed to `syncIncremental` for runtime
- * use. MUST be JSON-serializable: no functions, no class instances, no
- * circular references.
- *
- * Runtime configs may contain hydrated credentials. Do not persist a runtime
- * config directly. Any code that needs to store connector settings must call
- * `persistableConnectorConfig()` so credentials are stripped or replaced by
- * connector-owned references.
- */
-type ConnectorConfig = Record<string, unknown>;
-/**
- * Redact secret-looking keys from a JSON-serializable connector config.
- * Built-in connectors provide explicit projections, but this default keeps
- * third-party connectors from accidentally persisting obvious credentials.
- */
-declare function redactConnectorConfigSecrets(config: ConnectorConfig): ConnectorConfig;
-/**
- * Opaque cursor describing "where the last sync left off". Each connector
- * defines what `kind` and `value` mean (e.g. Drive: `{kind: "pageToken",
- * value: "..."}`, Gmail: `{kind: "historyId", value: "..."}`). The orchestrator
- * treats it as opaque and only round-trips it through the state store.
- *
- * `updatedAt` is an ISO 8601 timestamp set by the framework when the cursor is
- * written. It is informational — connectors MUST NOT use it to decide
- * monotonicity. They own the `value` semantics.
- */
-interface ConnectorCursor {
-    /** Connector-defined cursor kind (e.g. `"pageToken"`, `"historyId"`, `"sinceTs"`). */
-    readonly kind: string;
-    /** Connector-defined opaque cursor value. */
-    readonly value: string;
-    /** ISO 8601 timestamp of when this cursor was last written. */
-    readonly updatedAt: string;
-}
-/**
- * Provenance for a connector-ingested document. Required so downstream recall
- * can attribute facts back to their origin and avoid re-ingesting on the next
- * incremental pass.
- */
-interface ConnectorDocumentSource {
-    /** Stable connector id (matches `LiveConnector.id`). */
-    readonly connector: string;
-    /** Source-system identifier (Drive file id, Notion page id, Gmail msg id, ...). */
-    readonly externalId: string;
-    /** Optional source-system revision/version (etag, page version, history id). */
-    readonly externalRevision?: string;
-    /** Optional canonical URL pointing back at the source document. */
-    readonly externalUrl?: string;
-    /** ISO 8601 timestamp of when the connector fetched this document. */
-    readonly fetchedAt: string;
-}
-/**
- * A single document yielded by an incremental sync. Connectors are responsible
- * for chunking large source documents themselves if needed; the orchestrator
- * ingests `content` as a unit.
- */
-interface ConnectorDocument {
-    /** Connector-local stable id for this document. SHOULD match `source.externalId`. */
-    readonly id: string;
-    /** Optional human-readable title. */
-    readonly title?: string;
-    /** Body content. Plaintext or Markdown — connectors document their format. */
-    readonly content: string;
-    /** Provenance. Required. */
-    readonly source: ConnectorDocumentSource;
-}
-/**
- * Arguments passed to `syncIncremental`. The framework owns cursor/config
- * lifecycle; connectors only read these and return the next cursor.
- */
-interface SyncIncrementalArgs {
-    /** Last persisted cursor, or `null` on the first ever sync. */
-    readonly cursor: ConnectorCursor | null;
-    /** Validated connector config (already passed through `validateConfig`). */
-    readonly config: ConnectorConfig;
-    /** Optional abort signal. Connectors SHOULD honor it for cooperative cancellation. */
-    readonly abortSignal?: AbortSignal;
-}
-/**
- * Result of a single incremental sync pass.
- *
- * `newDocs` MAY be empty (no new documents since the last cursor). `nextCursor`
- * MUST always be returned — even on no-op syncs the framework persists it so
- * `updatedAt` reflects the most recent attempt.
- */
-interface SyncIncrementalResult {
-    readonly newDocs: ConnectorDocument[];
-    readonly nextCursor: ConnectorCursor;
-}
-/**
- * The contract every live connector implements.
- *
- * Connectors MUST be:
- *   - **Idempotent**: re-running with the same cursor MUST NOT duplicate
- *     documents. The `source.externalId` + `source.externalRevision` pair is
- *     used downstream for dedup.
- *   - **Read-only on the source**: live connectors never mutate the upstream
- *     system (no marking emails read, no editing Notion pages).
- *   - **Cancellable**: long-running syncs SHOULD periodically check
- *     `abortSignal.aborted` and bail cleanly.
- *   - **Privacy-aware**: connectors MUST NOT log document content. Logging
- *     metadata (counts, ids, timings) is fine.
- */
-interface LiveConnector {
-    /**
-     * Stable connector id. MUST match `CONNECTOR_ID_PATTERN` — lowercase
-     * alphanumeric plus dash, 1–64 chars, must start AND end with alphanumeric
-     * (no leading or trailing dash). The registry enforces this.
-     */
-    readonly id: string;
-    /** Short human-readable name shown in CLI / status output. */
-    readonly displayName: string;
-    /** Optional longer description. */
-    readonly description?: string;
-    /**
-     * Validate raw user-supplied config. MUST throw on malformed input — never
-     * silently default. The returned object is the runtime config passed back to
-     * `syncIncremental`; it may contain hydrated credentials and MUST NOT be
-     * persisted directly. Connectors SHOULD strip unknown fields.
-     */
-    validateConfig(raw: unknown): ConnectorConfig;
-    /**
-     * Return the subset of validated config that may be written to disk. Use this
-     * for state/config persistence instead of `validateConfig()`. Connectors that
-     * need credentials should omit the raw values here and store only non-secret
-     * scope/schedule fields plus any connector-owned secret references.
-     */
-    persistConfig?(validated: ConnectorConfig): ConnectorConfig;
-    /**
-     * Run one incremental sync pass. See `SyncIncrementalArgs` /
-     * `SyncIncrementalResult` for the contract.
-     */
-    syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult>;
-}
-declare function persistableConnectorConfig(connector: Pick<LiveConnector, "persistConfig">, validated: ConnectorConfig): ConnectorConfig;
-/**
- * Regex enforcing the connector-id naming rule. Exported so connectors and
- * tests can validate ids consistently with the registry.
- *
- * Rule: lowercase alphanumeric + dash, 1..64 chars, must start AND end with
- * alphanumeric (no leading or trailing dash). Single-char ids are allowed.
- */
-declare const CONNECTOR_ID_PATTERN: RegExp;
-/**
- * Returns `true` if `id` is a syntactically valid connector id.
- */
-declare function isValidConnectorId(id: unknown): id is string;
-
-export { type ConnectorConfig as C, type LiveConnector as L, type SyncIncrementalResult as S, type ConnectorDocument as a, type ConnectorCursor as b, CONNECTOR_ID_PATTERN as c, type ConnectorDocumentSource as d, type SyncIncrementalArgs as e, isValidConnectorId as i, persistableConnectorConfig as p, redactConnectorConfigSecrets as r };

package/dist/generic-recall-paths-C0J1Oxb7.d.ts

@@ -1,23 +0,0 @@
-import { Q as QmdSearchResult } from './types-Du6VdoAg.js';
-
-interface GenericRecallPathPolicy {
-    readonly memoryDir?: string;
-    readonly qmdCollection?: string;
-    readonly qmdColdCollection?: string;
-    /**
-     * The collection THIS request named, when it named one. A caller may select
-     * a custom collection whose name is also a memory category, which the
-     * configured names alone cannot disambiguate.
-     */
-    readonly requestedCollection?: string;
-}
-declare function filterRecallCandidates(candidates: QmdSearchResult[], options: {
-    namespacesEnabled: boolean;
-    recallNamespaces: string[];
-    resolveNamespace: (path: string) => string;
-    limit: number;
-    pathPolicy?: GenericRecallPathPolicy;
-    memoryRoot?: string;
-}): QmdSearchResult[];
-
-export { type GenericRecallPathPolicy as G, filterRecallCandidates as f };