@blokkli/editor 2.0.0-alpha.57 → 2.0.0-alpha.59

package/dist/modules/agent/runtime/app/tools/find_paragraphs/index.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema } from "../schemas.js";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import { getResolvedOptions } from "../helpers.js";
 import {
-  getAvailableOptions,
   getMutatedOptionValue,
   optionValueToStorable
 } from "#blokkli/editor/helpers/options";
@@ -11,8 +12,12 @@ const paramsSchema = z.object({
   bundle: z.string().optional().describe("Filter by exact bundle name"),
   bundles: z.array(z.string()).optional().describe("Filter by any of these bundles"),
   // Structure filters
-  hasChildren: z.boolean().optional().describe("Filter by whether paragraph has child paragraphs"),
-  isRootLevel: z.boolean().optional().describe("Filter to root level paragraphs (nesting 0)"),
+  hasChildren: booleanParam(
+    "Filter by whether paragraph has child paragraphs"
+  ).optional(),
+  isRootLevel: booleanParam(
+    "Filter to root level paragraphs (nesting 0)"
+  ).optional(),
   nestingLevel: z.number().optional().describe("Filter to exact nesting level"),
   parentBundle: z.string().optional().describe("Filter to paragraphs whose parent is this bundle"),
   inField: z.string().optional().describe("Filter to paragraphs in a field with this name"),
@@ -24,7 +29,7 @@ const paramsSchema = z.object({
     value: z.union([z.string(), z.boolean(), z.number()]).describe("Expected option value")
   }).optional().describe("Filter to paragraphs where an option equals a value"),
   // Pagination
-  limit: z.number().optional().default(50).describe("Maximum number of results to return (default: 50)")
+  limit: z.coerce.number().optional().default(50).describe("Maximum number of results to return (default: 50)")
 });
 const paragraphResultSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
