@deepseek-ai/dsh-experimental-webworker-runtime 0.2.1-alpha.2 → 0.2.1-alpha.4

package/lib/types/image-layout.d.ts

@@ -1,7 +1,7 @@
 /**
  * Image layout contract shared by the packer and the worker host: the virtual
- * root, where the composed config and the manifest sit inside the image, and
- * the working directories every image carries empty. One definition, two
+ * root, where the manifest sits inside the image, where lazy archives sit beside
+ * it, and the working directories every image carries empty. One definition, two
  * consumers — the packer writes this layout, the worker host mounts it.
  */
 /** Default virtual root; the runtime mounts the image here unless told otherwise. */
@@ -12,12 +12,21 @@ export declare const DEFAULT_ROOT = "/dsh";
  * there, so the extension is part of what a deployment serves.
  */
 export declare const IMAGE_FILE_NAME = "vfs-image.tar.gz";
-/** Image path the composed profile is written to; the runtime's Loader reads it. */
-export declare const IMAGE_CONFIG_PATH = "config/cordis.yml";
 /** Image path of the manifest the runtime reads before it wraps a single module. */
 export declare const IMAGE_MANIFEST_PATH = "config/vfs-manifest.json";
+/**
+ * Directory, relative to the base image URL, holding the lazy chunk archives:
+ * `lazy/<sha256 of the archive>.tar.gz`, one page chunk each.
+ */
+export declare const IMAGE_LAZY_DIRECTORY = "lazy";
 /** Home directory under the root; the process shim's `DSH_HOME`/`HOME` default. */
 export declare const IMAGE_HOME_DIRECTORY = "home";
+/**
+ * Config fields the Worker requires on Loader rows, by row id. The packer writes them into the image's home patch
+ * (`home/cordis.patch.yml`) over each row's composed config: the Worker carries no Zstandard codec, so JSONL Session
+ * logs stay plaintext.
+ */
+export declare const PLATFORM_ENTRY_CONFIG: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 /** Working directories the host tree expects to exist, empty. */
 export declare const IMAGE_EMPTY_DIRECTORIES: readonly string[];
 /**

package/lib/types/image-manifest.d.ts

@@ -0,0 +1,42 @@
+/** One file a lazy archive supplies. */
+export interface ImageLazyFile {
+    /** Path relative to the image root, as the archive names it. */
+    readonly path: string;
+    /** Byte length of the archived file. */
+    readonly size: number;
+}
+/** One archive beside the base image whose files arrive on first asynchronous read. */
+export interface ImageLazyArchive {
+    /** Archive path relative to the base image URL. */
+    readonly archive: string;
+    /** Every file the archive carries. */
+    readonly files: readonly ImageLazyFile[];
+}
+/** Fields recorded in the base image's manifest. */
+export interface ImageManifest {
+    /** Virtual root the image was packed for. */
+    readonly root: string;
+    /** Shipped profile template the worker host initializes and boots. */
+    readonly profile: string;
+    /** Package whose manifest alone anchors bundle resolution; absent in images that boot no tree. */
+    readonly installation?: string;
+    /** Wrapper contract every packed body was lowered against. */
+    readonly lowered: string;
+    /** JavaScript entries the image carries, lazy archives excluded. */
+    readonly javascriptEntries: number;
+    /** Entries the pack-time transform visited. */
+    readonly visitedEntries: number;
+    /** Visited entries the transform rewrote. */
+    readonly rewrittenEntries: number;
+    /** Page chunks requested only through `require.async`, one archive each. */
+    readonly lazy: readonly ImageLazyArchive[];
+}
+/**
+ * Validate a fetched base-image manifest.
+ * @param value - Parsed manifest JSON.
+ * @param path - Manifest path inside the image, named in refusals.
+ * @returns The detached manifest.
+ * @throws When the manifest is malformed, or its bodies were lowered against another wrapper contract.
+ */
+export declare function parseImageManifest(value: unknown, path: string): ImageManifest;
+//# sourceMappingURL=image-manifest.d.ts.map

