@lapis-notes/api 0.1.0

package/dist/platform.d.ts

@@ -0,0 +1,86 @@
+export declare const Platform: {
+    /**
+     * The UI is in desktop mode.
+     *
+     * @public
+     */
+    isDesktop: boolean;
+    /**
+     * The UI is in mobile mode.
+     *
+     * @public
+     */
+    isMobile: boolean;
+    /**
+     * We're running the native desktop app.
+     *
+     * @public
+     */
+    isDesktopApp: boolean;
+    /**
+     * We're running the capacitor-js mobile app.
+     *
+     * @public
+     */
+    isMobileApp: boolean;
+    /**
+     * We're running the iOS app.
+     *
+     * @public
+     */
+    isIosApp: boolean;
+    /**
+     * We're running the Android app.
+     *
+     * @public
+     */
+    isAndroidApp: boolean;
+    /**
+     * We're in a mobile app that has very limited screen space.
+     *
+     * @public
+     */
+    isPhone: boolean;
+    /**
+     * We're in a mobile app that has sufficiently large screen space.
+     *
+     * @public
+     */
+    isTablet: boolean;
+    /**
+     * We're on a macOS device, or a device that pretends to be one (like iPhones
+     * and iPads). Typically used to detect whether to use command-based hotkeys
+     * vs ctrl-based hotkeys.
+     *
+     * @public
+     */
+    isMacOS: boolean;
+    /**
+     * We're on a Windows device.
+     *
+     * @public
+     */
+    isWin: boolean;
+    /**
+     * We're on a Linux device.
+     *
+     * @public
+     */
+    isLinux: boolean;
+    /**
+     * We're running in Safari. Typically used to provide workarounds for Safari
+     * bugs.
+     *
+     * @public
+     */
+    isSafari: boolean;
+    /**
+     * The path prefix for resolving local files on this platform. This returns:
+     *
+     * - `file:///` on mobile
+     * - `app://random-id/` on desktop (Replaces the old format of `app://local/`)
+     *
+     * @public
+     */
+    resourcePathPrefix: string;
+};

package/dist/platform.js

@@ -0,0 +1,86 @@
+export const Platform = {
+    /**
+     * The UI is in desktop mode.
+     *
+     * @public
+     */
+    isDesktop: true,
+    /**
+     * The UI is in mobile mode.
+     *
+     * @public
+     */
+    isMobile: false,
+    /**
+     * We're running the native desktop app.
+     *
+     * @public
+     */
+    isDesktopApp: true,
+    /**
+     * We're running the capacitor-js mobile app.
+     *
+     * @public
+     */
+    isMobileApp: false,
+    /**
+     * We're running the iOS app.
+     *
+     * @public
+     */
+    isIosApp: false,
+    /**
+     * We're running the Android app.
+     *
+     * @public
+     */
+    isAndroidApp: false,
+    /**
+     * We're in a mobile app that has very limited screen space.
+     *
+     * @public
+     */
+    isPhone: false,
+    /**
+     * We're in a mobile app that has sufficiently large screen space.
+     *
+     * @public
+     */
+    isTablet: false,
+    /**
+     * We're on a macOS device, or a device that pretends to be one (like iPhones
+     * and iPads). Typically used to detect whether to use command-based hotkeys
+     * vs ctrl-based hotkeys.
+     *
+     * @public
+     */
+    isMacOS: true,
+    /**
+     * We're on a Windows device.
+     *
+     * @public
+     */
+    isWin: false,
+    /**
+     * We're on a Linux device.
+     *
+     * @public
+     */
+    isLinux: false,
+    /**
+     * We're running in Safari. Typically used to provide workarounds for Safari
+     * bugs.
+     *
+     * @public
+     */
+    isSafari: false,
+    /**
+     * The path prefix for resolving local files on this platform. This returns:
+     *
+     * - `file:///` on mobile
+     * - `app://random-id/` on desktop (Replaces the old format of `app://local/`)
+     *
+     * @public
+     */
+    resourcePathPrefix: "/",
+};

package/dist/plugin-asset-server.d.ts