@@ -47,12 +52,12 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `found ${r.total || 0} paragraphs${r.hasMore ? " (more available)" : ""}`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentFindBlocksRunning", "Finding blocks...");
+    return $t("aiAgentFindBlocksRunning", "Finding blocks", { more: true });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { blocks, state, context, types, dom, definitions, $t } = ctx.app;
+    const { blocks, state, context, types, dom, $t } = ctx.app;
     const limit = params.limit ?? 50;
     let candidates = blocks.getAllBlocks();
     if (params.bundle) {
@@ -104,17 +109,13 @@ export default defineBlokkliAgentTool({
     if (params.optionEquals) {
       const { key, value } = params.optionEquals;
       candidates = candidates.filter((block) => {
-        const definition = definitions.getBlockDefinition(
+        const availableOptions = getResolvedOptions(
+          ctx.app,
           block.bundle,
           block.fieldListType,
           block.parentBlockBundle
         );
-        if (!definition) return false;
-        const availableOptions = getAvailableOptions(
-          definition.options,
-          definition.globalOptions,
-          definitions.globalOptions.value
-        );
+        if (!availableOptions) return false;
         const optionDef = availableOptions.find((o) => o.property === key);
         if (!optionDef) return false;
         const currentValue = getMutatedOptionValue(

package/dist/modules/agent/runtime/app/tools/get_all_page_content/index.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { readBlockContentFields } from "../helpers.js";
 const paramsSchema = z.object({});
 const blockContentSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
@@ -21,7 +22,9 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `${r.content?.length || 0} paragraphs`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetAllPageContentRunning", "Getting all page content...");
+    return $t("aiAgentGetAllPageContentRunning", "Getting all page content", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
@@ -31,24 +34,15 @@ export default defineBlokkliAgentTool({
     function processBlock(blockUuid) {
       const block = blocks.getBlock(blockUuid);
       if (!block) return;
-      const editables = ctx.app.directive.getEditablesForBlock(blockUuid);
       const textParts = [];
-      for (const editable of editables) {
-        const fieldType = ctx.app.fieldValue.resolveFieldType(
-          ctx.itemEntityType,
-          block.bundle,
-          editable.fieldName
-        );
-        if (!fieldType) continue;
-        const value = ctx.app.fieldValue.readValue(
-          ctx.itemEntityType,
-          blockUuid,
-          block.bundle,
-          editable.fieldName,
-          fieldType
-        );
-        if (value.trim()) {
-          textParts.push(value.trim());
+      for (const f of readBlockContentFields(
+        ctx.app,
+        blockUuid,
+        ctx.itemEntityType,
+        block.bundle
+      )) {
+        if (f.value.trim()) {
+          textParts.push(f.value.trim());
         }
       }
       const droppableFields = ctx.app.types.droppableFieldConfig.forEntityTypeAndBundle(ctx.itemEntityType, block.bundle).map((f) => f.name);

package/dist/modules/agent/runtime/app/tools/get_bundle_info/index.js

@@ -1,12 +1,11 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { getAvailableOptions } from "#blokkli/editor/helpers/options";
 import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
 import { blockOptionsMapSchema } from "../schemas.js";
-import { extractOptionLabels } from "../helpers.js";
+import { extractOptionLabels, getResolvedOptions } from "../helpers.js";
 const paramsSchema = z.object({
   parentUuid: z.string().describe("The parent entity UUID"),
-  field: z.string().describe("The field name"),
+  parentField: z.string().describe("The field name on the parent"),
   bundles: z.array(z.string()).optional().describe(
     "Optional list of bundle names to filter by. If omitted, returns all allowed bundles."
   )
@@ -53,29 +52,31 @@ export default defineBlokkliAgentTool({
   lazy: true,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetBundleInfoRunning", "Getting bundle info...");
+    return $t("aiAgentGetBundleInfoRunning", "Getting bundle info", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { fields, types, state, definitions, $t, context, blocks } = ctx.app;
+    const { fields, types, state, $t, context, blocks } = ctx.app;
     const label = $t(
       "aiAgentGetBundleInfoDone",
       "Got bundle info for @field"
-    ).replace("@field", params.field);
-    const field = fields.find(params.parentUuid, params.field);
+    ).replace("@field", params.parentField);
+    const field = fields.find(params.parentUuid, params.parentField);
     if (!field) {
       return {
         label,
         result: {
-          fieldLabel: params.field,
+          fieldLabel: params.parentField,
           cardinality: -1,
           currentCount: 0,
           bundles: []
         }
       };
     }
-    const fieldKey = `${params.parentUuid}:${params.field}`;
+    const fieldKey = `${params.parentUuid}:${params.parentField}`;
     const currentCount = state.getFieldBlockCount(fieldKey);
     const allowedBundles = params.bundles ? field.allowedBundles.filter((b) => params.bundles.includes(b)) : field.allowedBundles;
     const includeOptions = allowedBundles.length < 3;
@@ -107,28 +108,24 @@ export default defineBlokkliAgentTool({
       }
       let options;
       if (includeOptions) {
-        const definition = definitions.getBlockDefinition(
+        const availableOptions = getResolvedOptions(
+          ctx.app,
           bundle,
           "default",
           parentBundle
         );
-        if (definition) {
-          const availableOptions = getAvailableOptions(
-            definition.options,
-            definition.globalOptions,
-            definitions.globalOptions.value
-          );
+        if (availableOptions) {
           if (availableOptions.length > 0) {
             options = {};
             for (const opt of availableOptions) {
-              const currentValue = getRuntimeOptionValue(
+              const resolvedValue = getRuntimeOptionValue(
                 opt.option,
                 opt.option.default
               );
               const entry = {
                 type: opt.option.type,
                 label: opt.option.label,
-                currentValue
+                currentValue: resolvedValue ?? ""
               };
               if (opt.option.description) {
                 entry.description = opt.option.description;
@@ -137,11 +134,13 @@ export default defineBlokkliAgentTool({
               if (labels) {
                 entry.options = labels;
               }
-              if ("min" in opt.option) {
-                entry.min = opt.option.min;
+              const optMin = opt.option.min;
+              const optMax = opt.option.max;
+              if (typeof optMin === "number") {
+                entry.min = optMin;
               }
-              if ("max" in opt.option) {
-                entry.max = opt.option.max;
+              if (typeof optMax === "number") {
+                entry.max = optMax;
               }
               if ("step" in opt.option && opt.option.type === "range") {
                 entry.step = opt.option.step;

package/dist/modules/agent/runtime/app/tools/get_content_fields/index.js

@@ -1,12 +1,15 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { readBlockContentFields } from "../helpers.js";
+import { stringArrayParam } from "../schemas.js";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
 const paramsSchema = z.object({
-  uuids: z.array(z.string()).describe(
+  uuids: stringArrayParam(
     "One or more paragraph UUIDs (or the page UUID to get page-level fields)"
   ),
-  includeNested: z.boolean().optional().default(true).describe(
+  includeNested: booleanParam(
     "Recursively include content fields from all nested child paragraphs (default: true). Set to false to only get direct fields."
-  )
+  ).optional().default(true)
 });
 const fieldSchema = z.discriminatedUnion("type", [
   z.object({
@@ -61,12 +64,14 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `fields for ${Object.keys(r || {}).length} paragraphs`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetContentFieldsRunning", "Getting content fields...");
+    return $t("aiAgentGetContentFieldsRunning", "Getting content fields", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { blocks, directive, state, types, $t, context } = ctx.app;
+    const { blocks, state, types, $t, context } = ctx.app;
     const result = {};
     const processedUuids = /* @__PURE__ */ new Set();
     function processEntity(entityUuid) {
@@ -106,29 +111,20 @@ export default defineBlokkliAgentTool({
       processedUuids.add(blockUuid);
       const block = blocks.getBlock(blockUuid);
       if (!block) return;
-      const editables = directive.getEditablesForBlock(blockUuid);
-      for (const editable of editables) {
-        const fieldType = ctx.app.fieldValue.resolveFieldType(
-          ctx.itemEntityType,
-          block.bundle,
-          editable.fieldName
-        );
-        if (!fieldType) continue;
-        const currentValue = ctx.app.fieldValue.readValue(
-          ctx.itemEntityType,
-          blockUuid,
-          block.bundle,
-          editable.fieldName,
-          fieldType
-        );
+      for (const f of readBlockContentFields(
+        ctx.app,
+        blockUuid,
+        ctx.itemEntityType,
+        block.bundle
+      )) {
         const config = types.editableFieldConfig.forName(
           ctx.itemEntityType,
           block.bundle,
-          editable.fieldName
+          f.fieldName
         );
-        addField(result, blockUuid, editable.fieldName, {
-          type: fieldType,
-          currentValue,
+        addField(result, blockUuid, f.fieldName, {
+          type: f.fieldType,
+          currentValue: f.value,
           required: config?.required ?? false,
           maxLength: config?.maxLength ?? 0
         });

package/dist/modules/agent/runtime/app/tools/get_mutation_history/index.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 const paramsSchema = z.object({
-  before: z.number().optional().describe("How many mutations before current to include"),
-  after: z.number().optional().describe("How many mutations after current to include (redo-able)")
+  before: z.coerce.number().optional().describe("How many mutations before current to include"),
+  after: z.coerce.number().optional().describe("How many mutations after current to include (redo-able)")
 });
 const mutationSummarySchema = z.object({
   index: z.number().describe("History index for use with go_to_history_index"),
@@ -32,7 +32,9 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `index ${r.currentIndex ?? -1}/${r.totalCount ?? 0}`,
   modes: ["editing", "translating"],
   label($t) {
-    return $t("aiAgentGetMutationHistoryRunning", "Getting mutation history...");
+    return $t("aiAgentGetMutationHistoryRunning", "Getting mutation history", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,

package/dist/modules/agent/runtime/app/tools/get_page_structure/index.js

@@ -56,7 +56,9 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `page structure (${r.totalParagraphs ?? 0} paragraphs)`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetPageStructureRunning", "Getting page structure...");
+    return $t("aiAgentGetPageStructureRunning", "Getting page structure", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,

package/dist/modules/agent/runtime/app/tools/get_paragraph_context/index.js

@@ -1,16 +1,24 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { parentSchema, blockOptionsMapSchema } from "../schemas.js";
-import { buildBlockOptionsMap } from "../helpers.js";
-import { getAvailableOptions } from "#blokkli/editor/helpers/options";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
+import {
+  buildBlockOptionsMap,
+  getResolvedOptions,
+  readBlockContentFields
+} from "../helpers.js";
 import { fragmentBlockBundle } from "#blokkli-build/config";
 const paramsSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),
-  includeParentChain: z.boolean().optional().default(true).describe("Include ancestor parent paragraphs up to the page"),
-  includeSiblings: z.boolean().optional().default(false).describe("Include sibling paragraphs in the same field"),
-  includeChildren: z.boolean().optional().default(true).describe("Include child fields summary"),
-  includeContentFields: z.boolean().optional().default(true).describe("Include content fields (text, media, links) with values"),
-  includeOptions: z.boolean().optional().default(true).describe("Include paragraph options")
+  includeParentChain: booleanParam(
+    "Include ancestor parent paragraphs up to the page"
+  ).optional().default(true),
+  includeSiblings: booleanParam("Include sibling paragraphs in the same field").optional().default(false),
+  includeChildren: booleanParam("Include child fields summary").optional().default(true),
+  includeContentFields: booleanParam(
+    "Include content fields (text, media, links) with values"
+  ).optional().default(true),
+  includeOptions: booleanParam("Include paragraph options").optional().default(true)
 });
 const parentChainItemSchema = z.object({
   uuid: z.string().describe("The parent paragraph UUID"),
@@ -93,21 +101,14 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `context for ${r.bundle || "paragraph"} (${r.uuid?.slice(0, 8) || "?"})`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetBlockContextRunning", "Getting block context...");
+    return $t("aiAgentGetBlockContextRunning", "Getting block context", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const {
-      blocks,
-      state,
-      context,
-      types,
-      directive,
-      definitions,
-      selection,
-      $t
-    } = ctx.app;
+    const { blocks, state, context, types, selection, $t } = ctx.app;
     const block = blocks.getBlock(params.uuid);
     if (!block) {
       return {
@@ -197,25 +198,16 @@ export default defineBlokkliAgentTool({
     }
     if (params.includeContentFields) {
       const fields = [];
-      const editables = directive.getEditablesForBlock(params.uuid);
-      for (const editable of editables) {
-        const fieldType = ctx.app.fieldValue.resolveFieldType(
-          ctx.itemEntityType,
-          block.bundle,
-          editable.fieldName
-        );
-        if (!fieldType) continue;
-        const currentValue = ctx.app.fieldValue.readValue(
-          ctx.itemEntityType,
-          params.uuid,
-          block.bundle,
-          editable.fieldName,
-          fieldType
-        );
+      for (const f of readBlockContentFields(
+        ctx.app,
+        params.uuid,
+        ctx.itemEntityType,
+        block.bundle
+      )) {
         fields.push({
-          field: editable.fieldName,
-          type: fieldType,
-          currentValue
+          field: f.fieldName,
+          type: f.fieldType,
+          currentValue: f.value
         });
       }
       const droppableConfigs = types.droppableFieldConfig.forEntityTypeAndBundle(
@@ -238,24 +230,18 @@ export default defineBlokkliAgentTool({
       const selectionItem = selection.items.value.find(
         (v) => v.uuid === params.uuid
       );
-      const definition = definitions.getBlockDefinition(
+      const availableOptions = getResolvedOptions(
+        ctx.app,
         block.bundle,
         selectionItem?.fieldListType ?? "default",
         selectionItem?.parentBlockBundle ?? null
       );
-      if (definition) {
-        const availableOptions = getAvailableOptions(
-          definition.options,
-          definition.globalOptions,
-          definitions.globalOptions.value
+      if (availableOptions && availableOptions.length > 0) {
+        result.options = buildBlockOptionsMap(
+          availableOptions,
+          state.mutatedOptions,
+          params.uuid
         );
-        if (availableOptions.length > 0) {
-          result.options = buildBlockOptionsMap(
-            availableOptions,
-            state.mutatedOptions,
-            params.uuid
-          );
-        }
       }
     }
     return {

package/dist/modules/agent/runtime/app/tools/get_paragraph_options/index.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { getAvailableOptions } from "#blokkli/editor/helpers/options";
 import { blockOptionsMapSchema } from "../schemas.js";
-import { buildBlockOptionsMap } from "../helpers.js";
+import { buildBlockOptionsMap, getResolvedOptions } from "../helpers.js";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The paragraph UUIDs to get options for")
 });
@@ -19,12 +18,14 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `options for ${Object.keys(r || {}).length} paragraphs`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetBlockOptionsRunning", "Getting block options...");
+    return $t("aiAgentGetBlockOptionsRunning", "Getting block options", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,
   execute(ctx, params) {
-    const { blocks, state, definitions, selection, types, $t } = ctx.app;
+    const { blocks, state, selection, types, $t } = ctx.app;
     const result = {};
     const affectedUuids = [];
     for (const uuid of params.uuids) {
@@ -32,17 +33,13 @@ export default defineBlokkliAgentTool({
       if (!block) continue;
       const bundle = block.library?.reusableBundle || block.bundle;
       const selectionItem = selection.items.value.find((v) => v.uuid === uuid);
-      const definition = definitions.getBlockDefinition(
+      const availableOptions = getResolvedOptions(
+        ctx.app,
         bundle,
         selectionItem?.fieldListType ?? "default",
         selectionItem?.parentBlockBundle ?? null
       );
-      if (!definition) continue;
-      const availableOptions = getAvailableOptions(
-        definition.options,
-        definition.globalOptions,
-        definitions.globalOptions.value
-      );
+      if (!availableOptions) continue;
       result[uuid] = buildBlockOptionsMap(
         availableOptions,
         state.mutatedOptions,

package/dist/modules/agent/runtime/app/tools/get_paragraphs_in_viewport/index.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+import { booleanParam } from "#blokkli/agent/shared/toolParams";
 const paramsSchema = z.object({
-  maxNestingLevel: z.number().optional().describe(
+  maxNestingLevel: z.coerce.number().optional().describe(
     "Maximum nesting depth to include (0 = only root paragraphs, 1 = root + direct children, etc.). Omit for unlimited depth."
   ),
-  includeDimensions: z.boolean().optional().default(false).describe(
+  includeDimensions: booleanParam(
     "Include x, y, width, height for each paragraph (default: false)"
-  )
+  ).optional().default(false)
 });
 const dimensionsSchema = z.object({
   x: z.number().describe("X position in artboard coordinates"),
@@ -148,7 +149,10 @@ export default defineBlokkliAgentTool({
   label($t) {
     return $t(
       "aiAgentGetBlocksInViewportRunning",
-      "Getting blocks in viewport..."
+      "Getting blocks in viewport",
+      {
+        more: true
+      }
     );
   },
   paramsSchema,

package/dist/modules/agent/runtime/app/tools/get_readability_issues/index.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { runReadabilityAnalysis } from "../helpers.js";
+import { runReadabilityAnalysis } from "../readability.js";
 const issueSchema = z.object({
   text: z.string(),
   impact: z.string().optional(),
@@ -29,7 +29,9 @@ export default defineBlokkliAgentTool({
   requiredAdapterMethods: ["getAnalyzers"],
   isAvailable: (app) => app.readability.isAvailable.value,
   label($t) {
-    return $t("aiAgentAnalyzeContentRunning", "Analyzing content...");
+    return $t("aiAgentAnalyzeContentRunning", "Analyzing content", {
+      more: true
+    });
   },
   prunedSummary: (r) => {
     let count = 0;

package/dist/modules/agent/runtime/app/tools/get_selected_paragraphs/index.js

@@ -18,7 +18,9 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => `${r.paragraphs?.length || 0} paragraphs selected`,
   modes: ["readonly", "editing", "translating", "review"],
   label($t) {
-    return $t("aiAgentGetSelectedBlocksRunning", "Getting selected blocks...");
+    return $t("aiAgentGetSelectedBlocksRunning", "Getting selected blocks", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema,

package/dist/modules/agent/runtime/app/tools/go_to_history_index/index.js

@@ -2,7 +2,9 @@ import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema } from "../schemas.js";
 const paramsSchema = z.object({
-  index: z.number().describe(
+  // Coerce so a numeric string (e.g. "5") is accepted — the LLM often sends the
+  // index as a string. A non-numeric string is still rejected.
+  index: z.coerce.number().describe(
     "History index to navigate to (-1 = pristine state, 0+ = mutation index)"
   )
 });
@@ -14,7 +16,9 @@ export default defineBlokkliAgentTool({
   prunedSummary: (r) => r.success ? `navigated to index ${r.historyIndex ?? "?"}` : "rejected",
   modes: ["editing", "translating"],
   label($t) {
-    return $t("aiAgentGoToHistoryIndexRunning", "Navigating history...");
+    return $t("aiAgentGoToHistoryIndexRunning", "Navigating history", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,

package/dist/modules/agent/runtime/app/tools/helpers.d.ts

@@ -1,27 +1,7 @@
 import type { OptionItem } from '#blokkli/editor/helpers/options';
 import type { BlokkliApp } from '#blokkli/editor/types/app';
 import type { BlockOptionsMap } from './schemas.js';
-import type { TextFieldValue } from '#blokkli/editor/providers/fieldValue';
-type ReadabilityIssue = {
-    text: string;
-    impact?: string;
-    score?: number;
-};
-type ReadabilityFieldResult = {
-    fieldValue?: string;
-    issues: ReadabilityIssue[];
-};
-export type ReadabilityResult = Record<string, Record<string, ReadabilityFieldResult>>;
-/**
- * Run readability analysis against all fields on the page and return results
- * grouped by paragraph UUID and field name.
- */
-export declare function runReadabilityAnalysis(app: BlokkliApp): Promise<ReadabilityResult>;
-/**
- * Run readability analysis for specific field values (without reading from
- * DOM/adapter). Used by the retry loop to analyze proposed values directly.
- */
-export declare function runReadabilityAnalysisForValues(app: BlokkliApp, fields: TextFieldValue[]): Promise<ReadabilityResult>;
+import type { FieldValueType } from '#blokkli/editor/providers/fieldValue';
 /**
  * Extract a simple key→label map from the various radios/checkboxes option formats.
  * Handles plain strings, icon objects, color objects, grid objects, etc.
@@ -78,4 +58,30 @@ export declare function resolvePosition(app: BlokkliApp, parentUuid: string, fie
 } | {
     error: string;
 };
-export {};
+/**
+ * The host entity of a UUID: the page entity itself when `uuid` is the root
+ * entity (`isRoot: true`), otherwise the block with that UUID. Returns null
+ * when the UUID is neither. The shape carries `entityType` + `bundle` (callers
+ * needing an `EntityContext` map `type ← entityType`).
+ */
+export declare function resolveHost(app: BlokkliApp, uuid: string): {
+    entityType: string;
+    bundle: string;
+    uuid: string;
+    isRoot: boolean;
+} | null;
+/**
+ * Resolve the available options for a block definition. Wraps
+ * `getBlockDefinition` + `getAvailableOptions` and localizes the global-options
+ * cast to this one place. Returns null when the definition is unknown.
+ */
+export declare function getResolvedOptions(app: BlokkliApp, bundleOrBlock: Parameters<BlokkliApp['definitions']['getBlockDefinition']>[0], fieldListType: Parameters<BlokkliApp['definitions']['getBlockDefinition']>[1], parentBundle: Parameters<BlokkliApp['definitions']['getBlockDefinition']>[2]): OptionItem[] | null;
+/**
+ * Read every editable content field of a block (or entity), skipping fields
+ * with no resolvable type. Callers map the result into their own output shape.
+ */
+export declare function readBlockContentFields(app: BlokkliApp, uuid: string, entityType: string, bundle: string): Array<{
+    fieldName: string;
+    fieldType: FieldValueType;
+    value: string;
+}>;