@dikolab/kbdb 0.6.4 → 0.6.5

package/dist/src/shared/cli/functions/learn-structured-document.function.d.ts

@@ -0,0 +1,10 @@
+import type { LearnClient } from '../typings/learn-client.interface.ts';
+import type { CliOptions } from '../typings/cli-options.interface.ts';
+import type { LearnResult } from '../typings/learn-result.model.ts';
+import type { SplitResult } from '../../content-splitter/index.ts';
+/**
+ * Stores each section of a split result as a separate
+ * knowledge-base section with parent resolution, then
+ * groups them under one document.
+ */
+export declare function learnStructuredDocument(client: LearnClient, options: CliOptions, path: string, splitResult: SplitResult, sourcePath?: string): Promise<LearnResult[]>;

package/dist/src/shared/cli/functions/learn-target-content.function.d.ts

@@ -2,23 +2,11 @@ import type { LearnClient } from '../typings/learn-client.interface.ts';
 import type { CliOptions } from '../typings/cli-options.interface.ts';
 import type { LearnResult } from '../typings/learn-result.model.ts';
 /**
- * Ingests one already-read target (a file's content, or stdin) as
- * either a single section or, for eligible markdown input, a set
- * of sections grouped under one document.
+ * Ingests one already-read target as either a single section
+ * or, for eligible structured content (Markdown, HTML, TOML),
+ * a set of sections grouped under one document.
  *
- * Markdown splitting is attempted when `path` is `'-'` (stdin) or
- * ends with `.md`, and `options.title` was not set explicitly --
- * an explicit title always maps to a single section. When splitting
- * does not apply, `content` is ingested as-is via `addSection()`.
- *
- * @param client - learn client to delegate ingestion to
- * @param options - parsed CLI options for this invocation
- * @param path - source file path, or `'-'` for stdin
- * @param content - raw text content already read from `path`
- * @param sourcePath - absolute file path for supersession, or
- *   `undefined` for stdin input
- * @param level - hierarchical level for the single-section
- *   fallback; ignored when markdown splitting applies
- * @returns one `LearnResult` per ingested section
+ * Splitting is attempted when `options.title` is not set and
+ * the content produces 2+ sections with at least one heading.
  */
 export declare function learnTargetContent(client: LearnClient, options: CliOptions, path: string, content: string, sourcePath?: string, level?: number): Promise<LearnResult[]>;

package/dist/src/shared/cli/functions/split-markdown-sections.function.d.ts

@@ -5,6 +5,10 @@ import type { MarkdownSection } from '../typings/markdown-section.interface.ts';
  * fenced code blocks are treated as plain text. A document with
  * no headings is returned as one titleless section.
  *
+ * Thin backward-compatible wrapper over the shared
+ * `splitMarkdown` strategy in `content-splitter`, stripping its
+ * `parentIndex` field for callers that predate section nesting.
+ *
  * @param content - raw markdown document text
  * @returns sections in document order, with trailing whitespace
  *   trimmed from each section's body

package/dist/src/shared/cli/typings/learn-client.interface.d.ts

@@ -28,6 +28,8 @@ export interface LearnClient {
         sourcePath?: string;
         /** Hierarchical level (1-6) assigned to the section. */
         level?: number;
+        /** KBID of the parent section for nesting. */
+        parent?: string;
     }): Promise<AddSectionResult>;
     /**
      * Groups a set of sections under a named document, creating the

package/dist/src/shared/cli/typings/learn-result.model.d.ts

@@ -31,4 +31,6 @@ export interface LearnResult {
         kbid: string;
         similarity: number;
     }[];
+    /** Kbid of the parent section for nesting, or `undefined`. */
+    parent?: string;
 }

package/dist/src/shared/content-splitter/classes/heading-parent-tracker.class.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tracks nesting of headings by depth to resolve each new
+ * heading's parent section index. Shared by splitters whose
+ * sections nest by a numeric depth (markdown, HTML).
+ */
+export declare class HeadingParentTracker {
+    private readonly stack;
+    /**
+     * Resolves the parent index for a heading at `level`
+     * appearing at output position `index`, then records the
+     * heading so subsequent, deeper headings can nest under it.
+     *
+     * @param level - heading depth, shallower is smaller
+     * @param index - position of this heading in the output
+     *   sections array
+     * @returns the parent's output index, or `null` when the
+     *   heading is at the root
+     */
+    resolve(level: number, index: number): number | null;
+}

