@camstack/system 1.2.390 → 1.2.391

package/dist/process/proc-stat.d.ts

@@ -1,74 +1,74 @@
 /**
- * Kernel jiffies per second (`USER_HZ`). `sysconf(_SC_CLK_TCK)` is not exposed
- * to Node, and this has been 100 on every Linux/x86-64 and arm64 kernel
- * configuration we ship to. A wrong value would scale every CPU number and
- * every elapsed time by one constant — visible at once, not a silent skew.
- */
+* Kernel jiffies per second (`USER_HZ`). `sysconf(_SC_CLK_TCK)` is not exposed
+* to Node, and this has been 100 on every Linux/x86-64 and arm64 kernel
+* configuration we ship to. A wrong value would scale every CPU number and
+* every elapsed time by one constant — visible at once, not a silent skew.
+*/
 export declare const CLOCK_TICKS_PER_SEC = 100;
 /** The fields of one `/proc/<pid>/stat` line this repository reads. */
 export interface ProcStat {
-    readonly pid: number;
-    readonly comm: string;
-    /** Field 3: `R`, `S`, `D`, `Z`, … */
-    readonly state: string;
-    readonly ppid: number;
-    readonly pgid: number;
-    /** `utime + stime`, in jiffies, over the process's whole life. */
-    readonly ticks: number;
-    /** Field 22: jiffies since boot at which this incarnation of the pid began. */
-    readonly startTicks: number;
-    /** Field 24: resident pages. Prefer `VmRSS` from `status`, which is in kB. */
-    readonly rssPages: number;
+	readonly pid: number;
+	readonly comm: string;
+	/** Field 3: `R`, `S`, `D`, `Z`, … */
+	readonly state: string;
+	readonly ppid: number;
+	readonly pgid: number;
+	/** `utime + stime`, in jiffies, over the process's whole life. */
+	readonly ticks: number;
+	/** Field 22: jiffies since boot at which this incarnation of the pid began. */
+	readonly startTicks: number;
+	/** Field 24: resident pages. Prefer `VmRSS` from `status`, which is in kB. */
+	readonly rssPages: number;
 }
 /**
- * Parse one `/proc/<pid>/stat` line. `null` for a line that does not parse —
- * a process that exited between the readdir and the read leaves a truncated
- * or empty file, and that is normal, not an error.
- */
+* Parse one `/proc/<pid>/stat` line. `null` for a line that does not parse —
+* a process that exited between the readdir and the read leaves a truncated
+* or empty file, and that is normal, not an error.
+*/
 export declare function parseProcStat(line: string): ProcStat | null;
 /** Resident memory from `/proc/<pid>/status`, in bytes. Absent is `undefined`, never 0. */
 export interface ProcStatusRss {
-    /** `VmRSS` — what `ps rss` prints. */
-    readonly rssBytes: number | undefined;
-    /** `RssAnon` — private anonymous memory, the runner's own cost. */
-    readonly privateBytes: number | undefined;
-    /** `RssFile` — file-backed pages shared with every process mapping the same files. */
-    readonly sharedBytes: number | undefined;
+	/** `VmRSS` — what `ps rss` prints. */
+	readonly rssBytes: number | undefined;
+	/** `RssAnon` — private anonymous memory, the runner's own cost. */
+	readonly privateBytes: number | undefined;
+	/** `RssFile` — file-backed pages shared with every process mapping the same files. */
+	readonly sharedBytes: number | undefined;
 }
 /** Read `VmRSS` / `RssAnon` / `RssFile` (kB in the file) out of `/proc/<pid>/status`. */
 export declare function parseProcStatusRss(status: string): ProcStatusRss;
 /** Inputs for the two `ps`-compatible derivations below. */
 export interface LifetimeCpuInput {
-    readonly ticks: number;
-    readonly startTicks: number;
-    /** First field of `/proc/uptime`, seconds since boot. */
-    readonly uptimeSec: number;
+	readonly ticks: number;
+	readonly startTicks: number;
+	/** First field of `/proc/uptime`, seconds since boot. */
+	readonly uptimeSec: number;
 }
 /** Seconds the process has been alive — `ps etime`, whole seconds. */
