deepline 0.1.33 → 0.1.35

package/dist/index.mjs

@@ -169,8 +169,8 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.33";
-var SDK_API_CONTRACT = "2026-05-host-env-generic-play-input-flags";
+var SDK_VERSION = "0.1.35";
+var SDK_API_CONTRACT = "2026-05-v2-tool-result-contract";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
 var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
@@ -252,7 +252,7 @@ var HttpClient = class {
           const response = await fetch(candidateUrl, {
             method,
             headers,
-            body: options?.formData !== void 0 ? options.formData : options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
+            body: options?.formData !== void 0 ? typeof options.formData === "function" ? options.formData() : options.formData : options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
             signal: controller.signal
           });
           clearTimeout(timeoutId);
@@ -335,10 +335,13 @@ var HttpClient = class {
           throw new AuthError();
         }
         if (!response.ok) {
+          const body = await response.text();
+          const parsed = parseResponseBody(body);
           throw new DeeplineError(
-            `HTTP ${response.status}`,
+            apiErrorMessage(parsed, response.status),
             response.status,
-            "API_ERROR"
+            "API_ERROR",
+            { response: parsed }
           );
         }
         if (!response.body) {
@@ -388,6 +391,26 @@ var HttpClient = class {
     return this.request(path, { method: "DELETE" });
   }
 };
+function parseResponseBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return body;
+  }
+}
+function apiErrorMessage(parsed, status) {
+  const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
+  if (typeof errorValue === "string") {
+    return errorValue;
+  }
+  if (errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string") {
+    return errorValue.message;
+  }
+  if (typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string") {
+    return parsed.message;
+  }
+  return `HTTP ${status}`;
+}
 function parseRetryAfter(response) {
   const header = response.headers.get("retry-after");
   if (header) {
@@ -457,6 +480,8 @@ function sleep(ms) {
 // src/client.ts
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
+var EXECUTE_RESPONSE_CONTRACT_HEADER = "x-deepline-execute-response-contract";
+var V2_EXECUTE_RESPONSE_CONTRACT = "v2-tool-execution-result";
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -725,13 +750,16 @@ var DeeplineClient = class {
   /**
    * Execute a tool and return the standard execution envelope.
    *
-   * The `result.data` field contains the provider payload. `result.meta`
-   * contains provider/upstream metadata such as HTTP status or paging details.
+   * The `toolExecutionResult.toolOutput.raw` field contains the raw tool output.
+   * `toolExecutionResult.toolOutput.meta` contains tool/provider metadata.
    * Top-level fields such as `status`, `job_id`, and `billing` describe the
-   * Deepline execution.
+   * Deepline execution envelope.
    */
   async executeTool(toolId, input, options) {
-    const headers = options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : void 0;
+    const headers = {
+      [EXECUTE_RESPONSE_CONTRACT_HEADER]: V2_EXECUTE_RESPONSE_CONTRACT,
+      ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {}
+    };
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       { payload: input },
@@ -1029,34 +1057,37 @@ var DeeplineClient = class {
    * ```
    */
   async stagePlayFiles(files) {
-    const formData = new FormData();
-    formData.set(
-      "metadata",
-      JSON.stringify({
-        files: files.map((file, index) => ({
-          index,
-          logicalPath: file.logicalPath,
-          contentHash: file.contentHash,
-          contentType: file.contentType,
-          bytes: file.bytes
-        }))
-      })
-    );
-    for (const [index, file] of files.entries()) {
-      const bytes = decodeBase64Bytes(file.contentBase64);
-      const body = bytes.buffer.slice(
-        bytes.byteOffset,
-        bytes.byteOffset + bytes.byteLength
-      );
+    const buildFormData = () => {
+      const formData = new FormData();
       formData.set(
-        `file:${index}`,
-        new Blob([body], { type: file.contentType }),
-        file.logicalPath
+        "metadata",
+        JSON.stringify({
+          files: files.map((file, index) => ({
+            index,
+            logicalPath: file.logicalPath,
+            contentHash: file.contentHash,
+            contentType: file.contentType,
+            bytes: file.bytes
+          }))
+        })
       );
-    }
+      for (const [index, file] of files.entries()) {
+        const bytes = decodeBase64Bytes(file.contentBase64);
+        const body = bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        );
+        formData.set(
+          `file:${index}`,
+          new Blob([body], { type: file.contentType }),
+          file.logicalPath
+        );
+      }
+      return formData;
+    };
     const response = await this.http.postFormData(
       "/api/v2/plays/files/stage",
-      formData
+      buildFormData
     );
     return response.files;
   }
@@ -1530,6 +1561,383 @@ var DeeplineClient = class {
   }
 };
 
+// ../shared_libs/play-runtime/tool-result.ts
+var TARGET_FALLBACK_KEYS = {
+  email: [/^email$/i, /^address$/i, /email/i],
+  phone: [/^phone$/i, /mobile/i, /phone/i, /telephone/i],
+  linkedin: [/^linkedin_url$/i, /^linkedin$/i, /linkedin/i],
+  company_linkedin_url: [/company.*linkedin/i, /linkedin.*company/i],
+  company_domain: [/^company_domain$/i, /company.*domain/i],
+  company_name: [/^company_name$/i, /company.*name/i],
+  domain: [/^domain$/i, /company_domain/i, /domain/i],
+  status: [/^email_status$/i, /^status$/i],
+  email_status: [/^email_status$/i, /^status$/i]
+};
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toV2RawToolOutputPath(path) {
+  const normalized = String(path || "").trim().replace(/^\./, "");
+  if (!normalized) return "toolExecutionResult.toolOutput.raw";
+  if (normalized === "toolExecutionResult.toolOutput.raw" || normalized.startsWith("toolExecutionResult.toolOutput.raw.")) {
+    return normalized;
+  }
+  const rawPath = normalized.replace(/^result\.data\.?/, "").replace(/^result\.?/, "").replace(/^data\.?/, "").replace(/^\./, "");
+  return rawPath ? `toolExecutionResult.toolOutput.raw.${rawPath}` : "toolExecutionResult.toolOutput.raw";
+}
+function isMeaningfulValue(value) {
+  if (value == null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function parsePath(path) {
+  const segments = [];
+  for (const rawPart of path.split(".").filter(Boolean)) {
+    const bracketPattern = /([^\[\]]+)|\[(\d+|\*)\]/g;
+    let matched = false;
+    for (const match of rawPart.matchAll(bracketPattern)) {
+      matched = true;
+      if (match[1]) {
+        segments.push(match[1]);
+      } else if (match[2] === "*") {
+        segments.push("*");
+      } else if (match[2]) {
+        segments.push(Number(match[2]));
+      }
+    }
+    if (!matched) {
+      segments.push(rawPart);
+    }
+  }
+  return segments;
+}
+function pathToString(segments) {
+  return segments.map(
+    (segment, index) => typeof segment === "number" ? `[${segment}]` : segment === "*" ? "[*]" : index === 0 ? segment : `.${segment}`
+  ).join("");
+}
+function valuesAtSegments(current, segments, path = []) {
+  if (segments.length === 0) {
+    return [{ value: current, path: pathToString(path) }];
+  }
+  const [segment, ...rest] = segments;
+  if (segment === "*") {
+    if (!Array.isArray(current)) return [];
+    return current.flatMap(
+      (entry, index) => valuesAtSegments(entry, rest, [...path, index])
+    );
+  }
+  if (typeof segment === "number") {
+    if (!Array.isArray(current)) return [];
+    return valuesAtSegments(current[segment], rest, [...path, segment]);
+  }
+  if (!isRecord2(current)) return [];
+  return valuesAtSegments(current[segment], rest, [...path, segment]);
+}
+function getValuesAtPath(root, path) {
+  return valuesAtSegments(root, parsePath(path)).map((entry) => entry.value);
+}
+function toResultEnvelope(value) {
+  if (isRecord2(value) && "data" in value) {
+    const envelope = { data: value.data };
+    if ("meta" in value) envelope.meta = value.meta;
+    return envelope;
+  }
+  return { data: value };
+}
+function normalizeResultPath(path) {
+  const trimmed = String(path || "").trim().replace(/^\./, "");
+  if (!trimmed) return "";
+  return toV2RawToolOutputPath(trimmed);
+}
+function toV2RawToolOutputPathPreservingProviderData(path) {
+  const normalized = String(path || "").trim().replace(/^\./, "");
+  if (!normalized) return "toolExecutionResult.toolOutput.raw";
+  if (normalized === "toolExecutionResult.toolOutput.raw" || normalized.startsWith("toolExecutionResult.toolOutput.raw.")) {
+    return normalized;
+  }
+  const rawPath = normalized.replace(/^result\.?/, "").replace(/^\./, "");
+  return rawPath ? `toolExecutionResult.toolOutput.raw.${rawPath}` : "toolExecutionResult.toolOutput.raw";
+}
+function candidateResultPaths(path) {
+  const candidates = [
+    normalizeResultPath(path),
+    toV2RawToolOutputPathPreservingProviderData(path)
+  ];
+  return candidates.filter(
+    (candidate, index, all) => candidate.length > 0 && all.indexOf(candidate) === index
+  );
+}
+function normalizeRelativePath(path) {
+  return String(path || "").trim().replace(/^result\./, "").replace(/^\./, "");
+}
+function getFirstMeaningfulValueAtPath(root, path) {
+  for (const entry of valuesAtSegments(root, parsePath(path))) {
+    if (isMeaningfulValue(entry.value)) {
+      return { value: entry.value, path: entry.path };
+    }
+  }
+  return null;
+}
+function getAtPath(root, path) {
+  const segments = parsePath(path);
+  if (segments.includes("*")) {
+    return getValuesAtPath(root, path).filter(isMeaningfulValue);
+  }
+  let current = root;
+  for (const segment of segments) {
+    if (typeof segment === "number") {
+      if (!Array.isArray(current)) return void 0;
+      current = current[segment];
+      continue;
+    }
+    if (!isRecord2(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function normalizeRows(value) {
+  if (!Array.isArray(value)) return null;
+  return value.map((entry) => isRecord2(entry) ? entry : { value: entry });
+}
+function findFirstTargetByPath(result, paths) {
+  for (const path of paths ?? []) {
+    for (const candidate of candidateResultPaths(path)) {
+      const match = getFirstMeaningfulValueAtPath(result, candidate);
+      if (match) return match;
+    }
+  }
+  return null;
+}
+function findFirstTargetByKey(result, target, depth = 0, path = []) {
+  if (depth > 6) return null;
+  if (Array.isArray(result)) {
+    for (let index = 0; index < result.length; index += 1) {
+      const found = findFirstTargetByKey(result[index], target, depth + 1, [
+        ...path,
+        index
+      ]);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (!isRecord2(result)) return null;
+  const patterns = TARGET_FALLBACK_KEYS[target] ?? [
+    new RegExp(`^${target}$`, "i")
+  ];
+  for (const [key, value] of Object.entries(result)) {
+    if (patterns.some((pattern) => pattern.test(key)) && isMeaningfulValue(value)) {
+      return { value, path: pathToString([...path, key]) };
+    }
+  }
+  for (const [key, value] of Object.entries(result)) {
+    const found = findFirstTargetByKey(value, target, depth + 1, [
+      ...path,
+      key
+    ]);
+    if (found) return found;
+  }
+  return null;
+}
+function resolveListRows(result, listExtractorPaths) {
+  const lists = {};
+  for (const rawPath of listExtractorPaths ?? []) {
+    const path = normalizeResultPath(rawPath);
+    if (!path) continue;
+    const candidates = [
+      ...candidateResultPaths(rawPath)
+    ].filter(
+      (candidate, index, all) => candidate && all.indexOf(candidate) === index
+    );
+    let resolvedPath = null;
+    let rows = null;
+    for (const candidate of candidates) {
+      rows = normalizeRows(getAtPath(result, candidate));
+      if (rows) {
+        resolvedPath = candidate;
+        break;
+      }
+    }
+    if (!rows) continue;
+    const storedPath = resolvedPath ?? path;
+    const name = storedPath.split(".").filter(Boolean).at(-1)?.replace(/\[\d+\]$/, "");
+    lists[name || storedPath] = { path: storedPath, rows };
+  }
+  return lists;
+}
+function deriveListKeys(input) {
+  const keys = {};
+  for (const [target, paths] of Object.entries(
+    input.listIdentityGetters ?? {}
+  )) {
+    const firstPath = paths.map(
+      (rawPath) => normalizeRelativePath(rawPath)
+    ).find(Boolean);
+    if (firstPath) {
+      keys[target] = firstPath;
+    }
+  }
+  if (Object.keys(keys).length > 0) {
+    return keys;
+  }
+  const listPrefix = input.listPath.replace(/\[\d+\]$/, "");
+  for (const [target, paths] of Object.entries(
+    input.resultIdentityGetters ?? {}
+  )) {
+    for (const rawPath of paths) {
+      const path = String(rawPath || "").trim().replace(/^\./, "");
+      if (!path) continue;
+      for (const resultPath of candidateResultPaths(path)) {
+        const directPrefix = `${listPrefix}.`;
+        if (resultPath.startsWith(directPrefix)) {
+          keys[target] = resultPath.slice(directPrefix.length).replace(/^\[\d+\]\.?/, "");
+          break;
+        }
+        const indexedPrefix = `${listPrefix}[0].`;
+        if (resultPath.startsWith(indexedPrefix)) {
+          keys[target] = resultPath.slice(indexedPrefix.length);
+          break;
+        }
+        const wildcardPrefix = `${listPrefix}[*].`;
+        if (resultPath.startsWith(wildcardPrefix)) {
+          keys[target] = resultPath.slice(wildcardPrefix.length);
+          break;
+        }
+        const dottedIndexPrefix = `${listPrefix}.0.`;
+        if (resultPath.startsWith(dottedIndexPrefix)) {
+          keys[target] = resultPath.slice(dottedIndexPrefix.length);
+          break;
+        }
+      }
+      if (keys[target]) break;
+    }
+  }
+  if (Object.keys(keys).length === 0 && input.rows[0]) {
+    for (const key of Object.keys(input.rows[0])) {
+      keys[key] = key;
+    }
+  }
+  return keys;
+}
+function buildTargets(result, resultIdentityGetters) {
+  const targets = {};
+  const metadataTargets = new Set(Object.keys(resultIdentityGetters ?? {}));
+  for (const target of metadataTargets) {
+    const fromMetadata = findFirstTargetByPath(
+      result,
+      resultIdentityGetters?.[target]
+    );
+    if (fromMetadata) {
+      targets[target] = fromMetadata;
+      continue;
+    }
+    const fallback = findFirstTargetByKey(result, target);
+    if (fallback) {
+      targets[target] = fallback;
+    }
+  }
+  if (metadataTargets.size > 0) return targets;
+  for (const target of ["email", "phone", "linkedin", "domain", "status"]) {
+    const found = findFirstTargetByKey(result, target);
+    if (found) targets[target] = found;
+  }
+  return targets;
+}
+function buildLists(result, metadata) {
+  const lists = {};
+  const resolved = resolveListRows(result, metadata.listExtractorPaths);
+  for (const [name, list] of Object.entries(resolved)) {
+    lists[name] = {
+      path: list.path,
+      count: list.rows.length,
+      keys: deriveListKeys({
+        listPath: list.path,
+        rows: list.rows,
+        resultIdentityGetters: metadata.resultIdentityGetters,
+        listIdentityGetters: metadata.listIdentityGetters
+      })
+    };
+  }
+  return lists;
+}
+function buildExtractedAccessors(targets) {
+  return Object.fromEntries(
+    Object.entries(targets).map(([target, metadata]) => {
+      const accessor = { path: metadata.path };
+      Object.defineProperties(accessor, {
+        value: {
+          value: metadata.value,
+          enumerable: false
+        },
+        get: {
+          value() {
+            return metadata.value ?? null;
+          },
+          enumerable: false
+        }
+      });
+      return [target, accessor];
+    })
+  );
+}
+function buildListAccessors(result, lists) {
+  return Object.fromEntries(
+    Object.entries(lists).map(([name, metadata]) => {
+      const accessor = {
+        path: metadata.path,
+        count: metadata.count,
+        keys: metadata.keys
+      };
+      Object.defineProperty(accessor, "get", {
+        value() {
+          return normalizeRows(getAtPath(result, metadata.path)) ?? [];
+        },
+        enumerable: false
+      });
+      return [name, accessor];
+    })
+  );
+}
+function createToolExecuteResult(input) {
+  const result = toResultEnvelope(input.result);
+  const resultRoot = {
+    toolExecutionResult: {
+      toolOutput: {
+        raw: result.data,
+        ...result.meta ? { meta: result.meta } : {}
+      }
+    }
+  };
+  const targets = buildTargets(
+    resultRoot,
+    input.metadata.resultIdentityGetters
+  );
+  const lists = buildLists(resultRoot, input.metadata);
+  const metadata = {
+    toolId: input.metadata.toolId,
+    execution: input.execution,
+    targets,
+    lists
+  };
+  const wrapper = {
+    status: input.status,
+    toolOutput: {
+      raw: result.data,
+      ...result.meta ? { meta: result.meta } : {}
+    },
+    meta: input.execution,
+    extractedValues: buildExtractedAccessors(targets),
+    extractedLists: buildListAccessors(resultRoot, lists)
+  };
+  Object.defineProperty(wrapper, "_metadata", {
+    value: metadata,
+    enumerable: false
+  });
+  return wrapper;
+}
+
 // src/play.ts
 var DeeplineConditionalStepResolver = class _DeeplineConditionalStepResolver {
   constructor(when2, run, elseValue) {
@@ -1666,10 +2074,10 @@ var DeeplineContext = class {
    *
    * @example
    * ```typescript
-   * const tools = await ctx.tools.list();
-   * const meta = await ctx.tools.get('apollo_people_search');
-   * const companyLookup = await ctx.tools.execute('test_company_search', { domain: 'stripe.com' });
-   * const company = companyLookup.result.data;
+   * const tools = await deepline.tools.list();
+   * const meta = await deepline.tools.get('apollo_people_search');
+   * const companyLookup = await deepline.tools.execute('test_company_search', { domain: 'stripe.com' });
+   * const company = companyLookup.toolOutput.raw;
    * ```
    */
   get tools() {
@@ -1679,11 +2087,14 @@ var DeeplineContext = class {
       /** Get detailed metadata for a tool. */
       get: (toolId) => this.client.getTool(toolId),
       /** Execute a tool and return the standard execution envelope. */
-      execute: async (toolId, input) => this.client.executeTool(
-        toolId,
-        input,
-        { includeToolMetadata: true }
-      )
+      execute: async (toolId, input) => {
+        const response = await this.client.executeTool(
+          toolId,
+          input,
+          { includeToolMetadata: true }
+        );
+        return toolExecutionEnvelopeToResult(toolId, response);
+      }
     };
   }
   get plays() {
@@ -1778,6 +2189,47 @@ var Deepline = class {
     return new DeeplineContext(options);
   }
 };
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringArrayRecord(value) {
+  if (!isRecord3(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).map(([key, paths]) => [
+      key,
+      Array.isArray(paths) ? paths.map(String) : []
+    ])
+  );
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.map(String) : [];
+}
+function toolExecutionEnvelopeToResult(fallbackToolId, response) {
+  const raw = response.toolExecutionResult?.toolOutput?.raw ?? null;
+  const meta = response.toolExecutionResult?.toolOutput?.meta;
+  const metadata = isRecord3(response._metadata) ? response._metadata.tool : null;
+  const toolMetadata = isRecord3(metadata) ? metadata : {};
+  return createToolExecuteResult({
+    status: typeof response.status === "string" ? response.status : "completed",
+    result: {
+      data: raw,
+      ...isRecord3(meta) ? { meta } : {}
+    },
+    metadata: {
+      toolId: typeof toolMetadata.toolId === "string" ? toolMetadata.toolId : fallbackToolId,
+      resultIdentityGetters: stringArrayRecord(
+        toolMetadata.resultIdentityGetters
+      ),
+      listExtractorPaths: stringArray(toolMetadata.listExtractorPaths),
+      listIdentityGetters: stringArrayRecord(toolMetadata.listIdentityGetters)
+    },
+    execution: {
+      idempotent: true,
+      cached: false,
+      source: "live"
+    }
+  });
+}
 function defineInput(schema) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     throw new Error(
@@ -1904,7 +2356,7 @@ function getByDottedPath(root, dottedPath) {
   }
   return current;
 }
-function normalizeRows(value) {
+function normalizeRows2(value) {
   if (!Array.isArray(value)) return null;
   return value.map((entry) => {
     if (isPlainObject(entry)) return entry;
@@ -1913,6 +2365,25 @@ function normalizeRows(value) {
 }
 function candidateRoots(payload) {
   const roots = [{ path: null, value: payload }];
+  if (isPlainObject(payload) && isPlainObject(payload.toolExecutionResult)) {
+    roots.push({ path: "toolExecutionResult", value: payload.toolExecutionResult });
+    const toolOutput = payload.toolExecutionResult.toolOutput;
+    if (isPlainObject(toolOutput)) {
+      roots.push({ path: "toolExecutionResult.toolOutput", value: toolOutput });
+      if (Object.prototype.hasOwnProperty.call(toolOutput, "raw")) {
+        roots.push({
+          path: "toolExecutionResult.toolOutput.raw",
+          value: toolOutput.raw
+        });
+      }
+    }
+  }
+  if (isPlainObject(payload) && isPlainObject(payload.output)) {
+    roots.push({ path: "output", value: payload.output });
+    if (Object.prototype.hasOwnProperty.call(payload.output, "body")) {
+      roots.push({ path: "output.body", value: payload.output.body });
+    }
+  }
   if (isPlainObject(payload) && isPlainObject(payload.result)) {
     roots.push({ path: "result", value: payload.result });
     if (isPlainObject(payload.result.data)) {
@@ -1923,7 +2394,7 @@ function candidateRoots(payload) {
 }
 function findBestArrayCandidate(value, pathPrefix = "", depth = 0) {
   if (depth > 5) return null;
-  const directRows = normalizeRows(value);
+  const directRows = normalizeRows2(value);
   const hasObjectRow = directRows?.some((row) => Object.keys(row).some((key) => key !== "value")) ?? false;
   let best = directRows && directRows.length > 0 && hasObjectRow ? { path: pathPrefix, rows: directRows } : null;
   if (!isPlainObject(value)) {
@@ -1945,7 +2416,7 @@ function tryConvertToList(payload, options) {
     for (const root of candidateRoots(payload)) {
       for (const extractorPath of listExtractorPaths) {
         const resolved = getByDottedPath(root.value, extractorPath);
-        const rows = normalizeRows(resolved);
+        const rows = normalizeRows2(resolved);
         if (rows && rows.length > 0) {
           const sourcePath = root.path ? `${root.path}.${extractorPath}` : extractorPath;
           return { rows, strategy: "configured_paths", sourcePath };