@camstack/system 1.2.390 → 1.2.391

package/dist/download/model-downloader.d.ts

@@ -1,139 +1,139 @@
-import { ModelCatalogEntry, ModelDownloadOptions, ModelDownloadResult, ModelFormat, ModelFormatEntry } from '@camstack/types';
+import type { ModelCatalogEntry, ModelDownloadOptions, ModelDownloadResult, ModelFormat, ModelFormatEntry } from "@camstack/types";
 export declare function isNonEmptyFile(filePath: string): boolean;
 /**
- * Sibling files of a single-file (non-directory) format — extra files the
- * format needs, fetched from the same remote directory as `url` and stored
- * flat alongside the main file in `modelsDir`. Catalog-declared via
- * `formatEntry.files`, e.g. OpenVINO IR lists its `.bin` weights next to the
- * `.xml`. The downloader stays format-agnostic; the convention lives in the
- * catalog data (like `MLPACKAGE_FILES` for the directory case).
- */
+* Sibling files of a single-file (non-directory) format — extra files the
+* format needs, fetched from the same remote directory as `url` and stored
+* flat alongside the main file in `modelsDir`. Catalog-declared via
+* `formatEntry.files`, e.g. OpenVINO IR lists its `.bin` weights next to the
+* `.xml`. The downloader stays format-agnostic; the convention lives in the
+* catalog data (like `MLPACKAGE_FILES` for the directory case).
+*/
 export declare function siblingFilesFor(formatEntry: ModelFormatEntry): readonly string[];
 /** Resolve a sibling's remote URL relative to the main file's directory. */
 export declare function siblingUrl(mainUrl: string, sibling: string): string;
 /**
- * The relative filenames a model format occupies under `modelsDir` — the main
- * file (URL basename, or `${id}.${format}` fallback), its declared siblings
- * (e.g. the OpenVINO `.bin` next to the `.xml`), and any `extraFiles`. For a
- * directory bundle the single entry is the bundle dir itself (tar/extract
- * recurse into it).
- *
- * Used by model distribution (P2): the hub tars exactly these names from its
- * `modelsDir` and the agent untars them into its own `modelsDir`, so both ends
- * agree on the on-disk layout without re-deriving it.
- */
+* The relative filenames a model format occupies under `modelsDir` — the main
+* file (URL basename, or `${id}.${format}` fallback), its declared siblings
+* (e.g. the OpenVINO `.bin` next to the `.xml`), and any `extraFiles`. For a
+* directory bundle the single entry is the bundle dir itself (tar/extract
+* recurse into it).
+*
+* Used by model distribution (P2): the hub tars exactly these names from its
+* `modelsDir` and the agent untars them into its own `modelsDir`, so both ends
+* agree on the on-disk layout without re-deriving it.
+*/
 export declare function collectModelFiles(entry: ModelCatalogEntry, format: ModelFormat): string[];
 export type DownloadRedirectPolicy = (url: URL, hop: number) => void;
 /**
- * A download that the server ANSWERED with a non-2xx status. Typed so a caller
- * can tell "the file is not there" (404/410 — nothing a retry changes) from
- * "the server was unreachable" by the STATUS, never by matching the message:
- * the embedding encoder's requirements gate (D649) sends the first to a
- * terminal state after a bounded number of attempts and only cools down on
- * the second.
- */
+* A download that the server ANSWERED with a non-2xx status. Typed so a caller
+* can tell "the file is not there" (404/410 — nothing a retry changes) from
+* "the server was unreachable" by the STATUS, never by matching the message:
+* the embedding encoder's requirements gate (D649) sends the first to a
+* terminal state after a bounded number of attempts and only cools down on
+* the second.
+*/
 export declare class ModelDownloadHttpError extends Error {
-    readonly status: number;
-    readonly url: string;
-    constructor(status: number, url: string, verb: 'downloading' | 'fetching');
+	readonly status: number;
+	readonly url: string;
+	constructor(status: number, url: string, verb: "downloading" | "fetching");
 }
 /** True when `err` is a {@link ModelDownloadHttpError} — same process only. */
 export declare function isModelDownloadHttpError(err: unknown): err is ModelDownloadHttpError;
 export interface DownloadFileOptions {
-    readonly onProgress?: (downloaded: number, total: number) => void;
-    /**
-     * When set, redirects are followed manually and THIS policy is applied to
-     * the initial URL and every Location hop before the next fetch. Absent ⇒
-     * native `redirect: 'follow'` (backward compatible).
-     */
-    readonly redirectPolicy?: DownloadRedirectPolicy;
-    readonly maxRedirects?: number;
-    readonly timeoutMs?: number;
-    readonly maxBytes?: number;
-    readonly fetchImpl?: typeof fetch;
+	readonly onProgress?: (downloaded: number, total: number) => void;
+	/**
+	* When set, redirects are followed manually and THIS policy is applied to
+	* the initial URL and every Location hop before the next fetch. Absent ⇒
+	* native `redirect: 'follow'` (backward compatible).
+	*/
+	readonly redirectPolicy?: DownloadRedirectPolicy;
+	readonly maxRedirects?: number;
+	readonly timeoutMs?: number;
+	readonly maxBytes?: number;
+	readonly fetchImpl?: typeof fetch;
 }
 /**
- * Download a single file from a URL to a destination path.
- * Streams to disk with optional progress callback.
- * Returns the destination path. Skips download if file already exists.
- *
- * The third argument remains a progress callback for existing callers. Pass
- * an options object to supply a per-hop redirect policy, timeout, or byte cap.
- */
+* Download a single file from a URL to a destination path.
+* Streams to disk with optional progress callback.
+* Returns the destination path. Skips download if file already exists.
+*
+* The third argument remains a progress callback for existing callers. Pass
+* an options object to supply a per-hop redirect policy, timeout, or byte cap.
+*/
 export declare function downloadFile(url: string, destPath: string, onProgress?: (downloaded: number, total: number) => void): Promise<string>;
 export declare function downloadFile(url: string, destPath: string, options: DownloadFileOptions): Promise<string>;
 /**
- * Fetch JSON from a URL using native fetch().
- */
+* Fetch JSON from a URL using native fetch().
+*/
 export declare function fetchJson(url: string): Promise<unknown>;
 /**
- * Download a model with fallback URLs and optional SHA256 verification.
- * Legacy API preserved for backward compatibility -- delegates to downloadFile().
- */
+* Download a model with fallback URLs and optional SHA256 verification.
+* Legacy API preserved for backward compatibility -- delegates to downloadFile().
+*/
 export declare function downloadModel(options: ModelDownloadOptions): Promise<ModelDownloadResult>;
 /** Progress callback: (downloadedBytes, totalBytes | undefined) */
 export type DownloadProgressCallback = (downloaded: number, total: number | undefined) => void;
 /**
- * Where a node records the catalog `revision` of the format it downloaded:
- * a sibling of the file or bundle, `<name>.revision` (D743). Outside the
- * bundle, so a `.mlpackage` keeps exactly the hosted files.
- */
+* Where a node records the catalog `revision` of the format it downloaded:
+* a sibling of the file or bundle, `<name>.revision` (D743). Outside the
+* bundle, so a `.mlpackage` keeps exactly the hosted files.
+*/
 export declare function revisionRecordPath(modelPath: string): string;
 /** The CamStack model mirror. Every artefact under it has a generated revision. */
 export declare const HOSTED_MODEL_MIRROR_PREFIX: string;
 /**
- * The revision a format must be at — the ONE rule every model download path
- * reads (D743, D744). An inline `revision` wins; otherwise a format hosted on
- * the CamStack mirror takes the revision generated for its path from the
- * mirror's LFS metadata (`hosted-model-revisions.ts`); anything else has none.
- */
+* The revision a format must be at — the ONE rule every model download path
+* reads (D743, D744). An inline `revision` wins; otherwise a format hosted on
+* the CamStack mirror takes the revision generated for its path from the
+* mirror's LFS metadata (`hosted-model-revisions.ts`); anything else has none.
+*/
 export declare function resolveFormatRevision(formatEntry: ModelFormatEntry): string | undefined;
 /**
- * The file whose sha256 IS a format's revision: a Core ML package's
- * `weight.bin`, an OpenVINO IR's `.bin` sibling, otherwise the file itself.
- * `null` for a bundle that is not a Core ML package (nothing to hash).
- */
+* The file whose sha256 IS a format's revision: a Core ML package's
+* `weight.bin`, an OpenVINO IR's `.bin` sibling, otherwise the file itself.
+* `null` for a bundle that is not a Core ML package (nothing to hash).
+*/
 export type RevisionWeightFile = {
-    readonly in: 'bundle';
-    readonly member: string;
+	readonly in: "bundle";
+	readonly member: string;
 } | {
-    readonly in: 'sibling';
-    readonly name: string;
+	readonly in: "sibling";
+	readonly name: string;
 } | {
-    readonly in: 'main';
+	readonly in: "main";
 };
 export declare function revisionWeightFile(formatEntry: ModelFormatEntry): RevisionWeightFile | null;
 /** Where the revision's weight file is hosted — what the mirror's `lfs.oid` describes. */
 export declare function revisionWeightUrl(formatEntry: ModelFormatEntry): string | null;
 /**
- * Resolve a `ModelCatalogEntry` against `modelsDir`: download model file
- * (or directory bundle) + extra files (labels JSON, charset dict, …),
- * skip if already on disk. Returns the local model path.
- */
+* Resolve a `ModelCatalogEntry` against `modelsDir`: download model file
+* (or directory bundle) + extra files (labels JSON, charset dict, …),
+* skip if already on disk. Returns the local model path.
+*/
 export declare function ensureModel(modelsDir: string, entry: ModelCatalogEntry, format: ModelFormat, onProgress?: DownloadProgressCallback): Promise<string>;
 /** What {@link adoptModelRevisions} found: `<modelId>/<format>` keys. */
 export interface ModelRevisionAdoption {
-    /** Copies proven current by hash and recorded — no download needed. */
-    readonly adopted: readonly string[];
-    /** Complete copies holding other bytes — `ensureModel` fetches them again. */
-    readonly stale: readonly string[];
+	/** Copies proven current by hash and recorded — no download needed. */
+	readonly adopted: readonly string[];
+	/** Complete copies holding other bytes — `ensureModel` fetches them again. */
+	readonly stale: readonly string[];
 }
 /**
- * Walk `entries` and record the revision of every complete copy on disk that
- * hashes to it, so a node's listing reports present models as downloaded
- * without waiting for something to `ensureModel` them. Offline: it reads
- * files and never fetches. A copy already recorded current is not re-hashed.
- */
+* Walk `entries` and record the revision of every complete copy on disk that
+* hashes to it, so a node's listing reports present models as downloaded
+* without waiting for something to `ensureModel` them. Offline: it reads
+* files and never fetches. A copy already recorded current is not re-hashed.
+*/
 export declare function adoptModelRevisions(modelsDir: string, entries: readonly ModelCatalogEntry[]): Promise<ModelRevisionAdoption>;
 /** Compute the on-disk path for a given model + format, even when not yet downloaded. */
 export declare function getModelFilePath(modelsDir: string, entry: ModelCatalogEntry, format: ModelFormat): string | null;
 /**
- * True iff the model file (or `Manifest.json` for directory bundles) exists and
- * is non-empty, and — when the format has a revision ({@link
- * resolveFormatRevision}) — the node recorded that same revision for it
- * (D743). Synchronous, so it never hashes: a copy not yet proven current
- * answers false until `ensureModel` or {@link adoptModelRevisions} records it.
- */
+* True iff the model file (or `Manifest.json` for directory bundles) exists and
+* is non-empty, and — when the format has a revision ({@link
+* resolveFormatRevision}) — the node recorded that same revision for it
+* (D743). Synchronous, so it never hashes: a copy not yet proven current
+* answers false until `ensureModel` or {@link adoptModelRevisions} records it.
+*/
 export declare function isModelDownloaded(modelsDir: string, entry: ModelCatalogEntry, format: ModelFormat): boolean;
 /** Remove the on-disk model file/directory. Returns true if something was deleted. */
 export declare function deleteModelFromDisk(modelsDir: string, entry: ModelCatalogEntry, format: ModelFormat): boolean;