-export declare function elapsedSecSince(input: Pick<LifetimeCpuInput, 'startTicks' | 'uptimeSec'>): number;
+export declare function elapsedSecSince(input: Pick<LifetimeCpuInput, "startTicks" | "uptimeSec">): number;
 /**
- * `ps pcpu`: CPU time over elapsed time, as a percentage with one decimal.
- *
- * This is deliberately the LIFETIME average `ps` prints, not an instantaneous
- * rate: the columns fed from it have always shown that quantity, and the
- * instantaneous split is a different number with a different owner
- * (`cpuMainPercent` / `cpuGcPercent` from `thread-cpu-sampler.ts`). A process
- * with no elapsed window yet reports 0, never a division by zero.
- */
+* `ps pcpu`: CPU time over elapsed time, as a percentage with one decimal.
+*
+* This is deliberately the LIFETIME average `ps` prints, not an instantaneous
+* rate: the columns fed from it have always shown that quantity, and the
+* instantaneous split is a different number with a different owner
+* (`cpuMainPercent` / `cpuGcPercent` from `thread-cpu-sampler.ts`). A process
+* with no elapsed window yet reports 0, never a division by zero.
+*/
 export declare function lifetimeCpuPercent(input: LifetimeCpuInput): number;
 /**
- * The procfs surface, injectable — the whole reason the readers above are
- * testable against fixtures rather than against a Linux kernel.
- */
+* The procfs surface, injectable — the whole reason the readers above are
+* testable against fixtures rather than against a Linux kernel.
+*/
 export interface ProcReader {
-    /** Numeric entries of `/proc`. */
-    readonly listPids: () => Promise<readonly number[]>;
-    readonly readStat: (pid: number) => Promise<string>;
-    readonly readStatus: (pid: number) => Promise<string>;
-    /** Raw `/proc/<pid>/cmdline`: NUL-separated argv, empty for a kernel thread. */
-    readonly readCmdline: (pid: number) => Promise<string>;
-    /** First field of `/proc/uptime`. */
-    readonly readUptimeSec: () => Promise<number>;
+	/** Numeric entries of `/proc`. */
+	readonly listPids: () => Promise<readonly number[]>;
+	readonly readStat: (pid: number) => Promise<string>;
+	readonly readStatus: (pid: number) => Promise<string>;
+	/** Raw `/proc/<pid>/cmdline`: NUL-separated argv, empty for a kernel thread. */
+	readonly readCmdline: (pid: number) => Promise<string>;
+	/** First field of `/proc/uptime`. */
+	readonly readUptimeSec: () => Promise<number>;
 }
 export declare const nodeProcReader: ProcReader;
 /** `ps command=`: argv joined by spaces, or `[comm]` when there is no argv. */

package/dist/process/resource-monitor.d.ts

@@ -1,28 +1,28 @@
-import { ProcReader } from './proc-stat.js';
+import { type ProcReader } from "./proc-stat.js";
 export interface PidStats {
-    cpu: number;
-    memory: number;
-    /**
-     * Private anonymous resident bytes (Linux RssAnon) — per-process V8 heap +
-     * native allocs NOT shared across processes. The meaningful "what this runner
-     * actually costs" number (RSS double-counts the shared mmap'd framework).
-     * undefined where /proc/<pid>/status is unavailable (e.g. macOS).
-     */
-    privateBytes?: number;
-    /** Shared file-backed resident bytes (Linux RssFile). undefined on macOS. */
-    sharedBytes?: number;
+	cpu: number;
+	memory: number;
+	/**
+	* Private anonymous resident bytes (Linux RssAnon) — per-process V8 heap +
+	* native allocs NOT shared across processes. The meaningful "what this runner
+	* actually costs" number (RSS double-counts the shared mmap'd framework).
+	* undefined where /proc/<pid>/status is unavailable (e.g. macOS).
+	*/
+	privateBytes?: number;
+	/** Shared file-backed resident bytes (Linux RssFile). undefined on macOS. */
+	sharedBytes?: number;
 }
 /** The impure inputs, injectable so the platform branch is pinned by a test. */
 export interface PidStatsDeps {
-    readonly platform: NodeJS.Platform;
-    readonly reader: ProcReader;
-    /** `ps -o pid=,pcpu=,rss= -p <pids>` — the fork, for a platform without `/proc`. */
-    readonly spawnPs: (pids: readonly number[]) => Promise<string>;
+	readonly platform: NodeJS.Platform;
+	readonly reader: ProcReader;
+	/** `ps -o pid=,pcpu=,rss= -p <pids>` — the fork, for a platform without `/proc`. */
+	readonly spawnPs: (pids: readonly number[]) => Promise<string>;
 }
 /**
- * Get CPU% and memory RSS for one or more PIDs.
- * Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
- */
+* Get CPU% and memory RSS for one or more PIDs.
+* Returns a map of pid → stats. Missing/dead PIDs are silently omitted.
+*/
 export declare function getPidStats(pids: number | readonly number[], deps?: PidStatsDeps): Promise<ReadonlyMap<number, PidStats>>;
 /** Get CPU% and memory RSS for a single PID. Returns null if dead. */
 export declare function getSinglePidStats(pid: number): Promise<PidStats | null>;

