@linxiraos/zeta 1.0.3 → 1.0.5

package/dist/types/extensibility/plugins/loader.d.ts

@@ -0,0 +1,59 @@
+import type { InstalledPlugin } from "./types.js";
+/** Installed plugin plus the root scope that supplied its runtime metadata. */
+export interface ScopedInstalledPlugin extends InstalledPlugin {
+    scope: "user" | "project";
+}
+/**
+ * Get list of enabled plugins with their resolved configurations.
+ *
+ * Enumerates two plugin roots in order: the user root
+ * (`getPluginsDir(home)`) and, when a project anchor (`.zeta/` or `.git/`)
+ * exists at or above `cwd`, the project root
+ * (`<projectAnchor>/.zeta/plugins`). Each root contributes the union of its
+ * `package.json#dependencies` and `zeta-plugins.lock.json#plugins`. Project
+ * entries shadow user entries with the same package name, matching the
+ * shadow semantics of `MarketplaceManager.listInstalledPlugins`.
+ *
+ * The optional `home` parameter pins the user plugins root for callers that
+ * need to enumerate plugins relative to a non-default home (tests with a
+ * tempdir, discovery loaders threaded with `LoadContext.home`).
+ */
+export declare function getEnabledPlugins(cwd: string, opts?: {
+    home?: string;
+}): Promise<ScopedInstalledPlugin[]>;
+/**
+ * Declared manifest entries paired with their resolved file path. Returns one
+ * record per declared entry — base entries first, then enabled-feature entries
+ * — so callers (e.g. install-time validation) can detect manifest entries that
+ * point at missing files instead of silently skipping them like
+ * {@link resolvePluginPaths} does.
+ */
+export declare function resolvePluginManifestEntries(plugin: InstalledPlugin, key: "tools" | "hooks" | "commands" | "extensions"): Array<{
+    entry: string;
+    resolvedPath: string | null;
+}>;
+export declare function resolvePluginToolPaths(plugin: InstalledPlugin): string[];
+export declare function resolvePluginHookPaths(plugin: InstalledPlugin): string[];
+export declare function resolvePluginCommandPaths(plugin: InstalledPlugin): string[];
+export declare function resolvePluginExtensionPaths(plugin: InstalledPlugin): string[];
+/**
+ * Get all tool paths from all enabled plugins.
+ */
+export declare function getAllPluginToolPaths(cwd: string): Promise<string[]>;
+/**
+ * Get all hook paths from all enabled plugins.
+ */
+export declare function getAllPluginHookPaths(cwd: string): Promise<string[]>;
+/**
+ * Get all command paths from all enabled plugins.
+ */
+export declare function getAllPluginCommandPaths(cwd: string): Promise<string[]>;
+/**
+ * Get all extension module paths from all enabled plugins.
+ */
+export declare function getAllPluginExtensionPaths(cwd: string): Promise<string[]>;
+/**
+ * Get plugin settings for use in tool/hook contexts.
+ * Merges global settings with project overrides.
+ */
+export declare function getPluginSettings(pluginName: string, cwd: string): Promise<Record<string, unknown>>;

package/dist/types/extensibility/plugins/manager.d.ts