package/lib/types/index.d.ts

@@ -13,11 +13,12 @@ export { lowerModuleSource, type LoweredModule } from './compile/transform.ts';
 export { API_PREFIX, SYNTHETIC_HOST, TunnelServer, type TunnelPort, type TunnelSeams, type TunnelServerOptions, } from './transport/tunnel.ts';
 export { installProcessGlobal, type ProcessShim, type ProcessShimOptions } from './node/globals/process.ts';
 export { createWorkerHost, type WorkerHost, type WorkerHostOptions, } from './worker-host.ts';
-export { DEFAULT_ROOT, IMAGE_CONFIG_PATH, IMAGE_EMPTY_DIRECTORIES, IMAGE_FILE_NAME, IMAGE_HOME_DIRECTORY, IMAGE_MANIFEST_PATH, IMAGE_OVERLAY_DIRECTORIES, LOWERING_VERSION, WRAPPER_PARAMS, } from './image-layout.ts';
+export { DEFAULT_ROOT, IMAGE_EMPTY_DIRECTORIES, IMAGE_FILE_NAME, IMAGE_HOME_DIRECTORY, IMAGE_LAZY_DIRECTORY, IMAGE_MANIFEST_PATH, IMAGE_OVERLAY_DIRECTORIES, LOWERING_VERSION, PLATFORM_ENTRY_CONFIG, WRAPPER_PARAMS, } from './image-layout.ts';
+export { parseImageManifest, type ImageLazyArchive, type ImageLazyFile, type ImageManifest, } from './image-manifest.ts';
 export { parsePreviewFixtureManifest, PREVIEW_FIXTURE_MANIFEST_FILE, PREVIEW_FIXTURE_MANIFEST_VERSION, type PreviewFixtureManifest, type PreviewFixtureManifestEntry, } from './fixture-manifest.ts';
 export { loadVfsImage, loadVfsOverlay, MemoryVfs } from './storage/memory.ts';
 export { inflateImage, inflateImageStream } from './storage/image-gzip.ts';
 export { packTar, parseTar, type TarEntry } from './storage/tar.ts';
 export { requireActiveVfs, setActiveVfs } from './storage/active.ts';
-export { type VfsDir, type VfsDirent, type VfsEncoding, type VfsError, type VfsFileHandle, type VfsReadOptions, type VfsStats, type VfsWriteOptions, } from './storage/types.ts';
+export { type VfsDeferredArchive, type VfsDeferredFile, type VfsDir, type VfsDirent, type VfsEncoding, type VfsError, type VfsFileHandle, type VfsReadOptions, type VfsStats, type VfsWriteOptions, } from './storage/types.ts';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/module-system/module-loader.d.ts

@@ -1,8 +1,9 @@
 /**
- * CommonJS module loader over the worker VFS. It fills the `loader.internal`
- * seam Cordis uses for every entry import, and backs the `node:module`
- * `createRequire` proxy that `typert-loader`, `client-modules`, and the plugin
- * package inventory resolve package metadata through.
+ * CommonJS module loader over the worker VFS. It backs the Node internal ESM
+ * loader that `node-addon-require-builtin` answers, which Cordis's Loader uses
+ * for every entry import, and the `node:module` `createRequire` proxy that
+ * `typert-loader`, `client-modules`, and the plugin package inventory resolve
+ * package metadata through.
  *
  * Resolution is a narrowed Node `require` algorithm: `exports` walk with a
  * fixed condition order, extension probing, and one cache keyed by resolved
@@ -11,6 +12,7 @@
  * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/module-system/module-loader
  */
 import { type AlsCausality } from '../polyfill/async-context/als-runtime.ts';
+import { type CascadedLoader } from '../node/internal_modules/esm-loader.ts';
 import type { MemoryVfs } from '../storage/memory.ts';
 /** Condition keys honoured in `exports`, in order; `node` is deliberately absent. */
 export declare const DEFAULT_CONDITIONS: readonly ["browser", "require", "import", "default"];
