@vormio/plugin-sdk 0.0.0-stage → 0.0.5

package/dist/node/publish.js

@@ -0,0 +1,213 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { z } from 'zod';
+import { packageLimits } from "../package-rules.js";
+import { CatalogError, catalogKeyId, catalogLimits, catalogPublicKey, compareVersions, generateCatalogKeys, signCatalog, verifyCatalog, } from "./catalog.js";
+import { PackageError, readPackageArchive } from "./package.js";
+import { ZipError } from "./zip.js";
+/** A publication that cannot go ahead; nothing has been written. */
+export class PublishError extends Error {
+    problems;
+    constructor(problems) {
+        super(problems.join('\n'));
+        this.problems = problems;
+        this.name = 'PublishError';
+    }
+}
+/** The Git working tree containing a folder, if any. */
+function gitWorkingTree(folder) {
+    for (let current = resolve(folder);;) {
+        if (existsSync(join(current, '.git')))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+async function readInput(path, what) {
+    try {
+        return await readFile(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw new PublishError([`${what} not found: ${path}`]);
+        throw error;
+    }
+}
+/**
+ * Generates a catalog key pair into `<prefix>.private.pem` and `<prefix>.public.txt`. Refuses to
+ * write inside a Git working tree, where the private key could end up in a commit, and never
+ * overwrites a file.
+ */
+export async function writeCatalogKeys(prefix) {
+    const base = resolve(prefix);
+    const repository = gitWorkingTree(dirname(base));
+    if (repository)
+        throw new PublishError([
+            `${dirname(base)} is inside the Git working tree ${repository}; keep private keys outside every repository`,
+        ]);
+    const privateKeyFile = `${base}.private.pem`;
+    const publicKeyFile = `${base}.public.txt`;
+    for (const file of [privateKeyFile, publicKeyFile])
+        if (existsSync(file))
+            throw new PublishError([`${file} already exists`]);
+    const keys = generateCatalogKeys();
+    await mkdir(dirname(base), { recursive: true });
+    await writeFile(privateKeyFile, keys.privateKey, { flag: 'wx', mode: 0o600 });
+    await writeFile(publicKeyFile, `${keys.publicKey}\n`, { flag: 'wx' });
+    return { keyId: keys.keyId, publicKey: keys.publicKey, privateKeyFile, publicKeyFile };
+}
+const releaseConfigSchema = z
+    .strictObject({
+    /** The catalog currently published; the new one continues its sequence. */
+    previous: z.string().min(1).optional(),
+    /** The sequence of a first publication, when there is no previous catalog. */
+    initialSequence: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER).optional(),
+    /** Every package the new catalog offers, as `.vormioplugin` files. */
+    packages: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(catalogLimits.maxPlugins * catalogLimits.maxReleasesPerPlugin),
+})
+    .refine((config) => (config.previous === undefined) !== (config.initialSequence === undefined), {
+    message: 'Give either previous or initialSequence',
+});
+async function readRelease(path) {
+    const size = (await stat(path).catch(() => undefined))?.size;
+    if (size === undefined)
+        throw new PublishError([`Package not found: ${path}`]);
+    if (size > packageLimits.maxArchiveBytes)
+        throw new PublishError([`${path}: larger than ${packageLimits.maxArchiveBytes} bytes`]);
+    const data = await readInput(path, 'Package');
+    try {
+        const { checked, contents } = readPackageArchive(data);
+        const sha256 = createHash('sha256').update(data).digest('hex');
+        const { id, version } = checked.manifest;
+        return {
+            id,
+            version,
+            // The manifest as the package has it, so hosts compare like with like after downloading.
+            manifest: JSON.parse(contents.get('manifest.json').toString('utf8')),
+            data,
+            sha256,
+            file: `packages/${id}-${version}-${sha256.slice(0, 12)}.vormioplugin`,
+        };
+    }
+    catch (error) {
+        if (error instanceof PackageError)
+            throw new PublishError(error.problems.map((problem) => `${path}: ${problem}`));
+        if (error instanceof ZipError)
+            throw new PublishError([`${path}: ${error.message}`]);
+        throw error;
+    }
+}
+/**
+ * Publishes a catalog into a new, empty folder: validates every package the way a host does before
+ * installing it, copies each under a name derived from its content, signs `catalog.json` and checks
+ * the result with the public key. Every check runs before anything is written. Upload the
+ * `packages` folder first and `catalog.json` last.
+ */
+export async function writeCatalog(options) {
+    const configFile = resolve(options.config);
+    const base = dirname(configFile);
+    let json;
+    try {
+        json = JSON.parse((await readInput(configFile, 'Release configuration')).toString('utf8'));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new PublishError([`${configFile}: not valid JSON`]);
+        throw error;
+    }
+    const parsed = releaseConfigSchema.safeParse(json);
+    if (!parsed.success)
+        throw new PublishError(parsed.error.issues.map((issue) => `${issue.path.join('.') || 'config'}: ${issue.message}`));
+    const config = parsed.data;
+    const privateKey = (await readInput(resolve(options.privateKey), 'Private key')).toString('utf8');
+    const publicKey = catalogPublicKey(privateKey);
+    const keyId = catalogKeyId(publicKey);
+    // The private key cannot be inside an empty folder, so this also keeps it out of the upload.
+    const out = resolve(options.out);
+    if (existsSync(out) && (await readdir(out)).length > 0)
+        throw new PublishError([`${out} is not empty; publish into a new folder`]);
+    let sequence = config.initialSequence;
+    if (config.previous !== undefined) {
+        const previousFile = resolve(base, config.previous);
+        try {
+            sequence =
+                verifyCatalog(await readInput(previousFile, 'Previous catalog'), publicKey).sequence + 1;
+        }
+        catch (error) {
+            if (error instanceof CatalogError)
+                throw new PublishError(error.problems.map((problem) => `${previousFile}: ${problem}`));
+            throw error;
+        }
+    }
+    const problems = [];
+    const plugins = new Map();
+    for (const path of config.packages) {
+        try {
+            const release = await readRelease(resolve(base, path));
+            const releases = plugins.get(release.id) ?? [];
+            if (releases.some((other) => other.version === release.version))
+                problems.push(`${release.id} ${release.version} is listed more than once`);
+            releases.push(release);
+            plugins.set(release.id, releases);
+        }
+        catch (error) {
+            if (!(error instanceof PublishError))
+                throw error;
+            problems.push(...error.problems);
+        }
+    }
+    if (problems.length)
+        throw new PublishError(problems);
+    const ordered = [...plugins.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : 1))
+        .map(([id, releases]) => ({
+        id,
+        releases: releases.sort((a, b) => compareVersions(b.version, a.version)),
+    }));
+    const payload = {
+        sequence,
+        publishedAt: (options.now ?? new Date()).toISOString(),
+        plugins: ordered.map(({ id, releases }) => ({
+            id,
+            releases: releases.map(({ manifest, file, data, sha256 }) => ({
+                manifest: manifest,
+                file,
+                bytes: data.length,
+                sha256,
+            })),
+        })),
+    };
+    let catalog;
+    try {
+        catalog = signCatalog(payload, privateKey);
+    }
+    catch (error) {
+        if (error instanceof CatalogError)
+            throw new PublishError([...error.problems]);
+        throw error;
+    }
+    await mkdir(join(out, 'packages'), { recursive: true });
+    const releases = ordered.flatMap(({ releases }) => releases);
+    for (const release of releases)
+        await writeFile(join(out, release.file), release.data, { flag: 'wx' });
+    await writeFile(join(out, 'catalog.json'), catalog, { flag: 'wx' });
+    verifyCatalog(await readFile(join(out, 'catalog.json')), publicKey);
+    return {
+        keyId,
+        sequence,
+        releases: releases.map(({ id, version, file, data, sha256 }) => ({
+            id,
+            version,
+            file,
+            bytes: data.length,
+            sha256,
+        })),
+    };
+}

package/dist/node/zip.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A minimal zip reader and writer for `.vormioplugin` files: stored and deflated entries only, no
+ * encryption, no zip64, no spanning. Anything else is rejected rather than guessed at.
+ */
+export interface ZipEntry {
+    path: string;
+    data: Buffer;
+}
+export declare class ZipError extends Error {
+    constructor(message: string);
+}
+export declare function writeZip(entries: readonly ZipEntry[]): Buffer;
+/** Reads every file entry, checking sizes against the package limits and each CRC. */
+export declare function readZip(zip: Buffer): ZipEntry[];

package/dist/node/zip.js

@@ -0,0 +1,132 @@
+import { crc32, deflateRawSync, inflateRawSync } from 'node:zlib';
+import { packageLimits } from "../package-rules.js";
+export class ZipError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ZipError';
+    }
+}
+const signatures = { local: 0x04034b50, central: 0x02014b50, end: 0x06054b50 };
+const utf8Flag = 0x0800;
+const symlinkMode = 0o120000;
+export function writeZip(entries) {
+    const locals = [];
+    const centrals = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const name = Buffer.from(entry.path, 'utf8');
+        const compressed = deflateRawSync(entry.data, { level: 9 });
+        const stored = compressed.length >= entry.data.length;
+        const body = stored ? entry.data : compressed;
+        const checksum = crc32(entry.data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(signatures.local, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(utf8Flag, 6);
+        local.writeUInt16LE(stored ? 0 : 8, 8);
+        local.writeUInt32LE(checksum, 14);
+        local.writeUInt32LE(body.length, 18);
+        local.writeUInt32LE(entry.data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        locals.push(local, name, body);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(signatures.central, 0);
+        central.writeUInt16LE(20, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(utf8Flag, 8);
+        central.writeUInt16LE(stored ? 0 : 8, 10);
+        central.writeUInt32LE(checksum, 16);
+        central.writeUInt32LE(body.length, 20);
+        central.writeUInt32LE(entry.data.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt32LE(offset, 42);
+        centrals.push(central, name);
+        offset += local.length + name.length + body.length;
+    }
+    const directory = Buffer.concat(centrals);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(signatures.end, 0);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(directory.length, 12);
+    end.writeUInt32LE(offset, 16);
+    return Buffer.concat([...locals, directory, end]);
+}
+/** Reads every file entry, checking sizes against the package limits and each CRC. */
+export function readZip(zip) {
+    const endOffset = findEnd(zip);
+    const count = zip.readUInt16LE(endOffset + 10);
+    const directorySize = zip.readUInt32LE(endOffset + 12);
+    const directoryOffset = zip.readUInt32LE(endOffset + 16);
+    if (zip.readUInt16LE(endOffset + 4) !== 0 || zip.readUInt16LE(endOffset + 6) !== 0)
+        throw new ZipError('Multi-part archives are not supported');
+    if (directoryOffset + directorySize > endOffset)
+        throw new ZipError('Damaged central directory');
+    if (count > packageLimits.maxFiles * 2)
+        throw new ZipError('Too many entries');
+    const entries = [];
+    let total = 0;
+    let position = directoryOffset;
+    for (let index = 0; index < count; index++) {
+        if (position + 46 > endOffset || zip.readUInt32LE(position) !== signatures.central)
+            throw new ZipError('Damaged central directory');
+        const flags = zip.readUInt16LE(position + 8);
+        const method = zip.readUInt16LE(position + 10);
+        const checksum = zip.readUInt32LE(position + 16);
+        const compressedSize = zip.readUInt32LE(position + 20);
+        const size = zip.readUInt32LE(position + 24);
+        const nameLength = zip.readUInt16LE(position + 28);
+        const extraLength = zip.readUInt16LE(position + 30);
+        const commentLength = zip.readUInt16LE(position + 32);
+        const madeBy = zip.readUInt16LE(position + 4) >> 8;
+        const attributes = zip.readUInt32LE(position + 38);
+        const localOffset = zip.readUInt32LE(position + 42);
+        const nameBytes = zip.subarray(position + 46, position + 46 + nameLength);
+        const path = flags & utf8Flag ? nameBytes.toString('utf8') : nameBytes.toString('latin1');
+        position += 46 + nameLength + extraLength + commentLength;
+        if (flags & 0x1)
+            throw new ZipError(`${path}: encrypted entries are not supported`);
+        if (size === 0xffffffff || compressedSize === 0xffffffff || localOffset === 0xffffffff)
+            throw new ZipError(`${path}: zip64 is not supported`);
+        // Unix-made archives keep the file mode in the upper attribute bits.
+        if (madeBy === 3 && ((attributes >>> 16) & 0o170000) === symlinkMode)
+            throw new ZipError(`${path}: symbolic links are not allowed`);
+        if (path.endsWith('/'))
+            continue;
+        if (size > packageLimits.maxFileBytes)
+            throw new ZipError(`${path}: file too large`);
+        total += size;
+        if (total > packageLimits.maxTotalBytes)
+            throw new ZipError('Package too large');
+        if (method !== 0 && method !== 8)
+            throw new ZipError(`${path}: unsupported compression`);
+        if (localOffset + 30 > zip.length || zip.readUInt32LE(localOffset) !== signatures.local)
+            throw new ZipError(`${path}: damaged entry`);
+        // A local name that differs from the central one would let tools disagree on the file name.
+        const localNameLength = zip.readUInt16LE(localOffset + 26);
+        if (!zip.subarray(localOffset + 30, localOffset + 30 + localNameLength).equals(nameBytes))
+            throw new ZipError(`${path}: inconsistent entry name`);
+        const dataStart = localOffset + 30 + localNameLength + zip.readUInt16LE(localOffset + 28);
+        if (dataStart + compressedSize > directoryOffset)
+            throw new ZipError(`${path}: damaged entry`);
+        const body = zip.subarray(dataStart, dataStart + compressedSize);
+        let data;
+        try {
+            data = method === 0 ? Buffer.from(body) : inflateRawSync(body, { maxOutputLength: size });
+        }
+        catch {
+            throw new ZipError(`${path}: damaged data`);
+        }
+        if (data.length !== size || crc32(data) !== checksum)
+            throw new ZipError(`${path}: damaged data`);
+        entries.push({ path, data });
+    }
+    return entries;
+}
+function findEnd(zip) {
+    const earliest = Math.max(0, zip.length - 22 - 0xffff);
+    for (let offset = zip.length - 22; offset >= earliest; offset--)
+        if (zip.readUInt32LE(offset) === signatures.end)
+            return offset;
+    throw new ZipError('Not a zip file');
+}

package/dist/package-rules.d.ts

@@ -0,0 +1,22 @@
+/** Limits for a plugin package or development directory. */
+export declare const packageLimits: {
+    readonly maxFiles: 1024;
+    readonly maxFileBytes: number;
+    readonly maxTotalBytes: number;
+    readonly maxPathLength: 240;
+    /** A `.vormioplugin` file. Archives are read whole, so this bounds memory before validation. */
+    readonly maxArchiveBytes: number;
+};
+/** Static file types a package may contain. Executables and archives are never accepted. */
+export declare const packageExtensions: ReadonlySet<string>;
+/**
+ * Checks a path inside a package: forward slashes, NFC, no empty, `.` or `..` segments, no
+ * characters or names Windows cannot store, and an allowed extension. Returns the problem, or null.
+ */
+export declare function checkPackagePath(path: string): string | null;
+export interface PackageFile {
+    path: string;
+    size: number;
+}
+/** Checks a package's file list as a whole; returns every problem found. */
+export declare function checkPackageFiles(files: readonly PackageFile[]): string[];

package/dist/package-rules.js

@@ -0,0 +1,80 @@
+/** Limits for a plugin package or development directory. */
+export const packageLimits = {
+    maxFiles: 1024,
+    maxFileBytes: 16 * 1024 * 1024,
+    maxTotalBytes: 64 * 1024 * 1024,
+    maxPathLength: 240,
+    /** A `.vormioplugin` file. Archives are read whole, so this bounds memory before validation. */
+    maxArchiveBytes: 96 * 1024 * 1024,
+};
+/** Static file types a package may contain. Executables and archives are never accepted. */
+export const packageExtensions = new Set([
+    'html',
+    'js',
+    'mjs',
+    'css',
+    'json',
+    'wasm',
+    'png',
+    'jpg',
+    'jpeg',
+    'webp',
+    'svg',
+    'woff2',
+    'txt',
+    'md',
+]);
+const reservedNames = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
+// eslint-disable-next-line no-control-regex
+const forbiddenCharacters = /[\u0000-\u001f\u007f\\:*?"<>|]/;
+/**
+ * Checks a path inside a package: forward slashes, NFC, no empty, `.` or `..` segments, no
+ * characters or names Windows cannot store, and an allowed extension. Returns the problem, or null.
+ */
+export function checkPackagePath(path) {
+    if (path.length === 0 || path.length > packageLimits.maxPathLength)
+        return 'invalid length';
+    if (path !== path.normalize('NFC'))
+        return 'not NFC';
+    if (forbiddenCharacters.test(path))
+        return 'forbidden character';
+    for (const segment of path.split('/')) {
+        if (segment === '' || segment === '.' || segment === '..')
+            return 'invalid segment';
+        if (/[. ]$/.test(segment))
+            return 'segment ends with a dot or space';
+        if (reservedNames.test(segment.split('.')[0]))
+            return 'reserved name';
+    }
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    const dot = name.lastIndexOf('.');
+    const extension = dot > 0 ? name.slice(dot + 1).toLowerCase() : '';
+    if (!packageExtensions.has(extension))
+        return `file type .${extension || '(none)'} not allowed`;
+    return null;
+}
+/** Checks a package's file list as a whole; returns every problem found. */
+export function checkPackageFiles(files) {
+    const problems = [];
+    if (files.length > packageLimits.maxFiles)
+        problems.push(`more than ${packageLimits.maxFiles} files`);
+    let total = 0;
+    const seen = new Set();
+    for (const file of files) {
+        const problem = checkPackagePath(file.path);
+        if (problem)
+            problems.push(`${file.path}: ${problem}`);
+        if (file.size > packageLimits.maxFileBytes)
+            problems.push(`${file.path}: file too large`);
+        total += file.size;
+        const folded = file.path.toLowerCase();
+        if (seen.has(folded))
+            problems.push(`${file.path}: duplicate name ignoring case`);
+        seen.add(folded);
+    }
+    if (total > packageLimits.maxTotalBytes)
+        problems.push('package too large');
+    if (!files.some((file) => file.path === 'manifest.json'))
+        problems.push('manifest.json missing');
+    return problems;
+}

package/dist/report.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { CompositionReport } from './bridge.ts';
+/** Limits of a composition report; larger reports are rejected as a failed analysis. */
+export declare const reportLimits: {
+    readonly subresources: 10000;
+    readonly references: 50000;
+    readonly diagnostics: 500;
+    /** Serialized size: UTF-8 bytes of the report as JSON. */
+    readonly bytes: number;
+};
+export declare const compositionReportSchema: z.ZodType<CompositionReport>;
+export type ReportResult = {
+    ok: true;
+    report: CompositionReport;
+} | {
+    ok: false;
+    problems: string[];
+};
+/** Validates a report as received from an analyzer, including its serialized size. */
+export declare function parseReport(value: unknown): ReportResult;

package/dist/report.js

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+/** Limits of a composition report; larger reports are rejected as a failed analysis. */
+export const reportLimits = {
+    subresources: 10_000,
+    references: 50_000,
+    diagnostics: 500,
+    /** Serialized size: UTF-8 bytes of the report as JSON. */
+    bytes: 4 * 1024 * 1024,
+};
+const controlCharacters = /[\u0000-\u001f\u007f]/; // eslint-disable-line no-control-regex
+/** Display text: bounded and free of control characters. */
+const plain = (max) => z
+    .string()
+    .max(max)
+    .refine((text) => !controlCharacters.test(text), 'Control characters are not allowed');
+const key = z.string().min(1).max(200);
+const subresourceSchema = z.strictObject({
+    key,
+    kind: plain(80).min(1),
+    name: plain(200),
+    parent: key.optional(),
+});
+const referenceSchema = z
+    .strictObject({
+    from: key.optional(),
+    uri: z.string().min(1).max(2048).optional(),
+    key: key.optional(),
+    role: plain(80).min(1),
+    evidence: plain(300).optional(),
+})
+    .refine((reference) => (reference.uri === undefined) !== (reference.key === undefined), {
+    message: 'Give exactly one of uri and key',
+});
+const diagnosticSchema = z.strictObject({
+    severity: z.enum(['error', 'warning', 'info']),
+    message: z.string().min(1).max(500),
+    key: key.optional(),
+});
+/**
+ * Checks a report as a whole: unique keys, references and parents that name existing keys, and no
+ * cycles in the hierarchy.
+ */
+function consistent(report, context) {
+    const keys = new Set();
+    for (const subresource of report.subresources) {
+        if (keys.has(subresource.key))
+            context.addIssue({ code: 'custom', message: `Duplicate key ${subresource.key}` });
+        keys.add(subresource.key);
+    }
+    const known = (value, where) => {
+        if (value !== undefined && !keys.has(value))
+            context.addIssue({ code: 'custom', message: `${where} names unknown key ${value}` });
+    };
+    for (const subresource of report.subresources)
+        known(subresource.parent, 'A parent');
+    for (const reference of report.references) {
+        known(reference.from, 'A reference');
+        known(reference.key, 'A reference target');
+    }
+    for (const diagnostic of report.diagnostics)
+        known(diagnostic.key, 'A diagnostic');
+    const parents = new Map(report.subresources.map((each) => [each.key, each.parent]));
+    // Keys whose chain of parents is known to end at a root, so each key is walked only once.
+    const settled = new Set();
+    for (const start of parents.keys()) {
+        const path = new Set();
+        let current = start;
+        while (current !== undefined && !settled.has(current)) {
+            if (path.has(current)) {
+                context.addIssue({ code: 'custom', message: `The hierarchy has a cycle at ${current}` });
+                return;
+            }
+            path.add(current);
+            current = parents.get(current);
+        }
+        for (const key of path)
+            settled.add(key);
+    }
+}
+export const compositionReportSchema = z
+    .strictObject({
+    subresources: z.array(subresourceSchema).max(reportLimits.subresources),
+    references: z.array(referenceSchema).max(reportLimits.references),
+    diagnostics: z.array(diagnosticSchema).max(reportLimits.diagnostics),
+    partial: z.boolean().optional(),
+})
+    .superRefine(consistent);
+/** Validates a report as received from an analyzer, including its serialized size. */
+export function parseReport(value) {
+    let json;
+    try {
+        json = JSON.stringify(value);
+    }
+    catch {
+        return { ok: false, problems: ['The report cannot be serialized'] };
+    }
+    // Measured in UTF-8 bytes. UTF-8 never takes fewer bytes than there are UTF-16 code units, so a
+    // string already too long is refused without encoding it.
+    const tooLarge = json !== undefined &&
+        (json.length > reportLimits.bytes ||
+            new TextEncoder().encode(json).byteLength > reportLimits.bytes);
+    if (tooLarge)
+        return { ok: false, problems: ['The report is larger than 4 MiB'] };
+    const result = compositionReportSchema.safeParse(value);
+    if (result.success)
+        return { ok: true, report: result.data };
+    return {
+        ok: false,
+        problems: result.error.issues
+            .slice(0, 20)
+            .map((issue) => `${issue.path.length ? issue.path.join('.') : 'report'}: ${issue.message}`),
+    };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,26 @@
+import type { CompanionResult, CompanionStatus, CompositionReport, PluginBridge, PluginInput } from './bridge.ts';
+export type { CompanionResult, CompanionStatus, CompositionReport, PluginBridge, PluginInput };
+/** The host bridge; throws outside a Vormio plugin page. */
+export declare function bridge(): PluginBridge;
+/**
+ * Reads a file next to the input, relative to the input's folder (`../` may move up within the
+ * linked folder). The host allows only extensions the contribution declares.
+ */
+export declare function readCompanion(input: PluginInput, relativePath: string): Promise<CompanionResult>;
+/** Reads the input's own bytes. */
+export declare function readInput(input: PluginInput): Promise<ArrayBuffer>;
+/**
+ * Runs a viewer: `show` is called for the first input and again whenever the host moves to another
+ * file, with the previous call's signal aborted. Resolving reports ready; throwing reports the
+ * error message.
+ */
+export declare function viewer(show: (input: PluginInput, signal: AbortSignal) => Promise<void>): void;
+/** Runs a thumbnail provider; a canvas is converted to PNG. */
+export declare function thumbnail(render: (input: PluginInput, size: {
+    maxEdge: number;
+}) => Promise<Blob | HTMLCanvasElement | OffscreenCanvas>): void;
+/**
+ * Runs an analyzer: `analyze` is called once per request and returns the composition report of
+ * the input. Throwing reports the analysis as failed with the error message.
+ */
+export declare function analyzer(analyze: (input: PluginInput) => Promise<CompositionReport>): void;