@@ -0,0 +1,76 @@
+import type { DoctorCheck, DoctorOptions, InstalledPlugin, InstallOptions, PluginSettingSchema } from "./types.js";
+export declare class PluginManager {
+    #private;
+    constructor(cwd?: string);
+    /**
+     * Install a plugin with optional feature selection.
+     *
+     * Accepts:
+     * - npm specs: `pkg`, `pkg@1.2.3`, `@scope/pkg`, `pkg[features]`
+     * - namespaced git shorthand: `github:user/repo[#ref]`, `gitlab:`, `bitbucket:`,
+     *   `codeberg:`, `sourcehut:`/`srht:`
+     * - full git URLs: `https://github.com/user/repo`, `git@github.com:user/repo`,
+     *   `ssh://…`, `git+https://…`
+     *
+     * For git specs the package name is not knowable from the spec, so the
+     * installer diffs `plugins/package.json` `dependencies` before and after
+     * to find the newly added key.
+     *
+     * @param specString - Package specifier with optional features: "pkg", "pkg[feat]", "pkg[*]", "pkg[]"
+     * @param options - Install options
+     * @returns Installed plugin metadata
+     */
+    install(specString: string, options?: InstallOptions): Promise<InstalledPlugin>;
+    /**
+     * Uninstall a plugin.
+     */
+    uninstall(name: string): Promise<void>;
+    /**
+     * List all installed plugins.
+     */
+    list(): Promise<InstalledPlugin[]>;
+    /**
+     * Link a local plugin for development.
+     */
+    link(localPath: string): Promise<InstalledPlugin>;
+    /**
+     * Enable or disable a plugin globally.
+     */
+    setEnabled(name: string, enabled: boolean): Promise<void>;
+    /**
+     * Get enabled features for a plugin.
+     */
+    getEnabledFeatures(name: string): Promise<string[] | null>;
+    /**
+     * Set enabled features for a plugin.
+     */
+    setEnabledFeatures(name: string, features: string[] | null): Promise<void>;
+    /**
+     * Get all settings for a plugin.
+     */
+    getPluginSettings(name: string): Promise<Record<string, unknown>>;
+    /**
+     * Set a plugin setting value.
+     */
+    setPluginSetting(name: string, key: string, value: unknown): Promise<void>;
+    /**
+     * Delete a plugin setting.
+     */
+    deletePluginSetting(name: string, key: string): Promise<void>;
+    /**
+     * Run health checks on the plugin system.
+     */
+    doctor(options?: DoctorOptions): Promise<DoctorCheck[]>;
+}
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * Validate a setting value against its schema.
+ */
+export declare function validateSetting(value: unknown, schema: PluginSettingSchema): ValidationResult;
+/**
+ * Parse a string value according to a setting schema's type.
+ */
+export declare function parseSettingValue(valueStr: string, schema: PluginSettingSchema): unknown;

package/dist/types/extensibility/plugins/marketplace/cache.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Plugin cache management.
+ *
+ * Cache layout: `<cacheDir>/<marketplace>___<pluginName>___<version>/`
+ *
+ * All three components are validated before any filesystem operation:
+ *   - marketplace / pluginName: isValidNameSegment (lowercase alnum + hyphens, max 64)
+ *   - version: isValidVersionForCache (alnum + ._+-, max 128)
+ *
+ * This ensures cache paths cannot be crafted to escape the cache directory.
+ */
+/** Return true when `version` is safe for use as a cache path component. */
+export declare function isValidVersionForCache(version: string): boolean;
+/**
+ * Return the absolute path for a cached plugin directory.
+ * Throws if any component fails validation.
+ */
+export declare function getCachedPluginPath(cacheDir: string, marketplace: string, pluginName: string, version: string): string;
+/**
+ * Copy `sourcePath` into the cache, returning the absolute cache path.
+ *
+ * Idempotent: if the target already exists it is removed before copying,
+ * so a partial previous cache is never silently reused.
+ */
+export declare function cachePlugin(sourcePath: string, cacheDir: string, marketplace: string, pluginName: string, version: string): Promise<string>;
+/**
+ * Synchronous check — true when the cache directory exists on disk.
+ * Uses `existsSync` because callers may need to run this check inline without async.
+ */
+export declare function isCached(cacheDir: string, marketplace: string, pluginName: string, version: string): boolean;
+/** Remove a single cached plugin directory. No-op if it does not exist. */
+export declare function removeCachedPlugin(cacheDir: string, marketplace: string, pluginName: string, version: string): Promise<void>;
+/**
+ * Remove all cache entries whose full path is not in `installedPaths`.
+ *
+ * Returns the count of removed directories. If `cacheDir` does not exist,
+ * returns `{ removed: 0 }` rather than throwing.
+ */
+export declare function cleanOrphanedCache(cacheDir: string, installedPaths: Set<string>): Promise<{
+    removed: number;
+}>;

