@blokkli/editor 2.0.0-alpha.36 → 2.0.0-alpha.38

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

@@ -1,24 +1,20 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 const paramsSchema = z.object({
-  itemId: z.string().describe("Content item ID from search_content_* results"),
+  itemId: z.string().describe("Content item ID from search_content results"),
   itemEntityType: z.string().describe("Entity type of the content item"),
   itemEntityBundle: z.string().describe("Entity bundle of the content item"),
   targetBundle: z.string().describe(
-    "Paragraph bundle to create (from targetBundles in search_content_* results)"
+    "Paragraph bundle to create (from targetBundles in search_content results)"
   ),
   parent: parentSchema.describe("The parent entity to add the paragraph to"),
   position: positionSchema
 });
 export default defineBlokkliAgentTool({
   name: "add_content_search_paragraphs",
-  description: "Add a paragraph using a content item from search results. Use search_content_* first to find content items, then use this tool to add one to the page. Requires user approval.",
+  description: "Add a paragraph using a content item from search results. Use search_content first to find content items, then use this tool to add one to the page. Requires user approval.",
   category: "mutation",
   prunedSummary: (r) => r.success ? "added content paragraph" : "rejected",
   modes: ["editing"],

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 const paramsSchema = z.object({
   name: z.string().describe("The fragment name to add"),
   parent: parentSchema.describe("The parent entity to add the fragment to"),

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 const paramsSchema = z.object({
   mediaId: z.string().describe("Media item ID from search_media results"),
   mediaBundle: z.string().describe('Media bundle type (e.g., "image")'),

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

@@ -5,10 +5,9 @@ import {
   mutationResultSchema,
   parentSchema,
   positionSchema,
-  resolvePosition,
-  optionValueSchema,
-  validateOptionValue
+  optionValueSchema
 } from "../schemas.js";
+import { resolvePosition, validateOptionValue } from "../helpers.js";
 import { itemEntityType } from "#blokkli-build/config";
 import {
   getAvailableOptions,

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 import { fromLibraryBlockBundle, itemEntityType } from "#blokkli-build/config";
 const paramsSchema = z.object({
   libraryItemUuid: z.string().describe(

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 const paramsSchema = z.object({
   templateUuid: z.string().describe(
     "The UUID of the template to add (from search_templates results)"

package/dist/modules/agent/runtime/app/tools/analyze_content/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const issueSchema = z.object({
+  text: z.string(),
+  impact: z.string().optional(),
+  scores: z.record(z.string(), z.number()).optional()
+});
+const fieldResultSchema = z.object({
+  fieldValue: z.string().optional(),
+  issues: z.array(issueSchema)
+});
+const paramsSchema = z.object({});
+const resultSchema = z.record(
+  z.string(),
+  z.record(z.string(), fieldResultSchema)
+);
+function resolveTargetInfo(target) {
+  const blockEl = target.closest("[data-bk-uuid]");
+  const paragraphUuid = blockEl?.getAttribute("data-bk-uuid") ?? void 0;
+  let fieldName;
+  let fieldEl;
+  let el = target;
+  while (el && el !== blockEl) {
+    if (el.dataset.blokkliEditableField) {
+      fieldName = el.dataset.blokkliEditableField;
+      fieldEl = el;
+      break;
+    }
+    el = el.parentElement;
+  }
+  const fieldText = fieldEl?.textContent?.trim() || void 0;
+  return { paragraphUuid, fieldName, fieldText };
+}
+export default defineBlokkliAgentTool({
+  name: "get_readability_issues",
+  description: "Run all readability analyzers against the full page. Returns an object keyed by paragraph UUID and field name, with the current field value and a list of issues. Each issue contains the flagged text segment, impact, and scores. Use the result to call batch_rewrite_text directly.",
+  category: "query",
+  volatile: true,
+  lazy: true,
+  modes: ["readonly", "editing", "translating", "review"],
+  requiredAdapterMethods: ["getAnalyzers"],
+  label($t) {
+    return $t("aiAgentAnalyzeContentRunning", "Analyzing content...");
+  },
+  prunedSummary: (r) => {
+    let count = 0;
+    for (const fields of Object.values(r)) {
+      for (const field of Object.values(fields)) {
+        count += field.issues.length;
+      }
+    }
+    return `found ${count} issues`;
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx) {
+    const { analyze, ui, $t } = ctx.app;
+    await analyze.ensureInitialized();
+    const readabilityAnalyzers = analyze.analyzers.value.filter(
+      (a) => a.type === "readability" && !a.requireRawPage
+    );
+    if (readabilityAnalyzers.length === 0) {
+      return {
+        label: $t(
+          "aiAgentAnalyzeContentDone",
+          "Analyzed @count results"
+        ).replace("@count", "0"),
+        result: {}
+      };
+    }
+    const analyzerCtx = analyze.createContext(ui.providerElement);
+    const result = {};
+    for (const analyzer of readabilityAnalyzers) {
+      const rawResults = await analyze.runAnalyzer(analyzer, analyzerCtx);
+      for (const r of rawResults) {
+        const rawNodes = Array.isArray(r.nodes) ? r.nodes : [r.nodes];
+        for (const node of rawNodes) {
+          const targets = Array.isArray(node.targets) ? node.targets : [node.targets];
+          for (const target of targets) {
+            if (!(target instanceof HTMLElement)) continue;
+            const info = resolveTargetInfo(target);
+            if (!info.paragraphUuid || !info.fieldName) continue;
+            const targetText = target.textContent?.trim();
+            if (!targetText) continue;
+            const uuid = info.paragraphUuid;
+            const field = info.fieldName;
+            if (!result[uuid]) {
+              result[uuid] = {};
+            }
+            if (!result[uuid][field]) {
+              result[uuid][field] = {
+                fieldValue: info.fieldText,
+                issues: []
+              };
+            }
+            result[uuid][field].issues.push({
+              text: targetText,
+              impact: node.impact,
+              scores: node.scores
+            });
+            break;
+          }
+        }
+      }
+    }
+    let issueCount = 0;
+    for (const fields of Object.values(result)) {
+      for (const field of Object.values(fields)) {
+        issueCount += field.issues.length;
+      }
+    }
+    return {
+      label: $t("aiAgentAnalyzeContentDone", "Analyzed @count results").replace(
+        "@count",
+        String(issueCount)
+      ),
+      result
+    };
+  }
+});

package/dist/modules/agent/runtime/app/tools/check_readability/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
+const nodeSchema = z.object({
+  description: z.string().optional(),
+  impact: z.string().optional(),
+  scores: z.record(z.string(), z.number()).optional()
+});
+const textResultSchema = z.object({
+  text: z.string(),
+  nodes: z.array(nodeSchema)
+});
+const paramsSchema = z.object({
+  texts: z.array(z.string()).describe(
+    "Text strings to check for readability. Each string is analyzed independently."
+  )
+});
+const resultSchema = z.object({
+  results: z.array(textResultSchema)
+});
+export default defineBlokkliAgentTool({
+  name: "check_readability_for_texts",
+  description: "Check readability scores for one or more text strings. Returns readability metrics (LIX, CLI, ARI) for each text. Use this to evaluate whether a rewritten text has better readability before applying it.",
+  category: "query",
+  lazy: true,
+  modes: ["readonly", "editing", "translating", "review"],
+  requiredAdapterMethods: ["getAnalyzers"],
+  label($t) {
+    return $t("aiAgentCheckReadabilityRunning", "Checking readability...");
+  },
+  prunedSummary: (r) => {
+    return `checked readability for ${r.results.length} texts`;
+  },
+  paramsSchema,
+  resultSchema,
+  async execute(ctx, params) {
+    const { analyze, $t } = ctx.app;
+    await analyze.ensureInitialized();
+    const rawResults = await analyze.runOnTexts(params.texts, "readability");
+    const results = rawResults.map(
+      (tr) => ({
+        text: tr.text,
+        nodes: tr.nodes.map((node) => ({
+          description: node.description,
+          impact: node.impact,
+          scores: node.scores
+        }))
+      })
+    );
+    return {
+      label: $t(
+        "aiAgentCheckReadabilityDone",
+        "Checked readability for @count texts"
+      ).replace("@count", String(results.length)),
+      result: { results }
+    };
+  }
+});

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 import {
   validateBlocksExist,
   validateSameField,

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { getFieldType, getEditableValue } from "../schemas.js";
+import { getFieldType, getEditableValue } from "../helpers.js";
 const paramsSchema = z.object({});
 const blockContentSchema = z.object({
   uuid: z.string().describe("The paragraph UUID"),

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

@@ -2,7 +2,8 @@ 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, extractOptionLabels } from "../schemas.js";
+import { blockOptionsMapSchema } from "../schemas.js";
+import { extractOptionLabels } from "../helpers.js";
 const paramsSchema = z.object({
   parentUuid: z.string().describe("The parent entity UUID"),
   field: z.string().describe("The field name"),

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import { getFieldType, getEditableValue } from "../schemas.js";
+import { getFieldType, getEditableValue } from "../helpers.js";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe(
     "One or more paragraph UUIDs (or the page UUID to get page-level fields)"

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

@@ -1,10 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  parentSchema,
-  blockOptionsMapSchema,
-  buildBlockOptionsMap
-} from "../schemas.js";
+import { parentSchema, blockOptionsMapSchema } from "../schemas.js";
+import { buildBlockOptionsMap } from "../helpers.js";
 import { getAvailableOptions } from "#blokkli/editor/helpers/options";
 import { fragmentBlockBundle } from "#blokkli-build/config";
 const paramsSchema = z.object({

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

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { getAvailableOptions } from "#blokkli/editor/helpers/options";
-import { blockOptionsMapSchema, buildBlockOptionsMap } from "../schemas.js";
+import { blockOptionsMapSchema } from "../schemas.js";
+import { buildBlockOptionsMap } from "../helpers.js";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The paragraph UUIDs to get options for")
 });

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

@@ -23,11 +23,10 @@ export default defineBlokkliAgentTool({
   resultSchema,
   execute(ctx) {
     const { selection, types, $t } = ctx.app;
-    const paragraphs = selection.uuids.value.map((uuid) => {
-      const item = selection.items.value.find((v) => v.uuid === uuid);
+    const paragraphs = selection.items.value.map((item) => {
       const bundle = item?.bundle ?? "unknown";
       return {
-        uuid,
+        uuid: item.uuid,
         bundle,
         label: types.getBlockLabel(bundle)
       };

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

@@ -0,0 +1,53 @@
+import type { OptionItem } from '#blokkli/editor/helpers/options';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { BlockOptionsMap } from './schemas.js';
+/**
+ * Extract a simple key→label map from the various radios/checkboxes option formats.
+ * Handles plain strings, icon objects, color objects, grid objects, etc.
+ */
+export declare function extractOptionLabels(option: Record<string, unknown>): Record<string, string> | undefined;
+/**
+ * Build a block options map from available options and mutated state.
+ */
+export declare function buildBlockOptionsMap(availableOptions: OptionItem[], mutatedOptions: Record<string, Record<string, string>>, uuid: string): BlockOptionsMap;
+/**
+ * Build a block options map from option definitions, using defaults as current values.
+ */
+export declare function buildBlockOptionsMapFromDefinitions(options: Record<string, Record<string, unknown>>): BlockOptionsMap;
+/**
+ * Validate a single option value against its definition.
+ * Returns an error string or undefined if valid.
+ */
+export declare function validateOptionValue(key: string, value: string | boolean | number | string[], optionDef: OptionItem): string | undefined;
+/**
+ * Resolve an editable field config to its simplified type.
+ * Returns 'plain' for text fields, 'markup' for rich text/frame fields, null for unsupported.
+ */
+export declare function getFieldType(app: BlokkliApp, entityType: string, bundle: string, fieldName: string): 'plain' | 'markup' | null;
+/**
+ * Read the current value of an editable field on a block or entity.
+ * Tries the registered getValue() callback first, falls back to DOM element reading.
+ */
+export declare function getEditableValue(app: BlokkliApp, entityType: string, uuid: string, bundle: string, fieldName: string, fieldType: 'plain' | 'markup'): string;
+/**
+ * Get all child fields and their paragraphs for a given entity UUID.
+ * Walks mutatedFields to find fields belonging to the entity.
+ */
+export declare function getParagraphChildren(app: BlokkliApp, uuid: string): {
+    fieldName: string;
+    paragraphs: {
+        uuid: string;
+        bundle: string;
+    }[];
+}[];
+/**
+ * Resolve a `position` string to the `afterUuid` value expected by adapter methods.
+ *
+ * Returns `{ afterUuid: string | null }` on success, or `{ error: string }` if
+ * the referenced UUID is not found in the target field.
+ */
+export declare function resolvePosition(app: BlokkliApp, parentUuid: string, fieldName: string, position?: string): {
+    afterUuid: string | null;
+} | {
+    error: string;
+};

package/dist/modules/agent/runtime/app/tools/helpers.js

@@ -0,0 +1,187 @@
+import { getMutatedOptionValue } from "#blokkli/editor/helpers/options";
+import { getRuntimeOptionValue } from "#blokkli/runtime-helpers";
+export function extractOptionLabels(option) {
+  if (!("options" in option) || !option.options) return void 0;
+  const raw = option.options;
+  const labels = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") {
+      labels[key] = value;
+    } else if (typeof value === "object" && value !== null && "label" in value) {
+      labels[key] = String(value.label);
+    } else {
+      labels[key] = key;
+    }
+  }
+  return labels;
+}
+export function buildBlockOptionsMap(availableOptions, mutatedOptions, uuid) {
+  const result = {};
+  for (const opt of availableOptions) {
+    const rawValue = getMutatedOptionValue(
+      mutatedOptions,
+      uuid,
+      opt.property,
+      opt.option.default
+    );
+    const currentValue = getRuntimeOptionValue(opt.option, rawValue);
+    result[opt.property] = buildBlockOptionEntry(opt.option, currentValue);
+  }
+  return result;
+}
+export function buildBlockOptionsMapFromDefinitions(options) {
+  const result = {};
+  for (const [key, opt] of Object.entries(options)) {
+    result[key] = buildBlockOptionEntry(
+      opt,
+      opt.default
+    );
+  }
+  return result;
+}
+function buildBlockOptionEntry(opt, currentValue) {
+  const entry = {
+    type: opt.type,
+    label: opt.label,
+    currentValue
+  };
+  if (opt.description) {
+    entry.description = opt.description;
+  }
+  const labels = extractOptionLabels(opt);
+  if (labels) {
+    entry.options = labels;
+  }
+  if ("min" in opt) {
+    entry.min = opt.min;
+  }
+  if ("max" in opt) {
+    entry.max = opt.max;
+  }
+  if ("step" in opt && opt.type === "range") {
+    entry.step = opt.step;
+  }
+  return entry;
+}
+export function validateOptionValue(key, value, optionDef) {
+  const optionType = optionDef.option.type;
+  if (optionType === "checkbox") {
+    if (typeof value !== "boolean" && value !== "1" && value !== "0" && value !== "true" && value !== "false") {
+      return `Option "${key}" expects a boolean value`;
+    }
+  } else if (optionType === "radios") {
+    if (typeof value !== "string") {
+      return `Option "${key}" expects a string value`;
+    }
+    if ("options" in optionDef.option && optionDef.option.options) {
+      const allowedKeys = Object.keys(optionDef.option.options);
+      if (!allowedKeys.includes(value)) {
+        return `Option "${key}" value must be one of: ${allowedKeys.join(", ")}`;
+      }
+    }
+  } else if (optionType === "checkboxes") {
+    if (!Array.isArray(value) && typeof value !== "string") {
+      return `Option "${key}" expects an array of strings or comma-separated string`;
+    }
+    if ("options" in optionDef.option && optionDef.option.options) {
+      const allowedKeys = Object.keys(optionDef.option.options);
+      const values = Array.isArray(value) ? value : value.split(",");
+      for (const v of values) {
+        if (!allowedKeys.includes(v)) {
+          return `Option "${key}" value "${v}" is not allowed. Must be one of: ${allowedKeys.join(", ")}`;
+        }
+      }
+    }
+  } else if (optionType === "number" || optionType === "range") {
+    const numValue = typeof value === "number" ? value : Number.parseFloat(String(value));
+    if (Number.isNaN(numValue)) {
+      return `Option "${key}" expects a numeric value`;
+    }
+    if ("min" in optionDef.option && numValue < optionDef.option.min) {
+      return `Option "${key}" value must be >= ${optionDef.option.min}`;
+    }
+    if ("max" in optionDef.option && numValue > optionDef.option.max) {
+      return `Option "${key}" value must be <= ${optionDef.option.max}`;
+    }
+  }
+  return void 0;
+}
+export function getFieldType(app, entityType, bundle, fieldName) {
+  const config = app.types.editableFieldConfig.forName(
+    entityType,
+    bundle,
+    fieldName
+  );
+  if (!config) return null;
+  if (config.type === "table") return null;
+  if (config.type === "frame" || config.type === "markup") return "markup";
+  return "plain";
+}
+export function getEditableValue(app, entityType, uuid, bundle, fieldName, fieldType) {
+  const editables = app.directive.getEditablesForBlock(uuid);
+  const editable = editables.find((e) => e.fieldName === fieldName);
+  if (editable?.getValue) {
+    return editable.getValue();
+  }
+  const element = app.directive.findEditableElement(fieldName, {
+    type: entityType,
+    uuid,
+    bundle
+  });
+  if (element) {
+    return fieldType === "markup" ? element.innerHTML || "" : element.textContent || "";
+  }
+  return "";
+}
+export function getParagraphChildren(app, uuid) {
+  const result = [];
+  for (const field of app.state.mutatedFields.value) {
+    if (field.entityUuid === uuid && field.list.length > 0) {
+      result.push({
+        fieldName: field.name,
+        paragraphs: field.list.map((item) => ({
+          uuid: item.uuid,
+          bundle: item.bundle
+        }))
+      });
+    }
+  }
+  return result;
+}
+export function resolvePosition(app, parentUuid, fieldName, position) {
+  const fieldList = app.state.mutatedFields.value.find(
+    (f) => f.entityUuid === parentUuid && f.name === fieldName
+  );
+  const list = fieldList?.list ?? [];
+  if (position === void 0 || position === "end") {
+    const lastBlock = list.at(-1);
+    return { afterUuid: lastBlock?.uuid ?? null };
+  }
+  if (position === "start") {
+    return { afterUuid: null };
+  }
+  if (position.startsWith("after:")) {
+    const uuid = position.slice(6);
+    const found = list.find((b) => b.uuid === uuid);
+    if (!found) {
+      return {
+        error: `Position "after:${uuid}": paragraph not found in field "${fieldName}".`
+      };
+    }
+    return { afterUuid: uuid };
+  }
+  if (position.startsWith("before:")) {
+    const uuid = position.slice(7);
+    const index = list.findIndex((b) => b.uuid === uuid);
+    if (index === -1) {
+      return {
+        error: `Position "before:${uuid}": paragraph not found in field "${fieldName}".`
+      };
+    }
+    const preceding = index > 0 ? list[index - 1] : void 0;
+    return { afterUuid: preceding?.uuid ?? null };
+  }
+  return {
+    error: `Invalid position value: "${position}". Use "start", "end", "after:<UUID>", or "before:<UUID>".`
+  };
+}

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

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
-import {
-  mutationResultSchema,
-  parentSchema,
-  positionSchema,
-  resolvePosition
-} from "../schemas.js";
+import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
+import { resolvePosition } from "../helpers.js";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).describe("The UUIDs of the paragraphs to move"),
   parent: parentSchema.describe("The target parent entity"),