conductor-oss 0.2.20 → 0.3.1

package/web/.next/standalone/packages/web/src/features/dashboard/components/WorkspaceOverview.tsx

@@ -112,6 +112,7 @@ export function WorkspaceOverview({
   }).length;
   const mergeReady = visibleSessions.filter((session) => getAttentionLevel(session) === "merge").length;
   const selectedProject = projectSummaries.find((project) => project.id === selectedProjectId) ?? null;
+  const showWelcomeState = projects.length === 0 && visibleSessions.length === 0;
 
   const statCards = [
     { label: "Projects", value: String(projects.length), icon: FolderGit2 },
@@ -120,9 +121,52 @@ export function WorkspaceOverview({
     { label: "Merge ready", value: String(mergeReady), icon: GitBranch },
   ];
 
+  if (showWelcomeState) {
+    return (
+      <div className="flex min-h-full flex-col bg-[linear-gradient(180deg,rgba(255,255,255,0.03),rgba(255,255,255,0))]">
+        <div className="mx-auto flex min-h-full w-full max-w-[1200px] flex-1 flex-col px-3 py-3 sm:px-4 sm:py-4">
+          <div className="mb-4 flex justify-end">
+            <Button variant="outline" size="md" onClick={onCreateWorkspace}>
+              Add workspace
+            </Button>
+          </div>
+
+          <div className="flex flex-1 items-center justify-center">
+            <Card className="w-full max-w-[880px] border-[var(--vk-border)] bg-[color:color-mix(in_srgb,var(--vk-bg-panel)_88%,transparent)]">
+              <CardContent className="flex flex-col items-center px-6 py-12 text-center sm:px-10 sm:py-16">
+                <span className="inline-flex h-14 w-14 items-center justify-center rounded-[12px] border border-[var(--vk-border)] bg-[var(--vk-bg-main)] text-[var(--vk-text-normal)]">
+                  <FolderKanban className="h-6 w-6" />
+                </span>
+                <p className="mt-5 text-[11px] uppercase tracking-[0.14em] text-[var(--vk-text-muted)]">
+                  Frontend Control Surface
+                </p>
+                <h1 className="mt-3 max-w-[14ch] text-[30px] font-semibold leading-[1.02] tracking-[-0.05em] text-[var(--vk-text-strong)] sm:text-[44px]">
+                  Operate workspaces, sessions, and agents from one surface.
+                </h1>
+                <p className="mt-4 max-w-[560px] text-[14px] leading-7 text-[var(--vk-text-muted)] sm:text-[15px]">
+                  Start by linking a workspace. Once a project is connected, this page will show active sessions,
+                  recent work, and project focus without sending you through an empty composer first.
+                </p>
+
+                <div className="mt-8 flex flex-wrap items-center justify-center gap-3">
+                  <Button variant="primary" size="md" onClick={onCreateWorkspace}>
+                    Add workspace
+                  </Button>
+                  <div className="inline-flex rounded-[6px] border border-[var(--vk-border)] bg-[var(--vk-bg-main)] px-3 py-2 text-[12px] text-[var(--vk-text-muted)]">
+                    0 projects · 0 active sessions
+                  </div>
+                </div>
+              </CardContent>
+            </Card>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
   return (
-    <div className="border-b border-[var(--vk-border)] bg-[linear-gradient(180deg,rgba(255,255,255,0.03),rgba(255,255,255,0))]">
-      <div className="mx-auto flex w-full max-w-[1440px] flex-col gap-4 px-3 py-3 sm:px-4">
+    <div className="flex min-h-full flex-col border-b border-[var(--vk-border)] bg-[linear-gradient(180deg,rgba(255,255,255,0.03),rgba(255,255,255,0))]">
+      <div className="mx-auto flex min-h-full w-full max-w-[1440px] flex-1 flex-col gap-4 px-3 py-3 sm:px-4">
         <div className="flex flex-col gap-3 lg:flex-row lg:items-start lg:justify-between">
           <div className="max-w-3xl">
             <p className="text-[11px] uppercase tracking-[0.12em] text-[var(--vk-text-muted)]">
@@ -185,8 +229,8 @@ export function WorkspaceOverview({
           ))}
         </div>
 
-        <div className="grid gap-3 xl:grid-cols-[1.35fr_0.95fr]">
-          <Card>
+        <div className="grid flex-1 gap-3 xl:grid-cols-[1.35fr_0.95fr]">
+          <Card className="flex h-full min-h-[280px] flex-col">
             <CardHeader className="justify-between">
               <div>
                 <p className="text-[14px] font-semibold text-[var(--vk-text-strong)]">Recent sessions</p>
@@ -194,9 +238,11 @@ export function WorkspaceOverview({
               </div>
               <Badge variant="outline">{visibleSessions.length}</Badge>
             </CardHeader>
-            <CardContent className="space-y-2">
+            <CardContent className="flex-1 space-y-2">
               {recentSessions.length === 0 ? (
-                <p className="text-[13px] text-[var(--vk-text-muted)]">No sessions yet. Create one from the launchpad below.</p>
+                <div className="flex h-full min-h-[180px] items-center justify-center rounded-[6px] border border-dashed border-[var(--vk-border)] bg-[var(--vk-bg-main)] px-4 text-center text-[13px] text-[var(--vk-text-muted)]">
+                  No sessions yet. Create or open a workspace to start work.
+                </div>
               ) : recentSessions.map((session) => (
                 <button
                   key={session.id}
@@ -226,7 +272,7 @@ export function WorkspaceOverview({
             </CardContent>
           </Card>
 
-          <Card>
+          <Card className="flex h-full min-h-[280px] flex-col">
             <CardHeader className="justify-between">
               <div>
                 <p className="text-[14px] font-semibold text-[var(--vk-text-strong)]">Project focus</p>
@@ -236,7 +282,7 @@ export function WorkspaceOverview({
               </div>
               <Badge variant="outline">{agentCount} agents</Badge>
             </CardHeader>
-            <CardContent className="space-y-2">
+            <CardContent className="flex-1 space-y-2">
               <button
                 type="button"
                 onClick={() => onSelectProject(null)}
@@ -251,7 +297,9 @@ export function WorkspaceOverview({
               </button>
 
               {projectSummaries.length === 0 ? (
-                <p className="text-[13px] text-[var(--vk-text-muted)]">No configured projects yet.</p>
+                <div className="flex h-full min-h-[180px] items-center justify-center rounded-[6px] border border-dashed border-[var(--vk-border)] bg-[var(--vk-bg-main)] px-4 text-center text-[13px] text-[var(--vk-text-muted)]">
+                  No configured projects yet.
+                </div>
               ) : projectSummaries.slice(0, 6).map((project) => (
                 <button
                   key={project.id}

package/web/.next/standalone/packages/web/src/hooks/useSessionOutputStream.ts

@@ -5,6 +5,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 type OutputStreamEvent =
   | { type: "output"; output: string }
   | { type: "delta"; line: string }
+  | { type: "refresh" }
   | { type: "error"; error: string };
 
 interface UseSessionOutputStreamOptions {
@@ -108,6 +109,11 @@ export function useSessionOutputStream(
             return;
           }
 
+          if (payload.type === "refresh") {
+            void fetchOutput();
+            return;
+          }
+
           if (payload.type === "error") {
             const normalized = (payload.error || "").toLowerCase();
             setConnected(false);
@@ -129,6 +135,11 @@ export function useSessionOutputStream(
         }
       };
 
+      eventSource.addEventListener("refresh", () => {
+        if (!mountedRef.current) return;
+        void fetchOutput();
+      });
+
       eventSource.onerror = () => {
         if (!mountedRef.current) return;
         setConnected(false);

package/web/.next/standalone/packages/web/src/lib/auth.ts

@@ -1,10 +1,12 @@
-import type { DashboardAccessConfig, DashboardRole } from "@conductor-oss/core/types";
+import { existsSync, statSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { findConfigFile, loadConfig } from "@conductor-oss/core";
+import type { DashboardAccessConfig, DashboardRole, OrchestratorConfig } from "@conductor-oss/core/types";
 import { cookies, headers } from "next/headers";
 import { NextRequest, NextResponse } from "next/server";
 import { resolveRoleForEmail, roleMeetsRequirement, isLoopbackHost } from "@/lib/accessControl";
 import { verifyTrustedEdgeIdentity } from "@/lib/edgeAuth";
 import { BUILTIN_REMOTE_SESSION_COOKIE, isBuiltinRemoteAuthEnabled, verifyBuiltinRemoteSession } from "@/lib/remoteAuth";
-import { getServices } from "@/lib/services";
 
 const clerkConfigured = Boolean(
   process.env.NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY && process.env.CLERK_SECRET_KEY,
@@ -26,6 +28,17 @@ export interface DashboardAccess {
   reason?: string;
 }
 
+type DashboardConfigSnapshot = {
+  access: DashboardAccessConfig | null;
+  dashboardUrl: string | null;
+};
+
+const globalForDashboardConfig = globalThis as typeof globalThis & {
+  _conductorDashboardConfig?: DashboardConfigSnapshot;
+  _conductorDashboardConfigPath?: string | null;
+  _conductorDashboardConfigMtimeMs?: number | null;
+};
+
 function parseCsv(value?: string): string[] {
   return (value ?? "")
     .split(",")
@@ -129,12 +142,76 @@ function passesLegacyEmailRestrictions(email: string): boolean {
   return emailAllowed && domainAllowed;
 }
 
-async function loadAccessConfig(): Promise<DashboardAccessConfig | null> {
+function resolveDashboardConfigPath(): string | null {
+  const envConfigPath = process.env.CO_CONFIG_PATH?.trim();
+  if (envConfigPath) {
+    const resolvedPath = resolve(envConfigPath);
+    return existsSync(resolvedPath) ? resolvedPath : null;
+  }
+
+  const workspaceHint = process.env.CONDUCTOR_WORKSPACE?.trim();
+  if (workspaceHint) {
+    const resolvedHint = resolve(workspaceHint);
+    if (/^conductor\.ya?ml$/i.test(basename(resolvedHint))) {
+      return existsSync(resolvedHint) ? resolvedHint : null;
+    }
+
+    const workspaceConfigPath = findConfigFile(resolvedHint);
+    if (workspaceConfigPath) {
+      return workspaceConfigPath;
+    }
+  }
+
+  return findConfigFile() ?? null;
+}
+
+function readDashboardConfigSnapshot(configPath: string): DashboardConfigSnapshot {
+  const config = loadConfig(configPath) as OrchestratorConfig;
+  return {
+    access: config.access ?? null,
+    dashboardUrl: config.dashboardUrl?.trim() || null,
+  };
+}
+
+function loadDashboardConfigSnapshot(): DashboardConfigSnapshot {
+  const configPath = resolveDashboardConfigPath();
+  const mtimeMs = configPath
+    ? (() => {
+        try {
+          return statSync(configPath).mtimeMs;
+        } catch {
+          return null;
+        }
+      })()
+    : null;
+
+  if (
+    globalForDashboardConfig._conductorDashboardConfig
+    && globalForDashboardConfig._conductorDashboardConfigPath === configPath
+    && globalForDashboardConfig._conductorDashboardConfigMtimeMs === mtimeMs
+  ) {
+    return globalForDashboardConfig._conductorDashboardConfig;
+  }
+
+  const fallback = { access: null, dashboardUrl: null };
+  if (!configPath) {
+    globalForDashboardConfig._conductorDashboardConfig = fallback;
+    globalForDashboardConfig._conductorDashboardConfigPath = null;
+    globalForDashboardConfig._conductorDashboardConfigMtimeMs = null;
+    return fallback;
+  }
+
   try {
-    const { config } = await getServices();
-    return config.access ?? null;
+    const snapshot = readDashboardConfigSnapshot(configPath);
+    globalForDashboardConfig._conductorDashboardConfig = snapshot;
+    globalForDashboardConfig._conductorDashboardConfigPath = configPath;
+    globalForDashboardConfig._conductorDashboardConfigMtimeMs = mtimeMs;
+    return snapshot;
   } catch {
-    return null;
+    globalForDashboardConfig._conductorDashboardConfig = fallback;
+    globalForDashboardConfig._conductorDashboardConfigPath = configPath;
+    globalForDashboardConfig._conductorDashboardConfigMtimeMs = mtimeMs;
+    return fallback;
   }
 }
 
@@ -320,7 +397,8 @@ async function resolveClerkAccess(access: DashboardAccessConfig | null): Promise
 }
 
 export async function getDashboardAccess(request?: Request): Promise<DashboardAccess> {
-  const access = await loadAccessConfig();
+  const dashboardConfig = loadDashboardConfigSnapshot();
+  const access = dashboardConfig.access;
   const host = await currentHost(request);
 
   const trustedHeaderAccess = await resolveTrustedHeaderAccess(request, access);
@@ -336,15 +414,13 @@ export async function getDashboardAccess(request?: Request): Promise<DashboardAc
 
   // Trust the configured dashboardUrl host (for remote access via tunnels like ngrok).
   let isTrustedDashboardHost = false;
-  try {
-    const { config } = await getServices();
-    const configuredDashboardUrl = config.dashboardUrl?.trim();
-    if (configuredDashboardUrl) {
-      const dashboardHost = new URL(configuredDashboardUrl).hostname.toLowerCase();
+  if (dashboardConfig.dashboardUrl) {
+    try {
+      const dashboardHost = new URL(dashboardConfig.dashboardUrl).hostname.toLowerCase();
       isTrustedDashboardHost = host.toLowerCase() === dashboardHost;
+    } catch {
+      // Ignore malformed dashboard URLs and continue with default host checks.
     }
-  } catch {
-    // Ignore config lookup errors and continue with default host checks.
   }
 
   if (!isLoopbackHost(host) && !isTrustedDashboardHost) {

package/web/.next/standalone/packages/web/src/lib/guardedRustProxy.ts

@@ -0,0 +1,25 @@
+import type { DashboardRole } from "@conductor-oss/core/types";
+import { NextRequest } from "next/server";
+import { guardApiAccess, guardApiActionAccess } from "@/lib/auth";
+import { proxyToRustOrUnavailable } from "@/lib/rustBackendProxy";
+
+type ProxyOptions = {
+  role?: DashboardRole;
+  requireActionGuard?: boolean;
+};
+
+export async function guardAndProxy(
+  request: Request,
+  pathname: string,
+  options: ProxyOptions = {},
+): Promise<Response> {
+  const denied = await guardApiAccess(request, options.role ?? "viewer");
+  if (denied) return denied;
+
+  if (options.requireActionGuard) {
+    const deniedAction = guardApiActionAccess(request as NextRequest);
+    if (deniedAction) return deniedAction;
+  }
+
+  return proxyToRustOrUnavailable(request, pathname);
+}

package/web/.next/standalone/packages/web/src/lib/liveEvents.ts

@@ -6,6 +6,59 @@ type SnapshotListener = (event: SSESnapshotEvent) => void;
 
 const listeners = new Set<SnapshotListener>();
 let eventSource: EventSource | null = null;
+let refreshInFlight: Promise<void> | null = null;
+
+function normalizeSessionArray(value: unknown): SSESnapshotEvent | null {
+  if (Array.isArray(value)) {
+    return { type: "snapshot", sessions: value as SSESnapshotEvent["sessions"] };
+  }
+
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+
+  if ((value as SSESnapshotEvent).type !== "snapshot") {
+    return null;
+  }
+
+  const payload = value as SSESnapshotEvent;
+  return Array.isArray(payload.sessions) ? payload : null;
+}
+
+function dispatchSnapshots(payload: SSESnapshotEvent) {
+  for (const listener of listeners) {
+    listener(payload);
+  }
+}
+
+async function refreshSessions() {
+  if (typeof fetch !== "function") {
+    return;
+  }
+
+  const load = (async () => {
+    try {
+      const response = await fetch("/api/sessions");
+      if (!response.ok) {
+        return;
+      }
+      const body = await response.json().catch(() => null);
+      const payload = normalizeSessionArray(body);
+      if (!payload) return;
+      dispatchSnapshots(payload);
+    } catch {
+      // Ignore transient refresh failures.
+    }
+  })();
+
+  refreshInFlight = load.finally(() => {
+    if (refreshInFlight === load) {
+      refreshInFlight = null;
+    }
+  });
+
+  await load;
+}
 
 function ensureEventSource() {
   if (eventSource || typeof EventSource === "undefined") {
@@ -15,18 +68,22 @@ function ensureEventSource() {
   eventSource = new EventSource("/api/events");
   eventSource.onmessage = (event) => {
     try {
-      const payload = JSON.parse(event.data as string) as SSESnapshotEvent;
-      if (payload.type !== "snapshot" || !Array.isArray(payload.sessions)) {
-        return;
-      }
-      for (const listener of listeners) {
-        listener(payload);
-      }
+      const payload = normalizeSessionArray(JSON.parse(event.data as string));
+      if (!payload) return;
+      dispatchSnapshots(payload);
     } catch {
       // Ignore malformed snapshot events.
     }
   };
 
+  eventSource.addEventListener("refresh", () => {
+    if (!refreshInFlight) {
+      void refreshSessions();
+    } else {
+      void refreshInFlight;
+    }
+  });
+
   eventSource.onerror = () => {
     if (listeners.size === 0) {
       eventSource?.close();

package/web/.next/standalone/packages/web/src/lib/proxyRoutes.ts

@@ -0,0 +1,46 @@
+import type { DashboardRole } from "@conductor-oss/core/types";
+import { guardAndProxy } from "@/lib/guardedRustProxy";
+import { proxyToRustOrUnavailable } from "@/lib/rustBackendProxy";
+
+type GuardOptions = {
+  role?: DashboardRole;
+  requireActionGuard?: boolean;
+};
+
+type RouteParams = Record<string, string | undefined>;
+type RouteContext = { params: Promise<RouteParams> | RouteParams };
+
+export function guardedProxyRoute(pathname: string, options: GuardOptions = {}) {
+  return async function proxyRoute(request: Request): Promise<Response> {
+    return guardAndProxy(request, pathname, options);
+  };
+}
+
+export function guardedProxyParamRoute(
+  buildPathname: (params: RouteParams) => string,
+  options: GuardOptions = {},
+) {
+  return async function proxyParamRoute(
+    request: Request,
+    context: RouteContext,
+  ): Promise<Response> {
+    const params = await context.params;
+    return guardAndProxy(request, buildPathname(params), options);
+  };
+}
+
+export function openProxyRoute(pathname: string) {
+  return async function proxyRoute(request: Request): Promise<Response> {
+    return proxyToRustOrUnavailable(request, pathname);
+  };
+}
+
+export function openProxyParamRoute(buildPathname: (params: RouteParams) => string) {
+  return async function proxyParamRoute(
+    request: Request,
+    context: RouteContext,
+  ): Promise<Response> {
+    const params = await context.params;
+    return proxyToRustOrUnavailable(request, buildPathname(params));
+  };
+}

package/web/.next/standalone/packages/web/src/lib/runtimeAgentModels.ts

@@ -362,7 +362,7 @@ function getClaudeAccessForModel(model: string): AgentModelAccess[] {
     return ["max", "api"];
   }
   if (normalized === "haiku" || normalized.includes("claude-haiku")) {
-    return ["api"];
+    return ["pro", "max", "api"];
   }
   return ["pro", "max", "api"];
 }

package/web/.next/standalone/packages/web/src/lib/rustBackendProxy.ts

@@ -0,0 +1,154 @@
+import { NextResponse } from "next/server";
+
+const backendUrl = process.env.CONDUCTOR_BACKEND_URL?.trim() ?? "";
+
+const BLOCKED_REQUEST_HEADERS = new Set<string>([
+  "connection",
+  "host",
+  "content-length",
+  "expect",
+  "upgrade",
+  "proxy-authorization",
+  "proxy-authenticate",
+  "te",
+  "trailers",
+  "transfer-encoding",
+  "accept-encoding",
+]);
+
+const BLOCKED_RESPONSE_HEADERS = new Set([
+  "connection",
+  "content-length",
+  "content-encoding",
+  "keep-alive",
+  "transfer-encoding",
+]);
+
+export function hasRustBackend(): boolean {
+  return backendUrl.length > 0;
+}
+
+function isEventStreamResponse(response: Response): boolean {
+  return response.headers.get("content-type")?.toLowerCase().includes("text/event-stream") ?? false;
+}
+
+function isIgnorableStreamTermination(error: unknown): boolean {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+
+  const candidate = error as {
+    name?: string;
+    code?: string;
+    message?: string;
+    cause?: unknown;
+  };
+
+  if (candidate.name === "AbortError" || candidate.code === "UND_ERR_SOCKET") {
+    return true;
+  }
+
+  if (candidate.message?.toLowerCase().includes("terminated")) {
+    return true;
+  }
+
+  return candidate.cause ? isIgnorableStreamTermination(candidate.cause) : false;
+}
+
+function wrapEventStreamBody(body: ReadableStream<Uint8Array> | null): ReadableStream<Uint8Array> | null {
+  if (!body) {
+    return null;
+  }
+
+  const reader = body.getReader();
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        if (!isIgnorableStreamTermination(error)) {
+          controller.error(error);
+          return;
+        }
+        controller.close();
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } catch {
+        // Ignore cancellations from an already-closed upstream SSE socket.
+      }
+    },
+  });
+}
+
+export async function proxyToRust(request: Request, pathname: string): Promise<Response> {
+  if (!hasRustBackend()) {
+    throw new Error("Rust backend URL is not configured");
+  }
+
+  const incomingUrl = new URL(request.url);
+  const target = new URL(pathname, backendUrl);
+  target.search = incomingUrl.search;
+
+  const headers = new Headers();
+  request.headers.forEach((value, key) => {
+    if (!BLOCKED_REQUEST_HEADERS.has(key.toLowerCase())) {
+      headers.set(key, value);
+    }
+  });
+  headers.set("x-forwarded-proto", incomingUrl.protocol.replace(":", ""));
+  headers.set("x-forwarded-host", incomingUrl.host);
+
+  const init: RequestInit = {
+    method: request.method,
+    headers,
+    redirect: "manual",
+    cache: "no-store",
+  };
+
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    const body = await request.arrayBuffer();
+    if (body.byteLength > 0) {
+      init.body = body;
+    }
+  }
+
+  const response = await fetch(target, init);
+  const responseHeaders = new Headers();
+  response.headers.forEach((value, key) => {
+    if (!BLOCKED_RESPONSE_HEADERS.has(key.toLowerCase())) {
+      responseHeaders.set(key, value);
+    }
+  });
+
+  return new Response(isEventStreamResponse(response) ? wrapEventStreamBody(response.body) : response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: responseHeaders,
+  });
+}
+
+export async function proxyToRustOrUnavailable(request: Request, pathname: string): Promise<Response> {
+  if (!hasRustBackend()) {
+    return NextResponse.json(
+      { error: "Rust backend URL is not configured" },
+      { status: 503 },
+    );
+  }
+
+  try {
+    return await proxyToRust(request, pathname);
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to reach Rust backend" },
+      { status: 502 },
+    );
+  }
+}

package/web/.next/standalone/packages/web/src/proxy.ts

@@ -13,26 +13,9 @@ const clerkConfigured = Boolean(
 );
 
 const backendUrl = process.env.CONDUCTOR_BACKEND_URL?.trim() || "";
-const RUST_API_PREFIXES = [
-  "/api/agents",
-  "/api/config",
-  "/api/preferences",
-  "/api/access",
-  "/api/events",
-  "/api/spawn",
-  "/api/sessions",
-  "/api/health",
-  "/api/executor/health",
-  "/api/repositories",
-  "/api/workspaces",
-  "/api/filesystem",
-  "/api/context-files",
-  "/api/boards",
-  "/api/github/repos",
-  "/api/attachments",
-  "/api/notifications",
-  "/api/auth/session",
-];
+// Sensitive browser API requests should terminate in Next so the route-level auth,
+// role checks, and CSRF/origin guards are consistently enforced.
+const RUST_API_PREFIXES: string[] = [];
 
 function shouldProxyToRust(pathname: string): boolean {
   return backendUrl.length > 0 && RUST_API_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`));

package/web/.next/static/chunks/{5c7e8425945ad682.js → 07a5ac7389686572.js}

@@ -1 +1 @@
-(globalThis.TURBOPACK||(globalThis.TURBOPACK=[])).push(["object"==typeof document?document.currentScript:void 0,34640,e=>{"use strict";var l=e.i(95187);let t=(0,l.createServerReference)("001ea7161acf37120fbad6a94bf5d4b7fb96c391a6",l.callServer,void 0,l.findSourceMapURL,"createOrReadKeylessAction");e.s(["createOrReadKeylessAction",()=>t])},37572,e=>{"use strict";var l=e.i(18566),t=e.i(71645),a=e.i(34640);let s=e=>{var s;let{children:i}=e,r=(null==(s=(0,l.useSelectedLayoutSegments)()[0])?void 0:s.startsWith("/_not-found"))||!1,[n,c]=t.default.useActionState(a.createOrReadKeylessAction,null);return((0,t.useEffect)(()=>{r||t.default.startTransition(()=>{c()})},[r]),t.default.isValidElement(i))?t.default.cloneElement(i,{key:null==n?void 0:n.publishableKey,publishableKey:null==n?void 0:n.publishableKey,__internal_keyless_claimKeylessApplicationUrl:null==n?void 0:n.claimUrl,__internal_keyless_copyInstanceKeysUrl:null==n?void 0:n.apiKeysUrl,__internal_bypassMissingPublishableKey:!0}):i};e.s(["KeylessCreatorOrReader",()=>s])}]);
+(globalThis.TURBOPACK||(globalThis.TURBOPACK=[])).push(["object"==typeof document?document.currentScript:void 0,85153,e=>{"use strict";var l=e.i(95187);let t=(0,l.createServerReference)("00bb3e598d529d314ff41b96ac038ed48fc3f7d9be",l.callServer,void 0,l.findSourceMapURL,"createOrReadKeylessAction");e.s(["createOrReadKeylessAction",()=>t])},37572,e=>{"use strict";var l=e.i(18566),t=e.i(71645),s=e.i(85153);let a=e=>{var a;let{children:i}=e,r=(null==(a=(0,l.useSelectedLayoutSegments)()[0])?void 0:a.startsWith("/_not-found"))||!1,[n,c]=t.default.useActionState(s.createOrReadKeylessAction,null);return((0,t.useEffect)(()=>{r||t.default.startTransition(()=>{c()})},[r]),t.default.isValidElement(i))?t.default.cloneElement(i,{key:null==n?void 0:n.publishableKey,publishableKey:null==n?void 0:n.publishableKey,__internal_keyless_claimKeylessApplicationUrl:null==n?void 0:n.claimUrl,__internal_keyless_copyInstanceKeysUrl:null==n?void 0:n.apiKeysUrl,__internal_bypassMissingPublishableKey:!0}):i};e.s(["KeylessCreatorOrReader",()=>a])}]);