package/dist/types/extensibility/plugins/marketplace/fetcher.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Marketplace catalog fetcher.
+ *
+ * Classifies a source string, resolves it, and loads the catalog.
+ */
+import type { MarketplaceCatalog, MarketplaceSourceType } from "./types.js";
+export interface FetchResult {
+    catalog: MarketplaceCatalog;
+    /** For git sources: path to the cloned marketplace directory. */
+    clonePath?: string;
+}
+/**
+ * Classify a marketplace source string into one of the four source types.
+ *
+ * Rules are ordered; the first match wins. Protocol/pattern checks (rules 1-3)
+ * run before any path.isAbsolute() check so that SCP-style git@ URLs are
+ * never misclassified as local paths on Windows.
+ *
+ * @throws if the source format is unrecognized.
+ */
+export declare function classifySource(source: string): MarketplaceSourceType;
+/**
+ * Parse and validate a marketplace.json catalog from raw JSON content.
+ *
+ * Required fields: name (valid name segment), owner.name, plugins array.
+ * Each plugin entry requires name (string) and source (string or object
+ * with a "source" field). Extra fields are preserved via spread.
+ *
+ * @throws on JSON parse failure or missing/invalid required fields.
+ */
+export declare function parseMarketplaceCatalog(content: string, filePath: string): MarketplaceCatalog;
+/**
+ * Fetch a marketplace catalog from a source.
+ *
+ * Dispatches on the source type: local filesystem paths are read directly;
+ * GitHub/git sources are cloned with `git`; URL sources are fetched over HTTP.
+ *
+ * @param source   Source identifier: path, GitHub shorthand, git URL, or HTTP URL.
+ * @param cacheDir Cache directory root for non-local sources.
+ */
+export declare function fetchMarketplace(source: string, cacheDir: string): Promise<FetchResult>;
+/**
+ * Promote a temporary clone directory to its final cache location.
+ *
+ * Callers should invoke this only after duplicate/drift checks pass.
+ * Removes any existing directory at the target path before renaming.
+ */
+export declare function promoteCloneToCache(tmpDir: string, cacheDir: string, name: string): Promise<string>;

package/dist/types/extensibility/plugins/marketplace/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./cache.js";
+export * from "./fetcher.js";
+export * from "./manager.js";
+export * from "./registry.js";
+export * from "./source-resolver.js";
+export * from "./types.js";

package/dist/types/extensibility/plugins/marketplace/manager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * MarketplaceManager — orchestrates registry, fetcher, resolver, and cache.
+ *
+ * Constructor takes explicit paths for testability (same pattern as registry.ts).
+ * The `clearPluginRootsCache` dependency is injected so callers can provide
+ * the real `clearClaudePluginRootsCache` while tests supply a counter stub.
+ */
+import type { InstalledPluginEntry, InstalledPluginSummary, MarketplacePluginEntry, MarketplaceRegistryEntry } from "./types.js";
+export interface MarketplaceManagerOptions {
+    marketplacesRegistryPath: string;
+    installedRegistryPath: string;
+    /**
+     * Path to the project-scoped installed_plugins.json.
+     * Required when installPlugin / uninstallPlugin is called with scope: "project".
+     * Resolved by resolveActiveProjectRegistryPath(cwd) in callers.
+     */
+    projectInstalledRegistryPath?: string;
+    marketplacesCacheDir: string;
+    pluginsCacheDir: string;
+    /** Injected for testing; production callers pass clearClaudePluginRootsCache.
+     *  Receives any additional file paths that should also be invalidated from the fs cache.
+     */
+    clearPluginRootsCache?: (extraPaths?: readonly string[]) => void;
+}
+export declare class MarketplaceManager {
+    #private;
+    constructor(options: MarketplaceManagerOptions);
+    addMarketplace(source: string): Promise<MarketplaceRegistryEntry>;
+    removeMarketplace(name: string): Promise<void>;
+    updateMarketplace(name: string): Promise<MarketplaceRegistryEntry>;
+    updateAllMarketplaces(): Promise<MarketplaceRegistryEntry[]>;
+    listMarketplaces(): Promise<MarketplaceRegistryEntry[]>;
+    listAvailablePlugins(marketplace?: string): Promise<MarketplacePluginEntry[]>;
+    getPluginInfo(name: string, marketplace: string): Promise<MarketplacePluginEntry | null>;
+    installPlugin(name: string, marketplace: string, options?: {
+        force?: boolean;
+        scope?: "user" | "project";
+    }): Promise<InstalledPluginEntry>;
+    /** Validates and removes a marketplace plugin, or only validates when `dryRun` is set. */
+    uninstallPlugin(pluginId: string, scope?: "user" | "project", options?: {
+        dryRun?: boolean;
+    }): Promise<void>;
+    listInstalledPlugins(): Promise<InstalledPluginSummary[]>;
+    setPluginEnabled(pluginId: string, enabled: boolean, scope?: "user" | "project"): Promise<void>;
+    refreshStaleMarketplaces(): Promise<void>;
+    checkForUpdates(): Promise<Array<{
+        pluginId: string;
+        scope: "user" | "project";
+        from: string;
+        to: string;
+    }>>;
+    upgradePlugin(pluginId: string, scope?: "user" | "project"): Promise<InstalledPluginEntry>;
+    upgradePluginAcrossScopes(pluginId: string): Promise<InstalledPluginEntry[]>;
+    upgradeAllPlugins(): Promise<Array<{
+        pluginId: string;
+        scope: "user" | "project";
+        from: string;
+        to: string;
+    }>>;
+}

