@jini-ai/platform 0.5.2 → 0.5.4

package/dist/secrets/credential-sets/vault.types.d.ts

@@ -0,0 +1,151 @@
+import type { SealedSecret } from "../types.js";
+export declare const VAULT_KINDS: readonly ["site-assistant", "personal-execution", "media-provider", "custom", "publish-peer", "database-destination", "vendor", "source-control", "mcp-env", "mcp-auth"];
+export type VaultKind = typeof VAULT_KINDS[number];
+export type VaultJson = null | boolean | number | string | VaultJson[] | {
+    [key: string]: VaultJson;
+};
+export type VaultMeta = {
+    [key: string]: VaultJson;
+};
+export type VaultOptions = Record<string, never>;
+/** Expected ownership is supplied by the caller, never reconstructed from an untrusted row. */
+export interface VaultContext {
+    workspaceId: string;
+    kind: VaultKind;
+    ownerKey: string;
+    principalId: string | null;
+    /** Host-canonicalized endpoint/resource binding; null for credentials without such a binding. */
+    binding: string | null;
+}
+export interface VaultIdentity extends VaultContext {
+    id: string;
+}
+export interface VaultRecord extends VaultIdentity {
+    provider: string | null;
+    label: string;
+    isDefault: boolean;
+    revision: number;
+    sealed: SealedSecret | null;
+    last4: string | null;
+    tokenLength: number | null;
+    meta: VaultMeta;
+    createdAt: string;
+    updatedAt: string;
+}
+export type VaultSummary = Omit<VaultRecord, "sealed"> & {
+    configured: boolean;
+};
+export interface VaultQuery {
+    workspaceId: string;
+    kind: VaultKind;
+    ownerKey: string;
+    principalId: string | null;
+    provider?: string | null;
+}
+/** A default belongs to one exact group; omitted provider never means all providers. */
+export interface VaultDefaultQuery extends VaultQuery {
+    provider: string | null;
+}
+/** Singleton lookup ignores provider/default; omitted owner/principal leave that dimension unfiltered.
+ * Hosts enforce singleton cardinality for their kind/scope. No binding is inferred by the service.
+ */
+export interface VaultSingletonQuery {
+    workspaceId: string;
+    kind: VaultKind;
+    ownerKey?: string | undefined;
+    principalId?: string | null | undefined;
+}
+/** Ordered CAS operations; default side effects affect later operations' revisions. */
+export type VaultBatchOp = {
+    put: {
+        record: VaultRecord;
+        expectedRevision: number | null;
+    };
+} | {
+    delete: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+    };
+} | {
+    patchMeta: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+        patch: VaultMeta;
+        updatedAt: string;
+    };
+};
+export type VaultBatchResult = VaultRecord | boolean;
+export interface VaultCopyResult {
+    kind: VaultKind;
+    id: string;
+    status: "copied" | "skipped" | "failed";
+    last4?: string;
+    reasonCode?: VaultError["code"] | "source-needs-upgrade" | "source-missing" | "target-exists" | "kind-not-copyable" | "requires-mcp-configuration" | "copy-failed";
+}
+export type VaultMetaParser = (input: {
+    meta: unknown;
+}, options?: VaultOptions) => VaultMeta;
+export type VaultMetaParsers = Readonly<Record<VaultKind, VaultMetaParser>>;
+/** Safe error codes never contain submitted values or encrypted material. */
+export declare class VaultError extends Error {
+    readonly code: "conflict" | "context" | "invalid-meta" | "invalid-record";
+    constructor({ code }: {
+        code: VaultError["code"];
+    }, _options?: VaultOptions);
+}
+/** CAS is mandatory: null creates only; a number replaces/deletes only that revision.
+ * Defaults group by workspace/kind/owner/principal/provider. Every default change increments
+ * revision; promotion uses updatedAt descending, then id descending (binary UTF-8 order).
+ * All writes must join a host transaction when the adapter supports transaction composition.
+ */
+export interface VaultRepoPort {
+    find(input: {
+        workspaceId: string;
+        id: string;
+    }, options?: VaultOptions): Promise<VaultRecord | null>;
+    /** Indexed exact-group lookup; returns at most one row without listing its siblings.
+     * Optional for compatibility with pre-C1 ports; both built-in adapters implement it.
+     */
+    findDefault?(input: VaultDefaultQuery, options?: VaultOptions): Promise<VaultRecord | null>;
+    /** Optional additions keep older injected ports source-compatible; built-in adapters implement both. */
+    findOne?(input: VaultSingletonQuery, options?: VaultOptions): Promise<VaultRecord | null>;
+    /** All operations commit together or throw with no published changes. Default side effects
+     * follow operation order; a delete carries full expected ownership.
+     * SQL joins the host transaction: callers must propagate failures to roll that transaction back.
+     * @example await repo.applyBatch!({ ops: [{ put: { record, expectedRevision: null } }] });
+     */
+    applyBatch?(input: {
+        ops: readonly VaultBatchOp[];
+    }, options?: VaultOptions): Promise<VaultBatchResult[]>;
+    list(input: VaultQuery, options?: VaultOptions): Promise<VaultRecord[]>;
+    put(input: {
+        record: VaultRecord;
+        expectedRevision: number | null;
+    }, options?: VaultOptions): Promise<VaultRecord>;
+    /** Service-validated patch: top-level keys are plain JSON-path identifiers. */
+    patchMeta(input: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+        patch: VaultMeta;
+        updatedAt: string;
+    }, options?: VaultOptions): Promise<VaultRecord>;
+    delete(input: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+    }, options?: VaultOptions): Promise<boolean>;
+}
+/** Unambiguous scope encoding keeps adapter default/identity checks on the same contract. */
+export declare function vaultGroupKey({ record }: {
+    record: VaultRecord;
+}, _options?: VaultOptions): string;
+/** Adapters guard CAS and immutable identity even for callers below the service. */
+export declare function assertVaultReplacement({ record, existing, expectedRevision }: {
+    record: VaultRecord;
+    existing: VaultRecord | null;
+    expectedRevision: number | null;
+}, _options?: VaultOptions): void;
+//# sourceMappingURL=vault.types.d.ts.map

