webfox 0.0.0-test.0 → 4.0.0

package/dist/chunk-U4BLULLV.js

@@ -0,0 +1,52 @@
+// src/errors.ts
+var WebfoxError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(
+      message,
+      options.cause === void 0 ? void 0 : { cause: options.cause }
+    );
+    this.code = code;
+    this.options = options;
+  }
+  code;
+  options;
+  name = "WebfoxError";
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.options.retryable === void 0 ? {} : { retryable: this.options.retryable }
+    };
+  }
+};
+function asWebfoxError(error) {
+  if (error instanceof WebfoxError) return error;
+  const record = error && typeof error === "object" ? error : {};
+  const message = typeof record.message === "string" ? record.message : String(error);
+  if (record.name === "AbortError" || record.name === "APIUserAbortError")
+    return new WebfoxError("CANCELLED", message);
+  if (record.name === "TimeoutError" || record.name === "RequestTimeoutError" || record.name === "APIConnectionTimeoutError")
+    return new WebfoxError("TIMEOUT", message, { retryable: true });
+  const status = record.status ?? record.statusCode;
+  const cause = record.cause && typeof record.cause === "object" ? record.cause : {};
+  const retryable = typeof status === "number" && [408, 429, 500, 502, 503, 504].includes(status) || [
+    "ECONNRESET",
+    "EHOSTUNREACH",
+    "EAI_AGAIN",
+    "ETIMEDOUT",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_SOCKET"
+  ].includes(String(record.code ?? cause.code)) || record.name === "APIConnectionError";
+  return new WebfoxError("PROVIDER_FAILURE", message, { retryable });
+}
+function httpError(response, message) {
+  return new WebfoxError("PROVIDER_FAILURE", message, {
+    retryable: [408, 429, 500, 502, 503, 504].includes(response.status)
+  });
+}
+
+export {
+  WebfoxError,
+  asWebfoxError,
+  httpError
+};

package/dist/chunk-WCTOYZVB.js

@@ -0,0 +1,85 @@
+import {
+  WebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// src/runtime/lifecycle.ts
+function deadline(timeoutMs, parent) {
+  const controller = new AbortController();
+  const abort = () => controller.abort(new WebfoxError("CANCELLED", "Operation cancelled."));
+  if (parent?.aborted) abort();
+  else parent?.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(
+    () => controller.abort(
+      new WebfoxError(
+        "TIMEOUT",
+        `Operation exceeded its ${formatDuration(timeoutMs)} overall deadline.`
+      )
+    ),
+    timeoutMs
+  );
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", abort);
+    }
+  };
+}
+function formatDuration(ms) {
+  const [unit, divisor] = ms >= 36e5 ? ["h", 36e5] : ms >= 6e4 ? ["m", 6e4] : ms >= 1e3 ? ["s", 1e3] : ["ms", 1];
+  return `${Number((ms / divisor).toFixed(3))}${unit}`;
+}
+async function withSignal(promise, signal) {
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(
+      signal.reason ?? new WebfoxError("CANCELLED", "Operation cancelled.")
+    );
+    if (signal.aborted) abort();
+    else signal.addEventListener("abort", abort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", abort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      }
+    );
+  });
+}
+function sleep(ms, signal) {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+async function orderedMap(items, concurrency, work) {
+  const results = new Array(items.length);
+  let next = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(items.length, concurrency) }, async () => {
+      while (next < items.length) {
+        const index = next++;
+        results[index] = await work(items[index], index);
+      }
+    })
+  );
+  return results;
+}
+
+export {
+  deadline,
+  withSignal,
+  sleep,
+  orderedMap
+};

package/dist/chunk-X6ZBIHZC.js

@@ -0,0 +1,21 @@
+// src/providers/shared.ts
+function trimSnippet(input, maxLength = 300) {
+  const text = (input ?? "").replace(/\s+/g, " ").trim();
+  return text.length <= maxLength ? text : `${text.slice(0, maxLength - 1)}\u2026`;
+}
+function normalizeContentText(input) {
+  return (input ?? "").replace(/\r/g, "").trim().split("\n").map((line) => line.replace(/[ \t]+$/g, "")).join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function asJsonObject(value) {
+  return value ? { ...value } : {};
+}
+function formatJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+export {
+  trimSnippet,
+  normalizeContentText,
+  asJsonObject,
+  formatJson
+};

package/dist/chunk-YZXM4U2C.js

@@ -0,0 +1,21 @@
+import {
+  WebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// src/contents.ts
+function orderedContents(response) {
+  return {
+    provider: response.provider,
+    answers: response.answers.map((answer, inputIndex) => ({
+      ...answer,
+      inputIndex,
+      ...answer.error ? {
+        error: typeof answer.error === "string" ? new WebfoxError("PROVIDER_FAILURE", answer.error).toJSON() : answer.error
+      } : { error: void 0 }
+    }))
+  };
+}
+
+export {
+  orderedContents
+};

package/dist/chunk-ZVTVERW5.js

@@ -0,0 +1,20 @@
+// src/runtime/process.ts
+function killProcessGroup(child, signal) {
+  if (process.platform !== "win32" && child.pid) {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  child.kill(signal);
+}
+function cancelProcessGroup(child) {
+  killProcessGroup(child, "SIGTERM");
+  setTimeout(() => killProcessGroup(child, "SIGKILL"), 250);
+}
+
+export {
+  killProcessGroup,
+  cancelProcessGroup
+};