@superblocksteam/sdk 2.0.119-next.1 → 2.0.120-next.0

package/src/dev-utils/dev-server.mts

@@ -1,5 +1,5 @@
 import * as child_process from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import type http from "node:http";
 import net from "node:net";
 import os from "node:os";
@@ -37,6 +37,10 @@ import pkg from "../../package.json" with { type: "json" };
 import type { SuperblocksSdk } from "../sdk.js";
 import { getTracer } from "../telemetry/index.js";
 import { getErrorMeta, getLogger } from "../telemetry/logging.js";
+import {
+  startMemoryMetrics,
+  stopMemoryMetrics,
+} from "../telemetry/memory-metrics.js";
 import {
   EDIT_APPLICATION_SCOPE,
   type SuperblocksScopedJwtPayload,
@@ -48,6 +52,12 @@ import {
   customComponentsPlugin,
   isCustomComponentsEnabled,
 } from "./custom-build.mjs";
+import { dedupeAsync } from "./dedupe-async.js";
+import {
+  type DevServerEndpoint,
+  type DevServerFailureType,
+  devServerMetrics,
+} from "./dev-server-metrics.mjs";
 import {
   formatViteDevServerStartedLog,
   logViteBuildError,
@@ -56,6 +66,60 @@ import { buildManifestStubPlugin } from "./vite-plugin-build-manifest-stub.mjs";
 import { ddRumPlugin } from "./vite-plugin-dd-rum.mjs";
 
 const tracer = getTracer();
+const logger = getLogger();
+
+/**
+ * Maps a dev-server request URL onto a low-cardinality endpoint label for
+ * metrics. Returns undefined for non-`/_sb_*` URLs (Vite-proxied traffic).
+ */
+function endpointForUrl(
+  url: string | undefined,
+): DevServerEndpoint | undefined {
+  if (!url) return undefined;
+  const path = url.split("?", 1)[0];
+  switch (path) {
+    case "/_sb_health":
+      return "_sb_health";
+    case "/_sb_connect":
+      return "_sb_connect";
+    case "/_sb_activate":
+      return "_sb_activate";
+    case "/_sb_disconnect":
+      return "_sb_disconnect";
+    case "/_sb_status":
+      return "_sb_status";
+    case "/_sb_activity":
+      return "_sb_activity";
+    case "/_sb_persist":
+      return "_sb_persist";
+    case "/_sb_ready":
+      return "_sb_ready";
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Extracts a coarse failure-type label from `res.locals.sbFailureType`,
+ * which endpoints set just before they error out. Stays server-side
+ * rather than leaking through response headers.
+ */
+function failureTypeFromLocals(
+  locals: Record<string, unknown>,
+): DevServerFailureType {
+  const value = locals?.sbFailureType;
+  if (typeof value !== "string") return "none";
+  switch (value) {
+    case "auth":
+    case "validation":
+    case "branch_mismatch":
+    case "vite_init":
+    case "internal":
+      return value;
+    default:
+      return "none";
+  }
+}
 
 function reactPlugin() {
   return react({
@@ -123,6 +187,29 @@ function vitePlugins(
   ];
 }
 
+// .superblocks subdirectories that should survive pod recycles.
+// Everything else under .superblocks/ is excluded automatically.
+const PERSIST_SUPERBLOCKS_SAFELIST = new Set(["context", "drafts"]);
+
+/**
+ * Build tar --exclude flags for .superblocks/ subdirectories that are NOT
+ * in the safelist.  If .superblocks/ doesn't exist we exclude it entirely.
+ */
+export function getSuperblocksTarExcludes(root: string): string[] {
+  const dotSuperblocks = path.join(root, ".superblocks");
+  let entries: string[];
+  try {
+    entries = readdirSync(dotSuperblocks, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return ["--exclude", ".superblocks"];
+  }
+  return entries
+    .filter((name) => !PERSIST_SUPERBLOCKS_SAFELIST.has(name))
+    .flatMap((name) => ["--exclude", `.superblocks/${name}`]);
+}
+
 export async function createWorkspacePersistArchive(root: string) {
   // Warm pods already have template dependencies installed, so persist only
   // user workspace files and let startup reconcile package drift if needed.
@@ -136,8 +223,7 @@ export async function createWorkspacePersistArchive(root: string) {
         ".git",
         "--exclude",
         "node_modules",
-        "--exclude",
-        ".superblocks",
+        ...getSuperblocksTarExcludes(root),
         "-C",
         root,
         ".",
@@ -213,11 +299,64 @@ export async function createWorkspacePersistArchive(root: string) {
   });
 }
 
+export function createWorkspacePersistUploadHeaders(
+  archiveLength: number,
+  uploadHeaders: Record<string, string> = {},
+) {
+  const headers = new Headers(uploadHeaders);
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/zstd");
+  }
+  headers.set("Content-Length", String(archiveLength));
+  return Object.fromEntries(headers.entries());
+}
+
+export function isWorkspacePersistUploadHeaders(
+  uploadHeaders: unknown,
+): uploadHeaders is Record<string, string> | undefined {
+  if (uploadHeaders === undefined) {
+    return true;
+  }
+  if (
+    uploadHeaders === null ||
+    typeof uploadHeaders !== "object" ||
+    Array.isArray(uploadHeaders)
+  ) {
+    return false;
+  }
+  const seen = new Set<string>();
+  for (const [key, value] of Object.entries(uploadHeaders)) {
+    if (typeof key !== "string" || typeof value !== "string") {
+      return false;
+    }
+    // Header names are case-insensitive. Two keys that differ only in casing
+    // (e.g. `Content-Type` + `content-type`) would be silently combined by
+    // `new Headers()` into a comma-joined value, which breaks S3 presigned
+    // PUTs that signed a single canonical value. Reject up front so the
+    // caller fixes the duplicate rather than getting a confusing S3 4xx.
+    const lower = key.toLowerCase();
+    if (seen.has(lower)) {
+      return false;
+    }
+    seen.add(lower);
+  }
+  // Validate header name/value syntax by attempting to construct a Headers
+  // instance. Doing this in the validator (rather than letting it throw
+  // later inside `createWorkspacePersistUploadHeaders`) keeps the failure
+  // mode as a 400 before any archive work runs.
+  try {
+    new Headers(uploadHeaders as Record<string, string>);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
 export const RESTART_EXIT_CODE = 98;
 
 function getJwksUriWithBaseUrl(superblocksBaseUrl?: string): string {
   if (process.env.SUPERBLOCKS_JWKS_URI) {
-    console.debug(
+    logger.debug(
       `[JWKS] Using override SUPERBLOCKS_JWKS_URI=${process.env.SUPERBLOCKS_JWKS_URI}`,
     );
     return process.env.SUPERBLOCKS_JWKS_URI;
@@ -254,7 +393,7 @@ function getJwksUriWithBaseUrl(superblocksBaseUrl?: string): string {
     jwksUri = "https://staging-cdn.superblocks.com/.well-known/jwks.json";
   }
 
-  console.debug(`[JWKS] Derived jwksUri=${jwksUri} from baseUrl=${baseUrl}`);
+  logger.debug(`[JWKS] Derived jwksUri=${jwksUri} from baseUrl=${baseUrl}`);
   return jwksUri;
 }
 
@@ -282,10 +421,57 @@ interface CreateDevServerOptions {
    * causes 502s from the gateway during the warm -> full server transition.
    */
   existingServer?: http.Server;
+  /**
+   * Wall-clock timestamp (Date.now()) when the warm-standby /_sb_activate POST
+   * was accepted. When provided, the dev server records the elapsed time from
+   * activation acceptance to full Express handler attachment as the
+   * `dev_server_warm_activation_handoff_duration_ms` histogram — the window
+   * during which the gateway can return 502s if the warm server stops
+   * responding before the full server takes over.
+   */
+  warmActivationStart?: number;
 }
 
 let httpServer: http.Server;
 
+/**
+ * Attaches a passive metrics-only listener for WebSocket upgrade attempts on
+ * the dev-server's HTTP socket.
+ *
+ * The outcome is a heuristic, not a direct accept/reject signal:
+ *   - `accepted` = the socket closed cleanly (no `hadError`) or stayed open
+ *                  past the 30s defensive timer. A long-lived HMR connection
+ *                  is the typical success case.
+ *   - `rejected` = the socket emitted `error` or closed with `hadError=true`.
+ * A clean rejection by the upstream WS layer (write 401 + end) can therefore
+ * bucket as `accepted` if the close event has no `hadError` flag — the WS
+ * handling layer does not surface a direct accept signal we can observe here.
+ *
+ * MUST be called only after Vite (or another component) has registered its own
+ * `'upgrade'` listener on the same server. Registering this listener first
+ * suppresses Node's default close-on-unhandled behavior, which would leave
+ * editor upgrade attempts hanging until client timeout in the pre-Vite window.
+ */
+function attachUpgradeMetricsListener(server: http.Server): void {
+  server.on("upgrade", (req, socket) => {
+    let recorded = false;
+    const recordOnce = (outcome: "accepted" | "rejected") => {
+      if (recorded) return;
+      recorded = true;
+      devServerMetrics.recordSocketUpgrade(outcome);
+    };
+    socket.once("close", (hadError: boolean) => {
+      recordOnce(hadError ? "rejected" : "accepted");
+    });
+    socket.once("error", () => recordOnce("rejected"));
+    // Defensive: if neither close nor error fires within 30s, count as accepted
+    // — a long-lived HMR connection is the success case for upgrades.
+    setTimeout(() => recordOnce("accepted"), 30_000).unref();
+    // Avoid lint warning for unused param without changing the listener shape.
+    void req;
+  });
+}
+
 // The "Dev Server" is a long-running HTTP server that manages the Vite server
 export async function createDevServer({
   root,
@@ -303,6 +489,7 @@ export async function createDevServer({
   sdk,
   superblocksBaseUrl: explicitBaseUrl,
   existingServer,
+  warmActivationStart,
 }: CreateDevServerOptions) {
   const logger = getLogger(loggerOverride);
   if (httpServer) {
@@ -346,7 +533,31 @@ export async function createDevServer({
   // attached at the viteStartPromise call site.
   vitePromise.catch(() => {});
 
-  async function gracefulShutdown({
+  // Dedupe re-entry. Multiple signals (SIGINT, SIGTERM, SIGABRT,
+  // uncaughtException) can fire in rapid succession during shutdown —
+  // particularly when a parent process kills the dev-server and the OS or
+  // test harness then sends a follow-up SIGINT. Without a dedupe, every
+  // signal handler re-runs lockService shutdown / vite close / httpServer
+  // close on already-freed native state, which surfaces as
+  // `double free or corruption (fasttop)` from glibc and SIGABRT killing
+  // the process before it can exit cleanly (hq-o55a).
+  //
+  // First-caller-wins on args: the second+ caller's `switchingTo` /
+  // `initiatedByEmail` are intentionally dropped (the first caller's run is
+  // already in flight; we don't restart cleanup with new args). The
+  // `/_sb_disconnect` HTTP handler that awaits `gracefulShutdown` therefore
+  // returns "ok" without applying its `switchingTo` if a signal beat it to
+  // the punch — the process exits regardless, so the dropped arg cannot
+  // drive downstream state in this process.
+  const gracefulShutdown = dedupeAsync(runGracefulShutdown, {
+    onDuplicate: (args) => {
+      logger.info(
+        `Shutdown already in progress; ignoring duplicate signal (source=${args.source ?? "unknown"})`,
+      );
+    },
+  });
+
+  async function runGracefulShutdown({
     logger,
     serverInitiated,
     switchingTo,
@@ -356,8 +567,16 @@ export async function createDevServer({
     serverInitiated: boolean;
     switchingTo?: "local" | "cloud" | "none";
     initiatedByEmail?: string;
-  }) {
+    /**
+     * Identifies what triggered the shutdown (signal name, "uncaughtException",
+     * or "/_sb_disconnect"). Threaded through so the dedupe-duplicate log can
+     * disambiguate "4 OS signals fired" from "1 signal fired and cleanup
+     * panicked 3 times".
+     */
+    source?: string;
+  }): Promise<void> {
     try {
+      stopMemoryMetrics();
       await lockService?.shutdown({
         serverInitiated,
         switchingTo,
@@ -401,6 +620,29 @@ export async function createDevServer({
     }),
   );
 
+  // Per-request metrics for dev-server endpoints. Identify the endpoint by URL
+  // pattern, time the request, record duration + status + coarse failure type
+  // when the response finishes. Non-`/_sb_*` traffic (Vite proxied requests)
+  // is not instrumented here — Vite's own middleware handles those.
+  app.use((req, res, next) => {
+    const endpoint = endpointForUrl(req.url);
+    if (!endpoint) {
+      return next();
+    }
+    const startedAt = Date.now();
+    res.on("finish", () => {
+      const failureType = failureTypeFromLocals(res.locals);
+      devServerMetrics.recordEndpoint(
+        endpoint,
+        req.method,
+        res.statusCode,
+        Date.now() - startedAt,
+        failureType,
+      );
+    });
+    next();
+  });
+
   app.use((req, res, next) => {
     res.setHeader("Cache-Control", "no-store, max-age=0");
     res.setHeader("x-csb-no-sw-proxy", "1");
@@ -514,6 +756,7 @@ export async function createDevServer({
     if (result.success) {
       return next();
     } else {
+      res.locals.sbFailureType = "auth";
       res.status(result.status).send(JSON.stringify({ error: result.error }));
     }
   };
@@ -537,6 +780,7 @@ export async function createDevServer({
         logger.info(
           `[dev-server-runtime] _sb_connect application mismatch: expected ${resourceConfig!.id}, got ${req.headers["x-superblocks-application-id"]}`,
         );
+        res.locals.sbFailureType = "validation";
         res.status(401).send(
           JSON.stringify({
             error: `Application ID header mismatch. Expected ${resourceConfig!.id}, received ${req.headers["x-superblocks-application-id"]}`,
@@ -559,6 +803,7 @@ export async function createDevServer({
         logger.info(
           `[dev-server-runtime] _sb_connect branch mismatch: expected ${currentBranch}, got ${incomingBranch}`,
         );
+        res.locals.sbFailureType = "branch_mismatch";
         res.status(401).send(
           JSON.stringify({
             error: `Dev server expects branch ${currentBranch}, but received ${incomingBranch}. Check your current branch with 'git branch' and try again.`,
@@ -579,6 +824,7 @@ export async function createDevServer({
         "Vite server failed to initialize",
         getErrorMeta(e as Error),
       );
+      res.locals.sbFailureType = "vite_init";
       res
         .status(500)
         .send(JSON.stringify({ error: "Dev server failed to initialize" }));
@@ -624,6 +870,7 @@ export async function createDevServer({
           serverInitiated: true,
           switchingTo,
           initiatedByEmail: initiatedByEmail as string | undefined,
+          source: "/_sb_disconnect",
         });
         res.send("ok");
       }
@@ -681,11 +928,21 @@ export async function createDevServer({
     persistInProgress = true;
     const persistStart = Date.now();
     try {
-      const { uploadURL } = req.body as { uploadURL: string };
+      const { uploadURL, uploadHeaders } = req.body as {
+        uploadURL: string;
+        uploadHeaders?: unknown;
+      };
       if (!uploadURL) {
         res.status(400).json({ error: "uploadURL required" });
         return;
       }
+      if (!isWorkspacePersistUploadHeaders(uploadHeaders)) {
+        res.status(400).json({
+          error:
+            "uploadHeaders must be a string map with valid HTTP header names and values and no case-insensitive duplicate keys",
+        });
+        return;
+      }
 
       logger.info("/_sb_persist: archiving and uploading workspace to S3...");
 
@@ -699,10 +956,10 @@ export async function createDevServer({
       const uploadResp = await fetch(uploadURL, {
         method: "PUT",
         body: archive,
-        headers: {
-          "Content-Type": "application/zstd",
-          "Content-Length": String(archive.length),
-        },
+        headers: createWorkspacePersistUploadHeaders(
+          archive.length,
+          uploadHeaders,
+        ),
         signal: AbortSignal.timeout(30_000),
       });
 
@@ -724,32 +981,63 @@ export async function createDevServer({
     }
   });
 
-  process.on("SIGINT", async () => {
+  // Signal handlers attach `.catch` so a synchronous throw in
+  // `runGracefulShutdown` (e.g. logger init or lockService shutdown throwing
+  // before the first `await`) is logged rather than surfacing as an
+  // unhandled rejection across N handlers (one per fired signal). Symmetric
+  // with the `uncaughtException` handler below.
+  process.on("SIGINT", () => {
     logger.info("SIGINT received");
-    await gracefulShutdown({ logger, serverInitiated: false });
+    gracefulShutdown({
+      logger,
+      serverInitiated: false,
+      source: "SIGINT",
+    }).catch((err) =>
+      logger.error("Error during SIGINT shutdown", getErrorMeta(err)),
+    );
   });
 
-  process.on("SIGTERM", async () => {
+  process.on("SIGTERM", () => {
     logger.info("SIGTERM received");
-    await gracefulShutdown({ logger, serverInitiated: false });
+    gracefulShutdown({
+      logger,
+      serverInitiated: false,
+      source: "SIGTERM",
+    }).catch((err) =>
+      logger.error("Error during SIGTERM shutdown", getErrorMeta(err)),
+    );
   });
 
-  process.on("SIGABRT", async () => {
+  process.on("SIGABRT", () => {
     logger.info("SIGABRT received");
-    await gracefulShutdown({ logger, serverInitiated: false });
+    gracefulShutdown({
+      logger,
+      serverInitiated: false,
+      source: "SIGABRT",
+    }).catch((err) =>
+      logger.error("Error during SIGABRT shutdown", getErrorMeta(err)),
+    );
   });
 
+  // `uncaughtException` always force-exits in `.finally`, even when the
+  // underlying shutdown promise was already resolved by a prior signal. With
+  // the dedupe in place, awaiting the cached resolved promise short-circuits
+  // through `.then` without firing `.catch`; without the `.finally` the
+  // process would linger in event-loop limbo until the OS killed it.
   process.on("uncaughtException", (error) => {
     logger.error(`Uncaught exception: ${error.message}`, getErrorMeta(error));
-    gracefulShutdown({ logger, serverInitiated: false }).catch(
-      (shutdownError) => {
+    gracefulShutdown({
+      logger,
+      serverInitiated: false,
+      source: "uncaughtException",
+    })
+      .catch((shutdownError) => {
         logger.error(
           "Error during shutdown after uncaught exception:",
           shutdownError,
         );
-        process.exit(1);
-      },
-    );
+      })
+      .finally(() => process.exit(1));
   });
 
   if (existingServer) {
@@ -758,12 +1046,19 @@ export async function createDevServer({
     existingServer.removeAllListeners("request");
     existingServer.on("request", app);
     httpServer = existingServer;
+    if (warmActivationStart) {
+      devServerMetrics.recordWarmHandoff(Date.now() - warmActivationStart);
+    }
     logger.info(
       `Attached full dev server to existing HTTP server on port ${port}`,
     );
   } else {
     logger.info(`Starting HTTP server on port ${port}`);
-    httpServer = await app.listen(port);
+    // `app.listen()` returns `http.Server` synchronously — the previous
+    // `await` was a no-op on a non-Promise. The server isn't actually bound
+    // until it emits `listening`; if downstream code ever depends on the
+    // socket being bound, switch to `new Promise(r => httpServer.once("listening", r))`.
+    httpServer = app.listen(port);
     logger.info(`HTTP server started successfully on port ${port}`);
   }
 
@@ -781,6 +1076,7 @@ export async function createDevServer({
         return undefined;
       });
 
+    const viteEagerInitStart = Date.now();
     const viteStartPromise = startVite({
       port,
       app,
@@ -808,11 +1104,34 @@ export async function createDevServer({
     // below via the rejection branch of .then().
     viteStartPromise.then(
       (result) => {
+        devServerMetrics.recordViteEagerInit(
+          Date.now() - viteEagerInitStart,
+          "success",
+        );
         logger.info("Vite server initialized eagerly");
         viteResolve();
         viteCreationResults = result;
+        // Start memory metrics only for claimed pods (after Vite init, not warm standby).
+        // Gated by either the LD flag (cloud) or the SABS-injected env var (cloud-prem/local).
+        if (
+          featureFlags?.devServerMemoryMetricsEnabled() ||
+          process.env.SUPERBLOCKS_DEV_SERVER_MEMORY_METRICS_ENABLED === "true"
+        ) {
+          startMemoryMetrics();
+        }
+        // Attach the WebSocket upgrade-tracking listener AFTER Vite has
+        // installed its own HMR upgrade handler. Registering an `upgrade`
+        // listener pre-Vite would suppress Node's default close-on-unhandled
+        // behavior, leaving editor upgrade attempts to hang until client
+        // timeout. By deferring until Vite is up, our listener coexists with
+        // the real handler instead of replacing the default close.
+        attachUpgradeMetricsListener(httpServer);
       },
       (e) => {
+        devServerMetrics.recordViteEagerInit(
+          Date.now() - viteEagerInitStart,
+          "error",
+        );
         logger.error("Error initializing vite server", getErrorMeta(e));
         viteReject(e);
       },
@@ -1031,7 +1350,7 @@ const PRE_WARM_TIMEOUT_MS = 60_000;
 
 export async function preWarmViteCache(root: string): Promise<void> {
   const start = Date.now();
-  console.log("[warm] Pre-warming Vite dependency cache...");
+  logger.info("[warm] Pre-warming Vite dependency cache...");
   try {
     const server = await createServer({
       root,
@@ -1053,11 +1372,26 @@ export async function preWarmViteCache(root: string): Promise<void> {
       await new Promise((r) => setTimeout(r, pollMs));
     }
     await server.close();
-    console.log(`[warm] Vite cache warmed in ${Date.now() - start}ms`);
+    devServerMetrics.recordWarmPrewarm(Date.now() - start, "success");
+    logger.info(`[warm] Vite cache warmed in ${Date.now() - start}ms`);
   } catch (error) {
-    console.error(
-      `[warm] Vite cache pre-warm failed (${Date.now() - start}ms) — exiting for fast pod recycle:`,
-      error,
+    const durationMs = Date.now() - start;
+    // Buffer the metric in case `flush()` is somehow drained later; in practice
+    // we exit before activation, so this observation is also surfaced through
+    // the structured log line below — telemetry isn't initialized yet in
+    // warm-standby (no auth token until /_sb_activate), so `configureTelemetry`
+    // can't run here, and synchronously POSTing an OTLP payload before exit
+    // would block pod recycle on a network call that may itself be hung.
+    devServerMetrics.recordWarmPrewarm(durationMs, "error");
+    // Stable inline `key=value` marker so a log-based metric (Datadog
+    // "Generate Metrics from Logs", Loki regex) can recover pre-warm failures
+    // the OTel pipeline misses. The Logger.error signature accepts only
+    // ErrorMeta (no arbitrary attributes) and must stay structurally
+    // compatible with the sister Logger in vite-plugin-file-sync, so the
+    // markers are embedded in the message body instead of passed as fields.
+    logger.error(
+      `[warm] Vite cache pre-warm failed — exiting for fast pod recycle metric=dev_server_warm_prewarm outcome=error duration_ms=${durationMs}`,
+      getErrorMeta(error),
     );
     process.exit(1);
   }
@@ -1071,7 +1405,7 @@ function getFreePort() {
     server.listen(0, () => {
       const address = server.address();
       if (typeof address === "string") {
-        console.debug(
+        logger.debug(
           `Port resolution: falling back to default HMR port ${DEFAULT_HMR_PORT}`,
         );
         resolve(DEFAULT_HMR_PORT);
@@ -1079,13 +1413,13 @@ function getFreePort() {
       }
       const port = address?.port;
       if (!port) {
-        console.debug(
+        logger.debug(
           `Port resolution: no port available, using default HMR port ${DEFAULT_HMR_PORT}`,
         );
         resolve(DEFAULT_HMR_PORT);
         return;
       }
-      console.debug(`Port resolution: successfully allocated port ${port}`);
+      logger.debug(`Port resolution: successfully allocated port ${port}`);
       server.close(() => resolve(port));
     });
   });

package/src/flag.ts

@@ -17,10 +17,6 @@ export class FeatureFlags {
     return this.flags["superblocks.git.split.large.steps.enabled"] ?? false;
   }
 
-  splitLargeApiStepsInNewEnabled(): boolean {
-    return this.flags["superblocks.git.split.large.steps.new.enabled"] ?? false;
-  }
-
   linesForLargeSteps(): number {
     return (
       this.flags["superblocks.git.split.large.step.lines"] ??
@@ -47,4 +43,8 @@ export class FeatureFlags {
   includeDotSuperblocks(): boolean {
     return this.flags["superblocks.deploy.include-dot-superblocks"] ?? false;
   }
+
+  devServerMemoryMetricsEnabled(): boolean {
+    return this.flags["superblocks.dev-server.memory-metrics.enabled"] ?? false;
+  }
 }