package/dist/events/event-bus.d.ts

@@ -1,10 +1,10 @@
 type EventCallback<T = unknown> = (data: T) => void;
 export declare class EventBus {
-    private listeners;
-    on<T = unknown>(event: string, callback: EventCallback<T>): () => void;
-    emit<T = unknown>(event: string, data: T): void;
-    once<T = unknown>(event: string, callback: EventCallback<T>): () => void;
-    removeAllListeners(event?: string): void;
-    listenerCount(event: string): number;
+	private listeners;
+	on<T = unknown>(event: string, callback: EventCallback<T>): () => void;
+	emit<T = unknown>(event: string, data: T): void;
+	once<T = unknown>(event: string, callback: EventCallback<T>): () => void;
+	removeAllListeners(event?: string): void;
+	listenerCount(event: string): number;
 }
 export {};

package/dist/events/system-event-bus.d.ts

@@ -1,14 +1,14 @@
-import { EventSource, SystemEvent, EventFilter, IEventBus } from '@camstack/types';
+import type { EventSource, SystemEvent, EventFilter, IEventBus } from "@camstack/types";
 export type { EventSource, SystemEvent, EventFilter };
 export declare class SystemEventBus implements IEventBus {
-    private readonly ringBuffer;
-    private readonly subscribers;
-    constructor(bufferSize?: number);
-    emit(event: SystemEvent): void;
-    /**
-     * Subscribe to events matching a filter.
-     * When called with a typed category filter, the handler receives typed event data.
-     */
-    subscribe(filter: EventFilter, handler: (event: SystemEvent) => void): () => void;
-    getRecent(filter?: EventFilter, limit?: number): readonly SystemEvent[];
+	private readonly ringBuffer;
+	private readonly subscribers;
+	constructor(bufferSize?: number);
+	emit(event: SystemEvent): void;
+	/**
+	* Subscribe to events matching a filter.
+	* When called with a typed category filter, the handler receives typed event data.
+	*/
+	subscribe(filter: EventFilter, handler: (event: SystemEvent) => void): () => void;
+	getRecent(filter?: EventFilter, limit?: number): readonly SystemEvent[];
 }

