@hanzo/build 0.2.63 → 0.2.64

package/lib/api/chat.d.ts

@@ -0,0 +1,12 @@
+/**
+ * One completion from Hanzo's own models, asked with the person's own bearer so
+ * it is attributed to them and metered as theirs.
+ *
+ *   POST /v1/chat/completions   {model, messages, max_tokens} → {choices: [{message: {content}}]}
+ */
+import { type Target } from './call.ts';
+/** The quick model a plugin thinks with: planning a search, drafting a template. */
+export declare const QUICK = "enso-flash";
+export declare function ask(t: Target, system: string, user: string, signal?: AbortSignal, tokens?: number): Promise<string>;
+/** The first JSON object in a model's answer, or null: a model may talk around it. */
+export declare function json(said: string): Record<string, unknown> | null;

package/lib/api/chat.js

@@ -0,0 +1,28 @@
+/**
+ * One completion from Hanzo's own models, asked with the person's own bearer so
+ * it is attributed to them and metered as theirs.
+ *
+ *   POST /v1/chat/completions   {model, messages, max_tokens} → {choices: [{message: {content}}]}
+ */
+import { call } from './call.js';
+/** The quick model a plugin thinks with: planning a search, drafting a template. */
+export const QUICK = 'enso-flash';
+export async function ask(t, system, user, signal, tokens = 800) {
+    const raw = await call(t, 'POST', '/v1/chat/completions', { model: QUICK, max_tokens: tokens, messages: [{ role: 'system', content: system }, { role: 'user', content: user }] }, { signal });
+    const said = raw?.choices?.[0]?.message?.content;
+    return typeof said === 'string' ? said : '';
+}
+/** The first JSON object in a model's answer, or null: a model may talk around it. */
+export function json(said) {
+    const from = said.indexOf('{');
+    const to = said.lastIndexOf('}');
+    if (from < 0 || to <= from)
+        return null;
+    try {
+        const v = JSON.parse(said.slice(from, to + 1));
+        return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}

package/lib/api/studio.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Hanzo Studio: a creation is a run of a template, its files kept in the Library.
+ *
+ *   GET  /v1/studio/templates           {data: [template]}  the public catalog, then the org's own
+ *   POST /v1/studio/runs                {template, input, title?, parent?} → 201 run, queued
+ *   GET  /v1/studio/runs/{id}           the run: status, text, outputs
+ *   POST /v1/studio/runs/{id}/cancel    stop it; what it reserved is released
+ *
+ * A run is priced and its estimate reserved against the org's wallet before it
+ * is queued (402 when the wallet cannot cover it). `parent` makes the run the
+ * next version of that one. Its outputs are Library items: their `url` is
+ * signed and expires, their `origin` is the app path that opens the run in
+ * Studio and does not.
+ */
+import { type Target } from './call.ts';
+import { type Item } from './library.ts';
+export interface Run {
+    id: string;
+    /** queued, running, succeeded, failed or cancelled. */
+    status: string;
+    title: string;
+    /** What the run's writing step said, when its product is words. */
+    text: string;
+    outputs: Item[];
+    /** Why it failed, in the platform's words, or ''. */
+    error: string;
+}
+export interface Start {
+    template: string;
+    input: Record<string, unknown>;
+    title?: string;
+    parent?: string;
+}
+export declare function run(raw: unknown): Run;
+/** A run that has ended, one way or the other. */
+export declare const ended: (r: Run) => boolean;
+/** The ids of the templates this org may run. */
+export declare function templates(t: Target, init?: {
+    signal?: AbortSignal;
+}): Promise<string[]>;
+/**
+ * Start a run and wait for it to end. Aborted, the run is cancelled so its
+ * reservation is released; a run that fails is thrown with its reason.
+ */
+export declare function make(t: Target, s: Start, signal?: AbortSignal): Promise<Run>;

package/lib/api/studio.js

@@ -0,0 +1,76 @@
+/**
+ * Hanzo Studio: a creation is a run of a template, its files kept in the Library.
+ *
+ *   GET  /v1/studio/templates           {data: [template]}  the public catalog, then the org's own
+ *   POST /v1/studio/runs                {template, input, title?, parent?} → 201 run, queued
+ *   GET  /v1/studio/runs/{id}           the run: status, text, outputs
+ *   POST /v1/studio/runs/{id}/cancel    stop it; what it reserved is released
+ *
+ * A run is priced and its estimate reserved against the org's wallet before it
+ * is queued (402 when the wallet cannot cover it). `parent` makes the run the
+ * next version of that one. Its outputs are Library items: their `url` is
+ * signed and expires, their `origin` is the app path that opens the run in
+ * Studio and does not.
+ */
+import { call, Refusal, seg } from './call.js';
+import { item } from './library.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+const obj = (v) => (v && typeof v === 'object' ? v : {});
+export function run(raw) {
+    const o = obj(raw);
+    const e = obj(o.error);
+    return {
+        id: str(o.id),
+        status: str(o.status),
+        title: str(o.title),
+        text: str(o.text),
+        outputs: (Array.isArray(o.outputs) ? o.outputs : []).map(item).filter((x) => x !== null),
+        error: str(e.detail) || str(e.title),
+    };
+}
+/** A run that has ended, one way or the other. */
+export const ended = (r) => r.status !== 'queued' && r.status !== 'running' && r.status !== '';
+/** The ids of the templates this org may run. */
+export async function templates(t, init) {
+    const raw = obj(await call(t, 'GET', '/v1/studio/templates', undefined, init));
+    return (Array.isArray(raw.data) ? raw.data : []).map((x) => str(obj(x).id)).filter(Boolean);
+}
+/** How often a run is read while it works, and the longest it is waited for. */
+const EVERY = 2_000;
+const LONGEST = 5 * 60_000;
+const pause = (ms, signal) => new Promise((done, fail) => {
+    const id = setTimeout(done, ms);
+    signal?.addEventListener('abort', () => {
+        clearTimeout(id);
+        fail(signal.reason);
+    }, { once: true });
+});
+/**
+ * Start a run and wait for it to end. Aborted, the run is cancelled so its
+ * reservation is released; a run that fails is thrown with its reason.
+ */
+export async function make(t, s, signal) {
+    let r = run(await call(t, 'POST', '/v1/studio/runs', s, { signal }).catch((e) => {
+        throw e instanceof Refusal && e.status === 402 ? new Error('Your balance does not cover it. Add credit in Settings › Billing.') : e;
+    }));
+    if (!r.id)
+        throw new Error('Studio started the run and named no id');
+    const id = r.id;
+    const stop = () => void call(t, 'POST', `/v1/studio/runs/${seg(id)}/cancel`, {}).catch(() => undefined);
+    signal?.addEventListener('abort', stop, { once: true });
+    try {
+        const until = Date.now() + LONGEST;
+        while (!ended(r)) {
+            if (Date.now() > until)
+                throw new Error('Studio is still making it. It will be in your Library when it is done.');
+            await pause(EVERY, signal);
+            r = run(await call(t, 'GET', `/v1/studio/runs/${seg(id)}`, undefined, { signal }));
+        }
+    }
+    finally {
+        signal?.removeEventListener('abort', stop);
+    }
+    if (r.status !== 'succeeded')
+        throw new Error(r.error || `Studio could not make it (${r.status})`);
+    return r;
+}

package/lib/carry.d.ts

@@ -1,10 +1,22 @@
+import { type ReactNode } from 'react';
 import { type Target } from './api/call.ts';
 import { type GearState } from './gear.ts';
+import type { Composer, Prep, Turn } from './plugin.ts';
 import type { Shelf } from './plus.tsx';
 import type { Chip } from './prompt.tsx';
+/** What the surface lends the plugins: its draft, its files, its way about. */
+export type Lent = Omit<Composer, 'target' | 'show'>;
 export interface Carry {
     gear: GearState;
     skills: Shelf;
+    /** The plugins that run for this person (`@` lists the same). */
+    plugins: Shelf;
+    /** A dialog a plugin opened, for the surface to draw; null when none is. */
+    dialog: ReactNode;
+    /** Whether a plugin that prepares a message is on. */
+    preparing: boolean;
+    /** What the plugins that are on add to the message about to go. */
+    prep: (turn: Turn, signal: AbortSignal) => Promise<Prep>;
     /** The chips after `+`: the skills on, Research, and Plan. */
     on: Chip[];
     /** The words the gear adds to every message, '' when none. */
@@ -14,4 +26,4 @@ export interface Carry {
  * The conversation `key` names (`''` for one not begun), for target `t`.
  * `customize(tab)` opens Dev's Customize on that tab.
  */
-export declare function useCarry(t: Target, key: string, customize: (tab: 'skills') => void): Carry;
+export declare function useCarry(t: Target, key: string, customize: (tab: 'skills') => void, lent: Lent): Carry;

package/lib/carry.js

@@ -16,11 +16,12 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * (Chat its agents, Dev its devices) beside these.
  */
 import { BookOpen, ListChecks, ScrollText } from '@hanzogui/lucide-icons-2';
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { call, query, unwrap } from './api/call.js';
 import { active, authored, document, nameOf as skillOf } from './api/skills.js';
 import { useRead } from './data.js';
 import { useGear } from './gear.js';
+import { active as lighted, prep, shelf as pluginShelf, usePlugins } from './plugins/index.js';
 /** The most of each skill a message carries. */
 const SKILL_MAX = 16_000;
 /** The memories every message carries at most, newest first. */
@@ -56,8 +57,23 @@ async function said(t, skills, memory, mode) {
  * The conversation `key` names (`''` for one not begun), for target `t`.
  * `customize(tab)` opens Dev's Customize on that tab.
  */
-export function useCarry(t, key, customize) {
+export function useCarry(t, key, customize, lent) {
     const gear = useGear(t, key);
+    const [dialog, show] = useState(null);
+    // The composer a plugin acts on, read when it acts: the draft moves under it.
+    const lentNow = useRef(lent);
+    lentNow.current = lent;
+    const composer = useMemo(() => ({
+        target: t,
+        get draft() {
+            return lentNow.current.draft;
+        },
+        setDraft: (x) => lentNow.current.setDraft(x),
+        attach: (f) => lentNow.current.attach(f),
+        go: (h) => lentNow.current.go(h),
+        show,
+    }), [t]);
+    const found = usePlugins(t);
     const signed = Boolean(t.token());
     const list = useRead(signed ? () => active(t) : null, [], [t, signed]);
     const names = useMemo(() => list.value.map((s) => skillOf(s.name)).filter(Boolean), [list.value]);
@@ -72,10 +88,15 @@ export function useCarry(t, key, customize) {
         manage: { label: 'Manage skills', onPress: () => customize('skills') },
         browse: { label: 'Browse skills', onPress: () => customize('skills') },
     };
+    const plugins = pluginShelf(found, gear, composer);
+    const lit = lighted(found.plugins, gear.gear);
     const on = [
         ...skills.map((n) => ({ id: `skill:${n}`, label: n, icon: _jsx(ScrollText, { size: 14 }), onRemove: () => gear.toggle('skills', n) })),
         ...(research ? [{ id: 'research', label: 'Research', icon: _jsx(BookOpen, { size: 14 }), onRemove: () => gear.set({ research: false }) }] : []),
         ...(mode === 'plan' ? [{ id: 'plan', label: 'Plan', icon: _jsx(ListChecks, { size: 14 }), onRemove: () => gear.set({ mode: 'auto' }) }] : []),
+        ...lit
+            .filter((p) => p.id !== 'research')
+            .map((p) => ({ id: `plugin:${p.id}`, label: p.name, icon: p.icon, onRemove: () => gear.toggle('plugins', p.id) })),
     ];
     const signedIn = Boolean(t.token());
     const [text, setText] = useState('');
@@ -91,5 +112,14 @@ export function useCarry(t, key, customize) {
         // `skills` is read through `asked`, its contents.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [t, signedIn, asked, memory, mode]);
-    return { gear, skills: shelf, on, text };
+    return {
+        gear,
+        skills: shelf,
+        plugins,
+        dialog,
+        on,
+        text,
+        preparing: lit.length > 0,
+        prep: (turn, signal) => prep(found.plugins, gear.gear, turn, composer, signal),
+    };
 }

package/lib/index.d.ts

@@ -54,12 +54,19 @@ export { Plus, type Link, type PlusProps, type Row as ShelfRow, type Shelf, type
 export { BARE, gearOf, MODES, useGear, useLanguage, type Gear, type GearState, type Mode as GearMode } from './gear.ts';
 export { useCarry, type Carry } from './carry.tsx';
 export { Dictation } from './mic.tsx';
-export type { Composer as PluginComposer, Plugin, Prep, Turn } from './plugin.ts';
 export { artifacts, blob, lead, renders, Reply, Served, speakable, speaker, type Artifact, type Listen } from './reply.tsx';
 export { frames, Page, Panel, PanelToggle, type Kind, type PageProps, type PanelProps, type Suggestion } from './panel.tsx';
 export { SideProvider, useSplit, type Split } from './side.tsx';
 export { PrefsProvider } from './prefs.tsx';
 export { kinds, Summary, useKinds, type Entry, type Section } from './summary.tsx';
+/**
+ * The composer's plugins, the same in Chat and Dev: `usePlugins` answers those
+ * that run for this person, `shelf` is the `+` menu's Plugins shelf, and `prep`
+ * asks the ones that are on what a message carries (Deep research is the
+ * Research switch, `research`).
+ */
+export { active, BUILD, merge, prep, shelf, usePlugins, research, type Plugins } from './plugins/index.ts';
+export type { Composer as PluginComposer, Plugin, Prep, Turn } from './plugin.ts';
 export { address, destination, located, name, PAGE, SEARCH, useDeck, useKey, usePanel, useShown, type Deck, type Tab, type Tabs } from './tabs.ts';
 /**
  * Up to three suggestions under the composer (above it on a phone), each from

package/lib/index.js

@@ -54,6 +54,13 @@ export { frames, Page, Panel, PanelToggle } from './panel.js';
 export { SideProvider, useSplit } from './side.js';
 export { PrefsProvider } from './prefs.js';
 export { kinds, Summary, useKinds } from './summary.js';
+/**
+ * The composer's plugins, the same in Chat and Dev: `usePlugins` answers those
+ * that run for this person, `shelf` is the `+` menu's Plugins shelf, and `prep`
+ * asks the ones that are on what a message carries (Deep research is the
+ * Research switch, `research`).
+ */
+export { active, BUILD, merge, prep, shelf, usePlugins, research } from './plugins/index.js';
 export { address, destination, located, name, PAGE, SEARCH, useDeck, useKey, usePanel, useShown } from './tabs.js';
 /**
  * Up to three suggestions under the composer (above it on a phone), each from

package/lib/landing.js

@@ -39,7 +39,7 @@ import { useCarry } from './carry.js';
 import { Suggestions, useSuggestions } from './suggestions.js';
 import { MEASURE, Prompt, useEar } from './prompt.js';
 import { Monitor as Device } from '@hanzogui/lucide-icons-2';
-import { compose, Files, pick } from './tools.js';
+import { compose, Files, pick, read as readFiles } from './tools.js';
 import { useSpoken } from './voice.js';
 /** One vocabulary for the mode, on New and in a workspace. */
 export const MODES = [
@@ -114,7 +114,27 @@ export function Landing({ onStarted }) {
     const voice = useVoice({ speech: useEar(t), language: useSpoken(), ...useDictation(draft, setDraft) });
     const talk = useTalk({ baseUrl: t.api, token: () => t.token(), ...(t.org ? { org: t.org } : {}) });
     // What the run carries beside the ask: skills, memory and the mode, as Chat's turns do.
-    const carry = useCarry(t, '', (tab) => host.go(path({ kind: 'customize', tab })));
+    const carry = useCarry(t, '', (tab) => host.go(path({ kind: 'customize', tab })), {
+        draft,
+        setDraft,
+        // A run reads text: a file that is one rides the ask, a picture goes with a chat.
+        attach: (list) => {
+            const text = list.filter((f) => !f.type.startsWith('image/'));
+            if (text.length < list.length)
+                setNote('A run reads text files; send a picture in Chat.');
+            if (text.length) {
+                const dt = new DataTransfer();
+                for (const f of text)
+                    dt.items.add(f);
+                void readFiles(files, dt.files).then(({ files: next, note: why }) => {
+                    setFiles(next);
+                    if (why)
+                        setNote(why);
+                });
+            }
+        },
+        go: (href) => (href.startsWith('http') ? host.open(href) : host.go(href)),
+    });
     const mode = carry.gear.gear.mode === 'plan' ? 'plan' : 'build';
     const hints = useSuggestions(t);
     // The chosen codebase's environment, so New can say when it has none yet.
@@ -181,8 +201,14 @@ export function Landing({ onStarted }) {
         setBusy(true);
         setNote('');
         try {
+            // What the plugins that are on add: words for the run, or an answer of their own.
+            const prepped = carry.preparing ? await carry.prep({ text: draft.trim(), files: [], thread: '' }, new AbortController().signal) : {};
+            if (prepped.reply && !prepped.system) {
+                setNote(prepped.reply);
+                return;
+            }
             const run = await start(t, {
-                prompt: compose([draft.trim(), carry.text].filter(Boolean).join('\n\n---\n'), files),
+                prompt: compose([draft.trim(), carry.text, prepped.system ?? ''].filter(Boolean).join('\n\n---\n'), files),
                 // The name alone. The org rides the request, and a slash is not a repo name.
                 // An empty base or place is not sent: the default branch, and the sandbox.
                 repo: repo?.name ?? hub?.full_name,
@@ -281,9 +307,10 @@ export function Landing({ onStarted }) {
                                             : `${codebase} has no environment yet, so every run starts it bare.` }), env.value.state === 'proposed' && env.value.session ? (_jsx(Button, { size: "sm", variant: "outline", onPress: () => host.go(env.value.session), children: "Review" })) : (_jsx(Button, { size: "sm", onPress: () => setOffering(true), children: "Set up environment" }))] })) : null, note || unhonoured(mode, place.id) || mind.note ? (_jsx(SizableText, { size: "$1", color: "$soft", role: "status", children: note || unhonoured(mode, place.id) || mind.note })) : null, _jsx(Prompt, { framed: true, value: draft, onChange: setDraft, onSend: () => void send(), busy: busy, label: "Describe a task or ask a question", head: head, plus: {
                                     upload: () => pick(files, setFiles, setNote),
                                     skills: carry.skills,
+                                    plugins: carry.plugins,
                                     devices,
                                     memory: { on: carry.gear.gear.memory, set: (on) => carry.gear.set({ memory: on }) },
-                                }, on: carry.on, slash: carry.skills, mode: { value: carry.gear.gear.mode, set: (m) => carry.gear.set({ mode: m }) }, where: where, below: _jsx(Suggestions, { rows: hints.rows, onPick: setDraft, onDismiss: hints.dismiss }), mind: mind, limits: limits, onUpgrade: () => host.go(path({ kind: 'screen', screen: 'plans' })), voice: voice, language: prefs.language ?? null, onLanguage: (id) => void savePrefs({ language: id }), talk: talk })] })] }), _jsx(Publish, { source: adding, onClose: () => setAdding(null) }), codebase ? (_jsx(SetupDialog, { repo: codebase, homes: homes, open: offering, onOpenChange: setOffering, onStart: setup, onRepo: choose, onSaved: () => {
+                                }, on: carry.on, slash: carry.skills, at: carry.plugins, mode: { value: carry.gear.gear.mode, set: (m) => carry.gear.set({ mode: m }) }, where: where, below: _jsx(Suggestions, { rows: hints.rows, onPick: setDraft, onDismiss: hints.dismiss }), mind: mind, limits: limits, onUpgrade: () => host.go(path({ kind: 'screen', screen: 'plans' })), voice: voice, language: prefs.language ?? null, onLanguage: (id) => void savePrefs({ language: id }), talk: talk })] })] }), _jsx(Publish, { source: adding, onClose: () => setAdding(null) }), carry.dialog, codebase ? (_jsx(SetupDialog, { repo: codebase, homes: homes, open: offering, onOpenChange: setOffering, onStart: setup, onRepo: choose, onSaved: () => {
                     setOffering(false);
                     env.reload();
                 } })) : null] }));

