@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/gateway/control-ui.js

@@ -1,35 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { resolveControlUiRootSync } from "../infra/control-ui-assets.js";
+import { isWithinDir } from "../infra/path-safety.js";
 import { DEFAULT_ASSISTANT_IDENTITY, resolveAssistantIdentity } from "./assistant-identity.js";
+import { CONTROL_UI_BOOTSTRAP_CONFIG_PATH, } from "./control-ui-contract.js";
+import { buildControlUiCspHeader } from "./control-ui-csp.js";
 import { buildControlUiAvatarUrl, CONTROL_UI_AVATAR_PREFIX, normalizeControlUiBasePath, resolveAssistantAvatarUrl, } from "./control-ui-shared.js";
 const ROOT_PREFIX = "/";
-function resolveControlUiRoot() {
-    const here = path.dirname(fileURLToPath(import.meta.url));
-    const execDir = (() => {
-        try {
-            return path.dirname(fs.realpathSync(process.execPath));
-        }
-        catch {
-            return null;
-        }
-    })();
-    const candidates = [
-        // Packaged app: control-ui lives alongside the executable.
-        execDir ? path.resolve(execDir, "control-ui") : null,
-        // Running from dist: dist/gateway/control-ui.js -> dist/control-ui
-        path.resolve(here, "../control-ui"),
-        // Running from source: src/gateway/control-ui.ts -> dist/control-ui
-        path.resolve(here, "../../dist/control-ui"),
-        // Fallback to cwd (dev)
-        path.resolve(process.cwd(), "dist", "control-ui"),
-    ].filter((dir) => Boolean(dir));
-    for (const dir of candidates) {
-        if (fs.existsSync(path.join(dir, "index.html")))
-            return dir;
-    }
-    return null;
-}
 function contentTypeForExt(ext) {
     switch (ext) {
         case ".html":
@@ -60,6 +37,33 @@ function contentTypeForExt(ext) {
             return "application/octet-stream";
     }
 }
+/**
+ * Extensions recognised as static assets.  Missing files with these extensions
+ * return 404 instead of the SPA index.html fallback.  `.html` is intentionally
+ * excluded — actual HTML files on disk are served earlier, and missing `.html`
+ * paths should fall through to the SPA router (client-side routers may use
+ * `.html`-suffixed routes).
+ */
+const STATIC_ASSET_EXTENSIONS = new Set([
+    ".js",
+    ".css",
+    ".json",
+    ".map",
+    ".svg",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".txt",
+]);
+function applyControlUiSecurityHeaders(res) {
+    res.setHeader("X-Frame-Options", "DENY");
+    res.setHeader("Content-Security-Policy", buildControlUiCspHeader());
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Referrer-Policy", "no-referrer");
+}
 function sendJson(res, status, body) {
     res.statusCode = status;
     res.setHeader("Content-Type", "application/json; charset=utf-8");
@@ -71,18 +75,22 @@ function isValidAgentId(agentId) {
 }
 export function handleControlUiAvatarRequest(req, res, opts) {
     const urlRaw = req.url;
-    if (!urlRaw)
+    if (!urlRaw) {
         return false;
-    if (req.method !== "GET" && req.method !== "HEAD")
+    }
+    if (req.method !== "GET" && req.method !== "HEAD") {
         return false;
+    }
     const url = new URL(urlRaw, "http://localhost");
     const basePath = normalizeControlUiBasePath(opts.basePath);
     const pathname = url.pathname;
     const pathWithBase = basePath
         ? `${basePath}${CONTROL_UI_AVATAR_PREFIX}/`
         : `${CONTROL_UI_AVATAR_PREFIX}/`;
-    if (!pathname.startsWith(pathWithBase))
+    if (!pathname.startsWith(pathWithBase)) {
         return false;
+    }
+    applyControlUiSecurityHeaders(res);
     const agentIdParts = pathname.slice(pathWithBase.length).split("/").filter(Boolean);
     const agentId = agentIdParts[0] ?? "";
     if (agentIdParts.length !== 1 || !agentId || !isValidAgentId(agentId)) {
@@ -119,66 +127,93 @@ function respondNotFound(res) {
     res.setHeader("Content-Type", "text/plain; charset=utf-8");
     res.end("Not Found");
 }
-function serveFile(res, filePath) {
+function setStaticFileHeaders(res, filePath) {
     const ext = path.extname(filePath).toLowerCase();
     res.setHeader("Content-Type", contentTypeForExt(ext));
     // Static UI should never be cached aggressively while iterating; allow the
     // browser to revalidate.
     res.setHeader("Cache-Control", "no-cache");
+}
+function serveFile(res, filePath) {
+    setStaticFileHeaders(res, filePath);
     res.end(fs.readFileSync(filePath));
 }
-function injectControlUiConfig(html, opts) {
-    const { basePath, assistantName, assistantAvatar } = opts;
-    const script = `<script>` +
-        `window.__CLAWDBOT_CONTROL_UI_BASE_PATH__=${JSON.stringify(basePath)};` +
-        `window.__CLAWDBOT_ASSISTANT_NAME__=${JSON.stringify(assistantName ?? DEFAULT_ASSISTANT_IDENTITY.name)};` +
-        `window.__CLAWDBOT_ASSISTANT_AVATAR__=${JSON.stringify(assistantAvatar ?? DEFAULT_ASSISTANT_IDENTITY.avatar)};` +
-        `</script>`;
-    // Check if already injected
-    if (html.includes("__CLAWDBOT_ASSISTANT_NAME__"))
-        return html;
-    const headClose = html.indexOf("</head>");
-    if (headClose !== -1) {
-        return `${html.slice(0, headClose)}${script}${html.slice(headClose)}`;
-    }
-    return `${script}${html}`;
+function serveResolvedFile(res, filePath, body) {
+    setStaticFileHeaders(res, filePath);
+    res.end(body);
 }
-function serveIndexHtml(res, indexPath, opts) {
-    const { basePath, config, agentId } = opts;
-    const identity = config
-        ? resolveAssistantIdentity({ cfg: config, agentId })
-        : DEFAULT_ASSISTANT_IDENTITY;
-    const resolvedAgentId = typeof identity.agentId === "string"
-        ? identity.agentId
-        : agentId;
-    const avatarValue = resolveAssistantAvatarUrl({
-        avatar: identity.avatar,
-        agentId: resolvedAgentId,
-        basePath,
-    }) ?? identity.avatar;
+function serveResolvedIndexHtml(res, body) {
     res.setHeader("Content-Type", "text/html; charset=utf-8");
     res.setHeader("Cache-Control", "no-cache");
-    const raw = fs.readFileSync(indexPath, "utf8");
-    res.end(injectControlUiConfig(raw, {
-        basePath,
-        assistantName: identity.name,
-        assistantAvatar: avatarValue,
-    }));
+    res.end(body);
+}
+function isContainedPath(baseDir, targetPath) {
+    const relative = path.relative(baseDir, targetPath);
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function isExpectedSafePathError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    return code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP";
+}
+function areSameFileIdentity(preOpen, opened) {
+    return preOpen.dev === opened.dev && preOpen.ino === opened.ino;
+}
+function resolveSafeControlUiFile(rootReal, filePath) {
+    let fd = null;
+    try {
+        const fileReal = fs.realpathSync(filePath);
+        if (!isContainedPath(rootReal, fileReal)) {
+            return null;
+        }
+        const preOpenStat = fs.lstatSync(fileReal);
+        if (!preOpenStat.isFile()) {
+            return null;
+        }
+        const openFlags = fs.constants.O_RDONLY |
+            (typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0);
+        fd = fs.openSync(fileReal, openFlags);
+        const openedStat = fs.fstatSync(fd);
+        // Compare inode identity so swaps between validation and open are rejected.
+        if (!openedStat.isFile() || !areSameFileIdentity(preOpenStat, openedStat)) {
+            return null;
+        }
+        const resolved = { path: fileReal, fd };
+        fd = null;
+        return resolved;
+    }
+    catch (error) {
+        if (isExpectedSafePathError(error)) {
+            return null;
+        }
+        throw error;
+    }
+    finally {
+        if (fd !== null) {
+            fs.closeSync(fd);
+        }
+    }
 }
 function isSafeRelativePath(relPath) {
-    if (!relPath)
+    if (!relPath) {
         return false;
+    }
     const normalized = path.posix.normalize(relPath);
-    if (normalized.startsWith("../") || normalized === "..")
+    if (path.posix.isAbsolute(normalized) || path.win32.isAbsolute(normalized)) {
         return false;
-    if (normalized.includes("\0"))
+    }
+    if (normalized.startsWith("../") || normalized === "..") {
+        return false;
+    }
+    if (normalized.includes("\0")) {
         return false;
+    }
     return true;
 }
 export function handleControlUiHttpRequest(req, res, opts) {
     const urlRaw = req.url;
-    if (!urlRaw)
+    if (!urlRaw) {
         return false;
+    }
     if (req.method !== "GET" && req.method !== "HEAD") {
         res.statusCode = 405;
         res.setHeader("Content-Type", "text/plain; charset=utf-8");
@@ -190,41 +225,104 @@ export function handleControlUiHttpRequest(req, res, opts) {
     const pathname = url.pathname;
     if (!basePath) {
         if (pathname === "/ui" || pathname.startsWith("/ui/")) {
+            applyControlUiSecurityHeaders(res);
             respondNotFound(res);
             return true;
         }
     }
     if (basePath) {
         if (pathname === basePath) {
+            applyControlUiSecurityHeaders(res);
             res.statusCode = 302;
             res.setHeader("Location", `${basePath}/${url.search}`);
             res.end();
             return true;
         }
-        if (!pathname.startsWith(`${basePath}/`))
+        if (!pathname.startsWith(`${basePath}/`)) {
             return false;
+        }
     }
-    const root = (() => {
-        if (opts?.root) {
-            if (opts.root.kind === "resolved")
-                return opts.root.path;
-            return null;
+    applyControlUiSecurityHeaders(res);
+    const bootstrapConfigPath = basePath
+        ? `${basePath}${CONTROL_UI_BOOTSTRAP_CONFIG_PATH}`
+        : CONTROL_UI_BOOTSTRAP_CONFIG_PATH;
+    if (pathname === bootstrapConfigPath) {
+        const config = opts?.config;
+        const identity = config
+            ? resolveAssistantIdentity({ cfg: config, agentId: opts?.agentId })
+            : DEFAULT_ASSISTANT_IDENTITY;
+        const avatarValue = resolveAssistantAvatarUrl({
+            avatar: identity.avatar,
+            agentId: identity.agentId,
+            basePath,
+        });
+        if (req.method === "HEAD") {
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.setHeader("Cache-Control", "no-cache");
+            res.end();
+            return true;
         }
-        return resolveControlUiRoot();
-    })();
+        sendJson(res, 200, {
+            basePath,
+            assistantName: identity.name,
+            assistantAvatar: avatarValue ?? identity.avatar,
+            assistantAgentId: identity.agentId,
+        });
+        return true;
+    }
+    const rootState = opts?.root;
+    if (rootState?.kind === "invalid") {
+        res.statusCode = 503;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end(`Control UI assets not found at ${rootState.path}. Build them with \`pnpm ui:build\` (auto-installs UI deps), or update gateway.controlUi.root.`);
+        return true;
+    }
+    if (rootState?.kind === "missing") {
+        res.statusCode = 503;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end("Control UI assets not found. Build them with `pnpm ui:build` (auto-installs UI deps), or run `pnpm ui:dev` during development.");
+        return true;
+    }
+    const root = rootState?.kind === "resolved"
+        ? rootState.path
+        : resolveControlUiRootSync({
+            moduleUrl: import.meta.url,
+            argv1: process.argv[1],
+            cwd: process.cwd(),
+        });
     if (!root) {
         res.statusCode = 503;
         res.setHeader("Content-Type", "text/plain; charset=utf-8");
         res.end("Control UI assets not found. Build them with `pnpm ui:build` (auto-installs UI deps), or run `pnpm ui:dev` during development.");
         return true;
     }
+    const rootReal = (() => {
+        try {
+            return fs.realpathSync(root);
+        }
+        catch (error) {
+            if (isExpectedSafePathError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    })();
+    if (!rootReal) {
+        res.statusCode = 503;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end("Control UI assets not found. Build them with `pnpm ui:build` (auto-installs UI deps), or run `pnpm ui:dev` during development.");
+        return true;
+    }
     const uiPath = basePath && pathname.startsWith(`${basePath}/`) ? pathname.slice(basePath.length) : pathname;
     const rel = (() => {
-        if (uiPath === ROOT_PREFIX)
+        if (uiPath === ROOT_PREFIX) {
             return "";
+        }
         const assetsIndex = uiPath.indexOf("/assets/");
-        if (assetsIndex >= 0)
+        if (assetsIndex >= 0) {
             return uiPath.slice(assetsIndex + 1);
+        }
         return uiPath.slice(1);
     })();
     const requested = rel && !rel.endsWith("/") ? rel : `${rel}index.html`;
@@ -233,32 +331,57 @@ export function handleControlUiHttpRequest(req, res, opts) {
         respondNotFound(res);
         return true;
     }
-    const filePath = path.join(root, fileRel);
-    if (!filePath.startsWith(root)) {
+    const filePath = path.resolve(root, fileRel);
+    if (!isWithinDir(root, filePath)) {
         respondNotFound(res);
         return true;
     }
-    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-        if (path.basename(filePath) === "index.html") {
-            serveIndexHtml(res, filePath, {
-                basePath,
-                config: opts?.config,
-                agentId: opts?.agentId,
-            });
+    const safeFile = resolveSafeControlUiFile(rootReal, filePath);
+    if (safeFile) {
+        try {
+            if (req.method === "HEAD") {
+                res.statusCode = 200;
+                setStaticFileHeaders(res, safeFile.path);
+                res.end();
+                return true;
+            }
+            if (path.basename(safeFile.path) === "index.html") {
+                serveResolvedIndexHtml(res, fs.readFileSync(safeFile.fd, "utf8"));
+                return true;
+            }
+            serveResolvedFile(res, safeFile.path, fs.readFileSync(safeFile.fd));
             return true;
         }
-        serveFile(res, filePath);
+        finally {
+            fs.closeSync(safeFile.fd);
+        }
+    }
+    // If the requested path looks like a static asset (known extension), return
+    // 404 rather than falling through to the SPA index.html fallback.  We check
+    // against the same set of extensions that contentTypeForExt() recognises so
+    // that dotted SPA routes (e.g. /user/jane.doe, /v2.0) still get the
+    // client-side router fallback.
+    if (STATIC_ASSET_EXTENSIONS.has(path.extname(fileRel).toLowerCase())) {
+        respondNotFound(res);
         return true;
     }
     // SPA fallback (client-side router): serve index.html for unknown paths.
     const indexPath = path.join(root, "index.html");
-    if (fs.existsSync(indexPath)) {
-        serveIndexHtml(res, indexPath, {
-            basePath,
-            config: opts?.config,
-            agentId: opts?.agentId,
-        });
-        return true;
+    const safeIndex = resolveSafeControlUiFile(rootReal, indexPath);
+    if (safeIndex) {
+        try {
+            if (req.method === "HEAD") {
+                res.statusCode = 200;
+                setStaticFileHeaders(res, safeIndex.path);
+                res.end();
+                return true;
+            }
+            serveResolvedIndexHtml(res, fs.readFileSync(safeIndex.fd, "utf8"));
+            return true;
+        }
+        finally {
+            fs.closeSync(safeIndex.fd);
+        }
     }
     respondNotFound(res);
     return true;

package/dist/gateway/events.js

@@ -0,0 +1 @@
+export const GATEWAY_EVENT_UPDATE_AVAILABLE = "update.available";

package/dist/gateway/hooks-mapping.js

@@ -15,16 +15,18 @@ const hookPresetMappings = {
     ],
 };
 const transformCache = new Map();
-export function resolveHookMappings(hooks) {
+export function resolveHookMappings(hooks, opts) {
     const presets = hooks?.presets ?? [];
     const gmailAllowUnsafe = hooks?.gmail?.allowUnsafeExternalContent;
     const mappings = [];
-    if (hooks?.mappings)
+    if (hooks?.mappings) {
         mappings.push(...hooks.mappings);
+    }
     for (const preset of presets) {
         const presetMappings = hookPresetMappings[preset];
-        if (!presetMappings)
+        if (!presetMappings) {
             continue;
+        }
         if (preset === "gmail" && typeof gmailAllowUnsafe === "boolean") {
             mappings.push(...presetMappings.map((mapping) => ({
                 ...mapping,
@@ -34,23 +36,26 @@ export function resolveHookMappings(hooks) {
         }
         mappings.push(...presetMappings);
     }
-    if (mappings.length === 0)
+    if (mappings.length === 0) {
         return [];
-    const configDir = path.dirname(CONFIG_PATH);
-    const transformsDir = hooks?.transformsDir
-        ? resolvePath(configDir, hooks.transformsDir)
-        : configDir;
+    }
+    const configDir = path.resolve(opts?.configDir ?? path.dirname(CONFIG_PATH));
+    const transformsRootDir = path.join(configDir, "hooks", "transforms");
+    const transformsDir = resolveOptionalContainedPath(transformsRootDir, hooks?.transformsDir, "Hook transformsDir");
     return mappings.map((mapping, index) => normalizeHookMapping(mapping, index, transformsDir));
 }
 export async function applyHookMappings(mappings, ctx) {
-    if (mappings.length === 0)
+    if (mappings.length === 0) {
         return null;
+    }
     for (const mapping of mappings) {
-        if (!mappingMatches(mapping, ctx))
+        if (!mappingMatches(mapping, ctx)) {
             continue;
+        }
         const base = buildActionFromMapping(mapping, ctx);
-        if (!base.ok)
+        if (!base.ok) {
             return base;
+        }
         let override = null;
         if (mapping.transform) {
             const transform = await loadTransform(mapping.transform);
@@ -59,11 +64,13 @@ export async function applyHookMappings(mappings, ctx) {
                 return { ok: true, action: null, skipped: true };
             }
         }
-        if (!base.action)
+        if (!base.action) {
             return { ok: true, action: null, skipped: true };
+        }
         const merged = mergeAction(base.action, override, mapping.action);
-        if (!merged.ok)
+        if (!merged.ok) {
             return merged;
+        }
         return merged;
     }
     return null;
@@ -76,7 +83,7 @@ function normalizeHookMapping(mapping, index, transformsDir) {
     const wakeMode = mapping.wakeMode ?? "now";
     const transform = mapping.transform
         ? {
-            modulePath: resolvePath(transformsDir, mapping.transform.module),
+            modulePath: resolveContainedPath(transformsDir, mapping.transform.module, "Hook transform"),
             exportName: mapping.transform.export?.trim() || undefined,
         }
         : undefined;
@@ -103,13 +110,15 @@ function normalizeHookMapping(mapping, index, transformsDir) {
 }
 function mappingMatches(mapping, ctx) {
     if (mapping.matchPath) {
-        if (mapping.matchPath !== normalizeMatchPath(ctx.path))
+        if (mapping.matchPath !== normalizeMatchPath(ctx.path)) {
             return false;
+        }
     }
     if (mapping.matchSource) {
         const source = typeof ctx.payload.source === "string" ? ctx.payload.source : undefined;
-        if (!source || source !== mapping.matchSource)
+        if (!source || source !== mapping.matchSource) {
             return false;
+        }
     }
     return true;
 }
@@ -149,7 +158,7 @@ function mergeAction(base, override, defaultAction) {
     if (!override) {
         return validateAction(base);
     }
-    const kind = (override.kind ?? base.kind ?? defaultAction);
+    const kind = override.kind ?? base.kind ?? defaultAction;
     if (kind === "wake") {
         const baseWake = base.kind === "wake" ? base : undefined;
         const text = typeof override.text === "string" ? override.text : (baseWake?.text ?? "");
@@ -190,13 +199,15 @@ function validateAction(action) {
     return { ok: true, action };
 }
 async function loadTransform(transform) {
-    const cached = transformCache.get(transform.modulePath);
-    if (cached)
+    const cacheKey = `${transform.modulePath}::${transform.exportName ?? "default"}`;
+    const cached = transformCache.get(cacheKey);
+    if (cached) {
         return cached;
+    }
     const url = pathToFileURL(transform.modulePath).href;
     const mod = (await import(url));
     const fn = resolveTransformFn(mod, transform.exportName);
-    transformCache.set(transform.modulePath, fn);
+    transformCache.set(cacheKey, fn);
     return fn;
 }
 function resolveTransformFn(mod, exportName) {
@@ -207,45 +218,73 @@ function resolveTransformFn(mod, exportName) {
     return candidate;
 }
 function resolvePath(baseDir, target) {
-    if (!target)
-        return baseDir;
-    if (path.isAbsolute(target))
-        return target;
-    return path.join(baseDir, target);
+    if (!target) {
+        return path.resolve(baseDir);
+    }
+    return path.isAbsolute(target) ? path.resolve(target) : path.resolve(baseDir, target);
+}
+function resolveContainedPath(baseDir, target, label) {
+    const base = path.resolve(baseDir);
+    const trimmed = target?.trim();
+    if (!trimmed) {
+        throw new Error(`${label} module path is required`);
+    }
+    const resolved = resolvePath(base, trimmed);
+    const relative = path.relative(base, resolved);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`${label} module path must be within ${base}: ${target}`);
+    }
+    return resolved;
+}
+function resolveOptionalContainedPath(baseDir, target, label) {
+    const trimmed = target?.trim();
+    if (!trimmed) {
+        return path.resolve(baseDir);
+    }
+    return resolveContainedPath(baseDir, trimmed, label);
 }
 function normalizeMatchPath(raw) {
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     return trimmed.replace(/^\/+/, "").replace(/\/+$/, "");
 }
 function renderOptional(value, ctx) {
-    if (!value)
+    if (!value) {
         return undefined;
+    }
     const rendered = renderTemplate(value, ctx).trim();
     return rendered ? rendered : undefined;
 }
 function renderTemplate(template, ctx) {
-    if (!template)
+    if (!template) {
         return "";
+    }
     return template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_, expr) => {
         const value = resolveTemplateExpr(expr.trim(), ctx);
-        if (value === undefined || value === null)
+        if (value === undefined || value === null) {
             return "";
-        if (typeof value === "string")
+        }
+        if (typeof value === "string") {
             return value;
-        if (typeof value === "number" || typeof value === "boolean")
+        }
+        if (typeof value === "number" || typeof value === "boolean") {
             return String(value);
+        }
         return JSON.stringify(value);
     });
 }
 function resolveTemplateExpr(expr, ctx) {
-    if (expr === "path")
+    if (expr === "path") {
         return ctx.path;
-    if (expr === "now")
+    }
+    if (expr === "now") {
         return new Date().toISOString();
+    }
     if (expr.startsWith("headers.")) {
         return getByPath(ctx.headers, expr.slice("headers.".length));
     }
@@ -257,9 +296,14 @@ function resolveTemplateExpr(expr, ctx) {
     }
     return getByPath(ctx.payload, expr);
 }
+// Block traversal into prototype-chain properties on attacker-controlled
+// webhook payloads.  Mirrors the same blocklist used by config-paths.ts
+// for config path traversal.
+const BLOCKED_PATH_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 function getByPath(input, pathExpr) {
-    if (!pathExpr)
+    if (!pathExpr) {
         return undefined;
+    }
     const parts = [];
     const re = /([^.[\]]+)|(\[(\d+)\])/g;
     let match = re.exec(pathExpr);
@@ -274,16 +318,22 @@ function getByPath(input, pathExpr) {
     }
     let current = input;
     for (const part of parts) {
-        if (current === null || current === undefined)
+        if (current === null || current === undefined) {
             return undefined;
+        }
         if (typeof part === "number") {
-            if (!Array.isArray(current))
+            if (!Array.isArray(current)) {
                 return undefined;
+            }
             current = current[part];
             continue;
         }
-        if (typeof current !== "object")
+        if (BLOCKED_PATH_KEYS.has(part)) {
+            return undefined;
+        }
+        if (typeof current !== "object") {
             return undefined;
+        }
         current = current[part];
     }
     return current;