package/dist/src/shared/content-splitter/constants/content-type-maps.constant.d.ts

@@ -0,0 +1,5 @@
+import type { ContentFormat } from '../typings/content-format.type.ts';
+/** Explicit type hints (MIME or short-form) mapped to format. */
+export declare const HINT_FORMAT_MAP: Record<string, ContentFormat>;
+/** File extensions (without the leading dot) mapped to format. */
+export declare const EXTENSION_FORMAT_MAP: Record<string, ContentFormat>;

package/dist/src/shared/content-splitter/constants/split-strategy-map.constant.d.ts

@@ -0,0 +1,4 @@
+import type { ContentFormat } from '../typings/content-format.type.ts';
+import type { SplitStrategy } from '../typings/split-strategy.interface.ts';
+/** Maps each recognized content format to its split strategy. */
+export declare const SPLIT_STRATEGY_MAP: Record<ContentFormat, SplitStrategy>;

package/dist/src/shared/content-splitter/functions/detect-content-type.function.d.ts

@@ -0,0 +1,13 @@
+import type { ContentFormat } from '../typings/content-format.type.ts';
+/**
+ * Detects the content format of a document, preferring an
+ * explicit type hint, then a file extension, then sniffing
+ * the content itself, and finally falling back to plain text.
+ *
+ * @param content - raw document text
+ * @param typeHint - explicit MIME type or short-form hint
+ *   (e.g. `'text/markdown'`, `'markdown'`)
+ * @param filePath - source file path used to infer format
+ *   from its extension
+ */
+export declare function detectContentType(content: string, typeHint?: string, filePath?: string): ContentFormat;

package/dist/src/shared/content-splitter/functions/flush-markdown-draft.function.d.ts

@@ -0,0 +1,14 @@
+import type { ContentSection } from '../typings/content-section.interface.ts';
+import type { HeadingParentTracker } from '../classes/heading-parent-tracker.class.ts';
+import type { MarkdownDraft } from '../typings/markdown-draft.interface.ts';
+/**
+ * Appends `draft` to `sections`, resolving its parent index
+ * via `tracker`. An empty, titleless draft (no accumulated
+ * preamble) is skipped.
+ *
+ * @param draft - accumulated section awaiting output
+ * @param sections - output array to append to, mutated in
+ *   place
+ * @param tracker - depth stack shared across a single split
+ */
+export declare function flushMarkdownDraft(draft: MarkdownDraft, sections: ContentSection[], tracker: HeadingParentTracker): void;

package/dist/src/shared/content-splitter/functions/flush-toml-draft.function.d.ts

@@ -0,0 +1,15 @@
+import type { ContentSection } from '../typings/content-section.interface.ts';
+import type { TomlDraft } from '../typings/toml-draft.interface.ts';
+/**
+ * Appends `draft` to `sections`, resolving its parent index
+ * via `pathIndex`. An empty, titleless draft (no accumulated
+ * preamble) is skipped. Registers titled drafts in
+ * `pathIndex` so later dotted headers can nest under them.
+ *
+ * @param draft - accumulated section awaiting output
+ * @param sections - output array to append to, mutated in
+ *   place
+ * @param pathIndex - lookup from header path to output index,
+ *   mutated in place
+ */
+export declare function flushTomlDraft(draft: TomlDraft, sections: ContentSection[], pathIndex: Map<string, number>): void;

package/dist/src/shared/content-splitter/functions/push-content-section.function.d.ts

@@ -0,0 +1,16 @@
+import type { ContentSection } from '../typings/content-section.interface.ts';
+import type { HeadingParentTracker } from '../classes/heading-parent-tracker.class.ts';
+/**
+ * Appends a section to `sections`, resolving its
+ * `parentIndex` via `tracker` when it carries a heading
+ * `level`. Shared by depth-nested splitters (markdown, HTML)
+ * so nesting logic is defined once.
+ *
+ * @param sections - output array to append to, mutated in
+ *   place
+ * @param tracker - depth stack shared across a single split
+ * @param content - section body content
+ * @param title - heading text, omitted for root content
+ * @param level - heading depth, omitted for root content
+ */
+export declare function pushContentSection(sections: ContentSection[], tracker: HeadingParentTracker, content: string, title?: string, level?: number): void;

