@lapis-notes/api 0.1.0

package/dist/plugin-distribution/plugin-bundle.js

@@ -0,0 +1,244 @@
+import { Unzip, UnzipInflate } from "fflate";
+import { PluginDistributionError } from "./errors";
+import { assertSafePluginRelativePath } from "./path-safety";
+export const PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH = "release.signed.json";
+export const PLUGIN_BUNDLE_STORED_METHOD = 0;
+export const PLUGIN_BUNDLE_DEFLATE_METHOD = 8;
+export const parsePluginBundle = (input, options = {}) => {
+    const bytes = toUint8(input);
+    const expectedEntries = inspectPluginBundleMetadata(bytes);
+    const entries = new Map();
+    let seenFileCount = 0;
+    let processedBytes = 0;
+    const fileCount = expectedEntries.length;
+    const totalBytes = expectedEntries.reduce((sum, entry) => sum + entry.uncompressedSize, 0);
+    let firstError = null;
+    const unzip = new Unzip((file) => {
+        if (firstError) {
+            return;
+        }
+        try {
+            const expectedEntry = expectedEntries[seenFileCount];
+            const fileIndex = seenFileCount + 1;
+            seenFileCount += 1;
+            if (!expectedEntry) {
+                throw invalidBundle(`Unexpected file in .lapis-plugin bundle: ${file.name}`);
+            }
+            if (file.name !== expectedEntry.path ||
+                file.compression !== expectedEntry.compressionMethod) {
+                throw invalidBundle(`Plugin bundle local entry order or method is invalid: ${file.name}`);
+            }
+            assertBundlePath(file.name);
+            if (entries.has(file.name)) {
+                throw invalidBundle(`Duplicate file in .lapis-plugin bundle: ${file.name}`);
+            }
+            if (!isSupportedCompressionMethod(file.compression)) {
+                throw invalidBundle(`Unsupported plugin bundle compression method ${file.compression}: ${file.name}`);
+            }
+            const chunks = [];
+            let byteLength = 0;
+            file.ondata = (error, chunk, final) => {
+                if (error) {
+                    firstError = invalidBundle(`Unable to extract plugin bundle file: ${file.name}`, error);
+                    return;
+                }
+                chunks.push(chunk);
+                byteLength += chunk.byteLength;
+                processedBytes += chunk.byteLength;
+                options.onProgress?.({
+                    phase: "extracting-files",
+                    message: `Extracting ${file.name}`,
+                    filePath: file.name,
+                    fileIndex,
+                    fileCount,
+                    processedBytes,
+                    totalBytes,
+                });
+                if (final) {
+                    entries.set(file.name, concatChunks(chunks, byteLength));
+                }
+            };
+            file.start();
+        }
+        catch (error) {
+            firstError = toInvalidBundleError(error);
+        }
+    });
+    unzip.register(UnzipInflate);
+    try {
+        unzip.push(bytes, true);
+    }
+    catch (error) {
+        firstError = toInvalidBundleError(error);
+    }
+    if (firstError) {
+        throw firstError;
+    }
+    if (seenFileCount !== expectedEntries.length) {
+        throw invalidBundle(".lapis-plugin bundle entry count is invalid.");
+    }
+    for (const expectedEntry of expectedEntries) {
+        if (!entries.has(expectedEntry.path)) {
+            throw invalidBundle(`.lapis-plugin bundle did not extract ${expectedEntry.path}.`);
+        }
+    }
+    if (!entries.has(PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH)) {
+        throw invalidBundle(".lapis-plugin bundle is missing release.signed.json.");
+    }
+    return entries;
+};
+const inspectPluginBundleMetadata = (bytes) => {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const eocdOffset = findEndOfCentralDirectory(view);
+    const totalEntries = readUint16(view, eocdOffset + 10);
+    const centralDirectorySize = readUint32(view, eocdOffset + 12);
+    const centralDirectoryOffset = readUint32(view, eocdOffset + 16);
+    if (readUint16(view, eocdOffset + 4) !== 0 ||
+        readUint16(view, eocdOffset + 6) !== 0 ||
+        readUint16(view, eocdOffset + 8) !== totalEntries) {
+        throw invalidBundle("Multi-disk .lapis-plugin bundles are not supported.");
+    }
+    if (totalEntries === 0xffff ||
+        centralDirectorySize === 0xffffffff ||
+        centralDirectoryOffset === 0xffffffff) {
+        throw invalidBundle("ZIP64 .lapis-plugin bundles are not supported.");
+    }
+    assertRange(centralDirectoryOffset, centralDirectorySize, bytes.byteLength, "central directory");
+    const decoder = new TextDecoder();
+    const entries = [];
+    const seenPaths = new Set();
+    let offset = centralDirectoryOffset;
+    for (let index = 0; index < totalEntries; index += 1) {
+        assertSignature(view, offset, 0x02014b50, "central directory entry");
+        const flags = readUint16(view, offset + 8);
+        const compressionMethod = readUint16(view, offset + 10);
+        const compressedSize = readUint32(view, offset + 20);
+        const uncompressedSize = readUint32(view, offset + 24);
+        const nameLength = readUint16(view, offset + 28);
+        const extraLength = readUint16(view, offset + 30);
+        const commentLength = readUint16(view, offset + 32);
+        const localHeaderOffset = readUint32(view, offset + 42);
+        const nameStart = offset + 46;
+        const nameEnd = nameStart + nameLength;
+        assertRange(nameStart, nameLength, bytes.byteLength, "entry name");
+        const path = decoder.decode(bytes.subarray(nameStart, nameEnd));
+        assertBundlePath(path);
+        if (seenPaths.has(path)) {
+            throw invalidBundle(`Duplicate file in .lapis-plugin bundle: ${path}`);
+        }
+        seenPaths.add(path);
+        if ((flags & 0x41) !== 0) {
+            throw invalidBundle(`Encrypted plugin bundle file is not supported: ${path}`);
+        }
+        if (!isSupportedCompressionMethod(compressionMethod)) {
+            throw invalidBundle(`Unsupported plugin bundle compression method ${compressionMethod}: ${path}`);
+        }
+        if (compressedSize === 0xffffffff || uncompressedSize === 0xffffffff) {
+            throw invalidBundle(`ZIP64 plugin bundle file metadata is not supported: ${path}`);
+        }
+        entries.push({
+            ...inspectLocalEntry({
+                bytes,
+                view,
+                decoder,
+                path,
+                localHeaderOffset,
+                compressionMethod,
+                flags,
+            }),
+            uncompressedSize,
+        });
+        offset += 46 + nameLength + extraLength + commentLength;
+    }
+    if (offset !== centralDirectoryOffset + centralDirectorySize) {
+        throw invalidBundle(".lapis-plugin central directory size is invalid.");
+    }
+    const localOrder = [...entries].sort((left, right) => left.localHeaderOffset - right.localHeaderOffset);
+    const firstEntry = localOrder[0];
+    if (firstEntry?.path !== PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH) {
+        throw invalidBundle(".lapis-plugin bundle must store release.signed.json as the first entry.");
+    }
+    if (firstEntry.compressionMethod !== PLUGIN_BUNDLE_STORED_METHOD) {
+        throw invalidBundle(".lapis-plugin release.signed.json entry must be stored.");
+    }
+    if (!seenPaths.has(PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH)) {
+        throw invalidBundle(".lapis-plugin bundle is missing release.signed.json.");
+    }
+    return localOrder;
+};
+const inspectLocalEntry = ({ bytes, view, decoder, path, localHeaderOffset, compressionMethod, flags, }) => {
+    assertSignature(view, localHeaderOffset, 0x04034b50, "local file header");
+    const localFlags = readUint16(view, localHeaderOffset + 6);
+    const localCompressionMethod = readUint16(view, localHeaderOffset + 8);
+    const nameLength = readUint16(view, localHeaderOffset + 26);
+    const extraLength = readUint16(view, localHeaderOffset + 28);
+    const nameStart = localHeaderOffset + 30;
+    const nameEnd = nameStart + nameLength;
+    assertRange(nameStart, nameLength, bytes.byteLength, "local entry name");
+    assertRange(nameEnd, extraLength, bytes.byteLength, "local entry extra");
+    const localPath = decoder.decode(bytes.subarray(nameStart, nameEnd));
+    if (localPath !== path ||
+        localFlags !== flags ||
+        localCompressionMethod !== compressionMethod) {
+        throw invalidBundle(`Plugin bundle local header mismatch: ${path}`);
+    }
+    return { path, compressionMethod, localHeaderOffset };
+};
+const assertBundlePath = (path) => {
+    if (path.endsWith("/")) {
+        throw invalidBundle(`Plugin bundle directories are not supported: ${path}`);
+    }
+    if (path === PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH) {
+        return;
+    }
+    assertSafePluginRelativePath(path);
+};
+const isSupportedCompressionMethod = (compressionMethod) => compressionMethod === PLUGIN_BUNDLE_STORED_METHOD ||
+    compressionMethod === PLUGIN_BUNDLE_DEFLATE_METHOD;
+const findEndOfCentralDirectory = (view) => {
+    const minimumSize = 22;
+    const minOffset = Math.max(0, view.byteLength - 0xffff - minimumSize);
+    for (let offset = view.byteLength - minimumSize; offset >= minOffset; offset -= 1) {
+        if (readUint32(view, offset) !== 0x06054b50) {
+            continue;
+        }
+        const commentLength = readUint16(view, offset + 20);
+        if (offset + minimumSize + commentLength === view.byteLength) {
+            return offset;
+        }
+    }
+    throw invalidBundle(".lapis-plugin bundle is not a ZIP-compatible archive.");
+};
+const assertSignature = (view, offset, expected, label) => {
+    assertRange(offset, 4, view.byteLength, label);
+    if (readUint32(view, offset) !== expected) {
+        throw invalidBundle(`Invalid .lapis-plugin ${label}.`);
+    }
+};
+const assertRange = (offset, length, totalLength, label) => {
+    if (!Number.isInteger(offset) ||
+        !Number.isInteger(length) ||
+        offset < 0 ||
+        length < 0 ||
+        offset + length > totalLength) {
+        throw invalidBundle(`Invalid .lapis-plugin ${label} range.`);
+    }
+};
+const readUint16 = (view, offset) => view.getUint16(offset, true);
+const readUint32 = (view, offset) => view.getUint32(offset, true);
+const toUint8 = (input) => input instanceof Uint8Array ? input : new Uint8Array(input);
+const concatChunks = (chunks, byteLength) => {
+    const bytes = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+};
+const toInvalidBundleError = (error) => error instanceof PluginDistributionError
+    ? error
+    : invalidBundle(error instanceof Error
+        ? error.message
+        : ".lapis-plugin bundle is invalid.", error);
+const invalidBundle = (message, cause) => new PluginDistributionError("metadata-invalid", message, { cause });

