@babylonjs-toolkit/server 0.0.0-stage → 9.35.1

package/lib/admin/ExtensionRoutes.js

@@ -0,0 +1,145 @@
+// The extensions and docs routes (game-server-admin-console DR §6.11 extensions/* and docs rows, D25): the custom
+// actions and panels a caller may use, running an action with its own permission, a panel's content, and the package's
+// README, DEPLOY and CUSTOM documents for the console's help pages.
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { AdminRequestError } from "./AdminApiRouter.js";
+import { bodyObject } from "./AdminRequestBodies.js";
+/** HTTP status of a successful answer. */
+const HTTP_OK = 200;
+/** HTTP statuses of the refusals. */
+const HTTP_BAD_REQUEST = 400;
+const HTTP_UNAUTHORIZED = 401;
+const HTTP_NOT_FOUND = 404;
+/** The package root (SVR/), two folders above lib/admin/. */
+const PACKAGE_ROOT = new URL("../../", import.meta.url);
+/** The documents GET docs/:documentName may read. */
+const READABLE_DOCUMENTS = new Set(["README.md", "DEPLOY.md", "CUSTOM.md"]);
+/**
+ * Registers the extensions/* and docs routes.
+ * @param router The admin API router.
+ * @param services The shared services.
+ */
+export function registerExtensionRoutes(router, services) {
+    const routes = [
+        { method: "GET", pattern: "extensions", permission: "signedIn", requiresStepUp: false, auditAction: null, handler: async (request) => ok(services.extensions.listFor(requireCaller(request))) },
+        {
+            method: "POST",
+            pattern: "extensions/actions/:actionName",
+            permission: (request) => services.extensions.permissionFor(request.params.actionName),
+            requiresStepUp: false,
+            auditAction: (request) => "extension." + request.params.actionName,
+            handler: async (request) => runAction(services, request)
+        },
+        { method: "GET", pattern: "extensions/panels/:panelName", permission: "signedIn", requiresStepUp: false, auditAction: null, handler: async (request) => ok(await services.extensions.panel(request.params.panelName, targetIdsOfQuery(request.query))) },
+        { method: "GET", pattern: "docs/:documentName", permission: "signedIn", requiresStepUp: false, auditAction: null, handler: async (request) => ok(await readDocument(request.params.documentName)) }
+    ];
+    for (const route of routes)
+        router.register(route);
+}
+/**
+ * A 200 answer.
+ * @param body The JSON body.
+ * @returns The result.
+ */
+function ok(body) {
+    return { status: HTTP_OK, body: body };
+}
+/**
+ * POST extensions/actions/:actionName: runs the action; the audit record has its inputs without secret fields.
+ * @param services The shared services.
+ * @param request The request.
+ * @returns The action's outcome.
+ */
+async function runAction(services, request) {
+    const body = bodyObject(request.body);
+    const target = targetIdsOfBody(body.target);
+    const inputs = bodyObject(body.inputs);
+    const actionName = request.params.actionName;
+    const result = await services.extensions.run(actionName, target, inputs, requireCaller(request));
+    const parameters = { target: target, inputs: services.extensions.auditParametersOf(actionName, inputs), ok: result.ok };
+    return { status: HTTP_OK, body: result, audit: { target: auditTargetOf(target, actionName), parameters: parameters } };
+}
+/**
+ * GET docs/:documentName: one of the package's documents.
+ * @param documentName README.md, DEPLOY.md or CUSTOM.md.
+ * @returns The markdown.
+ * @throws AdminRequestError 404 for another name or a missing file.
+ */
+async function readDocument(documentName) {
+    if (!READABLE_DOCUMENTS.has(documentName))
+        throw new AdminRequestError(HTTP_NOT_FOUND, "no such document");
+    try {
+        const markdown = await readFile(fileURLToPath(new URL(documentName, PACKAGE_ROOT)), "utf8");
+        return { markdown: markdown };
+    }
+    catch {
+        throw new AdminRequestError(HTTP_NOT_FOUND, "no such document");
+    }
+}
+/**
+ * The caller of a route that needs one (the router has checked it).
+ * @param request The request.
+ * @returns The caller.
+ * @throws AdminRequestError 401 without one.
+ */
+function requireCaller(request) {
+    if (request.caller == null)
+        throw new AdminRequestError(HTTP_UNAUTHORIZED, "sign in first");
+    return request.caller;
+}
+/**
+ * The target ids of an action body.
+ * @param value body.target.
+ * @returns The ids (only the known, well-typed ones).
+ * @throws AdminRequestError 400 when it is not an object.
+ */
+function targetIdsOfBody(value) {
+    if (value == null)
+        return {};
+    if (typeof value !== "object" || Array.isArray(value))
+        throw new AdminRequestError(HTTP_BAD_REQUEST, "target must be an object");
+    const fields = value;
+    const target = {};
+    if (typeof fields.processId === "string")
+        target.processId = fields.processId;
+    if (typeof fields.roomId === "string")
+        target.roomId = fields.roomId;
+    if (typeof fields.playerId === "number")
+        target.playerId = fields.playerId;
+    if (typeof fields.userId === "string" || fields.userId === null)
+        target.userId = fields.userId;
+    return target;
+}
+/**
+ * The target ids of a panel query (processId, roomId, playerId, userId).
+ * @param query The query.
+ * @returns The ids.
+ */
+function targetIdsOfQuery(query) {
+    const target = {};
+    const processId = query.get("processId");
+    const roomId = query.get("roomId");
+    const playerId = Number(query.get("playerId"));
+    const userId = query.get("userId");
+    if (processId != null)
+        target.processId = processId;
+    if (roomId != null)
+        target.roomId = roomId;
+    if (query.has("playerId") && Number.isInteger(playerId))
+        target.playerId = playerId;
+    if (userId != null)
+        target.userId = userId;
+    return target;
+}
+/**
+ * The audit target of an action call: the most specific target id, or "server".
+ * @param target The target ids.
+ * @param actionName The action (the target of a server action).
+ * @returns The target text.
+ */
+function auditTargetOf(target, actionName) {
+    if (target.roomId != null && target.playerId != null)
+        return target.roomId + "/" + target.playerId;
+    return target.roomId ?? target.processId ?? actionName;
+}