package/dist/src/shared/content-splitter/functions/resolve-parent-ids.function.d.ts

@@ -0,0 +1,14 @@
+import type { ContentSection } from '../typings/content-section.interface.ts';
+/**
+ * Resolves each section's `parentIndex` to the KBDB id of the
+ * section that was stored at that index. Used after sections
+ * have been persisted in order, to link children to parents.
+ *
+ * @param sections - split sections, in the same order as
+ *   `kbids`
+ * @param kbids - persisted section ids, one per `sections`
+ *   entry
+ * @returns one parent id per section, or `null` for
+ *   root-level sections
+ */
+export declare function resolveParentIds(sections: readonly ContentSection[], kbids: readonly string[]): (string | null)[];

package/dist/src/shared/content-splitter/functions/split-content.function.d.ts

@@ -0,0 +1,11 @@
+import type { SplitResult } from '../typings/split-result.interface.ts';
+/**
+ * Splits `content` into sections using the strategy matching
+ * its detected format. Detection prefers `typeHint`, then
+ * `filePath`'s extension, then sniffs the content itself.
+ *
+ * @param content - raw document text
+ * @param typeHint - explicit MIME type or short-form hint
+ * @param filePath - source file path used to infer format
+ */
+export declare function splitContent(content: string, typeHint?: string, filePath?: string): SplitResult;

package/dist/src/shared/content-splitter/functions/split-html.function.d.ts

@@ -0,0 +1,12 @@
+import type { ContentSection } from '../typings/content-section.interface.ts';
+/**
+ * Splits HTML content into sections on `<h1>` through `<h6>`
+ * tag boundaries, using regex matching rather than DOM
+ * parsing. Each heading section's `parentIndex` points to the
+ * nearest enclosing heading of a shallower depth.
+ *
+ * @param content - raw HTML document text
+ * @returns sections in document order, trailing whitespace
+ *   trimmed from each section's body
+ */
+export declare function splitHtml(content: string): ContentSection[];

package/dist/src/shared/content-splitter/functions/split-markdown.function.d.ts

@@ -0,0 +1,13 @@
+import type { ContentSection } from '../typings/content-section.interface.ts';
+/**
+ * Splits markdown content into sections on ATX heading
+ * boundaries (`# Title` through `###### Title`). Headings
+ * inside fenced code blocks are treated as plain text. Each
+ * heading section's `parentIndex` points to the nearest
+ * enclosing heading of a shallower depth.
+ *
+ * @param content - raw markdown document text
+ * @returns sections in document order, trailing whitespace
+ *   trimmed from each section's body
+ */
+export declare function splitMarkdown(content: string): ContentSection[];

package/dist/src/shared/content-splitter/functions/split-plain-text.function.d.ts

@@ -0,0 +1,8 @@
+import type { ContentSection } from '../typings/content-section.interface.ts';
+/**
+ * Passthrough splitter for unrecognized content formats.
+ * Wraps the entire input in a single root-level section.
+ *
+ * @param content - raw document text
+ */
+export declare function splitPlainText(content: string): ContentSection[];

package/dist/src/shared/content-splitter/functions/split-toml.function.d.ts

@@ -0,0 +1,12 @@
+import type { ContentSection } from '../typings/content-section.interface.ts';
+/**
+ * Splits TOML content into sections on `[table]` header
+ * boundaries. A dotted header (`[a.b]`) nests under the
+ * section matching its prefix (`[a]`); an undotted or quoted
+ * header is a root-level section.
+ *
+ * @param content - raw TOML document text
+ * @returns sections in document order, trailing whitespace
+ *   trimmed from each section's body
+ */
+export declare function splitToml(content: string): ContentSection[];

package/dist/src/shared/content-splitter/index.d.ts