package/dist/plugin-distribution/plugin-bundle.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugin-distribution/plugin-bundle.worker.js

@@ -0,0 +1,38 @@
+import { serializeWorkerError, } from "./plugin-bundle-worker";
+import { verifyPluginBundlePayload } from "./plugin-bundle-verifier";
+const worker = self;
+worker.addEventListener("message", async (event) => {
+    if (event.data.type !== "verify") {
+        return;
+    }
+    try {
+        const payload = await verifyPluginBundlePayload({
+            bundle: event.data.bundle,
+            trustedKeys: event.data.trustedKeys,
+            expectedBundle: event.data.expectedBundle,
+            onProgress: (progress) => {
+                worker.postMessage({
+                    type: "progress",
+                    progress,
+                });
+            },
+        });
+        const files = [...payload.files.entries()];
+        worker.postMessage({
+            type: "result",
+            payload: {
+                releaseEnvelope: payload.releaseEnvelope,
+                releaseManifest: payload.releaseManifest,
+                releaseManifestSha256: payload.releaseManifestSha256,
+                files,
+            },
+        }, files.map(([, bytes]) => bytes.buffer));
+    }
+    catch (error) {
+        worker.postMessage({
+            type: "error",
+            error: serializeWorkerError(error),
+        });
+    }
+});
+export {};