package/dist/python/python-env-manager.d.ts

@@ -1,12 +1,12 @@
-import { IPythonEnvironment, PythonProbeResult, PythonEnvReady } from '@camstack/types';
-import { ChildProcess } from 'node:child_process';
+import type { IPythonEnvironment, PythonProbeResult, PythonEnvReady } from "@camstack/types";
+import type { ChildProcess } from "node:child_process";
 export declare class PythonEnvManager implements IPythonEnvironment {
-    private venvPath;
-    private cachedProbe;
-    constructor(dataDir: string);
-    probe(): Promise<PythonProbeResult>;
-    ensure(options: {
-        packages: readonly string[];
-    }): Promise<PythonEnvReady>;
-    spawn(script: string, args: readonly string[]): ChildProcess;
+	private venvPath;
+	private cachedProbe;
+	constructor(dataDir: string);
+	probe(): Promise<PythonProbeResult>;
+	ensure(options: {
+		packages: readonly string[];
+	}): Promise<PythonEnvReady>;
+	spawn(script: string, args: readonly string[]): ChildProcess;
 }

package/dist/repl/interfaces.d.ts

@@ -1,31 +1,31 @@
-import { ReplResult } from '@camstack/types';
 export interface ReplScope {
-    readonly type: 'system' | 'provider' | 'device' | 'addon';
-    readonly providerId?: string;
-    readonly deviceId?: number;
-    readonly addonId?: string;
+	readonly type: "system" | "provider" | "device" | "addon";
+	readonly providerId?: string;
+	readonly deviceId?: number;
+	readonly addonId?: string;
 }
 export interface ReplSessionContext {
-    readonly scope: ReplScope;
-    /** Pre-populated variables available in the REPL session */
-    readonly variables: Record<string, unknown>;
+	readonly scope: ReplScope;
+	/** Pre-populated variables available in the REPL session */
+	readonly variables: Record<string, unknown>;
 }
+import type { ReplResult } from "@camstack/types";
 export type { ReplResult };
 export interface IReplEngine {
-    execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
-    getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
+	execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
+	getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
 }
 /**
- * Context provider that the server kernel implements.
- * The REPL engine calls this to build the sandbox for each scope type.
- *
- * Methods may return a Promise so the kernel can warm up async
- * resources (e.g. `SystemManager.init()`) before exposing them — the
- * engine awaits each before evaluating user code.
- */
+* Context provider that the server kernel implements.
+* The REPL engine calls this to build the sandbox for each scope type.
+*
+* Methods may return a Promise so the kernel can warm up async
+* resources (e.g. `SystemManager.init()`) before exposing them — the
+* engine awaits each before evaluating user code.
+*/
 export interface IReplContextProvider {
-    getSystemSandbox(): Record<string, unknown> | Promise<Record<string, unknown>>;
-    getDeviceSandbox(deviceId: number): Record<string, unknown> | Promise<Record<string, unknown>>;
-    getProviderSandbox(providerId: string): Record<string, unknown> | Promise<Record<string, unknown>>;
-    getAddonSandbox(addonId: string): Record<string, unknown> | Promise<Record<string, unknown>>;
+	getSystemSandbox(): Record<string, unknown> | Promise<Record<string, unknown>>;
+	getDeviceSandbox(deviceId: number): Record<string, unknown> | Promise<Record<string, unknown>>;
+	getProviderSandbox(providerId: string): Record<string, unknown> | Promise<Record<string, unknown>>;
+	getAddonSandbox(addonId: string): Record<string, unknown> | Promise<Record<string, unknown>>;
 }

