@speedkit/cli 4.17.0 → 4.18.0

package/dist/services/onboarding/browser/baqend-response.d.ts

@@ -7,11 +7,6 @@ export declare class BaqendResponse implements Partial<Protocol.Fetch.FulfillReq
     private readonly contentType;
     private readonly contentLength;
     constructor(body: string | Buffer, contentType?: string, headers?: Protocol.Fetch.HeaderEntry[], status?: number);
-    /**
-     * Epoch ms parsed from the `last-modified` header (set when the response was
-     * built), or 0 if absent/unparseable. Used to order cache entries by recency.
-     */
-    getLastModified(): number;
     setHeader(name: string, value: string): void;
     protected addCustomHeaders(headers?: Protocol.Fetch.HeaderEntry[]): Protocol.Fetch.HeaderEntry[];
 }

package/dist/services/onboarding/browser/baqend-response.js

@@ -23,15 +23,6 @@ export class BaqendResponse {
             ? body.toString("base64")
             : Buffer.from(body).toString("base64");
     }
-    /**
-     * Epoch ms parsed from the `last-modified` header (set when the response was
-     * built), or 0 if absent/unparseable. Used to order cache entries by recency.
-     */
-    getLastModified() {
-        const header = this.responseHeaders.find((h) => h.name.toLowerCase() === "last-modified");
-        const timestamp = header ? Date.parse(header.value) : NaN;
-        return Number.isNaN(timestamp) ? 0 : timestamp;
-    }
     setHeader(name, value) {
         for (const header of this.responseHeaders) {
             if (header.name === name) {

package/dist/services/onboarding/file-events/file-watcher.d.ts

@@ -20,10 +20,10 @@ export declare class FileWatcher {
     setCacheRefresher(cacheRefresher: VirtualOrestesApp): void;
     /**
      * Drop the dh-cache after a config change. When a cache refresher is wired
-     * (local mode) the most recent entries are re-warmed in the background so the
-     * developer's current pages stay instant and fresh; otherwise the cache is
-     * simply cleared.
+     * (local mode) the currently open page is re-warmed in the background so it
+     * stays instant and fresh; otherwise the cache is simply cleared.
      *
+     * @param page the browser page whose current url should be re-warmed
      * @private
      */
     private clearOrRefreshCache;

package/dist/services/onboarding/file-events/file-watcher.js

@@ -28,16 +28,20 @@ export class FileWatcher {
     }
     /**
      * Drop the dh-cache after a config change. When a cache refresher is wired
-     * (local mode) the most recent entries are re-warmed in the background so the
-     * developer's current pages stay instant and fresh; otherwise the cache is
-     * simply cleared.
+     * (local mode) the currently open page is re-warmed in the background so it
+     * stays instant and fresh; otherwise the cache is simply cleared.
      *
+     * @param page the browser page whose current url should be re-warmed
      * @private
      */
-    clearOrRefreshCache() {
+    clearOrRefreshCache(page) {
         if (this.cacheRefresher) {
+            // page.url() carries a hash fragment that never reaches the server, so it
+            // is not part of the cache key — strip it before matching.
+            const currentUrl = new URL(page.url());
+            currentUrl.hash = "";
             // fire-and-forget: refresh clears the cache first, then re-warms
-            void this.cacheRefresher.refreshRecent(10);
+            void this.cacheRefresher.refreshCurrentUrl(currentUrl.href);
             return;
         }
         this.cache.clear();
@@ -179,7 +183,7 @@ export class FileWatcher {
         this.cli.writeWarning(`changed file: ${file.name}`);
         await this.safeClearPageBrowsersCacheStorage(page);
         await this.documentHandler.buildDocumentHandler();
-        this.clearOrRefreshCache();
+        this.clearOrRefreshCache(page);
         await installResource.buildContent();
     }
     /**
@@ -192,7 +196,7 @@ export class FileWatcher {
     async onChangeDynamicStyleCallback(file, page) {
         this.cli.writeWarning(`changed file: ${file.name}`);
         await this.documentHandler.buildDocumentHandler();
-        this.clearOrRefreshCache();
+        this.clearOrRefreshCache(page);
         const escapedStyles = encodeURI(file.getContent());
         const evaluateResult = await safe(race(Promise.all([
             page.evaluate(this.updateStylesInlineFunction, escapedStyles),

package/dist/services/onboarding/virtual-orestes-app/index.d.ts

@@ -28,15 +28,15 @@ export declare class VirtualOrestesApp {
      */
     refreshUrl(originUrl: string): Promise<void>;
     /**
-     * Clear the whole dh-cache, then re-warm the most recently cached entries in
-     * the background (ordered by their `last-modified` header). Used as a
-     * replacement for a bare cache clear on config changes: stale entries are
-     * dropped, but the last `limit` pages are rebuilt proactively so the
-     * developer's current pages stay instant and fresh.
+     * Clear the whole dh-cache, then re-warm only the currently open page's
+     * cached entries in the background. Used as a replacement for a bare cache
+     * clear on config changes: every stale entry is dropped, but the page the
+     * developer is currently looking at is rebuilt proactively so it stays
+     * instant and fresh after the change.
      *
-     * @param limit how many of the most recently cached entries to re-warm
+     * @param currentUrl the url currently open in the browser (page.url())
      */
-    refreshRecent(limit?: number): Promise<void>;
+    refreshCurrentUrl(currentUrl: string): Promise<void>;
     /**
      * Rebuild a single cache entry (by its full asset request url), replacing the
      * previously cached response. On failure the stale entry is dropped so we

package/dist/services/onboarding/virtual-orestes-app/index.js

@@ -58,25 +58,24 @@ export class VirtualOrestesApp {
         }
     }
     /**
-     * Clear the whole dh-cache, then re-warm the most recently cached entries in
-     * the background (ordered by their `last-modified` header). Used as a
-     * replacement for a bare cache clear on config changes: stale entries are
-     * dropped, but the last `limit` pages are rebuilt proactively so the
-     * developer's current pages stay instant and fresh.
+     * Clear the whole dh-cache, then re-warm only the currently open page's
+     * cached entries in the background. Used as a replacement for a bare cache
+     * clear on config changes: every stale entry is dropped, but the page the
+     * developer is currently looking at is rebuilt proactively so it stays
+     * instant and fresh after the change.
      *
-     * @param limit how many of the most recently cached entries to re-warm
+     * @param currentUrl the url currently open in the browser (page.url())
      */
-    async refreshRecent(limit = 10) {
-        const recentKeys = [...this.cache.getAll()]
-            .sort(([, a], [, b]) => b.getLastModified() - a.getLastModified())
-            .slice(0, limit)
-            .map(([key]) => key);
+    async refreshCurrentUrl(currentUrl) {
+        const matchingKeys = [...this.cache.getAll()]
+            .map(([key]) => key)
+            .filter((key) => key.includes(currentUrl));
         this.cache.clear();
-        if (recentKeys.length === 0) {
+        if (matchingKeys.length === 0) {
             return;
         }
-        this.cli.write(`refreshing ${recentKeys.length} recent dh-cache entries in background`);
-        for (const key of recentKeys) {
+        this.cli.write(`refreshing ${matchingKeys.length} dh-cache entries for current url ${currentUrl} in background`);
+        for (const key of matchingKeys) {
             await this.refreshEntry(key);
         }
     }

package/dist/services/setup/browser/browser-detector.d.ts

@@ -0,0 +1,27 @@
+import { Platform } from "../os/tool-registry.js";
+export type BrowserSource = "system" | "puppeteer";
+export interface BrowserOption {
+    /** stable id used as the select value */
+    id: string;
+    /** display name incl. version/build when known */
+    name: string;
+    executablePath: string;
+    source: BrowserSource;
+    /** puppeteer buildId, only for puppeteer-managed browsers */
+    buildId?: string;
+    /** puppeteer Browser id (e.g. "chrome"), only for puppeteer-managed */
+    browser?: string;
+}
+export declare class BrowserDetector {
+    private readonly platform;
+    private readonly home;
+    private readonly cachePath;
+    private readonly env;
+    constructor(platform: Platform, home: string, cachePath: string, env?: NodeJS.ProcessEnv);
+    /** Browsers installed system-wide, discovered via the OS tool registry. */
+    detectSystemBrowsers(): BrowserOption[];
+    /** Browsers previously downloaded into the puppeteer cache. */
+    detectPuppeteerBrowsers(): BrowserOption[];
+    /** All detected browsers, puppeteer-managed first then system. */
+    detectAll(): BrowserOption[];
+}

package/dist/services/setup/browser/browser-detector.js

@@ -0,0 +1,47 @@
+import { Cache } from "@puppeteer/browsers";
+import { BROWSERS } from "../os/tool-registry.js";
+import { detectTools } from "../os/detector-helper.js";
+export class BrowserDetector {
+    platform;
+    home;
+    cachePath;
+    env;
+    constructor(platform, home, cachePath, env = process.env) {
+        this.platform = platform;
+        this.home = home;
+        this.cachePath = cachePath;
+        this.env = env;
+    }
+    /** Browsers installed system-wide, discovered via the OS tool registry. */
+    detectSystemBrowsers() {
+        return detectTools(BROWSERS, this.platform, this.home, this.env).map((tool) => ({
+            id: `system:${tool.id}`,
+            name: tool.name,
+            executablePath: tool.executablePath,
+            source: "system",
+        }));
+    }
+    /** Browsers previously downloaded into the puppeteer cache. */
+    detectPuppeteerBrowsers() {
+        const cache = new Cache(this.cachePath);
+        let installed;
+        try {
+            installed = cache.getInstalledBrowsers();
+        }
+        catch {
+            return [];
+        }
+        return installed.map((browser) => ({
+            id: `puppeteer:${browser.browser}@${browser.buildId}`,
+            name: `${browser.browser} ${browser.buildId} (puppeteer)`,
+            executablePath: browser.executablePath,
+            source: "puppeteer",
+            buildId: browser.buildId,
+            browser: browser.browser,
+        }));
+    }
+    /** All detected browsers, puppeteer-managed first then system. */
+    detectAll() {
+        return [...this.detectPuppeteerBrowsers(), ...this.detectSystemBrowsers()];
+    }
+}

package/dist/services/setup/browser/browser-manager.d.ts

@@ -0,0 +1,43 @@
+import { InstalledBrowser } from "@puppeteer/browsers";
+import { CliServiceInterface } from "../../cli/index.js";
+export type BrowserChannel = "stable" | "experimental";
+export interface InstalledBrowserInfo {
+    browser: string;
+    buildId: string;
+    executablePath: string;
+}
+/**
+ * Thin wrapper around `@puppeteer/browsers` for installing, listing and
+ * removing Chrome builds. Kept UI-agnostic apart from an optional progress
+ * spinner, so it can be reused by the wizard and the `sk browser` commands.
+ */
+export declare class BrowserManager {
+    private readonly cacheDir;
+    private readonly cli?;
+    constructor(cacheDir: string, cli?: CliServiceInterface);
+    /**
+     * Resolves the concrete buildId for a channel (e.g. "stable" -> "139.0...").
+     */
+    resolveBuildId(channel: BrowserChannel): Promise<string>;
+    /**
+     * Installs Chrome for the given channel and returns the installed build.
+     */
+    installChannel(channel: BrowserChannel): Promise<InstalledBrowser>;
+    /**
+     * Installs a specific Chrome buildId and returns the installed build.
+     */
+    installBuildId(buildId: string): Promise<InstalledBrowser>;
+    /**
+     * Lists all browsers currently present in the puppeteer cache.
+     */
+    list(): InstalledBrowserInfo[];
+    /**
+     * Removes a single browser build from the puppeteer cache.
+     */
+    remove(browser: string, buildId: string): Promise<void>;
+    /**
+     * Removes all browser builds from the puppeteer cache.
+     */
+    removeAll(): Promise<void>;
+    private getPlatform;
+}

package/dist/services/setup/browser/browser-manager.js

@@ -0,0 +1,101 @@
+import { Browser, detectBrowserPlatform, install, resolveBuildId, uninstall, Cache, } from "@puppeteer/browsers";
+/**
+ * Maps the wizard's user-facing channel to a puppeteer build tag.
+ * "experimental" follows Chrome Canary; "stable" follows the stable channel.
+ */
+function channelToTag(channel) {
+    return channel === "experimental" ? "canary" : "stable";
+}
+/**
+ * Thin wrapper around `@puppeteer/browsers` for installing, listing and
+ * removing Chrome builds. Kept UI-agnostic apart from an optional progress
+ * spinner, so it can be reused by the wizard and the `sk browser` commands.
+ */
+export class BrowserManager {
+    cacheDir;
+    cli;
+    constructor(cacheDir, cli) {
+        this.cacheDir = cacheDir;
+        this.cli = cli;
+    }
+    /**
+     * Resolves the concrete buildId for a channel (e.g. "stable" -> "139.0...").
+     */
+    async resolveBuildId(channel) {
+        const platform = this.getPlatform();
+        return resolveBuildId(Browser.CHROME, platform, channelToTag(channel));
+    }
+    /**
+     * Installs Chrome for the given channel and returns the installed build.
+     */
+    async installChannel(channel) {
+        const buildId = await this.resolveBuildId(channel);
+        return this.installBuildId(buildId);
+    }
+    /**
+     * Installs a specific Chrome buildId and returns the installed build.
+     */
+    async installBuildId(buildId) {
+        const platform = this.getPlatform();
+        const actionName = "browser-install";
+        this.cli?.startAction(actionName, `Downloading Chrome ${buildId}…`);
+        try {
+            const installed = await install({
+                browser: Browser.CHROME,
+                buildId,
+                cacheDir: this.cacheDir,
+                platform,
+            });
+            this.cli?.successAction(actionName, `Installed Chrome ${buildId}`);
+            return installed;
+        }
+        catch (error) {
+            this.cli?.failAction(actionName, `Failed to install Chrome ${buildId}: ${error?.message ?? error}`);
+            throw error;
+        }
+    }
+    /**
+     * Lists all browsers currently present in the puppeteer cache.
+     */
+    list() {
+        const cache = new Cache(this.cacheDir);
+        let installed;
+        try {
+            installed = cache.getInstalledBrowsers();
+        }
+        catch {
+            return [];
+        }
+        return installed.map((browser) => ({
+            browser: browser.browser,
+            buildId: browser.buildId,
+            executablePath: browser.executablePath,
+        }));
+    }
+    /**
+     * Removes a single browser build from the puppeteer cache.
+     */
+    async remove(browser, buildId) {
+        await uninstall({
+            browser: browser,
+            buildId,
+            cacheDir: this.cacheDir,
+            platform: this.getPlatform(),
+        });
+    }
+    /**
+     * Removes all browser builds from the puppeteer cache.
+     */
+    async removeAll() {
+        for (const installed of this.list()) {
+            await this.remove(installed.browser, installed.buildId);
+        }
+    }
+    getPlatform() {
+        const platform = detectBrowserPlatform();
+        if (!platform) {
+            throw new Error("Unable to detect browser platform for this OS");
+        }
+        return platform;
+    }
+}

package/dist/services/setup/browser/browser-setup-service.d.ts

@@ -0,0 +1,28 @@
+import { CliServiceInterface } from "../../cli/index.js";
+import { CliConfig, UserCliConfig } from "../../../helpers/cli-config.js";
+import { BrowserDetector } from "./browser-detector.js";
+import { BrowserManager } from "./browser-manager.js";
+export declare class BrowserSetupService {
+    private readonly cli;
+    private readonly cliConfig;
+    private readonly userConfig;
+    private readonly detector;
+    private readonly manager;
+    constructor(cli: CliServiceInterface, cliConfig: CliConfig, userConfig: UserCliConfig, detector: BrowserDetector, manager: BrowserManager);
+    /**
+     * Interactive browser selection: pick a detected browser or download one via
+     * puppeteer, then persist the choice.
+     */
+    run(): Promise<void>;
+    /**
+     * Checks — at most once per reminder interval — whether the puppeteer-managed
+     * browser has a newer build and offers to update it. Only applies to browsers
+     * we installed (i.e. a channel is configured). Safe to call on every command;
+     * callers must ensure the session is interactive first.
+     */
+    remindIfDue(): Promise<void>;
+    private installAndPersist;
+    private askReminderDays;
+    private isReminderDue;
+    private nowIso;
+}

package/dist/services/setup/browser/browser-setup-service.js

@@ -0,0 +1,136 @@
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+export class BrowserSetupService {
+    cli;
+    cliConfig;
+    userConfig;
+    detector;
+    manager;
+    constructor(cli, cliConfig, userConfig, detector, manager) {
+        this.cli = cli;
+        this.cliConfig = cliConfig;
+        this.userConfig = userConfig;
+        this.detector = detector;
+        this.manager = manager;
+    }
+    /**
+     * Interactive browser selection: pick a detected browser or download one via
+     * puppeteer, then persist the choice.
+     */
+    async run() {
+        const detected = this.detector.detectAll();
+        const choices = [
+            ...detected.map((browser) => ({
+                name: `${browser.name}  ${this.cli.style.grey(browser.executablePath)}`,
+                value: browser.id,
+            })),
+            {
+                name: "Download Chrome (stable) via puppeteer",
+                value: "install:stable",
+            },
+            {
+                name: "Download Chrome (experimental / canary) via puppeteer",
+                value: "install:experimental",
+            },
+        ];
+        const currentDefault = detected.find((browser) => browser.executablePath === this.userConfig.chromePath)?.id;
+        const selected = await this.cli.select("Which browser should Speed Kit use?", choices, currentDefault);
+        if (selected.startsWith("install:")) {
+            const channel = selected.slice("install:".length);
+            await this.installAndPersist(channel);
+            return;
+        }
+        const chosen = detected.find((browser) => browser.id === selected);
+        if (!chosen) {
+            this.cli.writeError("Selected browser could not be resolved.");
+            return;
+        }
+        this.cliConfig.save({
+            chromePath: chosen.executablePath,
+            // a manually selected browser is not update-managed by the wizard, so
+            // clear the channel to disable the update reminder for it
+            browserChannel: "",
+            browserBuildId: chosen.buildId ?? "",
+        });
+        this.cli.writeSuccess(`Using ${chosen.name} (${chosen.executablePath}).`);
+    }
+    /**
+     * Checks — at most once per reminder interval — whether the puppeteer-managed
+     * browser has a newer build and offers to update it. Only applies to browsers
+     * we installed (i.e. a channel is configured). Safe to call on every command;
+     * callers must ensure the session is interactive first.
+     */
+    async remindIfDue() {
+        const channel = this.userConfig.browserChannel;
+        if (channel !== "stable" && channel !== "experimental") {
+            return;
+        }
+        if (!this.isReminderDue()) {
+            return;
+        }
+        let latestBuildId;
+        try {
+            latestBuildId = await this.manager.resolveBuildId(channel);
+        }
+        catch {
+            // offline / resolution failure: try again next interval
+            return;
+        }
+        // stamp the check regardless so we don't re-check until the next interval
+        this.cliConfig.save({ lastBrowserUpdateCheck: this.nowIso() });
+        if (latestBuildId === this.userConfig.browserBuildId) {
+            return;
+        }
+        if (this.userConfig.browserAutoUpdate) {
+            await this.installAndPersist(channel);
+            return;
+        }
+        const update = await this.cli.confirm(`A newer Chrome ${channel} build (${latestBuildId}) is available. Update now?`, true);
+        if (update) {
+            await this.installAndPersist(channel);
+            return;
+        }
+        await this.askReminderDays();
+    }
+    async installAndPersist(channel) {
+        const installed = await this.manager.installChannel(channel);
+        this.cliConfig.save({
+            chromePath: installed.executablePath,
+            browserChannel: channel,
+            browserBuildId: installed.buildId,
+            lastBrowserUpdateCheck: this.nowIso(),
+        });
+        const autoUpdate = await this.cli.confirm("Automatically update the browser when a newer build is available?", this.userConfig.browserAutoUpdate);
+        this.cliConfig.save({ browserAutoUpdate: autoUpdate });
+        if (!autoUpdate) {
+            await this.askReminderDays();
+        }
+    }
+    async askReminderDays() {
+        const answer = await this.cli.prompt("Remind me to check for browser updates in how many days?", {
+            defaultAnswer: String(this.userConfig.updateReminderDays || 3),
+            validator: (value) => /^\d+$/.test(value.trim()) ? "" : "Enter a whole number of days",
+        });
+        const days = Number.parseInt(answer, 10);
+        if (!Number.isNaN(days) && days > 0) {
+            this.cliConfig.save({
+                updateReminderDays: days,
+                lastBrowserUpdateCheck: this.nowIso(),
+            });
+        }
+    }
+    isReminderDue() {
+        const days = this.userConfig.updateReminderDays || 3;
+        const last = this.userConfig.lastBrowserUpdateCheck;
+        if (!last) {
+            return true;
+        }
+        const lastMs = new Date(last).getTime();
+        if (Number.isNaN(lastMs)) {
+            return true;
+        }
+        return (Date.now() - lastMs) / MS_PER_DAY >= days;
+    }
+    nowIso() {
+        return new Date().toISOString();
+    }
+}

package/dist/services/setup/difftool/difftool-detector.d.ts

@@ -0,0 +1,14 @@
+import { Platform } from "../os/tool-registry.js";
+export interface DetectedEditor {
+    id: string;
+    name: string;
+    executablePath: string;
+    diffExecTemplate: string;
+}
+export declare class DiffToolDetector {
+    private readonly platform;
+    private readonly home;
+    private readonly env;
+    constructor(platform: Platform, home: string, env?: NodeJS.ProcessEnv);
+    detect(): DetectedEditor[];
+}

package/dist/services/setup/difftool/difftool-detector.js

@@ -0,0 +1,27 @@
+import { EDITORS } from "../os/tool-registry.js";
+import { detectTool } from "../os/detector-helper.js";
+export class DiffToolDetector {
+    platform;
+    home;
+    env;
+    constructor(platform, home, env = process.env) {
+        this.platform = platform;
+        this.home = home;
+        this.env = env;
+    }
+    detect() {
+        const detected = [];
+        for (const editor of EDITORS) {
+            const result = detectTool(editor, this.platform, this.home, this.env);
+            if (result) {
+                detected.push({
+                    id: editor.id,
+                    name: editor.name,
+                    executablePath: result.executablePath,
+                    diffExecTemplate: editor.diffExecTemplate,
+                });
+            }
+        }
+        return detected;
+    }
+}

package/dist/services/setup/difftool/difftool-setup-service.d.ts

@@ -0,0 +1,15 @@
+import { CliServiceInterface } from "../../cli/index.js";
+import { CliConfig, UserCliConfig } from "../../../helpers/cli-config.js";
+import { DiffToolDetector } from "./difftool-detector.js";
+export declare class DiffToolSetupService {
+    private readonly cli;
+    private readonly cliConfig;
+    private readonly userConfig;
+    private readonly detector;
+    constructor(cli: CliServiceInterface, cliConfig: CliConfig, userConfig: UserCliConfig, detector: DiffToolDetector);
+    /**
+     * Detects installed editors/diff tools, lets the user pick one, and persists
+     * it as diffExec + diffExecTemplate + diffTool.
+     */
+    run(): Promise<void>;
+}

package/dist/services/setup/difftool/difftool-setup-service.js

@@ -0,0 +1,46 @@
+export class DiffToolSetupService {
+    cli;
+    cliConfig;
+    userConfig;
+    detector;
+    constructor(cli, cliConfig, userConfig, detector) {
+        this.cli = cli;
+        this.cliConfig = cliConfig;
+        this.userConfig = userConfig;
+        this.detector = detector;
+    }
+    /**
+     * Detects installed editors/diff tools, lets the user pick one, and persists
+     * it as diffExec + diffExecTemplate + diffTool.
+     */
+    async run() {
+        const detected = this.detector.detect();
+        if (detected.length === 0) {
+            this.cli.writeWarning("No supported diff tool (IntelliJ / VS Code family) was found. " +
+                "You can set diffExec manually in the config later.");
+            return;
+        }
+        const choices = [
+            ...detected.map((editor) => ({
+                name: `${editor.name}  ${this.cli.style.grey(editor.executablePath)}`,
+                value: editor.id,
+            })),
+            { name: "Skip — configure manually later", value: "skip" },
+        ];
+        const selected = await this.cli.select("Which diff tool should Speed Kit use?", choices, this.userConfig.diffTool || undefined);
+        if (selected === "skip") {
+            return;
+        }
+        const chosen = detected.find((editor) => editor.id === selected);
+        if (!chosen) {
+            this.cli.writeError("Selected diff tool could not be resolved.");
+            return;
+        }
+        this.cliConfig.save({
+            diffTool: chosen.id,
+            diffExec: chosen.executablePath,
+            diffExecTemplate: chosen.diffExecTemplate,
+        });
+        this.cli.writeSuccess(`Using ${chosen.name} for diffs.`);
+    }
+}

package/dist/services/setup/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./setup-context.js";
+export * from "./setup-service.js";
+export * from "./setup-service-factory.js";
+export * from "./browser/browser-detector.js";
+export * from "./browser/browser-manager.js";
+export * from "./browser/browser-setup-service.js";
+export * from "./difftool/difftool-detector.js";
+export * from "./difftool/difftool-setup-service.js";
+export * from "./os/tool-registry.js";
+export * from "./os/detector-helper.js";