@dikolab/kbdb 0.3.0 → 0.3.1

package/dist/src/shared/wasm-codec/typings/paged-search-result.model.d.ts

@@ -0,0 +1,21 @@
+import type { SectionMatch } from './section-match.model.ts';
+/**
+ * Paginated search response envelope returned by the WASM engine.
+ */
+export interface PagedSearchResult {
+    /** Matching sections for the current page. */
+    items: SectionMatch[];
+    /** Total number of matches across all pages. */
+    total: number;
+    /** Number of results skipped (pagination offset). */
+    offset: number;
+    /** Maximum results per page. */
+    limit: number;
+    /** Whether more results exist beyond this page. */
+    has_more: boolean;
+    /**
+     * Whether the engine fell back to relaxed (OR-mode) search
+     * after strict (AND-mode) returned no results.
+     */
+    relaxed: boolean;
+}

package/dist/src/shared/wasm-codec/typings/section-match.model.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A single ranked result item from a paged search response.
+ */
+export interface SectionMatch {
+    /** Knowledge-base identifier for the matched section. */
+    kbid: string;
+    /** Section heading, or `null` when untitled. */
+    heading: string | null;
+    /** MIME type of the section content. */
+    type: string;
+    /** Document IDs this section belongs to. */
+    docids: string[];
+    /** Relevance score from the ranking engine. */
+    score: number;
+    /**
+     * Confidence modifier (0.0–1.0) applied after relaxed search.
+     * Always 1.0 for strict-mode results.
+     */
+    confidence: number;
+    /** KWIC snippet (~150 chars around the best match). */
+    snippet: string;
+    /** Query terms that matched within this section. */
+    matched_terms: string[];
+    /**
+     * Document fields that contained at least one matched term
+     * (e.g. `'title'`, `'body'`).
+     */
+    matched_fields: string[];
+    /** ISO 8601 creation timestamp of the section. */
+    created_at: string;
+}

package/dist/src/shared/wasm-codec/typings/section-record-trailing.model.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Trailing backward-compatible fields of a section record.
+ *
+ * These fields were added after the initial wire format. When
+ * decoding legacy binary output that stops before these fields,
+ * each defaults to `null` or `[]`.
+ */
+export interface SectionRecordTrailing {
+    /**
+     * Stable logical identity derived from source path and heading.
+     * `null` for stdin input or sections without a source path.
+     */
+    sourceKey: string | null;
+    /**
+     * Absolute path of the source file that was learned.
+     * `null` for stdin input or programmatic API calls.
+     */
+    sourcePath: string | null;
+    /**
+     * ISO 8601 modified time of the source file at learn time.
+     * `null` when no source file exists.
+     */
+    sourceMtime: string | null;
+    /**
+     * ISO 8601 timestamp of the last supersession.
+     * `null` on first creation.
+     */
+    updatedAt: string | null;
+    /** User-supplied tags for scoping and filtering. */
+    tags: string[];
+    /**
+     * The kbid of the section this one replaced via supersession.
+     * `null` on first creation or non-superseding additions.
+     */
+    supersedes: string | null;
+    /** Number of bytes consumed from the buffer. */
+    bytesRead: number;
+}

package/dist/src/shared/wasm-codec/typings/section-record.model.d.ts