package/dist/feature/feature-manager.d.ts

@@ -1,11 +1,11 @@
-import { FeatureManifest, FeatureFlag } from '@camstack/types';
+import type { FeatureManifest, FeatureFlag } from "@camstack/types";
 export type { FeatureManifest, FeatureFlag };
 export type FeatureConfigReader = {
-    readonly features: FeatureManifest;
+	readonly features: FeatureManifest;
 };
 export declare class FeatureManager {
-    private readonly configReader;
-    constructor(configReader: FeatureConfigReader);
-    isEnabled(flag: FeatureFlag): boolean;
-    getManifest(): FeatureManifest;
+	private readonly configReader;
+	constructor(configReader: FeatureConfigReader);
+	isEnabled(flag: FeatureFlag): boolean;
+	getManifest(): FeatureManifest;
 }

package/dist/http/asset-compression.d.ts

@@ -1,92 +1,54 @@
-/**
- * Content-coding for addon-served static assets: `Accept-Encoding` negotiation,
- * an eligibility rule, and a BOUNDED cache of the compressed bytes.
- *
- * ## Why the ADDON owns the encoding
- *
- * The hub's `/addon/:addonId/*` bridge is registered `{ compress: false }`. That
- * is not an oversight — on 2026-07-16 the global `@fastify/compress` was found
- * emitting an EMPTY brotli stream (`content-encoding: br`, `content-length: 0`)
- * for any compressible body over its 1 KiB threshold once the body had crossed
- * the UDS route bridge of a FORKED addon. It silently broke the notifier SVG
- * icons; the deploy-bundle pull route had already dodged the same class with
- * `compress: false`. The resolution then, and the contract now, is that an addon
- * route owns its content-coding END TO END: it negotiates, it compresses, it
- * stamps `content-encoding` + `Vary`, and the hub pipes those bytes through
- * untouched (`proxyToUpstream` replays the upstream headers verbatim).
- *
- * So compression belongs HERE, in the shared file data-plane, and nowhere above
- * it. Anything that re-compresses on top of this reintroduces the empty-brotli
- * bug rather than doubling the ratio.
- *
- * ## Why the bytes are cached, and why the cache is bounded
- *
- * Measured on the stream-broker embed bundle (`index-<hash>.js`, 1,443,142 B):
- * gzip-6 → 360,868 B, brotli-5 → 327,419 B in 27 ms, brotli-11 → 293,677 B in
- * 2,233 ms. Quality 5 is the request-path choice: 77% off the wire for 27 ms
- * paid ONCE. Quality 11 buys another 2.3% for eighty times the CPU, on a path
- * where a real client is waiting.
- *
- * The cache is an LRU bounded by BOTH entry count and total bytes, and it
- * refuses assets over {@link COMPRESSION_MAX_ASSET_BYTES} outright. An unbounded
- * `Map` keyed by URL is how a long-lived process walks into an OOM, and this
- * repo has already spent a session on one.
- *
- * The key carries `mtimeMs` and `size`, so a rebuild that rewrites an asset in
- * place under an UNCHANGED name (an SPA shell, a service worker) can never be
- * served from the previous build's bytes.
- */
 /** The codings this layer will produce. Identity is the absence of one. */