package/dist/repl/repl-engine.d.ts

@@ -1,8 +1,8 @@
-import { IReplEngine, IReplContextProvider, ReplSessionContext, ReplResult } from './interfaces.js';
+import type { IReplEngine, IReplContextProvider, ReplSessionContext, ReplResult } from "./interfaces.js";
 export declare class ReplEngine implements IReplEngine {
-    private readonly contextProvider;
-    constructor(contextProvider: IReplContextProvider);
-    execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
-    getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
-    private buildSandbox;
+	private readonly contextProvider;
+	constructor(contextProvider: IReplContextProvider);
+	execute(code: string, context: ReplSessionContext): Promise<ReplResult>;
+	getCompletions(partial: string, context: ReplSessionContext): Promise<string[]>;
+	private buildSandbox;
 }

package/dist/storage/fs-storage-backend.d.ts

@@ -1,40 +1,40 @@
 export interface IStorageBackend {
-    /** Backend type identifier */
-    readonly type: string;
-    /** Base path of this backend */
-    readonly basePath: string;
-    /** Resolve a subpath to an absolute path */
-    resolve(subpath: string): string;
-    /**
-     * Check whether the backend is usable: either the base directory
-     * already exists and is writable, OR we can create it on first
-     * write (i.e. the nearest existing ancestor is writable).
-     */
-    isAvailable(): boolean;
-    /** No-op for lazy backends. Kept for API compatibility. */
-    initialize(): Promise<void>;
+	/** Backend type identifier */
+	readonly type: string;
+	/** Base path of this backend */
+	readonly basePath: string;
+	/** Resolve a subpath to an absolute path */
+	resolve(subpath: string): string;
+	/**
+	* Check whether the backend is usable: either the base directory
+	* already exists and is writable, OR we can create it on first
+	* write (i.e. the nearest existing ancestor is writable).
+	*/
+	isAvailable(): boolean;
+	/** No-op for lazy backends. Kept for API compatibility. */
+	initialize(): Promise<void>;
 }
 /**
- * Filesystem storage backend — lazy by design.
- *
- * `initialize()` does NOT create the base directory eagerly. Instead,
- * consumers that write via `FilesystemStorageProvider` (and other write
- * helpers in storage-manager.ts) run `fs.mkdir(dirname(filePath), { recursive: true })`
- * right before every `writeFile`, so the directory tree appears on demand.
- *
- * The previous behaviour eagerly mkdir'd every location declared in
- * `StorageLocationManager.initializeDefaults()` — six directories (`db`,
- * `media`, `recordings`, `models`, `cache`, `logs`) got created at boot
- * even if the installation had no cameras, no recording addon, no
- * analytics addon, etc. That meant every fresh install looked like it
- * was producing data when it had nothing to write. Laziness fixes that:
- * a directory only exists once an addon decides to put a file there.
- */
+* Filesystem storage backend — lazy by design.
+*
+* `initialize()` does NOT create the base directory eagerly. Instead,
+* consumers that write via `FilesystemStorageProvider` (and other write
+* helpers in storage-manager.ts) run `fs.mkdir(dirname(filePath), { recursive: true })`
+* right before every `writeFile`, so the directory tree appears on demand.
+*
+* The previous behaviour eagerly mkdir'd every location declared in
+* `StorageLocationManager.initializeDefaults()` — six directories (`db`,
+* `media`, `recordings`, `models`, `cache`, `logs`) got created at boot
+* even if the installation had no cameras, no recording addon, no
+* analytics addon, etc. That meant every fresh install looked like it
+* was producing data when it had nothing to write. Laziness fixes that:
+* a directory only exists once an addon decides to put a file there.
+*/
 export declare class FsStorageBackend implements IStorageBackend {
-    readonly type = "local";
-    readonly basePath: string;
-    constructor(basePath: string);
-    resolve(subpath: string): string;
-    isAvailable(): boolean;
-    initialize(): Promise<void>;
+	readonly type = "local";
+	readonly basePath: string;
+	constructor(basePath: string);
+	resolve(subpath: string): string;
+	isAvailable(): boolean;
+	initialize(): Promise<void>;
 }

