@jini-ai/platform 0.5.1 → 0.5.3

package/dist/secrets/credential-token.d.ts

@@ -0,0 +1,64 @@
+/** Shared credential validation; application detection policy is injected at the metadata boundary. */
+export declare const CREDENTIAL_TOKEN_LIMIT = 8192;
+export declare const CREDENTIAL_MESSAGES: {
+    readonly showSecret: "Show";
+    readonly hideSecret: "Hide";
+    readonly generationUnavailable: "Generation is not available yet for this provider.";
+    readonly secretValue: "Secret value";
+    readonly saveSecret: "Save secret";
+    readonly cancel: "Cancel";
+    readonly secretForm: "Enter the value in this secure form.";
+    readonly env: "Enter environment variables as NAME=VALUE lines or a JSON object of strings.";
+    readonly url: "The server URL must be a valid absolute URL.";
+    readonly set: "Access token set";
+    readonly storage: "The credential could not be saved or unlocked. Check the site credential store.";
+    readonly savedTitle: "Saved.";
+    readonly blank: "Enter a token. Spaces alone are not a token.";
+    readonly limit: "The token exceeds the 8192-character limit. Copy only the token.";
+    readonly ascii: "Hosted tokens must use visible ASCII characters (0x21–0x7E).";
+    readonly control: "The token contains an invalid control character.";
+    readonly plain: "Put credentials in the secret field, not in this field.";
+    readonly saved: "Saved, not tested.";
+    readonly connected: "Connected.";
+    readonly auth: "The server rejected this token.";
+    readonly timeout: "The connection timed out.";
+    readonly unreachable: "Could not reach the server.";
+    readonly chars: "{length} chars";
+};
+export type CredentialMessageId = keyof typeof CREDENTIAL_MESSAGES;
+/** Errors carry only a rule and field, never the submitted value. */
+export declare class CredentialInputError extends Error {
+    readonly rule: CredentialMessageId;
+    readonly field: string;
+    constructor(rule: CredentialMessageId, field: string);
+}
+/** Validate without normalizing: cards may call this before a probe; only the store trims. */
+export declare function assertCredentialToken({ value, field, hosted }: {
+    value: unknown;
+    field?: string;
+    hosted?: boolean;
+}, _optional?: {}): void;
+/** The single normalization boundary. Interior characters are never rewritten or truncated. */
+export declare function normalizeCredentialToken(required: {
+    value: unknown;
+    field?: string;
+    hosted?: boolean;
+}, _optional?: {}): string;
+export interface CredentialTokenHint {
+    length: number;
+    last4: string | null;
+}
+/** Call only on a server-side unsealed value; short tokens expose no characters. */
+export declare function credentialTokenHint({ token }: {
+    token: string;
+}, _optional?: {}): CredentialTokenHint;
+/** Protect plaintext metadata, using Jini's detector plus structural URL/CLI rules. */
+export declare function assertCredentialFreeField({ value, field, containsSecret }: {
+    value: string;
+    field: string;
+    containsSecret: (required: {
+        text: string;
+    }) => boolean;
+}, _optional?: {}): void;
+export type CredentialConnection = 'connected' | 'auth' | 'timeout' | 'unreachable' | 'saved';
+//# sourceMappingURL=credential-token.d.ts.map

package/dist/secrets/credential-token.js

