@absolutejs/rag 0.10.0 → 0.12.0

package/dist/src/web/evidence.d.ts

@@ -0,0 +1,24 @@
+export type WebLink = {
+    url: string;
+    label: string;
+};
+export type WebImage = {
+    url: string | null;
+    label: string;
+    context: string;
+};
+export type WebMedia = {
+    kind: "video" | "audio" | "embed" | "captions";
+    url: string;
+    label: string;
+};
+export type WebEvidence = {
+    links: WebLink[];
+    images: WebImage[];
+    media: WebMedia[];
+    canonicalUrl: string | null;
+};
+/** Preserve semantic evidence that visible body text omits. Labels are not verified customer relationships. */
+export declare const extractWebEvidence: (html: string, url: string) => WebEvidence;
+/** Navigation/footer text alone must not mask an empty or loading app root. */
+export declare const hasIncompleteAppContent: (html: string) => boolean;

package/dist/src/web/index.d.ts

@@ -0,0 +1,52 @@
+import { type WebEvidence } from "./evidence";
+import type { WebRedirect } from "./transport";
+export type { WebEvidence, WebLink, WebImage, WebMedia } from "./evidence";
+export type { WebRedirect } from "./transport";
+import { fetchPublicWebResource } from "./transport";
+export { fetchPublicWebResource, validatePublicWebUrl, isPublicWebAddress, WebReadError, } from "./transport";
+export type { WebFetchResult, WebFetchOptions } from "./transport";
+export type WebReadAttempt = {
+    method: "http" | "browser";
+    status: string;
+    httpStatus?: number;
+    extractedChars?: number;
+};
+export type WebReadResult = {
+    status: "ok" | "partial" | "error";
+    url: string;
+    finalUrl: string;
+    title: string | null;
+    text: string;
+    method: "http" | "browser";
+    truncated: boolean;
+    attempts: WebReadAttempt[];
+    error?: {
+        code: string;
+        message: string;
+    };
+    fetchedAt: string;
+    redirects: WebRedirect[];
+    evidence: WebEvidence;
+    limitations: string[];
+};
+export type WebRenderer = (url: string, options: {
+    signal: AbortSignal;
+}) => Promise<{
+    html: string;
+    text?: string;
+    url: string;
+    status: number;
+    redirects?: WebRedirect[];
+    settled?: boolean;
+}>;
+export type ReadWebpageOptions = {
+    url: string;
+    render?: WebRenderer;
+    signal?: AbortSignal;
+    maxChars?: number;
+    mode?: "auto" | "browser";
+    fetchResource?: typeof fetchPublicWebResource;
+};
+/** Read prepared evidence, escalating thin HTML shells to a host-supplied browser. */
+export declare const readRAGWebpage: (options: ReadWebpageOptions) => Promise<WebReadResult>;
+export { readRAGWebsite } from "./website";

package/dist/src/web/playwright.d.ts

@@ -0,0 +1,9 @@
+import type { WebRenderer } from "./index";
+/** Fresh contexts share a browser, never cookies; all HTTP traffic uses pinned public DNS. */
+export declare const createPlaywrightWebRenderer: (options?: {
+    executablePath?: string;
+}) => {
+    render: WebRenderer;
+    ready: () => Promise<void>;
+    close: () => Promise<void>;
+};

package/dist/src/web/transport.d.ts

@@ -0,0 +1,29 @@
+export declare class WebReadError extends Error {
+    code: string;
+    constructor(code: string, message: string);
+}
+export declare const isPublicWebAddress: (address: string) => boolean;
+export type WebRedirect = {
+    from: string;
+    to: string;
+    kind: "http" | "client";
+    status?: number;
+};
+export type WebFetchResult = {
+    redirects?: WebRedirect[];
+    url: string;
+    status: number;
+    headers: Record<string, string>;
+    body: Uint8Array;
+};
+export type WebFetchOptions = {
+    signal?: AbortSignal;
+    redirect?: "follow" | "manual";
+    maxBytes?: number;
+    method?: string;
+    body?: string;
+    headers?: Record<string, string>;
+};
+export declare const validatePublicWebUrl: (raw: string) => URL;
+/** Pin the validated DNS answer into the connection, including every redirect. */
+export declare const fetchPublicWebResource: (raw: string, options?: WebFetchOptions) => Promise<WebFetchResult>;

package/dist/src/web/website.d.ts

@@ -0,0 +1,52 @@
+import { type ReadWebpageOptions, type WebReadResult } from "./index";
+/** Bounded company research: preserve citations and follow relevant same-origin links. */
+export declare const readRAGWebsite: (options: ReadWebpageOptions & {
+    maxPages?: number;
+}) => Promise<{
+    status: WebReadResult["status"];
+    text: string;
+    truncated: boolean;
+    pages: {
+        status: "ok" | "partial" | "error";
+        url: string;
+        finalUrl: string;
+        title: string | null;
+        method: "http" | "browser";
+        truncated: boolean;
+        attempts: import("./index").WebReadAttempt[];
+        error?: {
+            code: string;
+            message: string;
+        };
+        fetchedAt: string;
+        redirects: import("./transport").WebRedirect[];
+        evidence: import("./evidence").WebEvidence;
+        limitations: string[];
+    }[];
+    captionEvidence: {
+        url: string;
+        text: string;
+        error?: string;
+    }[];
+    coverage: {
+        pagesRead: number;
+        pageLimit: number;
+        remainingRelevantLinks: string[];
+        deadlineReached: boolean;
+        exhaustive: boolean;
+    };
+    citationGuidance: string;
+    url: string;
+    finalUrl: string;
+    title: string | null;
+    method: "http" | "browser";
+    attempts: import("./index").WebReadAttempt[];
+    error?: {
+        code: string;
+        message: string;
+    };
+    fetchedAt: string;
+    redirects: import("./transport").WebRedirect[];
+    evidence: import("./evidence").WebEvidence;
+    limitations: string[];
+}>;