-export type ContentEncoding = 'br' | 'gzip';
+export type ContentEncoding = "br" | "gzip";
 /**
- * Below this the framing and the `Vary` cache split cost more than the
- * compression saves. Same threshold the hub's global compressor is registered
- * with, deliberately.
- */
+* Below this the framing and the `Vary` cache split cost more than the
+* compression saves. Same threshold the hub's global compressor is registered
+* with, deliberately.
+*/
 export declare const COMPRESSION_MIN_BYTES = 1024;
 /**
- * Above this an asset is streamed identity and never buffered. Compression
- * requires the whole body in RAM twice; a multi-hundred-MB recording segment
- * must not be able to do that, whatever its content type says.
- */
+* Above this an asset is streamed identity and never buffered. Compression
+* requires the whole body in RAM twice; a multi-hundred-MB recording segment
+* must not be able to do that, whatever its content type says.
+*/
 export declare const COMPRESSION_MAX_ASSET_BYTES: number;
 /** Is a body of this content type worth compressing at all? */
 export declare function isCompressibleContentType(contentType: string): boolean;
 /**
- * Pick a coding for this request: brotli when offered, else gzip, else identity.
- *
- * Returns `null` for identity — including when the header is ABSENT. A client
- * that offers nothing gets the raw bytes; guessing on its behalf is how a
- * non-negotiating consumer (a native fetch, a probe, an OTA puller) ends up with
- * a body it cannot read.
- */
+* Pick a coding for this request: brotli when offered, else gzip, else identity.
+*
+* Returns `null` for identity — including when the header is ABSENT. A client
+* that offers nothing gets the raw bytes; guessing on its behalf is how a
+* non-negotiating consumer (a native fetch, a probe, an OTA puller) ends up with
+* a body it cannot read.
+*/
 export declare function negotiateContentEncoding(acceptEncoding: string | undefined): ContentEncoding | null;
 /** Identity of one compressed body. `mtimeMs`+`size` make a rebuild-in-place a MISS. */
 export interface CompressedAssetKey {
-    readonly path: string;
-    readonly mtimeMs: number;
-    readonly size: number;
-    readonly encoding: ContentEncoding;
+	readonly path: string;
+	readonly mtimeMs: number;
+	readonly size: number;
+	readonly encoding: ContentEncoding;
 }
 /** Counters for the cache. Exported so a test can prove the compressor ran ONCE. */
 export interface AssetCompressionStats {
-    /** Bodies actually run through zlib. */
-    readonly compressions: number;
-    /** Requests served from already-compressed bytes. */
-    readonly hits: number;
-    readonly entries: number;
-    readonly bytes: number;
+	/** Bodies actually run through zlib. */
+	readonly compressions: number;
+	/** Requests served from already-compressed bytes. */
+	readonly hits: number;
+	readonly entries: number;
+	readonly bytes: number;
 }
 /**
- * Compressed bytes for one asset, compressing at most once per key.
- *
- * `null` means "send the original" — the asset is too large to buffer, the
- * source could not be read, or compression did not actually shrink it. Every
- * failure degrades to identity, so this can only ever be an optimisation.
- *
- * Concurrent callers for the same key share ONE compression: a cold cache hit by
- * a dozen parallel asset requests must not run zlib a dozen times.
- */
+* Compressed bytes for one asset, compressing at most once per key.
+*
+* `null` means "send the original" — the asset is too large to buffer, the
+* source could not be read, or compression did not actually shrink it. Every
+* failure degrades to identity, so this can only ever be an optimisation.
+*
+* Concurrent callers for the same key share ONE compression: a cold cache hit by
+* a dozen parallel asset requests must not run zlib a dozen times.
+*/
 export declare function getCompressedAsset(key: CompressedAssetKey, readSource: () => Promise<Buffer>): Promise<Buffer | null>;
 export declare function getAssetCompressionStats(): AssetCompressionStats;
 /** Test seam — the cache and its counters are process-wide. */

