@recursiv/sdk 0.7.82 → 0.7.89

package/dist/assistant/hiddenText.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Text a reader cannot see is text a model must not be given: an instruction hidden in a zero-width run, in Unicode
+ * tag characters, behind a direction override, in an HTML comment or a hidden element, or in markdown that renders as
+ * nothing. Pure string work (no DOM, no Node APIs), so a phone builds the same bundle the server does.
+ */
+/** The longest raw string read. Hidden padding past it is never scanned. */
+export declare const HIDDEN_TEXT_SCAN_LIMIT = 100000;
+/**
+ * `text` without controls (but tab and newline) and default-ignorable characters, so a zero-width run inside a word
+ * cannot split it. Line breaks become '\n'. Markup is left as written: a member's own message is read in full.
+ */
+export declare function removeInvisibleCharacters(text: string): string;
+/**
+ * `text` as a reader sees it: no controls, no default-ignorable characters (zero-width, bidi, tags, variation
+ * selectors), no HTML comments or hidden elements, no invisible markdown, and pictures as their alt text. Line breaks
+ * become '\n'. Spacing is left to the caller.
+ */
+export declare function stripHiddenText(text: string): string;
+/** Every web address in `text`, in order, each once. */
+export declare function findUrls(text: string): string[];
+/** `text` with each web address in it passed through `replace`; the punctuation after one is kept. */
+export declare function mapUrls(text: string, replace: (url: string) => string): string;
+/** Every @handle in `text` (without the @), in order, each once. */
+export declare function findHandles(text: string): string[];

package/dist/assistant/hiddenText.js