@@ -0,0 +1,75 @@
+/** Shared credential validation; application detection policy is injected at the metadata boundary. */
+export const CREDENTIAL_TOKEN_LIMIT = 8192;
+export const CREDENTIAL_MESSAGES = {
+    showSecret: "Show",
+    hideSecret: "Hide",
+    generationUnavailable: "Generation is not available yet for this provider.",
+    secretValue: "Secret value",
+    saveSecret: "Save secret",
+    cancel: "Cancel",
+    secretForm: "Enter the value in this secure form.",
+    env: 'Enter environment variables as NAME=VALUE lines or a JSON object of strings.',
+    url: 'The server URL must be a valid absolute URL.',
+    set: 'Access token set',
+    storage: 'The credential could not be saved or unlocked. Check the site credential store.',
+    savedTitle: 'Saved.',
+    blank: 'Enter a token. Spaces alone are not a token.',
+    limit: 'The token exceeds the 8192-character limit. Copy only the token.',
+    ascii: 'Hosted tokens must use visible ASCII characters (0x21–0x7E).',
+    control: 'The token contains an invalid control character.',
+    plain: 'Put credentials in the secret field, not in this field.',
+    saved: 'Saved, not tested.',
+    connected: 'Connected.',
+    auth: 'The server rejected this token.',
+    timeout: 'The connection timed out.',
+    unreachable: 'Could not reach the server.',
+    chars: '{length} chars',
+};
+/** Errors carry only a rule and field, never the submitted value. */
+export class CredentialInputError extends Error {
+    rule;
+    field;
+    constructor(rule, field) {
+        super(CREDENTIAL_MESSAGES[rule]);
+        this.rule = rule;
+        this.field = field;
+        this.name = 'CredentialInputError';
+    }
+}
+/** Validate without normalizing: cards may call this before a probe; only the store trims. */
+export function assertCredentialToken({ value, field = 'token', hosted = true }, _optional = {}) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new CredentialInputError('blank', field);
+    // Validate the stored length, so incidental edge whitespace does not consume the token limit.
+    const token = value.trim();
+    if (token.length > CREDENTIAL_TOKEN_LIMIT)
+        throw new CredentialInputError('limit', field);
+    if (hosted && /[^\x21-\x7e]/.test(token))
+        throw new CredentialInputError('ascii', field);
+    if (/[\x00-\x1f\x7f-\x9f]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(token)) {
+        throw new CredentialInputError('control', field);
+    }
+}
+/** The single normalization boundary. Interior characters are never rewritten or truncated. */
+export function normalizeCredentialToken(required, _optional = {}) {
+    assertCredentialToken(required);
+    return required.value.trim();
+}
+/** Call only on a server-side unsealed value; short tokens expose no characters. */
+export function credentialTokenHint({ token }, _optional = {}) {
+    return { length: token.length, last4: token.length >= 12 ? token.slice(-4) : null };
+}
+const SECRET_NAME = /(?:^|[_-])(?:key|api[_-]?key|token|access[_-]?token|secret|password|auth|sig)$/i;
+const SECRET_ARG = /(?:^|\s)--[\w-]*(?:api[_-]?key|token|secret|password)(?:=|\s+)(?!\s*$)\S/i;
+/** Protect plaintext metadata, using Jini's detector plus structural URL/CLI rules. */
+export function assertCredentialFreeField({ value, field, containsSecret }, _optional = {}) {
+    let credential = containsSecret({ text: value }) || SECRET_ARG.test(value);
+    try {
+        const url = new URL(value);
+        credential ||= url.username !== '' || url.password !== '' || [...url.searchParams.keys()].some(key => SECRET_NAME.test(key));
+    }
+    catch { /* A label/argument is ordinarily not an absolute URL. */ }
+    if (credential)
+        throw new CredentialInputError('plain', field);
+}
+//# sourceMappingURL=credential-token.js.map

package/dist/secrets/index.d.ts

@@ -60,4 +60,5 @@ export type { GeneratedFileRootKey } from "./keyring.env.js";
 export { formatAad } from "./aad.js";
 export { defaultPlatformMessages } from "../messages.js";
 export type { PlatformMessages } from "../messages.js";
+export * from "./credential-token.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/secrets/index.js

@@ -32,4 +32,5 @@ export { deriveFromRootKey } from "./keyring.env.js"; // site-key-legacy: deprec
 export { deriveSigningSecretFromRootKey } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
 export { formatAad } from "./aad.js";
 export { defaultPlatformMessages } from "../messages.js";
+export * from "./credential-token.js";
 //# sourceMappingURL=index.js.map

package/dist/secrets/secret-sealer.aesgcm.d.ts

@@ -2,8 +2,14 @@ import type { KeyringPort, RootKeyHandle, SecretSealerPort } from "./ports.js";
 import type { SealedSecret } from "./types.js";
 export declare class AesGcmSecretSealer implements SecretSealerPort {
     private readonly keyring;
+    private readonly randomBytesFn;
+    /** Inject randomness for wire fixtures; production uses Node's CSPRNG for every fresh IV. */
     constructor({ keyring }: {
         keyring: KeyringPort;
+    }, optional?: {
+        randomBytesFn?: (input: {
+            byteLength: number;
+        }) => Uint8Array;
     });
     /** Encrypts under the requested generation with a fresh IV; AAD must be reconstructed on open. */
     seal(input: {

package/dist/secrets/secret-sealer.aesgcm.js

@@ -14,13 +14,20 @@ export class AesGcmSecretSealer {
     // Root keys stay behind handles, and the purpose separates this HKDF domain from signing/tokens.
     // Exercise real GCM with an in-memory keyring: a plaintext fake would miss authentication failures.
     keyring;
-    constructor({ keyring }) { this.keyring = keyring; }
+    randomBytesFn;
+    /** Inject randomness for wire fixtures; production uses Node's CSPRNG for every fresh IV. */
+    constructor({ keyring }, optional = {}) {
+        this.keyring = keyring;
+        this.randomBytesFn = optional.randomBytesFn ?? (({ byteLength }) => randomBytes(byteLength));
+    }
     /** Encrypts under the requested generation with a fresh IV; AAD must be reconstructed on open. */
     async seal(input) {
         if (typeof input.aad !== "string")
             throw new TypeError("AesGcmSecretSealer: aad must be a string");
         const aesKey = await this.deriveAesKey(input.key);
-        const iv = randomBytes(IV_LENGTH_BYTES);
+        const iv = Buffer.from(this.randomBytesFn({ byteLength: IV_LENGTH_BYTES }));
+        if (iv.length !== IV_LENGTH_BYTES)
+            throw new TypeError("AesGcmSecretSealer: IV must contain exactly 12 bytes");
         // GCM must never reuse an IV under the same key. AAD is authenticated but not stored in the
         // envelope, so callers must reconstruct the byte-identical context when opening the record.
         const cipher = createCipheriv(ALG, aesKey, iv);

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