@@ -96,9 +98,11 @@ export declare class WorkerModuleLoader {
     private readonly modules;
     private readonly manifests;
     private readonly stack;
+    private cascaded;
     /**
-     * The Cordis module seam. `parentURL` positions relative specifiers;
-     * import attributes are ignored, as the client implementation does.
+     * Resolution and loading over this mount, in Node's v1 argument order. The cascaded ESM loader
+     * ({@link cascadedLoader}) and the packer call it; `parentURL` positions relative specifiers and import attributes
+     * are ignored.
      */
     readonly internal: {
         readonly version: 'worker';
@@ -107,6 +111,16 @@ export declare class WorkerModuleLoader {
         resolveSync(specifier: string, parentURL?: string, attributes?: unknown): WorkerInternalResolution;
     };
     constructor(options: WorkerModuleLoaderOptions);
+    /**
+     * The `internal/modules/esm/loader` cascaded loader over this mount, created on first use.
+     * @returns This loader's one cascaded loader.
+     */
+    cascadedLoader(): CascadedLoader;
+    /**
+     * Throw this loader's diagnostic.
+     * @param detail - What failed.
+     * @param code - Node error code for a resolution failure Node also reports by code.
+     */
     private fail;
     /** @returns Directory a base path or URL resolves specifiers from. */
     private baseDirectoryOf;

package/lib/types/node/builtin_modules/implemented/path.d.ts

@@ -98,11 +98,17 @@ export declare const posix: typeof posixFace & {
     readonly posix: unknown;
     readonly win32: unknown;
 };
-/** Windows member set: reaching it means a platform branch went the wrong way. */
+/**
+ * Node's `path.win32.isAbsolute`, a string check cross-platform callers make on every platform.
+ * @param path - Path to classify.
+ * @returns Whether a Windows host would treat the path as absolute.
+ */
+declare function win32IsAbsolute(path: string): boolean;
+/** Windows member set: reaching a member other than `isAbsolute` means a platform branch went the wrong way. */
 export declare const win32: {
     resolve: () => never;
     normalize: () => never;
-    isAbsolute: () => never;
+    isAbsolute: typeof win32IsAbsolute;
     join: () => never;
     relative: () => never;
     dirname: () => never;

package/lib/types/node/builtin_modules/implemented/util.d.ts

@@ -54,6 +54,12 @@ export declare function parseArgs(): never;
  * @returns The same function, unwrapped.
  */
 export declare function deprecate<F>(fn: F): F;
+/**
+ * Node's `util.inherits`: link `ctor.prototype` to `superCtor.prototype` and record `ctor.super_`.
+ * @param ctor - Constructor that inherits.
+ * @param superCtor - Constructor inherited from.
+ */
+export declare function inherits(ctor: unknown, superCtor: unknown): void;
 /** Text decoder class, as `node:util` re-exports it. */
 declare const TextDecoderClass: {
     new (label?: string, options?: TextDecoderOptions): TextDecoder;
@@ -82,6 +88,7 @@ declare const _default: {
     };
     parseArgs: typeof parseArgs;
     deprecate: typeof deprecate;
+    inherits: typeof inherits;
     TextDecoder: {
         new (label?: string, options?: TextDecoderOptions): TextDecoder;
         prototype: TextDecoder;

package/lib/types/node/external_packages/node-addon-require-builtin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Answer one Node internal module.
+ * @param moduleId - Node internal module id.
+ * @returns The Worker's module object for that id.
+ * @throws Error with `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM` for an id the Worker does not provide.
+ */
+export declare function requireBuiltin(moduleId: string): object;
+//# sourceMappingURL=node-addon-require-builtin.d.ts.map

package/lib/types/node/globals/process.d.ts

@@ -68,9 +68,9 @@ export interface ProcessShim {
 /**
  * Publish `globalThis.process`.
  *
- * `versions.node` is `0.0.0` on purpose: it makes Cordis's
- * `ModuleLoader.fromInternal()` return undefined instead of reaching for Node
- * internals, which is what lets the worker install its own module seam.
+ * `versions.node` names the Node release the Worker's `node-addon-require-builtin` internals follow, so Cordis's
+ * `ModuleLoader.fromInternal()` reaches them the way it reaches Node's; `execArgv` stays empty, without
+ * `--expose-internals`.
  * @param options - Root, environment, and argument vector.
  * @returns The published object, for the module proxy table.
  */

package/lib/types/node/internal_modules/esm-loader.d.ts

@@ -0,0 +1,50 @@
+import { LoadCache } from './module-map.ts';
+/** One module request in Node's v2 loader signature. */
+export interface ModuleRequest {
+    readonly specifier: string;
+    readonly attributes?: Readonly<Record<string, string>>;
+}
+/** Worker module-loader operations a cascaded loader delegates to, in Node's v1 argument order. */
+export interface CascadedLoaderSource {
+    import(specifier: string, parentURL?: string): Promise<unknown>;
+    resolveSync(specifier: string, parentURL?: string): {
+        readonly url: string;
+        readonly format: string;
+    };
+}
+/** The cascaded loader members provided in the Worker. */
+export interface CascadedLoader {
+    /** Always empty: the Worker creates no ES module jobs. */
+    readonly loadCache: LoadCache;
+    /**
+     * Resolve one request for this repository's Node-loader callers.
+     * @param parentURL - URL of the requesting module; undefined resolves from the image root.
+     * @param request - Requested module.
+     * @returns The resolved URL and module format.
+     * @throws Error with `ERR_MODULE_NOT_FOUND` or `ERR_PACKAGE_PATH_NOT_EXPORTED` when the request does not resolve.
+     */
+    resolveSync(parentURL: string | undefined, request: ModuleRequest): {
+        url: string;
+        format: string;
+    };
+    /**
+     * Load one module through the Worker loader.
+     * @param specifier - Requested module.
+     * @param parentURL - URL of the requesting module.
+     * @param _importAttributes - Import attributes; the Worker loads CommonJS bodies and ignores them.
+     * @returns The module's exports.
+     */
+    import(specifier: string, parentURL: string | undefined, _importAttributes?: Readonly<Record<string, string>>): Promise<unknown>;
+    /**
+     * Refuse: the Worker creates no ES module jobs.
+     * @returns Never; always throws.
+     */
+    getOrCreateModuleJob(): never;
+}
+/**
+ * Build the cascaded loader for one Worker module loader.
+ * @param source - The Worker module loader's resolution and loading operations.
+ * @returns A cascaded loader delegating to `source`.
+ */
+export declare function createCascadedLoader(source: CascadedLoaderSource): CascadedLoader;
+//# sourceMappingURL=esm-loader.d.ts.map

package/lib/types/node/internal_modules/module-map.d.ts

@@ -0,0 +1,59 @@
+/** Resolutions keyed by parent URL, then by serialized module request. */
+export declare class ResolveCache extends Map<unknown, unknown> {
+    #private;
+    /**
+     * Serialize a module request: the specifier and its import attributes sorted by key.
+     * @param specifier - Requested module.
+     * @param importAttributes - Import attributes of the request.
+     * @returns The cache key Node uses for this request.
+     */
+    serializeKey(specifier: string, importAttributes: Record<string, string>): string;
+    /**
+     * Read one cached resolution.
+     * @param serializedKey - Key from {@link serializeKey}.
+     * @param parentURL - URL of the importing module.
+     * @returns The cached resolution, if any.
+     */
+    get(serializedKey: string, parentURL?: unknown): unknown;
+    /**
+     * Store one resolution.
+     * @param serializedKey - Key from {@link serializeKey}.
+     * @param parentURL - URL of the importing module.
+     * @param result - Resolution to cache.
+     * @returns This cache.
+     */
+    set(serializedKey: string, parentURL?: unknown, result?: unknown): this;
+    /**
+     * Check for one cached resolution.
+     * @param serializedKey - Key from {@link serializeKey}.
+     * @param parentURL - URL of the importing module.
+     * @returns Whether the request has a cached resolution.
+     */
+    has(serializedKey: string, parentURL?: unknown): boolean;
+}
+/** Module jobs keyed by URL, then by import `type` attribute; always empty in the Worker. */
+export declare class LoadCache extends Map<string, unknown> {
+    /**
+     * Read the job for one URL and type.
+     * @param url - Module URL.
+     * @param type - Import `type` attribute.
+     * @returns The cached job, if any.
+     */
+    get(url: string, type?: string): unknown;
+    /**
+     * Refuse to store a job: the Worker creates no ES module jobs.
+     * @param url - Module URL.
+     * @param type - Import `type` attribute.
+     * @param _job - Job Node would store.
+     * @returns Never; always throws.
+     */
+    set(url: string, type?: unknown, _job?: unknown): never;
+    /**
+     * Check for the job of one URL and type.
+     * @param url - Module URL.
+     * @param type - Import `type` attribute.
+     * @returns Whether a job is cached.
+     */
+    has(url: string, type?: string): boolean;
+}
+//# sourceMappingURL=module-map.d.ts.map

package/lib/types/node/internal_modules/package-surfaces.d.ts

@@ -0,0 +1,29 @@
+/** `Module` with the static members HMR reads and replaces. */
+export declare const Module: (() => never) & {
+    /** Empty: the Worker loader keeps its own resolution cache. */
+    _pathCache: Record<string, string>;
+    _resolveFilename: (...args: never[]) => never;
+    _load: (...args: never[]) => never;
+};
+/** `internal/modules/package_json_reader` with the member HMR replaces. */
+export declare const packageJsonReader: {
+    getNearestParentPackageJSON: (...args: never[]) => never;
+};
+/** `internalBinding('modules')` with the members HMR replaces. */
+declare const modulesBinding: {
+    readPackageJSON: (...args: never[]) => never;
+    getPackageScopeConfig: (...args: never[]) => never;
+    getPackageType: (...args: never[]) => never;
+};
+/** `internal/bootstrap/realm`: only the `modules` binding is provided. */
+export declare const realm: {
+    /**
+     * Answer one internal binding.
+     * @param name - Binding name.
+     * @returns The `modules` binding.
+     * @throws Error with `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM` for any other binding.
+     */
+    internalBinding(name: string): typeof modulesBinding;
+};
+export {};
+//# sourceMappingURL=package-surfaces.d.ts.map

package/lib/types/node/notImplementedFail.d.ts

@@ -2,7 +2,9 @@
  * Structural not-implemented stubs: a replaced module must expose every symbol
  * its importers name (a missing CommonJS symbol degrades to `undefined` at call
  * time instead of failing at link time), and every one of those symbols must
- * report exactly what is unavailable when it is finally called.
+ * report exactly what is unavailable when it is finally called. The refusal
+ * carries Node's `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM` code, so a caller that
+ * can run without the feature distinguishes it from other failures.
  */
 /**
  * Build a function that throws naming its module and symbol. The refusal is
@@ -28,7 +30,9 @@ export declare function notImplementedFail<Face = (...args: never[]) => never>(m
  * fakes).
  * @param module - module specifier being stubbed.
  * @param symbol - unavailable member, named as the importer sees it.
- * @returns the error to throw.
+ * @returns the error to throw, with `code` set to Node's `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`.
  */
-export declare function notAvailableError(module: string, symbol: string): Error;
+export declare function notAvailableError(module: string, symbol: string): Error & {
+    code: string;
+};
 //# sourceMappingURL=notImplementedFail.d.ts.map

package/lib/types/storage/memory.d.ts

@@ -1,4 +1,4 @@
-import type { Vfs, VfsBigIntStats, VfsDir, VfsDirent, VfsFileHandle, VfsOpenFile, VfsMutationListener, VfsMutationSink, VfsReadOptions, VfsSeedOptions, VfsStatOptions, VfsStats, VfsWriteOptions } from './types.ts';
+import type { Vfs, VfsBigIntStats, VfsDeferredArchive, VfsDir, VfsDirent, VfsFileHandle, VfsOpenFile, VfsMutationListener, VfsMutationSink, VfsReadOptions, VfsSeedOptions, VfsStatOptions, VfsStats, VfsWriteOptions } from './types.ts';
 /** Construction inputs for {@link MemoryVfs}. */
 export interface MemoryVfsOptions {
     /** Durable write-behind observer; absent leaves the filesystem ephemeral. */
@@ -11,6 +11,8 @@ export interface MemoryVfsOptions {
  */
 export declare class MemoryVfs implements Vfs {
     private readonly files;
+    /** Files a lazy archive supplies on their first asynchronous read. */
+    private readonly deferred;
     private readonly directories;
     /** Directory permission bits; absence means {@link DEFAULT_DIRECTORY_MODE}. */
     private readonly directoryModes;
@@ -71,6 +73,25 @@ export declare class MemoryVfs implements Vfs {
     };
     /** @returns Absolute path with no trailing separator. */
     private key;
+    /**
+     * Register files whose bytes arrive with one archive on the first
+     * asynchronous read of any of them. Their parent directories are created now.
+     * @param archive - Archive name, mount root, registered files, and fetch.
+     * @throws When a registered path already holds a file, directory, or another registration.
+     */
+    deferArchive(archive: VfsDeferredArchive): void;
+    /**
+     * Fetch the lazy archive that supplies a registered path. Concurrent readers
+     * of one archive share one fetch; a failed fetch leaves its files registered,
+     * so the next read fetches again.
+     * @param path - Path about to be read asynchronously.
+     * @returns A promise that settles once the archive arrived, or undefined when the path needs no fetch.
+     */
+    whenReadable(path: string): Promise<void> | undefined;
+    /** Fetch, validate against the registration, and mount one archive's files. */
+    private fetchArchive;
+    /** Refuse a synchronous operation on a registered file whose bytes have not arrived. */
+    private requireArrived;
     /**
      * Read a file.
      * @param path - File path.
@@ -283,7 +304,7 @@ export declare class MemoryVfs implements Vfs {
 /**
  * Mount a tar image produced by the build-time collector.
  *
- * Entry names are relative to `root` (`node_modules/...`, `config/cordis.yml`);
+ * Entry names are relative to `root` (`node_modules/...`, `config/vfs-manifest.json`);
  * an absolute entry name is a collector defect and fails loud. File contents
  * stay views into `image` — nothing is copied at mount time.
  * @param image - The ustar archive, as `inflateImage` produces it from the fetched image.

package/lib/types/storage/paths.d.ts

@@ -9,7 +9,7 @@ export declare const DSH_ROOT = "/dsh";
 export declare const DSH_HOME = "/dsh/home";
 /** Flat, symlink-free package tree resolved by the worker module loader. */
 export declare const DSH_NODE_MODULES = "/dsh/node_modules";
-/** Directory holding the composed cordis.yml. */
+/** Image configuration directory: the VFS manifest and the shipped agent presets. */
 export declare const DSH_CONFIG = "/dsh/config";
 /** Default (empty) workspace directory. */
 export declare const DSH_WORKSPACE = "/dsh/workspace";

package/lib/types/storage/types.d.ts

@@ -194,6 +194,34 @@ export type VfsMutation = {
 };
 /** Receives one committed VFS mutation. */
 export type VfsMutationListener = (mutation: VfsMutation) => void;
+/** One file a lazy archive carries, by its path relative to the archive root. */
+export interface VfsDeferredFile {
+    /** Entry name inside the archive, relative to {@link VfsDeferredArchive.root}. */
+    readonly path: string;
+    /** Byte length the archive must hold for this entry. */
+    readonly size: number;
+}
+/**
+ * Files registered by path and size whose bytes arrive with one archive on the
+ * first asynchronous read of any of them. Existence, stats, and listings answer
+ * from the registration. Until the archive arrives, synchronous reads, writes,
+ * appends, truncation, chmod, rename, and link are refused; unlink and recursive
+ * removal drop the registration, and seeding the path replaces it. The fetched
+ * archive is checked against the registered paths and sizes only.
+ */
+export interface VfsDeferredArchive {
+    /** Archive name quoted in refusals and fetch failures. */
+    readonly name: string;
+    /** Virtual directory the archive's relative entry names mount under. */
+    readonly root: string;
+    /** Every regular file the archive carries; anything else in it refuses the archive. */
+    readonly files: readonly VfsDeferredFile[];
+    /**
+     * Fetch the archive.
+     * @returns The uncompressed ustar bytes.
+     */
+    load(): Promise<Uint8Array>;
+}
 /** Durable observer attached to the synchronous VFS. */
 export interface VfsMutationSink {
     /**
@@ -275,5 +303,10 @@ export interface Vfs {
     subscribe(listener: VfsMutationListener): () => void;
     /** Settle the attached durable mutation sink, if any. */
     flush(): Promise<void>;
+    /**
+     * Fetch the lazy archive that supplies a registered path.
+     * @returns A promise that settles once the path's archive arrived, or undefined when the path needs no fetch.
+     */
+    whenReadable(path: string): Promise<void> | undefined;
 }
 //# sourceMappingURL=types.d.ts.map

package/lib/types/worker-host.d.ts

@@ -16,9 +16,11 @@
  * message handler before its first await.
  *
  * The tree itself boots through the host's own `boot()` glue loaded from the
- * image, so entry mounting, the activation audit, and its diagnostics are the
- * same code the Node deployment runs. The Worker supplies module loading,
- * profile locations, and the command line.
+ * image, over the profile the image's own app-boot initializes from the shipped
+ * template and composes from the bundles the image carries, so profile
+ * composition, entry mounting, the activation audit, and its diagnostics are the
+ * same code the Node deployment runs. The Worker supplies module loading, the
+ * platform overlay, and the command line.
  * @module @deepseek-ai/dsh-experimental-webworker-runtime/src/worker-host
  */
 import { WorkerModuleLoader, type StaticModuleFactory } from './module-system/module-loader.ts';
@@ -46,14 +48,12 @@ export interface LogExporter {
 }
 /** Minimal view of the Cordis context the entry itself touches. */
 export interface HostContext {
-    loader: {
-        internal: unknown;
-    };
     logger: {
         exporter(exporter: LogExporter): unknown;
     };
     get(service: string): unknown;
     provide(name: string, value: unknown): void;
+    plugin(plugin: unknown, config?: unknown): Promise<unknown>;
     fiber: {
         dispose(): Promise<void>;
     };
@@ -80,8 +80,6 @@ export interface WorkerHostOptions {
     readonly overlays?: readonly (Uint8Array | string)[];
     /** Virtual root; defaults to {@link DEFAULT_ROOT}. */
     readonly root?: string;
-    /** Composed configuration inside the image; defaults to `<root>/config/cordis.yml`. */
-    readonly configPath?: string;
     /**
      * Inner arguments the tree parses. The default binds the web server to the
      * loopback authority the tunnel synthesizes.
@@ -93,7 +91,8 @@ export interface WorkerHostOptions {
     readonly env?: Readonly<Record<string, string>>;
     /**
      * Image manifest path; defaults to `<root>/config/vfs-manifest.json`. Its
-     * `lowered` field must name this build's wrapper contract.
+     * `lowered` field must name this build's wrapper contract, and its lazy
+     * archives resolve against the image URL.
      */
     readonly manifestPath?: string;
     /**