package/dist/types/extensibility/plugins/marketplace/registry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Registry read/write operations for the marketplace plugin system.
+ *
+ * Two registries:
+ *   - marketplaces.json at getMarketplacesRegistryPath() — which catalogs the user has added
+ *   - installed_plugins.json under getPluginsDir() — which plugins are installed
+ *
+ * Read/write functions accept explicit file paths so callers control the
+ * location. Path helpers compute the default paths from the dir singleton.
+ *
+ * Both use atomic write (tmp + rename). On Windows, rename over existing file
+ * can fail with EPERM — fallback: unlink target then rename.
+ */
+export { getMarketplacesRegistryPath } from "@linxiraos/pi-utils";
+import type { InstalledPluginEntry, InstalledPluginsRegistry, MarketplaceRegistryEntry, MarketplacesRegistry } from "./types.js";
+export declare function getInstalledPluginsRegistryPath(): string;
+export declare function getMarketplacesCacheDir(): string;
+export declare function getPluginsCacheDir(): string;
+export declare function readMarketplacesRegistry(filePath: string): Promise<MarketplacesRegistry>;
+export declare function writeMarketplacesRegistry(filePath: string, reg: MarketplacesRegistry): Promise<void>;
+export declare function readInstalledPluginsRegistry(filePath: string): Promise<InstalledPluginsRegistry>;
+export declare function writeInstalledPluginsRegistry(filePath: string, reg: InstalledPluginsRegistry): Promise<void>;
+export declare function addMarketplaceEntry(reg: MarketplacesRegistry, entry: MarketplaceRegistryEntry): MarketplacesRegistry;
+export declare function removeMarketplaceEntry(reg: MarketplacesRegistry, name: string): MarketplacesRegistry;
+export declare function getMarketplaceEntry(reg: MarketplacesRegistry, name: string): MarketplaceRegistryEntry | undefined;
+export declare function addInstalledPlugin(reg: InstalledPluginsRegistry, id: string, entry: InstalledPluginEntry): InstalledPluginsRegistry;
+export declare function removeInstalledPlugin(reg: InstalledPluginsRegistry, id: string): InstalledPluginsRegistry;
+export declare function getInstalledPlugin(reg: InstalledPluginsRegistry, id: string): InstalledPluginEntry[] | undefined;
+/**
+ * Collect all installPath values referenced by any of the provided registries.
+ * Use this before deleting a cached plugin directory to verify it is not still
+ * referenced by another scope's registry.
+ */
+export declare function collectReferencedPaths(...registries: InstalledPluginsRegistry[]): Set<string>;

package/dist/types/extensibility/plugins/marketplace/source-resolver.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Source resolver for marketplace plugin entries.
+ *
+ * Resolves plugin sources to absolute local directory paths:
+ *   - Relative string "./plugins/foo" → path within marketplace clone
+ *   - { source: "url", url: "https://...git" } → git clone
+ *   - { source: "github", repo: "owner/repo" } → git clone from GitHub
+ *   - { source: "git-subdir", url: "...", path: "sub/dir" } → git clone + subdir
+ *   - { source: "npm", ... } → not yet supported
+ */
+import type { MarketplaceCatalogMetadata, MarketplacePluginEntry } from "./types.js";
+export interface ResolveContext {
+    /** Absolute path to the cloned/local marketplace directory. Required for relative sources. */
+    marketplaceClonePath?: string;
+    /** Catalog metadata — used for `pluginRoot` prepend. */
+    catalogMetadata?: MarketplaceCatalogMetadata;
+    /** Scratch directory for sources that require cloning or extraction. */
+    tmpDir: string;
+}
+/**
+ * Resolve a plugin source to an absolute local directory path.
+ *
+ * The resolved path is verified to exist on disk.
+ */
+export declare function resolvePluginSource(entry: MarketplacePluginEntry, context: ResolveContext): Promise<{
+    dir: string;
+    tempCloneRoot?: string;
+}>;