package/dist/http/authenticated-file-server.d.ts

@@ -1,53 +1,53 @@
 /** Does `token` grant access to `relPath`? Supplied by the caller. */
 export type FileServerTokenVerifier = (token: string, relPath: string) => boolean;
 export interface AuthenticatedFileServerOptions {
-    /** URL namespace prefix, e.g. `/rec/`. Requests are `<urlPrefix><token>/<rel>`. */
-    readonly urlPrefix: string;
-    /** Port to listen on (`0` = ephemeral). */
-    readonly port: number;
-    /** Current set of root dirs to search for a requested rel path (multi-location). */
-    readonly getRoots: () => readonly string[];
-    /** Validate the per-request scoped token against the requested rel path. */
-    readonly verifyToken: FileServerTokenVerifier;
-    /** `Access-Control-Allow-Origin` value. Default `*` (auth is the token, not the origin). */
-    readonly corsOrigin?: string;
-    /** Optional extension→content-type overrides merged over the media defaults. */
-    readonly contentTypes?: Readonly<Record<string, string>>;
+	/** URL namespace prefix, e.g. `/rec/`. Requests are `<urlPrefix><token>/<rel>`. */
+	readonly urlPrefix: string;
+	/** Port to listen on (`0` = ephemeral). */
+	readonly port: number;
+	/** Current set of root dirs to search for a requested rel path (multi-location). */
+	readonly getRoots: () => readonly string[];
+	/** Validate the per-request scoped token against the requested rel path. */
+	readonly verifyToken: FileServerTokenVerifier;
+	/** `Access-Control-Allow-Origin` value. Default `*` (auth is the token, not the origin). */
+	readonly corsOrigin?: string;
+	/** Optional extension→content-type overrides merged over the media defaults. */
+	readonly contentTypes?: Readonly<Record<string, string>>;
 }
 export interface FileServerHandle {
-    readonly port: number;
-    close(): Promise<void>;
+	readonly port: number;
+	close(): Promise<void>;
 }
 export type FileResolveResult = {
-    candidates: string[];
+	candidates: string[];
 } | {
-    error: 'forbidden';
+	error: "forbidden";
 };
 /**
- * Split a request URL (`<urlPrefix><token>/<relPath>`) into its token + rel
- * path. Returns null for anything outside the prefix or missing either part.
- * `relPath` is URL-decoded; a decode failure → null.
- */
+* Split a request URL (`<urlPrefix><token>/<relPath>`) into its token + rel
+* path. Returns null for anything outside the prefix or missing either part.
+* `relPath` is URL-decoded; a decode failure → null.
+*/
 export declare function parseTokenizedUrl(urlPrefix: string, urlPath: string): {
-    token: string;
-    rel: string;
+	token: string;
+	rel: string;
 } | null;
 /**
- * Map a rel path to one candidate absolute path PER root, keeping only roots the
- * path stays within (traversal guard). The handler serves the first candidate
- * that exists. Rejects a path that escapes every root.
- */
+* Map a rel path to one candidate absolute path PER root, keeping only roots the
+* path stays within (traversal guard). The handler serves the first candidate
+* that exists. Rejects a path that escapes every root.
+*/
 export declare function resolveFilePath(roots: readonly string[], rel: string): FileResolveResult;
 export declare function contentTypeFor(filePath: string, overrides?: Readonly<Record<string, string>>): string;
 export interface ByteRange {
-    start: number;
-    end: number;
+	start: number;
+	end: number;
 }
 /** Parse an HTTP `Range` header against a known size. Null = serve whole file. */
 export declare function parseRangeHeader(header: string | undefined, size: number): ByteRange | null;
 /**
- * Start an authenticated file-server. Returns the bound port so the caller can
- * build URLs. `getRoots`/`verifyToken` are invoked per request, so they always
- * reflect the live config.
- */
+* Start an authenticated file-server. Returns the bound port so the caller can
+* build URLs. `getRoots`/`verifyToken` are invoked per request, so they always
+* reflect the live config.
+*/
 export declare function createAuthenticatedFileServer(opts: AuthenticatedFileServerOptions): Promise<FileServerHandle>;

