@deepseek-ai/dsh-app-boot 0.1.6-alpha.2 → 0.1.7-alpha.2

package/lib/types/config-schema/collect.d.ts

@@ -0,0 +1,16 @@
+/** Boot-free inspection of declared plugin Config schemas using profile module resolution. */
+import type { Profile, RuntimeResolution } from '../profile.ts';
+import type { ConfigSchemaDiagnostic, ConfigSchemaDump } from './types.ts';
+/**
+ * Generate JSON Schema from parsed entry rows and root-tree patches without applying plugins or evaluating expressions.
+ * Imports, Config getters, and lazy schema builders execute trusted plugin code; transform callbacks do not. Calls must not overlap
+ * another profile-resolution interception; module imports remain cached after the interception is released.
+ * @param profile - prepared profile whose directory anchors root module and include resolution.
+ * @param entries - unvalidated rows from profile composition; malformed rows become positioned diagnostics without losing siblings.
+ * @param resolution - the same immutable package resolution used for profile boot.
+ * @param diagnostics - existing composition diagnostics; copied into the returned catalog.
+ * @returns a JSON Schema document with partial-result diagnostics and Config references under `x-cordis`.
+ * @throws when Node's profile module resolution cannot be installed.
+ */
+export declare function collectConfigSchemas(profile: Profile, entries: readonly unknown[], resolution: RuntimeResolution, diagnostics?: readonly ConfigSchemaDiagnostic[]): Promise<ConfigSchemaDump>;
+//# sourceMappingURL=collect.d.ts.map

package/lib/types/config-schema/document.d.ts

@@ -0,0 +1,13 @@
+/** Compose Loader entry/patch structure and discovered plugin input schemas into one JSON Schema document. */
+import type { CollectedConfigEntry, ConfigSchemaDiagnostic, ConfigSchemaDump } from './types.ts';
+/**
+ * Build a schema for the composed entry list and a separately addressable root-tree patch list.
+ * Unknown plugin names remain open; only collected schemas supply plugin-specific constraints.
+ * @param profile - selected profile name.
+ * @param collected - declarations discovered without mounting plugins, including include descendants.
+ * @param targets - last-id-wins patch targets from the root tree's patch index, excluding include descendants.
+ * @param initialDiagnostics - composition and import diagnostics already collected.
+ * @returns one JSON Schema document with explicit collection and projection annotations.
+ */
+export declare function buildConfigSchemaDocument(profile: string, collected: readonly CollectedConfigEntry[], targets: ReadonlyMap<string, CollectedConfigEntry>, initialDiagnostics: readonly ConfigSchemaDiagnostic[]): Promise<ConfigSchemaDump>;
+//# sourceMappingURL=document.d.ts.map

package/lib/types/config-schema/index.d.ts

@@ -0,0 +1,20 @@
+/** Profile schema generation: composition diagnostics, runtime resolution, and boot-free discovery. */
+import type { PatchOptions } from '@deepseek-ai/cordis-plugin-include';
+import { type Profile } from '../profile.ts';
+import type { ConfigSchemaDump } from './types.ts';
+export type { ConfigSchemaDump, NativeConfigSchema } from './types.ts';
+/**
+ * Generate JSON Schema for a prepared profile's ordered patch layers without mounting plugins or evaluating expressions.
+ * Reads the profile manifest; imports, Config getters, and lazy builders execute trusted code. Native validators and
+ * transform callbacks are not executed. Calls must not overlap another profile-resolution interception; collection
+ * releases its interception on success or rejection, while Node retains imported modules. Supplied layers are not mutated.
+ * Profile preparation, layer selection, process streams, and exit policy belong to the caller.
+ * @param binName - the diagnostic prefix on thrown manifest errors.
+ * @param profile - prepared on-disk profile whose directory anchors root module and include resolution.
+ * @param layers - already parsed patch lists in application order, including caller-selected home and argv overlays.
+ * @param installAnchor - package manifest anchoring the installation's runtime dependencies.
+ * @returns a JSON Schema document with declaration references, partial results, and diagnostics under `x-cordis`.
+ * @throws when profile metadata, composition, or runtime resolution cannot be prepared.
+ */
+export declare function generateConfigSchema(binName: string, profile: Profile, layers: readonly PatchOptions[][], installAnchor: string): Promise<ConfigSchemaDump>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/config-schema/native.d.ts