package/dist/types/extensibility/plugins/marketplace/types.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Marketplace plugin system types.
+ *
+ * Two registries:
+ *   - MarketplacesRegistry: which marketplace catalogs the user has added (config)
+ *   - InstalledPluginsRegistry: which plugins are installed (data, Claude Code-compatible)
+ *
+ * The installed registry MUST pass `parseClaudePluginsRegistry()` validation —
+ * it uses `version: 2` (numeric) and `plugins: Record<string, ...[]>`.
+ */
+/** Validate a plugin or marketplace name segment. */
+export declare function isValidNameSegment(s: string): boolean;
+/** Build canonical plugin ID: `"name@marketplace"`. Both segments are validated. */
+export declare function buildPluginId(name: string, marketplace: string): string;
+/** Parse `"name@marketplace"` → `{ name, marketplace }` or `null`. */
+export declare function parsePluginId(id: string): {
+    name: string;
+    marketplace: string;
+} | null;
+export interface MarketplaceCatalogOwner {
+    name: string;
+    email?: string;
+}
+export interface MarketplaceCatalogMetadata {
+    description?: string;
+    version?: string;
+    /** If set, prepended to relative plugin source paths. */
+    pluginRoot?: string;
+}
+export interface MarketplaceCatalog {
+    name: string;
+    owner: MarketplaceCatalogOwner;
+    metadata?: MarketplaceCatalogMetadata;
+    plugins: MarketplacePluginEntry[];
+}
+export interface MarketplacePluginAuthor {
+    name: string;
+    email?: string;
+}
+export interface MarketplacePluginEntry {
+    name: string;
+    source: PluginSource;
+    description?: string;
+    version?: string;
+    author?: MarketplacePluginAuthor;
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    keywords?: string[];
+    category?: string;
+    tags?: string[];
+    strict?: boolean;
+    commands?: string | string[];
+    agents?: string | string[];
+    hooks?: string | Record<string, unknown>;
+    mcpServers?: string | Record<string, unknown>;
+    lspServers?: string | Record<string, unknown>;
+    dapAdapters?: string | Record<string, unknown>;
+}
+export type PluginSource = string | PluginSourceGitHub | PluginSourceUrl | PluginSourceGitSubdir | PluginSourceNpm;
+export interface PluginSourceGitHub {
+    source: "github";
+    repo: string;
+    ref?: string;
+    sha?: string;
+}
+export interface PluginSourceUrl {
+    source: "url";
+    url: string;
+    ref?: string;
+    sha?: string;
+}
+export interface PluginSourceGitSubdir {
+    source: "git-subdir";
+    url: string;
+    path: string;
+    ref?: string;
+    sha?: string;
+}
+export interface PluginSourceNpm {
+    source: "npm";
+    package: string;
+    version?: string;
+    registry?: string;
+}
+export interface MarketplacesRegistry {
+    version: 1;
+    marketplaces: MarketplaceRegistryEntry[];
+}
+export type MarketplaceSourceType = "github" | "git" | "url" | "local";
+export interface MarketplaceRegistryEntry {
+    name: string;
+    sourceType: MarketplaceSourceType;
+    sourceUri: string;
+    catalogPath: string;
+    addedAt: string;
+    updatedAt: string;
+}
+export interface InstalledPluginsRegistry {
+    /** MUST be 2 — parseClaudePluginsRegistry rejects non-numeric version. */
+    version: 2;
+    plugins: Record<string, InstalledPluginEntry[]>;
+}
+export interface InstalledPluginEntry {
+    scope: "user" | "project";
+    /** Absolute path to cached plugin directory. */
+    installPath: string;
+    version: string;
+    /** ISO 8601 date string. */
+    installedAt: string;
+    /** ISO 8601 date string. */
+    lastUpdated: string;
+    /** For git-sourced plugins. */
+    gitCommitSha?: string;
+    /** OMP extension — not in Claude Code's type. CLI/UI concern only in v1. */
+    enabled?: boolean;
+}
+/**
+ * A merged view of an installed plugin, combining entries from both the user and
+ * project registries. Returned by MarketplaceManager.listInstalledPlugins().
+ *
+ * `shadowedBy` is set on user-scoped summaries when the same plugin ID also exists
+ * in the project registry — the project entry takes precedence for capability loading.
+ */
+export interface InstalledPluginSummary {
+    id: string;
+    scope: "user" | "project";
+    entries: InstalledPluginEntry[];
+    /** Set when a user-scoped plugin is overridden by a project-scoped install. */
+    shadowedBy?: "project";
+}