@@ -0,0 +1,11 @@
+export { splitContent } from './functions/split-content.function.ts';
+export { splitMarkdown } from './functions/split-markdown.function.ts';
+export { splitHtml } from './functions/split-html.function.ts';
+export { splitToml } from './functions/split-toml.function.ts';
+export { splitPlainText } from './functions/split-plain-text.function.ts';
+export { detectContentType } from './functions/detect-content-type.function.ts';
+export { resolveParentIds } from './functions/resolve-parent-ids.function.ts';
+export type { ContentSection } from './typings/content-section.interface.ts';
+export type { SplitResult } from './typings/split-result.interface.ts';
+export type { SplitStrategy } from './typings/split-strategy.interface.ts';
+export type { ContentFormat } from './typings/content-format.type.ts';

package/dist/src/shared/content-splitter/typings/content-format.type.d.ts

@@ -0,0 +1,2 @@
+/** Content formats recognized by the content splitter. */
+export type ContentFormat = 'markdown' | 'html' | 'toml' | 'plain-text';

package/dist/src/shared/content-splitter/typings/content-section.interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A section produced by a content splitter.
+ * Depth-first ordered within the document.
+ */
+export interface ContentSection {
+    /** Section heading text, if any. */
+    title?: string;
+    /** Heading depth (1-6), if detected. */
+    level?: number;
+    /** Section body content. */
+    content: string;
+    /**
+     * Index of the parent section in the output
+     * array, or `null` for root-level sections.
+     */
+    parentIndex: number | null;
+}

package/dist/src/shared/content-splitter/typings/markdown-draft.interface.d.ts

@@ -0,0 +1,12 @@
+/**
+ * In-progress markdown section accumulated while scanning
+ * document lines, before it is flushed into a `ContentSection`.
+ */
+export interface MarkdownDraft {
+    /** Heading text, omitted while accumulating preamble. */
+    title?: string;
+    /** Heading depth (1-6), omitted while accumulating preamble. */
+    level?: number;
+    /** Body lines collected since the last heading. */
+    lines: string[];
+}

package/dist/src/shared/content-splitter/typings/split-result.interface.d.ts

@@ -0,0 +1,8 @@
+import type { ContentSection } from './content-section.interface.ts';
+/** Result of splitting content by format. */
+export interface SplitResult {
+    /** Extracted sections, depth-first ordered. */
+    sections: ContentSection[];
+    /** Detected content format identifier. */
+    format: string;
+}

package/dist/src/shared/content-splitter/typings/split-strategy.interface.d.ts

@@ -0,0 +1,3 @@
+import type { ContentSection } from './content-section.interface.ts';
+/** Splits raw content into sections. */
+export type SplitStrategy = (content: string) => ContentSection[];

package/dist/src/shared/content-splitter/typings/toml-draft.interface.d.ts

@@ -0,0 +1,15 @@
+/**
+ * In-progress TOML section accumulated while scanning
+ * document lines, before it is flushed into a `ContentSection`.
+ */
+export interface TomlDraft {
+    /** Header text, omitted while accumulating preamble. */
+    title?: string;
+    /**
+     * Header text used for dotted-parent lookup, identical to
+     * `title` unless the header is quoted.
+     */
+    path?: string;
+    /** Body lines collected since the last header. */
+    lines: string[];
+}

package/dist/src/shared/mcp/functions/build-learn-payload.function.d.ts

@@ -0,0 +1,24 @@
+import type { AddSectionResult, NearDuplicateEntry } from '../../worker-client/typings/add-section-result.model.ts';
+/** JSON-serializable result envelope returned by the `learn` tool. */
+export interface LearnPayload {
+    /** Knowledge-base identifiers of all stored sections. */
+    readonly items: string[];
+    /** Number of items in the result set. */
+    readonly total: number;
+    /** Offset into the result set (always 0 for learn). */
+    readonly offset: number;
+    /** Kbid of a superseded section, or `null` if none. */
+    readonly superseded: string | null;
+    /** Advisory warnings emitted during indexing. */
+    readonly warnings: string[];
+    /** Near-duplicate sections detected above the threshold. */
+    readonly near_duplicates: NearDuplicateEntry[];
+}
+/**
+ * Normalizes an `AddSectionResult` into the `learn` tool's JSON
+ * result envelope, defaulting optional fields to their empty
+ * representation.
+ *
+ * @param result - the raw result from storing one or more sections
+ */
+export declare function buildLearnPayload(result: AddSectionResult): LearnPayload;