package/lib/pdf.d.ts

@@ -0,0 +1,139 @@
+/**
+ * A PDF, read where it is: its text page by page, and what its structure says
+ * about it — version, pages, metadata, encryption, how often it was revised
+ * after it was written, and whether each signature still covers the bytes it
+ * signed. Nothing leaves the browser.
+ *
+ * Text comes out of each page's content streams (and the forms they draw),
+ * decoded with each font's ToUnicode map: Flate is undone by the platform's own
+ * `DecompressionStream`, objects packed into object streams are unpacked, and a
+ * font without a map is read as single-byte Latin. What it cannot read it says
+ * it cannot: an encrypted file, a page that is only pictures (a scan needs OCR),
+ * a stream in a filter other than Flate.
+ *
+ * A signature is checked for integrity, not trust: that its byte range starts at
+ * the first byte, frames exactly its own signature, and reaches the end of the
+ * file (or how many bytes were added after it), and that the digest the
+ * signature carries (CMS `messageDigest`) is the digest of those bytes. Whether
+ * the signer's certificate is trusted is not decided here.
+ */
+/** A name (`/Type`), a string's bytes, an indirect reference, an operator in a content stream. */
+export declare class Name {
+    readonly n: string;
+    constructor(n: string);
+}
+export declare class Str {
+    readonly s: string;
+    constructor(s: string);
+}
+export declare class Ref {
+    readonly n: number;
+    constructor(n: number);
+}
+export declare class Op {
+    readonly o: string;
+    constructor(o: string);
+}
+export type Dict = Map<string, Value>;
+export type Value = number | boolean | null | Name | Str | Ref | Op | Value[] | Dict;
+/** The largest file read. */
+export declare const LARGEST: number;
+/** Bytes as a string of the same length, one char per byte. */
+export declare function latin(b: Uint8Array): string;
+/** A cursor over PDF syntax: the objects of a file, or the operators of a content stream. */
+export declare class Lexer {
+    readonly src: string;
+    at: number;
+    constructor(src: string, at?: number);
+    skip(): void;
+    /** The next value, or undefined at the end. */
+    next(): Value | undefined;
+    private literal;
+}
+interface Obj {
+    value: Value;
+    /** A stream's bytes as stored, still encoded. */
+    data?: Uint8Array;
+}
+export interface Doc {
+    bytes: Uint8Array;
+    src: string;
+    objects: Map<number, Obj>;
+}
+export declare function resolve(doc: Doc, v: Value | undefined, depth?: number): Value | undefined;
+/** Undo a stream's filters: Flate, ASCII85 and hex, in the order named. Null for one it cannot undo. */
+export declare function decode(doc: Doc, o: Obj): Promise<Uint8Array | null>;
+/** ASCII85, as PDF writes it: `z` for four zeros, ending at `~>`. */
+export declare function a85(s: string): Uint8Array;
+export declare function inflate(data: Uint8Array): Promise<Uint8Array | null>;
+/** Every object in the file, a later definition of a number winning, and those packed in object streams. */
+export declare function open(bytes: Uint8Array): Promise<Doc>;
+/** The pages in reading order, each with the resources it inherits. */
+export declare function pages(doc: Doc): {
+    page: Dict;
+    resources: Dict;
+}[];
+/** A font as text reads it: how many bytes a code takes, what each code says, and how far it moves the pen. */
+export interface Font {
+    width: number;
+    map: Map<number, string> | null;
+    /** Each code's advance, in thousandths of an em; a code not listed advances `dw`. */
+    advance: Map<number, number>;
+    dw: number;
+}
+/** A ToUnicode CMap: its code width and its map. */
+export declare function cmap(s: string, width: number): Pick<Font, 'width' | 'map'>;
+/** A simple font's /Differences as text, where each glyph name says what it is. */
+export declare function differences(v: Value | undefined): Map<number, string> | null;
+/** The codes a string holds, `width` bytes each. */
+export declare function codes(s: string, width: number): number[];
+/** What one code says in a font. A two-byte font with no map says nothing: its codes are glyph numbers. */
+export declare function say(code: number, f: Pick<Font, 'width' | 'map'> | undefined): string;
+/** Each page's text, in reading order. */
+export declare function text(doc: Doc): Promise<string[]>;
+/** A PDF text string: UTF-16 or UTF-8 with its mark, else one byte a character. */
+export declare function words(s: Str | Value | undefined): string;
+/** A PDF date (`D:20261020113000-07'00'`) as a person reads it, or the string as it was. */
+export declare function date(s: string): string;
+export interface Signature {
+    /** Who the signature dictionary names, or ''. */
+    name: string;
+    reason: string;
+    location: string;
+    time: string;
+    /** Its SubFilter: adbe.pkcs7.detached, ETSI.CAdES.detached, … */
+    filter: string;
+    /** The byte range starts at the first byte and frames exactly the signature's own bytes. */
+    framed: boolean;
+    /** Bytes in the file after the end of what was signed; 0 when the signature covers the whole file. */
+    after: number;
+    /** The digest the signature carries matches the signed bytes; null when it was not checked. */
+    intact: boolean | null;
+    /** The digest that was checked, `SHA-256`, or why none was. */
+    digest: string;
+}
+export interface Check {
+    version: string;
+    pages: number;
+    encrypted: boolean;
+    /** How many times it was saved: 1 is as first written, each incremental update adds one. */
+    saves: number;
+    info: Record<string, string>;
+    /** What is wrong with its structure, in words; empty when nothing is. */
+    problems: string[];
+    signatures: Signature[];
+}
+/** The digest a CMS signature says it signed: the value of its messageDigest attribute, or ''. */
+export declare function claimed(der: string): string;
+/** What the file's structure says about it. */
+export declare function check(doc: Doc): Promise<Check>;
+export interface Read {
+    check: Check;
+    /** Each page's text; empty when the file is encrypted. */
+    text: string[];
+}
+/** Read a PDF: its structure, and its text when it is not encrypted. */
+export declare function read(bytes: Uint8Array): Promise<Read>;
+/** What a read found, in words a model is given. */
+export declare function report(file: string, r: Read): string;
+export {};