create-windy 0.4.0 → 0.5.0

package/template/apps/server/src/system/system-resource-monitoring.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "bun:test";
+import {
+  calculateCpuMonitor,
+  createGpuMonitorProbe,
+  type CpuSample,
+} from "./system-resource-monitoring.js";
+
+describe("系统 CPU 与 GPU 监控", () => {
+  test("CPU 占用按宿主机时间和逻辑核心归一化进程时间计算", () => {
+    const previous: CpuSample = {
+      hostIdleMilliseconds: 2_000,
+      hostTotalMilliseconds: 10_000,
+      processMicroseconds: 1_000_000,
+      observedAtMicroseconds: 5_000_000,
+      logicalCores: 4,
+      loadAverage1m: 1,
+    };
+    const snapshot = calculateCpuMonitor(previous, {
+      hostIdleMilliseconds: 2_400,
+      hostTotalMilliseconds: 11_000,
+      processMicroseconds: 1_800_000,
+      observedAtMicroseconds: 6_000_000,
+      logicalCores: 4,
+      loadAverage1m: 1.5,
+    });
+
+    expect(snapshot).toMatchObject({
+      hostUsagePercent: 60,
+      processUsagePercent: 20,
+      logicalCores: 4,
+      loadAverage1m: 1.5,
+    });
+  });
+
+  test("NVIDIA 指标关联设备利用率与 AI 计算进程显存", async () => {
+    const probe = createGpuMonitorProbe(async (args) =>
+      args[0]?.startsWith("--query-gpu=")
+        ? {
+            exitCode: 0,
+            stdout: '0, GPU-abc, "NVIDIA RTX 5000", 75, 8192, 32768, 62\n',
+          }
+        : {
+            exitCode: 0,
+            stdout: 'GPU-abc, 4321, "python ai-service.py", 7168\n',
+          },
+    );
+
+    await expect(probe()).resolves.toMatchObject({
+      status: "available",
+      devices: [
+        {
+          index: 0,
+          name: "NVIDIA RTX 5000",
+          usagePercent: 75,
+          memoryUsagePercent: 25,
+          temperatureCelsius: 62,
+          processes: [
+            {
+              pid: 4321,
+              name: "python ai-service.py",
+              usedMemoryBytes: 7_168 * 1_024 ** 2,
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("没有 nvidia-smi 时返回可解释的不可探测状态", async () => {
+    const probe = createGpuMonitorProbe(async () => ({
+      exitCode: null,
+      stdout: "",
+      missing: true,
+    }));
+
+    await expect(probe()).resolves.toMatchObject({
+      status: "not-detected",
+      provider: "NVIDIA",
+      devices: [],
+    });
+  });
+});

package/template/apps/server/src/system/system-resource-monitoring.ts

@@ -0,0 +1,300 @@
+import { cpus, loadavg } from "node:os";
+
+export interface CpuMonitorSnapshot {
+  status: "available";
+  logicalCores: number;
+  hostUsagePercent: number | null;
+  processUsagePercent: number | null;
+  loadAverage1m: number | null;
+  message?: string;
+}
+
+export interface GpuProcessSnapshot {
+  pid: number;
+  name: string;
+  usedMemoryBytes: number | null;
+}
+
+export interface GpuDeviceSnapshot {
+  index: number;
+  uuid: string;
+  name: string;
+  usagePercent: number | null;
+  memoryUsedBytes: number | null;
+  memoryTotalBytes: number | null;
+  memoryUsagePercent: number | null;
+  temperatureCelsius: number | null;
+  processes: GpuProcessSnapshot[];
+}
+
+export interface GpuMonitorSnapshot {
+  status: "available" | "not-detected" | "unavailable";
+  provider: "NVIDIA";
+  devices: GpuDeviceSnapshot[];
+  message: string;
+}
+
+export type CpuMonitorProbe = () => Promise<CpuMonitorSnapshot>;
+export type GpuMonitorProbe = () => Promise<GpuMonitorSnapshot>;
+
+export interface CpuSample {
+  hostIdleMilliseconds: number;
+  hostTotalMilliseconds: number;
+  processMicroseconds: number;
+  observedAtMicroseconds: number;
+  logicalCores: number;
+  loadAverage1m: number | null;
+}
+
+export function createCpuMonitorProbe(
+  readSample: () => CpuSample = systemCpuSample,
+): CpuMonitorProbe {
+  let previous = readSample();
+  return async () => {
+    const current = readSample();
+    const snapshot = calculateCpuMonitor(previous, current);
+    previous = current;
+    return snapshot;
+  };
+}
+
+export function calculateCpuMonitor(
+  previous: CpuSample,
+  current: CpuSample,
+): CpuMonitorSnapshot {
+  const totalDelta =
+    current.hostTotalMilliseconds - previous.hostTotalMilliseconds;
+  const idleDelta =
+    current.hostIdleMilliseconds - previous.hostIdleMilliseconds;
+  const elapsedMicroseconds =
+    current.observedAtMicroseconds - previous.observedAtMicroseconds;
+  const processDelta =
+    current.processMicroseconds - previous.processMicroseconds;
+  const hostUsagePercent =
+    totalDelta > 0 ? percent(1 - Math.max(0, idleDelta) / totalDelta) : null;
+  const processUsagePercent =
+    elapsedMicroseconds > 0 && current.logicalCores > 0
+      ? percent(
+          Math.max(0, processDelta) /
+            elapsedMicroseconds /
+            current.logicalCores,
+        )
+      : null;
+  return {
+    status: "available",
+    logicalCores: current.logicalCores,
+    hostUsagePercent,
+    processUsagePercent,
+    loadAverage1m: current.loadAverage1m,
+    message:
+      hostUsagePercent === null || processUsagePercent === null
+        ? "等待下一次刷新以计算 CPU 占用。"
+        : undefined,
+  };
+}
+
+interface CommandResult {
+  exitCode: number | null;
+  stdout: string;
+  missing?: boolean;
+  timedOut?: boolean;
+}
+
+export type NvidiaSmiRunner = (args: string[]) => Promise<CommandResult>;
+
+export function createGpuMonitorProbe(
+  run: NvidiaSmiRunner = runNvidiaSmi,
+): GpuMonitorProbe {
+  return async () => {
+    const deviceResult = await run([
+      "--query-gpu=index,uuid,name,utilization.gpu,memory.used,memory.total,temperature.gpu",
+      "--format=csv,noheader,nounits",
+    ]);
+    if (deviceResult.missing) {
+      return {
+        status: "not-detected",
+        provider: "NVIDIA",
+        devices: [],
+        message:
+          "未检测到 nvidia-smi；当前仅支持 NVIDIA GPU，容器部署还需挂载 GPU 设备和驱动能力。",
+      };
+    }
+    if (deviceResult.exitCode !== 0) {
+      return {
+        status: "unavailable",
+        provider: "NVIDIA",
+        devices: [],
+        message: deviceResult.timedOut
+          ? "NVIDIA GPU 指标采集超时。"
+          : "nvidia-smi 查询失败，无法读取 GPU 指标。",
+      };
+    }
+    const devices = parseGpuDevices(deviceResult.stdout);
+    if (!devices.length) {
+      return {
+        status: "not-detected",
+        provider: "NVIDIA",
+        devices: [],
+        message: "nvidia-smi 未返回可用的 NVIDIA GPU。",
+      };
+    }
+    const processResult = await run([
+      "--query-compute-apps=gpu_uuid,pid,process_name,used_gpu_memory",
+      "--format=csv,noheader,nounits",
+    ]);
+    if (processResult.exitCode === 0) {
+      attachGpuProcesses(devices, processResult.stdout);
+    }
+    return {
+      status: "available",
+      provider: "NVIDIA",
+      devices,
+      message:
+        processResult.exitCode === 0
+          ? "GPU 利用率为设备采样值；进程列表展示计算进程的显存占用。"
+          : "GPU 设备指标可用，但计算进程明细暂不可用。",
+    };
+  };
+}
+
+function systemCpuSample(): CpuSample {
+  const cores = cpus();
+  const totals = cores.reduce(
+    (result, core) => {
+      const values = Object.values(core.times);
+      result.idle += core.times.idle;
+      result.total += values.reduce((total, value) => total + value, 0);
+      return result;
+    },
+    { idle: 0, total: 0 },
+  );
+  const processUsage = process.cpuUsage();
+  return {
+    hostIdleMilliseconds: totals.idle,
+    hostTotalMilliseconds: totals.total,
+    processMicroseconds: processUsage.user + processUsage.system,
+    observedAtMicroseconds: Number(process.hrtime.bigint() / 1_000n),
+    logicalCores: cores.length,
+    loadAverage1m: process.platform === "win32" ? null : loadavg()[0] || 0,
+  };
+}
+
+function percent(ratio: number): number {
+  return Number((Math.min(1, Math.max(0, ratio)) * 100).toFixed(2));
+}
+
+async function runNvidiaSmi(args: string[]): Promise<CommandResult> {
+  if (!Bun.which("nvidia-smi")) {
+    return { exitCode: null, stdout: "", missing: true };
+  }
+  const child = Bun.spawn(["nvidia-smi", ...args], {
+    stdout: "pipe",
+    stderr: "ignore",
+  });
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  const result = await Promise.race([
+    child.exited.then((exitCode) => ({ exitCode, timedOut: false })),
+    new Promise<{ exitCode: null; timedOut: true }>((resolve) => {
+      timeout = setTimeout(
+        () => resolve({ exitCode: null, timedOut: true }),
+        1_500,
+      );
+    }),
+  ]);
+  if (timeout) clearTimeout(timeout);
+  if (result.timedOut) {
+    child.kill();
+    await child.exited;
+    return { exitCode: null, stdout: "", timedOut: true };
+  }
+  return {
+    exitCode: result.exitCode,
+    stdout: await new Response(child.stdout).text(),
+  };
+}
+
+function parseGpuDevices(output: string): GpuDeviceSnapshot[] {
+  return output
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .flatMap((line) => {
+      const values = parseCsvLine(line);
+      if (values.length !== 7) return [];
+      const memoryUsedMiB = metric(values[4]);
+      const memoryTotalMiB = metric(values[5]);
+      return [
+        {
+          index: metric(values[0]) ?? 0,
+          uuid: values[1] || "",
+          name: values[2] || "NVIDIA GPU",
+          usagePercent: metric(values[3]),
+          memoryUsedBytes: mebibytes(memoryUsedMiB),
+          memoryTotalBytes: mebibytes(memoryTotalMiB),
+          memoryUsagePercent:
+            memoryUsedMiB !== null &&
+            memoryTotalMiB !== null &&
+            memoryTotalMiB > 0
+              ? percent(memoryUsedMiB / memoryTotalMiB)
+              : null,
+          temperatureCelsius: metric(values[6]),
+          processes: [],
+        },
+      ];
+    });
+}
+
+function attachGpuProcesses(
+  devices: GpuDeviceSnapshot[],
+  output: string,
+): void {
+  const byUuid = new Map(devices.map((device) => [device.uuid, device]));
+  for (const line of output.split(/\r?\n/).filter(Boolean)) {
+    const values = parseCsvLine(line);
+    const device = byUuid.get(values[0] || "");
+    if (!device || values.length !== 4) continue;
+    const pid = metric(values[1]);
+    if (pid === null) continue;
+    device.processes.push({
+      pid,
+      name: values[2] || "未知进程",
+      usedMemoryBytes: mebibytes(metric(values[3])),
+    });
+  }
+}
+
+function metric(value: string | undefined): number | null {
+  const normalized = value?.trim();
+  if (!normalized || normalized === "N/A" || normalized === "[Not Supported]") {
+    return null;
+  }
+  const parsed = Number(normalized);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function mebibytes(value: number | null): number | null {
+  return value === null ? null : value * 1_024 ** 2;
+}
+
+function parseCsvLine(line: string): string[] {
+  const values: string[] = [];
+  let value = "";
+  let quoted = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const character = line[index]!;
+    if (character === '"') {
+      if (quoted && line[index + 1] === '"') {
+        value += '"';
+        index += 1;
+      } else {
+        quoted = !quoted;
+      }
+    } else if (character === "," && !quoted) {
+      values.push(value.trim());
+      value = "";
+    } else {
+      value += character;
+    }
+  }
+  values.push(value.trim());
+  return values;
+}

package/template/apps/web/src/composables/useWatermarkSettings.webtest.ts

@@ -30,6 +30,8 @@ describe("全局水印策略状态", () => {
       density: "high",
       contentFields: ["custom"],
       customContent: "全局审计",
+      opacityPercent: 12,
+      fontSize: 18,
     });
     const { useWatermarkSettings } = await import("./useWatermarkSettings");
     const watermark = useWatermarkSettings(shallowRef(undefined));
@@ -42,6 +44,8 @@ describe("全局水印策略状态", () => {
       density: "high",
       contentFields: ["custom"],
       customContent: "全局审计",
+      opacityPercent: 12,
+      fontSize: 18,
     });
     expect(localStorageRead).not.toHaveBeenCalled();
     expect(localStorageWrite).not.toHaveBeenCalled();
@@ -54,6 +58,8 @@ describe("全局水印策略状态", () => {
       density: "medium",
       contentFields: ["username", "displayName"],
       customContent: "",
+      opacityPercent: 8,
+      fontSize: 14,
     });
     api.update.mockResolvedValue({
       enabled: true,
@@ -61,6 +67,8 @@ describe("全局水印策略状态", () => {
       density: "high",
       contentFields: ["username", "custom"],
       customContent: "  内部资料  ",
+      opacityPercent: 16,
+      fontSize: 20,
     });
     const { useWatermarkSettings } = await import("./useWatermarkSettings");
     const actor = shallowRef({
@@ -80,6 +88,8 @@ describe("全局水印策略状态", () => {
       density: "high",
       contentFields: ["username", "custom"],
       customContent: "内部资料",
+      opacityPercent: 16,
+      fontSize: 20,
     });
 
     expect(api.update).toHaveBeenCalledWith({
@@ -88,6 +98,8 @@ describe("全局水印策略状态", () => {
       density: "high",
       contentFields: ["username", "custom"],
       customContent: "内部资料",
+      opacityPercent: 16,
+      fontSize: 20,
     });
     expect(second.policy.value).toEqual({
       enabled: true,
@@ -95,6 +107,8 @@ describe("全局水印策略状态", () => {
       density: "high",
       contentFields: ["username", "custom"],
       customContent: "内部资料",
+      opacityPercent: 16,
+      fontSize: 20,
     });
   });
 });

package/template/apps/web/src/composables/watermark-settings.ts

@@ -3,6 +3,8 @@ import {
   DEFAULT_PLATFORM_WATERMARK_POLICY,
   WATERMARK_CONTENT_FIELDS,
   WATERMARK_DENSITIES,
+  WATERMARK_FONT_SIZE_RANGE,
+  WATERMARK_OPACITY_RANGE,
   type PlatformWatermarkPolicy,
   type WatermarkContentField,
   type WatermarkDensity,
@@ -16,8 +18,6 @@ const DENSITY_GAPS: Record<
   medium: { horizontal: 72, vertical: 48 },
   high: { horizontal: 36, vertical: 24 },
 };
-const FONT_SIZE = 14;
-const LINE_HEIGHT = 22;
 const ROTATION_RADIANS = (22 * Math.PI) / 180;
 const MAX_LINE_WEIGHT = 32;
 
@@ -58,15 +58,26 @@ export function normalizeWatermarkPolicy(
       ),
     ),
   ];
+  const enabled = Boolean(value.enabled && value.businessPagesEnabled);
   return {
-    enabled: value.enabled,
-    businessPagesEnabled: value.businessPagesEnabled,
+    enabled,
+    businessPagesEnabled: enabled,
     density,
     contentFields:
       contentFields.length > 0
         ? contentFields
         : [...DEFAULT_PLATFORM_WATERMARK_POLICY.contentFields],
     customContent: value.customContent.trim().slice(0, 80),
+    opacityPercent: boundedInteger(
+      value.opacityPercent,
+      WATERMARK_OPACITY_RANGE,
+      DEFAULT_PLATFORM_WATERMARK_POLICY.opacityPercent,
+    ),
+    fontSize: boundedInteger(
+      value.fontSize,
+      WATERMARK_FONT_SIZE_RANGE,
+      DEFAULT_PLATFORM_WATERMARK_POLICY.fontSize,
+    ),
   };
 }
 
@@ -78,10 +89,19 @@ export interface WatermarkPattern {
 export function createWatermarkPattern(
   content: string,
   density: WatermarkDensity,
+  fontSize: number,
 ): WatermarkPattern {
+  const safeFontSize = boundedInteger(
+    fontSize,
+    WATERMARK_FONT_SIZE_RANGE,
+    DEFAULT_PLATFORM_WATERMARK_POLICY.fontSize,
+  );
+  const lineHeight = Math.ceil(safeFontSize * 1.57);
   const lines = wrapWatermarkContent(content);
-  const textWidth = Math.max(...lines.map(estimatedTextWidth));
-  const textHeight = lines.length * LINE_HEIGHT;
+  const textWidth = Math.max(
+    ...lines.map((line) => estimatedTextWidth(line, safeFontSize)),
+  );
+  const textHeight = lines.length * lineHeight;
   const rotatedWidth =
     textWidth * Math.cos(ROTATION_RADIANS) +
     textHeight * Math.sin(ROTATION_RADIANS);
@@ -91,17 +111,17 @@ export function createWatermarkPattern(
   const gap = DENSITY_GAPS[density];
   const width = Math.ceil(rotatedWidth + gap.horizontal);
   const height = Math.ceil(rotatedHeight + gap.vertical);
-  const firstLineY = (height - textHeight) / 2 + FONT_SIZE;
+  const firstLineY = (height - textHeight) / 2 + safeFontSize;
   const tspans = lines
     .map(
       (line, index) =>
-        `<tspan x="${width / 2}" y="${firstLineY + index * LINE_HEIGHT}">${escapeXml(line)}</tspan>`,
+        `<tspan x="${width / 2}" y="${firstLineY + index * lineHeight}">${escapeXml(line)}</tspan>`,
     )
     .join("");
   const svg =
     `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">` +
     `<g transform="rotate(-22 ${width / 2} ${height / 2})">` +
-    `<text text-anchor="middle" font-family="system-ui,sans-serif" font-size="${FONT_SIZE}" font-weight="500" fill="black">${tspans}</text>` +
+    `<text text-anchor="middle" font-family="system-ui,sans-serif" font-size="${safeFontSize}" font-weight="500" fill="black">${tspans}</text>` +
     "</g></svg>";
   return {
     image: `url("data:image/svg+xml,${encodeURIComponent(svg)}")`,
@@ -125,8 +145,8 @@ function wrapWatermarkContent(content: string): string[] {
   return lines.length > 0 ? lines : [""];
 }
 
-function estimatedTextWidth(value: string): number {
-  return Math.max(1, textWeight(value)) * (FONT_SIZE * 0.56);
+function estimatedTextWidth(value: string, fontSize: number): number {
+  return Math.max(1, textWeight(value)) * (fontSize * 0.56);
 }
 
 function textWeight(value: string): number {
@@ -145,3 +165,12 @@ function escapeXml(value: string): string {
     .replaceAll('"', "&quot;")
     .replaceAll("'", "&apos;");
 }
+
+function boundedInteger(
+  value: number,
+  range: { readonly min: number; readonly max: number },
+  fallback: number,
+): number {
+  if (!Number.isFinite(value)) return fallback;
+  return Math.min(range.max, Math.max(range.min, Math.round(value)));
+}

package/template/apps/web/src/composables/watermark-settings.webtest.ts

@@ -73,8 +73,8 @@ describe("水印设置", () => {
   test("高密度缩小平铺单元且长内容自动换行以避免相邻水印重叠", () => {
     const content =
       "zhangsan · 张三 · 13800138000 · zs@example.com · 内部资料请勿外传";
-    const low = createWatermarkPattern(content, "low");
-    const high = createWatermarkPattern(content, "high");
+    const low = createWatermarkPattern(content, "low", 14);
+    const high = createWatermarkPattern(content, "high", 14);
     const dimensions = (value: typeof low) =>
       value.size.match(/\d+/g)!.map(Number);
 
@@ -86,21 +86,34 @@ describe("水印设置", () => {
     ).toBeGreaterThan(1);
   });
 
-  test("服务端策略内容会被规范化后渲染", () => {
+  test("字体大小会改变平铺尺寸并写入实际 SVG", () => {
+    const small = createWatermarkPattern("zhangsan · 张三", "medium", 12);
+    const large = createWatermarkPattern("zhangsan · 张三", "medium", 32);
+    const width = (value: typeof small) => Number(value.size.match(/\d+/)?.[0]);
+
+    expect(width(large)).toBeGreaterThan(width(small));
+    expect(decodeURIComponent(large.image)).toContain('font-size="32"');
+  });
+
+  test("服务端策略内容会被规范化后渲染且旧范围开关合并到总开关", () => {
     expect(
       normalizeWatermarkPolicy({
-        enabled: false,
-        businessPagesEnabled: true,
+        enabled: true,
+        businessPagesEnabled: false,
         density: "high",
         contentFields: ["phone", "phone"],
         customContent: `  ${"x".repeat(100)}  `,
+        opacityPercent: 99,
+        fontSize: 2,
       }),
     ).toEqual({
       enabled: false,
-      businessPagesEnabled: true,
+      businessPagesEnabled: false,
       density: "high",
       contentFields: ["phone"],
       customContent: "x".repeat(80),
+      opacityPercent: 30,
+      fontSize: 12,
     });
   });
 });

package/template/apps/web/src/layout/AppSidebar.vue

@@ -193,7 +193,12 @@ function findMenu(menus: MenuNode[], key: string): MenuNode | undefined {
       >
         <div
           data-testid="sidebar-brand-logo"
-          class="flex size-8 max-w-full shrink-0 items-center justify-center overflow-hidden rounded-lg bg-primary text-primary-foreground [&>svg]:size-5 group-data-[collapsible=icon]:size-4 group-data-[collapsible=icon]:rounded-sm group-data-[collapsible=icon]:[&>svg]:size-4"
+          class="flex size-8 max-w-full shrink-0 items-center justify-center overflow-hidden rounded-lg [&>svg]:size-5 group-data-[collapsible=icon]:size-4 group-data-[collapsible=icon]:rounded-sm group-data-[collapsible=icon]:[&>svg]:size-4"
+          :class="
+            platform.branding.value.logoUrl
+              ? 'bg-transparent text-sidebar-foreground'
+              : 'bg-primary text-primary-foreground'
+          "
         >
           <img
             v-if="platform.branding.value.logoUrl"

package/template/apps/web/src/layout/AppSidebar.webtest.ts

@@ -96,6 +96,8 @@ describe("AppSidebar", () => {
     expect(brandLink.classes()).toContain("group-data-[collapsible=icon]:p-0");
     expect(logo.classes()).toContain("group-data-[collapsible=icon]:size-4");
     expect(logo.classes()).toContain("overflow-hidden");
+    expect(logo.classes()).toContain("bg-transparent");
+    expect(logo.classes()).not.toContain("bg-primary");
     wrapper.unmount();
   });
 

package/template/apps/web/src/layout/GlobalWatermark.layering.webtest.ts

@@ -17,6 +17,8 @@ const state = vi.hoisted(() => {
       density: "medium",
       contentFields: ["username", "displayName"],
       customContent: "",
+      opacityPercent: 8,
+      fontSize: 14,
     },
   };
 

package/template/apps/web/src/layout/GlobalWatermark.vue

@@ -31,17 +31,16 @@ const allowed = computed(() => {
       props.scope === "admin" ? "system.watermark.read" : undefined,
   }).allowed;
 });
-const scopeEnabled = computed(
-  () => props.scope === "admin" || watermark.policy.value.businessPagesEnabled,
-);
 const patternStyle = computed<StyleValue>(() => {
   const pattern = createWatermarkPattern(
     watermark.content.value,
     watermark.policy.value.density,
+    watermark.policy.value.fontSize,
   );
   return {
     "--watermark-image": pattern.image,
     "--watermark-size": pattern.size,
+    opacity: watermark.policy.value.opacityPercent / 100,
   };
 });
 </script>
@@ -50,12 +49,9 @@ const patternStyle = computed<StyleValue>(() => {
   <Teleport to="body">
     <div
       v-if="
-        allowed &&
-        scopeEnabled &&
-        watermark.policy.value.enabled &&
-        watermark.content.value
+        allowed && watermark.policy.value.enabled && watermark.content.value
       "
-      class="global-watermark pointer-events-none fixed inset-0 isolate z-[60] transform-gpu bg-foreground opacity-[0.075] dark:opacity-[0.11]"
+      class="global-watermark pointer-events-none fixed inset-0 isolate z-[60] transform-gpu bg-foreground"
       :style="patternStyle"
       aria-hidden="true"
       data-testid="global-watermark"