@ai-projector/ide 0.0.0-stage → 0.11.1

package/packages/core/modules/workspace/pipeline-status.js

@@ -0,0 +1,86 @@
+export const PIPELINE_STATUS_LABEL = {
+    queued: "в очереди",
+    running: "идёт",
+    success: "успешно",
+    failed: "ошибка",
+    canceled: "отменён",
+    skipped: "пропущен",
+    manual: "вручную",
+    unknown: "неизвестно",
+};
+export const PIPELINE_STATUS_TONE = {
+    queued: "muted",
+    running: "warning",
+    success: "success",
+    failed: "danger",
+    canceled: "faint",
+    skipped: "faint",
+    manual: "warning",
+    unknown: "faint",
+};
+/** Seconds as a compact duration: `42 с`, `3 мин 07 с`, `1 ч 12 мин`. */
+export function durationLabel(seconds) {
+    if (seconds === null || !Number.isFinite(seconds) || seconds < 0)
+        return "";
+    const total = Math.round(seconds);
+    if (total < 60)
+        return `${total} с`;
+    const minutes = Math.floor(total / 60);
+    const rest = total % 60;
+    if (minutes < 60)
+        return rest ? `${minutes} мин ${String(rest).padStart(2, "0")} с` : `${minutes} мин`;
+    const hours = Math.floor(minutes / 60);
+    const restMinutes = minutes % 60;
+    return restMinutes ? `${hours} ч ${restMinutes} мин` : `${hours} ч`;
+}
+const SOURCE_LABEL = {
+    push: "push",
+    web: "веб",
+    api: "API",
+    trigger: "триггер",
+    schedule: "расписание",
+    pipeline: "pipeline",
+    parent_pipeline: "родительский pipeline",
+    merge_request_event: "MR",
+    external: "внешний",
+    chat: "чат",
+    webide: "Web IDE",
+    ondemand_dast_scan: "DAST-сканирование",
+    ondemand_dast_validation: "проверка DAST",
+    pull_request: "PR",
+    pull_request_target: "PR",
+    merge_group: "merge queue",
+    workflow_dispatch: "вручную",
+    workflow_run: "workflow",
+    repository_dispatch: "API",
+    release: "релиз",
+    deployment: "деплой",
+    deployment_status: "деплой",
+    issue_comment: "комментарий",
+    discussion: "discussion",
+};
+/** Host event of a CI run as a short human label; unknown sources stay as reported. */
+export function sourceLabel(source) {
+    if (!source)
+        return "";
+    return SOURCE_LABEL[source] ?? source;
+}
+/**
+ * A branch or MR ref without GitLab's internal prefix: `refs/merge-requests/12/merge` is `!12`,
+ * `refs/heads/main` is `main`. Other refs keep their shape minus `refs/`.
+ */
+export function refLabel(ref) {
+    const value = ref.trim();
+    const mergeRequest = /^refs\/merge-requests\/(\d+)\/(.+)$/.exec(value);
+    if (mergeRequest) {
+        const kind = mergeRequest[2];
+        return kind === "merge" || kind === "head"
+            ? `!${mergeRequest[1]}`
+            : `!${mergeRequest[1]} ${kind}`;
+    }
+    if (value.startsWith("refs/heads/"))
+        return value.slice("refs/heads/".length);
+    if (value.startsWith("refs/tags/"))
+        return value.slice("refs/tags/".length);
+    return value.replace(/^refs\//, "");
+}

package/packages/core/modules/workspace/pull-requests.js

@@ -0,0 +1 @@
+export {};

package/packages/core/modules/workspace/pull-status.js

@@ -0,0 +1,56 @@
+/** GitLab `detailed_merge_status` values; unknown codes stay as reported by the host. */
+const MERGE_STATUS_LABEL = {
+    mergeable: "можно вливать",
+    checking: "проверяется",
+    preparing: "готовится",
+    ci_still_running: "pipeline идёт",
+    ci_must_pass: "нужен успешный pipeline",
+    status_checks_must_pass: "нужны status checks",
+    approvals_syncing: "одобрения синхронизируются",
+    not_approved: "нужно одобрение",
+    blocked_status: "заблокирован",
+    merge_request_blocked: "ждёт другой merge request",
+    conflict: "конфликт",
+    discussions_not_resolved: "обсуждения не решены",
+    draft_status: "черновик",
+    commits_status: "нет коммитов",
+    merge_time: "время merge не наступило",
+    requested_changes: "запрошены изменения",
+    security_policy_violations: "нарушена security policy",
+    jira_association_missing: "нет связи с Jira",
+};
+const DANGER = new Set([
+    "conflict",
+    "discussions_not_resolved",
+    "draft_status",
+    "not_approved",
+    "requested_changes",
+    "security_policy_violations",
+]);
+const WARNING = new Set([
+    "checking",
+    "preparing",
+    "ci_still_running",
+    "ci_must_pass",
+    "status_checks_must_pass",
+    "approvals_syncing",
+    "blocked_status",
+    "merge_request_blocked",
+    "merge_time",
+    "jira_association_missing",
+]);
+/** Short Russian label of a merge readiness code; unknown codes are returned unchanged. */
+export function mergeStatusLabel(value) {
+    if (!value)
+        return "";
+    return MERGE_STATUS_LABEL[value] ?? value;
+}
+export function mergeStatusTone(value) {
+    if (value === "mergeable")
+        return "success";
+    if (DANGER.has(value))
+        return "danger";
+    if (WARNING.has(value))
+        return "warning";
+    return "muted";
+}

package/packages/core/modules/workspace/scope.js

@@ -0,0 +1,34 @@
+/** A stable key for tabs, sessions and directory caches. */
+export function fileScopeKey(scope) {
+    if (scope.kind === "live")
+        return "live";
+    if (scope.kind === "commit")
+        return `commit:${scope.rev}`;
+    return `compare:${scope.from}..${scope.to}`;
+}
+/** Parameters every read of this scope carries; the action itself stays at the call site. */
+export function fileScopeQuery(scope) {
+    if (scope.kind === "live")
+        return {};
+    if (scope.kind === "commit")
+        return { rev: scope.rev };
+    return { from: scope.from, to: scope.to };
+}
+export const isLiveScope = (scope) => scope.kind === "live";
+export const shortRevision = (rev) => rev.slice(0, 7);
+/** Sidebar section title: what the tree shows, not how it is read. */
+export function fileScopeTitle(scope) {
+    if (scope.kind === "live")
+        return "Файлы проекта";
+    if (scope.kind === "commit")
+        return `Файлы коммита @${shortRevision(scope.rev)}`;
+    return `Сравнение ${shortRevision(scope.from)}..${shortRevision(scope.to)}`;
+}
+/** Note above a read-only tree. Empty for the working copy. */
+export function fileScopeNote(scope) {
+    if (scope.kind === "live")
+        return "";
+    if (scope.kind === "commit")
+        return `Только чтение · коммит ${shortRevision(scope.rev)}`;
+    return `Только чтение · ${shortRevision(scope.from)}..${shortRevision(scope.to)}`;
+}

package/packages/core/modules/workspace/search.js

@@ -0,0 +1,28 @@
+/** Character offsets of one query in a line; shared by local and remote search adapters. */
+export function searchMatches(text, query, options = {}) {
+    const matches = [];
+    if (!query)
+        return matches;
+    if (options.regex) {
+        const expression = new RegExp(query, options.caseSensitive ? "g" : "gi");
+        for (const match of text.matchAll(expression)) {
+            if (!match[0])
+                break;
+            matches.push({ start: match.index ?? 0, end: (match.index ?? 0) + match[0].length });
+            if (matches.length >= 20)
+                break;
+        }
+        return matches;
+    }
+    const haystack = options.caseSensitive ? text : text.toLowerCase();
+    const needle = options.caseSensitive ? query : query.toLowerCase();
+    let offset = 0;
+    while (offset <= haystack.length && matches.length < 20) {
+        const start = haystack.indexOf(needle, offset);
+        if (start < 0)
+            break;
+        matches.push({ start, end: start + needle.length });
+        offset = start + Math.max(needle.length, 1);
+    }
+    return matches;
+}

package/packages/core/modules/workspace/tree-page.js

@@ -0,0 +1,25 @@
+export const TREE_PAGE_SIZE = 30;
+/** Apply the same sorted-directory paging contract to local and remote providers. */
+export function treePageRange(entries, path, params = {}) {
+    const integer = (key, fallback, minimum, maximum) => {
+        if (params[key] === undefined)
+            return fallback;
+        const value = Number(params[key]);
+        if (!/^\d+$/.test(params[key]) ||
+            !Number.isSafeInteger(value) ||
+            value < minimum ||
+            value > maximum)
+            throw new Error(`Неверный параметр ${key}`);
+        return value;
+    };
+    const offset = integer("offset", 0, 0, Number.MAX_SAFE_INTEGER);
+    const limit = integer("limit", 1000, 1, 1000);
+    let end = Math.min(entries.length, offset + limit);
+    // Explicit reveal may open several portions, preserving all preceding siblings.
+    if (params.reveal && offset === 0) {
+        const index = entries.findIndex((entry) => (path ? `${path}/` : "") + entry.name === params.reveal);
+        if (index >= 0)
+            end = Math.min(entries.length, Math.max(end, Math.ceil((index + 1) / TREE_PAGE_SIZE) * TREE_PAGE_SIZE));
+    }
+    return { offset, end, total: entries.length, nextOffset: end < entries.length ? end : null };
+}

package/packages/server/app/agents.js

@@ -0,0 +1,30 @@
+import { listAgentBackends, registerAgentBackend } from "../modules/agent/index.js";
+import { configureAgentPreferences } from "../modules/preferences/index.js";
+import { configureTerminalPrograms } from "../modules/terminal/index.js";
+import { claudeCodeBackend } from "../modules/agents/claude-code/index.js";
+import { codexBackend } from "../modules/agents/codex/index.js";
+import { cursorBackend } from "../modules/agents/cursor/index.js";
+import { kimiBackend } from "../modules/agents/kimi/index.js";
+import { opencodeBackend } from "../modules/agents/opencode/index.js";
+import { projectorBackend } from "../modules/agents/projector/index.js";
+/**
+ * The agents this server offers. The composition is the only place that names them: each agent
+ * module stays independent and the generic core never imports one. Registering again replaces.
+ */
+export function registerBuiltinAgents() {
+    registerAgentBackend(projectorBackend, { asDefault: true });
+    registerAgentBackend(claudeCodeBackend);
+    registerAgentBackend(codexBackend);
+    registerAgentBackend(opencodeBackend);
+    registerAgentBackend(cursorBackend);
+    registerAgentBackend(kimiBackend);
+    // The settings ask the live registry instead of keeping their own copy of the list.
+    configureAgentPreferences({
+        programs: () => listAgentBackends().flatMap(({ program }) => (program ? [program] : [])),
+        toggleable: () => listAgentBackends()
+            .filter(({ builtin }) => !builtin)
+            .map(({ id }) => id),
+    });
+    // Terminal programs come from the same registry; no list of agents lives in the terminal.
+    configureTerminalPrograms((program) => listAgentBackends().find((backend) => backend.terminal?.program === program)?.terminal);
+}

package/packages/server/app/api.js

@@ -0,0 +1,159 @@
+import { routes as hubRoutes } from "../routes/api/hub.js";
+import { HttpError } from "../modules/http/index.js";
+import { createRouteDispatcher, json } from "../modules/transport/index.js";
+import { localOrigin } from "../middlewares/local-origin.js";
+import { routes as integrationsActionsRoutes } from "../routes/api/integrations/[...action].js";
+import { routes as githubBrowseRoutes } from "../routes/api/integrations/github-browse.js";
+import { routes as directoriesRoutes } from "../routes/api/directories.js";
+import { routes as healthRoutes } from "../routes/api/health.js";
+import { routes as appOpenRoutes } from "../routes/api/app/open.js";
+import { routes as appHideRoutes } from "../routes/api/app/hide.js";
+import { routes as appRestartRoutes } from "../routes/api/app/restart.js";
+import { routes as appModeRoutes } from "../routes/api/app/mode.js";
+import { routes as appQuitRoutes } from "../routes/api/app/quit.js";
+import { routes as appNetworkRoutes } from "../routes/api/app/network.js";
+import { routes as launcherSettingsRoutes } from "../routes/api/launcher/settings.js";
+import { routes as launcherSearchRoutes } from "../routes/api/launcher/search.js";
+import { routes as launcherLaunchRoutes } from "../routes/api/launcher/launch.js";
+import { routes as launcherIconRoutes } from "../routes/api/launcher/icon.js";
+import { routes as eventsRoutes } from "../routes/api/events.js";
+import { routes as statusRoutes } from "../routes/api/status.js";
+import { routes as providersRoutes } from "../routes/api/providers.js";
+import { routes as providersActiveRoutes } from "../routes/api/providers/active.js";
+import { routes as providersBalanceRoutes } from "../routes/api/providers/balance.js";
+import { routes as providersModelsRoutes } from "../routes/api/providers/models.js";
+import { routes as agentRoutes } from "../routes/api/agent.js";
+import { routes as agentFormRepairRoutes } from "../routes/api/agent-form-repair.js";
+import { routes as agentAnswerRepairRoutes } from "../routes/api/agent-answer-repair.js";
+import { routes as agentSecretShowRoutes } from "../routes/api/agent-secret-show.js";
+import { routes as agentLensRoutes } from "../routes/api/agent-lens.js";
+import { routes as agentSideRoutes } from "../routes/api/agent-side.js";
+import { routes as agentSkillsRoutes } from "../routes/api/agent-skills.js";
+import { routes as agentFeaturesRoutes } from "../routes/api/agent-features.js";
+import { routes as agentJudgeRoutes } from "../routes/api/agent-judge.js";
+import { routes as agentRolesRoutes } from "../routes/api/agent-roles.js";
+import { routes as agentProjectRolesRoutes } from "../routes/api/agent-project-roles.js";
+import { routes as agentProjectWidgetsRoutes } from "../routes/api/agent-project-widgets.js";
+import { routes as agentWebRoutes } from "../routes/api/agent-web.js";
+import { routes as agentMcpRoutes } from "../routes/api/agent-mcp.js";
+import { routes as agentHooksRoutes } from "../routes/api/agent-hooks.js";
+import { routes as agentMemoryRoutes } from "../routes/api/agent-memory.js";
+import { routes as agentJobsRoutes } from "../routes/api/agent-jobs.js";
+import { routes as agentChatsRoutes } from "../routes/api/agent-chats.js";
+import { routes as agentWorktreesRoutes } from "../routes/api/agent-worktrees.js";
+import { routes as inspectRoutes } from "../routes/api/inspect.js";
+import { routes as pickFolderRoutes } from "../routes/api/pick-folder.js";
+import { routes as previewIconRoutes } from "../routes/api/preview-icon.js";
+import { routes as projectsIndexRoutes } from "../routes/api/projects/index.js";
+import { routes as projectWorkspaceRoutes } from "../routes/api/projects/[id]/workspace.js";
+import { routes as projectWorkspaceReadRoutes } from "../routes/api/projects/[id]/workspace-read.js";
+import { routes as projectSiteRoutes } from "../routes/api/projects/[id]/site.js";
+import { routes as projectTerminalsRoutes } from "../routes/api/projects/[id]/terminals.js";
+import { routes as projectActionsRoutes } from "../routes/api/projects/[id]/index.js";
+import { routes as ideKeybindingsRoutes } from "../routes/api/ide/keybindings.js";
+import { routes as ideCommandsRoutes } from "../routes/api/ide/commands.js";
+import { routes as editorSettingsRoutes } from "../routes/api/ide/editor.js";
+import { routes as appearanceRoutes } from "../routes/api/appearance.js";
+import { routes as filesExcludeRoutes } from "../routes/api/ide/files-exclude.js";
+import { routes as dockerRoutes } from "../routes/api/docker.js";
+import { routes as codexRoutes } from "../routes/api/codex.js";
+import { routes as openCodeRoutes } from "../routes/api/opencode.js";
+import { routes as cursorRoutes } from "../routes/api/cursor.js";
+import { routes as kimiRoutes } from "../routes/api/kimi.js";
+import { routes as claudeRoutes } from "../routes/api/claude.js";
+import { routes as analyticsRoutes } from "../routes/api/analytics.js";
+import { routes as openAiRoutes } from "../routes/api/openai.js";
+import { routes as browserRoutes } from "../routes/api/browser.js";
+const dispatch = createRouteDispatcher([
+    ...hubRoutes,
+    ...openAiRoutes,
+    ...browserRoutes,
+    ...claudeRoutes,
+    ...analyticsRoutes,
+    ...cursorRoutes,
+    ...kimiRoutes,
+    ...openCodeRoutes,
+    ...codexRoutes,
+    ...dockerRoutes,
+    ...filesExcludeRoutes,
+    ...editorSettingsRoutes,
+    ...appearanceRoutes,
+    ...ideKeybindingsRoutes,
+    ...ideCommandsRoutes,
+    ...githubBrowseRoutes,
+    ...integrationsActionsRoutes,
+    ...directoriesRoutes,
+    ...healthRoutes,
+    ...appOpenRoutes,
+    ...appHideRoutes,
+    ...appRestartRoutes,
+    ...appQuitRoutes,
+    ...appModeRoutes,
+    ...appNetworkRoutes,
+    ...launcherSettingsRoutes,
+    ...launcherSearchRoutes,
+    ...launcherLaunchRoutes,
+    ...launcherIconRoutes,
+    ...eventsRoutes,
+    ...statusRoutes,
+    ...providersRoutes,
+    ...providersActiveRoutes,
+    ...providersBalanceRoutes,
+    ...providersModelsRoutes,
+    ...agentMemoryRoutes,
+    ...agentMcpRoutes,
+    ...agentHooksRoutes,
+    ...agentWebRoutes,
+    ...agentSkillsRoutes,
+    ...agentFeaturesRoutes,
+    ...agentJudgeRoutes,
+    ...agentRolesRoutes,
+    ...agentProjectRolesRoutes,
+    ...agentProjectWidgetsRoutes,
+    ...agentRoutes,
+    ...agentFormRepairRoutes,
+    ...agentAnswerRepairRoutes,
+    ...agentSecretShowRoutes,
+    ...agentLensRoutes,
+    ...agentSideRoutes,
+    ...agentJobsRoutes,
+    ...agentChatsRoutes,
+    ...agentWorktreesRoutes,
+    ...inspectRoutes,
+    ...pickFolderRoutes,
+    ...previewIconRoutes,
+    ...projectsIndexRoutes,
+    ...projectSiteRoutes,
+    ...projectWorkspaceRoutes,
+    ...projectWorkspaceReadRoutes,
+    ...projectTerminalsRoutes,
+    ...projectActionsRoutes,
+]);
+export async function handleApi(req, res) {
+    let url;
+    try {
+        // Routing does not depend on the untrusted Host header.
+        url = new URL(req.url ?? "/", "http://localhost");
+    }
+    catch {
+        json(res, 400, { error: "Некорректный адрес запроса" });
+        return true;
+    }
+    if (!url.pathname.startsWith("/api"))
+        return false;
+    const method = req.method ?? "GET";
+    const context = { req, res, url, path: url.pathname, method };
+    try {
+        if (!localOrigin(context))
+            return true;
+        if (await dispatch(context))
+            return true;
+        json(res, 404, { error: "Не найден" });
+    }
+    catch (error) {
+        json(res, error instanceof HttpError ? error.status : 400, {
+            error: error instanceof Error ? error.message : "Ошибка",
+        });
+    }
+    return true;
+}

package/packages/server/app/claude-runner.js

@@ -0,0 +1,17 @@
+// One Claude Code run, held by its own process so that a server restart or a hot reload leaves the
+// answer going (see `runHostedRunner` for the protocol and `claude-code-backend.ts` for the server side).
+//
+// Usage: node claude-runner.ts <run directory>
+import { registerAgentBackend, runHostedRunner } from "../modules/agent/index.js";
+import { claudeCodeBackend, runClaudeCode } from "../modules/agents/claude-code/index.js";
+import { registerBuiltinWidgetDefinitions } from "./widgets.js";
+import { registerBuiltinAgentFeatures } from "./features.js";
+// The server registers these when it starts; the answer's system prompt lists the enabled features.
+// This process runs one agent, so it registers that backend before the features ask for the catalog.
+registerAgentBackend(claudeCodeBackend);
+registerBuiltinWidgetDefinitions();
+registerBuiltinAgentFeatures();
+// A test imports this module to check the registration without starting an answer; a real host
+// passes the run directory as the first argument.
+if (process.argv[2])
+    runHostedRunner(runClaudeCode);

package/packages/server/app/dev-plugin.js

@@ -0,0 +1,76 @@
+import { fileURLToPath } from "node:url";
+import { createRunnableDevEnvironment, isRunnableDevEnvironment, normalizePath, } from "vite-plus";
+import { DevRuntime } from "./dev-runtime.js";
+/** Keep this entry lightweight: the config bundle must never contain the server API graph. */
+export function projectorPlugin() {
+    let runtime;
+    const entry = fileURLToPath(new URL("./plugin.js", import.meta.url));
+    return {
+        name: "projector-api",
+        apply(_config, { mode }) {
+            // Tests that need API/PTY bind their own isolated servers; the Vitest coordinator does not.
+            return mode !== "test";
+        },
+        async hotUpdate({ file }) {
+            if (this.environment.name !== "ssr")
+                return;
+            const root = normalizePath(this.environment.config.root) + "/";
+            const path = normalizePath(file);
+            if (!path.startsWith(root + "packages/server/") && !path.startsWith(root + "packages/core/"))
+                return;
+            await runtime?.update(path);
+            return [];
+        },
+        async configureServer(server) {
+            const environment = server.environments.ssr;
+            if (!isRunnableDevEnvironment(environment))
+                throw new Error("Projector requires a runnable SSR environment");
+            runtime = new DevRuntime(environment, entry, (error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                server.config.logger.error(`Projector API reload failed: ${message}`, {
+                    timestamp: true,
+                });
+                server.environments.client.hot.send({
+                    type: "error",
+                    err: { message: `Projector API: ${message}`, stack: "" },
+                });
+            }, () => server.environments.client.hot.send({ type: "update", updates: [] }));
+            const owner = runtime;
+            await owner.start(server.httpServer);
+            server.middlewares.use((req, res, next) => owner.handle(req, res, next));
+            server.httpServer?.once("close", () => {
+                owner.close();
+                if (runtime === owner)
+                    runtime = undefined;
+            });
+        },
+        async configurePreviewServer(server) {
+            // Preview has no HMR but still needs a live runner for deferred platform imports.
+            const environment = createRunnableDevEnvironment("ssr", server.config, {
+                hot: false,
+                runnerOptions: { hmr: false },
+            });
+            await environment.init();
+            try {
+                const api = (await environment.runner.import(entry));
+                const dispose = api.bindRuntime(server.httpServer, "prod");
+                const handlers = api.getRuntimeHandlers();
+                server.middlewares.use((req, res, next) => {
+                    void handlers.handleHttp(req, res, next).catch(() => {
+                        if (!res.headersSent)
+                            res.writeHead(500);
+                        res.end();
+                    });
+                });
+                server.httpServer.once("close", () => {
+                    dispose();
+                    void environment.close();
+                });
+            }
+            catch (error) {
+                await environment.close();
+                throw error;
+            }
+        },
+    };
+}

package/packages/server/app/dev-runtime.js

@@ -0,0 +1,119 @@
+/** Owns one managed module graph, independently of how often API files change. */
+export class DevRuntime {
+    active;
+    loading;
+    revision = 0;
+    attempted = -1;
+    closed = false;
+    lastError;
+    subscriptions;
+    transports;
+    replaceTransports = false;
+    environment;
+    entry;
+    report;
+    recovered;
+    constructor(environment, entry, report, recovered) {
+        this.environment = environment;
+        this.entry = entry;
+        this.report = report;
+        this.recovered = recovered;
+    }
+    /** The same facade is retained by every socket; its target changes only after a valid load. */
+    handlers = () => {
+        if (!this.active)
+            throw new Error("Projector runtime is not active");
+        return this.active.handlers;
+    };
+    async update(file) {
+        this.revision++;
+        if (/\/server\/modules\/(terminal|terminal-control)\/(socket|shared-socket)\.ts$/.test(file) ||
+            file.endsWith("/server/modules/access/connections.ts") ||
+            file.includes("/server/modules/hub/") ||
+            file.endsWith("/server/app/plugin.ts"))
+            this.replaceTransports = true;
+        await this.load();
+    }
+    async start(server) {
+        const current = await this.load();
+        this.transports = current.module.bindRuntime(server, "dev", this.handlers);
+        server?.once("close", () => this.close());
+        this.server = server;
+    }
+    server = null;
+    async loadOnce() {
+        if (this.closed)
+            throw new Error("Projector runtime is closed");
+        if (this.active && this.attempted === this.revision)
+            return this.active;
+        const epoch = this.revision;
+        this.attempted = epoch;
+        if (this.active) {
+            this.environment.moduleGraph.invalidateAll();
+            this.environment.runner.clearCache();
+        }
+        try {
+            const module = (await this.environment.runner.import(this.entry));
+            const next = { module, handlers: module.getRuntimeHandlers() };
+            if (this.closed)
+                throw new Error("Projector runtime is closed");
+            if (epoch !== this.revision) {
+                this.attempted = -1;
+                return this.loadOnce();
+            }
+            if (this.active) {
+                const dispose = module.bindRuntime(null, "dev");
+                this.subscriptions?.();
+                this.subscriptions = dispose;
+            }
+            this.active = next;
+            if (this.replaceTransports && this.server) {
+                this.transports?.();
+                this.transports = module.bindRuntime(this.server, "dev", this.handlers);
+                this.replaceTransports = false;
+            }
+            if (this.lastError)
+                this.recovered();
+            this.lastError = undefined;
+            return next;
+        }
+        catch (error) {
+            if (this.closed || !this.active)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            if (this.lastError !== message)
+                this.report(error);
+            this.lastError = message;
+            if (epoch !== this.revision) {
+                this.attempted = -1;
+                return this.loadOnce();
+            }
+            return this.active;
+        }
+    }
+    load() {
+        return (this.loading ??= this.loadOnce().finally(() => {
+            this.loading = undefined;
+        }));
+    }
+    handle(req, res, next) {
+        // Only loading falls back. A failed operation is never retried against an older generation.
+        void this.load()
+            .then(({ handlers }) => handlers.handleHttp(req, res, next))
+            .catch(() => {
+            if (!res.headersSent)
+                res.writeHead(500);
+            res.end();
+        });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.subscriptions?.();
+        this.transports?.();
+        this.subscriptions = this.transports = undefined;
+        this.active = undefined;
+        this.server = null;
+    }
+}