package/dist/storage/storage-location-manager.d.ts

@@ -1,23 +1,23 @@
-import { IStorageBackend } from './fs-storage-backend.js';
-export type StorageLocationName = 'data' | 'media' | 'recordings' | 'models' | 'cache' | 'logs';
+import { type IStorageBackend } from "./fs-storage-backend.js";
+export type StorageLocationName = "data" | "media" | "recordings" | "models" | "cache" | "logs";
 export declare class StorageLocationManager {
-    private readonly backends;
-    private readonly dataPath;
-    constructor(dataPath: string);
-    /** Initialize all locations with default paths */
-    initializeDefaults(): Promise<void>;
-    /** Override a specific location's backend path */
-    setLocationPath(name: StorageLocationName, basePath: string): Promise<void>;
-    /** Get the backend for a location */
-    getBackend(name: StorageLocationName): IStorageBackend;
-    /** Resolve a path within a location */
-    resolve(location: StorageLocationName, subpath: string): string;
-    /** Check if all locations are available */
-    getStatus(): Array<{
-        name: StorageLocationName;
-        available: boolean;
-        path: string;
-    }>;
-    /** All location names */
-    getLocationNames(): StorageLocationName[];
+	private readonly backends;
+	private readonly dataPath;
+	constructor(dataPath: string);
+	/** Initialize all locations with default paths */
+	initializeDefaults(): Promise<void>;
+	/** Override a specific location's backend path */
+	setLocationPath(name: StorageLocationName, basePath: string): Promise<void>;
+	/** Get the backend for a location */
+	getBackend(name: StorageLocationName): IStorageBackend;
+	/** Resolve a path within a location */
+	resolve(location: StorageLocationName, subpath: string): string;
+	/** Check if all locations are available */
+	getStatus(): Array<{
+		name: StorageLocationName;
+		available: boolean;
+		path: string;
+	}>;
+	/** All location names */
+	getLocationNames(): StorageLocationName[];
 }

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