package/dist/secrets/credential-sets/vault.types.js

@@ -0,0 +1,28 @@
+export const VAULT_KINDS = ["site-assistant", "personal-execution", "media-provider", "custom", "publish-peer",
+    "database-destination", "vendor", "source-control", "mcp-env", "mcp-auth"];
+/** Safe error codes never contain submitted values or encrypted material. */
+export class VaultError extends Error {
+    code;
+    constructor({ code }, _options = {}) {
+        super(`Secrets vault: ${code}`);
+        this.code = code;
+        this.name = "VaultError";
+    }
+}
+/** Unambiguous scope encoding keeps adapter default/identity checks on the same contract. */
+export function vaultGroupKey({ record }, _options = {}) {
+    return JSON.stringify([record.workspaceId, record.kind, record.ownerKey, record.principalId, record.provider]);
+}
+/** Adapters guard CAS and immutable identity even for callers below the service. */
+export function assertVaultReplacement({ record, existing, expectedRevision }, _options = {}) {
+    if (expectedRevision === null ? existing !== null : existing?.revision !== expectedRevision)
+        throw new VaultError({ code: "conflict" });
+    if (!Number.isSafeInteger(record.revision) || record.revision !== (expectedRevision ?? 0) + 1)
+        throw new VaultError({ code: "invalid-record" });
+    // Provider groups defaults, but is not authenticated identity (see buildVaultAad).
+    if (existing && (record.workspaceId !== existing.workspaceId || record.kind !== existing.kind ||
+        record.ownerKey !== existing.ownerKey || record.principalId !== existing.principalId ||
+        record.id !== existing.id || record.binding !== existing.binding || record.createdAt !== existing.createdAt))
+        throw new VaultError({ code: "context" });
+}
+//# sourceMappingURL=vault.types.js.map

package/dist/secrets/testing.d.ts

@@ -1,4 +1,3 @@
 export { InMemoryKeyring } from "./keyring.memory.js";
 export { FixedRootKeyKeyring } from "./keyring.env.js";
-export { InMemoryVendorCredentialSetRepo } from "./credential-sets/repo.memory.js";
 //# sourceMappingURL=testing.d.ts.map

package/dist/secrets/testing.js

@@ -1,4 +1,3 @@
 export { InMemoryKeyring } from "./keyring.memory.js";
 export { FixedRootKeyKeyring } from "./keyring.env.js";
-export { InMemoryVendorCredentialSetRepo } from "./credential-sets/repo.memory.js";
 //# sourceMappingURL=testing.js.map

