@jskit-ai/users-core 0.1.15 → 0.1.17

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/users-core",
-  version: "0.1.15",
+  version: "0.1.17",
   description: "Users/workspace domain runtime plus HTTP routes for workspace, account, and console features.",
   dependsOn: [
     "@jskit-ai/auth-core",
@@ -203,10 +203,10 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/auth-core": "0.1.10",
-        "@jskit-ai/database-runtime": "0.1.10",
-        "@jskit-ai/http-runtime": "0.1.10",
-        "@jskit-ai/kernel": "0.1.10",
+        "@jskit-ai/auth-core": "0.1.12",
+        "@jskit-ai/database-runtime": "0.1.13",
+        "@jskit-ai/http-runtime": "0.1.12",
+        "@jskit-ai/kernel": "0.1.12",
         "@fastify/multipart": "^9.4.0",
         "@fastify/type-provider-typebox": "^6.1.0",
         "typebox": "^1.0.81"
@@ -436,7 +436,7 @@ export default Object.freeze({
         file: "config/server.js",
         position: "bottom",
         skipIfContains: "config.workspaceColor =",
-        value: "\nconfig.workspaceColor = \"indigo\";\n",
+        value: "\nconfig.workspaceColor = \"#1867C0\";\n",
         reason: "Append default server-only users/workspace settings into app-owned config.",
         category: "users-core",
         id: "users-core-server-config"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/users-core",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -24,10 +24,10 @@
     "./shared/resources/consoleSettingsFields": "./src/shared/resources/consoleSettingsFields.js"
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.10",
-    "@jskit-ai/database-runtime": "0.1.10",
-    "@jskit-ai/http-runtime": "0.1.10",
-    "@jskit-ai/kernel": "0.1.10",
+    "@jskit-ai/auth-core": "0.1.12",
+    "@jskit-ai/database-runtime": "0.1.13",
+    "@jskit-ai/http-runtime": "0.1.12",
+    "@jskit-ai/kernel": "0.1.12",
     "@fastify/multipart": "^9.4.0",
     "@fastify/type-provider-typebox": "^6.1.0",
     "typebox": "^1.0.81"

package/src/server/common/formatters/workspaceFormatter.js

@@ -1,21 +1,15 @@
 import {
   coerceWorkspaceColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor
+  resolveWorkspaceThemePalettes
 } from "../../../shared/settings.js";
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
 
 function mapWorkspaceSummary(workspace, membership) {
-  const color = coerceWorkspaceColor(workspace.color);
   return {
     id: Number(workspace.id),
     slug: normalizeText(workspace.slug),
     name: normalizeText(workspace.name),
-    color,
-    secondaryColor: coerceWorkspaceSecondaryColor(workspace.secondaryColor, { color }),
-    surfaceColor: coerceWorkspaceSurfaceColor(workspace.surfaceColor, { color }),
-    surfaceVariantColor: coerceWorkspaceSurfaceVariantColor(workspace.surfaceVariantColor, { color }),
+    color: coerceWorkspaceColor(workspace.color),
     avatarUrl: normalizeText(workspace.avatarUrl),
     roleId: normalizeLowerText(membership?.roleId || "member") || "member",
     isAccessible: normalizeLowerText(membership?.status || "active") === "active"
@@ -26,13 +20,18 @@ function mapWorkspaceSettingsPublic(workspaceSettings, { workspaceInvitationsEna
   const source = workspaceSettings && typeof workspaceSettings === "object" ? workspaceSettings : {};
   const invitesAvailable = workspaceInvitationsEnabled === true;
   const invitesEnabled = invitesAvailable && source.invitesEnabled !== false;
-  const color = coerceWorkspaceColor(source.color);
+  const themePalettes = resolveWorkspaceThemePalettes(source);
+
   return {
     name: normalizeText(source.name),
-    color,
-    secondaryColor: coerceWorkspaceSecondaryColor(source.secondaryColor, { color }),
-    surfaceColor: coerceWorkspaceSurfaceColor(source.surfaceColor, { color }),
-    surfaceVariantColor: coerceWorkspaceSurfaceVariantColor(source.surfaceVariantColor, { color }),
+    lightPrimaryColor: themePalettes.light.color,
+    lightSecondaryColor: themePalettes.light.secondaryColor,
+    lightSurfaceColor: themePalettes.light.surfaceColor,
+    lightSurfaceVariantColor: themePalettes.light.surfaceVariantColor,
+    darkPrimaryColor: themePalettes.dark.color,
+    darkSecondaryColor: themePalettes.dark.secondaryColor,
+    darkSurfaceColor: themePalettes.dark.surfaceColor,
+    darkSurfaceVariantColor: themePalettes.dark.surfaceVariantColor,
     avatarUrl: normalizeText(source.avatarUrl),
     invitesEnabled,
     invitesAvailable,

package/src/server/common/repositories/workspacesRepository.js

@@ -6,12 +6,7 @@ import {
   nowDb,
   isDuplicateEntryError
 } from "./repositoryUtils.js";
-import {
-  coerceWorkspaceColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor
-} from "../../../shared/settings.js";
+import { coerceWorkspaceColor } from "../../../shared/settings.js";
 
 function mapRow(row) {
   if (!row) {
@@ -27,15 +22,6 @@ function mapRow(row) {
     isPersonal: Boolean(row.is_personal),
     avatarUrl: row.avatar_url ? normalizeText(row.avatar_url) : "",
     color,
-    secondaryColor: coerceWorkspaceSecondaryColor(row.secondary_color, {
-      color
-    }),
-    surfaceColor: coerceWorkspaceSurfaceColor(row.surface_color, {
-      color
-    }),
-    surfaceVariantColor: coerceWorkspaceSurfaceVariantColor(row.surface_variant_color, {
-      color
-    }),
     createdAt: toIsoString(row.created_at),
     updatedAt: toIsoString(row.updated_at),
     deletedAt: toNullableIso(row.deleted_at)
@@ -67,10 +53,7 @@ function createRepository(knex) {
       "w.owner_user_id",
       "w.is_personal",
       client.raw("COALESCE(ws.avatar_url, w.avatar_url) as avatar_url"),
-      client.raw("COALESCE(ws.color, w.color) as color"),
-      client.raw("COALESCE(ws.secondary_color, ws.color, w.color) as secondary_color"),
-      client.raw("COALESCE(ws.surface_color, ws.color, w.color) as surface_color"),
-      client.raw("COALESCE(ws.surface_variant_color, ws.color, w.color) as surface_variant_color"),
+      "w.color",
       "w.created_at",
       "w.updated_at",
       "w.deleted_at"

package/src/shared/index.js

@@ -8,19 +8,21 @@ import {
 } from "./roles.js";
 
 import {
-  coerceWorkspaceBackgroundColor,
+  DEFAULT_WORKSPACE_DARK_PALETTE,
+  DEFAULT_WORKSPACE_LIGHT_PALETTE,
   DEFAULT_WORKSPACE_COLOR,
   DEFAULT_USER_SETTINGS,
   coerceWorkspaceColor,
+  coerceWorkspaceThemeColor,
   coerceWorkspaceSecondaryColor,
   coerceWorkspaceSurfaceColor,
   coerceWorkspaceSurfaceVariantColor,
-  deriveWorkspaceBackgroundColor,
-  deriveWorkspaceSecondaryColor,
-  deriveWorkspaceSurfaceColor,
-  deriveWorkspaceSurfaceVariantColor,
-  mixHexColors,
   normalizeWorkspaceHexColor,
+  normalizeWorkspaceThemeMode,
+  resolveWorkspaceThemeDefaultPalette,
+  resolveWorkspaceThemePalettes,
+  WORKSPACE_THEME_MODE_DARK,
+  WORKSPACE_THEME_MODE_LIGHT,
   resolveWorkspaceThemePalette
 } from "./settings.js";
 import {
@@ -51,19 +53,21 @@ const USERS_SHARED_API = Object.freeze({
   resolveRolePermissions,
   listRoleDescriptors,
   hasPermission,
+  DEFAULT_WORKSPACE_LIGHT_PALETTE,
+  DEFAULT_WORKSPACE_DARK_PALETTE,
   DEFAULT_WORKSPACE_COLOR,
   DEFAULT_USER_SETTINGS,
   coerceWorkspaceColor,
+  coerceWorkspaceThemeColor,
   coerceWorkspaceSecondaryColor,
   coerceWorkspaceSurfaceColor,
   coerceWorkspaceSurfaceVariantColor,
-  coerceWorkspaceBackgroundColor,
-  deriveWorkspaceSecondaryColor,
-  deriveWorkspaceSurfaceColor,
-  deriveWorkspaceSurfaceVariantColor,
-  deriveWorkspaceBackgroundColor,
+  WORKSPACE_THEME_MODE_LIGHT,
+  WORKSPACE_THEME_MODE_DARK,
+  normalizeWorkspaceThemeMode,
+  resolveWorkspaceThemeDefaultPalette,
+  resolveWorkspaceThemePalettes,
   normalizeWorkspaceHexColor,
-  mixHexColors,
   resolveWorkspaceThemePalette,
   TENANCY_MODE_NONE,
   TENANCY_MODE_PERSONAL,
@@ -90,19 +94,21 @@ export {
   resolveRolePermissions,
   listRoleDescriptors,
   hasPermission,
+  DEFAULT_WORKSPACE_LIGHT_PALETTE,
+  DEFAULT_WORKSPACE_DARK_PALETTE,
   DEFAULT_WORKSPACE_COLOR,
   DEFAULT_USER_SETTINGS,
   coerceWorkspaceColor,
+  coerceWorkspaceThemeColor,
   coerceWorkspaceSecondaryColor,
   coerceWorkspaceSurfaceColor,
   coerceWorkspaceSurfaceVariantColor,
-  coerceWorkspaceBackgroundColor,
-  deriveWorkspaceSecondaryColor,
-  deriveWorkspaceSurfaceColor,
-  deriveWorkspaceSurfaceVariantColor,
-  deriveWorkspaceBackgroundColor,
+  WORKSPACE_THEME_MODE_LIGHT,
+  WORKSPACE_THEME_MODE_DARK,
+  normalizeWorkspaceThemeMode,
+  resolveWorkspaceThemeDefaultPalette,
+  resolveWorkspaceThemePalettes,
   normalizeWorkspaceHexColor,
-  mixHexColors,
   resolveWorkspaceThemePalette,
   TENANCY_MODE_NONE,
   TENANCY_MODE_PERSONAL,

package/src/shared/settings.js

@@ -1,6 +1,23 @@
-const DEFAULT_WORKSPACE_COLOR = "#2F5D9E";
+const WORKSPACE_THEME_MODE_LIGHT = "light";
+const WORKSPACE_THEME_MODE_DARK = "dark";
 const HEX_COLOR_PATTERN = /^#[0-9A-Fa-f]{6}$/;
 
+const DEFAULT_WORKSPACE_LIGHT_PALETTE = Object.freeze({
+  color: "#1867C0",
+  secondaryColor: "#48A9A6",
+  surfaceColor: "#FFFFFF",
+  surfaceVariantColor: "#424242"
+});
+
+const DEFAULT_WORKSPACE_DARK_PALETTE = Object.freeze({
+  color: "#2196F3",
+  secondaryColor: "#54B6B2",
+  surfaceColor: "#212121",
+  surfaceVariantColor: "#C8C8C8"
+});
+
+const DEFAULT_WORKSPACE_COLOR = DEFAULT_WORKSPACE_LIGHT_PALETTE.color;
+
 const DEFAULT_USER_SETTINGS = Object.freeze({
   theme: "system",
   locale: "en",
@@ -25,124 +42,95 @@ function normalizeWorkspaceHexColor(value) {
   return normalized.toUpperCase();
 }
 
-function clampChannel(value) {
-  if (!Number.isFinite(value)) {
-    return 0;
-  }
-  if (value < 0) {
-    return 0;
-  }
-  if (value > 255) {
-    return 255;
-  }
-  return Math.round(value);
-}
-
-function toHexChannel(value) {
-  return clampChannel(value).toString(16).padStart(2, "0").toUpperCase();
-}
-
-function parseHexColor(value) {
-  const normalized = normalizeWorkspaceHexColor(value);
-  if (!normalized) {
-    return null;
-  }
-  return {
-    red: Number.parseInt(normalized.slice(1, 3), 16),
-    green: Number.parseInt(normalized.slice(3, 5), 16),
-    blue: Number.parseInt(normalized.slice(5, 7), 16)
-  };
-}
-
-function mixHexColors(baseColor, mixColor, mixRatio = 0) {
-  const base = parseHexColor(baseColor);
-  const mixed = parseHexColor(mixColor);
-  if (!base || !mixed) {
-    return "";
-  }
-
-  const ratio = Math.min(1, Math.max(0, Number(mixRatio) || 0));
-  const keepRatio = 1 - ratio;
-  return `#${toHexChannel(base.red * keepRatio + mixed.red * ratio)}${toHexChannel(
-    base.green * keepRatio + mixed.green * ratio
-  )}${toHexChannel(base.blue * keepRatio + mixed.blue * ratio)}`;
-}
-
 function coerceWorkspaceColor(value) {
   return normalizeWorkspaceHexColor(value) || DEFAULT_WORKSPACE_COLOR;
 }
 
-function deriveWorkspaceSecondaryColor(workspaceColor = DEFAULT_WORKSPACE_COLOR) {
-  return mixHexColors(coerceWorkspaceColor(workspaceColor), "#000000", 0.28) || "#224372";
-}
-
-function deriveWorkspaceSurfaceColor(workspaceColor = DEFAULT_WORKSPACE_COLOR) {
-  return mixHexColors(coerceWorkspaceColor(workspaceColor), "#FFFFFF", 0.93) || "#F0F4F8";
-}
-
-function deriveWorkspaceSurfaceVariantColor(workspaceColor = DEFAULT_WORKSPACE_COLOR) {
-  return mixHexColors(coerceWorkspaceColor(workspaceColor), "#FFFFFF", 0.86) || "#E2E8F1";
+function normalizeWorkspaceThemeMode(value = "") {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === WORKSPACE_THEME_MODE_DARK) {
+    return WORKSPACE_THEME_MODE_DARK;
+  }
+  return WORKSPACE_THEME_MODE_LIGHT;
 }
 
-function deriveWorkspaceBackgroundColor(workspaceColor = DEFAULT_WORKSPACE_COLOR) {
-  const surfaceColor = deriveWorkspaceSurfaceColor(workspaceColor);
-  return mixHexColors(surfaceColor, "#FFFFFF", 0.45) || "#F4FAF8";
+function resolveWorkspaceThemeDefaultPalette(mode = WORKSPACE_THEME_MODE_LIGHT) {
+  const normalizedMode = normalizeWorkspaceThemeMode(mode);
+  return normalizedMode === WORKSPACE_THEME_MODE_DARK
+    ? DEFAULT_WORKSPACE_DARK_PALETTE
+    : DEFAULT_WORKSPACE_LIGHT_PALETTE;
 }
 
-function coerceWorkspaceSecondaryColor(value, { color = DEFAULT_WORKSPACE_COLOR } = {}) {
-  return normalizeWorkspaceHexColor(value) || deriveWorkspaceSecondaryColor(color);
+function coerceWorkspaceThemeColor(value, fallbackColor = DEFAULT_WORKSPACE_COLOR) {
+  return normalizeWorkspaceHexColor(value) || normalizeWorkspaceHexColor(fallbackColor) || DEFAULT_WORKSPACE_COLOR;
 }
 
-function coerceWorkspaceSurfaceColor(value, { color = DEFAULT_WORKSPACE_COLOR } = {}) {
-  return normalizeWorkspaceHexColor(value) || deriveWorkspaceSurfaceColor(color);
+function coerceWorkspaceSecondaryColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
+  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).secondaryColor);
 }
 
-function coerceWorkspaceSurfaceVariantColor(value, { color = DEFAULT_WORKSPACE_COLOR } = {}) {
-  return normalizeWorkspaceHexColor(value) || deriveWorkspaceSurfaceVariantColor(color);
+function coerceWorkspaceSurfaceColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
+  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).surfaceColor);
 }
 
-function coerceWorkspaceBackgroundColor(value, { color = DEFAULT_WORKSPACE_COLOR } = {}) {
-  return normalizeWorkspaceHexColor(value) || deriveWorkspaceBackgroundColor(color);
+function coerceWorkspaceSurfaceVariantColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
+  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).surfaceVariantColor);
 }
 
-function resolveWorkspaceThemePalette(input = {}) {
+function resolveWorkspaceThemePalette(input = {}, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
   const source = input && typeof input === "object" ? input : {};
-  const color = coerceWorkspaceColor(source.color);
-  const secondaryColor = coerceWorkspaceSecondaryColor(source.secondaryColor, {
-    color
-  });
-  const surfaceColor = coerceWorkspaceSurfaceColor(source.surfaceColor, {
-    color
-  });
-  const surfaceVariantColor = coerceWorkspaceSurfaceVariantColor(source.surfaceVariantColor, {
-    color
-  });
-  const backgroundColor = coerceWorkspaceBackgroundColor(source.backgroundColor, {
-    color
+  const normalizedMode = normalizeWorkspaceThemeMode(mode);
+  const paletteDefaults = resolveWorkspaceThemeDefaultPalette(normalizedMode);
+
+  if (normalizedMode === WORKSPACE_THEME_MODE_DARK) {
+    return Object.freeze({
+      color: coerceWorkspaceThemeColor(source.darkPrimaryColor, paletteDefaults.color),
+      secondaryColor: coerceWorkspaceThemeColor(source.darkSecondaryColor, paletteDefaults.secondaryColor),
+      surfaceColor: coerceWorkspaceThemeColor(source.darkSurfaceColor, paletteDefaults.surfaceColor),
+      surfaceVariantColor: coerceWorkspaceThemeColor(
+        source.darkSurfaceVariantColor,
+        paletteDefaults.surfaceVariantColor
+      )
+    });
+  }
+
+  return Object.freeze({
+    color: coerceWorkspaceThemeColor(source.lightPrimaryColor, paletteDefaults.color),
+    secondaryColor: coerceWorkspaceThemeColor(source.lightSecondaryColor, paletteDefaults.secondaryColor),
+    surfaceColor: coerceWorkspaceThemeColor(source.lightSurfaceColor, paletteDefaults.surfaceColor),
+    surfaceVariantColor: coerceWorkspaceThemeColor(
+      source.lightSurfaceVariantColor,
+      paletteDefaults.surfaceVariantColor
+    )
   });
+}
 
+function resolveWorkspaceThemePalettes(input = {}) {
   return Object.freeze({
-    color,
-    secondaryColor,
-    surfaceColor,
-    surfaceVariantColor,
-    backgroundColor
+    light: resolveWorkspaceThemePalette(input, {
+      mode: WORKSPACE_THEME_MODE_LIGHT
+    }),
+    dark: resolveWorkspaceThemePalette(input, {
+      mode: WORKSPACE_THEME_MODE_DARK
+    })
   });
 }
 
 export {
+  DEFAULT_WORKSPACE_DARK_PALETTE,
+  DEFAULT_WORKSPACE_LIGHT_PALETTE,
   DEFAULT_WORKSPACE_COLOR,
   DEFAULT_USER_SETTINGS,
-  coerceWorkspaceBackgroundColor,
   coerceWorkspaceColor,
+  coerceWorkspaceThemeColor,
   coerceWorkspaceSecondaryColor,
   coerceWorkspaceSurfaceColor,
   coerceWorkspaceSurfaceVariantColor,
-  deriveWorkspaceBackgroundColor,
-  deriveWorkspaceSecondaryColor,
-  deriveWorkspaceSurfaceColor,
-  deriveWorkspaceSurfaceVariantColor,
-  mixHexColors,
   normalizeWorkspaceHexColor,
+  normalizeWorkspaceThemeMode,
+  resolveWorkspaceThemeDefaultPalette,
+  resolveWorkspaceThemePalettes,
+  WORKSPACE_THEME_MODE_DARK,
+  WORKSPACE_THEME_MODE_LIGHT,
   resolveWorkspaceThemePalette
 };

package/templates/migrations/users_core_initial.cjs

@@ -25,7 +25,7 @@ exports.up = async function up(knex) {
     table.integer("owner_user_id").unsigned().notNullable().references("id").inTable("user_profiles").onDelete("CASCADE");
     table.boolean("is_personal").notNullable().defaultTo(true);
     table.string("avatar_url", 512).notNullable().defaultTo("");
-    table.string("color", 7).notNullable().defaultTo("#2F5D9E");
+    table.string("color", 7).notNullable().defaultTo("#1867C0");
     table.timestamp("created_at", { useTz: false }).notNullable().defaultTo(knex.fn.now());
     table.timestamp("updated_at", { useTz: false }).notNullable().defaultTo(knex.fn.now());
     table.timestamp("deleted_at", { useTz: false }).nullable();
@@ -46,10 +46,14 @@ exports.up = async function up(knex) {
     table.integer("workspace_id").unsigned().primary().references("id").inTable("workspaces").onDelete("CASCADE");
     table.string("name", 160).notNullable().defaultTo("Workspace");
     table.string("avatar_url", 512).notNullable().defaultTo("");
-    table.string("color", 7).notNullable().defaultTo("#2F5D9E");
-    table.string("secondary_color", 7).notNullable().defaultTo("#224372");
-    table.string("surface_color", 7).notNullable().defaultTo("#F0F4F8");
-    table.string("surface_variant_color", 7).notNullable().defaultTo("#E2E8F1");
+    table.string("light_primary_color", 7).notNullable().defaultTo("#1867C0");
+    table.string("light_secondary_color", 7).notNullable().defaultTo("#48A9A6");
+    table.string("light_surface_color", 7).notNullable().defaultTo("#FFFFFF");
+    table.string("light_surface_variant_color", 7).notNullable().defaultTo("#424242");
+    table.string("dark_primary_color", 7).notNullable().defaultTo("#2196F3");
+    table.string("dark_secondary_color", 7).notNullable().defaultTo("#54B6B2");
+    table.string("dark_surface_color", 7).notNullable().defaultTo("#212121");
+    table.string("dark_surface_variant_color", 7).notNullable().defaultTo("#C8C8C8");
     table.boolean("invites_enabled").notNullable().defaultTo(true);
     table.timestamp("created_at", { useTz: false }).notNullable().defaultTo(knex.fn.now());
     table.timestamp("updated_at", { useTz: false }).notNullable().defaultTo(knex.fn.now());

package/templates/packages/main/src/shared/resources/workspaceSettingsFields.js

@@ -4,10 +4,9 @@
 import { Type } from "typebox";
 import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
 import {
-  coerceWorkspaceColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor
+  DEFAULT_WORKSPACE_DARK_PALETTE,
+  DEFAULT_WORKSPACE_LIGHT_PALETTE,
+  coerceWorkspaceThemeColor
 } from "@jskit-ai/users-core/shared/settings";
 import {
   defineField,
@@ -34,10 +33,6 @@ function normalizeHexColor(value) {
   return /^#[0-9A-Fa-f]{6}$/.test(color) ? color.toUpperCase() : null;
 }
 
-function resolveThemeBaseColor({ workspace = {}, settings = {} } = {}) {
-  return normalizeText(settings.color || workspace.color);
-}
-
 resetWorkspaceSettingsFields();
 
 defineField({
@@ -78,101 +73,163 @@ defineField({
 });
 
 defineField({
-  key: "color",
-  dbColumn: "color",
+  key: "lightPrimaryColor",
+  dbColumn: "light_primary_color",
+  required: true,
+  inputSchema: Type.String({
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Light primary color is required.",
+      pattern: "Light primary color must be a hex color like #1867C0.",
+      default: "Light primary color must be a hex color like #1867C0."
+    }
+  }),
+  outputSchema: Type.String({ minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" }),
+  normalizeInput: normalizeHexColor,
+  normalizeOutput: (value) => coerceWorkspaceThemeColor(value, DEFAULT_WORKSPACE_LIGHT_PALETTE.color),
+  resolveDefault: () => DEFAULT_WORKSPACE_LIGHT_PALETTE.color
+});
+
+defineField({
+  key: "lightSecondaryColor",
+  dbColumn: "light_secondary_color",
+  required: true,
+  inputSchema: Type.String({
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Light secondary color is required.",
+      pattern: "Light secondary color must be a hex color like #48A9A6.",
+      default: "Light secondary color must be a hex color like #48A9A6."
+    }
+  }),
+  outputSchema: Type.String({ minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" }),
+  normalizeInput: normalizeHexColor,
+  normalizeOutput: (value) => coerceWorkspaceThemeColor(value, DEFAULT_WORKSPACE_LIGHT_PALETTE.secondaryColor),
+  resolveDefault: () => DEFAULT_WORKSPACE_LIGHT_PALETTE.secondaryColor
+});
+
+defineField({
+  key: "lightSurfaceColor",
+  dbColumn: "light_surface_color",
+  required: true,
+  inputSchema: Type.String({
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Light surface color is required.",
+      pattern: "Light surface color must be a hex color like #FFFFFF.",
+      default: "Light surface color must be a hex color like #FFFFFF."
+    }
+  }),
+  outputSchema: Type.String({ minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" }),
+  normalizeInput: normalizeHexColor,
+  normalizeOutput: (value) => coerceWorkspaceThemeColor(value, DEFAULT_WORKSPACE_LIGHT_PALETTE.surfaceColor),
+  resolveDefault: () => DEFAULT_WORKSPACE_LIGHT_PALETTE.surfaceColor
+});
+
+defineField({
+  key: "lightSurfaceVariantColor",
+  dbColumn: "light_surface_variant_color",
+  required: true,
+  inputSchema: Type.String({
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Light surface variant color is required.",
+      pattern: "Light surface variant color must be a hex color like #424242.",
+      default: "Light surface variant color must be a hex color like #424242."
+    }
+  }),
+  outputSchema: Type.String({ minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" }),
+  normalizeInput: normalizeHexColor,
+  normalizeOutput: (value) => coerceWorkspaceThemeColor(value, DEFAULT_WORKSPACE_LIGHT_PALETTE.surfaceVariantColor),
+  resolveDefault: () => DEFAULT_WORKSPACE_LIGHT_PALETTE.surfaceVariantColor
+});
+
+defineField({
+  key: "darkPrimaryColor",
+  dbColumn: "dark_primary_color",
   required: true,
   inputSchema: Type.String({
     minLength: 7,
     maxLength: 7,
     pattern: "^#[0-9A-Fa-f]{6}$",
     messages: {
-      required: "Workspace color is required.",
-      pattern: "Workspace color must be a hex color like #2F5D9E.",
-      default: "Workspace color must be a hex color like #2F5D9E."
+      required: "Dark primary color is required.",
+      pattern: "Dark primary color must be a hex color like #2196F3.",
+      default: "Dark primary color must be a hex color like #2196F3."
     }
   }),
   outputSchema: Type.String({ minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" }),
   normalizeInput: normalizeHexColor,
-  normalizeOutput: (value) => coerceWorkspaceColor(value),
-  resolveDefault: ({ workspace = {} } = {}) => coerceWorkspaceColor(workspace.color)
+  normalizeOutput: (value) => coerceWorkspaceThemeColor(value, DEFAULT_WORKSPACE_DARK_PALETTE.color),
+  resolveDefault: () => DEFAULT_WORKSPACE_DARK_PALETTE.color
 });
 
 defineField({
-  key: "secondaryColor",
-  dbColumn: "secondary_color",
+  key: "darkSecondaryColor",
+  dbColumn: "dark_secondary_color",
   required: true,
   inputSchema: Type.String({
     minLength: 7,
     maxLength: 7,
     pattern: "^#[0-9A-Fa-f]{6}$",
     messages: {
-      required: "Secondary color is required.",
-      pattern: "Secondary color must be a hex color like #224372.",
-      default: "Secondary color must be a hex color like #224372."
+      required: "Dark secondary color is required.",
+      pattern: "Dark secondary color must be a hex color like #54B6B2.",
+      default: "Dark secondary color must be a hex color like #54B6B2."
     }
   }),
   outputSchema: Type.String({ minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" }),
   normalizeInput: normalizeHexColor,
-  normalizeOutput: (value, { workspace = {}, settings = {} } = {}) =>
-    coerceWorkspaceSecondaryColor(value, {
-      color: resolveThemeBaseColor({ workspace, settings })
-    }),
-  resolveDefault: ({ workspace = {}, settings = {} } = {}) =>
-    coerceWorkspaceSecondaryColor(workspace.secondaryColor, {
-      color: resolveThemeBaseColor({ workspace, settings })
-    })
+  normalizeOutput: (value) => coerceWorkspaceThemeColor(value, DEFAULT_WORKSPACE_DARK_PALETTE.secondaryColor),
+  resolveDefault: () => DEFAULT_WORKSPACE_DARK_PALETTE.secondaryColor
 });
 
 defineField({
-  key: "surfaceColor",
-  dbColumn: "surface_color",
+  key: "darkSurfaceColor",
+  dbColumn: "dark_surface_color",
   required: true,
   inputSchema: Type.String({
     minLength: 7,
     maxLength: 7,
     pattern: "^#[0-9A-Fa-f]{6}$",
     messages: {
-      required: "Surface color is required.",
-      pattern: "Surface color must be a hex color like #F0F4F8.",
-      default: "Surface color must be a hex color like #F0F4F8."
+      required: "Dark surface color is required.",
+      pattern: "Dark surface color must be a hex color like #212121.",
+      default: "Dark surface color must be a hex color like #212121."
     }
   }),
   outputSchema: Type.String({ minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" }),
   normalizeInput: normalizeHexColor,
-  normalizeOutput: (value, { workspace = {}, settings = {} } = {}) =>
-    coerceWorkspaceSurfaceColor(value, {
-      color: resolveThemeBaseColor({ workspace, settings })
-    }),
-  resolveDefault: ({ workspace = {}, settings = {} } = {}) =>
-    coerceWorkspaceSurfaceColor(workspace.surfaceColor, {
-      color: resolveThemeBaseColor({ workspace, settings })
-    })
+  normalizeOutput: (value) => coerceWorkspaceThemeColor(value, DEFAULT_WORKSPACE_DARK_PALETTE.surfaceColor),
+  resolveDefault: () => DEFAULT_WORKSPACE_DARK_PALETTE.surfaceColor
 });
 
 defineField({
-  key: "surfaceVariantColor",
-  dbColumn: "surface_variant_color",
+  key: "darkSurfaceVariantColor",
+  dbColumn: "dark_surface_variant_color",
   required: true,
   inputSchema: Type.String({
     minLength: 7,
     maxLength: 7,
     pattern: "^#[0-9A-Fa-f]{6}$",
     messages: {
-      required: "Surface variant color is required.",
-      pattern: "Surface variant color must be a hex color like #E2E8F1.",
-      default: "Surface variant color must be a hex color like #E2E8F1."
+      required: "Dark surface variant color is required.",
+      pattern: "Dark surface variant color must be a hex color like #C8C8C8.",
+      default: "Dark surface variant color must be a hex color like #C8C8C8."
     }
   }),
   outputSchema: Type.String({ minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" }),
   normalizeInput: normalizeHexColor,
-  normalizeOutput: (value, { workspace = {}, settings = {} } = {}) =>
-    coerceWorkspaceSurfaceVariantColor(value, {
-      color: resolveThemeBaseColor({ workspace, settings })
-    }),
-  resolveDefault: ({ workspace = {}, settings = {} } = {}) =>
-    coerceWorkspaceSurfaceVariantColor(workspace.surfaceVariantColor, {
-      color: resolveThemeBaseColor({ workspace, settings })
-    })
+  normalizeOutput: (value) => coerceWorkspaceThemeColor(value, DEFAULT_WORKSPACE_DARK_PALETTE.surfaceVariantColor),
+  resolveDefault: () => DEFAULT_WORKSPACE_DARK_PALETTE.surfaceVariantColor
 });
 
 defineField({

package/test/workspaceSettingsRepository.test.js

@@ -1,16 +1,14 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import "../test-support/registerDefaultSettingsFields.js";
-import { resolveWorkspaceThemePalette } from "../src/shared/settings.js";
+import { resolveWorkspaceThemePalettes } from "../src/shared/settings.js";
 import { createRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
 
 function createDefaultWorkspaceSettings() {
   return true;
 }
 
-const DEFAULT_WORKSPACE_THEME = resolveWorkspaceThemePalette({
-  color: "#2F5D9E"
-});
+const DEFAULT_WORKSPACE_THEME = resolveWorkspaceThemePalettes({});
 
 function createKnexStub(rowOverrides = {}) {
   const state = {
@@ -20,10 +18,14 @@ function createKnexStub(rowOverrides = {}) {
       workspace_id: 1,
       name: "Workspace",
       avatar_url: "",
-      color: "#2F5D9E",
-      secondary_color: DEFAULT_WORKSPACE_THEME.secondaryColor,
-      surface_color: DEFAULT_WORKSPACE_THEME.surfaceColor,
-      surface_variant_color: DEFAULT_WORKSPACE_THEME.surfaceVariantColor,
+      light_primary_color: DEFAULT_WORKSPACE_THEME.light.color,
+      light_secondary_color: DEFAULT_WORKSPACE_THEME.light.secondaryColor,
+      light_surface_color: DEFAULT_WORKSPACE_THEME.light.surfaceColor,
+      light_surface_variant_color: DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor,
+      dark_primary_color: DEFAULT_WORKSPACE_THEME.dark.color,
+      dark_secondary_color: DEFAULT_WORKSPACE_THEME.dark.secondaryColor,
+      dark_surface_color: DEFAULT_WORKSPACE_THEME.dark.surfaceColor,
+      dark_surface_variant_color: DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor,
       invites_enabled: 1,
       created_at: "2026-03-09 00:26:35.710",
       updated_at: "2026-03-09 00:26:35.710",
@@ -41,10 +43,14 @@ function createKnexStub(rowOverrides = {}) {
           workspace_id: payload.workspace_id,
           name: payload.name,
           avatar_url: payload.avatar_url,
-          color: payload.color,
-          secondary_color: payload.secondary_color,
-          surface_color: payload.surface_color,
-          surface_variant_color: payload.surface_variant_color,
+          light_primary_color: payload.light_primary_color,
+          light_secondary_color: payload.light_secondary_color,
+          light_surface_color: payload.light_surface_color,
+          light_surface_variant_color: payload.light_surface_variant_color,
+          dark_primary_color: payload.dark_primary_color,
+          dark_secondary_color: payload.dark_secondary_color,
+          dark_surface_color: payload.dark_surface_color,
+          dark_surface_variant_color: payload.dark_surface_variant_color,
           invites_enabled: payload.invites_enabled,
           created_at: "2026-03-10 00:00:00.000",
           updated_at: "2026-03-10 00:00:00.000"
@@ -69,17 +75,29 @@ function createKnexStub(rowOverrides = {}) {
             if (Object.hasOwn(payload, "avatar_url")) {
               state.row.avatar_url = payload.avatar_url;
             }
-            if (Object.hasOwn(payload, "color")) {
-              state.row.color = payload.color;
+            if (Object.hasOwn(payload, "light_primary_color")) {
+              state.row.light_primary_color = payload.light_primary_color;
+            }
+            if (Object.hasOwn(payload, "light_secondary_color")) {
+              state.row.light_secondary_color = payload.light_secondary_color;
+            }
+            if (Object.hasOwn(payload, "light_surface_color")) {
+              state.row.light_surface_color = payload.light_surface_color;
+            }
+            if (Object.hasOwn(payload, "light_surface_variant_color")) {
+              state.row.light_surface_variant_color = payload.light_surface_variant_color;
+            }
+            if (Object.hasOwn(payload, "dark_primary_color")) {
+              state.row.dark_primary_color = payload.dark_primary_color;
             }
-            if (Object.hasOwn(payload, "secondary_color")) {
-              state.row.secondary_color = payload.secondary_color;
+            if (Object.hasOwn(payload, "dark_secondary_color")) {
+              state.row.dark_secondary_color = payload.dark_secondary_color;
             }
-            if (Object.hasOwn(payload, "surface_color")) {
-              state.row.surface_color = payload.surface_color;
+            if (Object.hasOwn(payload, "dark_surface_color")) {
+              state.row.dark_surface_color = payload.dark_surface_color;
             }
-            if (Object.hasOwn(payload, "surface_variant_color")) {
-              state.row.surface_variant_color = payload.surface_variant_color;
+            if (Object.hasOwn(payload, "dark_surface_variant_color")) {
+              state.row.dark_surface_variant_color = payload.dark_surface_variant_color;
             }
             if (Object.hasOwn(payload, "updated_at")) {
               state.row.updated_at = payload.updated_at;
@@ -106,10 +124,14 @@ test("workspaceSettingsRepository.findByWorkspaceId maps the stored row", async
     workspaceId: 1,
     name: "Workspace",
     avatarUrl: "",
-    color: "#2F5D9E",
-    secondaryColor: DEFAULT_WORKSPACE_THEME.secondaryColor,
-    surfaceColor: DEFAULT_WORKSPACE_THEME.surfaceColor,
-    surfaceVariantColor: DEFAULT_WORKSPACE_THEME.surfaceVariantColor,
+    lightPrimaryColor: DEFAULT_WORKSPACE_THEME.light.color,
+    lightSecondaryColor: DEFAULT_WORKSPACE_THEME.light.secondaryColor,
+    lightSurfaceColor: DEFAULT_WORKSPACE_THEME.light.surfaceColor,
+    lightSurfaceVariantColor: DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor,
+    darkPrimaryColor: DEFAULT_WORKSPACE_THEME.dark.color,
+    darkSecondaryColor: DEFAULT_WORKSPACE_THEME.dark.secondaryColor,
+    darkSurfaceColor: DEFAULT_WORKSPACE_THEME.dark.surfaceColor,
+    darkSurfaceVariantColor: DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor,
     invitesEnabled: true,
     createdAt: "2026-03-08T16:26:35.710Z",
     updatedAt: "2026-03-08T16:26:35.710Z"
@@ -142,17 +164,31 @@ test("workspaceSettingsRepository.ensureForWorkspaceId inserts the injected defa
   assert.equal(state.insertedRow.workspace_id, 5);
   assert.equal(state.insertedRow.name, "Workspace");
   assert.equal(state.insertedRow.avatar_url, "");
-  assert.equal(state.insertedRow.color, "#2F5D9E");
-  assert.equal(state.insertedRow.secondary_color, DEFAULT_WORKSPACE_THEME.secondaryColor);
-  assert.equal(state.insertedRow.surface_color, DEFAULT_WORKSPACE_THEME.surfaceColor);
-  assert.equal(state.insertedRow.surface_variant_color, DEFAULT_WORKSPACE_THEME.surfaceVariantColor);
+  assert.equal(state.insertedRow.light_primary_color, DEFAULT_WORKSPACE_THEME.light.color);
+  assert.equal(state.insertedRow.light_secondary_color, DEFAULT_WORKSPACE_THEME.light.secondaryColor);
+  assert.equal(state.insertedRow.light_surface_color, DEFAULT_WORKSPACE_THEME.light.surfaceColor);
+  assert.equal(
+    state.insertedRow.light_surface_variant_color,
+    DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor
+  );
+  assert.equal(state.insertedRow.dark_primary_color, DEFAULT_WORKSPACE_THEME.dark.color);
+  assert.equal(state.insertedRow.dark_secondary_color, DEFAULT_WORKSPACE_THEME.dark.secondaryColor);
+  assert.equal(state.insertedRow.dark_surface_color, DEFAULT_WORKSPACE_THEME.dark.surfaceColor);
+  assert.equal(
+    state.insertedRow.dark_surface_variant_color,
+    DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor
+  );
   assert.equal(state.insertedRow.invites_enabled, false);
   assert.equal(record.name, "Workspace");
   assert.equal(record.avatarUrl, "");
-  assert.equal(record.color, "#2F5D9E");
-  assert.equal(record.secondaryColor, DEFAULT_WORKSPACE_THEME.secondaryColor);
-  assert.equal(record.surfaceColor, DEFAULT_WORKSPACE_THEME.surfaceColor);
-  assert.equal(record.surfaceVariantColor, DEFAULT_WORKSPACE_THEME.surfaceVariantColor);
+  assert.equal(record.lightPrimaryColor, DEFAULT_WORKSPACE_THEME.light.color);
+  assert.equal(record.lightSecondaryColor, DEFAULT_WORKSPACE_THEME.light.secondaryColor);
+  assert.equal(record.lightSurfaceColor, DEFAULT_WORKSPACE_THEME.light.surfaceColor);
+  assert.equal(record.lightSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor);
+  assert.equal(record.darkPrimaryColor, DEFAULT_WORKSPACE_THEME.dark.color);
+  assert.equal(record.darkSecondaryColor, DEFAULT_WORKSPACE_THEME.dark.secondaryColor);
+  assert.equal(record.darkSurfaceColor, DEFAULT_WORKSPACE_THEME.dark.surfaceColor);
+  assert.equal(record.darkSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor);
   assert.equal(record.invitesEnabled, false);
 });
 
@@ -165,15 +201,15 @@ test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates name/avata
   const updated = await repository.updateSettingsByWorkspaceId(1, {
     name: "New name",
     avatarUrl: "https://example.com/avatar.png",
-    color: "#123abc"
+    lightPrimaryColor: "#123abc"
   });
 
   assert.equal(state.updatePayload.name, "New name");
   assert.equal(state.updatePayload.avatar_url, "https://example.com/avatar.png");
-  assert.equal(state.updatePayload.color, "#123ABC");
+  assert.equal(state.updatePayload.light_primary_color, "#123ABC");
   assert.equal(updated.name, "New name");
   assert.equal(updated.avatarUrl, "https://example.com/avatar.png");
-  assert.equal(updated.color, "#123ABC");
+  assert.equal(updated.lightPrimaryColor, "#123ABC");
 });
 
 test("workspaceSettingsRepository can be constructed without validating app config shape", () => {

package/test/workspaceSettingsResource.test.js

@@ -2,7 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
 import "../test-support/registerDefaultSettingsFields.js";
-import { resolveWorkspaceThemePalette } from "../src/shared/settings.js";
+import { resolveWorkspaceThemePalettes } from "../src/shared/settings.js";
 import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
 import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
 
@@ -48,10 +48,14 @@ test("workspace settings patch body normalizes valid payload before validation",
   const parsed = parseBody(workspaceSettingsResource.operations.patch, {
     name: "  Team Mercury  ",
     avatarUrl: "https://example.com/avatar.png",
-    color: "#0f6b54",
-    secondaryColor: "#0b4d3c",
-    surfaceColor: "#eef5f3",
-    surfaceVariantColor: "#ddeae7",
+    lightPrimaryColor: "#0f6b54",
+    lightSecondaryColor: "#0b4d3c",
+    lightSurfaceColor: "#eef5f3",
+    lightSurfaceVariantColor: "#ddeae7",
+    darkPrimaryColor: "#123456",
+    darkSecondaryColor: "#234567",
+    darkSurfaceColor: "#345678",
+    darkSurfaceVariantColor: "#456789",
     invitesEnabled: false
   });
 
@@ -60,10 +64,14 @@ test("workspace settings patch body normalizes valid payload before validation",
   assert.deepEqual(parsed.value, {
     name: "Team Mercury",
     avatarUrl: "https://example.com/avatar.png",
-    color: "#0F6B54",
-    secondaryColor: "#0B4D3C",
-    surfaceColor: "#EEF5F3",
-    surfaceVariantColor: "#DDEAE7",
+    lightPrimaryColor: "#0F6B54",
+    lightSecondaryColor: "#0B4D3C",
+    lightSurfaceColor: "#EEF5F3",
+    lightSurfaceVariantColor: "#DDEAE7",
+    darkPrimaryColor: "#123456",
+    darkSecondaryColor: "#234567",
+    darkSurfaceColor: "#345678",
+    darkSurfaceVariantColor: "#456789",
     invitesEnabled: false
   });
 });
@@ -95,16 +103,20 @@ test("workspace settings create body requires full-write fields", () => {
   });
 
   assert.equal(parsed.ok, false);
-  assert.equal(parsed.fieldErrors.color, "Workspace color is required.");
-  assert.equal(parsed.fieldErrors.secondaryColor, "Secondary color is required.");
-  assert.equal(parsed.fieldErrors.surfaceColor, "Surface color is required.");
-  assert.equal(parsed.fieldErrors.surfaceVariantColor, "Surface variant color is required.");
+  assert.equal(parsed.fieldErrors.lightPrimaryColor, "Light primary color is required.");
+  assert.equal(parsed.fieldErrors.lightSecondaryColor, "Light secondary color is required.");
+  assert.equal(parsed.fieldErrors.lightSurfaceColor, "Light surface color is required.");
+  assert.equal(parsed.fieldErrors.lightSurfaceVariantColor, "Light surface variant color is required.");
+  assert.equal(parsed.fieldErrors.darkPrimaryColor, "Dark primary color is required.");
+  assert.equal(parsed.fieldErrors.darkSecondaryColor, "Dark secondary color is required.");
+  assert.equal(parsed.fieldErrors.darkSurfaceColor, "Dark surface color is required.");
+  assert.equal(parsed.fieldErrors.darkSurfaceVariantColor, "Dark surface variant color is required.");
   assert.equal(parsed.fieldErrors.invitesEnabled, "invitesEnabled is required.");
 });
 
 test("workspace settings output normalizes raw service payloads", () => {
-  const expectedTheme = resolveWorkspaceThemePalette({
-    color: "#0F6B54"
+  const expectedTheme = resolveWorkspaceThemePalettes({
+    lightPrimaryColor: "#0F6B54"
   });
   const normalized = workspaceSettingsResource.operations.view.outputValidator.normalize({
     workspace: {
@@ -115,7 +127,7 @@ test("workspace settings output normalizes raw service payloads", () => {
     settings: {
       name: "  Mercury Workspace  ",
       avatarUrl: "  https://example.com/avatar.png  ",
-      color: "#0f6b54",
+      lightPrimaryColor: "#0f6b54",
       invitesEnabled: false
     },
     roleCatalog: createRoleCatalog()
@@ -130,10 +142,14 @@ test("workspace settings output normalizes raw service payloads", () => {
     settings: {
       name: "Mercury Workspace",
       avatarUrl: "https://example.com/avatar.png",
-      color: "#0F6B54",
-      secondaryColor: expectedTheme.secondaryColor,
-      surfaceColor: expectedTheme.surfaceColor,
-      surfaceVariantColor: expectedTheme.surfaceVariantColor,
+      lightPrimaryColor: "#0F6B54",
+      lightSecondaryColor: expectedTheme.light.secondaryColor,
+      lightSurfaceColor: expectedTheme.light.surfaceColor,
+      lightSurfaceVariantColor: expectedTheme.light.surfaceVariantColor,
+      darkPrimaryColor: expectedTheme.dark.color,
+      darkSecondaryColor: expectedTheme.dark.secondaryColor,
+      darkSurfaceColor: expectedTheme.dark.surfaceColor,
+      darkSurfaceVariantColor: expectedTheme.dark.surfaceVariantColor,
       invitesEnabled: false,
       invitesAvailable: true,
       invitesEffective: false

package/test/workspaceSettingsService.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import "../test-support/registerDefaultSettingsFields.js";
-import { resolveWorkspaceThemePalette } from "../src/shared/settings.js";
+import { resolveWorkspaceThemePalettes } from "../src/shared/settings.js";
 import { createService } from "../src/server/workspaceSettings/workspaceSettingsService.js";
 
 function authorizedOptions(permissions = []) {
@@ -16,8 +16,8 @@ function authorizedOptions(permissions = []) {
 }
 
 function createFixture({ workspaceInvitationsEnabled = true } = {}) {
-  const defaultTheme = resolveWorkspaceThemePalette({
-    color: "#0F6B54"
+  const defaultTheme = resolveWorkspaceThemePalettes({
+    lightPrimaryColor: "#0F6B54"
   });
   const state = {
     settingsPatch: null,
@@ -27,15 +27,19 @@ function createFixture({ workspaceInvitationsEnabled = true } = {}) {
       name: "TonyMobily3",
       ownerUserId: 9,
       avatarUrl: "",
-      color: defaultTheme.color
+      color: defaultTheme.light.color
     },
     settings: {
       name: "TonyMobily3",
       avatarUrl: "",
-      color: defaultTheme.color,
-      secondaryColor: defaultTheme.secondaryColor,
-      surfaceColor: defaultTheme.surfaceColor,
-      surfaceVariantColor: defaultTheme.surfaceVariantColor,
+      lightPrimaryColor: defaultTheme.light.color,
+      lightSecondaryColor: defaultTheme.light.secondaryColor,
+      lightSurfaceColor: defaultTheme.light.surfaceColor,
+      lightSurfaceVariantColor: defaultTheme.light.surfaceVariantColor,
+      darkPrimaryColor: defaultTheme.dark.color,
+      darkSecondaryColor: defaultTheme.dark.secondaryColor,
+      darkSurfaceColor: defaultTheme.dark.surfaceColor,
+      darkSurfaceVariantColor: defaultTheme.dark.surfaceVariantColor,
       invitesEnabled: true
     }
   };
@@ -73,10 +77,14 @@ test("workspaceSettingsService.getWorkspaceSettings returns the stored invitesEn
   assert.deepEqual(response.settings, {
     name: "TonyMobily3",
     avatarUrl: "",
-    color: "#0F6B54",
-    secondaryColor: "#0B4D3C",
-    surfaceColor: "#EEF5F3",
-    surfaceVariantColor: "#DDEAE7",
+    lightPrimaryColor: "#0F6B54",
+    lightSecondaryColor: "#48A9A6",
+    lightSurfaceColor: "#FFFFFF",
+    lightSurfaceVariantColor: "#424242",
+    darkPrimaryColor: "#2196F3",
+    darkSecondaryColor: "#54B6B2",
+    darkSurfaceColor: "#212121",
+    darkSurfaceVariantColor: "#C8C8C8",
     invitesEnabled: true,
     invitesAvailable: true,
     invitesEffective: true
@@ -102,10 +110,14 @@ test("workspaceSettingsService.updateWorkspaceSettings writes editable fields th
   assert.deepEqual(response.settings, {
     name: "New Name",
     avatarUrl: "",
-    color: "#0F6B54",
-    secondaryColor: "#0B4D3C",
-    surfaceColor: "#EEF5F3",
-    surfaceVariantColor: "#DDEAE7",
+    lightPrimaryColor: "#0F6B54",
+    lightSecondaryColor: "#48A9A6",
+    lightSurfaceColor: "#FFFFFF",
+    lightSurfaceVariantColor: "#424242",
+    darkPrimaryColor: "#2196F3",
+    darkSecondaryColor: "#54B6B2",
+    darkSurfaceColor: "#212121",
+    darkSurfaceVariantColor: "#C8C8C8",
     invitesEnabled: false,
     invitesAvailable: true,
     invitesEffective: false
@@ -125,10 +137,14 @@ test("workspaceSettingsService disables invite settings in output when app polic
   assert.deepEqual(response.settings, {
     name: "TonyMobily3",
     avatarUrl: "",
-    color: "#0F6B54",
-    secondaryColor: "#0B4D3C",
-    surfaceColor: "#EEF5F3",
-    surfaceVariantColor: "#DDEAE7",
+    lightPrimaryColor: "#0F6B54",
+    lightSecondaryColor: "#48A9A6",
+    lightSurfaceColor: "#FFFFFF",
+    lightSurfaceVariantColor: "#424242",
+    darkPrimaryColor: "#2196F3",
+    darkSecondaryColor: "#54B6B2",
+    darkSurfaceColor: "#212121",
+    darkSurfaceVariantColor: "#C8C8C8",
     invitesEnabled: false,
     invitesAvailable: false,
     invitesEffective: false