@@ -1,83 +1,83 @@
-import { StorageLocationManager, StorageLocationName } from './storage-location-manager.js';
-import { IStorageProvider as INewStorageProvider, ISettingsBackend, HistogramBucket } from '@camstack/types';
+import { StorageLocationManager, type StorageLocationName } from "./storage-location-manager.js";
+import type { IStorageProvider as INewStorageProvider, ISettingsBackend, HistogramBucket } from "@camstack/types";
 export interface IStorageProvider {
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    getLocation(name: StorageLocationName): IStorageLocation;
-    export?(locationName: StorageLocationName): Promise<Buffer>;
-    import?(locationName: StorageLocationName, data: Buffer): Promise<void>;
+	initialize(): Promise<void>;
+	shutdown(): Promise<void>;
+	getLocation(name: StorageLocationName): IStorageLocation;
+	export?(locationName: StorageLocationName): Promise<Buffer>;
+	import?(locationName: StorageLocationName, data: Buffer): Promise<void>;
 }
 export interface QueryFilter {
-    where?: Record<string, unknown>;
-    whereIn?: Record<string, unknown[]>;
-    whereBetween?: Record<string, [unknown, unknown]>;
-    orderBy?: {
-        field: string;
-        direction: 'asc' | 'desc';
-    };
-    limit?: number;
-    offset?: number;
+	where?: Record<string, unknown>;
+	whereIn?: Record<string, unknown[]>;
+	whereBetween?: Record<string, [unknown, unknown]>;
+	orderBy?: {
+		field: string;
+		direction: "asc" | "desc";
+	};
+	limit?: number;
+	offset?: number;
 }
 export interface StorageRecord {
-    collection: string;
-    id: string;
-    data: Record<string, unknown>;
+	collection: string;
+	id: string;
+	data: Record<string, unknown>;
 }
 export interface IStructuredStorage {
-    query(collection: string, filter?: QueryFilter): Promise<readonly StorageRecord[]>;
-    insert(record: StorageRecord): Promise<StorageRecord>;
-    update(collection: string, id: string, data: Record<string, unknown>): Promise<StorageRecord>;
-    delete(collection: string, id: string): Promise<void>;
-    count(collection: string, filter?: QueryFilter): Promise<number>;
-    histogram(input: {
-        collection: string;
-        field: string;
-        bucketSize: number;
-        origin: number;
-        filter?: QueryFilter;
-    }): Promise<readonly HistogramBucket[]>;
+	query(collection: string, filter?: QueryFilter): Promise<readonly StorageRecord[]>;
+	insert(record: StorageRecord): Promise<StorageRecord>;
+	update(collection: string, id: string, data: Record<string, unknown>): Promise<StorageRecord>;
+	delete(collection: string, id: string): Promise<void>;
+	count(collection: string, filter?: QueryFilter): Promise<number>;
+	histogram(input: {
+		collection: string;
+		field: string;
+		bucketSize: number;
+		origin: number;
+		filter?: QueryFilter;
+	}): Promise<readonly HistogramBucket[]>;
 }
 export interface IFileStorage {
-    readFile(path: string): Promise<Buffer>;
-    writeFile(path: string, data: Buffer): Promise<void>;
-    deleteFile(path: string): Promise<void>;
-    listFiles(prefix?: string): Promise<readonly string[]>;
-    getFileUrl(path: string): Promise<string>;
-    exists(path: string): Promise<boolean>;
+	readFile(path: string): Promise<Buffer>;
+	writeFile(path: string, data: Buffer): Promise<void>;
+	deleteFile(path: string): Promise<void>;
+	listFiles(prefix?: string): Promise<readonly string[]>;
+	getFileUrl(path: string): Promise<string>;
+	exists(path: string): Promise<boolean>;
 }
 export interface IStorageLocation {
-    structured?: IStructuredStorage;
-    files?: IFileStorage;
+	structured?: IStructuredStorage;
+	files?: IFileStorage;
 }
 /**
- * StorageManager — bridge between legacy code (getLocation/getLocationPath)
- * and the new capability-based storage system.
- *
- * Legacy consumers call getLocation('addon', namespace) to get structured + file storage.
- * This manager builds the response from:
- *   - SettingsBackend (for structured queries) — provided by sqlite-settings addon
- *   - LocationManager (for file paths) — set during Phase 2 boot
- */
+* StorageManager — bridge between legacy code (getLocation/getLocationPath)
+* and the new capability-based storage system.
+*
+* Legacy consumers call getLocation('addon', namespace) to get structured + file storage.
+* This manager builds the response from:
+*   - SettingsBackend (for structured queries) — provided by sqlite-settings addon
+*   - LocationManager (for file paths) — set during Phase 2 boot
+*/
 export declare class StorageManager {
-    private legacyProvider;
-    private locationManager;
-    private newStorageProvider;
-    private settingsBackend;
-    /** @deprecated Set by legacy capability consumer — use setNewStorageProvider instead */
-    setProvider(provider: IStorageProvider | INewStorageProvider): void;
-    setNewStorageProvider(provider: INewStorageProvider): void;
-    setSettingsBackend(backend: ISettingsBackend): void;
-    getSettingsBackend(): ISettingsBackend;
-    getProvider(): IStorageProvider;
-    setLocationManager(manager: StorageLocationManager): void;
-    getLocationManager(): StorageLocationManager;
-    initializeLocations(dataPath: string): Promise<void>;
-    getLocationPath(name: StorageLocationName): string;
-    /**
-     * Get a storage location with optional namespace scoping.
-     * Builds IStorageLocation from settingsBackend (structured) + locationManager (files).
-     */
-    getLocation(name: StorageLocationName | string, namespace?: string): IStorageLocation;
-    private createLegacyShim;
-    private createNamespacedLocation;
+	private legacyProvider;
+	private locationManager;
+	private newStorageProvider;
+	private settingsBackend;
+	/** @deprecated Set by legacy capability consumer — use setNewStorageProvider instead */
+	setProvider(provider: IStorageProvider | INewStorageProvider): void;
+	setNewStorageProvider(provider: INewStorageProvider): void;
+	setSettingsBackend(backend: ISettingsBackend): void;
+	getSettingsBackend(): ISettingsBackend;
+	getProvider(): IStorageProvider;
+	setLocationManager(manager: StorageLocationManager): void;
+	getLocationManager(): StorageLocationManager;
+	initializeLocations(dataPath: string): Promise<void>;
+	getLocationPath(name: StorageLocationName): string;
+	/**
+	* Get a storage location with optional namespace scoping.
+	* Builds IStorageLocation from settingsBackend (structured) + locationManager (files).
+	*/
+	getLocation(name: StorageLocationName | string, namespace?: string): IStorageLocation;
+	private createLegacyShim;
+	private createNamespacedLocation;
 }