package/dist/web/html-document.d.ts

@@ -0,0 +1,70 @@
+import { type DefaultTreeAdapterMap } from "parse5";
+type Element = DefaultTreeAdapterMap["element"];
+export interface PageLink {
+    href: string;
+    text: string;
+    internal: boolean;
+}
+export interface PageImage {
+    src: string;
+    alt: string;
+}
+export interface HtmlDocumentFacts {
+    title?: string;
+    description?: string;
+    lang?: string;
+    links: PageLink[];
+    linksTruncated: boolean;
+    images: PageImage[];
+    imagesTruncated: boolean;
+    stylesheets: string[];
+    meta: Record<string, string>;
+}
+export declare const MAX_LINKS = 500;
+export declare const MAX_IMAGES = 300;
+export declare const LINK_PROTOCOLS: ReadonlySet<string>;
+export declare const ASSET_PROTOCOLS: ReadonlySet<string>;
+export declare function attr({ element, name }: {
+    element: Element;
+    name: string;
+}, _optional?: Record<string, never>): string | undefined;
+/** Resolves against `base`; drops fragment-only, unparseable and other-protocol values, and fragments. */
+export declare function absolute({ raw, base, protocols }: {
+    raw: string | undefined;
+    base: string;
+    protocols: ReadonlySet<string>;
+}, _optional?: Record<string, never>): string | undefined;
+/** First usable image URL: lazy loaders park the real one in `data-src` behind a `data:` placeholder. */
+export declare function imageSource({ img }: {
+    img: Element;
+}, _optional?: Record<string, never>): string | undefined;
+/**
+ * Extracts page facts. Relative URLs resolve against `<base href>` (itself resolved against the page
+ * URL) so links match what a browser would follow.
+ * @param required.html - Decoded page source; untrusted.
+ * @param required.pageUrl - The final URL the HTML was served from (after redirects).
+ * @returns Facts with every URL absolute; links deduped (fragment-free) and capped at {@link MAX_LINKS},
+ *   images at {@link MAX_IMAGES}; `internal` ignores a leading `www.`.
+ * @complexity O(nodes) plus O(anchor subtree) per anchor for its text.
+ */
+export declare function readHtmlDocument({ html, pageUrl }: {
+    html: string;
+    pageUrl: string;
+}, _optional?: Record<string, never>): HtmlDocumentFacts;
+/**
+ * Visible text with one line per block element; scripts, styles, `<head>`, SVG and embeds omitted.
+ * @complexity O(nodes).
+ */
+export declare function htmlToText({ html }: {
+    html: string;
+}, _optional?: Record<string, never>): string;
+/**
+ * The page HTML with `<script>`, `<noscript>`, `<template>`, comments, `on*` handler attributes and
+ * `javascript:` attribute values removed (styles and classes kept: theming needs them). Re-serialized by parse5, so it is well-formed rather than byte-identical.
+ * @complexity O(nodes).
+ */
+export declare function stripActiveHtml({ html }: {
+    html: string;
+}, _optional?: Record<string, never>): string;
+export {};
+//# sourceMappingURL=html-document.d.ts.map

package/dist/web/html-document.js