package/dist/plugin-distribution/registry-cache.d.ts

@@ -0,0 +1,26 @@
+import type { DataAdapter } from "../storage/fs";
+import type { PluginCatalogDetail, PluginCatalogIndex, PluginRevocationIndex } from "./types";
+export interface PluginRegistryCacheRecord {
+    schemaVersion: 1;
+    updatedAt: string;
+    sourceUrl: string;
+    index: PluginCatalogIndex;
+    details: Record<string, PluginCatalogDetail>;
+    revocations?: PluginRevocationIndex;
+}
+export declare class PluginRegistryCache {
+    private readonly options;
+    private memory;
+    constructor(options?: {
+        adapter?: DataAdapter;
+        cachePath?: string;
+        now?: () => Date;
+    });
+    getMemory(): PluginRegistryCacheRecord | null;
+    read(): Promise<PluginRegistryCacheRecord | null>;
+    write(sourceUrl: string, index: PluginCatalogIndex, details?: Record<string, PluginCatalogDetail>, revocations?: PluginRevocationIndex): Promise<PluginRegistryCacheRecord>;
+    putDetail(pluginId: string, detail: PluginCatalogDetail): Promise<PluginRegistryCacheRecord | null>;
+    putRevocations(revocations: PluginRevocationIndex): Promise<PluginRegistryCacheRecord | null>;
+    private get cachePath();
+    private get cacheFolder();
+}