@@ -0,0 +1,60 @@
+import type { InstalledPluginRecord } from "./plugin-distribution/types";
+export declare const WEB_PLUGIN_ASSET_ROUTE_PREFIX = "/__lapis/plugins";
+export declare const WEB_PLUGIN_ASSET_CACHE_NAME = "lapis-plugin-assets-v1";
+/** Compatibility classifier for installed-plugin diagnostics; not a host. */
+export declare const ELECTRON_PLUGIN_ASSET_SCHEME = "lapis-plugin";
+export type PluginAssetServerErrorCode = "asset-server-unavailable" | "invalid-url" | "invalid-path" | "unsupported-asset-type" | "asset-not-installed" | "asset-not-found" | "asset-size-mismatch" | "asset-hash-mismatch" | "asset-version-mismatch";
+export declare class PluginAssetServerError extends Error {
+    readonly code: PluginAssetServerErrorCode;
+    readonly details?: Record<string, unknown>;
+    readonly cause?: unknown;
+    constructor(code: PluginAssetServerErrorCode, message: string, options?: {
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+export declare const isPluginAssetServerError: (error: unknown) => error is PluginAssetServerError;
+export interface PluginAssetUrlParts {
+    vaultId: string;
+    pluginId: string;
+    version: string;
+    sha256: string;
+    path: string;
+}
+export interface PluginAssetUrlRequest {
+    pluginId: string;
+    pluginPath: string;
+    relativePath: string;
+    version: string;
+}
+export interface PluginAssetServer {
+    getPluginAssetUrl(request: PluginAssetUrlRequest): Promise<string> | string;
+}
+export interface PluginAssetDataAdapter {
+    readBinary(path: string): Promise<ArrayBuffer>;
+}
+export interface InstalledPluginAssetReadOptions {
+    adapter: PluginAssetDataAdapter;
+    installedPlugin: InstalledPluginRecord;
+    relativePath: string;
+    expectedSha256?: string;
+    pluginsPath?: string;
+    verifyHash?: boolean;
+}
+export interface InstalledPluginAsset {
+    bytes: Uint8Array;
+    contentType: string;
+    path: string;
+    sha256: string;
+    size: number;
+}
+export declare function createWebPluginAssetUrl(parts: PluginAssetUrlParts): string;
+export declare function parseWebPluginAssetUrl(value: string, base?: string): PluginAssetUrlParts;
+export declare function getInstalledPluginAssetVersion(record: InstalledPluginRecord): string;
+export declare function getInstalledPluginAssetHash(record: InstalledPluginRecord, relativePath: string): string;
+export declare function getInstalledPluginAssetFingerprint(record: InstalledPluginRecord): string;
+export declare function isSupportedPluginAssetPath(path: string): boolean;
+export declare function assertSupportedPluginAssetPath(path: string): void;
+export declare function getPluginAssetContentType(path: string): string;
+export declare function readInstalledPluginAsset({ adapter, installedPlugin, relativePath, expectedSha256, pluginsPath, verifyHash, }: InstalledPluginAssetReadOptions): Promise<InstalledPluginAsset>;
+export declare function normalizePluginAssetRelativePath(path: string): string;

package/dist/plugin-asset-server.js

@@ -0,0 +1,222 @@
+import { joinPath } from "./storage/path";
+import { assertSafePluginRelativePath } from "./plugin-distribution/path-safety";
+import { sha256Hex } from "./plugin-distribution/hashes";
+export const WEB_PLUGIN_ASSET_ROUTE_PREFIX = "/__lapis/plugins";
+export const WEB_PLUGIN_ASSET_CACHE_NAME = "lapis-plugin-assets-v1";
+/** Compatibility classifier for installed-plugin diagnostics; not a host. */
+export const ELECTRON_PLUGIN_ASSET_SCHEME = "lapis-plugin";
+export class PluginAssetServerError extends Error {
+    code;
+    details;
+    cause;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = "PluginAssetServerError";
+        this.code = code;
+        this.details = options.details;
+        this.cause = options.cause;
+    }
+}
+export const isPluginAssetServerError = (error) => error instanceof PluginAssetServerError;
+export function createWebPluginAssetUrl(parts) {
+    const path = normalizePluginAssetRelativePath(parts.path);
+    return [
+        WEB_PLUGIN_ASSET_ROUTE_PREFIX,
+        encodePathSegment(parts.vaultId),
+        encodePathSegment(parts.pluginId),
+        encodePathSegment(parts.version),
+        encodePathSegment(normalizePluginAssetSha256(parts.sha256)),
+        encodePluginAssetPath(path),
+    ].join("/");
+}
+export function parseWebPluginAssetUrl(value, base = "http://lapis.local") {
+    const url = new URL(value, base);
+    const prefixParts = WEB_PLUGIN_ASSET_ROUTE_PREFIX.split("/").filter(Boolean);
+    const parts = url.pathname.split("/").filter(Boolean);
+    if (parts.length < prefixParts.length + 5 ||
+        !prefixParts.every((part, index) => parts[index] === part)) {
+        throw new PluginAssetServerError("invalid-url", `Invalid web plugin asset URL: ${value}`, { details: { url: value } });
+    }
+    const [vaultId, pluginId, version, sha256, ...assetPathParts] = parts.slice(prefixParts.length);
+    return normalizePluginAssetUrlParts({
+        vaultId: decodePathSegment(vaultId),
+        pluginId: decodePathSegment(pluginId),
+        version: decodePathSegment(version),
+        sha256: decodePathSegment(sha256),
+        path: decodePluginAssetPath(assetPathParts),
+    });
+}
+export function getInstalledPluginAssetVersion(record) {
+    return record.installedVersion;
+}
+export function getInstalledPluginAssetHash(record, relativePath) {
+    const path = normalizePluginAssetRelativePath(relativePath);
+    const metadata = getInstalledPluginAssetMetadata(record, path);
+    return normalizePluginAssetSha256(metadata.sha256);
+}
+export function getInstalledPluginAssetFingerprint(record) {
+    return record.files
+        .filter((file) => isSupportedPluginAssetPath(file.path))
+        .map((file) => ({
+        path: normalizePluginAssetRelativePath(file.path),
+        sha256: normalizePluginAssetSha256(file.sha256),
+        size: file.size,
+    }))
+        .sort((left, right) => left.path.localeCompare(right.path))
+        .map((file) => `${file.path}:${file.size}:${file.sha256}`)
+        .join("|");
+}
+export function isSupportedPluginAssetPath(path) {
+    return /\.(?:mjs|js|cjs|css|json|wasm|svg|png|jpg|jpeg|gif)$/iu.test(path);
+}
+export function assertSupportedPluginAssetPath(path) {
+    if (isSupportedPluginAssetPath(path)) {
+        return;
+    }
+    throw new PluginAssetServerError("unsupported-asset-type", `Plugin asset ${path} is not a supported module asset type`, { details: { path } });
+}
+export function getPluginAssetContentType(path) {
+    const lowerPath = path.toLowerCase();
+    if (/\.(?:mjs|js|cjs)$/u.test(lowerPath)) {
+        return "text/javascript; charset=utf-8";
+    }
+    if (lowerPath.endsWith(".css")) {
+        return "text/css; charset=utf-8";
+    }
+    if (lowerPath.endsWith(".json")) {
+        return "application/json; charset=utf-8";
+    }
+    if (lowerPath.endsWith(".wasm")) {
+        return "application/wasm";
+    }
+    if (lowerPath.endsWith(".svg")) {
+        return "image/svg+xml";
+    }
+    if (lowerPath.endsWith(".png")) {
+        return "image/png";
+    }
+    if (lowerPath.endsWith(".jpg") || lowerPath.endsWith(".jpeg")) {
+        return "image/jpeg";
+    }
+    if (lowerPath.endsWith(".gif")) {
+        return "image/gif";
+    }
+    return "application/octet-stream";
+}
+export async function readInstalledPluginAsset({ adapter, installedPlugin, relativePath, expectedSha256, pluginsPath = ".obsidian/plugins", verifyHash = true, }) {
+    const path = normalizePluginAssetRelativePath(relativePath);
+    assertSupportedPluginAssetPath(path);
+    const metadata = getInstalledPluginAssetMetadata(installedPlugin, path);
+    const metadataSha256 = normalizePluginAssetSha256(metadata.sha256);
+    if (expectedSha256 &&
+        normalizePluginAssetSha256(expectedSha256) !== metadataSha256) {
+        throw new PluginAssetServerError("asset-hash-mismatch", `Plugin asset URL hash for ${path} does not match installed metadata`, {
+            details: {
+                pluginId: installedPlugin.pluginId,
+                path,
+                expectedSha256: metadataSha256,
+                actualSha256: normalizePluginAssetSha256(expectedSha256),
+            },
+        });
+    }
+    const assetPath = joinPath(pluginsPath, installedPlugin.pluginId, path);
+    let bytes;
+    try {
+        bytes = new Uint8Array(await adapter.readBinary(assetPath));
+    }
+    catch (error) {
+        throw new PluginAssetServerError("asset-not-found", `Installed plugin asset ${assetPath} could not be read`, {
+            cause: error,
+            details: {
+                pluginId: installedPlugin.pluginId,
+                path,
+                assetPath,
+            },
+        });
+    }
+    if (bytes.byteLength !== metadata.size) {
+        throw new PluginAssetServerError("asset-size-mismatch", `Installed plugin asset ${path} size mismatch: expected ${metadata.size}, got ${bytes.byteLength}`, {
+            details: {
+                pluginId: installedPlugin.pluginId,
+                path,
+                expectedSize: metadata.size,
+                actualSize: bytes.byteLength,
+            },
+        });
+    }
+    if (verifyHash) {
+        const actualSha256 = await sha256Hex(bytes);
+        if (actualSha256.toLowerCase() !== metadataSha256) {
+            throw new PluginAssetServerError("asset-hash-mismatch", `Installed plugin asset ${path} SHA-256 mismatch`, {
+                details: {
+                    pluginId: installedPlugin.pluginId,
+                    path,
+                    expectedSha256: metadataSha256,
+                    actualSha256,
+                },
+            });
+        }
+    }
+    return {
+        bytes,
+        contentType: getPluginAssetContentType(path),
+        path,
+        sha256: metadataSha256,
+        size: metadata.size,
+    };
+}
+export function normalizePluginAssetRelativePath(path) {
+    try {
+        assertSafePluginRelativePath(path);
+    }
+    catch (error) {
+        throw new PluginAssetServerError("invalid-path", `Plugin asset path is not safe: ${path}`, { cause: error, details: { path } });
+    }
+    return path;
+}
+function normalizePluginAssetUrlParts(parts) {
+    if (!parts.vaultId || !parts.pluginId || !parts.version || !parts.sha256) {
+        throw new PluginAssetServerError("invalid-url", "Plugin asset URL is incomplete", {
+            details: { ...parts },
+        });
+    }
+    return {
+        ...parts,
+        sha256: normalizePluginAssetSha256(parts.sha256),
+        path: normalizePluginAssetRelativePath(parts.path),
+    };
+}
+function getInstalledPluginAssetMetadata(installedPlugin, path) {
+    const metadata = installedPlugin.files.find((file) => file.path === path);
+    if (!metadata) {
+        throw new PluginAssetServerError("asset-not-installed", `Plugin ${installedPlugin.pluginId} does not declare installed asset ${path}`, {
+            details: {
+                pluginId: installedPlugin.pluginId,
+                path,
+            },
+        });
+    }
+    return metadata;
+}
+function normalizePluginAssetSha256(value) {
+    const normalized = value.toLowerCase();
+    if (/^[a-f0-9]{64}$/u.test(normalized)) {
+        return normalized;
+    }
+    throw new PluginAssetServerError("invalid-url", `Plugin asset SHA-256 hash is invalid: ${value}`, { details: { sha256: value } });
+}
+function encodePluginAssetPath(path) {
+    return path.split("/").map(encodePathSegment).join("/");
+}
+function decodePluginAssetPath(parts) {
+    if (!parts.length) {
+        throw new PluginAssetServerError("invalid-url", "Plugin asset URL is missing an asset path");
+    }
+    return parts.map(decodePathSegment).join("/");
+}
+function encodePathSegment(value) {
+    return encodeURIComponent(value);
+}
+function decodePathSegment(value) {
+    return decodeURIComponent(value);
+}

package/dist/plugin-assets.d.ts

@@ -0,0 +1,4 @@
+/** Narrow public host boundary for verified desktop and web plugin assets. */
+export * from "./plugin-asset-server";
+export { sha256Hex, verifySha256 } from "./plugin-distribution/hashes";
+export type { InstalledPluginRecord } from "./plugin-distribution/types";

package/dist/plugin-assets.js

@@ -0,0 +1,3 @@
+/** Narrow public host boundary for verified desktop and web plugin assets. */
+export * from "./plugin-asset-server";
+export { sha256Hex, verifySha256 } from "./plugin-distribution/hashes";

package/dist/plugin-capability-facade.d.ts

@@ -0,0 +1,104 @@
+export type HostedPluginCapability = "vault:read" | "vault:write" | "plugin:data" | "commands" | "notices" | "settings" | "metadata:query" | "events" | "logging";
+export declare const HOSTED_PLUGIN_CAPABILITIES: readonly HostedPluginCapability[];
+export type HostedPluginLogLevel = "trace" | "debug" | "info" | "warn" | "error";
+export interface HostedPluginCapabilityRequest<TPayload extends Record<string, unknown> = Record<string, unknown>> {
+    pluginId: string;
+    capability: HostedPluginCapability;
+    action: string;
+    payload?: TPayload;
+}
+export interface HostedPluginCapabilityBroker {
+    invoke<T = unknown>(request: HostedPluginCapabilityRequest): Promise<T>;
+}
+export interface HostedPluginVaultStat {
+    type: "file" | "folder";
+    size: number;
+    ctime: number;
+    mtime: number;
+}
+export interface HostedPluginVaultListing {
+    files: string[];
+    folders: string[];
+}
+export interface HostedPluginCommandDescriptor {
+    id: string;
+    name: string;
+    icon?: string;
+    hotkeys?: Array<{
+        modifiers: string[];
+        key: string;
+    }>;
+}
+export interface HostedPluginSettingsSurface {
+    id: string;
+    title: string;
+    sections?: Array<Record<string, unknown>>;
+}
+export interface HostedPluginMetadataQuery {
+    path?: string;
+    tag?: string;
+    limit?: number;
+}
+export interface HostedPluginMetadataResult {
+    path: string;
+    metadata: Record<string, unknown>;
+}
+export interface HostedPluginEventSubscription {
+    subscriptionId: string;
+}
+export interface HostedPluginCapabilityFacade {
+    readonly pluginId: string;
+    readonly capabilities: readonly HostedPluginCapability[];
+    readonly vault: {
+        exists(path: string): Promise<boolean>;
+        stat(path: string): Promise<HostedPluginVaultStat | null>;
+        list(path?: string): Promise<HostedPluginVaultListing>;
+        readText(path: string): Promise<string>;
+        readBinary(path: string): Promise<ArrayBuffer>;
+        writeText(path: string, data: string): Promise<void>;
+        writeBinary(path: string, data: ArrayBuffer): Promise<void>;
+        mkdir(path: string, options?: {
+            recursive?: boolean;
+        }): Promise<void>;
+        remove(path: string): Promise<void>;
+        rename(path: string, newPath: string): Promise<void>;
+    };
+    readonly pluginData: {
+        load<T = unknown>(): Promise<T | null>;
+        save(data: unknown): Promise<void>;
+    };
+    readonly commands: {
+        register(command: HostedPluginCommandDescriptor): Promise<void>;
+        unregister(commandId: string): Promise<void>;
+    };
+    readonly notices: {
+        show(message: string, options?: {
+            timeoutMs?: number;
+        }): Promise<void>;
+    };
+    readonly settings: {
+        read<T = unknown>(key?: string): Promise<T | null>;
+        registerSurface(surface: HostedPluginSettingsSurface): Promise<void>;
+    };
+    readonly metadata: {
+        query(query: HostedPluginMetadataQuery): Promise<HostedPluginMetadataResult[]>;
+    };
+    readonly events: {
+        subscribe(event: string, options?: Record<string, unknown>): Promise<HostedPluginEventSubscription>;
+        unsubscribe(subscriptionId: string): Promise<void>;
+    };
+    readonly logging: {
+        log(level: HostedPluginLogLevel, message: string, data?: unknown): Promise<void>;
+        trace(message: string, data?: unknown): Promise<void>;
+        debug(message: string, data?: unknown): Promise<void>;
+        info(message: string, data?: unknown): Promise<void>;
+        warn(message: string, data?: unknown): Promise<void>;
+        error(message: string, data?: unknown): Promise<void>;
+    };
+}
+export interface CreateHostedPluginCapabilityFacadeOptions {
+    pluginId: string;
+    broker: HostedPluginCapabilityBroker;
+    capabilities?: readonly HostedPluginCapability[];
+}
+export declare function createHostedPluginCapabilityFacade({ pluginId, broker, capabilities, }: CreateHostedPluginCapabilityFacadeOptions): HostedPluginCapabilityFacade;

package/dist/plugin-capability-facade.js

@@ -0,0 +1,61 @@
+export const HOSTED_PLUGIN_CAPABILITIES = [
+    "vault:read",
+    "vault:write",
+    "plugin:data",
+    "commands",
+    "notices",
+    "settings",
+    "metadata:query",
+    "events",
+    "logging",
+];
+export function createHostedPluginCapabilityFacade({ pluginId, broker, capabilities = HOSTED_PLUGIN_CAPABILITIES, }) {
+    const invoke = (capability, action, payload = {}) => broker.invoke({ pluginId, capability, action, payload });
+    const log = (level, message, data) => invoke("logging", "log", { level, message, data });
+    return {
+        pluginId,
+        capabilities,
+        vault: {
+            exists: (path) => invoke("vault:read", "exists", { path }),
+            stat: (path) => invoke("vault:read", "stat", { path }),
+            list: (path = "/") => invoke("vault:read", "list", { path }),
+            readText: (path) => invoke("vault:read", "read-text", { path }),
+            readBinary: (path) => invoke("vault:read", "read-binary", { path }),
+            writeText: (path, data) => invoke("vault:write", "write-text", { path, data }),
+            writeBinary: (path, data) => invoke("vault:write", "write-binary", { path, data }),
+            mkdir: (path, options = {}) => invoke("vault:write", "mkdir", { path, ...options }),
+            remove: (path) => invoke("vault:write", "remove", { path }),
+            rename: (path, newPath) => invoke("vault:write", "rename", { path, newPath }),
+        },
+        pluginData: {
+            load: () => invoke("plugin:data", "load"),
+            save: (data) => invoke("plugin:data", "save", { data }),
+        },
+        commands: {
+            register: (command) => invoke("commands", "register", { command }),
+            unregister: (commandId) => invoke("commands", "unregister", { commandId }),
+        },
+        notices: {
+            show: (message, options = {}) => invoke("notices", "show", { message, ...options }),
+        },
+        settings: {
+            read: (key) => invoke("settings", "read", { key }),
+            registerSurface: (surface) => invoke("settings", "register-surface", { surface }),
+        },
+        metadata: {
+            query: (query) => invoke("metadata:query", "query", { query }),
+        },
+        events: {
+            subscribe: (event, options = {}) => invoke("events", "subscribe", { event, options }),
+            unsubscribe: (subscriptionId) => invoke("events", "unsubscribe", { subscriptionId }),
+        },
+        logging: {
+            log,
+            trace: (message, data) => log("trace", message, data),
+            debug: (message, data) => log("debug", message, data),
+            info: (message, data) => log("info", message, data),
+            warn: (message, data) => log("warn", message, data),
+            error: (message, data) => log("error", message, data),
+        },
+    };
+}

package/dist/plugin-dependency-resolver.d.ts

@@ -0,0 +1,36 @@
+import type { PluginManifest } from "./plugin";
+export interface PluginDependencyContext {
+    pluginId: string;
+    pluginPath: string;
+    manifest: PluginManifest;
+    host: "workspace" | "electron-renderer" | "electron-sidecar";
+    format: "commonjs" | "esm" | "node-esm";
+}
+export interface PluginSharedDependencyInfo {
+    specifier: string;
+    version?: string;
+    platforms: string[];
+    public: boolean;
+    deprecated?: boolean;
+    replacement?: string;
+    reason?: string;
+}
+export interface PluginDependencyResolver {
+    list(): PluginSharedDependencyInfo[];
+    prepare(specifiers: string[], context: PluginDependencyContext): Promise<void>;
+    require(specifier: string, context: PluginDependencyContext): unknown;
+    canResolve(specifier: string, context: PluginDependencyContext): boolean;
+}
+export type PluginDependencyResolverFactory = (dependencies: Record<string, any>) => PluginDependencyResolver;
+export declare class LegacyObjectDependencyResolver implements PluginDependencyResolver {
+    private readonly dependencies;
+    constructor(dependencies: Record<string, any>);
+    list(): PluginSharedDependencyInfo[];
+    prepare(): Promise<void>;
+    require(specifier: string, context: PluginDependencyContext): unknown;
+    canResolve(specifier: string, _context?: PluginDependencyContext): boolean;
+    private resolve;
+    private normalizeAllowedScopedSubpath;
+    private isAllowedScopedDependency;
+}
+export declare function isPluginDependencyResolver(value: unknown): value is PluginDependencyResolver;