package/lib/admin/FileAdminStore.d.ts

@@ -0,0 +1,157 @@
+import { type AdminClock } from "./AdminClock.js";
+import { type AdminCollection, type ChainedRecordBuilder, type AdminStore, type AdminStream, type RecordQuery, type StoredDocument, type StoredRecord } from "./AdminStore.js";
+/** Admin data in JSON files (single instance, D7). */
+export declare class FileAdminStore implements AdminStore {
+    /** Always "file". */
+    readonly kind: "file";
+    /** False when the folder sits on a container's own filesystem, so its data is lost on restart. */
+    readonly isPersistent: boolean;
+    /** The absolute data folder. */
+    private readonly rootFolder;
+    /** The clock of `updatedAt` and `at`. */
+    private readonly clock;
+    /** The pending write of each file, so writes to one file run one at a time. */
+    private readonly writeChains;
+    /** The cached last sequence of each stream. */
+    private readonly streamPositions;
+    /**
+     * Opens the store; nothing is read or created yet.
+     * @param dataDir The data folder (relative to the working directory).
+     * @param clock The clock of stored times.
+     */
+    constructor(dataDir: string, clock?: AdminClock);
+    /**
+     * Reads one document.
+     * @param collection The collection.
+     * @param documentId The document id.
+     * @returns The document, or null.
+     */
+    getDocument<Value>(collection: AdminCollection, documentId: string): Promise<StoredDocument<Value> | null>;
+    /**
+     * Reads every document of a collection.
+     * @param collection The collection.
+     * @returns The documents.
+     */
+    listDocuments<Value>(collection: AdminCollection): Promise<StoredDocument<Value>[]>;
+    /**
+     * Writes a document after checking its revision.
+     * @param collection The collection.
+     * @param documentId The document id.
+     * @param value The document.
+     * @param expectedRevision The revision read, or null for no check.
+     * @returns The stored document.
+     * @throws AdminConflictError on a stale expectedRevision.
+     */
+    putDocument<Value>(collection: AdminCollection, documentId: string, value: Value, expectedRevision: number | null): Promise<StoredDocument<Value>>;
+    /**
+     * Deletes a document.
+     * @param collection The collection.
+     * @param documentId The document id.
+     * @returns True when it existed.
+     */
+    deleteDocument(collection: AdminCollection, documentId: string): Promise<boolean>;
+    /**
+     * Appends a record with the stream's next sequence.
+     * @param stream The stream.
+     * @param value The record.
+     * @returns The stored record.
+     */
+    appendRecord<Value>(stream: AdminStream, value: Value): Promise<StoredRecord<Value>>;
+    /**
+     * Appends a record built from the newest one; the per-file write chain makes it atomic in this process (R21).
+     * @param stream The stream.
+     * @param build Builds the value.
+     * @returns The stored record.
+     */
+    appendChainedRecord<Value>(stream: AdminStream, build: ChainedRecordBuilder<Value>): Promise<StoredRecord<Value>>;
+    /**
+     * Appends a built record after the pending writes of its file.
+     * @param stream The stream.
+     * @param build Builds the value.
+     * @param needsPrevious True to read the newest record for the builder (chained appends); plain appends skip the read.
+     * @returns The stored record.
+     */
+    private appendBuilt;
+    /**
+     * Reads records of a stream.
+     * @param stream The stream.
+     * @param query The range, limit and order.
+     * @returns The records.
+     */
+    readRecords<Value>(stream: AdminStream, query: RecordQuery): Promise<StoredRecord<Value>[]>;
+    /**
+     * Removes records appended before the cutoff.
+     * @param stream The stream.
+     * @param cutoff The oldest time kept.
+     * @returns How many were removed.
+     */
+    trimRecordsBefore(stream: AdminStream, cutoff: Date): Promise<number>;
+    /**
+     * Keeps only the newest records.
+     * @param stream The stream.
+     * @param keepCount How many to keep.
+     * @returns How many were removed.
+     */
+    trimRecordsToCount(stream: AdminStream, keepCount: number): Promise<number>;
+    /**
+     * A file store serves one instance, so its holder always holds every lease.
+     * @returns True.
+     */
+    tryAcquireLease(): Promise<boolean>;
+    /** Waits for pending writes; nothing else is held open. */
+    close(): Promise<void>;
+    /**
+     * Runs a task after the pending writes of one file, so a read-modify-write never interleaves with another.
+     * @param fileKey The file the task writes.
+     * @param task The task.
+     * @returns The task's result.
+     */
+    private serialize;
+    /**
+     * Reads a collection file (empty when it does not exist yet).
+     * @param collection The collection.
+     * @returns Document id → entry.
+     */
+    private readCollection;
+    /**
+     * Writes a collection file atomically: a temporary file renamed over the old one.
+     * @param collection The collection.
+     * @param entries Document id → entry.
+     */
+    private writeCollection;
+    /**
+     * Reads every record of a stream, oldest first.
+     * @param stream The stream.
+     * @returns The records.
+     */
+    private readStream;
+    /**
+     * Replaces a stream's records with a filtered list, remembering the last sequence so it never restarts.
+     * @param stream The stream.
+     * @param keep Picks the records kept from the oldest-first list.
+     * @returns How many were removed.
+     */
+    private rewriteStream;
+    /**
+     * The last sequence of a stream: cached while the file is as this store left it, else read from the file (the CLI
+     * may have appended) and the sequence file of an earlier trim.
+     * @param stream The stream.
+     * @returns The last sequence, or 0 for a new stream.
+     */
+    private lastSequence;
+    /**
+     * @param collection The collection.
+     * @returns The path of its file.
+     */
+    private collectionFile;
+    /**
+     * @param stream The stream.
+     * @returns The path of its file (the name is URI-encoded, since metrics streams contain a colon).
+     */
+    private streamFile;
+    /**
+     * @param stream The stream.
+     * @returns The path of its sequence file.
+     */
+    private sequenceFile;
+}