package/dist/plugin-distribution/registry-cache.js

@@ -0,0 +1,85 @@
+import { pluginCatalogDetailSchema, pluginCatalogIndexSchema, pluginRevocationIndexSchema, parsePluginDistributionMetadata, } from "./schemas";
+export class PluginRegistryCache {
+    options;
+    memory = null;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getMemory() {
+        return this.memory;
+    }
+    async read() {
+        if (this.memory)
+            return this.memory;
+        if (!this.options.adapter)
+            return null;
+        try {
+            const raw = await this.options.adapter.read(this.cachePath);
+            const parsed = JSON.parse(raw);
+            this.memory = {
+                schemaVersion: 1,
+                updatedAt: parsed.updatedAt,
+                sourceUrl: parsed.sourceUrl,
+                index: parsePluginDistributionMetadata(pluginCatalogIndexSchema, parsed.index),
+                details: Object.fromEntries(Object.entries(parsed.details ?? {}).map(([pluginId, detail]) => [
+                    pluginId,
+                    parsePluginDistributionMetadata(pluginCatalogDetailSchema, detail),
+                ])),
+                revocations: parsed.revocations
+                    ? parsePluginDistributionMetadata(pluginRevocationIndexSchema, parsed.revocations)
+                    : undefined,
+            };
+            return this.memory;
+        }
+        catch {
+            return null;
+        }
+    }
+    async write(sourceUrl, index, details = {}, revocations) {
+        const record = {
+            schemaVersion: 1,
+            updatedAt: (this.options.now?.() ?? new Date()).toISOString(),
+            sourceUrl,
+            index,
+            details,
+        };
+        if (revocations)
+            record.revocations = revocations;
+        this.memory = record;
+        if (this.options.adapter) {
+            await ensureFolder(this.options.adapter, this.cacheFolder);
+            await this.options.adapter.write(this.cachePath, JSON.stringify(record));
+        }
+        return record;
+    }
+    async putDetail(pluginId, detail) {
+        const existing = await this.read();
+        if (!existing)
+            return null;
+        return this.write(existing.sourceUrl, existing.index, {
+            ...existing.details,
+            [pluginId]: detail,
+        }, existing.revocations);
+    }
+    async putRevocations(revocations) {
+        const existing = await this.read();
+        if (!existing)
+            return null;
+        return this.write(existing.sourceUrl, existing.index, existing.details, revocations);
+    }
+    get cachePath() {
+        return this.options.cachePath ?? ".obsidian/plugin-registry-cache.json";
+    }
+    get cacheFolder() {
+        const parts = this.cachePath.split("/");
+        parts.pop();
+        return parts.join("/") || "/";
+    }
+}
+const ensureFolder = async (adapter, folderPath) => {
+    if (folderPath === "/" || (await adapter.exists(folderPath)))
+        return;
+    const parent = folderPath.split("/").slice(0, -1).join("/") || "/";
+    await ensureFolder(adapter, parent);
+    await adapter.mkdir(folderPath);
+};

package/dist/plugin-distribution/registry-client.d.ts

