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

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

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

package/lib/types/profile.d.ts

@@ -7,24 +7,22 @@
  * `dsh.profile` with its ordered `bundles` list) and a `cordis.patch.yml`
  * (the user's own patch layer, applied after every bundle layer). Bundles are
  * npm packages whose manifest declares
- * `"dsh": { "bundle": { "patch": "./cordis.patch.yml" } }`; the tree is
- * composed by applying each bundle's patch list in `dsh.profile.bundles` order over
- * an empty entry list, then the profile's own patches, then any launcher
- * layers (`--patch` files and flag-derived patches).
+ * `"dsh": { "bundle": { "patch": "./cordis.patch.yml" } }` (one file, or an
+ * ordered list of files); the tree is composed by applying each bundle's patch
+ * lists in `dsh.profile.bundles` order over an empty entry list, then the
+ * profile's own patches, then any launcher layers (`--patch` files and
+ * flag-derived patches).
  *
  * Module resolution is two-anchor by construction: a bundle name resolves
  * first from the dsh installation (the launcher's own package), then from the
  * profile directory. Pnpm-managed entries in the profile's `node_modules`
- * resolve first. Dsh-owned links add packages carried only by selected
- * bundles, while `$DSH_HOME/profiles/node_modules` supplies the installation
- * dependency closure through Node's ordinary parent-walk. Plain Node uses
- * symlinks for that shared fallback; packaged executables use ESM proxies so
- * external plugins retain the installation's module instances.
+ * resolve first. The runtime resolution supplies packages carried by the
+ * installation and selected bundles to Node's ESM and CommonJS resolvers.
  * @module @deepseek-ai/dsh-app-boot/profile
  */
 import type { EntryOptions } from '@deepseek-ai/cordis-plugin-loader';
 import { type PatchOptions } from '@deepseek-ai/cordis-plugin-include';
-import type { DshPackageManifest } from '@deepseek-ai/dsh-package-manifest';
+import type { DshBundleManifest, DshPackageManifest } from '@deepseek-ai/dsh-package-manifest';
 /** Directory under the Harness home holding every profile. */
 export declare const PROFILES_DIR = "profiles";
 /** The user patch layer inside a profile directory (hot-reloaded on long-lived surfaces). */
@@ -36,15 +34,31 @@ export interface ProfileTemplate {
 }
 /** Package metadata accepted by the profile reader; local profiles need no published identity. */
 export type ProfileManifest = Partial<DshPackageManifest>;
+/**
+ * The patch files a bundle declares, as written: one file for a string
+ * `patch`, the listed files in order for an array.
+ * @param bundle - the bundle's `dsh.bundle` declaration, as read from package.json.
+ * @returns the package-relative patch file paths in application order.
+ * @throws {Error} when `patch` is neither a string nor a list of strings.
+ */
+export declare function bundlePatchFiles(bundle: DshBundleManifest): string[];
+/**
+ * Resolve a bundle declaration to its ordered absolute patch files.
+ * @param packageDir - absolute directory of the bundle package.
+ * @param bundle - the bundle's `dsh.bundle` declaration, as read from package.json.
+ * @returns the absolute patch file paths in application order.
+ * @throws {Error} when `patch` is neither a string nor a list of strings.
+ */
+export declare function bundlePatchPaths(packageDir: string, bundle: DshBundleManifest): string[];
 /** One resolved bundle layer of a profile. */
 export interface ProfileLayer {
     /** The bundle's package name, as listed in `dsh.profile.bundles`. */
     packageName: string;
     /** Absolute directory of the resolved bundle package. */
     packageDir: string;
-    /** Absolute path of the bundle's patch file. */
-    patchPath: string;
-    /** The parsed patch list. */
+    /** Absolute paths of the bundle's patch files, in application order. */
+    patchPaths: readonly string[];
+    /** The parsed patch lists of every file, concatenated in application order. */
     patches: PatchOptions[];
 }
 /** A loaded profile: resolved bundle layers plus the user's own patch layer. */
@@ -60,8 +74,8 @@ export interface Profile {
     /** The profile's own patches; empty when the file is absent. */
     patches: PatchOptions[];
 }
-/** One package selected by the profile module-fallback rules. */
-export interface ProfileResolutionEntry {
+/** One package the runtime resolution supplies at the interception layer. */
+export interface RuntimeResolutionEntry {
     /** Bare package name. */
     readonly name: string;
     /** Package directory selected by the existing dependency traversal. */
@@ -70,22 +84,32 @@ export interface ProfileResolutionEntry {
     readonly version: string | undefined;
     /** Manifest whose dependency edge selected this package. */
     readonly declarer: string;
-    /** Whether every profile or only the active profile receives this fallback. */
+    /** Whether every profile or only the active profile receives this entry. */
     readonly scope: 'installation' | 'profile';
 }
-/** Complete immutable fallback table for one profile launch. */
-export interface ProfileResolutionGeneration {
-    /** Directory containing every profile and the shared fallback position. */
+/**
+ * A profile node_modules entry linked to a directory outside the shared profiles tree and the active profile.
+ * Importers below `realPath` use Node's real ancestor chain, with peer mappings read at each node_modules position.
+ */
+export interface LinkedRoot {
+    /** Package name of the profile `node_modules` entry, including its scope. */
+    readonly name: string;
+    /** Real directory outside the shared profiles tree and active profile; a package.json is optional. */
+    readonly realPath: string;
+}
+/** Complete immutable package table for one profile launch. */
+export interface RuntimeResolution {
+    /** Directory containing every profile; its node_modules is the interception layer. */
     readonly profilesDir: string;
-    /** Active profile directory, when bundle-only fallbacks were included. */
+    /** Active profile directory, when profile-scope entries were included. */
     readonly profileDir: string | undefined;
-    /** Profile-declared packages already installed before the fallback position. */
+    /** Profile-declared packages installed in the profile's own node_modules. */
     readonly localPackageNames: readonly string[];
-    /** Installation entries followed by bundle-only entries in precedence order. */
-    readonly entries: readonly ProfileResolutionEntry[];
+    /** Installation-scope entries followed by profile-scope entries in precedence order. */
+    readonly entries: readonly RuntimeResolutionEntry[];
+    /** Active profile links to external directories, sorted by name. */
+    readonly linkedRoots: readonly LinkedRoot[];
 }
-/** Startup backend selection for one computed profile resolution generation. */
-export type ProfileResolutionMode = 'link' | 'dual' | 'runtime';
 /**
  * Resolve a profile's directory under the Harness home.
  * @param name - the profile name (`dsh --profile <name>`).
@@ -112,52 +136,36 @@ export declare const OPTIONAL_BUNDLES: readonly string[];
  * @param bundles - the initial `dsh.profile.bundles` layer list.
  */
 export declare function initProfile(dir: string, bundles: readonly string[]): void;
-/** Inputs for {@link healProfilesModuleFallback}. */
-export interface ProfileModuleFallbackOptions {
+/**
+ * Remove the package projections a link-backend launch left in a profile.
+ * Only symlinks under the profile's `node_modules` whose target lies inside
+ * `<profile>/.dsh-module-fallback/node_modules` are unlinked, then that directory is removed;
+ * pnpm-installed packages and every other symlink stay. A profile without the directory is untouched.
+ * @param dir - the profile directory.
+ */
+export declare function removeLinkProjections(dir: string): void;
+/** Inputs for {@link createRuntimeResolution}. */
+export interface RuntimeResolutionOptions {
     /** Absolute package.json path of the running dsh installation. */
     installAnchor: string;
     /** Loaded profile whose selected bundles may carry profile-local plugins. */
     profile?: Profile;
     /** Harness home; defaults to {@link resolveDshHome}. */
     home?: string;
-    /** Whether to materialize the computed generation; defaults to true. */
-    materialize?: boolean;
 }
 /**
- * Maintain module fallbacks for one profile launch. The shared
- * `$DSH_HOME/profiles/node_modules` mirrors the dsh installation dependency
- * closure. Plain Node writes symlinks; a packaged executable writes ESM
- * proxies under a cross-process lock because operating-system links cannot
- * enter pkg's virtual filesystem. Missing packages carried only by selected
- * bundles are linked through a profile-owned directory into that profile's
- * `node_modules`; pnpm-managed entries remain authoritative, and another
- * profile's links cannot change its resolution.
+ * Compute the runtime resolution without writing module-resolution files.
  * @param options - installation anchor, optional loaded profile, and Harness home.
- * @returns the computed fallback generation after optional materialization.
- */
-export declare function healProfilesModuleFallback(options: ProfileModuleFallbackOptions): Promise<ProfileResolutionGeneration>;
-/**
- * Compute a profile resolution generation without materializing links or proxies.
- * @param options - installation anchor, profile, and optional Harness home.
- * @returns the complete immutable generation.
- */
-export declare function createProfileResolutionGeneration(options: Omit<ProfileModuleFallbackOptions, 'materialize'>): Promise<ProfileResolutionGeneration>;
-/**
- * Supply an application-owned profile with filesystem packages from its installation and selected bundles.
- * All fallback links belong to the profile; no shared Harness-home directory is written.
- * Existing pnpm-managed packages remain authoritative. The caller serializes profile mutations.
- * @param options - owning installation package.json and the loaded application profile.
+ * @returns the complete immutable runtime resolution.
  */
-export declare function healIsolatedProfileModuleFallback(options: {
-    installAnchor: string;
-    profile: Profile;
-}): void;
+export declare function createRuntimeResolution(options: RuntimeResolutionOptions): Promise<RuntimeResolution>;
 /**
- * Detach this profile's fallback links before a package-manager mutation.
- * Installed packages and links replaced by pnpm remain untouched; the next profile launch restores fallbacks.
- * @param profileDir - profile directory whose package mutation is serialized by the caller.
+ * Identify selected bundles that did not produce a loaded layer.
+ * @param profile - loaded profile, when present.
+ * @param manifest - its parsed manifest, when present.
+ * @returns selected bundle names missing from the loaded layers, for resolution and diagnostics.
  */
-export declare function unlinkProfileModuleFallback(profileDir: string): void;
+export declare function skippedProfileBundles(profile: Profile | undefined, manifest: ProfileManifest | undefined): ReadonlySet<string>;
 /**
  * Read a profile's manifest.
  * @param binName - the diagnostic prefix on the thrown error.
@@ -188,20 +196,20 @@ export declare function resolveBundleDir(binName: string, packageName: string, i
  * Load an already initialized profile directory without resolving it through
  * the shared Harness home. This is used by application-owned profiles whose
  * package project and lifecycle belong to that application.
+ * Unreadable bundles are reported on stderr and skipped without changing the manifest.
  * @param binName - the diagnostic prefix on thrown errors.
  * @param dir - absolute profile package directory.
  * @param installAnchor - absolute path of the owning dsh app's package.json.
  * @param options - `userLayer: false` skips reading `cordis.patch.yml`.
- * @returns the resolved bundle layers and optional user patch layer.
+ * @returns the successfully loaded bundle layers and optional user patch layer.
  */
 export declare function loadProfileDirectory(binName: string, dir: string, installAnchor: string, options?: {
     userLayer?: boolean;
 }): Profile;
 /**
  * Load a profile: resolve every `dsh.profile.bundles` entry to its patch
- * layer and parse the profile's own patch file. A listed bundle without a
- * `dsh.bundle` manifest fails loud — naming a bundle-less package as a layer
- * is a misconfiguration, not "no patches".
+ * layer and parse the profile's own patch file. Unreadable bundles are reported
+ * on stderr and skipped; profile manifest and user patch errors still throw.
  * @param binName - the diagnostic prefix on thrown errors.
  * @param name - the profile name.
  * @param installAnchor - absolute path of the dsh app's package.json (first resolution anchor).