@@ -0,0 +1,66 @@
+/**
+ * A single section record decoded from WASM binary output.
+ *
+ * Represents a stored knowledge-base section with all its metadata
+ * and token counts as returned by `worker_read_sections` or
+ * `worker_list_by_type`.
+ */
+export interface SectionRecord {
+    /** Unique knowledge-base identifier for this section. */
+    kbid: string;
+    /** Document identifier this section belongs to, or `null`. */
+    docid: string | null;
+    /** Semantic type discriminant: `'text'`, `'code'`, or `'image'`. */
+    sectionType: string;
+    /** MIME type string, present only for `'code'` and `'image'` types. */
+    mimeType?: string;
+    /** Human-readable title for the section, or `null`. */
+    title: string | null;
+    /** Optional description of the section content, or `null`. */
+    description: string | null;
+    /** Raw text or base64-encoded content of the section. */
+    content: string;
+    /** Byte size of the stored content. */
+    size: number;
+    /** Section creation timestamp as a Unix epoch value. */
+    createdAt: bigint;
+    /** Integrity checksum of the stored content. */
+    checksum: string;
+    /** Total number of tokens in the section. */
+    tokenCount: number;
+    /** Number of heading tokens in the section. */
+    headingTokenCount: number;
+    /** Number of body tokens in the section. */
+    bodyTokenCount: number;
+    /** Number of code tokens in the section. */
+    codeTokenCount: number;
+    /** Application-level type name assigned to this section. */
+    typeName: string;
+    /**
+     * Stable logical identity derived from source path and heading.
+     * `null` for stdin input or sections without a source path.
+     */
+    sourceKey: string | null;
+    /**
+     * Absolute path of the source file that was learned.
+     * `null` for stdin input or programmatic API calls.
+     */
+    sourcePath: string | null;
+    /**
+     * ISO 8601 modified time of the source file at learn time.
+     * `null` when no source file exists.
+     */
+    sourceMtime: string | null;
+    /**
+     * ISO 8601 timestamp of the last supersession.
+     * `null` on first creation.
+     */
+    updatedAt: string | null;
+    /** User-supplied tags for scoping and filtering. */
+    tags: string[];
+    /**
+     * The kbid of the section this one replaced via supersession.
+     * `null` on first creation or non-superseding additions.
+     */
+    supersedes: string | null;
+}

package/dist/src/shared/wasm-codec/typings/section-type-result.model.d.ts

@@ -0,0 +1,12 @@
+/** Result of decoding a section type discriminant from binary output. */
+export interface SectionTypeResult {
+    /** Semantic section category: `'text'`, `'code'`, or `'image'`. */
+    sectionType: string;
+    /**
+     * MIME type string, present only for `'code'` and `'image'`
+     * types.
+     */
+    mimeType?: string;
+    /** Number of bytes consumed from the buffer. */
+    bytesRead: number;
+}

package/dist/src/shared/worker-client/functions/handle-ipc-data.function.d.ts

@@ -0,0 +1,16 @@
+import type { PendingCall } from '../typings/pending-call.interface.ts';
+/**
+ * Processes an incoming data chunk from the IPC socket.
+ *
+ * Appends the chunk to `buffer`, splits on newline boundaries,
+ * parses complete JSON-RPC response lines, and resolves or rejects
+ * the matching pending call. Returns the updated buffer with any
+ * incomplete trailing line retained.
+ *
+ * @param data - raw string chunk received from the socket
+ * @param buffer - partial line buffer from the previous call
+ * @param pending - map of outstanding request IDs to their
+ *   resolve/reject pairs; mutated by this function
+ * @returns the updated buffer (incomplete trailing line, if any)
+ */
+export declare function handleIpcData(data: string, buffer: string, pending: Map<number, PendingCall>): string;

package/dist/src/shared/worker-client/functions/send-ipc-request.function.d.ts

@@ -0,0 +1,19 @@
+import type { Socket } from 'node:net';
+import type { PendingCall } from '../typings/pending-call.interface.ts';
+/**
+ * Sends a JSON-RPC 2.0 request over `socket` and registers the
+ * `resolve`/`reject` pair in `pending` so the response can be
+ * matched back.
+ *
+ * @param socket - connected IPC socket
+ * @param pending - map of outstanding request IDs to their
+ *   resolve/reject pairs; mutated by this function
+ * @param nextId - the request ID to assign; must be the current
+ *   value of the caller's monotonic counter
+ * @param contextId - 16-character context identifier sent as `ctx`
+ * @param method - JSON-RPC method name
+ * @param params - method parameters (merged with `ctx`)
+ * @throws {Error} when the socket is not connected (`socket` is
+ *   null) -- call the check before invoking this function
+ */
+export declare function sendIpcRequest(socket: Socket, pending: Map<number, PendingCall>, nextId: number, contextId: string, method: string, params: unknown): Promise<unknown>;

package/dist/src/shared/worker-client/typings/add-section-result.model.d.ts

