@crawlee/basic 4.0.0-beta.210 → 4.0.0-beta.212

package/internals/autoscaling/autoscaled_pool.d.ts

@@ -175,24 +175,4 @@ export declare class AutoscaledPool {
      * every `maybeRunIntervalSecs` seconds. If you want to trigger the processing immediately, use this method.
      */
     notify(): Promise<void>;
-    /**
-     * Starts a new task
-     * if the number of running tasks (current concurrency) is lower than desired concurrency
-     * and the system is not currently overloaded
-     * and `isTaskReadyFunction()` returns true.
-     *
-     * It doesn't allow multiple concurrent runs of this method.
-     */
-    private maybeRunTask;
-    /**
-     * If there are no running tasks and `isFinishedFunction()` returns true then closes
-     * the pool and resolves the pool's promise returned by the run() method.
-     *
-     * It doesn't allow multiple concurrent runs of this method.
-     */
-    private maybeFinish;
-    /**
-     * Cleans up resources.
-     */
-    private destroy;
 }

package/internals/autoscaling/autoscaled_pool.js

@@ -111,7 +111,6 @@ export class AutoscaledPool {
         this.#isStopped = false;
         this.#resolve = null;
         this.#reject = null;
-        this.maybeRunTask = this.maybeRunTask.bind(this);
     }
     /**
      * The governor backing this pool, as supplied to the constructor — exposed as the read-only
@@ -157,14 +156,14 @@ export class AutoscaledPool {
         // This is here because if we scale down to let's say 1, then after each promise is finished
         // this.maybeRunTask() doesn't trigger another one. So if that 1 instance gets stuck it results
         // in the crawler getting stuck and even after scaling up it never triggers another promise.
-        this.#maybeRunInterval = betterSetInterval(this.maybeRunTask, this.#maybeRunIntervalMillis);
+        this.#maybeRunInterval = betterSetInterval((cb) => this.#maybeRunTask(cb), this.#maybeRunIntervalMillis);
         try {
             await poolPromise;
         }
         finally {
             // If resolve is null, the pool is already destroyed.
             if (this.#resolve)
-                await this.destroy();
+                await this.#destroy();
         }
     }
     /**
@@ -182,7 +181,7 @@ export class AutoscaledPool {
         this.#isStopped = true;
         if (this.#resolve) {
             this.#resolve();
-            await this.destroy();
+            await this.#destroy();
         }
     }
     /**
@@ -241,7 +240,7 @@ export class AutoscaledPool {
      * every `maybeRunIntervalSecs` seconds. If you want to trigger the processing immediately, use this method.
      */
     async notify() {
-        setImmediate(this.maybeRunTask);
+        setImmediate(() => this.#maybeRunTask());
     }
     /**
      * Starts a new task
@@ -251,7 +250,7 @@ export class AutoscaledPool {
      *
      * It doesn't allow multiple concurrent runs of this method.
      */
-    async maybeRunTask(intervalCallback) {
+    async #maybeRunTask(intervalCallback) {
         this.#log.perf('Attempting to run a task.');
         // Check if the function was invoked by the maybeRunInterval and use an empty function if not.
         const done = intervalCallback || (() => { });
@@ -273,7 +272,7 @@ export class AutoscaledPool {
             // to notice that *this* pool has run out of work — `maybeFinish()` is the only thing that ever resolves
             // `run()`. It no-ops while this pool has tasks of its own in flight, which is every case in which an
             // unshared governor reports no capacity.
-            return this.maybeFinish();
+            return this.#maybeFinish();
         }
         // - a task is ready.
         this.#queryingIsTaskReady = true;
@@ -299,7 +298,7 @@ export class AutoscaledPool {
             this.#log.perf('Task will not run. No tasks are ready.');
             done();
             // No tasks could mean that we're finished with all tasks.
-            return this.maybeFinish();
+            return this.#maybeFinish();
         }
         const taskId = String(this.#nextTaskId++);
         // - the budget still has room. Re-checked atomically, because another pool sharing the governor may have taken
@@ -312,7 +311,7 @@ export class AutoscaledPool {
             // Everything's fine. Run task.
             // Try to run next task to build up concurrency,
             // but defer it so it doesn't create a cycle.
-            setImmediate(this.maybeRunTask);
+            setImmediate(() => this.#maybeRunTask());
             // We need to restart interval here, so that it doesn't get blocked by a stalled task.
             done();
             // Execute the current task.
@@ -326,7 +325,7 @@ export class AutoscaledPool {
             this.#log.perf('Task finished.');
             // Run task after the previous one finished. Only on success: a failed task rejects the pool, and
             // nudging the loop afterwards could start work on an already destroyed pool.
-            setImmediate(this.maybeRunTask);
+            setImmediate(() => this.#maybeRunTask());
         }
         catch (e) {
             const err = e;
@@ -354,7 +353,7 @@ export class AutoscaledPool {
      *
      * It doesn't allow multiple concurrent runs of this method.
      */
-    async maybeFinish() {
+    async #maybeFinish() {
         if (this.#queryingIsFinished)
             return;
         if (this.#ownConcurrency > 0)
@@ -380,7 +379,7 @@ export class AutoscaledPool {
     /**
      * Cleans up resources.
      */
-    async destroy() {
+    async #destroy() {
         this.#resolve = null;
         this.#reject = null;
         betterClearInterval(this.#maybeRunInterval);

package/internals/autoscaling/concurrency_system.d.ts

@@ -159,14 +159,8 @@ export interface IConcurrencySystem {
  */
 export declare class ConcurrencySystem implements IConcurrencySystem {
     #private;
-    private readonly log;
-    private readonly desiredConcurrencyRatio;
-    private readonly scaleUpStepRatio;
-    private readonly scaleDownStepRatio;
     /** The cap on tasks started per minute, or `Infinity` when uncapped. */
     readonly maxTasksPerMinute: number;
-    private readonly snapshotter;
-    private readonly systemStatus;
     constructor(options?: ConcurrencySystemOptions);
     /**
      * Gets the minimum number of tasks running in parallel.
@@ -198,13 +192,6 @@ export declare class ConcurrencySystem implements IConcurrencySystem {
      * Tune the budget through `minConcurrency`/`maxConcurrency` instead.
      */
     get desiredConcurrency(): number;
-    /**
-     * Re-establishes `minConcurrency <= desiredConcurrency <= maxConcurrency` after any of the three is retuned.
-     * Dispatch gates on the desired value alone, so one stranded above `maxConcurrency` would make the ceiling
-     * meaningless. A contradictory pair (`minConcurrency > maxConcurrency`) resolves in favour of the maximum, since
-     * that is the limit callers set in order to protect something.
-     */
-    private clampDesiredConcurrency;
     get currentConcurrency(): number;
     /** Whether the system is currently monitoring load and autoscaling the budget. */
     get isRunning(): boolean;
@@ -214,20 +201,11 @@ export declare class ConcurrencySystem implements IConcurrencySystem {
      * signal fails to start.
      */
     start(): Promise<void>;
-    private boot;
     [Symbol.asyncDispose](): Promise<void>;
     /**
      * Stops the snapshotter and intervals. Idempotent and safe to call even if the system was never started.
      */
     stop(): Promise<void>;
-    private shutDown;
-    /**
-     * Reports, once per session, that capacity is being queried on a system that isn't running — a mistake nothing
-     * else catches, since {@link AutoscaledPool.run|`pool.run()`} only checks
-     * {@link ConcurrencySystem.isRunning|`isRunning`} on the way in. Both the overload verdict and
-     * `desiredConcurrency` are frozen at that point, so the borrowing pool would otherwise just quietly mis-scale.
-     */
-    private warnIfNotRunning;
     /**
      * May **one more** task start right now? Returns `false` when the shared budget is spent (desired concurrency
      * reached) or when the machine is overloaded past `minConcurrency`.
@@ -236,8 +214,6 @@ export declare class ConcurrencySystem implements IConcurrencySystem {
      * interface, letting the answer be queried directly.
      */
     hasCapacityForTask(_consumer?: ConcurrencyConsumer): boolean;
-    /** Whether the per-minute task cap has been reached. */
-    private get isOverMaxRequestLimit();
     /**
      * Atomically books a task against the shared budget: re-checks
      * {@link ConcurrencySystem.hasCapacityForTask|`hasCapacityForTask()`} plus the per-minute task cap and
@@ -256,18 +232,4 @@ export declare class ConcurrencySystem implements IConcurrencySystem {
      * The one public window into load monitoring — useful for answering *why* a crawl is not scaling up.
      */
     getCurrentStatus(): SystemInfo;
-    /**
-     * Evaluates the historical system status and scales the shared desired concurrency up or down accordingly. Driven
-     * by the autoscaling interval started in {@link ConcurrencySystem.start|`start()`}.
-     */
-    private autoscale;
-    /**
-     * Scales the system up by increasing the desired concurrency by the scaleUpStepRatio.
-     */
-    private scaleUp;
-    /**
-     * Scales the system down by decreasing the desired concurrency by the scaleDownStepRatio.
-     */
-    private scaleDown;
-    private incrementTasksDonePerSecond;
 }

package/internals/autoscaling/concurrency_system.js

@@ -44,10 +44,10 @@ const concurrencySystemOptionsSchema = z.strictObject({
  * @category Scaling
  */
 export class ConcurrencySystem {
-    log;
-    desiredConcurrencyRatio;
-    scaleUpStepRatio;
-    scaleDownStepRatio;
+    #log;
+    #desiredConcurrencyRatio;
+    #scaleUpStepRatio;
+    #scaleDownStepRatio;
     #loggingIntervalMillis;
     #autoscaleIntervalMillis;
     /** The cap on tasks started per minute, or `Infinity` when uncapped. */
@@ -58,9 +58,9 @@ export class ConcurrencySystem {
     #currentConcurrency = 0;
     #lastLoggingTime;
     #tasksPerMinute = Array.from({ length: 60 }, () => 0);
-    snapshotter;
+    #snapshotter;
     #loadSignals;
-    systemStatus;
+    #systemStatus;
     #autoscaleInterval;
     #tasksDonePerSecondInterval;
     /** Whether the snapshotter and autoscaling intervals are currently running. */
@@ -71,25 +71,23 @@ export class ConcurrencySystem {
     #warnedAboutQueryWhileStopped = false;
     constructor(options = {}) {
         const { maxConcurrency, minConcurrency, desiredConcurrency, desiredConcurrencyRatio, scaleUpStepRatio, scaleDownStepRatio, loggingIntervalSecs, autoscaleIntervalSecs, loadSignals, snapshotHistorySecs, currentHistorySecs, log, maxTasksPerMinute, } = parseArgument(options, concurrencySystemOptionsSchema, 'ConcurrencySystemOptions');
-        this.log = log.child({ prefix: 'ConcurrencySystem' });
-        this.desiredConcurrencyRatio = desiredConcurrencyRatio;
-        this.scaleUpStepRatio = scaleUpStepRatio;
-        this.scaleDownStepRatio = scaleDownStepRatio;
+        this.#log = log.child({ prefix: 'ConcurrencySystem' });
+        this.#desiredConcurrencyRatio = desiredConcurrencyRatio;
+        this.#scaleUpStepRatio = scaleUpStepRatio;
+        this.#scaleDownStepRatio = scaleDownStepRatio;
         this.#loggingIntervalMillis = (loggingIntervalSecs ?? 0) * 1000;
         this.#autoscaleIntervalMillis = autoscaleIntervalSecs * 1000;
         this.maxTasksPerMinute = maxTasksPerMinute;
         this.#minConcurrency = minConcurrency;
         this.#maxConcurrency = maxConcurrency;
         this.#desiredConcurrency = desiredConcurrency ?? minConcurrency;
-        this.clampDesiredConcurrency();
-        this.autoscale = this.autoscale.bind(this);
-        this.incrementTasksDonePerSecond = this.incrementTasksDonePerSecond.bind(this);
+        this.#clampDesiredConcurrency();
         // The built-in signals are collected by the snapshotter; custom ones are simply evaluated alongside them.
         const { custom: customLoadSignals = [], ...builtinSignalOptions } = loadSignals;
-        this.snapshotter = new Snapshotter(builtinSignalOptions);
+        this.#snapshotter = new Snapshotter(builtinSignalOptions);
         this.#loadSignals = customLoadSignals;
-        this.systemStatus = new SystemStatus({
-            snapshotter: this.snapshotter,
+        this.#systemStatus = new SystemStatus({
+            snapshotter: this.#snapshotter,
             loadSignals: customLoadSignals,
             currentHistorySecs,
             // Both windows are requested from the signals explicitly, so a signal's own retention can neither widen
@@ -112,7 +110,7 @@ export class ConcurrencySystem {
     set minConcurrency(value) {
         parseArgument(value, concurrencySchema);
         this.#minConcurrency = value;
-        this.clampDesiredConcurrency();
+        this.#clampDesiredConcurrency();
     }
     /**
      * Gets the maximum number of tasks running in parallel.
@@ -129,7 +127,7 @@ export class ConcurrencySystem {
     set maxConcurrency(value) {
         parseArgument(value, concurrencySchema);
         this.#maxConcurrency = value;
-        this.clampDesiredConcurrency();
+        this.#clampDesiredConcurrency();
     }
     /**
      * Gets the desired concurrency for the system,
@@ -147,7 +145,7 @@ export class ConcurrencySystem {
      * meaningless. A contradictory pair (`minConcurrency > maxConcurrency`) resolves in favour of the maximum, since
      * that is the limit callers set in order to protect something.
      */
-    clampDesiredConcurrency() {
+    #clampDesiredConcurrency() {
         const atLeastMin = Math.max(this.#desiredConcurrency, this.#minConcurrency);
         this.#desiredConcurrency = Math.min(atLeastMin, this.#maxConcurrency);
     }
@@ -166,14 +164,14 @@ export class ConcurrencySystem {
     async start() {
         // Unwound and dropped again on failure, so a later `start()` retries instead of resolving instantly against
         // a system that is down.
-        this.#startPromise ??= this.boot().catch(async (error) => {
+        this.#startPromise ??= this.#boot().catch(async (error) => {
             this.#startPromise = undefined;
-            await this.shutDown();
+            await this.#shutDown();
             throw error;
         });
         await this.#startPromise;
     }
-    async boot() {
+    async #boot() {
         // Per-session measurement state, reset so a restarted system isn't judged on the previous session. The
         // per-minute window matters most: its ageing interval is cleared while we are down, so starts from before an
         // arbitrarily long stop would otherwise still count against "this minute" and trip the cap immediately.
@@ -182,12 +180,12 @@ export class ConcurrencySystem {
         this.#warnedAboutQueryWhileStopped = false;
         // Signals are told how much history to keep when they start: exactly the longest window they will be sampled
         // over, so nobody has to guess a retention value that matches this system's configuration.
-        const startContext = { maxSampleWindowMillis: this.systemStatus.maxSampleWindowMillis };
-        await this.snapshotter.start(startContext);
+        const startContext = { maxSampleWindowMillis: this.#systemStatus.maxSampleWindowMillis };
+        await this.#snapshotter.start(startContext);
         await Promise.all(this.#loadSignals.map(async (s) => s.start(startContext)));
-        this.#autoscaleInterval = betterSetInterval(this.autoscale, this.#autoscaleIntervalMillis);
+        this.#autoscaleInterval = betterSetInterval((cb) => this.#autoscale(cb), this.#autoscaleIntervalMillis);
         if (this.maxTasksPerMinute !== Infinity) {
-            this.#tasksDonePerSecondInterval = betterSetInterval(this.incrementTasksDonePerSecond, 1000);
+            this.#tasksDonePerSecondInterval = betterSetInterval((cb) => this.#incrementTasksDonePerSecond(cb), 1000);
         }
         // Last, so `isRunning` never claims a system whose signals aren't collecting yet.
         this.#running = true;
@@ -206,14 +204,14 @@ export class ConcurrencySystem {
         await this.#startPromise.catch(() => { });
         this.#startPromise = undefined;
         this.#running = false;
-        await this.shutDown();
+        await this.#shutDown();
     }
-    async shutDown() {
+    async #shutDown() {
         if (this.#autoscaleInterval)
             betterClearInterval(this.#autoscaleInterval);
         if (this.#tasksDonePerSecondInterval)
             betterClearInterval(this.#tasksDonePerSecondInterval);
-        await this.snapshotter.stop();
+        await this.#snapshotter.stop();
         await Promise.all(this.#loadSignals.map(async (s) => s.stop()));
     }
     /**
@@ -222,12 +220,12 @@ export class ConcurrencySystem {
      * {@link ConcurrencySystem.isRunning|`isRunning`} on the way in. Both the overload verdict and
      * `desiredConcurrency` are frozen at that point, so the borrowing pool would otherwise just quietly mis-scale.
      */
-    warnIfNotRunning() {
+    #warnIfNotRunning() {
         if (this.#running || this.#warnedAboutQueryWhileStopped) {
             return;
         }
         this.#warnedAboutQueryWhileStopped = true;
-        this.log.warning('Capacity is being queried on a ConcurrencySystem that is not running, so system load is no longer being ' +
+        this.#log.warning('Capacity is being queried on a ConcurrencySystem that is not running, so system load is no longer being ' +
             'monitored and the concurrency will no longer be adjusted. Whoever creates a ConcurrencySystem owns ' +
             'its lifecycle: call `await concurrencySystem.stop()` only once every pool and crawler borrowing it ' +
             'has finished.');
@@ -240,21 +238,21 @@ export class ConcurrencySystem {
      * interface, letting the answer be queried directly.
      */
     hasCapacityForTask(_consumer) {
-        this.warnIfNotRunning();
+        this.#warnIfNotRunning();
         if (this.#currentConcurrency >= this.#desiredConcurrency) {
-            this.log.perf('Task will not run. Desired concurrency achieved.');
+            this.#log.perf('Task will not run. Desired concurrency achieved.');
             return false;
         }
-        const currentStatus = this.systemStatus.getCurrentStatus();
+        const currentStatus = this.#systemStatus.getCurrentStatus();
         const { isSystemIdle } = currentStatus;
         if (!isSystemIdle && this.#currentConcurrency >= this.#minConcurrency) {
-            this.log.perf('Task will not be run. System is overloaded.', currentStatus);
+            this.#log.perf('Task will not be run. System is overloaded.', currentStatus);
             return false;
         }
         return true;
     }
     /** Whether the per-minute task cap has been reached. */
-    get isOverMaxRequestLimit() {
+    get #isOverMaxRequestLimit() {
         if (this.maxTasksPerMinute === Infinity) {
             return false;
         }
@@ -273,8 +271,8 @@ export class ConcurrencySystem {
         if (!this.hasCapacityForTask(consumer)) {
             return false;
         }
-        if (this.isOverMaxRequestLimit) {
-            this.log.perf('Task will not run. Maximum tasks per minute reached.');
+        if (this.#isOverMaxRequestLimit) {
+            this.#log.perf('Task will not run. Maximum tasks per minute reached.');
             return false;
         }
         this.#currentConcurrency++;
@@ -291,26 +289,26 @@ export class ConcurrencySystem {
      * The one public window into load monitoring — useful for answering *why* a crawl is not scaling up.
      */
     getCurrentStatus() {
-        return this.systemStatus.getCurrentStatus();
+        return this.#systemStatus.getCurrentStatus();
     }
     /**
      * Evaluates the historical system status and scales the shared desired concurrency up or down accordingly. Driven
      * by the autoscaling interval started in {@link ConcurrencySystem.start|`start()`}.
      */
-    autoscale(intervalCallback) {
-        if (this.isOverMaxRequestLimit)
+    #autoscale(intervalCallback) {
+        if (this.#isOverMaxRequestLimit)
             return intervalCallback();
-        const systemStatus = this.systemStatus.getHistoricalStatus();
+        const systemStatus = this.#systemStatus.getHistoricalStatus();
         const { isSystemIdle } = systemStatus;
         const weAreNotAtMax = this.#desiredConcurrency < this.#maxConcurrency;
-        const minCurrentConcurrency = Math.floor(this.#desiredConcurrency * this.desiredConcurrencyRatio);
+        const minCurrentConcurrency = Math.floor(this.#desiredConcurrency * this.#desiredConcurrencyRatio);
         const weAreReachingDesiredConcurrency = this.#currentConcurrency >= minCurrentConcurrency;
         if (isSystemIdle && weAreNotAtMax && weAreReachingDesiredConcurrency)
-            this.scaleUp(systemStatus);
+            this.#scaleUp(systemStatus);
         const isSystemOverloaded = !isSystemIdle;
         const weAreNotAtMin = this.#desiredConcurrency > this.#minConcurrency;
         if (isSystemOverloaded && weAreNotAtMin)
-            this.scaleDown(systemStatus);
+            this.#scaleDown(systemStatus);
         if (this.#loggingIntervalMillis > 0) {
             const now = Date.now();
             if (this.#lastLoggingTime == null) {
@@ -318,7 +316,7 @@ export class ConcurrencySystem {
             }
             else if (now > this.#lastLoggingTime + this.#loggingIntervalMillis) {
                 this.#lastLoggingTime = now;
-                this.log.info('state', {
+                this.#log.info('state', {
                     currentConcurrency: this.#currentConcurrency,
                     desiredConcurrency: this.#desiredConcurrency,
                     systemStatus,
@@ -330,10 +328,10 @@ export class ConcurrencySystem {
     /**
      * Scales the system up by increasing the desired concurrency by the scaleUpStepRatio.
      */
-    scaleUp(systemStatus) {
-        const step = Math.ceil(this.#desiredConcurrency * this.scaleUpStepRatio);
+    #scaleUp(systemStatus) {
+        const step = Math.ceil(this.#desiredConcurrency * this.#scaleUpStepRatio);
         this.#desiredConcurrency = Math.min(this.#maxConcurrency, this.#desiredConcurrency + step);
-        this.log.debug('scaling up', {
+        this.#log.debug('scaling up', {
             oldConcurrency: this.#desiredConcurrency - step,
             newConcurrency: this.#desiredConcurrency,
             systemStatus,
@@ -342,16 +340,16 @@ export class ConcurrencySystem {
     /**
      * Scales the system down by decreasing the desired concurrency by the scaleDownStepRatio.
      */
-    scaleDown(systemStatus) {
-        const step = Math.ceil(this.#desiredConcurrency * this.scaleDownStepRatio);
+    #scaleDown(systemStatus) {
+        const step = Math.ceil(this.#desiredConcurrency * this.#scaleDownStepRatio);
         this.#desiredConcurrency = Math.max(this.#minConcurrency, this.#desiredConcurrency - step);
-        this.log.debug('scaling down', {
+        this.#log.debug('scaling down', {
             oldConcurrency: this.#desiredConcurrency + step,
             newConcurrency: this.#desiredConcurrency,
             systemStatus,
         });
     }
-    incrementTasksDonePerSecond(intervalCallback) {
+    #incrementTasksDonePerSecond(intervalCallback) {
         this.#tasksPerMinute.unshift(0);
         this.#tasksPerMinute.pop();
         return intervalCallback();

package/internals/autoscaling/memory_load_signal.d.ts

@@ -42,6 +42,4 @@ export declare class MemoryLoadSignal implements LoadSignal {
     getSample(sampleDurationMillis?: number): LoadSnapshot[];
     /** @internal Records a snapshot from a `SYSTEM_INFO` payload. Exposed for tests. */
     handle(systemInfo: SystemInfo): void;
-    private memoryOverloadWarning;
-    private getTotalMemoryBytes;
 }

package/internals/autoscaling/memory_load_signal.js

@@ -51,7 +51,7 @@ export class MemoryLoadSignal {
                     'Use the CRAWLEE_MEMORY_MBYTES or CRAWLEE_AVAILABLE_MEMORY_RATIO environment variable to override it.');
             }
             // Fallback memory measurement in case memTotalBytes is missing from SystemInfo.
-            this.#maxMemoryBytes = await this.getTotalMemoryBytes();
+            this.#maxMemoryBytes = await this.#getTotalMemoryBytes();
         }
         this.#events.on(EventType.SYSTEM_INFO, this.handle);
     }
@@ -76,9 +76,9 @@ export class MemoryLoadSignal {
             usedBytes: memCurrentBytes,
         };
         this.#store.push(snapshot, createdAt);
-        this.memoryOverloadWarning(systemInfo, maxMemoryBytes);
+        this.#memoryOverloadWarning(systemInfo, maxMemoryBytes);
     }
-    memoryOverloadWarning(systemInfo, maxMemoryBytes) {
+    #memoryOverloadWarning(systemInfo, maxMemoryBytes) {
         const effectiveMax = maxMemoryBytes ?? this.#maxMemoryBytes;
         const { memCurrentBytes } = systemInfo;
         const createdAt = systemInfo.createdAt ? new Date(systemInfo.createdAt) : new Date();
@@ -97,7 +97,7 @@ export class MemoryLoadSignal {
             this.#lastLoggedCriticalMemoryOverloadAt = createdAt;
         }
     }
-    async getTotalMemoryBytes() {
+    async #getTotalMemoryBytes() {
         const containerized = this.#config.containerized ?? (await isContainerized());
         return (await getMemoryInfo({ containerized, logger: serviceLocator.getLogger() })).totalBytes;
     }

package/internals/autoscaling/system_status.d.ts

@@ -76,12 +76,6 @@ export declare class SystemStatus {
      * defaults.
      */
     get maxSampleWindowMillis(): number;
-    /**
-     * Signal names are the keys of the reported {@link SystemInfo}, so a duplicate would leave a status object that
-     * contradicts actual behavior: both signals are still evaluated (any overloaded one holds concurrency down), but
-     * only the last is reported.
-     */
-    private assertUniqueSignalNames;
     /**
      * Returns an {@link SystemInfo} object with the following structure:
      *
@@ -115,8 +109,4 @@ export declare class SystemStatus {
      * `historySecs` seconds and `true` otherwise.
      */
     getHistoricalStatus(): SystemInfo;
-    /**
-     * Returns a system status object.
-     */
-    private isSystemIdle;
 }

package/internals/autoscaling/system_status.js

@@ -40,7 +40,7 @@ export class SystemStatus {
         this.#currentHistoryMillis = currentHistorySecs * 1000;
         this.#historyMillis = historySecs * 1000;
         this.#signals = [...snapshotter.getLoadSignals(), ...loadSignals];
-        this.assertUniqueSignalNames();
+        this.#assertUniqueSignalNames();
     }
     /**
      * The widest window any signal will be queried with, and therefore exactly how much history the signals are asked
@@ -55,7 +55,7 @@ export class SystemStatus {
      * contradicts actual behavior: both signals are still evaluated (any overloaded one holds concurrency down), but
      * only the last is reported.
      */
-    assertUniqueSignalNames() {
+    #assertUniqueSignalNames() {
         const seen = new Set();
         for (const { name } of this.#signals) {
             if (!seen.has(name)) {
@@ -85,7 +85,7 @@ export class SystemStatus {
      * and `true` otherwise.
      */
     getCurrentStatus() {
-        return this.isSystemIdle(this.#currentHistoryMillis);
+        return this.#isSystemIdle(this.#currentHistoryMillis);
     }
     /**
      * Returns an {@link SystemInfo} object with the following structure:
@@ -103,12 +103,12 @@ export class SystemStatus {
      * `historySecs` seconds and `true` otherwise.
      */
     getHistoricalStatus() {
-        return this.isSystemIdle(this.#historyMillis);
+        return this.#isSystemIdle(this.#historyMillis);
     }
     /**
      * Returns a system status object.
      */
-    isSystemIdle(sampleDurationMillis) {
+    #isSystemIdle(sampleDurationMillis) {
         const result = {
             isSystemIdle: true,
             memInfo: { isOverloaded: false, limitRatio: 0, actualRatio: 0 },