package/dist/http/data-plane-registry.d.ts

@@ -1,48 +1,58 @@
-import { AddonDataPlaneEndpoint } from '@camstack/types';
+/**
+* Hub-side registry of addon HTTP **data-planes**. Maps `addonId` → the set of
+* `{ prefix, access, baseUrl, secret }` endpoints the addon advertised (pulled
+* over the UDS `data-planes` call when the addon mounts). The hub's
+* `/addon/:addonId/*` dispatch consults `match()` BEFORE the control-route path:
+* a hit means "authenticate, then reverse-proxy to the addon's listener".
+*
+* Single authority, hub-resident, in-memory — rebuilt from the addons on every
+* mount (no persistence, no shadow copies).
+*/
+import type { AddonDataPlaneEndpoint } from "@camstack/types";
 export interface DataPlaneMatch {
-    readonly addonId: string;
-    readonly endpoint: AddonDataPlaneEndpoint;
-    /** Request path AFTER the matched prefix, leading-slashed (`/7/master.m3u8`).
-     *  Query string is NOT included here — the caller appends it. */
-    readonly rest: string;
+	readonly addonId: string;
+	readonly endpoint: AddonDataPlaneEndpoint;
+	/** Request path AFTER the matched prefix, leading-slashed (`/7/master.m3u8`).
+	*  Query string is NOT included here — the caller appends it. */
+	readonly rest: string;
 }
 export declare class DataPlaneRegistry {
-    private readonly byAddon;
-    /** Replace ALL endpoints for an addon (idempotent re-mount). */
-    registerAddon(addonId: string, endpoints: readonly AddonDataPlaneEndpoint[]): void;
-    /** Drop an addon's endpoints (stop / disconnect). */
-    unregisterAddon(addonId: string): void;
-    /** True when the addon has at least one data-plane registered. */
-    has(addonId: string): boolean;
-    /**
-     * Match `subPath` (the part after `/addon/<addonId>/`, with or without a
-     * leading slash, NO query string) against the addon's prefixes. Longest prefix
-     * wins. Returns the matched endpoint + the remaining path the addon handler sees.
-     */
-    match(addonId: string, subPath: string): DataPlaneMatch | null;
+	private readonly byAddon;
+	/** Replace ALL endpoints for an addon (idempotent re-mount). */
+	registerAddon(addonId: string, endpoints: readonly AddonDataPlaneEndpoint[]): void;
+	/** Drop an addon's endpoints (stop / disconnect). */
+	unregisterAddon(addonId: string): void;
+	/** True when the addon has at least one data-plane registered. */
+	has(addonId: string): boolean;
+	/**
+	* Match `subPath` (the part after `/addon/<addonId>/`, with or without a
+	* leading slash, NO query string) against the addon's prefixes. Longest prefix
+	* wins. Returns the matched endpoint + the remaining path the addon handler sees.
+	*/
+	match(addonId: string, subPath: string): DataPlaneMatch | null;
 }
 /** What the hub knows about an addon when it re-evaluates its data-planes. */
 export interface DataPlaneEligibility {
-    /** The addon still has an entry in the registry service. */
-    readonly hasEntry: boolean;
-    /** That entry is a FORKED addon — the only kind that serves a data-plane today. */
-    readonly isForked: boolean;
-    /** The child process is currently known to the child registry. */
-    readonly childKnown: boolean;
+	/** The addon still has an entry in the registry service. */
+	readonly hasEntry: boolean;
+	/** That entry is a FORKED addon — the only kind that serves a data-plane today. */
+	readonly isForked: boolean;
+	/** The child process is currently known to the child registry. */
+	readonly childKnown: boolean;
 }
 /**
- * Whether an addon can serve a data-plane RIGHT NOW.
- *
- * Extracted as a predicate because the three ways of answering "no" used to be
- * three early `return`s inside the mount path, and every one of them left the
- * PREVIOUS registration standing. The registry then held a `baseUrl` pointing
- * at the port of a process that no longer existed, and `/addon/:addonId/*` kept
- * reverse-proxying to it — a 502 per request until a replacement child finished
- * handshaking, and forever for an addon removed from disk. `unregisterAddon`
- * existed for exactly this and had no call site anywhere in the repo.
- *
- * A `false` here means UNREGISTER, never "leave it alone". Dropping is the safe
- * direction: an absent data-plane falls through to the control-route path,
- * while a stale one sends live traffic at a dead socket.
- */
+* Whether an addon can serve a data-plane RIGHT NOW.
+*
+* Extracted as a predicate because the three ways of answering "no" used to be
+* three early `return`s inside the mount path, and every one of them left the
+* PREVIOUS registration standing. The registry then held a `baseUrl` pointing
+* at the port of a process that no longer existed, and `/addon/:addonId/*` kept
+* reverse-proxying to it — a 502 per request until a replacement child finished
+* handshaking, and forever for an addon removed from disk. `unregisterAddon`
+* existed for exactly this and had no call site anywhere in the repo.
+*
+* A `false` here means UNREGISTER, never "leave it alone". Dropping is the safe
+* direction: an absent data-plane falls through to the control-route path,
+* while a stale one sends live traffic at a dead socket.
+*/
 export declare function canServeDataPlane(state: DataPlaneEligibility): boolean;