@okf/ootils 1.30.0 → 1.31.0

package/dist/browser.d.mts

@@ -1428,6 +1428,14 @@ interface BlockDef {
         icon?: string;
         iconWeight?: string;
         displayInDirectImportUI?: string;
+        /**
+         * Position of this comp in the direct import field selector dropdown,
+         * as a tuple [groupIdx, orderInGroup]. Groups are rendered in ascending
+         * groupIdx order with separators between them. Within a group, items are
+         * rendered in ascending orderInGroup.
+         * Currently: 1 = title, 2 = content fields, 3 = tags. Add more as needed.
+         */
+        directImportGroupsIdx?: [number, number];
     };
     /** Full chunking config used by okf-sub CreateChunksHandler */
     chunkingConfig?: {
@@ -1436,10 +1444,16 @@ interface BlockDef {
     };
 }
 interface BlockCapabilities {
-    /** Block's value contains extractable plain text (even if value also has other structure like JSON) */
+    /**
+     * Block's value contains extractable plain text — even if the value also has other structure
+     * (like Lexical's JSON editorState alongside its allText). True for: TextInput, TitleInput,
+     * SubtitleInput, LexicalTextEditor, etc. False for: media inputs, selection inputs, tags, dates.
+     *
+     * Used wherever code needs "give me all the blocks I can pull readable text from" — e.g.
+     * AI annotation context extraction, document text usage stats, AI suggestion text field
+     * filtering. Combine with `fieldPaths.plainTextString` to know HOW to extract the text.
+     */
     hasPlainText: boolean;
-    /** Block's value is in the Lexical shape — editorState, allText, etc. */
-    hasLexicalShape: boolean;
     /**
      * General annotation flag — this block type supports annotation
      * (human, human-in-the-loop, or AI). Used by general checks: should the
@@ -1456,10 +1470,6 @@ interface BlockCapabilities {
     aiAnnotation: boolean;
     /** Supports AI enrichment — categorization, sentiment analysis, NER */
     aiEnrichment: boolean;
-    /** Treated as qualitative in AI Chat? */
-    aiChatQualField: boolean;
-    /** Treated as quantitative in AI Chat? */
-    aiChatQuantField: boolean;
     /** Can be searched via ES/listing search? */
     searchable: boolean;
     /** Supported in direct data import? */
@@ -1476,6 +1486,13 @@ interface BlockCapabilities {
      * in chunk/anno metadata — the actual text already lives in the chunks/annos themselves.
      */
     stripFromMainOnAnnoChunkSync: boolean;
+    /**
+     * Project this block out of listing fetches (e.g. published listings) for performance.
+     * Used for large-payload blocks (like Lexical) where the listing UI doesn't need the
+     * full content. Independent of stripFromMainOnAnnoChunkSync — same blocks today, but
+     * the two concerns may diverge later.
+     */
+    excludeFromListingProjection: boolean;
 }
 
 /**
@@ -1545,6 +1562,24 @@ declare class BlockRegistry {
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
+    /**
+     * Get compName strings for all registered blocks that have a chunking config.
+     * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+     * description) to know which fields actually have chunks to search.
+     */
+    getCompsWithChunking(): string[];
+    /**
+     * Filter a list of block instances down to those where annotation is enabled.
+     * A block is annotation-enabled if its registry capability `annotation` is true.
+     * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+     * falls back to the legacy per-instance `props.annotation.enable` toggle.
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     */
+    getAnnotationEnabledBlocks(allBlocks: Array<{
+        comp: string;
+        props?: any;
+    }>): any[];
 }
 /** Singleton instance — the one registry shared across the app. */
 declare const blockRegistry: BlockRegistry;

package/dist/browser.d.ts