package/dist/src/shared/mcp/functions/determine-learn-split.function.d.ts

@@ -0,0 +1,18 @@
+import type { SplitResult } from '../../content-splitter/index.ts';
+/**
+ * Determines whether `learn` content should be imported as
+ * multiple linked sections instead of one, and returns the split
+ * result when it should.
+ *
+ * Splitting applies only when no explicit `title` is given, the
+ * section type is a splittable text format (`text/*` or the bare
+ * `'markdown'` alias), and splitting produces at least two
+ * sections with at least one heading title.
+ *
+ * @param content - raw content to evaluate for splitting
+ * @param sectionType - the section's semantic type label
+ * @param title - explicit title from the caller, if any
+ * @returns the split result when splitting should apply,
+ *   otherwise `undefined`
+ */
+export declare function determineLearnSplit(content: string, sectionType: string, title: string | undefined): SplitResult | undefined;

package/dist/src/shared/mcp/functions/handle-tool-learn.function.d.ts

@@ -4,7 +4,9 @@ import type { ToolCallResult } from '../typings/tool-call-result.model.ts';
  * Handles the `learn` MCP tool call.
  *
  * Validates that image content includes a title, then imports the
- * content into the knowledge base via the worker client.
+ * content into the knowledge base via the worker client. Text
+ * content without an explicit title is automatically split into
+ * linked sections when it contains multiple headings.
  *
  * @param client - the worker client used to execute operations
  * @param args - tool arguments from the MCP request

package/dist/src/shared/mcp/functions/learn-with-splitting.function.d.ts

@@ -0,0 +1,22 @@
+import type { McpWorkerClient } from '../typings/mcp-client.interface.ts';
+import type { LearnSectionParams } from '../typings/learn-section-params.interface.ts';
+import type { SplitResult } from '../../content-splitter/index.ts';
+/** Result of storing a split document's sections. */
+export interface LearnWithSplittingResult {
+    /** Knowledge-base identifiers, one per stored section. */
+    readonly kbids: string[];
+    /** Resolved title for the document these sections belong to. */
+    readonly docTitle: string;
+}
+/**
+ * Stores each section of a `splitContent` result as a separate
+ * knowledge-base section, in depth-first order. Every section
+ * shares a single `docid`, and each child section is linked to
+ * its parent via the kbid assigned when that parent was stored.
+ *
+ * @param client - the worker client used to store sections
+ * @param splitResult - depth-first ordered sections to persist
+ * @param params - metadata shared across all stored sections
+ * @returns the persisted kbids and the resolved document title
+ */
+export declare function learnWithSplitting(client: McpWorkerClient, splitResult: SplitResult, params: LearnSectionParams): Promise<LearnWithSplittingResult>;

package/dist/src/shared/mcp/functions/parse-learn-args.function.d.ts

@@ -0,0 +1,24 @@
+/** Parsed and type-narrowed arguments for the `learn` tool call. */
+export interface LearnArgs {
+    /** Section type, defaulting to `'text/markdown'`. */
+    readonly sectionType: string;
+    /** Explicit section title, if provided. */
+    readonly title?: string;
+    /** Optional section description. */
+    readonly description?: string;
+    /** Optional shared document ID. */
+    readonly docid?: string;
+    /** Optional tags for scoping and filtering. */
+    readonly tags?: string[];
+    /** Whether to replace an existing section (supersession). */
+    readonly replace?: boolean;
+    /** Optional hierarchical level (1-6). */
+    readonly level?: number;
+}
+/**
+ * Narrows the raw `learn` tool call arguments into typed fields,
+ * applying `'text/markdown'` as the default section type.
+ *
+ * @param args - tool arguments from the MCP request
+ */
+export declare function parseLearnArgs(args: Record<string, unknown>): LearnArgs;

package/dist/src/shared/mcp/functions/store-split-learn-sections.function.d.ts