@@ -0,0 +1,9 @@
+/** Identity checks at the plugin-export and lazy-builder boundaries. */
+import type { NativeConfigSchema } from './types.ts';
+/**
+ * Recognize the native Schemastery graph protocol without invoking a validator or serialization hook.
+ * @param value - plugin Config export or lazy-builder result.
+ * @returns whether native schema fields can be inspected.
+ */
+export declare function isNativeConfigSchema(value: unknown): value is NativeConfigSchema;
+//# sourceMappingURL=native.d.ts.map

package/lib/types/config-schema/pattern.d.ts

@@ -0,0 +1,8 @@
+/** Conservative compatibility checks between native RegExp validation and Unicode JSON Schema patterns. */
+/**
+ * Create a checker for patterns that can retain native acceptance under Unicode regex semantics.
+ * Unrecognized flagless syntax stays explicitly partial rather than becoming a misleading constraint.
+ * @returns the compatibility predicate; parsing never executes the regular expression against config values.
+ */
+export declare function createPatternCheck(): Promise<(source: string, flags?: string) => boolean>;
+//# sourceMappingURL=pattern.d.ts.map

package/lib/types/config-schema/projector.d.ts

@@ -0,0 +1,20 @@
+/** Project native Config input constraints without executing their validators or transform callbacks. */
+import type { ConfigJsonSchema, ConfigJsonSchemaObject, NativeConfigSchema } from './types.ts';
+/** Definition that projected value positions reference as `#/$defs/loaderExpression`; an enclosing document must define it. */
+export declare const LOADER_EXPRESSION_SCHEMA: ConfigJsonSchemaObject;
+/** One Config projection; unknown omission behavior is explicit rather than an invented default. */
+export interface ConfigProjection {
+    /** Object-form root: value positions are wrapped in `anyOf` with the loader-expression reference. */
+    schema: ConfigJsonSchemaObject;
+    definitions: Record<string, ConfigJsonSchema>;
+    acceptsMissing: boolean | 'unknown';
+    limitations: string[];
+}
+/**
+ * Create an invocation-local projector. Ajv checks only literal defaults against generated schemas;
+ * it does not fill defaults, coerce input, or call native plugin validators. Opaque input or metadata effects
+ * widen validation with explicit limitations instead of simulating native mutation.
+ * @returns a function projecting one trusted native Config graph into the enclosing document's definitions.
+ */
+export declare function createConfigProjector(): Promise<(root: NativeConfigSchema, prefix: string) => ConfigProjection>;
+//# sourceMappingURL=projector.d.ts.map

package/lib/types/config-schema/types.d.ts