@@ -0,0 +1,263 @@
+/**
+ * Text a reader cannot see is text a model must not be given: an instruction hidden in a zero-width run, in Unicode
+ * tag characters, behind a direction override, in an HTML comment or a hidden element, or in markdown that renders as
+ * nothing. Pure string work (no DOM, no Node APIs), so a phone builds the same bundle the server does.
+ */
+/**
+ * Every character Unicode calls default-ignorable (DerivedCoreProperties.txt, Default_Ignorable_Code_Point), as
+ * ranges: soft hyphen, grapheme joiner, Arabic letter mark, Hangul fillers, Khmer inherent vowels, Mongolian variation
+ * selectors, zero-width spaces and joiners, direction marks, embeddings and isolates, word joiner and invisible
+ * operators, variation selectors, the BOM and the tag characters. Written out because Hermes is not known to take
+ * `\p{Default_Ignorable_Code_Point}` (the same list as minds' lib/chatRecipientTargets.ts).
+ */
+const DEFAULT_IGNORABLE = [
+    [0x00ad, 0x00ad], [0x034f, 0x034f], [0x061c, 0x061c], [0x115f, 0x1160], [0x17b4, 0x17b5],
+    [0x180b, 0x180f], [0x200b, 0x200f], [0x202a, 0x202e], [0x2060, 0x206f], [0x3164, 0x3164],
+    [0xfe00, 0xfe0f], [0xfeff, 0xfeff], [0xffa0, 0xffa0], [0xfff0, 0xfff8], [0x1bca0, 0x1bca3],
+    [0x1d173, 0x1d17a], [0xe0000, 0xe0fff],
+];
+function isDefaultIgnorable(point) {
+    return DEFAULT_IGNORABLE.some(([from, to]) => point >= from && point <= to);
+}
+const INVISIBLE = new RegExp(`[${DEFAULT_IGNORABLE.map(([from, to]) => `\\u{${from.toString(16)}}-\\u{${to.toString(16)}}`).join('')}]`, 'gu');
+/** C0 and C1 controls and DEL, except tab and newline. */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: removing control characters is the point
+const CONTROLS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g;
+/** Line breaks in every spelling, read as one newline. */
+const LINE_BREAKS = /\r\n?|[\u0085\u2028\u2029]/g;
+/**
+ * A numeric character reference (the semicolon is optional to a browser), and the named ones that stand for an
+ * invisible character. Minds shows text after one entity decode, so `&#xE0069;` is as invisible as the tag character.
+ */
+const NUMERIC_REFERENCE = /&#(?:[xX]([0-9A-Fa-f]{1,8})|([0-9]{1,10}));?/g;
+const INVISIBLE_NAMED_REFERENCE = /&(?:shy;?|(?:zwj|zwnj|lrm|rlm|ZeroWidthSpace|NegativeVeryThinSpace|NegativeThinSpace|NegativeMediumSpace|NegativeThickSpace|NoBreak|ApplyFunction|af|InvisibleTimes|it|InvisibleComma|ic);)/g;
+/** A C0 control or DEL a reference may spell, except tab, newline and carriage return (and NUL, shown as U+FFFD). */
+function isReferencedControl(point) {
+    return (point >= 0x01 && point <= 0x08) || point === 0x0b || point === 0x0c || (point >= 0x0e && point <= 0x1f) || point === 0x7f;
+}
+/** Character references to invisible characters and controls are dropped; every other reference is left as written. */
+function removeInvisibleReferences(text) {
+    if (!text.includes('&'))
+        return text;
+    return text
+        .replace(NUMERIC_REFERENCE, (reference, hex, decimal) => {
+        const point = hex !== undefined ? Number.parseInt(hex, 16) : Number.parseInt(decimal, 10);
+        return isDefaultIgnorable(point) || isReferencedControl(point) ? '' : reference;
+    })
+        .replace(INVISIBLE_NAMED_REFERENCE, '');
+}
+/** Elements whose content a browser never shows as text. */
+const HIDDEN_ELEMENTS = new Set([
+    'script', 'style', 'template', 'noscript', 'head', 'title', 'iframe', 'object', 'embed', 'svg', 'datalist',
+    'audio', 'video', 'meta', 'link', 'source', 'track',
+]);
+/** Elements with no closing tag. */
+const VOID_ELEMENTS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr',
+]);
+/** `hidden` as an attribute: after a space or a solidus (`<div/hidden>`), which a browser reads as a separator. */
+const HIDDEN_ATTRIBUTE = /(?:^|[\s/])hidden(?:[\s=/]|$)/i;
+const HIDDEN_INPUT = /\btype\s*=\s*["']?hidden\b/i;
+/**
+ * A style attribute's value, quoted or not: `style=display:none` is valid HTML. A quote left open runs to the end of
+ * the tag, so an unclosed value is still read.
+ */
+const STYLE_ATTRIBUTE = /(?:^|[\s/])style\s*=\s*(?:"([^"]*)(?:"|$)|'([^']*)(?:'|$)|([^\s"'<>`]+))/gi;
+/** A declaration that hides what it styles. */
+const HIDDEN_DECLARATION = /display\s*:\s*none|visibility\s*:\s*(?:hidden|collapse)|font-size\s*:\s*0(?:\.0+)?(?:px|pt|em|rem|%)?\s*(?:;|!|$)|opacity\s*:\s*0(?:\.0+)?\s*(?:;|!|$)|color\s*:\s*transparent/i;
+/** An opening tag. Attributes stop at the next angle bracket, so the scan stays linear. */
+const OPEN_TAG = /<([A-Za-z][A-Za-z0-9-]{0,31})\b([^<>]{0,4000})>/g;
+/** An opening or closing tag, to find where a hidden element ends. */
+const ANY_TAG = /<(\/?)([A-Za-z][A-Za-z0-9-]{0,31})\b[^<>]{0,4000}>/g;
+const IMG_TAG = /<img\b([^<>]{0,4000})>/gi;
+const ALT_ATTRIBUTE = /\balt\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i;
+function removeHtmlComments(text) {
+    let out = '';
+    let from = 0;
+    for (;;) {
+        const start = text.indexOf('<!--', from);
+        if (start < 0)
+            return out + text.slice(from);
+        out += text.slice(from, start);
+        const end = text.indexOf('-->', start + 4);
+        // An unclosed comment hides everything after it.
+        if (end < 0)
+            return out;
+        from = end + 3;
+    }
+}
+/** Whether any style attribute on the tag hides it. Every one is read, so a second attribute cannot slip by. */
+function hasHiddenStyle(attributes) {
+    if (!/style/i.test(attributes))
+        return false;
+    for (const match of attributes.matchAll(STYLE_ATTRIBUTE)) {
+        if (HIDDEN_DECLARATION.test(match[1] ?? match[2] ?? match[3] ?? ''))
+            return true;
+    }
+    return false;
+}
+function isHiddenElement(name, attributes) {
+    return HIDDEN_ELEMENTS.has(name)
+        || HIDDEN_ATTRIBUTE.test(attributes)
+        || hasHiddenStyle(attributes)
+        || (name === 'input' && HIDDEN_INPUT.test(attributes));
+}
+/** Where the element opened before `from` ends: after its matching closing tag, or the end of the text. */
+function closingEnd(text, from, name) {
+    ANY_TAG.lastIndex = from;
+    let depth = 1;
+    for (let match = ANY_TAG.exec(text); match; match = ANY_TAG.exec(text)) {
+        if (match[2].toLowerCase() !== name)
+            continue;
+        if (match[1])
+            depth -= 1;
+        else if (!/\/\s*>$/.test(match[0]))
+            depth += 1;
+        if (depth === 0)
+            return ANY_TAG.lastIndex;
+    }
+    // An unclosed hidden element hides everything after it.
+    return text.length;
+}
+function removeHiddenElements(text) {
+    if (!text.includes('<'))
+        return text;
+    let out = '';
+    let last = 0;
+    OPEN_TAG.lastIndex = 0;
+    for (let match = OPEN_TAG.exec(text); match; match = OPEN_TAG.exec(text)) {
+        const name = match[1].toLowerCase();
+        const attributes = match[2];
+        if (!isHiddenElement(name, attributes))
+            continue;
+        out += text.slice(last, match.index);
+        const selfClosing = VOID_ELEMENTS.has(name) || /\/\s*$/.test(attributes);
+        last = selfClosing ? OPEN_TAG.lastIndex : closingEnd(text, OPEN_TAG.lastIndex, name);
+        OPEN_TAG.lastIndex = last;
+    }
+    return out + text.slice(last);
+}
+const imageLabel = (alt) => {
+    const words = (alt ?? '').replace(/\s+/g, ' ').trim();
+    return words ? `[image: ${words}]` : '';
+};
+/** An HTML picture is its alt text, never its address. */
+function replaceHtmlImages(text) {
+    if (!text.includes('<'))
+        return text;
+    return text.replace(IMG_TAG, (_tag, attributes) => {
+        const alt = ALT_ATTRIBUTE.exec(attributes);
+        return imageLabel(alt ? (alt[1] ?? alt[2] ?? alt[3]) : undefined);
+    });
+}
+/** How deep parentheses inside a link target or a web address are read as part of it. */
+const PAREN_DEPTH = 4;
+/** `character`, or a run of them in parentheses, nested up to PAREN_DEPTH deep: `a(1).jpg`, `Foo_(bar)`. */
+function balanced(character) {
+    let pattern = `(?:${character})`;
+    for (let level = 0; level < PAREN_DEPTH; level += 1)
+        pattern = `(?:${character}|\\((?:${pattern})*\\))`;
+    return pattern;
+}
+/**
+ * A markdown link target: `<anything on one line>`, or a run with no spaces whose parentheses balance, as CommonMark
+ * reads `![alt](https://cdn.example/a(1).jpg)`. A backslash escapes the character after it.
+ */
+const TARGET = String.raw `<[^<>\n]{0,4000}>|${balanced(String.raw `[^\s()\\]|\\\S`)}{0,4000}`;
+/** A markdown link title, in any of its three quotings. */
+const TITLE = String.raw `(?:"[^"\n]{0,1000}"|'[^'\n]{0,1000}'|\([^()\n]{0,1000}\))`;
+/** `(target "title")` after a link's or picture's brackets. The bounded classes keep every scan linear. */
+const DESTINATION = String.raw `\([ \t]*(?:${TARGET})(?:[ \t]+${TITLE})?[ \t]*\)`;
+/**
+ * Markdown that renders as nothing, or as a picture: link reference definitions (also the `[//]: # (note)` comment
+ * idiom; footnotes `[^1]:` show and stay), empty links, link titles (shown only on hover), and pictures, which become
+ * their alt text with no address.
+ *
+ * A reference definition is only a whole line of `[label]:`, one destination and an optional quoted title, as
+ * CommonMark has it. "[EDIT]: the vote moved to Tuesday" is words a reader sees, and stays.
+ */
+const REFERENCE_DEFINITION = /^ {0,3}\[(?!\^)[^[\]\n]{1,999}\]:[ \t]*(?:<[^<>\n]{0,4000}>|[^\s<]\S{0,4000})(?:[ \t]+(?:"[^"\n]{0,1000}"|'[^'\n]{0,1000}'|\([^()\n]{0,1000}\)))?[ \t]*(?:\n|$)/gm;
+const MARKDOWN_IMAGE = new RegExp(`!\\[([^[\\]\\n]{0,1000})\\]${DESTINATION}`, 'g');
+const MARKDOWN_IMAGE_REFERENCE = /!\[([^[\]\n]{0,1000})\]\[[^[\]\n]{0,1000}\]/g;
+const EMPTY_LINK = new RegExp(`\\[[ \\t]*\\]${DESTINATION}`, 'g');
+const TITLED_LINK = new RegExp(`\\[([^[\\]\\n]{1,1000})\\]\\([ \\t]*(${TARGET})[ \\t]+${TITLE}[ \\t]*\\)`, 'g');
+function removeInvisibleMarkdown(text) {
+    if (!text.includes('['))
+        return text;
+    return text
+        .replace(REFERENCE_DEFINITION, '')
+        .replace(MARKDOWN_IMAGE, (_image, alt) => imageLabel(alt))
+        .replace(MARKDOWN_IMAGE_REFERENCE, (_image, alt) => imageLabel(alt))
+        .replace(EMPTY_LINK, '')
+        .replace(TITLED_LINK, '[$1]($2)');
+}
+/** The longest raw string read. Hidden padding past it is never scanned. */
+export const HIDDEN_TEXT_SCAN_LIMIT = 100_000;
+/**
+ * `text` without controls (but tab and newline) and default-ignorable characters, so a zero-width run inside a word
+ * cannot split it. Line breaks become '\n'. Markup is left as written: a member's own message is read in full.
+ */
+export function removeInvisibleCharacters(text) {
+    if (typeof text !== 'string' || !text)
+        return '';
+    return text.replace(LINE_BREAKS, '\n').replace(CONTROLS, '').replace(INVISIBLE, '');
+}
+/**
+ * `text` as a reader sees it: no controls, no default-ignorable characters (zero-width, bidi, tags, variation
+ * selectors), no HTML comments or hidden elements, no invisible markdown, and pictures as their alt text. Line breaks
+ * become '\n'. Spacing is left to the caller.
+ */
+export function stripHiddenText(text) {
+    if (typeof text !== 'string' || !text)
+        return '';
+    let out = text.length > HIDDEN_TEXT_SCAN_LIMIT ? text.slice(0, HIDDEN_TEXT_SCAN_LIMIT) : text;
+    out = out.replace(LINE_BREAKS, '\n').replace(CONTROLS, '').replace(INVISIBLE, '');
+    out = removeInvisibleReferences(out);
+    out = removeHtmlComments(out);
+    out = removeHiddenElements(out);
+    out = replaceHtmlImages(out);
+    out = removeInvisibleMarkdown(out);
+    return out;
+}
+/**
+ * Web addresses as they appear in text, without trailing punctuation. Parentheses that balance are part of one
+ * (`https://cdn.example/a(1).jpg`); a closing one with no opening one ends it, as in "(see https://a.example)".
+ */
+const URL_CHARACTER = /[^\s<>"'`()[\]{}|\\^]/.source;
+const URL_PATTERN = new RegExp(`https?://${balanced(URL_CHARACTER)}+`, 'gi');
+/** @handles as they appear in text, a federated server included; never the middle of an email address. */
+const HANDLE_PATTERN = /(^|[^A-Za-z0-9_@./])@([A-Za-z0-9_](?:[A-Za-z0-9_.-]{0,62}[A-Za-z0-9_])?(?:@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+)?)/g;
+/** A web address as matched, without the punctuation that ends a sentence after it. */
+const trimUrl = (match) => match.replace(/[.,;:!?*_~]+$/, '');
+const HAS_HOST = /^https?:\/\/[^/?#\s]/i;
+/** Every web address in `text`, in order, each once. */
+export function findUrls(text) {
+    if (typeof text !== 'string' || !text)
+        return [];
+    const found = new Set();
+    for (const match of text.match(URL_PATTERN) ?? []) {
+        const url = trimUrl(match);
+        if (HAS_HOST.test(url))
+            found.add(url);
+    }
+    return [...found];
+}
+/** `text` with each web address in it passed through `replace`; the punctuation after one is kept. */
+export function mapUrls(text, replace) {
+    if (typeof text !== 'string' || !text.includes('://'))
+        return text;
+    return text.replace(URL_PATTERN, (match) => {
+        const url = trimUrl(match);
+        return HAS_HOST.test(url) ? `${replace(url)}${match.slice(url.length)}` : match;
+    });
+}
+/** Every @handle in `text` (without the @), in order, each once. */
+export function findHandles(text) {
+    if (typeof text !== 'string' || !text)
+        return [];
+    const found = new Set();
+    HANDLE_PATTERN.lastIndex = 0;
+    for (let match = HANDLE_PATTERN.exec(text); match; match = HANDLE_PATTERN.exec(text))
+        found.add(match[2]);
+    return [...found];
+}

package/dist/assistant/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `@recursiv/sdk/assistant`: what an assistant may read about a post, and how it is handed to a model.
+ *
+ * - `buildSubjectBundle(input)` applies the reading rules (author choices, blocks and mutes both ways, known minors,
+ *   child-safety holds, moderator suppression, captions instead of pictures, hidden-text stripping, limits) to data the
+ *   caller already holds, and says what it left out, as counts. The reasons the asker may see never say who blocked
+ *   them, whose account is a minor's or that a post is held; the detail is in `audit`, for the server's log only.
+ * - `renderBundleForModel(bundle, intent, { boundary, pictures? })` spotlights the bundle as model input. With
+ *   `pictures` (the caller's clock, the pictures it approved and its image cache), pictures on the asked-about post,
+ *   parent or quote that Minds checked in the last 24 hours also go as image parts; `bundlePictures` lists them first,
+ *   so a phone can run its own checks and approve only those that pass.
+ * - `sealedTurnCaps(input)` decides what one Sealed message may carry: search, the chat so far, memory, About you and
+ *   pictures from the phone ("never all three", sealed-full-scope-v1 3.2 rule 5, 4.3 and 2.6), with a copy id for
+ *   whatever it turns off.
+ *
+ * - `matchFixedCard(text, { country, locale })` finds the fixed election or crisis card a member's message calls for,
+ *   with no model call: plain phrase lists in English and Spanish over normalised text, and fixed cards whose every
+ *   number and address has a cited source. `fixedCardAnswer` says whether the model may answer after the card.
+ *
+ * All are pure (no network, clock, randomness or Node-only API), so the server, a Sealed phone and an app build the
+ * same input from the same data, and show the same card. Nothing here sends anything: a clock, where one matters, is
+ * an argument.
+ */
+export * from './types.js';
+export { buildSubjectBundle, isPictureAddress, resolveAskChoice, SUBJECT_BUNDLE_LIMITS } from './subjectBundle.js';
+export { BUNDLE_PICTURE_LIMITS, bundlePictures, MEMBER_LINE_PREFIX, renderBundleForModel } from './render.js';
+export { sealedTurnCaps } from './turnCaps.js';
+export { findHandles, findUrls, HIDDEN_TEXT_SCAN_LIMIT, stripHiddenText } from './hiddenText.js';
+export { ELECTION_CARD_ONLY_UNTIL, FIXED_CARD_SCAN_LIMIT, fixedCardAnswer, fixedCardFor, matchFixedCard, normaliseForMatching, } from './fixedCards.js';
+export { CRISIS_DIRECTORY, CRISIS_LINES, type CrisisCountryData, type CrisisLineData, ELECTION_SITES, type ElectionCountryData, type ElectionSiteData, type EmergencyNumberData, FIXED_CARD_DATA_AS_OF, type LocalizedText, } from './fixedCardData.js';

package/dist/assistant/index.js

@@ -0,0 +1,30 @@
+/**
+ * `@recursiv/sdk/assistant`: what an assistant may read about a post, and how it is handed to a model.
+ *
+ * - `buildSubjectBundle(input)` applies the reading rules (author choices, blocks and mutes both ways, known minors,
+ *   child-safety holds, moderator suppression, captions instead of pictures, hidden-text stripping, limits) to data the
+ *   caller already holds, and says what it left out, as counts. The reasons the asker may see never say who blocked
+ *   them, whose account is a minor's or that a post is held; the detail is in `audit`, for the server's log only.
+ * - `renderBundleForModel(bundle, intent, { boundary, pictures? })` spotlights the bundle as model input. With
+ *   `pictures` (the caller's clock, the pictures it approved and its image cache), pictures on the asked-about post,
+ *   parent or quote that Minds checked in the last 24 hours also go as image parts; `bundlePictures` lists them first,
+ *   so a phone can run its own checks and approve only those that pass.
+ * - `sealedTurnCaps(input)` decides what one Sealed message may carry: search, the chat so far, memory, About you and
+ *   pictures from the phone ("never all three", sealed-full-scope-v1 3.2 rule 5, 4.3 and 2.6), with a copy id for
+ *   whatever it turns off.
+ *
+ * - `matchFixedCard(text, { country, locale })` finds the fixed election or crisis card a member's message calls for,
+ *   with no model call: plain phrase lists in English and Spanish over normalised text, and fixed cards whose every
+ *   number and address has a cited source. `fixedCardAnswer` says whether the model may answer after the card.
+ *
+ * All are pure (no network, clock, randomness or Node-only API), so the server, a Sealed phone and an app build the
+ * same input from the same data, and show the same card. Nothing here sends anything: a clock, where one matters, is
+ * an argument.
+ */
+export * from './types.js';
+export { buildSubjectBundle, isPictureAddress, resolveAskChoice, SUBJECT_BUNDLE_LIMITS } from './subjectBundle.js';
+export { BUNDLE_PICTURE_LIMITS, bundlePictures, MEMBER_LINE_PREFIX, renderBundleForModel } from './render.js';
+export { sealedTurnCaps } from './turnCaps.js';
+export { findHandles, findUrls, HIDDEN_TEXT_SCAN_LIMIT, stripHiddenText } from './hiddenText.js';
+export { ELECTION_CARD_ONLY_UNTIL, FIXED_CARD_SCAN_LIMIT, fixedCardAnswer, fixedCardFor, matchFixedCard, normaliseForMatching, } from './fixedCards.js';
+export { CRISIS_DIRECTORY, CRISIS_LINES, ELECTION_SITES, FIXED_CARD_DATA_AS_OF, } from './fixedCardData.js';

package/dist/assistant/render.d.ts

@@ -0,0 +1,31 @@
+import type { AssistIntent, BundlePicture, BundlePictureOptions, RenderBundleOptions, RenderedBundle, SubjectBundle } from './types.js';
+/** Every line a member wrote starts with this. */
+export declare const MEMBER_LINE_PREFIX = "| ";
+/**
+ * When a post picture may go to a model as a picture (sealed-full-scope-v1 2.1, 2.2): at most `max_pictures` in one
+ * message, pictures from the phone included (the caller passes the room left as `max`); only while Minds' last
+ * child-safety check of it is younger than `fresh_ms`; a check time up to `clock_skew_ms` ahead of the caller's clock
+ * still counts (clocks drift), and one further ahead is not a time Minds wrote, so it does not.
+ */
+export declare const BUNDLE_PICTURE_LIMITS: Readonly<{
+    max_pictures: 3;
+    fresh_ms: number;
+    clock_skew_ms: number;
+}>;
+/**
+ * The post pictures in `bundle` that may go to the model as pictures for `intent`, in the order the renderer attaches
+ * them: pictures (not clips or sounds) on the asked-about post, its parent and its quote (never on a reply), with a
+ * plain media id, whose `checked_at` is under 24 hours old by `now`; at most `max` (3 when absent, never more), and
+ * none for 'translate'. A picture whose check is missing, cannot be read, is 24 hours old or more, or is over 5
+ * minutes ahead of `now`, is not listed: it goes as alt text only. Load each listed picture from your own image cache
+ * (never fetch it), run your own checks, and pass the ones that passed to renderBundleForModel as `allowed`, with the
+ * same `max` and a fresh `now`: it attaches only those that still qualify, so a picture left out, or one that went
+ * stale during your checks, goes as alt text only and no other takes its place.
+ */
+export declare function bundlePictures(bundle: SubjectBundle, intent: AssistIntent, options: BundlePictureOptions): BundlePicture[];
+/**
+ * `bundle` as model input for `intent`. Throws on a missing bundle, an unknown intent, a boundary that is not a fresh
+ * random string or that the content contains, a translate without a language tag, and `pictures` without a clock, an
+ * approved list or a cache lookup.
+ */
+export declare function renderBundleForModel(bundle: SubjectBundle, intent: AssistIntent, options: RenderBundleOptions): RenderedBundle;