nudge-ui 0.2.0

package/dist/project/files.d.ts

@@ -0,0 +1,19 @@
+export { isExcludedDirectoryName, isSensitiveProjectPath } from "./pathPolicy.js";
+export type ProjectFileChangeKind = "add" | "change" | "remove";
+export interface ProjectFileChange {
+    readonly absolutePath: string;
+    readonly kind: ProjectFileChangeKind;
+}
+export interface ProjectFileWatcherOptions {
+    readonly rootDirectory: string;
+    readonly debounceMs?: number;
+    readonly onSettled: (changes: readonly ProjectFileChange[]) => void | Promise<void>;
+    readonly onError?: (error: unknown) => void;
+}
+export interface ProjectFileWatcher {
+    /** Starts watching and resolves after the initial directory walk is ready. */
+    start(): Promise<void>;
+    close(): Promise<void>;
+}
+/** Creates a watcher that starts and stops explicitly with the server. */
+export declare function createProjectFileWatcher(options: ProjectFileWatcherOptions): ProjectFileWatcher;

package/dist/project/files.js

@@ -0,0 +1,226 @@
+/**
+ * Node's recursive `fs.watch` is not available on every supported platform, so
+ * this watches each directory and adds watches for ones created later. The
+ * public surface is lifecycle and settled batches; debounce and symlink
+ * confinement stay internal.
+ */
+import { watch } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { realpathSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { isExcludedDirectoryName, isSensitiveProjectPath } from "./pathPolicy.js";
+export { isExcludedDirectoryName, isSensitiveProjectPath } from "./pathPolicy.js";
+/** Creates a watcher that starts and stops explicitly with the server. */
+export function createProjectFileWatcher(options) {
+    const rootDirectory = realpathSync(resolve(options.rootDirectory));
+    const debounceMs = Math.max(0, options.debounceMs ?? 60);
+    const watches = new Map();
+    const pending = new Map();
+    let timer = null;
+    let scanQueue = Promise.resolve();
+    let pendingScans = 0;
+    let readyPromise = null;
+    let resolveReady = null;
+    let closed = false;
+    const reportError = (error) => {
+        options.onError?.(error);
+    };
+    const schedule = (absolutePath, wasRenamed = false) => {
+        if (closed || !isProjectPath(rootDirectory, absolutePath))
+            return;
+        const kind = classifyChange(absolutePath, wasRenamed);
+        const existing = pending.get(absolutePath);
+        pending.set(absolutePath, mergeChangeKind(existing, kind));
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(flush, debounceMs);
+    };
+    const flush = () => {
+        timer = null;
+        if (closed || pending.size === 0)
+            return;
+        const changes = [...pending.entries()]
+            .sort(([a], [b]) => comparePosixStrings(a, b))
+            .map(([absolutePath, kind]) => ({ absolutePath, kind }));
+        pending.clear();
+        void Promise.resolve(options.onSettled(changes)).catch(reportError);
+    };
+    const closeDirectory = (directory) => {
+        const entry = watches.get(directory);
+        if (!entry)
+            return;
+        watches.delete(directory);
+        entry.watcher.close();
+    };
+    const closeDescendants = (directory) => {
+        for (const watchedDirectory of [...watches.keys()]) {
+            if (watchedDirectory === directory || watchedDirectory.startsWith(`${directory}${sep}`)) {
+                closeDirectory(watchedDirectory);
+            }
+        }
+    };
+    const watchDirectory = (directory) => {
+        if (closed || !isProjectDirectory(rootDirectory, directory))
+            return;
+        const canonicalDirectory = canonicalProjectPath(rootDirectory, directory);
+        if (!canonicalDirectory || [...watches.values()].some((entry) => entry.canonicalDirectory === canonicalDirectory))
+            return;
+        let directoryWatcher;
+        try {
+            directoryWatcher = watch(directory, { persistent: true }, (eventType, filename) => {
+                const changedName = filename?.toString();
+                const changedPath = changedName ? join(directory, changedName) : directory;
+                if (!isProjectPath(rootDirectory, changedPath))
+                    return;
+                if (isProjectDirectory(rootDirectory, changedPath))
+                    watchDirectory(changedPath);
+                else if (!exists(changedPath))
+                    closeDescendants(changedPath);
+                schedule(changedPath, eventType === "rename");
+            });
+            directoryWatcher.on("error", reportError);
+        }
+        catch (error) {
+            reportError(error);
+            return;
+        }
+        watches.set(directory, { directory, canonicalDirectory, watcher: directoryWatcher });
+        // Watch before scanning so events during the async walk are not missed. Scans
+        // run serially and re-check `closed` after every await, so none leak past close().
+        pendingScans += 1;
+        scanQueue = scanQueue
+            .then(() => scanSubdirectories(directory))
+            .catch(reportError)
+            .finally(() => {
+            pendingScans -= 1;
+            if (pendingScans === 0)
+                resolveReady?.();
+        });
+    };
+    const scanSubdirectories = async (directory) => {
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => comparePosixStrings(a.name, b.name));
+        for (const entry of entries) {
+            if (closed)
+                return;
+            if (!entry.isDirectory() || isExcludedDirectoryName(entry.name))
+                continue;
+            const child = join(directory, entry.name);
+            if (!isProjectPath(rootDirectory, child))
+                continue;
+            watchDirectory(child);
+        }
+    };
+    return {
+        start: () => {
+            if (readyPromise)
+                return readyPromise;
+            if (closed)
+                return Promise.resolve();
+            readyPromise = new Promise((resolveReadyPromise) => {
+                resolveReady = resolveReadyPromise;
+            });
+            watchDirectory(rootDirectory);
+            if (pendingScans === 0)
+                resolveReady?.();
+            return readyPromise;
+        },
+        close: async () => {
+            if (closed)
+                return;
+            closed = true;
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            pending.clear();
+            for (const directory of [...watches.keys()])
+                closeDirectory(directory);
+            // Waiting on the serial queue keeps close() deterministic.
+            await scanQueue;
+        },
+    };
+}
+function mergeChangeKind(previous, next) {
+    if (!previous)
+        return next;
+    if (next === "remove")
+        return "remove";
+    if (next === "add")
+        return previous === "remove" ? "add" : previous;
+    if (previous === "remove")
+        return "change";
+    return "change";
+}
+function classifyChange(absolutePath, wasRenamed) {
+    if (!exists(absolutePath))
+        return "remove";
+    return wasRenamed ? "add" : "change";
+}
+function exists(path) {
+    try {
+        return statSync(path).isFile() || statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isProjectDirectory(rootDirectory, path) {
+    if (!isProjectPath(rootDirectory, path) || isExcludedDirectory(rootDirectory, path))
+        return false;
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isProjectPath(rootDirectory, path) {
+    if (!isWithin(rootDirectory, resolve(path)) || isExcludedDirectory(rootDirectory, path))
+        return false;
+    return canonicalProjectPath(rootDirectory, path) !== null;
+}
+function canonicalProjectPath(rootDirectory, path) {
+    try {
+        const canonical = realpathSync(path);
+        return isWithin(rootDirectory, canonical)
+            && !isSensitiveProjectPath(relative(rootDirectory, canonical).split(sep).join("/"))
+            ? canonical
+            : null;
+    }
+    catch {
+        const parent = dirname(path);
+        if (parent === path)
+            return null;
+        try {
+            const canonicalParent = realpathSync(parent);
+            return isWithin(rootDirectory, canonicalParent)
+                && !isSensitiveProjectPath(relative(rootDirectory, canonicalParent).split(sep).join("/"))
+                ? canonicalParent
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function isExcludedDirectory(rootDirectory, path) {
+    return relative(rootDirectory, resolve(path)).split(sep).some((segment) => isExcludedDirectoryName(segment));
+}
+function isWithin(rootDirectory, candidate) {
+    const pathFromRoot = relative(rootDirectory, candidate);
+    return pathFromRoot === ""
+        || (!pathFromRoot.startsWith(`..${sep}`)
+            && pathFromRoot !== ".."
+            && !isAbsolute(pathFromRoot));
+}
+/** Compares UTF-8 path bytes so ordering does not depend on the host locale. */
+function comparePosixStrings(a, b) {
+    return Buffer.from(a, "utf8").compare(Buffer.from(b, "utf8"));
+}

package/dist/project/identity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Names a project deterministically across restarts. The root is canonicalized
+ * first, so a symlinked working directory resolves to the same project — and
+ * therefore the same durable session — as its real path.
+ */
+export declare function createProjectId(host: string, root: string): string;

package/dist/project/identity.js

@@ -0,0 +1,19 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+const PROJECT_DIGEST_LENGTH = 24;
+/**
+ * Names a project deterministically across restarts. The root is canonicalized
+ * first, so a symlinked working directory resolves to the same project — and
+ * therefore the same durable session — as its real path.
+ */
+export function createProjectId(host, root) {
+    let canonical = root;
+    try {
+        canonical = realpathSync(root);
+    }
+    catch {
+        /* an unresolvable root keeps its textual form */
+    }
+    const digest = createHash("sha256").update(canonical).digest("hex").slice(0, PROJECT_DIGEST_LENGTH);
+    return `${host}:${digest}`;
+}

package/dist/project/pathPolicy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dot-prefixed segments commonly hold credentials, source-control metadata, or
+ * local tool state. Treating the whole segment as sensitive keeps one policy
+ * across direct requests, symlink targets, token discovery, and file watching.
+ */
+export declare function isSensitiveProjectPath(projectPath: string): boolean;
+/** Returns whether a directory name is outside the standalone project view. */
+export declare function isExcludedDirectoryName(name: string): boolean;

package/dist/project/pathPolicy.js

@@ -0,0 +1,12 @@
+/**
+ * Dot-prefixed segments commonly hold credentials, source-control metadata, or
+ * local tool state. Treating the whole segment as sensitive keeps one policy
+ * across direct requests, symlink targets, token discovery, and file watching.
+ */
+export function isSensitiveProjectPath(projectPath) {
+    return projectPath.split(/[\\/]/).some((segment) => segment.startsWith("."));
+}
+/** Returns whether a directory name is outside the standalone project view. */
+export function isExcludedDirectoryName(name) {
+    return name.startsWith(".") || name === "build" || name === "dist" || name === "node_modules";
+}

package/dist/project/tokens.d.ts

@@ -0,0 +1,36 @@
+import type { TokenCatalogDiagnostic, TokenDefinition, TokenEntry } from "../css/model/index.js";
+/** The serializable token knowledge published by the standalone manifest. */
+export interface ProjectTokenSnapshot {
+    readonly tokenCatalog: readonly TokenDefinition[];
+    readonly tokens: readonly TokenEntry[];
+    readonly tokenDiagnostics: readonly TokenCatalogDiagnostic[];
+    readonly tokenGeneration: string;
+}
+/** The placeholder used before and in place of a successful project scan. */
+export declare const EMPTY_PROJECT_TOKEN_SNAPSHOT: ProjectTokenSnapshot;
+/** A CSS file discovered below the project root before inventory parsing. */
+export interface ProjectCssArtifact {
+    readonly absolutePath: string;
+    readonly projectPath: string;
+    readonly content?: string;
+    readonly readError?: string;
+}
+/** Injectable so unreadable-file handling stays testable. */
+export type ProjectCssFileReader = (absolutePath: string) => string | Promise<string>;
+/** Options for the deterministic project CSS scan. */
+export interface ProjectTokenSnapshotOptions {
+    readonly rootDirectory: string;
+    /** Additional authored roots to include in the same deterministic inventory. */
+    readonly additionalRootDirectories?: readonly string[];
+    readonly readFile?: ProjectCssFileReader;
+    /** Prefixed to the digest so two hosts scanning one project publish distinct generations. */
+    readonly generationLabel: string;
+}
+/**
+ * Files are sorted by project-relative POSIX path before receiving
+ * discoveryOrder. Symlinks are followed only when their canonical target stays
+ * below rootDirectory. Read and parse failures become diagnostics, never rejections.
+ */
+export declare function createProjectTokenSnapshot(options: ProjectTokenSnapshotOptions): Promise<ProjectTokenSnapshot>;
+/** Exported as a seam so provenance and symlink confinement are testable without PostCSS. */
+export declare function discoverProjectCssArtifacts(rootDirectory: string, readFile?: ProjectCssFileReader): Promise<readonly ProjectCssArtifact[]>;

package/dist/project/tokens.js

@@ -0,0 +1,223 @@
+/**
+ * Node-only CSS token discovery for the static HTML host. Reports directory
+ * order as discovery evidence only: a directory walk cannot prove the order in
+ * which a browser applies stylesheets. Every filesystem operation is async so a
+ * large tree never blocks the server's event loop.
+ */
+import { createHash } from "node:crypto";
+import { readFile as readUtf8File, readdir, realpath, stat, } from "node:fs/promises";
+import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createTokenInventory, } from "../css/token-inventory/index.js";
+import { isExcludedDirectoryName, isSensitiveProjectPath } from "./pathPolicy.js";
+/** The placeholder used before and in place of a successful project scan. */
+export const EMPTY_PROJECT_TOKEN_SNAPSHOT = {
+    tokenCatalog: [],
+    tokens: [],
+    tokenDiagnostics: [],
+    tokenGeneration: "empty",
+};
+/**
+ * Files are sorted by project-relative POSIX path before receiving
+ * discoveryOrder. Symlinks are followed only when their canonical target stays
+ * below rootDirectory. Read and parse failures become diagnostics, never rejections.
+ */
+export async function createProjectTokenSnapshot(options) {
+    const rootDirectory = await canonicalRoot(options.rootDirectory);
+    const additionalRoots = (await Promise.all((options.additionalRootDirectories ?? []).map((directory) => canonicalOptionalRoot(directory)))).filter((root) => root !== null);
+    const scanRoots = [rootDirectory, ...additionalRoots.filter((root) => root !== rootDirectory)];
+    const discovered = await Promise.all(scanRoots.map((root) => discoverProjectCssArtifacts(root, options.readFile)));
+    const artifacts = [];
+    const seenFiles = new Set();
+    for (let index = 0; index < discovered.length; index += 1) {
+        for (const artifact of discovered[index] ?? []) {
+            const canonicalPath = await realpath(artifact.absolutePath).catch(() => artifact.absolutePath);
+            if (seenFiles.has(canonicalPath))
+                continue;
+            seenFiles.add(canonicalPath);
+            // Additional roots are expressed relative to the primary one so a single
+            // inventory can merge their declarations without losing provenance.
+            artifacts.push({
+                ...artifact,
+                projectPath: index === 0
+                    ? artifact.projectPath
+                    : relative(rootDirectory, artifact.absolutePath).split(sep).join("/"),
+            });
+        }
+    }
+    artifacts.sort((a, b) => comparePosixStrings(a.projectPath, b.projectPath));
+    const inventory = createTokenInventory();
+    for (const [discoveryOrder, artifact] of artifacts.entries()) {
+        const inventoryArtifact = {
+            buildTool: "static-html",
+            id: artifact.projectPath,
+            stage: "authored",
+            provenance: "project",
+            discoveryOrder,
+            ...(artifact.content !== undefined ? { content: artifact.content } : {}),
+            ...(artifact.readError ? {
+                diagnostics: [{
+                        code: "stylesheet-unreadable",
+                        message: `Stylesheet "${artifact.projectPath}" could not be read: ${artifact.readError}`,
+                        module: artifact.projectPath,
+                    }],
+            } : {}),
+        };
+        inventory.apply(inventoryArtifact);
+    }
+    const snapshot = inventory.snapshot();
+    const tokenGeneration = artifacts.length === 0
+        ? "empty"
+        : deterministicGeneration(artifacts, snapshot.generation, options.generationLabel);
+    return {
+        tokenCatalog: snapshot.definitions.map((definition) => ({
+            ...definition,
+            declarations: definition.declarations.map((declaration) => ({
+                id: declaration.id,
+                order: declaration.order,
+                value: declaration.value,
+                source: declaration.source,
+                important: declaration.important,
+                context: declaration.context,
+            })),
+        })),
+        tokens: snapshot.tokens,
+        tokenDiagnostics: snapshot.diagnostics.map(mapDiagnostic),
+        tokenGeneration,
+    };
+}
+/** Exported as a seam so provenance and symlink confinement are testable without PostCSS. */
+export async function discoverProjectCssArtifacts(rootDirectory, readFile = (absolutePath) => readUtf8File(absolutePath, "utf8")) {
+    const root = await canonicalRoot(rootDirectory);
+    const artifacts = [];
+    const visitedDirectories = new Set();
+    const visitedFiles = new Set();
+    await walkDirectory(root, root, visitedDirectories, visitedFiles, artifacts, readFile);
+    artifacts.sort((a, b) => comparePosixStrings(a.projectPath, b.projectPath));
+    return artifacts;
+}
+async function walkDirectory(rootDirectory, directory, visitedDirectories, visitedFiles, artifacts, readFile) {
+    const canonicalDirectoryPath = await canonicalWithinRoot(rootDirectory, directory);
+    if (!canonicalDirectoryPath || visitedDirectories.has(canonicalDirectoryPath))
+        return;
+    const projectDirectoryPath = relative(rootDirectory, directory).split(sep).join("/");
+    const canonicalProjectDirectoryPath = relative(rootDirectory, canonicalDirectoryPath)
+        .split(sep)
+        .join("/");
+    if (isSensitiveProjectPath(projectDirectoryPath)
+        || isSensitiveProjectPath(canonicalProjectDirectoryPath))
+        return;
+    visitedDirectories.add(canonicalDirectoryPath);
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    entries.sort((a, b) => comparePosixStrings(a.name, b.name));
+    for (const entry of entries) {
+        if (entry.isDirectory() && isExcludedDirectoryName(entry.name))
+            continue;
+        const absolutePath = join(directory, entry.name);
+        const canonicalPath = await canonicalWithinRoot(rootDirectory, absolutePath);
+        if (!canonicalPath)
+            continue;
+        let stats;
+        try {
+            stats = await stat(absolutePath);
+        }
+        catch {
+            continue;
+        }
+        if (stats.isDirectory()) {
+            if (isExcludedDirectoryName(entry.name))
+                continue;
+            await walkDirectory(rootDirectory, absolutePath, visitedDirectories, visitedFiles, artifacts, readFile);
+            continue;
+        }
+        if (!stats.isFile() || extname(entry.name).toLowerCase() !== ".css")
+            continue;
+        if (visitedFiles.has(canonicalPath))
+            continue;
+        visitedFiles.add(canonicalPath);
+        const projectPath = relative(rootDirectory, absolutePath).split(sep).join("/");
+        const canonicalProjectPath = relative(rootDirectory, canonicalPath).split(sep).join("/");
+        if (isSensitiveProjectPath(projectPath) || isSensitiveProjectPath(canonicalProjectPath)) {
+            continue;
+        }
+        try {
+            const content = await readFile(absolutePath);
+            artifacts.push({ absolutePath, projectPath, content });
+        }
+        catch (error) {
+            artifacts.push({
+                absolutePath,
+                projectPath,
+                readError: readErrorMessage(error),
+            });
+        }
+    }
+}
+async function canonicalRoot(rootDirectory) {
+    const root = await realpath(resolve(rootDirectory));
+    if (!(await stat(root)).isDirectory()) {
+        throw new Error(`Standalone root is not a directory: ${rootDirectory}`);
+    }
+    return root;
+}
+async function canonicalOptionalRoot(rootDirectory) {
+    try {
+        return await canonicalRoot(rootDirectory);
+    }
+    catch {
+        return null;
+    }
+}
+async function canonicalWithinRoot(rootDirectory, candidate) {
+    try {
+        const canonical = await realpath(candidate);
+        const pathFromRoot = relative(rootDirectory, canonical);
+        if (pathFromRoot === ""
+            || (!pathFromRoot.startsWith(`..${sep}`)
+                && pathFromRoot !== ".."
+                && !isAbsolute(pathFromRoot))) {
+            return canonical;
+        }
+    }
+    catch {
+        // A disappearing file is absent from this scan; read failures are handled above.
+    }
+    return null;
+}
+function readErrorMessage(error) {
+    if (typeof error === "object" && error !== null && "code" in error) {
+        const code = error.code;
+        if (typeof code === "string")
+            return code;
+    }
+    return "read failed";
+}
+function mapDiagnostic(diagnostic) {
+    return {
+        code: diagnostic.code,
+        message: diagnostic.message,
+        module: diagnostic.module ?? diagnostic.artifact ?? "standalone-css",
+        ...(diagnostic.exportName !== undefined ? { exportName: diagnostic.exportName } : {}),
+    };
+}
+function deterministicGeneration(artifacts, inventoryGeneration, label) {
+    const facts = artifacts.map((artifact) => JSON.stringify({
+        path: artifact.projectPath,
+        content: artifact.content,
+        readError: artifact.readError,
+    }));
+    const digest = createHash("sha256")
+        .update(`${facts.join("\n")}\n${inventoryGeneration}`)
+        .digest("hex")
+        .slice(0, 24);
+    return `${label}:${digest}`;
+}
+/** Compares UTF-8 path bytes so discovery is independent of the host locale. */
+function comparePosixStrings(a, b) {
+    return Buffer.from(a, "utf8").compare(Buffer.from(b, "utf8"));
+}

package/dist/transport/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The wire contract between any host and the browser client. Must stay
+ * browser-safe: the inspector's mount components import these routes directly.
+ * Anything needing Node belongs in `project/`.
+ */
+export * from "./routes.js";
+/** Envelope version understood by the browser client. */
+export declare const NUDGE_UI_MANIFEST_VERSION = 1;

package/dist/transport/index.js

@@ -0,0 +1,8 @@
+/**
+ * The wire contract between any host and the browser client. Must stay
+ * browser-safe: the inspector's mount components import these routes directly.
+ * Anything needing Node belongs in `project/`.
+ */
+export * from "./routes.js";
+/** Envelope version understood by the browser client. */
+export const NUDGE_UI_MANIFEST_VERSION = 1;

package/dist/transport/routes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The reserved URL namespace every host serves the inspector through. Hosts
+ * own their own middleware and reload policy, but the paths are one contract:
+ * the browser client is built once and requests the same URLs everywhere.
+ */
+/** A host must not serve project files here. */
+export declare const NUDGE_UI_ROUTE_PREFIX = "/__nudge_ui__/";
+export declare const NUDGE_UI_MANIFEST_PATH = "/__nudge_ui__/manifest";
+export declare const NUDGE_UI_CLIENT_PATH = "/__nudge_ui__/client.mjs";
+/** Server-sent events announcing settled project changes. */
+export declare const NUDGE_UI_RELOAD_PATH = "/__nudge_ui__/reload";
+export declare const NUDGE_UI_MOUNT_ID = "nudge-ui-root";
+export declare function isReservedNudgeUiRoute(pathname: string): boolean;

package/dist/transport/routes.js

@@ -0,0 +1,16 @@
+/**
+ * The reserved URL namespace every host serves the inspector through. Hosts
+ * own their own middleware and reload policy, but the paths are one contract:
+ * the browser client is built once and requests the same URLs everywhere.
+ */
+/** A host must not serve project files here. */
+export const NUDGE_UI_ROUTE_PREFIX = "/__nudge_ui__/";
+export const NUDGE_UI_MANIFEST_PATH = `${NUDGE_UI_ROUTE_PREFIX}manifest`;
+export const NUDGE_UI_CLIENT_PATH = `${NUDGE_UI_ROUTE_PREFIX}client.mjs`;
+/** Server-sent events announcing settled project changes. */
+export const NUDGE_UI_RELOAD_PATH = `${NUDGE_UI_ROUTE_PREFIX}reload`;
+export const NUDGE_UI_MOUNT_ID = "nudge-ui-root";
+export function isReservedNudgeUiRoute(pathname) {
+    return pathname === NUDGE_UI_ROUTE_PREFIX.slice(0, -1)
+        || pathname.startsWith(NUDGE_UI_ROUTE_PREFIX);
+}