@midscene/core 1.8.11 → 1.9.0

package/dist/es/ai-model/shared/model-locate-result/bbox.mjs

@@ -0,0 +1,68 @@
+function maxPixelIndex(size) {
+    return Math.max(size - 1, 0);
+}
+function normalizedCoordinateToPixelIndex(value, normalizedBy, size) {
+    return Math.round(value * maxPixelIndex(size) / normalizedBy);
+}
+function mapNormalizedCoordinatesToPixelBbox(coordinates, normalizedBy, width, height) {
+    const [left, top, right, bottom] = coordinates;
+    return [
+        normalizedCoordinateToPixelIndex(left, normalizedBy, width),
+        normalizedCoordinateToPixelIndex(top, normalizedBy, height),
+        normalizedCoordinateToPixelIndex(right, normalizedBy, width),
+        normalizedCoordinateToPixelIndex(bottom, normalizedBy, height)
+    ];
+}
+function expandPointToBbox(x, y, maxX, maxY, halfSize) {
+    return [
+        Math.max(0, x - halfSize),
+        Math.max(0, y - halfSize),
+        Math.min(maxX, x + halfSize),
+        Math.min(maxY, y + halfSize)
+    ];
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function assertFinitePixelBbox(pixelBbox, rawResult) {
+    if (4 !== pixelBbox.length || !pixelBbox.every((value)=>'number' == typeof value && Number.isFinite(value))) throw new Error(`invalid locate bbox data: ${JSON.stringify(rawResult)} `);
+}
+function assertPixelBboxOrder(pixelBbox, rawResult) {
+    const [left, top, right, bottom] = pixelBbox;
+    if (right >= left && bottom >= top) return;
+    throw new Error(`locate pixel bbox has invalid coordinate order: bbox=${JSON.stringify(rawResult)} pixelBbox=${JSON.stringify(pixelBbox)}`);
+}
+function assertPixelBboxInsideImage(pixelBbox, rawResult, width, height) {
+    const [left, top, right, bottom] = pixelBbox;
+    const maxRight = maxPixelIndex(width);
+    const maxBottom = maxPixelIndex(height);
+    const outOfImage = left < 0 || top < 0 || right > maxRight || bottom > maxBottom;
+    if (!outOfImage) return;
+    throw new Error(`locate pixel bbox is outside the image size: bbox=${JSON.stringify(rawResult)} imageSize=${width}x${height}`);
+}
+function finalizePixelBbox(pixelBbox, rawResult, { preparedSize, contentSize }) {
+    const { width, height } = preparedSize;
+    assertFinitePixelBbox(pixelBbox, rawResult);
+    assertPixelBboxOrder(pixelBbox, rawResult);
+    assertPixelBboxInsideImage(pixelBbox, rawResult, width, height);
+    const rightLimit = maxPixelIndex(contentSize?.width ?? width);
+    const bottomLimit = maxPixelIndex(contentSize?.height ?? height);
+    const [left, top, right, bottom] = pixelBbox;
+    return [
+        clamp(left, 0, rightLimit),
+        clamp(top, 0, bottomLimit),
+        clamp(right, 0, rightLimit),
+        clamp(bottom, 0, bottomLimit)
+    ];
+}
+function finalizeSectionLocatePixelBboxGroup(result, rawResult, ctx) {
+    return {
+        target: finalizePixelBbox(result.target, rawResult, ctx),
+        ...result.references ? {
+            references: result.references.map((reference)=>finalizePixelBbox(reference, rawResult, ctx))
+        } : {}
+    };
+}
+export { expandPointToBbox, finalizePixelBbox, finalizeSectionLocatePixelBboxGroup, mapNormalizedCoordinatesToPixelBbox, maxPixelIndex, normalizedCoordinateToPixelIndex };
+
+//# sourceMappingURL=bbox.mjs.map

package/dist/es/ai-model/shared/model-locate-result/bbox.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/shared/model-locate-result/bbox.mjs","sources":["../../../../../src/ai-model/shared/model-locate-result/bbox.ts"],"sourcesContent":["import type {\n  LocateResultBbox,\n  LocateResultContext,\n  PixelBbox,\n  SectionLocatePixelBboxGroup,\n} from './types';\n\nexport function maxPixelIndex(size: number) {\n  return Math.max(size - 1, 0);\n}\n\nexport function normalizedCoordinateToPixelIndex(\n  value: number,\n  normalizedBy: number,\n  size: number,\n) {\n  return Math.round((value * maxPixelIndex(size)) / normalizedBy);\n}\n\nexport function mapNormalizedCoordinatesToPixelBbox(\n  coordinates: LocateResultBbox,\n  normalizedBy: number,\n  width: number,\n  height: number,\n): PixelBbox {\n  // PixelBbox uses inclusive pixel indexes, so normalized coordinates map to\n  // size - 1.\n  const [left, top, right, bottom] = coordinates;\n  return [\n    normalizedCoordinateToPixelIndex(left, normalizedBy, width),\n    normalizedCoordinateToPixelIndex(top, normalizedBy, height),\n    normalizedCoordinateToPixelIndex(right, normalizedBy, width),\n    normalizedCoordinateToPixelIndex(bottom, normalizedBy, height),\n  ];\n}\n\nexport function expandPointToBbox(\n  x: number,\n  y: number,\n  maxX: number,\n  maxY: number,\n  halfSize: number,\n): LocateResultBbox {\n  return [\n    Math.max(0, x - halfSize),\n    Math.max(0, y - halfSize),\n    Math.min(maxX, x + halfSize),\n    Math.min(maxY, y + halfSize),\n  ];\n}\n\nfunction clamp(value: number, min: number, max: number) {\n  return Math.min(Math.max(value, min), max);\n}\n\nfunction assertFinitePixelBbox(\n  pixelBbox: readonly number[],\n  rawResult: unknown,\n): asserts pixelBbox is PixelBbox {\n  if (\n    pixelBbox.length !== 4 ||\n    !pixelBbox.every(\n      (value) => typeof value === 'number' && Number.isFinite(value),\n    )\n  ) {\n    throw new Error(`invalid locate bbox data: ${JSON.stringify(rawResult)} `);\n  }\n}\n\nfunction assertPixelBboxOrder(pixelBbox: PixelBbox, rawResult: unknown) {\n  const [left, top, right, bottom] = pixelBbox;\n  if (right >= left && bottom >= top) {\n    return;\n  }\n\n  throw new Error(\n    `locate pixel bbox has invalid coordinate order: bbox=${JSON.stringify(\n      rawResult,\n    )} pixelBbox=${JSON.stringify(pixelBbox)}`,\n  );\n}\n\nfunction assertPixelBboxInsideImage(\n  pixelBbox: PixelBbox,\n  rawResult: unknown,\n  width: number,\n  height: number,\n) {\n  const [left, top, right, bottom] = pixelBbox;\n  const maxRight = maxPixelIndex(width);\n  const maxBottom = maxPixelIndex(height);\n  const outOfImage =\n    left < 0 || top < 0 || right > maxRight || bottom > maxBottom;\n\n  if (!outOfImage) {\n    return;\n  }\n\n  throw new Error(\n    `locate pixel bbox is outside the image size: bbox=${JSON.stringify(\n      rawResult,\n    )} imageSize=${width}x${height}`,\n  );\n}\n\nexport function finalizePixelBbox(\n  pixelBbox: PixelBbox,\n  rawResult: unknown,\n  { preparedSize, contentSize }: LocateResultContext,\n): PixelBbox {\n  const { width, height } = preparedSize;\n  assertFinitePixelBbox(pixelBbox, rawResult);\n  assertPixelBboxOrder(pixelBbox, rawResult);\n  assertPixelBboxInsideImage(pixelBbox, rawResult, width, height);\n\n  const rightLimit = maxPixelIndex(contentSize?.width ?? width);\n  const bottomLimit = maxPixelIndex(contentSize?.height ?? height);\n  const [left, top, right, bottom] = pixelBbox;\n\n  return [\n    clamp(left, 0, rightLimit),\n    clamp(top, 0, bottomLimit),\n    clamp(right, 0, rightLimit),\n    clamp(bottom, 0, bottomLimit),\n  ];\n}\n\nexport function finalizeSectionLocatePixelBboxGroup(\n  result: SectionLocatePixelBboxGroup,\n  rawResult: unknown,\n  ctx: LocateResultContext,\n): SectionLocatePixelBboxGroup {\n  return {\n    target: finalizePixelBbox(result.target, rawResult, ctx),\n    ...(result.references\n      ? {\n          references: result.references.map((reference) =>\n            finalizePixelBbox(reference, rawResult, ctx),\n          ),\n        }\n      : {}),\n  };\n}\n"],"names":["maxPixelIndex","size","Math","normalizedCoordinateToPixelIndex","value","normalizedBy","mapNormalizedCoordinatesToPixelBbox","coordinates","width","height","left","top","right","bottom","expandPointToBbox","x","y","maxX","maxY","halfSize","clamp","min","max","assertFinitePixelBbox","pixelBbox","rawResult","Number","Error","JSON","assertPixelBboxOrder","assertPixelBboxInsideImage","maxRight","maxBottom","outOfImage","finalizePixelBbox","preparedSize","contentSize","rightLimit","bottomLimit","finalizeSectionLocatePixelBboxGroup","result","ctx","reference"],"mappings":"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"}

package/dist/es/ai-model/shared/model-locate-result/factory.mjs

@@ -0,0 +1,96 @@
+import { createLocateResultPromptSpec } from "../../prompts/locate-result-coordinates.mjs";
+import { finalizePixelBbox, finalizeSectionLocatePixelBboxGroup } from "./bbox.mjs";
+import { parseNumericLocateResult } from "./parse.mjs";
+import { mapLocateResultToPixelBboxByCoordinates } from "./pixel-bbox-mapper.mjs";
+const rawLocateValueFields = {
+    primary: {
+        bbox: [
+            'bbox',
+            'bbox_2d'
+        ],
+        point: [
+            'point'
+        ]
+    },
+    references: {
+        bbox: [
+            'references_bbox',
+            'references_bbox_2d'
+        ],
+        point: [
+            'references_point'
+        ]
+    }
+};
+function resolveLocateResultCoordinates(coordinates) {
+    const order = coordinates.order ?? 'xy';
+    if (void 0 !== coordinates.normalizedBy && coordinates.normalizedBy <= 0) throw new Error(`locate result coordinates normalizedBy must be positive: ${coordinates.normalizedBy}`);
+    return {
+        shape: coordinates.shape,
+        order,
+        normalizedBy: coordinates.normalizedBy
+    };
+}
+function extractFirstObjectField(input, fields) {
+    if (!input || 'object' != typeof input) return;
+    const record = input;
+    const matchedField = fields.find((field)=>void 0 !== record[field]);
+    return matchedField ? record[matchedField] : void 0;
+}
+function normalizeReferenceResults(input) {
+    if (null == input) return [];
+    return Array.isArray(input) ? input : [
+        input
+    ];
+}
+function pickRawLocateValue(input, resolvedCoordinates, purpose) {
+    const fields = rawLocateValueFields[purpose][resolvedCoordinates.shape];
+    return extractFirstObjectField(input, fields);
+}
+function extractPrimaryRawLocateValue(input, resolvedCoordinates) {
+    const pickedRawResult = pickRawLocateValue(input, resolvedCoordinates, 'primary');
+    if (void 0 === pickedRawResult && null !== input && 'object' == typeof input && !Array.isArray(input)) throw new Error('locate response does not contain a recognizable locate result field');
+    return void 0 === pickedRawResult ? input : pickedRawResult;
+}
+function extractReferenceRawLocateValues(input, resolvedCoordinates) {
+    return normalizeReferenceResults(pickRawLocateValue(input, resolvedCoordinates, 'references'));
+}
+function createStandardLocateResultAdapterImplementation(config) {
+    const resolvedCoordinates = resolveLocateResultCoordinates(config.coordinates);
+    const parseRawLocateValue = config.parseRawLocateValue ?? ((input)=>parseNumericLocateResult(resolvedCoordinates, input));
+    const mapLocateResultToPixelBbox = config.mapLocateResultToPixelBbox ?? ((result, ctx)=>mapLocateResultToPixelBboxByCoordinates(result, ctx, resolvedCoordinates));
+    const mapRawLocateValueToPixelBbox = (rawResult, ctx)=>mapLocateResultToPixelBbox(parseRawLocateValue(rawResult), ctx);
+    const adaptRawLocateInputToPixelBbox = (input, ctx)=>mapRawLocateValueToPixelBbox(extractPrimaryRawLocateValue(input, resolvedCoordinates), ctx);
+    const adaptElementLocateResultToPixelBbox = (input, ctx)=>adaptRawLocateInputToPixelBbox(input, ctx);
+    const adaptPlanningParamToPixelBbox = (input, ctx)=>adaptRawLocateInputToPixelBbox(input, ctx);
+    const adaptSectionLocateResultToPixelBboxGroup = (input, ctx)=>{
+        const target = adaptRawLocateInputToPixelBbox(input, ctx);
+        const references = extractReferenceRawLocateValues(input, resolvedCoordinates).map((raw)=>mapRawLocateValueToPixelBbox(raw, ctx));
+        return {
+            target,
+            ...references.length > 0 ? {
+                references
+            } : {}
+        };
+    };
+    return {
+        kind: 'standard',
+        promptSpec: createLocateResultPromptSpec(resolvedCoordinates),
+        adaptElementLocateResultToPixelBbox,
+        adaptSectionLocateResultToPixelBboxGroup,
+        adaptPlanningParamToPixelBbox
+    };
+}
+function createLocateResultAdapter(config) {
+    const adapter = 'custom' === config.kind ? config : createStandardLocateResultAdapterImplementation(config);
+    return {
+        kind: adapter.kind,
+        promptSpec: adapter.promptSpec,
+        adaptElementLocateResultToPixelBbox: (input, ctx)=>finalizePixelBbox(adapter.adaptElementLocateResultToPixelBbox(input, ctx), input, ctx),
+        adaptSectionLocateResultToPixelBboxGroup: (input, ctx)=>finalizeSectionLocatePixelBboxGroup(adapter.adaptSectionLocateResultToPixelBboxGroup(input, ctx), input, ctx),
+        adaptPlanningParamToPixelBbox: (input, ctx)=>finalizePixelBbox(adapter.adaptPlanningParamToPixelBbox(input, ctx), input, ctx)
+    };
+}
+export { createLocateResultAdapter };
+
+//# sourceMappingURL=factory.mjs.map

package/dist/es/ai-model/shared/model-locate-result/factory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/shared/model-locate-result/factory.mjs","sources":["../../../../../src/ai-model/shared/model-locate-result/factory.ts"],"sourcesContent":["import { createLocateResultPromptSpec } from '../../prompts/locate-result-coordinates';\nimport { finalizePixelBbox, finalizeSectionLocatePixelBboxGroup } from './bbox';\nimport { parseNumericLocateResult } from './parse';\nimport { mapLocateResultToPixelBboxByCoordinates } from './pixel-bbox-mapper';\nimport type {\n  LocateResultAdapter,\n  LocateResultAdapterDefinition,\n  LocateResultContext,\n  LocateResultCoordinates,\n  PixelBbox,\n  ResolvedLocateResultCoordinates,\n  SectionLocatePixelBboxGroup,\n  StandardLocateResultAdapterDefinition,\n} from './types';\n\ntype RawLocateValuePurpose = 'primary' | 'references';\n\nconst rawLocateValueFields = {\n  primary: {\n    bbox: ['bbox', 'bbox_2d'],\n    point: ['point'],\n  },\n  references: {\n    bbox: ['references_bbox', 'references_bbox_2d'],\n    point: ['references_point'],\n  },\n} as const;\n\nfunction resolveLocateResultCoordinates(\n  coordinates: LocateResultCoordinates,\n): ResolvedLocateResultCoordinates {\n  const order = coordinates.order ?? 'xy';\n  if (coordinates.normalizedBy !== undefined && coordinates.normalizedBy <= 0) {\n    throw new Error(\n      `locate result coordinates normalizedBy must be positive: ${coordinates.normalizedBy}`,\n    );\n  }\n  return {\n    shape: coordinates.shape,\n    order,\n    normalizedBy: coordinates.normalizedBy,\n  };\n}\n\nfunction extractFirstObjectField(\n  input: unknown,\n  fields: readonly string[],\n): unknown | undefined {\n  if (!input || typeof input !== 'object') {\n    return undefined;\n  }\n\n  const record = input as Record<string, unknown>;\n  const matchedField = fields.find((field) => record[field] !== undefined);\n  return matchedField ? record[matchedField] : undefined;\n}\n\nfunction normalizeReferenceResults(input: unknown): unknown[] {\n  if (input === undefined || input === null) {\n    return [];\n  }\n  return Array.isArray(input) ? input : [input];\n}\n\nfunction pickRawLocateValue(\n  input: unknown,\n  resolvedCoordinates: ResolvedLocateResultCoordinates,\n  purpose: RawLocateValuePurpose,\n): unknown | undefined {\n  const fields = rawLocateValueFields[purpose][resolvedCoordinates.shape];\n  return extractFirstObjectField(input, fields);\n}\n\nfunction extractPrimaryRawLocateValue(\n  input: unknown,\n  resolvedCoordinates: ResolvedLocateResultCoordinates,\n): unknown {\n  const pickedRawResult = pickRawLocateValue(\n    input,\n    resolvedCoordinates,\n    'primary',\n  );\n  if (\n    pickedRawResult === undefined &&\n    input !== null &&\n    typeof input === 'object' &&\n    !Array.isArray(input)\n  ) {\n    throw new Error(\n      'locate response does not contain a recognizable locate result field',\n    );\n  }\n\n  return pickedRawResult === undefined ? input : pickedRawResult;\n}\n\nfunction extractReferenceRawLocateValues(\n  input: unknown,\n  resolvedCoordinates: ResolvedLocateResultCoordinates,\n): unknown[] {\n  return normalizeReferenceResults(\n    pickRawLocateValue(input, resolvedCoordinates, 'references'),\n  );\n}\n\nfunction createStandardLocateResultAdapterImplementation(\n  config: StandardLocateResultAdapterDefinition,\n): LocateResultAdapter {\n  const resolvedCoordinates = resolveLocateResultCoordinates(\n    config.coordinates,\n  );\n  const parseRawLocateValue =\n    config.parseRawLocateValue ??\n    ((input) => parseNumericLocateResult(resolvedCoordinates, input));\n  const mapLocateResultToPixelBbox =\n    config.mapLocateResultToPixelBbox ??\n    ((result, ctx) =>\n      mapLocateResultToPixelBboxByCoordinates(\n        result,\n        ctx,\n        resolvedCoordinates,\n      ));\n\n  const mapRawLocateValueToPixelBbox = (\n    rawResult: unknown,\n    ctx: LocateResultContext,\n  ) => mapLocateResultToPixelBbox(parseRawLocateValue(rawResult), ctx);\n  // Keep error semantics out of the adapter: callers may preserve, ignore, or\n  // fail fast on `error` / `errors`, while this layer only extracts coordinates.\n  const adaptRawLocateInputToPixelBbox = (\n    input: unknown,\n    ctx: LocateResultContext,\n  ): PixelBbox =>\n    mapRawLocateValueToPixelBbox(\n      extractPrimaryRawLocateValue(input, resolvedCoordinates),\n      ctx,\n    );\n  const adaptElementLocateResultToPixelBbox = (\n    input: unknown,\n    ctx: LocateResultContext,\n  ): PixelBbox => adaptRawLocateInputToPixelBbox(input, ctx);\n  const adaptPlanningParamToPixelBbox = (\n    input: unknown,\n    ctx: LocateResultContext,\n  ): PixelBbox => adaptRawLocateInputToPixelBbox(input, ctx);\n  const adaptSectionLocateResultToPixelBboxGroup = (\n    input: unknown,\n    ctx: LocateResultContext,\n  ): SectionLocatePixelBboxGroup => {\n    const target = adaptRawLocateInputToPixelBbox(input, ctx);\n    const references = extractReferenceRawLocateValues(\n      input,\n      resolvedCoordinates,\n    ).map((raw) => mapRawLocateValueToPixelBbox(raw, ctx));\n    return {\n      target,\n      ...(references.length > 0 ? { references } : {}),\n    };\n  };\n  return {\n    kind: 'standard',\n    promptSpec: createLocateResultPromptSpec(resolvedCoordinates),\n    adaptElementLocateResultToPixelBbox,\n    adaptSectionLocateResultToPixelBboxGroup,\n    adaptPlanningParamToPixelBbox,\n  };\n}\n\nexport function createLocateResultAdapter(\n  config: LocateResultAdapterDefinition,\n): LocateResultAdapter {\n  const adapter: LocateResultAdapter =\n    config.kind === 'custom'\n      ? config\n      : createStandardLocateResultAdapterImplementation(config);\n\n  return {\n    kind: adapter.kind,\n    promptSpec: adapter.promptSpec,\n    adaptElementLocateResultToPixelBbox: (input, ctx) =>\n      finalizePixelBbox(\n        adapter.adaptElementLocateResultToPixelBbox(input, ctx),\n        input,\n        ctx,\n      ),\n    adaptSectionLocateResultToPixelBboxGroup: (input, ctx) =>\n      finalizeSectionLocatePixelBboxGroup(\n        adapter.adaptSectionLocateResultToPixelBboxGroup(input, ctx),\n        input,\n        ctx,\n      ),\n    adaptPlanningParamToPixelBbox: (input, ctx) =>\n      finalizePixelBbox(\n        adapter.adaptPlanningParamToPixelBbox(input, ctx),\n        input,\n        ctx,\n      ),\n  };\n}\n"],"names":["rawLocateValueFields","resolveLocateResultCoordinates","coordinates","order","undefined","Error","extractFirstObjectField","input","fields","record","matchedField","field","normalizeReferenceResults","Array","pickRawLocateValue","resolvedCoordinates","purpose","extractPrimaryRawLocateValue","pickedRawResult","extractReferenceRawLocateValues","createStandardLocateResultAdapterImplementation","config","parseRawLocateValue","parseNumericLocateResult","mapLocateResultToPixelBbox","result","ctx","mapLocateResultToPixelBboxByCoordinates","mapRawLocateValueToPixelBbox","rawResult","adaptRawLocateInputToPixelBbox","adaptElementLocateResultToPixelBbox","adaptPlanningParamToPixelBbox","adaptSectionLocateResultToPixelBboxGroup","target","references","raw","createLocateResultPromptSpec","createLocateResultAdapter","adapter","finalizePixelBbox","finalizeSectionLocatePixelBboxGroup"],"mappings":"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"}

package/dist/es/ai-model/shared/model-locate-result/index.mjs

@@ -0,0 +1,3 @@
+import { createLocateResultAdapter } from "./factory.mjs";
+import { unwrapCoordinateListLikeInput } from "./parse.mjs";
+export { createLocateResultAdapter, unwrapCoordinateListLikeInput };

package/dist/es/ai-model/shared/model-locate-result/parse.mjs

@@ -0,0 +1,41 @@
+function unwrapCoordinateListLikeInput(coordinateList) {
+    if (Array.isArray(coordinateList)) {
+        if (Array.isArray(coordinateList[0])) return coordinateList[0];
+    }
+    return coordinateList;
+}
+function parseCoordinateList(input, label) {
+    const unwrapped = unwrapCoordinateListLikeInput(input);
+    const values = 'string' == typeof unwrapped ? unwrapped.trim().split(/[\s,]+/).filter(Boolean) : unwrapped;
+    if (!Array.isArray(values)) throw new Error(`invalid ${label} data: ${JSON.stringify(input)} `);
+    const numericValues = values.map((value)=>'number' == typeof value ? value : Number(value));
+    if (!numericValues.every((value)=>Number.isFinite(value))) throw new Error(`invalid ${label} data: ${JSON.stringify(input)} `);
+    return numericValues;
+}
+function parseNumericLocateResult(resolvedCoordinates, input) {
+    if ('point' === resolvedCoordinates.shape) {
+        const point = parseCoordinateList(input, 'point');
+        if (point.length < 2) throw new Error(`invalid point data: ${JSON.stringify(input)} `);
+        return {
+            type: 'point',
+            coordinates: [
+                point[0],
+                point[1]
+            ]
+        };
+    }
+    const bbox = parseCoordinateList(input, 'bbox');
+    if (4 !== bbox.length) throw new Error(`invalid bbox data: ${JSON.stringify(input)} `);
+    return {
+        type: 'bbox',
+        coordinates: [
+            bbox[0],
+            bbox[1],
+            bbox[2],
+            bbox[3]
+        ]
+    };
+}
+export { parseNumericLocateResult, unwrapCoordinateListLikeInput };
+
+//# sourceMappingURL=parse.mjs.map

package/dist/es/ai-model/shared/model-locate-result/parse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/shared/model-locate-result/parse.mjs","sources":["../../../../../src/ai-model/shared/model-locate-result/parse.ts"],"sourcesContent":["import type {\n  LocateResultValue,\n  ResolvedLocateResultCoordinates,\n} from './types';\n\ntype CoordinateListLikeInput =\n  | number[]\n  | string[]\n  | string\n  | (number[] | string[])[];\n\nexport function unwrapCoordinateListLikeInput(\n  coordinateList: CoordinateListLikeInput,\n): number[] | string[] | string {\n  if (Array.isArray(coordinateList)) {\n    if (Array.isArray(coordinateList[0])) {\n      return coordinateList[0] as number[] | string[];\n    }\n    return coordinateList as number[] | string[];\n  }\n  return coordinateList as string;\n}\n\nfunction parseCoordinateList(input: unknown, label: string): number[] {\n  const unwrapped = unwrapCoordinateListLikeInput(\n    input as CoordinateListLikeInput,\n  );\n  const values =\n    typeof unwrapped === 'string'\n      ? unwrapped\n          .trim()\n          .split(/[\\s,]+/)\n          .filter(Boolean)\n      : unwrapped;\n\n  if (!Array.isArray(values)) {\n    throw new Error(`invalid ${label} data: ${JSON.stringify(input)} `);\n  }\n\n  const numericValues = values.map((value) =>\n    typeof value === 'number' ? value : Number(value),\n  );\n\n  if (!numericValues.every((value) => Number.isFinite(value))) {\n    throw new Error(`invalid ${label} data: ${JSON.stringify(input)} `);\n  }\n\n  return numericValues;\n}\n\nexport function parseNumericLocateResult(\n  resolvedCoordinates: ResolvedLocateResultCoordinates,\n  input: unknown,\n): LocateResultValue {\n  if (resolvedCoordinates.shape === 'point') {\n    const point = parseCoordinateList(input, 'point');\n    if (point.length < 2) {\n      throw new Error(`invalid point data: ${JSON.stringify(input)} `);\n    }\n    return { type: 'point', coordinates: [point[0], point[1]] };\n  }\n\n  const bbox = parseCoordinateList(input, 'bbox');\n  if (bbox.length !== 4) {\n    throw new Error(`invalid bbox data: ${JSON.stringify(input)} `);\n  }\n\n  return {\n    type: 'bbox',\n    coordinates: [bbox[0], bbox[1], bbox[2], bbox[3]],\n  };\n}\n"],"names":["unwrapCoordinateListLikeInput","coordinateList","Array","parseCoordinateList","input","label","unwrapped","values","Boolean","Error","JSON","numericValues","value","Number","parseNumericLocateResult","resolvedCoordinates","point","bbox"],"mappings":"AAWO,SAASA,8BACdC,cAAuC;IAEvC,IAAIC,MAAM,OAAO,CAACD,iBAChB;QAAA,IAAIC,MAAM,OAAO,CAACD,cAAc,CAAC,EAAE,GACjC,OAAOA,cAAc,CAAC,EAAE;IAC1B;IAGF,OAAOA;AACT;AAEA,SAASE,oBAAoBC,KAAc,EAAEC,KAAa;IACxD,MAAMC,YAAYN,8BAChBI;IAEF,MAAMG,SACJ,AAAqB,YAArB,OAAOD,YACHA,UACG,IAAI,GACJ,KAAK,CAAC,UACN,MAAM,CAACE,WACVF;IAEN,IAAI,CAACJ,MAAM,OAAO,CAACK,SACjB,MAAM,IAAIE,MAAM,CAAC,QAAQ,EAAEJ,MAAM,OAAO,EAAEK,KAAK,SAAS,CAACN,OAAO,CAAC,CAAC;IAGpE,MAAMO,gBAAgBJ,OAAO,GAAG,CAAC,CAACK,QAChC,AAAiB,YAAjB,OAAOA,QAAqBA,QAAQC,OAAOD;IAG7C,IAAI,CAACD,cAAc,KAAK,CAAC,CAACC,QAAUC,OAAO,QAAQ,CAACD,SAClD,MAAM,IAAIH,MAAM,CAAC,QAAQ,EAAEJ,MAAM,OAAO,EAAEK,KAAK,SAAS,CAACN,OAAO,CAAC,CAAC;IAGpE,OAAOO;AACT;AAEO,SAASG,yBACdC,mBAAoD,EACpDX,KAAc;IAEd,IAAIW,AAA8B,YAA9BA,oBAAoB,KAAK,EAAc;QACzC,MAAMC,QAAQb,oBAAoBC,OAAO;QACzC,IAAIY,MAAM,MAAM,GAAG,GACjB,MAAM,IAAIP,MAAM,CAAC,oBAAoB,EAAEC,KAAK,SAAS,CAACN,OAAO,CAAC,CAAC;QAEjE,OAAO;YAAE,MAAM;YAAS,aAAa;gBAACY,KAAK,CAAC,EAAE;gBAAEA,KAAK,CAAC,EAAE;aAAC;QAAC;IAC5D;IAEA,MAAMC,OAAOd,oBAAoBC,OAAO;IACxC,IAAIa,AAAgB,MAAhBA,KAAK,MAAM,EACb,MAAM,IAAIR,MAAM,CAAC,mBAAmB,EAAEC,KAAK,SAAS,CAACN,OAAO,CAAC,CAAC;IAGhE,OAAO;QACL,MAAM;QACN,aAAa;YAACa,IAAI,CAAC,EAAE;YAAEA,IAAI,CAAC,EAAE;YAAEA,IAAI,CAAC,EAAE;YAAEA,IAAI,CAAC,EAAE;SAAC;IACnD;AACF"}

package/dist/es/ai-model/shared/model-locate-result/pixel-bbox-mapper.mjs

@@ -0,0 +1,64 @@
+import { expandPointToBbox, mapNormalizedCoordinatesToPixelBbox, maxPixelIndex } from "./bbox.mjs";
+const defaultBboxSize = 20;
+function resolveCoordinateLimits(result, resolvedCoordinates, width, height) {
+    const normalizedBy = resolvedCoordinates.normalizedBy;
+    if (void 0 !== normalizedBy) return result.coordinates.map(()=>normalizedBy);
+    if ('bbox' === result.type) return 'yx' === resolvedCoordinates.order ? [
+        height,
+        width,
+        height,
+        width
+    ] : [
+        width,
+        height,
+        width,
+        height
+    ];
+    return 'yx' === resolvedCoordinates.order ? [
+        height,
+        width
+    ] : [
+        width,
+        height
+    ];
+}
+function assertLocateResultCoordinates(result, resolvedCoordinates, width, height) {
+    const normalizedBy = resolvedCoordinates.normalizedBy;
+    const limits = resolveCoordinateLimits(result, resolvedCoordinates, width, height);
+    const outOfRange = result.coordinates.some((value, index)=>{
+        const limit = limits[index];
+        return 'number' != typeof value || !Number.isFinite(value) || value < 0 || value > limit;
+    });
+    if (!outOfRange) return;
+    const source = void 0 !== normalizedBy ? `normalized range [0, ${normalizedBy}]` : `image size [0, ${width}]x[0, ${height}]`;
+    const normalizedInfo = void 0 !== normalizedBy ? ` normalizedBy=${normalizedBy}` : '';
+    throw new Error(`locate result coordinates ${JSON.stringify(result.coordinates)} exceed ${source}. shape=${resolvedCoordinates.shape} order=${resolvedCoordinates.order}${normalizedInfo} limits=${JSON.stringify(limits)}`);
+}
+function reorderCoordinatesToXy(coordinates, order) {
+    if ('yx' !== order) return coordinates;
+    if (4 === coordinates.length) {
+        const [top, left, bottom, right] = coordinates;
+        return [
+            left,
+            top,
+            right,
+            bottom
+        ];
+    }
+    const [y, x] = coordinates;
+    return [
+        x,
+        y
+    ];
+}
+function mapLocateResultToPixelBboxByCoordinates(result, { preparedSize }, resolvedCoordinates) {
+    const { width, height } = preparedSize;
+    const normalizedBy = resolvedCoordinates.normalizedBy;
+    assertLocateResultCoordinates(result, resolvedCoordinates, width, height);
+    const xyCoordinates = reorderCoordinatesToXy(result.coordinates, resolvedCoordinates.order);
+    const xyBbox = 4 === xyCoordinates.length ? xyCoordinates : expandPointToBbox(xyCoordinates[0], xyCoordinates[1], normalizedBy ?? maxPixelIndex(width), normalizedBy ?? maxPixelIndex(height), void 0 === normalizedBy ? defaultBboxSize / 2 : normalizedBy / 100);
+    return void 0 === normalizedBy ? xyBbox : mapNormalizedCoordinatesToPixelBbox(xyBbox, normalizedBy, width, height);
+}
+export { mapLocateResultToPixelBboxByCoordinates };
+
+//# sourceMappingURL=pixel-bbox-mapper.mjs.map

package/dist/es/ai-model/shared/model-locate-result/pixel-bbox-mapper.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/shared/model-locate-result/pixel-bbox-mapper.mjs","sources":["../../../../../src/ai-model/shared/model-locate-result/pixel-bbox-mapper.ts"],"sourcesContent":["import {\n  expandPointToBbox,\n  mapNormalizedCoordinatesToPixelBbox,\n  maxPixelIndex,\n} from './bbox';\nimport type {\n  LocateResultBbox,\n  LocateResultValue,\n  PixelBbox,\n  ResolvedLocateResultCoordinates,\n} from './types';\n\ntype Point = [number, number];\n\nconst defaultBboxSize = 20; // must be even number\n\nfunction resolveCoordinateLimits(\n  result: LocateResultValue,\n  resolvedCoordinates: ResolvedLocateResultCoordinates,\n  width: number,\n  height: number,\n): number[] {\n  const normalizedBy = resolvedCoordinates.normalizedBy;\n  if (normalizedBy !== undefined) {\n    return result.coordinates.map(() => normalizedBy);\n  }\n\n  if (result.type === 'bbox') {\n    return resolvedCoordinates.order === 'yx'\n      ? [height, width, height, width]\n      : [width, height, width, height];\n  }\n\n  return resolvedCoordinates.order === 'yx' ? [height, width] : [width, height];\n}\n\nfunction assertLocateResultCoordinates(\n  result: LocateResultValue,\n  resolvedCoordinates: ResolvedLocateResultCoordinates,\n  width: number,\n  height: number,\n) {\n  const normalizedBy = resolvedCoordinates.normalizedBy;\n  const limits = resolveCoordinateLimits(\n    result,\n    resolvedCoordinates,\n    width,\n    height,\n  );\n  const outOfRange = result.coordinates.some((value, index) => {\n    const limit = limits[index];\n    return (\n      typeof value !== 'number' ||\n      !Number.isFinite(value) ||\n      value < 0 ||\n      value > limit\n    );\n  });\n\n  if (!outOfRange) {\n    return;\n  }\n\n  const source =\n    normalizedBy !== undefined\n      ? `normalized range [0, ${normalizedBy}]`\n      : `image size [0, ${width}]x[0, ${height}]`;\n  const normalizedInfo =\n    normalizedBy !== undefined ? ` normalizedBy=${normalizedBy}` : '';\n  throw new Error(\n    `locate result coordinates ${JSON.stringify(\n      result.coordinates,\n    )} exceed ${source}. shape=${\n      resolvedCoordinates.shape\n    } order=${resolvedCoordinates.order}${normalizedInfo} limits=${JSON.stringify(\n      limits,\n    )}`,\n  );\n}\n\nfunction reorderCoordinatesToXy(\n  coordinates: LocateResultBbox,\n  order: ResolvedLocateResultCoordinates['order'],\n): LocateResultBbox;\nfunction reorderCoordinatesToXy(\n  coordinates: Point,\n  order: ResolvedLocateResultCoordinates['order'],\n): Point;\nfunction reorderCoordinatesToXy(\n  coordinates: LocateResultBbox | Point,\n  order: ResolvedLocateResultCoordinates['order'],\n): LocateResultBbox | Point;\nfunction reorderCoordinatesToXy(\n  coordinates: LocateResultBbox | Point,\n  order: ResolvedLocateResultCoordinates['order'],\n): LocateResultBbox | Point {\n  if (order !== 'yx') {\n    return coordinates;\n  }\n\n  if (coordinates.length === 4) {\n    const [top, left, bottom, right] = coordinates;\n    return [left, top, right, bottom];\n  }\n\n  const [y, x] = coordinates;\n  return [x, y];\n}\n\nexport function mapLocateResultToPixelBboxByCoordinates(\n  result: LocateResultValue,\n  { preparedSize }: { preparedSize: { width: number; height: number } },\n  resolvedCoordinates: ResolvedLocateResultCoordinates,\n): PixelBbox {\n  // The parsed result type decides whether this maps a bbox or expands a point.\n  // `resolvedCoordinates` describes coordinate order and normalization only.\n  const { width, height } = preparedSize;\n  const normalizedBy = resolvedCoordinates.normalizedBy;\n  assertLocateResultCoordinates(result, resolvedCoordinates, width, height);\n\n  const xyCoordinates = reorderCoordinatesToXy(\n    result.coordinates,\n    resolvedCoordinates.order,\n  );\n\n  const xyBbox =\n    xyCoordinates.length === 4\n      ? xyCoordinates\n      : expandPointToBbox(\n          xyCoordinates[0],\n          xyCoordinates[1],\n          normalizedBy ?? maxPixelIndex(width),\n          normalizedBy ?? maxPixelIndex(height),\n          normalizedBy === undefined ? defaultBboxSize / 2 : normalizedBy / 100,\n        );\n\n  return normalizedBy === undefined\n    ? xyBbox\n    : mapNormalizedCoordinatesToPixelBbox(xyBbox, normalizedBy, width, height);\n}\n"],"names":["defaultBboxSize","resolveCoordinateLimits","result","resolvedCoordinates","width","height","normalizedBy","undefined","assertLocateResultCoordinates","limits","outOfRange","value","index","limit","Number","source","normalizedInfo","Error","JSON","reorderCoordinatesToXy","coordinates","order","top","left","bottom","right","y","x","mapLocateResultToPixelBboxByCoordinates","preparedSize","xyCoordinates","xyBbox","expandPointToBbox","maxPixelIndex","mapNormalizedCoordinatesToPixelBbox"],"mappings":";AAcA,MAAMA,kBAAkB;AAExB,SAASC,wBACPC,MAAyB,EACzBC,mBAAoD,EACpDC,KAAa,EACbC,MAAc;IAEd,MAAMC,eAAeH,oBAAoB,YAAY;IACrD,IAAIG,AAAiBC,WAAjBD,cACF,OAAOJ,OAAO,WAAW,CAAC,GAAG,CAAC,IAAMI;IAGtC,IAAIJ,AAAgB,WAAhBA,OAAO,IAAI,EACb,OAAOC,AAA8B,SAA9BA,oBAAoB,KAAK,GAC5B;QAACE;QAAQD;QAAOC;QAAQD;KAAM,GAC9B;QAACA;QAAOC;QAAQD;QAAOC;KAAO;IAGpC,OAAOF,AAA8B,SAA9BA,oBAAoB,KAAK,GAAY;QAACE;QAAQD;KAAM,GAAG;QAACA;QAAOC;KAAO;AAC/E;AAEA,SAASG,8BACPN,MAAyB,EACzBC,mBAAoD,EACpDC,KAAa,EACbC,MAAc;IAEd,MAAMC,eAAeH,oBAAoB,YAAY;IACrD,MAAMM,SAASR,wBACbC,QACAC,qBACAC,OACAC;IAEF,MAAMK,aAAaR,OAAO,WAAW,CAAC,IAAI,CAAC,CAACS,OAAOC;QACjD,MAAMC,QAAQJ,MAAM,CAACG,MAAM;QAC3B,OACE,AAAiB,YAAjB,OAAOD,SACP,CAACG,OAAO,QAAQ,CAACH,UACjBA,QAAQ,KACRA,QAAQE;IAEZ;IAEA,IAAI,CAACH,YACH;IAGF,MAAMK,SACJT,AAAiBC,WAAjBD,eACI,CAAC,qBAAqB,EAAEA,aAAa,CAAC,CAAC,GACvC,CAAC,eAAe,EAAEF,MAAM,MAAM,EAAEC,OAAO,CAAC,CAAC;IAC/C,MAAMW,iBACJV,AAAiBC,WAAjBD,eAA6B,CAAC,cAAc,EAAEA,cAAc,GAAG;IACjE,MAAM,IAAIW,MACR,CAAC,0BAA0B,EAAEC,KAAK,SAAS,CACzChB,OAAO,WAAW,EAClB,QAAQ,EAAEa,OAAO,QAAQ,EACzBZ,oBAAoB,KAAK,CAC1B,OAAO,EAAEA,oBAAoB,KAAK,GAAGa,eAAe,QAAQ,EAAEE,KAAK,SAAS,CAC3ET,SACC;AAEP;AAcA,SAASU,uBACPC,WAAqC,EACrCC,KAA+C;IAE/C,IAAIA,AAAU,SAAVA,OACF,OAAOD;IAGT,IAAIA,AAAuB,MAAvBA,YAAY,MAAM,EAAQ;QAC5B,MAAM,CAACE,KAAKC,MAAMC,QAAQC,MAAM,GAAGL;QACnC,OAAO;YAACG;YAAMD;YAAKG;YAAOD;SAAO;IACnC;IAEA,MAAM,CAACE,GAAGC,EAAE,GAAGP;IACf,OAAO;QAACO;QAAGD;KAAE;AACf;AAEO,SAASE,wCACd1B,MAAyB,EACzB,EAAE2B,YAAY,EAAuD,EACrE1B,mBAAoD;IAIpD,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAE,GAAGwB;IAC1B,MAAMvB,eAAeH,oBAAoB,YAAY;IACrDK,8BAA8BN,QAAQC,qBAAqBC,OAAOC;IAElE,MAAMyB,gBAAgBX,uBACpBjB,OAAO,WAAW,EAClBC,oBAAoB,KAAK;IAG3B,MAAM4B,SACJD,AAAyB,MAAzBA,cAAc,MAAM,GAChBA,gBACAE,kBACEF,aAAa,CAAC,EAAE,EAChBA,aAAa,CAAC,EAAE,EAChBxB,gBAAgB2B,cAAc7B,QAC9BE,gBAAgB2B,cAAc5B,SAC9BC,AAAiBC,WAAjBD,eAA6BN,kBAAkB,IAAIM,eAAe;IAG1E,OAAOA,AAAiBC,WAAjBD,eACHyB,SACAG,oCAAoCH,QAAQzB,cAAcF,OAAOC;AACvE"}

package/dist/es/ai-model/workflows/image-preprocess.mjs

@@ -0,0 +1,27 @@
+import { paddingToMatchBlockByBase64 } from "@midscene/shared/img";
+async function prepareModelImage(options) {
+    const { imageBase64, width, height, policy } = options;
+    let preparedImageBase64 = imageBase64;
+    let modelWidth = width;
+    let modelHeight = height;
+    if (void 0 !== policy.padBlockSize) {
+        const paddedResult = await paddingToMatchBlockByBase64(imageBase64, policy.padBlockSize);
+        preparedImageBase64 = paddedResult.imageBase64;
+        modelWidth = paddedResult.width;
+        modelHeight = paddedResult.height;
+    }
+    return {
+        imageBase64: preparedImageBase64,
+        preparedSize: {
+            width: modelWidth,
+            height: modelHeight
+        },
+        contentSize: {
+            width,
+            height
+        }
+    };
+}
+export { prepareModelImage };
+
+//# sourceMappingURL=image-preprocess.mjs.map

package/dist/es/ai-model/workflows/image-preprocess.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/workflows/image-preprocess.mjs","sources":["../../../../src/ai-model/workflows/image-preprocess.ts"],"sourcesContent":["import { paddingToMatchBlockByBase64 } from '@midscene/shared/img';\n\nexport interface ImagePreprocessPolicy {\n  padBlockSize?: number;\n}\n\nexport interface PreparedModelImage {\n  imageBase64: string;\n  /**\n   * Size of the image sent to the model after preprocessing. This can be larger\n   * than the original screenshot when padding is applied to satisfy model block\n   * size requirements.\n   */\n  preparedSize: {\n    width: number;\n    height: number;\n  };\n  /**\n   * Size of the real screenshot content inside the prepared image. Pixel bboxes\n   * are parsed against `preparedSize`, then clipped to `contentSize` so padding\n   * added for the model is not treated as valid UI content.\n   */\n  contentSize: {\n    width: number;\n    height: number;\n  };\n}\n\nexport async function prepareModelImage(options: {\n  imageBase64: string;\n  width: number;\n  height: number;\n  policy: ImagePreprocessPolicy;\n}): Promise<PreparedModelImage> {\n  const { imageBase64, width, height, policy } = options;\n  let preparedImageBase64 = imageBase64;\n  let modelWidth = width;\n  let modelHeight = height;\n\n  if (policy.padBlockSize !== undefined) {\n    const paddedResult = await paddingToMatchBlockByBase64(\n      imageBase64,\n      policy.padBlockSize,\n    );\n    preparedImageBase64 = paddedResult.imageBase64;\n    modelWidth = paddedResult.width;\n    modelHeight = paddedResult.height;\n  }\n\n  return {\n    imageBase64: preparedImageBase64,\n    preparedSize: {\n      width: modelWidth,\n      height: modelHeight,\n    },\n    contentSize: {\n      width,\n      height,\n    },\n  };\n}\n"],"names":["prepareModelImage","options","imageBase64","width","height","policy","preparedImageBase64","modelWidth","modelHeight","undefined","paddedResult","paddingToMatchBlockByBase64"],"mappings":";AA4BO,eAAeA,kBAAkBC,OAKvC;IACC,MAAM,EAAEC,WAAW,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGJ;IAC/C,IAAIK,sBAAsBJ;IAC1B,IAAIK,aAAaJ;IACjB,IAAIK,cAAcJ;IAElB,IAAIC,AAAwBI,WAAxBJ,OAAO,YAAY,EAAgB;QACrC,MAAMK,eAAe,MAAMC,4BACzBT,aACAG,OAAO,YAAY;QAErBC,sBAAsBI,aAAa,WAAW;QAC9CH,aAAaG,aAAa,KAAK;QAC/BF,cAAcE,aAAa,MAAM;IACnC;IAEA,OAAO;QACL,aAAaJ;QACb,cAAc;YACZ,OAAOC;YACP,QAAQC;QACV;QACA,aAAa;YACXL;YACAC;QACF;IACF;AACF"}

package/dist/es/ai-model/workflows/inspect/index.mjs

@@ -0,0 +1,2 @@
+import { AiExtractElementInfo, AiJudgeOrderSensitive, AiLocateElement, AiLocateSection, buildSearchAreaConfig } from "../../inspect.mjs";
+export { AiExtractElementInfo, AiJudgeOrderSensitive, AiLocateElement, AiLocateSection, buildSearchAreaConfig };

package/dist/es/ai-model/workflows/inspect/locate-result-rect.mjs

@@ -0,0 +1,23 @@
+function mergePixelBboxesToRect(pixelBboxes) {
+    const minLeft = Math.min(...pixelBboxes.map(([left])=>left));
+    const minTop = Math.min(...pixelBboxes.map(([, top])=>top));
+    const maxRight = Math.max(...pixelBboxes.map(([, , right])=>right));
+    const maxBottom = Math.max(...pixelBboxes.map(([, , , bottom])=>bottom));
+    return pixelBboxToRect([
+        minLeft,
+        minTop,
+        maxRight,
+        maxBottom
+    ]);
+}
+function pixelBboxToRect([left, top, right, bottom]) {
+    return {
+        left,
+        top,
+        width: right - left + 1,
+        height: bottom - top + 1
+    };
+}
+export { mergePixelBboxesToRect, pixelBboxToRect };
+
+//# sourceMappingURL=locate-result-rect.mjs.map

package/dist/es/ai-model/workflows/inspect/locate-result-rect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/workflows/inspect/locate-result-rect.mjs","sources":["../../../../../src/ai-model/workflows/inspect/locate-result-rect.ts"],"sourcesContent":["import type { PixelBbox } from '@/ai-model/shared/model-locate-result';\nimport type { Rect } from '@/types';\n\nexport function mergePixelBboxesToRect(pixelBboxes: PixelBbox[]): Rect {\n  const minLeft = Math.min(...pixelBboxes.map(([left]) => left));\n  const minTop = Math.min(...pixelBboxes.map(([, top]) => top));\n  const maxRight = Math.max(...pixelBboxes.map(([, , right]) => right));\n  const maxBottom = Math.max(...pixelBboxes.map(([, , , bottom]) => bottom));\n  return pixelBboxToRect([minLeft, minTop, maxRight, maxBottom]);\n}\n\nexport function pixelBboxToRect([left, top, right, bottom]: PixelBbox): Rect {\n  return {\n    left,\n    top,\n    width: right - left + 1,\n    height: bottom - top + 1,\n  };\n}\n"],"names":["mergePixelBboxesToRect","pixelBboxes","minLeft","Math","left","minTop","top","maxRight","right","maxBottom","bottom","pixelBboxToRect"],"mappings":"AAGO,SAASA,uBAAuBC,WAAwB;IAC7D,MAAMC,UAAUC,KAAK,GAAG,IAAIF,YAAY,GAAG,CAAC,CAAC,CAACG,KAAK,GAAKA;IACxD,MAAMC,SAASF,KAAK,GAAG,IAAIF,YAAY,GAAG,CAAC,CAAC,GAAGK,IAAI,GAAKA;IACxD,MAAMC,WAAWJ,KAAK,GAAG,IAAIF,YAAY,GAAG,CAAC,CAAC,KAAKO,MAAM,GAAKA;IAC9D,MAAMC,YAAYN,KAAK,GAAG,IAAIF,YAAY,GAAG,CAAC,CAAC,OAAOS,OAAO,GAAKA;IAClE,OAAOC,gBAAgB;QAACT;QAASG;QAAQE;QAAUE;KAAU;AAC/D;AAEO,SAASE,gBAAgB,CAACP,MAAME,KAAKE,OAAOE,OAAkB;IACnE,OAAO;QACLN;QACAE;QACA,OAAOE,QAAQJ,OAAO;QACtB,QAAQM,SAASJ,MAAM;IACzB;AACF"}

package/dist/es/ai-model/workflows/inspect/search-area-mapping.mjs

@@ -0,0 +1,18 @@
+function mapSearchAreaPixelBboxToOriginalPixelBbox([left, top, right, bottom], mapping) {
+    const offset = mapping?.offset ?? {
+        x: 0,
+        y: 0
+    };
+    const scale = mapping?.scale ?? 1;
+    const mapX = (x)=>(1 !== scale ? Math.round(x / scale) : x) + offset.x;
+    const mapY = (y)=>(1 !== scale ? Math.round(y / scale) : y) + offset.y;
+    return [
+        mapX(left),
+        mapY(top),
+        mapX(right),
+        mapY(bottom)
+    ];
+}
+export { mapSearchAreaPixelBboxToOriginalPixelBbox };
+
+//# sourceMappingURL=search-area-mapping.mjs.map

package/dist/es/ai-model/workflows/inspect/search-area-mapping.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/workflows/inspect/search-area-mapping.mjs","sources":["../../../../../src/ai-model/workflows/inspect/search-area-mapping.ts"],"sourcesContent":["import type { PixelBbox } from '@/ai-model/shared/model-locate-result';\nimport type { SearchAreaImageMapping } from './types';\n\nexport function mapSearchAreaPixelBboxToOriginalPixelBbox(\n  [left, top, right, bottom]: PixelBbox,\n  mapping?: SearchAreaImageMapping,\n): PixelBbox {\n  const offset = mapping?.offset ?? { x: 0, y: 0 };\n  const scale = mapping?.scale ?? 1;\n  const mapX = (x: number) =>\n    (scale !== 1 ? Math.round(x / scale) : x) + offset.x;\n  const mapY = (y: number) =>\n    (scale !== 1 ? Math.round(y / scale) : y) + offset.y;\n\n  return [mapX(left), mapY(top), mapX(right), mapY(bottom)];\n}\n"],"names":["mapSearchAreaPixelBboxToOriginalPixelBbox","left","top","right","bottom","mapping","offset","scale","mapX","x","Math","mapY","y"],"mappings":"AAGO,SAASA,0CACd,CAACC,MAAMC,KAAKC,OAAOC,OAAkB,EACrCC,OAAgC;IAEhC,MAAMC,SAASD,SAAS,UAAU;QAAE,GAAG;QAAG,GAAG;IAAE;IAC/C,MAAME,QAAQF,SAAS,SAAS;IAChC,MAAMG,OAAO,CAACC,IACXF,AAAAA,CAAAA,AAAU,MAAVA,QAAcG,KAAK,KAAK,CAACD,IAAIF,SAASE,CAAAA,IAAKH,OAAO,CAAC;IACtD,MAAMK,OAAO,CAACC,IACXL,AAAAA,CAAAA,AAAU,MAAVA,QAAcG,KAAK,KAAK,CAACE,IAAIL,SAASK,CAAAA,IAAKN,OAAO,CAAC;IAEtD,OAAO;QAACE,KAAKP;QAAOU,KAAKT;QAAMM,KAAKL;QAAQQ,KAAKP;KAAQ;AAC3D"}

package/dist/es/ai-model/workflows/planning/index.mjs

@@ -0,0 +1,5 @@
+import { plan } from "../../llm-planning.mjs";
+const genericXmlPlan = plan;
+export { genericXmlPlan };
+
+//# sourceMappingURL=index.mjs.map

package/dist/es/ai-model/workflows/planning/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-model/workflows/planning/index.mjs","sources":["../../../../../src/ai-model/workflows/planning/index.ts"],"sourcesContent":["import { plan } from '../../llm-planning';\nimport type { PlanFn } from './types';\n\nexport const genericXmlPlan: PlanFn = plan;\n"],"names":["genericXmlPlan","plan"],"mappings":";AAGO,MAAMA,iBAAyBC"}