@@ -0,0 +1,36 @@
+import type { PluginCatalogDetail, PluginCatalogEntry, PluginCatalogIndex, PluginRegistrySource, PluginRevocationIndex, SignatureRecord, TrustedSigningKey } from "./types";
+import { PluginRegistryCache } from "./registry-cache";
+export type PluginRegistryFetch = (url: string, init?: RequestInit) => Promise<Pick<Response, "ok" | "status" | "statusText" | "text">>;
+export interface PluginRegistryRefreshResult {
+    index: PluginCatalogIndex;
+    revocations: PluginRevocationIndex;
+    stale: boolean;
+    source: PluginRegistrySource;
+}
+export interface PluginRegistryDetailResult {
+    detail: PluginCatalogDetail;
+    stale: boolean;
+}
+export declare class PluginRegistryClient {
+    private readonly options;
+    private currentIndex;
+    private readonly fetchImpl;
+    private readonly cache;
+    constructor(options: {
+        trustedKeys: TrustedSigningKey[];
+        fetch?: PluginRegistryFetch;
+        cache?: PluginRegistryCache;
+    });
+    refresh(source: PluginRegistrySource): Promise<PluginRegistryRefreshResult>;
+    getDetail(entry: PluginCatalogEntry): Promise<PluginRegistryDetailResult>;
+    getCachedIndex(): PluginCatalogIndex | null;
+    private fetchJson;
+    private verifyIndex;
+    private fetchRevocations;
+    private verifyDetail;
+    private normalizeEntry;
+    private trustedKeysFor;
+}
+export declare const verifyInlineSignedMetadata: <T extends {
+    signatures?: SignatureRecord[];
+}>(metadata: T, signatures: SignatureRecord[] | undefined, trustedKeys: TrustedSigningKey[]) => Promise<Omit<T, "signatures">>;

package/dist/plugin-distribution/registry-client.js

@@ -0,0 +1,115 @@
+import { PluginDistributionError } from "./errors";
+import { assertPluginIdAllowedForProvenance } from "./reserved-ids";
+import { pluginCatalogDetailSchema, pluginCatalogIndexSchema, pluginRevocationIndexSchema, parsePluginDistributionMetadata, } from "./schemas";
+import { verifySignedEnvelope } from "./signing";
+import { PluginRegistryCache } from "./registry-cache";
+export class PluginRegistryClient {
+    options;
+    currentIndex = null;
+    fetchImpl;
+    cache;
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl =
+            options.fetch ??
+                ((url, init) => globalThis.fetch(url, init));
+        this.cache = options.cache ?? new PluginRegistryCache();
+    }
+    async refresh(source) {
+        try {
+            const metadata = await this.fetchJson(source.url);
+            const index = await this.verifyIndex(metadata, source);
+            const revocations = await this.fetchRevocations(source);
+            this.currentIndex = index;
+            await this.cache.write(source.url, index, {}, revocations);
+            return { index, revocations, stale: false, source };
+        }
+        catch (error) {
+            const cached = await this.cache.read();
+            if (cached && cached.sourceUrl === source.url) {
+                this.currentIndex = cached.index;
+                return {
+                    index: cached.index,
+                    revocations: cached.revocations ?? emptyRevocationIndex(),
+                    stale: true,
+                    source,
+                };
+            }
+            throw error;
+        }
+    }
+    async getDetail(entry) {
+        try {
+            const metadata = await this.fetchJson(entry.detail);
+            const detail = await this.verifyDetail(metadata, entry);
+            await this.cache.putDetail(entry.id, detail);
+            return { detail, stale: false };
+        }
+        catch (error) {
+            const cached = await this.cache.read();
+            const detail = cached?.details[entry.id];
+            if (detail)
+                return { detail, stale: true };
+            throw error;
+        }
+    }
+    getCachedIndex() {
+        return this.currentIndex ?? this.cache.getMemory()?.index ?? null;
+    }
+    async fetchJson(url) {
+        const response = await this.fetchImpl(url);
+        if (!response.ok) {
+            throw new PluginDistributionError("metadata-invalid", `Registry fetch failed for ${url}: ${response.status} ${response.statusText}`, { details: { url, status: response.status } });
+        }
+        return JSON.parse(await response.text());
+    }
+    async verifyIndex(metadata, source) {
+        const index = parsePluginDistributionMetadata(pluginCatalogIndexSchema, metadata);
+        const verified = (await verifyInlineSignedMetadata(index, index.signatures, this.trustedKeysFor(source.trustTier)));
+        return {
+            ...verified,
+            plugins: verified.plugins.map((entry) => this.normalizeEntry(entry, source)),
+        };
+    }
+    async fetchRevocations(source) {
+        const url = new URL("revoked.json", source.url).toString();
+        const metadata = await this.fetchJson(url);
+        const revocations = parsePluginDistributionMetadata(pluginRevocationIndexSchema, metadata);
+        const verified = await verifyInlineSignedMetadata(revocations, revocations.signatures, this.trustedKeysFor(source.trustTier));
+        return verified;
+    }
+    async verifyDetail(metadata, entry) {
+        const detail = parsePluginDistributionMetadata(pluginCatalogDetailSchema, metadata);
+        const verified = (await verifyInlineSignedMetadata(detail, detail.signatures, this.options.trustedKeys));
+        if (verified.id !== entry.id) {
+            throw new PluginDistributionError("metadata-invalid", `Plugin detail id ${verified.id} does not match catalog entry ${entry.id}.`, { details: { entryId: entry.id, detailId: verified.id } });
+        }
+        return verified;
+    }
+    normalizeEntry(entry, source) {
+        const provenance = source.trustTier === "official" ? "official" : "community";
+        assertPluginIdAllowedForProvenance(entry.id, provenance);
+        if (entry.channel === "official" && source.trustTier !== "official") {
+            throw new PluginDistributionError("metadata-invalid", `Non-official registry source ${source.id} cannot publish official entry ${entry.id}.`, { details: { sourceId: source.id, pluginId: entry.id } });
+        }
+        return {
+            ...entry,
+            detail: new URL(entry.detail, source.url).toString(),
+        };
+    }
+    trustedKeysFor(trustTier) {
+        return this.options.trustedKeys.filter((key) => key.trustTier === trustTier || key.trustTier === "official");
+    }
+}
+export const verifyInlineSignedMetadata = async (metadata, signatures, trustedKeys) => {
+    if (!signatures?.length) {
+        throw new PluginDistributionError("signature-invalid", "Signed registry metadata did not include any signatures.");
+    }
+    const { signatures: _signatures, ...signed } = metadata;
+    return verifySignedEnvelope({ signed, signatures }, trustedKeys);
+};
+const emptyRevocationIndex = () => ({
+    schemaVersion: 1,
+    generatedAt: new Date(0).toISOString(),
+    revoked: [],
+});