@@ -0,0 +1,95 @@
+/** JSON Schema output and native graph inputs for boot-free configuration inspection. */
+/** JSON Schema 2020-12, including annotations that standard validators may ignore. */
+export type ConfigJsonSchema = boolean | ConfigJsonSchemaObject;
+/** Object-form JSON Schema; vocabulary extensions are annotations, not executable validators. */
+export interface ConfigJsonSchemaObject {
+    [keyword: string]: unknown;
+    $schema?: string;
+    $ref?: string;
+    $defs?: Record<string, ConfigJsonSchema>;
+    type?: string | string[];
+    properties?: Record<string, ConfigJsonSchema>;
+    required?: string[];
+    items?: ConfigJsonSchema;
+    prefixItems?: ConfigJsonSchema[];
+    additionalProperties?: ConfigJsonSchema;
+    propertyNames?: ConfigJsonSchema;
+    anyOf?: ConfigJsonSchema[];
+    allOf?: ConfigJsonSchema[];
+    not?: ConfigJsonSchema;
+    if?: ConfigJsonSchema;
+    then?: ConfigJsonSchema;
+    default?: unknown;
+    description?: string;
+}
+/** A collection or projection diagnostic, without independently collected config values. */
+export interface ConfigSchemaDiagnostic {
+    level: 'warning' | 'error';
+    /** Structural position in the discovered entry tree, when applicable. */
+    path?: string;
+    message: string;
+}
+/** One declared entry and its generated Config reference; include paths describe discovery, not root JSON pointers. */
+export interface ConfigSchemaEntry {
+    path: string;
+    id?: string;
+    /** Omitted when a malformed row has no literal plugin name. */
+    name?: string;
+    status: 'schema' | 'partial' | 'absent' | 'unsupported' | 'error';
+    configRef?: string;
+    /** Native Loader carrier, whose config is not interpolated as an ordinary plugin config. */
+    tree?: 'group' | 'include';
+}
+/** JSON Schema for a composed entry list; `$defs.patchList` describes profile overlays. */
+export interface ConfigSchemaDump extends ConfigJsonSchemaObject {
+    $schema: 'https://json-schema.org/draft/2020-12/schema';
+    $defs: Record<string, ConfigJsonSchema>;
+    'x-cordis': {
+        profile: string;
+        /** False for error diagnostics, partial/unsupported/error entries, or ambiguous plugin-name schemas; includes disabled declarations. */
+        complete: boolean;
+        entries: ConfigSchemaEntry[];
+        diagnostics: ConfigSchemaDiagnostic[];
+        patchSchema: '#/$defs/patchList';
+    };
+}
+/** Native Schemastery graph protocol after its identity marker has been checked. */
+export interface NativeConfigSchema {
+    type: string;
+    meta: {
+        role?: string;
+        extra?: unknown;
+        hidden?: boolean;
+        disabled?: boolean;
+        collapse?: boolean;
+        link?: string;
+        comment?: string;
+        badges?: {
+            text: string;
+            type: string;
+        }[];
+        required?: boolean;
+        volatile?: boolean;
+        default?: unknown;
+        min?: number;
+        max?: number;
+        step?: number;
+        pattern?: {
+            source: string;
+            flags?: string;
+        };
+        description?: string | Record<string, string>;
+        loose?: boolean;
+    };
+    dict?: Record<string, NativeConfigSchema>;
+    inner?: NativeConfigSchema;
+    sKey?: NativeConfigSchema;
+    list?: NativeConfigSchema[];
+    value?: unknown;
+    builder?: unknown;
+}
+/** Collected declaration used only while constructing the JSON Schema document. */
+export interface CollectedConfigEntry extends ConfigSchemaEntry {
+    native?: NativeConfigSchema;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/index.d.ts

@@ -12,14 +12,26 @@ import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
 import { type LaunchEnvironmentSnapshot } from '@deepseek-ai/dsh-launch-environment';
 export { readProfilePatches, resolveTelemetryPatch, type ProfileContext, type ProfilePnpmInvocation } from './profile-context.ts';
 export { sanitizeProfile } from './profile-sanitize.ts';
+export { readPluginMeta } from './package-meta.ts';
+export { generateConfigSchema, type ConfigSchemaDump, type NativeConfigSchema } from './config-schema/index.ts';
+export { createConfigProjector, LOADER_EXPRESSION_SCHEMA, type ConfigProjection } from './config-schema/projector.ts';
+export { isNativeConfigSchema } from './config-schema/native.ts';
 export { readProfilePlugins, reconcileProfilePlugins, writeProfileBundles, type ProfilePluginLocation, type ProfilePluginDependency, type ProfilePluginInventory, type ProfilePluginReconciliation, } from './profile-plugins.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         /** Harness-home path resolver available to Loader `!!js` config expressions. */
         dshHomePath?: typeof dshHomePath;
     }
+    interface Events {
+        /**
+         * Profile patches were reconciled into the running Loader tree: every entry update settled and no new
+         * inactive entry was introduced. Carries no diff; listeners re-read Loader entries.
+         * @mode emit
+         */
+        'app-boot/config-reload'(): void;
+    }
 }
-export { composeEntries, createProfileResolutionGeneration, DEFAULT_PROFILE_BUNDLES, OPTIONAL_BUNDLES, healProfilesModuleFallback, healIsolatedProfileModuleFallback, unlinkProfileModuleFallback, initProfile, loadProfile, loadProfileDirectory, PROFILE_PATCH_FILENAME, PROFILE_TEMPLATES, PROFILES_DIR, readProfileManifest, resolveBundleDir, resolveProfileDir, writeProfileManifest, type Profile, type ProfileLayer, type ProfileManifest, type ProfileModuleFallbackOptions, type ProfileResolutionEntry, type ProfileResolutionGeneration, type ProfileResolutionMode, type ProfileTemplate, } from './profile.ts';
+export { composeEntries, createRuntimeResolution, DEFAULT_PROFILE_BUNDLES, OPTIONAL_BUNDLES, bundlePatchFiles, bundlePatchPaths, initProfile, removeLinkProjections, loadProfile, loadProfileDirectory, PROFILE_PATCH_FILENAME, PROFILE_TEMPLATES, PROFILES_DIR, readProfileManifest, resolveBundleDir, resolveProfileDir, writeProfileManifest, type Profile, type ProfileLayer, type ProfileManifest, type LinkedRoot, type RuntimeResolutionOptions, type RuntimeResolutionEntry, type RuntimeResolution, type ProfileTemplate, } from './profile.ts';
 export { PluginPackages, type PluginPackage, type PluginPackagesConfig, } from './profile-resolution/service.ts';
 /**
  * Resolve the config to boot. Replay swaps a `cordis.yml` basename for
@@ -132,13 +144,15 @@ export declare function renderConfigDump(binName: string, absoluteConfigPath: st
  * entry creation was in flight.
  */
 export declare function mountRootInclude(ctx: Context, absoluteConfigPath: string, patches?: readonly PatchOptions[], bareModuleBaseUrl?: string): Promise<Entry | undefined>;