@@ -6,6 +6,8 @@ export interface NearDuplicateEntry {
     readonly kbid: string;
     /** Jaccard similarity score (0.0--1.0). */
     readonly similarity: number;
+    /** Detection method that produced this match. */
+    readonly method?: 'jaccard' | 'cosine';
 }
 /** Result returned by the daemon after adding a new section. */
 export interface AddSectionResult {

package/dist/src/shared/worker-client/typings/json-rpc-response.interface.d.ts

@@ -0,0 +1,16 @@
+/** Shape of a JSON-RPC 2.0 error object from the daemon. */
+export interface JsonRpcError {
+    /** Numeric JSON-RPC error code. */
+    readonly code: number;
+    /** Human-readable error message. */
+    readonly message: string;
+}
+/** Shape of a JSON-RPC 2.0 response from the daemon. */
+export interface JsonRpcResponse {
+    /** Monotonically increasing request identifier. */
+    readonly id: number;
+    /** Result payload; present on success. */
+    readonly result?: unknown;
+    /** Error detail; present on failure. */
+    readonly error?: JsonRpcError;
+}

package/dist/src/shared/worker-client/typings/pending-call.interface.d.ts

@@ -0,0 +1,7 @@
+/** Pending JSON-RPC call awaiting a response from the daemon. */
+export interface PendingCall {
+    /** Resolves with the result when the daemon responds. */
+    resolve: (v: unknown) => void;
+    /** Rejects with an error when the daemon returns an error. */
+    reject: (e: Error) => void;
+}

package/dist/src/shared/worker-client/typings/recall-document.model.d.ts

@@ -0,0 +1,16 @@
+/** A document record included at depth >= 1. */
+export interface RecallDocument {
+    /** Unique document identifier. */
+    readonly docid: string;
+    /** Human-readable document title. */
+    readonly title: string;
+    /** Ordered list of section summaries belonging to this document. */
+    readonly sections: readonly {
+        /** Knowledge-base identifier of the section. */
+        readonly kbid: string;
+        /** Section heading text, or `null` when absent. */
+        readonly heading: string | null;
+        /** Semantic type label for the section. */
+        readonly type: string;
+    }[];
+}

package/dist/src/shared/worker-client/typings/recall-params.model.d.ts

@@ -0,0 +1,15 @@
+/** Parameters for a recall operation. */
+export interface RecallParams {
+    /** Single section identifier to recall. */
+    readonly kbid?: string;
+    /** Batch of section identifiers to recall. */
+    readonly kbids?: readonly string[];
+    /**
+     * Context expansion depth (0-3).
+     *
+     * At depth 0 only the section itself is returned.
+     * Higher values include progressively more context:
+     * documents, siblings, and references.
+     */
+    readonly depth?: number;
+}

package/dist/src/shared/worker-client/typings/recall-reference.model.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A section that references or is referenced by the recalled
+ * section.
+ */
+export interface RecallReference {
+    /**
+     * Knowledge-base identifier of the referencing/referenced
+     * section.
+     */
+    readonly kbid: string;
+    /**
+     * Heading text of the referencing section, or `null` when
+     * absent.
+     */
+    readonly heading: string | null;
+    /** Semantic type label of the referencing section. */
+    readonly type: string;
+    /**
+     * Application-level marker type (e.g. `'see_also'`, `'link'`).
+     */
+    readonly marker_type: string;
+    /**
+     * Short excerpt from the referencing section surrounding the
+     * marker.
+     */
+    readonly context_snippet: string;
+    /**
+     * Whether the reference is `'forward'` (outgoing) or `'back'`
+     * (incoming).
+     */
+    readonly direction: 'forward' | 'back';
+}

package/dist/src/shared/worker-client/typings/recall-sibling.model.d.ts

@@ -0,0 +1,11 @@
+/** A sibling section adjacent to the recalled section. */
+export interface RecallSibling {
+    /** Knowledge-base identifier of the sibling section. */
+    readonly kbid: string;
+    /** Sibling heading text, or `null` when absent. */
+    readonly heading: string | null;
+    /** Semantic type label for the sibling section. */
+    readonly type: string;
+    /** Full text content of the sibling section. */
+    readonly content: string;
+}

package/dist/src/shared/worker-client/typings/recall-single-result.model.d.ts

@@ -0,0 +1,40 @@
+import type { RecallDocument } from './recall-document.model.ts';
+import type { RecallReference } from './recall-reference.model.ts';
+import type { RecallSibling } from './recall-sibling.model.ts';
+/** Full content and context for a recalled knowledge-base section. */
+export interface RecallResult {
+    /** Knowledge-base identifier of the recalled section. */
+    readonly kbid: string;
+    /** Section heading text, or `null` when absent. */
+    readonly heading: string | null;
+    /** Semantic type label for the section. */
+    readonly type: string;
+    /** Full text content of the section. */
+    readonly content: string;
+    /** Identifiers of documents that contain this section. */
+    readonly docids: readonly string[];
+    /**
+     * Full document records containing this section.
+     *
+     * Populated when `depth >= 1`.
+     */
+    readonly documents?: readonly RecallDocument[];
+    /**
+     * Sections that contain a marker pointing back to this section.
+     *
+     * Populated when `depth >= 1`.
+     */
+    readonly back_references?: readonly RecallReference[];
+    /**
+     * Sections adjacent to this section in the same document.
+     *
+     * Populated when `depth >= 1`.
+     */
+    readonly siblings?: readonly RecallSibling[];
+    /**
+     * Sections that this section points to via markers.
+     *
+     * Populated when `depth >= 1`.
+     */
+    readonly references?: readonly RecallReference[];
+}

package/dist/src/shared/worker-daemon/classes/ipc-error.class.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Typed JSON-RPC error thrown inside WorkerDaemon dispatch.
+ *
+ * Carries a numeric JSON-RPC error code alongside the standard
+ * `Error` message so that `handleRequest` can build a well-formed
+ * JSON-RPC error response without an additional type check.
+ */
+export declare class IpcError extends Error {
+    /** JSON-RPC error code. */
+    readonly code: number;
+    /**
+     * @param code - JSON-RPC error code (e.g. `-32601` for
+     *   method-not-found, `-32000` for application errors)
+     * @param message - human-readable error description
+     */
+    constructor(code: number, message: string);
+}

package/dist/src/shared/worker-daemon/constants/wasm-method-map.constant.d.ts

@@ -0,0 +1,16 @@
+import type { DaemonConfig } from '../typings/daemon-config.interface.ts';
+/**
+ * Maps incoming IPC method names to `kb-worker.wasm` export names.
+ *
+ * Both camelCase and snake_case variants of each method are
+ * included so that clients may use either convention.
+ */
+export declare const WASM_METHOD_MAP: Readonly<Partial<Record<string, string>>>;
+/** Prefix shared by all IPC config-accessor method names. */
+export declare const CONFIG_PREFIX = "config_";
+/**
+ * Maps config IPC key suffixes to `DaemonConfig` property names.
+ *
+ * A client sends `config_timeout_ms` to read `config.timeoutMs`.
+ */
+export declare const CONFIG_KEY_MAP: Readonly<Partial<Record<string, keyof DaemonConfig>>>;

package/dist/src/shared/worker-daemon/functions/build-ipc-error-response.function.d.ts

@@ -0,0 +1,9 @@
+import type { IpcResponse } from '../typings/ipc-handler.interface.ts';
+/**
+ * Builds a JSON-RPC 2.0 error response object.
+ *
+ * @param id - request identifier to echo back in the response
+ * @param code - JSON-RPC error code
+ * @param message - human-readable error description
+ */
+export declare function buildIpcErrorResponse(id: number | string, code: number, message: string): IpcResponse;

package/dist/src/shared/worker-daemon/functions/check-catalog-version.function.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reads `catalog.toml` in `targetDir` and validates its version
+ * against `DB_FORMAT_VERSION`.
+ *
+ * @param targetDir - absolute path to the `.kbdb` directory
+ * @throws {Error} when the catalog cannot be read, is missing a
+ *   version, or the version is incompatible with the current engine
+ */
+export declare function checkCatalogVersion(targetDir: string): void;

package/dist/src/shared/worker-daemon/functions/check-preconditions.function.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validates startup preconditions for the worker daemon.
+ *
+ * Checks that `targetDir` exists, is readable and writable, and
+ * that `catalog.toml` reports a compatible format version.
+ *
+ * @param targetDir - absolute path to the `.kbdb` directory
+ * @throws {Error} when any precondition fails
+ */
+export declare function checkPreconditions(targetDir: string): void;

package/dist/src/shared/worker-daemon/functions/detect-stale-pid.function.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks whether a PID file contains a stale process ID.
+ *
+ * Reads the PID from the file and checks whether the process is
+ * still running using `process.kill(pid, 0)`. If the process is
+ * dead, or the PID is unparseable, removes the PID file and
+ * returns `true`. Returns `false` when the process is alive or
+ * the file does not exist.
+ *
+ * @param pidPath - absolute path to the PID file to inspect
+ * @returns `true` if the PID file is stale (process dead or
+ *   content invalid) and was removed; `false` if the process is
+ *   alive or the file does not exist
+ */
+export declare function detectStalePid(pidPath: string): boolean;

package/dist/src/shared/worker-daemon/functions/dispatch-request.function.d.ts

@@ -0,0 +1,35 @@
+import type { DaemonConfig } from '../typings/daemon-config.interface.ts';
+import type { HandlerContext } from '../typings/handler-context.interface.ts';
+import type { WriteLockState } from '../typings/write-lock.interface.ts';
+/** Daemon status information returned by `status` and `idle_at`. */
+interface DaemonStatus {
+    /** Whether the daemon is currently serving connections. */
+    readonly status: 'busy' | 'idle';
+    /** Whether the startup integrity check passed. */
+    readonly integrityOk: boolean;
+    /** Integrity errors found at startup, if any. */
+    readonly integrityErrors: string[];
+    /** Unix timestamp (seconds) of the last completed request. */
+    readonly idleAt: number;
+}
+/**
+ * Dispatches an IPC method to its handler.
+ *
+ * Routes daemon-state methods inline and delegates WASM read/write
+ * operations to their respective handler functions. Write operations
+ * are serialised through the single-writer lock.
+ *
+ * @param method - IPC method name
+ * @param params - request parameters
+ * @param ctx - handler context (WASM modules, config, targetDir)
+ * @param daemonStatus - live daemon state read by the `status` method
+ * @param writeLock - shared write-lock state
+ */
+export declare function dispatchRequest(method: string, params: Record<string, unknown>, ctx: HandlerContext, daemonStatus: DaemonStatus, writeLock: WriteLockState): Promise<unknown>;
+/**
+ * Re-export `DaemonConfig` so callers can pass strongly-typed
+ * config without an extra import.
+ *
+ * @internal
+ */
+export type { DaemonConfig };

package/dist/src/shared/worker-daemon/functions/handle-check-version.function.d.ts

@@ -0,0 +1,23 @@
+/** Payload returned by the `checkVersion` IPC method. */
+interface VersionCheckResult {
+    /** Compatibility status string. */
+    readonly status: string;
+    /** Format version stored in the catalog. */
+    readonly currentVersion: number;
+    /** Format version required by the current engine. */
+    readonly requiredVersion: number;
+}
+/**
+ * Handles the `checkVersion` IPC method.
+ *
+ * Reads `catalog.toml` at `targetPath` and compares its format
+ * version to `DB_FORMAT_VERSION`. Returns a result object without
+ * making any modifications.
+ *
+ * @param targetPath - absolute path to the `.kbdb` directory to
+ *   inspect; falls back to `defaultDir` when not provided in params
+ * @param defaultDir - fallback directory when `params.targetPath`
+ *   is absent
+ */
+export declare function handleCheckVersion(params: Record<string, unknown>, defaultDir: string): VersionCheckResult;
+export {};

package/dist/src/shared/worker-daemon/functions/handle-config-method.function.d.ts

@@ -0,0 +1,11 @@
+import type { DaemonConfig } from '../typings/daemon-config.interface.ts';
+/**
+ * Handles `config_{key}` IPC methods by returning the corresponding
+ * `DaemonConfig` field value.
+ *
+ * @param method - the full method name, e.g. `config_timeout_ms`
+ * @param config - parsed daemon configuration
+ * @throws {IpcError} with code `-32601` when the key suffix is not
+ *   in `CONFIG_KEY_MAP`
+ */
+export declare function handleConfigMethod(method: string, config: DaemonConfig): unknown;

package/dist/src/shared/worker-daemon/functions/handle-read-ops.function.d.ts

@@ -0,0 +1,52 @@
+import type { HandlerContext } from '../typings/handler-context.interface.ts';
+/**
+ * Handles `search` and `query` IPC methods.
+ *
+ * Encodes parameters, invokes the `worker_search` token pipeline,
+ * waits synchronously for the result, and decodes the paged result.
+ */
+export declare function handleSearch(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `get_result_status` IPC method.
+ */
+export declare function handleResultStatus(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `get_result` IPC method.
+ */
+export declare function handleGetResult(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `readSections` IPC method.
+ */
+export declare function handleReadSections(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `retrieveDocument` IPC method.
+ */
+export declare function handleRetrieveDoc(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `content` and `compose` IPC methods.
+ */
+export declare function handleCompose(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `integrityCheck` IPC method.
+ */
+export declare function handleIntegrityCheck(ctx: HandlerContext): unknown;
+/**
+ * Handles the `dbStatus` IPC method.
+ */
+export declare function handleDbStatus(ctx: HandlerContext): unknown;
+/**
+ * Handles the `listByType` IPC method.
+ */
+export declare function handleListByType(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `listDocumentsByType` IPC method.
+ */
+export declare function handleListDocsByType(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `recall` IPC method.
+ */
+export declare function handleRecall(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `export` and `exportDb` IPC methods.
+ */
+export declare function handleExport(ctx: HandlerContext, params: Record<string, unknown>): unknown;

package/dist/src/shared/worker-daemon/functions/handle-write-ops.function.d.ts

@@ -0,0 +1,44 @@
+import type { HandlerContext } from '../typings/handler-context.interface.ts';
+/**
+ * Handles the `addSection` IPC method.
+ *
+ * Encodes the section input, delegates to `worker_add_section`, and
+ * runs a near-duplicate scan when the WASM result reports none.
+ */
+export declare function handleAddSection(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `updateSection` IPC method.
+ */
+export declare function handleUpdateSection(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `removeSection` IPC method.
+ */
+export declare function handleRemoveSection(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `groupSections` IPC method.
+ */
+export declare function handleGroupSections(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `removeGrouping` IPC method.
+ */
+export declare function handleRemoveGrouping(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `initDirectory` IPC method.
+ */
+export declare function handleInitDirectory(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `invalidate` IPC method.
+ */
+export declare function handleInvalidate(ctx: HandlerContext, params: Record<string, unknown>): unknown;
+/**
+ * Handles the `invalidateAll` IPC method.
+ */
+export declare function handleInvalidateAll(ctx: HandlerContext): unknown;
+/**
+ * Handles the `gc` IPC method.
+ */
+export declare function handleGc(ctx: HandlerContext): unknown;
+/**
+ * Handles the `rebuildIndexes` IPC method.
+ */
+export declare function handleRebuild(ctx: HandlerContext): unknown;

package/dist/src/shared/worker-daemon/functions/parse-auto-capture-section.function.d.ts

@@ -0,0 +1,14 @@
+import type { AutoCaptureConfig } from '../../auto-capture/typings/auto-capture-config.interface.ts';
+/**
+ * Parses key-value pairs from an `[auto_capture]` TOML section
+ * into an `AutoCaptureConfig`.
+ *
+ * Recognised keys: `enabled`, `trigger_after_tool_calls`,
+ * `min_interval_ms`, `max_captures_per_session`, `dry_run`.
+ * Unknown keys are silently ignored. Falls back to
+ * `AUTO_CAPTURE_DEFAULTS` for any absent key.
+ *
+ * @param entries - key-value pairs from inside the
+ *   `[auto_capture]` section
+ */
+export declare function parseAutoCaptureSection(entries: ReadonlyMap<string, string>): AutoCaptureConfig;

package/dist/src/shared/worker-daemon/functions/parse-catalog-version.function.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parses the `version` field from a minimal TOML string.
+ *
+ * Supports only `version = <integer>` syntax. Comment lines are
+ * skipped. Returns `null` when no `version` field is present.
+ *
+ * @param text - raw TOML text from `catalog.toml`
+ * @returns the integer version, or `null` if absent
+ */
+export declare function parseCatalogVersion(text: string): number | null;