@lapis-notes/api 0.1.0

package/dist/plugin-distribution/manager.js

@@ -0,0 +1,358 @@
+import { EventDispatcher } from "../events";
+import { hasNativeDesktopCapability } from "../storage/desktop-native";
+import { checkCatalogEntryCompatibility, checkCatalogReleaseCompatibility, compareVersions, } from "./compatibility";
+import { PluginDistributionError } from "./errors";
+import { InstalledPluginStateStore } from "./installed-plugin-state";
+import { VerifiedPluginInstaller, } from "./installer";
+import { PluginRegistryCache } from "./registry-cache";
+import { PluginRegistryClient } from "./registry-client";
+export const DEFAULT_OFFICIAL_PLUGIN_REGISTRY_SOURCE = {
+    id: "lapis-official",
+    name: "Lapis Official Plugins",
+    url: "https://registry.lapis.md/v1/index.json",
+    trustTier: "official",
+    enabled: true,
+    builtin: true,
+};
+export const DEFAULT_PLUGIN_REGISTRY_SOURCES = [
+    DEFAULT_OFFICIAL_PLUGIN_REGISTRY_SOURCE,
+];
+export const EMBEDDED_PLUGIN_REGISTRY_KEYS = [
+    {
+        keyId: "lapis-registry-2026-06",
+        alg: "ed25519",
+        publicKey: "/MmGQHJ5rOUECVsU5Ee/PLTouW8V3TyxGBnPKJT87JA=",
+        trustTier: "official",
+    },
+    {
+        keyId: "lapis-plugin-release-2026-06",
+        alg: "ed25519",
+        publicKey: "bMPnlO7b+Xtthfk5wGUQAWWUV7NuIAhED4kX2EGzJqc=",
+        trustTier: "official",
+    },
+];
+export class DefaultPluginDistributionManager extends EventDispatcher {
+    options;
+    catalog = null;
+    registryClient;
+    stateStore;
+    installer;
+    registries;
+    trustedKeys;
+    installedIds = new Set();
+    revocations = null;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.registries = options.registries ?? DEFAULT_PLUGIN_REGISTRY_SOURCES;
+        this.trustedKeys = options.trustedKeys ?? EMBEDDED_PLUGIN_REGISTRY_KEYS;
+        this.stateStore = new InstalledPluginStateStore(options.adapter);
+        this.registryClient = new PluginRegistryClient({
+            trustedKeys: this.trustedKeys,
+            fetch: options.fetch,
+            cache: new PluginRegistryCache({ adapter: options.adapter }),
+        });
+        this.installer = new VerifiedPluginInstaller({
+            adapter: options.adapter,
+            trustedKeys: this.trustedKeys,
+            fetch: options.fetch,
+            stateStore: this.stateStore,
+            pluginManager: options.pluginManager,
+            bundleVerification: options.bundleVerification ??
+                (this.platform === "web" ? "auto" : "main-thread"),
+        });
+    }
+    async refreshCatalog(_options = {}) {
+        this.emitProgress("*", "fetching-catalog");
+        const source = this.registries.find((registry) => registry.enabled);
+        if (!source) {
+            this.catalog = {
+                schemaVersion: 1,
+                generatedAt: new Date(0).toISOString(),
+                plugins: [],
+            };
+            return this.catalog;
+        }
+        const refreshed = await this.registryClient.refresh(source);
+        this.catalog = refreshed.index;
+        this.revocations = refreshed.revocations;
+        await this.applyRevocationsToInstalled();
+        return refreshed.index;
+    }
+    search(query = {}) {
+        const text = query.text?.trim().toLowerCase();
+        return (this.catalog?.plugins ?? []).filter((entry) => {
+            if (text) {
+                const haystack = `${entry.name} ${entry.id} ${entry.description} ${entry.author}`.toLowerCase();
+                if (!haystack.includes(text))
+                    return false;
+            }
+            if (query.category && !entry.categories.includes(query.category)) {
+                return false;
+            }
+            if (query.channel &&
+                query.channel !== "all" &&
+                entry.channel !== query.channel) {
+                return false;
+            }
+            if (typeof query.installed === "boolean" &&
+                this.installedIds.has(entry.id) !== query.installed) {
+                return false;
+            }
+            if (query.compatibleOnly) {
+                const compatibility = checkCatalogEntryCompatibility(entry, this.compatibilityInput(false));
+                if (!compatibility.compatible)
+                    return false;
+            }
+            return true;
+        });
+    }
+    getCatalogEntry(pluginId) {
+        return this.catalog?.plugins.find((entry) => entry.id === pluginId);
+    }
+    async getPluginDetail(pluginId) {
+        const entry = this.getCatalogEntry(pluginId);
+        if (!entry)
+            return null;
+        const result = await this.registryClient.getDetail(entry);
+        return result.detail;
+    }
+    async install(pluginId, options = {}) {
+        try {
+            this.emitProgress(pluginId, "resolving", "Resolving plugin");
+            const entry = this.requireEntry(pluginId);
+            if (options.requireOfficial && entry.channel !== "official") {
+                throw new PluginDistributionError("metadata-invalid", `Plugin ${pluginId} is not an official registry entry.`);
+            }
+            const entryCompatibility = checkCatalogEntryCompatibility(entry, this.compatibilityInput(false));
+            if (!entryCompatibility.compatible) {
+                throw new PluginDistributionError("compatibility-failed", `Plugin ${pluginId} is not compatible: ${entryCompatibility.reasons.join(", ")}`, { details: { reasons: entryCompatibility.reasons } });
+            }
+            this.emitProgress(pluginId, "fetching-release", "Fetching release metadata");
+            const detail = await this.getPluginDetail(pluginId);
+            if (!detail) {
+                throw new PluginDistributionError("metadata-invalid", `Plugin ${pluginId} is missing registry detail metadata.`);
+            }
+            const release = detail.versions[options.version ?? detail.latestVersion];
+            if (!release) {
+                throw new PluginDistributionError("metadata-invalid", `Plugin ${pluginId} has no requested release.`);
+            }
+            const releaseCompatibility = checkCatalogReleaseCompatibility(release, this.compatibilityInput(false));
+            if (!releaseCompatibility.compatible) {
+                throw new PluginDistributionError("compatibility-failed", `Plugin ${pluginId} release is not compatible: ${releaseCompatibility.reasons.join(", ")}`, { details: { reasons: releaseCompatibility.reasons } });
+            }
+            this.emitProgress(pluginId, "verifying-signature", "Verifying release signature");
+            const installOptions = {
+                entry,
+                detail,
+                version: options.version,
+                enable: options.enable,
+                registryId: options.registryId ?? this.sourceForEntry(entry)?.id,
+                registryUrl: this.sourceForEntry(entry)?.url,
+                provenance: entry.channel,
+                compatibility: this.compatibilityInput(await this.isWorkspaceTrusted()),
+                signal: options.signal,
+                onProgress: ({ phase, message, ...details }) => {
+                    this.emitProgress(pluginId, phase, message, details);
+                },
+            };
+            const record = await this.installer.install(installOptions);
+            this.installedIds.add(pluginId);
+            this.emitProgress(pluginId, "complete", "Plugin installed");
+            return record;
+        }
+        catch (error) {
+            this.emitProgress(pluginId, "failed", error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    }
+    async installBundle(bundle, options = {}) {
+        let progressPluginId = "*";
+        try {
+            this.emitProgress(progressPluginId, "verifying-signature", "Verifying plugin bundle");
+            const installOptions = {
+                bundle,
+                enable: options.enable,
+                provenance: "official",
+                compatibility: this.compatibilityInput(await this.isWorkspaceTrusted()),
+                signal: options.signal,
+                onProgress: ({ phase, message, ...details }) => {
+                    this.emitProgress(progressPluginId, phase, message, details);
+                },
+            };
+            const record = await this.installer.installBundle(installOptions);
+            progressPluginId = record.pluginId;
+            this.installedIds.add(record.pluginId);
+            this.emitProgress(record.pluginId, "complete", "Plugin installed");
+            return record;
+        }
+        catch (error) {
+            this.emitProgress(progressPluginId, "failed", error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    }
+    async update(pluginId, version, options = {}) {
+        const installed = await this.getInstalled(pluginId);
+        const entry = this.getCatalogEntry(pluginId);
+        if (!installed || !entry)
+            return null;
+        const targetVersion = version ?? installed.revoked?.replacementVersion ?? entry.latestVersion;
+        if (compareVersions(targetVersion, installed.installedVersion) <= 0) {
+            return installed;
+        }
+        const wasEnabled = Boolean(this.options.pluginManager?.isPluginEnabled?.(pluginId));
+        const updated = await this.install(pluginId, {
+            version: targetVersion,
+            enable: wasEnabled,
+            signal: options.signal,
+        });
+        if (updated.installedAt !== installed.installedAt) {
+            const merged = { ...updated, installedAt: installed.installedAt };
+            await this.stateStore.upsert(merged);
+            return merged;
+        }
+        return updated;
+    }
+    async uninstall(pluginId, options = {}) {
+        await this.installer.uninstall(pluginId, options);
+        this.installedIds.delete(pluginId);
+    }
+    async listInstalled() {
+        const installed = await this.stateStore.list();
+        this.installedIds = new Set(installed.map((record) => record.pluginId));
+        return installed;
+    }
+    getInstalled(pluginId) {
+        return this.stateStore.get(pluginId);
+    }
+    async listUpdates() {
+        const installed = await this.listInstalled();
+        const updates = [];
+        for (const record of installed) {
+            if (record.provenance !== "official")
+                continue;
+            const entry = this.getCatalogEntry(record.pluginId);
+            const revoked = this.revocationFor(record) ?? record.revoked;
+            if (!entry) {
+                if (revoked) {
+                    updates.push({
+                        id: record.pluginId,
+                        name: record.pluginId,
+                        currentVersion: record.installedVersion,
+                        latestVersion: record.installedVersion,
+                        targetVersion: record.installedVersion,
+                        provenance: record.provenance,
+                        registryId: record.registryId,
+                        compatible: false,
+                        canUpdate: false,
+                        status: "revoked",
+                        reasons: ["revoked"],
+                        revoked,
+                    });
+                }
+                continue;
+            }
+            const targetVersion = revoked?.replacementVersion ?? entry.latestVersion;
+            const hasNewerTarget = compareVersions(targetVersion, record.installedVersion) > 0;
+            if (!hasNewerTarget && !revoked)
+                continue;
+            let compatibility = checkCatalogEntryCompatibility(entry, this.compatibilityInput(false));
+            const detail = await this.getPluginDetail(record.pluginId);
+            const targetRelease = detail?.versions[targetVersion];
+            if (targetRelease) {
+                compatibility = checkCatalogReleaseCompatibility(targetRelease, this.compatibilityInput(false));
+            }
+            const canUpdate = hasNewerTarget && compatibility.compatible;
+            const update = {
+                id: record.pluginId,
+                name: entry.name,
+                currentVersion: record.installedVersion,
+                latestVersion: entry.latestVersion,
+                targetVersion,
+                provenance: record.provenance,
+                registryId: record.registryId,
+                compatible: compatibility.compatible,
+                canUpdate,
+                bundleSize: targetRelease?.bundle.size,
+                status: revoked
+                    ? "revoked"
+                    : compatibility.compatible
+                        ? "update-available"
+                        : "incompatible",
+                reasons: compatibility.reasons,
+            };
+            if (revoked)
+                update.revoked = revoked;
+            updates.push(update);
+        }
+        return updates;
+    }
+    addProgressListener(listener) {
+        this.on("progress", listener);
+        return () => this.off("progress", listener);
+    }
+    requireEntry(pluginId) {
+        const entry = this.getCatalogEntry(pluginId);
+        if (!entry) {
+            throw new PluginDistributionError("metadata-invalid", `Plugin ${pluginId} is not in the current registry catalog.`);
+        }
+        return entry;
+    }
+    sourceForEntry(entry) {
+        return (this.registries.find((source) => source.enabled &&
+            (entry.channel === "official") === (source.trustTier === "official")) ?? null);
+    }
+    compatibilityInput(workspaceTrusted) {
+        return {
+            appVersion: this.options.appVersion,
+            platform: this.platform,
+            workspaceTrusted,
+        };
+    }
+    get platform() {
+        return (this.options.platform ??
+            (hasNativeDesktopCapability("resource") ? "electron" : "web"));
+    }
+    async isWorkspaceTrusted() {
+        return Boolean(await this.options.workspaceTrusted?.());
+    }
+    async applyRevocationsToInstalled() {
+        const installed = await this.stateStore.list();
+        for (const record of installed) {
+            if (record.provenance !== "official")
+                continue;
+            const revoked = this.revocationFor(record);
+            if (sameRevocation(record.revoked, revoked))
+                continue;
+            const next = {
+                ...record,
+                updatedAt: new Date().toISOString(),
+            };
+            if (revoked) {
+                next.revoked = revoked;
+            }
+            else {
+                delete next.revoked;
+            }
+            await this.stateStore.upsert(next);
+        }
+    }
+    revocationFor(record) {
+        const match = this.revocations?.revoked.find((revocation) => revocation.pluginId === record.pluginId &&
+            revocation.versions.includes(record.installedVersion));
+        if (!match)
+            return undefined;
+        const { pluginId: _pluginId, versions: _versions, ...revocation } = match;
+        return revocation;
+    }
+    emitProgress(pluginId, phase, message, details = {}) {
+        this.dispatch("progress", { pluginId, phase, message, ...details });
+    }
+}
+const sameRevocation = (left, right) => (!left && !right) ||
+    Boolean(left &&
+        right &&
+        left.revokedAt === right.revokedAt &&
+        left.reason === right.reason &&
+        left.message === right.message &&
+        left.replacementVersion === right.replacementVersion);

package/dist/plugin-distribution/path-safety.d.ts

@@ -0,0 +1,2 @@
+export declare const assertSafePluginRelativePath: (path: string) => void;
+export declare const isSafePluginRelativePath: (path: string) => boolean;

package/dist/plugin-distribution/path-safety.js

@@ -0,0 +1,20 @@
+import { PluginDistributionError } from "./errors";
+export const assertSafePluginRelativePath = (path) => {
+    if (path.length === 0 ||
+        path.startsWith("/") ||
+        path.startsWith("\\") ||
+        path.includes("\\") ||
+        path.includes("\0") ||
+        path.split("/").some((part) => part === "" || part === "." || part === "..")) {
+        throw new PluginDistributionError("invalid-path", `Plugin release file path is not safe: ${path}`, { details: { path } });
+    }
+};
+export const isSafePluginRelativePath = (path) => {
+    try {
+        assertSafePluginRelativePath(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

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

@@ -0,0 +1,28 @@
+import type { PluginReleaseManifest, RemoteFileReference, SignedEnvelope, TrustedSigningKey } from "./types";
+export type PluginBundleVerificationProgressPhase = "verifying-bundle" | "extracting-files" | "verifying-files";
+export interface PluginBundleVerificationProgressEvent {
+    phase: PluginBundleVerificationProgressPhase;
+    message?: string;
+    filePath?: string;
+    fileIndex?: number;
+    fileCount?: number;
+    processedBytes?: number;
+    totalBytes?: number;
+}
+export interface VerifyPluginBundlePayloadOptions {
+    bundle: ArrayBuffer | Uint8Array;
+    trustedKeys: TrustedSigningKey[];
+    expectedBundle?: RemoteFileReference;
+    signal?: AbortSignal;
+    onProgress?: (event: PluginBundleVerificationProgressEvent) => void;
+}
+export interface VerifiedPluginBundlePayload {
+    releaseEnvelope: SignedEnvelope<PluginReleaseManifest>;
+    releaseManifest: PluginReleaseManifest;
+    releaseManifestSha256: string;
+    files: Map<string, Uint8Array>;
+}
+export declare const verifyPluginBundlePayload: (options: VerifyPluginBundlePayloadOptions) => Promise<VerifiedPluginBundlePayload>;
+export declare function throwIfAborted(signal: AbortSignal | undefined): void;
+export declare function createAbortError(): Error;
+export declare function exactArrayBuffer(bytes: Uint8Array): ArrayBuffer;

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

@@ -0,0 +1,96 @@
+import { sha256Hex, verifySha256 } from "./hashes";
+import { assertSafePluginRelativePath } from "./path-safety";
+import { PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH, parsePluginBundle, } from "./plugin-bundle";
+import { parsePluginDistributionMetadata, pluginReleaseManifestSchema, signedEnvelopeSchema, } from "./schemas";
+import { verifySignedEnvelope } from "./signing";
+import { PluginDistributionError } from "./errors";
+export const verifyPluginBundlePayload = async (options) => {
+    throwIfAborted(options.signal);
+    const bundle = toUint8(options.bundle);
+    options.onProgress?.({
+        phase: "verifying-bundle",
+        message: "Verifying plugin bundle",
+    });
+    if (typeof options.expectedBundle?.size === "number" &&
+        bundle.byteLength !== options.expectedBundle.size) {
+        throw new PluginDistributionError("hash-mismatch", `Plugin bundle size mismatch: expected ${options.expectedBundle.size}, got ${bundle.byteLength}.`, {
+            details: {
+                expectedSize: options.expectedBundle.size,
+                actualSize: bundle.byteLength,
+            },
+        });
+    }
+    if (options.expectedBundle?.sha256) {
+        await verifySha256(bundle, options.expectedBundle.sha256);
+    }
+    throwIfAborted(options.signal);
+    const bundledFiles = parsePluginBundle(bundle, {
+        onProgress: options.onProgress,
+    });
+    const signedReleaseBytes = bundledFiles.get(PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH);
+    if (!signedReleaseBytes) {
+        throw new PluginDistributionError("metadata-invalid", "Plugin bundle is missing release.signed.json.");
+    }
+    const releaseEnvelope = parsePluginDistributionMetadata(signedEnvelopeSchema(pluginReleaseManifestSchema), JSON.parse(new TextDecoder().decode(signedReleaseBytes)));
+    const releaseManifest = await verifySignedEnvelope(releaseEnvelope, options.trustedKeys);
+    const files = new Map();
+    const expectedPaths = new Set();
+    const fileCount = releaseManifest.files.length;
+    for (const [index, file] of releaseManifest.files.entries()) {
+        throwIfAborted(options.signal);
+        assertSafePluginRelativePath(file.path);
+        expectedPaths.add(file.path);
+        const bytes = bundledFiles.get(file.path);
+        if (!bytes) {
+            throw new PluginDistributionError("metadata-invalid", `Plugin bundle is missing signed file: ${file.path}`, { details: { path: file.path } });
+        }
+        if (bytes.byteLength !== file.size) {
+            throw new PluginDistributionError("hash-mismatch", `Plugin file ${file.path} size mismatch: expected ${file.size}, got ${bytes.byteLength}.`, {
+                details: {
+                    path: file.path,
+                    expectedSize: file.size,
+                    actualSize: bytes.byteLength,
+                },
+            });
+        }
+        options.onProgress?.({
+            phase: "verifying-files",
+            message: `Verifying ${file.path}`,
+            filePath: file.path,
+            fileIndex: index + 1,
+            fileCount,
+        });
+        await verifySha256(bytes, file.sha256);
+        files.set(file.path, bytes);
+    }
+    const extraPaths = [...bundledFiles.keys()].filter((path) => path !== PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH && !expectedPaths.has(path));
+    if (extraPaths.length) {
+        throw new PluginDistributionError("metadata-invalid", "Plugin bundle includes files that are not listed in the signed release manifest.", { details: { paths: extraPaths } });
+    }
+    return {
+        releaseEnvelope,
+        releaseManifest,
+        releaseManifestSha256: await sha256Hex(signedReleaseBytes),
+        files,
+    };
+};
+export function throwIfAborted(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    throw createAbortError();
+}
+export function createAbortError() {
+    if (typeof DOMException !== "undefined") {
+        return new DOMException("Operation cancelled", "AbortError");
+    }
+    const error = new Error("Operation cancelled");
+    error.name = "AbortError";
+    return error;
+}
+export function exactArrayBuffer(bytes) {
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return copy.buffer;
+}
+const toUint8 = (input) => input instanceof Uint8Array ? input : new Uint8Array(input);

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

@@ -0,0 +1,34 @@
+import { type PluginBundleVerificationProgressEvent, type VerifiedPluginBundlePayload, type VerifyPluginBundlePayloadOptions } from "./plugin-bundle-verifier";
+import type { PluginReleaseManifest, RemoteFileReference, SignedEnvelope, TrustedSigningKey } from "./types";
+export type PluginBundleVerificationMode = "auto" | "worker" | "main-thread";
+export interface PluginBundleWorkerVerifyRequest {
+    type: "verify";
+    bundle: ArrayBuffer;
+    trustedKeys: TrustedSigningKey[];
+    expectedBundle?: RemoteFileReference;
+}
+export type PluginBundleWorkerResponse = {
+    type: "progress";
+    progress: PluginBundleVerificationProgressEvent;
+} | {
+    type: "result";
+    payload: SerializedVerifiedPluginBundlePayload;
+} | {
+    type: "error";
+    error: SerializedPluginBundleWorkerError;
+};
+export interface SerializedVerifiedPluginBundlePayload {
+    releaseEnvelope: SignedEnvelope<PluginReleaseManifest>;
+    releaseManifest: PluginReleaseManifest;
+    releaseManifestSha256: string;
+    files: Array<[string, Uint8Array]>;
+}
+export interface SerializedPluginBundleWorkerError {
+    name: string;
+    message: string;
+    code?: string;
+    details?: Record<string, unknown>;
+}
+export declare const canUsePluginBundleWorker: () => boolean;
+export declare const verifyPluginBundlePayloadInWorker: (options: VerifyPluginBundlePayloadOptions) => Promise<VerifiedPluginBundlePayload>;
+export declare const serializeWorkerError: (error: unknown) => SerializedPluginBundleWorkerError;

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

@@ -0,0 +1,99 @@
+import { PluginDistributionError } from "./errors";
+import { createAbortError, exactArrayBuffer, } from "./plugin-bundle-verifier";
+export const canUsePluginBundleWorker = () => typeof Worker !== "undefined";
+export const verifyPluginBundlePayloadInWorker = async (options) => {
+    if (!canUsePluginBundleWorker()) {
+        throw new Error("Plugin bundle worker is not available.");
+    }
+    const bundle = exactArrayBuffer(toUint8(options.bundle));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let worker = null;
+        const settle = (callback, abortListener) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (abortListener) {
+                options.signal?.removeEventListener("abort", abortListener);
+            }
+            worker?.terminate();
+            callback();
+        };
+        const abortListener = () => {
+            settle(() => reject(createAbortError()), abortListener);
+        };
+        try {
+            worker = createPluginBundleWorker();
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        if (options.signal?.aborted) {
+            worker.terminate();
+            reject(createAbortError());
+            return;
+        }
+        const activeWorker = worker;
+        options.signal?.addEventListener("abort", abortListener, { once: true });
+        activeWorker.addEventListener("message", (event) => {
+            const message = event.data;
+            if (message.type === "progress") {
+                options.onProgress?.(message.progress);
+                return;
+            }
+            if (message.type === "result") {
+                settle(() => resolve(deserializeVerifiedPayload(message.payload)), abortListener);
+                return;
+            }
+            if (message.type === "error") {
+                settle(() => reject(deserializeWorkerError(message.error)), abortListener);
+            }
+        });
+        activeWorker.addEventListener("error", (event) => {
+            const message = event.message;
+            settle(() => reject(new Error(message || "Plugin bundle worker verification failed.")), abortListener);
+        });
+        activeWorker.postMessage({
+            type: "verify",
+            bundle,
+            trustedKeys: options.trustedKeys,
+            ...(options.expectedBundle
+                ? { expectedBundle: options.expectedBundle }
+                : {}),
+        }, [bundle]);
+    });
+};
+export const serializeWorkerError = (error) => {
+    if (error instanceof PluginDistributionError) {
+        return {
+            name: error.name,
+            message: error.message,
+            code: error.code,
+            details: error.details,
+        };
+    }
+    if (error instanceof Error) {
+        return { name: error.name, message: error.message };
+    }
+    return { name: "Error", message: String(error) };
+};
+const createPluginBundleWorker = () => new Worker(new URL("./plugin-bundle.worker.js", import.meta.url), {
+    type: "module",
+});
+const deserializeVerifiedPayload = (payload) => ({
+    releaseEnvelope: payload.releaseEnvelope,
+    releaseManifest: payload.releaseManifest,
+    releaseManifestSha256: payload.releaseManifestSha256,
+    files: new Map(payload.files),
+});
+const deserializeWorkerError = (error) => {
+    if (error.code) {
+        return new PluginDistributionError(error.code, error.message, { details: error.details });
+    }
+    const deserialized = new Error(error.message);
+    deserialized.name = error.name;
+    return deserialized;
+};
+const toUint8 = (input) => input instanceof Uint8Array ? input : new Uint8Array(input);

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

@@ -0,0 +1,16 @@
+export declare const PLUGIN_BUNDLE_RELEASE_MANIFEST_PATH = "release.signed.json";
+export declare const PLUGIN_BUNDLE_STORED_METHOD = 0;
+export declare const PLUGIN_BUNDLE_DEFLATE_METHOD = 8;
+export interface ParsePluginBundleProgressEvent {
+    phase: "extracting-files";
+    message?: string;
+    filePath?: string;
+    fileIndex?: number;
+    fileCount?: number;
+    processedBytes?: number;
+    totalBytes?: number;
+}
+export interface ParsePluginBundleOptions {
+    onProgress?: (event: ParsePluginBundleProgressEvent) => void;
+}
+export declare const parsePluginBundle: (input: ArrayBuffer | Uint8Array, options?: ParsePluginBundleOptions) => Map<string, Uint8Array>;