package/lib/admin/FileAdminStore.js

@@ -0,0 +1,349 @@
+// The file backend of the admin store (game-server-admin-console D7, DR §6.1): one JSON file per collection and one
+// JSON-lines file per stream under admin.dataDir. It creates nothing until its first write (R3).
+import { existsSync, statSync } from "node:fs";
+import { appendFile, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { SYSTEM_CLOCK } from "./AdminClock.js";
+import { AdminConflictError, clampRecordLimit } from "./AdminStore.js";
+/** Folder of the collection files. */
+const COLLECTIONS_FOLDER = "collections";
+/** Folder of the stream files. */
+const STREAMS_FOLDER = "streams";
+/** Extension of a collection file. */
+const COLLECTION_EXTENSION = ".json";
+/** Extension of a stream file. */
+const STREAM_EXTENSION = ".jsonl";
+/** Extension of the file that remembers a stream's last sequence after a trim emptied it. */
+const SEQUENCE_EXTENSION = ".seq";
+/** Marker file Docker creates in every container. */
+const DOCKER_MARKER_FILE = "/.dockerenv";
+/** Environment variable Kubernetes sets in every pod. */
+const KUBERNETES_VARIABLE = "KUBERNETES_SERVICE_HOST";
+/** The container's own root folder. */
+const FILESYSTEM_ROOT = "/";
+/** Node's error code of a missing file. */
+const FILE_MISSING_CODE = "ENOENT";
+/** Admin data in JSON files (single instance, D7). */
+export class FileAdminStore {
+    /** Always "file". */
+    kind = "file";
+    /** False when the folder sits on a container's own filesystem, so its data is lost on restart. */
+    isPersistent;
+    /** The absolute data folder. */
+    rootFolder;
+    /** The clock of `updatedAt` and `at`. */
+    clock;
+    /** The pending write of each file, so writes to one file run one at a time. */
+    writeChains = new Map();
+    /** The cached last sequence of each stream. */
+    streamPositions = new Map();
+    /**
+     * Opens the store; nothing is read or created yet.
+     * @param dataDir The data folder (relative to the working directory).
+     * @param clock The clock of stored times.
+     */
+    constructor(dataDir, clock = SYSTEM_CLOCK) {
+        this.rootFolder = path.resolve(dataDir);
+        this.clock = clock;
+        this.isPersistent = !(isInsideContainer() && isOnContainerFilesystem(this.rootFolder));
+    }
+    /**
+     * Reads one document.
+     * @param collection The collection.
+     * @param documentId The document id.
+     * @returns The document, or null.
+     */
+    async getDocument(collection, documentId) {
+        const entries = await this.readCollection(collection);
+        const entry = entries[documentId];
+        return (entry != null) ? toDocument(documentId, entry) : null;
+    }
+    /**
+     * Reads every document of a collection.
+     * @param collection The collection.
+     * @returns The documents.
+     */
+    async listDocuments(collection) {
+        const entries = await this.readCollection(collection);
+        return Object.entries(entries).map(([documentId, entry]) => toDocument(documentId, entry));
+    }
+    /**
+     * Writes a document after checking its revision.
+     * @param collection The collection.
+     * @param documentId The document id.
+     * @param value The document.
+     * @param expectedRevision The revision read, or null for no check.
+     * @returns The stored document.
+     * @throws AdminConflictError on a stale expectedRevision.
+     */
+    putDocument(collection, documentId, value, expectedRevision) {
+        return this.serialize(this.collectionFile(collection), async () => {
+            const entries = await this.readCollection(collection);
+            const current = entries[documentId];
+            const currentRevision = current?.revision ?? 0;
+            if (expectedRevision != null && expectedRevision !== currentRevision) {
+                throw new AdminConflictError((current != null) ? toDocument(documentId, current) : null);
+            }
+            const entry = { revision: currentRevision + 1, updatedAt: new Date(this.clock.now()).toISOString(), value: value };
+            entries[documentId] = entry;
+            await this.writeCollection(collection, entries);
+            return toDocument(documentId, entry);
+        });
+    }
+    /**
+     * Deletes a document.
+     * @param collection The collection.
+     * @param documentId The document id.
+     * @returns True when it existed.
+     */
+    deleteDocument(collection, documentId) {
+        return this.serialize(this.collectionFile(collection), async () => {
+            const entries = await this.readCollection(collection);
+            if (entries[documentId] == null)
+                return false;
+            delete entries[documentId];
+            await this.writeCollection(collection, entries);
+            return true;
+        });
+    }
+    /**
+     * Appends a record with the stream's next sequence.
+     * @param stream The stream.
+     * @param value The record.
+     * @returns The stored record.
+     */
+    appendRecord(stream, value) {
+        return this.appendBuilt(stream, () => value, false);
+    }
+    /**
+     * Appends a record built from the newest one; the per-file write chain makes it atomic in this process (R21).
+     * @param stream The stream.
+     * @param build Builds the value.
+     * @returns The stored record.
+     */
+    appendChainedRecord(stream, build) {
+        return this.appendBuilt(stream, build, true);
+    }
+    /**
+     * Appends a built record after the pending writes of its file.
+     * @param stream The stream.
+     * @param build Builds the value.
+     * @param needsPrevious True to read the newest record for the builder (chained appends); plain appends skip the read.
+     * @returns The stored record.
+     */
+    appendBuilt(stream, build, needsPrevious) {
+        const filePath = this.streamFile(stream);
+        return this.serialize(filePath, async () => {
+            const lastSequence = await this.lastSequence(stream);
+            const records = needsPrevious ? await this.readStream(stream) : [];
+            const previous = (records.length > 0) ? records[records.length - 1] : null;
+            const sequence = lastSequence + 1;
+            const at = new Date(this.clock.now()).toISOString();
+            const record = { sequence: sequence, at: at, value: build(previous, sequence, at) };
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await appendFile(filePath, JSON.stringify(record) + "\n", "utf8");
+            const fileStats = await stat(filePath);
+            this.streamPositions.set(stream, { sequence: record.sequence, byteLength: fileStats.size });
+            return record;
+        });
+    }
+    /**
+     * Reads records of a stream.
+     * @param stream The stream.
+     * @param query The range, limit and order.
+     * @returns The records.
+     */
+    async readRecords(stream, query) {
+        // Appends are not atomic, so reads wait for them and never see half a line.
+        const records = await this.serialize(this.streamFile(stream), () => this.readStream(stream));
+        const inRange = records.filter((record) => (query.afterSequence == null || record.sequence > query.afterSequence) && (query.beforeSequence == null || record.sequence < query.beforeSequence));
+        if (query.newestFirst)
+            inRange.reverse();
+        return inRange.slice(0, clampRecordLimit(query.limit));
+    }
+    /**
+     * Removes records appended before the cutoff.
+     * @param stream The stream.
+     * @param cutoff The oldest time kept.
+     * @returns How many were removed.
+     */
+    trimRecordsBefore(stream, cutoff) {
+        const cutoffMilliseconds = cutoff.getTime();
+        return this.rewriteStream(stream, (records) => records.filter((record) => Date.parse(record.at) >= cutoffMilliseconds));
+    }
+    /**
+     * Keeps only the newest records.
+     * @param stream The stream.
+     * @param keepCount How many to keep.
+     * @returns How many were removed.
+     */
+    trimRecordsToCount(stream, keepCount) {
+        return this.rewriteStream(stream, (records) => records.slice(Math.max(0, records.length - Math.max(0, keepCount))));
+    }
+    /**
+     * A file store serves one instance, so its holder always holds every lease.
+     * @returns True.
+     */
+    async tryAcquireLease() {
+        return true;
+    }
+    /** Waits for pending writes; nothing else is held open. */
+    async close() {
+        await Promise.all(Array.from(this.writeChains.values()));
+    }
+    /**
+     * Runs a task after the pending writes of one file, so a read-modify-write never interleaves with another.
+     * @param fileKey The file the task writes.
+     * @param task The task.
+     * @returns The task's result.
+     */
+    serialize(fileKey, task) {
+        const previous = this.writeChains.get(fileKey) ?? Promise.resolve();
+        const next = previous.then(task, task);
+        this.writeChains.set(fileKey, next.catch(() => undefined));
+        return next;
+    }
+    /**
+     * Reads a collection file (empty when it does not exist yet).
+     * @param collection The collection.
+     * @returns Document id → entry.
+     */
+    async readCollection(collection) {
+        const text = await readTextIfPresent(this.collectionFile(collection));
+        return (text != null) ? JSON.parse(text) : {};
+    }
+    /**
+     * Writes a collection file atomically: a temporary file renamed over the old one.
+     * @param collection The collection.
+     * @param entries Document id → entry.
+     */
+    async writeCollection(collection, entries) {
+        await writeFileAtomically(this.collectionFile(collection), JSON.stringify(entries, null, 2));
+    }
+    /**
+     * Reads every record of a stream, oldest first.
+     * @param stream The stream.
+     * @returns The records.
+     */
+    async readStream(stream) {
+        const text = await readTextIfPresent(this.streamFile(stream));
+        if (text == null)
+            return [];
+        return text.split("\n").filter((line) => line.trim() !== "").map((line) => JSON.parse(line));
+    }
+    /**
+     * Replaces a stream's records with a filtered list, remembering the last sequence so it never restarts.
+     * @param stream The stream.
+     * @param keep Picks the records kept from the oldest-first list.
+     * @returns How many were removed.
+     */
+    rewriteStream(stream, keep) {
+        const filePath = this.streamFile(stream);
+        return this.serialize(filePath, async () => {
+            const records = await this.readStream(stream);
+            const kept = keep(records);
+            const removedCount = records.length - kept.length;
+            if (removedCount === 0)
+                return 0;
+            const lastSequence = await this.lastSequence(stream);
+            await writeFileAtomically(this.sequenceFile(stream), String(lastSequence));
+            await writeFileAtomically(filePath, kept.map((record) => JSON.stringify(record) + "\n").join(""));
+            const fileStats = await stat(filePath);
+            this.streamPositions.set(stream, { sequence: lastSequence, byteLength: fileStats.size });
+            return removedCount;
+        });
+    }
+    /**
+     * The last sequence of a stream: cached while the file is as this store left it, else read from the file (the CLI
+     * may have appended) and the sequence file of an earlier trim.
+     * @param stream The stream.
+     * @returns The last sequence, or 0 for a new stream.
+     */
+    async lastSequence(stream) {
+        const filePath = this.streamFile(stream);
+        const cached = this.streamPositions.get(stream);
+        const currentSize = existsSync(filePath) ? (await stat(filePath)).size : 0;
+        if (cached != null && cached.byteLength === currentSize)
+            return cached.sequence;
+        const records = await this.readStream(stream);
+        const fileSequence = (records.length > 0) ? records[records.length - 1].sequence : 0;
+        const trimmedSequence = Number(await readTextIfPresent(this.sequenceFile(stream)) ?? 0);
+        return Math.max(fileSequence, trimmedSequence);
+    }
+    /**
+     * @param collection The collection.
+     * @returns The path of its file.
+     */
+    collectionFile(collection) {
+        return path.join(this.rootFolder, COLLECTIONS_FOLDER, collection + COLLECTION_EXTENSION);
+    }
+    /**
+     * @param stream The stream.
+     * @returns The path of its file (the name is URI-encoded, since metrics streams contain a colon).
+     */
+    streamFile(stream) {
+        return path.join(this.rootFolder, STREAMS_FOLDER, encodeURIComponent(stream) + STREAM_EXTENSION);
+    }
+    /**
+     * @param stream The stream.
+     * @returns The path of its sequence file.
+     */
+    sequenceFile(stream) {
+        return path.join(this.rootFolder, STREAMS_FOLDER, encodeURIComponent(stream) + SEQUENCE_EXTENSION);
+    }
+}
+/**
+ * Builds a document from a collection file entry.
+ * @param documentId The id.
+ * @param entry The entry.
+ * @returns The document.
+ */
+function toDocument(documentId, entry) {
+    return { id: documentId, revision: entry.revision, updatedAt: entry.updatedAt, value: entry.value };
+}
+/**
+ * Reads a text file.
+ * @param filePath The file.
+ * @returns Its text, or null when it does not exist.
+ * @throws Any read error other than a missing file.
+ */
+async function readTextIfPresent(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === FILE_MISSING_CODE)
+            return null;
+        throw error;
+    }
+}
+/**
+ * Writes a file through a temporary file and a rename, so a crash never leaves half a file.
+ * @param filePath The file.
+ * @param text Its new text.
+ */
+async function writeFileAtomically(filePath, text) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const temporaryPath = filePath + ".tmp-" + process.pid;
+    await writeFile(temporaryPath, text, "utf8");
+    await rename(temporaryPath, filePath);
+}
+/**
+ * Whether this process runs in a container (Docker or Kubernetes).
+ * @returns True inside a container.
+ */
+function isInsideContainer() {
+    return existsSync(DOCKER_MARKER_FILE) || process.env[KUBERNETES_VARIABLE] != null;
+}
+/**
+ * Whether a folder lives on the container's own filesystem rather than a mounted volume. The folder may not exist yet
+ * (R3), so its nearest existing parent is checked.
+ * @param folder The absolute folder.
+ * @returns True when it shares the root filesystem's device.
+ */
+function isOnContainerFilesystem(folder) {
+    let existing = folder;
+    while (!existsSync(existing) && path.dirname(existing) !== existing)
+        existing = path.dirname(existing);
+    return statSync(existing).dev === statSync(FILESYSTEM_ROOT).dev;
+}