package/dist/tls/boot-tls.d.ts

@@ -1,29 +1,29 @@
-import { CertOptions, EnsureTlsResult, TlsCertPair } from './cert-manager.js';
+import { type CertOptions, type EnsureTlsResult, type TlsCertPair } from "./cert-manager.js";
 /** The certificate source a booting listener serves. */
-export type BootTlsMode = 'generated' | 'uploaded';
+export type BootTlsMode = "generated" | "uploaded";
 export interface BootTls {
-    readonly mode: BootTlsMode;
-    readonly pair: TlsCertPair;
-    /**
-     * The `ensureTlsCert` outcome — present only for a generated certificate,
-     * so a reissue reaches the operator as an alert. `undefined` when an
-     * uploaded certificate is served: the hub never evaluates, let alone
-     * reissues, a certificate the operator supplied.
-     */
-    readonly ensured: EnsureTlsResult | undefined;
-    /**
-     * True when the mode marker said `uploaded` but the files were gone, so
-     * the node fell back to its generated certificate. The caller logs it:
-     * a certificate source that changed under the operator is never silent.
-     */
-    readonly uploadedMissing: boolean;
+	readonly mode: BootTlsMode;
+	readonly pair: TlsCertPair;
+	/**
+	* The `ensureTlsCert` outcome — present only for a generated certificate,
+	* so a reissue reaches the operator as an alert. `undefined` when an
+	* uploaded certificate is served: the hub never evaluates, let alone
+	* reissues, a certificate the operator supplied.
+	*/
+	readonly ensured: EnsureTlsResult | undefined;
+	/**
+	* True when the mode marker said `uploaded` but the files were gone, so
+	* the node fell back to its generated certificate. The caller logs it:
+	* a certificate source that changed under the operator is never silent.
+	*/
+	readonly uploadedMissing: boolean;
 }
 /**
- * Decide what the listener serves at boot. The admin UI (Network → Local
- * access) is the only way to set a certificate (D726): it either leaves the
- * hub on its generated local-CA leaf (D227) or uploads one, recorded by the
- * `tls/mode` marker. An uploaded certificate is served verbatim — running it
- * through `ensureTlsCert` would replace it on the first restart, because a
- * leaf the local root did not issue is one of that rule's reissue triggers.
- */
+* Decide what the listener serves at boot. The admin UI (Network → Local
+* access) is the only way to set a certificate (D726): it either leaves the
+* hub on its generated local-CA leaf (D227) or uploads one, recorded by the
+* `tls/mode` marker. An uploaded certificate is served verbatim — running it
+* through `ensureTlsCert` would replace it on the first restart, because a
+* leaf the local root did not issue is one of that rule's reissue triggers.
+*/
 export declare function prepareBootTls(dataDir: string, options?: CertOptions): Promise<BootTls>;