@@ -0,0 +1,16 @@
+import type { McpWorkerClient } from '../typings/mcp-client.interface.ts';
+import type { LearnSectionParams } from '../typings/learn-section-params.interface.ts';
+import type { AddSectionResult } from '../../worker-client/typings/add-section-result.model.ts';
+import type { SplitResult } from '../../content-splitter/index.ts';
+/**
+ * Stores a split document's sections and groups them under a
+ * shared document manifest, returning the same result envelope
+ * shape as a single-section `learn` call.
+ *
+ * @param client - the worker client used to store and group
+ *   sections
+ * @param splitResult - depth-first ordered sections to persist
+ * @param params - metadata shared across all stored sections
+ * @returns a learn-result envelope listing every stored kbid
+ */
+export declare function storeSplitLearnSections(client: McpWorkerClient, splitResult: SplitResult, params: LearnSectionParams): Promise<AddSectionResult>;

package/dist/src/shared/mcp/functions/unwrap-json-content.function.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Unwraps content that AI clients accidentally wrap in a JSON
+ * object. If the string starts with `{` and parses as JSON with
+ * a `content` or `text` field, returns that inner field value.
+ * Otherwise returns the original string.
+ *
+ * @param raw - the raw content string from a tool call argument
+ */
+export declare function unwrapJsonContent(raw: string): string;

package/dist/src/shared/mcp/typings/learn-section-params.interface.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Metadata shared across every section stored for a single
+ * `learn` tool call, whether stored as one section or split
+ * into several linked sections.
+ */
+export interface LearnSectionParams {
+    /** Semantic type label applied to every stored section. */
+    readonly sectionType: string;
+    /** Optional description applied to every stored section. */
+    readonly description?: string;
+    /** Optional document ID shared by every stored section. */
+    readonly docid?: string;
+    /** Optional tags applied to every stored section. */
+    readonly tags?: string[];
+    /**
+     * When `true`, replaces an existing section that has the same
+     * source key (supersession).
+     */
+    readonly replace?: boolean;
+}

package/dist/src/shared/mcp/typings/mcp-client.interface.d.ts

@@ -144,6 +144,10 @@ export interface McpWorkerClient {
          * source key (supersession).
          */
         readonly replace?: boolean;
+        /** Hierarchical level (1-6). */
+        readonly level?: number;
+        /** Kbid of the parent section for nesting. */
+        readonly parent?: string;
     }): Promise<AddSectionResult>;
     /**
      * Removes a section from the knowledge base.

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

@@ -84,6 +84,10 @@ export interface McpWorkerClient {
          * source key (supersession).
          */
         readonly replace?: boolean;
+        /** Hierarchical level (1-6). */
+        readonly level?: number;
+        /** Kbid of the parent section for nesting. */
+        readonly parent?: string;
     }): Promise<AddSectionResult>;
     /**
      * Removes a section from the knowledge base.

package/dist/src/shared/version/constants/version.constant.d.ts

@@ -1,2 +1,2 @@
 /** Current package version, kept in sync with package.json. */
-export declare const VERSION = "0.6.4";
+export declare const VERSION = "0.6.5";

package/dist/src/shared/wasm-codec/functions/decode-one-recall-result.function.d.ts