package/dist/types/extensibility/plugins/marketplace-auto-update.d.ts

@@ -0,0 +1,8 @@
+type MarketplaceAutoUpdateMode = "off" | "notify" | "auto";
+interface MarketplaceAutoUpdateOptions {
+    autoUpdate: MarketplaceAutoUpdateMode;
+    resolveActiveProjectRegistryPath: (cwd: string) => Promise<string | null>;
+    clearPluginRootsCache: () => void;
+}
+export declare function scheduleMarketplaceAutoUpdate(options: MarketplaceAutoUpdateOptions): void;
+export {};

package/dist/types/extensibility/plugins/parser.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Feature bracket parser for plugin specifiers.
+ *
+ * Supports syntax like:
+ * - "my-plugin" -> base features (null)
+ * - "my-plugin[search,web]" -> specific features
+ * - "my-plugin[*]" -> all features
+ * - "my-plugin[]" -> no optional features
+ * - "@scope/plugin@1.2.3[feat]" -> scoped with version and features
+ */
+export interface ParsedPluginSpec {
+    /** Package name (may include version specifier like @1.0.0) */
+    packageName: string;
+    /**
+     * Feature selection:
+     * - null: use defaults (base features on first install, preserve on reinstall)
+     * - "*": all features
+     * - string[]: specific features (empty array = no optional features)
+     */
+    features: string[] | null | "*";
+}
+/**
+ * Parse plugin specifier with feature bracket syntax.
+ *
+ * @example
+ * parsePluginSpec("my-plugin") // { packageName: "my-plugin", features: null }
+ * parsePluginSpec("my-plugin[search,web]") // { packageName: "my-plugin", features: ["search", "web"] }
+ * parsePluginSpec("my-plugin[*]") // { packageName: "my-plugin", features: "*" }
+ * parsePluginSpec("my-plugin[]") // { packageName: "my-plugin", features: [] }
+ * parsePluginSpec("@scope/pkg@1.2.3[feat]") // { packageName: "@scope/pkg@1.2.3", features: ["feat"] }
+ */
+export declare function parsePluginSpec(spec: string): ParsedPluginSpec;
+/**
+ * Format a parsed plugin spec back to string form.
+ *
+ * @example
+ * formatPluginSpec({ packageName: "pkg", features: null }) // "pkg"
+ * formatPluginSpec({ packageName: "pkg", features: "*" }) // "pkg[*]"
+ * formatPluginSpec({ packageName: "pkg", features: [] }) // "pkg[]"
+ * formatPluginSpec({ packageName: "pkg", features: ["a", "b"] }) // "pkg[a,b]"
+ */
+export declare function formatPluginSpec(spec: ParsedPluginSpec): string;
+/**
+ * Extract the dependency key from an npm package specifier.
+ * Used for path lookups after npm install.
+ *
+ * @example
+ * extractPackageName("lodash@4.17.21") // "lodash"
+ * extractPackageName("@scope/pkg@1.0.0") // "@scope/pkg"
+ * extractPackageName("@scope/pkg") // "@scope/pkg"
+ * extractPackageName("npm:lodash") // "lodash"
+ */
+export declare function extractPackageName(specifier: string): string;

package/dist/types/extensibility/plugins/runtime-config.d.ts

@@ -0,0 +1,3 @@
+import type { PluginRuntimeConfig } from "./types.js";
+/** Normalizes persisted plugin runtime config across legacy lockfile shapes. */
+export declare function normalizePluginRuntimeConfig(config: Partial<PluginRuntimeConfig>): PluginRuntimeConfig;