+/** The two process events {@link installFailLoud} turns into a fatal exit. */
+export type FailLoudEvent = 'unhandledRejection' | 'uncaughtException';
 /**
  * The slice of `process` {@link installFailLoud} needs — injectable so tests
  * exercise the handler without registering on (or exiting) the real process.
  */
 export interface FailLoudProcess {
-    on(event: 'unhandledRejection', handler: (err: unknown) => void): unknown;
-    off(event: 'unhandledRejection', handler: (err: unknown) => void): unknown;
+    on(event: FailLoudEvent, handler: (err: unknown) => void): unknown;
+    off(event: FailLoudEvent, handler: (err: unknown) => void): unknown;
     stderr: {
         write(chunk: string): unknown;
     };
@@ -155,11 +169,22 @@ export interface FailLoudProcess {
  */
 export declare const FAIL_LOUD_RELEASE_TIMEOUT_MS = 2000;
 /**
- * Install before boot to turn a late unhandled plugin-init rejection into one
- * labelled stderr diagnostic and `exit(1)`. A rejection already included by
- * {@link auditStartupEntries} is ignored during its process checkpoint;
- * every other rejection remains fatal. Stdout remains untouched for ACP; the
- * returned function removes the handler.
+ * Install before boot to turn an unhandled rejection or an uncaught exception,
+ * at any point in the process lifetime, into one labelled stderr diagnostic and
+ * `exit(1)`. A rejection already included by {@link auditStartupEntries} is
+ * ignored during its process checkpoint; every other rejection and every
+ * uncaught exception remains fatal. Control never returns to the failed
+ * operation after either: only the throw site knows which state is intact, and
+ * a listener that threw mid-update (a stream `'data'` handler, a half-applied
+ * registry write) leaves silently wrong results behind if it were resumed. The
+ * event loop keeps running only until the release hook settles or times out.
+ * Stdout remains untouched for ACP; the returned function removes both handlers.
+ *
+ * The diagnostic is `util.inspect(err)`, not `err.stack`: a `node:fs` error's
+ * `code`, `syscall`, and `path` and any `cause` chain are enumerable properties
+ * that the stack line omits, and they are what a crash report needs. Once a
+ * handler is installed Node prints nothing of its own, so this line is the
+ * only record of the failure.
  *
  * The Loader mounts entries concurrently, so a surface that owns the terminal
  * can already hold it when a sibling entry rejects. Exiting straight from the
@@ -181,7 +206,7 @@ export declare const FAIL_LOUD_RELEASE_TIMEOUT_MS = 2000;
  * @param release - optional teardown awaited before exit, used by a
  *   terminal-owning surface to restore the terminal. Its own failure is
  *   swallowed because the pending fatal exit already owns the outcome.
- * @returns the uninstaller that removes the rejection handler.
+ * @returns the uninstaller that removes both handlers.
  */
 export declare function installFailLoud(binName: string, proc?: FailLoudProcess, release?: () => Promise<void> | void): () => void;
 interface InactiveEntry {

package/lib/types/package-meta.d.ts

@@ -0,0 +1,25 @@
+/** Read plugin display text and icons through exported resources without evaluating plugin code. */
+import type { PluginLocalizedMeta } from '@deepseek-ai/dsh-package-manifest';
+/**
+ * Resolve a plugin resource through the active Node ESM resolver without evaluating it.
+ * @param specifier - complete resource module specifier, including its locale filename.
+ * @param parentURL - owning module-resolution base.
+ * @returns the local filesystem path selected by Node and the active profile.
+ * @throws when the resolver is unavailable or the resource cannot resolve to a local file.
+ */
+export declare function resolvePluginResource(specifier: string, parentURL: string): string;
+/**
+ * Read localized display text and the icon declared in a plugin's exported package.json.
+ * Icons are manifest-relative SVG, PNG, JPEG, or WebP files of at most 256 KiB,
+ * contained in the manifest directory after realpath resolution. Icon failures retain display text.
+ * Non-package specifiers are skipped without invoking the resource resolver.
+ * Language files share the directory containing the resolved English resource;
+ * each file is resolved through the complete plugin specifier before reading.
+ * Missing fields use the same address's package.json name/description. Translation
+ * maps retain an English fallback, ultimately the full module specifier for titles and empty for descriptions.
+ * @param specifier - configured plugin module name, including any package subpath.
+ * @param parentURL - owning Loader tree's module-resolution base.
+ * @returns display fields and any icon diagnostic, or undefined for non-package specifiers or absent metadata.
+ */
+export declare function readPluginMeta(specifier: string, parentURL: string): PluginLocalizedMeta | undefined;
+//# sourceMappingURL=package-meta.d.ts.map

package/lib/types/profile-resolution/legacy-links.d.ts

@@ -1,35 +1,8 @@
-/** Legacy profile-link inspection shared by the disk materializer and runtime resolver. */
-/** Profile-private package links projected into its pnpm-managed node_modules. */
-export declare const PROFILE_MODULE_FALLBACK_DIR = ".dsh-module-fallback";
-/**
- * Return whether the process reads application modules from pkg's virtual filesystem.
- * @returns whether pkg owns the module filesystem.
- */
-export declare function isPackagedExecutable(): boolean;
+/** Package directory canonicalization through the active runtime carrier's filesystem. */
 /**
  * Resolve a directory through the active carrier's filesystem implementation.
  * @param path - directory path to canonicalize.
  * @returns the canonical directory path.
  */
 export declare function realModuleDirectory(path: string): string;
-/**
- * Resolve a link target without following the final path component.
- * @param path - candidate path whose parent is canonicalized.
- * @returns the canonical candidate, or undefined when its parent is absent.
- */
-export declare function canonicalLinkPath(path: string): string | undefined;
-/**
- * Return whether a symlink or junction points at the same path as `target`.
- * @param link - symlink or junction to inspect.
- * @param target - expected target path.
- * @returns whether both paths identify the same entry.
- */
-export declare function symlinkPointsTo(link: string, target: string): boolean;
-/**
- * Return whether an observed profile package must not claim local precedence.
- * @param profileDir - profile directory containing the package projection.
- * @param packageName - bare package name to inspect.
- * @returns whether the entry is a managed fallback link or disappeared during inspection.
- */
-export declare function isProfileModuleFallbackLink(profileDir: string, packageName: string): boolean;
 //# sourceMappingURL=legacy-links.d.ts.map

package/lib/types/profile-resolution/resolver.d.ts

@@ -1,23 +1,24 @@
 /** In-memory profile package routing for Node's default ESM and CommonJS loaders. */
-import type { ProfileResolutionGeneration } from '../profile.ts';
-/** Whether runtime resolution redirects requests or verifies the materialized backend. */
-export type ProfileResolutionBehavior = 'enforce' | 'verify';
-/** Active resolver registration in one Node isolate. */
-export interface ProfileResolutionRegistration {
+import type { RuntimeResolution } from '../profile.ts';
+/** Active interception in one Node isolate. */
+export interface RuntimeInterception {
     /**
      * Locate a bare package without requiring one of its exports.
+     * A package subpath selects its package directory without resolving or validating the requested file.
      * @param specifier - bare package or package-subpath specifier.
      * @param parentURL - file URL whose lookup order applies.
      * @returns selected package directory, or undefined when it is absent.
      */
     packageDir(specifier: string, parentURL: string): string | undefined;
     /**
-     * Atomically publish an additive package table and fresh generation-owned caches.
-     * @param generation - fully constructed successor generation.
-     * @throws when the profile scope or an existing package mapping changes.
+     * Atomically publish a complete successor and fresh caches. Linked roots may be added or removed.
+     * Removed roots stop intercepting uncovered directories; existing modules and Node caches remain intact.
+     * @param successor - fully constructed generation retaining existing package mappings and local names.
+     * @throws when the profile scope or existing mappings change, local names are removed or override
+     * existing mappings, or a previously published link name selects a different real directory.
      */
-    replace(generation: ProfileResolutionGeneration): void;
-    /** Restore the native resolver methods. Registrations dispose in reverse order. */
+    replace(successor: RuntimeResolution): void;
+    /** Restore the native resolver methods. Interceptions dispose in reverse order. */
     dispose(): void;
 }
 /**
@@ -27,17 +28,15 @@ export interface ProfileResolutionRegistration {
  */
 export declare function barePackageName(request: string): string | undefined;
 /**
- * Install one profile generation on Node's default ESM and CommonJS resolvers.
- * @param generation - complete package table and profile scope.
- * @param behavior - enforce the generation, or verify a materialized generation.
- * @returns a registration that replaces the generation or restores the native methods.
+ * Install one runtime resolution as the interception on Node's default ESM and CommonJS resolvers.
+ * @param resolution - complete package table and profile scope.
+ * @returns an interception that publishes a successor or restores the native methods.
  */
-export declare function installProfileResolution(generation: ProfileResolutionGeneration, behavior?: ProfileResolutionBehavior): ProfileResolutionRegistration;
+export declare function installRuntimeInterception(resolution: RuntimeResolution): RuntimeInterception;
 /**
- * Publish one generation for Harness-owned Workers.
- * @param generation - complete package table and profile scope.
- * @param behavior - enforce or verify the generation in newly created Workers.
+ * Publish one runtime resolution for Harness-owned Workers.
+ * @param resolution - complete package table and profile scope.
  * @returns a disposer restoring the previous thread environment data.
  */
-export declare function registerWorkerResolution(generation: ProfileResolutionGeneration, behavior?: ProfileResolutionBehavior): () => void;
+export declare function registerWorkerResolution(resolution: RuntimeResolution): () => void;
 //# sourceMappingURL=resolver.d.ts.map

package/lib/types/profile-resolution/service.d.ts

@@ -1,7 +1,7 @@
-/** Package metadata resolved through one profile resolution registration. */
+/** Package metadata resolved through one runtime interception. */
 import { Service, type Context } from '@deepseek-ai/cordis';
-import { type ProfileResolutionBehavior } from './resolver.ts';
-import type { ProfileResolutionGeneration } from '../profile.ts';
+import type { PluginLocalizedMeta } from '@deepseek-ai/dsh-package-manifest';
+import type { RuntimeResolution } from '../profile.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         /** Deterministic package lookup for configured plugin specifiers. */
@@ -21,25 +21,23 @@ export interface PluginPackage {
     /** Parsed manifest shared by metadata readers. */
     manifest: Record<string, unknown>;
 }
-/** Optional runtime resolver installed and owned by {@link PluginPackages}. */
+/** Optional runtime interception installed and owned by {@link PluginPackages}. */
 export interface PluginPackagesConfig {
     /** Complete package table; omit it to expose native package lookup only. */
-    generation?: ProfileResolutionGeneration;
-    /** Enforce the table or compare it with a materialized fallback. */
-    behavior?: ProfileResolutionBehavior;
+    resolution?: RuntimeResolution;
 }
 /** Package lookup shared by metadata consumers in one profile process. */
 export declare class PluginPackages extends Service {
     private packages;
-    private readonly resolver;
-    private readonly behavior;
+    private readonly interception;
     private disposeWorkerResolution;
     constructor(ctx: Context, config?: PluginPackagesConfig);
     /**
-     * Publish an additive generation for this process and subsequently created Workers.
-     * @param generation - fully constructed successor generation.
+     * Publish a complete successor generation for this process and subsequently created Workers.
+     * Linked roots may be removed without unloading modules or clearing Node caches.
+     * @param successor - fully constructed generation accepted by {@link RuntimeInterception.replace}.
      */
-    replace(generation: ProfileResolutionGeneration): void;
+    replace(successor: RuntimeResolution): void;
     /**
      * Locate the package named by a specifier without requiring a package export.
      * @param specifier - module specifier whose package owns the requested module.
@@ -47,5 +45,12 @@ export declare class PluginPackages extends Service {
      * @returns the parsed package, or undefined when no package owns the request.
      */
     packageOf(specifier: string, parentURL: string): PluginPackage | undefined;
+    /**
+     * Read display metadata without loading or activating the target plugin.
+     * @param specifier - configured package module, including package subpaths.
+     * @param parentURL - owning Loader tree's resolution base.
+     * @returns local display metadata or its diagnostic; undefined for non-package requests or absent metadata.
+     */
+    metaOf(specifier: string, parentURL: string): PluginLocalizedMeta | undefined;
 }
 //# sourceMappingURL=service.d.ts.map

package/lib/types/profile-resolution/worker-bootstrap.d.ts

@@ -1,3 +1,3 @@
-/** Install an inherited profile resolution generation in one Harness-owned Worker. */
+/** Install the inherited runtime resolution in one Harness-owned Worker. */
 export {};
 //# sourceMappingURL=worker-bootstrap.d.ts.map