@@ -3,7 +3,8 @@ import type { RecallResult } from '../../worker-client/typings/recall-result.mod
 /**
  * Decodes a single `RecallResult` record from WASM binary output.
  *
- * Wire format: kbid, heading, section_type, content, docid list,
+ * Wire format: kbid, heading, section_type, content, level
+ * (Option<u8>), parent (Option<String>), docid list,
  * document list, back_references list, siblings list,
  * references list.
  *

package/dist/src/shared/wasm-codec/functions/decode-recall-document.function.d.ts

@@ -5,7 +5,8 @@ import type { RecallDocument } from '../../worker-client/typings/recall-result.m
  *
  * Wire format: docid (String), title (String), section_count (u32),
  * then each section as kbid (String), heading (Option<String>),
- * section_type (String).
+ * section_type (String), level (Option<u8>), parent
+ * (Option<String>).
  *
  * @param bytes - raw binary buffer
  * @param offset - byte position of the record start

package/dist/src/shared/wasm-codec/functions/decode-recall-result.function.d.ts

@@ -14,6 +14,8 @@ import type { RecallResult } from '../../worker-client/typings/recall-result.mod
  * Option<String> heading  (0x00=null, 0x01 + String)
  * String section_type
  * String content
+ * Option<u8> level
+ * Option<String> parent
  * u32 docids_count + String[] docids
  * u32 documents_count + RecallDocument[]
  * u32 back_references_count + RecallReference[]

package/dist/src/shared/wasm-codec/functions/decode-recall-sibling.function.d.ts

@@ -4,7 +4,8 @@ import type { RecallSibling } from '../../worker-client/typings/recall-result.mo
  * Decodes a single `RecallSibling` record from WASM binary output.
  *
  * Wire format: kbid (String), heading (Option<String>),
- * section_type (String), content (String).
+ * section_type (String), content (String), level
+ * (Option<u8>), parent (Option<String>).
  *
  * @param bytes - raw binary buffer
  * @param offset - byte position of the record start

package/dist/src/shared/wasm-codec/functions/decode-scored-results.function.d.ts

@@ -28,6 +28,10 @@ export interface SectionMatch {
     matched_fields: string[];
     /** ISO 8601 creation timestamp of the section. */
     created_at: string;
+    /** Heading level (1-6), or `null` when unset. */
+    level: number | null;
+    /** Kbid of the parent section, or `null`. */
+    parent: string | null;
 }
 /**
  * Paginated search response envelope returned by the WASM engine.
@@ -71,5 +75,7 @@ export interface PagedSearchResult {
  *   - `matched_terms`: `u32` count + `String[]`
  *   - `matched_fields`: `u32` count + `String[]`
  *   - `created_at`: `String`
+ *   - `level`: `Option<u8>`
+ *   - `parent`: `Option<String>`
  */
 export declare function decodePagedSearchResult(bytes: Uint8Array): PagedSearchResult;

package/dist/src/shared/wasm-codec/functions/decode-section-match.function.d.ts

@@ -6,7 +6,8 @@ import type { SectionMatch } from '../typings/section-match.model.ts';
  * Wire format per item: kbid, heading (Option<String>),
  * section_type, docids (u32 count + String[]), score (f32),
  * confidence (f32), snippet, matched_terms (u32 + String[]),
- * matched_fields (u32 + String[]), created_at.
+ * matched_fields (u32 + String[]), created_at, level
+ * (Option<u8>), parent (Option<String>).
  *
  * @param bytes - raw binary buffer
  * @param startOffset - byte position of the item start

package/dist/src/shared/wasm-codec/functions/decode-section-records.function.d.ts

@@ -67,6 +67,10 @@ export interface SectionRecord {
      * Hierarchical level (1-6). `null` when not set.
      */
     level?: number | null;
+    /**
+     * KBDB ID of the parent section for nesting. `null` for root.
+     */
+    parent?: string | null;
 }
 /**
  * Decodes a list of `SectionRecord` values from WASM binary output.

package/dist/src/shared/wasm-codec/functions/encode-add-section-params.function.d.ts

@@ -15,5 +15,6 @@ import type { AddSectionInput } from '../typings/add-section-input.model.ts';
  * - `tags`: `u32` count + each `String`
  * - `replace`: `u8` (0 or 1)
  * - `level`: `u8` flag + optional `u8` (`Option<u8>`)
+ * - `parent`: `u8` flag + optional `String`
  */
 export declare function encodeAddSectionParams(params: AddSectionInput): Uint8Array;

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

@@ -48,4 +48,6 @@ export interface AddSectionInput {
      * no explicit level (defaults to 1 in the engine).
      */
     level?: number;
+    /** Kbid of the parent section for nesting. */
+    parent?: string | null;
 }

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

@@ -28,4 +28,8 @@ export interface SectionMatch {
     matched_fields: string[];
     /** ISO 8601 creation timestamp of the section. */
     created_at: string;
+    /** Heading level (1-6), or `null` when unset. */
+    level: number | null;
+    /** Kbid of the parent section, or `null`. */
+    parent: string | null;
 }