@dsh-workbench/core 0.1.16 → 0.1.17

package/dist/types/app/layouts/market/use-module-versions.d.ts

@@ -1,6 +1,8 @@
 import type { ModuleVersion } from '../../../shared/api/bundle-install';
+import type { InstalledPlugin } from '../../../shared/api/installed-plugins';
 export interface ModuleVersionsState {
     readonly modules: readonly ModuleVersion[] | null;
+    readonly plugins: readonly InstalledPlugin[] | null;
     readonly read: boolean;
     readonly checkedAt: number | null;
 }

package/dist/types/app/layouts/rightbar/MarketView.d.ts

@@ -2,6 +2,7 @@ import type { Translate } from '@dsh-workbench/shared';
 import type { UnitManifest } from '@dsh-workbench/shared';
 import type { CapabilityMap } from '../../../shared/hooks/use-capabilities';
 import type { MarketFreshness } from './market-freshness';
+import type { InstalledPlugin } from '../../../shared/api/installed-plugins';
 import { type InstalledWorkbenchModule } from './market-rows';
 import type { MarketMock } from './market-mock';
 import type { ModuleUpdateMap } from './market-rows';
@@ -14,7 +15,8 @@ export interface MarketViewProps {
     readonly updates?: ModuleUpdateMap | undefined;
     readonly installed?: readonly InstalledWorkbenchModule[] | undefined;
     readonly installedRead?: boolean | undefined;
+    readonly plugins?: readonly InstalledPlugin[] | null | undefined;
     readonly settling?: ReadonlySet<string> | undefined;
     readonly mock?: MarketMock | undefined;
 }
-export declare function MarketView({ t, manifests, capabilities, freshness, onChanged, updates, installed, installedRead, settling, mock, }: MarketViewProps): JSX.Element;
+export declare function MarketView({ t, manifests, capabilities, freshness, onChanged, updates, installed, installedRead, plugins, settling, mock, }: MarketViewProps): JSX.Element;

package/dist/types/app/layouts/rightbar/__tests__/market-rows-plugins.test.d.ts

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

package/dist/types/app/layouts/rightbar/market-mock.d.ts

@@ -1,4 +1,5 @@
 import type { InstalledWorkbenchModule } from './market-rows';
+import type { InstalledPlugin } from '../../../shared/api/installed-plugins';
 import type { UnitManifest } from '@dsh-workbench/shared';
 import type { MarketRowAction, ModuleUpdateMap } from './market-rows';
 import type { CapabilityMap } from '../../../shared/hooks/use-capabilities';