@@ -1428,6 +1428,14 @@ interface BlockDef {
         icon?: string;
         iconWeight?: string;
         displayInDirectImportUI?: string;
+        /**
+         * Position of this comp in the direct import field selector dropdown,
+         * as a tuple [groupIdx, orderInGroup]. Groups are rendered in ascending
+         * groupIdx order with separators between them. Within a group, items are
+         * rendered in ascending orderInGroup.
+         * Currently: 1 = title, 2 = content fields, 3 = tags. Add more as needed.
+         */
+        directImportGroupsIdx?: [number, number];
     };
     /** Full chunking config used by okf-sub CreateChunksHandler */
     chunkingConfig?: {
@@ -1436,10 +1444,16 @@ interface BlockDef {
     };
 }
 interface BlockCapabilities {
-    /** Block's value contains extractable plain text (even if value also has other structure like JSON) */
+    /**
+     * Block's value contains extractable plain text — even if the value also has other structure
+     * (like Lexical's JSON editorState alongside its allText). True for: TextInput, TitleInput,
+     * SubtitleInput, LexicalTextEditor, etc. False for: media inputs, selection inputs, tags, dates.
+     *
+     * Used wherever code needs "give me all the blocks I can pull readable text from" — e.g.
+     * AI annotation context extraction, document text usage stats, AI suggestion text field
+     * filtering. Combine with `fieldPaths.plainTextString` to know HOW to extract the text.
+     */
     hasPlainText: boolean;
-    /** Block's value is in the Lexical shape — editorState, allText, etc. */
-    hasLexicalShape: boolean;
     /**
      * General annotation flag — this block type supports annotation
      * (human, human-in-the-loop, or AI). Used by general checks: should the
@@ -1456,10 +1470,6 @@ interface BlockCapabilities {
     aiAnnotation: boolean;
     /** Supports AI enrichment — categorization, sentiment analysis, NER */
     aiEnrichment: boolean;
-    /** Treated as qualitative in AI Chat? */
-    aiChatQualField: boolean;
-    /** Treated as quantitative in AI Chat? */
-    aiChatQuantField: boolean;
     /** Can be searched via ES/listing search? */
     searchable: boolean;
     /** Supported in direct data import? */
@@ -1476,6 +1486,13 @@ interface BlockCapabilities {
      * in chunk/anno metadata — the actual text already lives in the chunks/annos themselves.
      */
     stripFromMainOnAnnoChunkSync: boolean;
+    /**
+     * Project this block out of listing fetches (e.g. published listings) for performance.
+     * Used for large-payload blocks (like Lexical) where the listing UI doesn't need the
+     * full content. Independent of stripFromMainOnAnnoChunkSync — same blocks today, but
+     * the two concerns may diverge later.
+     */
+    excludeFromListingProjection: boolean;
 }
 
 /**
@@ -1545,6 +1562,24 @@ declare class BlockRegistry {
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
+    /**
+     * Get compName strings for all registered blocks that have a chunking config.
+     * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+     * description) to know which fields actually have chunks to search.
+     */
+    getCompsWithChunking(): string[];
+    /**
+     * Filter a list of block instances down to those where annotation is enabled.
+     * A block is annotation-enabled if its registry capability `annotation` is true.
+     * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+     * falls back to the legacy per-instance `props.annotation.enable` toggle.
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     */
+    getAnnotationEnabledBlocks(allBlocks: Array<{
+        comp: string;
+        props?: any;
+    }>): any[];
 }
 /** Singleton instance — the one registry shared across the app. */
 declare const blockRegistry: BlockRegistry;

package/dist/browser.js