package/dist/plugin-distribution/reserved-ids.d.ts

@@ -0,0 +1,4 @@
+import type { PluginProvenance } from "./types";
+export declare const isReservedPluginId: (pluginId: string) => boolean;
+export declare const assertPluginIdAllowedForProvenance: (pluginId: string, provenance: PluginProvenance) => void;
+export declare const provenanceFromPluginManifest: (_manifest?: unknown) => "community";

package/dist/plugin-distribution/reserved-ids.js

@@ -0,0 +1,10 @@
+import { PluginDistributionError } from "./errors";
+const RESERVED_PREFIXES = ["lapis-"];
+export const isReservedPluginId = (pluginId) => RESERVED_PREFIXES.some((prefix) => pluginId.startsWith(prefix));
+export const assertPluginIdAllowedForProvenance = (pluginId, provenance) => {
+    if (isReservedPluginId(pluginId) &&
+        (provenance === "community" || provenance === "manual")) {
+        throw new PluginDistributionError("reserved-id", `Plugin id ${pluginId} is reserved for bundled, official, or development plugins.`, { details: { pluginId, provenance } });
+    }
+};
+export const provenanceFromPluginManifest = (_manifest) => "community";

package/dist/plugin-distribution/runtime-validation.d.ts

@@ -0,0 +1,14 @@
+import type { PluginManifest } from "../plugin";
+import type { PluginProvenance, PluginReleaseManifest, PluginReleaseRuntimeDiagnostic } from "./types";
+export interface PluginReleaseRuntimeValidationOptions {
+    releaseManifest: PluginReleaseManifest;
+    pluginManifest: PluginManifest;
+    files: ReadonlyMap<string, Uint8Array>;
+    provenance?: PluginProvenance;
+}
+export interface PluginReleaseRuntimeValidationResult {
+    diagnostics: PluginReleaseRuntimeDiagnostic[];
+    errors: PluginReleaseRuntimeDiagnostic[];
+    warnings: PluginReleaseRuntimeDiagnostic[];
+}
+export declare function validatePluginReleaseRuntime(options: PluginReleaseRuntimeValidationOptions): PluginReleaseRuntimeValidationResult;