@@ -11,7 +12,13 @@ export interface MarketMockExpect {
     readonly shared?: number;
     readonly installed?: number;
     readonly installedActions?: readonly MarketRowAction[];
+    readonly installedNote?: boolean;
     readonly sharedActions?: readonly MarketRowAction[];
+    readonly plugins?: number;
+    readonly pluginActions?: readonly MarketRowAction[];
+    readonly pluginNote?: boolean;
+    readonly pluginNoteKey?: 'panels.market.pluginLocalNoUpdate' | 'panels.market.pluginAlsoKnownAs' | 'panels.market.pluginBroken';
+    readonly notice?: boolean;
 }
 export interface MarketMock {
     readonly id: string;
@@ -25,12 +32,14 @@ export interface MarketMock {
     readonly updates?: ModuleUpdateMap;
     readonly installed?: readonly InstalledWorkbenchModule[];
     readonly installedRead?: boolean;
+    readonly plugins?: readonly InstalledPlugin[];
     readonly loaded?: boolean;
     readonly confirming?: string;
     readonly failure?: {
         readonly id: string;
         readonly message: string;
     };
+    readonly notice?: string;
     readonly expect: MarketMockExpect;
 }
 export declare function buildMarketMocks(roster: readonly UnitManifest[]): readonly MarketMock[];

package/dist/types/app/layouts/rightbar/market-plugin-rows.d.ts

@@ -0,0 +1,8 @@
+import type { InstalledPlugin } from '../../../shared/api/installed-plugins';
+import type { MarketRow } from './market-rows';
+export interface InstalledPluginKept {
+    readonly key: 'panels.market.pluginKeptInUse' | 'panels.market.pluginKeptUnsure' | 'panels.market.pluginKeptHeld' | 'panels.market.pluginKeptUnnamed';
+    readonly names?: readonly string[];
+}
+export declare function installedPluginKept(value: unknown): InstalledPluginKept | undefined;
+export declare function installedPluginRows(plugins: readonly InstalledPlugin[]): MarketRow[];

package/dist/types/app/layouts/rightbar/market-rows.d.ts

@@ -1,12 +1,12 @@
 import type { ModuleVersion } from '../../../shared/api/bundle-install';
-import type { UnitManifest } from '@dsh-workbench/shared';
-export type MarketRowAction = 'install' | 'update' | 'update-bundle' | 'remove-bundle' | 'uninstall' | 'update-dependency';
+import type { Translate, UnitManifest } from '@dsh-workbench/shared';
+export type MarketRowAction = 'install' | 'update' | 'update-bundle' | 'remove-bundle' | 'uninstall' | 'update-dependency' | 'update-plugin' | 'uninstall-plugin';
 import type { CapabilityMap } from '../../../shared/hooks/use-capabilities';
 export type MarketState = 'checking' | 'installed' | 'outdated' | 'missing' | 'unchecked' | 'unknown';
 export declare const MARKET_STATE_KEY: Readonly<Record<MarketState, string>>;
 export declare const MARKET_DOT: Readonly<Record<MarketState, 'ongoing' | 'done' | 'warning' | 'idle'>>;
 export interface MarketNote {
-    readonly key: 'panels.market.needEnv' | 'panels.market.noSource' | 'panels.market.badSource' | 'panels.market.moduleRestartHint';
+    readonly key: 'panels.market.needEnv' | 'panels.market.noSource' | 'panels.market.badSource' | 'panels.market.moduleRefused' | 'panels.market.moduleRestartHint' | 'panels.market.pluginLocalNoUpdate' | 'panels.market.pluginAlsoKnownAs' | 'panels.market.pluginBroken';
     readonly params: Readonly<Record<string, string>>;
 }
 export type MarketHintKey = 'panels.market.moduleRestartHint';
@@ -18,10 +18,12 @@ export type ModuleUpdateMap = Readonly<Record<string, ModuleUpdate>>;
 export interface MarketRow {
     readonly id: string;
     readonly titleKey: string;
+    readonly label?: string;
     readonly state: MarketState;
     readonly canInstall: boolean;
     readonly canUpdate: boolean;
     readonly canUninstall: boolean;
+    readonly plugin?: boolean;
     readonly note?: MarketNote;
     readonly hint?: MarketHintKey;
     readonly version?: {
@@ -31,14 +33,23 @@ export interface MarketRow {
     readonly moduleUpdate?: ModuleUpdate;
     readonly pkg?: string;
     readonly local?: boolean;
+    readonly broken?: boolean;
 }
+export declare function marketRowTitle(row: MarketRow, t: Translate): string;
 export interface InstalledWorkbenchModule {
     readonly unit: string;
     readonly pkg: string;
     readonly installed: string;
     readonly latest?: string | undefined;
     readonly local?: boolean | undefined;
+    readonly refused?: readonly string[] | undefined;
+    readonly clientRefused?: readonly string[] | undefined;
 }
+export declare function withClientRefusals(modules: readonly InstalledWorkbenchModule[], refusals: readonly {
+    readonly unit: string;
+    readonly reasons: readonly string[];
+}[]): readonly InstalledWorkbenchModule[];
+export declare function refusalReasons(host: readonly string[] | undefined, client: readonly string[] | undefined): readonly string[];
 export declare function mergeTitles(known: ReadonlyMap<string, string>, manifests: readonly UnitManifest[]): ReadonlyMap<string, string>;
 export declare function installedRows(modules: readonly InstalledWorkbenchModule[], manifests: readonly UnitManifest[], listed: ReadonlySet<string>, known?: ReadonlyMap<string, string> | undefined): MarketRow[];
 export declare function marketActions(row: MarketRow): MarketRowAction[];

package/dist/types/app/layouts/rightbar/registry.d.ts

@@ -2,7 +2,6 @@ import type { BoardModule } from '@dsh-workbench/shared';
 export interface BoardRegistry {
     register(module: BoardModule): () => void;
     all(): readonly BoardModule[];
-    visible(): readonly BoardModule[];
     byId(id: string): BoardModule | undefined;
     stepOwner(kind: string): BoardModule | undefined;
     subscribe(listener: () => void): () => void;

package/dist/types/app/units/__tests__/manifests.test.d.ts

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

package/dist/types/app/units/fixture-unit-mock.d.ts

@@ -1,7 +1,7 @@
-import type { BoardModule, UnitClientFace, UnitManifest } from '@dsh-workbench/shared';
+import type { BoardModule, UnitManifest, UnitOwnedClientFace } from '@dsh-workbench/shared';
 export declare const FIXTURE_UNIT_ID = "wb-fixture";
 export declare const CRASH_UNIT_ID = "wb-fixture-crash";
-export declare const FIXTURE_FACE: UnitClientFace;
-export declare const CRASH_FACE: UnitClientFace;
+export declare const FIXTURE_FACE: UnitOwnedClientFace;
+export declare const CRASH_FACE: UnitOwnedClientFace;
 export declare function fixtureRoster(roster: readonly UnitManifest[]): readonly UnitManifest[];
 export declare function fixtureSeed(roster: readonly UnitManifest[], all: readonly BoardModule[], crash?: boolean): readonly BoardModule[];

package/dist/types/app/units/host.d.ts

@@ -1,4 +1,4 @@
-import type { UnitHostFace } from '@dsh-workbench/shared/host';
+import type { UnitOwnedFace } from '@dsh-workbench/shared/host';
 export declare function assembleHostUnits(registry: {
-    register(face: UnitHostFace): () => void;
+    registerOwned(face: UnitOwnedFace): () => void;
 }): void;

package/dist/types/app/units/manifests.d.ts

@@ -0,0 +1,5 @@
+import type { ClientUnitRegistry } from './registry';
+export interface UnitManifestLoaderOptions {
+    readonly subscribeFacts?: (fact: string, listener: () => void) => () => void;
+}
+export declare function createUnitManifestLoader(options?: UnitManifestLoaderOptions): (registry: ClientUnitRegistry) => void;

package/dist/types/app/units/registry.d.ts

@@ -1,13 +1,21 @@
 import type { UnitManifest } from '@dsh-workbench/shared';
 import type { BoardModule, UnitClientFace } from '@dsh-workbench/shared';
 import { type BoardRegistry } from '../layouts/rightbar/registry';
+export interface ClientUnitRefusal {
+    readonly unit: string;
+    readonly reasons: readonly string[];
+}
 export interface ClientUnitRegistry {
     register(face: UnitClientFace): () => void;
     all(): readonly UnitClientFace[];
     manifests(): readonly UnitManifest[];
+    refusals(): readonly ClientUnitRefusal[];
+    setManifests(manifests: readonly UnitManifest[]): void;
     readonly board: BoardRegistry;
     subscribe(listener: () => void): () => void;
     version(): number;
 }
-export declare function toBoardModule(face: UnitClientFace): BoardModule;
-export declare function createClientUnitRegistry(): ClientUnitRegistry;
+export declare function toBoardModule(face: UnitClientFace, manifest: UnitManifest): BoardModule;
+export declare function createClientUnitRegistry(options?: {
+    readonly onUnknownUnit?: (unit: string) => void;
+}): ClientUnitRegistry;

package/dist/types/modules/panels/__tests__/market-env.test.d.ts

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

package/dist/types/modules/panels/__tests__/market-plugin.test.d.ts

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

package/dist/types/modules/panels/__tests__/market-route.test.d.ts

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

package/dist/types/modules/panels/__tests__/plugin-actions.test.d.ts

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

package/dist/types/modules/panels/__tests__/plugin-ledger.test.d.ts

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

package/dist/types/modules/panels/__tests__/plugin-section.test.d.ts

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

package/dist/types/modules/panels/__tests__/scope.test.d.ts

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

package/dist/types/modules/panels/__tests__/service-release.test.d.ts

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

package/dist/types/modules/panels/index.d.ts

@@ -1,2 +1,2 @@
-import type { UnitHostFace } from '@dsh-workbench/shared/host';
-export declare const panelsHost: UnitHostFace;
+import type { UnitOwnedFace } from '@dsh-workbench/shared/host';
+export declare const panelsHost: UnitOwnedFace;

package/dist/types/modules/panels/model/config.d.ts

@@ -1,5 +1,22 @@
-import type { UnitManifest } from '@dsh-workbench/shared';
-export type ShownPanels = readonly string[];
+import type { UnitManifest } from '@dsh-workbench/shared/host';
+export type PanelList = readonly string[];
+export interface PanelBoard {
+    readonly shown: PanelList;
+    readonly hidden: PanelList;
+}
+export declare const EMPTY_BOARD: PanelBoard;
+export interface ScopeBoards {
+    readonly workspace: PanelBoard | null;
+    readonly machine: PanelBoard | null;
+}
+export type BoardTarget = 'machine' | 'workspace';
+export declare const BOARD_TARGETS: readonly BoardTarget[];
+export declare const DEFAULT_BOARD_TARGET: BoardTarget;
+export interface ScopeQuery {
+    readonly id: string;
+    readonly boards: ScopeBoards;
+}
+export declare function resolveScope(query: ScopeQuery): boolean;
 export interface PanelEntry {
     readonly id: string;
     readonly titleKey: string;
@@ -8,11 +25,12 @@ export interface PanelEntry {
     readonly source: 'default' | 'user';
     readonly hasCard: boolean;
 }
-export declare function parseShown(raw: unknown): string[];
+export declare function parseBoard(raw: unknown): PanelBoard;
 export declare function parseReleased(raw: unknown): string[];
-export declare function resolvePanels(manifests: readonly UnitManifest[], panels: ShownPanels | null): PanelEntry[];
-export declare function withoutReleased(released: ShownPanels, id: string): string[];
-export declare function withReleased(released: ShownPanels, id: string): string[];
-export declare function withShown(panels: ShownPanels, id: string): string[];
-export declare function withHidden(panels: ShownPanels, id: string): string[];
-export declare function withMoved(panels: ShownPanels, id: string, index: number): string[];
+export declare function resolvePanels(manifests: readonly UnitManifest[], boards: ScopeBoards): PanelEntry[];
+export declare function withoutReleased(released: PanelList, id: string): string[];
+export declare function withReleased(released: PanelList, id: string): string[];
+export declare function withShown(board: PanelBoard, id: string): PanelBoard;
+export declare function withHidden(board: PanelBoard, id: string): PanelBoard;
+export declare function withoutPanel(board: PanelBoard, id: string): PanelBoard;
+export declare function withMoved(board: PanelBoard, id: string, index: number): PanelBoard;

package/dist/types/modules/panels/model/market-dispatch.d.ts

@@ -2,6 +2,7 @@ import type { ProvisionRequest } from '@dsh-workbench/shared/host';
 import type { BundleCancellation, BundleChange } from '../../../shared/api/bundle-install';
 import type { InstalledModule } from '../../../shared/api/host/installed-module';
 import type { BundleSupply, MarketEntry, MarketService } from './market';
+import type { PluginKept } from './plugin-actions';
 import type { SharedDependency } from './market-dependency';
 export type ProvisionResult = {
     readonly ok: true;
@@ -28,5 +29,13 @@ export type ProvisionResult = {
     readonly ok: true;
     readonly action: 'cancel-install';
     readonly cancellation: BundleCancellation | null;
+} | {
+    readonly ok: true;
+    readonly action: 'update-plugin';
+} | {
+    readonly ok: true;
+    readonly action: 'uninstall-plugin';
+    readonly removed: boolean;
+    readonly kept?: PluginKept;
 };
 export declare function dispatchMarket(market: MarketService, request: ProvisionRequest): Promise<ProvisionResult>;

package/dist/types/modules/panels/model/market-env.d.ts

@@ -0,0 +1,20 @@
+import type { UnitEnvNeeds, UnitManifest } from '@dsh-workbench/shared';
+import type { UnitCapability } from '../../../shared/api/host/probe-units';
+import { type PluginReferences } from './plugin-actions';
+import type { PluginLedger } from './plugin-ledger';
+export interface EnvDropper {
+    usersOf(plugin: string, except?: string): string[];
+    drop(unit: string, env: UnitEnvNeeds | undefined, before: UnitCapability): Promise<string[]>;
+}
+export declare function createEnvDropper(options: {
+    readonly catalog: () => readonly UnitManifest[];
+    readonly isReleased?: ((unit: string) => boolean) | undefined;
+    readonly ledger?: PluginLedger | undefined;
+    readonly references?: (() => PluginReferences) | undefined;
+    readonly command: string;
+    readonly run: (line: string, optional?: boolean) => Promise<void>;
+    readonly logger?: {
+        info?(message: string): void;
+        warn?(message: string): void;
+    } | undefined;
+}): EnvDropper;

package/dist/types/modules/panels/model/market-route.d.ts

@@ -0,0 +1,26 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import type { PluginSourceCommand } from '@dsh-workbench/shared/host';
+import type { BundleChange } from '../../../shared/api/bundle-install';
+import type { BundleManager } from '../../../shared/api/host/bundle-manager';
+import type { InstalledModule } from '../../../shared/api/host/installed-module';
+import type { PluginLedger } from './plugin-ledger';
+import type { BundleInstallOptions, BundleInstallOutcome, BundleSupply } from './market-types';
+export interface BundleInstallDeps {
+    readonly spec: string;
+    readonly options?: BundleInstallOptions | undefined;
+    readonly registry?: string | undefined;
+    readonly command: string;
+    readonly shell?: DshShell | undefined;
+    readonly manager: BundleManager;
+    readonly installed?: ((pkg: string) => InstalledModule) | undefined;
+    readonly logger?: {
+        info?(message: string): void;
+        warn?(message: string): void;
+    } | undefined;
+    readonly ledger?: PluginLedger | undefined;
+    readonly runAll: (commands: readonly PluginSourceCommand[]) => Promise<void>;
+    readonly supplyAfter: (module: InstalledModule, change: BundleChange) => Promise<BundleSupply>;
+    readonly rememberSource: (manager: BundleManager, pkg: string, registry: string | undefined) => Promise<void>;
+}
+export declare function installDshBundle(deps: Omit<BundleInstallDeps, 'spec' | 'options'>, spec: string, options?: BundleInstallOptions): Promise<BundleInstallOutcome>;
+export declare function installRouted(deps: BundleInstallDeps): Promise<BundleInstallOutcome>;

package/dist/types/modules/panels/model/market-types.d.ts

@@ -0,0 +1,71 @@
+import type { PluginSource } from '@dsh-workbench/shared';
+import type { ProvisionAction } from '@dsh-workbench/shared/host';
+import type { BundleCancellation, BundleChange, BundleInstalledPlugin } from '../../../shared/api/bundle-install';
+import type { InstalledModule } from '../../../shared/api/host/installed-module';
+import type { UnitCapability } from '../../../shared/api/host/probe-units';
+import type { PluginUninstallOutcome, PluginUpdateOutcome } from './plugin-actions';
+import type { SharedDependency } from './market-dependency';
+export type MarketAction = ProvisionAction;
+export interface MarketEntry {
+    readonly unit: string;
+    readonly titleKey: string;
+    readonly plugins: readonly {
+        readonly name: string;
+        readonly source?: PluginSource;
+    }[];
+    readonly libs: readonly {
+        readonly name: string;
+        readonly version?: string | undefined;
+        readonly purpose: string;
+    }[];
+    readonly capability: UnitCapability;
+}
+export interface UninstallResult {
+    readonly entry: MarketEntry;
+    readonly keptFor: readonly string[];
+    readonly change?: BundleChange;
+}
+export interface BundleInstallOptions {
+    readonly registry?: string | undefined;
+    readonly approvedBuilds?: readonly string[] | undefined;
+    readonly requestId?: string | undefined;
+}
+export type BundleSupply = {
+    readonly state: 'not-a-module';
+} | {
+    readonly state: 'no-needs';
+} | {
+    readonly state: 'installed';
+    readonly entry: MarketEntry;
+} | {
+    readonly state: 'failed';
+    readonly reason: string;
+} | {
+    readonly state: 'pending-restart';
+};
+export interface BundleInstallOutcome {
+    readonly change: BundleChange;
+    readonly module: InstalledModule;
+    readonly supply: BundleSupply;
+    readonly plugin?: BundleInstalledPlugin;
+}
+export interface BundleRemoveOutcome {
+    readonly change: BundleChange;
+    readonly keptFor: readonly string[];
+}
+export interface MarketService {
+    list(): Promise<{
+        readonly modules: MarketEntry[];
+        readonly shared: readonly SharedDependency[];
+    }>;
+    install(unit: string): Promise<MarketEntry>;
+    update(unit: string): Promise<MarketEntry>;
+    uninstall(unit: string): Promise<UninstallResult>;
+    updateDependency(id: string): Promise<readonly SharedDependency[]>;
+    installBundle(spec: string, options?: BundleInstallOptions): Promise<BundleInstallOutcome>;
+    updateBundle(unit: string): Promise<BundleInstallOutcome | null>;
+    removeBundle(pkg: string): Promise<BundleRemoveOutcome>;
+    cancelInstall(requestId: string): Promise<BundleCancellation | null>;
+    updatePlugin(pkg: string): Promise<PluginUpdateOutcome>;
+    uninstallPlugin(pkg: string): Promise<PluginUninstallOutcome>;
+}

package/dist/types/modules/panels/model/market.d.ts

@@ -1,75 +1,14 @@
 import type { DshShell } from '@dsh-workbench/shared';
-import type { PluginSource, UnitManifest } from '@dsh-workbench/shared';
-import type { BundleCancellation, BundleChange } from '../../../shared/api/bundle-install';
+import type { UnitManifest } from '@dsh-workbench/shared';
 import type { BundleManager } from '../../../shared/api/host/bundle-manager';
 import type { InstalledModule, ProfileModule } from '../../../shared/api/host/installed-module';
 import { type RegistryNotebook } from '../../../shared/api/host/profile-registries';
-import type { UnitCapability } from '../../../shared/api/host/probe-units';
-import type { ProvisionAction } from '@dsh-workbench/shared/host';
 import type { UnitMountDeps } from '@dsh-workbench/shared/host';
-import { type SharedDependency } from './market-dependency';
+import { type PluginReferences } from './plugin-actions';
+import type { PluginLedger } from './plugin-ledger';
+import type { MarketService } from './market-types';
 export type { SharedDependency } from './market-dependency';
-export type MarketAction = ProvisionAction;
-export interface MarketEntry {
-    readonly unit: string;
-    readonly titleKey: string;
-    readonly plugins: readonly {
-        readonly name: string;
-        readonly source?: PluginSource;
-    }[];
-    readonly libs: readonly {
-        readonly name: string;
-        readonly version?: string | undefined;
-        readonly purpose: string;
-    }[];
-    readonly capability: UnitCapability;
-}
-export interface UninstallResult {
-    readonly entry: MarketEntry;
-    readonly keptFor: readonly string[];
-    readonly change?: BundleChange;
-}
-export interface BundleInstallOptions {
-    readonly registry?: string | undefined;
-    readonly approvedBuilds?: readonly string[] | undefined;
-    readonly requestId?: string | undefined;
-}
-export type BundleSupply = {
-    readonly state: 'not-a-module';
-} | {
-    readonly state: 'no-needs';
-} | {
-    readonly state: 'installed';
-    readonly entry: MarketEntry;
-} | {
-    readonly state: 'failed';
-    readonly reason: string;
-} | {
-    readonly state: 'pending-restart';
-};
-export interface BundleInstallOutcome {
-    readonly change: BundleChange;
-    readonly module: InstalledModule;
-    readonly supply: BundleSupply;
-}
-export interface BundleRemoveOutcome {
-    readonly change: BundleChange;
-    readonly keptFor: readonly string[];
-}
-export interface MarketService {
-    list(): Promise<{
-        readonly modules: MarketEntry[];
-        readonly shared: readonly SharedDependency[];
-    }>;
-    install(unit: string): Promise<MarketEntry>;
-    update(unit: string): Promise<MarketEntry>;
-    uninstall(unit: string): Promise<UninstallResult>;
-    updateDependency(id: string): Promise<readonly SharedDependency[]>;
-    installBundle(spec: string, options?: BundleInstallOptions): Promise<BundleInstallOutcome>;
-    updateBundle(unit: string): Promise<BundleInstallOutcome | null>;
-    removeBundle(pkg: string): Promise<BundleRemoveOutcome>;
-    cancelInstall(requestId: string): Promise<BundleCancellation | null>;
-}
+export type { BundleInstallOptions, BundleInstallOutcome, BundleRemoveOutcome, BundleSupply, MarketAction, MarketEntry, MarketService, UninstallResult, } from './market-types';
 export declare function createMarketService(options: {
     manifests: readonly UnitManifest[];
     manifestsNow?: (() => readonly UnitManifest[]) | undefined;
@@ -83,6 +22,8 @@ export declare function createMarketService(options: {
     installed?: ((pkg: string) => InstalledModule) | undefined;
     modules?: (() => readonly ProfileModule[]) | undefined;
     registries?: RegistryNotebook | undefined;
+    ledger?: PluginLedger | undefined;
+    references?: (() => PluginReferences) | undefined;
     logger?: {
         info?(message: string): void;
         warn?(message: string): void;

package/dist/types/modules/panels/model/plugin-actions.d.ts

@@ -0,0 +1,50 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import { type PluginSourceCommand } from '@dsh-workbench/shared/host';
+import type { PluginLedger } from './plugin-ledger';
+export type PluginKept = {
+    readonly kind: 'held';
+} | {
+    readonly kind: 'claimed';
+    readonly by: readonly string[];
+} | {
+    readonly kind: 'unsure';
+    readonly unreadable: readonly string[];
+} | {
+    readonly kind: 'unnamed';
+};
+export interface PluginUninstallOutcome {
+    readonly removed: boolean;
+    readonly name?: string;
+    readonly kept?: PluginKept;
+}
+export interface PluginUpdateOutcome {
+    readonly name?: string;
+}
+export interface PluginReferences {
+    readonly trustworthy: boolean;
+    readonly unreadable: readonly string[];
+}
+export declare function pluginKeptOf(retention: 'keep-held' | 'keep-claimed' | 'keep-unsure', detail: {
+    readonly by: readonly string[];
+    readonly unreadable: readonly string[];
+}): PluginKept;
+export declare function pluginKeptText(kept: PluginKept): string;
+export declare function pluginRemovedText(pkg: string): string;
+export declare function pluginSweptText(pkg: string): string;
+export interface PluginActions {
+    update(pkg: string): Promise<PluginUpdateOutcome>;
+    uninstall(pkg: string): Promise<PluginUninstallOutcome>;
+    sweep(): Promise<readonly string[]>;
+}
+export declare function createPluginActions(options: {
+    readonly ledger?: PluginLedger | undefined;
+    readonly shell?: DshShell | undefined;
+    readonly command: string;
+    readonly runAll: (commands: readonly PluginSourceCommand[]) => Promise<void>;
+    readonly claimedBy?: ((plugin: string) => readonly string[]) | undefined;
+    readonly references?: (() => PluginReferences) | undefined;
+    readonly logger?: {
+        info?(message: string): void;
+        warn?(message: string): void;
+    } | undefined;
+}): PluginActions;

package/dist/types/modules/panels/model/plugin-ledger.d.ts

@@ -0,0 +1,22 @@
+import type { PluginLedgerEntry, WorkspaceStore } from '@dsh-workbench/shared/host';
+export interface PluginLedgerIntent {
+    readonly package: string;
+    readonly registry?: string | undefined;
+    readonly local?: boolean | undefined;
+}
+export interface PluginLedger {
+    readonly home: string;
+    list(): readonly PluginLedgerEntry[];
+    all(): readonly PluginLedgerEntry[];
+    read(pkg: string): PluginLedgerEntry | undefined;
+    held(pkg: string): boolean;
+    heldAsPlugin(plugin: string): PluginLedgerEntry | undefined;
+    intend(intent: PluginLedgerIntent): void;
+    complete(pkg: string, name: string | undefined): void;
+    release(pkg: string): void;
+    drop(pkg: string): void;
+}
+export declare function createPluginLedger(options: {
+    readonly store: WorkspaceStore;
+    readonly home: string;
+}): PluginLedger;

package/dist/types/modules/panels/model/plugin-name.d.ts

@@ -0,0 +1,8 @@
+export interface PluginEntryRef {
+    readonly package: string;
+    readonly local?: boolean | undefined;
+    readonly name?: string | undefined;
+}
+export declare function pluginDirOf(entry: PluginEntryRef): string;
+export declare function pluginOnDisk(entry: PluginEntryRef): boolean;
+export declare function pluginNameOf(entry: PluginEntryRef): string | undefined;

package/dist/types/modules/panels/model/plugin-name.test.d.ts

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

package/dist/types/modules/panels/model/plugin-section.d.ts

@@ -0,0 +1,13 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import { type RouteTable } from '@dsh-workbench/shared/host';
+import type { InstalledPlugin } from '../../../shared/api/installed-plugins';
+import type { PluginLedger } from './plugin-ledger';
+export declare function installedPlugins(options: {
+    readonly ledger: PluginLedger;
+    readonly shell?: DshShell | undefined;
+    readonly force?: boolean;
+}): Promise<readonly InstalledPlugin[]>;
+export declare function pluginRoutes(options: {
+    readonly ledger: PluginLedger;
+    readonly shell?: DshShell | undefined;
+}): RouteTable;

package/dist/types/modules/panels/model/service.d.ts

@@ -1,24 +1,26 @@
 import type { WorkspaceStore } from '@dsh-workbench/shared/host';
 import type { UnitManifest } from '@dsh-workbench/shared';
-import { type PanelEntry } from './config';
+import { type BoardTarget, type PanelEntry, type ScopeBoards } from './config';
 export declare const PANELS_MODULE_ID = "panels";
 export declare const PANELS_FILE = "config.json";
 export declare const RELEASED_FILE = "released.json";
 export interface PanelsService {
-    list(workspace: string | null): PanelEntry[];
+    list(workspace: string | null, target?: BoardTarget): PanelEntry[];
+    boards(workspace: string | null): ScopeBoards;
     isReleased(id: string): boolean;
     release(id: string): void;
     accept(id: string): void;
     subscribe(listener: () => void): () => void;
     isEnabled(id: string, workspace: string | null): boolean;
-    show(id: string, workspace: string | null): PanelEntry[];
-    hide(id: string, workspace: string | null): PanelEntry[];
-    move(id: string, index: number, workspace: string | null): PanelEntry[];
-    resetWorkspace(workspace: string | null): PanelEntry[];
+    show(id: string, workspace: string | null, target?: BoardTarget): PanelEntry[];
+    hide(id: string, workspace: string | null, target?: BoardTarget): PanelEntry[];
+    move(id: string, index: number, workspace: string | null, target?: BoardTarget): PanelEntry[];
+    reset(workspace: string | null, target?: BoardTarget): PanelEntry[];
 }
 export declare function createPanelsService(options: {
     manifests: () => readonly UnitManifest[];
     store: WorkspaceStore;
+    owned?: (() => readonly string[]) | undefined;
     logger?: {
         warn?(message: string): void;
     } | undefined;