@@ -2269,18 +2269,16 @@ var LexicalTextEditor = {
   // Capabilities
   capabilities: {
     hasPlainText: true,
-    hasLexicalShape: true,
     annotation: true,
     aiAnnotation: true,
     aiEnrichment: true,
-    aiChatQualField: true,
-    aiChatQuantField: false,
     searchable: true,
     directDataImport: true,
     csvExport: true,
     translatable: true,
     documentSummarizer: true,
-    stripFromMainOnAnnoChunkSync: true
+    stripFromMainOnAnnoChunkSync: true,
+    excludeFromListingProjection: true
   },
   // Field paths
   fieldPaths: {
@@ -2317,7 +2315,8 @@ var LexicalTextEditor = {
   // Content block option — TCI template builder & direct import UI
   contentBlockOption: {
     display: "Rich Text Field",
-    icon: "TextAa"
+    icon: "TextAa",
+    directImportGroupsIdx: [2, 2]
   },
   // Chunking config — used by okf-sub CreateChunksHandler
   chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
@@ -2384,6 +2383,29 @@ var BlockRegistry = class {
   getAll() {
     return Array.from(this.blocks.values());
   }
+  /**
+   * Get compName strings for all registered blocks that have a chunking config.
+   * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+   * description) to know which fields actually have chunks to search.
+   */
+  getCompsWithChunking() {
+    return Array.from(this.blocks.values()).filter((b) => !!b.chunkingConfig).map((b) => b.compName);
+  }
+  /**
+   * Filter a list of block instances down to those where annotation is enabled.
+   * A block is annotation-enabled if its registry capability `annotation` is true.
+   * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+   * falls back to the legacy per-instance `props.annotation.enable` toggle.
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   */
+  getAnnotationEnabledBlocks(allBlocks) {
+    return allBlocks.filter((block) => {
+      const blockDef = this.blocks.get(block.comp);
+      if (blockDef) return !!blockDef.capabilities.annotation;
+      return block.props?.annotation?.enable === true;
+    });
+  }
 };
 var blockRegistry = new BlockRegistry();
 // Annotate the CommonJS export names for ESM import in node:

package/dist/browser.mjs

@@ -2203,18 +2203,16 @@ var LexicalTextEditor = {
   // Capabilities
   capabilities: {
     hasPlainText: true,
-    hasLexicalShape: true,
     annotation: true,
     aiAnnotation: true,
     aiEnrichment: true,
-    aiChatQualField: true,
-    aiChatQuantField: false,
     searchable: true,
     directDataImport: true,
     csvExport: true,
     translatable: true,
     documentSummarizer: true,
-    stripFromMainOnAnnoChunkSync: true
+    stripFromMainOnAnnoChunkSync: true,
+    excludeFromListingProjection: true
   },
   // Field paths
   fieldPaths: {
@@ -2251,7 +2249,8 @@ var LexicalTextEditor = {
   // Content block option — TCI template builder & direct import UI
   contentBlockOption: {
     display: "Rich Text Field",
-    icon: "TextAa"
+    icon: "TextAa",
+    directImportGroupsIdx: [2, 2]
   },
   // Chunking config — used by okf-sub CreateChunksHandler
   chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
@@ -2318,6 +2317,29 @@ var BlockRegistry = class {
   getAll() {
     return Array.from(this.blocks.values());
   }
+  /**
+   * Get compName strings for all registered blocks that have a chunking config.
+   * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+   * description) to know which fields actually have chunks to search.
+   */
+  getCompsWithChunking() {
+    return Array.from(this.blocks.values()).filter((b) => !!b.chunkingConfig).map((b) => b.compName);
+  }
+  /**
+   * Filter a list of block instances down to those where annotation is enabled.
+   * A block is annotation-enabled if its registry capability `annotation` is true.
+   * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+   * falls back to the legacy per-instance `props.annotation.enable` toggle.
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   */
+  getAnnotationEnabledBlocks(allBlocks) {
+    return allBlocks.filter((block) => {
+      const blockDef = this.blocks.get(block.comp);
+      if (blockDef) return !!blockDef.capabilities.annotation;
+      return block.props?.annotation?.enable === true;
+    });
+  }
 };
 var blockRegistry = new BlockRegistry();
 export {

package/dist/node.d.mts

@@ -1435,6 +1435,14 @@ interface BlockDef {
         icon?: string;
         iconWeight?: string;
         displayInDirectImportUI?: string;
+        /**
+         * Position of this comp in the direct import field selector dropdown,
+         * as a tuple [groupIdx, orderInGroup]. Groups are rendered in ascending
+         * groupIdx order with separators between them. Within a group, items are
+         * rendered in ascending orderInGroup.
+         * Currently: 1 = title, 2 = content fields, 3 = tags. Add more as needed.
+         */
+        directImportGroupsIdx?: [number, number];
     };
     /** Full chunking config used by okf-sub CreateChunksHandler */
     chunkingConfig?: {
@@ -1443,10 +1451,16 @@ interface BlockDef {
     };
 }
 interface BlockCapabilities {
-    /** Block's value contains extractable plain text (even if value also has other structure like JSON) */
+    /**
+     * Block's value contains extractable plain text — even if the value also has other structure
+     * (like Lexical's JSON editorState alongside its allText). True for: TextInput, TitleInput,
+     * SubtitleInput, LexicalTextEditor, etc. False for: media inputs, selection inputs, tags, dates.
+     *
+     * Used wherever code needs "give me all the blocks I can pull readable text from" — e.g.
+     * AI annotation context extraction, document text usage stats, AI suggestion text field
+     * filtering. Combine with `fieldPaths.plainTextString` to know HOW to extract the text.
+     */
     hasPlainText: boolean;
-    /** Block's value is in the Lexical shape — editorState, allText, etc. */
-    hasLexicalShape: boolean;
     /**
      * General annotation flag — this block type supports annotation
      * (human, human-in-the-loop, or AI). Used by general checks: should the
@@ -1463,10 +1477,6 @@ interface BlockCapabilities {
     aiAnnotation: boolean;
     /** Supports AI enrichment — categorization, sentiment analysis, NER */
     aiEnrichment: boolean;
-    /** Treated as qualitative in AI Chat? */
-    aiChatQualField: boolean;
-    /** Treated as quantitative in AI Chat? */
-    aiChatQuantField: boolean;
     /** Can be searched via ES/listing search? */
     searchable: boolean;
     /** Supported in direct data import? */
@@ -1483,6 +1493,13 @@ interface BlockCapabilities {
      * in chunk/anno metadata — the actual text already lives in the chunks/annos themselves.
      */
     stripFromMainOnAnnoChunkSync: boolean;
+    /**
+     * Project this block out of listing fetches (e.g. published listings) for performance.
+     * Used for large-payload blocks (like Lexical) where the listing UI doesn't need the
+     * full content. Independent of stripFromMainOnAnnoChunkSync — same blocks today, but
+     * the two concerns may diverge later.
+     */
+    excludeFromListingProjection: boolean;
 }
 
 /**
@@ -1552,6 +1569,24 @@ declare class BlockRegistry {
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
+    /**
+     * Get compName strings for all registered blocks that have a chunking config.
+     * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+     * description) to know which fields actually have chunks to search.
+     */
+    getCompsWithChunking(): string[];
+    /**
+     * Filter a list of block instances down to those where annotation is enabled.
+     * A block is annotation-enabled if its registry capability `annotation` is true.
+     * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+     * falls back to the legacy per-instance `props.annotation.enable` toggle.
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     */
+    getAnnotationEnabledBlocks(allBlocks: Array<{
+        comp: string;
+        props?: any;
+    }>): any[];
 }
 /** Singleton instance — the one registry shared across the app. */
 declare const blockRegistry: BlockRegistry;

package/dist/node.d.ts

@@ -1435,6 +1435,14 @@ interface BlockDef {
         icon?: string;
         iconWeight?: string;
         displayInDirectImportUI?: string;
+        /**
+         * Position of this comp in the direct import field selector dropdown,
+         * as a tuple [groupIdx, orderInGroup]. Groups are rendered in ascending
+         * groupIdx order with separators between them. Within a group, items are
+         * rendered in ascending orderInGroup.
+         * Currently: 1 = title, 2 = content fields, 3 = tags. Add more as needed.
+         */
+        directImportGroupsIdx?: [number, number];
     };
     /** Full chunking config used by okf-sub CreateChunksHandler */
     chunkingConfig?: {
@@ -1443,10 +1451,16 @@ interface BlockDef {
     };
 }
 interface BlockCapabilities {
-    /** Block's value contains extractable plain text (even if value also has other structure like JSON) */
+    /**
+     * Block's value contains extractable plain text — even if the value also has other structure
+     * (like Lexical's JSON editorState alongside its allText). True for: TextInput, TitleInput,
+     * SubtitleInput, LexicalTextEditor, etc. False for: media inputs, selection inputs, tags, dates.
+     *
+     * Used wherever code needs "give me all the blocks I can pull readable text from" — e.g.
+     * AI annotation context extraction, document text usage stats, AI suggestion text field
+     * filtering. Combine with `fieldPaths.plainTextString` to know HOW to extract the text.
+     */
     hasPlainText: boolean;
-    /** Block's value is in the Lexical shape — editorState, allText, etc. */
-    hasLexicalShape: boolean;
     /**
      * General annotation flag — this block type supports annotation
      * (human, human-in-the-loop, or AI). Used by general checks: should the
@@ -1463,10 +1477,6 @@ interface BlockCapabilities {
     aiAnnotation: boolean;
     /** Supports AI enrichment — categorization, sentiment analysis, NER */
     aiEnrichment: boolean;
-    /** Treated as qualitative in AI Chat? */
-    aiChatQualField: boolean;
-    /** Treated as quantitative in AI Chat? */
-    aiChatQuantField: boolean;
     /** Can be searched via ES/listing search? */
     searchable: boolean;
     /** Supported in direct data import? */
@@ -1483,6 +1493,13 @@ interface BlockCapabilities {
      * in chunk/anno metadata — the actual text already lives in the chunks/annos themselves.
      */
     stripFromMainOnAnnoChunkSync: boolean;
+    /**
+     * Project this block out of listing fetches (e.g. published listings) for performance.
+     * Used for large-payload blocks (like Lexical) where the listing UI doesn't need the
+     * full content. Independent of stripFromMainOnAnnoChunkSync — same blocks today, but
+     * the two concerns may diverge later.
+     */
+    excludeFromListingProjection: boolean;
 }
 
 /**
@@ -1552,6 +1569,24 @@ declare class BlockRegistry {
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
+    /**
+     * Get compName strings for all registered blocks that have a chunking config.
+     * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+     * description) to know which fields actually have chunks to search.
+     */
+    getCompsWithChunking(): string[];
+    /**
+     * Filter a list of block instances down to those where annotation is enabled.
+     * A block is annotation-enabled if its registry capability `annotation` is true.
+     * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+     * falls back to the legacy per-instance `props.annotation.enable` toggle.
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     */
+    getAnnotationEnabledBlocks(allBlocks: Array<{
+        comp: string;
+        props?: any;
+    }>): any[];
 }
 /** Singleton instance — the one registry shared across the app. */
 declare const blockRegistry: BlockRegistry;

package/dist/node.js

@@ -3863,18 +3863,16 @@ var LexicalTextEditor = {
   // Capabilities
   capabilities: {
     hasPlainText: true,
-    hasLexicalShape: true,
     annotation: true,
     aiAnnotation: true,
     aiEnrichment: true,
-    aiChatQualField: true,
-    aiChatQuantField: false,
     searchable: true,
     directDataImport: true,
     csvExport: true,
     translatable: true,
     documentSummarizer: true,
-    stripFromMainOnAnnoChunkSync: true
+    stripFromMainOnAnnoChunkSync: true,
+    excludeFromListingProjection: true
   },
   // Field paths
   fieldPaths: {
@@ -3911,7 +3909,8 @@ var LexicalTextEditor = {
   // Content block option — TCI template builder & direct import UI
   contentBlockOption: {
     display: "Rich Text Field",
-    icon: "TextAa"
+    icon: "TextAa",
+    directImportGroupsIdx: [2, 2]
   },
   // Chunking config — used by okf-sub CreateChunksHandler
   chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
@@ -3978,6 +3977,29 @@ var BlockRegistry = class {
   getAll() {
     return Array.from(this.blocks.values());
   }
+  /**
+   * Get compName strings for all registered blocks that have a chunking config.
+   * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+   * description) to know which fields actually have chunks to search.
+   */
+  getCompsWithChunking() {
+    return Array.from(this.blocks.values()).filter((b) => !!b.chunkingConfig).map((b) => b.compName);
+  }
+  /**
+   * Filter a list of block instances down to those where annotation is enabled.
+   * A block is annotation-enabled if its registry capability `annotation` is true.
+   * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+   * falls back to the legacy per-instance `props.annotation.enable` toggle.
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   */
+  getAnnotationEnabledBlocks(allBlocks) {
+    return allBlocks.filter((block) => {
+      const blockDef = this.blocks.get(block.comp);
+      if (blockDef) return !!blockDef.capabilities.annotation;
+      return block.props?.annotation?.enable === true;
+    });
+  }
 };
 var blockRegistry = new BlockRegistry();
 

package/dist/node.mjs

@@ -3796,18 +3796,16 @@ var LexicalTextEditor = {
   // Capabilities
   capabilities: {
     hasPlainText: true,
-    hasLexicalShape: true,
     annotation: true,
     aiAnnotation: true,
     aiEnrichment: true,
-    aiChatQualField: true,
-    aiChatQuantField: false,
     searchable: true,
     directDataImport: true,
     csvExport: true,
     translatable: true,
     documentSummarizer: true,
-    stripFromMainOnAnnoChunkSync: true
+    stripFromMainOnAnnoChunkSync: true,
+    excludeFromListingProjection: true
   },
   // Field paths
   fieldPaths: {
@@ -3844,7 +3842,8 @@ var LexicalTextEditor = {
   // Content block option — TCI template builder & direct import UI
   contentBlockOption: {
     display: "Rich Text Field",
-    icon: "TextAa"
+    icon: "TextAa",
+    directImportGroupsIdx: [2, 2]
   },
   // Chunking config — used by okf-sub CreateChunksHandler
   chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
@@ -3911,6 +3910,29 @@ var BlockRegistry = class {
   getAll() {
     return Array.from(this.blocks.values());
   }
+  /**
+   * Get compName strings for all registered blocks that have a chunking config.
+   * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+   * description) to know which fields actually have chunks to search.
+   */
+  getCompsWithChunking() {
+    return Array.from(this.blocks.values()).filter((b) => !!b.chunkingConfig).map((b) => b.compName);
+  }
+  /**
+   * Filter a list of block instances down to those where annotation is enabled.
+   * A block is annotation-enabled if its registry capability `annotation` is true.
+   * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+   * falls back to the legacy per-instance `props.annotation.enable` toggle.
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   */
+  getAnnotationEnabledBlocks(allBlocks) {
+    return allBlocks.filter((block) => {
+      const blockDef = this.blocks.get(block.comp);
+      if (blockDef) return !!blockDef.capabilities.annotation;
+      return block.props?.annotation?.enable === true;
+    });
+  }
 };
 var blockRegistry = new BlockRegistry();
 

package/dist/universal.d.mts

@@ -1428,6 +1428,14 @@ interface BlockDef {
         icon?: string;
         iconWeight?: string;
         displayInDirectImportUI?: string;
+        /**
+         * Position of this comp in the direct import field selector dropdown,
+         * as a tuple [groupIdx, orderInGroup]. Groups are rendered in ascending
+         * groupIdx order with separators between them. Within a group, items are
+         * rendered in ascending orderInGroup.
+         * Currently: 1 = title, 2 = content fields, 3 = tags. Add more as needed.
+         */
+        directImportGroupsIdx?: [number, number];
     };
     /** Full chunking config used by okf-sub CreateChunksHandler */
     chunkingConfig?: {
@@ -1436,10 +1444,16 @@ interface BlockDef {
     };
 }
 interface BlockCapabilities {
-    /** Block's value contains extractable plain text (even if value also has other structure like JSON) */
+    /**
+     * Block's value contains extractable plain text — even if the value also has other structure
+     * (like Lexical's JSON editorState alongside its allText). True for: TextInput, TitleInput,
+     * SubtitleInput, LexicalTextEditor, etc. False for: media inputs, selection inputs, tags, dates.
+     *
+     * Used wherever code needs "give me all the blocks I can pull readable text from" — e.g.
+     * AI annotation context extraction, document text usage stats, AI suggestion text field
+     * filtering. Combine with `fieldPaths.plainTextString` to know HOW to extract the text.
+     */
     hasPlainText: boolean;
-    /** Block's value is in the Lexical shape — editorState, allText, etc. */
-    hasLexicalShape: boolean;
     /**
      * General annotation flag — this block type supports annotation
      * (human, human-in-the-loop, or AI). Used by general checks: should the
@@ -1456,10 +1470,6 @@ interface BlockCapabilities {
     aiAnnotation: boolean;
     /** Supports AI enrichment — categorization, sentiment analysis, NER */
     aiEnrichment: boolean;
-    /** Treated as qualitative in AI Chat? */
-    aiChatQualField: boolean;
-    /** Treated as quantitative in AI Chat? */
-    aiChatQuantField: boolean;
     /** Can be searched via ES/listing search? */
     searchable: boolean;
     /** Supported in direct data import? */
@@ -1476,6 +1486,13 @@ interface BlockCapabilities {
      * in chunk/anno metadata — the actual text already lives in the chunks/annos themselves.
      */
     stripFromMainOnAnnoChunkSync: boolean;
+    /**
+     * Project this block out of listing fetches (e.g. published listings) for performance.
+     * Used for large-payload blocks (like Lexical) where the listing UI doesn't need the
+     * full content. Independent of stripFromMainOnAnnoChunkSync — same blocks today, but
+     * the two concerns may diverge later.
+     */
+    excludeFromListingProjection: boolean;
 }
 
 /**
@@ -1545,6 +1562,24 @@ declare class BlockRegistry {
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
+    /**
+     * Get compName strings for all registered blocks that have a chunking config.
+     * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+     * description) to know which fields actually have chunks to search.
+     */
+    getCompsWithChunking(): string[];
+    /**
+     * Filter a list of block instances down to those where annotation is enabled.
+     * A block is annotation-enabled if its registry capability `annotation` is true.
+     * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+     * falls back to the legacy per-instance `props.annotation.enable` toggle.
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     */
+    getAnnotationEnabledBlocks(allBlocks: Array<{
+        comp: string;
+        props?: any;
+    }>): any[];
 }
 /** Singleton instance — the one registry shared across the app. */
 declare const blockRegistry: BlockRegistry;

package/dist/universal.d.ts

@@ -1428,6 +1428,14 @@ interface BlockDef {
         icon?: string;
         iconWeight?: string;
         displayInDirectImportUI?: string;
+        /**
+         * Position of this comp in the direct import field selector dropdown,
+         * as a tuple [groupIdx, orderInGroup]. Groups are rendered in ascending
+         * groupIdx order with separators between them. Within a group, items are
+         * rendered in ascending orderInGroup.
+         * Currently: 1 = title, 2 = content fields, 3 = tags. Add more as needed.
+         */
+        directImportGroupsIdx?: [number, number];
     };
     /** Full chunking config used by okf-sub CreateChunksHandler */
     chunkingConfig?: {
@@ -1436,10 +1444,16 @@ interface BlockDef {
     };
 }
 interface BlockCapabilities {
-    /** Block's value contains extractable plain text (even if value also has other structure like JSON) */
+    /**
+     * Block's value contains extractable plain text — even if the value also has other structure
+     * (like Lexical's JSON editorState alongside its allText). True for: TextInput, TitleInput,
+     * SubtitleInput, LexicalTextEditor, etc. False for: media inputs, selection inputs, tags, dates.
+     *
+     * Used wherever code needs "give me all the blocks I can pull readable text from" — e.g.
+     * AI annotation context extraction, document text usage stats, AI suggestion text field
+     * filtering. Combine with `fieldPaths.plainTextString` to know HOW to extract the text.
+     */
     hasPlainText: boolean;
-    /** Block's value is in the Lexical shape — editorState, allText, etc. */
-    hasLexicalShape: boolean;
     /**
      * General annotation flag — this block type supports annotation
      * (human, human-in-the-loop, or AI). Used by general checks: should the
@@ -1456,10 +1470,6 @@ interface BlockCapabilities {
     aiAnnotation: boolean;
     /** Supports AI enrichment — categorization, sentiment analysis, NER */
     aiEnrichment: boolean;
-    /** Treated as qualitative in AI Chat? */
-    aiChatQualField: boolean;
-    /** Treated as quantitative in AI Chat? */
-    aiChatQuantField: boolean;
     /** Can be searched via ES/listing search? */
     searchable: boolean;
     /** Supported in direct data import? */
@@ -1476,6 +1486,13 @@ interface BlockCapabilities {
      * in chunk/anno metadata — the actual text already lives in the chunks/annos themselves.
      */
     stripFromMainOnAnnoChunkSync: boolean;
+    /**
+     * Project this block out of listing fetches (e.g. published listings) for performance.
+     * Used for large-payload blocks (like Lexical) where the listing UI doesn't need the
+     * full content. Independent of stripFromMainOnAnnoChunkSync — same blocks today, but
+     * the two concerns may diverge later.
+     */
+    excludeFromListingProjection: boolean;
 }
 
 /**
@@ -1545,6 +1562,24 @@ declare class BlockRegistry {
     hasCapability(compType: string, capability: keyof BlockCapabilities): boolean;
     /** Get all registered block descriptors. */
     getAll(): BlockDef[];
+    /**
+     * Get compName strings for all registered blocks that have a chunking config.
+     * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+     * description) to know which fields actually have chunks to search.
+     */
+    getCompsWithChunking(): string[];
+    /**
+     * Filter a list of block instances down to those where annotation is enabled.
+     * A block is annotation-enabled if its registry capability `annotation` is true.
+     * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+     * falls back to the legacy per-instance `props.annotation.enable` toggle.
+     *
+     * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+     */
+    getAnnotationEnabledBlocks(allBlocks: Array<{
+        comp: string;
+        props?: any;
+    }>): any[];
 }
 /** Singleton instance — the one registry shared across the app. */
 declare const blockRegistry: BlockRegistry;

package/dist/universal.js

@@ -2269,18 +2269,16 @@ var LexicalTextEditor = {
   // Capabilities
   capabilities: {
     hasPlainText: true,
-    hasLexicalShape: true,
     annotation: true,
     aiAnnotation: true,
     aiEnrichment: true,
-    aiChatQualField: true,
-    aiChatQuantField: false,
     searchable: true,
     directDataImport: true,
     csvExport: true,
     translatable: true,
     documentSummarizer: true,
-    stripFromMainOnAnnoChunkSync: true
+    stripFromMainOnAnnoChunkSync: true,
+    excludeFromListingProjection: true
   },
   // Field paths
   fieldPaths: {
@@ -2317,7 +2315,8 @@ var LexicalTextEditor = {
   // Content block option — TCI template builder & direct import UI
   contentBlockOption: {
     display: "Rich Text Field",
-    icon: "TextAa"
+    icon: "TextAa",
+    directImportGroupsIdx: [2, 2]
   },
   // Chunking config — used by okf-sub CreateChunksHandler
   chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
@@ -2384,6 +2383,29 @@ var BlockRegistry = class {
   getAll() {
     return Array.from(this.blocks.values());
   }
+  /**
+   * Get compName strings for all registered blocks that have a chunking config.
+   * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+   * description) to know which fields actually have chunks to search.
+   */
+  getCompsWithChunking() {
+    return Array.from(this.blocks.values()).filter((b) => !!b.chunkingConfig).map((b) => b.compName);
+  }
+  /**
+   * Filter a list of block instances down to those where annotation is enabled.
+   * A block is annotation-enabled if its registry capability `annotation` is true.
+   * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+   * falls back to the legacy per-instance `props.annotation.enable` toggle.
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   */
+  getAnnotationEnabledBlocks(allBlocks) {
+    return allBlocks.filter((block) => {
+      const blockDef = this.blocks.get(block.comp);
+      if (blockDef) return !!blockDef.capabilities.annotation;
+      return block.props?.annotation?.enable === true;
+    });
+  }
 };
 var blockRegistry = new BlockRegistry();
 // Annotate the CommonJS export names for ESM import in node:

package/dist/universal.mjs

@@ -2203,18 +2203,16 @@ var LexicalTextEditor = {
   // Capabilities
   capabilities: {
     hasPlainText: true,
-    hasLexicalShape: true,
     annotation: true,
     aiAnnotation: true,
     aiEnrichment: true,
-    aiChatQualField: true,
-    aiChatQuantField: false,
     searchable: true,
     directDataImport: true,
     csvExport: true,
     translatable: true,
     documentSummarizer: true,
-    stripFromMainOnAnnoChunkSync: true
+    stripFromMainOnAnnoChunkSync: true,
+    excludeFromListingProjection: true
   },
   // Field paths
   fieldPaths: {
@@ -2251,7 +2249,8 @@ var LexicalTextEditor = {
   // Content block option — TCI template builder & direct import UI
   contentBlockOption: {
     display: "Rich Text Field",
-    icon: "TextAa"
+    icon: "TextAa",
+    directImportGroupsIdx: [2, 2]
   },
   // Chunking config — used by okf-sub CreateChunksHandler
   chunkingConfig: CHUNKING_PRESETS.lexicalSemantic
@@ -2318,6 +2317,29 @@ var BlockRegistry = class {
   getAll() {
     return Array.from(this.blocks.values());
   }
+  /**
+   * Get compName strings for all registered blocks that have a chunking config.
+   * Used by chunking pipelines and prompt-string injection (e.g. searchChunks tool
+   * description) to know which fields actually have chunks to search.
+   */
+  getCompsWithChunking() {
+    return Array.from(this.blocks.values()).filter((b) => !!b.chunkingConfig).map((b) => b.compName);
+  }
+  /**
+   * Filter a list of block instances down to those where annotation is enabled.
+   * A block is annotation-enabled if its registry capability `annotation` is true.
+   * For backwards compat with un-migrated blocks (e.g. deprecated KPRichInput/RichTextEditor),
+   * falls back to the legacy per-instance `props.annotation.enable` toggle.
+   *
+   * Today: every registered annotation-capable block (e.g. LexicalTextEditor) is auto-enabled.
+   */
+  getAnnotationEnabledBlocks(allBlocks) {
+    return allBlocks.filter((block) => {
+      const blockDef = this.blocks.get(block.comp);
+      if (blockDef) return !!blockDef.capabilities.annotation;
+      return block.props?.annotation?.enable === true;
+    });
+  }
 };
 var blockRegistry = new BlockRegistry();
 export {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.30.0",
+  "version": "1.31.0",
   "description": "Utility functions for both browser and Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",