@@ -0,0 +1,268 @@
+import { parse, serialize } from "parse5";
+export const MAX_LINKS = 500;
+export const MAX_IMAGES = 300;
+const MAX_STYLESHEETS = 100;
+const MAX_META = 60;
+const MAX_LINK_TEXT = 200;
+const MAX_META_VALUE = 500;
+export const LINK_PROTOCOLS = new Set(["http:", "https:", "mailto:", "tel:"]);
+export const ASSET_PROTOCOLS = new Set(["http:", "https:"]);
+/** Never visible and never page content; removed from the text and the returned HTML copy. */
+const STRIPPED = new Set(["script", "noscript", "template"]);
+/** Not visible text either, but `style` stays in the HTML copy because theming needs it. */
+const INVISIBLE = new Set([...STRIPPED, "style", "head", "svg", "iframe", "object", "canvas"]);
+const BLOCKS = new Set(["address", "article", "aside", "blockquote", "br", "dd", "div", "dl", "dt", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hr", "li", "main", "nav", "ol", "p", "pre", "section", "table", "td", "th", "tr", "ul"]);
+/** `meta name=` keys worth returning; every `og:*` property is returned as well. */
+const META_NAMES = new Set(["generator", "theme-color", "author", "keywords", "twitter:title", "twitter:description", "twitter:image", "application-name"]);
+export function attr({ element, name }, _optional = {}) {
+    return element.attrs.find(a => a.name === name)?.value;
+}
+function isElement(node) {
+    return "tagName" in node;
+}
+/** Iterative pre-order walk: deeply nested hostile HTML cannot overflow the stack. O(nodes). */
+function* walk(root) {
+    const pending = [root];
+    while (pending.length) {
+        const node = pending.pop();
+        yield node;
+        // Read after the yield on purpose: stripActiveHtml filters childNodes in between.
+        const children = "childNodes" in node ? node.childNodes : [];
+        for (let i = children.length - 1; i >= 0; i--)
+            pending.push(children[i]);
+    }
+}
+function collapse(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function textOf(root) {
+    const parts = [];
+    for (const node of walk(root))
+        if (node.nodeName === "#text" && "value" in node)
+            parts.push(node.value);
+    return collapse(parts.join(" "));
+}
+/** Resolves against `base`; drops fragment-only, unparseable and other-protocol values, and fragments. */
+export function absolute({ raw, base, protocols }, _optional = {}) {
+    const value = raw?.trim();
+    if (!value || value.startsWith("#"))
+        return undefined;
+    let url;
+    try {
+        url = new URL(value, base);
+    }
+    catch {
+        return undefined;
+    }
+    if (!protocols.has(url.protocol))
+        return undefined;
+    if (url.protocol === "http:" || url.protocol === "https:")
+        url.hash = "";
+    return url.href;
+}
+function siteHost(hostname) {
+    return hostname.toLowerCase().replace(/^www\./, "");
+}
+function isInternal(href, pageHost) {
+    const url = new URL(href);
+    return (url.protocol === "http:" || url.protocol === "https:") && siteHost(url.hostname) === pageHost;
+}
+function linkText(anchor) {
+    const text = textOf(anchor) || attr({ element: anchor, name: "aria-label" }) || attr({ element: anchor, name: "title" }) || "";
+    if (text)
+        return collapse(text).slice(0, MAX_LINK_TEXT);
+    for (const node of walk(anchor))
+        if (isElement(node) && node.tagName === "img")
+            return collapse(attr({ element: node, name: "alt" }) ?? "").slice(0, MAX_LINK_TEXT);
+    return "";
+}
+/** First usable image URL: lazy loaders park the real one in `data-src` behind a `data:` placeholder. */
+export function imageSource({ img }, _optional = {}) {
+    const src = attr({ element: img, name: "src" });
+    if (src && !src.trim().startsWith("data:"))
+        return src;
+    return attr({ element: img, name: "data-src" }) ?? attr({ element: img, name: "data-lazy-src" }) ?? attr({ element: img, name: "srcset" })?.trim().split(/\s+/)[0];
+}
+function collect(document) {
+    const raw = { anchors: [], images: [], linkTags: [], metas: [] };
+    for (const node of walk(document)) {
+        if (!isElement(node))
+            continue;
+        switch (node.tagName) {
+            case "a":
+                raw.anchors.push(node);
+                break;
+            case "img":
+                raw.images.push(node);
+                break;
+            case "link":
+                raw.linkTags.push(node);
+                break;
+            case "meta":
+                raw.metas.push(node);
+                break;
+            case "title":
+                raw.title ??= node;
+                break;
+            case "html":
+                raw.html ??= node;
+                break;
+            case "base":
+                raw.base ??= attr({ element: node, name: "href" });
+                break;
+        }
+    }
+    return raw;
+}
+function readMeta(raw, base) {
+    const meta = {};
+    const put = (key, value) => {
+        if (value === undefined || key in meta || Object.keys(meta).length >= MAX_META)
+            return;
+        meta[key] = collapse(value).slice(0, MAX_META_VALUE);
+    };
+    for (const element of raw.metas) {
+        const property = attr({ element, name: "property" })?.toLowerCase();
+        const name = attr({ element, name: "name" })?.toLowerCase();
+        const content = attr({ element, name: "content" });
+        if (property?.startsWith("og:"))
+            put(property, property === "og:image" || property === "og:url" ? absolute({ raw: content, base, protocols: ASSET_PROTOCOLS }) : content);
+        else if (name && META_NAMES.has(name))
+            put(name, name === "twitter:image" ? absolute({ raw: content, base, protocols: ASSET_PROTOCOLS }) : content);
+    }
+    for (const element of raw.linkTags) {
+        const rel = (attr({ element, name: "rel" }) ?? "").toLowerCase().split(/\s+/);
+        const href = absolute({ raw: attr({ element, name: "href" }), base, protocols: ASSET_PROTOCOLS });
+        if (rel.includes("canonical"))
+            put("canonical", href);
+        if (rel.includes("icon"))
+            put("favicon", href);
+        if (rel.includes("apple-touch-icon"))
+            put("apple-touch-icon", href);
+    }
+    return meta;
+}
+function readLinks(anchors, base, pageHost) {
+    const seen = new Set();
+    const links = [];
+    let truncated = false;
+    for (const anchor of anchors) {
+        const href = absolute({ raw: attr({ element: anchor, name: "href" }), base, protocols: LINK_PROTOCOLS });
+        if (!href || seen.has(href))
+            continue;
+        seen.add(href);
+        if (links.length === MAX_LINKS) {
+            truncated = true;
+            break;
+        }
+        links.push({ href, text: linkText(anchor), internal: isInternal(href, pageHost) });
+    }
+    return { links, truncated };
+}
+function readImages(images, base) {
+    const seen = new Set();
+    const out = [];
+    let truncated = false;
+    for (const img of images) {
+        const src = absolute({ raw: imageSource({ img }), base, protocols: ASSET_PROTOCOLS });
+        if (!src || seen.has(src))
+            continue;
+        seen.add(src);
+        if (out.length === MAX_IMAGES) {
+            truncated = true;
+            break;
+        }
+        out.push({ src, alt: collapse(attr({ element: img, name: "alt" }) ?? "") });
+    }
+    return { images: out, truncated };
+}
+function readStylesheets(linkTags, base) {
+    const out = new Set();
+    for (const element of linkTags) {
+        const rel = (attr({ element, name: "rel" }) ?? "").toLowerCase().split(/\s+/);
+        const href = absolute({ raw: attr({ element, name: "href" }), base, protocols: ASSET_PROTOCOLS });
+        if (rel.includes("stylesheet") && href && out.size < MAX_STYLESHEETS)
+            out.add(href);
+    }
+    return [...out];
+}
+/**
+ * Extracts page facts. Relative URLs resolve against `<base href>` (itself resolved against the page
+ * URL) so links match what a browser would follow.
+ * @param required.html - Decoded page source; untrusted.
+ * @param required.pageUrl - The final URL the HTML was served from (after redirects).
+ * @returns Facts with every URL absolute; links deduped (fragment-free) and capped at {@link MAX_LINKS},
+ *   images at {@link MAX_IMAGES}; `internal` ignores a leading `www.`.
+ * @complexity O(nodes) plus O(anchor subtree) per anchor for its text.
+ */
+export function readHtmlDocument({ html, pageUrl }, _optional = {}) {
+    const document = parse(html);
+    const raw = collect(document);
+    const base = absolute({ raw: raw.base, base: pageUrl, protocols: ASSET_PROTOCOLS }) ?? pageUrl;
+    const pageHost = siteHost(new URL(pageUrl).hostname);
+    const links = readLinks(raw.anchors, base, pageHost);
+    const images = readImages(raw.images, base);
+    const description = raw.metas.find(m => attr({ element: m, name: "name" })?.toLowerCase() === "description");
+    const title = raw.title ? textOf(raw.title) : "";
+    const lang = raw.html ? attr({ element: raw.html, name: "lang" })?.trim() : undefined;
+    const descriptionText = description ? collapse(attr({ element: description, name: "content" }) ?? "") : "";
+    return {
+        ...(title ? { title } : {}),
+        ...(descriptionText ? { description: descriptionText } : {}),
+        ...(lang ? { lang } : {}),
+        links: links.links, linksTruncated: links.truncated,
+        images: images.images, imagesTruncated: images.truncated,
+        stylesheets: readStylesheets(raw.linkTags, base),
+        meta: readMeta(raw, base),
+    };
+}
+/**
+ * Visible text with one line per block element; scripts, styles, `<head>`, SVG and embeds omitted.
+ * @complexity O(nodes).
+ */
+export function htmlToText({ html }, _optional = {}) {
+    const pending = [parse(html)];
+    const out = [];
+    while (pending.length) {
+        const node = pending.pop();
+        if (node === "\n") {
+            out.push("\n");
+            continue;
+        }
+        if (isElement(node) && INVISIBLE.has(node.tagName))
+            continue;
+        if (node.nodeName === "#text" && "value" in node) {
+            out.push(node.value);
+            continue;
+        }
+        if (!("childNodes" in node))
+            continue;
+        const block = isElement(node) && BLOCKS.has(node.tagName);
+        if (block) {
+            out.push("\n");
+            pending.push("\n");
+        }
+        for (let i = node.childNodes.length - 1; i >= 0; i--)
+            pending.push(node.childNodes[i]);
+    }
+    return out.join("").split("\n").map(line => line.replace(/[^\S\n]+/g, " ").trim()).filter(Boolean).join("\n");
+}
+/**
+ * The page HTML with `<script>`, `<noscript>`, `<template>`, comments, `on*` handler attributes and
+ * `javascript:` attribute values removed (styles and classes kept: theming needs them). Re-serialized by parse5, so it is well-formed rather than byte-identical.
+ * @complexity O(nodes).
+ */
+export function stripActiveHtml({ html }, _optional = {}) {
+    const document = parse(html);
+    for (const node of walk(document)) {
+        if (!("childNodes" in node))
+            continue;
+        const parent = node;
+        parent.childNodes = parent.childNodes.filter(child => child.nodeName !== "#comment" && !(isElement(child) && STRIPPED.has(child.tagName)));
+        // Inert copy: an agent may paste this into a page, so handlers and script URLs never survive.
+        if (isElement(node))
+            node.attrs = node.attrs.filter(a => !/^on/i.test(a.name) && !/^\s*javascript:/i.test(a.value));
+    }
+    return serialize(document);
+}
+//# sourceMappingURL=html-document.js.map

package/dist/web/html-resource.d.ts

@@ -0,0 +1,15 @@
+/** Bound synchronous HTML parsers independently of the HTTP response byte limit. */
+export declare const MAX_HTML_CHARS = 1000000;
+/** Return a bounded prefix without splitting UTF-16; fetch projections expose its truncation flag.
+ * The caller may supply a lower projection budget; direct conversion always has a fixed ceiling.
+ * O(1) decision plus O(cap) prefix allocation; raw body output keeps its separate transport cap.
+ */
+export declare function boundHtml({ html }: {
+    html: string;
+}, { maxChars }?: {
+    maxChars?: number;
+}): {
+    html: string;
+    truncated: boolean;
+};
+//# sourceMappingURL=html-resource.d.ts.map

package/dist/web/html-resource.js

@@ -0,0 +1,12 @@
+/** Bound synchronous HTML parsers independently of the HTTP response byte limit. */
+export const MAX_HTML_CHARS = 1_000_000;
+/** Return a bounded prefix without splitting UTF-16; fetch projections expose its truncation flag.
+ * The caller may supply a lower projection budget; direct conversion always has a fixed ceiling.
+ * O(1) decision plus O(cap) prefix allocation; raw body output keeps its separate transport cap.
+ */
+export function boundHtml({ html }, { maxChars = MAX_HTML_CHARS } = {}) {
+    const limit = Math.min(MAX_HTML_CHARS, maxChars);
+    const end = /[\uDC00-\uDFFF]/.test(html[limit] ?? "") ? limit - 1 : limit;
+    return html.length > limit ? { html: html.slice(0, end), truncated: true } : { html, truncated: false };
+}
+//# sourceMappingURL=html-resource.js.map

package/dist/web/html-to-markdown.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Convert untrusted HTML to readable Markdown with absolute, allowlisted link/image URLs.
+ * @returns Markdown without surrounding whitespace; input is capped before parsing and errors propagate.
+ * @complexity O(nodes + output size) time/space for ordinary pages; nesting is bounded at 300.
+ * @example htmlToMarkdown({ html: "<h1>Hello</h1>", pageUrl: "https://example.com/" })
+ */
+export declare function htmlToMarkdown({ html, pageUrl }: {
+    html: string;
+    pageUrl: string;
+}, _optional?: Record<string, never>): string;
+//# sourceMappingURL=html-to-markdown.d.ts.map