@jskit-ai/workspaces-core 0.1.30 → 0.1.32

package/test/workspaceSettingsRepository.test.js

@@ -1,119 +1,154 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import "../test-support/registerDefaultSettingsFields.js";
 import { toIsoString } from "@jskit-ai/database-runtime/shared";
 import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
 import { createRepository } from "../src/server/workspaceSettings/workspaceSettingsRepository.js";
 
-function createDefaultWorkspaceSettings() {
-  return true;
+function createKnexStub() {
+  const knex = Object.assign(() => {
+    throw new Error("query execution not expected");
+  }, {
+    async transaction(work) {
+      return work({ trxId: "trx-1" });
+    }
+  });
+
+  return knex;
+}
+
+function normalizeWorkspaceColor(value) {
+  return typeof value === "string" ? value.toUpperCase() : value;
 }
 
-const DEFAULT_WORKSPACE_THEME = resolveWorkspaceThemePalettes({});
-const STUB_CREATED_AT = "2026-03-09 00:26:35.710";
+function createWorkspaceSettingsApiStub(rowOverrides = {}) {
+  const DEFAULT_WORKSPACE_THEME = resolveWorkspaceThemePalettes({});
+  const STUB_CREATED_AT = "2026-03-09 00:26:35.710";
+  const STUB_CREATED_AT_ISO = toIsoString(STUB_CREATED_AT);
 
-function createKnexStub(rowOverrides = {}) {
   const state = {
-    insertedRow: null,
-    updatePayload: null,
+    postPayload: null,
+    patchPayload: null,
     row: {
-      workspace_id: 1,
-      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: STUB_CREATED_AT,
-      updated_at: STUB_CREATED_AT,
+      id: "1",
+      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: STUB_CREATED_AT_ISO,
+      updatedAt: STUB_CREATED_AT_ISO,
       ...rowOverrides
     }
   };
 
-  function tableBuilder(tableName) {
-    assert.equal(tableName, "workspace_settings");
-
-    return {
-      insert(payload) {
-        state.insertedRow = { ...payload };
-        state.row = {
-          workspace_id: payload.workspace_id,
-          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"
-        };
-        return Promise.resolve([1]);
-      },
-      where(criteria) {
-        assert.equal(typeof criteria, "object");
-
-        return {
-          first() {
-            return Promise.resolve(state.row ? { ...state.row } : null);
-          },
-          update(payload) {
-            state.updatePayload = payload;
-            if (Object.hasOwn(payload, "invites_enabled")) {
-              state.row.invites_enabled = payload.invites_enabled;
-            }
-            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, "dark_secondary_color")) {
-              state.row.dark_secondary_color = payload.dark_secondary_color;
-            }
-            if (Object.hasOwn(payload, "dark_surface_color")) {
-              state.row.dark_surface_color = payload.dark_surface_color;
-            }
-            if (Object.hasOwn(payload, "dark_surface_variant_color")) {
-              state.row.dark_surface_variant_color = payload.dark_surface_variant_color;
+  const api = {
+    resources: {
+      workspaceSettings: {
+        async query({ queryParams }) {
+          const id = String(queryParams?.filters?.id || "");
+          if (!state.row || (id && String(state.row.id) !== id)) {
+            return { data: [] };
+          }
+
+          return {
+            data: [{
+              type: "workspaceSettings",
+              id: String(state.row.id),
+              attributes: {
+                lightPrimaryColor: state.row.lightPrimaryColor,
+                lightSecondaryColor: state.row.lightSecondaryColor,
+                lightSurfaceColor: state.row.lightSurfaceColor,
+                lightSurfaceVariantColor: state.row.lightSurfaceVariantColor,
+                darkPrimaryColor: state.row.darkPrimaryColor,
+                darkSecondaryColor: state.row.darkSecondaryColor,
+                darkSurfaceColor: state.row.darkSurfaceColor,
+                darkSurfaceVariantColor: state.row.darkSurfaceVariantColor,
+                invitesEnabled: state.row.invitesEnabled,
+                createdAt: state.row.createdAt,
+                updatedAt: state.row.updatedAt
+              }
+            }]
+          };
+        },
+        async post(payload) {
+          assert.equal(payload?.simplified, false);
+          const inputRecord = payload?.inputRecord?.data || {};
+          const attributes = inputRecord.attributes || {};
+          state.postPayload = inputRecord;
+          state.row = {
+            id: String(inputRecord.id),
+            lightPrimaryColor: normalizeWorkspaceColor(attributes.lightPrimaryColor ?? DEFAULT_WORKSPACE_THEME.light.color),
+            lightSecondaryColor: normalizeWorkspaceColor(attributes.lightSecondaryColor ?? DEFAULT_WORKSPACE_THEME.light.secondaryColor),
+            lightSurfaceColor: normalizeWorkspaceColor(attributes.lightSurfaceColor ?? DEFAULT_WORKSPACE_THEME.light.surfaceColor),
+            lightSurfaceVariantColor: normalizeWorkspaceColor(attributes.lightSurfaceVariantColor ?? DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor),
+            darkPrimaryColor: normalizeWorkspaceColor(attributes.darkPrimaryColor ?? DEFAULT_WORKSPACE_THEME.dark.color),
+            darkSecondaryColor: normalizeWorkspaceColor(attributes.darkSecondaryColor ?? DEFAULT_WORKSPACE_THEME.dark.secondaryColor),
+            darkSurfaceColor: normalizeWorkspaceColor(attributes.darkSurfaceColor ?? DEFAULT_WORKSPACE_THEME.dark.surfaceColor),
+            darkSurfaceVariantColor: normalizeWorkspaceColor(attributes.darkSurfaceVariantColor ?? DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor),
+            invitesEnabled: attributes.invitesEnabled ?? true,
+            createdAt: toIsoString("2026-03-10 00:00:00.000"),
+            updatedAt: toIsoString("2026-03-10 00:00:00.000")
+          };
+          return {
+            data: {
+              type: "workspaceSettings",
+              id: String(state.row.id),
+              attributes: {
+                ...state.row
+              }
             }
-            if (Object.hasOwn(payload, "updated_at")) {
-              state.row.updated_at = payload.updated_at;
+          };
+        },
+        async patch(payload) {
+          assert.equal(payload?.simplified, false);
+          const inputRecord = payload?.inputRecord?.data || {};
+          const attributes = inputRecord.attributes || {};
+          state.patchPayload = inputRecord;
+          state.row = {
+            ...state.row,
+            ...attributes,
+            ...(Object.hasOwn(attributes, "lightPrimaryColor") ? { lightPrimaryColor: normalizeWorkspaceColor(attributes.lightPrimaryColor) } : {}),
+            ...(Object.hasOwn(attributes, "lightSecondaryColor") ? { lightSecondaryColor: normalizeWorkspaceColor(attributes.lightSecondaryColor) } : {}),
+            ...(Object.hasOwn(attributes, "lightSurfaceColor") ? { lightSurfaceColor: normalizeWorkspaceColor(attributes.lightSurfaceColor) } : {}),
+            ...(Object.hasOwn(attributes, "lightSurfaceVariantColor") ? { lightSurfaceVariantColor: normalizeWorkspaceColor(attributes.lightSurfaceVariantColor) } : {}),
+            ...(Object.hasOwn(attributes, "darkPrimaryColor") ? { darkPrimaryColor: normalizeWorkspaceColor(attributes.darkPrimaryColor) } : {}),
+            ...(Object.hasOwn(attributes, "darkSecondaryColor") ? { darkSecondaryColor: normalizeWorkspaceColor(attributes.darkSecondaryColor) } : {}),
+            ...(Object.hasOwn(attributes, "darkSurfaceColor") ? { darkSurfaceColor: normalizeWorkspaceColor(attributes.darkSurfaceColor) } : {}),
+            ...(Object.hasOwn(attributes, "darkSurfaceVariantColor") ? { darkSurfaceVariantColor: normalizeWorkspaceColor(attributes.darkSurfaceVariantColor) } : {}),
+            id: String(inputRecord.id || state.row?.id || "")
+          };
+          return {
+            data: {
+              type: "workspaceSettings",
+              id: String(state.row.id),
+              attributes: {
+                ...state.row
+              }
             }
-            return Promise.resolve(1);
-          }
-        };
+          };
+        }
       }
-    };
-  }
+    }
+  };
 
-  return { knexStub: tableBuilder, state };
+  return { api, state, DEFAULT_WORKSPACE_THEME, STUB_CREATED_AT };
 }
 
-test("workspaceSettingsRepository.findByWorkspaceId maps the stored row", async () => {
-  const { knexStub } = createKnexStub();
-  const repository = createRepository(knexStub, {
-    defaultInvitesEnabled: createDefaultWorkspaceSettings()
+test("workspaceSettingsRepository.findByWorkspaceId returns the canonical workspace-settings row", async () => {
+  const { api, DEFAULT_WORKSPACE_THEME, STUB_CREATED_AT } = createWorkspaceSettingsApiStub();
+  const repository = createRepository({
+    api,
+    knex: createKnexStub()
   });
 
   const record = await repository.findByWorkspaceId("1");
 
   assert.deepEqual(record, {
-    workspaceId: "1",
+    id: "1",
     lightPrimaryColor: DEFAULT_WORKSPACE_THEME.light.color,
     lightSecondaryColor: DEFAULT_WORKSPACE_THEME.light.secondaryColor,
     lightSurfaceColor: DEFAULT_WORKSPACE_THEME.light.surfaceColor,
@@ -129,44 +164,40 @@ test("workspaceSettingsRepository.findByWorkspaceId maps the stored row", async
 });
 
 test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates invitesEnabled only", async () => {
-  const { knexStub, state } = createKnexStub();
-  const repository = createRepository(knexStub, {
-    defaultInvitesEnabled: createDefaultWorkspaceSettings()
+  const { api, state } = createWorkspaceSettingsApiStub();
+  const repository = createRepository({
+    api,
+    knex: createKnexStub()
   });
 
   const updated = await repository.updateSettingsByWorkspaceId("1", {
     invitesEnabled: false
   });
 
-  assert.equal(state.updatePayload.invites_enabled, false);
+  assert.equal(state.patchPayload.attributes?.invitesEnabled, false);
   assert.equal(updated.invitesEnabled, false);
 });
 
-test("workspaceSettingsRepository.ensureForWorkspaceId inserts the injected defaults exactly", async () => {
-  const { knexStub, state } = createKnexStub();
+test("workspaceSettingsRepository.ensureForWorkspaceId delegates defaults to the resource create path", async () => {
+  const { api, state, DEFAULT_WORKSPACE_THEME } = createWorkspaceSettingsApiStub();
   state.row = null;
-  const repository = createRepository(knexStub, {
-    defaultInvitesEnabled: false
+  const repository = createRepository({
+    api,
+    knex: createKnexStub()
   });
 
   const record = await repository.ensureForWorkspaceId("5");
 
-  assert.equal(state.insertedRow.workspace_id, "5");
-  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(state.postPayload.id, "5");
+  assert.equal(state.postPayload.attributes?.lightPrimaryColor, DEFAULT_WORKSPACE_THEME.light.color);
+  assert.equal(state.postPayload.attributes?.lightSecondaryColor, DEFAULT_WORKSPACE_THEME.light.secondaryColor);
+  assert.equal(state.postPayload.attributes?.lightSurfaceColor, DEFAULT_WORKSPACE_THEME.light.surfaceColor);
+  assert.equal(state.postPayload.attributes?.lightSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.light.surfaceVariantColor);
+  assert.equal(state.postPayload.attributes?.darkPrimaryColor, DEFAULT_WORKSPACE_THEME.dark.color);
+  assert.equal(state.postPayload.attributes?.darkSecondaryColor, DEFAULT_WORKSPACE_THEME.dark.secondaryColor);
+  assert.equal(state.postPayload.attributes?.darkSurfaceColor, DEFAULT_WORKSPACE_THEME.dark.surfaceColor);
+  assert.equal(state.postPayload.attributes?.darkSurfaceVariantColor, DEFAULT_WORKSPACE_THEME.dark.surfaceVariantColor);
+  assert.equal(state.postPayload.attributes?.invitesEnabled, true);
   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);
@@ -175,28 +206,32 @@ test("workspaceSettingsRepository.ensureForWorkspaceId inserts the injected defa
   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);
-  assert.equal(record.workspaceId, "5");
+  assert.equal(record.invitesEnabled, true);
+  assert.equal(record.id, "5");
 });
 
-test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates workspace settings columns", async () => {
-  const { knexStub, state } = createKnexStub();
-  const repository = createRepository(knexStub, {
-    defaultInvitesEnabled: true
+test("workspaceSettingsRepository.updateSettingsByWorkspaceId updates workspace settings fields", async () => {
+  const { api, state } = createWorkspaceSettingsApiStub();
+  const repository = createRepository({
+    api,
+    knex: createKnexStub()
   });
 
   const updated = await repository.updateSettingsByWorkspaceId("1", {
     lightPrimaryColor: "#123abc"
   });
 
-  assert.equal(state.updatePayload.light_primary_color, "#123ABC");
+  assert.equal(state.patchPayload.attributes?.lightPrimaryColor, "#123abc");
   assert.equal(updated.lightPrimaryColor, "#123ABC");
 });
 
 test("workspaceSettingsRepository can be constructed without validating app config shape", () => {
-  const { knexStub } = createKnexStub();
+  const { api } = createWorkspaceSettingsApiStub();
 
-  const repository = createRepository(knexStub);
+  const repository = createRepository({
+    api,
+    knex: createKnexStub()
+  });
 
   assert.ok(repository);
 });

package/test/workspaceSettingsResource.test.js

@@ -1,9 +1,12 @@
 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 { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
-import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
+import {
+  WORKSPACE_SETTINGS_FIELD_KEYS,
+  workspaceSettingsResource
+} from "../src/shared/resources/workspaceSettingsResource.js";
 import { createWorkspaceRoleCatalog } from "../src/shared/roles.js";
 
 function createRoleCatalog() {
@@ -41,13 +44,13 @@ function createRoleCatalog() {
 function parseBody(operation, payload = {}) {
   return validateOperationSection({
     operation,
-    section: "bodyValidator",
+    section: "body",
     value: payload
   });
 }
 
-test("workspace settings patch body normalizes valid payload before validation", () => {
-  const parsed = parseBody(workspaceSettingsResource.operations.patch, {
+test("workspace settings patch body validates valid payload without reshaping it", async () => {
+  const parsed = await parseBody(workspaceSettingsResource.operations.patch, {
     lightPrimaryColor: "#0f6b54",
     lightSecondaryColor: "#0b4d3c",
     lightSurfaceColor: "#eef5f3",
@@ -62,10 +65,10 @@ test("workspace settings patch body normalizes valid payload before validation",
   assert.equal(parsed.ok, true);
   assert.deepEqual(parsed.fieldErrors, {});
   assert.deepEqual(parsed.value, {
-    lightPrimaryColor: "#0F6B54",
-    lightSecondaryColor: "#0B4D3C",
-    lightSurfaceColor: "#EEF5F3",
-    lightSurfaceVariantColor: "#DDEAE7",
+    lightPrimaryColor: "#0f6b54",
+    lightSecondaryColor: "#0b4d3c",
+    lightSurfaceColor: "#eef5f3",
+    lightSurfaceVariantColor: "#ddeae7",
     darkPrimaryColor: "#123456",
     darkSecondaryColor: "#234567",
     darkSurfaceColor: "#345678",
@@ -74,18 +77,17 @@ test("workspace settings patch body normalizes valid payload before validation",
   });
 });
 
-test("workspace settings patch body ignores unknown fields after normalization", () => {
-  const parsed = parseBody(workspaceSettingsResource.operations.patch, {
+test("workspace settings patch body rejects unknown fields", async () => {
+  const parsed = await parseBody(workspaceSettingsResource.operations.patch, {
     avatarUrl: "https://example.com/avatar.png"
   });
 
-  assert.equal(parsed.ok, true);
-  assert.deepEqual(parsed.fieldErrors, {});
-  assert.deepEqual(parsed.value, {});
+  assert.equal(parsed.ok, false);
+  assert.equal(typeof parsed.fieldErrors.avatarUrl, "string");
 });
 
-test("workspace settings create body requires full-write fields", () => {
-  const parsed = parseBody(workspaceSettingsResource.operations.create, {});
+test("workspace settings create body requires full-write fields", async () => {
+  const parsed = await parseBody(workspaceSettingsResource.operations.create, {});
 
   assert.equal(parsed.ok, false);
   assert.equal(parsed.fieldErrors.lightPrimaryColor, "Light primary color is required.");
@@ -99,24 +101,17 @@ test("workspace settings create body requires full-write fields", () => {
   assert.equal(parsed.fieldErrors.invitesEnabled, "invitesEnabled is required.");
 });
 
-test("workspace settings output normalizes raw service payloads", () => {
+test("workspace settings output schema accepts already-shaped service payloads", () => {
+  const outputSchema = resolveStructuredSchemaTransportSchema(workspaceSettingsResource.operations.view.output, {
+    context: "workspaceSettings.view.output",
+    defaultMode: "replace"
+  });
+  const settingsRef = outputSchema.properties.settings.allOf[0].$ref.replace(/^#\/definitions\//, "");
+  const settingsSchema = outputSchema.definitions[settingsRef];
   const expectedTheme = resolveWorkspaceThemePalettes({
     lightPrimaryColor: "#0F6B54"
   });
-  const normalized = workspaceSettingsResource.operations.view.outputValidator.normalize({
-    workspace: {
-      id: "7",
-      slug: "  mercury  ",
-      ownerUserId: "9"
-    },
-    settings: {
-      lightPrimaryColor: "#0f6b54",
-      invitesEnabled: false
-    },
-    roleCatalog: createRoleCatalog()
-  });
-
-  assert.deepEqual(normalized, {
+  const payload = {
     workspace: {
       id: "7",
       slug: "mercury",
@@ -135,35 +130,29 @@ test("workspace settings output normalizes raw service payloads", () => {
       invitesAvailable: true,
       invitesEffective: false
     },
-    roleCatalog: {
-      collaborationEnabled: true,
-      defaultInviteRole: "member",
-      roles: [
-        {
-          id: "owner",
-          assignable: false,
-          permissions: ["*"]
-        },
-        {
-          id: "admin",
-          assignable: true,
-          permissions: [
-            "workspace.roles.view",
-            "workspace.settings.view",
-            "workspace.settings.update",
-            "workspace.members.view",
-            "workspace.members.invite",
-            "workspace.members.manage",
-            "workspace.invites.revoke"
-          ]
-        },
-        {
-          id: "member",
-          assignable: true,
-          permissions: ["workspace.settings.view"]
-        }
-      ],
-      assignableRoleIds: ["admin", "member"]
-    }
-  });
+    roleCatalog: createRoleCatalog()
+  };
+
+  assert.equal(outputSchema.type, "object");
+  assert.equal(outputSchema.additionalProperties, false);
+  assert.equal(outputSchema.properties.workspace["x-json-rest-schema"]?.castType, "object");
+  assert.equal(outputSchema.properties.settings["x-json-rest-schema"]?.castType, "object");
+  assert.equal(outputSchema.properties.roleCatalog["x-json-rest-schema"]?.castType, "object");
+  assert.equal(settingsSchema.properties.lightPrimaryColor.type, "string");
+  assert.equal(payload.settings.lightPrimaryColor, "#0F6B54");
+});
+
+async function importWithIdentity(url, identity) {
+  return import(`${url.href}?identity=${identity}`);
+}
+
+test("workspace settings key exports stay stable across module identities", async () => {
+  const workspaceModuleUrl = new URL("../src/shared/resources/workspaceSettingsResource.js", import.meta.url);
+
+  const workspaceA = await importWithIdentity(workspaceModuleUrl, "workspace-a");
+  const workspaceB = await importWithIdentity(workspaceModuleUrl, "workspace-b");
+
+  assert.deepEqual(workspaceA.WORKSPACE_SETTINGS_FIELD_KEYS, workspaceB.WORKSPACE_SETTINGS_FIELD_KEYS);
+  assert.deepEqual(workspaceA.WORKSPACE_SETTINGS_FIELD_KEYS, WORKSPACE_SETTINGS_FIELD_KEYS);
+  assert.ok(Object.isFrozen(workspaceA.WORKSPACE_SETTINGS_FIELD_KEYS));
 });

package/test/workspaceSettingsService.test.js

@@ -1,6 +1,5 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import "../test-support/registerDefaultSettingsFields.js";
 import { resolveWorkspaceThemePalettes } from "@jskit-ai/workspaces-core/shared/settings";
 import { createService } from "../src/server/workspaceSettings/workspaceSettingsService.js";